@_tc/template-core 0.0.2 → 0.1.0

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

@@ -1,12 +1,57 @@
+import { getText } from '../../../common/language';
+import { frontendLangKeys } from '../../../language';
 import { Ajv } from 'ajv';
 // 初始化 AJV (全局复用)
 export const ajvInstance = new Ajv({ allErrors: true, verbose: true, strict: false });
+const isPlainObject = (value) => Object.prototype.toString.call(value) === '[object Object]';
+const isEmptyValue = (value) => value === undefined ||
+    value === null ||
+    value === '' ||
+    (Array.isArray(value) && value.length === 0) ||
+    (isPlainObject(value) && Object.keys(value).length === 0);
+const getErrorPath = (error) => {
+    const path = error.instancePath.replace(/^\//, '');
+    if (path)
+        return path;
+    const missingProperty = error.params.missingProperty;
+    return missingProperty || getText(frontendLangKeys.validatorValue);
+};
+const getTypeText = (type) => {
+    const types = Array.isArray(type) ? type : [type];
+    return types
+        .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(' / ');
+};
 /**
  * 创建验证器
  */
-export function createAjvValidator(schema) {
+export function createAjvValidator(schema, options = {}) {
     const validate = ajvInstance.compile(schema);
     return (rule, value, callback) => {
+        if (!options.required && isEmptyValue(value)) {
+            callback();
+            return;
+        }
         const valid = validate(value);
         if (valid) {
             callback();
@@ -19,18 +64,108 @@ export function createAjvValidator(schema) {
 }
 // 格式化错误信息
 function formatError(error) {
-    const path = error.instancePath.replace(/^\//, '') || 'value';
+    const path = getErrorPath(error);
     switch (error.keyword) {
         case 'required':
-            return `缺少必填字段: ${error.params.missingProperty}`;
+            return getText(frontendLangKeys.validatorRequired, {
+                field: error.params.missingProperty,
+            });
         case 'type':
-            return `${path} 类型错误，期望 ${error.params.type}`;
+            return getText(frontendLangKeys.validatorType, {
+                path,
+                type: getTypeText(error.params.type),
+            });
         case 'format':
-            return `${path} 格式不正确`;
+            return getText(frontendLangKeys.validatorFormat, {
+                path,
+                format: String(error.params.format ?? ''),
+            });
         case 'minimum':
+            return getText(frontendLangKeys.validatorMinimum, {
+                path,
+                limit: error.params.limit,
+            });
         case 'maximum':
-            return `${path} 超出允许范围`;
+            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 `${path} ${error.message}`;
+            return getText(frontendLangKeys.validatorFallback, { path });
     }
 }

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

@@ -9,7 +9,8 @@ const SidebarSlotPage = () => {
     const params = useParams();
     // top left 从当前路由中获取到 sidebarConfig中的数据
     const { menu: parentMenuInfo } = useCurrentMenuData();
-    const prefixPath = useMemo(() => `/${params[QK.k]}`, [params[QK.k]]);
+    const menuKey = params[QK.k];
+    const prefixPath = useMemo(() => `/${menuKey}`, [menuKey]);
     const menuItem = generateMenuItemData(parentMenuInfo?.sidebarConfig?.menu ?? []);
     return (_jsx(SidebarSlotContainer, { menuItems: menuItem, rawMenuData: parentMenuInfo?.sidebarConfig.menu, prefixPath: prefixPath }));
 };

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

@@ -11,7 +11,7 @@ const SidebarSlotPageTmp = () => {
             return [generateMenuItemData(projInfo.menu), projInfo.menu];
         }
         return [[], []];
-    }, []);
+    }, [projInfo]);
     return (_jsx(SidebarSlotContainer, { prefixPath: '/' + leftSidebarBasePath, rawMenuData: rawMenuData, menuItems: menuItems }));
 };
 export default SidebarSlotPageTmp;

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

@@ -3,6 +3,7 @@ import { memo, useMemo } from 'react';
 import { logPageNotFound } from '../../common/logFn';
 import useCurrentMenuData from '../../hooks/useCurrentMenuData';
 import Iframe from '../Iframe';
+import NotFoundPage from '../NotFoundPage';
 import Schema from '../SchemaPage';
 const SlotPage = memo(() => {
     const { menu } = useCurrentMenuData(true);
@@ -17,7 +18,7 @@ const SlotPage = memo(() => {
             // 运行到这 说明异常路径
             // 自定义路径会在进入这之前被拦截;
             logPageNotFound();
-            return _jsx("div", { children: "404" });
+            return _jsx(NotFoundPage, {});
         }
     }, [menu?.moduleType]);
     return RenderDom;

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

@@ -22,7 +22,7 @@ const useCurrentMenuData = (useSibe = false) => {
             return sMenu;
         }
         return menu;
-    }, [projectInfo?.menu, params]);
+    }, [projectInfo?.menu, params, useSibe]);
     return { menu: menu };
 };
 export default useCurrentMenuData;

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

