@_tc/template-core 0.0.1-bate.6 → 0.0.1-bate.60

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

@@ -0,0 +1,64 @@
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+//#region packages/react/ui/lib/utils.ts
+function cn(...inputs) {
+	return twMerge(clsx(inputs));
+}
+/**
+* 日期时间格式化工具
+*/
+/**
+* 格式化日期时间
+* @param date 日期字符串或 Date 对象
+* @param format 格式化模板，默认 'YYYY-MM-DD HH:mm:ss'
+* @returns 格式化后的字符串
+*/
+function formatDateTime(date, format = "YYYY-MM-DD HH:mm:ss") {
+	if (!date) return "-";
+	let d = new Date(date);
+	const tmpY = d.getFullYear();
+	if (typeof date === "number" && tmpY === 1970) d = /* @__PURE__ */ new Date(date * 1e3);
+	if (isNaN(d.getTime())) return "-";
+	const year = d.getFullYear();
+	const month = String(d.getMonth() + 1).padStart(2, "0");
+	const day = String(d.getDate()).padStart(2, "0");
+	const hours = String(d.getHours()).padStart(2, "0");
+	const minutes = String(d.getMinutes()).padStart(2, "0");
+	const seconds = String(d.getSeconds()).padStart(2, "0");
+	return format.replace("YYYY", String(year)).replace("MM", month).replace("DD", day).replace("HH", hours).replace("mm", minutes).replace("ss", seconds);
+}
+/**
+* 格式化日期
+* @param date 日期字符串或 Date 对象
+* @returns 格式化后的字符串 YYYY-MM-DD
+*/
+function formatDate(date) {
+	return formatDateTime(date, "YYYY-MM-DD");
+}
+/**
+* 格式化时间
+* @param date 日期字符串或 Date 对象
+* @returns 格式化后的字符串 HH:mm:ss
+*/
+function formatTime(date) {
+	return formatDateTime(date, "HH:mm:ss");
+}
+/**
+* 生成开始结束时间
+* @param dates 日期字符串或 Date 对象数组
+* @returns 开始结束时间对象 { start: string; end: string }
+*/
+function generateStartEndTime(dates) {
+	if (!dates) return {
+		start: "",
+		end: ""
+	};
+	const start = dates[0];
+	const end = dates[dates.length - 1];
+	return {
+		start: formatDateTime(start, "YYYY-MM-DD 00:00:00"),
+		end: formatDateTime(end, "YYYY-MM-DD 23:59:59")
+	};
+}
+//#endregion
+export { cn, formatDate, formatDateTime, formatTime, generateStartEndTime };

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

@@ -0,0 +1,14 @@
+import type { BreadcrumbItemData } from "../components/breadcrumb/index";
+type State = {
+    items: BreadcrumbItemData[];
+};
+type Actions = {
+    setItems: (items: BreadcrumbItemData[]) => void;
+    addItem: (item: BreadcrumbItemData) => void;
+    removeItem: (id: string | number) => void;
+    clearItems: () => void;
+    setActiveItem: (id: string | number) => void;
+};
+export declare const breadcrumbStore: import("zustand").UseBoundStore<import("zustand").StoreApi<State & Actions>>;
+export declare const useBreadcrumbStore: import("zustand").UseBoundStore<import("zustand").StoreApi<State & Actions>>;
+export {};

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

