@sinclair/typebox 0.21.2 → 0.23.1

package/typebox.js

@@ -27,16 +27,16 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Type = exports.TypeBuilder = exports.VoidKind = exports.UndefinedKind = exports.PromiseKind = exports.FunctionKind = exports.ConstructorKind = exports.AnyKind = exports.UnknownKind = exports.NullKind = exports.BooleanKind = exports.IntegerKind = exports.NumberKind = exports.StringKind = exports.LiteralKind = exports.EnumKind = exports.ArrayKind = exports.RecordKind = exports.ObjectKind = exports.TupleKind = exports.UnionKind = exports.IntersectKind = exports.KeyOfKind = exports.BoxKind = exports.ReadonlyModifier = exports.OptionalModifier = exports.ReadonlyOptionalModifier = void 0;
-// ------------------------------------------------------------------------
+exports.Type = exports.TypeBuilder = exports.VoidKind = exports.UndefinedKind = exports.PromiseKind = exports.FunctionKind = exports.ConstructorKind = exports.RefKind = exports.AnyKind = exports.UnknownKind = exports.NullKind = exports.BooleanKind = exports.IntegerKind = exports.NumberKind = exports.StringKind = exports.LiteralKind = exports.EnumKind = exports.ArrayKind = exports.RecordKind = exports.ObjectKind = exports.TupleKind = exports.UnionKind = exports.IntersectKind = exports.KeyOfKind = exports.BoxKind = exports.ReadonlyModifier = exports.OptionalModifier = exports.ReadonlyOptionalModifier = void 0;
+// --------------------------------------------------------------------------
 // Modifiers
-// ------------------------------------------------------------------------
+// --------------------------------------------------------------------------
 exports.ReadonlyOptionalModifier = Symbol('ReadonlyOptionalModifier');
 exports.OptionalModifier = Symbol('OptionalModifier');
 exports.ReadonlyModifier = Symbol('ReadonlyModifier');
-// ------------------------------------------------------------------------
+// --------------------------------------------------------------------------
 // Schema Standard
-// ------------------------------------------------------------------------
+// --------------------------------------------------------------------------
 exports.BoxKind = Symbol('BoxKind');
 exports.KeyOfKind = Symbol('KeyOfKind');
 exports.IntersectKind = Symbol('IntersectKind');
@@ -54,17 +54,18 @@ exports.BooleanKind = Symbol('BooleanKind');
 exports.NullKind = Symbol('NullKind');
 exports.UnknownKind = Symbol('UnknownKind');
 exports.AnyKind = Symbol('AnyKind');
-// ------------------------------------------------------------------------
+exports.RefKind = Symbol('RefKind');
+// --------------------------------------------------------------------------
 // Extended Schema Types
-// ------------------------------------------------------------------------
+// --------------------------------------------------------------------------
 exports.ConstructorKind = Symbol('ConstructorKind');
 exports.FunctionKind = Symbol('FunctionKind');
 exports.PromiseKind = Symbol('PromiseKind');
 exports.UndefinedKind = Symbol('UndefinedKind');
 exports.VoidKind = Symbol('VoidKind');
-// ------------------------------------------------------------------------
+// --------------------------------------------------------------------------
 // Utility
-// ------------------------------------------------------------------------
+// --------------------------------------------------------------------------
 function isObject(object) {
     return typeof object === 'object' && object !== null && !Array.isArray(object);
 }
@@ -78,32 +79,34 @@ function clone(object) {
         return object.map((item) => clone(item));
     return object;
 }
-// ------------------------------------------------------------------------
+// --------------------------------------------------------------------------
 // TypeBuilder
