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

package/fe/frontend/src/defaultPages/SchemaPage/utils/validator.js

@@ -0,0 +1,122 @@
+import { frontendLangKeys } from "../../../language/index.js";
+import { getText } from "../../../common/language.js";
+import { Ajv } from "ajv";
+//#region frontend/src/defaultPages/SchemaPage/utils/validator.ts
+var ajvInstance = new Ajv({
+	allErrors: true,
+	verbose: true,
+	strict: false
+});
+var isPlainObject = (value) => Object.prototype.toString.call(value) === "[object Object]";
+var isEmptyValue = (value) => value === void 0 || value === null || value === "" || Array.isArray(value) && value.length === 0 || isPlainObject(value) && Object.keys(value).length === 0;
+var getErrorPath = (error) => {
+	const path = error.instancePath.replace(/^\//, "");
+	if (path) return path;
+	return error.params.missingProperty || getText(frontendLangKeys.validatorValue);
+};
+var getTypeText = (type) => {
+	return (Array.isArray(type) ? type : [type]).filter((item) => typeof item === "string").map((item) => {
+		switch (item) {
+			case "string": return getText(frontendLangKeys.validatorTypeString);
+			case "number": return getText(frontendLangKeys.validatorTypeNumber);
+			case "integer": return getText(frontendLangKeys.validatorTypeInteger);
+			case "boolean": return getText(frontendLangKeys.validatorTypeBoolean);
+			case "array": return getText(frontendLangKeys.validatorTypeArray);
+			case "object": return getText(frontendLangKeys.validatorTypeObject);
+			case "null": return getText(frontendLangKeys.validatorTypeNull);
+			default: return item;
+		}
+	}).join(" / ");
+};
+/**
+* 创建验证器
+*/
+function createAjvValidator(schema, options = {}) {
+	const validate = ajvInstance.compile(schema);
+	return (rule, value, callback) => {
+		if (!options.required && isEmptyValue(value)) {
+			callback();
+			return;
+		}
+		if (validate(value)) callback();
+		else callback((validate.errors || []).map(formatError));
+	};
+}
+function formatError(error) {
+	const path = getErrorPath(error);
+	switch (error.keyword) {
+		case "required": return getText(frontendLangKeys.validatorRequired, { field: error.params.missingProperty });
+		case "type": return getText(frontendLangKeys.validatorType, {
+			path,
+			type: getTypeText(error.params.type)
+		});
+		case "format": return getText(frontendLangKeys.validatorFormat, {
+			path,
+			format: String(error.params.format ?? "")
+		});
+		case "minimum": return getText(frontendLangKeys.validatorMinimum, {
+			path,
+			limit: error.params.limit
+		});
+		case "maximum": return getText(frontendLangKeys.validatorMaximum, {
+			path,
+			limit: error.params.limit
+		});
+		case "exclusiveMinimum": return getText(frontendLangKeys.validatorExclusiveMinimum, {
+			path,
+			limit: error.params.limit
+		});
+		case "exclusiveMaximum": return getText(frontendLangKeys.validatorExclusiveMaximum, {
+			path,
+			limit: error.params.limit
+		});
+		case "multipleOf": return getText(frontendLangKeys.validatorMultipleOf, {
+			path,
+			multipleOf: error.params.multipleOf
+		});
+		case "minLength": return getText(frontendLangKeys.validatorMinLength, {
+			path,
+			limit: error.params.limit
+		});
+		case "maxLength": return getText(frontendLangKeys.validatorMaxLength, {
+			path,
+			limit: error.params.limit
+		});
+		case "pattern": return getText(frontendLangKeys.validatorPattern, { path });
+		case "minItems": return getText(frontendLangKeys.validatorMinItems, {
+			path,
+			limit: error.params.limit
+		});
+		case "maxItems": return getText(frontendLangKeys.validatorMaxItems, {
+			path,
+			limit: error.params.limit
+		});
+		case "uniqueItems": return getText(frontendLangKeys.validatorUniqueItems, { path });
+		case "minProperties": return getText(frontendLangKeys.validatorMinProperties, {
+			path,
+			limit: error.params.limit
+		});
+		case "maxProperties": return getText(frontendLangKeys.validatorMaxProperties, {
+			path,
+			limit: error.params.limit
+		});
+		case "additionalProperties": return getText(frontendLangKeys.validatorAdditionalProperties, {
+			path,
+			property: error.params.additionalProperty
+		});
+		case "enum": return getText(frontendLangKeys.validatorEnum, { path });
+		case "const": return getText(frontendLangKeys.validatorConst, { path });
+		case "oneOf": return getText(frontendLangKeys.validatorOneOf, { path });
+		case "anyOf": return getText(frontendLangKeys.validatorAnyOf, { path });
+		case "allOf": return getText(frontendLangKeys.validatorAllOf, { path });
+		case "not": return getText(frontendLangKeys.validatorNot, { path });
+		case "propertyNames": return getText(frontendLangKeys.validatorPropertyNames, { path });
+		case "dependencies":
+		case "dependentRequired": return getText(frontendLangKeys.validatorDependencies, { path });
+		case "contains": return getText(frontendLangKeys.validatorContains, { path });
+		case "if": return getText(frontendLangKeys.validatorIf, { path });
+		default: return getText(frontendLangKeys.validatorFallback, { path });
+	}
+}
+//#endregion
+export { ajvInstance, createAjvValidator };

package/fe/frontend/src/defaultPages/SidebarSlotPage/SidebarSlotContainer.d.ts

@@ -0,0 +1,9 @@
+import { BaseMenuType } from "../../../../model/types/menuType";
+import { MenuItemData } from "../../../../packages/react/ui/components/index";
+interface SidebarSlotContainerProps {
+    prefixPath: string;
+    rawMenuData: BaseMenuType[];
+    menuItems: MenuItemData[];
+}
+declare const SidebarSlotContainer: (props: SidebarSlotContainerProps) => import("react/jsx-runtime").JSX.Element;
+export default SidebarSlotContainer;

package/fe/frontend/src/defaultPages/SidebarSlotPage/SidebarSlotContainer.js

@@ -0,0 +1,55 @@
+import { Menu } from "../../../../packages/react/ui/components/Menu/Menu.js";
+import "../../../../packages/react/ui/components/index.js";
+import { QK, findMenuItem } from "../../common/menu.js";
+import useRouterParams from "../../hooks/useRouterParams.js";
+import { logPageNotFound } from "../../common/logFn/index.js";
+import { useEffect, useState } from "react";
+import { Outlet, useNavigate } from "react-router-dom";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region frontend/src/defaultPages/SidebarSlotPage/SidebarSlotContainer.tsx
+var SidebarSlotContainer = (props) => {
+	const { prefixPath, rawMenuData, menuItems } = props;
+	const params = useRouterParams();
+	const [SK, uSK] = useState(params[QK.sk]);
+	const nav = useNavigate();
+	useEffect(() => {
+		/**
+		* 如果没有 sidebar key 说明当前是 自定义路由
+		* 则需要获取 query 中的 ck 来查找 menuinfo
+		*/
+		if (!params[QK.sk]) {
+			if (params[QK.ck]) {
+				const m = findMenuItem(rawMenuData, params[QK.ck]);
+				if (m) {
+					uSK(m.key);
+					return;
+				}
+			}
+			logPageNotFound();
+		}
+	}, [rawMenuData, params]);
+	return /* @__PURE__ */ jsxs("div", {
+		className: "sidebar-slot flex h-full w-full gap-0 overflow-hidden bg-theme-bg",
+		children: [/* @__PURE__ */ jsx("div", {
+			className: "sidebar-slot-container flex h-full shrink-0 border-r border-border/70 bg-background/70 px-2 py-2",
+			children: /* @__PURE__ */ jsx(Menu, {
+				className: "sidebar-shell-menu",
+				items: menuItems,
+				selectedKey: SK,
+				onSelect: (e) => {
+					const m = findMenuItem(rawMenuData, e);
+					uSK(e);
+					nav({
+						...m.path,
+						pathname: prefixPath + m.path.pathname
+					});
+				}
+			})
+		}), /* @__PURE__ */ jsx("div", {
+			className: "min-w-0 flex-1 overflow-hidden",
+			children: /* @__PURE__ */ jsx(Outlet, {})
+		})]
+	});
+};
+//#endregion
+export { SidebarSlotContainer as default };

package/fe/frontend/src/defaultPages/SidebarSlotPage/index.d.ts

@@ -0,0 +1,2 @@
+declare const SidebarSlotPage: () => import("react/jsx-runtime").JSX.Element;
+export default SidebarSlotPage;

package/fe/frontend/src/defaultPages/SidebarSlotPage/index.js

@@ -0,0 +1,21 @@
+import { generateMenuItemData } from "../../common/generateMenuData.js";
+import { QK } from "../../common/menu.js";
+import useCurrentMenuData from "../../hooks/useCurrentMenuData.js";
+import SidebarSlotContainer from "./SidebarSlotContainer.js";
+import { useMemo } from "react";
+import { useParams } from "react-router-dom";
+import { jsx } from "react/jsx-runtime";
+//#region frontend/src/defaultPages/SidebarSlotPage/index.tsx
+var SidebarSlotPage = () => {
+	const params = useParams();
+	const { menu: parentMenuInfo } = useCurrentMenuData();
+	const menuKey = params[QK.k];
+	const prefixPath = useMemo(() => `/${menuKey}`, [menuKey]);
+	return /* @__PURE__ */ jsx(SidebarSlotContainer, {
+		menuItems: generateMenuItemData(parentMenuInfo?.sidebarConfig?.menu ?? []),
+		rawMenuData: parentMenuInfo?.sidebarConfig.menu,
+		prefixPath
+	});
+};
+//#endregion
+export { SidebarSlotPage as default };

package/fe/frontend/src/defaultPages/SidebarSlotPageTmp.d.ts

@@ -0,0 +1,2 @@
+declare const SidebarSlotPageTmp: () => import("react/jsx-runtime").JSX.Element;
+export default SidebarSlotPageTmp;

package/fe/frontend/src/defaultPages/SidebarSlotPageTmp.js

@@ -0,0 +1,21 @@
+import { generateMenuItemData } from "../common/generateMenuData.js";
+import { useModeStore } from "../stores/mode.js";
+import { leftSidebarBasePath } from "../common/menu.js";
+import SidebarSlotContainer from "./SidebarSlotPage/SidebarSlotContainer.js";
+import { useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region frontend/src/defaultPages/SidebarSlotPageTmp.tsx
+var SidebarSlotPageTmp = () => {
+	const projInfo = useModeStore((s) => s.projectInfo);
+	const [menuItems, rawMenuData] = useMemo(() => {
+		if (projInfo) return [generateMenuItemData(projInfo.menu), projInfo.menu];
+		return [[], []];
+	}, [projInfo]);
+	return /* @__PURE__ */ jsx(SidebarSlotContainer, {
+		prefixPath: "/" + leftSidebarBasePath,
+		rawMenuData,
+		menuItems
+	});
+};
+//#endregion
+export { SidebarSlotPageTmp as default };

package/fe/frontend/src/defaultPages/SlotPage/index.d.ts

@@ -0,0 +1,2 @@
+declare const SlotPage: import("react").MemoExoticComponent<() => import("react/jsx-runtime").JSX.Element>;
+export default SlotPage;

package/fe/frontend/src/defaultPages/SlotPage/index.js

@@ -0,0 +1,22 @@
+import { logPageNotFound } from "../../common/logFn/index.js";
+import useCurrentMenuData from "../../hooks/useCurrentMenuData.js";
+import Iframe from "../Iframe/index.js";
+import NotFoundPage from "../NotFoundPage/index.js";
+import Schema from "../SchemaPage/index.js";
+import { memo, useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region frontend/src/defaultPages/SlotPage/index.tsx
+var SlotPage = memo(() => {
+	const { menu } = useCurrentMenuData(true);
+	return useMemo(() => {
+		if (menu?.moduleType === "iframe") return /* @__PURE__ */ jsx(Iframe, {});
+		else if (menu?.moduleType === "schema") return /* @__PURE__ */ jsx(Schema, {});
+		else {
+			logPageNotFound();
+			return /* @__PURE__ */ jsx(NotFoundPage, {});
+		}
+	}, [menu?.moduleType]);
+});
+SlotPage.displayName = "SlotPage";
+//#endregion
+export { SlotPage as default };

package/fe/frontend/src/exportStore.d.ts

@@ -0,0 +1,4 @@
+export * from "./stores/mode";
+export * from "./stores/schemaEventBus";
+export * from "./stores/schemaStore";
+export * from "./stores/apiFreezer";

package/fe/frontend/src/exportStore.js

@@ -0,0 +1,5 @@
+import { FreezeState, apiFreezerStore, useApiFreezer } from "./stores/apiFreezer.js";
+import { modeStore, useModeStore } from "./stores/mode.js";
+import { schemaEventBus } from "./stores/schemaEventBus.js";
+import { schemaStore, useSchemaStore } from "./stores/schemaStore.js";
+export { FreezeState, apiFreezerStore, modeStore, schemaEventBus, schemaStore, useApiFreezer, useModeStore, useSchemaStore };

package/fe/frontend/src/hooks/useCurrentMenuData.d.ts

@@ -0,0 +1,10 @@
+import { BasicModuleType, SidebarModuleType } from "../../../model/types/menuType";
+declare const useCurrentMenuData: <T = {
+    moduleType: BasicModuleType["moduleType"];
+    sidebarConfig: SidebarModuleType["sidebarConfig"];
+}>(useSibe?: boolean) => {
+    menu: T & {
+        moduleType: BasicModuleType["moduleType"];
+    };
+};
+export default useCurrentMenuData;

package/fe/frontend/src/hooks/useCurrentMenuData.js

@@ -0,0 +1,30 @@
+import { useModeStore } from "../stores/mode.js";
+import { QK, findMenuItem } from "../common/menu.js";
+import { useMemo } from "react";
+import { useParams } from "react-router-dom";
+//#region frontend/src/hooks/useCurrentMenuData.ts
+/**
+*
+* 自定义路由直接交由路由器渲染
+*
+* 也就是说 这里找不到 自定义相关的菜单数据
+*
+* @param useSibe 使用侧边数据
+*/
+var useCurrentMenuData = (useSibe = false) => {
+	const params = useParams();
+	const projectInfo = useModeStore((s) => s.projectInfo);
+	return { menu: useMemo(() => {
+		const isSide = params[QK.sk];
+		const menuTypeIsTop = !!params[QK.k];
+		const menu = findMenuItem(projectInfo?.menu, menuTypeIsTop ? params[QK.k] : params[QK.sk]);
+		if (isSide && useSibe && menuTypeIsTop && menu) return findMenuItem(menu.sidebarConfig?.menu ?? [], params[QK.sk]);
+		return menu;
+	}, [
+		projectInfo?.menu,
+		params,
+		useSibe
+	]) };
+};
+//#endregion
+export { useCurrentMenuData as default };

package/fe/frontend/src/hooks/useRouterParams.d.ts

@@ -0,0 +1,4 @@
+declare const useRouterParams: <T extends Record<string, string>>() => Readonly<[T] extends [string] ? import("react-router-dom").Params<T> : Partial<T>> & {
+    custk?: string | undefined;
+};
+export default useRouterParams;

package/fe/frontend/src/hooks/useRouterParams.js

@@ -0,0 +1,16 @@
+import { QK, deserializationUrlSearch } from "../common/menu.js";
+import { useMemo } from "react";
+import { useParams } from "react-router-dom";
+//#region frontend/src/hooks/useRouterParams.ts
+var useRouterParams = () => {
+	const params = useParams();
+	return useMemo(() => {
+		const query = deserializationUrlSearch(location.search);
+		return {
+			...params,
+			...query[QK.ck] ? { [QK.ck]: query[QK.ck] } : {}
+		};
+	}, [params]);
+};
+//#endregion
+export { useRouterParams as default };

package/fe/frontend/src/index.d.ts

@@ -0,0 +1,13 @@
+import "./typing/scalability";
+export type * from "../apps/dash/types";
+export * from "./main";
+export type { CallComComponentsMap, CallComRenderer } from "./defaultPages/SchemaPage/schemaType";
+export * from "./components/index";
+export type { FormFieldSchema, SchemaFormComponentsMap, SchemaFormNamespace, SelectProps } from "../../packages/react/ui/index";
+export { api, del, get, patch, post, put, request } from "./common/request";
+export type { AxiosError, BaseResponse, PageParams, PageResponse, RequestConfig, ResponseConfig } from "./common/request";
+export * from "./defaultPages/SchemaPage/data/eventInfo";
+export { merge } from "./defaultPages/SchemaPage/utils/permissions";
+export * from "./exportStore";
+export { i18n, i18nStore } from "../../packages/react/ui/i18n/index";
+export { getAuthToken, localKeyMap, setAuthToken } from "./common/auth/index";

package/fe/frontend/src/index.js

@@ -0,0 +1,20 @@
+import { getAuthToken, localKeyMap, setAuthToken } from "./common/auth/index.js";
+import { i18n, i18nStore } from "../../packages/common/i18n/index.js";
+import "../../packages/react/ui/i18n/index.js";
+import { FreezeState, apiFreezerStore, useApiFreezer } from "./stores/apiFreezer.js";
+import { api, del, get, patch, post, put, request } from "./common/request.js";
+import { modeStore, useModeStore } from "./stores/mode.js";
+import HeaderView from "./components/BasePage/HeaderView.js";
+import { generateRouter } from "./components/Router/index.js";
+import { schemaEventBus } from "./stores/schemaEventBus.js";
+import { schemaStore, useSchemaStore } from "./stores/schemaStore.js";
+import "./exportStore.js";
+import { initApp } from "./main.js";
+import AsyncSelect_default from "./components/AsyncSelect/index.js";
+import LanguageSwitch_default from "./components/LanguageSwitch/index.js";
+import { themeSwitchStorageKey } from "./components/ThemeSwitch/ThemeSwitch.js";
+import ThemeSwitch_default from "./components/ThemeSwitch/index.js";
+import "./components/index.js";
+import { eventsInfo } from "./defaultPages/SchemaPage/data/eventInfo.js";
+import { merge } from "./defaultPages/SchemaPage/utils/permissions.js";
+export { AsyncSelect_default as AsyncSelect, FreezeState, HeaderView, LanguageSwitch_default as LanguageSwitch, ThemeSwitch_default as ThemeSwitch, api, apiFreezerStore, del, eventsInfo, generateRouter, get, getAuthToken, i18n, i18nStore, initApp, localKeyMap, merge, modeStore, patch, post, put, request, schemaEventBus, schemaStore, setAuthToken, themeSwitchStorageKey, useApiFreezer, useModeStore, useSchemaStore };

package/fe/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/fe/frontend/src/language/en-US.js

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

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

@@ -0,0 +1,72 @@
+import type { I18nResources } from "../../../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;
+};