@@ -0,0 +1,52 @@
+import { create } from "zustand";
+//#region packages/react/ui/stores/breadcrumb.ts
+var BREADCRUMB_STORAGE_KEY = "app-breadcrumb";
+var loadBreadcrumbFromStorage = () => {
+	try {
+		const stored = localStorage.getItem(BREADCRUMB_STORAGE_KEY);
+		if (stored) return JSON.parse(stored).map((item) => ({
+			id: item.id,
+			label: item.label || item.name || "",
+			desctext: item.desctext,
+			path: item.path,
+			active: item.active,
+			closable: item.closable
+		}));
+	} catch {}
+	return [];
+};
+var saveBreadcrumbToStorage = (items) => {
+	try {
+		localStorage.setItem(BREADCRUMB_STORAGE_KEY, JSON.stringify(items));
+	} catch {}
+};
+var breadcrumbStore = create((set) => ({
+	items: loadBreadcrumbFromStorage(),
+	setItems: (items) => {
+		set({ items });
+	},
+	addItem: (item) => {
+		set((state) => {
+			if (state.items.some((i) => i.id === item.id)) return state;
+			return { items: [...state.items, item] };
+		});
+	},
+	removeItem: (id) => {
+		set((state) => ({ items: state.items.filter((item) => item.id !== id || item.closable === false) }));
+	},
+	clearItems: () => {
+		set((state) => ({ items: state.items.filter((item) => item.closable === false) }));
+	},
+	setActiveItem: (id) => {
+		set((state) => ({ items: state.items.map((item) => ({
+			...item,
+			active: item.id === id
+		})) }));
+	}
+}));
+breadcrumbStore.subscribe((state) => {
+	saveBreadcrumbToStorage(state.items);
+});
+var useBreadcrumbStore = breadcrumbStore;
+//#endregion
+export { breadcrumbStore, useBreadcrumbStore };

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

@@ -0,0 +1,3 @@
+export { getLanguage, i18n, t } from "../../../common/i18n/index";
+export type { I18nLanguage as Language } from "../../../common/i18n/index";
+export { useI18nStore as useLanguages } from "../i18n";

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

@@ -0,0 +1,4 @@
+import { getLanguage, i18n, t } from "../../../common/i18n/index.js";
+import { useI18nStore } from "../i18n/useI18n.js";
+import "../i18n/index.js";
+export { getLanguage, i18n, t, useI18nStore as useLanguages };

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

@@ -0,0 +1 @@
+export type MOmit<T, K extends keyof T> = Omit<T, K>;

package/fe/typings/type.d.ts

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

package/model/frontend/extended/SchemaForm/data.d.ts

@@ -0,0 +1,9 @@
+declare const frameComponentsMap: {
+    asyncSelect: import("react").LazyExoticComponent<(props: import("@/components/AsyncSelect").AsyncSelectProps) => import("react/jsx-runtime").JSX.Element>;
+};
+export type FrameComponentsMap = typeof frameComponentsMap;
+export type FrameComponentsMapKey = keyof FrameComponentsMap;
+export type FrameComponentPropsMap = {
+    [K in FrameComponentsMapKey]: FrameComponentsMap[K] extends React.ComponentType<infer P> ? P : never;
+};
+export default frameComponentsMap;

package/model/frontend/src/common/auth/index.d.ts

@@ -0,0 +1,11 @@
+export declare const localKeyMap: {
+    AUTH_LOCAL_KEY: string;
+    API_AUTH_LOCAL_KEY: string;
+};
+export declare const AUTH_HEADER_KEY = "Authorization";
+export declare function getAuthToken(): string | null;
+export declare function setAuthToken(t: string): void | null;
+export declare function clearAuthToken(): Promise<void>;
+export declare const API_AUTH_HEADER_KEY = "projk";
+export declare const getApiAuth: () => string;
+export declare const setApiAuth: (v: string) => void;

package/model/frontend/src/common/fetchErrorShow.d.ts

@@ -0,0 +1,2 @@
+import type { BaseResponse, ResponseConfig } from "@/common/request";
+export declare const handlingRequestErrors: <D>(data: Promise<ResponseConfig<BaseResponse<D>, any>>) => Promise<ResponseConfig<BaseResponse<D>, any>>;

package/model/frontend/src/common/language.d.ts

@@ -0,0 +1,2 @@
+import type { I18nInterpolationValues, I18nTranslateOptions } from "../../../../fe/packages/react/ui/i18n/index";
+export declare const getText: (key: string, fillingData?: I18nInterpolationValues, options?: I18nTranslateOptions) => string;

