@lobehub/ui 5.61.0 → 5.62.0

package/es/base-ui/ProTable/type.d.mts

@@ -0,0 +1,343 @@
+import { FormInstance, FormValues, UseFormOptions } from "../FormKit/type.mjs";
+import { SortOrder, TableColumnFilterItem, TableColumnType, TablePaginationConfig, TableProps, TableRowSelection, TableSize, TableVariant } from "../Table/type.mjs";
+import "../FormKit/index.mjs";
+import { CSSProperties, Key, MutableRefObject, ReactNode, Ref } from "react";
+//#region src/base-ui/ProTable/type.d.ts
+type ValidateOn = UseFormOptions<FormValues>['validateOn'];
+/** Built-in value types; they pick both the cell renderer and the search-form control. */
+type ProTableValueType = 'text' | 'textarea' | 'password' | 'digit' | 'money' | 'percent' | 'select' | 'radio' | 'checkbox' | 'switch' | 'date' | 'dateTime' | 'dateRange' | 'dateTimeRange' | 'time' | 'progress' | 'code' | 'index' | 'indexBorder' | 'option';
+/** ProComponents `valueEnum` status names; `status` draws a colored dot before the text. */
+type ProTableStatus = 'Default' | 'Error' | 'Processing' | 'Success' | 'Warning';
+interface ProTableValueEnumItem {
+  color?: string;
+  disabled?: boolean;
+  status?: ProTableStatus;
+  text: ReactNode;
+}
+/** `{ value: text | { text, status, color, disabled } }`, or a `Map` of the same. */
+type ProTableValueEnum = Record<string, ReactNode | ProTableValueEnumItem> | Map<string | number | boolean, ReactNode | ProTableValueEnumItem>;
+/** `transform(value, name, allValues)` returns the params to merge (e.g. split a range). */
+type ProTableSearchTransform = (value: any, name: string, allValues: Record<string, any>) => Record<string, any> | string | undefined;
+/** antd-style validation rule, mapped onto base-ui Form `required` / `validate`. */
+interface ProTableFormRule {
+  len?: number;
+  max?: number;
+  message?: ReactNode;
+  min?: number;
+  pattern?: RegExp;
+  required?: boolean;
+  /** Reject (throw) to fail; the error message (or `message`) is shown. */
+  validator?: (rule: ProTableFormRule, value: any, values: Record<string, any>) => Promise<void> | void;
+}
+/**
+ * The search-form handle passed as `formRef`: the base-ui Form instance (`getValue`,
+ * `getValues`, `setValue`, `setValues`, `reset`, `resetField`, `validate`, `submit`,
+ * `setErrors`, `isDirty`, `isTouched`, `subscribe`, `setSchema`) plus antd-style aliases.
+ */
+interface ProTableFormInstance<Values extends Record<string, any> = Record<string, any>> extends FormInstance<Values> {
+  /** Values converted the way they are sent to `request` (`dateFormatter`, `transform`). */
+  getFieldsFormatValue: () => Record<string, any>;
+  /** Raw field values (dates stay `Date`). */
+  getFieldsValue: () => Values;
+  getFieldValue: (name: string) => any;
+  /** Back to the initial values (base-ui `reset()` goes back to the last submitted values). */
+  resetFields: () => void;
+  setFieldsValue: (values: Partial<Values>) => void;
+  setFieldValue: (name: string, value: any) => void;
+  /** Validate every registered field; resolves the values or rejects with `{ errors, valid }`. */
+  validateFields: () => Promise<Values>;
+}
+interface ProTablePageInfo {
+  current: number;
+  pageSize: number;
+  total: number;
+}
+/** `actionRef.current`: imperative actions of the table. */
+interface ProTableActionType {
+  clearSelected: () => void;
+  fullScreen: () => void;
+  getSortFilter: () => {
+    filter: Record<string, (string | number | boolean)[] | null>;
+    sort: Record<string, SortOrder>;
+  };
+  nativeElement: HTMLDivElement | null;
+  pageInfo: ProTablePageInfo;
+  /** Fetch again; `resetPageIndex` jumps back to page 1 first. */
+  reload: (resetPageIndex?: boolean) => Promise<void>;
+  /** Clear the selection, go back to page 1 and fetch. */
+  reloadAndRest: () => Promise<void>;
+  /** Reset the search form to its initial values, go back to page 1 and fetch. */
+  reset: () => void;
+  setPageInfo: (pageInfo: Partial<ProTablePageInfo>) => void;
+}
+interface ProTableSchemaConfig<T> {
+  /** Current form handle; lets `renderFormItem` read sibling fields. */
+  form: ProTableFormInstance;
+  /** `true` in the search form, `false` in the light filter bar. */
+  isQuery: boolean;
+  onChange: (value: any) => void;
+  record?: T;
+  value: any;
+}
+interface ProColumnType<T = any> extends Omit<TableColumnType<T>, 'filters' | 'onFilter' | 'render' | 'sorter' | 'title'> {
+  children?: ProColumnType<T>[];
+  /** Grid cells the field takes in the search form. @default 1 */
+  colSize?: number;
+  /** Show a copy button after the cell text. */
+  copyable?: boolean;
+  /** Column-setting checkbox disabled (the column can't be hidden). */
+  disable?: boolean | {
+    checkbox: boolean;
+  };
+  /** Props of the generated form control (placeholder, options, allowClear, …). */
+  fieldProps?: Record<string, any>;
+  /** `true` builds header filters from `valueEnum`. */
+  filters?: boolean | TableColumnFilterItem[];
+  /** Extra props for the field wrapper; `label` overrides the title in the form. */
+  formItemProps?: {
+    /** Help text under the control. */
+    extra?: ReactNode;
+    label?: ReactNode;
+    required?: boolean;
+    /** Validation rules (base-ui Form `required` / `validate`); the query is blocked until they pass. */
+    rules?: ProTableFormRule[];
+    style?: CSSProperties;
+  };
+  hideInForm?: boolean;
+  hideInSearch?: boolean;
+  hideInSetting?: boolean;
+  hideInTable?: boolean;
+  /** Initial value of the search field. */
+  initialValue?: any;
+  /** `true` filters locally by exact `valueEnum` key match; `false` disables it. */
+  onFilter?: boolean | TableColumnType<T>['onFilter'];
+  /** Order in the search form (larger first). */
+  order?: number;
+  /**
+   * `render(dom, record, index, action, schema)`; `dom` is the value-type rendering. With
+   * `valueType: 'option'` return an array of action nodes.
+   */
+  render?: (dom: ReactNode, record: T, index: number, action: ProTableActionType | undefined, schema: ProColumnType<T>) => ReactNode;
+  /** Custom search control: `(schema, config, form) => node`. */
+  renderFormItem?: (schema: ProColumnType<T>, config: ProTableSchemaConfig<T>, form: ProTableFormInstance) => ReactNode;
+  /** Transform the raw cell value before the value-type rendering. */
+  renderText?: (text: any, record: T, index: number, action: ProTableActionType | undefined) => any;
+  /** `false` hides the column in the search form; `{ transform }` reshapes the submitted value. */
+  search?: boolean | {
+    transform: ProTableSearchTransform;
+  };
+  /** `true` sorts on the server (sent to `request` as `sort`); a function sorts locally. */
+  sorter?: TableColumnType<T>['sorter'] | string;
+  title?: ReactNode;
+  /** Info icon next to the header title. */
+  tooltip?: ReactNode;
+  valueEnum?: ProTableValueEnum | ((record?: T) => ProTableValueEnum);
+  valueType?: ProTableValueType | ((record?: T) => ProTableValueType);
+}
+type ProColumns<T = any> = ProColumnType<T>;
+interface ProTableColumnsStateItem {
+  /** Column-setting checkbox disabled. */
+  disable?: boolean;
+  fixed?: 'left' | 'right' | 'start' | 'end' | boolean;
+  order?: number;
+  show?: boolean;
+}
+type ProTableColumnsStateMap = Record<string, ProTableColumnsStateItem>;
+interface ProTableColumnsState {
+  defaultValue?: ProTableColumnsStateMap;
+  onChange?: (map: ProTableColumnsStateMap) => void;
+  persistenceKey?: string;
+  persistenceType?: 'localStorage' | 'sessionStorage';
+  value?: ProTableColumnsStateMap;
+}
+interface ProTableRequestData<T> {
+  [key: string]: any;
+  data: T[] | undefined;
+  success?: boolean;
+  total?: number;
+}
+type ProTableRequest<T, Params> = (params: Params & {
+  current?: number;
+  keyword?: string;
+  pageSize?: number;
+}, sort: Record<string, SortOrder>, filter: Record<string, (string | number | boolean)[] | null>) => Promise<Partial<ProTableRequestData<T>>>;
+type ProTableDensity = 'large' | 'medium' | 'small';
+interface ProTableOptionConfig {
+  density?: boolean;
+  fullScreen?: boolean | (() => void);
+  reload?: boolean | (() => void);
+  /** Keyword input in the toolbar; its value goes to `request` as `params[name ?? 'keyword']`. */
+  search?: boolean | {
+    name?: string;
+    onSearch?: (keyword: string) => boolean | void;
+    placeholder?: string;
+  };
+  setting?: boolean | {
+    checkable?: boolean;
+    /** Up / down buttons in the panel (drag sorting is not implemented). */
+    draggable?: boolean;
+    showListItemOption?: boolean;
+  };
+}
+interface ProTableSearchConfig {
+  /** Collapsed state (controlled). */
+  collapsed?: boolean;
+  /** Replace the collapse toggle; `false` hides it. */
+  collapseRender?: false | ((collapsed: boolean) => ReactNode);
+  /** @default true */
+  defaultCollapsed?: boolean;
+  /** Fields visible while collapsed. @default one row */
+  defaultColsNumber?: number;
+  /** `query` is the grid form; `light` is the compact filter bar. @default 'query' */
+  filterType?: 'query' | 'light';
+  /** Label column width in px; `'auto'` keeps the label width natural. @default 80 */
+  labelWidth?: number | 'auto';
+  /** Field layout of the query form. @default 'horizontal' */
+  layout?: 'horizontal' | 'vertical';
+  onCollapse?: (collapsed: boolean) => void;
+  /** Replace the action buttons; `false` hides them. */
+  optionRender?: false | ((config: {
+    form: ProTableFormInstance;
+    onReset: () => void;
+    onSubmit: () => void;
+  }, dom: ReactNode[]) => ReactNode[]);
+  resetText?: ReactNode;
+  searchText?: ReactNode;
+  /** Span of each field in a 24-column grid (`8` = 3 per row). Responsive to the width by default. */
+  span?: number;
+  submitText?: ReactNode;
+}
+interface ProTableAlertRenderProps<T> {
+  onCleanSelected: () => void;
+  selectedRowKeys: Key[];
+  selectedRows: T[];
+}
+type ProTableAlertRender<T> = false | ((props: ProTableAlertRenderProps<T>) => ReactNode);
+interface ProTableToolbarConfig {
+  actions?: ReactNode[];
+  /** Replaces the default `options` icons. */
+  settings?: ReactNode[];
+  subTitle?: ReactNode;
+  title?: ReactNode;
+  tooltip?: ReactNode;
+}
+interface ProTableLocale {
+  alertClear?: ReactNode;
+  alertSelected?: (count: number) => ReactNode;
+  collapse?: ReactNode;
+  columnSetting?: string;
+  columnSettingReset?: ReactNode;
+  columnSettingTitle?: ReactNode;
+  copy?: string;
+  density?: string;
+  densityLarge?: ReactNode;
+  densityMedium?: ReactNode;
+  densitySmall?: ReactNode;
+  expand?: ReactNode;
+  fixedEnd?: string;
+  fixedEndTitle?: ReactNode;
+  fixedStart?: string;
+  fixedStartTitle?: ReactNode;
+  fullScreen?: string;
+  moveDown?: string;
+  moveUp?: string;
+  noFixed?: string;
+  reload?: string;
+  reset?: ReactNode;
+  search?: ReactNode;
+  searchPlaceholder?: string;
+  selectPlaceholder?: string;
+  unfixedTitle?: ReactNode;
+}
+interface ProTableProps<T = any, Params = Record<string, any>> extends Omit<TableProps<T>, 'columns' | 'dataSource' | 'pagination' | 'rowSelection' | 'size' | 'title' | 'loading' | 'ref'> {
+  actionRef?: MutableRefObject<ProTableActionType | undefined> | Ref<ProTableActionType>;
+  /** Hook to reshape the form values before they become `params`. */
+  beforeSearchSubmit?: (params: Record<string, any>) => Record<string, any>;
+  /** Frame the query form / table (border, radius, padding); they are flat by default. `{ search, table }` per part. */
+  cardBordered?: boolean | {
+    search?: boolean;
+    table?: boolean;
+  };
+  /** Render cells with empty values as this. @default '-' */
+  columnEmptyText?: ReactNode | false;
+  columns?: ProColumns<T>[];
+  columnsState?: ProTableColumnsState;
+  /** Controlled data, used when there is no `request`. */
+  dataSource?: T[];
+  /** How dates in the search form are sent: `'string'` (`YYYY-MM-DD`), `'number'` (ms), `false` (Date) or a function. @default 'string' */
+  dateFormatter?: 'string' | 'number' | false | ((value: Date, valueType: string) => any);
+  /** Debounce of `params` driven fetches in ms. @default 10 */
+  debounceTime?: number;
+  defaultData?: T[];
+  /** @default 'medium' */
+  defaultSize?: ProTableDensity;
+  /** Initial values of the search form. */
+  form?: {
+    initialValues?: Record<string, any>;
+    onValuesChange?: (changed: any, all: any) => void;
+    /** base-ui Form `validateOn`. @default 'auto' */
+    validateOn?: ValidateOn;
+  };
+  formRef?: MutableRefObject<ProTableFormInstance | undefined> | Ref<ProTableFormInstance>;
+  /** Kept for ProComponents compatibility; the parts have no card background to remove. */
+  ghost?: boolean;
+  headerTitle?: ReactNode;
+  loading?: boolean;
+  locale?: TableProps<T>['locale'] & ProTableLocale;
+  /** Don't fetch on mount; call `actionRef.current.reload()` (or submit the form). */
+  manualRequest?: boolean;
+  onDataSourceChange?: (dataSource: T[]) => void;
+  onLoad?: (dataSource: T[]) => void;
+  onLoadingChange?: (loading: boolean) => void;
+  onRequestError?: (error: Error) => void;
+  onReset?: () => void;
+  onSizeChange?: (size: ProTableDensity) => void;
+  onSubmit?: (params: Record<string, any>) => void;
+  /** Toolbar icons; `false` hides them all. */
+  options?: ProTableOptionConfig | false;
+  /** `pagination.total` is filled from `request`. */
+  pagination?: false | TablePaginationConfig;
+  /** Change of reference re-fetches from page 1. */
+  params?: Params;
+  /** Polling interval in ms (min 2000), or a function of the current data. */
+  polling?: number | ((dataSource: T[]) => number);
+  /** Post-process the `request` data before it's shown. */
+  postData?: (data: T[]) => T[];
+  request?: ProTableRequest<T, Params>;
+  /** `alwaysShowAlert` keeps the alert bar while nothing is selected. */
+  rowSelection?: (TableRowSelection<T> & {
+    alwaysShowAlert?: boolean;
+  }) | false;
+  /** Query form config; `false` hides it. */
+  search?: false | ProTableSearchConfig;
+  /** Wrap / replace the search form. */
+  searchFormRender?: (props: ProTableProps<T, Params>, defaultDom: ReactNode) => ReactNode;
+  /** Controlled density. */
+  size?: ProTableDensity;
+  tableAlertOptionRender?: ProTableAlertRender<T>;
+  tableAlertRender?: ProTableAlertRender<T>;
+  tableClassName?: string;
+  /** Content between the search form and the table card. */
+  tableExtraRender?: (props: ProTableProps<T, Params>, dataSource: T[]) => ReactNode;
+  /** Arrange the parts yourself. */
+  tableRender?: (props: ProTableProps<T, Params>, defaultDom: ReactNode, domList: {
+    alert: ReactNode;
+    table: ReactNode;
+    toolbar: ReactNode;
+  }) => ReactNode;
+  tableStyle?: CSSProperties;
+  /** Light / header title config (subset of Pro `ListToolBar`). */
+  toolbar?: ProTableToolbarConfig;
+  /** Buttons on the right of the toolbar; `false` hides the whole toolbar. */
+  toolBarRender?: false | ((action: ProTableActionType | undefined, rows: {
+    selectedRowKeys?: Key[];
+    selectedRows?: T[];
+  }) => ReactNode[]);
+  /** Info icon after `headerTitle`. */
+  tooltip?: ReactNode;
+  /** Table cell style; the card follows it. @default 'borderless' */
+  variant?: TableVariant;
+}
+//#endregion
+export { ProColumnType, ProColumns, ProTableActionType, ProTableAlertRender, ProTableAlertRenderProps, ProTableColumnsState, ProTableColumnsStateItem, ProTableColumnsStateMap, ProTableDensity, ProTableFormInstance, ProTableFormRule, ProTableLocale, ProTableOptionConfig, ProTablePageInfo, ProTableProps, ProTableRequest, ProTableRequestData, ProTableSchemaConfig, ProTableSearchConfig, ProTableSearchTransform, ProTableStatus, ProTableToolbarConfig, ProTableValueEnum, ProTableValueEnumItem, ProTableValueType, type SortOrder };
+//# sourceMappingURL=type.d.mts.map

