@archbase/components 3.0.0

package/dist/editors/ArchbaseSelectItem.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+export interface ArchbaseSelectItemProps<T> {
+    /** Texto a ser apresentado no select */
+    label: ReactNode;
+    /** Valor do item */
+    value?: T;
+    /** Indicador se o item está desabilitado */
+    disabled?: boolean;
+    /** Parâmetros adicionais */
+    [key: string]: any;
+}
+export declare function ArchbaseSelectItem<T>(_props: ArchbaseSelectItemProps<T>): any;
+export declare namespace ArchbaseSelectItem {
+    var displayName: string;
+}

package/dist/editors/ArchbaseSwitch.d.ts

@@ -0,0 +1,53 @@
+import { MantineColor, MantineSize } from '@mantine/core';
+import type { CSSProperties } from 'react';
+import React from 'react';
+import type { IArchbaseDataSourceBase } from '@archbase/data';
+export interface ArchbaseSwitchProps<T, ID> {
+    /** Fonte de dados onde será atribuido o valor do switch (V1 ou V2) */
+    dataSource?: IArchbaseDataSourceBase<T>;
+    /** Campo onde deverá ser atribuido o valor do switch na fonte de dados */
+    dataField?: string;
+    /** Indicador se o switch está desabilitado */
+    disabled?: boolean;
+    /** Indicador se o switch é somente leitura. Obs: usado em conjunto com o status da fonte de dados */
+    readOnly?: boolean;
+    /** Indicador se o preenchimento do switch é obrigatório */
+    required?: boolean;
+    /** Estilo do switch */
+    style?: CSSProperties;
+    /** Valor quando o switch estiver true */
+    trueValue?: any;
+    /** Valor quando o switch estiver false */
+    falseValue?: any;
+    /** Rótulo interno quando o switch está no estado desmarcado */
+    offLabel?: React.ReactNode;
+    /** Rótulo interno quando o switch está no estado checado */
+    onLabel?: React.ReactNode;
+    /** Mude a cor do estado marcado de theme.colors, padrão para theme.primaryColor*/
+    color?: MantineColor;
+    /** Valor de tamanho predefinido */
+    size?: MantineSize;
+    /** Chave de theme.radius ou qualquer valor CSS válido para definir border-radius, "xl" por padrão */
+    radius?: string | number | undefined;
+    /** Ícone dentro do polegar do interruptor */
+    thumbIcon?: React.ReactNode;
+    /** Indicador se o switch está marcado */
+    isChecked?: boolean;
+    /** Título do switch */
+    label?: string;
+    /** Largura do switch */
+    width?: string | number | undefined;
+    /** Descrição do switch */
+    description?: string;
+    /** Último erro ocorrido no switch */
+    error?: string;
+    /** Evento quando o foco sai do switch */
+    onFocusExit?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    /** Evento quando o switch recebe o foco */
+    onFocusEnter?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    /** Evento quando o valor do switch é alterado */
+    onChangeValue?: (value: any, event: any) => void;
+    /** Referência para o componente interno */
+    innerRef?: React.RefObject<HTMLInputElement> | undefined;
+}
+export declare function ArchbaseSwitch<T, ID>({ dataSource, dataField, disabled, readOnly, required, style, trueValue, falseValue, isChecked, width, label, description, error, offLabel, onLabel, size, radius, thumbIcon, onFocusExit, onFocusEnter, onChangeValue, innerRef, }: ArchbaseSwitchProps<T, ID>): import("react/jsx-runtime").JSX.Element;

package/dist/editors/ArchbaseTextArea.d.ts

