@archbase/components 3.0.0

package/dist/editors/ArchbaseLookupNumber.d.ts

@@ -0,0 +1,69 @@
+import { MantineSize } from '@mantine/core';
+import type { CSSProperties, ReactNode } from 'react';
+import React from 'react';
+import type { IArchbaseDataSourceBase } from '@archbase/data';
+export interface ArchbaseLookupNumberProps<T, ID, O> {
+    /** Fonte de dados onde será atribuido o valor do lookup edit (V1 ou V2) */
+    dataSource?: IArchbaseDataSourceBase<T>;
+    /** Campo onde deverá ser atribuido o valor do lookup edit na fonte de dados */
+    dataField?: string;
+    /** Campo da fonte de dados que será usado para apresentar o valor no lookup edit */
+    lookupField?: string;
+    /** Indicador se o lookup edit está desabilitado */
+    disabled?: boolean;
+    /** Indicador se o lookup edit é somente leitura. Obs: usado em conjunto com o status da fonte de dados */
+    readOnly?: boolean;
+    /** Indicador se o preenchimento do lookup edit é obrigatório */
+    required?: boolean;
+    /** Validar ao sair do campo se localizou o valor */
+    validateOnExit?: boolean;
+    /** Mensagem caso falhe ao localizar o valor */
+    validateMessage?: string;
+    /** Estilo do lookup edit */
+    style?: CSSProperties;
+    /** Tamanho do campo */
+    size?: MantineSize;
+    /** Largura do lookup edit */
+    width?: string | number | undefined;
+    /** Texto sugestão do lookup edit */
+    placeholder?: string;
+    /** Título do lookup edit */
+    label?: string;
+    /** Descrição do lookup edit */
+    description?: string;
+    /** Último erro ocorrido no lookup edit */
+    error?: string;
+    /** Icone para apresentar lado direito do lookup edit que representa a busca */
+    iconSearch?: ReactNode;
+    /** Dica para botão localizar */
+    tooltipIconSearch?: string;
+    /** Caracter separador decimal */
+    decimalSeparator?: string;
+    /** Caracter separador de milhar */
+    thousandSeparator?: string;
+    /** Número de casas decimais */
+    precision?: number;
+    /** Permite números negativos */
+    allowNegative?: boolean;
+    /** Aceita em branco */
+    allowEmpty?: boolean;
+    /** Valor atual caso não esteje usando fonte de dados*/
+    value?: any;
+    /** Evento ocorre quando clica no botão localizar */
+    onActionSearchExecute?: () => void;
+    /** Evento quando o foco sai do lookup edit */
+    onFocusExit?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    /** Evento quando o lookup edit recebe o foco */
+    onFocusEnter?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    /** Evento quando o valor do lookup edit é alterado */
+    onChangeValue?: (value: any, event: any) => void;
+    /** Evento ocorre quando um valor é localizado */
+    onLookupResult?: (value: O) => void;
+    /** Evento ocorre quando se obtém um erro ao localizar valor */
+    onLookupError?: (error: string) => void;
+    /** Função responsável por localizar um valor */
+    lookupValueDelegator: (value: any) => Promise<O>;
+    /** Referência para o componente interno */
+    innerRef?: React.RefObject<HTMLInputElement> | undefined;
+}
+export declare function ArchbaseLookupNumber<T, ID, O>({ dataSource, dataField, lookupField, iconSearch, disabled, readOnly, style, placeholder, label, description, error, required, size, width, value, lookupValueDelegator, onLookupError, onLookupResult, validateMessage, tooltipIconSearch, validateOnExit, onFocusExit, onFocusEnter, onChangeValue, onActionSearchExecute, innerRef, decimalSeparator, thousandSeparator, precision, allowNegative, allowEmpty, }: ArchbaseLookupNumberProps<T, ID, O>): import("react/jsx-runtime").JSX.Element;

package/dist/editors/ArchbaseLookupSelect.d.ts

