@1money/component-ui 0.0.68 → 0.0.70

package/lib/components/ProTable/core/genSearchFields.js

@@ -0,0 +1,111 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.applySearchTransforms = applySearchTransforms;
+exports.genSearchFields = genSearchFields;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _jsxRuntime = require("react/jsx-runtime");
+var _ProForm = require("../../ProForm");
+var _utils = require("./utils");
+function isSearchable(column) {
+  if (column.hideInSearch === true || column.search === false) return false;
+  return Boolean(column.renderFormItem || column.valueType);
+}
+/**
+ * Build the QueryFilter children (ProForm fields) from searchable columns, plus
+ * the aggregated initial values. `renderFormItem` overrides the valueType mapping.
+ */
+function genSearchFields(columns) {
+  var initialValues = {};
+  var names = [];
+  var fields = columns.filter(isSearchable).map(function (column, index) {
+    return {
+      column: column,
+      name: (0, _utils.getColumnSearchName)(column),
+      index: index
+    };
+  }).filter(function (entry) {
+    return entry.name !== null;
+  }).sort(function (a, b) {
+    var _a, _b;
+    return ((_a = a.column.order) !== null && _a !== void 0 ? _a : a.index) - ((_b = b.column.order) !== null && _b !== void 0 ? _b : b.index);
+  }).map(function (_ref) {
+    var column = _ref.column,
+      name = _ref.name;
+    names.push(name);
+    if (column.initialValue !== undefined) initialValues[name] = column.initialValue;
+    if (column.renderFormItem) {
+      return (0, _jsxRuntime.jsx)("span", {
+        children: column.renderFormItem()
+      }, name);
+    }
+    var fieldProps = column.fieldProps;
+    // No labels — use the column title as the placeholder so the field stays self-describing.
+    var placeholder = typeof column.title === 'string' ? column.title : undefined;
+    switch (column.valueType) {
+      case 'select':
+        return (0, _jsxRuntime.jsx)(_ProForm.ProForm.Select, {
+          name: name,
+          placeholder: placeholder,
+          valueEnum: column.valueEnum,
+          fieldProps: fieldProps
+        }, name);
+      case 'date':
+        return (0, _jsxRuntime.jsx)(_ProForm.ProForm.DatePicker, {
+          name: name,
+          placeholder: placeholder,
+          fieldProps: fieldProps
+        }, name);
+      case 'dateRange':
+        return (0, _jsxRuntime.jsx)(_ProForm.ProForm.DatePicker, {
+          name: name,
+          placeholder: placeholder,
+          fieldProps: Object.assign({
+            selectionMode: 'range'
+          }, fieldProps)
+        }, name);
+      case 'digit':
+        return (0, _jsxRuntime.jsx)(_ProForm.ProForm.Text, {
+          name: name,
+          placeholder: placeholder,
+          fieldProps: Object.assign({
+            type: 'number'
+          }, fieldProps)
+        }, name);
+      case 'text':
+      default:
+        return (0, _jsxRuntime.jsx)(_ProForm.ProForm.Text, {
+          name: name,
+          placeholder: placeholder,
+          fieldProps: fieldProps
+        }, name);
+    }
+  });
+  return {
+    fields: fields,
+    initialValues: initialValues,
+    names: names
+  };
+}
+/**
+ * Apply per-column `search.transform` to submitted values, replacing the original
+ * field name with the mapped params.
+ */
+function applySearchTransforms(values, columns) {
+  var result = Object.assign({}, values);
+  columns.forEach(function (column) {
+    if ((0, _typeof2["default"])(column.search) === 'object' && column.search.transform) {
+      var name = (0, _utils.getColumnSearchName)(column);
+      if (name && name in result) {
+        var mapped = column.search.transform(result[name]);
+        delete result[name];
+        Object.assign(result, mapped);
+      }
+    }
+  });
+  return result;
+}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/ProTable/core/genSearchFields.js","components/ProTable/src/components/ProTable/core/genSearchFields.tsx"],"names":["_jsxRuntime","require","_ProForm","_utils","isSearchable","column","hideInSearch","search","Boolean","renderFormItem","valueType","genSearchFields","columns","initialValues","names","fields","filter","map","index","name","getColumnSearchName","entry","sort","a","b","_a","_b","order","_ref","push","initialValue","undefined","_jsx","children","fieldProps","placeholder","title","ProForm","Select","valueEnum","DatePicker","Object","assign","selectionMode","Text","type","applySearchTransforms","values","result","forEach","_typeof2","transform","mapped"],"mappings":"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","file":"components/ProTable/core/genSearchFields.js","sourcesContent":["import { jsx as _jsx } from \"react/jsx-runtime\";\nimport { ProForm } from '../../ProForm';\nimport { getColumnSearchName } from './utils';\nfunction isSearchable(column) {\n    if (column.hideInSearch === true || column.search === false)\n        return false;\n    return Boolean(column.renderFormItem || column.valueType);\n}\n/**\n * Build the QueryFilter children (ProForm fields) from searchable columns, plus\n * the aggregated initial values. `renderFormItem` overrides the valueType mapping.\n */\nexport function genSearchFields(columns) {\n    const initialValues = {};\n    const names = [];\n    const fields = columns\n        .filter(isSearchable)\n        .map((column, index) => ({ column, name: getColumnSearchName(column), index }))\n        .filter((entry) => entry.name !== null)\n        .sort((a, b) => { var _a, _b; return ((_a = a.column.order) !== null && _a !== void 0 ? _a : a.index) - ((_b = b.column.order) !== null && _b !== void 0 ? _b : b.index); })\n        .map(({ column, name }) => {\n        names.push(name);\n        if (column.initialValue !== undefined)\n            initialValues[name] = column.initialValue;\n        if (column.renderFormItem) {\n            return _jsx(\"span\", { children: column.renderFormItem() }, name);\n        }\n        const fieldProps = column.fieldProps;\n        // No labels — use the column title as the placeholder so the field stays self-describing.\n        const placeholder = typeof column.title === 'string' ? column.title : undefined;\n        switch (column.valueType) {\n            case 'select':\n                return (_jsx(ProForm.Select, { name: name, placeholder: placeholder, valueEnum: column.valueEnum, fieldProps: fieldProps }, name));\n            case 'date':\n                return _jsx(ProForm.DatePicker, { name: name, placeholder: placeholder, fieldProps: fieldProps }, name);\n            case 'dateRange':\n                return (_jsx(ProForm.DatePicker, { name: name, placeholder: placeholder, fieldProps: Object.assign({ selectionMode: 'range' }, fieldProps) }, name));\n            case 'digit':\n                return (_jsx(ProForm.Text, { name: name, placeholder: placeholder, fieldProps: Object.assign({ type: 'number' }, fieldProps) }, name));\n            case 'text':\n            default:\n                return _jsx(ProForm.Text, { name: name, placeholder: placeholder, fieldProps: fieldProps }, name);\n        }\n    });\n    return { fields, initialValues, names };\n}\n/**\n * Apply per-column `search.transform` to submitted values, replacing the original\n * field name with the mapped params.\n */\nexport function applySearchTransforms(values, columns) {\n    const result = Object.assign({}, values);\n    columns.forEach((column) => {\n        if (typeof column.search === 'object' && column.search.transform) {\n            const name = getColumnSearchName(column);\n            if (name && name in result) {\n                const mapped = column.search.transform(result[name]);\n                delete result[name];\n                Object.assign(result, mapped);\n            }\n        }\n    });\n    return result;\n}",null],"sourceRoot":"../../../../../../../../../../src"}