@@ -0,0 +1,47 @@
+import { MantineSize } from '@mantine/core';
+import type { CSSProperties } from 'react';
+import React from 'react';
+import type { IArchbaseDataSourceBase } from '@archbase/data';
+export interface ArchbaseTextAreaProps<T, ID> {
+    /** Fonte de dados onde será atribuido o valor do textarea (V1 ou V2) */
+    dataSource?: IArchbaseDataSourceBase<T>;
+    /** Campo onde deverá ser atribuido o valor do textarea na fonte de dados */
+    dataField?: string;
+    /** Indicador se o textarea está desabilitado */
+    disabled?: boolean;
+    /** Indicador se o textarea é somente leitura. Obs: usado em conjunto com o status da fonte de dados */
+    readOnly?: boolean;
+    /** Indicador se o preenchimento do textarea é obrigatório */
+    required?: boolean;
+    /** Estilo do textarea */
+    style?: CSSProperties;
+    /** Tamanho do textarea */
+    size?: MantineSize;
+    /** Largura do textarea */
+    width?: string | number | undefined;
+    /** Indicador se textarea crescerá com o conteúdo até que maxRows sejam atingidos  */
+    autosize?: boolean;
+    /** Número mínimo de linhas obrigatórias */
+    minRows?: number;
+    /** Número máximo de linhas aceitas */
+    maxRows?: number;
+    /** Desabilita conversão do conteúdo em base64 antes de salvar na fonte de dados */
+    disabledBase64Convertion?: boolean;
+    /** Texto sugestão do textarea */
+    placeholder?: string;
+    /** Título do textarea */
+    label?: string;
+    /** Descrição do textarea */
+    description?: string;
+    /** Último erro ocorrido no textarea */
+    error?: string;
+    /** Evento quando o foco sai do textarea */
+    onFocusExit?: (event: React.FocusEvent<HTMLTextAreaElement>) => void;
+    /** Evento quando o textarea recebe o foco */
+    onFocusEnter?: (event: React.FocusEvent<HTMLTextAreaElement>) => void;
+    /** Evento quando o valor do textarea é alterado */
+    onChangeValue?: (value: any, event: any) => void;
+    /** Referência para o componente interno */
+    innerRef?: React.RefObject<HTMLTextAreaElement> | undefined;
+}
+export declare function ArchbaseTextArea<T, ID>({ dataSource, dataField, disabled, readOnly, style, placeholder, label, description, error, onFocusExit, onFocusEnter, onChangeValue, autosize, minRows, maxRows, required, disabledBase64Convertion, innerRef, }: ArchbaseTextAreaProps<T, ID>): import("react/jsx-runtime").JSX.Element;

package/dist/editors/ArchbaseTimeEdit.d.ts

@@ -0,0 +1,52 @@
+import { ActionIconVariant, MantineSize } from '@mantine/core';
+import type { CSSProperties, ReactNode } from 'react';
+import React from 'react';
+import type { IArchbaseDataSourceBase } from '@archbase/data';
+export interface ArchbaseTimeEditProps<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 no formato HH:MM */
+    value?: string;
+    /** Estilo do edit */
+    style?: CSSProperties;
+    /** Tamanho do edit */
+    size?: MantineSize;
+    /** Largura do edit */
+    width?: string | number | undefined;
+    /** Icone à direita (substitui o ícone padrão de relógio) */
+    icon?: ReactNode;
+    /** Dica para botão localizar */
+    tooltipIconSearch?: string;
+    /** Evento ocorre quando clica no botão localizar */
+    onActionSearchExecute?: () => void;
+    /** 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: string, event: any) => void;
+    onKeyDown?: (event: any) => void;
+    onKeyUp?: (event: any) => void;
+    /** Referência para o componente interno */
+    innerRef?: React.RefObject<HTMLInputElement> | undefined;
+    variant?: ActionIconVariant;
+    /** Controla se o picker de hora será exibido */
+    withPicker?: boolean;
+}
+export declare function ArchbaseTimeEdit<T, ID>({ dataSource, dataField, disabled, readOnly, style, placeholder, label, description, error, required, size, width, innerRef, value, icon, onKeyDown, onKeyUp, onActionSearchExecute, tooltipIconSearch, onFocusExit, onFocusEnter, onChangeValue, variant, withPicker }: ArchbaseTimeEditProps<T, ID>): import("react/jsx-runtime").JSX.Element;

package/dist/editors/ArchbaseTimeRangeSelector.d.ts

