@sinclair/typebox 0.33.21 → 0.34.0

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

@@ -1,22 +0,0 @@
-import type { TSchema } from '../schema/index';
-import type { Evaluate } from '../helpers/index';
-import type { TTuple } from '../tuple/index';
-import type { TIntersect } from '../intersect/index';
-import type { TUnion } from '../union/index';
-import type { TPromise } from '../promise/index';
-import type { TAsyncIterator } from '../async-iterator/index';
-import type { TIterator } from '../iterator/index';
-import type { TArray } from '../array/index';
-import type { TConstructor } from '../constructor/index';
-import type { TFunction } from '../function/index';
-import type { TRef } from '../ref/index';
-import type { TObject, TProperties } from '../object/index';
-export type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Acc, TDeref<L>]> : Acc);
-type FromProperties<T extends TProperties> = Evaluate<{
-    [K in keyof T]: TDeref<T[K]>;
-}>;
-declare function FromProperties(properties: TProperties, references: TSchema[]): never;
-export type TDeref<T extends TSchema> = T extends TConstructor<infer S extends TSchema[], infer R extends TSchema> ? TConstructor<TFromRest<S>, TDeref<R>> : T extends TFunction<infer S extends TSchema[], infer R extends TSchema> ? TFunction<TFromRest<S>, TDeref<R>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<TFromRest<S>> : T extends TUnion<infer S extends TSchema[]> ? TUnion<TFromRest<S>> : T extends TTuple<infer S extends TSchema[]> ? TTuple<TFromRest<S>> : T extends TObject<infer S extends TProperties> ? TObject<FromProperties<S>> : T extends TArray<infer S extends TSchema> ? TArray<TDeref<S>> : T extends TPromise<infer S extends TSchema> ? TPromise<TDeref<S>> : T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<TDeref<S>> : T extends TIterator<infer S extends TSchema> ? TIterator<TDeref<S>> : T extends TRef<infer S extends TSchema> ? TDeref<S> : T;
-/** `[Json]` Creates a dereferenced type */
-export declare function Deref<T extends TSchema>(schema: T, references: TSchema[]): TDeref<T>;
-export {};

package/build/cjs/type/deref/deref.js

@@ -1,106 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Deref = Deref;
-const type_1 = require("../clone/type");
-const index_1 = require("../discard/index");
-const value_1 = require("../guard/value");
-// ------------------------------------------------------------------
-// TypeGuard
-// ------------------------------------------------------------------
-const kind_1 = require("../guard/kind");
-function FromRest(schema, references) {
-    return schema.map((schema) => Deref(schema, references));
-}
-// prettier-ignore
-function FromProperties(properties, references) {
-    const Acc = {};
-    for (const K of globalThis.Object.getOwnPropertyNames(properties)) {
-        Acc[K] = Deref(properties[K], references);
-    }
-    return Acc;
-}
-// prettier-ignore
-function FromConstructor(schema, references) {
-    schema.parameters = FromRest(schema.parameters, references);
-    schema.returns = Deref(schema.returns, references);
-    return schema;
-}
-// prettier-ignore
-function FromFunction(schema, references) {
-    schema.parameters = FromRest(schema.parameters, references);
-    schema.returns = Deref(schema.returns, references);
-    return schema;
-}
-// prettier-ignore
-function FromIntersect(schema, references) {
-    schema.allOf = FromRest(schema.allOf, references);
-    return schema;
-}
-// prettier-ignore
-function FromUnion(schema, references) {
-    schema.anyOf = FromRest(schema.anyOf, references);
-    return schema;
-}
-// prettier-ignore
-function FromTuple(schema, references) {
-    if ((0, value_1.IsUndefined)(schema.items))
-        return schema;
-    schema.items = FromRest(schema.items, references);
-    return schema;
-}
-// prettier-ignore
-function FromArray(schema, references) {
-    schema.items = Deref(schema.items, references);
-    return schema;
-}
-// prettier-ignore
-function FromObject(schema, references) {
-    schema.properties = FromProperties(schema.properties, references);
-    return schema;
-}
-// prettier-ignore
-function FromPromise(schema, references) {
-    schema.item = Deref(schema.item, references);
-    return schema;
-}
-// prettier-ignore
-function FromAsyncIterator(schema, references) {
-    schema.items = Deref(schema.items, references);
-    return schema;
-}
-// prettier-ignore
-function FromIterator(schema, references) {
-    schema.items = Deref(schema.items, references);
-    return schema;
-}
-// prettier-ignore
-function FromRef(schema, references) {
-    const target = references.find(remote => remote.$id === schema.$ref);
-    if (target === undefined)
-        throw Error(`Unable to dereference schema with $id ${schema.$ref}`);
-    const discard = (0, index_1.Discard)(target, ['$id']);
-    return Deref(discard, references);
-}
-// prettier-ignore
-function DerefResolve(schema, references) {
-    return ((0, kind_1.IsConstructor)(schema) ? FromConstructor(schema, references) :
-        (0, kind_1.IsFunction)(schema) ? FromFunction(schema, references) :
-            (0, kind_1.IsIntersect)(schema) ? FromIntersect(schema, references) :
-                (0, kind_1.IsUnion)(schema) ? FromUnion(schema, references) :
-                    (0, kind_1.IsTuple)(schema) ? FromTuple(schema, references) :
-                        (0, kind_1.IsArray)(schema) ? FromArray(schema, references) :
-                            (0, kind_1.IsObject)(schema) ? FromObject(schema, references) :
-                                (0, kind_1.IsPromise)(schema) ? FromPromise(schema, references) :
-                                    (0, kind_1.IsAsyncIterator)(schema) ? FromAsyncIterator(schema, references) :
-                                        (0, kind_1.IsIterator)(schema) ? FromIterator(schema, references) :
-                                            (0, kind_1.IsRef)(schema) ? FromRef(schema, references) :
-                                                schema);
-}
-// ------------------------------------------------------------------
-// TDeref
-// ------------------------------------------------------------------
-/** `[Json]` Creates a dereferenced type */
-function Deref(schema, references) {
-    return DerefResolve((0, type_1.CloneType)(schema), (0, type_1.CloneRest)(references));
-}