package/lib/components/ProTable/core/useAwaitableReload.d.ts

@@ -0,0 +1,17 @@
+export interface AwaitableReload {
+    /** Include in the fetch effect deps; a change forces the effect to re-run. */
+    token: number;
+    /** Force a refetch; resolves once `settle()` runs after the triggered fetch completes. */
+    request: () => Promise<void>;
+    /** Resolve every pending `request()` promise. Call when the triggered fetch settles. */
+    settle: () => void;
+}
+/**
+ * Bridges imperative, awaitable reloads onto a reactive (effect-driven) fetch.
+ *
+ * `request()` bumps `token` (which the consuming effect depends on) and returns a
+ * promise; the effect calls `settle()` once the fetch it triggered finishes,
+ * resolving that promise. This keeps a single, fresh-closure fetch path while
+ * still letting callers `await` a reload — no stale refs, no duplicate fetches.
+ */
+export declare function useAwaitableReload(): AwaitableReload;

package/lib/components/ProTable/core/useAwaitableReload.js

@@ -0,0 +1,46 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useAwaitableReload = useAwaitableReload;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _react = require("react");
+var _hooks = require("@1money/hooks");
+/**
+ * Bridges imperative, awaitable reloads onto a reactive (effect-driven) fetch.
+ *
+ * `request()` bumps `token` (which the consuming effect depends on) and returns a
+ * promise; the effect calls `settle()` once the fetch it triggered finishes,
+ * resolving that promise. This keeps a single, fresh-closure fetch path while
+ * still letting callers `await` a reload — no stale refs, no duplicate fetches.
+ */
+function useAwaitableReload() {
+  var _useSafeState = (0, _hooks.useSafeState)(0),
+    _useSafeState2 = (0, _slicedToArray2["default"])(_useSafeState, 2),
+    token = _useSafeState2[0],
+    setToken = _useSafeState2[1];
+  var resolversRef = (0, _react.useRef)([]);
+  var request = (0, _hooks.useMemoizedFn)(function () {
+    return new Promise(function (resolve) {
+      resolversRef.current.push(resolve);
+      setToken(function (value) {
+        return value + 1;
+      });
+    });
+  });
+  var settle = (0, _hooks.useMemoizedFn)(function () {
+    var resolvers = resolversRef.current;
+    resolversRef.current = [];
+    resolvers.forEach(function (resolve) {
+      return resolve();
+    });
+  });
+  return {
+    token: token,
+    request: request,
+    settle: settle
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvUHJvVGFibGUvc3JjL2NvbXBvbmVudHMvUHJvVGFibGUvY29yZS91c2VBd2FpdGFibGVSZWxvYWQudHMiLCJjb21wb25lbnRzL1Byb1RhYmxlL2NvcmUvdXNlQXdhaXRhYmxlUmVsb2FkLmpzIl0sIm5hbWVzIjpbIl9yZWFjdCIsInJlcXVpcmUiLCJfaG9va3MiLCJ1c2VBd2FpdGFibGVSZWxvYWQiLCJfdXNlU2FmZVN0YXRlIiwidXNlU2FmZVN0YXRlIiwiX3VzZVNhZmVTdGF0ZTIiLCJfc2xpY2VkVG9BcnJheTIiLCJ0b2tlbiIsInNldFRva2VuIiwicmVzb2x2ZXJzUmVmIiwidXNlUmVmIiwicmVxdWVzdCIsInVzZU1lbW9pemVkRm4iLCJQcm9taXNlIiwicmVzb2x2ZSIsImN1cnJlbnQiLCJwdXNoIiwidmFsdWUiLCJzZXR0bGUiLCJyZXNvbHZlcnMiLCJmb3JFYWNoIl0sIm1hcHBpbmdzIjoiOzs7Ozs7OztBQUFBLElBQUFBLE1BQUEsR0FBQUMsT0FBQTtBQUNBLElBQUFDLE1BQUEsR0FBQUQsT0FBQTtBQVdBO0FDVEE7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QURXTSxTQUFVRSxrQkFBa0JBLENBQUEsRUFBQTtFQUNoQyxJQUFBQyxhQUFBLEdBQTBCLElBQUFDLG1CQUFZLEVBQUMsQ0FBQyxDQUFDO0lBQUFDLGNBQUEsT0FBQUMsZUFBQSxhQUFBSCxhQUFBO0lBQWxDSSxLQUFLLEdBQUFGLGNBQUE7SUFBRUcsUUFBUSxHQUFBSCxjQUFBO0VBQ3RCLElBQU1JLFlBQVksR0FBRyxJQUFBQyxhQUFNLEVBQW9CLEVBQUUsQ0FBQztFQUVsRCxJQUFNQyxPQUFPLEdBQUcsSUFBQUMsb0JBQWEsRUFDM0I7SUFBQSxPQUNFLElBQUlDLE9BQU8sQ0FBTyxVQUFDQyxPQUFPLEVBQUk7TUFDNUJMLFlBQVksQ0FBQ00sT0FBTyxDQUFDQyxJQUFJLENBQUNGLE9BQU8sQ0FBQztNQUNsQ04sUUFBUSxDQUFDLFVBQUNTLEtBQUs7UUFBQSxPQUFLQSxLQUFLLEdBQUcsQ0FBQztNQUFBLEVBQUM7SUFDaEMsQ0FBQyxDQUFDO0VBQUEsRUFDTDtFQUVELElBQU1DLE1BQU0sR0FBRyxJQUFBTixvQkFBYSxFQUFDLFlBQUs7SUFDaEMsSUFBTU8sU0FBUyxHQUFHVixZQUFZLENBQUNNLE9BQU87SUFDdENOLFlBQVksQ0FBQ00sT0FBTyxHQUFHLEVBQUU7SUFDekJJLFNBQVMsQ0FBQ0MsT0FBTyxDQUFDLFVBQUNOLE9BQU87TUFBQSxPQUFLQSxPQUFPLENBQUEsQ0FBRTtJQUFBLEVBQUM7RUFDM0MsQ0FBQyxDQUFDO0VBRUYsT0FBTztJQUFFUCxLQUFLLEVBQUxBLEtBQUs7SUFBRUksT0FBTyxFQUFQQSxPQUFPO0lBQUVPLE1BQU0sRUFBTkE7RUFBTSxDQUFFO0FBQ25DIiwiZmlsZSI6ImNvbXBvbmVudHMvUHJvVGFibGUvY29yZS91c2VBd2FpdGFibGVSZWxvYWQuanMiLCJzb3VyY2VzQ29udGVudCI6W251bGwsImltcG9ydCB7IHVzZVJlZiB9IGZyb20gJ3JlYWN0JztcbmltcG9ydCB7IHVzZU1lbW9pemVkRm4sIHVzZVNhZmVTdGF0ZSB9IGZyb20gJ0AxbW9uZXkvaG9va3MnO1xuLyoqXG4gKiBCcmlkZ2VzIGltcGVyYXRpdmUsIGF3YWl0YWJsZSByZWxvYWRzIG9udG8gYSByZWFjdGl2ZSAoZWZmZWN0LWRyaXZlbikgZmV0Y2guXG4gKlxuICogYHJlcXVlc3QoKWAgYnVtcHMgYHRva2VuYCAod2hpY2ggdGhlIGNvbnN1bWluZyBlZmZlY3QgZGVwZW5kcyBvbikgYW5kIHJldHVybnMgYVxuICogcHJvbWlzZTsgdGhlIGVmZmVjdCBjYWxscyBgc2V0dGxlKClgIG9uY2UgdGhlIGZldGNoIGl0IHRyaWdnZXJlZCBmaW5pc2hlcyxcbiAqIHJlc29sdmluZyB0aGF0IHByb21pc2UuIFRoaXMga2VlcHMgYSBzaW5nbGUsIGZyZXNoLWNsb3N1cmUgZmV0Y2ggcGF0aCB3aGlsZVxuICogc3RpbGwgbGV0dGluZyBjYWxsZXJzIGBhd2FpdGAgYSByZWxvYWQg4oCUIG5vIHN0YWxlIHJlZnMsIG5vIGR1cGxpY2F0ZSBmZXRjaGVzLlxuICovXG5leHBvcnQgZnVuY3Rpb24gdXNlQXdhaXRhYmxlUmVsb2FkKCkge1xuICAgIGNvbnN0IFt0b2tlbiwgc2V0VG9rZW5dID0gdXNlU2FmZVN0YXRlKDApO1xuICAgIGNvbnN0IHJlc29sdmVyc1JlZiA9IHVzZVJlZihbXSk7XG4gICAgY29uc3QgcmVxdWVzdCA9IHVzZU1lbW9pemVkRm4oKCkgPT4gbmV3IFByb21pc2UoKHJlc29sdmUpID0+IHtcbiAgICAgICAgcmVzb2x2ZXJzUmVmLmN1cnJlbnQucHVzaChyZXNvbHZlKTtcbiAgICAgICAgc2V0VG9rZW4oKHZhbHVlKSA9PiB2YWx1ZSArIDEpO1xuICAgIH0pKTtcbiAgICBjb25zdCBzZXR0bGUgPSB1c2VNZW1vaXplZEZuKCgpID0+IHtcbiAgICAgICAgY29uc3QgcmVzb2x2ZXJzID0gcmVzb2x2ZXJzUmVmLmN1cnJlbnQ7XG4gICAgICAgIHJlc29sdmVyc1JlZi5jdXJyZW50ID0gW107XG4gICAgICAgIHJlc29sdmVycy5mb3JFYWNoKChyZXNvbHZlKSA9PiByZXNvbHZlKCkpO1xuICAgIH0pO1xuICAgIHJldHVybiB7IHRva2VuLCByZXF1ZXN0LCBzZXR0bGUgfTtcbn0iXSwic291cmNlUm9vdCI6Ii4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYyJ9

package/lib/components/ProTable/core/utils.d.ts

@@ -0,0 +1,12 @@
+import type { TableRecord } from "../../Table";
+import type { ProColumns } from '../interface';
+/**
+ * Stable string key for a Pro column. Prefers an explicit `key`, then a string
+ * `dataIndex`, then an array `dataIndex` joined by `.`, falling back to the index.
+ */
+export declare function getColumnKey<T extends TableRecord>(column: ProColumns<T>, index: number): string;
+/**
+ * Name used for the generated search field / request param. Only a flat string
+ * key (`key` or string `dataIndex`) can be auto-mapped; otherwise returns null.
+ */
+export declare function getColumnSearchName<T extends TableRecord>(column: ProColumns<T>): string | null;

package/lib/components/ProTable/core/utils.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getColumnKey = getColumnKey;
+exports.getColumnSearchName = getColumnSearchName;
+/**
+ * Stable string key for a Pro column. Prefers an explicit `key`, then a string
+ * `dataIndex`, then an array `dataIndex` joined by `.`, falling back to the index.
+ */
+function getColumnKey(column, index) {
+  if (column.key !== undefined && column.key !== null) return String(column.key);
+  var dataIndex = column.dataIndex;
+  if (typeof dataIndex === 'string' || typeof dataIndex === 'number') return String(dataIndex);
+  if (Array.isArray(dataIndex)) return dataIndex.join('.');
+  return "col-".concat(index);
+}
+/**
+ * Name used for the generated search field / request param. Only a flat string
+ * key (`key` or string `dataIndex`) can be auto-mapped; otherwise returns null.
+ */
+function getColumnSearchName(column) {
+  if (column.key !== undefined && column.key !== null) return String(column.key);
+  if (typeof column.dataIndex === 'string') return column.dataIndex;
+  return null;
+}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/components/ProTable/index.d.ts

@@ -0,0 +1,4 @@
+import ProTable from './ProTable';
+export { ProTable } from './ProTable';
+export default ProTable;
+export * from './interface';

package/lib/components/ProTable/index.js

@@ -0,0 +1,33 @@
+"use strict";
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  ProTable: true
+};
+Object.defineProperty(exports, "ProTable", {
+  enumerable: true,
+  get: function get() {
+    return _ProTable.ProTable;
+  }
+});
+exports["default"] = void 0;
+var _ProTable = _interopRequireWildcard(require("./ProTable"));
+var _interface = require("./interface");
+Object.keys(_interface).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _interface[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _interface[key];
+    }
+  });
+});
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+var _default = exports["default"] = _ProTable["default"];
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/components/ProTable/interface.d.ts