@@ -0,0 +1,9 @@
+import { IArchbaseDataSourceBase } from '@archbase/data';
+import { ArchbaseSelectProps } from './ArchbaseSelect';
+export interface ArchbaseLookupSelectProps<T, ID, O> extends Omit<ArchbaseSelectProps<T, ID, O>, 'getOptionLabel'> {
+    lookupDataSource: IArchbaseDataSourceBase<O> | undefined;
+    lookupDataFieldText: string | ((record: any) => string);
+    lookupDataFieldId: string;
+    simpleValue?: boolean;
+}
+export declare function ArchbaseLookupSelect<T, ID, O>({ lookupDataSource, lookupDataFieldText, lookupDataFieldId, simpleValue, children, dataSource, dataField, options, error, getOptionValue, ...otherProps }: ArchbaseLookupSelectProps<T, ID, O>): import("react/jsx-runtime").JSX.Element;

package/dist/editors/ArchbaseMarkdownEdit.d.ts

@@ -0,0 +1,52 @@
+import { CSSProperties } from 'react';
+import type { IArchbaseDataSourceBase } from '@archbase/data';
+export interface ArchbaseMarkdownEditProps<T, ID> {
+    /** Indicador se o editor recebe o foco automaticamente */
+    autoFocus?: boolean;
+    /** Fonte de dados onde será atribuido o valor do editor (V1 ou V2) */
+    dataSource?: IArchbaseDataSourceBase<T>;
+    /** Campo onde deverá ser atribuido o valor do editor na fonte de dados */
+    dataField?: string;
+    /** Indicador se o editor está desabilitado */
+    disabled?: boolean;
+    /** Indicador se o editor é somente leitura. Obs: usado em conjunto com o status da fonte de dados */
+    readOnly?: boolean;
+    /** Indicador se o preenchimento do editor é obrigatório */
+    required?: boolean;
+    /** Estilo do editor */
+    style?: CSSProperties;
+    /** Largura do editor */
+    width?: string | number | undefined;
+    /** Altura do editor */
+    height?: string | number | undefined;
+    /** Altura mínima do editor */
+    minHeight?: string | number | undefined;
+    /** Título do editor */
+    label?: string;
+    /** Descrição do editor */
+    description?: string;
+    /** Último erro ocorrido no editor */
+    error?: string;
+    /** Valor inicial do markdown */
+    value?: string;
+    /** Texto de espaço reservado quando vazio */
+    placeholder?: string;
+    /** Habilitar visualização em tempo real */
+    enablePreview?: boolean;
+    /** Sanitização HTML */
+    sanitize?: ((html: string) => string) | boolean;
+    /** Evento quando o valor do editor é alterado */
+    onChangeValue?: (value: string) => void;
+    /** Evento quando o editor é salvo (Ctrl+S) */
+    onSave?: (value: string) => void;
+    /** Evento quando o foco sai do editor */
+    onFocusExit?: (event: FocusEvent) => void;
+    /** Evento quando o editor recebe o foco */
+    onFocusEnter?: (event: FocusEvent) => void;
+    /** Evento quando HTML é gerado */
+    onHtmlChanged?: (html: string) => void;
+    /** Modo de edição (live, preview, readonly, etc.) */
+    previewOnly?: boolean;
+}
+export declare function ArchbaseMarkdownEdit<T, ID>({ autoFocus, dataSource, dataField, disabled, readOnly, required, label, description, error, width, height, minHeight, placeholder, enablePreview, sanitize, onChangeValue, onSave, onFocusExit, onFocusEnter, onHtmlChanged, previewOnly, value, style, }: ArchbaseMarkdownEditProps<T, ID>): import("react/jsx-runtime").JSX.Element;
+export type { default as MarkdownEditorLite } from 'react-markdown-editor-lite';

package/dist/editors/ArchbaseMaskEdit.d.ts

