@sinclair/typebox 0.34.5 → 0.34.7

package/build/cjs/type/guard/kind.js

@@ -247,6 +247,7 @@ function IsSchema(value) {
         IsBoolean(value) ||
         IsBigInt(value) ||
         IsAsyncIterator(value) ||
+        IsComputed(value) ||
         IsConstructor(value) ||
         IsDate(value) ||
         IsFunction(value) ||

package/build/cjs/type/guard/type.js

@@ -199,7 +199,11 @@ function IsBoolean(value) {
 }
 /** Returns true if the given value is TComputed */
 function IsComputed(value) {
-    return IsKindOf(value, 'Computed') && IsString(value.target) && ValueGuard.IsArray(value.parameters) && value.parameters.every((schema) => IsSchema(schema));
+    // prettier-ignore
+    return (IsKindOf(value, 'Computed') &&
+        ValueGuard.IsString(value.target) &&
+        ValueGuard.IsArray(value.parameters) &&
+        value.parameters.every((schema) => IsSchema(schema)));
 }
 /** Returns true if the given value is TConstructor */
 function IsConstructor(value) {
@@ -517,6 +521,7 @@ function IsSchema(value) {
         IsBoolean(value) ||
         IsBigInt(value) ||
         IsAsyncIterator(value) ||
+        IsComputed(value) ||
         IsConstructor(value) ||
         IsDate(value) ||
         IsFunction(value) ||

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

@@ -1,9 +1,28 @@
 import type { TSchema, SchemaOptions } from '../schema/index';
 import { Kind } from '../symbols/index';
+import { TUnsafe } from '../unsafe/index';
+import { Static } from '../static/index';
 export interface TRef<Ref extends string = string> extends TSchema {
     [Kind]: 'Ref';
     static: unknown;
     $ref: Ref;
 }
-/** `[Json]` Creates a Ref type. The referenced type must contain a $id */
+export type TRefUnsafe<Type extends TSchema> = TUnsafe<Static<Type>>;
+/** `[Json]` Creates a Ref type.*/
 export declare function Ref<Ref extends string>($ref: Ref, options?: SchemaOptions): TRef<Ref>;
+/**
+ * @deprecated `[Json]` Creates a Ref type. The referenced type MUST contain a $id. The Ref(TSchema) signature was
+ * deprecated on 0.34.0 in support of a new type referencing model (Module). Existing implementations using Ref(TSchema)
+ * can migrate using the following. The Ref(TSchema) validation behavior of Ref will be preserved how the construction
+ * of legacy Ref(TSchema) will require wrapping in TUnsafe (where TUnsafe is used for inference only)
+ *
+ * ```typescript
+ * const R = Type.Ref(T)
+ * ```
+ * to
+ *
+ * ```typescript
+ * const R = Type.Unsafe<Static<T>>(T.$id)
+ * ```
+ */
+export declare function Ref<Type extends TSchema>(type: Type, options?: SchemaOptions): TRefUnsafe<Type>;

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

@@ -2,9 +2,13 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Ref = Ref;
+const index_1 = require("../error/index");
 const type_1 = require("../create/type");
-const index_1 = require("../symbols/index");
+const index_2 = require("../symbols/index");
 /** `[Json]` Creates a Ref type. The referenced type must contain a $id */
-function Ref($ref, options) {
-    return (0, type_1.CreateType)({ [index_1.Kind]: 'Ref', $ref }, options);
+function Ref(...args) {
+    const [$ref, options] = typeof args[0] === 'string' ? [args[0], args[1]] : [args[0].$id, args[1]];
+    if (typeof $ref !== 'string')
+        throw new index_1.TypeBoxError('Ref: $ref must be a string');
+    return (0, type_1.CreateType)({ [index_2.Kind]: 'Ref', $ref }, options);
 }

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

@@ -29,7 +29,7 @@ import { type TReadonlyWithFlag, type TReadonlyFromMappedResult } from '../reado
 import { type TReadonlyOptional } from '../readonly-optional/index';
 import { type TRecordOrObject } from '../record/index';
 import { type TRecursive, type TThis } from '../recursive/index';
-import { type TRef } from '../ref/index';
+import { type TRef, type TRefUnsafe } from '../ref/index';
 import { type TRequired, type TRequiredFromMappedResult } from '../required/index';
 import { type TRest } from '../rest/index';
 import { type TSchema, type SchemaOptions } from '../schema/index';
@@ -142,8 +142,24 @@ export declare class JsonTypeBuilder {
     Record<Key extends TSchema, Value extends TSchema>(key: Key, value: Value, options?: ObjectOptions): TRecordOrObject<Key, Value>;
     /** `[Json]` Creates a Recursive type */
     Recursive<T extends TSchema>(callback: (thisType: TThis) => T, options?: SchemaOptions): TRecursive<T>;
-    /** `[Json]` Creates a Ref type. */
+    /** `[Json]` Creates a Ref type.*/
     Ref<Ref extends string>($ref: Ref, options?: SchemaOptions): TRef<Ref>;
+    /**
+     * @deprecated `[Json]` Creates a Ref type. The referenced type MUST contain a $id. The Ref(TSchema) signature was
+     * deprecated on 0.34.0 in support of a new type referencing model (Module). Existing implementations using Ref(TSchema)
+     * can migrate using the following. The Ref(TSchema) validation behavior of Ref will be preserved how the construction
+     * of legacy Ref(TSchema) will require wrapping in TUnsafe (where TUnsafe is used for inference only)
+     *
+     * ```typescript
+     * const R = Type.Ref(T)
+     * ```
+     * to
+     *
+     * ```typescript
+     * const R = Type.Unsafe<Static<T>>(T.$id)
+     * ```
+     */
+    Ref<Type extends TSchema>(type: Type, options?: SchemaOptions): TRefUnsafe<Type>;
     /** `[Json]` Constructs a type where all properties are required */
     Required<MappedResult extends TMappedResult>(type: MappedResult, options?: SchemaOptions): TRequiredFromMappedResult<MappedResult>;
     /** `[Json]` Constructs a type where all properties are required */

package/build/cjs/type/type/json.js

@@ -174,9 +174,9 @@ class JsonTypeBuilder {
     Recursive(callback, options) {
         return (0, index_30.Recursive)(callback, options);
     }
-    /** `[Json]` Creates a Ref type. */
-    Ref($ref, options) {
-        return (0, index_31.Ref)($ref, options);
+    /** `[Json]` Creates a Ref type. The referenced type must contain a $id */
+    Ref(...args) {
+        return (0, index_31.Ref)(args[0], args[1]);
     }
     /** `[Json]` Constructs a type where all properties are required */
     Required(type, options) {

package/build/esm/type/guard/kind.mjs

@@ -196,6 +196,7 @@ export function IsSchema(value) {
         IsBoolean(value) ||
         IsBigInt(value) ||
         IsAsyncIterator(value) ||
+        IsComputed(value) ||
         IsConstructor(value) ||
         IsDate(value) ||
         IsFunction(value) ||

package/build/esm/type/guard/type.mjs

@@ -145,7 +145,11 @@ export function IsBoolean(value) {
 }
 /** Returns true if the given value is TComputed */
 export function IsComputed(value) {
-    return IsKindOf(value, 'Computed') && IsString(value.target) && ValueGuard.IsArray(value.parameters) && value.parameters.every((schema) => IsSchema(schema));
+    // prettier-ignore
+    return (IsKindOf(value, 'Computed') &&
+        ValueGuard.IsString(value.target) &&
+        ValueGuard.IsArray(value.parameters) &&
+        value.parameters.every((schema) => IsSchema(schema)));
 }
 /** Returns true if the given value is TConstructor */
 export function IsConstructor(value) {
@@ -463,6 +467,7 @@ export function IsSchema(value) {
         IsBoolean(value) ||
         IsBigInt(value) ||
         IsAsyncIterator(value) ||
+        IsComputed(value) ||
         IsConstructor(value) ||
         IsDate(value) ||
         IsFunction(value) ||

package/build/esm/type/module/compute.mjs

@@ -4,7 +4,7 @@ import { Awaited } from '../awaited/index.mjs';
 import { AsyncIterator } from '../async-iterator/index.mjs';
 import { Constructor } from '../constructor/index.mjs';
 import { Index } from '../indexed/index.mjs';
-import { Function } from '../function/index.mjs';
+import { Function as FunctionType } from '../function/index.mjs';
 import { Intersect } from '../intersect/index.mjs';
 import { Iterator } from '../iterator/index.mjs';
 import { KeyOf } from '../keyof/index.mjs';
@@ -93,7 +93,7 @@ function FromConstructor(moduleProperties, parameters, instanceType) {
 }
 // prettier-ignore
 function FromFunction(moduleProperties, parameters, returnType) {
-    return Function(FromRest(moduleProperties, parameters), FromType(moduleProperties, returnType));
+    return FunctionType(FromRest(moduleProperties, parameters), FromType(moduleProperties, returnType));
 }
 function FromTuple(moduleProperties, types) {
     return Tuple(FromRest(moduleProperties, types));

package/build/esm/type/ref/ref.d.mts

@@ -1,9 +1,28 @@
 import type { TSchema, SchemaOptions } from '../schema/index.mjs';
 import { Kind } from '../symbols/index.mjs';
+import { TUnsafe } from '../unsafe/index.mjs';
+import { Static } from '../static/index.mjs';
 export interface TRef<Ref extends string = string> extends TSchema {
     [Kind]: 'Ref';
     static: unknown;
     $ref: Ref;
 }
-/** `[Json]` Creates a Ref type. The referenced type must contain a $id */
+export type TRefUnsafe<Type extends TSchema> = TUnsafe<Static<Type>>;
+/** `[Json]` Creates a Ref type.*/
 export declare function Ref<Ref extends string>($ref: Ref, options?: SchemaOptions): TRef<Ref>;
+/**
+ * @deprecated `[Json]` Creates a Ref type. The referenced type MUST contain a $id. The Ref(TSchema) signature was
+ * deprecated on 0.34.0 in support of a new type referencing model (Module). Existing implementations using Ref(TSchema)
+ * can migrate using the following. The Ref(TSchema) validation behavior of Ref will be preserved how the construction
+ * of legacy Ref(TSchema) will require wrapping in TUnsafe (where TUnsafe is used for inference only)
+ *
+ * ```typescript
+ * const R = Type.Ref(T)
+ * ```
+ * to
+ *
+ * ```typescript
+ * const R = Type.Unsafe<Static<T>>(T.$id)
+ * ```
+ */
+export declare function Ref<Type extends TSchema>(type: Type, options?: SchemaOptions): TRefUnsafe<Type>;

package/build/esm/type/ref/ref.mjs

@@ -1,6 +1,10 @@
+import { TypeBoxError } from '../error/index.mjs';
 import { CreateType } from '../create/type.mjs';
 import { Kind } from '../symbols/index.mjs';
 /** `[Json]` Creates a Ref type. The referenced type must contain a $id */
-export function Ref($ref, options) {
+export function Ref(...args) {
+    const [$ref, options] = typeof args[0] === 'string' ? [args[0], args[1]] : [args[0].$id, args[1]];
+    if (typeof $ref !== 'string')
+        throw new TypeBoxError('Ref: $ref must be a string');
     return CreateType({ [Kind]: 'Ref', $ref }, options);
 }

package/build/esm/type/type/json.d.mts

@@ -29,7 +29,7 @@ import { type TReadonlyWithFlag, type TReadonlyFromMappedResult } from '../reado
 import { type TReadonlyOptional } from '../readonly-optional/index.mjs';
 import { type TRecordOrObject } from '../record/index.mjs';
 import { type TRecursive, type TThis } from '../recursive/index.mjs';
-import { type TRef } from '../ref/index.mjs';
+import { type TRef, type TRefUnsafe } from '../ref/index.mjs';
 import { type TRequired, type TRequiredFromMappedResult } from '../required/index.mjs';
 import { type TRest } from '../rest/index.mjs';
 import { type TSchema, type SchemaOptions } from '../schema/index.mjs';
@@ -142,8 +142,24 @@ export declare class JsonTypeBuilder {
     Record<Key extends TSchema, Value extends TSchema>(key: Key, value: Value, options?: ObjectOptions): TRecordOrObject<Key, Value>;
     /** `[Json]` Creates a Recursive type */
     Recursive<T extends TSchema>(callback: (thisType: TThis) => T, options?: SchemaOptions): TRecursive<T>;
-    /** `[Json]` Creates a Ref type. */
+    /** `[Json]` Creates a Ref type.*/
     Ref<Ref extends string>($ref: Ref, options?: SchemaOptions): TRef<Ref>;
+    /**
+     * @deprecated `[Json]` Creates a Ref type. The referenced type MUST contain a $id. The Ref(TSchema) signature was
+     * deprecated on 0.34.0 in support of a new type referencing model (Module). Existing implementations using Ref(TSchema)
+     * can migrate using the following. The Ref(TSchema) validation behavior of Ref will be preserved how the construction
+     * of legacy Ref(TSchema) will require wrapping in TUnsafe (where TUnsafe is used for inference only)
+     *
+     * ```typescript
+     * const R = Type.Ref(T)
+     * ```
+     * to
+     *
+     * ```typescript
+     * const R = Type.Unsafe<Static<T>>(T.$id)
+     * ```
+     */
+    Ref<Type extends TSchema>(type: Type, options?: SchemaOptions): TRefUnsafe<Type>;
     /** `[Json]` Constructs a type where all properties are required */
     Required<MappedResult extends TMappedResult>(type: MappedResult, options?: SchemaOptions): TRequiredFromMappedResult<MappedResult>;
     /** `[Json]` Constructs a type where all properties are required */

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

@@ -170,9 +170,9 @@ export class JsonTypeBuilder {
     Recursive(callback, options) {
         return Recursive(callback, options);
     }
-    /** `[Json]` Creates a Ref type. */
-    Ref($ref, options) {
-        return Ref($ref, options);
+    /** `[Json]` Creates a Ref type. The referenced type must contain a $id */
+    Ref(...args) {
+        return Ref(args[0], args[1]);
     }
     /** `[Json]` Constructs a type where all properties are required */
     Required(type, options) {

package/package.json

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

package/readme.md

@@ -337,7 +337,7 @@ The following table lists the supported Json types. These types are fully compat
 │   }),                          │   y: number                 │     required: ['x'],           │
 │   Type.Object({                │ }                           │     properties: {              │
 │     y: Type.Number()           │                             │       x: {                     │
-│   ])                           │                             │         type: 'number'         │
+│   })                           │                             │         type: 'number'         │
 │ ])                             │                             │       }                        │
 │                                │                             │     }                          │
 │                                │                             │   }, {                         │
@@ -534,15 +534,7 @@ The following table lists the supported Json types. These types are fully compat
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
-│ const T = Type.Object({        │ type T = {                  │ const R = {                    │
-│    x: Type.Number(),           │   x: number,                │   $ref: 'T'                    │
-│    y: Type.Number()            │   y: number                 │ }                              │
-│ }, { $id: 'T' })               | }                           │                                │
-│                                │                             │                                │
-│ const R = Type.Ref(T)          │ type R = T                  │                                │
-│                                │                             │                                │
-│                                │                             │                                │
-│                                │                             │                                │
+│ const R = Type.Ref('T')        │ type R = unknown            │ const R = { $ref: 'T' }        │
 │                                │                             │                                │
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
 ```