@sinclair/typebox 0.32.34 → 0.33.0

package/build/cjs/type/pick/pick.js

@@ -2,13 +2,13 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Pick = Pick;
+const type_1 = require("../create/type");
 const index_1 = require("../intersect/index");
 const index_2 = require("../union/index");
 const index_3 = require("../object/index");
 const index_4 = require("../indexed/index");
 const index_5 = require("../discard/index");
 const index_6 = require("../symbols/index");
-const type_1 = require("../clone/type");
 const pick_from_mapped_key_1 = require("./pick-from-mapped-key");
 const pick_from_mapped_result_1 = require("./pick-from-mapped-result");
 // ------------------------------------------------------------------
@@ -40,7 +40,7 @@ function PickResolve(T, K) {
             (0, kind_1.IsObject)(T) ? (0, index_3.Object)(FromProperties(T.properties, K)) :
                 (0, index_3.Object)({}));
 }
-function Pick(T, K, options = {}) {
+function Pick(T, K, options) {
     // mapped
     if ((0, kind_1.IsMappedKey)(K))
         return (0, pick_from_mapped_key_1.PickFromMappedKey)(T, K, options);
@@ -49,6 +49,6 @@ function Pick(T, K, options = {}) {
     // non-mapped
     const I = (0, kind_1.IsSchema)(K) ? (0, index_4.IndexPropertyKeys)(K) : K;
     const D = (0, index_5.Discard)(T, [index_6.TransformKind, '$id', 'required']);
-    const R = (0, type_1.CloneType)(PickResolve(T, I), options);
-    return { ...D, ...R };
+    const R = PickResolve(T, I);
+    return (0, type_1.CreateType)({ ...D, ...R }, options);
 }

package/build/cjs/type/promise/promise.js

@@ -2,14 +2,9 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Promise = Promise;
-const type_1 = require("../clone/type");
+const type_1 = require("../create/type");
 const index_1 = require("../symbols/index");
 /** `[JavaScript]` Creates a Promise type */
-function Promise(item, options = {}) {
-    return {
-        ...options,
-        [index_1.Kind]: 'Promise',
-        type: 'Promise',
-        item: (0, type_1.CloneType)(item),
-    };
+function Promise(item, options) {
+    return (0, type_1.CreateType)({ [index_1.Kind]: 'Promise', type: 'Promise', item }, options);
 }

package/build/cjs/type/readonly/readonly.js

@@ -2,16 +2,16 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Readonly = Readonly;
+const type_1 = require("../create/type");
 const index_1 = require("../symbols/index");
-const type_1 = require("../clone/type");
 const index_2 = require("../discard/index");
 const readonly_from_mapped_result_1 = require("./readonly-from-mapped-result");
 const kind_1 = require("../guard/kind");
 function RemoveReadonly(schema) {
-    return (0, index_2.Discard)((0, type_1.CloneType)(schema), [index_1.ReadonlyKind]);
+    return (0, type_1.CreateType)((0, index_2.Discard)(schema, [index_1.ReadonlyKind]));
 }
 function AddReadonly(schema) {
-    return { ...(0, type_1.CloneType)(schema), [index_1.ReadonlyKind]: 'Readonly' };
+    return (0, type_1.CreateType)({ ...schema, [index_1.ReadonlyKind]: 'Readonly' });
 }
 // prettier-ignore
 function ReadonlyWithFlag(schema, F) {

package/build/cjs/type/record/record.d.ts

@@ -1,6 +1,7 @@
 import type { TSchema } from '../schema/index';
 import type { Static } from '../static/index';
 import type { Evaluate, Ensure, Assert } from '../helpers/index';
+import { type TAny } from '../any/index';
 import { type TObject, type TProperties, type TAdditionalProperties, type ObjectOptions } from '../object/index';
 import { type TLiteral, type TLiteralValue } from '../literal/index';
 import { type TNever } from '../never/index';
@@ -33,6 +34,8 @@ type TFromLiteralKey<K extends TLiteralValue, T extends TSchema> = (Ensure<TObje
 }>>);
 type TFromRegExpKey<_ extends TRegExp, T extends TSchema> = (Ensure<TRecord<TRegExp, T>>);
 type TFromStringKey<_ extends TString, T extends TSchema> = (Ensure<TRecord<TString, T>>);
+type TFromAnyKey<_ extends TAny, T extends TSchema> = (Ensure<TRecord<TAny, T>>);
+type TFromNeverKey<_ extends TNever, T extends TSchema> = (Ensure<TRecord<TNever, T>>);
 type TFromIntegerKey<_ extends TSchema, T extends TSchema> = (Ensure<TRecord<TNumber, T>>);
 type TFromNumberKey<_ extends TSchema, T extends TSchema> = (Ensure<TRecord<TNumber, T>>);
 type RecordStatic<K extends TSchema, T extends TSchema, P extends unknown[]> = (Evaluate<{
@@ -47,7 +50,7 @@ export interface TRecord<K extends TSchema = TSchema, T extends TSchema = TSchem
     };
     additionalProperties: TAdditionalProperties;
 }
-export type TRecordOrObject<K extends TSchema, T extends TSchema> = K extends TTemplateLiteral ? TFromTemplateLiteralKey<K, T> : K extends TEnum<infer S> ? TFromEnumKey<S, T> : K extends TUnion<infer S> ? TFromUnionKey<S, T> : K extends TLiteral<infer S> ? TFromLiteralKey<S, T> : K extends TInteger ? TFromIntegerKey<K, T> : K extends TNumber ? TFromNumberKey<K, T> : K extends TRegExp ? TFromRegExpKey<K, T> : K extends TString ? TFromStringKey<K, T> : TNever;
+export type TRecordOrObject<K extends TSchema, T extends TSchema> = K extends TTemplateLiteral ? TFromTemplateLiteralKey<K, T> : K extends TEnum<infer S> ? TFromEnumKey<S, T> : K extends TUnion<infer S> ? TFromUnionKey<S, T> : K extends TLiteral<infer S> ? TFromLiteralKey<S, T> : K extends TInteger ? TFromIntegerKey<K, T> : K extends TNumber ? TFromNumberKey<K, T> : K extends TRegExp ? TFromRegExpKey<K, T> : K extends TString ? TFromStringKey<K, T> : K extends TAny ? TFromAnyKey<K, T> : K extends TNever ? TFromNeverKey<K, T> : TNever;
 /** `[Json]` Creates a Record type */
 export declare function Record<K extends TSchema, T extends TSchema>(K: K, T: T, options?: ObjectOptions): TRecordOrObject<K, T>;
 export {};

package/build/cjs/type/record/record.js

@@ -2,6 +2,7 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Record = Record;
+const type_1 = require("../create/type");
 const index_1 = require("../object/index");
 const index_2 = require("../never/index");
 const index_3 = require("../union/index");
@@ -9,7 +10,6 @@ const index_4 = require("../template-literal/index");
 const index_5 = require("../patterns/index");
 const index_6 = require("../indexed/index");
 const index_7 = require("../symbols/index");
-const type_1 = require("../clone/type");
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
@@ -23,12 +23,11 @@ const kind_1 = require("../guard/kind");
 // ------------------------------------------------------------------
 // prettier-ignore
 function RecordCreateFromPattern(pattern, T, options) {
-    return {
-        ...options,
+    return (0, type_1.CreateType)({
         [index_7.Kind]: 'Record',
         type: 'object',
-        patternProperties: { [pattern]: (0, type_1.CloneType)(T) }
-    };
+        patternProperties: { [pattern]: T }
+    }, options);
 }
 // ------------------------------------------------------------------
 // RecordCreateFromKeys
@@ -37,7 +36,7 @@ function RecordCreateFromPattern(pattern, T, options) {
 function RecordCreateFromKeys(K, T, options) {
     const Acc = {};
     for (const K2 of K)
-        Acc[K2] = (0, type_1.CloneType)(T);
+        Acc[K2] = T;
     return (0, index_1.Object)(Acc, { ...options, [index_7.Hint]: 'Record' });
 }
 // prettier-ignore
@@ -64,6 +63,14 @@ function FromStringKey(K, T, options) {
     return RecordCreateFromPattern(pattern, T, options);
 }
 // prettier-ignore
+function FromAnyKey(K, T, options) {
+    return RecordCreateFromPattern(index_5.PatternStringExact, T, options);
+}
+// prettier-ignore
+function FromNeverKey(K, T, options) {
+    return RecordCreateFromPattern(index_5.PatternNeverExact, T, options);
+}
+// prettier-ignore
 function FromIntegerKey(_, T, options) {
     return RecordCreateFromPattern(index_5.PatternNumberExact, T, options);
 }
@@ -84,5 +91,7 @@ function Record(K, T, options = {}) {
                     (0, kind_1.IsNumber)(K) ? FromNumberKey(K, T, options) :
                         (0, kind_1.IsRegExp)(K) ? FromRegExpKey(K, T, options) :
                             (0, kind_1.IsString)(K) ? FromStringKey(K, T, options) :
-                                (0, index_2.Never)(options));
+                                (0, kind_1.IsAny)(K) ? FromAnyKey(K, T, options) :
+                                    (0, kind_1.IsNever)(K) ? FromNeverKey(K, T, options) :
+                                        (0, index_2.Never)(options));
 }

package/build/cjs/type/recursive/recursive.js

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Recursive = Recursive;
 const type_1 = require("../clone/type");
+const type_2 = require("../create/type");
 const value_1 = require("../guard/value");
 const index_1 = require("../symbols/index");
 // Auto Tracked For Recursive Types without ID's
@@ -11,8 +12,8 @@ let Ordinal = 0;
 function Recursive(callback, options = {}) {
     if ((0, value_1.IsUndefined)(options.$id))
         options.$id = `T${Ordinal++}`;
-    const thisType = callback({ [index_1.Kind]: 'This', $ref: `${options.$id}` });
+    const thisType = (0, type_1.CloneType)(callback({ [index_1.Kind]: 'This', $ref: `${options.$id}` }));
     thisType.$id = options.$id;
     // prettier-ignore
-    return (0, type_1.CloneType)({ ...options, [index_1.Hint]: 'Recursive', ...thisType });
+    return (0, type_2.CreateType)({ [index_1.Hint]: 'Recursive', ...thisType }, options);
 }

package/build/cjs/type/ref/ref.js

@@ -2,20 +2,17 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Ref = Ref;
+const type_1 = require("../create/type");
 const index_1 = require("../symbols/index");
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
 const value_1 = require("../guard/value");
 /** `[Json]` Creates a Ref type. */
-function Ref(unresolved, options = {}) {
+function Ref(unresolved, options) {
     if ((0, value_1.IsString)(unresolved))
-        return { ...options, [index_1.Kind]: 'Ref', $ref: unresolved };
+        return (0, type_1.CreateType)({ [index_1.Kind]: 'Ref', $ref: unresolved }, options);
     if ((0, value_1.IsUndefined)(unresolved.$id))
         throw new Error('Reference target type must specify an $id');
-    return {
-        ...options,
-        [index_1.Kind]: 'Ref',
-        $ref: unresolved.$id,
-    };
+    return (0, type_1.CreateType)({ [index_1.Kind]: 'Ref', $ref: unresolved.$id }, options);
 }

package/build/cjs/type/regexp/regexp.js

@@ -2,10 +2,11 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RegExp = RegExp;
+const type_1 = require("../create/type");
 const value_1 = require("../guard/value");
 const index_1 = require("../symbols/index");
 /** `[JavaScript]` Creates a RegExp type */
-function RegExp(unresolved, options = {}) {
+function RegExp(unresolved, options) {
     const expr = (0, value_1.IsString)(unresolved) ? new globalThis.RegExp(unresolved) : unresolved;
-    return { ...options, [index_1.Kind]: 'RegExp', type: 'RegExp', source: expr.source, flags: expr.flags };
+    return (0, type_1.CreateType)({ [index_1.Kind]: 'RegExp', type: 'RegExp', source: expr.source, flags: expr.flags }, options);
 }

package/build/cjs/type/required/required-from-mapped-result.d.ts

@@ -8,5 +8,5 @@ type TFromProperties<P extends TProperties> = ({
 });
 type TFromMappedResult<R extends TMappedResult> = (Evaluate<TFromProperties<R['properties']>>);
 export type TRequiredFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>> = (Ensure<TMappedResult<P>>);
-export declare function RequiredFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>>(R: R, options: SchemaOptions): TMappedResult<P>;
+export declare function RequiredFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>>(R: R, options?: SchemaOptions): TMappedResult<P>;
 export {};

package/build/cjs/type/required/required.js

@@ -2,11 +2,11 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Required = Required;
+const type_1 = require("../create/type");
 const index_1 = require("../intersect/index");
 const index_2 = require("../union/index");
 const index_3 = require("../object/index");
 const index_4 = require("../symbols/index");
-const type_1 = require("../clone/type");
 const index_5 = require("../discard/index");
 const required_from_mapped_result_1 = require("./required-from-mapped-result");
 // ------------------------------------------------------------------
@@ -35,13 +35,13 @@ function RequiredResolve(T) {
                 (0, index_3.Object)({}));
 }
 /** `[Json]` Constructs a type where all properties are required */
-function Required(T, options = {}) {
+function Required(T, options) {
     if ((0, kind_1.IsMappedResult)(T)) {
         return (0, required_from_mapped_result_1.RequiredFromMappedResult)(T, options);
     }
     else {
         const D = (0, index_5.Discard)(T, [index_4.TransformKind, '$id', 'required']);
-        const R = (0, type_1.CloneType)(RequiredResolve(T), options);
-        return { ...D, ...R };
+        const R = RequiredResolve(T);
+        return (0, type_1.CreateType)({ ...D, ...R }, options);
     }
 }

package/build/cjs/type/rest/rest.d.ts

@@ -2,7 +2,7 @@ import type { TSchema } from '../schema/index';
 import type { TIntersect } from '../intersect/index';
 import type { TUnion } from '../union/index';
 import type { TTuple } from '../tuple/index';
-type TRestResolve<T extends TSchema> = T extends TIntersect<infer S> ? [...S] : T extends TUnion<infer S> ? [...S] : T extends TTuple<infer S> ? [...S] : [
+type TRestResolve<T extends TSchema> = T extends TIntersect<infer S extends TSchema[]> ? S : T extends TUnion<infer S extends TSchema[]> ? S : T extends TTuple<infer S extends TSchema[]> ? S : [
 ];
 export type TRest<T extends TSchema> = TRestResolve<T>;
 /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */

package/build/cjs/type/rest/rest.js

@@ -2,19 +2,18 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Rest = Rest;
-const type_1 = require("../clone/type");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
 const kind_1 = require("../guard/kind");
 // prettier-ignore
 function RestResolve(T) {
-    return ((0, kind_1.IsIntersect)(T) ? (0, type_1.CloneRest)(T.allOf) :
-        (0, kind_1.IsUnion)(T) ? (0, type_1.CloneRest)(T.anyOf) :
-            (0, kind_1.IsTuple)(T) ? (0, type_1.CloneRest)(T.items ?? []) :
+    return ((0, kind_1.IsIntersect)(T) ? T.allOf :
+        (0, kind_1.IsUnion)(T) ? T.anyOf :
+            (0, kind_1.IsTuple)(T) ? T.items ?? [] :
                 []);
 }
 /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
 function Rest(T) {
-    return (0, type_1.CloneRest)(RestResolve(T));
+    return RestResolve(T);
 }

package/build/cjs/type/return-type/return-type.js

@@ -2,8 +2,8 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReturnType = ReturnType;
-const type_1 = require("../clone/type");
+const type_1 = require("../create/type");
 /** `[JavaScript]` Extracts the ReturnType from the given Function type */
-function ReturnType(schema, options = {}) {
-    return (0, type_1.CloneType)(schema.returns, options);
+function ReturnType(schema, options) {
+    return (0, type_1.CreateType)(schema.returns, options);
 }

package/build/cjs/type/string/string.js

@@ -2,8 +2,9 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.String = String;
+const type_1 = require("../create/type");
 const index_1 = require("../symbols/index");
 /** `[Json]` Creates a String type */
-function String(options = {}) {
-    return { ...options, [index_1.Kind]: 'String', type: 'string' };
+function String(options) {
+    return (0, type_1.CreateType)({ [index_1.Kind]: 'String', type: 'string' }, options);
 }

package/build/cjs/type/symbol/symbol.js

@@ -2,8 +2,9 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Symbol = Symbol;
+const type_1 = require("../create/type");
 const index_1 = require("../symbols/index");
 /** `[JavaScript]` Creates a Symbol type */
 function Symbol(options) {
-    return { ...options, [index_1.Kind]: 'Symbol', type: 'symbol' };
+    return (0, type_1.CreateType)({ [index_1.Kind]: 'Symbol', type: 'symbol' }, options);
 }

package/build/cjs/type/template-literal/template-literal.js

@@ -2,15 +2,16 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TemplateLiteral = TemplateLiteral;
+const type_1 = require("../create/type");
 const syntax_1 = require("./syntax");
 const pattern_1 = require("./pattern");
 const value_1 = require("../guard/value");
 const index_1 = require("../symbols/index");
 /** `[Json]` Creates a TemplateLiteral type */
 // prettier-ignore
-function TemplateLiteral(unresolved, options = {}) {
+function TemplateLiteral(unresolved, options) {
     const pattern = (0, value_1.IsString)(unresolved)
         ? (0, pattern_1.TemplateLiteralPattern)((0, syntax_1.TemplateLiteralSyntax)(unresolved))
         : (0, pattern_1.TemplateLiteralPattern)(unresolved);
-    return { ...options, [index_1.Kind]: 'TemplateLiteral', type: 'string', pattern };
+    return (0, type_1.CreateType)({ [index_1.Kind]: 'TemplateLiteral', type: 'string', pattern }, options);
 }

package/build/cjs/type/transform/transform.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransformEncodeBuilder = exports.TransformDecodeBuilder = void 0;
 exports.Transform = Transform;
 const index_1 = require("../symbols/index");
-const type_1 = require("../clone/type");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -38,8 +37,7 @@ class TransformEncodeBuilder {
         return { ...schema, [index_1.TransformKind]: Codec };
     }
     Encode(encode) {
-        const schema = (0, type_1.CloneType)(this.schema);
-        return ((0, kind_1.IsTransform)(schema) ? this.EncodeTransform(encode, schema) : this.EncodeSchema(encode, schema));
+        return ((0, kind_1.IsTransform)(this.schema) ? this.EncodeTransform(encode, this.schema) : this.EncodeSchema(encode, this.schema));
     }
 }
 exports.TransformEncodeBuilder = TransformEncodeBuilder;

package/build/cjs/type/tuple/tuple.js

@@ -2,14 +2,12 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Tuple = Tuple;
-const type_1 = require("../clone/type");
+const type_1 = require("../create/type");
 const index_1 = require("../symbols/index");
 /** `[Json]` Creates a Tuple type */
-function Tuple(items, options = {}) {
-    // return TupleResolver.Resolve(T)
-    const [additionalItems, minItems, maxItems] = [false, items.length, items.length];
+function Tuple(items, options) {
     // prettier-ignore
-    return (items.length > 0 ?
-        { ...options, [index_1.Kind]: 'Tuple', type: 'array', items: (0, type_1.CloneRest)(items), additionalItems, minItems, maxItems } :
-        { ...options, [index_1.Kind]: 'Tuple', type: 'array', minItems, maxItems });
+    return (0, type_1.CreateType)(items.length > 0 ?
+        { [index_1.Kind]: 'Tuple', type: 'array', items, additionalItems: false, minItems: items.length, maxItems: items.length } :
+        { [index_1.Kind]: 'Tuple', type: 'array', minItems: items.length, maxItems: items.length }, options);
 }

package/build/cjs/type/type/javascript.js

@@ -23,19 +23,19 @@ const index_17 = require("../void/index");
 /** JavaScript Type Builder with Static Resolution for TypeScript */
 class JavaScriptTypeBuilder extends json_1.JsonTypeBuilder {
     /** `[JavaScript]` Creates a AsyncIterator type */
-    AsyncIterator(items, options = {}) {
+    AsyncIterator(items, options) {
         return (0, index_1.AsyncIterator)(items, options);
     }
     /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
-    Awaited(schema, options = {}) {
+    Awaited(schema, options) {
         return (0, index_2.Awaited)(schema, options);
     }
     /** `[JavaScript]` Creates a BigInt type */
-    BigInt(options = {}) {
+    BigInt(options) {
         return (0, index_3.BigInt)(options);
     }
     /** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
-    ConstructorParameters(schema, options = {}) {
+    ConstructorParameters(schema, options) {
         return (0, index_5.ConstructorParameters)(schema, options);
     }
     /** `[JavaScript]` Creates a Constructor type */
@@ -51,27 +51,27 @@ class JavaScriptTypeBuilder extends json_1.JsonTypeBuilder {
         return (0, index_7.Function)(parameters, returns, options);
     }
     /** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
-    InstanceType(schema, options = {}) {
+    InstanceType(schema, options) {
         return (0, index_8.InstanceType)(schema, options);
     }
     /** `[JavaScript]` Creates an Iterator type */
-    Iterator(items, options = {}) {
+    Iterator(items, options) {
         return (0, index_9.Iterator)(items, options);
     }
     /** `[JavaScript]` Extracts the Parameters from the given Function type */
-    Parameters(schema, options = {}) {
+    Parameters(schema, options) {
         return (0, index_10.Parameters)(schema, options);
     }
     /** `[JavaScript]` Creates a Promise type */
-    Promise(item, options = {}) {
+    Promise(item, options) {
         return (0, index_11.Promise)(item, options);
     }
     /** `[JavaScript]` Creates a RegExp type */
-    RegExp(unresolved, options = {}) {
+    RegExp(unresolved, options) {
         return (0, index_12.RegExp)(unresolved, options);
     }
     /** `[JavaScript]` Extracts the ReturnType from the given Function type */
-    ReturnType(schema, options = {}) {
+    ReturnType(schema, options) {
         return (0, index_13.ReturnType)(schema, options);
     }
     /** `[JavaScript]` Creates a Symbol type */
@@ -79,15 +79,15 @@ class JavaScriptTypeBuilder extends json_1.JsonTypeBuilder {
         return (0, index_14.Symbol)(options);
     }
     /** `[JavaScript]` Creates a Undefined type */
-    Undefined(options = {}) {
+    Undefined(options) {
         return (0, index_16.Undefined)(options);
     }
     /** `[JavaScript]` Creates a Uint8Array type */
-    Uint8Array(options = {}) {
+    Uint8Array(options) {
         return (0, index_15.Uint8Array)(options);
     }
     /** `[JavaScript]` Creates a Void type */
-    Void(options = {}) {
+    Void(options) {
         return (0, index_17.Void)(options);
     }
 }