@@ -0,0 +1,79 @@
+/**
+ * ArchbaseMaskEdit — input mascarado com padrões comuns e integração com dataSource.
+ * @status stable
+ */
+import { __InputProps, InputStylesNames, InputVariant, InputWrapperStylesNames, MantineSize, PolymorphicFactory, StylesApiProps } from '@mantine/core';
+import type { CSSProperties } from 'react';
+import React from 'react';
+import type { IArchbaseDataSourceBase } from '@archbase/data';
+export declare enum MaskPattern {
+    CNPJ = "00.000.000/0000-00",
+    CEP = "00.000-000",
+    CPF = "000.000.000-00",
+    PLACA = "aaa-00*00",
+    PHONE = "(00) 00000-0000"
+}
+export type ArchbaseMaskEditStylesNames = InputStylesNames | InputWrapperStylesNames;
+export interface ArchbaseMaskEditProps<T, ID> extends StylesApiProps<ArchbaseMaskEditFactory>, __InputProps, Omit<React.ComponentPropsWithoutRef<'input'>, 'size'> {
+    /** Tipo de campo html */
+    type?: React.HTMLInputTypeAttribute;
+    /** Propriedades para atribuir ao wrapper do mask edit */
+    wrapperProps?: Record<string, any>;
+    /** Nome do seletor estático */
+    __staticSelector?: string;
+    /** Fonte de dados onde será atribuido o valor do mask edit (V1 ou V2) */
+    dataSource?: IArchbaseDataSourceBase<T>;
+    /** Campo onde deverá ser atribuido o valor do mask edit na fonte de dados */
+    dataField?: string;
+    /** Indicador se o mask edit está desabilitado */
+    disabled?: boolean;
+    /** Indicador se o mask edit é somente leitura. Obs: usado em conjunto com o status da fonte de dados */
+    readOnly?: boolean;
+    /** Estilo do mask edit */
+    style?: CSSProperties;
+    /** Tamanho do mask edit */
+    size?: MantineSize;
+    /** Largura do mask edit */
+    width?: string | number | undefined;
+    /** Valor inicial do mask edit */
+    value?: any;
+    /** Texto sugestão do mask edit */
+    placeholder?: string;
+    /** Caractere a ser mostrado onde não houver valor no campo */
+    placeholderChar?: string;
+    /** Indicador se apresenta ou não a máscara */
+    showMask?: boolean;
+    /** Mascara podendo ser o tipo MaskPattern, uma Function ou uma string. Mais detalhes em: https://github.com/uNmAnNeR/imaskjs */
+    mask?: MaskPattern | Function | string;
+    /** Indicador se deverá ser salvo o valor com a máscara */
+    saveWithMask?: boolean;
+    /** Evento quando o foco sai do edit */
+    onFocusExit?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    /** Evento quando o edit recebe o foco */
+    onFocusEnter?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    /** Evento quando o valor do edit é alterado */
+    onChangeValue?: (value: string, event: any) => void;
+    /** Referência para o componente interno */
+    innerRef?: React.RefObject<HTMLInputElement> | undefined;
+    /** Último erro ocorrido no mask edit */
+    error?: string;
+    /** Título do edit */
+    title?: string;
+    /** Título do edit */
+    label?: string;
+    /** Evento que retorna o valor do erro */
+    onChangeError?: (error: string) => void;
+    /** Mensagem customizada a ser exibida quando o campo está incompleto */
+    customIncompleteErrorMessage?: string;
+}
+export type ArchbaseMaskEditFactory = PolymorphicFactory<{
+    props: ArchbaseMaskEditProps<any, any>;
+    defaultRef: HTMLInputElement;
+    defaultComponent: 'input';
+    stylesNames: ArchbaseMaskEditStylesNames;
+    variant: InputVariant;
+}>;
+export declare function ArchbaseMaskEdit<T, ID>(props: ArchbaseMaskEditProps<any, any>): import("react/jsx-runtime").JSX.Element;
+export declare namespace ArchbaseMaskEdit {
+    var displayName: string;
+}

package/dist/editors/ArchbaseNumberEdit.d.ts

