dinocollab-core 1.0.20 → 1.0.21

package/dist/types/filter-bar/base.d.ts

@@ -1,26 +1,21 @@
 import { Component } from 'react';
-import { IFilterField, IFilterFields, IFilterItemModel, IFilterModel, IFilterState } from './types';
+import { IFilterModel, IFilterState, IQuickSearchDef } from './types';
+import { IFilterField, IFilterFields, IFilterItemChangeModel } from './types';
 export declare const filterPanelClasses: {
     root: string;
     list: string;
     item: string;
 };
+export interface IFilterChange<T> {
+    isChanged: boolean;
+    filterState: IFilterState<T>;
+}
 export default class FilterBarBase<P, S, T = any> extends Component<P, S> {
     mergeFilter: (f1?: IFilterState<T>, f2?: IFilterState<T>) => IFilterState<T>;
-    patchFilterWithKey: (filterState: IFilterState<T>, key: keyof IFilterModel<T>, value: IFilterItemModel) => {
-        isChanged: boolean;
-        filterState: {
-            filter: IFilterModel<T>;
-            details?: "add" | "remove" | undefined;
-        };
-    };
-    deleteFilterWithKey: (filterState: IFilterState<T>, key: keyof IFilterModel<T>) => {
-        isChanged: boolean;
-        filterState: {
-            filter: IFilterModel<T>;
-            details?: "add" | "remove" | undefined;
-        };
-    };
+    addQuickSearch: (filterState: IFilterState<T>, def?: IQuickSearchDef<T>, value?: string) => IFilterChange<T>;
+    removeQuickSearch: (filterState: IFilterState<T>) => IFilterChange<T>;
+    patchFilterWithKey: (filterState: IFilterState<T>, data: IFilterItemChangeModel<T>) => IFilterChange<T>;
+    deleteFilterWithKey: (filterState: IFilterState<T>, data: IFilterItemChangeModel<T>) => IFilterChange<T>;
     isFilterEmpty: (filterState: IFilterState<T>) => boolean;
     isYoutubeLink: (val: string) => boolean;
     isGenericLink: (val: string) => boolean;
@@ -30,5 +25,4 @@ export default class FilterBarBase<P, S, T = any> extends Component<P, S> {
         error: boolean;
         message?: string;
     };
-    getSortFields: (fields: IFilterFields<T>) => IFilterFields<T>;
 }

package/dist/types/filter-bar/create.filter-bar.d.ts

