@archbase/advanced 3.0.0 → 3.0.2

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './querybuilder';
+export * from './kanban';
+export declare const ArchbaseAdvancedVersion = "3.0.0";

package/dist/kanban/index.d.ts

@@ -0,0 +1 @@
+export declare const ArchbaseKanbanVersion = "3.0.0";

package/dist/querybuilder/ArchbaseAdvancedFilter.d.ts

@@ -0,0 +1,142 @@
+import { ButtonVariant } from '@mantine/core';
+import { Component, ReactNode } from 'react';
+import { ArchbaseQueryFilter, Condition, DataType, Field, Operator, Rule, Schema, SelectedSort, SortField } from './ArchbaseFilterCommons';
+import { ArchbaseDataSource } from '@archbase/data';
+interface ArchbaseAdvancedFilterProps<_T, _ID> {
+    id: string;
+    currentFilter: ArchbaseQueryFilter;
+    activeFilterIndex: number;
+    children?: ReactNode | ReactNode[];
+    onFilterChanged: (currentFilter: ArchbaseQueryFilter, activeFilterIndex: number) => void;
+    onApplyFilterClick?: (filter: ArchbaseQueryFilter) => void;
+    horizontal?: boolean;
+    operators: Operator[];
+    conditions: Condition[];
+    getOperators: (args: any) => any;
+    onError?: (error: string) => void;
+    height?: string;
+    width?: string;
+    allowSort?: boolean;
+    disabled?: boolean;
+    onSearchButtonClick?: () => void;
+    border?: string;
+    variant?: ButtonVariant;
+}
+interface ArchbaseAdvancedFilterState {
+    currentFilter: ArchbaseQueryFilter;
+    modalOpen?: string;
+    activeFilterIndex: number;
+    schema: Schema;
+    sortFocused?: string;
+    forceUpdateCounter: number;
+}
+declare class ArchbaseAdvancedFilter<T, ID> extends Component<ArchbaseAdvancedFilterProps<T, ID>, ArchbaseAdvancedFilterState> {
+    static defaultProps: {
+        operators: {
+            name: string;
+            label: string;
+            dataTypes: string[];
+        }[];
+        conditions: {
+            name: string;
+            label: string;
+        }[];
+        getOperators: any;
+        onFilterChanged: any;
+        allowSort: boolean;
+        disabled: boolean;
+        horizontal: boolean;
+        sortFocused: string;
+        width: string;
+        border: string;
+    };
+    constructor(props: ArchbaseAdvancedFilterProps<T, ID>);
+    shouldComponentUpdate: (nextProps: ArchbaseAdvancedFilterProps<T, ID>, nextState: ArchbaseAdvancedFilterState) => boolean;
+    createCompatibleDataSource: (records: any[]) => ArchbaseDataSource<any, unknown>;
+    getQuickFields: () => any;
+    getQuickFilterSort: () => string;
+    UNSAFE_componentWillReceiveProps: (nextProps: any) => void;
+    createRuleGroup: () => Rule;
+    createSchema: () => Schema;
+    getSelectedSort: () => SelectedSort[];
+    getSortItem: (field: string) => SortField | undefined;
+    getSortItemByOrder: (order: number) => SortField | undefined;
+    onChangeSortItem: (field: string, selected: any, order: any, asc_desc: any) => void;
+    propagateFilterChanged: () => void;
+    onSortDown: (_event: any) => void;
+    onSortUp: (_event: any) => void;
+    getFields: (props: Readonly<ArchbaseAdvancedFilterProps<T, ID>>) => Field[];
+    isRuleGroup: (rule: {
+        condition: any;
+        rules: any;
+    }) => boolean;
+    createRule: () => Rule;
+    getField: (name: string) => any;
+    getOperators: (field: string) => Operator[];
+    onRuleAdd: (rule: Rule, parentId: any) => void;
+    onGroupAdd: (group: Rule, parentId: any) => void;
+    onPropChange: (prop: string, value: string, ruleId: any) => void;
+    onRuleRemove: (ruleId: string, parentId: any) => void;
+    onGroupRemove: (groupId: any, parentId: any) => void;
+    getLevel: (id: any) => number;
+    _getLevel: (id: any, index: any, root: any) => number;
+    _findRule: (id: string, parent: Rule) => Rule | undefined;
+    _notifyQueryChange: (fn: any, ...args: any[]) => void;
+    onSelectListItem: (index: number, _item: any) => void;
+    render(): import("react/jsx-runtime").JSX.Element;
+}
+interface CustomSortItemProps<T, ID> {
+    id: string;
+    disabled?: boolean;
+    active: boolean;
+    index: number;
+    recordData: any;
+    dataFieldId: string;
+    dataSource: ArchbaseDataSource<T, ID>;
+    onSelectListItem?: (index: number, self: CustomSortItem<T, ID>) => void;
+    onChangeSortItem: (field: string, checked: boolean, order: any, ascDesc: 'asc' | 'desc') => void;
+}
+interface CustomSortItemState {
+    update: number;
+    selected: boolean;
+}
+export declare class CustomSortItem<T, ID> extends Component<CustomSortItemProps<T, ID>, CustomSortItemState> {
+    static defaultProps: {
+        disabled: boolean;
+        active: boolean;
+        selected: boolean;
+    };
+    constructor(props: CustomSortItemProps<T, ID>);
+    static get componentName(): string;
+    UNSAFE_componentWillReceiveProps: (nextProps: CustomSortItemProps<T, ID>) => void;
+    onClick: (event: any) => void;
+    onCheckboxChange: (event: any) => void;
+    onDoubleClick: (_event: any) => void;
+    isAsc: () => boolean;
+    render: () => import("react/jsx-runtime").JSX.Element;
+}
+interface ValueEditorProps {
+    field: string;
+    operator: string;
+    value: string;
+    value2?: string;
+    level?: number;
+    listValues?: string[];
+    searchField: string;
+    disabled: boolean;
+    dataType: DataType;
+    twoFields?: boolean;
+    className?: string;
+    handleOnChange: (value: any) => void;
+    onSearchButtonClick: (field: string, event: any, handleOnChange: (value: string) => void, operator: string, searchField: string) => void;
+}
+export declare class ValueEditor extends Component<ValueEditorProps> {
+    private onInput;
+    constructor(props: ValueEditorProps);
+    static get componentName(): string;
+    onActionSearchExecute: () => void;
+    convertValueCombobox: (value: string, dataType: string) => string | string[];
+    handleRangeChange: (value: [Date | null, Date | null]) => void;
+    render: () => import("react/jsx-runtime").JSX.Element;
+}
+export { ArchbaseAdvancedFilter };