-// ------------------------------------------------------------------------
+// --------------------------------------------------------------------------
 class TypeBuilder {
-    /** `standard` Modifies an object property to be both readonly and optional */
+    schemas = new Map();
+    /** `Standard` Modifies an object property to be both readonly and optional */
     ReadonlyOptional(item) {
         return { ...item, modifier: exports.ReadonlyOptionalModifier };
     }
-    /** `standard` Modifies an object property to be readonly */
+    /** `Standard` Modifies an object property to be readonly */
     Readonly(item) {
         return { ...item, modifier: exports.ReadonlyModifier };
     }
-    /** `standard` Modifies an object property to be optional */
+    /** `Standard` Modifies an object property to be optional */
     Optional(item) {
         return { ...item, modifier: exports.OptionalModifier };
     }
-    /** `standard` Creates a type type */
+    /** `Standard` Creates a type type */
     Tuple(items, options = {}) {
         const additionalItems = false;
         const minItems = items.length;
         const maxItems = items.length;
-        return (items.length > 0)
+        const schema = ((items.length > 0)
             ? { ...options, kind: exports.TupleKind, type: 'array', items, additionalItems, minItems, maxItems }
-            : { ...options, kind: exports.TupleKind, type: 'array', minItems, maxItems };
+            : { ...options, kind: exports.TupleKind, type: 'array', minItems, maxItems });
+        return this.Store(schema);
     }
-    /** `standard` Creates an object type with the given properties */
+    /** `Standard` Creates an object type with the given properties */
     Object(properties, options = {}) {
         const property_names = Object.keys(properties);
         const optional = property_names.filter(name => {
@@ -114,88 +117,90 @@ class TypeBuilder {
         });
         const required_names = property_names.filter(name => !optional.includes(name));
         const required = (required_names.length > 0) ? required_names : undefined;
-        return (required) ?
-            { ...options, kind: exports.ObjectKind, type: 'object', properties, required } :
-            { ...options, kind: exports.ObjectKind, type: 'object', properties };
+        return this.Store(((required)
+            ? { ...options, kind: exports.ObjectKind, type: 'object', properties, required }
+            : { ...options, kind: exports.ObjectKind, type: 'object', properties }));
     }
-    /** `standard` Creates an intersection type. Note this function requires draft `2019-09` to constrain with `unevaluatedProperties` */
+    /** `Standard` Creates an intersect type. */
     Intersect(items, options = {}) {
-        return { ...options, kind: exports.IntersectKind, type: 'object', allOf: items };
+        return this.Store({ ...options, kind: exports.IntersectKind, type: 'object', allOf: items });
     }
-    /** `standard` Creates a union type */
+    /** `Standard` Creates a union type */
     Union(items, options = {}) {
-        return { ...options, kind: exports.UnionKind, anyOf: items };
+        return this.Store({ ...options, kind: exports.UnionKind, anyOf: items });
     }
-    /** `standard` Creates an array type */
+    /** `Standard` Creates an array type */
     Array(items, options = {}) {
-        return { ...options, kind: exports.ArrayKind, type: 'array', items };
+        return this.Store({ ...options, kind: exports.ArrayKind, type: 'array', items });
     }
-    /** `standard` Creates an enum type from a TypeScript enum */
+    /** `Standard` Creates an enum type from a TypeScript enum */
     Enum(item, options = {}) {
         const values = Object.keys(item).filter(key => isNaN(key)).map(key => item[key]);
         const anyOf = values.map(value => typeof value === 'string' ? { type: 'string', const: value } : { type: 'number', const: value });
-        return { ...options, kind: exports.EnumKind, anyOf };
+        return this.Store({ ...options, kind: exports.EnumKind, anyOf });
     }
-    /** `standard` Creates a literal type. Supports string, number and boolean values only */
+    /** `Standard` Creates a literal type. Supports string, number and boolean values only */
     Literal(value, options = {}) {
-        return { ...options, kind: exports.LiteralKind, const: value, type: typeof value };
+        return this.Store({ ...options, kind: exports.LiteralKind, const: value, type: typeof value });
     }
-    /** `standard` Creates a string type */
+    /** `Standard` Creates a string type */
     String(options = {}) {
-        return { ...options, kind: exports.StringKind, type: 'string' };
+        return this.Store({ ...options, kind: exports.StringKind, type: 'string' });
     }
-    /** `standard` Creates a string type from a regular expression */
+    /** `Standard` Creates a string type from a regular expression */
     RegEx(regex, options = {}) {
         return this.String({ ...options, pattern: regex.source });
     }
-    /** `standard` Creates a number type */
+    /** `Standard` Creates a number type */
     Number(options = {}) {
-        return { ...options, kind: exports.NumberKind, type: 'number' };
+        return this.Store({ ...options, kind: exports.NumberKind, type: 'number' });
     }
-    /** `standard` Creates an integer type */
+    /** `Standard` Creates an integer type */
     Integer(options = {}) {
-        return { ...options, kind: exports.IntegerKind, type: 'integer' };
+        return this.Store({ ...options, kind: exports.IntegerKind, type: 'integer' });
     }
-    /** `standard` Creates a boolean type */
+    /** `Standard` Creates a boolean type */
     Boolean(options = {}) {
-        return { ...options, kind: exports.BooleanKind, type: 'boolean' };
+        return this.Store({ ...options, kind: exports.BooleanKind, type: 'boolean' });
     }
-    /** `standard` Creates a null type */
+    /** `Standard` Creates a null type */
     Null(options = {}) {
-        return { ...options, kind: exports.NullKind, type: 'null' };
+        return this.Store({ ...options, kind: exports.NullKind, type: 'null' });
     }
-    /** `standard` Creates an unknown type */
+    /** `Standard` Creates an unknown type */
     Unknown(options = {}) {
-        return { ...options, kind: exports.UnknownKind };
+        return this.Store({ ...options, kind: exports.UnknownKind });
     }
-    /** `standard` Creates an any type */
+    /** `Standard` Creates an any type */
     Any(options = {}) {
-        return { ...options, kind: exports.AnyKind };
+        return this.Store({ ...options, kind: exports.AnyKind });
     }
-    /** `standard` Creates a keyof type from the given object */
-    KeyOf(schema, options = {}) {
-        const keys = Object.keys(schema.properties);
-        return { ...options, kind: exports.KeyOfKind, type: 'string', enum: keys };
-    }
-    /** `standard` Creates a record type */
+    /** `Standard` Creates a record type */
     Record(key, value, options = {}) {
         const pattern = (() => {
             switch (key.kind) {
-                case exports.UnionKind: return `^${key.anyOf.map(literal => literal.const).join('|')}$`;
+                case exports.UnionKind: return `^${key.anyOf.map((literal) => literal.const).join('|')}$`;
                 case exports.KeyOfKind: return `^${key.enum.join('|')}$`;
                 case exports.NumberKind: return '^(0|[1-9][0-9]*)$';
                 case exports.StringKind: return key.pattern ? key.pattern : '^.*$';
                 default: throw Error('Invalid Record Key');
             }
         })();
-        return { ...options, kind: exports.RecordKind, type: 'object', patternProperties: { [pattern]: value } };
-    }
-    /** `standard` Makes all properties in the given object type required */
-    Required(schema, options = {}) {
-        const next = { ...clone(schema), ...options };
-        next.required = Object.keys(next.properties);
-        for (const key of Object.keys(next.properties)) {
-            const property = next.properties[key];
+        return this.Store({ ...options, kind: exports.RecordKind, type: 'object', patternProperties: { [pattern]: value } });
+    }
+    /** `Standard` Creates a keyof type from the given object */
+    KeyOf(object, options = {}) {
+        const source = this.Deref(object);
+        const keys = Object.keys(source.properties);
+        return this.Store({ ...options, kind: exports.KeyOfKind, type: 'string', enum: keys });
+    }
+    /** `Standard` Makes all properties in the given object type required */
+    Required(object, options = {}) {
+        const source = this.Deref(object);
+        const schema = { ...clone(source), ...options };
+        schema.required = Object.keys(schema.properties);
+        for (const key of Object.keys(schema.properties)) {
+            const property = schema.properties[key];
             switch (property.modifier) {
                 case exports.ReadonlyOptionalModifier:
                     property.modifier = exports.ReadonlyModifier;
@@ -211,14 +216,15 @@ class TypeBuilder {
                     break;
             }
         }
-        return next;
-    }
-    /** `standard` Makes all properties in the given object type optional */
-    Partial(schema, options = {}) {
-        const next = { ...clone(schema), ...options };
-        delete next.required;
-        for (const key of Object.keys(next.properties)) {
-            const property = next.properties[key];
+        return this.Store(schema);
+    }
+    /** `Standard` Makes all properties in the given object type optional */
+    Partial(object, options = {}) {
+        const source = this.Deref(object);
+        const schema = { ...clone(source), ...options };
+        delete schema.required;
+        for (const key of Object.keys(schema.properties)) {
+            const property = schema.properties[key];
             switch (property.modifier) {
                 case exports.ReadonlyOptionalModifier:
                     property.modifier = exports.ReadonlyOptionalModifier;
@@ -234,71 +240,100 @@ class TypeBuilder {
                     break;
             }
         }
-        return next;
-    }
-    /** `standard` Picks property keys from the given object type */
-    Pick(schema, keys, options = {}) {
-        const next = { ...clone(schema), ...options };
-        next.required = next.required ? next.required.filter((key) => keys.includes(key)) : undefined;
-        for (const key of Object.keys(next.properties)) {
+        return this.Store(schema);
+    }
+    /** `Standard` Picks property keys from the given object type */
+    Pick(object, keys, options = {}) {
+        const source = this.Deref(object);
+        const schema = { ...clone(source), ...options };
+        schema.required = schema.required ? schema.required.filter((key) => keys.includes(key)) : undefined;
+        for (const key of Object.keys(schema.properties)) {
             if (!keys.includes(key))
-                delete next.properties[key];
+                delete schema.properties[key];
         }
-        return next;
-    }
-    /** `standard` Omits property keys from the given object type */
-    Omit(schema, keys, options = {}) {
-        const next = { ...clone(schema), ...options };
-        next.required = next.required ? next.required.filter((key) => !keys.includes(key)) : undefined;
-        for (const key of Object.keys(next.properties)) {
+        return this.Store(schema);
+    }
+    /** `Standard` Omits property keys from the given object type */
+    Omit(object, keys, options = {}) {
+        const source = this.Deref(object);
+        const schema = { ...clone(source), ...options };
+        schema.required = schema.required ? schema.required.filter((key) => !keys.includes(key)) : undefined;
+        for (const key of Object.keys(schema.properties)) {
             if (keys.includes(key))
-                delete next.properties[key];
+                delete schema.properties[key];
         }
-        return next;
+        return this.Store(schema);
     }
-    /** `standard` Omits the `kind` and `modifier` properties from the underlying schema */
+    /** `Standard` Omits the `kind` and `modifier` properties from the underlying schema */
     Strict(schema, options = {}) {
         return JSON.parse(JSON.stringify({ ...options, ...schema }));
     }
-    /** `extended` Creates a constructor type */
+    /** `Extended` Creates a constructor type */
     Constructor(args, returns, options = {}) {
-        return { ...options, kind: exports.ConstructorKind, type: 'constructor', arguments: args, returns };
+        return this.Store({ ...options, kind: exports.ConstructorKind, type: 'constructor', arguments: args, returns });
     }
-    /** `extended` Creates a function type */
+    /** `Extended` Creates a function type */
     Function(args, returns, options = {}) {
-        return { ...options, kind: exports.FunctionKind, type: 'function', arguments: args, returns };
+        return this.Store({ ...options, kind: exports.FunctionKind, type: 'function', arguments: args, returns });
     }
-    /** `extended` Creates a promise type */
+    /** `Extended` Creates a promise type */
     Promise(item, options = {}) {
-        return { ...options, type: 'promise', kind: exports.PromiseKind, item };
+        return this.Store({ ...options, type: 'promise', kind: exports.PromiseKind, item });
     }
-    /** `extended` Creates a undefined type */
+    /** `Extended` Creates a undefined type */
     Undefined(options = {}) {
-        return { ...options, type: 'undefined', kind: exports.UndefinedKind };
+        return this.Store({ ...options, type: 'undefined', kind: exports.UndefinedKind });
     }
-    /** `extended` Creates a void type */
+    /** `Extended` Creates a void type */
     Void(options = {}) {
-        return { ...options, type: 'void', kind: exports.VoidKind };
+        return this.Store({ ...options, type: 'void', kind: exports.VoidKind });
     }
-    /** `experimental` Creates a recursive type */
-    Rec(callback, options = {}) {
-        const $id = options.$id || '';
-        const self = callback({ $ref: `${$id}#/definitions/self` });
-        return { ...options, $ref: `${$id}#/definitions/self`, definitions: { self } };
-    }
-    /** `experimental` Creates a recursive type. Pending https://github.com/ajv-validator/ajv/issues/1709 */
-    // public Rec<T extends TProperties>($id: string, callback: (self: TAny) => T, options: ObjectOptions = {}): TObject<T> {
-    //     const properties = callback({ $recursiveRef: `${$id}` } as any)
-    //     return { ...options, kind: ObjectKind, $id, $recursiveAnchor: true, type: 'object', properties }
-    // }
-    /** `experimental` Creates a namespace for a set of related types */
-    Namespace(definitions, options = {}) {
-        return { ...options, kind: exports.BoxKind, definitions };
+    /** `Standard` Creates a namespace for a set of related types */
+    Namespace($defs, options = {}) {
+        return this.Store({ ...options, kind: exports.BoxKind, $defs });
     }
     Ref(...args) {
-        const $id = args[0]['$id'] || '';
-        const key = args[1];
-        return (args.length === 2) ? { $ref: `${$id}#/definitions/${key}` } : { $ref: $id };
+        if (args.length === 2) {
+            const namespace = args[0];
+            const targetKey = args[1];
+            if (namespace.$id === undefined)
+                throw new Error(`Referenced namespace has no $id`);
+            if (!this.schemas.has(namespace.$id))
+                throw new Error(`Unable to locate namespace with $id '${namespace.$id}'`);
+            return this.Store({ kind: exports.RefKind, $ref: `${namespace.$id}#/$defs/${targetKey}` });
+        }
+        else if (args.length === 1) {
+            const target = args[0];
+            if (target.$id === undefined)
+                throw new Error(`Referenced schema has no $id`);
+            if (!this.schemas.has(target.$id))
+                throw new Error(`Unable to locate schema with $id '${target.$id}'`);
+            return this.Store({ kind: exports.RefKind, $ref: target.$id });
+        }
+        else {
+            throw new Error('Type.Ref: Invalid arguments');
+        }
+    }
+    /** `Experimental` Creates a recursive type */
+    Rec(callback, options = {}) {
+        const $id = options.$id || '';
+        const self = callback({ $ref: `${$id}#/$defs/self` });
+        return this.Store({ ...options, $ref: `${$id}#/$defs/self`, $defs: { self } });
+    }
+    /** Conditionally stores and schema if it contains an $id and returns.  */
+    Store(schema) {
+        if (!schema.$id)
+            return schema;
+        this.schemas.set(schema.$id, schema);
+        return schema;
+    }
+    /** Conditionally dereferences a schema if RefKind. Otherwise return argument. */
+    Deref(schema) {
+        if (schema.kind !== exports.RefKind)
+            return schema;
+        if (!this.schemas.has(schema.$ref))
+            throw Error(`Unable to locate schema with $id '${schema.$ref}'`);
+        return this.Deref(this.schemas.get(schema.$ref));
     }
 }
 exports.TypeBuilder = TypeBuilder;