dinocollab-core 1.1.3 → 1.1.4

package/dist/types/data-view/filter-store.d.ts

@@ -0,0 +1,39 @@
+import { IFilterState, IFilterMap, IPagination, ISort, IFilterChangeDetails, IFilterItem, SingleOrArray } from './types';
+export declare class FilterStore<T> {
+    private _state;
+    private _defaultFilter;
+    constructor(initialState?: IFilterState<T>, defaultFilter?: IFilterState<T>);
+    get state(): IFilterState<T>;
+    addFilterItem(field: keyof T, filterItem: IFilterItem, details?: IFilterChangeDetails): FilterStore<T>;
+    removeFilterFiled(field: keyof T, details?: IFilterChangeDetails): FilterStore<T>;
+    removeFilterItem(field: keyof T, value: string, details?: IFilterChangeDetails): FilterStore<T>;
+    updateFilter(filter?: IFilterMap<T>, details?: IFilterChangeDetails): this;
+    addQuickSearch(value?: SingleOrArray<string>, details?: IFilterChangeDetails): FilterStore<T>;
+    removeQuickSearch(details?: IFilterChangeDetails): FilterStore<T>;
+    removeQuickSearchItem(value: string, details?: IFilterChangeDetails): FilterStore<T>;
+    updateSearchInput(quickSearch: SingleOrArray<string>): FilterStore<T>;
+    changePagination(pagination: IPagination, details?: IFilterChangeDetails): FilterStore<T>;
+    removePagination(details?: IFilterChangeDetails): FilterStore<T>;
+    changeSort(sort: ISort<T>, details?: IFilterChangeDetails): FilterStore<T>;
+    removeSort(details?: IFilterChangeDetails): FilterStore<T>;
+    toggleSortDirection(details: IFilterChangeDetails): FilterStore<T>;
+    updateState(updates: Partial<IFilterState<T>>, details?: IFilterChangeDetails): FilterStore<T>;
+    reset(): FilterStore<T>;
+    resetFilter(details?: IFilterChangeDetails): FilterStore<T>;
+    resetQuickSearch(details?: IFilterChangeDetails): FilterStore<T>;
+    resetPagination(details?: IFilterChangeDetails): FilterStore<T>;
+    resetSort(details?: IFilterChangeDetails): FilterStore<T>;
+    private isPaginationEqualToDefault;
+    private isSortEqualToDefault;
+    extractFilter(): IFilterState<T>;
+    countFilterItems(): number;
+    hasFilter(): boolean;
+    hasQuickSearch(): boolean;
+    hasPagination(): boolean;
+    hasSort(): boolean;
+    isEmpty(): boolean;
+    converToQueryParam: (base: string) => string;
+    build(): IFilterState<T>;
+}
+export default FilterStore;
+export declare function createFilterStore<T>(filterState: IFilterState<T>, defaultFilter?: IFilterState<T>): FilterStore<T>;

package/dist/types/data-view/helpers.d.ts

@@ -1,6 +1,12 @@
-import { GridColDef, GridValidRowModel } from '@mui/x-data-grid';
-import { ITableColDef } from './types';
-export interface IGenerateColumnsOptions {
-    extendColDefs?: GridColDef[];
-}
-export declare const generateColumns: <T extends GridValidRowModel>(cols: ITableColDef<T>, options?: IGenerateColumnsOptions) => GridColDef[];
+import { IFilterConfig, IFilterConfigs } from './types';
+export declare const filterMenuClasses: {
+    list: string;
+    item: string;
+};
+export declare const convertFormDataToJson: <TModel>(form: FormData) => Partial<TModel>;
+export declare const getFieldsMatches: <T>(fields?: IFilterConfigs<T> | undefined, keyword?: string) => IFilterConfigs<T>;
+export declare const getFieldsValidation: <T>(fields?: IFilterConfigs<T> | undefined) => IFilterConfigs<T>;
+export declare const filterFieldValidated: <T>(value: string, fieldKey: keyof T, filterField?: IFilterConfig) => {
+    error: boolean;
+    message?: string;
+};

package/dist/types/data-view/index.d.ts

@@ -1,6 +1,9 @@
-import createDataView from './create.data-view';
 export * from './types';