package/dist/querybuilder/ArchbaseCompositeFilter.d.ts

@@ -0,0 +1,72 @@
+import { ButtonVariant } from '@mantine/core';
+import { Component, ReactNode } from 'react';
+import { ArchbaseQueryFilter, ArchbaseQueryFilterDelegator, Field } from './ArchbaseFilterCommons';
+import { ArchbaseDataSource } from '@archbase/data';
+interface ArchbaseCompositeFilterProps {
+    variant?: ButtonVariant;
+    activeFilterIndex: number;
+    currentFilter: ArchbaseQueryFilter;
+    width?: string | number | undefined;
+    height?: string | number | undefined;
+    persistenceDelegator: ArchbaseQueryFilterDelegator;
+    update?: number;
+    children?: ReactNode | ReactNode[];
+    onSaveFilter?: (itemId: string) => void;
+    onChangeFilterType?: (index: number) => void;
+    onChangeSelectedFilter?: (filter: ArchbaseQueryFilter, index: number) => void;
+    onFilterChanged: (currentFilter: ArchbaseQueryFilter, activeFilterIndex: number) => void;
+    onSearchButtonClick?: (field: string, event?: any, handleOnChange?: any, operator?: any, searchField?: any) => void;
+    onActionClick?: (action: string) => void;
+    toggleFilterButtonRef?: any;
+}
+interface ArchbaseCompositeFilterState {
+    modalOpen: string;
+    activeFilterIndex: number;
+    fields: Field[];
+    showEditor: boolean;
+    expandedFilter: boolean;
+    dataSource: ArchbaseDataSource<any, any>;
+    isDataSourceV2: boolean;
+    forceUpdateCounter: number;
+}
+declare class ArchbaseCompositeFilter extends Component<ArchbaseCompositeFilterProps, ArchbaseCompositeFilterState> {
+    constructor(props: ArchbaseCompositeFilterProps);
+    shouldComponentUpdate: (nextProps: ArchbaseCompositeFilterProps, nextState: ArchbaseCompositeFilterState) => boolean;
+    UNSAFE_componentWillReceiveProps: (nextProps: ArchbaseCompositeFilterProps) => void;
+    onSelectMenuItem: (itemId: string) => void;
+    onChangeFilterType: (index: number) => void;
+    onSelectItem: (index: number, data: any) => void;
+    getColor: (color: string) => string;
+    render: () => import("react/jsx-runtime").JSX.Element;
+}
+interface ArchbaseDetailedFilterProps {
+    currentFilter: ArchbaseQueryFilter;
+    onChangeSelectedFilter?: (filter: ArchbaseQueryFilter, index: number) => void;
+    onSaveFilter?: (item: string) => void;
+    onFilterChanged: (currentFilter: ArchbaseQueryFilter, activeFilterIndex: number) => void;
+    height?: string;
+    width?: string;
+    activeFilterIndex: number;
+    children?: ReactNode | ReactNode[];
+    onClickOkSaveFilter?: () => void;
+    onClickCancelSaveFilter?: () => void;
+    onSearchButtonClick?: (field: string) => void;
+    isOpen?: boolean;
+    update?: number;
+    selectedOptions?: Field[];
+    variant?: ButtonVariant;
+}
+interface ArchbaseAdvancedFilterState {
+    modalOpen: string;
+    update: number;
+}
+declare class ArchbaseDetailedFilter extends Component<ArchbaseDetailedFilterProps, ArchbaseAdvancedFilterState> {
+    static defaultProps: {
+        isOpen: boolean;
+    };
+    constructor(props: ArchbaseDetailedFilterProps);
+    onSelectMenuItem: (itemId: string) => void;
+    onSelectItem: (index: number, data: any) => void;
+    render(): import("react/jsx-runtime").JSX.Element;
+}
+export { ArchbaseCompositeFilter, ArchbaseDetailedFilter };

package/dist/querybuilder/ArchbaseFeedback.d.ts

@@ -0,0 +1,18 @@
+import { default as React, Component, ReactNode } from 'react';
+interface ArchbaseFeedbackProps {
+    style?: React.CSSProperties;
+    classNameFeedback?: string | undefined;
+    when?: (inputValue: any) => boolean;
+    inputValue?: any;
+    primary?: boolean;
+    info?: boolean;
+    danger?: boolean;
+    warning?: boolean;
+    secondary?: boolean;
+    default?: boolean;
+    children?: ReactNode;
+}
+export declare class ArchbaseFeedback extends Component<ArchbaseFeedbackProps> {
+    render: () => import("react/jsx-runtime").JSX.Element;
+}
+export {};

package/dist/querybuilder/ArchbaseFilterCommons.d.ts

