@uxf/data-grid 11.3.0 → 11.4.0

package/_generator/index.js

@@ -14,90 +14,23 @@ function writeFile(filename, value) {
     writeFileSync(filename, value);
 }
 
-function generateSchemaFile(gridName, schemaRelativeImport) {
+function generateSchemaFile(gridName, schema, schemaRelativeImport) {
     return `import { Schema } from "@uxf/data-grid";
 import json from "${schemaRelativeImport}";
 
-export const dataGridSchema_${camelize(gridName)}: Schema<any> = json as any;`;
+type DataGrid_${camelize(gridName)} = {
+    columns: {
+        ${schema.columns.map((column) => `"${column.name}": "${column.type}",`).join("\n        ")}
+    },
+    filters: {
+        ${schema.filters.map((filter) => `"${filter.name}": "${filter.type}",`).join("\n        ")}
+    }
 }
 
-function generateUseDataGridControl(gridName) {
-    return `import { useDataGridControl, UseDataGridControlConfig } from "@uxf/data-grid/use-data-grid-control";
-import { dataGridSchema_${camelize(gridName)} as schema } from "./schema";
-
-export function useDataGridControl_${camelize(gridName)}(config: Omit<UseDataGridControlConfig, "schema">) {
-    return useDataGridControl({
-        schema,
-        ...config,
-    });
-}
-`;
-}
-
-function generateUseDataGridFetching(gridName, isLoaderRequired) {
-    return `import { Loader } from "@uxf/data-grid/types/core";
-import { useDataGridFetching, UseDataGridFetchingConfig } from "@uxf/data-grid/use-data-grid-fetching";
-import { dataGridSchema_${camelize(gridName)} as schema } from "./schema";
-    
-export function useDataGridFetching_${camelize(gridName)}(
-    config: Omit<UseDataGridFetchingConfig, "gridName" | "loader" | "schema"> & { loader${
-        isLoaderRequired ? "" : "?"
-    }: Loader },
-) {
-    return useDataGridFetching({ gridName: "${gridName}", schema, ...config });
-}
-`;
-}
-
-function generateDataGridFile(gridName, isLoaderRequired) {
-    return `import { Nullish } from "@uxf/core/types";
-import { DataGrid, DataGridProps, DataGridUserConfig, Loader, Request } from "@uxf/data-grid";
-import { useDataGridControl } from "@uxf/data-grid/use-data-grid-control";
-import { useDataGridFetching } from "@uxf/data-grid/use-data-grid-fetching";
-import React from "react";
-import { dataGridSchema_${camelize(gridName)} as schema } from "./schema";
-
-type Props = Omit<
-    DataGridProps<any, any>,
-    "gridName" | "schema" | "state" | "actions" | "data" | "isLoading" | "onReload"
-> & {
-    loader${isLoaderRequired ? "" : "?"}: Loader;
-    initialUserConfig?: DataGridUserConfig | Nullish;
-    initialState?: Request | string | Nullish;
-};
-
-export function DataGrid_${camelize(gridName)}(props: Props) {
-    const { state, actions } = useDataGridControl({
-        schema,
-        initialState: props.initialState,
-        initialUserConfig: props.initialUserConfig,
-    });
-    
-    const { data, error, onReload, isLoading } = useDataGridFetching({
-        gridName: "${gridName}",
-        schema,
-        state,
-        loader: props.loader,
-    });
-
-    return (
-        <DataGrid<any>
-            state={state}
-            actions={actions}
-            data={data}
-            isLoading={isLoading}
-            error={error}
-            onReload={onReload}
-            {...props}
-            gridName="admin-club"
-            schema={schema}
-        />
-    );
-}
-`;
+export const dataGridSchema_${camelize(gridName)}: Schema<DataGrid_${camelize(gridName)}> = json as any;`;
 }
 
-function generate(jsonSchema, filename, outputDirectory, isLoaderRequired) {
+function generate(schema, filename, outputDirectory) {
     const gridName = parse(filename).name;
     const generatedPath = join(process.cwd(), outputDirectory, gridName);
 
@@ -105,16 +38,12 @@ function generate(jsonSchema, filename, outputDirectory, isLoaderRequired) {
 
     writeFile(
         generatedSchemaFilename,
-        generateSchemaFile(gridName, relative(dirname(generatedSchemaFilename), filename)),
+        generateSchemaFile(gridName, schema, relative(dirname(generatedSchemaFilename), filename)),
     );
-
-    // writeFile(`${generatedPath}/data-grid.tsx`, generateDataGridFile(gridName, isLoaderRequired));
-    // writeFile(`${generatedPath}/use-data-grid-control.ts`, generateUseDataGridControl(gridName));
-    // writeFile(`${generatedPath}/use-data-grid-fetching.ts`, generateUseDataGridFetching(gridName, isLoaderRequired));
 }
 
 module.exports = (schemaDirectory, outputDirectory, requiredLoader) => {
     globSync(schemaDirectory + "/*.json")
         .map((path) => process.cwd() + "/" + path)
-        .forEach((filename) => generate(readFileSync(filename), filename, outputDirectory, requiredLoader));
+        .forEach((filename) => generate(JSON.parse(readFileSync(filename)), filename, outputDirectory, requiredLoader));
 };

package/_store/reducer.d.ts

@@ -1,8 +1,8 @@
 import { Nullish } from "@uxf/core/types";
 import { Reducer } from "react";
 import { Request } from "../types/api";
-import { Schema } from "../types/schema";
+import { BaseGridType, Schema } from "../types/schema";
 import { DataGridState, DataGridUserConfig } from "../types/state";
-export declare const getInitialState: (schema: Schema<any>, init?: Request | string | Nullish, initialUserConfig?: DataGridUserConfig | Nullish) => DataGridState;
-export declare const reducer: Reducer<DataGridState, any>;
-export declare const debugReducer: Reducer<DataGridState, any>;
+export declare function getInitialState<GridType extends BaseGridType>(schema: Schema<GridType>, init?: Request | string | Nullish, initialUserConfig?: DataGridUserConfig<GridType> | Nullish): DataGridState<GridType>;
+export declare const reducer: Reducer<DataGridState<any>, any>;
+export declare const debugReducer: Reducer<DataGridState<any>, any>;

package/_store/reducer.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.debugReducer = exports.reducer = exports.getInitialState = void 0;
 const is_nil_1 = require("@uxf/core/utils/is-nil");
 const utils_1 = require("../utils");
-const getInitialState = (schema, init, initialUserConfig) => {
+function getInitialState(schema, init, initialUserConfig) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
     const initialState = (0, is_nil_1.isNil)(init) ? {} : typeof init === "string" ? (_a = (0, utils_1.decodeFilter)(init)) !== null && _a !== void 0 ? _a : {} : init;
     const tabName = (_e = (_b = initialState.tab) !== null && _b !== void 0 ? _b : (_d = (_c = schema.tabs) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d.name) !== null && _e !== void 0 ? _e : null;
@@ -23,7 +23,7 @@ const getInitialState = (schema, init, initialUserConfig) => {
         },
         tabRequests: {},
     };
-};
+}
 exports.getInitialState = getInitialState;
 // eslint-disable-next-line complexity
 const reducer = (state, action) => {

package/data-grid.stories.js

@@ -38,6 +38,14 @@ function Default() {
     const [noBorder, setNoBorder] = (0, react_1.useState)(false);
     const { state, actions } = (0, use_data_grid_control_1.useDataGridControl)({
         schema: schema_1.schema,
+        initialUserConfig: {
+            columns: {
+                id: { minWidth: 50 },
+                text: { minWidth: 300 },
+                mail: { minWidth: 300 },
+                tel: { minWidth: 300 },
+            },
+        },
     });
     const { isLoading, error, data, onReload } = (0, use_data_grid_fetching_1.useDataGridFetching)({
         loader: loader_1.loader,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uxf/data-grid",
-  "version": "11.3.0",
+  "version": "11.4.0",
   "description": "UXF DataGrid",
   "homepage": "https://gitlab.com/uxf-npm/data-grid#readme",
   "main": "index.js",
@@ -31,7 +31,7 @@
     "typecheck": "tsc --noEmit --skipLibCheck"
   },
   "dependencies": {
-    "@uxf/ui": "11.3.0",
+    "@uxf/ui": "11.4.0",
     "dayjs": "1.11.10",
     "fast-glob": "^3.3.2",
     "qs": "6.11.2",

package/table/hooks/use-react-data-grid-columns.d.ts

@@ -1,4 +1,4 @@
 import { Column } from "react-data-grid";
 import { DataGridState } from "../../types";
 import { TableProps } from "../types";
-export declare function useReactDataGridColumns(props: TableProps<any>, state: DataGridState): Column<any>[];
+export declare function useReactDataGridColumns(props: TableProps<any>, state: DataGridState<any>): Column<any>[];

package/types/state.d.ts

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

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

@@ -1,15 +1,15 @@
 import { Nullish } from "@uxf/core/types";
 import { Request } from "../types/api";
-import { Schema } from "../types/schema";
+import { BaseGridType, Schema } from "../types/schema";
 import { DataGridUserConfig } from "../types/state";
-export interface UseDataGridControlConfig {
-    schema: Schema<any>;
+export interface UseDataGridControlConfig<GridType extends BaseGridType> {
+    schema: Schema<GridType>;
     initialState?: Request | string | Nullish;
     isDebug?: boolean;
-    initialUserConfig?: DataGridUserConfig | Nullish;
+    initialUserConfig?: DataGridUserConfig<GridType> | Nullish;
 }
-export declare function useDataGridControl(config: UseDataGridControlConfig): {
-    state: import("../types/state").DataGridState;
+export declare function useDataGridControl<T extends BaseGridType>(config: UseDataGridControlConfig<T>): {
+    state: import("../types/state").DataGridState<any>;
     actions: {
         changePage: (page: number) => void;
         changePerPage: (perPage: number) => void;