package/model/frontend/src/common/logFn/index.d.ts

@@ -0,0 +1,4 @@
+export declare const logPageNotFound: () => void;
+export declare const logIllegalComponentCallback: (comName: string) => void;
+export declare const logSubscriptionError: () => void;
+export declare const logApiTamper: () => void;

package/model/frontend/src/common/request.d.ts

@@ -0,0 +1,33 @@
+import type { AxiosError, RequestConfig, ResponseConfig } from "@tc/common/http";
+import { FetchAxios } from "@tc/common/http";
+declare const api: FetchAxios;
+export interface PageParams {
+    page?: number;
+    pageSize?: number;
+    [key: string]: string | number | boolean | undefined | null;
+}
+export type PageResponse<T> = {
+    data: T[];
+    total: number;
+    page: number;
+    pageSize: number;
+};
+export interface BaseResponse<T> {
+    data: T;
+    code: number;
+    message: string;
+}
+export declare const get: <T = unknown, D = unknown>(url: string, data?: D, config?: RequestConfig<D>) => Promise<ResponseConfig<BaseResponse<T>, D>>;
+export declare const post: <T = unknown, D = unknown>(url: string, data?: D, config?: RequestConfig<D>) => Promise<ResponseConfig<BaseResponse<T>, D>>;
+export declare const put: <T = unknown, D = unknown>(url: string, data?: D, config?: RequestConfig<D>) => Promise<ResponseConfig<BaseResponse<T>, D>>;
+export declare const patch: <T = unknown, D = unknown>(url: string, data?: D, config?: RequestConfig<D>) => Promise<ResponseConfig<BaseResponse<T>, D>>;
+export declare const del: <T = unknown, D = unknown>(url: string, data?: D, config?: RequestConfig<D>) => Promise<ResponseConfig<BaseResponse<T>, D>>;
+export { api, FetchAxios };
+export type { AxiosError, RequestConfig, ResponseConfig };
+export declare const request: {
+    get: <T = unknown, D = unknown>(url: string, data?: D, config?: RequestConfig<D>) => Promise<ResponseConfig<BaseResponse<T>, D>>;
+    put: <T = unknown, D = unknown>(url: string, data?: D, config?: RequestConfig<D>) => Promise<ResponseConfig<BaseResponse<T>, D>>;
+    post: <T = unknown, D = unknown>(url: string, data?: D, config?: RequestConfig<D>) => Promise<ResponseConfig<BaseResponse<T>, D>>;
+    del: <T = unknown, D = unknown>(url: string, data?: D, config?: RequestConfig<D>) => Promise<ResponseConfig<BaseResponse<T>, D>>;
+    patch: <T = unknown, D = unknown>(url: string, data?: D, config?: RequestConfig<D>) => Promise<ResponseConfig<BaseResponse<T>, D>>;
+};

package/model/frontend/src/components/AsyncSelect/AsyncSelect.d.ts

@@ -0,0 +1,7 @@
+import type { MergeType, MOmit } from "../../../../../types/typings/type";
+import { FetchInfo } from "@model/data/fetchInfo";
+import { SelectProps } from "../../../../../fe/packages/react/ui/index";
+export interface AsyncSelectProps extends MergeType<[MOmit<FetchInfo, 'fetchKey'>, MOmit<SelectProps, 'options'>]> {
+}
+declare const AsyncSelect: (props: AsyncSelectProps) => import("react/jsx-runtime").JSX.Element;
+export default AsyncSelect;

package/model/frontend/src/components/AsyncSelect/index.d.ts

@@ -0,0 +1,3 @@
+import AsyncSelect from "./AsyncSelect";
+export * from "./AsyncSelect";
+export default AsyncSelect;

package/model/frontend/src/defaultPages/SchemaPage/components/CallCom/DetailPanel.d.ts