package/es/base-ui/ProTable/useFetchData.mjs

@@ -0,0 +1,98 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+//#region src/base-ui/ProTable/useFetchData.ts
+/** `request` driving: debounced fetch on deps / page change, stale-response guard, polling. */
+const useFetchData = (options) => {
+	const [data, setData] = useState(options.defaultData ?? []);
+	const [loading, setLoading] = useState(false);
+	const latest = useRef(options);
+	latest.current = options;
+	const requestId = useRef(0);
+	const [enabled, setEnabled] = useState(!options.manual);
+	const [token, setToken] = useState(0);
+	const pending = useRef([]);
+	const updateLoading = (next) => {
+		setLoading(next);
+		latest.current.onLoadingChange?.(next);
+	};
+	const run = useCallback(async () => {
+		const opts = latest.current;
+		if (!opts.request) return;
+		const id = ++requestId.current;
+		updateLoading(true);
+		try {
+			const params = { ...opts.getParams() };
+			if (opts.paginated) {
+				params.current = opts.pageInfo.current;
+				params.pageSize = opts.pageInfo.pageSize;
+			}
+			const response = await opts.request(params, opts.sort, opts.filter);
+			if (id !== requestId.current) return;
+			if (response.success === false) return;
+			const raw = response.data ?? [];
+			const next = opts.postData ? opts.postData(raw) : raw;
+			setData(next);
+			opts.setTotal(response.total ?? next.length);
+			opts.onLoad?.(next);
+			opts.onDataSourceChange?.(next);
+		} catch (error) {
+			if (id !== requestId.current) return;
+			if (opts.onRequestError) opts.onRequestError(error);
+			else console.error(error);
+		} finally {
+			if (id === requestId.current) updateLoading(false);
+			const resolvers = pending.current;
+			pending.current = [];
+			resolvers.forEach((resolve) => resolve());
+		}
+	}, []);
+	const { current, pageSize } = options.pageInfo;
+	useEffect(() => {
+		if (!enabled || !latest.current.request) return;
+		const delay = latest.current.debounceTime;
+		if (delay <= 0) {
+			run();
+			return;
+		}
+		const timer = setTimeout(() => void run(), delay);
+		return () => clearTimeout(timer);
+	}, [
+		enabled,
+		token,
+		options.depsKey,
+		current,
+		pageSize,
+		run
+	]);
+	useEffect(() => {
+		const { polling } = latest.current;
+		if (!polling || loading || !enabled) return;
+		const interval = typeof polling === "function" ? polling(data) : polling;
+		if (!interval) return;
+		const timer = setTimeout(() => void run(), Math.max(interval, 2e3));
+		return () => clearTimeout(timer);
+	}, [
+		data,
+		loading,
+		enabled,
+		options.polling,
+		run
+	]);
+	return {
+		data,
+		loading,
+		reload: useCallback(() => new Promise((resolve) => {
+			if (!latest.current.request) {
+				resolve();
+				return;
+			}
+			pending.current.push(resolve);
+			setEnabled(true);
+			setToken((value) => value + 1);
+		}), []),
+		setData
+	};
+};
+//#endregion
+export { useFetchData };
+
+//# sourceMappingURL=useFetchData.mjs.map

