@_tc/template-core 0.0.1-bate.46 → 0.0.1-bate.48

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,8 @@
-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';
+export * from "./default";
+export * from "./en-US";
 //# sourceMappingURL=locales.d.ts.map

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/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./array";
 export * from "./cache";
 export * from "./guards";
+export * from "./http";
 export * from "./i18n";
 export * from "./log";
 export * from "./number";

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/react/hooks/useBreadcrumb.d.ts

@@ -0,0 +1,10 @@
+export declare const useBreadcrumb: import("zustand").UseBoundStore<import("zustand").StoreApi<{
+    items: import("../ui/index").BreadcrumbItemData[];
+} & {
+    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.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/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,2 @@
+export declare function useLanguage(): import("../ui/index").I18nStore;
+//# sourceMappingURL=useLanguage.d.ts.map

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/react/hooks/usePagination.js

@@ -0,0 +1,30 @@
+import useInit from "./useInit.js";
+import { useCallback, useRef, useState } from "react";
+//#region packages/react/hooks/usePagination.ts
+function usePagination(params) {
+	const paginationData = useRef({
+		...params?.defaultValue ?? {
+			current: 1,
+			size: 10,
+			total: 0
+		},
+		onChange: () => {}
+	});
+	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;
+}
+//#endregion
+export { usePagination as default };

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

@@ -1,4 +1,4 @@
-import { RefObject } from 'react';
+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<{

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

@@ -0,0 +1,35 @@
+import useInit from "./useInit.js";
+import { useCallback, useLayoutEffect, useRef, useState } from "react";
+//#region packages/react/hooks/useRefState.ts
+function useRefState(initialState) {
+	const [v, setValue] = useState(initialState);
+	const data = useRef({ data: void 0 });
+	const callbackRef = useRef(null);
+	const [callbackVersion, setCallbackVersion] = useState(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
+	];
+}
+//#endregion
+export { useRefState as default };

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

@@ -0,0 +1,60 @@
+import { useEffect, useRef } from "react";
+//#region packages/react/hooks/useWatch.ts
+var identityCompare = (value, prevValue) => Object.is(value, prevValue);
+var 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);
+		if (valuePrototype !== Object.getPrototypeOf(prevValue) || 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;
+};
+var defaultCompare = (value, prevValue) => {
+	if (Array.isArray(value) && Array.isArray(prevValue)) return shallowCompare(value, prevValue);
+	return identityCompare(value, prevValue);
+};
+var getCompare = (compare) => {
+	if (compare === "identity") return identityCompare;
+	if (compare === "shallow") return shallowCompare;
+	return compare ?? defaultCompare;
+};
+var useStableWatchValue = (value, compare) => {
+	const valueRef = useRef(value);
+	if (!compare(value, valueRef.current)) valueRef.current = value;
+	return valueRef.current;
+};
+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 stableValue = useStableWatchValue(selector ? selector(source) : source, 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, void 0);
+			return;
+		}
+		const prevValue = valueRef.current;
+		if (Object.is(stableValue, prevValue)) return;
+		valueRef.current = stableValue;
+		return callbackRef.current(stableValue, prevValue);
+	}, [stableValue]);
+}
+//#endregion
+export { useWatch as default, useWatch, defaultCompare, identityCompare, shallowCompare };