@uxf/data-grid 11.74.0 → 11.74.2

package/types/components.d.ts

@@ -0,0 +1,32 @@
+import { ComponentType, FunctionComponent } from "react";
+import { Column, Filter } from "./schema";
+export interface ActionCellProps<R> {
+    row: R;
+    reload: () => Promise<any>;
+}
+export type ActionCellComponent<R> = FunctionComponent<ActionCellProps<R>>;
+export type DataGridActionCell<Row> = {
+    width: number;
+    Component: ActionCellComponent<Row>;
+};
+export interface BodyCellProps<Value> {
+    value: Value;
+    column: Column<any, any>;
+    /** @deprecated will be removed */
+    row: any;
+    reload: () => Promise<any>;
+}
+export type BodyCellComponent<Value> = ComponentType<BodyCellProps<Value>>;
+export type BodyCellComponents = {
+    [key: string]: BodyCellComponent<any>;
+    default: BodyCellComponent<any>;
+};
+export interface FilterProps<StateValue> {
+    gridName?: string;
+    filter: Filter;
+    value: StateValue;
+    op?: string;
+    onChange: (value: StateValue | undefined, op?: string) => void;
+    onClear: () => void;
+}
+export type ChangeTabFilterBehavior = "sharedFiltersAndSearch" | "sharedFiltersAndSearchAndSort" | "filtersPerTab";

package/types/components.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/types/core.d.ts

@@ -0,0 +1,20 @@
+import { Nullish } from "@uxf/core/types";
+import { Request, Response, ResultItem } from "./api";
+import { BaseGridType } from "./schema";
+export type KeyExtractor = (row: ResultItem) => number;
+export type CsvDownloadGetUrl = (request: Request) => string;
+export type Loader = (gridName: string | undefined, request: Request, encodedRequest: string) => Promise<Response>;
+export type CallbackRef = {
+    reload: () => Promise<any>;
+};
+export type RowAccent = "success" | "warning" | "error" | "primary" | "secondary" | Nullish;
+export type Config<C extends BaseGridType["columns"]> = {
+    columns: Partial<{
+        [columnName in keyof C]: {
+            hidden?: boolean;
+            maxWidth?: number;
+            minWidth?: number;
+            width?: number;
+        };
+    }>;
+};

package/types/core.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/types/data-grid-props.d.ts

@@ -0,0 +1,34 @@
+import { Nullish } from "@uxf/core/types";
+import { FilterHandlers } from "../filter-handler";
+import { SelectedRowsToolbarActionsComponent } from "../selected-rows-toolbar";
+import { NoRowsFallbackComponent } from "../table/no-rows-fallback";
+import { DataGridTableProps } from "../table/types";
+import { DataGridToolbarCustomsProps } from "../toolbar-customs";
+import { DataGridControl } from "../use-data-grid-control";
+import { DataGridFetchingResult } from "../use-data-grid-fetching";
+import { BodyCellComponents, ChangeTabFilterBehavior } from "./components";
+import { CsvDownloadGetUrl, KeyExtractor, RowAccent } from "./core";
+import { BaseGridType, Schema } from "./schema";
+export type DataGridControlProps = DataGridControl;
+export type DataGridDataProps<Row> = DataGridFetchingResult<Row>;
+export type DataGridBaseProps<GridType extends BaseGridType, Row> = {
+    schema: Schema<GridType>;
+    gridName?: string;
+    keyExtractor?: KeyExtractor;
+    getCsvDownloadUrl?: CsvDownloadGetUrl;
+    rowHeight?: number | ((row: Row) => number) | "auto";
+    headerRowHeight?: number;
+    rowAccent?: (row: Row) => RowAccent;
+    rowClassName?: (row: Row) => string | Nullish;
+    className?: string;
+    customActions?: DataGridToolbarCustomsProps["buttons"];
+    actionCell?: DataGridTableProps<Row>["actionCell"];
+    bodyCells?: BodyCellComponents;
+    filterHandlers?: FilterHandlers;
+    NoRowsFallback?: NoRowsFallbackComponent;
+    SelectedRowsToolbarActions?: SelectedRowsToolbarActionsComponent;
+    isRowSelectable?: boolean;
+    isDebug?: boolean;
+    changeTabFilterBehavior?: ChangeTabFilterBehavior;
+};
+export type DataGridProps<GridType extends BaseGridType, Row> = DataGridBaseProps<GridType, Row> & DataGridDataProps<Row> & DataGridControlProps;