-declare class DinoDataViewBase {
-    createDataView: typeof createDataView;
-}
-export declare const DinoDataView: DinoDataViewBase;
+export { EViewMode } from './view-mode.types';
+export * from './create.pagination-bar';
+export * from './filter-store';
+export * from './key-converter';
+export * from './convert-filter-to-graphql';
+export * from './create.view-mode';
+export type { IViewModeProps } from './view-mode.units';
+export * from './dino';

package/dist/types/data-view/key-converter.d.ts

@@ -0,0 +1,13 @@
+import { SingleOrArray } from './types';
+export interface IKeyConverterDef<Q> {
+    field?: keyof Q;
+    deep?: string;
+    prefix?: string;
+    suffix?: string;
+    custom?: (value: string) => string;
+}
+export type IKeyConverterModel<T, Q> = {
+    [key in keyof T]?: SingleOrArray<IKeyConverterDef<Q>>;
+};
+export declare const createKeyConverter: <T, Q>(params: IKeyConverterModel<T, Q>) => IKeyConverterModel<T, Q>;
+export declare const getKeyConverter: <T, Q>(key: keyof T, converter: IKeyConverterModel<T, Q>) => IKeyConverterDef<Q>[];

package/dist/types/data-view/query-param-url.d.ts

@@ -0,0 +1,26 @@
+import { IFilterState } from './types';
+import { EViewMode } from './view-mode.types';
+export interface IViewDataQueryParams {
+    filter?: string;
+    sk?: string;
+    mode?: string;
+}
+export interface IViewDataHandlerDef<T> {
+    filter?: IFilterState<T>;
+    seedKey?: string;
+    defaultFilter?: IFilterState<T>;
+    defaultSeedKey?: string;
+    defaultValue?: string;
+    viewMode?: EViewMode;
+    defaultViewMode?: EViewMode;
+}
+export type IViewDataHandlerParams<T, K extends keyof IViewDataHandlerDef<T> = keyof IViewDataHandlerDef<T>> = Pick<IViewDataHandlerDef<T>, K>;
+export declare const syncQueryToURL: <T>(params: IViewDataHandlerParams<T, "filter" | "defaultFilter" | "seedKey">) => void;
+export declare const getQueryFromURL: <T>(params: IViewDataHandlerParams<T, "defaultFilter" | "defaultSeedKey">) => {
+    filter: IFilterState<T>;
+    seedKey: string;
+} | null;
+export declare const getSeedKeyFromURL: <T>(params: IViewDataHandlerParams<T, "defaultSeedKey">) => string;
+export declare const syncViewModeToURL: <T>(params: IViewDataHandlerParams<T, "viewMode" | "defaultViewMode">) => void;
+export declare const getViewModeFromURL: <T>(params: IViewDataHandlerParams<T, "defaultViewMode">) => EViewMode | undefined;
+export declare const converFilterToQueryParam: <T>(filterState?: IFilterState<T> | undefined) => string;

package/dist/types/data-view/scroll-tracking.d.ts

@@ -0,0 +1,10 @@
+import { FC } from 'react';
+export interface IScrollTrackingData {
+    isScrolled: boolean;
+}
+export declare const useScrollTracking: () => IScrollTrackingData;
+export interface IScrollTrackingProps {
+    onChange: (data: IScrollTrackingData) => void;
+}
+declare const ScrollTracking: FC<IScrollTrackingProps>;
+export default ScrollTracking;

package/dist/types/data-view/types.d.ts

