dinocollab-core 1.0.1 → 1.0.2

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

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+import { IPartialError } from './validator';
+export interface IFormBase<TModel> {
+    data?: Partial<TModel>;
+    messageErrors: IPartialError<TModel>;
+    onBlur: (keyName: keyof TModel) => void;
+    disabled?: boolean;
+}
+export interface IFormInputBase<TModel, TSlots = any> extends Partial<IFormBase<TModel>> {
+    name?: keyof TModel;
+    label?: React.ReactNode;
+    placeholder?: string;
+    defaultValue?: any;
+    slots?: TSlots;
+}

package/dist/types/form/validator.d.ts

@@ -0,0 +1,64 @@
+export type IModelBase = {
+    [key: string]: any;
+};
+export declare enum SingleRuleValidate {
+    Required = "Required",
+    Regex = "Regex",
+    RequiredValue = "RequiredValue",
+    Array = "Array",
+    Number = "Number",
+    Email = "Email",
+    PhoneNumber = "PhoneNumber",
+    Url = "Url",
+    File = "File",
+    FileRequired = "FileRequired",
+    Custom = "Custom"
+}
+export interface IRuleOptions {
+    File: {
+        maxSize: number;
+        all?: boolean;
+    };
+}
+export declare const mapRuleOptions: <TK extends "File">(key: TK, options?: IRuleOptions[TK] | undefined) => IRuleOptions[TK] | undefined;
+export interface IRuleOption<TModel = any> {
+    rule: SingleRuleValidate;
+    message?: string;
+    Value?: RegExp | ((value: any, model: TModel) => boolean) | number | Array<any> | boolean;
+    options?: any;
+}
+export interface IConfigValue<TModel = any> {
+    Rules: IRuleOption<TModel>[];
+    label?: string;
+}
+export interface IModelError {
+    message: string;
+    error: boolean;
+}
+export type IFormValidatorConfig<TModel> = {
+    [key in keyof Extract<TModel, IModelBase>]?: IConfigValue<TModel>;
+};
+export type IPartialError<TModel> = {
+    [key in keyof TModel]?: IRuleOption<TModel>[];
+};
+export default class FormValidator<TModel> {
+    configs: IFormValidatorConfig<TModel>;
+    constructor(configs: IFormValidatorConfig<TModel>);
+    static initial: <T>(configs: IFormValidatorConfig<T>) => FormValidator<T>;
+    AddRules: (key: keyof TModel, ...rule: IRuleOption<TModel>[]) => this;
+    Required: (RuleOption: IRuleOption, value: any) => boolean;
+    Regex: (RuleOption: IRuleOption, value: string, Regex: RegExp) => boolean;
+    RequiredValue: (RuleOption: IRuleOption, value: any) => boolean;
+    Custom: (RuleOption: IRuleOption, value: any, model: any) => boolean;
+    Array: (RuleOption: IRuleOption, value: any) => boolean;
+    Number: (RuleOption: IRuleOption, value: any) => boolean;
+    Email: (RuleOption: IRuleOption, value: any) => boolean;
+    PhoneNumber: (RuleOption: IRuleOption, value: any) => boolean;
+    Url: (RuleOption: IRuleOption, value: any) => boolean;
+    File: (RuleOption: IRuleOption, value: any) => boolean;
+    FileRequired: (RuleOption: IRuleOption, value: any) => boolean;
+    RenderMessage: (RuleOption: IRuleOption, key: string, label?: string) => IRuleOption<any>;
+    run: (model: TModel) => IPartialError<TModel>;
+    Executed: (Config: IConfigValue, valueField: any, model: any) => IRuleOption<any>[];
+}
+export declare const createFormValidator: <TModel>() => FormValidator<Partial<TModel>>;

package/dist/types/hooks/index.d.ts

@@ -0,0 +1,4 @@
+export declare const useCheckScrolled: () => {
+    isScrolled: boolean;
+};
+export declare const useDebounce: <T>(value: T, delay: number) => T;

package/dist/types/index.d.ts