@@ -1,92 +1,4 @@
-import React from 'react';
-import { IFilterHelpNotesProps } from './ui.units';
-import { IFilterFields, IFilterItemModel, IFilterModel, FilterReason, IFilterState } from './types';
-import { FilterPanelState } from './create.filter-panel';
-export interface IFilterBarParams<T> {
-    fields: IFilterFields<T>;
-    id?: string;
-    placeholder?: string;
-    helpNotes?: IFilterHelpNotesProps;
-}
-export interface IFilterBarProps<T> {
-    id?: string;
-    placeholder?: string;
-    value?: IFilterState<T>;
-    onChange?: (value: IFilterState<T>) => void;
-}
-export interface IFilterBarState {
-    panelState: FilterPanelState;
-    keyword: string;
-}
-declare function CreateFilterBar<T>(params: IFilterBarParams<T>): {
-    new (props: IFilterBarProps<T>): {
-        defaultState: IFilterBarState;
-        filterStateStore: IFilterState<T>;
-        readonly filterState: IFilterState<T>;
-        setFilterState: (filterState: IFilterState<T>) => void;
-        readonly configs: {
-            id: string;
-            placeholder: string;
-            helpNotes: IFilterHelpNotesProps | undefined;
-        };
-        refFilterButton: HTMLButtonElement | null;
-        refSortButton: HTMLButtonElement | null;
-        render(): import("react/jsx-runtime").JSX.Element;
-        refInput: HTMLInputElement | null;
-        refBeforeInput: HTMLElement | null;
-        renderTextField: () => import("react/jsx-runtime").JSX.Element;
-        handleKeyDown: (event: React.KeyboardEvent<HTMLInputElement | HTMLTextAreaElement>) => void;
-        handleAdd: (key: keyof IFilterModel<T>, value: IFilterItemModel) => void;
-        handleRemove: (key: keyof IFilterModel<T>) => void;
-        handleClear: () => void;
-        showPanel: (reason: FilterReason) => void;
-        closePanel: () => void;
-        mergeFilter: (f1?: IFilterState<T> | undefined, f2?: IFilterState<T> | undefined) => IFilterState<T>;
-        patchFilterWithKey: (filterState: IFilterState<T>, key: "Search" | keyof T, value: IFilterItemModel) => {
-            isChanged: boolean;
-            filterState: {
-                filter: IFilterModel<T>;
-                details?: "add" | "remove" | undefined;
-            };
-        };
-        deleteFilterWithKey: (filterState: IFilterState<T>, key: "Search" | keyof T) => {
-            isChanged: boolean;
-            filterState: {
-                filter: IFilterModel<T>;
-                details?: "add" | "remove" | undefined;
-            };
-        };
-        isFilterEmpty: (filterState: IFilterState<T>) => boolean;
-        isYoutubeLink: (val: string) => boolean;
-        isGenericLink: (val: string) => boolean;
-        isGuid: (val: string) => boolean;
-        getFieldsMatches: (fields: IFilterFields<T>, keyword: string, showAll?: boolean | undefined) => IFilterFields<T>;
-        validated: (value: string, fieldKey: "Search" | keyof T, filterField?: import("./types").IFilterField | undefined) => {
-            error: boolean;
-            message?: string | undefined;
-        };
-        getSortFields: (fields: IFilterFields<T>) => IFilterFields<T>;
-        context: unknown;
-        setState<K extends keyof IFilterBarState>(state: IFilterBarState | ((prevState: Readonly<IFilterBarState>, props: Readonly<IFilterBarProps<T>>) => IFilterBarState | Pick<IFilterBarState, K> | null) | Pick<IFilterBarState, K> | null, callback?: (() => void) | undefined): void;
-        forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<IFilterBarProps<T>>;
-        state: Readonly<IFilterBarState>;
-        refs: {
-            [key: string]: React.ReactInstance;
-        };
-        componentDidMount?(): void;
-        shouldComponentUpdate?(nextProps: Readonly<IFilterBarProps<T>>, nextState: Readonly<IFilterBarState>, nextContext: any): boolean;
-        componentWillUnmount?(): void;
-        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<IFilterBarProps<T>>, prevState: Readonly<IFilterBarState>): any;
-        componentDidUpdate?(prevProps: Readonly<IFilterBarProps<T>>, prevState: Readonly<IFilterBarState>, snapshot?: any): void;
-        componentWillMount?(): void;
-        UNSAFE_componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<IFilterBarProps<T>>, nextContext: any): void;
-        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<IFilterBarProps<T>>, nextContext: any): void;
-        componentWillUpdate?(nextProps: Readonly<IFilterBarProps<T>>, nextState: Readonly<IFilterBarState>, nextContext: any): void;
-        UNSAFE_componentWillUpdate?(nextProps: Readonly<IFilterBarProps<T>>, nextState: Readonly<IFilterBarState>, nextContext: any): void;
-    };
-    contextType?: React.Context<any> | undefined;
-};
+import { ComponentType } from 'react';
+import { IFilterBarParams, IFilterBarProps } from './types';
+declare function CreateFilterBar<T>(params: IFilterBarParams<T>): ComponentType<IFilterBarProps<T>>;
 export default CreateFilterBar;

package/dist/types/filter-bar/create.filter-menu.d.ts

@@ -1,66 +1,13 @@
-import React from 'react';
+import { ComponentType } from 'react';
 import { ButtonProps } from '@mui/material';