@@ -1,24 +1,206 @@
-import { GridColDef, GridRowIdGetter, GridValidRowModel } from '@mui/x-data-grid';
-export declare enum EDataViewMode {
-    Table = "Table",
-    Grid = "Grid"
+import type { ReactNode } from 'react';
+import type { ButtonProps } from '@mui/material';
+import type { IFilterNotesProps } from './ui.units';
+export type SingleOrArray<T> = T | T[];
+export type IRelativePosition = 'above' | 'below' | 'left' | 'right';
+export type IPositionElementDef = {
+    [key in IRelativePosition]?: ReactNode;
+};
+export type IPositionElement<K extends IRelativePosition = IRelativePosition> = Pick<IPositionElementDef, K>;
+export declare enum EViewStatus {
+    Loading = "Loading",
+    Loaded = "Loaded",
+    Error = "Error"
+}
+export type IFilterArea = 'input' | 'filterButton' | 'sortButton';
+export type IFilterReason = 'field' | 'quickSearch' | 'pagination' | 'sort';
+export type IFilterAction = 'add' | 'remove' | 'change' | 'reset';
+export type IFilterType = 'string' | 'select' | 'select-multi' | 'date' | 'date-range';
+export type IFilterLogic = 'and' | 'or';
+export type IFilterDateLogic = 'equals' | 'before' | 'after';
+export type IFilterDateRangeLogic = 'between' | 'not-between';
+export interface IItemBase {
+    value: string;
+    label?: string;
+}
+export interface IValidationResult {
+    hasError: boolean;
+    message?: string;
+}
+export declare enum EFieldMatch {
+    AlwaysVisible = "AlwaysVisible",
+    MatchOnly = "MatchOnly",
+    LinkYoutube = "LinkYoutube",
+    Link = "Link",
+    Guid = "Guid"
+}
+export interface IFieldMatchDef {
+    rule: EFieldMatch;
+}
+export interface IFieldMatchMatchOnly extends IFieldMatchDef {
+    rule: EFieldMatch.MatchOnly;
+    match: (value: string) => boolean;
+}
+export interface IFieldMatchBasic extends IFieldMatchDef {
+    rule: EFieldMatch.AlwaysVisible | EFieldMatch.LinkYoutube | EFieldMatch.Link | EFieldMatch.Guid;
+}
+export type IFieldMatchConfig = IFieldMatchMatchOnly | IFieldMatchBasic;
+export type IFieldMatchConfigs = {
+    rules: SingleOrArray<IFieldMatchConfig>;
+    notes?: IFilterNotesProps;
+};
+export declare enum EFieldValidate {
+    Required = "Required",
+    LinkYoutube = "LinkYoutube",
+    Link = "Link",
+    Custom = "Custom"
+}
+export interface IFieldValidateDef {
+    rule: EFieldValidate;
+}
+export interface IFieldValidateCustom extends IFieldValidateDef {
+    rule: EFieldValidate.Custom;
+    validator: (value: string) => boolean;
+}
+export interface IFieldValidateBasic extends IFieldValidateDef {
+    rule: EFieldValidate.Required | EFieldValidate.Link | EFieldValidate.LinkYoutube;
 }
-export type ITableColDef<T extends GridValidRowModel> = {
-    [key in keyof T]?: Omit<GridColDef, 'field'>;
+export type IFieldValidateConfig = IFieldValidateCustom | IFieldValidateBasic;
+export type IFieldValidateConfigs = {
+    rules: SingleOrArray<IFieldValidateConfig>;
+    notes?: IFilterNotesProps;
 };
-export interface ITableConfigs<T extends GridValidRowModel> {
-    getRowId: GridRowIdGetter<T>;
-    columns: ITableColDef<T>;
+export interface IPagination {
+    page?: number;
+    pageSize?: number;
+}
+export interface ISort<T> {
+    field: keyof T;
+    direction: 'asc' | 'desc';
+}
+export interface IQuickSearchConfig<T> {
+    fields: SingleOrArray<keyof T>;
+    label?: string;
+    notes?: IFilterNotesProps;
+    logic?: IFilterLogic;
+}
+interface IFilterDef {
+    /** Display label for the filter field */
+    label?: string;
+    /**
+     * Filter input type
+     * @default 'string'
+     */
+    type?: IFilterType;
+    /**
+     * Configuration for quick search matching behavior.
+     * Determines how the quick search should match against field values.
+     */
+    quickSearchMatch?: IFieldMatchConfigs;
+    /**
+     * Notes for the filter field.
+     */
+    notes?: IFilterNotesProps;
+    /**
+     * Validation rules for the filter menu input.
+     * @default
+     * { rules: [{ rule: EFieldValidate.Required }] }
+     */
+    validation?: IFieldValidateConfigs;
+    /**
+     * Notes to display in the filter menu.
+     * Useful for providing additional context or instructions.
+     */
+    filterable?: boolean;
+    /**
+     * Whether the filter field is sortable.
+     * If true, the field can be used for sorting in the filter menu.
+     * @default true
+     */
+    sortable?: boolean;
+}
+export interface IFilterBasicDef extends IFilterDef {
+    type?: 'string';
+}
+export interface IFilterSelectDef extends IFilterDef {
+    type: 'select' | 'select-multi';
+    options: {
+        value: string;
+        label?: string;
+    }[];
+}
+export interface IFilterDateDef extends IFilterDef {
+    type: 'date' | 'date-range';
+    /**
+     * Date format for display and validation
+     * @default 'YYYY-MM-DD'
+     */
+    format?: string;
+    /**
+     * Minimum date allowed
+     */
+    minDate?: string | Date;
+    /**
+     * Maximum date allowed
+     */
+    maxDate?: string | Date;
+}
+export type IFilterConfig = IFilterBasicDef | IFilterSelectDef | IFilterDateDef;
+export type IFilterConfigs<T> = {
+    [key in keyof T]?: IFilterConfig;
+};
+export interface IFilterItem {
+    type?: IFilterType;
+    value?: string | number | boolean;
+    label?: string;
+    logic?: IFilterLogic;
+    dateLogic?: IFilterDateLogic;
+    dateRangeLogic?: IFilterDateRangeLogic;
+    startDate?: string;
+    endDate?: string;
+}
+export type IFilterMap<T> = {
+    [key in keyof T]?: IFilterItem[];
+};
+export interface IFilterChangeDetails {
+    reason?: IFilterReason;
+    area?: IFilterArea;
+    action?: IFilterAction;
+    isChanged?: boolean;
+}
+export interface IFilterState<T> {
+    filter?: IFilterMap<T>;
+    quickSearch?: SingleOrArray<string>;
+    quickSearchLogic?: IFilterLogic;
+    pagination?: IPagination;
+    sort?: ISort<T>;
+    details?: IFilterChangeDetails;
+}
+export type IFilterStateChangeHandler<T> = (filterState: IFilterState<T>) => void;
+export interface ISortButtonConfigs {
+    text?: string;
+    icon?: ReactNode;
+    wrapProps?: ButtonProps;
 }
-export interface IDataViewInitial {
-    mode?: EDataViewMode;
+export interface IFilterBarConfigBase {
+    /** @default false */
+    enableSticky?: boolean;
+    /** @default false */
+    enableSort?: boolean;
 }
-export interface IDataViewData<T extends GridValidRowModel> {
-    items?: T[];
-    rowTotal?: number;
+export interface IFilterBarConfigs<T> extends IFilterBarConfigBase {
+    id?: string;
+    placeholder?: string;
+    notes?: IFilterNotesProps;
+    fields?: IFilterConfigs<T>;
+    quickSearch?: IQuickSearchConfig<T>;
+    defaultValue?: IFilterState<T>;
+    sortButton?: ISortButtonConfigs;
 }
-export interface IDataViewPropsBase<T extends GridValidRowModel> {
-    data?: IDataViewData<T>;
-    filter?: any;
-    onFilterChange?: (filter: any) => void;
+export interface IViewData<T> {
+    items: T[];
+    totalItems?: number;
+    hasPreviousPage?: boolean;
+    hasNextPage?: boolean;
 }
+export {};

package/dist/types/data-view/ui.units.d.ts

@@ -1,11 +1,77 @@
-import { FC, ReactNode } from 'react';
-import { SvgIconProps } from '@mui/material';
-import { EDataViewMode } from './types';
-export interface ISwitchDataViewWithModeProps {
-    mode?: EDataViewMode;
-    Table: ReactNode;
-    Grid: ReactNode;
-}
-export declare const SwitchDataViewWithMode: FC<ISwitchDataViewWithModeProps>;
-export declare const ToggleButtons: FC;
-export declare const NoDataIcon: FC<SvgIconProps>;
+import React, { FC, ReactNode } from 'react';
+import { ButtonProps, InputBaseProps } from '@mui/material';
+import { IconButtonProps } from '@mui/material';
+import { IFilterLogic, IFilterDateLogic, IFilterDateRangeLogic, IFilterSelectDef, IValidationResult, IFilterDateDef, IFilterBasicDef } from './types';
+export declare const mapSortConfigs: Record<'asc' | 'desc', {
+    title: string;
+    icon: ReactNode;
+}>;
+export interface IFilterLogicToggleProps {
+    value?: IFilterLogic;
+    onChange?: (event: React.MouseEvent<HTMLElement>, value: IFilterLogic) => void;
+}
+export declare const FilterLogicToggle: FC<IFilterLogicToggleProps>;
+export interface IDateLogicToggleProps {
+    value?: IFilterDateLogic;
+    onChange?: (event: React.MouseEvent<HTMLElement>, value: IFilterDateLogic) => void;
+}
+export declare const DateLogicToggle: FC<IDateLogicToggleProps>;
+export interface IDateRangeLogicToggleProps {
+    value?: IFilterDateRangeLogic;
+    onChange?: (event: React.MouseEvent<HTMLElement>, value: IFilterDateRangeLogic) => void;
+}
+export declare const DateRangeLogicToggle: FC<IDateRangeLogicToggleProps>;
+export interface IFilterNotesProps {
+    title?: string;
+    items?: string[];
+    disabledSize?: boolean;
+    renderContent?: () => ReactNode;
+}
+export declare const FilterNotes: FC<IFilterNotesProps>;
+export declare const FilterInput: React.ForwardRefExoticComponent<Omit<InputBaseProps, "ref"> & React.RefAttributes<HTMLInputElement>>;
+interface IFilterInputAdornmentProps {
+    notes?: IFilterNotesProps;
+    keyword?: string;
+    onClear: IconButtonProps['onClick'];
+    onEnterSearch: ButtonProps['onClick'];
+}
+export declare const FilterInputAdornment: FC<IFilterInputAdornmentProps>;
+export interface IButtonClearProps {
+    visibled?: boolean;
+    onClick: IconButtonProps['onClick'];
+}
+export declare const ButtonClear: FC<IButtonClearProps>;
+export declare const ClearAllButton: React.ForwardRefExoticComponent<Omit<ButtonProps<"button", {}>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export declare const FilterButton: React.ForwardRefExoticComponent<Omit<IconButtonProps<"button", {}>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export declare const SortIconButton: React.ForwardRefExoticComponent<Omit<IconButtonProps<"button", {}>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export declare const SortButton: FC<ButtonProps>;
+export declare const PanelNotFound: FC<{
+    area?: string;
+}>;
+interface IMenuWithTypeBaseProps {
+    name: string;
+    validationResult?: IValidationResult;
+}
+interface IMenuWithTypeStringProps extends IMenuWithTypeBaseProps {
+    fieldConfig?: IFilterBasicDef;
+}
+export declare const MenuWithTypeString: FC<IMenuWithTypeStringProps>;
+export interface IMenuWithTypeSelectProps extends IMenuWithTypeBaseProps {
+    fieldConfig?: IFilterSelectDef;
+    onChange?: (event: React.ChangeEvent<HTMLInputElement>) => void;
+}
+export declare const MenuWithTypeSelect: FC<IMenuWithTypeSelectProps>;
+export interface IMenuWithTypeSelectMultiProps extends IMenuWithTypeBaseProps {
+    fieldConfig?: IFilterSelectDef;
+    onChange?: (event: React.SyntheticEvent, checked: boolean) => void;
+}
+export declare const MenuWithTypeSelectMulti: FC<IMenuWithTypeSelectMultiProps>;
+export interface IMenuWithTypeDateProps extends IMenuWithTypeBaseProps {
+    fieldConfig?: IFilterDateDef;
+}
+export declare const MenuWithTypeDate: FC<IMenuWithTypeDateProps>;
+export interface IMenuWithTypeDateRangeProps extends IMenuWithTypeBaseProps {
+    fieldConfig?: IFilterDateDef;
+}
+export declare const MenuWithTypeDateRange: FC<IMenuWithTypeDateRangeProps>;
+export {};

package/dist/types/data-view/view-mode.content.d.ts

@@ -0,0 +1,17 @@
+import { ComponentType } from 'react';
+import { DataGridProps } from '@mui/x-data-grid';
+import { IViewModeListConfig, IViewModeModuleConfig, IViewModeValidModel } from './view-mode.types';
+interface IViewModeModuleProps<T extends IViewModeValidModel> {
+    data: T[];
+    configs: IViewModeModuleConfig<T>;
+}
+export declare function createViewModeModule<T extends IViewModeValidModel>(): ComponentType<IViewModeModuleProps<T>>;
+export interface IViewModeListProps<T extends IViewModeValidModel> {
+    value: T[];
+    configs: IViewModeListConfig<T>;
+    slots?: {
+        dataGridProps?: Partial<Omit<DataGridProps, 'columns' | 'rows'>>;
+    };
+}
+export declare function createViewModeList<T extends IViewModeValidModel>(): ComponentType<IViewModeListProps<T>>;
+export {};

package/dist/types/data-view/view-mode.types.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="react" />
+import { BoxProps, Breakpoint, GridProps } from '@mui/material';
+import { GridColDef, GridRowIdGetter } from '@mui/x-data-grid';
+export type IViewModeValidModel = {
+    [key: string | symbol]: any;
+};
+export declare enum EViewMode {
+    List = "list",
+    Module = "module"
+}
+export type IResponsiveSize = {
+    [key in Breakpoint]?: number;
+};
+export interface IViewModeElementProps {
+    mode?: EViewMode;
+}
+export interface IViewModeItemProps<T> {
+    data: T;
+    index: number;
+}
+export type GridColsDef<T extends IViewModeValidModel> = {
+    [key in keyof T]?: Omit<GridColDef<T>, 'field'>;
+};
+export interface IViewModeListConfig<T extends IViewModeValidModel> {
+    getRowId?: GridRowIdGetter<T>;
+    columns?: GridColsDef<T>;
+    rowHeight?: number;
+}
+export type IViewModeModuleConfig<T> = {
+    getElementId?: (value: T) => string | number;
+    Element?: React.ComponentType<IViewModeItemProps<T>>;
+    elementWrapProps?: Omit<GridProps, 'size' | 'children'>;
+    elementWrapPropsGetter?: (props: IViewModeItemProps<T>) => Omit<GridProps, 'size' | 'children'>;
+    spacing?: GridProps['spacing'];
+    size?: IResponsiveSize;
+    wrapProps?: Omit<GridProps, 'size' | 'children'>;
+};
+export interface IViewModeConfigs<T extends IViewModeValidModel> {
+    list?: IViewModeListConfig<T>;
+    module?: IViewModeModuleConfig<T>;
+    NoData?: React.ComponentType<IViewModeElementProps>;
+    ErrorData?: React.ComponentType<IViewModeElementProps>;
+    Skeleton?: React.ComponentType<IViewModeElementProps>;
+    wrapProps?: BoxProps;
+    defaultValue?: EViewMode;
+}

package/dist/types/data-view/view-mode.units.d.ts

@@ -0,0 +1,18 @@
+import { FC } from 'react';
+import { BoxProps } from '@mui/material';
+import { EViewMode, IResponsiveSize, IViewModeElementProps } from './view-mode.types';
+export declare const defaultSize: IResponsiveSize;
+export declare const defaultViewMode = EViewMode.List;
+export interface IViewModeProps {
+    value?: EViewMode;
+    onChange?: (value: EViewMode) => void;
+}
+export declare const ViewModeButtons: FC<IViewModeProps>;
+export declare const createViewModeButtons: () => FC<IViewModeProps>;
+export declare const LoadingOverlay: FC<BoxProps>;
+export declare const LoadingError: FC<{
+    error: string;
+}>;
+export declare const LoadingNoData: FC<IViewModeElementProps>;
+export declare const LoadingWaiting: FC;
+export declare const LoadingMissingConfig: React.FC;

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

@@ -1,14 +1,20 @@
 import React, { ComponentType, PropsWithChildren } from 'react';
-import { SxProps, Theme } from '@mui/material';
+import { BoxProps } from '@mui/material';
 import { IFormBaseContext } from './types';
 import FormValidator, { IPartialError } from './validator';
-export interface IFormBaseParams<T> {
-    validate?: FormValidator<Partial<T>>;
+export interface IFormBaseSlots {
+    formProps?: Omit<BoxProps, 'ref' | 'onSubmit' | 'component'>;
 }
-export interface IFormBaseProps<T> extends PropsWithChildren {
-    sx?: SxProps<Theme>;
+export interface IFormBaseConfigs<T> {
     validate?: FormValidator<Partial<T>>;
+    dataTrimed?: boolean;
+    dataGetter?: (data: Partial<T>) => Partial<T>;
+}
+export interface IFormBaseParams<T> extends IFormBaseConfigs<T> {
+}
+export interface IFormBaseProps<T> extends PropsWithChildren, IFormBaseConfigs<T> {
     onSubmit: (data: Partial<T>, e: React.FormEvent<HTMLFormElement>) => Promise<void>;
+    slots?: IFormBaseSlots;
 }
 export interface IFormBaseState<T> {
     modelState?: Partial<T>;

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

@@ -2,6 +2,7 @@ import React, { ComponentType } from 'react';
 import { BoxProps, RegularBreakpoints, SxProps, Theme } from '@mui/material';
 import { IFormBase, IFormInputBase } from './types';
 import FormValidator from './validator';
+import { IFormBaseSlots } from './create.form-base';
 export interface IFormGridLayoutConfig<T> {
     key: keyof T;
     label?: string;
@@ -10,20 +11,22 @@ export interface IFormGridLayoutConfig<T> {
     defaultValue?: any;
     inputElement?: React.ComponentType<IFormInputBase<T>>;
 }
-export type ISubmitMappingEvent<T> = (value: Partial<T>, oldValue?: T) => Partial<T>;
+export type IPreSubmitEvent<T> = (value: Partial<T>, oldValue?: T) => Partial<T>;
 export interface IFormGridLayoutSlots<T> {
     action?: React.ComponentType<IFormBase<T>>;
     actionBefore?: JSX.Element;
     contentBefore?: JSX.Element;
     contentAfter?: JSX.Element;
-    inputVisibility?: Partial<Record<keyof T, boolean>>;
-    inputDisabled?: Partial<Record<keyof T, boolean>>;
+    hiddenFields?: Partial<Record<keyof T, boolean>>;
+    getHiddenFields?: (value: Partial<T>) => Partial<Record<keyof T, boolean>>;
+    disabledFields?: Partial<Record<keyof T, boolean>>;
     closeState?: {
         Success?: boolean;
         Fail?: boolean;
     };
     contentProps?: BoxProps;
-    submitMapping?: ISubmitMappingEvent<T>;
+    preSubmit?: IPreSubmitEvent<T>;
+    formSlots?: IFormBaseSlots;
 }
 export interface IFormGridLayoutParams<T> extends IFormGridLayoutSlots<T> {
     configs: IFormGridLayoutConfig<T>[];

package/dist/types/index.d.ts

@@ -1,11 +1,10 @@
 /// <reference path="./@types/global.d.ts" />
+export * from './utils';
 export * from './api-context';
 export * from './components';
-export * from './data-view';
-export * from './filter-bar';
 export * from './form';
 export * from './hooks';
 export * from './redux';
 export * from './table';
 export * from './table-grid';
-export * from './utils';
+export * from './data-view';

package/dist/types/{filter-bar → table-grid/filter-bar}/types.d.ts

@@ -20,20 +20,20 @@ interface ISearchMatchQuickly extends ISearchMatchBase {
     rule: ESearchMatch.AlwaysVisible | ESearchMatch.LinkYoutube | ESearchMatch.Link | ESearchMatch.Guid;
 }
 type IFieldSearchMatch = ISearchMatchMatchOnly | ISearchMatchQuickly;
-export declare enum EFieldValidate {
+export declare enum EMenuValidate {
     LinkYoutube = "LinkYoutube",
     Link = "Link",
     Custom = "Custom"
 }
 interface IFieldValidateBase {
-    rule: EFieldValidate;
+    rule: EMenuValidate;
 }
 interface IFieldValidateCustom extends IFieldValidateBase {
-    rule: EFieldValidate.Custom;
+    rule: EMenuValidate.Custom;
     custom: (value: string) => boolean;
 }
 interface IFieldValidateQuickly extends IFieldValidateBase {
-    rule: EFieldValidate.Link | EFieldValidate.LinkYoutube;
+    rule: EMenuValidate.Link | EMenuValidate.LinkYoutube;
 }
 type IFieldValidate = IFieldValidateQuickly | IFieldValidateCustom;
 export interface IQuickSearchDef<T> {

package/dist/types/table-grid/index.d.ts

@@ -1,3 +1,4 @@
 export { default as DinoTableGrid } from './dino';
 export * from './types';
 export * from './item-actions';
+export { EMenuValidate, ESearchMatch } from './filter-bar/types';

package/dist/types/table-grid/types.d.ts

@@ -1,7 +1,7 @@
 import { ComponentType, ReactNode } from 'react';
 import { GridProps, RegularBreakpoints } from '@mui/material';
 import { IToolbarPannelProps } from './toolbar-pannel';
-import { IFilterBarConfigs, IFilterState } from '../filter-bar';
+import { IFilterBarConfigs, IFilterState } from './filter-bar';
 import { TableGridItemActionsConfig, ITableGridItemActionsBaseProps } from './item-actions';
 export interface ITableGridItemProps<T = any> {
     value: T;