@@ -0,0 +1,40 @@
+import React, { FC } from 'react';
+export type RangeOption = {
+    label: string;
+    value: string;
+    rangeFunction: (current: Date) => {
+        start: Date;
+        end: Date;
+    };
+};
+export type ArchbaseTimeRangeSelectorRef = {
+    updateCurrentRange: () => {
+        start: Date | null;
+        end: Date | null;
+    };
+    getCurrentRange: () => {
+        selectedValue: string | null;
+        range: {
+            start: Date | null;
+            end: Date | null;
+        };
+    };
+};
+export type ArchbaseTimeRangeSelectorProps = {
+    ranges: RangeOption[];
+    onRangeChange?: (selectedValue: string | null, range: {
+        start: Date | null;
+        end: Date | null;
+    }) => void;
+    defaultRangeValue?: string | null;
+    defaultDateRange?: {
+        start: Date | null;
+        end: Date | null;
+    };
+    label?: string;
+    popoverTitle?: string;
+    width?: number | string;
+    position?: 'bottom' | 'top' | 'left' | 'right';
+    componentRef?: React.MutableRefObject<ArchbaseTimeRangeSelectorRef>;
+};
+export declare const ArchbaseTimeRangeSelector: FC<ArchbaseTimeRangeSelectorProps>;

package/dist/editors/ArchbaseTreeSelect.d.ts

@@ -0,0 +1,65 @@
+import { MantineSize } from '@mantine/core';
+import { IArchbaseDataSourceBase } from '@archbase/data';
+import { ArchbaseTreeNode } from '../list';
+import React, { ReactNode } from 'react';
+export interface ArchbaseTreeSelectProps<T, ID> {
+    /** Fonte de dados onde será atribuido o valor selecionado (V1 ou V2) */
+    dataSource?: IArchbaseDataSourceBase<T>;
+    /** Campo onde deverá ser atribuido o valor selecionado na fonte de dados */
+    dataField?: string;
+    /** 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;
+    /** Indicador se o select está em estado de carregamento */
+    loading?: boolean;
+    /** Indicador se o campo é obrigatório */
+    required?: boolean;
+    /** Valor inicial controlado */
+    value?: any;
+    /** Valor padrão inicial não controlado */
+    defaultValue?: any;
+    /** Tamanho do select */
+    size?: MantineSize;
+    /** Largura do select */
+    width: string | number;
+    /** Altura do select */
+    height?: string | number;
+    /** Largura do dropdown da árvore */
+    widthTreeView?: string | number;
+    /** Altura do dropdown da árvore */
+    heightTreeView?: string | number;
+    /** Ícone à esquerda do select */
+    icon?: ReactNode;
+    /** Texto sugestão do select */
+    placeholder?: string;
+    /** Título do select */
+    label?: string;
+    /** Descrição do select */
+    description?: string;
+    /** Último erro ocorrido no select */
+    error?: string;
+    /** Opções da árvore disponíveis para seleção */
+    options: ArchbaseTreeNode[];
+    /** Tipos de nós que podem ser selecionados */
+    allowNodeSelectType?: string[];
+    /** Função customizada para renderizar o componente selecionado */
+    renderComponent?: (node: ArchbaseTreeNode) => ReactNode;
+    /** Função que retorna o label de um nó */
+    getOptionLabel?: (node: ArchbaseTreeNode) => string;
+    /** Função que retorna o valor de um nó */
+    getOptionValue?: (node: ArchbaseTreeNode) => any;
+    /** Evento quando um valor é selecionado */
+    onSelectValue?: (node: ArchbaseTreeNode) => void;
+    /** Evento quando o select recebe foco */
+    onFocusEnter?: (event: React.FocusEvent<HTMLButtonElement>) => void;
+    /** Evento quando o foco sai do select */
+    onFocusExit?: (event: React.FocusEvent<HTMLButtonElement>) => void;
+    /** Evento quando o popover é aberto */
+    onDropdownOpen?: () => void;
+    /** Evento quando o popover é fechado */
+    onDropdownClose?: () => void;
+}
+export declare const ArchbaseTreeSelect: <T, ID>(props: ArchbaseTreeSelectProps<T, ID> & {
+    ref?: React.ForwardedRef<HTMLButtonElement>;
+}) => React.ReactElement;

package/dist/editors/index.d.ts