@@ -0,0 +1,132 @@
+import type { ReactNode, Ref } from 'react';
+import type { TableChangeMeta, TableColumn, TableProps, TableRecord, TableRowSelection, TableSize, TableSortOrder } from "../Table";
+import type { ProFormValueEnumObj } from "../ProForm";
+import type { ProTableValueType } from './constants';
+export type { ProTableValueType } from './constants';
+export interface PageInfo {
+    current: number;
+    pageSize: number;
+    total: number;
+}
+/** Shape returned by the `request` prop. */
+export interface RequestData<T> {
+    data: T[];
+    /** Total record count for server-side pagination. Defaults to `data.length`. */
+    total?: number;
+    /** `false` marks a soft failure — data is left untouched, no error thrown. */
+    success?: boolean;
+}
+export interface ProTablePaginationConfig {
+    pageSize?: number;
+    current?: number;
+    defaultCurrent?: number;
+    defaultPageSize?: number;
+}
+/** Sort params handed to `request` — `{ [columnKey]: 'ascend' | 'descend' }`. */
+export type ProTableSortParam = Record<string, Exclude<TableSortOrder, null>>;
+/** Filter params handed to `request`, keyed by column key. */
+export type ProTableFilterParam = Record<string, (string | number | boolean)[] | null>;
+/** Remap a single search-field value into one or more request params. */
+export type SearchTransform = (value: unknown) => Record<string, unknown>;
+/** Extra options passed to `request` — notably an `AbortSignal` for cancellation. */
+export interface ProTableRequestOptions {
+    signal?: AbortSignal;
+}
+/** The `request` contract. The 4th `options` arg carries an `AbortSignal`. */
+export type ProTableRequest<T, Params extends Record<string, unknown> = Record<string, unknown>> = (params: Params & {
+    current?: number;
+    pageSize?: number;
+}, sort: ProTableSortParam, filter: ProTableFilterParam, options?: ProTableRequestOptions) => Promise<RequestData<T>>;
+export interface ProColumnType<T extends TableRecord = TableRecord> extends TableColumn<T> {
+    /** Drives the default cell render and the auto-generated search-field type. */
+    valueType?: ProTableValueType;
+    /** Enum for `select` value type — used for both cell text and field options. */
+    valueEnum?: ProFormValueEnumObj;
+    /**
+     * Include this column in the search form. `false` hides it. Object form lets you
+     * remap the submitted value into request params (e.g. a range → `{ start, end }`).
+     */
+    search?: boolean | {
+        transform: SearchTransform;
+    };
+    /** Omit the column from the rendered table. */
+    hideInTable?: boolean;
+    /** Omit the column from the search form (alias of `search: false`). */
+    hideInSearch?: boolean;
+    /** Provide a custom search field — overrides `valueType`. */
+    renderFormItem?: () => ReactNode;
+    /** Extra props forwarded to the generated search field. */
+    fieldProps?: Record<string, unknown>;
+    /** Default value for the generated search field. */
+    initialValue?: unknown;
+    /** Sort order of the field within the search form (ascending). */
+    order?: number;
+}
+export type ProColumns<T extends TableRecord = TableRecord> = ProColumnType<T>;
+export type SyncToUrl = boolean | ((values: Record<string, unknown>, type: 'get' | 'set') => Record<string, unknown>);
+export interface SearchConfig {
+    defaultCollapsed?: boolean;
+    labelWidth?: number | 'auto';
+    /** Visible fields before the form collapses. */
+    defaultColsNumber?: number;
+    searchText?: string;
+    resetText?: string;
+    /**
+     * Sync the search values to the URL query string. `true` mirrors values 1:1;
+     * a function maps between form values and URL params (`type` is `'get'` on read,
+     * `'set'` on write). Restored URL values also seed the first request.
+     */
+    syncToUrl?: SyncToUrl;
+}
+export interface ProTableActionRef {
+    /** Refetch the current page. */
+    reload: () => Promise<void>;
+    /** Reset to page 1, then refetch. */
+    reloadAndRest: () => Promise<void>;
+    /** Reset the search form and pagination to their defaults. */
+    reset: () => void;
+    setPageInfo: (info: Partial<PageInfo>) => void;
+}
+export interface ProTableProps<T extends TableRecord = TableRecord, Params extends Record<string, unknown> = Record<string, unknown>> extends Pick<TableProps<T>, 'rowKey' | 'rowSelection' | 'variant' | 'bordered' | 'scroll' | 'sticky' | 'expandable' | 'empty' | 'tableLayout' | 'rowClassName' | 'onRow' | 'size' | 'summary' | 'footer'> {
+    prefixCls?: string;
+    className?: string;
+    /**
+     * Column definitions. Keep this array referentially stable (module-level or
+     * `useMemo`) — a new array each render re-derives the columns and search form.
+     */
+    columns: ProColumns<T>[];
+    /** Server data source. Mutually exclusive with `dataSource`. */
+    request?: ProTableRequest<T, Params>;
+    /** Extra params merged into every request; a change triggers a refetch (resets to page 1). */
+    params?: Params;
+    /** Controlled data — when provided, `request` is ignored (presentational mode). */
+    dataSource?: T[];
+    /** Controlled loading — overrides the internal request loading. */
+    loading?: boolean;
+    /** Initial data before the first request resolves. */
+    defaultData?: T[];
+    /** Skip the initial auto request; only fetch after the first search / `reload`. */
+    manualRequest?: boolean;
+    /** Debounce (ms) applied to every request trigger. */
+    debounceTime?: number;
+    /** Transform the response rows before they are rendered. */
+    postData?: (data: T[]) => T[];
+    /** Transform the whole search-param set before it is sent to `request`. */
+    beforeSearchSubmit?: (params: Record<string, unknown>) => Record<string, unknown>;
+    /** Placeholder rendered for empty cell values (defaults to `'-'`). */
+    columnEmptyText?: ReactNode;
+    /** Poll interval (ms), or a function of the current rows. `0`/falsy disables. */
+    polling?: number | ((data: T[]) => number);
+    /** Customize the rendered search form; receives the default QueryFilter node. */
+    searchFormRender?: (defaultDom: ReactNode) => ReactNode;
+    pagination?: false | ProTablePaginationConfig;
+    search?: false | SearchConfig;
+    rowSelection?: TableRowSelection<T>;
+    size?: TableSize;
+    actionRef?: Ref<ProTableActionRef>;
+    onLoad?: (data: T[]) => void;
+    onLoadingChange?: (loading: boolean) => void;
+    onRequestError?: (error: Error) => void;
+    /** Forwarded from the base Table (sort/filter changes). */
+    onChange?: (meta: TableChangeMeta<T>) => void;
+}

