@_tc/template-core 0.0.1 → 0.0.2

package/fe/packages/ui/react/hooks/usePagination.js

@@ -0,0 +1,27 @@
+import { useCallback, useRef, useState } from 'react';
+import useInit from './useInit';
+export default function usePagination(params) {
+    const initValue = {
+        ...(params?.defaultValue ?? { current: 1, size: 10, total: 0 }),
+        onChange: () => { },
+    };
+    const paginationData = useRef({ ...initValue });
+    const [, changeView] = useState(0);
+    const updata = useCallback((params) => {
+        if (typeof params.current !== 'undefined') {
+            paginationData.current.current = params.current;
+        }
+        if (typeof params.size !== 'undefined') {
+            paginationData.current.size = params.size;
+        }
+        if (typeof params.total !== 'undefined') {
+            paginationData.current.total = params.total;
+        }
+        if ([params.size, params.current, params.total].some((i) => typeof i !== 'undefined'))
+            changeView((e) => e + 1);
+    }, []);
+    useInit(() => {
+        paginationData.current.onChange = updata;
+    });
+    return paginationData;
+}

package/fe/packages/ui/react/hooks/useRefState.d.ts

@@ -0,0 +1,30 @@
+import { RefObject } from 'react';
+type SetState<S> = (value: S | ((preValue: S) => S), callback?: CallBackFN<S>) => void;
+type CallBackFN<T> = (value: T) => void;
+type RefState<T> = RefObject<{
+    data: T;
+}>;
+/**
+ *
+ * @demo
+ * ```
+    const [data, setData, dataRef] = useState(0);
+    
+    setData(1, (newData) => {
+        // newData 1
+        // data 0
+    })
+ * ```
+ */
+export default function useRefState<S>(initialState: S | (() => S)): [
+    S,
+    SetState<S>,
+    RefState<S>
+];
+export default function useRefState<S = undefined>(): [
+    S | undefined,
+    SetState<S | undefined>,
+    RefState<S | undefined>
+];
+export {};
+//# sourceMappingURL=useRefState.d.ts.map

package/fe/packages/ui/react/hooks/useRefState.js

@@ -0,0 +1,29 @@
+import { useState as RUS, useCallback, useLayoutEffect, useRef } from 'react';
+import useInit from './useInit';
+export default function useRefState(initialState) {
+    const [v, setValue] = RUS(initialState);
+    const data = useRef({ data: undefined });
+    const callbackRef = useRef(null);
+    const [callbackVersion, setCallbackVersion] = RUS(0);
+    useInit(() => {
+        data.current.data = v;
+    });
+    const setData = useCallback((action, callback) => {
+        const value = typeof action === 'function' ? action(data.current.data) : action;
+        setValue(value);
+        data.current.data = value;
+        if (callback) {
+            callbackRef.current = callback;
+            setCallbackVersion((version) => version + 1);
+        }
+    }, [setCallbackVersion, setValue]);
+    useLayoutEffect(() => {
+        if (callbackRef.current) {
+            const callback = callbackRef.current;
+            callbackRef.current = null;
+            callback(data.current.data);
+        }
+    }, [callbackVersion]);
+    return [v, setData, data];
+    // as [ExtractFNType<S>, SetState<S>];
+}

package/fe/packages/ui/react/hooks/useWatch.d.ts

@@ -0,0 +1,23 @@
+export type WatchCallback<T> = (value: T, prevValue: T | undefined) => void | (() => void);
+export type WatchCompare<T> = (value: T, prevValue: T) => boolean;
+export type WatchCompareType = 'identity' | 'shallow';
+export type WatchSelector<TSource, TValue> = (source: TSource) => TValue;
+export type UseWatchOptions<T> = {
+    /**
+     * @default false
+     */
+    immediate?: boolean;
+    /**
+     * Return true when the two values should be treated as equal.
+     *
+     * @default Array values use shallow compare, other values use Object.is.
+     */
+    compare?: WatchCompareType | WatchCompare<T>;
+};
+export declare const identityCompare: <T>(value: T, prevValue: T) => boolean;
+export declare const shallowCompare: <T>(value: T, prevValue: T) => boolean;
+export declare const defaultCompare: <T>(value: T, prevValue: T) => boolean;
+export declare function useWatch<T>(value: T, callback: WatchCallback<T>, options?: UseWatchOptions<T>): void;
+export declare function useWatch<TSource, TValue>(source: TSource, selector: WatchSelector<TSource, TValue>, callback: WatchCallback<TValue>, options?: UseWatchOptions<TValue>): void;
+export default useWatch;
+//# sourceMappingURL=useWatch.d.ts.map

