@_tc/template-core 0.0.1-bate.36 → 0.0.1-bate.37

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

@@ -0,0 +1,142 @@
+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);
+};
+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;
+};
+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;
+};
+export const getI18nPathValue = (dictionary, key) => {
+    if (!dictionary)
+        return undefined;
+    return key.split('.').reduce((value, currentKey) => {
+        if (!isPlainI18nDictionary(value))
+            return undefined;
+        return value[currentKey];
+    }, dictionary);
+};
+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);
+    });
+};
+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);
+};
+const getBrowserWindow = () => {
+    return globalThis.window;
+};
+const getStoredLanguage = (storageKey) => {
+    const windowRef = getBrowserWindow();
+    if (!windowRef) {
+        return defaultLanguage;
+    }
+    return windowRef.localStorage.getItem(storageKey) || defaultLanguage;
+};
+const 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,
+});
+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);
+            };
+        },
+    };
+};
+export const i18nStore = createI18nStore();
+export const i18n = (key, fillingData, options) => {
+    return translate(i18nStore.getState(), key, fillingData, options);
+};
+export const t = i18n;
+export const getLanguage = i18n;

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

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

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

@@ -0,0 +1,10 @@
+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,
+};
+export * from './default';
+export * from './en-US';

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

@@ -0,0 +1,47 @@
+export type I18nLanguage = string;
+export type I18nPrimitive = string | number | boolean | null | undefined;
+export type I18nMessage = I18nPrimitive | I18nMessage[] | readonly I18nMessage[] | I18nDictionary;
+export interface I18nDictionary {
+    [key: string]: I18nMessage;
+}
+export type I18nResources<Language extends I18nLanguage = I18nLanguage> = Partial<Record<Language, I18nDictionary>>;
+export type I18nInterpolationValues = Record<string, I18nPrimitive>;
+export interface I18nTranslateState {
+    language: I18nLanguage;
+    fallbackLanguage: I18nLanguage;
+    resources: I18nResources;
+}
+export interface I18nState extends I18nTranslateState {
+    storageKey: string;
+    persist: boolean;
+}
+export interface I18nTranslateOptions {
+    language?: I18nLanguage;
+    fallbackLanguage?: I18nLanguage;
+    fallback?: I18nMessage;
+}
+export interface I18nSetResourcesOptions {
+    merge?: boolean;
+}
+export interface I18nAddResourcesOptions {
+    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;
+    configureI18n: (config: Partial<Pick<I18nState, 'storageKey' | 'persist'>>) => void;
+    resetI18n: () => void;
+    t: I18nTranslator;
+}
+export type I18nStore = I18nState & I18nActions;
+export type I18nStoreListener = (state: I18nStore, previousState: I18nStore) => void;
+export interface I18nStoreApi {
+    getState: () => I18nStore;
+    getInitialState: () => I18nStore;
+    setState: (partial: Partial<I18nStore> | ((state: I18nStore) => Partial<I18nStore>)) => void;
+    subscribe: (listener: I18nStoreListener) => () => void;
+}
+//# sourceMappingURL=types.d.ts.map

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

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

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

@@ -0,0 +1,10 @@
+export * from "./array";
+export * from "./cache";
+export * from "./guards";
+export * from "./i18n";
+export * from "./log";
+export * from "./number";
+export * from "./object";
+export * from "./string";
+export * from "./types";
+//# sourceMappingURL=index.d.ts.map

package/fe/packages/common/index.js

@@ -0,0 +1,9 @@
+export * from "./array";
+export * from "./cache";
+export * from "./guards";
+export * from "./i18n";
+export * from "./log";
+export * from "./number";
+export * from "./object";
+export * from "./string";
+export * from "./types";

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

@@ -0,0 +1,33 @@
+export declare const ANSI_RESET = "\u001B[0m";
+export declare const ansiColors: {
+    readonly black: "\u001B[30m";
+    readonly red: "\u001B[31m";
+    readonly green: "\u001B[32m";
+    readonly yellow: "\u001B[33m";
+    readonly blue: "\u001B[34m";
+    readonly magenta: "\u001B[35m";
+    readonly pink: "\u001B[95m";
+    readonly cyan: "\u001B[36m";
+    readonly white: "\u001B[37m";
+    readonly gray: "\u001B[90m";
+};
+export type LogColor = keyof typeof ansiColors;
+export type ColorLogOptions = {
+    color?: LogColor;
+    prefix?: string;
+    suffix?: string;
+};
+export type ColorLogAffixes = Omit<ColorLogOptions, 'color'>;
+export declare const colorize: (message: unknown, color?: LogColor) => string;
+export declare const joinColorized: (...messages: readonly unknown[]) => string;
+export declare const logJoinColorized: (...messages: readonly unknown[]) => void;
+export declare function colorLog(color: LogColor, ...data: unknown[]): void;
+export declare function colorLog(...data: unknown[]): void;
+export declare const logColor: (color: LogColor, ...data: unknown[]) => void;
+export declare const logColorized: (...messages: readonly unknown[]) => void;
+export declare const logGreen: (...data: unknown[]) => void;
+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/log/index.js