-import { IFilterModel, IFilterPanelParams, IFilterPannelSubmitFunc } from './types';
-interface IProps<T> {
-    onSubmit?: IFilterPannelSubmitFunc<T>;
+import { IFilterBarParams, IFilterModel, IFilterSubmitFunc } from './types';
+export interface IFilterMenuProps<T> {
+    onSubmit?: IFilterSubmitFunc<T>;
     onCancel?: ButtonProps['onClick'];
 }
-interface IState<T> {
+export interface IFilterMenuState<T> {
     fieldSelected: keyof IFilterModel<T> | null;
     messageError?: string;
 }
-declare function CreateFilterMenu<T>(params: IFilterPanelParams<T>): {
-    new (props: IProps<T>): {
-        render(): import("react/jsx-runtime").JSX.Element;
-        renderFrom: (fieldSelected: keyof IFilterModel<T>) => import("react/jsx-runtime").JSX.Element;
-        renderWithMode: (fieldSelected: keyof IFilterModel<T>) => import("react/jsx-runtime").JSX.Element;
-        handleSubmit: (fieldSelected: keyof IFilterModel<T>, event: React.FormEvent<HTMLFormElement>) => void;
-        mergeFilter: (f1?: import("./types").IFilterState<T> | undefined, f2?: import("./types").IFilterState<T> | undefined) => import("./types").IFilterState<T>;
-        patchFilterWithKey: (filterState: import("./types").IFilterState<T>, key: "Search" | keyof T, value: import("./types").IFilterItemModel) => {
-            isChanged: boolean;
-            filterState: {
-                filter: IFilterModel<T>;
-                details?: "add" | "remove" | undefined;
-            };
-        };
-        deleteFilterWithKey: (filterState: import("./types").IFilterState<T>, key: "Search" | keyof T) => {
-            isChanged: boolean;
-            filterState: {
-                filter: IFilterModel<T>;
-                details?: "add" | "remove" | undefined;
-            };
-        };
-        isFilterEmpty: (filterState: import("./types").IFilterState<T>) => boolean;
-        isYoutubeLink: (val: string) => boolean;
-        isGenericLink: (val: string) => boolean;
-        isGuid: (val: string) => boolean;
-        getFieldsMatches: (fields: import("./types").IFilterFields<T>, keyword: string, showAll?: boolean | undefined) => import("./types").IFilterFields<T>;
-        validated: (value: string, fieldKey: "Search" | keyof T, filterField?: import("./types").IFilterField | undefined) => {
-            error: boolean;
-            message?: string | undefined;
-        };
-        getSortFields: (fields: import("./types").IFilterFields<T>) => import("./types").IFilterFields<T>;
-        context: unknown;
-        setState<K extends keyof IState<T>>(state: IState<T> | ((prevState: Readonly<IState<T>>, props: Readonly<IProps<T>>) => IState<T> | Pick<IState<T>, K> | null) | Pick<IState<T>, K> | null, callback?: (() => void) | undefined): void;
-        forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<IProps<T>>;
-        state: Readonly<IState<T>>;
-        refs: {
-            [key: string]: React.ReactInstance;
-        };
-        componentDidMount?(): void;
-        shouldComponentUpdate?(nextProps: Readonly<IProps<T>>, nextState: Readonly<IState<T>>, nextContext: any): boolean;
-        componentWillUnmount?(): void;
-        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<IProps<T>>, prevState: Readonly<IState<T>>): any;
-        componentDidUpdate?(prevProps: Readonly<IProps<T>>, prevState: Readonly<IState<T>>, snapshot?: any): void;
-        componentWillMount?(): void;
-        UNSAFE_componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<IProps<T>>, nextContext: any): void;
-        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<IProps<T>>, nextContext: any): void;
-        componentWillUpdate?(nextProps: Readonly<IProps<T>>, nextState: Readonly<IState<T>>, nextContext: any): void;
-        UNSAFE_componentWillUpdate?(nextProps: Readonly<IProps<T>>, nextState: Readonly<IState<T>>, nextContext: any): void;
-    };
-    contextType?: React.Context<any> | undefined;
-};
+declare function CreateFilterMenu<T>(params: IFilterBarParams<T>): ComponentType<IFilterMenuProps<T>>;
 export default CreateFilterMenu;

package/dist/types/filter-bar/create.filter-panel.d.ts