package/fe/packages/ui/react/hooks/useWatch.js

@@ -0,0 +1,87 @@
+import { useEffect, useRef } from 'react';
+export const identityCompare = (value, prevValue) => Object.is(value, prevValue);
+export const shallowCompare = (value, prevValue) => {
+    if (Object.is(value, prevValue)) {
+        return true;
+    }
+    if (Array.isArray(value) && Array.isArray(prevValue)) {
+        if (value.length !== prevValue.length) {
+            return false;
+        }
+        return value.every((item, index) => Object.is(item, prevValue[index]));
+    }
+    if (value &&
+        prevValue &&
+        typeof value === 'object' &&
+        typeof prevValue === 'object') {
+        const valuePrototype = Object.getPrototypeOf(value);
+        const prevValuePrototype = Object.getPrototypeOf(prevValue);
+        if (valuePrototype !== prevValuePrototype ||
+            (valuePrototype !== Object.prototype && valuePrototype !== null)) {
+            return false;
+        }
+        const valueKeys = Object.keys(value);
+        const prevValueKeys = Object.keys(prevValue);
+        if (valueKeys.length !== prevValueKeys.length) {
+            return false;
+        }
+        return valueKeys.every((key) => Object.prototype.hasOwnProperty.call(prevValue, key) &&
+            Object.is(value[key], prevValue[key]));
+    }
+    return false;
+};
+export const defaultCompare = (value, prevValue) => {
+    if (Array.isArray(value) && Array.isArray(prevValue)) {
+        return shallowCompare(value, prevValue);
+    }
+    return identityCompare(value, prevValue);
+};
+const getCompare = (compare) => {
+    if (compare === 'identity') {
+        return identityCompare;
+    }
+    if (compare === 'shallow') {
+        return shallowCompare;
+    }
+    return compare ?? defaultCompare;
+};
+const useStableWatchValue = (value, compare) => {
+    const valueRef = useRef(value);
+    if (!compare(value, valueRef.current)) {
+        valueRef.current = value;
+    }
+    return valueRef.current;
+};
+export function useWatch(source, selectorOrCallback, callbackOrOptions, options) {
+    const hasSelector = typeof callbackOrOptions === 'function';
+    const selector = hasSelector ? selectorOrCallback : null;
+    const callback = hasSelector
+        ? callbackOrOptions
+        : selectorOrCallback;
+    const watchOptions = hasSelector ? options : callbackOrOptions;
+    const nextValue = selector ? selector(source) : source;
+    const stableValue = useStableWatchValue(nextValue, getCompare(watchOptions?.compare));
+    const isInit = useRef(false);
+    const valueRef = useRef(stableValue);
+    const callbackRef = useRef(callback);
+    const optionsRef = useRef(watchOptions);
+    callbackRef.current = callback;
+    optionsRef.current = watchOptions;
+    useEffect(() => {
+        if (!isInit.current) {
+            isInit.current = true;
+            valueRef.current = stableValue;
+            if (optionsRef.current?.immediate) {
+                return callbackRef.current(stableValue, undefined);
+            }
+            return;
+        }
+        const prevValue = valueRef.current;
+        if (Object.is(stableValue, prevValue)) {
+            return;
+        }
+        valueRef.current = stableValue;
+        return callbackRef.current(stableValue, prevValue);
+    }, [stableValue]);
+}
+export default useWatch;