@@ -0,0 +1,81 @@
+export { ArchbaseEdit } from './ArchbaseEdit';
+export type { ArchbaseEditProps } from './ArchbaseEdit';
+export { ArchbaseCheckbox } from './ArchbaseCheckbox';
+export type { ArchbaseCheckboxProps } from './ArchbaseCheckbox';
+export { ArchbaseDatePickerEdit } from './ArchbaseDatePickerEdit';
+export type { ArchbaseDatePickerEditProps, ArchbaseDatePickerEditStylesNames } from './ArchbaseDatePickerEdit';
+export { ArchbaseAsyncMultiSelect } from './ArchbaseAsyncMultiSelect';
+export type { ArchbaseAsyncSelectProps, OptionsResult } from './ArchbaseAsyncSelect';
+export { ArchbaseAsyncSelect, CustomSelectScrollArea } from './ArchbaseAsyncSelect';
+export type { ArchbaseAsyncSelectContextValue } from './ArchbaseAsyncSelect.context';
+export { ArchbaseAsyncSelectProvider, ArchbaseAsyncSelectContext } from './ArchbaseAsyncSelect.context';
+export type { ArchbaseChipProps } from './ArchbaseChip';
+export { ArchbaseChip } from './ArchbaseChip';
+export type { ArchbaseChipGroupProps } from './ArchbaseChipGroup';
+export { ArchbaseChipGroup } from './ArchbaseChipGroup';
+export type { ArchbaseChipItemProps } from './ArchbaseChipItem';
+export { ArchbaseChipItem } from './ArchbaseChipItem';
+export type { ArchbaseColorPickerProps } from './ArchbaseColorPicker';
+export { ArchbaseColorPicker } from './ArchbaseColorPicker';
+export type { ArchbaseDatePickerRangeProps } from './ArchbaseDatePickerRange';
+export { ArchbaseDatePickerRange } from './ArchbaseDatePickerRange';
+export type { ArchbaseDateTimePickerEditProps, } from './ArchbaseDateTimePickerEdit';
+export { ArchbaseDateTimePickerEdit } from './ArchbaseDateTimePickerEdit';
+export type { ArchbaseDateTimePickerRangeProps } from './ArchbaseDateTimePickerRange';
+export { ArchbaseDateTimePickerRange } from './ArchbaseDateTimePickerRange';
+export { ArchbaseImageEdit } from './ArchbaseImageEdit';
+export type { ArchbaseImageEditProps } from './ArchbaseImageEdit';
+export { ArchbaseJsonEdit } from './ArchbaseJsonEdit';
+export type { ArchbaseJsonEditProps } from './ArchbaseJsonEdit';
+export { ArchbaseLookupEdit } from './ArchbaseLookupEdit';
+export type { ArchbaseLookupEditProps } from './ArchbaseLookupEdit';
+export { ArchbaseLookupNumber } from './ArchbaseLookupNumber';
+export type { ArchbaseLookupNumberProps } from './ArchbaseLookupNumber';
+export { ArchbaseLookupSelect } from './ArchbaseLookupSelect';
+export type { ArchbaseLookupSelectProps } from './ArchbaseLookupSelect';
+export { ArchbaseMaskEdit, MaskPattern } from './ArchbaseMaskEdit';
+export type { ArchbaseMaskEditProps, ArchbaseMaskEditStylesNames } from './ArchbaseMaskEdit';
+export { ArchbaseNumberEdit } from './ArchbaseNumberEdit';
+export type { ArchbaseNumberEditProps } from './ArchbaseNumberEdit';
+export { ArchbasePasswordEdit } from './ArchbasePasswordEdit';
+export type { ArchbasePasswordEditProps } from './ArchbasePasswordEdit';
+export { ArchbaseRadioGroup } from './ArchbaseRadioGroup';
+export type { ArchbaseRadioGroupProps } from './ArchbaseRadioGroup';
+export { ArchbaseRadioItem } from './ArchbaseRadioItem';
+export type { ArchbaseRadioItemProps } from './ArchbaseRadioItem';
+export { ArchbaseRating } from './ArchbaseRating';
+export type { ArchbaseRatingProps } from './ArchbaseRating';
+export { ArchbaseRichTextEdit } from './ArchbaseRichTextEdit';
+export type { ArchbaseRichTextEditProps } from './ArchbaseRichTextEdit';
+export { ArchbaseMarkdownEdit } from './ArchbaseMarkdownEdit';
+export type { ArchbaseMarkdownEditProps } from './ArchbaseMarkdownEdit';
+export { ArchbaseSelect } from './ArchbaseSelect';
+export type { ArchbaseSelectProps } from './ArchbaseSelect';
+export { ArchbaseSelectItem } from './ArchbaseSelectItem';
+export type { ArchbaseSelectItemProps } from './ArchbaseSelectItem';
+export { ArchbaseSwitch } from './ArchbaseSwitch';
+export type { ArchbaseSwitchProps } from './ArchbaseSwitch';
+export { ArchbaseThemeEditor } from '../themes/ArchbaseThemeEditor';
+export type { ArchbaseThemeEditorProps } from '../themes/ArchbaseThemeEditor';
+export { ArchbaseTextArea } from './ArchbaseTextArea';
+export type { ArchbaseTextAreaProps } from './ArchbaseTextArea';
+export { ArchbaseSelectContext, ArchbaseSelectProvider } from './ArchbaseSelect.context';
+export type { ArchbaseSelectContextValue } from './ArchbaseSelect.context';
+export { ArchbaseCronExpressionEditor } from './ArchbaseCronExpressionEditor';
+export type { ArchbaseCronExpressionEditorProps } from './ArchbaseCronExpressionEditor';
+export { ArchbaseKeyValueEditor } from './ArchbaseKeyValueEditor';
+export { ArchbaseTimeRangeSelector } from './ArchbaseTimeRangeSelector';
+export type { ArchbaseTimeRangeSelectorProps, RangeOption, ArchbaseTimeRangeSelectorRef } from './ArchbaseTimeRangeSelector';
+export { ArchbaseTreeSelect } from './ArchbaseTreeSelect';
+export type { ArchbaseTreeSelectProps } from './ArchbaseTreeSelect';
+export { ArchbaseOperatingHoursEditor } from './ArchbaseOperationHoursEditor';
+export type { ArchbaseOperatingHoursEditorProps } from './ArchbaseOperationHoursEditor';
+export { ArchbaseCountdownProgress } from "./ArchbaseCountdownProgress";
+export type { ArchbaseCountdownProgressProps } from "./ArchbaseCountdownProgress";
+export { ArchbaseFileAttachment } from "./ArchbaseFileAttachment";
+export { ArchbaseCronExpressionEdit } from "./ArchbaseCronExpressionEdit";
+export type { ArchbaseFileAttachmentProps, Attachment } from "./ArchbaseFileAttachment";
+export { ArchbaseTimeEdit } from './ArchbaseTimeEdit';
+export type { ArchbaseTimeEditProps } from './ArchbaseTimeEdit';
+export { ArchbaseAvatarEdit } from './ArchbaseAvatarEdit';
+export type { ArchbaseAvatarEditProps } from './ArchbaseAvatarEdit';