@@ -0,0 +1,299 @@
+import { default as React, Component, ReactNode } from 'react';
+import { MaskPattern } from '@archbase/components';
+import { ButtonVariant } from '@mantine/core';
+declare const QUICK_FILTER_INDEX = -2;
+declare const NEW_FILTER_INDEX = -1;
+declare const NORMAL = "normal";
+declare const QUICK = "quick";
+declare const ADVANCED = "advanced";
+declare const OP_NULL = "null";
+declare const OP_NOT_NULL = "notNull";
+declare const OP_CONTAINS = "contains";
+declare const OP_STARTSWITH = "startsWith";
+declare const OP_ENDSWITH = "endsWith";
+declare const OP_EQUALS = "=";
+declare const OP_NOT_EQUALS = "!=";
+declare const OP_GREATER = ">";
+declare const OP_LESS = "<";
+declare const OP_GREATER_OR_EQUAL = ">=";
+declare const OP_LESS_OR_EQUAL = "<=";
+declare const OP_BETWEEN = "between";
+declare const OP_IN_LIST = "inList";
+declare const OP_NOT_IN_LIST = "notInList";
+type FilterType = 'quick' | 'normal' | 'advanced' | undefined;
+type PositionType = 'filter' | 'fields' | 'range' | undefined;
+type RangeType = 'month' | 'week' | 'range' | 'day' | undefined;
+type DataType = 'string' | 'number' | 'date' | 'date_time' | 'time' | 'boolean';
+interface Operator {
+    name: string;
+    label: string;
+    dataTypes: DataType[];
+}
+interface SortField {
+    name: string;
+    selected: boolean;
+    order: number;
+    asc_desc: string;
+    label: string;
+}
+interface FilterValue {
+    label: string;
+    value: string;
+}
+interface Field {
+    name: string;
+    label: string;
+    dataType: DataType;
+    operator: string;
+    quickFilter: boolean;
+    quickFilterSort: boolean;
+    sortable: boolean;
+    listValues: FilterValue[];
+    searchComponent: ReactNode;
+    searchField: any;
+    nameSql?: string;
+}
+interface Filter {
+    id: string;
+    selectedFields: Field[];
+    quickFilterText: string;
+    quickFilterFieldsText: string;
+    rules: Rule[];
+    condition: string;
+    filterType: FilterType;
+}
+interface Sort {
+    quickFilterSort: string;
+    sortFields: SortField[];
+    activeIndex: number;
+}
+interface ArchbaseQueryFilter {
+    id?: number;
+    filter: Filter;
+    sort: Sort;
+    name?: string;
+    viewName?: string;
+    apiVersion?: string;
+    selectedFields?: Field[];
+}
+interface FilterOptions {
+    currentFilter?: ArchbaseQueryFilter;
+    activeFilterIndex: number;
+    enabledAdvancedFilter: boolean;
+    apiVersion: string;
+    viewName: string;
+    componentName: string;
+    onApplyFilter?: (currentFilter: ArchbaseQueryFilter, index: number) => void;
+}
+interface ArchbaseQueryFilterState {
+    currentFilter?: ArchbaseQueryFilter;
+    activeFilterIndex: number;
+    expandedFilter: boolean;
+}
+interface Position {
+    left?: string | number | undefined;
+    top?: string | number | undefined;
+    height?: string | number | undefined;
+}
+interface SelectedSort {
+    name: string;
+    asc_desc: string;
+}
+interface Rule {
+    id: string;
+    parentId?: string | null;
+    field?: string | null;
+    fieldSql?: string | null;
+    dataType?: DataType;
+    operator?: string | null;
+    value?: any | null;
+    value2?: any | null;
+    disabled?: boolean;
+    rules?: Rule[];
+    condition?: string;
+}
+interface Condition {
+    name: string;
+    label: string;
+}
+interface IQueryFilterEntity {
+    id?: any;
+    companyId?: any;
+    filter?: any;
+    name?: string;
+    viewName?: string;
+    componentName?: string;
+    userName?: string;
+    shared?: boolean;
+    code?: string;
+    isNewFilter?: boolean;
+    setId: (id: any) => void;
+    setCompanyId: (companyId: any) => void;
+    setFilter: (filter: any) => void;
+    setName: (name: string) => void;
+    setViewName: (viewName: string) => void;
+    setComponentName: (componentName: string) => void;
+    setUserName: (userName: string) => void;
+    setShared: (shared: boolean) => void;
+    setCode: (code: string) => void;
+    setIsNewFilter: (value: boolean) => void;
+}
+declare class QueryFilterEntity implements IQueryFilterEntity {
+    private _id?;
+    private _companyId?;
+    private _filter?;
+    private _name?;
+    private _viewName?;
+    private _componentName?;
+    private _userName?;
+    private _shared?;
+    private _code?;
+    private _isNewFilter?;
+    constructor();
+    get id(): any;
+    get companyId(): any;
+    get filter(): any | undefined;
+    get name(): string | undefined;
+    get viewName(): string | undefined;
+    get componentName(): string | undefined;
+    get userName(): string | undefined;
+    get isShared(): boolean | undefined;
+    get code(): string | undefined;
+    get isNewFilter(): boolean | undefined;
+    setId(id: any): void;
+    setCompanyId(companyId: any): void;
+    setFilter(filter: any): void;
+    setName(name: string): void;
+    setViewName(viewName: string): void;
+    setComponentName(componentName: string): void;
+    setUserName(userName: string): void;
+    setShared(shared: boolean): void;
+    setCode(code: string): void;
+    setIsNewFilter(value: boolean): void;
+    static createInstance(): QueryFilterEntity;
+    static createInstanceWithValues(values: Partial<IQueryFilterEntity>): IQueryFilterEntity;
+}
+type DelegatorCallback = (error: any, id?: any) => void;
+interface ArchbaseQueryFilterDelegator {
+    getFilterById: (id: any) => IQueryFilterEntity | undefined;
+    addNewFilter: (filter: IQueryFilterEntity, onResult: DelegatorCallback) => void;
+    saveFilter: (filter: IQueryFilterEntity, onResult: DelegatorCallback) => void;
+    removeFilterBy: (filter: IQueryFilterEntity, onResult: DelegatorCallback) => void;
+    getFirstFilter: () => IQueryFilterEntity | undefined;
+    getFilters: () => IQueryFilterEntity[];
+}
+interface Schema {
+    fields: Field[];
+    operators: Operator[];
+    conditions: Condition[];
+    createRule: () => Rule;
+    createRuleGroup: () => Rule;
+    onRuleAdd: (rule: any, parentId: any) => void;
+    onGroupAdd: (group: any, parentId: any) => void;
+    onRuleRemove: (ruleId: any, parentId: any) => void;
+    onGroupRemove: (groupId: any, parentId: any) => void;
+    onPropChange: (prop: any, value: any, ruleId: any) => void;
+    getLevel: (id: any) => number;
+    isRuleGroup: (rule: any) => boolean;
+    getOperators: (field: any) => Operator[];
+}
+interface FilterFieldProps {
+    name: string;
+    label: string;
+    dataType: DataType;
+    sortable?: boolean;
+    quickFilter?: boolean;
+    quickFilterSort?: boolean;
+}
+declare function FilterField({ sortable, quickFilter, quickFilterSort, ...others }: FilterFieldProps): any;
+interface ArchbaseQueryBuilderProps {
+    persistenceDelegator: ArchbaseQueryFilterDelegator;
+    showClearButton?: boolean;
+    showToggleButton?: boolean;
+    showPrintButton?: boolean;
+    showExportButton?: boolean;
+    onClearFilter?: (self: any) => {};
+    variant?: ButtonVariant;
+    viewName: string;
+    id: string;
+    apiVersion: string;
+    width?: string;
+    height?: string;
+    placeholder?: string;
+    detailsWidth?: number;
+    detailsHeight?: number;
+    currentFilter?: ArchbaseQueryFilter;
+    expandedFilter?: boolean;
+    activeFilterIndex: number;
+    onToggleExpandedFilter?: (value: boolean) => void;
+    onFilterChanged?: (currentFilter: ArchbaseQueryFilter, index: number, callback?: () => void) => void;
+    onSearchByFilter?: () => void;
+    onSelectedFilter?: (filter: ArchbaseQueryFilter, index: number) => void;
+    userName?: any;
+    children?: ReactNode | ReactNode[];
+    onPrint?: () => void;
+    onExport?: () => void;
+}
+interface FilterFieldValueProps {
+    label: string;
+    value: string;
+}
+declare class FilterFieldValue extends Component<FilterFieldValueProps> {
+    static get componentName(): string;
+    render(): any;
+}
+interface FilterFieldsProps {
+    children?: ReactNode | ReactNode[];
+}
+declare function FilterFields({ children }: FilterFieldsProps): import("react/jsx-runtime").JSX.Element;
+declare const getSortString: (currentFilter: {
+    sort: {
+        sortFields: any[];
+    };
+}) => string | undefined;
+declare const convertQueryFields: (children: React.ReactNode) => React.ReactNode;
+declare const getFields: (props: any) => Field[];
+declare const getFieldSql: (field: any, fields: string | any[]) => any;
+declare const getFieldValues: (field: any, fields: string | any[]) => any;
+declare const getQuickFields: (fields: Field[]) => Field[];
+declare const getQuickFieldsSort: (fields: Field[]) => SortField[];
+declare const getQuickFilterSort: (fields: any[]) => string;
+declare const getQuickFilterSortBySelectedFields: (fields: any[]) => string;
+declare const mergeSortWithFields: (sort: any[], fields: any[]) => SortField[];
+declare const getQuickFilterFields: (currentFilter: ArchbaseQueryFilter | null, fields: any[]) => string;
+declare const getDefaultEmptyFilter: () => ArchbaseQueryFilter;
+declare const defaultOperators: Operator[];
+declare const defaultConditions: Condition[];
+declare const getDefaultFilter: (props: Readonly<ArchbaseQueryBuilderProps>, type: FilterType) => ArchbaseQueryFilter;
+interface QueryFieldProps {
+    name: string;
+    label: string;
+    dataType: 'string' | 'number' | 'date' | 'date_time' | 'time' | 'boolean';
+    operator?: 'contains' | 'startsWith' | 'endsWith' | '=' | '!=' | '<' | '>' | '<=' | '>=' | 'between' | 'inList' | 'notInList';
+    sortable?: boolean;
+    quickFilter?: boolean;
+    quickFilterSort?: boolean;
+    searchComponent?: any;
+    children?: ReactNode | ReactNode[] | undefined;
+    mask?: MaskPattern | Function | string;
+    filterWithMask?: boolean;
+}
+interface QueryFieldValueProps {
+    label: string;
+    value: string;
+}
+interface QueryFieldsProps {
+    children: ReactNode | ReactNode[];
+}
+declare function QueryFields({ children }: QueryFieldsProps): import("react/jsx-runtime").JSX.Element;
+declare function QueryField({ sortable, quickFilter, quickFilterSort, operator, mask, ...others }: QueryFieldProps): any;
+interface QueryFieldValueProps {
+    label: string;
+    value: string;
+}
+declare class QueryFieldValue extends Component<QueryFieldValueProps> {
+    static get componentName(): string;
+    render(): any;
+}
+export { QueryFieldValue, QueryField, QueryFields, QueryFilterEntity, FilterField, FilterFieldValue, FilterFields, getDefaultFilter, defaultConditions, defaultOperators, getDefaultEmptyFilter, getQuickFilterFields, mergeSortWithFields, getQuickFilterSort, getQuickFields, getFieldValues, getFieldSql, getFields, getQuickFieldsSort, getQuickFilterSortBySelectedFields, convertQueryFields, getSortString, QUICK_FILTER_INDEX, NEW_FILTER_INDEX, NORMAL, QUICK, ADVANCED, OP_NULL, OP_NOT_NULL, OP_CONTAINS, OP_STARTSWITH, OP_ENDSWITH, OP_EQUALS, OP_NOT_EQUALS, OP_GREATER, OP_LESS, OP_GREATER_OR_EQUAL, OP_LESS_OR_EQUAL, OP_BETWEEN, OP_IN_LIST, OP_NOT_IN_LIST };
+export type { Field, SortField, Filter, FilterOptions, ArchbaseQueryFilter, ArchbaseQueryFilterState, ArchbaseQueryFilterDelegator, PositionType, RangeType, Position, FilterType, DataType, FilterValue, SelectedSort, Operator, Rule, Condition, Schema, DelegatorCallback, IQueryFilterEntity, ArchbaseQueryBuilderProps };