@@ -1,117 +1,13 @@
-import React, { PropsWithChildren } from 'react';
-import { IFilterModel, FilterReason, IFilterPanelParams, IFilterPannelSubmitFunc } from './types';
-export interface FilterPanelState {
+import { ComponentType, PropsWithChildren } from 'react';
+import { IFilterReason, IFilterSubmitFunc, IFilterBarParams } from './types';
+export interface IFilterPanelState {
     anchorEl: HTMLElement | null;
-    reason?: FilterReason;
+    reason?: IFilterReason;
 }
-interface IProps<T> extends FilterPanelState, PropsWithChildren {
+interface IFilterPanelProps<T> extends IFilterPanelState, PropsWithChildren {
     keyword?: string;
-    onSubmit?: IFilterPannelSubmitFunc<T>;
+    onSubmit?: IFilterSubmitFunc<T>;
     onClose?: () => void;
 }
-declare function CreateFilterPanel<T>(params: IFilterPanelParams<T>): {
-    new (props: IProps<T>): {
-        render(): import("react/jsx-runtime").JSX.Element;
-        renderContent: () => import("react/jsx-runtime").JSX.Element | undefined;
-        renderSearchInput: () => import("react/jsx-runtime").JSX.Element;
-        handleClick: (key: keyof IFilterModel<T>) => void;
-        mergeFilter: (f1?: import("./types").IFilterState<T> | undefined, f2?: import("./types").IFilterState<T> | undefined) => import("./types").IFilterState<T>;
-        patchFilterWithKey: (filterState: import("./types").IFilterState<T>, key: "Search" | keyof T, value: import("./types").IFilterItemModel) => {
-            isChanged: boolean;
-            filterState: {
-                filter: IFilterModel<T>;
-                details?: "add" | "remove" | undefined;
-            };
-        };
-        deleteFilterWithKey: (filterState: import("./types").IFilterState<T>, key: "Search" | keyof T) => {
-            isChanged: boolean;
-            filterState: {
-                filter: IFilterModel<T>;
-                details?: "add" | "remove" | undefined;
-            };
-        };
-        isFilterEmpty: (filterState: import("./types").IFilterState<T>) => boolean;
-        isYoutubeLink: (val: string) => boolean;
-        isGenericLink: (val: string) => boolean;
-        isGuid: (val: string) => boolean;
-        getFieldsMatches: (fields: import("./types").IFilterFields<T>, keyword: string, showAll?: boolean | undefined) => import("./types").IFilterFields<T>;
-        validated: (value: string, fieldKey: "Search" | keyof T, filterField?: import("./types").IFilterField | undefined) => {
-            error: boolean;
-            message?: string | undefined;
-        };
-        getSortFields: (fields: import("./types").IFilterFields<T>) => import("./types").IFilterFields<T>;
-        context: unknown;
-        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<IProps<T>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
-        forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<IProps<T>>;
-        state: Readonly<{}>;
-        refs: {
-            [key: string]: React.ReactInstance;
-        };
-        componentDidMount?(): void;
-        shouldComponentUpdate?(nextProps: Readonly<IProps<T>>, nextState: Readonly<{}>, nextContext: any): boolean;
-        componentWillUnmount?(): void;
-        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<IProps<T>>, prevState: Readonly<{}>): any;
-        componentDidUpdate?(prevProps: Readonly<IProps<T>>, prevState: Readonly<{}>, snapshot?: any): void;
-        componentWillMount?(): void;
-        UNSAFE_componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<IProps<T>>, nextContext: any): void;
-        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<IProps<T>>, nextContext: any): void;
-        componentWillUpdate?(nextProps: Readonly<IProps<T>>, nextState: Readonly<{}>, nextContext: any): void;
-        UNSAFE_componentWillUpdate?(nextProps: Readonly<IProps<T>>, nextState: Readonly<{}>, nextContext: any): void;
-    };
-    new (props: IProps<T>, context: any): {
-        render(): import("react/jsx-runtime").JSX.Element;
-        renderContent: () => import("react/jsx-runtime").JSX.Element | undefined;
-        renderSearchInput: () => import("react/jsx-runtime").JSX.Element;
-        handleClick: (key: keyof IFilterModel<T>) => void;
-        mergeFilter: (f1?: import("./types").IFilterState<T> | undefined, f2?: import("./types").IFilterState<T> | undefined) => import("./types").IFilterState<T>;
-        patchFilterWithKey: (filterState: import("./types").IFilterState<T>, key: "Search" | keyof T, value: import("./types").IFilterItemModel) => {
-            isChanged: boolean;
-            filterState: {
-                filter: IFilterModel<T>;
-                details?: "add" | "remove" | undefined;
-            };
-        };
-        deleteFilterWithKey: (filterState: import("./types").IFilterState<T>, key: "Search" | keyof T) => {
-            isChanged: boolean;
-            filterState: {
-                filter: IFilterModel<T>;
-                details?: "add" | "remove" | undefined;
-            };
-        };
-        isFilterEmpty: (filterState: import("./types").IFilterState<T>) => boolean;
-        isYoutubeLink: (val: string) => boolean;
-        isGenericLink: (val: string) => boolean;
-        isGuid: (val: string) => boolean;
-        getFieldsMatches: (fields: import("./types").IFilterFields<T>, keyword: string, showAll?: boolean | undefined) => import("./types").IFilterFields<T>;
-        validated: (value: string, fieldKey: "Search" | keyof T, filterField?: import("./types").IFilterField | undefined) => {
-            error: boolean;
-            message?: string | undefined;
-        };
-        getSortFields: (fields: import("./types").IFilterFields<T>) => import("./types").IFilterFields<T>;
-        context: unknown;
-        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<IProps<T>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
-        forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<IProps<T>>;
-        state: Readonly<{}>;
-        refs: {
-            [key: string]: React.ReactInstance;
-        };
-        componentDidMount?(): void;
-        shouldComponentUpdate?(nextProps: Readonly<IProps<T>>, nextState: Readonly<{}>, nextContext: any): boolean;
-        componentWillUnmount?(): void;
-        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<IProps<T>>, prevState: Readonly<{}>): any;
-        componentDidUpdate?(prevProps: Readonly<IProps<T>>, prevState: Readonly<{}>, snapshot?: any): void;
-        componentWillMount?(): void;
-        UNSAFE_componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<IProps<T>>, nextContext: any): void;
-        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<IProps<T>>, nextContext: any): void;
-        componentWillUpdate?(nextProps: Readonly<IProps<T>>, nextState: Readonly<{}>, nextContext: any): void;
-        UNSAFE_componentWillUpdate?(nextProps: Readonly<IProps<T>>, nextState: Readonly<{}>, nextContext: any): void;
-    };
-    contextType?: React.Context<any> | undefined;
-};
+declare function CreateFilterPanel<T>(params: IFilterBarParams<T>): ComponentType<IFilterPanelProps<T>>;
 export default CreateFilterPanel;