@@ -0,0 +1,51 @@
+import { CloseButtonProps, MantineSize, TextInputProps } from '@mantine/core';
+import { IArchbaseDataSourceBase } from '@archbase/data';
+import type { CSSProperties } from 'react';
+import React from 'react';
+export interface ArchbaseNumberEditProps<T, ID> extends TextInputProps, Omit<React.ComponentPropsWithoutRef<'input'>, 'size' | 'value' | 'defaultValue' | 'onChange'>, React.RefAttributes<HTMLInputElement> {
+    clearable?: boolean;
+    clearButtonProps?: CloseButtonProps;
+    /** Fonte de dados onde será atribuido o valor (V1 ou V2) */
+    dataSource?: IArchbaseDataSourceBase<T>;
+    dataField?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+    style?: CSSProperties;
+    size?: MantineSize;
+    width?: string | number | undefined;
+    className?: string;
+    error?: string;
+    onFocusExit?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    onFocusEnter?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    onChangeValue?: (maskValue: string, value: number | null, event: any) => void;
+    value?: number | string;
+    decimalSeparator?: string;
+    thousandSeparator?: string;
+    precision?: number;
+    allowNegative?: boolean;
+    allowEmpty?: boolean;
+    prefix?: string;
+    suffix?: string;
+    integer?: boolean;
+    innerRef?: React.RefObject<HTMLInputElement> | undefined;
+    onClear?: () => void;
+    minValue?: number;
+    maxValue?: number;
+}
+export declare function ArchbaseNumberEdit<T, ID>({ dataSource, dataField, disabled, readOnly, style, className, onFocusExit, onFocusEnter, onChangeValue, value, decimalSeparator, thousandSeparator, precision, allowNegative, allowEmpty, clearable, prefix, suffix, integer, wrapperProps, clearButtonProps, rightSection, unstyled, classNames, width, size, error, innerRef, onClear, minValue, maxValue, ...others }: ArchbaseNumberEditProps<T, ID>): import("react/jsx-runtime").JSX.Element;
+export declare namespace ArchbaseNumberEdit {
+    var defaultProps: {
+        decimalSeparator: string;
+        thousandSeparator: string;
+        precision: number;
+        allowNegative: boolean;
+        prefix: string;
+        suffix: string;
+        integer: boolean;
+        disabled: boolean;
+        allowEmpty: boolean;
+        clearable: boolean;
+        value: string;
+    };
+    var displayName: string;
+}

package/dist/editors/ArchbaseNumberInput.d.ts

@@ -0,0 +1,2 @@
+export { NumberInput as ArchbaseNumberInput } from '@mantine/core';
+export type { NumberInputProps as ArchbaseNumberInputProps } from '@mantine/core';

package/dist/editors/ArchbaseOperationHoursEditor.d.ts

@@ -0,0 +1,8 @@
+export type ArchbaseOperatingHoursEditorProps = {
+    onChange: (value: any) => void;
+    readOnly?: boolean;
+    initialValue: any;
+    label?: any;
+    error?: string;
+};
+export declare function ArchbaseOperatingHoursEditor({ label, initialValue, onChange, readOnly, error }: ArchbaseOperatingHoursEditorProps): import("react/jsx-runtime").JSX.Element;

package/dist/editors/ArchbasePasswordEdit.d.ts

@@ -0,0 +1,44 @@
+import { InputVariant, MantineSize } from '@mantine/core';
+import type { CSSProperties } from 'react';
+import React from 'react';
+import type { IArchbaseDataSourceBase } from '@archbase/data';
+export interface ArchbasePasswordEditProps<T, ID> {
+    /** Fonte de dados onde será atribuido o valor do edit (V1 ou V2) */
+    dataSource?: IArchbaseDataSourceBase<T>;
+    /** Campo onde deverá ser atribuido o valor do edit na fonte de dados */
+    dataField?: string;
+    /** Indicador se o edit está desabilitado */
+    disabled?: boolean;
+    /** Indicador se o edit é somente leitura. Obs: usado em conjunto com o status da fonte de dados */
+    readOnly?: boolean;
+    /** Indicador se o preenchimento do edit é obrigatório */
+    required?: boolean;
+    /** Valor inicial */
+    value?: string;
+    /** Estilo do edit */
+    style?: CSSProperties;
+    /** Tamanho do edit */
+    size?: MantineSize;
+    /** Largura do edit */
+    width?: string | number | undefined;
+    /** Texto sugestão do edit */
+    placeholder?: string;
+    /** Título do edit */
+    label?: string;
+    /** Descrição do edit */
+    description?: string;
+    /** Último erro ocorrido no edit */
+    error?: string;
+    /** Evento quando o foco sai do edit */
+    onFocusExit?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    /** Evento quando o edit recebe o foco */
+    onFocusEnter?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    /** Evento quando o valor do edit é alterado */
+    onChangeValue?: (value: any, event: any) => void;
+    onKeyDown?: (event: any) => void;
+    onKeyUp?: (event: any) => void;
+    /** Referência para o componente interno */
+    innerRef?: React.RefObject<HTMLInputElement> | undefined;
+    variant?: InputVariant;
+}
+export declare function ArchbasePasswordEdit<T, ID>({ dataSource, dataField, disabled, readOnly, style, placeholder, label, description, error, required, size, width, innerRef, value, onKeyDown, onKeyUp, onFocusExit, onFocusEnter, onChangeValue, variant, }: ArchbasePasswordEditProps<T, ID>): import("react/jsx-runtime").JSX.Element;