package/lib/components/ProTable/interface.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcG9uZW50cy9Qcm9UYWJsZS9pbnRlcmZhY2UuanMiLCJuYW1lcyI6W10sInNvdXJjZVJvb3QiOiIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMiLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvUHJvVGFibGUvaW50ZXJmYWNlLmpzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7fTsiXSwibWFwcGluZ3MiOiIiLCJpZ25vcmVMaXN0IjpbXX0=

package/lib/components/ProTable/style/ProTable.css

@@ -0,0 +1,47 @@
+/**
+  * Retrieves the spacing value for a given token key.
+  *
+  * @param {string} $key - The spacing token key (e.g., '100', '200').
+  * @return {length|null} The computed spacing value or null if the key is invalid.
+  * @example
+  *   .element {
+  *     padding: om-spacing-token('200'); // Returns 8px if $om-sys-spacing-unit is 4px
+  *   }
+  */
+/**
+  * Computes the spacing value based on a token key or a direct length value.
+  *
+  * @param {string|length} $value - The spacing token key (e.g., '100') or a direct length value (e.g., '16px').
+  * @return {length} The computed spacing value.
+  * @example
+  *   .element {
+  *     margin: om-spacing-value('300'); // Returns 12px if $om-sys-spacing-unit is 4px
+  *     padding: om-spacing-value(16px); // Returns 16px
+  *     gap: om-spacing-value(2); // Returns 8px if $om-sys-spacing-unit is 4px
+  *   }
+  */
+.om-component-ui-pro-table {
+  box-sizing: border-box;
+  width: 100%;
+}
+.om-component-ui-pro-table-search {
+  margin-bottom: var(--om-spacing-400, 16px);
+}
+.om-component-ui-pro-table-search .om-component-ui-proform-query-filter {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: var(--om-spacing-200, 8px);
+}
+.om-component-ui-pro-table-search .om-component-ui-form-item {
+  margin-bottom: 0;
+}
+.om-component-ui-pro-table-container {
+  position: relative;
+  box-sizing: border-box;
+}
+.om-component-ui-pro-table-pagination {
+  display: flex;
+  justify-content: flex-end;
+  padding-block: var(--om-spacing-300, 12px);
+}