package/fe/packages/ui/react/hooks/useWatch.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=useWatch.test.d.ts.map

package/fe/packages/ui/react/hooks/useWatch.test.js

@@ -0,0 +1,22 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { defaultCompare, identityCompare, shallowCompare } from './useWatch';
+test('defaultCompare treats inline arrays with the same items as equal', () => {
+    assert.equal(defaultCompare([1, 'a'], [1, 'a']), true);
+});
+test('defaultCompare detects changed array items', () => {
+    assert.equal(defaultCompare([1, 'a'], [1, 'b']), false);
+});
+test('defaultCompare uses identity for object values', () => {
+    assert.equal(defaultCompare({ current: 1 }, { current: 1 }), false);
+});
+test('identityCompare detects changed array references', () => {
+    assert.equal(identityCompare([1, 2], [1, 2]), false);
+});
+test('shallowCompare supports selector array results', () => {
+    assert.equal(shallowCompare([1, 10], [1, 10]), true);
+    assert.equal(shallowCompare([1, 10], [2, 10]), false);
+});
+test('shallowCompare does not treat non-plain objects as equal by empty keys', () => {
+    assert.equal(shallowCompare(new Date(0), new Date(0)), false);
+});

package/fe/packages/ui/react/i18n/I18nProvider.d.ts