package/dist/editors/ArchbasePasswordInput.d.ts

@@ -0,0 +1,2 @@
+export { PasswordInput as ArchbasePasswordInput } from '@mantine/core';
+export type { PasswordInputProps as ArchbasePasswordInputProps } from '@mantine/core';

package/dist/editors/ArchbaseRadio.d.ts

@@ -0,0 +1,2 @@
+export { Radio as ArchbaseRadio } from '@mantine/core';
+export type { RadioProps as ArchbaseRadioProps } from '@mantine/core';

package/dist/editors/ArchbaseRadioGroup.d.ts

@@ -0,0 +1,45 @@
+import { MantineSize } from '@mantine/core';
+import type { CSSProperties } from 'react';
+import React, { ReactNode } from 'react';
+import type { IArchbaseDataSourceBase } from '@archbase/data';
+export interface ArchbaseRadioGroupProps<T, ID, O> {
+    /** Fonte de dados onde será atribuido o valor do RadioGroup (V1 ou V2) */
+    dataSource?: IArchbaseDataSourceBase<T>;
+    /** Campo onde deverá ser atribuido o valor do RadioGroup na fonte de dados */
+    dataField?: string;
+    /** Estilo do componente */
+    style?: CSSProperties;
+    /** Estilo do componente filho */
+    childStyle?: CSSProperties;
+    /** Tamanho do edit */
+    size?: MantineSize;
+    /** Título do RadioGroup */
+    label?: string;
+    /** Descrição do RadioGroup */
+    description?: string;
+    /** Último erro ocorrido no RadioGroup */
+    error?: string;
+    /** Evento quando o foco sai do RadioGroup */
+    onFocusExit?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    /** Evento quando o RadioGroup recebe o foco */
+    onFocusEnter?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    /** Evento quando um valor é selecionado */
+    onSelectValue?: (value: any) => void;
+    /** Function que retorna o label de uma RadioItem */
+    getOptionLabel?: (option: O) => string;
+    /** Function que retorna o valor de uma RadioItem */
+    getOptionValue?: (option: O) => any;
+    /** Function que converte o valor selecionado do tipo padrão string para o tipo desejado */
+    convertFromString?: (selected: string) => any;
+    /** Opções de seleção iniciais */
+    initialOptions?: O[] | object;
+    /** Coleção de RadioItem[] que representam as opções do select */
+    children?: ReactNode | ReactNode[];
+    /** Valor de entrada controlado */
+    value?: any;
+    /** Valor padrão de entrada não controlado */
+    defaultValue?: any;
+    /** Direção dos itens do RadioGroup */
+    direction?: 'horizontal' | 'vertical';
+}
+export declare function ArchbaseRadioGroup<T, ID, O>({ dataSource, dataField, style, childStyle, size, label, description, error, onFocusExit, onFocusEnter, onSelectValue, getOptionLabel, getOptionValue, convertFromString, value, defaultValue, initialOptions, children, direction, }: ArchbaseRadioGroupProps<T, ID, O>): import("react/jsx-runtime").JSX.Element;

package/dist/editors/ArchbaseRadioItem.d.ts

@@ -0,0 +1,12 @@
+export interface ArchbaseRadioItemProps<T> {
+    /** Texto a ser apresentado no radio */
+    label: string;
+    /** Cor de fundo do item */
+    value?: T;
+    /** Indicador se o item está desabilitado */
+    disabled: boolean;
+}
+export declare function ArchbaseRadioItem<T>(_props: ArchbaseRadioItemProps<T>): any;
+export declare namespace ArchbaseRadioItem {
+    var displayName: string;
+}

package/dist/editors/ArchbaseRating.d.ts