@@ -0,0 +1,6 @@
+import type { CallComNames, SchemaDefaultValue } from "../../schemaType";
+declare const DetailPanel: import("react").MemoExoticComponent<(props: {
+    data: SchemaDefaultValue;
+    comName: CallComNames;
+}) => import("react/jsx-runtime").JSX.Element>;
+export default DetailPanel;

package/model/frontend/src/defaultPages/SchemaPage/components/CallCom/PopFrom.d.ts

@@ -0,0 +1,12 @@
+import type { CallComNames, ComponentConfig, SchemaDefaultValue } from "../../schemaType";
+type PopFormComName = keyof ComponentConfig;
+export interface PopFormValue {
+    comName: PopFormComName;
+    data?: SchemaDefaultValue;
+}
+export interface PopFormProps {
+    data: SchemaDefaultValue;
+    comName: CallComNames;
+}
+declare const PopForm: import("react").MemoExoticComponent<(props: PopFormProps) => import("react/jsx-runtime").JSX.Element>;
+export default PopForm;

package/model/frontend/src/defaultPages/SchemaPage/components/CallCom/builtIn.d.ts

@@ -0,0 +1,28 @@
+import type { FetchInfo } from "@model/data/fetchInfo";
+import type { ComponentType, LazyExoticComponent } from "react";
+type CallComRenderer = ComponentType<any> | LazyExoticComponent<ComponentType<any>>;
+type CallComDefinition<Config> = CallComRenderer & {
+    readonly __config: Config;
+};
+type CreateFormConfig = {
+    title: string;
+    saveBtnText?: string;
+} & Partial<Pick<FetchInfo, 'fetchConfig'>>;
+type EditFormConfig = {
+    title: string;
+    saveBtnText?: string;
+} & FetchInfo;
+type DetailPanelConfig = {
+    title: string;
+} & FetchInfo;
+export declare const baseComponentsMap: {
+    editForm: CallComDefinition<EditFormConfig>;
+    createForm: CallComDefinition<CreateFormConfig>;
+    detailPanel: CallComDefinition<DetailPanelConfig>;
+};
+export type BuiltInCallComNames = Extract<keyof typeof baseComponentsMap, string>;
+type InferCallComConfig<T> = T extends CallComDefinition<infer Config> ? Config : never;
+export type BuiltInCallComConfigMap = {
+    [K in BuiltInCallComNames]?: InferCallComConfig<(typeof baseComponentsMap)[K]>;
+};
+export {};

package/model/frontend/src/defaultPages/SchemaPage/data/eventInfo.d.ts

@@ -0,0 +1,7 @@
+export declare const eventsInfo: {
+    readonly none: 0;
+    readonly closeCom: 1;
+    readonly initTable: 2;
+    readonly resetSearch: 2;
+};
+export type EventInfoKey = keyof typeof eventsInfo;

package/model/frontend/src/defaultPages/SchemaPage/data/index.d.ts

@@ -0,0 +1,2 @@
+export declare const suffixKey = "Option";
+export type SuffixKey = typeof suffixKey;

package/model/frontend/src/defaultPages/SchemaPage/hooks/useComConfig.d.ts

@@ -0,0 +1,9 @@
+import type { CallComNames, NamedComponentConfig, NamedSchemaType } from "../schemaType";
+declare const useComConfig: <CN extends CallComNames>({ comName }: {
+    comName: CallComNames;
+}) => {
+    config: NamedComponentConfig<CN>;
+    schema: NamedSchemaType<`${CN}Option`>;
+    api: string | undefined;
+};
+export default useComConfig;

package/model/frontend/src/defaultPages/SchemaPage/schemaType.d.ts