package/types/data-grid-props.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/types/index.d.ts

@@ -0,0 +1,6 @@
+export type * from "./api";
+export type * from "./components";
+export type * from "./core";
+export type * from "./data-grid-props";
+export type * from "./schema";
+export type * from "./state";

package/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/types/schema.d.ts

@@ -0,0 +1,56 @@
+import { ReactElement } from "react";
+export interface DataGridSort {
+    name: string;
+    dir: "asc" | "desc";
+}
+export interface Tab {
+    name: string;
+    label: string;
+    icon?: string;
+    s?: DataGridSort;
+}
+export type BaseGridType = {
+    columns: any;
+    filters: any;
+};
+export type ColumnWidthUnit = number | `${number}fr`;
+export type ColumnConfig = {
+    isHidden?: boolean;
+    width?: ColumnWidthUnit;
+    minWidth?: number;
+};
+export type Column<Name, Type> = {
+    name: Name;
+    label: string | ReactElement;
+    type: Type;
+    sort?: boolean;
+    hidden?: boolean;
+    config?: ColumnConfig;
+};
+export type Columns<C extends BaseGridType["columns"]> = {
+    [K in keyof C]: Column<K, C[K]>;
+}[keyof C];
+export type FilterConfig = {
+    placeholder?: string;
+};
+export interface FilterOption {
+    id: string | number;
+    label: string;
+}
+export interface Filter {
+    name: string;
+    label: string;
+    type: string;
+    options?: FilterOption[];
+    autocomplete?: string | null;
+    config?: FilterConfig;
+}
+export interface Schema<GridType extends BaseGridType> {
+    name: string;
+    columns: Columns<GridType["columns"]>[];
+    filters: Filter[];
+    tabs?: Tab[];
+    s: DataGridSort;
+    perPage: number;
+    fullText?: boolean;
+}

package/types/schema.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/types/state.d.ts

@@ -0,0 +1,25 @@
+import { RequestFilter } from "./api";
+import { BaseGridType, ColumnConfig, DataGridSort, FilterConfig } from "./schema";
+export type GridRequest = {
+    f: RequestFilter[];
+    s: DataGridSort | null;
+    page: number;
+    perPage: number;
+    search: string;
+    tab: string | null;
+};
+export interface DataGridUserConfig<GridType extends BaseGridType> {
+    columns?: Partial<Record<keyof GridType["columns"], ColumnConfig>>;
+    perPage?: number;
+}
+export interface DataGridFrontendConfig<GridType extends BaseGridType> extends DataGridUserConfig<GridType> {
+    filters?: Partial<Record<keyof GridType["filters"], FilterConfig>>;
+}
+export interface DataGridState<GridType extends BaseGridType> {
+    request: GridRequest;
+    selectedRows?: any[];
+    userConfig: DataGridUserConfig<GridType>;
+    tabRequests: {
+        [tab: string]: GridRequest;
+    };
+}

package/types/state.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/types/user-config-storage-adapter.d.ts

@@ -0,0 +1,8 @@
+import { DataGridControl } from "../use-data-grid-control";
+import { Action } from "../use-data-grid-control/action";
+import { Middleware } from "../use-data-grid-control/use-middleware-reducer";
+import { DataGridState } from "./state";
+export type UserConfigStorageAdapter = {
+    middleware: Middleware<DataGridState<any>, Action>;
+    useUserConfig: (actions: DataGridControl["actions"]) => void;
+};

package/types/user-config-storage-adapter.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/use-data-grid-control/action.d.ts

