@archbase/components 3.0.0

package/src/editors/ArchbaseAsyncMultiSelect.tsx

@@ -0,0 +1,667 @@
+import {
+	CheckIcon,
+	CloseButton,
+	Combobox,
+	ComboboxDropdown,
+	ComboboxTarget,
+	FloatingPosition,
+	Group,
+	Image,
+	Loader,
+	MantineSize,
+	OptionsFilter,
+	Pill,
+	PillsInput,
+	ScrollArea,
+	ScrollAreaProps,
+	Text,
+	useCombobox,
+} from '@mantine/core';
+import { useDebouncedValue } from '@mantine/hooks';
+import { uniqueId } from 'lodash';
+import React, {
+	CSSProperties,
+	FocusEventHandler,
+	forwardRef,
+	ReactNode,
+	useCallback,
+	useContext,
+	useEffect,
+	useRef,
+	useState
+} from 'react';
+import { ArchbaseDataSource, DataSourceEvent, DataSourceEventNames, IArchbaseDataSourceBase } from '@archbase/data';
+import { useArchbaseDidUpdate } from '@archbase/data';
+import { useArchbaseV1V2Compatibility } from '@archbase/data';
+import { useValidationErrors } from '@archbase/core';
+import { useForceUpdate } from '@mantine/hooks';
+import {
+	ArchbaseAsyncSelectContext,
+	ArchbaseAsyncSelectContextValue,
+	ArchbaseAsyncSelectProvider,
+} from './ArchbaseAsyncSelect.context';
+
+export type OptionsResult<O> = {
+  options: O[];
+  page: number;
+  totalPages: number;
+};
+
+export interface ArchbaseAsyncMultiSelectProps<T, ID, O> {
+  /** Permite ou não desselecionar um item */
+  allowDeselect?: boolean;
+  /** Indicador se permite limpar o select */
+  clearable?: boolean;
+  /** Fonte de dados onde será atribuido o item selecionado (V1 ou V2) */
+  dataSource?: IArchbaseDataSourceBase<T>;
+  /** Campo onde deverá ser atribuido o item selecionado na fonte de dados */
+  dataField?: string;
+  /** Tempo de espero antes de realizar a busca */
+  debounceTime?: number;
+  /** Minimo caracteres para busca */
+  minCharsToSearch?: number;
+  /** Indicador se o select está desabilitado */
+  disabled?: boolean;
+  /** Indicador se o select é somente leitura. Obs: usado em conjunto com o status da fonte de dados */
+  readOnly?: boolean;
+  /** Texto explicativo do select */
+  placeholder?: string;
+  /** Título do select */
+  label?: string;
+  /** Descrição do select */
+  description?: string;
+  /** Último erro ocorrido no select */
+  error?: string;
+  /** Permite pesquisar no select */
+  searchable?: boolean;
+  /** Icon a esquerda do select */
+  icon?: ReactNode;
+  /** Largura do icone a esquerda do select */
+  iconWidth?: MantineSize;
+  /** Valor de entrada controlado */
+  value?: any;
+  /** Valor padrão de entrada não controlado */
+  defaultValue?: any;
+  /** Função com base em quais itens no menu suspenso são filtrados */
+  filter?: OptionsFilter;
+  /** Estilo do select */
+  style?: CSSProperties;
+  /** Tamanho do campo */
+  size?: MantineSize;
+  /** Largura do select */
+  width?: number | string | undefined;
+  /** Estado aberto do menu suspenso inicial */
+  initiallyOpened?: boolean;
+  /** Alterar renderizador de item */
+  itemComponent?: React.FC<any>;
+  /** Alterar renderizador de item selecionado */
+  selectedItemComponent?: React.FC<any>;
+  /** Chamado quando o menu suspenso é aberto */
+  onDropdownOpen?(): void;
+  /** Chamado quando o menu suspenso é aberto */
+  onDropdownClose?(): void;
+  /** Limite a quantidade de itens exibidos por vez para seleção pesquisável */
+  limit?: number;
+  /** Rótulo nada encontrado */
+  nothingFound?: React.ReactNode;
+  /** Índice z dropdown */
+  zIndex?: React.CSSProperties['zIndex'];
+  /** Comportamento de posicionamento dropdown */
+  dropdownPosition?: FloatingPosition;
+  /** Evento quando os valores selecionados são alterados */
+  onChangeValues?: (values: O[]) => void;
+  /** Evento quando o foco sai do select */
+  onFocusExit?: (event: React.FocusEvent<HTMLInputElement>) => void;
+  /** Evento quando o select recebe o foco */
+  onFocusEnter?: (event: React.FocusEvent<HTMLInputElement>) => void;
+  /** Opções de seleção iniciais */
+  initialOptions?: OptionsResult<O>;
+  /** Function que retorna o label de uma opção */
+  getOptionLabel: (option: O) => string;
+  /** Function que retorna o valor de uma opção */
+  getOptionValue: (option: O) => any;
+  /** Function que retorna a imagem de uma opção */
+  getOptionImage?: (option: O) => any | undefined | null;
+  /** Function responsável por retornar uma promessa contendo opções. Usado para buscar dados remotos. */
+  getOptions: (page: number, value: string) => Promise<OptionsResult<O>>;
+  /** Evento quando ocorreu um erro carregando dados através da promessa fornecida por getOptions. */
+  onErrorLoadOptions?: (error: string) => void;
+  /** Indica se o select tem o preenchimento obrigatório */
+  required?: boolean;
+  /** Chamado sempre que o valor da pesquisa muda */
+  onSearchChange?(query: string): void;
+  /** Converte o valor antes de atribuir ao field do registro atual no datasource */
+  converter?: (value: O) => any;
+  /** Function que busca o valor original antes de converter pelo valor de retorno do converter */
+  getConvertedOption?: (value: any) => Promise<O>;
+}
+function buildOptions<O>(
+  initialOptions: O[],
+  getOptionLabel: (option: O) => string,
+  getOptionValue: (option: O) => any,
+  getOptionImage?: (option: O) => any | undefined | null,
+): any {
+  if (!initialOptions) {
+    return [];
+  }
+  if (getOptionImage) {
+    return initialOptions.map((item: O) => {
+      return {
+        label: getOptionLabel(item),
+        value: getOptionValue(item),
+        image: getOptionImage(item),
+        origin: item,
+        key: uniqueId('select'),
+      };
+    });
+  }
+
+  return initialOptions.map((item: O) => {
+    return {
+      label: getOptionLabel(item),
+      value: getOptionValue(item),
+      origin: item,
+      key: uniqueId('select'),
+    };
+  });
+}
+
+const areArraysEqual = (arr1: any[], arr2: any[]) => {
+  if (arr1.length !== arr2.length) return false;
+  return arr1.every((item, index) => item === arr2[index]);
+};
+
+export const SelectItem = ({ image, label, description, values, value, ...others }) => (
+  <div {...others}>
+    <Group style={{ flexWrap: "nowrap" }}>
+      <Image w={50} src={image} />
+      <div>
+        <Text size="sm">{label}</Text>
+        <Text size="xs" opacity={0.65}>
+          {description}
+        </Text>
+      </div>
+      {values.includes(value) ? <CheckIcon size={12} /> : null}
+    </Group>
+  </div>
+);
+
+export const SelectedItem = ({ item, value, onRemove, label }) => (
+  <Pill
+    key={value}
+    withRemoveButton
+    onRemove={() => onRemove()}
+  >
+    {label}
+  </Pill>
+);
+
+export function ArchbaseAsyncMultiSelect<T, ID, O>({
+  allowDeselect = true,
+  clearable = true,
+  dataSource,
+  dataField,
+  disabled = false,
+  debounceTime = 500,
+  minCharsToSearch = 3,
+  readOnly = false,
+  placeholder,
+  initialOptions = { options: [], page: 0, totalPages: 0 },
+  searchable = true,
+  label,
+  description,
+  error,
+  icon,
+  iconWidth,
+  required,
+  getOptionLabel,
+  getOptionValue,
+  getOptionImage,
+  getOptions,
+  onFocusEnter,
+  onFocusExit,
+  onChangeValues,
+  value,
+  defaultValue,
+  filter,
+  size,
+  style,
+  width,
+  initiallyOpened,
+  itemComponent: ItemComponent = SelectItem,
+  selectedItemComponent: SelectedItemComponent = SelectedItem,
+  onDropdownOpen,
+  onDropdownClose,
+  limit,
+  nothingFound,
+  zIndex,
+  dropdownPosition,
+  onErrorLoadOptions,
+  onSearchChange,
+  converter,
+  getConvertedOption
+}: ArchbaseAsyncMultiSelectProps<T, ID, O>) {
+  const forceUpdate = useForceUpdate();
+
+  // 🔄 MIGRAÇÃO V1/V2: Hook de compatibilidade
+  const v1v2Compatibility = useArchbaseV1V2Compatibility<O[]>(
+    'ArchbaseAsyncMultiSelect',
+    dataSource,
+    dataField,
+    []
+  );
+
+  // 🔄 MIGRAÇÃO V1/V2: Debug info para desenvolvimento
+  if (process.env.NODE_ENV === 'development' && dataSource) {
+  }
+
+  // Contexto de validação (opcional - pode não existir)
+  const validationContext = useValidationErrors();
+
+  // Chave única para o field
+  const fieldKey = `${dataField}`;
+
+  // Recuperar erro do contexto se existir
+  const contextError = validationContext?.getError(fieldKey);
+
+  const combobox = useCombobox({
+    onDropdownClose: () => combobox.resetSelectedOption(),
+  });
+  const [options, setOptions] = useState<any[]>(
+    buildOptions<O>(initialOptions.options, getOptionLabel, getOptionValue, getOptionImage),
+  );
+  const [selectedValues, setSelectedValues] = useState<O[]>([]);
+  const [updateCounter, setUpdateCounter] = useState(0);
+  const [queryValue, setQueryValue] = useState<string>('');
+  const [debouncedQueryValue] = useDebouncedValue(queryValue, debounceTime);
+  const [loading, setLoading] = useState(false);
+  const [currentPage, setCurrentPage] = useState(initialOptions.page);
+  const [totalPages, setTotalPages] = useState(initialOptions.totalPages);
+  const [isLastPage, setIsLastPage] = useState(currentPage === totalPages - 1);
+  const [originData, setOriginData] = useState(initialOptions.options);
+  const [internalError, setInternalError] = useState<string | undefined>(error);
+
+  const loadDataSourceFieldValue = async () => {
+    let initialValue: any = value;
+
+    if (dataSource && dataField) {
+      initialValue = dataSource.getFieldValue(dataField);
+      if (!initialValue) {
+        initialValue = [];
+      }
+    }
+    if (getConvertedOption && converter && initialValue) {
+      initialValue = await getConvertedOption(initialValue)
+    }
+    setSelectedValues(initialValue ?? []);
+    setQueryValue(getOptionLabel(initialValue) || '');
+  };
+
+  const fieldChangedListener = useCallback(() => {
+    loadDataSourceFieldValue();
+  }, []);
+
+  const dataSourceEvent = useCallback((event: DataSourceEvent<T>) => {
+    if (dataSource && dataField) {
+      if (
+        event.type === DataSourceEventNames.dataChanged ||
+        event.type === DataSourceEventNames.recordChanged ||
+        event.type === DataSourceEventNames.afterScroll ||
+        event.type === DataSourceEventNames.afterCancel
+      ) {
+        loadDataSourceFieldValue();
+        // 🔄 MIGRAÇÃO V1/V2: forceUpdate apenas para V1
+        if (!v1v2Compatibility.isDataSourceV2) {
+          forceUpdate();
+        }
+      }
+      if (event.type === DataSourceEventNames.beforeClose) {
+        setOptions([]);
+      }
+
+      if (event.type === DataSourceEventNames.onFieldError && event.fieldName === dataField) {
+        setInternalError(event.error);
+        // Salvar no contexto (se disponível)
+        validationContext?.setError(fieldKey, event.error);
+      }
+    }
+  }, [v1v2Compatibility.isDataSourceV2, validationContext, fieldKey]);
+
+  // Ref para manter callback sempre atualizado (corrige problema de closure desatualizada)
+  const dataSourceEventRef = useRef(dataSourceEvent);
+  useEffect(() => {
+    dataSourceEventRef.current = dataSourceEvent;
+  }, [dataSourceEvent]);
+
+  // Wrapper estável que delega para ref
+  const stableDataSourceEvent = useCallback((event: DataSourceEvent<T>) => {
+    dataSourceEventRef.current(event);
+  }, []);
+
+  // Registrar listeners com cleanup apropriado
+  useEffect(() => {
+    loadDataSourceFieldValue();
+    if (dataSource && dataField) {
+      const hasFieldListener = typeof (dataSource as any).addFieldChangeListener === 'function';
+      dataSource.addListener(stableDataSourceEvent);
+      if (hasFieldListener) {
+        (dataSource as any).addFieldChangeListener(dataField, fieldChangedListener);
+      }
+
+      return () => {
+        dataSource.removeListener(stableDataSourceEvent);
+        if (hasFieldListener) {
+          (dataSource as any).removeFieldChangeListener(dataField, fieldChangedListener);
+        }
+      };
+    }
+  }, [dataSource, dataField, stableDataSourceEvent, fieldChangedListener]);
+
+  useEffect(() => {
+    if (onSearchChange) {
+      onSearchChange(debouncedQueryValue);
+    }
+    if (
+      debouncedQueryValue &&
+      debouncedQueryValue.length >= minCharsToSearch
+    ) {
+      setLoading(true);
+      loadOptions(0, false);
+    }
+  }, [debouncedQueryValue]);
+
+  useEffect(() => { }, [currentPage, totalPages]);
+
+  useArchbaseDidUpdate(() => {
+    loadDataSourceFieldValue();
+  }, []);
+
+  // ❌ REMOVIDO: Não limpar erro automaticamente quando valor muda
+  // O erro deve ser limpo apenas quando o usuário EDITA o campo (no handleChange)
+  // useEffect(() => {
+  //   setInternalError(undefined);
+  // }, [value, selectedValues, debouncedQueryValue]);
+
+  // ✅ CORRIGIDO: Apenas atualizar se o prop error vier definido
+  // Não limpar o internalError se o prop error for undefined
+  useEffect(() => {
+    if (error !== undefined && error !== internalError) {
+      setInternalError(error);
+    }
+  }, [error]);
+
+  const handleConverter = (value) => {
+    if (converter && value) {
+      return converter(value)
+    }
+    return value
+  }
+
+  const handleValueRemove = (val: O) => {
+    // ✅ Limpa erro quando usuário edita o campo (tanto do estado local quanto do contexto)
+    const hasError = internalError || contextError;
+    if (hasError) {
+      setInternalError(undefined);
+      validationContext?.clearError(fieldKey);
+    }
+
+    setSelectedValues((current) => {
+      const updatedValues = current.filter((item) => getOptionValue(item) !== getOptionValue(val))
+      const convertedValues = updatedValues.map(updatedValue => handleConverter(updatedValue))
+      
+      // 🔄 MIGRAÇÃO V1/V2: Usar handleValueChange do padrão de compatibilidade
+      if (dataSource && dataField) {
+        v1v2Compatibility.handleValueChange(convertedValues);
+      }
+
+      if (onChangeValues) {
+        onChangeValues(updatedValues);
+      }
+
+      return updatedValues
+    });
+  }
+
+  const handleChange = (value) => {
+    // ✅ Limpa erro quando usuário edita o campo (tanto do estado local quanto do contexto)
+    const hasError = internalError || contextError;
+    if (hasError) {
+      setInternalError(undefined);
+      validationContext?.clearError(fieldKey);
+    }
+
+    setSelectedValues((prevSelected) => {
+      const isSelected = prevSelected.some(
+        (item) => getOptionValue(item) === getOptionValue(value)
+      );
+
+      // Se o valor já está selecionado, o removemos. Caso contrário, adicionamos.
+      const updatedValues = isSelected
+        ? prevSelected.filter(
+          (item) => getOptionValue(item) !== getOptionValue(value)
+        )
+        : [...prevSelected, value];
+      const convertedValues = updatedValues.map(updatedValue => handleConverter(updatedValue))
+      
+      // 🔄 MIGRAÇÃO V1/V2: Usar handleValueChange do padrão de compatibilidade
+      if (dataSource && dataField) {
+        v1v2Compatibility.handleValueChange(convertedValues);
+      }
+
+      if (onChangeValues) {
+        onChangeValues(updatedValues);
+      }
+
+      return updatedValues;
+    });
+  };
+
+  const handleOnFocusExit = (event) => {
+    if (onFocusExit) {
+      onFocusExit(event);
+    }
+  };
+
+  const handleOnFocusEnter = (event) => {
+    if (onFocusEnter) {
+      onFocusEnter(event);
+    }
+  };
+
+  const handleDropdownScrollEnded = () => {
+    if (debouncedQueryValue && debouncedQueryValue.length >= minCharsToSearch && currentPage < totalPages - 1) {
+      setLoading(true);
+      loadOptions(currentPage + 1, true);
+    }
+  };
+
+  const handleSearchChange = (query: string) => {
+    if (!selectedValues) {
+      setQueryValue(query);
+    }
+    if (query && query.length >= minCharsToSearch) {
+      combobox.openDropdown();
+    }
+  };
+
+  const loadOptions = async (page: number, incremental = false) => {
+    const promise = getOptions(page, debouncedQueryValue);
+    promise.then(
+      (data: OptionsResult<O>) => {
+        setLoading(false);
+        if (data === undefined || data == null) {
+          if (onErrorLoadOptions) {
+            onErrorLoadOptions('Response incorreto.');
+          }
+        }
+        const options = incremental ? originData.concat(data.options) : data.options;
+        setOriginData(options);
+        setOptions(buildOptions<O>(options, getOptionLabel, getOptionValue, getOptionImage));
+        setCurrentPage(data.page);
+        setTotalPages(data.totalPages);
+        setIsLastPage(data.page === data.totalPages - 1);
+        setUpdateCounter((prevCounter) => prevCounter + 1);
+      },
+      (err) => {
+        setLoading(false);
+        if (onErrorLoadOptions) {
+          onErrorLoadOptions(err);
+        }
+      },
+    );
+  };
+
+  const isReadOnly = () => {
+    // 🔄 MIGRAÇÃO V1/V2: Usar padrão de compatibilidade para isReadOnly
+    return readOnly || v1v2Compatibility.isReadOnly;
+  };
+
+  const shouldFilterOptions = options.every((item) => item !== queryValue);
+  const filteredOptions = shouldFilterOptions
+    ? options.filter((item) => {
+      return item.label.toLowerCase().includes(queryValue.toLowerCase().trim());
+    })
+    : options;
+
+  const values = selectedValues.map((item) => (
+    <SelectedItemComponent
+      item={item}
+      value={getOptionValue(item)}
+      onRemove={() => handleValueRemove(item)}
+      label={getOptionLabel(item)}
+    />
+  ));
+
+  // Erro a ser exibido: local ou do contexto
+  const displayError = internalError || contextError;
+
+  return (
+    <ArchbaseAsyncSelectProvider
+      value={{
+        handleDropdownScrollEnded,
+      }}
+    >
+      <Combobox
+        store={combobox}
+        withinPortal={true}
+        position={dropdownPosition}
+        zIndex={zIndex}
+        onOptionSubmit={(val) => {
+          handleChange(val);
+        }}
+      >
+        <ComboboxTarget>
+          <PillsInput
+            disabled={disabled}
+            leftSection={icon}
+            leftSectionWidth={iconWidth}
+            label={label}
+            w={width}
+            description={description}
+            error={displayError}
+            required={required}
+            style={style}
+            onClick={() => combobox.openDropdown()}
+            rightSection={
+              <>
+                {loading && <Loader size="xs" />}
+                {!loading && selectedValues !== null && clearable && !disabled && !isReadOnly() ? (
+                  <CloseButton
+                    size="sm"
+                    onMouseDown={(event) => event.preventDefault()}
+                    onClick={() => {
+                      setQueryValue('');
+                      setSelectedValues([]);
+                      // 🔄 MIGRAÇÃO V1/V2: Usar handleValueChange do padrão de compatibilidade
+                      if (dataSource && dataField) {
+                        v1v2Compatibility.handleValueChange([]);
+                      }
+                      if (onChangeValues) {
+                        onChangeValues([])
+                      }
+                    }}
+                    aria-label="Clear value"
+                  />
+                ) : (
+                  <Combobox.Chevron />
+                )}
+              </>
+            }
+            rightSectionPointerEvents={selectedValues === null ? 'none' : 'all'}
+          >
+            <Pill.Group>
+              {values}
+              <PillsInput.Field
+                readOnly={isReadOnly()}
+                value={queryValue}
+                onChange={(event) => {
+                  setQueryValue(event.currentTarget.value);
+                  if (filteredOptions.length > 0) {
+                    combobox.openDropdown();
+                  }
+                  combobox.updateSelectedOptionIndex();
+                  handleSearchChange(event.currentTarget.value);
+                }}
+                onBlur={(event) => {
+                  handleOnFocusExit(event);
+                }}
+                onFocus={(event) => handleOnFocusEnter(event)}
+
+                onClick={() => {
+                  if (filteredOptions.length > 0) {
+                    combobox.openDropdown();
+                  }
+                }}
+                placeholder={placeholder}
+                onKeyDown={(event) => {
+                  if (event.key === 'Backspace' && queryValue.length === 0) {
+                    handleValueRemove(selectedValues[selectedValues.length - 1]);
+                  }
+                }}
+              />
+            </Pill.Group>
+          </PillsInput>
+        </ComboboxTarget>
+        <ComboboxDropdown>
+          <Combobox.Options>
+            <CustomSelectScrollArea mah={280}>
+              {(limit ? filteredOptions.slice(0, limit) : filteredOptions).map((option) => (
+                <Combobox.Option value={option.value} key={option.key}>
+                  {ItemComponent ? <ItemComponent values={selectedValues} {...option} /> : option.label}
+                </Combobox.Option>
+              ))}
+            </CustomSelectScrollArea>
+          </Combobox.Options>
+        </ComboboxDropdown>
+      </Combobox>
+    </ArchbaseAsyncSelectProvider>
+  );
+}
+
+export const CustomSelectScrollArea = forwardRef<HTMLDivElement, ScrollAreaProps>(
+  ({ style, ...others }: ScrollAreaProps, _ref) => {
+    const sRef = useRef<any>(null);
+    const selectContextValue = useContext<ArchbaseAsyncSelectContextValue>(ArchbaseAsyncSelectContext);
+    const handleScrollPositionChange = (_position: { x: number; y: number }): void => {
+      if (sRef && sRef.current) {
+        if (sRef.current.scrollTop === sRef.current.scrollHeight - sRef.current.offsetHeight) {
+          selectContextValue.handleDropdownScrollEnded!();
+        }
+      }
+    };
+
+    return (
+      <ScrollArea.Autosize
+        {...others}
+        style={{ width: '100%', ...style }}
+        viewportProps={{ tabIndex: -1 }}
+        viewportRef={sRef}
+        onScrollPositionChange={handleScrollPositionChange}
+      >
+        {others.children}
+      </ScrollArea.Autosize>
+    );
+  },
+);
+
+CustomSelectScrollArea.displayName = 'CustomSelectScrollArea';