@@ -0,0 +1,7 @@
+export * from './api-context';
+export * from './components';
+export * from './form';
+export * from './hooks';
+export * from './redux';
+export * from './table';
+export * from './utils';

package/dist/types/lab/create.autocomplete.simple.d.ts

@@ -0,0 +1,19 @@
+import { ComponentType } from 'react';
+import { AutocompleteProps } from '@mui/material';
+import { IFormInputBase } from '../form';
+export interface IAutocompleteSimpleModel<O = any> {
+    value: string;
+    label?: string;
+    other?: O;
+}
+export type IOptionsGetter<T, O = any> = (value: any, model: T) => IAutocompleteSimpleModel<O>;
+export interface IAutocompleteSimpleSlots<O> {
+    options?: IAutocompleteSimpleModel<O>[];
+    autocompleteProps?: AutocompleteProps<any, any, any, any>;
+}
+export interface IAutocompleteSimpleProps<T, O> extends IFormInputBase<T>, IAutocompleteSimpleSlots<O> {
+}
+export interface IAutocompleteSimpleState {
+}
+declare function CreateAutocompleteSimple<T, O = any>(params: IAutocompleteSimpleSlots<O>): ComponentType<IAutocompleteSimpleProps<T, O>>;
+export default CreateAutocompleteSimple;

package/dist/types/lab/create.dino-store.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/lab/create.multi-select-dropdown.d.ts

@@ -0,0 +1,23 @@
+import React from 'react';
+import { BoxProps, ButtonProps } from '@mui/material';
+type ILogic = 'and' | 'or';
+export interface IMultiSelectDropdownFilter {
+    logic?: ILogic;
+}
+interface ISlots {
+    buttonProps?: ButtonProps;
+    contentPorps?: BoxProps;
+}
+interface IProps {
+    options?: string[];
+    value?: string[];
+    onChange?: (value: string[], filter?: IMultiSelectDropdownFilter) => void;
+    slots?: ISlots;
+}
+interface IParams extends ISlots {
+    btnText: string;
+    options?: string[];
+    placeholder?: string;
+}
+declare function CreateMultiSelectDropdown(params: IParams): React.FC<IProps>;
+export default CreateMultiSelectDropdown;

package/dist/types/lab/create.select-mul-with-api/index.d.ts

@@ -0,0 +1,26 @@
+import { ComponentType } from 'react';
+import { GridPaginationModel } from '@mui/x-data-grid';
+import { FilterBarParams, IFilterState } from '../filter-bar';
+import { ISeclectMulFetchData, ISeclectMulFetchTotal, ISelectModel } from './types';
+export interface ISelectMulWithApiProps<T> {
+    fetchData?: ISeclectMulFetchData<T>;
+    fetchTotal?: ISeclectMulFetchTotal;
+    onSubmit?: (value: ISelectModel[]) => Promise<void>;
+}
+export interface ISelectMulWithApiState<T> {
+    loading?: boolean;
+    submiting?: boolean;
+    filterState: IFilterState<T>;
+    pagination: GridPaginationModel;
+    rows: ISelectModel[];
+    totalRows: number;
+    rowSelecteds: ISelectModel[];
+    searchKeyLocal?: string;
+    isUnselected?: boolean;
+}
+export interface ISelectMulWithApiParams<T> {
+    filterConfig: FilterBarParams<T>;
+}
+declare function CreateSelectMulWithApi<T>(params: ISelectMulWithApiParams<T>): ComponentType<ISelectMulWithApiProps<T>>;
+export * from './types';
+export default CreateSelectMulWithApi;

package/dist/types/lab/create.select-mul-with-api/table-custom.d.ts