@@ -0,0 +1,47 @@
+import { type ChangeTabFilterBehavior, Tab } from "../types";
+export type Action = {
+    type: "CHANGE_PAGE";
+    page: number;
+} | {
+    type: "CHANGE_PER_PAGE";
+    perPage: number;
+} | {
+    type: "FILTER";
+    name: string;
+    value: any;
+    op: any;
+} | {
+    type: "FILTER_CLEAR";
+    name: string;
+} | {
+    type: "FILTER_CLEAR_ALL";
+} | {
+    type: "SORT";
+    columnName?: string;
+    direction?: string | null;
+} | {
+    type: "SORT_CLEAR";
+} | {
+    type: "FULLTEXT";
+    search: string;
+} | {
+    type: "CHANGE_TAB";
+    tab: Tab;
+    filterBehavior: ChangeTabFilterBehavior;
+} | {
+    type: "SET_SELECTED_ROWS";
+    rows: any;
+} | {
+    type: "HIDE_COLUMN";
+    name: string;
+} | {
+    type: "SHOW_COLUMN";
+    name: string;
+} | {
+    type: "UPDATE_USER_CONFIG";
+    userConfig: any;
+} | {
+    type: "REINITIALIZE_USER_CONFIG";
+    userConfig: any;
+};
+export declare const ACTIONS_CHANGING_USER_CONFIG: Array<Action["type"]>;

package/use-data-grid-control/action.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ACTIONS_CHANGING_USER_CONFIG = void 0;
+exports.ACTIONS_CHANGING_USER_CONFIG = [
+    "CHANGE_PER_PAGE",
+    "HIDE_COLUMN",
+    "SHOW_COLUMN",
+    "UPDATE_USER_CONFIG",
+];

package/use-data-grid-control/actions-factory.d.ts

@@ -0,0 +1,21 @@
+import { Dispatch } from "react";
+import type { ChangeTabFilterBehavior } from "../types";
+import { Tab } from "../types/schema";
+import { DataGridUserConfig } from "../types/state";
+import { Action } from "./action";
+export declare function createActions(dispatch: Dispatch<Action>): {
+    changePage: (page: number) => void;
+    changePerPage: (perPage: number) => void;
+    filter: (name: string, value: any, op?: string) => void;
+    filterClear: (name: string) => void;
+    filterClearAll: () => void;
+    sort: (columnName: string, direction?: string | null) => void;
+    sortClear: () => void;
+    search: (search: string) => void;
+    changeTab: (tab: Tab, filterBehavior: ChangeTabFilterBehavior) => void;
+    setSelectedRows: (rows: any[]) => void;
+    hideColumn: (name: string) => void;
+    showColumn: (name: string) => void;
+    updateUserConfig: (userConfig: DataGridUserConfig<any>) => void;
+    reinitializeUserConfig: (userConfig: DataGridUserConfig<any>) => void;
+};

package/use-data-grid-control/actions-factory.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createActions = createActions;
+function createActions(dispatch) {
+    return {
+        changePage: (page) => dispatch({ type: "CHANGE_PAGE", page }),
+        changePerPage: (perPage) => dispatch({ type: "CHANGE_PER_PAGE", perPage }),
+        filter: (name, value, op) => dispatch({ type: "FILTER", name, value, op }),
+        filterClear: (name) => dispatch({ type: "FILTER_CLEAR", name }),
+        filterClearAll: () => dispatch({ type: "FILTER_CLEAR_ALL" }),
+        sort: (columnName, direction = null) => dispatch({ type: "SORT", columnName, direction }),
+        sortClear: () => dispatch({ type: "SORT_CLEAR" }),
+        search: (search) => dispatch({ type: "FULLTEXT", search }),
+        changeTab: (tab, filterBehavior) => dispatch({ type: "CHANGE_TAB", tab, filterBehavior }),
+        setSelectedRows: (rows) => dispatch({ type: "SET_SELECTED_ROWS", rows }),
+        hideColumn: (name) => dispatch({ type: "HIDE_COLUMN", name }),
+        showColumn: (name) => dispatch({ type: "SHOW_COLUMN", name }),
+        updateUserConfig: (userConfig) => dispatch({ type: "UPDATE_USER_CONFIG", userConfig }),
+        reinitializeUserConfig: (userConfig) => dispatch({ type: "REINITIALIZE_USER_CONFIG", userConfig }),
+    };
+}