@@ -13,4 +13,8 @@ export { merge } from './defaultPages/SchemaPage/utils/permissions';
  * 导出依赖的 共享数据
  */
 export * from './exportStore';
+/**
+ * 导出多语言相关
+ */
+export { i18n, i18nStore } from '../../packages/ui/react/i18n';
 //# sourceMappingURL=index.d.ts.map

package/fe/frontend/src/index.js

@@ -11,3 +11,7 @@ export { merge } from './defaultPages/SchemaPage/utils/permissions';
  * 导出依赖的 共享数据
  */
 export * from './exportStore';
+/**
+ * 导出多语言相关
+ */
+export { i18n, i18nStore } from '../../packages/ui/react/i18n';

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

@@ -0,0 +1,76 @@
+export declare const frontendEnUSResources: {
+    readonly frontend: {
+        readonly app: {
+            readonly title: "Template Core";
+            readonly uiComponentsTitle: "UI Components";
+            readonly uiComponentsButton: "Click me";
+        };
+        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";
+        };
+    };
+};
+//# sourceMappingURL=en-US.d.ts.map

package/fe/frontend/src/language/en-US.js

@@ -0,0 +1,75 @@
+export const frontendEnUSResources = {
+    frontend: {
+        app: {
+            title: 'Template Core',
+            uiComponentsTitle: 'UI Components',
+            uiComponentsButton: 'Click me',
+        },
+        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',
+        },
+    },
+};

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

@@ -0,0 +1,66 @@
+import type { I18nResources } from '../../../packages/ui/react/i18n';
+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 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;
+};
+//# sourceMappingURL=index.d.ts.map

package/fe/frontend/src/language/index.js