package/src/editors/ArchbaseAsyncSelect.context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ArchbaseAsyncSelect.context.d.ts","sourceRoot":"","sources":["ArchbaseAsyncSelect.context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,MAAM,WAAW,+BAA+B;IAC9C,8EAA8E;IAC9E,yBAAyB,CAAC,EAAE,MAAM,IAAI,CAAC;CACxC;AACD,QAAA,MAAM,0BAA0B,gDAA2D,CAAC;AAC5F,QAAA,MAAM,2BAA2B,iDAAsC,CAAC;AACxE,OAAO,EAAE,2BAA2B,EAAE,0BAA0B,EAAE,CAAC"}

package/src/editors/ArchbaseAsyncSelect.context.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+
+export interface ArchbaseAsyncSelectContextValue {
+  /** Function para notificar o select que o dropdown chegou ao final da lista*/
+  handleDropdownScrollEnded?: () => void;
+}
+const ArchbaseAsyncSelectContext = React.createContext<ArchbaseAsyncSelectContextValue>({});
+const ArchbaseAsyncSelectProvider = ArchbaseAsyncSelectContext.Provider;
+export { ArchbaseAsyncSelectProvider, ArchbaseAsyncSelectContext };

package/src/editors/ArchbaseAsyncSelect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ArchbaseAsyncSelect.d.ts","sourceRoot":"","sources":["ArchbaseAsyncSelect.tsx"],"names":[],"mappings":"AAAA,OAAO,EAKN,gBAAgB,EAIhB,WAAW,EACX,aAAa,EAEb,eAAe,EAEf,MAAM,eAAe,CAAC;AAGvB,OAAO,KAAK,EAAE,EACb,aAAa,EAIb,SAAS,EAMT,MAAM,OAAO,CAAC;AACf,OAAO,EAAE,kBAAkB,EAAyC,MAAM,gBAAgB,CAAC;AAU3F,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI;IAC9B,OAAO,EAAE,CAAC,EAAE,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,WAAW,wBAAwB,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC;IACjD,2CAA2C;IAC3C,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,2CAA2C;IAC3C,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,4DAA4D;IAC5D,UAAU,CAAC,EAAE,kBAAkB,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IACvC,2EAA2E;IAC3E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gDAAgD;IAChD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,mCAAmC;IACnC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,8CAA8C;IAC9C,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,qGAAqG;IACrG,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,kCAAkC;IAClC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,uBAAuB;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,0BAA0B;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,qCAAqC;IACrC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,kCAAkC;IAClC,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,gCAAgC;IAChC,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,4CAA4C;IAC5C,SAAS,CAAC,EAAE,WAAW,CAAC;IACxB,kCAAkC;IAClC,KAAK,CAAC,EAAE,GAAG,CAAC;IACZ,6CAA6C;IAC7C,YAAY,CAAC,EAAE,GAAG,CAAC;IACnB,oEAAoE;IACpE,MAAM,CAAC,EAAE,aAAa,CAAC;IACvB,uBAAuB;IACvB,KAAK,CAAC,EAAE,aAAa,CAAC;IACtB,uBAAuB;IACvB,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,wBAAwB;IACxB,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;IACpC,6CAA6C;IAC7C,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,mCAAmC;IACnC,aAAa,CAAC,EAAE,KAAK,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;IAC9B,8CAA8C;IAC9C,cAAc,CAAC,IAAI,IAAI,CAAC;IACxB,8CAA8C;IAC9C,eAAe,CAAC,IAAI,IAAI,CAAC;IACzB,6EAA6E;IAC7E,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,6BAA6B;IAC7B,YAAY,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAC/B,wBAAwB;IACxB,MAAM,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;IACvC,+CAA+C;IAC/C,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpC,2CAA2C;IAC3C,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;IACnC,yCAAyC;IACzC,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,UAAU,CAAC,gBAAgB,CAAC,KAAK,IAAI,CAAC;IAClE,2CAA2C;IAC3C,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,UAAU,CAAC,gBAAgB,CAAC,KAAK,IAAI,CAAC;IACnE,iCAAiC;IACjC,cAAc,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC;IAClC,gDAAgD;IAChD,cAAc,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,MAAM,CAAC;IACtC,gDAAgD;IAChD,cAAc,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,GAAG,CAAC;IACnC,iDAAiD;IACjD,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,GAAG,GAAG,SAAS,GAAG,IAAI,CAAC;IACvD,uGAAuG;IACvG,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;IACvE,mGAAmG;IACnG,kBAAkB,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAC7C,yDAAyD;IACzD,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,2CAA2C;IAC3C,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC,gBAAgB,CAAC,GAAG,SAAS,CAAC;IACzD,kDAAkD;IAClD,cAAc,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,kFAAkF;IAClF,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,GAAG,CAAC;IAC9B,gGAAgG;IAChG,kBAAkB,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;CAChD;AAgCD,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAC7C,aAAoB,EACpB,SAAgB,EAChB,UAAU,EACV,SAAS,EACT,QAAgB,EAChB,YAAkB,EAClB,gBAAoB,EACpB,QAAgB,EAChB,WAAW,EACX,cAAwD,EACxD,UAAiB,EACjB,KAAK,EACL,WAAW,EACX,KAAK,EACL,IAAI,EACJ,SAAS,EACT,QAAQ,EACR,cAAc,EACd,cAAc,EACd,cAAc,EACd,UAAU,EACV,YAAY,EACZ,WAAW,EACX,aAAa,EACb,KAAK,EACL,YAAY,EACZ,MAAM,EACN,IAAI,EACJ,KAAK,EACL,KAAK,EACL,eAAe,EACf,aAAa,EAAE,aAAa,EAC5B,cAAc,EACd,eAAe,EACf,KAAK,EACL,YAAY,EACZ,MAAM,EACN,gBAAgB,EAChB,kBAAkB,EAClB,QAAQ,EACR,cAAc,EACd,SAAS,EACT,kBAAkB,EAChB,EAAE,wBAAwB,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,2CAsSpC;AAED,eAAO,MAAM,sBAAsB,wFAwBlC,CAAC"}