@@ -0,0 +1,31 @@
+import type { I18nLanguage, I18nResources } from '../../../common/i18n';
+import { type ReactNode } from 'react';
+export interface I18nProviderProps {
+    /**
+     * 外部控制的显示语言。
+     */
+    language?: I18nLanguage;
+    /**
+     * 未命中当前语言文案时的兜底语言。
+     */
+    fallbackLanguage?: I18nLanguage;
+    /**
+     * 业务侧注入的多语言资源。
+     */
+    resources?: I18nResources;
+    /**
+     * 是否把传入 resources 和现有 resources 合并。默认 true。
+     */
+    mergeResources?: boolean;
+    /**
+     * 是否把 language 写入 localStorage。默认 true。
+     */
+    persist?: boolean;
+    /**
+     * localStorage key。
+     */
+    storageKey?: string;
+    children: ReactNode;
+}
+export declare function I18nProvider({ language, fallbackLanguage, resources, mergeResources, persist, storageKey, children, }: I18nProviderProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=I18nProvider.d.ts.map

package/fe/packages/ui/react/i18n/I18nProvider.js

@@ -0,0 +1,25 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { defaultLanguage, languageLocalKey } from '../../../common/i18n';
+import { useEffect } from 'react';
+import { useI18nStore } from './useI18n';
+export function I18nProvider({ language = defaultLanguage, fallbackLanguage = defaultLanguage, resources, mergeResources = true, persist = true, storageKey = languageLocalKey, children, }) {
+    const configureI18n = useI18nStore((state) => state.configureI18n);
+    const setLanguage = useI18nStore((state) => state.setLanguage);
+    const setFallbackLanguage = useI18nStore((state) => state.setFallbackLanguage);
+    const setResources = useI18nStore((state) => state.setResources);
+    useEffect(() => {
+        configureI18n({ persist, storageKey });
+    }, [configureI18n, persist, storageKey]);
+    useEffect(() => {
+        setLanguage(language);
+    }, [language, setLanguage]);
+    useEffect(() => {
+        setFallbackLanguage(fallbackLanguage);
+    }, [fallbackLanguage, setFallbackLanguage]);
+    useEffect(() => {
+        if (!resources)
+            return;
+        setResources(resources, { merge: mergeResources });
+    }, [mergeResources, resources, setResources]);
+    return _jsx(_Fragment, { children: children });
+}

package/fe/packages/ui/react/i18n/index.d.ts

@@ -0,0 +1,4 @@
+export * from '../../../common/i18n';
+export * from './I18nProvider';
+export * from './useI18n';
+//# sourceMappingURL=index.d.ts.map

package/fe/packages/ui/react/i18n/index.js

@@ -0,0 +1,3 @@
+export * from '../../../common/i18n';
+export * from './I18nProvider';
+export * from './useI18n';

package/fe/packages/ui/react/i18n/useI18n.d.ts

@@ -0,0 +1,13 @@
+import type { I18nInterpolationValues, I18nTranslateOptions } from '../../../common/i18n';
+export declare const useI18nStore: import("..").StoreHook<{
+    getState: () => import("..").I18nStore;
+    getInitialState: () => import("..").I18nStore;
+    setState: (partial: Partial<import("..").I18nStore> | ((state: import("..").I18nStore) => Partial<import("..").I18nStore>)) => void;
+    subscribe: (listener: import("..").I18nStoreListener) => () => void;
+}>;
+/**
+ * React 组件内使用的翻译 hook。
+ * 会订阅 language、fallbackLanguage、resources，语言或资源变化时触发组件更新。
+ */
+export declare function useI18n(): <T = string>(key: string, fillingData?: I18nInterpolationValues, options?: I18nTranslateOptions) => string | T;
+//# sourceMappingURL=useI18n.d.ts.map

package/fe/packages/ui/react/i18n/useI18n.js

@@ -0,0 +1,18 @@
+import { i18nStore, translate } from '../../../common/i18n';
+import { useCallback } from 'react';
+import { createStoreHook } from '../lib/createStoreHook';
+export const useI18nStore = createStoreHook(i18nStore);
+/**
+ * React 组件内使用的翻译 hook。
+ * 会订阅 language、fallbackLanguage、resources，语言或资源变化时触发组件更新。
+ */
+export function useI18n() {
+    const language = useI18nStore((state) => state.language);
+    const fallbackLanguage = useI18nStore((state) => state.fallbackLanguage);
+    const resources = useI18nStore((state) => state.resources);
+    return useCallback((key, fillingData, options) => translate({
+        language,
+        fallbackLanguage,
+        resources,
+    }, key, fillingData, options), [fallbackLanguage, language, resources]);
+}

package/fe/packages/ui/react/index.css

@@ -0,0 +1,238 @@
+@import "tailwindcss";
+
+/* 内容扫描 */
+/* baseComponents */
+@source "./**/*.{js,ts,jsx,tsx}";
+
+/* 暗色模式变体 */
+@custom-variant dark (&:where(.dark, .dark *));
+
+/* 主题配置 */
+@theme {
+  /* 圆角 */
+  --radius-lg: var(--radius);
+  --radius-md: calc(var(--radius) - 2px);
+  --radius-sm: calc(var(--radius) - 4px);
+
+  /* 颜色 */
+  --color-background: hsl(var(--background));
+  --color-foreground: hsl(var(--foreground));
+
+  --color-card: hsl(var(--card));
+  --color-card-foreground: hsl(var(--card-foreground));
+
+  --color-popover: hsl(var(--popover));
+  --color-popover-foreground: hsl(var(--popover-foreground));
+
+  --color-primary: hsl(var(--primary));
+  --color-primary-foreground: hsl(var(--primary-foreground));
+
+  --color-secondary: hsl(var(--secondary));
+  --color-secondary-foreground: hsl(var(--secondary-foreground));
+
+  --color-muted: hsl(var(--muted));
+  --color-muted-foreground: hsl(var(--muted-foreground));
+
+  --color-accent: hsl(var(--accent));
+  --color-accent-foreground: hsl(var(--accent-foreground));
+
+  --color-destructive: hsl(var(--destructive));
+  --color-destructive-foreground: hsl(var(--destructive-foreground));
+
+  --color-border: hsl(var(--border));
+  --color-input: hsl(var(--input));
+  --color-ring: hsl(var(--ring));
+
+  --color-chart-1: hsl(var(--chart-1));
+  --color-chart-2: hsl(var(--chart-2));
+  --color-chart-3: hsl(var(--chart-3));
+  --color-chart-4: hsl(var(--chart-4));
+  --color-chart-5: hsl(var(--chart-5));
+
+  /* 主题色 - 与 @layer base 中的 CSS 变量对应 */
+  --color-theme: hsl(var(--theme-primary));
+  --color-theme-foreground: hsl(var(--theme-primary-foreground));
+  --color-theme-bg: hsl(var(--theme-bg));
+  --color-theme-text: hsl(var(--theme-text));
+
+  /* 表格颜色 */
+  --color-table-header: hsl(var(--table-header-bg));
+  --color-table-header-text: hsl(var(--table-header-text));
+  --color-table-head-text: hsl(var(--table-head-text));
+  --color-table-cell-text: hsl(var(--table-cell-text));
+  --color-table-action: hsl(var(--table-action-bg));
+  --color-table-action-text: hsl(var(--table-action-text));
+
+  /* 面包屑颜色 */
+  --color-breadcrumb-text: hsl(var(--breadcrumb-text));
+  --color-breadcrumb-border: hsl(var(--breadcrumb-border));
+  --color-breadcrumb-active-text: hsl(var(--breadcrumb-active-text));
+  --color-breadcrumb-active-bg: hsl(var(--breadcrumb-active-bg));
+}
+
+/* CSS 变量定义 */
+:root {
+  --background: 0 0% 100%;
+  --foreground: 240 10% 3.9%;
+  --card: 0 0% 100%;
+  --card-foreground: 240 10% 3.9%;
+  --popover: 0 0% 100%;
+  --popover-foreground: 240 10% 3.9%;
+  --primary: 240 5.9% 10%;
+  --primary-foreground: 0 0% 98%;
+  --secondary: 240 4.8% 95.9%;
+  --secondary-foreground: 240 5.9% 10%;
+  --muted: 240 4.8% 95.9%;
+  --muted-foreground: 240 3.8% 46.1%;
+  --accent: 240 4.8% 95.9%;
+  --accent-foreground: 240 5.9% 10%;
+  --destructive: 0 84.2% 60.2%;
+  --destructive-foreground: 0 0% 98%;
+  --border: 240 5.9% 90%;
+  --input: 240 5.9% 90%;
+  --ring: 240 5.9% 10%;
+  --radius: 0.5rem;
+  --chart-1: 12 76% 61%;
+  --chart-2: 173 58% 39%;
+  --chart-3: 197 37% 24%;
+  --chart-4: 43 74% 66%;
+  --chart-5: 27 87% 67%;
+
+  /* 主题色 - 默认亮色中性主题 */
+  --theme-primary: 0 0% 0%;
+  --theme-primary-foreground: 0 0% 100%;
+  --theme-bg: 210 20% 98%;
+  --theme-text: 222 47% 11%;
+
+  /* 表格颜色 - 默认亮色中性主题 */
+  --table-header-bg: 220 14% 96%;
+  --table-header-text: 220 9% 46%;
+  --table-head-text: 217 19% 27%;
+  --table-cell-text: 180 4% 16%;
+  --table-action-bg: 220 13% 91%;
+  --table-action-text: 0 0% 0%;
+
+  /* 面包屑颜色 - 默认亮色中性主题 */
+  --breadcrumb-text: 220 10% 46%;
+  --breadcrumb-border: 0 0% 88%;
+  --breadcrumb-active-text: 0 0% 100%;
+  --breadcrumb-active-bg: 0 0% 0%;
+}
+
+/* 绿色主题 */
+[data-theme='green'] {
+  --theme-primary: 142 76% 36%;
+  --theme-primary-foreground: 0 0% 100%;
+  --theme-bg: 120 25% 93%;
+  --theme-text: 141 48% 13%;
+
+  --table-header-bg: 0 0% 88%;
+  --table-header-text: 120 4% 16%;
+  --table-head-text: 120 4% 16%;
+  --table-cell-text: 120 4% 16%;
+  --table-action-bg: 120 25% 93% / 0.8;
+  --table-action-text: 141 48% 13%;
+
+  --breadcrumb-text: 0 0% 27%;
+  --breadcrumb-border: 0 0% 88%;
+  --breadcrumb-active-text: 141 48% 13%;
+  --breadcrumb-active-bg: 140 96% 72%;
+}
+
+/* 暗色模式 */
+.dark {
+  --background: 240 10% 8%;
+  --foreground: 0 0% 95%;
+  --card: 240 10% 8%;
+  --card-foreground: 0 0% 95%;
+  --popover: 240 10% 8%;
+  --popover-foreground: 0 0% 95%;
+  --primary: 0 0% 95%;
+  --primary-foreground: 240 5% 15%;
+  --secondary: 240 6% 20%;
+  --secondary-foreground: 0 0% 95%;
+  --muted: 240 6% 20%;
+  --muted-foreground: 240 5% 75%;
+  --accent: 240 6% 20%;
+  --accent-foreground: 0 0% 95%;
+  --destructive: 0 70% 40%;
+  --destructive-foreground: 0 0% 98%;
+  --border: 240 6% 20%;
+  --input: 240 6% 20%;
+  --ring: 240 4.9% 83.9%;
+  --chart-1: 220 70% 50%;
+  --chart-2: 160 60% 45%;
+  --chart-3: 30 80% 55%;
+  --chart-4: 280 65% 60%;
+  --chart-5: 340 75% 55%;
+
+  /* 主题色调整 */
+  --theme-primary: 0 0% 92%;
+  --theme-primary-foreground: 240 10% 10%;
+  --theme-bg: 240 8% 12%;
+  --theme-text: 0 0% 95%;
+
+  /* 表格颜色优化 */
+  --table-header-bg: 240 5% 18%;
+  --table-header-text: 240 5% 75%;
+  --table-head-text: 240 5% 85%;
+  --table-cell-text: 0 0% 90%;
+  --table-action-bg: 240 5% 22%;
+  --table-action-text: 0 0% 95%;
+
+  /* 面包屑颜色优化 */
+  --breadcrumb-text: 240 5% 72%;
+  --breadcrumb-border: 240 4% 24%;
+  --breadcrumb-active-text: 240 10% 10%;
+  --breadcrumb-active-bg: 0 0% 92%;
+}
+
+.dark[data-theme='green'],
+.dark [data-theme='green'] {
+  --theme-primary: 142 68% 46%;
+  --theme-primary-foreground: 0 0% 100%;
+  --theme-bg: 145 22% 14%;
+  --theme-text: 140 30% 92%;
+
+  --table-header-bg: 145 18% 18%;
+  --table-header-text: 142 20% 72%;
+  --table-head-text: 140 24% 88%;
+  --table-cell-text: 140 18% 90%;
+  --table-action-bg: 145 16% 22%;
+  --table-action-text: 140 24% 88%;
+
+  --breadcrumb-text: 142 16% 72%;
+  --breadcrumb-border: 145 12% 26%;
+  --breadcrumb-active-text: 0 0% 100%;
+  --breadcrumb-active-bg: 142 68% 46%;
+}
+
+/* 中间态主题 */
+[data-theme='gray'] {
+  --theme-primary: 220 9% 38%;
+  --theme-primary-foreground: 0 0% 100%;
+  --theme-bg: 220 16% 92%;
+  --theme-text: 222 20% 22%;
+
+  --table-header-bg: 220 12% 90%;
+  --table-header-text: 220 9% 38%;
+  --table-head-text: 220 15% 24%;
+  --table-cell-text: 220 10% 22%;
+  --table-action-bg: 220 11% 86%;
+  --table-action-text: 220 15% 24%;
+
+  --breadcrumb-text: 220 10% 40%;
+  --breadcrumb-border: 220 10% 82%;
+  --breadcrumb-active-text: 0 0% 100%;
+  --breadcrumb-active-bg: 220 9% 38%;
+}
+
+/* 全局样式 */
+* {
+  border-color: hsl(var(--border));
+}
+
+body {
+  background-color: hsl(var(--background));
+  color: hsl(var(--foreground));
+}

package/fe/packages/ui/react/index.d.ts

@@ -0,0 +1,5 @@
+export * from './components';
+export * from './i18n';
+export * from './lib/createStoreHook';
+export * from './lib/utils';
+//# sourceMappingURL=index.d.ts.map

package/fe/packages/ui/react/index.js

@@ -0,0 +1,6 @@
+export * from './components';
+export * from './i18n';
+// export * from './hooks'
+// export * from './stores'
+export * from './lib/createStoreHook';
+export * from './lib/utils';

package/fe/packages/ui/react/lib/createStoreHook.d.ts

@@ -0,0 +1,9 @@
+import type { ExtractState, StoreApi } from 'zustand/vanilla';
+type ReadonlyStoreApi<T> = Pick<StoreApi<T>, 'getState' | 'getInitialState' | 'subscribe'>;
+export type StoreHook<TStore extends ReadonlyStoreApi<unknown>> = {
+    (): ExtractState<TStore>;
+    <T>(selector: (state: ExtractState<TStore>) => T): T;
+};
+export declare function createStoreHook<TStore extends ReadonlyStoreApi<unknown>>(store: TStore): StoreHook<TStore>;
+export {};
+//# sourceMappingURL=createStoreHook.d.ts.map

package/fe/packages/ui/react/lib/createStoreHook.js

@@ -0,0 +1,6 @@
+import { useStore } from 'zustand';
+export function createStoreHook(store) {
+    return ((selector) => {
+        return selector ? useStore(store, selector) : useStore(store);
+    });
+}

package/fe/packages/ui/react/lib/export.d.ts

@@ -0,0 +1,66 @@
+/**
+ * 导出 Excel 工具方法
+ *
+ * 功能：
+ * - 支持导出「当前页」或「当前查询条件下的全部页数据」
+ * - 通过 DataTable 的 columns 控制导出列及顺序
+ *
+ * 使用方式（示例）：
+ * ```ts
+ * await exportToExcel({
+ *   fetchData: (pageNum, pageSize) => getWithdrawList({ ...searchParams, pageNum, pageSize }),
+ *   columns, // 直接复用 DataTable 的 columns
+ *   exportType: 'all', // 'all' 导出全部页；'current' 仅导出当前页
+ *   currentPage,
+ *   pageSize,
+ *   total,
+ *   currentPageData: tableData, // 可选，导出当前页时直接使用现有数据，避免重复请求
+ *   fileName: '提币记录',
+ * })
+ * ```
+ */
+import { type TableColumnDef } from '../components';
+export declare const ExportType: {
+    /**
+     * 当前查询条件下所有页
+     */
+    readonly all: 0;
+    /**
+     * 当前页
+     */
+    readonly current: 1;
+};
+export type ExportType = (typeof ExportType)[keyof typeof ExportType];
+interface ExportExcelParams<T> {
+    /** 获取数据方法 */
+    fetchData: (pageNum: number, pageSize: number, searchParams?: Record<string, any>) => Promise<{
+        records: T[];
+        total: number;
+    }>;
+    /** 直接复用 DataTable 的 columns 配置  会自动过滤 操作栏*/
+    columns: TableColumnDef<T>[];
+    /** 导出类型：all=当前查询条件下所有页；current=当前页 */
+    exportType: ExportType;
+    /** 当前页码（导出当前页时使用）默认 1 */
+    currentPage?: number;
+    /** 每页条数，默认 2000 */
+    pageSize?: number;
+    /**
+     * 最大导出条数，超过则停止继续请求
+     * @default 10000
+     */
+    maxCount?: number;
+    /**
+     * 当前页已有数据
+     * - 当 exportType === 'current' 且传入该字段时，将直接使用该数据，不会再次请求接口
+     */
+    currentPageData?: T[];
+    /** 文件名（不含扩展名），默认：export-YYYYMMDDHHmmss */
+    fileName?: string;
+}
+/**
+ * 通用导出 Excel 方法
+ */
+export declare function exportToExcel<T>(options: ExportExcelParams<T>): Promise<void>;
+export {};
+//# sourceMappingURL=export.d.ts.map