package/build/cjs/type/deref/index.d.ts

@@ -1 +0,0 @@
-export * from './deref';

package/build/cjs/type/strict/index.d.ts

@@ -1 +0,0 @@
-export * from './strict';

package/build/cjs/type/strict/index.js

@@ -1,18 +0,0 @@
-"use strict";
-
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./strict"), exports);

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

@@ -1,12 +0,0 @@
-import type { TSchema } from '../schema/index';
-export type TStrict<T extends TSchema> = T;
-/**
- * @deprecated `[Json]` Omits compositing symbols from this schema. It is recommended
- * to use the JSON parse/stringify to remove compositing symbols if needed. This
- * is how Strict works internally.
- *
- * ```typescript
- * JSON.parse(JSON.stringify(Type.String()))
- * ```
- */
-export declare function Strict<T extends TSchema>(schema: T): TStrict<T>;

package/build/cjs/type/strict/strict.js

@@ -1,16 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Strict = Strict;
-/**
- * @deprecated `[Json]` Omits compositing symbols from this schema. It is recommended
- * to use the JSON parse/stringify to remove compositing symbols if needed. This
- * is how Strict works internally.
- *
- * ```typescript
- * JSON.parse(JSON.stringify(Type.String()))
- * ```
- */
-function Strict(schema) {
-    return JSON.parse(JSON.stringify(schema));
-}

package/build/esm/parse/parse.d.mts

@@ -1,11 +0,0 @@
-import { Static } from './parsebox/index.mjs';
-import { TSchema, SchemaOptions } from '../type/schema/index.mjs';
-import { Type } from './static.mjs';
-/** `[Experimental]` Parses a TypeScript type annotation as an inferred TypeBox type */
-export declare function Parse<Code extends string, Context extends Record<PropertyKey, TSchema> = {}>(context: Context, code: Code, options?: SchemaOptions): Static.Parse<Type, Code, Context>[0];
-/** `[Experimental]` Parses a TypeScript type annotation as an inferred TypeBox type */
-export declare function Parse<Code extends string>(code: Code, options?: SchemaOptions): Static.Parse<Type, Code, {}>[0];
-/** `[Experimental]` Parses a TypeScript type annotation as TSchema */
-export declare function ParseOnly<Code extends string, Context extends Record<PropertyKey, TSchema> = {}>(context: Context, code: Code, options?: SchemaOptions): TSchema | undefined;
-/** `[Experimental]` Parses a TypeScript type annotation as TSchema */
-export declare function ParseOnly<Code extends string>(code: Code, options?: SchemaOptions): TSchema | undefined;