@@ -0,0 +1,52 @@
+import { MantineSize } from '@mantine/core';
+import React, { CSSProperties } from 'react';
+import { IArchbaseDataSourceBase } from '@archbase/data';
+export interface ArchbaseRatingProps<T, ID> {
+    /** Fonte de dados onde será atribuido o valor do rating (V1 ou V2) */
+    dataSource?: IArchbaseDataSourceBase<T>;
+    /** Campo onde deverá ser atribuido o valor do rating na fonte de dados */
+    dataField?: string;
+    /** Indicador se o rating está desabilitado */
+    disabled?: boolean;
+    /** Indicador se o rating é somente leitura. Obs: usado em conjunto com o status da fonte de dados */
+    readOnly?: boolean;
+    /** Indicador se o preenchimento do rating é obrigatório */
+    required?: boolean;
+    /** Quantidade de controles a ser renderizado */
+    count: number;
+    /** Valor inicial */
+    value?: number;
+    /** O ícone que é exibido quando o símbolo está vazio*/
+    emptySymbol?: React.ReactNode | ((value: number) => React.ReactNode);
+    /** Este ícone que é exibido quando o símbolo está cheio */
+    fullSymbol?: React.ReactNode | ((value: number) => React.ReactNode);
+    /** Número de frações em que cada item pode ser dividido, 1 por padrão */
+    fractions?: number;
+    /** Chamado quando o item é pairado */
+    onHover?(value: number): void;
+    /** A função deve retornar labelText para os símbolos */
+    getSymbolLabel?: (value: number) => string;
+    /** Nome da avaliação, deve ser único na página */
+    name?: string;
+    /** Se verdadeiro, apenas o símbolo selecionado mudará para símbolo completo */
+    highlightSelectedOnly?: boolean;
+    /** Estilo do rating */
+    style?: CSSProperties;
+    /** Título do rating */
+    label?: string;
+    /** Descrição do rating */
+    description?: string;
+    /** Último erro ocorrido no rating */
+    error?: string;
+    /** Tamanho do rating */
+    size?: MantineSize;
+    /** Evento quando o foco sai do rating */
+    onFocusExit?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    /** Evento quando o rating recebe o foco */
+    onFocusEnter?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    /** Evento quando o valor do rating é alterado */
+    onChangeValue?: (value?: number) => void;
+    /** Referência para o componente interno */
+    innerRef?: React.RefObject<HTMLInputElement> | undefined;
+}
+export declare function ArchbaseRating<T, ID>({ dataSource, dataField, readOnly, style, size, innerRef, value, fractions, onFocusExit, onFocusEnter, onChangeValue, error, label, description, }: ArchbaseRatingProps<T, ID>): import("react/jsx-runtime").JSX.Element;

package/dist/editors/ArchbaseRichTextEdit.d.ts