@@ -0,0 +1,41 @@
+import type { ComponentConfig } from "@model/data/component";
+import type { BaseOption, ConfigSchema, SchemaDataType, SearchConfig, TableConfig, UsedConfigSchema } from "@model/data/schema";
+import type { LazyExoticComponent, ComponentType as ReactComponentType } from "react";
+import type { SuffixKey } from "./data";
+export type { ComponentConfig, SearchConfig, TableConfig };
+export type FieldType = ConfigSchema['properties'][''];
+export type SchemaType = Required<SchemaDataType>['schema'];
+export type AllFieldKeys = keyof FieldType;
+export type AllOptionsPreNames = {
+    [K in AllFieldKeys]: K extends `${infer Name}${SuffixKey}` ? Name : never;
+}[AllFieldKeys];
+export type NonOptionKey = {
+    [K in AllFieldKeys]: K extends `${string}${SuffixKey}` ? never : K;
+}[AllFieldKeys];
+export type StoreSchemaType = UsedConfigSchema<BaseOption<FieldType[`${AllOptionsPreNames}${SuffixKey}`]>>;
+export type NamedSchemaType<N extends `${AllOptionsPreNames}${SuffixKey}`> = UsedConfigSchema<BaseOption<FieldType[N]>>;
+export type NamedComOption<N extends CallComNames> = ComponentType<ComponentConfig>[N];
+export type NamedComponentConfig<N extends CallComNames> = ComponentConfig[N];
+type ComponentC<C extends ComponentConfig> = {
+    [K in keyof C]: {
+        schema: StoreSchemaType;
+        config: C[K];
+    };
+}[keyof C];
+export type ComponentType<C extends ComponentConfig> = {
+    [K in keyof C]: ComponentC<C>;
+};
+export type CallComNames = keyof ComponentConfig;
+export type CallComRenderer = ReactComponentType<any> | LazyExoticComponent<ReactComponentType<any>>;
+export type SchemaDefaultValue = Record<string, any>;
+export type SchemaTableEmitData = SchemaDefaultValue & {
+    comName: CallComNames;
+};
+export declare const enum ComEventType {
+    close = 0
+}
+export type SchemaComEventInfo = {
+    type: number;
+};
+export type CallComponent<T> = Partial<Record<CallComNames, T>>;
+export type CallComComponentsMap = CallComponent<CallComRenderer>;

package/model/frontend/src/defaultPages/SchemaPage/utils/permissions.d.ts

@@ -0,0 +1,2 @@
+export declare const merge: (...params: number[]) => number;
+export declare const isAllowed: (key1: number, key2: number) => boolean;

package/model/frontend/src/defaultPages/SchemaPage/utils/validator.d.ts

@@ -0,0 +1,7 @@
+import { Ajv } from "ajv";
+export declare const ajvInstance: Ajv;
+type AjvValidatorOptions = {
+    required?: boolean;
+};
+export declare function createAjvValidator(schema: object, options?: AjvValidatorOptions): (rule: object, value: unknown, callback: (errors?: string[]) => void) => void;
+export {};

package/model/frontend/src/language/en-US.d.ts

