The Open Source DocuSign Alternative.
TypeScript digital-signaturedocument-signingdocusign-alternativee-signatureesignesignaturenext-authnextjsopen-sourcepades-standardpdfpdf-signpdf-signaturepostgresqlprismaself-hostedsigningtypescript
fix: improve multiselect for webhook triggers (#1795)
Lucas Smithbd64ad9fefaa
diff --git a/apps/remix/app/components/general/webhook-multiselect-combobox.tsx b/apps/remix/app/components/general/webhook-multiselect-combobox.tsxindex d9f7bea62..ef4403eba 100644--- a/apps/remix/app/components/general/webhook-multiselect-combobox.tsx+++ b/apps/remix/app/components/general/webhook-multiselect-combobox.tsx@@ -1,96 +1,47 @@-import { useEffect, useState } from 'react';--import { Plural, Trans } from '@lingui/react/macro';+import { msg } from '@lingui/core/macro';+import { useLingui } from '@lingui/react';import { WebhookTriggerEvents } from '@prisma/client';-import { Check, ChevronsUpDown } from 'lucide-react';import { toFriendlyWebhookEventName } from '@documenso/lib/universal/webhook/to-friendly-webhook-event-name';-import { cn } from '@documenso/ui/lib/utils';-import { Button } from '@documenso/ui/primitives/button';-import {- Command,- CommandEmpty,- CommandGroup,- CommandInput,- CommandItem,-} from '@documenso/ui/primitives/command';-import { Popover, PopoverContent, PopoverTrigger } from '@documenso/ui/primitives/popover';--import { truncateTitle } from '~/utils/truncate-title';+import { MultiSelect, type Option } from '@documenso/ui/primitives/multiselect';type WebhookMultiSelectComboboxProps = {listValues: string[];onChange: (_values: string[]) => void;};+const triggerEvents = Object.values(WebhookTriggerEvents).map((event) => ({+ value: event,+ label: toFriendlyWebhookEventName(event),+}));+export const WebhookMultiSelectCombobox = ({listValues,onChange,}: WebhookMultiSelectComboboxProps) => {- const [isOpen, setIsOpen] = useState(false);- const [selectedValues, setSelectedValues] = useState<string[]>([]);-- const triggerEvents = Object.values(WebhookTriggerEvents);-- useEffect(() => {- setSelectedValues(listValues);- }, [listValues]);-- const allEvents = [...new Set([...triggerEvents, ...selectedValues])];-- const handleSelect = (currentValue: string) => {- let newSelectedValues;+ const { _ } = useLingui();- if (selectedValues.includes(currentValue)) {- newSelectedValues = selectedValues.filter((value) => value !== currentValue);- } else {- newSelectedValues = [...selectedValues, currentValue];- }+ const value = listValues.map((event) => ({+ value: event,+ label: toFriendlyWebhookEventName(event),+ }));- setSelectedValues(newSelectedValues);- onChange(newSelectedValues);- setIsOpen(false);+ const onMutliSelectChange = (options: Option[]) => {+ onChange(options.map((option) => option.value));};return (- <Popover open={isOpen} onOpenChange={setIsOpen}>- <PopoverTrigger asChild>- <Button- variant="outline"- role="combobox"- aria-expanded={isOpen}- className="w-[200px] justify-between"- >- <Plural value={selectedValues.length} zero="Select values" other="# selected..." />- <ChevronsUpDown className="ml-2 h-4 w-4 shrink-0 opacity-50" />- </Button>- </PopoverTrigger>- <PopoverContent className="z-9999 w-full max-w-[280px] p-0">- <Command>- <CommandInput- placeholder={truncateTitle(- selectedValues.map((v) => toFriendlyWebhookEventName(v)).join(', '),- 15,- )}- />- <CommandEmpty>- <Trans>No value found.</Trans>- </CommandEmpty>- <CommandGroup>- {allEvents.map((value: string, i: number) => (- <CommandItem key={i} onSelect={() => handleSelect(value)}>- <Check- className={cn(- 'mr-2 h-4 w-4',- selectedValues.includes(value) ? 'opacity-100' : 'opacity-0',- )}- />- {toFriendlyWebhookEventName(value)}- </CommandItem>- ))}- </CommandGroup>- </Command>- </PopoverContent>- </Popover>+ <MultiSelect+ commandProps={{+ label: _(msg`Select triggers`),+ }}+ defaultOptions={triggerEvents}+ value={value}+ onChange={onMutliSelectChange}+ placeholder={_(msg`Select triggers`)}+ hideClearAllButton+ hidePlaceholderWhenSelected+ emptyIndicator={<p className="text-center text-sm">No triggers available</p>}+ />);};diff --git a/packages/ui/lib/use-debounce.ts b/packages/ui/lib/use-debounce.tsnew file mode 100644index 000000000..ae8b4ad4f--- /dev/null+++ b/packages/ui/lib/use-debounce.ts@@ -0,0 +1,15 @@+import React, { useEffect } from 'react';++export const useDebounce = <T>(value: T, delay?: number): T => {+ const [debouncedValue, setDebouncedValue] = React.useState<T>(value);++ useEffect(() => {+ const timer = setTimeout(() => setDebouncedValue(value), delay || 500);++ return () => {+ clearTimeout(timer);+ };+ }, [value, delay]);++ return debouncedValue;+};diff --git a/packages/ui/primitives/multiselect.tsx b/packages/ui/primitives/multiselect.tsxnew file mode 100644index 000000000..5129f646e--- /dev/null+++ b/packages/ui/primitives/multiselect.tsx@@ -0,0 +1,585 @@+'use client';++import * as React from 'react';+import { useEffect } from 'react';++import { Command as CommandPrimitive, useCommandState } from 'cmdk';+import { XIcon } from 'lucide-react';++import { useDebounce } from '../lib/use-debounce';+import { cn } from '../lib/utils';+import { Command, CommandGroup, CommandItem, CommandList } from './command';++export interface Option {+ value: string;+ label: string;+ disable?: boolean;+ /** fixed option that can't be removed. */+ fixed?: boolean;+ /** Group the options by providing key. */+ [key: string]: string | boolean | undefined;+}+interface GroupOption {+ [key: string]: Option[];+}++interface MultiSelectProps {+ value?: Option[];+ defaultOptions?: Option[];+ /** manually controlled options */+ options?: Option[];+ placeholder?: string;+ /** Loading component. */+ loadingIndicator?: React.ReactNode;+ /** Empty component. */+ emptyIndicator?: React.ReactNode;+ /** Debounce time for async search. Only work with `onSearch`. */+ delay?: number;+ /**+ * Only work with `onSearch` prop. Trigger search when `onFocus`.+ * For example, when user click on the input, it will trigger the search to get initial options.+ **/+ triggerSearchOnFocus?: boolean;+ /** async search */+ onSearch?: (value: string) => Promise<Option[]>;+ /**+ * sync search. This search will not showing loadingIndicator.+ * The rest props are the same as async search.+ * i.e.: creatable, groupBy, delay.+ **/+ onSearchSync?: (value: string) => Option[];+ onChange?: (options: Option[]) => void;+ /** Limit the maximum number of selected options. */+ maxSelected?: number;+ /** When the number of selected options exceeds the limit, the onMaxSelected will be called. */+ onMaxSelected?: (maxLimit: number) => void;+ /** Hide the placeholder when there are options selected. */+ hidePlaceholderWhenSelected?: boolean;+ disabled?: boolean;+ /** Group the options base on provided key. */+ groupBy?: string;+ className?: string;+ badgeClassName?: string;+ /**+ * First item selected is a default behavior by cmdk. That is why the default is true.+ * This is a workaround solution by add a dummy item.+ *+ * @reference: https://github.com/pacocoursey/cmdk/issues/171+ */+ selectFirstItem?: boolean;+ /** Allow user to create option when there is no option matched. */+ creatable?: boolean;+ /** Props of `Command` */+ commandProps?: React.ComponentPropsWithoutRef<typeof Command>;+ /** Props of `CommandInput` */+ inputProps?: Omit<+ React.ComponentPropsWithoutRef<typeof CommandPrimitive.Input>,+ 'value' | 'placeholder' | 'disabled'+ >;+ /** hide the clear all button. */+ hideClearAllButton?: boolean;+}++export interface MultiSelectRef {+ selectedValue: Option[];+ input: HTMLInputElement;+ focus: () => void;+ reset: () => void;+}++function transToGroupOption(options: Option[], groupBy?: string) {+ if (options.length === 0) {+ return {};+ }+ if (!groupBy) {+ return {+ '': options,+ };+ }++ const groupOption: GroupOption = {};+ options.forEach((option) => {+ const key = (option[groupBy] as string) || '';+ if (!groupOption[key]) {+ groupOption[key] = [];+ }+ groupOption[key].push(option);+ });+ return groupOption;+}++function removePickedOption(groupOption: GroupOption, picked: Option[]) {+ const cloneOption = JSON.parse(JSON.stringify(groupOption)) as GroupOption;++ for (const [key, value] of Object.entries(cloneOption)) {+ cloneOption[key] = value.filter((val) => !picked.find((p) => p.value === val.value));+ }+ return cloneOption;+}++function isOptionsExist(groupOption: GroupOption, targetOption: Option[]) {+ for (const [, value] of Object.entries(groupOption)) {+ if (value.some((option) => targetOption.find((p) => p.value === option.value))) {+ return true;+ }+ }+ return false;+}++const CommandEmpty = ({+ className,+ ...props+}: React.ComponentProps<typeof CommandPrimitive.Empty>) => {+ const render = useCommandState((state) => state.filtered.count === 0);++ if (!render) return null;++ return (+ <div+ className={cn('px-2 py-4 text-center text-sm', className)}+ cmdk-empty=""+ role="presentation"+ {...props}+ />+ );+};++CommandEmpty.displayName = 'CommandEmpty';++const MultiSelect = ({+ value,+ onChange,+ placeholder,+ defaultOptions: arrayDefaultOptions = [],+ options: arrayOptions,+ delay,+ onSearch,+ onSearchSync,+ loadingIndicator,+ emptyIndicator,+ maxSelected = Number.MAX_SAFE_INTEGER,+ onMaxSelected,+ hidePlaceholderWhenSelected,+ disabled,+ groupBy,+ className,+ badgeClassName,+ selectFirstItem = true,+ creatable = false,+ triggerSearchOnFocus = false,+ commandProps,+ inputProps,+ hideClearAllButton = false,+}: MultiSelectProps) => {+ const inputRef = React.useRef<HTMLInputElement>(null);+ const [open, setOpen] = React.useState(false);+ const [onScrollbar, setOnScrollbar] = React.useState(false);+ const [isLoading, setIsLoading] = React.useState(false);+ const dropdownRef = React.useRef<HTMLDivElement>(null); // Added this++ const [selected, setSelected] = React.useState<Option[]>(value || []);+ const [options, setOptions] = React.useState<GroupOption>(+ transToGroupOption(arrayDefaultOptions, groupBy),+ );+ const [inputValue, setInputValue] = React.useState('');+ const debouncedSearchTerm = useDebounce(inputValue, delay || 500);++ const handleClickOutside = (event: MouseEvent | TouchEvent) => {+ if (+ dropdownRef.current &&+ !dropdownRef.current.contains(event.target as Node) &&+ inputRef.current &&+ !inputRef.current.contains(event.target as Node)+ ) {+ setOpen(false);+ inputRef.current.blur();+ }+ };++ const handleUnselect = React.useCallback(+ (option: Option) => {+ const newOptions = selected.filter((s) => s.value !== option.value);+ setSelected(newOptions);+ onChange?.(newOptions);+ },+ [onChange, selected],+ );++ const handleKeyDown = React.useCallback(+ (e: React.KeyboardEvent<HTMLDivElement>) => {+ const input = inputRef.current;+ if (input) {+ if (e.key === 'Delete' || e.key === 'Backspace') {+ if (input.value === '' && selected.length > 0) {+ const lastSelectOption = selected[selected.length - 1];+ // If last item is fixed, we should not remove it.+ if (!lastSelectOption.fixed) {+ handleUnselect(selected[selected.length - 1]);+ }+ }+ }+ // This is not a default behavior of the <input /> field+ if (e.key === 'Escape') {+ input.blur();+ }+ }+ },+ [handleUnselect, selected],+ );++ useEffect(() => {+ if (open) {+ document.addEventListener('mousedown', handleClickOutside);+ document.addEventListener('touchend', handleClickOutside);+ } else {+ document.removeEventListener('mousedown', handleClickOutside);+ document.removeEventListener('touchend', handleClickOutside);+ }++ return () => {+ document.removeEventListener('mousedown', handleClickOutside);+ document.removeEventListener('touchend', handleClickOutside);+ };+ }, [open]);++ useEffect(() => {+ if (value) {+ setSelected(value);+ }+ }, [value]);++ useEffect(() => {+ /** If `onSearch` is provided, do not trigger options updated. */+ if (!arrayOptions || onSearch) {+ return;+ }+ const newOption = transToGroupOption(arrayOptions || [], groupBy);+ if (JSON.stringify(newOption) !== JSON.stringify(options)) {+ setOptions(newOption);+ }+ }, [arrayDefaultOptions, arrayOptions, groupBy, onSearch, options]);++ useEffect(() => {+ /** sync search */++ const doSearchSync = () => {+ const res = onSearchSync?.(debouncedSearchTerm);+ setOptions(transToGroupOption(res || [], groupBy));+ };++ // eslint-disable-next-line @typescript-eslint/require-await+ const exec = async () => {+ if (!onSearchSync || !open) return;++ if (triggerSearchOnFocus) {+ doSearchSync();+ }++ if (debouncedSearchTerm) {+ doSearchSync();+ }+ };++ void exec();+ // eslint-disable-next-line react-hooks/exhaustive-deps+ }, [debouncedSearchTerm, groupBy, open, triggerSearchOnFocus]);++ useEffect(() => {+ /** async search */++ const doSearch = async () => {+ setIsLoading(true);+ const res = await onSearch?.(debouncedSearchTerm);+ setOptions(transToGroupOption(res || [], groupBy));+ setIsLoading(false);+ };++ const exec = async () => {+ if (!onSearch || !open) return;++ if (triggerSearchOnFocus) {+ await doSearch();+ }++ if (debouncedSearchTerm) {+ await doSearch();+ }+ };++ void exec();+ // eslint-disable-next-line react-hooks/exhaustive-deps+ }, [debouncedSearchTerm, groupBy, open, triggerSearchOnFocus]);++ const CreatableItem = () => {+ if (!creatable) return undefined;+ if (+ isOptionsExist(options, [{ value: inputValue, label: inputValue }]) ||+ selected.find((s) => s.value === inputValue)+ ) {+ return undefined;+ }++ const Item = (+ <CommandItem+ value={inputValue}+ className="cursor-pointer"+ onMouseDown={(e) => {+ e.preventDefault();+ e.stopPropagation();+ }}+ onSelect={(value: string) => {+ if (selected.length >= maxSelected) {+ onMaxSelected?.(selected.length);+ return;+ }+ setInputValue('');+ const newOptions = [...selected, { value, label: value }];+ setSelected(newOptions);+ onChange?.(newOptions);+ }}+ >+ {`Create "${inputValue}"`}+ </CommandItem>+ );++ // For normal creatable+ if (!onSearch && inputValue.length > 0) {+ return Item;+ }++ // For async search creatable. avoid showing creatable item before loading at first.+ if (onSearch && debouncedSearchTerm.length > 0 && !isLoading) {+ return Item;+ }++ return undefined;+ };++ const EmptyItem = React.useCallback(() => {+ if (!emptyIndicator) return undefined;++ // For async search that showing emptyIndicator+ if (onSearch && !creatable && Object.keys(options).length === 0) {+ return (+ <CommandItem value="-" disabled>+ {emptyIndicator}+ </CommandItem>+ );+ }++ return <CommandEmpty>{emptyIndicator}</CommandEmpty>;+ }, [creatable, emptyIndicator, onSearch, options]);++ const selectables = React.useMemo<GroupOption>(+ () => removePickedOption(options, selected),+ [options, selected],+ );++ /** Avoid Creatable Selector freezing or lagging when paste a long string. */+ const commandFilter = React.useCallback(() => {+ if (commandProps?.filter) {+ return commandProps.filter;+ }++ if (creatable) {+ return (value: string, search: string) => {+ return value.toLowerCase().includes(search.toLowerCase()) ? 1 : -1;+ };+ }+ // Using default filter in `cmdk`. We don‘t have to provide it.+ return undefined;+ }, [creatable, commandProps?.filter]);++ return (+ <Command+ ref={dropdownRef}+ {...commandProps}+ onKeyDown={(e) => {+ handleKeyDown(e);+ commandProps?.onKeyDown?.(e);+ }}+ className={cn('h-auto overflow-visible bg-transparent', commandProps?.className)}+ shouldFilter={+ commandProps?.shouldFilter !== undefined ? commandProps.shouldFilter : !onSearch+ } // When onSearch is provided, we don‘t want to filter the options. You can still override it.+ filter={commandFilter()}+ >+ <div+ className={cn(+ 'border-input focus-within:border-ring focus-within:ring-ring/50 has-aria-invalid:ring-destructive/20 dark:has-aria-invalid:ring-destructive/40 has-aria-invalid:border-destructive has-disabled:pointer-events-none has-disabled:cursor-not-allowed has-disabled:opacity-50 relative min-h-[38px] rounded-md border text-sm outline-none transition-[color,box-shadow] focus-within:ring-[3px]',+ {+ 'p-1': selected.length !== 0,+ 'cursor-text': !disabled && selected.length !== 0,+ },+ !hideClearAllButton && 'pe-9',+ className,+ )}+ onClick={() => {+ if (disabled) return;+ inputRef?.current?.focus();+ }}+ >+ <div className="flex flex-wrap gap-1">+ {selected.map((option) => {+ return (+ <div+ key={option.value}+ className={cn(+ 'animate-fadeIn bg-background text-secondary-foreground hover:bg-background data-fixed:pe-2 relative inline-flex h-7 cursor-default items-center rounded-md border pe-7 pl-2 ps-2 text-xs font-medium transition-all disabled:pointer-events-none disabled:cursor-not-allowed disabled:opacity-50',+ badgeClassName,+ )}+ data-fixed={option.fixed}+ data-disabled={disabled || undefined}+ >+ {option.label}+ <button+ className="text-muted-foreground/80 hover:text-foreground focus-visible:border-ring focus-visible:ring-ring/50 absolute -inset-y-px -end-px flex size-7 items-center justify-center rounded-e-md border border-transparent p-0 outline-none transition-[color,box-shadow] focus-visible:ring-[3px]"+ onKeyDown={(e) => {+ if (e.key === 'Enter') {+ handleUnselect(option);+ }+ }}+ onMouseDown={(e) => {+ e.preventDefault();+ e.stopPropagation();+ }}+ onClick={() => handleUnselect(option)}+ aria-label="Remove"+ >+ <XIcon size={14} aria-hidden="true" />+ </button>+ </div>+ );+ })}+ {/* Avoid having the "Search" Icon */}+ <CommandPrimitive.Input+ {...inputProps}+ ref={inputRef}+ value={inputValue}+ disabled={disabled}+ onValueChange={(value) => {+ setInputValue(value);+ inputProps?.onValueChange?.(value);+ }}+ onBlur={(event) => {+ if (!onScrollbar) {+ setOpen(false);+ }+ inputProps?.onBlur?.(event);+ }}+ onFocus={(event) => {+ setOpen(true);+ if (triggerSearchOnFocus) {+ void onSearch?.(debouncedSearchTerm);+ }+ inputProps?.onFocus?.(event);+ }}+ placeholder={hidePlaceholderWhenSelected && selected.length !== 0 ? '' : placeholder}+ className={cn(+ 'placeholder:text-muted-foreground/70 flex-1 bg-transparent outline-none disabled:cursor-not-allowed',+ {+ 'w-full': hidePlaceholderWhenSelected,+ 'px-3 py-2': selected.length === 0,+ 'ml-1': selected.length !== 0,+ },+ inputProps?.className,+ )}+ />+ <button+ type="button"+ onClick={() => {+ setSelected(selected.filter((s) => s.fixed));+ onChange?.(selected.filter((s) => s.fixed));+ }}+ className={cn(+ 'text-muted-foreground/80 hover:text-foreground focus-visible:border-ring focus-visible:ring-ring/50 absolute end-0 top-0 flex size-9 items-center justify-center rounded-md border border-transparent outline-none transition-[color,box-shadow] focus-visible:ring-[3px]',+ (hideClearAllButton ||+ disabled ||+ selected.length < 1 ||+ selected.filter((s) => s.fixed).length === selected.length) &&+ 'hidden',+ )}+ aria-label="Clear all"+ >+ <XIcon size={16} aria-hidden="true" />+ </button>+ </div>+ </div>+ <div className="relative">+ <div+ className={cn(+ 'border-input absolute top-2 z-10 w-full overflow-hidden rounded-md border',+ 'data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95',+ !open && 'hidden',+ )}+ data-state={open ? 'open' : 'closed'}+ >+ {open && (+ <CommandList+ className="bg-popover text-popover-foreground shadow-lg outline-none"+ onMouseLeave={() => {+ setOnScrollbar(false);+ }}+ onMouseEnter={() => {+ setOnScrollbar(true);+ }}+ onMouseUp={() => {+ inputRef?.current?.focus();+ }}+ >+ {isLoading ? (+ <>{loadingIndicator}</>+ ) : (+ <>+ {EmptyItem()}+ {CreatableItem()}+ {!selectFirstItem && <CommandItem value="-" className="hidden" />}+ {Object.entries(selectables).map(([key, dropdowns]) => (+ <CommandGroup key={key} heading={key} className="h-full overflow-auto">+ <>+ {dropdowns.map((option) => {+ return (+ <CommandItem+ key={option.value}+ value={option.value}+ disabled={option.disable}+ onMouseDown={(e) => {+ e.preventDefault();+ e.stopPropagation();+ }}+ onSelect={() => {+ if (selected.length >= maxSelected) {+ onMaxSelected?.(selected.length);+ return;+ }+ setInputValue('');+ const newOptions = [...selected, option];+ setSelected(newOptions);+ onChange?.(newOptions);+ }}+ className={cn(+ 'cursor-pointer',+ option.disable &&+ 'pointer-events-none cursor-not-allowed opacity-50',+ )}+ >+ {option.label}+ </CommandItem>+ );+ })}+ </>+ </CommandGroup>+ ))}+ </>+ )}+ </CommandList>+ )}+ </div>+ </div>+ </Command>+ );+};++MultiSelect.displayName = 'MultiSelect';++export { MultiSelect };