package/build/esm/parse/parse.mjs

@@ -1,13 +0,0 @@
-import { CreateType } from '../type/create/type.mjs';
-import { Module } from './runtime.mjs';
-/** `[Experimental]` Parses a TypeScript type annotation as an inferred TypeBox type */
-export function Parse(...args) {
-    return ParseOnly.apply(null, args);
-}
-/** `[Experimental]` Parses a TypeScript type annotation as TSchema */
-export function ParseOnly(...args) {
-    const withContext = typeof args[0] === 'string' ? false : true;
-    const [context, code, options] = withContext ? [args[0], args[1], args[2] || {}] : [{}, args[0], args[1] || {}];
-    const type = Module.Parse('Type', code, context)[0];
-    return (type !== undefined ? CreateType(type, options) : undefined);
-}

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

@@ -1,22 +0,0 @@
-import type { TSchema } from '../schema/index.mjs';
-import type { Evaluate } from '../helpers/index.mjs';
-import type { TTuple } from '../tuple/index.mjs';
-import type { TIntersect } from '../intersect/index.mjs';
-import type { TUnion } from '../union/index.mjs';
-import type { TPromise } from '../promise/index.mjs';
-import type { TAsyncIterator } from '../async-iterator/index.mjs';
-import type { TIterator } from '../iterator/index.mjs';
-import type { TArray } from '../array/index.mjs';
-import type { TConstructor } from '../constructor/index.mjs';
-import type { TFunction } from '../function/index.mjs';
-import type { TRef } from '../ref/index.mjs';
-import type { TObject, TProperties } from '../object/index.mjs';
-export type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Acc, TDeref<L>]> : Acc);
-type FromProperties<T extends TProperties> = Evaluate<{
-    [K in keyof T]: TDeref<T[K]>;
-}>;
-declare function FromProperties(properties: TProperties, references: TSchema[]): never;
-export type TDeref<T extends TSchema> = T extends TConstructor<infer S extends TSchema[], infer R extends TSchema> ? TConstructor<TFromRest<S>, TDeref<R>> : T extends TFunction<infer S extends TSchema[], infer R extends TSchema> ? TFunction<TFromRest<S>, TDeref<R>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<TFromRest<S>> : T extends TUnion<infer S extends TSchema[]> ? TUnion<TFromRest<S>> : T extends TTuple<infer S extends TSchema[]> ? TTuple<TFromRest<S>> : T extends TObject<infer S extends TProperties> ? TObject<FromProperties<S>> : T extends TArray<infer S extends TSchema> ? TArray<TDeref<S>> : T extends TPromise<infer S extends TSchema> ? TPromise<TDeref<S>> : T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<TDeref<S>> : T extends TIterator<infer S extends TSchema> ? TIterator<TDeref<S>> : T extends TRef<infer S extends TSchema> ? TDeref<S> : T;
-/** `[Json]` Creates a dereferenced type */
-export declare function Deref<T extends TSchema>(schema: T, references: TSchema[]): TDeref<T>;
-export {};

package/build/esm/type/deref/deref.mjs