@@ -0,0 +1,43 @@
+import React, { Component, ReactNode } from 'react';
+import { DataGridProps, GridColDef, GridFeatureMode, GridPaginationModel, GridRowSelectionModel } from '@mui/x-data-grid';
+import { ISelectModel } from './types';
+interface IProps {
+    title: string;
+    rows: ISelectModel[];
+    featureMode?: GridFeatureMode;
+    totalRows?: number;
+    maxSelected?: number;
+    pagination?: GridPaginationModel;
+    defaultPagination?: GridPaginationModel;
+    loading?: boolean;
+    onPaginationChange?: DataGridProps['onPaginationModelChange'];
+    isRowSelectable?: DataGridProps['isRowSelectable'];
+    slots?: {
+        title?: {
+            before?: ReactNode;
+            after?: ReactNode;
+        };
+        renderAction?: (value: ISelectModel) => ReactNode;
+        renderHeaderAction?: (parmas: {
+            rowSelecteds: GridRowSelectionModel;
+        }) => ReactNode;
+        header?: ReactNode;
+        topBar?: ReactNode;
+        dataGridProps?: Partial<DataGridProps>;
+    };
+}
+export declare class TableCustom extends Component<IProps> {
+    rowSelecteds: GridRowSelectionModel;
+    constructor(props: IProps);
+    shouldComponentUpdate(nextProps: Readonly<IProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+    render(): import("react/jsx-runtime").JSX.Element;
+    getDataGridProps: () => DataGridProps;
+    getData: () => {
+        rows: ISelectModel<any>[];
+        rowSelecteds: import("@mui/x-data-grid").GridRowId[];
+    };
+    getColumns: () => GridColDef[];
+    renderHeader: () => number | true | import("react/jsx-runtime").JSX.Element | Iterable<React.ReactNode>;
+    handleRowSelectionChange: (value: GridRowSelectionModel) => void;
+}
+export {};

package/dist/types/lab/create.select-mul-with-api/types.d.ts

@@ -0,0 +1,21 @@
+import { IFilterState } from '../filter-bar';
+export interface ISelectModel<F = any> {
+    value: string;
+    label?: string;
+    disabled?: boolean;
+    other?: F;
+}
+export interface IPaginationModel {
+    /** @default 0 */
+    page: number;
+    /** @default 100 */
+    pageSize: number;
+}
+export interface IFilterStateCustom<T> extends IFilterState<T> {
+    pagination: IPaginationModel;
+}
+export type ISeclectMulFetchData<T> = (filterState: IFilterStateCustom<T>, signal?: AbortSignal) => Promise<{
+    items: ISelectModel<T>[];
+    totalItems: number;
+}>;
+export type ISeclectMulFetchTotal = (signal?: AbortSignal) => Promise<number>;

package/dist/types/lab/create.select-mul-with-api/ui.units.d.ts

@@ -0,0 +1,29 @@
+import React, { FC } from 'react';
+import { InputBaseProps } from '@mui/material';
+import { ButtonProps, SwitchProps } from '@mui/material';
+import { ISelectModel } from './types';
+import { LoadingButtonProps } from '../../components/loading-buttons';
+export declare const ButtonAddToRight: FC<ButtonProps>;
+export declare const ButtonRemoveSelected: FC<ButtonProps>;
+export declare const ButtonAdd: FC<Omit<ButtonProps, 'value'> & {
+    value: ISelectModel;
+}>;
+export declare const ButtonRemove: FC<ButtonProps>;
+export declare const ButtonSubmit: FC<LoadingButtonProps>;
+export declare const Buttons: {
+    AddToRight: React.FC<ButtonProps<"button", {}>>;
+    RemoveSelected: React.FC<ButtonProps<"button", {}>>;
+    Add: React.FC<Omit<ButtonProps<"button", {}>, "value"> & {
+        value: ISelectModel;
+    }>;
+    Remove: React.FC<ButtonProps<"button", {}>>;
+    Submit: React.FC<LoadingButtonProps>;
+};
+export declare const SwitchUnselected: FC<SwitchProps & {
+    totalHidden?: number;
+}>;
+interface InputSearchLocalProps extends Omit<InputBaseProps, 'onChange'> {
+    onChange?: (value: string) => void;
+}
+export declare const InputSearchLocal: FC<InputSearchLocalProps>;
+export {};

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

@@ -0,0 +1,34 @@
+import { Component } from 'react';
+import { IFilterField, IFilterFields, IFilterItemModel, IFilterModel, IFilterState } from './types';
+export declare const filterPanelClasses: {
+    root: string;
+    list: string;
+    item: string;
+};
+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;
+        };
+    };
+    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) => IFilterFields<T>;
+    validated: (value: string, fieldKey: keyof IFilterModel<T>, filterField?: IFilterField) => {
+        error: boolean;
+        message?: string;
+    };
+    getSortFields: (fields: IFilterFields<T>) => IFilterFields<T>;
+}

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