@@ -0,0 +1,88 @@
+export declare const frontendEnUSResources: {
+    readonly frontend: {
+        readonly app: {
+            readonly title: "Template Core";
+            readonly uiComponentsTitle: "UI Components";
+            readonly uiComponentsButton: "Click me";
+        };
+        readonly components: {
+            readonly languageSwitch: {
+                readonly placeholder: "Select language";
+                readonly zhCN: "简体中文";
+                readonly enUS: "English";
+            };
+            readonly themeSwitch: {
+                readonly light: "Light";
+                readonly dark: "Dark";
+                readonly toLight: "Switch to light theme";
+                readonly toDark: "Switch to dark theme";
+            };
+        };
+        readonly common: {
+            readonly yes: "Yes";
+            readonly no: "No";
+            readonly noData: "No data";
+            readonly loading: "Loading";
+            readonly operation: "Actions";
+        };
+        readonly feedback: {
+            readonly confirmDelete: "Confirm delete?";
+            readonly requiredInput: "Please enter {label}";
+            readonly unknownError: "Unknown error";
+            readonly requestTimedOut: "Request timed out";
+            readonly networkError: "Network error";
+        };
+        readonly notFound: {
+            readonly title: "Page not found";
+            readonly description: "The current path is invalid, or the page is not registered in the router.";
+        };
+        readonly validator: {
+            readonly value: "value";
+            readonly required: "Missing required field: {field}";
+            readonly type: "{path} type error, expected {type}";
+            readonly typeString: "string";
+            readonly typeNumber: "number";
+            readonly typeInteger: "integer";
+            readonly typeBoolean: "boolean";
+            readonly typeArray: "array";
+            readonly typeObject: "object";
+            readonly typeNull: "null";
+            readonly format: "{path} format is invalid";
+            readonly minimum: "{path} cannot be less than {limit}";
+            readonly maximum: "{path} cannot be greater than {limit}";
+            readonly exclusiveMinimum: "{path} must be greater than {limit}";
+            readonly exclusiveMaximum: "{path} must be less than {limit}";
+            readonly multipleOf: "{path} must be a multiple of {multipleOf}";
+            readonly minLength: "{path} must be at least {limit} characters";
+            readonly maxLength: "{path} must be at most {limit} characters";
+            readonly pattern: "{path} format does not match the requirement";
+            readonly minItems: "{path} must contain at least {limit} items";
+            readonly maxItems: "{path} must contain at most {limit} items";
+            readonly uniqueItems: "{path} must not contain duplicate items";
+            readonly minProperties: "{path} must contain at least {limit} properties";
+            readonly maxProperties: "{path} must contain at most {limit} properties";
+            readonly additionalProperties: "{path} contains disallowed property {property}";
+            readonly enum: "{path} is not in the allowed options";
+            readonly const: "{path} must equal the specified value";
+            readonly oneOf: "{path} must match exactly one rule";
+            readonly anyOf: "{path} must match at least one rule";
+            readonly allOf: "{path} does not satisfy all rules";
+            readonly not: "{path} must not match this rule";
+            readonly propertyNames: "{path} property name is invalid";
+            readonly dependencies: "{path} is missing dependent fields";
+            readonly contains: "{path} is missing a required matching item";
+            readonly if: "{path} conditional validation failed";
+            readonly fallback: "{path} validation failed";
+        };
+        readonly log: {
+            readonly pageNotFound: "The URL is incorrect, or the custom page is not registered with the router.";
+            readonly pageNotFoundEn: "The URL is incorrect, or the custom page is not registered with the router.";
+            readonly illegalComponentCallback: "Illegal component callback - {comName}";
+            readonly illegalComponentCallbackEn: "Illegal component callback - {comName}";
+            readonly subscriptionError: "You haven't subscribed. Please check your code; the follow function and unsubscribe function must be the same.";
+            readonly subscriptionErrorEn: "You haven't subscribed. Please check your code; the follow function and unsubscribe function must be the same.";
+            readonly apiTamper: "API attributes cannot be tampered with";
+            readonly apiTamperEn: "API attributes cannot be tampered with";
+        };
+    };
+};

package/model/frontend/src/language/index.d.ts