@@ -1,102 +0,0 @@
-import { CloneType, CloneRest } from '../clone/type.mjs';
-import { Discard } from '../discard/index.mjs';
-import { IsUndefined } from '../guard/value.mjs';
-// ------------------------------------------------------------------
-// TypeGuard
-// ------------------------------------------------------------------
-import { IsConstructor, IsFunction, IsIntersect, IsUnion, IsTuple, IsArray, IsObject, IsPromise, IsAsyncIterator, IsIterator, IsRef } from '../guard/kind.mjs';
-function FromRest(schema, references) {
-    return schema.map((schema) => Deref(schema, references));
-}
-// prettier-ignore
-function FromProperties(properties, references) {
-    const Acc = {};
-    for (const K of globalThis.Object.getOwnPropertyNames(properties)) {
-        Acc[K] = Deref(properties[K], references);
-    }
-    return Acc;
-}
-// prettier-ignore
-function FromConstructor(schema, references) {
-    schema.parameters = FromRest(schema.parameters, references);
-    schema.returns = Deref(schema.returns, references);
-    return schema;
-}
-// prettier-ignore
-function FromFunction(schema, references) {
-    schema.parameters = FromRest(schema.parameters, references);
-    schema.returns = Deref(schema.returns, references);
-    return schema;
-}
-// prettier-ignore
-function FromIntersect(schema, references) {
-    schema.allOf = FromRest(schema.allOf, references);
-    return schema;
-}
-// prettier-ignore
-function FromUnion(schema, references) {
-    schema.anyOf = FromRest(schema.anyOf, references);
-    return schema;
-}
-// prettier-ignore
-function FromTuple(schema, references) {
-    if (IsUndefined(schema.items))
-        return schema;
-    schema.items = FromRest(schema.items, references);
-    return schema;
-}
-// prettier-ignore
-function FromArray(schema, references) {
-    schema.items = Deref(schema.items, references);
-    return schema;
-}
-// prettier-ignore
-function FromObject(schema, references) {
-    schema.properties = FromProperties(schema.properties, references);
-    return schema;
-}
-// prettier-ignore
-function FromPromise(schema, references) {
-    schema.item = Deref(schema.item, references);
-    return schema;
-}
-// prettier-ignore
-function FromAsyncIterator(schema, references) {
-    schema.items = Deref(schema.items, references);
-    return schema;
-}
-// prettier-ignore
-function FromIterator(schema, references) {
-    schema.items = Deref(schema.items, references);
-    return schema;
-}
-// prettier-ignore
-function FromRef(schema, references) {
-    const target = references.find(remote => remote.$id === schema.$ref);
-    if (target === undefined)
-        throw Error(`Unable to dereference schema with $id ${schema.$ref}`);
-    const discard = Discard(target, ['$id']);
-    return Deref(discard, references);
-}
-// prettier-ignore
-function DerefResolve(schema, references) {
-    return (IsConstructor(schema) ? FromConstructor(schema, references) :
-        IsFunction(schema) ? FromFunction(schema, references) :
-            IsIntersect(schema) ? FromIntersect(schema, references) :
-                IsUnion(schema) ? FromUnion(schema, references) :
-                    IsTuple(schema) ? FromTuple(schema, references) :
-                        IsArray(schema) ? FromArray(schema, references) :
-                            IsObject(schema) ? FromObject(schema, references) :
-                                IsPromise(schema) ? FromPromise(schema, references) :
-                                    IsAsyncIterator(schema) ? FromAsyncIterator(schema, references) :
-                                        IsIterator(schema) ? FromIterator(schema, references) :
-                                            IsRef(schema) ? FromRef(schema, references) :
-                                                schema);
-}
-// ------------------------------------------------------------------
-// TDeref
-// ------------------------------------------------------------------
-/** `[Json]` Creates a dereferenced type */
-export function Deref(schema, references) {
-    return DerefResolve(CloneType(schema), CloneRest(references));
-}

package/build/esm/type/deref/index.d.mts

@@ -1 +0,0 @@
-export * from './deref.mjs';

package/build/esm/type/deref/index.mjs

@@ -1 +0,0 @@
-export * from './deref.mjs';

package/build/esm/type/strict/index.d.mts

@@ -1 +0,0 @@
-export * from './strict.mjs';

package/build/esm/type/strict/index.mjs

@@ -1 +0,0 @@
-export * from './strict.mjs';

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

@@ -1,12 +0,0 @@
-import type { TSchema } from '../schema/index.mjs';
-export type TStrict<T extends TSchema> = T;
-/**
- * @deprecated `[Json]` Omits compositing symbols from this schema. It is recommended
- * to use the JSON parse/stringify to remove compositing symbols if needed. This
- * is how Strict works internally.
- *
- * ```typescript
- * JSON.parse(JSON.stringify(Type.String()))
- * ```
- */
-export declare function Strict<T extends TSchema>(schema: T): TStrict<T>;

package/build/esm/type/strict/strict.mjs

@@ -1,12 +0,0 @@
-/**
- * @deprecated `[Json]` Omits compositing symbols from this schema. It is recommended
- * to use the JSON parse/stringify to remove compositing symbols if needed. This
- * is how Strict works internally.
- *
- * ```typescript
- * JSON.parse(JSON.stringify(Type.String()))
- * ```
- */
-export function Strict(schema) {
-    return JSON.parse(JSON.stringify(schema));
-}

package/parse/package.json

@@ -1,4 +0,0 @@
-{
-  "main": "../build/cjs/parse/index.js",
-  "types": "../build/cjs/parse/index.d.ts"
-}