package/lib/components/ProTable/style/css.js

@@ -0,0 +1,8 @@
+"use strict";
+
+require("../../Button/style/css");
+require("../../Pagination/style/css");
+require("../../ProForm/style/css");
+require("../../Table/style/css");
+require("./ProTable.css");
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvUHJvVGFibGUvc3JjL2NvbXBvbmVudHMvUHJvVGFibGUvc3R5bGUvaW5kZXgudHMiXSwibmFtZXMiOlsicmVxdWlyZSJdLCJtYXBwaW5ncyI6Ijs7QUFBQUEsT0FBQTtBQUNBQSxPQUFBO0FBQ0FBLE9BQUE7QUFDQUEsT0FBQTtBQUNBQSxPQUFBIiwiZmlsZSI6ImNvbXBvbmVudHMvUHJvVGFibGUvc3R5bGUvY3NzLmpzIiwic291cmNlc0NvbnRlbnQiOltudWxsXSwic291cmNlUm9vdCI6Ii4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYyJ9

package/lib/components/ProTable/style/index.d.ts

@@ -0,0 +1,5 @@
+import "../../Button/style";
+import "../../Pagination/style";
+import "../../ProForm/style";
+import "../../Table/style";
+import './ProTable.css';

package/lib/components/ProTable/style/index.js