@@ -0,0 +1,92 @@
+import React from 'react';
+import { FilterHelpNotesProps } from './ui.units';
+import { IFilterFields, IFilterItemModel, IFilterModel, FilterReason, IFilterState } from './types';
+import { FilterPanelState } from './create.filter-panel';
+export interface FilterBarParams<T> {
+    fields: IFilterFields<T>;
+    id?: string;
+    placeholder?: string;
+    helpNotes?: FilterHelpNotesProps;
+}
+interface IProps<T> {
+    id?: string;
+    placeholder?: string;
+    value?: IFilterState<T>;
+    onChange?: (value: IFilterState<T>) => void;
+}
+interface IState {
+    panelState: FilterPanelState;
+    keyword: string;
+}
+declare function CreateFilterBar<T>(params: FilterBarParams<T>): {
+    new (props: IProps<T>): {
+        defaultState: IState;
+        filterStateStore: IFilterState<T>;
+        readonly filterState: IFilterState<T>;
+        setFilterState: (filterState: IFilterState<T>) => void;
+        readonly configs: {
+            id: string;
+            placeholder: string;
+            helpNotes: FilterHelpNotesProps | 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 IState>(state: IState | ((prevState: Readonly<IState>, props: Readonly<IProps<T>>) => IState | Pick<IState, K> | null) | Pick<IState, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<IProps<T>>;
+        state: Readonly<IState>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<IProps<T>>, nextState: Readonly<IState>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<IProps<T>>, prevState: Readonly<IState>): any;
+        componentDidUpdate?(prevProps: Readonly<IProps<T>>, prevState: Readonly<IState>, 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>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<IProps<T>>, nextState: Readonly<IState>, nextContext: any): void;
+    };
+    contextType?: React.Context<any> | undefined;
+};
+export default CreateFilterBar;

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

@@ -0,0 +1,66 @@
+import React from 'react';
+import { ButtonProps } from '@mui/material';
+import { IFilterModel, IFilterPanelParams, IFilterPannelSubmitFunc } from './types';
+interface IProps<T> {
+    onSubmit?: IFilterPannelSubmitFunc<T>;
+    onCancel?: ButtonProps['onClick'];
+}
+interface IState<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;
+};
+export default CreateFilterMenu;

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

@@ -0,0 +1,117 @@
+import React, { PropsWithChildren } from 'react';
+import { IFilterModel, FilterReason, IFilterPanelParams, IFilterPannelSubmitFunc } from './types';
+export interface FilterPanelState {
+    anchorEl: HTMLElement | null;
+    reason?: FilterReason;
+}
+interface IProps<T> extends FilterPanelState, PropsWithChildren {
+    keyword?: string;
+    onSubmit?: IFilterPannelSubmitFunc<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;
+};
+export default CreateFilterPanel;

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

@@ -0,0 +1,59 @@
+import React from 'react';
+import { IFilterFields, IFilterModel, IFilterState } from './types';
+interface IProps<T> {
+    fields: IFilterFields<T>;
+    filterState: IFilterState<T>;
+    onRemove?: (key: keyof IFilterModel<T>) => void;
+}
+declare function CreateFiltered<T>(): {
+    new (props: IProps<T>): {
+        render(): import("react/jsx-runtime").JSX.Element[];
+        handleRemove: (key: keyof IFilterModel<T>) => 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;
+        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[];
+        handleRemove: (key: keyof IFilterModel<T>) => 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;
+        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;
+};
+export default CreateFiltered;

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

@@ -0,0 +1,7 @@
+/// <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;

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

@@ -0,0 +1,3 @@
+import { FC } from 'react';
+declare const FilterBarDemo: FC;
+export default FilterBarDemo;