package/dist/types/filter-bar/create.filtered.d.ts

@@ -1,14 +1,15 @@
 import React from 'react';
-import { IFilterFields, IFilterModel, IFilterState } from './types';
+import { IFilterBarParams, IFilterState, IFilterSubmitFunc } from './types';
 interface IProps<T> {
-    fields: IFilterFields<T>;
     filterState: IFilterState<T>;
-    onRemove?: (key: keyof IFilterModel<T>) => void;
+    onRemove?: IFilterSubmitFunc<T>;
 }
-declare function CreateFiltered<T>(): {
+declare function CreateFiltered<T>(params: IFilterBarParams<T>): {
     new (props: IProps<T>): {
-        render(): import("react/jsx-runtime").JSX.Element[];
-        handleRemove: (key: keyof IFilterModel<T>) => void;
+        render(): import("react/jsx-runtime").JSX.Element;
+        renderQuickSearch: () => import("react/jsx-runtime").JSX.Element;
+        handleRemove: (field: keyof T) => void;
+        handleQuickSearchRemove: () => void;
         context: unknown;
         setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<IProps<T>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
         forceUpdate(callback?: (() => void) | undefined): void;
@@ -31,8 +32,10 @@ declare function CreateFiltered<T>(): {
         UNSAFE_componentWillUpdate?(nextProps: Readonly<IProps<T>>, nextState: Readonly<{}>, nextContext: any): void;
     };
     new (props: IProps<T>, context: any): {
-        render(): import("react/jsx-runtime").JSX.Element[];
-        handleRemove: (key: keyof IFilterModel<T>) => void;
+        render(): import("react/jsx-runtime").JSX.Element;
+        renderQuickSearch: () => import("react/jsx-runtime").JSX.Element;
+        handleRemove: (field: keyof T) => void;
+        handleQuickSearchRemove: () => void;
         context: unknown;
         setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<IProps<T>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
         forceUpdate(callback?: (() => void) | undefined): void;

package/dist/types/filter-bar/create.sort-menu.d.ts

@@ -1,7 +1 @@
-/// <reference types="react" />
-import { IFilterPanelParams, IFilterPannelSubmitFunc } from './types';
-interface IProps<T> {
-    onSubmit?: IFilterPannelSubmitFunc<T>;
-}
-declare function CreateFilterSort<T>(params: IFilterPanelParams<T>): React.ComponentType<IProps<T>>;
-export default CreateFilterSort;
+export {};

package/dist/types/filter-bar/index.d.ts

@@ -1,3 +1,2 @@
 export { default as CreateFilterBar } from './create.filter-bar';
-export type { IFilterBarParams as FilterBarParams } from './create.filter-bar';
 export * from './types';

package/dist/types/filter-bar/types.d.ts

@@ -1,7 +1,6 @@
-export type FilterReason = 'searchInput' | 'filterButton' | 'sortButton';
-type Dictionary<T, V, E = any> = {
-    [key in keyof T | keyof E]?: V;
-};
+import { IFilterPanelState } from './create.filter-panel';
+import { IFilterNotesProps } from './ui.units';
+export type IFilterReason = 'searchInput' | 'filterButton';
 type SingleOrArray<T> = T | T[];
 export declare enum ESearchMatch {
     AlwaysVisible = "AlwaysVisible",
@@ -37,24 +36,24 @@ interface IFieldValidateQuickly extends IFieldValidateBase {
     rule: EFieldValidate.Link | EFieldValidate.LinkYoutube;
 }
 type IFieldValidate = IFieldValidateQuickly | IFieldValidateCustom;
-interface IFilterFieldBase {
+export interface IQuickSearchDef<T> {
+    fields: SingleOrArray<keyof T>;
+    label?: string;
+    notes?: IFilterNotesProps;
+}
+interface IFilterFieldDef {
     label?: string;
     /** @default string */
     type?: 'string' | 'select';
     searchMatches?: SingleOrArray<IFieldSearchMatch>;
-    helpeNotes?: {
-        title?: string;
-        items: string[];
-    };
-    /** @default true */
-    sortable?: boolean;
+    notes?: IFilterNotesProps;
     /** @default Required */
     validate?: SingleOrArray<IFieldValidate>;
 }
-export interface IFilterFieldString extends IFilterFieldBase {
+export interface IFilterFieldString extends IFilterFieldDef {
     type?: 'string';
 }
-export interface IFilterFieldSelect extends IFilterFieldBase {
+export interface IFilterFieldSelect extends IFilterFieldDef {
     type: 'select';
     options: {
         value: string;
@@ -62,24 +61,44 @@ export interface IFilterFieldSelect extends IFilterFieldBase {
     }[];
 }
 export type IFilterField = IFilterFieldString | IFilterFieldSelect;
-export type IFilterFields<T> = Dictionary<T, IFilterField, {
-    Search?: string;
-}>;
+export type IFilterFields<T> = {
+    [key in keyof T]?: IFilterField;
+};
 export interface IFilterItemModel {
     value?: string | number | boolean;
     label?: string;
-    /** @default true */
-    sortable?: boolean;
 }
-export type IFilterModel<T> = Dictionary<T, IFilterItemModel[], {
-    Search?: string;
-}>;
+export interface IFilterItemChangeModel<T> extends IFilterItemModel {
+    field: keyof T;
+}
+export type IFilterModel<T> = {
+    [key in keyof T]?: IFilterItemModel[];
+};
+export interface IQuickSearchModel<T> {
+    fields: SingleOrArray<keyof T>;
+    values?: SingleOrArray<string>;
+}
 export interface IFilterState<T> {
     filter?: IFilterModel<T>;
+    quickSearch?: IQuickSearchModel<T>;
     details?: 'add' | 'remove';
 }
-export interface IFilterPanelParams<T> {
+export interface IFilterBarParams<T> {
     fields: IFilterFields<T>;
+    quickSearch?: IQuickSearchDef<T>;
+    id?: string;
+    placeholder?: string;
+    notes?: IFilterNotesProps;
+}
+export interface IFilterBarProps<T> {
+    id?: string;
+    placeholder?: string;
+    value?: IFilterState<T>;
+    onChange?: (value: IFilterState<T>) => void;
+}
+export interface IFilterBarState {
+    panelState: IFilterPanelState;
+    keyword: string;
 }
-export type IFilterPannelSubmitFunc<T> = (filed: keyof IFilterModel<T>, value: IFilterItemModel) => void;
+export type IFilterSubmitFunc<T> = (mode: 'field' | 'quickSearch', data?: IFilterItemChangeModel<T>) => void;
 export {};

package/dist/types/filter-bar/ui.units.d.ts

@@ -1,13 +1,14 @@
-import { FC } from 'react';
+import { FC, ReactNode } from 'react';
 import { IconButtonProps } from '@mui/material';
 export interface IButtonClearProps {
     visibled?: boolean;
     onClick: IconButtonProps['onClick'];
 }
 export declare const ButtonClear: FC<IButtonClearProps>;
-export interface IFilterHelpNotesProps {
+export interface IFilterNotesProps {
     title?: string;
     items?: string[];
     disabledSize?: boolean;
+    renderContent?: () => ReactNode;
 }
-export declare const FilterHelpNotes: FC<IFilterHelpNotesProps>;
+export declare const FilterNotes: FC<IFilterNotesProps>;

package/dist/types/form/create.autocomplete.chips.d.ts

@@ -1,16 +1,16 @@
 import { ComponentType } from 'react';
 import { IFormInputBase } from './types';
-export interface IAutocompleteChipParams {
+export interface IAutocompleteChipSlots {
     optionItems?: string[];
     limitTags?: number;
     separator?: string;
     saveLocalStorageByKey?: string;
 }
-export interface IAutocompleteChipProps<T> extends IFormInputBase<T, IAutocompleteChipParams> {
+export interface IAutocompleteChipProps<T> extends IFormInputBase<T, IAutocompleteChipSlots> {
 }
 export interface IAutocompleteChipState {
     value: string[];
     options: string[];
 }
-declare function CreateAutocompleteChip<T>(params?: IAutocompleteChipParams): ComponentType<IAutocompleteChipProps<T>>;
+declare function CreateAutocompleteChip<T>(params?: IAutocompleteChipSlots): ComponentType<IAutocompleteChipProps<T>>;
 export default CreateAutocompleteChip;

package/dist/types/form/create.form-base.d.ts

@@ -1,30 +1,24 @@
 import React, { ComponentType, PropsWithChildren } from 'react';
 import { SxProps, Theme } from '@mui/material';
-import { IFormBase } from './types';
+import { IFormBaseContext } from './types';
 import FormValidator, { IPartialError } from './validator';
-export interface FormBaseParam<TModel> {
-    validate?: FormValidator<Partial<TModel>>;
+export interface IFormBaseParams<T> {
+    validate?: FormValidator<Partial<T>>;
 }
-export interface FormBaseProps<TModel> extends PropsWithChildren {
+export interface IFormBaseProps<T> extends PropsWithChildren {
     sx?: SxProps<Theme>;
-    validate?: FormValidator<Partial<TModel>>;
-    onSubmit: (data: Partial<TModel>, e: React.FormEvent<HTMLFormElement>) => Promise<void>;
+    validate?: FormValidator<Partial<T>>;
+    onSubmit: (data: Partial<T>, e: React.FormEvent<HTMLFormElement>) => Promise<void>;
 }
-export interface FormBaseState<TModel> extends Pick<IFormBase<TModel>, 'messageErrors'> {
-    modelState?: Partial<TModel>;
+export interface IFormBaseState<T> {
+    modelState?: Partial<T>;
+    messageErrors: IPartialError<T>;
 }
-export interface IFormContextBase<TModel> {
-    modelState?: Partial<TModel>;
-    messageErrors: IPartialError<TModel>;
-    onBlur: (keyName: keyof TModel) => void;
-    setError: (keyName: keyof TModel, message: string) => void;
-    clearErrorAll: (keyName: keyof TModel) => void;
+export interface IFormBaseResult<T> {
+    Form: ComponentType<IFormBaseProps<T>>;
+    Validator?: FormValidator<Partial<T>>;
+    Context: React.Context<IFormBaseContext<T>>;
+    mapContext: (params: (context: IFormBaseContext<T>) => JSX.Element) => JSX.Element;
 }
-export interface FormBaseResult<TModel> {
-    Form: ComponentType<FormBaseProps<TModel>>;
-    Validator?: FormValidator<Partial<TModel>>;
-    Context: React.Context<IFormContextBase<TModel>>;
-    contextMapping: (params: (context: IFormContextBase<TModel>) => JSX.Element) => JSX.Element;
-}
-declare const CreateFormBase: <TModel>(param?: FormBaseParam<TModel> | undefined) => FormBaseResult<TModel>;
+declare const CreateFormBase: <T>(params?: IFormBaseParams<T> | undefined) => IFormBaseResult<T>;
 export default CreateFormBase;

package/dist/types/form/create.form-grid-layout.units.d.ts

@@ -1,8 +1,12 @@
 import React, { ReactNode } from 'react';
 import { IFormBase } from './types';
-export declare const ContentWrap: StyledComponent<ComponentProps, SpecificComponentProps, JSXProps>;
+export declare const ContentWrap: import("@emotion/styled").StyledComponent<import("@mui/system").BoxOwnProps<import("@mui/material").Theme> & Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void) | React.RefObject<HTMLDivElement> | null | undefined;
+}, keyof import("@mui/system").BoxOwnProps<import("@mui/material").Theme>> & import("@mui/system").MUIStyledCommonProps<import("@mui/material").Theme>, {}, {}>;
 export interface IFormBottomBarProps<T> extends IFormBase<T> {
     before?: ReactNode;
 }
 export declare function CreateFormBottomBar<T>(): React.FC<IFormBottomBarProps<T>>;
-export declare const FormBottomBarWrap: StyledComponent<ComponentProps, SpecificComponentProps, JSXProps>;
+export declare const FormBottomBarWrap: import("@emotion/styled").StyledComponent<import("@mui/system").BoxOwnProps<import("@mui/material").Theme> & Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void) | React.RefObject<HTMLDivElement> | null | undefined;
+}, keyof import("@mui/system").BoxOwnProps<import("@mui/material").Theme>> & import("@mui/system").MUIStyledCommonProps<import("@mui/material").Theme>, {}, {}>;

package/dist/types/form/create.input-file.csv-local-parser.d.ts

@@ -32,9 +32,8 @@ export interface IInputFileCsvLocalParserSlots {
 }
 export interface IInputFileCsvLocalParserParams extends IInputFileCsvLocalParserSlots {
 }
-export interface IInputFileCsvLocalParserProps<T, C> extends IFormInputBase<T> {
+export interface IInputFileCsvLocalParserProps<T, C> extends IFormInputBase<T, IInputFileCsvLocalParserSlots> {
     onChange?: (value: C[]) => void;
-    slots?: IInputFileCsvLocalParserSlots;
 }
 export interface IInputFileCsvLocalParserState<C> {
     parsedData: C[];

package/dist/types/form/create.input.d.ts

@@ -17,8 +17,7 @@ export interface IInputSlots<T> {
     imageLeft?: InputBaseImage<T>;
     imageRight?: InputBaseImage<T>;
 }
-export interface IInputProps<T> extends IFormInputBase<T> {
-    slots?: IInputSlots<T>;
+export interface IInputProps<T> extends IFormInputBase<T, IInputSlots<T>> {
 }
 export interface IInputState {
     value?: string;

package/dist/types/form/dino-form.d.ts

@@ -8,10 +8,12 @@ import CreateAutocompleteChip from './create.autocomplete.chips';
 import { createInputFileCsvLocalParser } from './create.input-file.csv-local-parser';
 declare class DinoFormBase {
     ModalWrap: import("react").FC<import("./modal-wrapper").IFormModalWrapperProps>;
-    BottomBarWrap: StyledComponent<ComponentProps, SpecificComponentProps, JSXProps>;
+    BottomBarWrap: import("@emotion/styled").StyledComponent<import("@mui/system").BoxOwnProps<import("@mui/material").Theme> & Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        ref?: ((instance: HTMLDivElement | null) => void) | import("react").RefObject<HTMLDivElement> | null | undefined;
+    }, keyof import("@mui/system").BoxOwnProps<import("@mui/material").Theme>> & import("@mui/system").MUIStyledCommonProps<import("@mui/material").Theme>, {}, {}>;
     FormValidator: typeof FormValidator;
     validator: <T>(configs: import("./validator").IFormValidatorConfig<T>) => FormValidator<T>;
-    createFormBase: <TModel>(param?: import("./create.form-base").FormBaseParam<TModel> | undefined) => import("./create.form-base").FormBaseResult<TModel>;
+    createFormBase: <T>(params?: import("./create.form-base").IFormBaseParams<T> | undefined) => import("./create.form-base").IFormBaseResult<T>;
     createFormComfirm: <T = any>(param?: import("./create.form-comfirm").IFormComfirmParam<T> | undefined) => import("react").ComponentType<import("react").PropsWithChildren<import("./create.form-comfirm").IFormComfirmProps<T>>>;
     createFormGridLayout: <T>(params: import("./create.form-grid-layout").IFormGridLayoutParams<T>) => import("react").ComponentType<import("./create.form-grid-layout").IFormGridLayoutProps<T>>;
     createDateExpired: typeof CreateDateExpired;