package/es/base-ui/ProTable/useFetchData.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFetchData.mjs","names":[],"sources":["../../../src/base-ui/ProTable/useFetchData.ts"],"sourcesContent":["import { useCallback, useEffect, useRef, useState } from 'react';\n\nimport type { SortOrder } from '@/base-ui/Table/type';\n\nimport type { ProTablePageInfo, ProTableRequest } from './type';\n\ntype Filter = Record<string, (string | number | boolean)[] | null>;\n\nexport interface UseFetchDataOptions<T> {\n  debounceTime: number;\n  defaultData?: T[];\n  /** Everything except the page that a fetch depends on, as a stable string. */\n  depsKey: string;\n  filter: Filter;\n  getParams: () => Record<string, any>;\n  manual: boolean;\n  onDataSourceChange?: (data: T[]) => void;\n  onLoad?: (data: T[]) => void;\n  onLoadingChange?: (loading: boolean) => void;\n  onRequestError?: (error: Error) => void;\n  pageInfo: ProTablePageInfo;\n  paginated: boolean;\n  polling?: number | ((data: T[]) => number);\n  postData?: (data: T[]) => T[];\n  request?: ProTableRequest<T, any>;\n  setTotal: (total: number) => void;\n  sort: Record<string, SortOrder>;\n}\n\n/** `request` driving: debounced fetch on deps / page change, stale-response guard, polling. */\nexport const useFetchData = <T>(options: UseFetchDataOptions<T>) => {\n  const [data, setData] = useState<T[]>(options.defaultData ?? []);\n  const [loading, setLoading] = useState(false);\n  const latest = useRef(options);\n  latest.current = options;\n  const requestId = useRef(0);\n  const [enabled, setEnabled] = useState(!options.manual);\n  const [token, setToken] = useState(0);\n  const pending = useRef<(() => void)[]>([]);\n\n  const updateLoading = (next: boolean) => {\n    setLoading(next);\n    latest.current.onLoadingChange?.(next);\n  };\n\n  const run = useCallback(async () => {\n    const opts = latest.current;\n    if (!opts.request) return;\n    const id = ++requestId.current;\n    updateLoading(true);\n    try {\n      const params: Record<string, any> = { ...opts.getParams() };\n      if (opts.paginated) {\n        params.current = opts.pageInfo.current;\n        params.pageSize = opts.pageInfo.pageSize;\n      }\n      const response = await opts.request(params as any, opts.sort, opts.filter);\n      if (id !== requestId.current) return;\n      if (response.success === false) {\n        // Pro keeps the previous data when the request reports failure.\n        return;\n      }\n      const raw = response.data ?? [];\n      const next = opts.postData ? opts.postData(raw) : raw;\n      setData(next);\n      opts.setTotal(response.total ?? next.length);\n      opts.onLoad?.(next);\n      opts.onDataSourceChange?.(next);\n    } catch (error) {\n      if (id !== requestId.current) return;\n      if (opts.onRequestError) opts.onRequestError(error as Error);\n      else console.error(error);\n    } finally {\n      if (id === requestId.current) updateLoading(false);\n      const resolvers = pending.current;\n      pending.current = [];\n      resolvers.forEach((resolve) => resolve());\n    }\n  }, []);\n\n  const { current, pageSize } = options.pageInfo;\n  useEffect(() => {\n    if (!enabled || !latest.current.request) return;\n    const delay = latest.current.debounceTime;\n    if (delay <= 0) {\n      void run();\n      return;\n    }\n    const timer = setTimeout(() => void run(), delay);\n    return () => clearTimeout(timer);\n  }, [enabled, token, options.depsKey, current, pageSize, run]);\n\n  // Polling: schedule the next round once the current one is done.\n  useEffect(() => {\n    const { polling } = latest.current;\n    if (!polling || loading || !enabled) return;\n    const interval = typeof polling === 'function' ? polling(data) : polling;\n    if (!interval) return;\n    const timer = setTimeout(() => void run(), Math.max(interval, 2000));\n    return () => clearTimeout(timer);\n  }, [data, loading, enabled, options.polling, run]);\n\n  /** Force a fetch (also enables a `manualRequest` table); resolves when it settles. */\n  const reload = useCallback(\n    () =>\n      new Promise<void>((resolve) => {\n        if (!latest.current.request) {\n          resolve();\n          return;\n        }\n        pending.current.push(resolve);\n        setEnabled(true);\n        setToken((value) => value + 1);\n      }),\n    [],\n  );\n\n  return { data, loading, reload, setData };\n};\n"],"mappings":";;;AA8BA,MAAa,gBAAmB,YAAoC;CAClE,MAAM,CAAC,MAAM,WAAW,SAAc,QAAQ,eAAe,CAAC,CAAC;CAC/D,MAAM,CAAC,SAAS,cAAc,SAAS,KAAK;CAC5C,MAAM,SAAS,OAAO,OAAO;CAC7B,OAAO,UAAU;CACjB,MAAM,YAAY,OAAO,CAAC;CAC1B,MAAM,CAAC,SAAS,cAAc,SAAS,CAAC,QAAQ,MAAM;CACtD,MAAM,CAAC,OAAO,YAAY,SAAS,CAAC;CACpC,MAAM,UAAU,OAAuB,CAAC,CAAC;CAEzC,MAAM,iBAAiB,SAAkB;EACvC,WAAW,IAAI;EACf,OAAO,QAAQ,kBAAkB,IAAI;CACvC;CAEA,MAAM,MAAM,YAAY,YAAY;EAClC,MAAM,OAAO,OAAO;EACpB,IAAI,CAAC,KAAK,SAAS;EACnB,MAAM,KAAK,EAAE,UAAU;EACvB,cAAc,IAAI;EAClB,IAAI;GACF,MAAM,SAA8B,EAAE,GAAG,KAAK,UAAU,EAAE;GAC1D,IAAI,KAAK,WAAW;IAClB,OAAO,UAAU,KAAK,SAAS;IAC/B,OAAO,WAAW,KAAK,SAAS;GAClC;GACA,MAAM,WAAW,MAAM,KAAK,QAAQ,QAAe,KAAK,MAAM,KAAK,MAAM;GACzE,IAAI,OAAO,UAAU,SAAS;GAC9B,IAAI,SAAS,YAAY,OAEvB;GAEF,MAAM,MAAM,SAAS,QAAQ,CAAC;GAC9B,MAAM,OAAO,KAAK,WAAW,KAAK,SAAS,GAAG,IAAI;GAClD,QAAQ,IAAI;GACZ,KAAK,SAAS,SAAS,SAAS,KAAK,MAAM;GAC3C,KAAK,SAAS,IAAI;GAClB,KAAK,qBAAqB,IAAI;EAChC,SAAS,OAAO;GACd,IAAI,OAAO,UAAU,SAAS;GAC9B,IAAI,KAAK,gBAAgB,KAAK,eAAe,KAAc;QACtD,QAAQ,MAAM,KAAK;EAC1B,UAAU;GACR,IAAI,OAAO,UAAU,SAAS,cAAc,KAAK;GACjD,MAAM,YAAY,QAAQ;GAC1B,QAAQ,UAAU,CAAC;GACnB,UAAU,SAAS,YAAY,QAAQ,CAAC;EAC1C;CACF,GAAG,CAAC,CAAC;CAEL,MAAM,EAAE,SAAS,aAAa,QAAQ;CACtC,gBAAgB;EACd,IAAI,CAAC,WAAW,CAAC,OAAO,QAAQ,SAAS;EACzC,MAAM,QAAQ,OAAO,QAAQ;EAC7B,IAAI,SAAS,GAAG;GACd,IAAS;GACT;EACF;EACA,MAAM,QAAQ,iBAAiB,KAAK,IAAI,GAAG,KAAK;EAChD,aAAa,aAAa,KAAK;CACjC,GAAG;EAAC;EAAS;EAAO,QAAQ;EAAS;EAAS;EAAU;CAAG,CAAC;CAG5D,gBAAgB;EACd,MAAM,EAAE,YAAY,OAAO;EAC3B,IAAI,CAAC,WAAW,WAAW,CAAC,SAAS;EACrC,MAAM,WAAW,OAAO,YAAY,aAAa,QAAQ,IAAI,IAAI;EACjE,IAAI,CAAC,UAAU;EACf,MAAM,QAAQ,iBAAiB,KAAK,IAAI,GAAG,KAAK,IAAI,UAAU,GAAI,CAAC;EACnE,aAAa,aAAa,KAAK;CACjC,GAAG;EAAC;EAAM;EAAS;EAAS,QAAQ;EAAS;CAAG,CAAC;CAiBjD,OAAO;EAAE;EAAM;EAAS,QAdT,kBAEX,IAAI,SAAe,YAAY;GAC7B,IAAI,CAAC,OAAO,QAAQ,SAAS;IAC3B,QAAQ;IACR;GACF;GACA,QAAQ,QAAQ,KAAK,OAAO;GAC5B,WAAW,IAAI;GACf,UAAU,UAAU,QAAQ,CAAC;EAC/B,CAAC,GACH,CAAC,CAG0B;EAAG;CAAQ;AAC1C"}

package/es/base-ui/ProTable/useSearchForm.mjs

@@ -0,0 +1,151 @@
+import { useForm } from "../FormKit/useForm.mjs";
+import { formatDateValue, getByPath, getFieldName, isDateType, isEmptyValue, isNil, resolveValueType, setByPath } from "./utils.mjs";
+import { useMemo, useRef } from "react";
+//#region src/base-ui/ProTable/useSearchForm.ts
+const NON_SEARCH_TYPES = /* @__PURE__ */ new Set([
+	"index",
+	"indexBorder",
+	"option"
+]);
+/** Flatten (group children included) and pick the columns that show in the search form. */
+const getSearchFields = (columns = []) => {
+	const list = [];
+	const walk = (items) => {
+		items.forEach((column) => {
+			if (column.children?.length) {
+				walk(column.children);
+				return;
+			}
+			const index = list.length;
+			const valueType = resolveValueType(column);
+			if (column.hideInSearch || column.search === false) return;
+			if (valueType && NON_SEARCH_TYPES.has(valueType)) return;
+			if (isNil(column.dataIndex) && isNil(column.key) && !column.renderFormItem) return;
+			list.push({
+				column,
+				index,
+				name: getFieldName(column, index)
+			});
+		});
+	};
+	walk(columns);
+	return list.map((field, position) => ({
+		field,
+		position
+	})).sort((a, b) => (b.field.column.order ?? 0) - (a.field.column.order ?? 0) || a.position - b.position).map(({ field }) => field);
+};
+const ruleLength = (value) => typeof value === "string" || Array.isArray(value) ? value.length : Number(value);
+/**
+* antd-style `rules` → the base-ui Form field props: the first `required` rule becomes
+* `required` (its `message` is the text), the rest run in order through one `validate`.
+*/
+const rulesToFieldProps = (rules, required) => {
+	const list = rules ?? [];
+	const requiredRule = list.find((rule) => rule.required);
+	const rest = list.filter((rule) => !rule.required || Object.keys(rule).length > 2);
+	const result = {};
+	if (requiredRule) result.required = requiredRule.message ? String(requiredRule.message) : true;
+	else if (required) result.required = true;
+	if (rest.length === 0) return result;
+	result.validate = async (value, values) => {
+		for (const rule of rest) {
+			const message = rule.message ? String(rule.message) : void 0;
+			if (rule.validator) {
+				try {
+					await rule.validator(rule, value, values);
+				} catch (error) {
+					return (error instanceof Error ? error.message : String(error ?? "")) || message || "Invalid value";
+				}
+				continue;
+			}
+			if (isEmptyValue(value)) continue;
+			if (rule.pattern && !rule.pattern.test(String(value))) return message ?? "Invalid format";
+			if (rule.len !== void 0 && ruleLength(value) !== rule.len) return message ?? `Must be ${rule.len}`;
+			if (rule.min !== void 0 && ruleLength(value) < rule.min) return message ?? `At least ${rule.min}`;
+			if (rule.max !== void 0 && ruleLength(value) > rule.max) return message ?? `At most ${rule.max}`;
+		}
+	};
+	return result;
+};
+/**
+* The search form instance: a base-ui `useForm` instance (validation, `reset`, `subscribe` …)
+* with the antd-style aliases ProTable users expect (`getFieldsValue`, `setFieldsValue`,
+* `resetFields`, `validateFields`, `getFieldsFormatValue`).
+*/
+const useSearchForm = ({ dateFormatter, fields, initialValues, onSubmit, onValuesChange, validateOn }) => {
+	const latest = useRef({
+		dateFormatter,
+		fields,
+		onSubmit
+	});
+	latest.current = {
+		dateFormatter,
+		fields,
+		onSubmit
+	};
+	const [initial] = useMemo(() => {
+		const values = {};
+		fields.forEach(({ column, name }) => {
+			if (column.initialValue !== void 0) setByPath(values, name, column.initialValue);
+		});
+		return [{
+			...values,
+			...initialValues
+		}];
+	}, []);
+	const format = (raw) => {
+		const { dateFormatter: formatter, fields: list } = latest.current;
+		const result = {};
+		const fieldRoots = new Set(list.map((field) => field.name.split(".")[0]));
+		Object.entries(raw).forEach(([key, value]) => {
+			if (!fieldRoots.has(key) && !isEmptyValue(value)) result[key] = value;
+		});
+		list.forEach(({ column, name }) => {
+			const value = getByPath(raw, name.split("."));
+			if (isEmptyValue(value)) return;
+			const valueType = resolveValueType(column);
+			let next = valueType && isDateType(valueType) ? formatDateValue(value, valueType, formatter) : value;
+			const { search } = column;
+			if (search && typeof search === "object" && search.transform) {
+				const transformed = search.transform(next, name, raw);
+				if (transformed && typeof transformed === "object") {
+					Object.assign(result, transformed);
+					return;
+				}
+				if (typeof transformed === "string") {
+					setByPath(result, transformed, next);
+					return;
+				}
+				next = transformed;
+			}
+			setByPath(result, name, next);
+		});
+		return result;
+	};
+	const base = useForm({
+		initialValues: initial,
+		onSubmit: (values) => latest.current.onSubmit(format(values)),
+		onValuesChange,
+		validateOn
+	});
+	return {
+		base,
+		form: useMemo(() => Object.assign(base, {
+			getFieldsFormatValue: () => format(base.getValues()),
+			getFieldsValue: () => base.getValues(),
+			getFieldValue: (name) => base.getValue(name),
+			resetFields: () => base.reset(structuredClone(initial)),
+			setFieldsValue: (values) => base.setValues(values),
+			setFieldValue: (name, value) => base.setValue(name, value),
+			validateFields: async () => {
+				const result = await base.validate();
+				if (!result.valid) throw result;
+				return base.getValues();
+			}
+		}), [base])
+	};
+};
+//#endregion
+export { getSearchFields, rulesToFieldProps, useSearchForm };
+
+//# sourceMappingURL=useSearchForm.mjs.map

package/es/base-ui/ProTable/useSearchForm.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSearchForm.mjs","names":[],"sources":["../../../src/base-ui/ProTable/useSearchForm.ts"],"sourcesContent":["import {\n  type FieldValidate,\n  type FormValues,\n  useForm,\n  type UseFormOptions,\n} from '@lobehub/ui/base-ui/form';\nimport { useMemo, useRef } from 'react';\n\nimport type { ProColumnType, ProTableFormInstance, ProTableFormRule } from './type';\nimport {\n  type DateFormatter,\n  formatDateValue,\n  getByPath,\n  getFieldName,\n  isDateType,\n  isEmptyValue,\n  isNil,\n  resolveValueType,\n  setByPath,\n} from './utils';\n\ntype ValidateOn = UseFormOptions<FormValues>['validateOn'];\n\nexport interface SearchFieldSchema {\n  column: ProColumnType<any>;\n  index: number;\n  name: string;\n}\n\nconst NON_SEARCH_TYPES = new Set(['index', 'indexBorder', 'option']);\n\n/** Flatten (group children included) and pick the columns that show in the search form. */\nexport const getSearchFields = (columns: ProColumnType<any>[] = []): SearchFieldSchema[] => {\n  const list: SearchFieldSchema[] = [];\n  const walk = (items: ProColumnType<any>[]) => {\n    items.forEach((column) => {\n      if (column.children?.length) {\n        walk(column.children);\n        return;\n      }\n      const index = list.length;\n      const valueType = resolveValueType(column);\n      if (column.hideInSearch || column.search === false) return;\n      if (valueType && NON_SEARCH_TYPES.has(valueType)) return;\n      if (isNil(column.dataIndex) && isNil(column.key) && !column.renderFormItem) return;\n      list.push({ column, index, name: getFieldName(column, index) });\n    });\n  };\n  walk(columns);\n  // Pro: larger `order` first; stable for equal orders.\n  return list\n    .map((field, position) => ({ field, position }))\n    .sort(\n      (a, b) =>\n        (b.field.column.order ?? 0) - (a.field.column.order ?? 0) || a.position - b.position,\n    )\n    .map(({ field }) => field);\n};\n\nconst ruleLength = (value: unknown) =>\n  typeof value === 'string' || Array.isArray(value) ? value.length : Number(value);\n\n/**\n * antd-style `rules` → the base-ui Form field props: the first `required` rule becomes\n * `required` (its `message` is the text), the rest run in order through one `validate`.\n */\nexport const rulesToFieldProps = (\n  rules: ProTableFormRule[] | undefined,\n  required?: boolean,\n): { required?: boolean | string; validate?: FieldValidate } => {\n  const list = rules ?? [];\n  const requiredRule = list.find((rule) => rule.required);\n  const rest = list.filter((rule) => !rule.required || Object.keys(rule).length > 2);\n  const result: { required?: boolean | string; validate?: FieldValidate } = {};\n  if (requiredRule) result.required = requiredRule.message ? String(requiredRule.message) : true;\n  else if (required) result.required = true;\n  if (rest.length === 0) return result;\n  result.validate = async (value, values) => {\n    for (const rule of rest) {\n      const message = rule.message ? String(rule.message) : undefined;\n      if (rule.validator) {\n        try {\n          await rule.validator(rule, value, values);\n        } catch (error) {\n          return (\n            (error instanceof Error ? error.message : String(error ?? '')) ||\n            message ||\n            'Invalid value'\n          );\n        }\n        continue;\n      }\n      if (isEmptyValue(value)) continue;\n      if (rule.pattern && !rule.pattern.test(String(value))) return message ?? 'Invalid format';\n      if (rule.len !== undefined && ruleLength(value) !== rule.len)\n        return message ?? `Must be ${rule.len}`;\n      if (rule.min !== undefined && ruleLength(value) < rule.min)\n        return message ?? `At least ${rule.min}`;\n      if (rule.max !== undefined && ruleLength(value) > rule.max)\n        return message ?? `At most ${rule.max}`;\n    }\n    return undefined;\n  };\n  return result;\n};\n\nexport interface UseSearchFormOptions {\n  dateFormatter: DateFormatter;\n  fields: SearchFieldSchema[];\n  initialValues?: Record<string, any>;\n  onSubmit: (formatted: Record<string, any>) => void;\n  onValuesChange?: (changed: Record<string, any>, all: Record<string, any>) => void;\n  validateOn?: ValidateOn;\n}\n\n/**\n * The search form instance: a base-ui `useForm` instance (validation, `reset`, `subscribe` …)\n * with the antd-style aliases ProTable users expect (`getFieldsValue`, `setFieldsValue`,\n * `resetFields`, `validateFields`, `getFieldsFormatValue`).\n */\nexport const useSearchForm = ({\n  dateFormatter,\n  fields,\n  initialValues,\n  onSubmit,\n  onValuesChange,\n  validateOn,\n}: UseSearchFormOptions) => {\n  const latest = useRef({ dateFormatter, fields, onSubmit });\n  latest.current = { dateFormatter, fields, onSubmit };\n\n  const [initial] = useMemo(() => {\n    const values: Record<string, any> = {};\n    fields.forEach(({ column, name }) => {\n      if (column.initialValue !== undefined) setByPath(values, name, column.initialValue);\n    });\n    return [{ ...values, ...initialValues }];\n    // Initial values are read once, like antd / Pro.\n  }, []);\n\n  const format = (raw: Record<string, any>) => {\n    const { dateFormatter: formatter, fields: list } = latest.current;\n    const result: Record<string, any> = {};\n    const fieldRoots = new Set(list.map((field) => field.name.split('.')[0]));\n    // Values set through `formRef` without a matching field pass through untouched.\n    Object.entries(raw).forEach(([key, value]) => {\n      if (!fieldRoots.has(key) && !isEmptyValue(value)) result[key] = value;\n    });\n    list.forEach(({ column, name }) => {\n      const value = getByPath(raw, name.split('.'));\n      if (isEmptyValue(value)) return;\n      const valueType = resolveValueType(column);\n      let next =\n        valueType && isDateType(valueType) ? formatDateValue(value, valueType, formatter) : value;\n      const { search } = column;\n      if (search && typeof search === 'object' && search.transform) {\n        const transformed = search.transform(next, name, raw);\n        if (transformed && typeof transformed === 'object') {\n          Object.assign(result, transformed);\n          return;\n        }\n        if (typeof transformed === 'string') {\n          setByPath(result, transformed, next);\n          return;\n        }\n        next = transformed;\n      }\n      setByPath(result, name, next);\n    });\n    return result;\n  };\n\n  const base = useForm<Record<string, any>>({\n    initialValues: initial,\n    onSubmit: (values) => latest.current.onSubmit(format(values)),\n    onValuesChange,\n    validateOn,\n  });\n\n  // Aliases go onto the instance itself: base-ui `Form` looks the instance up by identity.\n  const form = useMemo<ProTableFormInstance>(\n    () =>\n      Object.assign(base, {\n        getFieldsFormatValue: () => format(base.getValues()),\n        getFieldsValue: () => base.getValues(),\n        getFieldValue: (name: string) => base.getValue(name),\n        // base-ui `reset()` returns to the last submitted values; Pro resets to the initial ones.\n        resetFields: () => base.reset(structuredClone(initial)),\n        setFieldsValue: (values: Record<string, any>) => base.setValues(values),\n        setFieldValue: (name: string, value: any) => base.setValue(name, value),\n        validateFields: async () => {\n          const result = await base.validate();\n          if (!result.valid) throw result;\n          return base.getValues();\n        },\n      }) as ProTableFormInstance,\n    // `format` only reads `latest`.\n    [base],\n  );\n\n  return { base, form };\n};\n"],"mappings":"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"}