@_tc/template-core 0.1.16 → 0.2.0-bate.0

package/fe/packages/common/i18n/index.js

@@ -1,173 +1,162 @@
-import { defaultLanguage, languageLocalKey, translations } from './locales';
-export * from './types';
-export * from './locales';
-export const isPlainI18nDictionary = (value) => {
-    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+import "./default.js";
+import "./en-US.js";
+import { defaultLanguage, languageLocalKey, translations } from "./locales.js";
+//#region packages/common/i18n/index.ts
+var isPlainI18nDictionary = (value) => {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 };
 /**
- * 深合并单个语言包。
- * 嵌套对象递归合并，字符串、数组、数字等叶子节点直接以 patch 覆盖 base。
- */
-export const mergeI18nDictionary = (base = {}, patch = {}) => {
-    const next = { ...base };
-    Object.entries(patch).forEach(([key, value]) => {
-        const current = next[key];
-        if (isPlainI18nDictionary(current) && isPlainI18nDictionary(value)) {
-            next[key] = mergeI18nDictionary(current, value);
-            return;
-        }
-        next[key] = value;
-    });
-    return next;
+* 深合并单个语言包。
+* 嵌套对象递归合并，字符串、数组、数字等叶子节点直接以 patch 覆盖 base。
+*/
+var mergeI18nDictionary = (base = {}, patch = {}) => {
+	const next = { ...base };
+	Object.entries(patch).forEach(([key, value]) => {
+		const current = next[key];
+		if (isPlainI18nDictionary(current) && isPlainI18nDictionary(value)) {
+			next[key] = mergeI18nDictionary(current, value);
+			return;
+		}
+		next[key] = value;
+	});
+	return next;
 };
 /**
- * 合并多语言资源。
- * 结构示例：{ 'zh-CN': { common: { ok: '确定' } }, 'en-US': { common: { ok: 'OK' } } }
- */
-export const mergeI18nResources = (base = {}, patch = {}) => {
-    const next = { ...base };
-    Object.entries(patch).forEach(([language, messages]) => {
-        if (!messages)
-            return;
-        next[language] = mergeI18nDictionary(next[language], messages);
-    });
-    return next;
+* 合并多语言资源。
+* 结构示例：{ 'zh-CN': { common: { ok: '确定' } }, 'en-US': { common: { ok: 'OK' } } }
+*/
+var mergeI18nResources = (base = {}, patch = {}) => {
+	const next = { ...base };
+	Object.entries(patch).forEach(([language, messages]) => {
+		if (!messages) return;
+		next[language] = mergeI18nDictionary(next[language], messages);
+	});
+	return next;
 };
 /**
- * 根据点分 key 从语言包中取值。
- * 例如 common.submit 会读取 resources[language].common.submit。
- */
-export const getI18nPathValue = (dictionary, key) => {
-    if (!dictionary)
-        return undefined;
-    return key.split('.').reduce((value, currentKey) => {
-        if (!isPlainI18nDictionary(value))
-            return undefined;
-        return value[currentKey];
-    }, dictionary);
+* 根据点分 key 从语言包中取值。
+* 例如 common.submit 会读取 resources[language].common.submit。
+*/
+var getI18nPathValue = (dictionary, key) => {
+	if (!dictionary) return void 0;
+	return key.split(".").reduce((value, currentKey) => {
+		if (!isPlainI18nDictionary(value)) return void 0;
+		return value[currentKey];
+	}, dictionary);
 };
 /**
- * 替换文案中的插值占位符。
- * 例如 "Hello, {name}" + { name: "Tom" } => "Hello, Tom"。
- */
-export const interpolateI18nMessage = (value, data) => {
-    if (!data)
-        return value;
-    return value.replace(/\{([A-Za-z0-9_]+)\}/g, (match, key) => {
-        const nextValue = data[key];
-        return typeof nextValue === 'undefined' || nextValue === null ? match : String(nextValue);
-    });
+* 替换文案中的插值占位符。
+* 例如 "Hello, {name}" + { name: "Tom" } => "Hello, Tom"。
+*/
+var interpolateI18nMessage = (value, data) => {
+	if (!data) return value;
+	return value.replace(/\{([A-Za-z0-9_]+)\}/g, (match, key) => {
+		const nextValue = data[key];
+		return typeof nextValue === "undefined" || nextValue === null ? match : String(nextValue);
+	});
 };
 /**
- * 纯翻译函数：只依赖传入的 state。
- * 优先级：指定语言 -> 兜底语言 -> options.fallback -> 原 key。
- */
-export const translate = (state, key, fillingData, options) => {
-    const language = options?.language || state.language;
-    const fallbackLanguage = options?.fallbackLanguage || state.fallbackLanguage;
-    const value = getI18nPathValue(state.resources[language], key) ??
-        getI18nPathValue(state.resources[fallbackLanguage], key) ??
-        options?.fallback ??
-        key;
-    return (typeof value === 'string' ? interpolateI18nMessage(value, fillingData) : value);
+* 纯翻译函数：只依赖传入的 state。
+* 优先级：指定语言 -> 兜底语言 -> options.fallback -> 原 key。
+*/
+var translate = (state, key, fillingData, options) => {
+	const language = options?.language || state.language;
+	const fallbackLanguage = options?.fallbackLanguage || state.fallbackLanguage;
+	const value = getI18nPathValue(state.resources[language], key) ?? getI18nPathValue(state.resources[fallbackLanguage], key) ?? options?.fallback ?? key;
+	return typeof value === "string" ? interpolateI18nMessage(value, fillingData) : value;
 };
-const getBrowserWindow = () => {
-    return globalThis.window;
+var getBrowserWindow = () => {
+	return globalThis.window;
 };
 /**
- * 初始化时优先读取本地缓存语言。
- * SSR 环境没有 window，直接回退到默认语言。
- */
-const getStoredLanguage = (storageKey) => {
-    const windowRef = getBrowserWindow();
-    if (!windowRef) {
-        return defaultLanguage;
-    }
-    return windowRef.localStorage.getItem(storageKey) || defaultLanguage;
+* 初始化时优先读取本地缓存语言。
+* SSR 环境没有 window，直接回退到默认语言。
+*/
+var getStoredLanguage = (storageKey) => {
+	const windowRef = getBrowserWindow();
+	if (!windowRef) return defaultLanguage;
+	return windowRef.localStorage.getItem(storageKey) || "zh-CN";
 };
 /**
- * 持久化当前语言，用于刷新页面后保持用户选择。
- */
-const persistLanguage = (storageKey, language) => {
-    const windowRef = getBrowserWindow();
-    if (!windowRef)
-        return;
-    windowRef.localStorage.setItem(storageKey, language);
+* 持久化当前语言，用于刷新页面后保持用户选择。
+*/
+var persistLanguage = (storageKey, language) => {
+	const windowRef = getBrowserWindow();
+	if (!windowRef) return;
+	windowRef.localStorage.setItem(storageKey, language);
 };
-const createInitialState = () => ({
-    language: getStoredLanguage(languageLocalKey),
-    fallbackLanguage: defaultLanguage,
-    resources: translations,
-    storageKey: languageLocalKey,
-    persist: true,
+var createInitialState = () => ({
+	language: getStoredLanguage(languageLocalKey),
+	fallbackLanguage: defaultLanguage,
+	resources: translations,
+	storageKey: languageLocalKey,
+	persist: true
 });
-const createI18nStore = () => {
-    let state;
-    const listeners = new Set();
-    const setState = (partial) => {
-        const previousState = state;
-        const nextPartial = typeof partial === 'function' ? partial(state) : partial;
-        state = { ...state, ...nextPartial };
-        listeners.forEach((listener) => listener(state, previousState));
-    };
-    const initialState = createInitialState();
-    state = {
-        ...initialState,
-        t: (key, fillingData, options) => i18n(key, fillingData, options),
-        setLanguage: (language) => {
-            setState({ language });
-            const { persist, storageKey } = state;
-            if (persist) {
-                persistLanguage(storageKey, language);
-            }
-        },
-        setFallbackLanguage: (fallbackLanguage) => {
-            setState({ fallbackLanguage });
-        },
-        setResources: (resources, options) => {
-            setState((currentState) => ({
-                resources: options?.merge ? mergeI18nResources(currentState.resources, resources) : resources,
-            }));
-        },
-        addResources: (language, messages, options) => {
-            setState((currentState) => {
-                const shouldMerge = options?.merge ?? true;
-                const currentMessages = currentState.resources[language];
-                return {
-                    resources: {
-                        ...currentState.resources,
-                        [language]: shouldMerge ? mergeI18nDictionary(currentMessages, messages) : messages,
-                    },
-                };
-            });
-        },
-        configureI18n: (config) => {
-            setState(config);
-        },
-        resetI18n: () => {
-            setState(createInitialState());
-        },
-    };
-    const initialStoreState = state;
-    return {
-        getState: () => state,
-        getInitialState: () => initialStoreState,
-        setState,
-        subscribe: (listener) => {
-            listeners.add(listener);
-            return () => {
-                listeners.delete(listener);
-            };
-        },
-    };
+var createI18nStore = () => {
+	let state;
+	const listeners = /* @__PURE__ */ new Set();
+	const setState = (partial) => {
+		const previousState = state;
+		const nextPartial = typeof partial === "function" ? partial(state) : partial;
+		state = {
+			...state,
+			...nextPartial
+		};
+		listeners.forEach((listener) => listener(state, previousState));
+	};
+	state = {
+		...createInitialState(),
+		t: (key, fillingData, options) => i18n(key, fillingData, options),
+		setLanguage: (language) => {
+			setState({ language });
+			const { persist, storageKey } = state;
+			if (persist) persistLanguage(storageKey, language);
+		},
+		setFallbackLanguage: (fallbackLanguage) => {
+			setState({ fallbackLanguage });
+		},
+		setResources: (resources, options) => {
+			setState((currentState) => ({ resources: options?.merge ? mergeI18nResources(currentState.resources, resources) : resources }));
+		},
+		addResources: (language, messages, options) => {
+			setState((currentState) => {
+				const shouldMerge = options?.merge ?? true;
+				const currentMessages = currentState.resources[language];
+				return { resources: {
+					...currentState.resources,
+					[language]: shouldMerge ? mergeI18nDictionary(currentMessages, messages) : messages
+				} };
+			});
+		},
+		configureI18n: (config) => {
+			setState(config);
+		},
+		resetI18n: () => {
+			setState(createInitialState());
+		}
+	};
+	const initialStoreState = state;
+	return {
+		getState: () => state,
+		getInitialState: () => initialStoreState,
+		setState,
+		subscribe: (listener) => {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		}
+	};
 };
-export const i18nStore = createI18nStore();
+var i18nStore = createI18nStore();
 /**
- * 对外使用的 i18n 函数。
- * 每次调用都会读取最新 state，适合在非 React 代码中直接使用。
- */
-export const i18n = (key, fillingData, options) => {
-    return translate(i18nStore.getState(), key, fillingData, options);
+* 对外使用的 i18n 函数。
+* 每次调用都会读取最新 state，适合在非 React 代码中直接使用。
+*/
+var i18n = (key, fillingData, options) => {
+	return translate(i18nStore.getState(), key, fillingData, options);
 };
-export const t = i18n;
-export const getLanguage = i18n;
+var t = i18n;
+var getLanguage = i18n;
+//#endregion
+export { getI18nPathValue, getLanguage, i18n, i18nStore, interpolateI18nMessage, isPlainI18nDictionary, mergeI18nDictionary, mergeI18nResources, t, translate };

package/fe/packages/common/i18n/locales.d.ts

@@ -1,8 +1,7 @@
-import type { I18nResources } from './types';
+import type { I18nResources } from "./types";
 export declare const defaultLanguage: "zh-CN";
 export declare const languageLocalKey = "tc_language";
 export declare const translations: I18nResources;
 export type Language = keyof typeof translations | (string & {});
-export * from './default';
-export * from './en-US';
-//# sourceMappingURL=locales.d.ts.map
+export * from "./default";
+export * from "./en-US";

package/fe/packages/common/i18n/locales.js

@@ -1,10 +1,11 @@
-import { defaultLanguageResources } from './default';
-import { defaultEnglishResources } from './en-US';
-export const defaultLanguage = 'zh-CN';
-export const languageLocalKey = 'tc_language';
-export const translations = {
-    'zh-CN': defaultLanguageResources,
-    'en-US': defaultEnglishResources,
+import { defaultLanguageResources } from "./default.js";
+import { defaultEnglishResources } from "./en-US.js";
+//#region packages/common/i18n/locales.ts
+var defaultLanguage = "zh-CN";
+var languageLocalKey = "tc_language";
+var translations = {
+	"zh-CN": defaultLanguageResources,
+	"en-US": defaultEnglishResources
 };
-export * from './default';
-export * from './en-US';
+//#endregion
+export { defaultLanguage, languageLocalKey, translations };

package/fe/packages/common/i18n/types.d.ts

@@ -12,52 +12,28 @@ export interface I18nTranslateState {
     resources: I18nResources;
 }
 export interface I18nState extends I18nTranslateState {
-    /** 持久化语言时使用的 localStorage key。 */
     storageKey: string;
-    /** 是否把 setLanguage 的结果写入 localStorage。 */
     persist: boolean;
 }
 export interface I18nTranslateOptions {
-    /**
-     * 指定本次翻译使用的语言，不传则使用全局 language。
-     */
     language?: I18nLanguage;
-    /**
-     * 当前语言未命中时使用的兜底语言，不传则使用全局 fallbackLanguage。
-     */
     fallbackLanguage?: I18nLanguage;
-    /**
-     * 当前语言和兜底语言都未命中时返回的兜底值。
-     */
     fallback?: I18nMessage;
 }
 export interface I18nSetResourcesOptions {
-    /**
-     * 是否和现有资源深合并。默认 false，直接替换 resources。
-     */
     merge?: boolean;
 }
 export interface I18nAddResourcesOptions {
-    /**
-     * 是否和当前语言资源深合并。默认 true。
-     */
     merge?: boolean;
 }
 export type I18nTranslator = <T = string>(key: string, fillingData?: I18nInterpolationValues, options?: I18nTranslateOptions) => T | string;
 export interface I18nActions {
-    /** 设置当前展示语言。 */
     setLanguage: (language: I18nLanguage) => void;
-    /** 设置兜底语言。 */
     setFallbackLanguage: (language: I18nLanguage) => void;
-    /** 批量设置多语言资源，可选择替换或合并。 */
     setResources: (resources: I18nResources, options?: I18nSetResourcesOptions) => void;
-    /** 为指定语言追加资源，默认和已有资源深合并。 */
     addResources: (language: I18nLanguage, messages: I18nDictionary, options?: I18nAddResourcesOptions) => void;
-    /** 配置存储行为，主要由 I18nProvider 同步外部 props 使用。 */
     configureI18n: (config: Partial<Pick<I18nState, 'storageKey' | 'persist'>>) => void;
-    /** 重置为默认语言、默认资源和默认存储配置。 */
     resetI18n: () => void;
-    /** 挂在 store 上的翻译函数，方便直接读取。 */
     t: I18nTranslator;
 }
 export type I18nStore = I18nState & I18nActions;
@@ -68,4 +44,3 @@ export interface I18nStoreApi {
     setState: (partial: Partial<I18nStore> | ((state: I18nStore) => Partial<I18nStore>)) => void;
     subscribe: (listener: I18nStoreListener) => () => void;
 }
-//# sourceMappingURL=types.d.ts.map

package/fe/packages/common/index.d.ts

@@ -8,4 +8,3 @@ export * from "./number";
 export * from "./object";
 export * from "./string";
 export * from "./types";
-//# sourceMappingURL=index.d.ts.map

package/fe/packages/common/log/index.d.ts

@@ -30,4 +30,3 @@ export declare const logYellow: (...data: unknown[]) => void;
 export declare const logPink: (...data: unknown[]) => void;
 export declare const logWhite: (...data: unknown[]) => void;
 export declare const logRed: (...data: unknown[]) => void;
-//# sourceMappingURL=index.d.ts.map

package/fe/packages/common/number/index.d.ts

@@ -1,3 +1,2 @@
 export declare const clamp: (value: number, min: number, max: number) => number;
 export declare const toFiniteNumber: (value: unknown, fallback?: number) => number;
-//# sourceMappingURL=index.d.ts.map

package/fe/packages/common/object/filterEmpty.d.ts

@@ -1,3 +1,2 @@
 export declare function filterEmpty<T>(data: T): T | undefined;
 export declare const filtereEmpty: typeof filterEmpty;
-//# sourceMappingURL=filterEmpty.d.ts.map

package/fe/packages/common/object/filterEmpty.js

@@ -1,33 +1,28 @@
-import { isPlainObject } from "../guards";
-const isEmptyValue = (value) => {
-    if (value === undefined)
-        return true;
-    if (Array.isArray(value))
-        return value.length === 0;
-    if (isPlainObject(value))
-        return Object.keys(value).length === 0;
-    return false;
+import { isPlainObject } from "../guards/index.js";
+//#region packages/common/object/filterEmpty.ts
+var isEmptyValue = (value) => {
+	if (value === void 0) return true;
+	if (Array.isArray(value)) return value.length === 0;
+	if (isPlainObject(value)) return Object.keys(value).length === 0;
+	return false;
 };
-const filterEmptyValue = (value) => {
-    if (Array.isArray(value)) {
-        const result = value
-            .map((item) => filterEmptyValue(item))
-            .filter((item) => !isEmptyValue(item));
-        return result.length > 0 ? result : undefined;
-    }
-    if (isPlainObject(value)) {
-        const result = {};
-        for (const [key, item] of Object.entries(value)) {
-            const nextValue = filterEmptyValue(item);
-            if (!isEmptyValue(nextValue)) {
-                result[key] = nextValue;
-            }
-        }
-        return Object.keys(result).length > 0 ? result : undefined;
-    }
-    return value;
+var filterEmptyValue = (value) => {
+	if (Array.isArray(value)) {
+		const result = value.map((item) => filterEmptyValue(item)).filter((item) => !isEmptyValue(item));
+		return result.length > 0 ? result : void 0;
+	}
+	if (isPlainObject(value)) {
+		const result = {};
+		for (const [key, item] of Object.entries(value)) {
+			const nextValue = filterEmptyValue(item);
+			if (!isEmptyValue(nextValue)) result[key] = nextValue;
+		}
+		return Object.keys(result).length > 0 ? result : void 0;
+	}
+	return value;
 };
-export function filterEmpty(data) {
-    return filterEmptyValue(data);
+function filterEmpty(data) {
+	return filterEmptyValue(data);
 }
-export const filtereEmpty = filterEmpty;
+//#endregion
+export { filterEmpty };

package/fe/packages/common/object/filtereEmpty.d.ts

@@ -0,0 +1 @@
+export { filterEmpty, filtereEmpty } from "./filterEmpty";

package/fe/packages/common/object/index.d.ts

@@ -2,4 +2,3 @@ export * from "./filterEmpty";
 export declare const pick: <T extends object, K extends keyof T>(target: T, keys: readonly K[]) => Pick<T, K>;
 export declare const omit: <T extends object, K extends keyof T>(target: T, keys: readonly K[]) => Omit<T, K>;
 export declare const mapValues: <T extends object, TResult>(target: T, mapper: <K extends keyof T>(value: T[K], key: K) => TResult) => { [K in keyof T]: TResult; };
-//# sourceMappingURL=index.d.ts.map

package/fe/packages/common/string/index.d.ts

@@ -1,4 +1,3 @@
 export declare const isBlank: (value: string | null | undefined) => boolean;
 export declare const capitalize: (value: string) => string;
 export declare const kebabCase: (value: string) => string;
-//# sourceMappingURL=index.d.ts.map

package/fe/packages/common/types/index.d.ts

@@ -1,4 +1,3 @@
 export type Maybe<T> = T | null | undefined;
 export type Primitive = string | number | boolean | bigint | symbol | null | undefined;
 export type Dictionary<T = unknown> = Record<string, T>;
-//# sourceMappingURL=index.d.ts.map

package/fe/packages/{ui/react → react}/hooks/useBreadcrumb.d.ts

@@ -1,10 +1,9 @@
 export declare const useBreadcrumb: import("zustand").UseBoundStore<import("zustand").StoreApi<{
-    items: import("..").BreadcrumbItemData[];
+    items: import("../ui/index").BreadcrumbItemData[];
 } & {
-    setItems: (items: import("..").BreadcrumbItemData[]) => void;
-    addItem: (item: import("..").BreadcrumbItemData) => void;
+    setItems: (items: import("../ui/index").BreadcrumbItemData[]) => void;
+    addItem: (item: import("../ui/index").BreadcrumbItemData) => void;
     removeItem: (id: string | number) => void;
     clearItems: () => void;
     setActiveItem: (id: string | number) => void;
 }>>;
-//# sourceMappingURL=useBreadcrumb.d.ts.map

package/fe/packages/react/hooks/useBreadcrumb.js

@@ -0,0 +1,5 @@
+import { useBreadcrumbStore } from "../ui/stores/breadcrumb.js";
+//#region packages/react/hooks/useBreadcrumb.ts
+var useBreadcrumb = useBreadcrumbStore;
+//#endregion
+export { useBreadcrumb };

package/fe/packages/react/hooks/useExecuteOnce.d.ts

@@ -0,0 +1,11 @@
+export declare const executionPhaseType: {
+    readonly mount: "mount";
+    readonly render: "render";
+    readonly unMount: "unMount";
+};
+type ExecutionPhaseTypeKeys = keyof typeof executionPhaseType;
+export type ExecutionPhaseType = (typeof executionPhaseType)[ExecutionPhaseTypeKeys];
+export default function useExecuteOnce<T>(factory: () => T, options?: {
+    executionPhase: ExecutionPhaseType[] | ExecutionPhaseType;
+}): T | null;
+export {};

package/fe/packages/react/hooks/useExecuteOnce.js

@@ -0,0 +1,47 @@
+import { useEffect, useMemo, useRef } from "react";
+//#region packages/react/hooks/useExecuteOnce.ts
+var executionPhaseType = {
+	mount: "mount",
+	render: "render",
+	unMount: "unMount"
+};
+/**
+* 
+* @description 在各个阶段只触发一次
+*  @demo
+* ```
+const count = useExecuteOnce(() => {
+console.log('123'); // 只会在第一次render时触发
+return 123
+})
+
+// count 123
+
+* ```
+*/
+function useExecuteOnce(factory, options) {
+	const { executionPhase: pExecutionPhase = executionPhaseType.render } = options ?? {};
+	const result = useRef(null);
+	const _executionPhase = useMemo(() => typeof pExecutionPhase === "string" ? [pExecutionPhase] : pExecutionPhase, [pExecutionPhase]);
+	const allowExecution = useRef([]);
+	const executionPhase = useRef(_executionPhase);
+	const runFN = (phase) => {
+		if (!allowExecution.current.includes(phase)) {
+			result.current = factory();
+			allowExecution.current.push(phase);
+		}
+	};
+	const fn = useRef(runFN);
+	executionPhase.current = _executionPhase;
+	fn.current = runFN;
+	if (executionPhase.current.includes(executionPhaseType.render)) fn.current(executionPhaseType.render);
+	useEffect(() => {
+		if (executionPhase.current.includes(executionPhaseType.mount)) fn.current(executionPhaseType["mount"]);
+		return () => {
+			if (executionPhase.current.includes(executionPhaseType["unMount"])) fn.current(executionPhaseType["unMount"]);
+		};
+	}, []);
+	return result.current;
+}
+//#endregion
+export { useExecuteOnce as default, executionPhaseType };

package/fe/packages/{ui/react → react}/hooks/useInit.d.ts

@@ -1,3 +1,2 @@
 declare const useInit: (callback: (isInit: boolean) => void) => void;
 export default useInit;
-//# sourceMappingURL=useInit.d.ts.map

package/fe/packages/react/hooks/useInit.js

@@ -0,0 +1,11 @@
+import { useRef } from "react";
+//#region packages/react/hooks/useInit.ts
+var useInit = (callback) => {
+	const isInit = useRef(false);
+	if (!isInit.current) {
+		callback(isInit.current);
+		isInit.current = true;
+	}
+};
+//#endregion
+export { useInit as default };

package/fe/packages/react/hooks/useLanguage.d.ts

@@ -0,0 +1 @@
+export declare function useLanguage(): import("../ui/index").I18nStore;

package/fe/packages/react/hooks/useLanguage.js

@@ -0,0 +1,8 @@
+import { useI18nStore } from "../ui/i18n/useI18n.js";
+import "../ui/stores/language.js";
+//#region packages/react/hooks/useLanguage.ts
+function useLanguage() {
+	return useI18nStore();
+}
+//#endregion
+export { useLanguage };

package/fe/packages/{ui/react → react}/hooks/usePagination.d.ts

@@ -13,4 +13,3 @@ export default function usePagination(params?: IParams): import("react").RefObje
     onChange: (params: Partial<PaginationValue>) => void;
 }>;
 export {};
-//# sourceMappingURL=usePagination.d.ts.map