@@ -0,0 +1,8 @@
+"use strict";
+
+require("../../Button/style");
+require("../../Pagination/style");
+require("../../ProForm/style");
+require("../../Table/style");
+require("./ProTable.css");
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvUHJvVGFibGUvc3JjL2NvbXBvbmVudHMvUHJvVGFibGUvc3R5bGUvaW5kZXgudHMiXSwibmFtZXMiOlsicmVxdWlyZSJdLCJtYXBwaW5ncyI6Ijs7QUFBQUEsT0FBQTtBQUNBQSxPQUFBO0FBQ0FBLE9BQUE7QUFDQUEsT0FBQTtBQUNBQSxPQUFBIiwiZmlsZSI6ImNvbXBvbmVudHMvUHJvVGFibGUvc3R5bGUvaW5kZXguanMiLCJzb3VyY2VzQ29udGVudCI6W251bGxdLCJzb3VyY2VSb290IjoiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjIn0=

package/lib/components/ProTable/useFetchData.d.ts

@@ -0,0 +1,48 @@
+import type { PageInfo, ProTableFilterParam, ProTableRequest, ProTableSortParam } from './interface';
+export interface UseFetchDataOptions<T, Params extends Record<string, unknown>> {
+    request?: ProTableRequest<T, Params>;
+    /** Skip all internal fetching (controlled `dataSource` mode). */
+    manual: boolean;
+    /** Skip only the initial auto request; later triggers still fetch. */
+    manualRequest?: boolean;
+    /** Debounce (ms) applied to every request trigger. */
+    debounceTime?: number;
+    /** Transform the response rows before they are stored. */
+    postData?: (data: T[]) => T[];
+    /** Poll interval (ms), or a function of the current rows. */
+    polling?: number | ((data: T[]) => number);
+    params?: Params;
+    defaultData?: T[];
+    paginated: boolean;
+    defaultCurrent: number;
+    defaultPageSize: number;
+    /** Submitted (and transformed) search-form values. */
+    searchParams: Record<string, unknown>;
+    sort: ProTableSortParam;
+    filter: ProTableFilterParam;
+    onLoad?: (data: T[]) => void;
+    onLoadingChange?: (loading: boolean) => void;
+    onRequestError?: (error: Error) => void;
+}
+export interface UseFetchDataResult<T> {
+    dataSource: T[];
+    loading: boolean;
+    pageInfo: PageInfo;
+    setPageInfo: (info: Partial<PageInfo>) => void;
+    /** Force a refetch; resolves once the triggered request settles. */
+    reload: () => Promise<void>;
+    reset: () => void;
+}
+/**
+ * Owns the request lifecycle for ProTable: data, loading, and pagination.
+ *
+ * One effect is the single fetch path. It reads its query inputs from the
+ * **render closure** (never a lagging ref), so every state change — search,
+ * sort, filter, params, page — refetches with correct values. An awaitable
+ * reload signal lets imperative callers force the same effect and `await` it.
+ *
+ * `runRequest` aborts the previous in-flight request (`AbortController`, exposed
+ * to `request` as `{ signal }`), tags itself with a request id, and drops stale
+ * or aborted responses.
+ */
+export declare function useFetchData<T, Params extends Record<string, unknown>>(options: UseFetchDataOptions<T, Params>): UseFetchDataResult<T>;