package/dist/querybuilder/ArchbaseFilterGraphQL.d.ts

@@ -0,0 +1,11 @@
+import { ArchbaseQueryFilter } from './ArchbaseFilterCommons';
+declare class GraphQLQueryBuilder {
+    private query;
+    constructor();
+    buildFrom(filter: ArchbaseQueryFilter): string;
+    buildGraphQLQuery(condition: any, rules: any): void;
+    getFieldName(fieldName: any): any;
+    getOperator(operator: any): any;
+    formatValue(value: any, dataType: any): any;
+}
+export default GraphQLQueryBuilder;

package/dist/querybuilder/ArchbaseFilterRSQL.d.ts

@@ -0,0 +1,7 @@
+import { ExpressionNode } from '@archbase/core';
+import { ArchbaseQueryFilter } from './ArchbaseFilterCommons';
+declare function buildFrom(filter: ArchbaseQueryFilter): {
+    expressionNode: ExpressionNode;
+    sortStrings: string[];
+};
+export { buildFrom };

package/dist/querybuilder/ArchbaseFilterSelectFields.d.ts

@@ -0,0 +1,40 @@
+import { ArchbaseDataSource } from '@archbase/data';
+import { ButtonVariant } from '@mantine/core';
+import { default as React, Component } from 'react';
+import { ArchbaseQueryFilter, Field, SortField } from './ArchbaseFilterCommons';
+interface ArchbaseFilterSelectFieldsProps {
+    variant?: ButtonVariant | string;
+    currentFilter: ArchbaseQueryFilter;
+    fields: Field[];
+    selectedOptions: Field[];
+    sort: SortField[];
+    id: string;
+    key: string;
+    width?: string | number | undefined;
+    sortFocused?: boolean;
+    onConfirmSelectFields?: (selectedFields: Field[], sortFields: SortField[], activeIndex: number) => void;
+    onCancelSelectFields?: () => void;
+}
+interface ArchbaseFilterSelectFieldsState {
+    selectedFields: Field[];
+    sortFields: SortField[];
+    allChecked: boolean;
+    activeIndex: number;
+    update: number;
+    forceUpdateCounter: number;
+}
+declare class ArchbaseFilterSelectFields extends Component<ArchbaseFilterSelectFieldsProps, ArchbaseFilterSelectFieldsState> {
+    constructor(props: ArchbaseFilterSelectFieldsProps);
+    createCompatibleDataSource: (records: any[]) => ArchbaseDataSource<any, unknown>;
+    onCheckboxChange: (_value: any, _checked: boolean, item: any) => void;
+    renderCheckboxFields: () => import("react/jsx-runtime").JSX.Element[];
+    getSortItem: (field: string) => SortField | undefined;
+    onChangeSortItem: (field: string, selected: any, order: any, asc_desc: any) => void;
+    getSortItemByOrder: (order: number) => SortField | undefined;
+    onSortDown: (_event: React.MouseEvent) => void;
+    onSortUp: (_event: React.MouseEvent) => void;
+    onSelectListItem: (index: number, _item: any) => void;
+    selectAllFields: (checked: boolean) => void;
+    render: () => import("react/jsx-runtime").JSX.Element;
+}
+export { ArchbaseFilterSelectFields };