@@ -0,0 +1,69 @@
+import { frontendEnUSResources } from './en-US';
+import { frontendZhCNResources } from './zh-CN';
+export const i18nKeyPrefix = '$i18n::';
+export const frontendI18nResources = {
+    'zh-CN': frontendZhCNResources,
+    'en-US': frontendEnUSResources,
+};
+export const withI18nKey = (key) => `${i18nKeyPrefix}${key}`;
+export const frontendLangKeys = {
+    appTitle: withI18nKey('frontend.app.title'),
+    uiComponentsTitle: withI18nKey('frontend.app.uiComponentsTitle'),
+    uiComponentsButton: withI18nKey('frontend.app.uiComponentsButton'),
+    yes: withI18nKey('frontend.common.yes'),
+    no: withI18nKey('frontend.common.no'),
+    noData: withI18nKey('frontend.common.noData'),
+    loading: withI18nKey('frontend.common.loading'),
+    operation: withI18nKey('frontend.common.operation'),
+    confirmDelete: withI18nKey('frontend.feedback.confirmDelete'),
+    requiredInput: withI18nKey('frontend.feedback.requiredInput'),
+    unknownError: withI18nKey('frontend.feedback.unknownError'),
+    requestTimedOut: withI18nKey('frontend.feedback.requestTimedOut'),
+    networkError: withI18nKey('frontend.feedback.networkError'),
+    notFoundTitle: withI18nKey('frontend.notFound.title'),
+    notFoundDescription: withI18nKey('frontend.notFound.description'),
+    validatorValue: withI18nKey('frontend.validator.value'),
+    validatorRequired: withI18nKey('frontend.validator.required'),
+    validatorType: withI18nKey('frontend.validator.type'),
+    validatorTypeString: withI18nKey('frontend.validator.typeString'),
+    validatorTypeNumber: withI18nKey('frontend.validator.typeNumber'),
+    validatorTypeInteger: withI18nKey('frontend.validator.typeInteger'),
+    validatorTypeBoolean: withI18nKey('frontend.validator.typeBoolean'),
+    validatorTypeArray: withI18nKey('frontend.validator.typeArray'),
+    validatorTypeObject: withI18nKey('frontend.validator.typeObject'),
+    validatorTypeNull: withI18nKey('frontend.validator.typeNull'),
+    validatorFormat: withI18nKey('frontend.validator.format'),
+    validatorMinimum: withI18nKey('frontend.validator.minimum'),
+    validatorMaximum: withI18nKey('frontend.validator.maximum'),
+    validatorExclusiveMinimum: withI18nKey('frontend.validator.exclusiveMinimum'),
+    validatorExclusiveMaximum: withI18nKey('frontend.validator.exclusiveMaximum'),
+    validatorMultipleOf: withI18nKey('frontend.validator.multipleOf'),
+    validatorMinLength: withI18nKey('frontend.validator.minLength'),
+    validatorMaxLength: withI18nKey('frontend.validator.maxLength'),
+    validatorPattern: withI18nKey('frontend.validator.pattern'),
+    validatorMinItems: withI18nKey('frontend.validator.minItems'),
+    validatorMaxItems: withI18nKey('frontend.validator.maxItems'),
+    validatorUniqueItems: withI18nKey('frontend.validator.uniqueItems'),
+    validatorMinProperties: withI18nKey('frontend.validator.minProperties'),
+    validatorMaxProperties: withI18nKey('frontend.validator.maxProperties'),
+    validatorAdditionalProperties: withI18nKey('frontend.validator.additionalProperties'),
+    validatorEnum: withI18nKey('frontend.validator.enum'),
+    validatorConst: withI18nKey('frontend.validator.const'),
+    validatorOneOf: withI18nKey('frontend.validator.oneOf'),
+    validatorAnyOf: withI18nKey('frontend.validator.anyOf'),
+    validatorAllOf: withI18nKey('frontend.validator.allOf'),
+    validatorNot: withI18nKey('frontend.validator.not'),
+    validatorPropertyNames: withI18nKey('frontend.validator.propertyNames'),
+    validatorDependencies: withI18nKey('frontend.validator.dependencies'),
+    validatorContains: withI18nKey('frontend.validator.contains'),
+    validatorIf: withI18nKey('frontend.validator.if'),
+    validatorFallback: withI18nKey('frontend.validator.fallback'),
+    logPageNotFound: withI18nKey('frontend.log.pageNotFound'),
+    logPageNotFoundEn: withI18nKey('frontend.log.pageNotFoundEn'),
+    logIllegalComponentCallback: withI18nKey('frontend.log.illegalComponentCallback'),
+    logIllegalComponentCallbackEn: withI18nKey('frontend.log.illegalComponentCallbackEn'),
+    logSubscriptionError: withI18nKey('frontend.log.subscriptionError'),
+    logSubscriptionErrorEn: withI18nKey('frontend.log.subscriptionErrorEn'),
+    logApiTamper: withI18nKey('frontend.log.apiTamper'),
+    logApiTamperEn: withI18nKey('frontend.log.apiTamperEn'),
+};

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

@@ -0,0 +1,76 @@
+export declare const frontendZhCNResources: {
+    readonly frontend: {
+        readonly app: {
+            readonly title: "Template Core";
+            readonly uiComponentsTitle: "UI 组件";
+            readonly uiComponentsButton: "点击我";
+        };
+        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";
+        };
+    };
+};
+//# sourceMappingURL=zh-CN.d.ts.map