@zhin.js/schema 1.1.3 → 1.1.5

package/lib/json-schema.d.ts

@@ -1,4 +1,10 @@
 import type { Schema } from './schema.js';
+/** Optional display metadata; translated labels never change stored values. */
+export type ConfigFieldI18n = Readonly<Partial<Record<'zh-CN' | 'en', Readonly<{
+    title?: string;
+    description?: string;
+    enumLabels?: Readonly<Record<string, string>>;
+}>>>>;
 /** Form annotations on the same JSON Schema used for configuration validation. */
 export interface ConfigFieldMetadata {
     readonly secret?: boolean;

package/lib/json-schema.js

@@ -69,6 +69,8 @@ export function toJsonSchema(schema) {
     }
     if (meta.description !== undefined)
         result.description = meta.description;
+    if (meta.i18n !== undefined)
+        result['x-i18n'] = structuredClone(meta.i18n);
     if (meta.default !== undefined) {
         assertJsonValue(meta.default);
         assertPublicDefault(schema, meta.default);

package/lib/schema.d.ts

@@ -1,5 +1,5 @@
 import { safeParseSchema, type SchemaSafeParseResult } from './validate.js';
-import { type ConfigFieldMetadata } from './json-schema.js';
+import { type ConfigFieldMetadata, type ConfigFieldI18n } from './json-schema.js';
 export { SchemaValidationError, type SchemaSafeParseResult, type SchemaValidationIssue } from './validate.js';
 export { safeParseSchema };
 declare const configPresent: unique symbol;
@@ -23,6 +23,8 @@ export declare class Schema<S = any, T = S> {
     hidden(): this;
     /** 设置描述 */
     description(description: string): this;
+    /** Translate form labels without changing validation, defaults or values. */
+    i18n(translations: ConfigFieldI18n): this;
     /** 设置默认值 */
     default(defaultValue: T): this & Schema.Present;
     /** Secret values remain environment references in application configuration. */
@@ -55,7 +57,9 @@ export declare class Schema<S = any, T = S> {
     static date(key?: string): Schema<number | Date, Date>;
     /** 声明一个字典类型 */
     static dict<X extends Schema>(input: X, key?: string): Schema<Record<string, Schema.Input<X>>, Record<string, Schema.Output<X>>>;
-    static object<X extends Record<string, Schema<any, any>>>(input: X, key?: string): Schema<Schema.InputRecord<X>, Schema.RecordTypes<X>>;
+    static object<X extends Record<string, Schema<any, any>>>(input: X, key?: string): Schema<Schema.InputRecord<X>, Schema.RecordTypes<X>> & {
+        readonly output?: Schema.RecordTypes<X>;
+    };
     /** 声明一个列表类型 */
     static list<X extends Schema>(inner: X, key?: string): Schema<Schema.Input<X>[], Schema.Output<X>[]>;
     /** 声明一个元组类型 */
@@ -114,6 +118,7 @@ export declare namespace Schema {
         multiple?: boolean;
         key?: string;
         description?: string;
+        i18n?: ConfigFieldI18n;
         component?: string;
         min?: number;
         max?: number;
@@ -127,11 +132,11 @@ export declare namespace Schema {
         list?: readonly Schema[];
     }
     type Types<T> = Output<T>;
-    type RecordTypes<T> = T extends Record<string, Schema> ? {
+    type RecordTypes<T extends Record<string, any>> = {
         [K in keyof T as T[K] extends Present ? K : never]-?: Output<T[K]>;
     } & {
         [K in keyof T as T[K] extends Present ? never : K]?: Output<T[K]>;
-    } : unknown;
+    };
     type Union<T extends readonly any[]> = T extends readonly [infer L, ...infer R] ? Types<L> | Union<R> : never;
     type Intersect<T extends readonly any[]> = T extends readonly [infer L, ...infer R] ? Types<L> & Intersect<R> : unknown;
     type Tuple<T extends readonly any[]> = T extends readonly [infer L, ...infer R] ? [Types<L>, ...Tuple<R>] : [];

package/lib/schema.js

@@ -24,6 +24,9 @@ export class Schema {
             set(target, p, value, receiver) {
                 return Reflect.set(_this, p, value, receiver);
             },
+            has(target, p) {
+                return Reflect.has(_this, p) || Reflect.has(target, p);
+            },
         });
     }
     static fromJSON(json) {
@@ -75,6 +78,11 @@ export class Schema {
         this.meta.description = description;
         return this;
     }
+    /** Translate form labels without changing validation, defaults or values. */
+    i18n(translations) {
+        this.meta.i18n = structuredClone(translations);
+        return this;
+    }
     /** 设置默认值 */
     default(defaultValue) {
         this.meta.default = defaultValue;
@@ -216,7 +224,7 @@ export class Schema {
                         throw new TypeError(`${key} is not a string`);
                     break;
                 case 'number':
-                    if (!['number', 'undefined'].includes(typeof value))
+                    if (!['number', 'undefined'].includes(typeof value) || (typeof value === 'number' && Number.isNaN(value)))
                         throw new TypeError(`${key} is not a number`);
                     break;
                 case 'boolean':
@@ -234,11 +242,11 @@ export class Schema {
                         throw new TypeError(`${key} is not a valid Date`);
                     break;
                 case 'dict':
-                    if (!['object', 'undefined', 'null'].includes(typeof value))
+                    if (!['object', 'undefined'].includes(typeof value) || value === null || Array.isArray(value))
                         throw new TypeError(`${key} is not a object`);
                     break;
                 case 'object':
-                    if (!['object', 'undefined', 'null'].includes(typeof value))
+                    if (!['object', 'undefined'].includes(typeof value) || value === null || Array.isArray(value))
                         throw new TypeError(`${key} is not a object`);
                     break;
                 case 'list':
@@ -305,19 +313,27 @@ Schema.extend('dict', function (key, value) {
 Schema.extend('object', function (key, value) {
     const getDefault = (schema) => {
         const result = Object.create(null);
-        for (const key in schema.options.object) {
-            const propSchema = schema.options.object[key];
-            result[key] = propSchema.default !== undefined ? propSchema.default : undefined;
+        for (const propKey in schema.options.object) {
+            const propSchema = schema.options.object[propKey];
+            result[propKey] = propSchema.meta.default !== undefined ? propSchema.meta.default : undefined;
         }
         return result;
     };
     value = Schema.checkDefault(this, key, value, getDefault(this));
+    if (value === undefined)
+        return value;
     const result = Object.create(null);
-    for (const [k, val] of Object.entries(value)) {
-        const propSchema = this.options.object[k];
+    const shape = this.options.object || {};
+    const allKeys = new Set([...Object.keys(shape), ...Object.keys(value)]);
+    for (const k of allKeys) {
+        const val = value[k];
+        const propSchema = shape[k];
         if (propSchema) {
             // propSchema是一个可调用的Schema实例
-            result[k] = propSchema(val, `${key}.${k}`);
+            const evaluated = propSchema(val, `${key}.${k}`);
+            if (evaluated !== undefined || k in value) {
+                result[k] = evaluated;
+            }
         }
         else {
             result[k] = val;

package/lib/validate.js

@@ -29,7 +29,7 @@ function validateOnly(schema, path, value) {
             }
             return value;
         case 'number':
-            if (value !== undefined && typeof value !== 'number') {
+            if (value !== undefined && (typeof value !== 'number' || Number.isNaN(value))) {
                 throw issue(path, `${path} is not a number`);
             }
             return value;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhin.js/schema",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "description": "Configuration validation and schema system for Zhin.js",
   "type": "module",
   "main": "./lib/index.js",