@zhin.js/schema 1.1.4 → 1.1.5

package/lib/schema.d.ts

@@ -57,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>[]>;
     /** 声明一个元组类型 */
@@ -130,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) {
@@ -221,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':
@@ -239,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':
@@ -310,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.4",
+  "version": "1.1.5",
   "description": "Configuration validation and schema system for Zhin.js",
   "type": "module",
   "main": "./lib/index.js",