@@ -0,0 +1,80 @@
+import React, { CSSProperties } from 'react';
+import type { UploadBeforeHandler, UploadBeforeReturn, UploadInfo } from 'suneditor-react/dist/types/upload';
+import type { IArchbaseDataSourceBase } from '@archbase/data';
+export interface ArchbaseRichTextEditProps<T, ID> {
+    /** Indicador se o rich editor recebe o foco automaticamente */
+    autoFocus?: boolean;
+    /** Fonte de dados onde será atribuido o valor do rich edit (V1 ou V2) */
+    dataSource?: IArchbaseDataSourceBase<T>;
+    /** Campo onde deverá ser atribuido o valor do rich edit na fonte de dados */
+    dataField?: string;
+    /** Indicador se o rich edit está desabilitado */
+    disabled?: boolean;
+    /** Indicador se o rich edit é somente leitura. Obs: usado em conjunto com o status da fonte de dados */
+    readOnly?: boolean;
+    /** Indicador se o preenchimento do rich edit é obrigatório */
+    required?: boolean;
+    /** Estilo do checkbox */
+    style?: CSSProperties;
+    /** Largura do edit */
+    width?: string | undefined;
+    /** Altura do edit */
+    height?: string | undefined;
+    /** Título do rich edit */
+    label?: string;
+    /** Descrição do rich edit */
+    description?: string;
+    /** Último erro ocorrido no rich edit */
+    error?: string;
+    /** Esconder barra de ações */
+    hideToolbar?: boolean;
+    /** Desabilitar barra de açõess */
+    disableToolbar?: boolean;
+    /** Valor inicial */
+    value?: string;
+    /** Desabilita conversão do conteúdo em base64 antes de salvar na fonte de dados */
+    disabledBase64Convertion?: boolean;
+    /** Evento quando o foco sai do rich edit */
+    onFocusExit?: (event: FocusEvent) => void;
+    /** Evento quando o rich edit recebe o foco */
+    onFocusEnter?: (event: FocusEvent) => void;
+    /** Evento quando o valor do rich edit é alterado */
+    onChangeValue?: (value: any) => void;
+    /** Referência para o componente interno */
+    innerRef?: React.RefObject<HTMLInputElement> | undefined;
+    onScroll?: (event: UIEvent) => void;
+    onCopy?: (event: ClipboardEvent, clipboardData: ClipboardEvent['clipboardData']) => boolean;
+    onCut?: (event: ClipboardEvent, clipboardData: ClipboardEvent['clipboardData']) => boolean;
+    onClick?: (event: MouseEvent) => void;
+    onMouseDown?: (event: MouseEvent) => void;
+    onKeyUp?: (event: KeyboardEvent) => void;
+    onKeyDown?: (event: KeyboardEvent) => void;
+    onSave?: (contents: string) => void;
+    onSetToolbarButtons?: (buttonList: Array<any>) => void;
+    onLoad?: (reload: boolean) => void;
+    onDrop?: (event: DragEvent, cleanData: string, maxCharCount: boolean) => boolean | Array<any> | void;
+    onPaste?: (event: ClipboardEvent, cleanData: string, maxCharCount: boolean) => void;
+    onImageUpload?: (targetImgElement: HTMLImageElement, index: number, state: 'create' | 'update' | 'delete', imageInfo: UploadInfo<HTMLImageElement>, remainingFilesCount: number) => void;
+    onVideoUpload?: (targetElement: HTMLVideoElement, index: number, state: 'create' | 'update' | 'delete', videoInfo: UploadInfo<HTMLVideoElement>, remainingFilesCount: number) => void;
+    onAudioUpload?: (targetElement: HTMLAudioElement, index: number, state: 'create' | 'update' | 'delete', audioInfo: UploadInfo<HTMLAudioElement>, remainingFilesCount: number) => void;
+    onImageUploadBefore?: (files: Array<File>, info: object, uploadHandler: UploadBeforeHandler) => UploadBeforeReturn;
+    onVideoUploadBefore?: (files: Array<File>, info: object, uploadHandler: UploadBeforeHandler) => UploadBeforeReturn;
+    onAudioUploadBefore?: (files: Array<File>, info: object, uploadHandler: UploadBeforeHandler) => UploadBeforeReturn;
+    onImageUploadError?: (errorMessage: string, result: any) => void;
+    onVideoUploadError?: (errorMessage: string, result: any) => void;
+    onAudioUploadError?: (errorMessage: string, result: any) => void;
+    toggleCodeView?: (isCodeView: boolean) => void;
+    toggleFullScreen?: (isFullScreen: boolean) => void;
+    showInline?: (toolbar: Element, context: any) => void;
+    showController?: (name: string, controllers: Array<any>) => void;
+    imageUploadHandler?: (xmlHttpRequest: XMLHttpRequest, info: {
+        isUpdate: boolean;
+        linkValue: any;
+        element: Element;
+        align: any;
+        linkNewWindow: any;
+        [key: string]: any;
+    }) => void;
+    onResizeEditor?: (height: number, prevHeight: number) => any;
+}
+export declare function ArchbaseRichTextEdit<T, ID>({ autoFocus, dataSource, dataField, disabled, readOnly, required, label, description, error, width, height, hideToolbar, disableToolbar, value, disabledBase64Convertion, onFocusExit, onFocusEnter, onChangeValue, onScroll, onCopy, onCut, onClick, onMouseDown, onKeyUp, onKeyDown, onSave, onSetToolbarButtons, onLoad, onDrop, onPaste, onImageUpload, onVideoUpload, onAudioUpload, onImageUploadBefore, onVideoUploadBefore, onAudioUploadBefore, onImageUploadError, onVideoUploadError, onAudioUploadError, toggleCodeView, toggleFullScreen, showInline, showController, imageUploadHandler, }: ArchbaseRichTextEditProps<T, ID>): import("react/jsx-runtime").JSX.Element;