@@ -0,0 +1,176 @@
+export const ANSI_RESET = '\x1b[0m';
+export const ansiColors = {
+    black: '\x1b[30m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    pink: '\x1b[95m',
+    cyan: '\x1b[36m',
+    white: '\x1b[37m',
+    gray: '\x1b[90m',
+};
+const getConsole = () => {
+    const globalValue = globalThis;
+    return globalValue.console;
+};
+export const colorize = (message, color = 'green') => {
+    return `${ansiColors[color]}${String(message)}${ANSI_RESET}`;
+};
+export const joinColorized = (...messages) => {
+    return messages.map(String).join('');
+};
+export const logJoinColorized = (...messages) => {
+    getConsole()?.log(messages.map(String).join(''));
+};
+const inspectPrimitive = (value) => {
+    if (typeof value === 'string')
+        return `'${value}'`;
+    if (typeof value === 'bigint')
+        return `${value}n`;
+    if (typeof value === 'symbol')
+        return String(value);
+    if (typeof value === 'function')
+        return `[Function${value.name ? `: ${value.name}` : ''}]`;
+    if (value === undefined)
+        return 'undefined';
+    if (value === null)
+        return 'null';
+    return String(value);
+};
+const inspectValue = (value, context, depth = 0) => {
+    if (value === null || typeof value !== 'object')
+        return inspectPrimitive(value);
+    if (context.seen.has(value))
+        return '[Circular]';
+    if (value instanceof Date)
+        return value.toISOString();
+    if (value instanceof Error)
+        return value.stack ?? `${value.name}: ${value.message}`;
+    context.seen.add(value);
+    if (Array.isArray(value)) {
+        const items = value.map((item) => inspectValue(item, context, depth + 1));
+        context.seen.delete(value);
+        return `[${items.join(', ')}]`;
+    }
+    const entries = Object.entries(value);
+    if (entries.length === 0) {
+        context.seen.delete(value);
+        return '{}';
+    }
+    const indent = '  '.repeat(depth);
+    const nextIndent = '  '.repeat(depth + 1);
+    const body = entries
+        .map(([key, item]) => `${nextIndent}${key}: ${inspectValue(item, context, depth + 1)}`)
+        .join(',\n');
+    context.seen.delete(value);
+    return `{\n${body}\n${indent}}`;
+};
+const stringifyLogValue = (value) => {
+    return typeof value === 'string' ? value : inspectValue(value, { seen: new WeakSet() });
+};
+const formatSpecifier = (specifier, value) => {
+    if (specifier === '%%')
+        return '%';
+    if (specifier === '%s')
+        return String(value);
+    if (specifier === '%d' || specifier === '%i')
+        return Number.parseInt(String(value), 10).toString();
+    if (specifier === '%f')
+        return Number.parseFloat(String(value)).toString();
+    if (specifier === '%j') {
+        try {
+            return JSON.stringify(value);
+        }
+        catch {
+            return '[Circular]';
+        }
+    }
+    if (specifier === '%o' || specifier === '%O')
+        return stringifyLogValue(value);
+    if (specifier === '%c')
+        return '';
+    return specifier;
+};
+const formatLogData = (data) => {
+    if (data.length === 0)
+        return '';
+    const [first, ...rest] = data;
+    if (typeof first !== 'string') {
+        return data.map(stringifyLogValue).join(' ');
+    }
+    let index = 0;
+    const formatted = first.replace(/%[sdifjoOc%]/g, (specifier) => {
+        if (specifier === '%%')
+            return '%';
+        if (index >= rest.length)
+            return specifier;
+        const value = rest[index];
+        index += 1;
+        return formatSpecifier(specifier, value);
+    });
+    const remaining = rest.slice(index).map(stringifyLogValue);
+    return [formatted, ...remaining].join(' ');
+};
+const isLogColor = (value) => {
+    return typeof value === 'string' && value in ansiColors;
+};
+const isColorLogOptions = (value) => {
+    if (value === null || typeof value !== 'object')
+        return false;
+    const keys = Object.keys(value);
+    if (!keys.some((key) => key === 'color' || key === 'prefix' || key === 'suffix')) {
+        return false;
+    }
+    const options = value;
+    return options.color === undefined || isLogColor(options.color);
+};
+const withColor = (color, data, options = {}) => {
+    const prefix = options.prefix ?? '';
+    const suffix = options.suffix ?? '';
+    const message = formatLogData(data);
+    return [`${ansiColors[color]}${prefix}${message}${suffix}${ANSI_RESET}`];
+};
+const printColorMessage = (data, config) => {
+    const color = config.color ?? 'green';
+    getConsole()?.log(...withColor(color, data, config));
+};
+export function colorLog(...data) {
+    const [first, ...rest] = data;
+    const last = data.at(-1);
+    if (isLogColor(first) && data.length >= 2) {
+        printColorMessage(rest, { color: first });
+        return;
+    }
+    if (isLogColor(last) && data.length === 2) {
+        printColorMessage([first], { color: last });
+        return;
+    }
+    if (isColorLogOptions(last) && data.length >= 2) {
+        printColorMessage(data.slice(0, -1), last);
+        return;
+    }
+    printColorMessage(data, { color: 'green' });
+}
+export const logColor = (color, ...data) => {
+    printColorMessage(data, { color });
+};
+export const logColorized = (...messages) => {
+    getConsole()?.log(...messages);
+};
+export const logGreen = (...data) => {
+    logColor('green', ...data);
+};
+export const logYellow = (...data) => {
+    logColor('yellow', ...data);
+};
+export const logPink = (...data) => {
+    logColor('pink', ...data);
+};
+export const logWhite = (...data) => {
+    logColor('white', ...data);
+};
+export const logRed = (...data) => {
+    logColor('red', ...data);
+};

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

@@ -0,0 +1,3 @@
+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/number/index.js

@@ -0,0 +1,10 @@
+export const clamp = (value, min, max) => {
+    if (min > max) {
+        throw new RangeError("min must be less than or equal to max");
+    }
+    return Math.min(Math.max(value, min), max);
+};
+export const toFiniteNumber = (value, fallback = 0) => {
+    const numberValue = typeof value === "number" ? value : Number(value);
+    return Number.isFinite(numberValue) ? numberValue : fallback;
+};

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

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

@@ -0,0 +1,33 @@
+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;
+};
+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;
+};
+export function filterEmpty(data) {
+    return filterEmptyValue(data);
+}
+export const filtereEmpty = filterEmpty;

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

