@lucania/schema 3.1.2 → 3.1.4

package/build/builder.d.ts

@@ -11,6 +11,7 @@ import { NumberSchema, NumberSource } from "./schema/NumberSchema";
 import { ObjectSchema, ObjectSource, ObjectSubschema } from "./schema/ObjectSchema";
 import { OrSetSchema, OrSetSchemaSource } from "./schema/OrSetSchema";
 import { StringSchema, StringSource } from "./schema/StringSchema";
+import { TupleSchema, TupleSource } from "./schema/TupleSchema";
 import { BaseSchemaAny } from "./typing/extended";
 import { DefaultValue, ModelValue, SourceValue } from "./typing/toolbox";
 /**
@@ -147,6 +148,9 @@ export declare namespace Schema {
     function Enumeration<Members extends string[]>(subschema: TypedMembers<Members>): EnumerationSchema<Members, true, undefined>;
     function Enumeration<Members extends string[], Required extends boolean>(subschema: TypedMembers<Members>, required: Required): EnumerationSchema<Members, Required, undefined>;
     function Enumeration<Members extends string[], Required extends boolean, Default extends DefaultValue<EnumerationSource<Members>>>(subschema: TypedMembers<Members>, required: Required, defaultValue: Default): EnumerationSchema<Members, Required, Default>;
+    function Tuple<Members extends BaseSchemaAny[]>(members: TypedMembers<Members>): TupleSchema<Members, true, undefined>;
+    function Tuple<Members extends BaseSchemaAny[], Required extends boolean>(members: TypedMembers<Members>, required: Required): TupleSchema<Members, Required, undefined>;
+    function Tuple<Members extends BaseSchemaAny[], Required extends boolean, Default extends DefaultValue<TupleSource<Members>>>(members: TypedMembers<Members>, required: Required, defaultValue: Default): TupleSchema<Members, Required, Default>;
     function OrSet<MemberSchemas extends BaseSchemaAny[]>(subschema: TypedMembers<MemberSchemas>): OrSetSchema<MemberSchemas, true, undefined>;
     function OrSet<MemberSchemas extends BaseSchemaAny[], Required extends boolean>(subschema: TypedMembers<MemberSchemas>, required: Required): OrSetSchema<MemberSchemas, Required, undefined>;
     function OrSet<MemberSchemas extends BaseSchemaAny[], Required extends boolean, Default extends DefaultValue<OrSetSchemaSource<MemberSchemas>>>(subschema: TypedMembers<MemberSchemas>, required: Required, defaultValue: Default): OrSetSchema<MemberSchemas, Required, Default>;

package/build/index.js

@@ -262,6 +262,9 @@
             }
             const type = typeof value;
             if (type === "object") {
+                if (value.constructor === undefined) {
+                    return type;
+                }
                 const constructor = value.constructor.name;
                 if (constructor === "Object") {
                     return type;
@@ -707,7 +710,7 @@
             return output;
         }
         convert(value, pass) {
-            pass.assert(typeof value === "object", `Unable to convert ${ObjectSchema.getType(value)} to object.`);
+            pass.assert(typeof value === "object" && value !== null, `Unable to convert ${ObjectSchema.getType(value)} to object.`);
             const model = {};
             for (const key in this.subschema) {
                 const nestedSchema = this.subschema[key];
@@ -856,6 +859,30 @@
         }
     }
 
+    class TupleSchema extends BaseSchema {
+        subschema;
+        constructor(subschema, required, defaultValue, additionalValidationPasses) {
+            super(required, defaultValue, additionalValidationPasses);
+            this.subschema = subschema;
+        }
+        get type() { return "Tuple"; }
+        _validate(source, options, pass) {
+            return source;
+        }
+        convert(value, pass) {
+            return this.subschema.map((schema, i) => schema.validate(value[i]));
+        }
+        clone() {
+            return new TupleSchema(this.subschema, this._required, this._default, this._additionalValidationPasses);
+        }
+        getJsonSchema() {
+            return {
+                type: "Tuple",
+                description: this._getJsonSchemaDescription(),
+            };
+        }
+    }
+
     /**
      * A collection of helper functions used to create the standard set of schemas.
      */
@@ -901,6 +928,10 @@
             return new EnumerationSchema($members, required, defaultValue);
         }
         Schema.Enumeration = Enumeration;
+        function Tuple({ $members }, required = true, defaultValue = undefined) {
+            return new TupleSchema($members, required, defaultValue);
+        }
+        Schema.Tuple = Tuple;
         function OrSet({ $members }, required = true, defaultValue = undefined) {
             return new OrSetSchema($members, required, defaultValue);
         }
@@ -923,30 +954,6 @@
         Schema.Values = Values;
     })(exports.Schema || (exports.Schema = {}));
 
-    class TupleSchema extends BaseSchema {
-        subschema;
-        constructor(subschema, required, defaultValue, additionalValidationPasses) {
-            super(required, defaultValue, additionalValidationPasses);
-            this.subschema = subschema;
-        }
-        get type() { return "Tuple"; }
-        _validate(source, options, pass) {
-            return source;
-        }
-        convert(value, pass) {
-            return this.subschema.map((schema, i) => schema.validate(value[i]));
-        }
-        clone() {
-            return new TupleSchema(this.subschema, this._required, this._default, this._additionalValidationPasses);
-        }
-        getJsonSchema() {
-            return {
-                type: "Tuple",
-                description: this._getJsonSchemaDescription(),
-            };
-        }
-    }
-
     exports.$ = exports.Schema;
     exports.AnySchema = AnySchema;
     exports.ArraySchema = ArraySchema;

package/build/typing/toolbox.d.ts

@@ -9,7 +9,7 @@ export type SourceRequirement<Layout extends BaseSchemaAny> = (Layout extends Ba
 export type SourceValue<Source, Required extends boolean, Default extends DefaultValue<Source>> = (Required extends true ? (undefined extends Default ? (Source) : (Source | undefined)) : Source | undefined);
 export type ModelRequirement<Layout extends BaseSchemaAny> = (Layout extends BaseSchema<any, any, infer Required, infer Default> ? (Required extends true ? (true) : (Default extends undefined ? false : true)) : never);
 export type ModelValue<Source, Model, Required extends boolean, Default extends DefaultValue<Source>> = (Required extends true ? Model : Default extends undefined ? Model | undefined : Model);
-export type DefaultValue<Type> = undefined | Type | ((pass: ValidationPass) => Type);
+export type DefaultValue<Source> = undefined | Source | ((pass: ValidationPass) => Source);
 export type AdditionalValidatorBeforeType = ("beforeAll" | "beforeDefault" | "afterDefault");
 export type AdditionalValidatorAfterType = ("beforeConversion" | "afterConversion" | "afterAll");
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@lucania/schema",
-    "version": "3.1.2",
+    "version": "3.1.4",
     "description": "A schema module for compile-time and runtime type checking.",
     "main": "./build/index.js",
     "types": "./build/index.d.ts",