@@ -0,0 +1,72 @@
+import type { I18nResources } from "../../../../fe/packages/react/ui/i18n/index";
+export declare const i18nKeyPrefix = "$i18n::";
+export declare const frontendI18nResources: I18nResources;
+export declare const withI18nKey: (key: string) => string;
+export declare const frontendLangKeys: {
+    readonly appTitle: string;
+    readonly uiComponentsTitle: string;
+    readonly uiComponentsButton: string;
+    readonly languageSwitchPlaceholder: string;
+    readonly languageSwitchZhCN: string;
+    readonly languageSwitchEnUS: string;
+    readonly themeSwitchLight: string;
+    readonly themeSwitchDark: string;
+    readonly themeSwitchToLight: string;
+    readonly themeSwitchToDark: string;
+    readonly yes: string;
+    readonly no: string;
+    readonly noData: string;
+    readonly loading: string;
+    readonly operation: string;
+    readonly confirmDelete: string;
+    readonly requiredInput: string;
+    readonly unknownError: string;
+    readonly requestTimedOut: string;
+    readonly networkError: string;
+    readonly notFoundTitle: string;
+    readonly notFoundDescription: string;
+    readonly validatorValue: string;
+    readonly validatorRequired: string;
+    readonly validatorType: string;
+    readonly validatorTypeString: string;
+    readonly validatorTypeNumber: string;
+    readonly validatorTypeInteger: string;
+    readonly validatorTypeBoolean: string;
+    readonly validatorTypeArray: string;
+    readonly validatorTypeObject: string;
+    readonly validatorTypeNull: string;
+    readonly validatorFormat: string;
+    readonly validatorMinimum: string;
+    readonly validatorMaximum: string;
+    readonly validatorExclusiveMinimum: string;
+    readonly validatorExclusiveMaximum: string;
+    readonly validatorMultipleOf: string;
+    readonly validatorMinLength: string;
+    readonly validatorMaxLength: string;
+    readonly validatorPattern: string;
+    readonly validatorMinItems: string;
+    readonly validatorMaxItems: string;
+    readonly validatorUniqueItems: string;
+    readonly validatorMinProperties: string;
+    readonly validatorMaxProperties: string;
+    readonly validatorAdditionalProperties: string;
+    readonly validatorEnum: string;
+    readonly validatorConst: string;
+    readonly validatorOneOf: string;
+    readonly validatorAnyOf: string;
+    readonly validatorAllOf: string;
+    readonly validatorNot: string;
+    readonly validatorPropertyNames: string;
+    readonly validatorDependencies: string;
+    readonly validatorContains: string;
+    readonly validatorIf: string;
+    readonly validatorFallback: string;
+    readonly logPageNotFound: string;
+    readonly logPageNotFoundEn: string;
+    readonly logIllegalComponentCallback: string;
+    readonly logIllegalComponentCallbackEn: string;
+    readonly logSubscriptionError: string;
+    readonly logSubscriptionErrorEn: string;
+    readonly logApiTamper: string;
+    readonly logApiTamperEn: string;
+};

package/model/frontend/src/language/zh-CN.d.ts