package/use-data-grid-control/index.d.ts

@@ -0,0 +1 @@
+export * from "./use-data-grid-control";

package/use-data-grid-control/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./use-data-grid-control"), exports);

package/use-data-grid-control/use-data-grid-control.d.ts

@@ -0,0 +1,32 @@
+import { Nullish } from "@uxf/core/types";
+import { Request } from "../types/api";
+import { BaseGridType, Schema } from "../types/schema";
+import { DataGridState, DataGridUserConfig } from "../types/state";
+import { Action } from "./action";
+import { Middleware } from "./use-middleware-reducer";
+export interface UseDataGridControlConfig<GridType extends BaseGridType> {
+    schema: Schema<GridType>;
+    initialState?: Request | string | Nullish;
+    initialUserConfig?: DataGridUserConfig<GridType> | Nullish;
+    middleware?: Middleware<DataGridState<any>, Action>;
+}
+export declare function useDataGridControl<T extends BaseGridType>(config: UseDataGridControlConfig<T>): {
+    state: DataGridState<T>;
+    actions: {
+        changePage: (page: number) => void;
+        changePerPage: (perPage: number) => void;
+        filter: (name: string, value: any, op?: string) => void;
+        filterClear: (name: string) => void;
+        filterClearAll: () => void;
+        sort: (columnName: string, direction?: string | null) => void;
+        sortClear: () => void;
+        search: (search: string) => void;
+        changeTab: (tab: import("../types/schema").Tab, filterBehavior: import("..").ChangeTabFilterBehavior) => void;
+        setSelectedRows: (rows: any[]) => void;
+        hideColumn: (name: string) => void;
+        showColumn: (name: string) => void;
+        updateUserConfig: (userConfig: DataGridUserConfig<any>) => void;
+        reinitializeUserConfig: (userConfig: DataGridUserConfig<any>) => void;
+    };
+};
+export type DataGridControl = ReturnType<typeof useDataGridControl>;

package/use-data-grid-control/use-data-grid-control.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDataGridControl = useDataGridControl;
+const react_1 = require("react");
+const reducer_1 = require("../_store/reducer");
+const actions_factory_1 = require("./actions-factory");
+const use_middleware_reducer_1 = require("./use-middleware-reducer");
+function useDataGridControl(config) {
+    const [state, dispatch] = (0, use_middleware_reducer_1.useMiddlewareReducer)(reducer_1.reducer, (0, reducer_1.getInitialState)(config.schema, config.initialState, config.initialUserConfig), config.middleware);
+    const actions = (0, react_1.useMemo)(() => (0, actions_factory_1.createActions)(dispatch), [dispatch]);
+    return { state, actions };
+}

package/use-data-grid-control/use-middleware-reducer.d.ts

@@ -0,0 +1,3 @@
+import { Dispatch, Reducer } from "react";
+export type Middleware<State, Action> = (newState: State, action: Action) => void;
+export declare function useMiddlewareReducer<S, A>(reducer: Reducer<S, A>, initialState: S, middleware?: (state: NoInfer<S>, action: NoInfer<A>) => void): [S, Dispatch<A>];

package/use-data-grid-control/use-middleware-reducer.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMiddlewareReducer = useMiddlewareReducer;
+const react_1 = require("react");
+function useMiddlewareReducer(reducer, initialState, middleware) {
+    const [state, dispatch] = (0, react_1.useReducer)(reducer, initialState);
+    const stateRef = (0, react_1.useRef)(state);
+    stateRef.current = state;
+    const middlewareRef = (0, react_1.useRef)(middleware);
+    middlewareRef.current = middleware;
+    const enhancedDispatch = (0, react_1.useCallback)((action) => {
+        dispatch(action);
+        if (middlewareRef.current) {
+            const newState = reducer(stateRef.current, action);
+            middlewareRef.current(newState, action);
+        }
+    }, [reducer]);
+    return [state, enhancedDispatch];
+}