package/dist/feedback/index.d.ts

@@ -0,0 +1,4 @@
+export { Alert as ArchbaseMantineAlert } from '@mantine/core';
+export { Notification as ArchbaseNotification } from '@mantine/core';
+export { Loader as ArchbaseLoader } from '@mantine/core';
+export { Progress as ArchbaseProgress } from '@mantine/core';

package/dist/filters/ArchbaseCompositeFilters.d.ts

@@ -0,0 +1,23 @@
+import type { ArchbaseCompositeFiltersProps } from './ArchbaseCompositeFilters.types';
+/**
+ * Componente principal de filtros compostos com saída RSQL
+ *
+ * @example
+ * ```tsx
+ * const filters: ArchbaseFilterDefinition[] = [
+ *   { key: 'nome', label: 'Nome', type: 'text' },
+ *   { key: 'idade', label: 'Idade', type: 'integer' },
+ *   { key: 'ativo', label: 'Ativo', type: 'boolean' }
+ * ];
+ *
+ * <ArchbaseCompositeFilters
+ *   filters={filters}
+ *   value={activeFilters}
+ *   onChange={(filters, rsql) => {
+ *     console.log('RSQL:', rsql); // "nome=like=*João*;idade>18"
+ *   }}
+ * />
+ * ```
+ */
+export declare function ArchbaseCompositeFilters({ filters: filterDefinitions, value: controlledValue, onChange, rsqlOutput, onRSQLChange, placeholder, maxFilters, variant, enablePresets, enableHistory, enableQuickFilters, quickFilters, storageKeyPrefix, customRenderPill, styles, classNames, onFilterAdd, onFilterRemove, onFiltersCleared, }: ArchbaseCompositeFiltersProps): import("react/jsx-runtime").JSX.Element;
+export type { ArchbaseFilterDefinition, ArchbaseActiveFilter, ArchbaseFilterOperator, FilterValue, SavedFilterPreset, FilterHistoryEntry, QuickFilterPreset, } from './ArchbaseCompositeFilters.types';