@sinclair/typebox 0.30.0-dev-3 → 0.30.0-dev-4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.30.0-dev-3",
+  "version": "0.30.0-dev-4",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

package/readme.md

@@ -1586,11 +1586,11 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '128.2 kb' │ ' 58.2 kb' │  '2.20 x'   │
-│ typebox/errors       │ '110.4 kb' │ ' 49.5 kb' │  '2.23 x'   │
-│ typebox/system       │ ' 75.2 kb' │ ' 31.1 kb' │  '2.42 x'   │
-│ typebox/value        │ '179.6 kb' │ ' 78.7 kb' │  '2.28 x'   │
-│ typebox              │ ' 74.1 kb' │ ' 30.6 kb' │  '2.42 x'   │
+│ typebox/compiler     │ '128.3 kb' │ ' 58.0 kb' │  '2.21 x'   │
+│ typebox/errors       │ '110.5 kb' │ ' 49.5 kb' │  '2.23 x'   │
+│ typebox/system       │ ' 75.4 kb' │ ' 31.2 kb' │  '2.42 x'   │
+│ typebox/value        │ '179.7 kb' │ ' 78.7 kb' │  '2.28 x'   │
+│ typebox              │ ' 74.3 kb' │ ' 30.7 kb' │  '2.42 x'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```
 

package/typebox.d.ts

@@ -601,7 +601,7 @@ export declare namespace TypeExtends {
 /** Specialized Clone for Types */
 export declare namespace TypeClone {
     /** Clones a type. */
-    function Clone<T extends TSchema>(schema: T, options: SchemaOptions): T;
+    function Clone<T extends TSchema>(schema: T, options?: SchemaOptions): T;
 }
 export declare namespace IndexedAccessor {
     function Resolve(schema: TSchema, keys: Key[], options?: SchemaOptions): TSchema;

package/typebox.js

@@ -1369,7 +1369,7 @@ var TypeClone;
         return value;
     }
     /** Clones a type. */
-    function Clone(schema, options) {
+    function Clone(schema, options = {}) {
         return { ...Visit(schema), ...options };
     }
     TypeClone.Clone = Clone;
@@ -1381,7 +1381,7 @@ var IndexedAccessor;
 (function (IndexedAccessor) {
     function OptionalUnwrap(schema) {
         return schema.map((schema) => {
-            const { [exports.Optional]: _, ...clone } = TypeClone.Clone(schema, {});
+            const { [exports.Optional]: _, ...clone } = TypeClone.Clone(schema);
             return clone;
         });
     }
@@ -1477,7 +1477,7 @@ var ObjectMap;
         return schema;
     }
     function Map(schema, callback, options) {
-        return { ...Visit(TypeClone.Clone(schema, {}), callback), ...options };
+        return { ...Visit(TypeClone.Clone(schema), callback), ...options };
     }
     ObjectMap.Map = Map;
 })(ObjectMap || (exports.ObjectMap = ObjectMap = {}));
@@ -1931,11 +1931,11 @@ class StandardTypeBuilder extends TypeBuilder {
     }
     /** `[Standard]` Creates a Readonly property */
     Readonly(schema) {
-        return { ...TypeClone.Clone(schema, {}), [exports.Readonly]: 'Readonly' };
+        return { ...TypeClone.Clone(schema), [exports.Readonly]: 'Readonly' };
     }
     /** `[Standard]` Creates an Optional property */
     Optional(schema) {
-        return { ...TypeClone.Clone(schema, {}), [exports.Optional]: 'Optional' };
+        return { ...TypeClone.Clone(schema), [exports.Optional]: 'Optional' };
     }
     // ------------------------------------------------------------------------
     // Types
@@ -1946,7 +1946,7 @@ class StandardTypeBuilder extends TypeBuilder {
     }
     /** `[Standard]` Creates an Array type */
     Array(items, options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'Array', type: 'array', items: TypeClone.Clone(items, {}) });
+        return this.Create({ ...options, [exports.Kind]: 'Array', type: 'array', items: TypeClone.Clone(items) });
     }
     /** `[Standard]` Creates a Boolean type */
     Boolean(options = {}) {
@@ -2012,12 +2012,12 @@ class StandardTypeBuilder extends TypeBuilder {
         }
         else if (TypeGuard.TTuple(schema) && TypeGuard.TNumber(unresolved)) {
             const items = ValueGuard.IsUndefined(schema.items) ? [] : schema.items;
-            const cloned = items.map((schema) => TypeClone.Clone(schema, {}));
+            const cloned = items.map((schema) => TypeClone.Clone(schema));
             return this.Union(cloned, options);
         }
         else {
             const keys = KeyArrayResolver.Resolve(unresolved);
-            const clone = TypeClone.Clone(schema, {});
+            const clone = TypeClone.Clone(schema);
             return IndexedAccessor.Resolve(clone, keys, options);
         }
     }
@@ -2031,8 +2031,8 @@ class StandardTypeBuilder extends TypeBuilder {
         if (allOf.length === 1)
             return TypeClone.Clone(allOf[0], options);
         const objects = allOf.every((schema) => TypeGuard.TObject(schema));
-        const cloned = allOf.map((schema) => TypeClone.Clone(schema, {}));
-        const clonedUnevaluatedProperties = TypeGuard.TSchema(options.unevaluatedProperties) ? { unevaluatedProperties: TypeClone.Clone(options.unevaluatedProperties, {}) } : {};
+        const cloned = allOf.map((schema) => TypeClone.Clone(schema));
+        const clonedUnevaluatedProperties = TypeGuard.TSchema(options.unevaluatedProperties) ? { unevaluatedProperties: TypeClone.Clone(options.unevaluatedProperties) } : {};
         if (options.unevaluatedProperties === false || TypeGuard.TSchema(options.unevaluatedProperties) || objects) {
             return this.Create({ ...options, ...clonedUnevaluatedProperties, [exports.Kind]: 'Intersect', type: 'object', allOf: cloned });
         }
@@ -2091,8 +2091,8 @@ class StandardTypeBuilder extends TypeBuilder {
         const propertyKeys = Object.getOwnPropertyNames(properties);
         const optionalKeys = propertyKeys.filter((key) => TypeGuard.TOptional(properties[key]));
         const requiredKeys = propertyKeys.filter((name) => !optionalKeys.includes(name));
-        const clonedAdditionalProperties = TypeGuard.TSchema(options.additionalProperties) ? { additionalProperties: TypeClone.Clone(options.additionalProperties, {}) } : {};
-        const clonedProperties = propertyKeys.reduce((acc, key) => ({ ...acc, [key]: TypeClone.Clone(properties[key], {}) }), {});
+        const clonedAdditionalProperties = TypeGuard.TSchema(options.additionalProperties) ? { additionalProperties: TypeClone.Clone(options.additionalProperties) } : {};
+        const clonedProperties = propertyKeys.reduce((acc, key) => ({ ...acc, [key]: TypeClone.Clone(properties[key]) }), {});
         if (requiredKeys.length > 0) {
             return this.Create({ ...options, ...clonedAdditionalProperties, [exports.Kind]: 'Object', type: 'object', properties: clonedProperties, required: requiredKeys });
         }
@@ -2103,17 +2103,17 @@ class StandardTypeBuilder extends TypeBuilder {
     Omit(schema, unresolved, options = {}) {
         const keys = KeyArrayResolver.Resolve(unresolved);
         // prettier-ignore
-        return ObjectMap.Map(TypeClone.Clone(schema, {}), (schema) => {
-            if (schema.required) {
-                schema.required = schema.required.filter((key) => !keys.includes(key));
-                if (schema.required.length === 0)
-                    delete schema.required;
+        return ObjectMap.Map(TypeClone.Clone(schema), (object) => {
+            if (ValueGuard.IsArray(object.required)) {
+                object.required = object.required.filter((key) => !keys.includes(key));
+                if (object.required.length === 0)
+                    delete object.required;
             }
-            for (const key of Object.getOwnPropertyNames(schema.properties)) {
+            for (const key of Object.getOwnPropertyNames(object.properties)) {
                 if (keys.includes(key))
-                    delete schema.properties[key];
+                    delete object.properties[key];
             }
-            return this.Create(schema);
+            return this.Create(object);
         }, options);
     }
     /** `[Standard]` Creates a mapped type where all properties are Optional */
@@ -2129,17 +2129,17 @@ class StandardTypeBuilder extends TypeBuilder {
     Pick(schema, unresolved, options = {}) {
         const keys = KeyArrayResolver.Resolve(unresolved);
         // prettier-ignore
-        return ObjectMap.Map(TypeClone.Clone(schema, {}), (schema) => {
-            if (schema.required) {
-                schema.required = schema.required.filter((key) => keys.includes(key));
-                if (schema.required.length === 0)
-                    delete schema.required;
+        return ObjectMap.Map(TypeClone.Clone(schema), (object) => {
+            if (ValueGuard.IsArray(object.required)) {
+                object.required = object.required.filter((key) => keys.includes(key));
+                if (object.required.length === 0)
+                    delete object.required;
             }
-            for (const key of Object.getOwnPropertyNames(schema.properties)) {
+            for (const key of Object.getOwnPropertyNames(object.properties)) {
                 if (!keys.includes(key))
-                    delete schema.properties[key];
+                    delete object.properties[key];
             }
-            return this.Create(schema);
+            return this.Create(object);
         }, options);
     }
     /** `[Standard]` Creates a Record type */
@@ -2148,13 +2148,13 @@ class StandardTypeBuilder extends TypeBuilder {
             const expression = TemplateLiteralParser.ParseExact(key.pattern);
             // prettier-ignore
             return TemplateLiteralFinite.Check(expression)
-                ? (this.Object([...TemplateLiteralGenerator.Generate(expression)].reduce((acc, key) => ({ ...acc, [key]: TypeClone.Clone(schema, {}) }), {}), options))
-                : this.Create({ ...options, [exports.Kind]: 'Record', type: 'object', patternProperties: { [key.pattern]: TypeClone.Clone(schema, {}) } });
+                ? (this.Object([...TemplateLiteralGenerator.Generate(expression)].reduce((acc, key) => ({ ...acc, [key]: TypeClone.Clone(schema) }), {}), options))
+                : this.Create({ ...options, [exports.Kind]: 'Record', type: 'object', patternProperties: { [key.pattern]: TypeClone.Clone(schema) } });
         }
         else if (TypeGuard.TUnion(key)) {
             const union = UnionResolver.Resolve(key);
             if (TypeGuard.TUnionLiteral(union)) {
-                const properties = union.anyOf.reduce((acc, literal) => ({ ...acc, [literal.const]: TypeClone.Clone(schema, {}) }), {});
+                const properties = union.anyOf.reduce((acc, literal) => ({ ...acc, [literal.const]: TypeClone.Clone(schema) }), {});
                 return this.Object(properties, { ...options, [exports.Hint]: 'Record' });
             }
             else
@@ -2162,17 +2162,17 @@ class StandardTypeBuilder extends TypeBuilder {
         }
         else if (TypeGuard.TLiteral(key)) {
             if (ValueGuard.IsString(key.const) || ValueGuard.IsNumber(key.const)) {
-                return this.Object({ [key.const]: TypeClone.Clone(schema, {}) }, options);
+                return this.Object({ [key.const]: TypeClone.Clone(schema) }, options);
             }
             else
                 throw Error('StandardTypeBuilder: Record key of type literal is not of type string or number');
         }
         else if (TypeGuard.TInteger(key) || TypeGuard.TNumber(key)) {
-            return this.Create({ ...options, [exports.Kind]: 'Record', type: 'object', patternProperties: { [exports.PatternNumberExact]: TypeClone.Clone(schema, {}) } });
+            return this.Create({ ...options, [exports.Kind]: 'Record', type: 'object', patternProperties: { [exports.PatternNumberExact]: TypeClone.Clone(schema) } });
         }
         else if (TypeGuard.TString(key)) {
             const pattern = ValueGuard.IsUndefined(key.pattern) ? exports.PatternStringExact : key.pattern;
-            return this.Create({ ...options, [exports.Kind]: 'Record', type: 'object', patternProperties: { [pattern]: TypeClone.Clone(schema, {}) } });
+            return this.Create({ ...options, [exports.Kind]: 'Record', type: 'object', patternProperties: { [pattern]: TypeClone.Clone(schema) } });
         }
         else {
             throw Error(`StandardTypeBuilder: Record key is an invalid type`);
@@ -2209,10 +2209,10 @@ class StandardTypeBuilder extends TypeBuilder {
         if (TypeGuard.TTuple(schema)) {
             if (ValueGuard.IsUndefined(schema.items))
                 return [];
-            return schema.items.map((schema) => TypeClone.Clone(schema, {}));
+            return schema.items.map((schema) => TypeClone.Clone(schema));
         }
         else {
-            return [TypeClone.Clone(schema, {})];
+            return [TypeClone.Clone(schema)];
         }
     }
     /** `[Standard]` Creates a String type */
@@ -2230,7 +2230,7 @@ class StandardTypeBuilder extends TypeBuilder {
     /** `[Standard]` Creates a Tuple type */
     Tuple(items, options = {}) {
         const [additionalItems, minItems, maxItems] = [false, items.length, items.length];
-        const clonedItems = items.map((item) => TypeClone.Clone(item, {}));
+        const clonedItems = items.map((item) => TypeClone.Clone(item));
         // prettier-ignore
         const schema = (items.length > 0 ?
             { ...options, [exports.Kind]: 'Tuple', type: 'array', items: clonedItems, additionalItems, minItems, maxItems } :
@@ -2247,7 +2247,7 @@ class StandardTypeBuilder extends TypeBuilder {
                 return this.Never(options);
             if (anyOf.length === 1)
                 return this.Create(TypeClone.Clone(anyOf[0], options));
-            const clonedAnyOf = anyOf.map((schema) => TypeClone.Clone(schema, {}));
+            const clonedAnyOf = anyOf.map((schema) => TypeClone.Clone(schema));
             return this.Create({ ...options, [exports.Kind]: 'Union', anyOf: clonedAnyOf });
         }
     }
@@ -2267,7 +2267,7 @@ exports.StandardTypeBuilder = StandardTypeBuilder;
 class ExtendedTypeBuilder extends StandardTypeBuilder {
     /** `[Extended]` Creates a AsyncIterator type */
     AsyncIterator(items, options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'AsyncIterator', type: 'AsyncIterator', items: TypeClone.Clone(items, {}) });
+        return this.Create({ ...options, [exports.Kind]: 'AsyncIterator', type: 'AsyncIterator', items: TypeClone.Clone(items) });
     }
     /** `[Extended]` Creates a BigInt type */
     BigInt(options = {}) {
@@ -2279,8 +2279,8 @@ class ExtendedTypeBuilder extends StandardTypeBuilder {
     }
     /** `[Extended]` Creates a Constructor type */
     Constructor(parameters, returns, options) {
-        const clonedReturns = TypeClone.Clone(returns, {});
-        const clonedParameters = parameters.map((parameter) => TypeClone.Clone(parameter, {}));
+        const clonedReturns = TypeClone.Clone(returns);
+        const clonedParameters = parameters.map((parameter) => TypeClone.Clone(parameter));
         return this.Create({ ...options, [exports.Kind]: 'Constructor', type: 'constructor', parameters: clonedParameters, returns: clonedReturns });
     }
     /** `[Extended]` Creates a Date type */
@@ -2290,7 +2290,7 @@ class ExtendedTypeBuilder extends StandardTypeBuilder {
     /** `[Extended]` Creates a Function type */
     Function(parameters, returns, options) {
         const clonedReturns = TypeClone.Clone(returns, {});
-        const clonedParameters = parameters.map((parameter) => TypeClone.Clone(parameter, {}));
+        const clonedParameters = parameters.map((parameter) => TypeClone.Clone(parameter));
         return this.Create({ ...options, [exports.Kind]: 'Function', type: 'function', parameters: clonedParameters, returns: clonedReturns });
     }
     /** `[Extended]` Extracts the InstanceType from the given Constructor */
@@ -2299,7 +2299,7 @@ class ExtendedTypeBuilder extends StandardTypeBuilder {
     }
     /** `[Extended]` Creates an Iterator type */
     Iterator(items, options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'Iterator', type: 'Iterator', items: TypeClone.Clone(items, {}) });
+        return this.Create({ ...options, [exports.Kind]: 'Iterator', type: 'Iterator', items: TypeClone.Clone(items) });
     }
     /** `[Extended]` Extracts the Parameters from the given Function type */
     Parameters(schema, options = {}) {
@@ -2307,7 +2307,7 @@ class ExtendedTypeBuilder extends StandardTypeBuilder {
     }
     /** `[Extended]` Creates a Promise type */
     Promise(item, options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'Promise', type: 'Promise', item: TypeClone.Clone(item, {}) });
+        return this.Create({ ...options, [exports.Kind]: 'Promise', type: 'Promise', item: TypeClone.Clone(item) });
     }
     /** `[Extended]` Creates a String pattern type from Regular Expression */
     RegExp(unresolved, options = {}) {