package/dist/querybuilder/ArchbaseFilterSelectRange.d.ts

@@ -0,0 +1,24 @@
+import { ButtonVariant } from '@mantine/core';
+import { Component } from 'react';
+import { Value } from 'react-multi-date-picker';
+interface ArchbaseFilterSelectRangeProps {
+    id?: string;
+    key?: string;
+    onCancelSelectRange?: () => void;
+    onConfirmSelectRange?: (value: Value | undefined, selectRangeType: any) => void;
+    width?: string | undefined;
+    selectRangeType?: 'day' | 'week' | 'month' | 'range';
+    variant?: ButtonVariant | string;
+}
+interface ArchbaseFilterSelectRangeState {
+    value?: Value;
+    selectRangeType?: 'day' | 'week' | 'month' | 'range';
+}
+declare class ArchbaseFilterSelectRange extends Component<ArchbaseFilterSelectRangeProps, ArchbaseFilterSelectRangeState> {
+    private dateRef;
+    constructor(props: ArchbaseFilterSelectRangeProps);
+    UNSAFE_componentWillReceiveProps: (_nextProps: ArchbaseFilterSelectRangeProps) => void;
+    handleDateChange: (value: Value) => void;
+    render: () => import("react/jsx-runtime").JSX.Element;
+}
+export { ArchbaseFilterSelectRange };

package/dist/querybuilder/ArchbaseGlobalFilter.d.ts