@@ -0,0 +1,5 @@
+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/object/index.js

@@ -0,0 +1,25 @@
+export * from "./filterEmpty";
+export const pick = (target, keys) => {
+    const result = {};
+    for (const key of keys) {
+        if (key in target) {
+            result[key] = target[key];
+        }
+    }
+    return result;
+};
+export const omit = (target, keys) => {
+    const result = { ...target };
+    for (const key of keys) {
+        delete result[key];
+    }
+    return result;
+};
+export const mapValues = (target, mapper) => {
+    const result = {};
+    const keys = Object.keys(target);
+    for (const key of keys) {
+        result[key] = mapper(target[key], key);
+    }
+    return result;
+};

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

@@ -0,0 +1,4 @@
+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/string/index.js

@@ -0,0 +1,17 @@
+export const isBlank = (value) => {
+    return value === null || value === undefined || value.trim().length === 0;
+};
+export const capitalize = (value) => {
+    if (value.length === 0)
+        return value;
+    const first = value.charAt(0).toUpperCase();
+    return `${first}${value.slice(1)}`;
+};
+export const kebabCase = (value) => {
+    return value
+        .trim()
+        .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+        .replace(/[\s_]+/g, "-")
+        .replace(/-+/g, "-")
+        .toLowerCase();
+};

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

@@ -0,0 +1,4 @@
+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/common/types/index.js

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

package/fe/packages/ui/react/components/Button/Button.d.ts

@@ -1,39 +1,25 @@
-import type { ButtonHTMLAttributes, ReactNode } from 'react';
-export type ButtonVariant = 'default' | 'primary' | 'text' | 'link';
+import type { AnchorHTMLAttributes, ButtonHTMLAttributes, ReactNode } from 'react';
+export type ButtonVariant = 'default' | 'primary' | 'dashed' | 'text' | 'link';
+export type ButtonState = 'danger' | 'ghost';
 export type ButtonSize = 'sm' | 'md' | 'lg';
-export interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
-    /**
-     * 按钮变体
-     * @default 'default'
-     */
-    variant?: ButtonVariant;
-    /**
-     * 按钮尺寸
-     * @default 'md'
-     */
+type ButtonCommonProps = {
     size?: ButtonSize;
-    /**
-     * 是否显示加载状态
-     */
+    state?: ButtonState;
+    disabled?: boolean;
     loading?: boolean;
-    /**
-     * 左侧图标
-     */
     leftIcon?: ReactNode;
-    /**
-     * 右侧图标
-     */
     rightIcon?: ReactNode;
-    /**
-     * 是否去除下划线（仅对 variant="link" 有效）
-     * @default false
-     */
     noUnderline?: boolean;
-    /**
-     * 作为子元素，用于更灵活的布局
-     */
     children?: ReactNode;
-}
-declare const Button: import("react").ForwardRefExoticComponent<ButtonProps & import("react").RefAttributes<HTMLButtonElement>>;
+};
+type ButtonElementVariant = Exclude<ButtonVariant, 'link'>;
+export type ButtonProps = ButtonElementProps | ButtonLinkProps;
+export type ButtonElementProps = ButtonCommonProps & Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'disabled'> & {
+    variant?: ButtonElementVariant;
+};
+export type ButtonLinkProps = ButtonCommonProps & AnchorHTMLAttributes<HTMLAnchorElement> & {
+    variant: 'link';
+};
+declare const Button: import("react").ForwardRefExoticComponent<ButtonProps & import("react").RefAttributes<HTMLButtonElement | HTMLAnchorElement>>;
 export { Button };
 //# sourceMappingURL=Button.d.ts.map