package/dist/editors/ArchbaseSelect.context.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+export interface ArchbaseSelectContextValue {
+    /** Function para notificar o select que o dropdown chegou ao final da lista*/
+    handleDropdownScrollEnded?: () => void;
+}
+declare const ArchbaseSelectContext: React.Context<ArchbaseSelectContextValue>;
+declare const ArchbaseSelectProvider: React.Provider<ArchbaseSelectContextValue>;
+export { ArchbaseSelectContext, ArchbaseSelectProvider };

package/dist/editors/ArchbaseSelect.d.ts

@@ -0,0 +1,107 @@
+import { ComboboxItem, CSSProperties, MantineSize, MantineStyleProp, MantineTheme, SelectProps, SelectStylesNames } from '@mantine/core';
+import React, { ReactNode } from 'react';
+import { ArchbaseDataSource, IArchbaseDataSourceBase } from '@archbase/data';
+export interface SelectItem extends ComboboxItem {
+    selected?: boolean;
+    group?: string;
+    [key: string]: any;
+}
+export interface ArchbaseSelectProps<T, ID, O> {
+    /** Permite ou não delecionar 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;
+    /** 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;
+    /** Estilo do select */
+    style?: MantineStyleProp;
+    /** 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?(value: string, item: any): boolean;
+    /** Tamanho de entrada */
+    size?: MantineSize;
+    /** Estado aberto do menu suspenso inicial */
+    initiallyOpened?: boolean;
+    /** Alterar renderizador de item */
+    itemComponent?: React.FC<any>;
+    /** Largura do select */
+    width?: string | number;
+    /** Estado do dropdown controlado*/
+    dropdownOpened?: boolean;
+    /** 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?: 'bottom' | 'top' | 'flip';
+    /** Evento quando um valor é selecionado */
+    onSelectValue?: (value: O, origin: any) => void;
+    /** Evento de click */
+    onClick?: React.MouseEventHandler<HTMLInputElement>;
+    /** 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?: 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) => string;
+    /** Coleção de ArchbaseSelectItem[] que representam as opções do select */
+    children?: ReactNode | ReactNode[];
+    /** Indica se o select tem o preenchimento obrigatório */
+    required?: boolean;
+    /** Referência para o componente interno */
+    innerRef?: React.RefObject<HTMLInputElement> | undefined;
+    /** Selecione os dados usados ​​para renderizar itens no menu suspenso */
+    options?: ReadonlyArray<string | SelectItem> | ArchbaseDataSource<any, any>;
+    optionsLabelField?: string;
+    customGetDataSourceFieldValue?: () => any;
+    customSetDataSourceFieldValue?: (value: any) => void;
+    classNames?: Partial<Record<SelectStylesNames, string>> | ((theme: MantineTheme, props: SelectProps, ctx: unknown) => Partial<Record<SelectStylesNames, string>>);
+    styles?: Partial<Record<SelectStylesNames, CSSProperties>> | ((theme: MantineTheme, props: SelectProps, ctx: unknown) => Partial<Record<SelectStylesNames, CSSProperties>>);
+    /** Converte o valor antes de atribuir ao field do registro atual no datasource
+     * Por exemplo: (obj) => obj.id para armazenar apenas o ID de um objeto
+     */
+    converter?: (value: O) => any;
+    /** Function que busca o valor original antes de converter pelo valor de retorno do converter
+     * Por exemplo: (id) => fetchObjectById(id) para converter ID de volta ao objeto
+     */
+    getConvertedOption?: (value: any) => Promise<O>;
+}
+export declare function ArchbaseSelect<T, ID, O>({ allowDeselect, clearable, dataSource, dataField, disabled, debounceTime, readOnly, placeholder, initialOptions, searchable, label, description, error, icon, iconWidth, required, width, getOptionLabel, getOptionValue, optionsLabelField, onFocusEnter, onFocusExit, onSelectValue, onClick, value, defaultValue, filter, size, initiallyOpened, itemComponent: ItemComponent, dropdownOpened, onDropdownOpen, onDropdownClose, limit, nothingFound, zIndex, style, dropdownPosition, children, innerRef, options, customGetDataSourceFieldValue, customSetDataSourceFieldValue, classNames, styles, converter, getConvertedOption }: ArchbaseSelectProps<T, ID, O>): import("react/jsx-runtime").JSX.Element;
+export declare namespace ArchbaseSelect {
+    var displayName: string;
+}