@@ -0,0 +1,25 @@
+import { ActionIconProps, TextInputProps } from '@mantine/core';
+export interface ArchbaseGlobalFilterProps {
+    /** Lista dos nomes dos campos a serem efetuados a pesquisa filtrada */
+    searchableFields: string[];
+    /** Evento ocorre quando é efetuado a pesquisa filtrada */
+    onFilter: (buildedQuery: string, value: string) => void;
+    /** Quantidade minima de carácteres do valor do filtro para que seja disparada a pesquisa filtrada */
+    minFilterValueLength: number;
+    /** Opções para personalização */
+    options?: {
+        inputProps?: TextInputProps;
+        buttonRefreshProps?: ActionIconProps;
+        buttonClearProps?: ActionIconProps;
+        iconRefreshProps?: {
+            size?: string | number;
+            color?: string;
+        };
+        iconClearProps?: {
+            size?: string | number;
+            color?: string;
+        };
+        spacing?: number | string;
+    };
+}
+export declare function ArchbaseGlobalFilter({ searchableFields, onFilter, minFilterValueLength, options, }: ArchbaseGlobalFilterProps): import("react/jsx-runtime").JSX.Element;

package/dist/querybuilder/ArchbaseInputSearch.d.ts

@@ -0,0 +1,13 @@
+import { ActionIconVariant, MantineColorScheme, MantineTheme } from '@mantine/core';
+import { Component } from 'react';
+interface ArchbaseInputSearchProps {
+    placeholder?: string | undefined;
+    theme: MantineTheme;
+    colorScheme: MantineColorScheme;
+    onSearchClick?: () => void;
+    variant?: ActionIconVariant;
+}
+export declare class ArchbaseInputSearch extends Component<ArchbaseInputSearchProps> {
+    render: () => import("react/jsx-runtime").JSX.Element;
+}
+export {};

package/dist/querybuilder/ArchbaseQueryBuilder.d.ts