package/use-data-grid-fetching/index.d.ts

@@ -0,0 +1 @@
+export * from "./use-data-grid-fetching";

package/use-data-grid-fetching/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./use-data-grid-fetching"), exports);

package/use-data-grid-fetching/loader.d.ts

@@ -0,0 +1,2 @@
+import { Loader } from "../types/core";
+export declare const dataGridLoader: Loader;

package/use-data-grid-fetching/loader.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataGridLoader = void 0;
+const _api_1 = require("../_api");
+const dataGridLoader = (gridName, request) => (0, _api_1.dataGridGetResult)(gridName !== null && gridName !== void 0 ? gridName : "", request);
+exports.dataGridLoader = dataGridLoader;

package/use-data-grid-fetching/use-data-grid-fetching.d.ts

@@ -0,0 +1,24 @@
+import { Nullish } from "@uxf/core/types";
+import { Loader } from "../types/core";
+import { Schema } from "../types/schema";
+import { DataGridControl } from "../use-data-grid-control";
+interface Response<Row> {
+    result: Row[];
+    count: number;
+    tabCounts: Record<string, number> | Nullish;
+    totalCount: number;
+}
+export interface DataGridFetchingResult<Row> {
+    isLoading: boolean;
+    error?: any;
+    data: Response<Row> | null;
+    reload: () => Promise<any>;
+}
+export interface UseDataGridFetchingConfig {
+    loader?: Loader;
+    schema: Schema<any>;
+    state: DataGridControl["state"];
+    isWithTabCounts?: true;
+}
+export declare function useDataGridFetching(config: UseDataGridFetchingConfig): DataGridFetchingResult<any>;
+export {};

