@1money/component-ui 0.0.68 → 0.0.70

package/es/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/es/components/ProTable/core/useAwaitableReload.js

@@ -0,0 +1,39 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { useRef } from 'react';
+import { useMemoizedFn, useSafeState } from '@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.
+ */
+export function useAwaitableReload() {
+  var _useSafeState = useSafeState(0),
+    _useSafeState2 = _slicedToArray(_useSafeState, 2),
+    token = _useSafeState2[0],
+    setToken = _useSafeState2[1];
+  var resolversRef = useRef([]);
+  var request = useMemoizedFn(function () {
+    return new Promise(function (resolve) {
+      resolversRef.current.push(resolve);
+      setToken(function (value) {
+        return value + 1;
+      });
+    });
+  });
+  var settle = 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,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

package/es/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/es/components/ProTable/core/utils.js

@@ -0,0 +1,21 @@
+/**
+ * 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 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.
+ */
+export 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/es/components/ProTable/index.d.ts

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

package/es/components/ProTable/index.js

@@ -0,0 +1,5 @@
+import ProTable from './ProTable';
+export { ProTable } from './ProTable';
+export default ProTable;
+export * from './interface';
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvc3JjL2NvbXBvbmVudHMvUHJvVGFibGUvaW5kZXgudHMiXSwibmFtZXMiOlsiUHJvVGFibGUiXSwibWFwcGluZ3MiOiJBQUFBLE9BQU9BLFFBQVEsTUFBTSxZQUFZO0FBRWpDLFNBQVNBLFFBQVEsUUFBUSxZQUFZO0FBRXJDLGVBQWVBLFFBQVE7QUFFdkIsY0FBYyxhQUFhIiwiZmlsZSI6ImNvbXBvbmVudHMvUHJvVGFibGUvaW5kZXguanMiLCJzb3VyY2VzQ29udGVudCI6W251bGxdLCJzb3VyY2VSb290IjoiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjIn0=

package/es/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/es/components/ProTable/interface.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcG9uZW50cy9Qcm9UYWJsZS9pbnRlcmZhY2UuanMiLCJuYW1lcyI6W10sInNvdXJjZVJvb3QiOiIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMiLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvUHJvVGFibGUvaW50ZXJmYWNlLmpzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7fTsiXSwibWFwcGluZ3MiOiJBQUFBIiwiaWdub3JlTGlzdCI6W119

package/es/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/es/components/ProTable/style/css.js

@@ -0,0 +1,6 @@
+import '../../Button/style/css';
+import '../../Pagination/style/css';
+import '../../ProForm/style/css';
+import '../../Table/style/css';
+import './ProTable.css';
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvUHJvVGFibGUvc3JjL2NvbXBvbmVudHMvUHJvVGFibGUvc3R5bGUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTywyQkFBMkI7QUFDbEMsT0FBTywrQkFBK0I7QUFDdEMsT0FBTyw0QkFBNEI7QUFDbkMsT0FBTywwQkFBMEI7QUFDakMsT0FBTyxpQkFBaUIiLCJmaWxlIjoiY29tcG9uZW50cy9Qcm9UYWJsZS9zdHlsZS9jc3MuanMiLCJzb3VyY2VzQ29udGVudCI6W251bGxdLCJzb3VyY2VSb290IjoiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjIn0=

package/es/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/es/components/ProTable/style/index.js

@@ -0,0 +1,6 @@
+import '../../Button/style';
+import '../../Pagination/style';
+import '../../ProForm/style';
+import '../../Table/style';
+import './ProTable.css';
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvUHJvVGFibGUvc3JjL2NvbXBvbmVudHMvUHJvVGFibGUvc3R5bGUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTywyQkFBMkI7QUFDbEMsT0FBTywrQkFBK0I7QUFDdEMsT0FBTyw0QkFBNEI7QUFDbkMsT0FBTywwQkFBMEI7QUFDakMsT0FBTyxpQkFBaUIiLCJmaWxlIjoiY29tcG9uZW50cy9Qcm9UYWJsZS9zdHlsZS9pbmRleC5qcyIsInNvdXJjZXNDb250ZW50IjpbbnVsbF0sInNvdXJjZVJvb3QiOiIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMifQ==

package/es/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>;