@@ -0,0 +1,97 @@
+import { default as React, Component, ReactNode } from 'react';
+import { ArchbaseQueryBuilderProps, ArchbaseQueryFilter, Field, Position, PositionType, RangeType, SortField } from './ArchbaseFilterCommons';
+export interface ArchbaseQueryBuilderState {
+    currentFilter: ArchbaseQueryFilter;
+    modalOpen: string;
+    expandedFilter: boolean;
+    activeFilterIndex: number;
+    isOpenSelectRange: boolean;
+    isOpenSelectFields: boolean;
+    selectRangeType?: RangeType | undefined;
+    detailsAlign?: 'left' | 'right';
+    modalOperator?: string | undefined;
+    modalSearchField: string;
+    children?: React.ReactNode | React.ReactNode[];
+    update: number;
+    modalHandleOnChange?: (value: string) => void;
+}
+export declare const DebouncedTextInput: ({ onActionSearchExecute, icon, disabled, label, error, initialValue, onChange, style, placeholder, keyProp, readOnly, innerRef, onFocus, onKeyDown, tooltipIconSearch, variant, }: {
+    onActionSearchExecute: any;
+    icon: any;
+    disabled: any;
+    label: any;
+    error: any;
+    initialValue: any;
+    onChange: any;
+    style: any;
+    placeholder: any;
+    keyProp: any;
+    readOnly: any;
+    innerRef: any;
+    onFocus: any;
+    onKeyDown: any;
+    tooltipIconSearch?: string;
+    variant?: string;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare class ArchbaseQueryBuilder extends Component<ArchbaseQueryBuilderProps, ArchbaseQueryBuilderState> {
+    static defaultProps: {
+        showClearButton: boolean;
+        showToggleButton: boolean;
+        showPrintButton: boolean;
+        showExportButton: boolean;
+        expandedFilter: boolean;
+        width: string;
+        height: string;
+        detailsHeight: number;
+        detailsWidth: number;
+        detailsAlign: string;
+    };
+    private timeout;
+    private divMain;
+    private refEdit;
+    private toggleFilterButtonRef;
+    private inputValue;
+    constructor(props: ArchbaseQueryBuilderProps);
+    shouldComponentUpdate: (nextProps: ArchbaseQueryBuilderProps, nextState: ArchbaseQueryBuilderState) => boolean;
+    UNSAFE_componentWillReceiveProps: (nextProps: ArchbaseQueryBuilderProps) => void;
+    componentDidMount: () => void;
+    componentWillUnmount: () => void;
+    toggleExpandedFilter: () => void;
+    clearFilter: () => void;
+    onSearchClick: () => void;
+    onChangeQuickFilter: (value: string) => void;
+    changeQuickFilter: (value: string) => void;
+    handleQuickFilter: (event: any) => void;
+    getQuickFilterText: () => string;
+    onFilterChanged: (currentFilter: ArchbaseQueryFilter, activeFilterIndex: number, callback: () => void) => void;
+    loadListValuesToFilter: (parent: string, rules: string | any[], values: any) => void;
+    getItemListById: (values: string | any[], parent: string, id: any) => any;
+    convertFilterToListValues: (parent: string, rules: string | any[], result: {
+        parent: any;
+        id: any;
+        value: any;
+        value2: any;
+    }[]) => void;
+    onSaveFilter: (itemId: string) => void;
+    onChangeFilterType: (index: number) => void;
+    onChangeSelectedFilter: (filter: ArchbaseQueryFilter, index: number) => void;
+    addNewFilter: () => void;
+    onActionClick: (action: string) => void;
+    removeFilter: () => void;
+    onCloseFilterClick: () => void;
+    getPosition: (type: PositionType, rangeType?: RangeType) => Position;
+    onResize: () => void;
+    onSelectRange: (rangeType: RangeType) => void;
+    onCancelSelectRange: () => void;
+    onConfirmSelectRange: (values: any, selectRangeType: any) => void;
+    selectFields: () => void;
+    onCancelSelectFields: () => void;
+    getSortString: (currentFilter: ArchbaseQueryFilter) => string;
+    onConfirmSelectFields: (selectedFields: Field[], sortFields: SortField[], activeIndex: number) => void;
+    onFocusEdit: () => void;
+    onClickOk: (_event: any, selectedRecords: any[]) => void;
+    onClickCancel: (_event: any) => void;
+    onSearchButtonClick: (field: string, _event: any, handleOnChange: any, operator: any, searchField: any) => void;
+    buildSearchModals: () => ReactNode[];
+    render: () => import("react/jsx-runtime").JSX.Element;
+}

package/dist/querybuilder/ArchbaseSaveFilter.d.ts

@@ -0,0 +1,13 @@
+import { ButtonVariant } from '@mantine/core';
+import { default as React } from 'react';
+interface ArchbaseSaveFilterProps {
+    title: string;
+    id: string;
+    onClickOk?: (filterName: string, shared: boolean) => void;
+    onClickCancel?: (event?: React.MouseEvent) => void;
+    modalOpen?: string;
+    placeholder?: string;
+    variant?: ButtonVariant;
+}
+export declare const ArchbaseSaveFilter: React.FC<ArchbaseSaveFilterProps>;
+export {};

package/dist/querybuilder/ArchbaseSimpleFilter.d.ts

@@ -0,0 +1,99 @@
+import { MantineColorScheme, MantineTheme } from '@mantine/core';
+import { Component, ReactNode } from 'react';
+import { ArchbaseQueryFilter, Condition, Field, Operator, SelectedSort } from './ArchbaseFilterCommons';
+interface Schema {
+    fields: Field[];
+    conditions: Condition[];
+    operators: Operator[];
+    onPropChange: (prop: any, value: any, ruleId: any) => void;
+    getLevel: (id: any) => number;
+    isRuleGroup: (rule: any) => boolean;
+    getOperators: (...args: any) => Operator[];
+}
+export interface ArchbaseSimpleFilterProps {
+    currentFilter?: any;
+    operators: any[];
+    onFilterChanged?: (filter: any, index: number) => void;
+    onError?: (error: any) => void;
+    fields: any[];
+    conditions: any[];
+    activeFilterIndex?: number;
+    allowSort?: boolean;
+    sortFocused?: boolean;
+    onSearchButtonClick?: (field: string, event?: any, handleOnChange?: any, operator?: any, searchField?: any) => void;
+    update?: number;
+    theme?: MantineTheme | null;
+    colorScheme?: MantineColorScheme | null;
+}
+export interface ArchbaseSimpleFilterState {
+    currentFilter: any;
+    update: number;
+    activeFilterIndex?: number;
+    simpleFields: ReactNode[];
+    schema: Schema;
+}
+declare class ArchbaseSimpleFilter extends Component<ArchbaseSimpleFilterProps, ArchbaseSimpleFilterState> {
+    static defaultProps: {
+        operators: {
+            name: string;
+            label: string;
+            dataTypes: string[];
+        }[];
+        conditions: {
+            name: string;
+            label: string;
+        }[];
+        onFilterChanged: any;
+        onError: any;
+    };
+    private prefixId;
+    constructor(props: ArchbaseSimpleFilterProps);
+    shouldComponentUpdate: (nextProps: ArchbaseSimpleFilterProps, nextState: ArchbaseSimpleFilterState) => boolean;
+    UNSAFE_componentWillReceiveProps: (nextProps: ArchbaseSimpleFilterProps) => void;
+    createSchema: () => Schema;
+    getDataType: (field: any, fields: string | any[]) => any;
+    getSelectedSort: () => SelectedSort[];
+    getSortItem: (field: any) => any;
+    getSortItemByOrder: (order: number) => any;
+    onChangeSortItem: (field: any, selected: any, order: any, asc_desc: any) => void;
+    propagateFilterChanged: () => void;
+    onSortDown: (_event: any) => void;
+    onSortUp: (_event: any) => void;
+    isRuleGroup: (rule: {
+        condition: any;
+        rules: any;
+    }) => boolean;
+    getField: (name: string) => any;
+    getOperators: (field: string) => Operator[];
+    onPropChange: (prop: string, value: any, ruleId: any) => void;
+    getLevel: (id: number) => number;
+    getLevel2: (id: any, index: number, root: any) => number;
+    findRule: (id: string, parent: {
+        id: any;
+        rules: any;
+    }) => any;
+    notifyQueryChange: (fn: Function, ...args: any[]) => void;
+    onSelectListItem: (index: any, _item: any) => void;
+    onOperatorChanged: (rule: {
+        id: any;
+    }, value: any) => void;
+    onDisabledChanged: (_value: any, checked: any, rule: {
+        id: any;
+    }, id: string) => void;
+    onValueChanged: (rule: {
+        id?: any;
+        field?: any;
+        operator?: any;
+    }, value: any | {
+        toString: () => any;
+    }[]) => void;
+    onValue2Changed: (rule: {
+        id: any;
+    }, value: any) => void;
+    onElementChanged: (property: string, value: string | boolean, id: any) => void;
+    getFieldValues: (field: any, fields: Field[] | any[]) => any;
+    getColor: (color: string) => string;
+    createFilterFields: (props: any, schema: Schema, currentFilter: ArchbaseQueryFilter) => ReactNode[];
+    render: () => import("react/jsx-runtime").JSX.Element;
+}
+export { ArchbaseSimpleFilter };

package/dist/querybuilder/index.d.ts

@@ -0,0 +1,17 @@
+export { QueryFieldValue, QueryField, QueryFields, QueryFilterEntity, FilterField, FilterFieldValue, FilterFields, getDefaultFilter, defaultConditions, defaultOperators, getDefaultEmptyFilter, getQuickFilterFields, mergeSortWithFields, getQuickFilterSort, getQuickFields, getFieldValues, getFieldSql, getFields, getQuickFieldsSort, getQuickFilterSortBySelectedFields, convertQueryFields, getSortString, QUICK_FILTER_INDEX, NEW_FILTER_INDEX, NORMAL, QUICK, ADVANCED, OP_NULL, OP_NOT_NULL, OP_CONTAINS, OP_STARTSWITH, OP_ENDSWITH, OP_EQUALS, OP_NOT_EQUALS, OP_GREATER, OP_LESS, OP_GREATER_OR_EQUAL, OP_LESS_OR_EQUAL, OP_BETWEEN, OP_IN_LIST, OP_NOT_IN_LIST, } from './ArchbaseFilterCommons';
+export type { Field, SortField, Filter, FilterOptions, ArchbaseQueryFilter, ArchbaseQueryFilterState, ArchbaseQueryFilterDelegator, PositionType, RangeType, Position, FilterType, DataType, FilterValue, SelectedSort, Operator, Rule, Condition, Schema, DelegatorCallback, IQueryFilterEntity, ArchbaseQueryBuilderProps, } from './ArchbaseFilterCommons';
+export { ArchbaseAdvancedFilter, CustomSortItem, ValueEditor } from './ArchbaseAdvancedFilter';
+export { ArchbaseCompositeFilter, ArchbaseDetailedFilter } from './ArchbaseCompositeFilter';
+export { ArchbaseFeedback } from './ArchbaseFeedback';
+export { ArchbaseFilterSelectFields } from './ArchbaseFilterSelectFields';
+export { ArchbaseFilterSelectRange } from './ArchbaseFilterSelectRange';
+export { ArchbaseInputSearch } from './ArchbaseInputSearch';
+export { ArchbaseQueryBuilder } from './ArchbaseQueryBuilder';
+export type { ArchbaseQueryBuilderState } from './ArchbaseQueryBuilder';
+export { ArchbaseSaveFilter } from './ArchbaseSaveFilter';
+export { ArchbaseSimpleFilter } from './ArchbaseSimpleFilter';
+export { ArchbaseGlobalFilter } from './ArchbaseGlobalFilter';
+export type { ArchbaseGlobalFilterProps } from './ArchbaseGlobalFilter';
+export type { ArchbaseSimpleFilterProps, ArchbaseSimpleFilterState } from './ArchbaseSimpleFilter';
+export { buildFrom } from './ArchbaseFilterRSQL';
+export * as GraphQLQueryBuilder from './ArchbaseFilterGraphQL';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@archbase/advanced",
-  "version": "3.0.0",
+  "version": "3.0.2",
   "description": "Archbase React Advanced Components - Charts, Kanban, QueryBuilder",
   "type": "module",
   "main": "./dist/index.js",
@@ -10,51 +10,54 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "require": "./dist/index.js"
-    }
+    },
+    "./dist/index.css": "./dist/index.css"
   },
   "files": [
     "dist"
   ],
   "peerDependencies": {
-    "react": "^19.0.0",
-    "react-dom": "^19.0.0",
     "@mantine/core": "8.3.12",
-    "@mantine/hooks": "8.3.12",
     "@mantine/dates": "8.3.12",
-    "@tabler/icons-react": "^3.29.0"
+    "@mantine/hooks": "8.3.12",
+    "@tabler/icons-react": "^3.29.0",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0"
   },
   "dependencies": {
+    "@archbase/components": "3.0.2",
+    "@archbase/core": "3.0.2",
+    "@archbase/data": "3.0.2",
+    "@archbase/layout": "3.0.2",
+    "date-fns": "^2.30.0",
+    "dayjs": "^1.11.10",
     "i18next": "^23.16.8",
     "lodash": "^4.17.21",
+    "react-accessible-accordion": "^5.0.0",
     "react-addons-shallow-compare": "^15.6.3",
-    "react-select": "^5.8.0",
-    "react-multi-date-picker": "4.1.2",
     "react-date-object": "^2.1.8",
-    "react-accessible-accordion": "^5.0.0",
-    "uuid": "^9.0.1",
-    "react-use": "^17.5.0",
-    "dayjs": "^1.11.10",
     "react-i18next": "^13.5.0",
     "react-modal": "^3.16.1",
-    "date-fns": "^2.30.0",
-    "@archbase/core": "3.0.0",
-    "@archbase/data": "3.0.0",
-    "@archbase/components": "3.0.0",
-    "@archbase/layout": "3.0.0"
+    "react-multi-date-picker": "4.1.2",
+    "react-select": "^5.8.0",
+    "react-use": "^17.5.0",
+    "uuid": "^9.0.1"
   },
   "devDependencies": {
-    "@types/react": "^19.0.2",
-    "@types/react-dom": "^19.0.2",
     "@types/lodash": "^4.17.13",
+    "@types/react": "^19.0.6",
     "@types/react-addons-shallow-compare": "^0.14.22",
+    "@types/react-dom": "^19.0.2",
     "typescript": "^5.7.2",
-    "vite": "^6.3.5"
+    "vite": "^6.3.5",
+    "vite-plugin-dts": "^4.5.4"
   },
   "publishConfig": {
     "registry": "http://192.168.1.110:4873"
   },
+  "module": "./dist/index.js",
   "scripts": {
-    "build": "NODE_OPTIONS=\"--max-old-space-size=16384\" vite build && tsc --emitDeclarationOnly || true",
+    "build": "NODE_OPTIONS=\"--max-old-space-size=16384\" vite build",
     "typecheck": "tsc --noEmit",
     "lint": "eslint src --ext .ts,.tsx",
     "clean": "rm -rf dist"