@sinclair/typebox 0.32.34 → 0.33.0

package/build/esm/type/type/javascript.mjs

@@ -19,19 +19,19 @@ import { Void } from '../void/index.mjs';
 /** JavaScript Type Builder with Static Resolution for TypeScript */
 export class JavaScriptTypeBuilder extends JsonTypeBuilder {
     /** `[JavaScript]` Creates a AsyncIterator type */
-    AsyncIterator(items, options = {}) {
+    AsyncIterator(items, options) {
         return AsyncIterator(items, options);
     }
     /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
-    Awaited(schema, options = {}) {
+    Awaited(schema, options) {
         return Awaited(schema, options);
     }
     /** `[JavaScript]` Creates a BigInt type */
-    BigInt(options = {}) {
+    BigInt(options) {
         return BigInt(options);
     }
     /** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
-    ConstructorParameters(schema, options = {}) {
+    ConstructorParameters(schema, options) {
         return ConstructorParameters(schema, options);
     }
     /** `[JavaScript]` Creates a Constructor type */
@@ -47,27 +47,27 @@ export class JavaScriptTypeBuilder extends JsonTypeBuilder {
         return FunctionType(parameters, returns, options);
     }
     /** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
-    InstanceType(schema, options = {}) {
+    InstanceType(schema, options) {
         return InstanceType(schema, options);
     }
     /** `[JavaScript]` Creates an Iterator type */
-    Iterator(items, options = {}) {
+    Iterator(items, options) {
         return Iterator(items, options);
     }
     /** `[JavaScript]` Extracts the Parameters from the given Function type */
-    Parameters(schema, options = {}) {
+    Parameters(schema, options) {
         return Parameters(schema, options);
     }
     /** `[JavaScript]` Creates a Promise type */
-    Promise(item, options = {}) {
+    Promise(item, options) {
         return Promise(item, options);
     }
     /** `[JavaScript]` Creates a RegExp type */
-    RegExp(unresolved, options = {}) {
+    RegExp(unresolved, options) {
         return RegExp(unresolved, options);
     }
     /** `[JavaScript]` Extracts the ReturnType from the given Function type */
-    ReturnType(schema, options = {}) {
+    ReturnType(schema, options) {
         return ReturnType(schema, options);
     }
     /** `[JavaScript]` Creates a Symbol type */
@@ -75,15 +75,15 @@ export class JavaScriptTypeBuilder extends JsonTypeBuilder {
         return Symbol(options);
     }
     /** `[JavaScript]` Creates a Undefined type */
-    Undefined(options = {}) {
+    Undefined(options) {
         return Undefined(options);
     }
     /** `[JavaScript]` Creates a Uint8Array type */
-    Uint8Array(options = {}) {
+    Uint8Array(options) {
         return Uint8Array(options);
     }
     /** `[JavaScript]` Creates a Void type */
-    Void(options = {}) {
+    Void(options) {
         return Void(options);
     }
 }

package/build/esm/type/type/json.mjs

@@ -67,19 +67,19 @@ export class JsonTypeBuilder {
     // Types
     // ------------------------------------------------------------------------
     /** `[Json]` Creates an Any type */
-    Any(options = {}) {
+    Any(options) {
         return Any(options);
     }
     /** `[Json]` Creates an Array type */
-    Array(schema, options = {}) {
+    Array(schema, options) {
         return Array(schema, options);
     }
     /** `[Json]` Creates a Boolean type */
-    Boolean(options = {}) {
+    Boolean(options) {
         return Boolean(options);
     }
     /** `[Json]` Intrinsic function to Capitalize LiteralString types */
-    Capitalize(schema, options = {}) {
+    Capitalize(schema, options) {
         return Capitalize(schema, options);
     }
     /** `[Json]` Creates a Composite object type */
@@ -87,7 +87,7 @@ export class JsonTypeBuilder {
         return Composite(schemas, options); // (error) TS 5.4.0-dev - review TComposite implementation
     }
     /** `[JavaScript]` Creates a readonly const type from the given value. */
-    Const(value, options = {}) {
+    Const(value, options) {
         return Const(value, options);
     }
     /** `[Json]` Creates a dereferenced type */
@@ -95,51 +95,51 @@ export class JsonTypeBuilder {
         return Deref(schema, references);
     }
     /** `[Json]` Creates a Enum type */
-    Enum(item, options = {}) {
+    Enum(item, options) {
         return Enum(item, options);
     }
     /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
-    Exclude(unionType, excludedMembers, options = {}) {
+    Exclude(unionType, excludedMembers, options) {
         return Exclude(unionType, excludedMembers, options);
     }
     /** `[Json]` Creates a Conditional type */
-    Extends(L, R, T, F, options = {}) {
+    Extends(L, R, T, F, options) {
         return Extends(L, R, T, F, options);
     }
     /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
-    Extract(type, union, options = {}) {
+    Extract(type, union, options) {
         return Extract(type, union, options);
     }
     /** `[Json]` Returns an Indexed property type for the given keys */
-    Index(schema, unresolved, options = {}) {
+    Index(schema, unresolved, options) {
         return Index(schema, unresolved, options);
     }
     /** `[Json]` Creates an Integer type */
-    Integer(options = {}) {
+    Integer(options) {
         return Integer(options);
     }
     /** `[Json]` Creates an Intersect type */
-    Intersect(T, options = {}) {
+    Intersect(T, options) {
         return Intersect(T, options);
     }
     /** `[Json]` Creates a KeyOf type */
-    KeyOf(schema, options = {}) {
+    KeyOf(schema, options) {
         return KeyOf(schema, options);
     }
     /** `[Json]` Creates a Literal type */
-    Literal(value, options = {}) {
+    Literal(value, options) {
         return Literal(value, options);
     }
     /** `[Json]` Intrinsic function to Lowercase LiteralString types */
-    Lowercase(schema, options = {}) {
+    Lowercase(schema, options) {
         return Lowercase(schema, options);
     }
     /** `[Json]` Creates a Mapped object type */
-    Mapped(key, map, options = {}) {
+    Mapped(key, map, options) {
         return Mapped(key, map, options);
     }
     /** `[Json]` Creates a Never type */
-    Never(options = {}) {
+    Never(options) {
         return Never(options);
     }
     /** `[Json]` Creates a Not type */
@@ -147,43 +147,43 @@ export class JsonTypeBuilder {
         return Not(schema, options);
     }
     /** `[Json]` Creates a Null type */
-    Null(options = {}) {
+    Null(options) {
         return Null(options);
     }
     /** `[Json]` Creates a Number type */
-    Number(options = {}) {
+    Number(options) {
         return Number(options);
     }
     /** `[Json]` Creates an Object type */
-    Object(properties, options = {}) {
+    Object(properties, options) {
         return Object(properties, options);
     }
     /** `[Json]` Constructs a type whose keys are omitted from the given type */
-    Omit(schema, unresolved, options = {}) {
+    Omit(schema, unresolved, options) {
         return Omit(schema, unresolved, options);
     }
     /** `[Json]` Constructs a type where all properties are optional */
-    Partial(schema, options = {}) {
+    Partial(schema, options) {
         return Partial(schema, options);
     }
     /** `[Json]` Constructs a type whose keys are picked from the given type */
-    Pick(schema, unresolved, options = {}) {
+    Pick(schema, unresolved, options) {
         return Pick(schema, unresolved, options);
     }
     /** `[Json]` Creates a Record type */
-    Record(key, schema, options = {}) {
+    Record(key, schema, options) {
         return Record(key, schema, options);
     }
     /** `[Json]` Creates a Recursive type */
-    Recursive(callback, options = {}) {
+    Recursive(callback, options) {
         return Recursive(callback, options);
     }
     /** `[Json]` Creates a Ref type. */
-    Ref(unresolved, options = {}) {
+    Ref(unresolved, options) {
         return Ref(unresolved, options);
     }
     /** `[Json]` Constructs a type where all properties are required */
-    Required(schema, options = {}) {
+    Required(schema, options) {
         return Required(schema, options);
     }
     /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
@@ -191,11 +191,11 @@ export class JsonTypeBuilder {
         return Rest(schema);
     }
     /** `[Json]` Creates a String type */
-    String(options = {}) {
+    String(options) {
         return String(options);
     }
     /** `[Json]` Creates a TemplateLiteral type */
-    TemplateLiteral(unresolved, options = {}) {
+    TemplateLiteral(unresolved, options) {
         return TemplateLiteral(unresolved, options);
     }
     /** `[Json]` Creates a Transform type */
@@ -203,27 +203,27 @@ export class JsonTypeBuilder {
         return Transform(schema);
     }
     /** `[Json]` Creates a Tuple type */
-    Tuple(items, options = {}) {
+    Tuple(items, options) {
         return Tuple(items, options);
     }
     /** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
-    Uncapitalize(schema, options = {}) {
+    Uncapitalize(schema, options) {
         return Uncapitalize(schema, options);
     }
     /** `[Json]` Creates a Union type */
-    Union(schemas, options = {}) {
+    Union(schemas, options) {
         return Union(schemas, options);
     }
     /** `[Json]` Creates an Unknown type */
-    Unknown(options = {}) {
+    Unknown(options) {
         return Unknown(options);
     }
     /** `[Json]` Creates a Unsafe type that will infers as the generic argument T */
-    Unsafe(options = {}) {
+    Unsafe(options) {
         return Unsafe(options);
     }
     /** `[Json]` Intrinsic function to Uppercase LiteralString types */
-    Uppercase(schema, options = {}) {
+    Uppercase(schema, options) {
         return Uppercase(schema, options);
     }
 }

package/build/esm/type/uint8array/uint8array.mjs

@@ -1,5 +1,6 @@
+import { CreateType } from '../create/type.mjs';
 import { Kind } from '../symbols/index.mjs';
 /** `[JavaScript]` Creates a Uint8Array type */
-export function Uint8Array(options = {}) {
-    return { ...options, [Kind]: 'Uint8Array', type: 'Uint8Array' };
+export function Uint8Array(options) {
+    return CreateType({ [Kind]: 'Uint8Array', type: 'Uint8Array' }, options);
 }

package/build/esm/type/undefined/undefined.mjs

@@ -1,5 +1,6 @@
+import { CreateType } from '../create/type.mjs';
 import { Kind } from '../symbols/index.mjs';
 /** `[JavaScript]` Creates a Undefined type */
-export function Undefined(options = {}) {
-    return { ...options, [Kind]: 'Undefined', type: 'undefined' };
+export function Undefined(options) {
+    return CreateType({ [Kind]: 'Undefined', type: 'undefined' }, options);
 }

package/build/esm/type/union/union-create.d.mts

@@ -1,3 +1,3 @@
 import type { TSchema, SchemaOptions } from '../schema/index.mjs';
 import { TUnion } from './union-type.mjs';
-export declare function UnionCreate<T extends TSchema[]>(T: [...T], options: SchemaOptions): TUnion<T>;
+export declare function UnionCreate<T extends TSchema[]>(T: [...T], options?: SchemaOptions): TUnion<T>;

package/build/esm/type/union/union-create.mjs

@@ -1,5 +1,5 @@
-import { CloneRest } from '../clone/type.mjs';
+import { CreateType } from '../create/type.mjs';
 import { Kind } from '../symbols/index.mjs';
 export function UnionCreate(T, options) {
-    return { ...options, [Kind]: 'Union', anyOf: CloneRest(T) };
+    return CreateType({ [Kind]: 'Union', anyOf: T }, options);
 }

package/build/esm/type/union/union-evaluated.mjs

@@ -1,5 +1,5 @@
+import { CreateType } from '../create/type.mjs';
 import { OptionalKind } from '../symbols/index.mjs';
-import { CloneType } from '../clone/type.mjs';
 import { Discard } from '../discard/index.mjs';
 import { Never } from '../never/index.mjs';
 import { Optional } from '../optional/index.mjs';
@@ -27,9 +27,9 @@ function ResolveUnion(T, options) {
         : UnionCreate(RemoveOptionalFromRest(T), options));
 }
 /** `[Json]` Creates an evaluated Union type */
-export function UnionEvaluated(T, options = {}) {
+export function UnionEvaluated(T, options) {
     // prettier-ignore
     return (T.length === 0 ? Never(options) :
-        T.length === 1 ? CloneType(T[0], options) :
+        T.length === 1 ? CreateType(T[0], options) :
             ResolveUnion(T, options));
 }

package/build/esm/type/union/union.mjs

@@ -1,10 +1,10 @@
 import { Never } from '../never/index.mjs';
-import { CloneType } from '../clone/type.mjs';
+import { CreateType } from '../create/type.mjs';
 import { UnionCreate } from './union-create.mjs';
 /** `[Json]` Creates a Union type */
-export function Union(T, options = {}) {
+export function Union(T, options) {
     // prettier-ignore
     return (T.length === 0 ? Never(options) :
-        T.length === 1 ? CloneType(T[0], options) :
+        T.length === 1 ? CreateType(T[0], options) :
             UnionCreate(T, options));
 }

package/build/esm/type/unknown/unknown.mjs

@@ -1,8 +1,6 @@
+import { CreateType } from '../create/type.mjs';
 import { Kind } from '../symbols/index.mjs';
 /** `[Json]` Creates an Unknown type */
-export function Unknown(options = {}) {
-    return {
-        ...options,
-        [Kind]: 'Unknown',
-    };
+export function Unknown(options) {
+    return CreateType({ [Kind]: 'Unknown' }, options);
 }

package/build/esm/type/unsafe/unsafe.mjs

@@ -1,8 +1,6 @@
+import { CreateType } from '../create/type.mjs';
 import { Kind } from '../symbols/index.mjs';
 /** `[Json]` Creates a Unsafe type that will infers as the generic argument T */
 export function Unsafe(options = {}) {
-    return {
-        ...options,
-        [Kind]: options[Kind] ?? 'Unsafe',
-    };
+    return CreateType({ [Kind]: options[Kind] ?? 'Unsafe' }, options);
 }

package/build/esm/type/void/void.mjs

@@ -1,9 +1,6 @@
+import { CreateType } from '../create/type.mjs';
 import { Kind } from '../symbols/index.mjs';
 /** `[JavaScript]` Creates a Void type */
-export function Void(options = {}) {
-    return {
-        ...options,
-        [Kind]: 'Void',
-        type: 'void',
-    };
+export function Void(options) {
+    return CreateType({ [Kind]: 'Void', type: 'void' }, options);
 }

package/build/esm/value/convert/convert.mjs

@@ -151,6 +151,9 @@ function FromObject(schema, references, value) {
     return result;
 }
 function FromRecord(schema, references, value) {
+    const isConvertable = IsObject(value);
+    if (!isConvertable)
+        return value;
     const propertyKey = Object.getOwnPropertyNames(schema.patternProperties)[0];
     const property = schema.patternProperties[propertyKey];
     const result = {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.34",
+  "version": "0.33.0",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",