package/use-data-grid-fetching/use-data-grid-fetching.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDataGridFetching = useDataGridFetching;
+const react_1 = require("react");
+const utils_1 = require("../utils");
+const loader_1 = require("./loader");
+function useDataGridFetching(config) {
+    const { state, loader = loader_1.dataGridLoader } = config;
+    const [isLoading, setIsLoading] = (0, react_1.useState)(false);
+    const [error, setError] = (0, react_1.useState)(null);
+    const [data, setData] = (0, react_1.useState)(null);
+    const stringStateRequest = JSON.stringify(state.request);
+    const reload = (0, react_1.useCallback)(() => {
+        const stateRequest = JSON.parse(stringStateRequest);
+        const request = (0, utils_1.createRequest)(stateRequest, { isWithTabCounts: config.isWithTabCounts });
+        setIsLoading(true);
+        return loader(config.schema.name, request, (0, utils_1.encodeFilter)(request))
+            .then((response) => {
+            setData(response);
+            setError(null);
+            setIsLoading(false);
+        })
+            .catch((e) => {
+            // eslint-disable-next-line no-console
+            console.error(e);
+            setIsLoading(false);
+            setError(e);
+        });
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [stringStateRequest, config.schema]);
+    (0, react_1.useEffect)(() => {
+        reload();
+    }, [reload]);
+    return {
+        data,
+        isLoading,
+        error,
+        reload,
+    };
+}

package/user-config-storage-adapters/local-storage.d.ts

@@ -0,0 +1,3 @@
+import { Schema } from "../types";
+import { UserConfigStorageAdapter } from "../types/user-config-storage-adapter";
+export declare function useUserConfigLocalStorageAdapter(schema: Schema<any>): UserConfigStorageAdapter;

package/user-config-storage-adapters/local-storage.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useUserConfigLocalStorageAdapter = useUserConfigLocalStorageAdapter;
+const react_1 = require("react");
+const action_1 = require("../use-data-grid-control/action");
+const get_config_key_1 = require("../utils/get-config-key");
+const isObject = (value) => typeof value === "function" || (typeof value === "object" && Boolean(value));
+function useUserConfigLocalStorageAdapter(schema) {
+    const configKey = (0, get_config_key_1.getConfigKey)(schema);
+    return (0, react_1.useMemo)(() => ({
+        middleware: (newState, action) => {
+            if (action_1.ACTIONS_CHANGING_USER_CONFIG.includes(action.type)) {
+                window.localStorage.setItem(configKey, JSON.stringify(newState.userConfig));
+            }
+        },
+        useUserConfig: (actions) => {
+            (0, react_1.useEffect)(() => {
+                var _a;
+                let config = null;
+                try {
+                    config = JSON.parse((_a = window.localStorage.getItem(configKey)) !== null && _a !== void 0 ? _a : "{}");
+                }
+                catch {
+                    // ignore
+                }
+                if (isObject(config) && config !== null) {
+                    actions.reinitializeUserConfig(config);
+                }
+            }, [actions]);
+        },
+    }), [configKey]);
+}

package/utils/create-filter-component-props.d.ts

@@ -0,0 +1,4 @@
+import { FilterProps } from "../types/components";
+import { Filter } from "../types/schema";
+import { DataGridControl } from "../use-data-grid-control";
+export declare function createFilterComponentProps(gridName: string | undefined, filter: Filter, state: DataGridControl["state"], actions: DataGridControl["actions"]): FilterProps<any>;

package/utils/create-filter-component-props.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFilterComponentProps = createFilterComponentProps;
+const is_nil_1 = require("@uxf/core/utils/is-nil");
+function createFilterComponentProps(gridName, filter, state, actions) {
+    const requestFilter = state.request.f.find((f) => f.name === filter.name);
+    return {
+        filter,
+        value: requestFilter === null || requestFilter === void 0 ? void 0 : requestFilter.value,
+        op: requestFilter === null || requestFilter === void 0 ? void 0 : requestFilter.op,
+        gridName,
+        onChange: (value, op) => (0, is_nil_1.isNil)(value) ? actions.filterClear(filter.name) : actions.filter(filter.name, value, op),
+        onClear: () => actions.filterClear(filter.name),
+    };
+}

package/utils/get-config-key.d.ts

@@ -0,0 +1,2 @@
+import { Schema } from "../types";
+export declare function getConfigKey(schema: Schema<any>): string;

package/utils/get-config-key.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfigKey = getConfigKey;
+function getConfigKey(schema) {
+    return `data-grid-config__v2__${schema.name}`;
+}

package/utils/merge-schema-with-config.d.ts

@@ -0,0 +1,3 @@
+import { BaseGridType, Schema } from "../types/schema";
+import { DataGridFrontendConfig } from "../types/state";
+export declare function mergeSchemaWithConfig<GridType extends BaseGridType>(schema: Schema<GridType>, frontendConfig: DataGridFrontendConfig<GridType>): Schema<GridType>;

package/utils/merge-schema-with-config.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeSchemaWithConfig = mergeSchemaWithConfig;
+function mergeSchemaWithConfig(schema, frontendConfig) {
+    var _a;
+    return {
+        ...schema,
+        perPage: (_a = frontendConfig.perPage) !== null && _a !== void 0 ? _a : schema.perPage,
+        columns: schema.columns.map((column) => {
+            var _a;
+            return ({
+                ...column,
+                config: {
+                    ...column.config,
+                    ...(_a = frontendConfig.columns) === null || _a === void 0 ? void 0 : _a[column.name],
+                },
+            });
+        }),
+        filters: schema.filters.map((filter) => {
+            var _a;
+            return ({
+                ...filter,
+                config: {
+                    ...filter.config,
+                    ...(_a = frontendConfig.filters) === null || _a === void 0 ? void 0 : _a[filter.name],
+                },
+            });
+        }),
+    };
+}

package/utils/merge-schema-with-config.test.d.ts

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