@_tc/template-core 0.0.1-bate.9 → 0.0.2

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

@@ -1,3 +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

@@ -1,4 +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

@@ -19,7 +19,7 @@
  * })
  * ```
  */
-import { type ColumnDef } from '../components';
+import { type TableColumnDef } from '../components';
 export declare const ExportType: {
     /**
      * 当前查询条件下所有页
@@ -38,7 +38,7 @@ interface ExportExcelParams<T> {
         total: number;
     }>;
     /** 直接复用 DataTable 的 columns 配置  会自动过滤 操作栏*/
-    columns: ColumnDef<T>[];
+    columns: TableColumnDef<T>[];
     /** 导出类型：all=当前查询条件下所有页；current=当前页 */
     exportType: ExportType;
     /** 当前页码（导出当前页时使用）默认 1 */

package/fe/packages/ui/react/stores/language.d.ts

@@ -1,13 +1,4 @@
-import { type Language } from '../locales';
-export declare const getLanguage: <T extends object>(key: string, fillingData?: T) => any;
-export declare const t: <T extends object>(key: string, fillingData?: T) => any;
-type State = {
-    language: Language;
-};
-type Actions = {
-    setLanguage: (lang: Language) => void;
-    t: typeof t;
-};
-export declare const useLanguages: import("zustand").UseBoundStore<import("zustand").StoreApi<State & Actions>>;
-export {};
+export { getLanguage, i18n, t } from '../../../common/i18n';
+export type { I18nLanguage as Language } from '../../../common/i18n';
+export { useI18nStore as useLanguages } from '../i18n';
 //# sourceMappingURL=language.d.ts.map

package/fe/packages/ui/react/stores/language.js

@@ -1,51 +1,2 @@
-import { defaultLanguage, languageLocalKey, translations } from '../locales';
-import { create } from 'zustand';
-export const getLanguage = (key, fillingData) => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    let value = translations[languageStore.getState().language];
-    const keys = key.split('.');
-    for (const k of keys) {
-        value = value?.[k];
-    }
-    if (typeof value === 'string') {
-        const tags = value.match(/\{[A-Za-z0-9_]*?\}/g);
-        if (tags && tags.length) {
-            tags.forEach((k) => {
-                const fKey = k.replace(/[{}]/g, '');
-                const v = fillingData?.[fKey];
-                if (typeof v !== 'undefined') {
-                    value = value.replace(k, v);
-                }
-            });
-            return value;
-        }
-        return value;
-    }
-    else if (typeof value !== 'undefined') {
-        return value;
-    }
-    return key;
-};
-export const t = getLanguage;
-const languageStore = create((set) => ({
-    t,
-    language: (() => {
-        if (typeof window === 'undefined') {
-            return defaultLanguage;
-        }
-        const stored = window.localStorage.getItem(languageLocalKey);
-        return (Object.keys(translations).includes(stored) ? stored : defaultLanguage);
-    })(),
-    setLanguage: (lang) => {
-        set({
-            language: lang,
-            t: function (...args) {
-                return getLanguage.apply(this, args);
-            },
-        });
-        if (typeof window !== 'undefined') {
-            window.localStorage.setItem(languageLocalKey, lang);
-        }
-    },
-}));
-export const useLanguages = languageStore;
+export { getLanguage, i18n, t } from '../../../common/i18n';
+export { useI18nStore as useLanguages } from '../i18n';

package/fe/typings/type.d.ts

@@ -0,0 +1,5 @@
+export type MOmit<T, K extends keyof T> = Omit<T, K>;
+export type UnionToTuple<T> = [T] extends [never] ? [] : ((t: T) => T) extends (t: infer U) => infer U ? [...UnionToTuple<Exclude<T, U>>, U] : never;
+export type MergeType<T extends unknown[]> = T extends [infer F, ...infer R] ? F & (R extends [] ? MergeType<R> : {}) : {};
+export type GetInstance<T extends (...args: never[]) => unknown> = T extends (...args: never[]) => infer R ? R extends new () => infer C ? C : R extends Promise<infer P> ? P extends new () => infer C2 ? C2 : never : never : never;
+//# sourceMappingURL=type.d.ts.map

package/fe/typings/type.js

@@ -0,0 +1 @@
+export {};

package/model/index.d.ts

@@ -0,0 +1,2 @@
+export type { ModelDataType } from './types';
+//# sourceMappingURL=index.d.ts.map

package/model/test.d.ts

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

package/model/types/data/button.d.ts

@@ -0,0 +1,32 @@
+import type { ButtonProps } from '../../../fe/packages/ui/react';
+import { ComponentNames } from './component';
+type ButtonTemplates = {
+    /**
+     * 按钮名
+     */
+    label?: string;
+} & ButtonProps;
+type ParamsValueData = 'schema::tableKey' | string | number;
+type RemoveBtn = {
+    eventKey: 'remove';
+    /**
+     * 事件配置 (参数配置)
+     */
+    eventOption: {
+        params: {
+            /**
+             *  @example user_id: 'schema::tableKey' | '123' | 123
+             */
+            [paramKey: string]: ParamsValueData;
+        };
+    };
+};
+type HandlerBtn = {
+    eventKey: 'callComponent';
+    eventOption: {
+        comName: ComponentNames;
+    };
+};
+export type BaseButton = ButtonTemplates & (RemoveBtn | HandlerBtn);
+export {};
+//# sourceMappingURL=button.d.ts.map