@@ -0,0 +1,88 @@
+export declare const frontendZhCNResources: {
+    readonly frontend: {
+        readonly app: {
+            readonly title: "Template Core";
+            readonly uiComponentsTitle: "UI 组件";
+            readonly uiComponentsButton: "点击我";
+        };
+        readonly components: {
+            readonly languageSwitch: {
+                readonly placeholder: "选择语言";
+                readonly zhCN: "简体中文";
+                readonly enUS: "English";
+            };
+            readonly themeSwitch: {
+                readonly light: "浅色";
+                readonly dark: "深色";
+                readonly toLight: "切换为浅色主题";
+                readonly toDark: "切换为深色主题";
+            };
+        };
+        readonly common: {
+            readonly yes: "是";
+            readonly no: "否";
+            readonly noData: "暂无数据";
+            readonly loading: "加载中";
+            readonly operation: "操作";
+        };
+        readonly feedback: {
+            readonly confirmDelete: "确认删除？";
+            readonly requiredInput: "请输入{label}";
+            readonly unknownError: "未知错误";
+            readonly requestTimedOut: "请求超时";
+            readonly networkError: "网络错误";
+        };
+        readonly notFound: {
+            readonly title: "页面不存在";
+            readonly description: "当前路径无效，或页面未在路由中注册。";
+        };
+        readonly validator: {
+            readonly value: "值";
+            readonly required: "缺少必填字段: {field}";
+            readonly type: "{path} 类型错误，期望 {type}";
+            readonly typeString: "字符串";
+            readonly typeNumber: "数字";
+            readonly typeInteger: "整数";
+            readonly typeBoolean: "布尔值";
+            readonly typeArray: "数组";
+            readonly typeObject: "对象";
+            readonly typeNull: "空值";
+            readonly format: "{path} 格式不正确";
+            readonly minimum: "{path} 不能小于 {limit}";
+            readonly maximum: "{path} 不能大于 {limit}";
+            readonly exclusiveMinimum: "{path} 必须大于 {limit}";
+            readonly exclusiveMaximum: "{path} 必须小于 {limit}";
+            readonly multipleOf: "{path} 必须是 {multipleOf} 的倍数";
+            readonly minLength: "{path} 长度不能少于 {limit} 个字符";
+            readonly maxLength: "{path} 长度不能超过 {limit} 个字符";
+            readonly pattern: "{path} 格式不符合要求";
+            readonly minItems: "{path} 至少需要 {limit} 项";
+            readonly maxItems: "{path} 不能超过 {limit} 项";
+            readonly uniqueItems: "{path} 不能包含重复项";
+            readonly minProperties: "{path} 至少需要 {limit} 个属性";
+            readonly maxProperties: "{path} 不能超过 {limit} 个属性";
+            readonly additionalProperties: "{path} 包含不允许的属性 {property}";
+            readonly enum: "{path} 不在可选范围内";
+            readonly const: "{path} 必须等于指定值";
+            readonly oneOf: "{path} 只能匹配一个规则";
+            readonly anyOf: "{path} 至少需要匹配一个规则";
+            readonly allOf: "{path} 未满足全部规则";
+            readonly not: "{path} 不能匹配该规则";
+            readonly propertyNames: "{path} 属性名不符合要求";
+            readonly dependencies: "{path} 缺少关联字段";
+            readonly contains: "{path} 缺少符合要求的项";
+            readonly if: "{path} 条件校验未通过";
+            readonly fallback: "{path} 校验未通过";
+        };
+        readonly log: {
+            readonly pageNotFound: "url有问题 或者 自定义页面未在路由器注册";
+            readonly pageNotFoundEn: "The URL is incorrect, or the custom page is not registered with the router.";
+            readonly illegalComponentCallback: "非法的组件回调 - {comName}";
+            readonly illegalComponentCallbackEn: "Illegal component callback - {comName}";
+            readonly subscriptionError: "不曾订阅过，请检查代码，关注函数与取消函数必须为同一个";
+            readonly subscriptionErrorEn: "You haven't subscribed. Please check your code; the follow function and unsubscribe function must be the same.";
+            readonly apiTamper: "api属性不允许篡改";
+            readonly apiTamperEn: "API attributes cannot be tampered with";
+        };
+    };
+};

package/model/frontend/src/stores/apiFreezer.d.ts

@@ -0,0 +1,26 @@
+type freezeQueue = Map<string, {
+    originFn: Function;
+    callBackFns: {
+        resolve: (value: unknown) => void;
+        reject: (reason?: any) => void;
+    }[];
+}>;
+export declare const FreezeState: {
+    readonly Hibernation: "Hibernation";
+    readonly Freeze: "Freeze";
+    readonly Thawing: "Thawing";
+};
+export type FreezeStateKeys = keyof typeof FreezeState;
+export type FreezeStateEnum = (typeof FreezeState)[FreezeStateKeys];
+export type ApiFreezerRequestMatcher = string | RegExp | ((api: string, params: readonly unknown[]) => boolean);
+interface ApiFreezerState {
+    readonly state: FreezeStateEnum;
+    freezing: () => void;
+    thawing: () => void;
+    requestWhitelist: ApiFreezerRequestMatcher[];
+    setRequestWhitelist: (data: ApiFreezerState['requestWhitelist']) => void;
+    readonly freezeQueue: freezeQueue;
+}
+export declare const apiFreezerStore: import("zustand").StoreApi<ApiFreezerState>;
+export declare const useApiFreezer: import("../../../../fe/packages/react/ui/index").StoreHook<import("zustand").StoreApi<ApiFreezerState>>;
+export {};