@sinclair/typebox 0.32.32 → 0.32.34

package/build/cjs/value/value/value.js

@@ -1,7 +1,21 @@
 "use strict";
 
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Mutate = exports.Patch = exports.Hash = exports.Diff = exports.Equal = exports.Errors = exports.Encode = exports.Default = exports.Decode = exports.Clone = exports.Convert = exports.Clean = exports.Check = exports.Create = exports.Cast = void 0;
+exports.Cast = Cast;
+exports.Create = Create;
+exports.Check = Check;
+exports.Clean = Clean;
+exports.Convert = Convert;
+exports.Clone = Clone;
+exports.Decode = Decode;
+exports.Default = Default;
+exports.Encode = Encode;
+exports.Errors = Errors;
+exports.Equal = Equal;
+exports.Diff = Diff;
+exports.Hash = Hash;
+exports.Patch = Patch;
+exports.Mutate = Mutate;
 const index_1 = require("../transform/index");
 const index_2 = require("../mutate/index");
 const index_3 = require("../hash/index");
@@ -19,32 +33,26 @@ const index_13 = require("../../errors/index");
 function Cast(...args) {
     return index_5.Cast.apply(index_5.Cast, args);
 }
-exports.Cast = Cast;
 /** Creates a value from the given type */
 function Create(...args) {
     return index_8.Create.apply(index_8.Create, args);
 }
-exports.Create = Create;
 /** Returns true if the value matches the given type */
 function Check(...args) {
     return index_10.Check.apply(index_10.Check, args);
 }
-exports.Check = Check;
 /** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
 function Clean(...args) {
     return index_9.Clean.apply(index_9.Clean, args);
 }
-exports.Clean = Clean;
 /** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
 function Convert(...args) {
     return index_7.Convert.apply(index_7.Convert, args);
 }
-exports.Convert = Convert;
 /** Returns a structural clone of the given value */
 function Clone(value) {
     return (0, index_6.Clone)(value);
 }
-exports.Clone = Clone;
 /** Decodes a value or throws if error */
 function Decode(...args) {
     const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
@@ -52,12 +60,10 @@ function Decode(...args) {
         throw new index_1.TransformDecodeCheckError(schema, value, Errors(schema, references, value).First());
     return (0, index_1.HasTransform)(schema, references) ? (0, index_1.TransformDecode)(schema, references, value) : value;
 }
-exports.Decode = Decode;
 /** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
 function Default(...args) {
     return index_11.Default.apply(index_11.Default, args);
 }
-exports.Default = Default;
 /** Encodes a value or throws if error */
 function Encode(...args) {
     const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
@@ -66,34 +72,27 @@ function Encode(...args) {
         throw new index_1.TransformEncodeCheckError(schema, encoded, Errors(schema, references, encoded).First());
     return encoded;
 }
-exports.Encode = Encode;
 /** Returns an iterator for each error in this value. */
 function Errors(...args) {
     return index_13.Errors.apply(index_13.Errors, args);
 }
-exports.Errors = Errors;
 /** Returns true if left and right values are structurally equal */
 function Equal(left, right) {
     return (0, index_4.Equal)(left, right);
 }
-exports.Equal = Equal;
 /** Returns edits to transform the current value into the next value */
 function Diff(current, next) {
     return (0, index_12.Diff)(current, next);
 }
-exports.Diff = Diff;
 /** Returns a FNV1A-64 non cryptographic hash of the given value */
 function Hash(value) {
     return (0, index_3.Hash)(value);
 }
-exports.Hash = Hash;
 /** Returns a new value with edits applied to the given value */
 function Patch(current, edits) {
     return (0, index_12.Patch)(current, edits);
 }
-exports.Patch = Patch;
 /** `[Mutable]` Performs a deep mutable value assignment while retaining internal references. */
 function Mutate(current, next) {
     (0, index_2.Mutate)(current, next);
 }
-exports.Mutate = Mutate;

package/build/esm/compiler/compiler.mjs

@@ -21,11 +21,6 @@ import { IsSchema } from '../type/guard/type.mjs';
 // TypeCheck
 // ------------------------------------------------------------------
 export class TypeCheck {
-    schema;
-    references;
-    checkFunc;
-    code;
-    hasTransform;
     constructor(schema, references, checkFunc, code) {
         this.schema = schema;
         this.references = references;
@@ -144,14 +139,12 @@ var LiteralString;
 // Errors
 // ------------------------------------------------------------------
 export class TypeCompilerUnknownTypeError extends TypeBoxError {
-    schema;
     constructor(schema) {
         super('Unknown type');
         this.schema = schema;
     }
 }
 export class TypeCompilerTypeGuardError extends TypeBoxError {
-    schema;
     constructor(schema) {
         super('Preflight validation check failed to guard for the given schema');
         this.schema = schema;

package/build/esm/errors/errors.mjs

@@ -87,7 +87,6 @@ export var ValueErrorType;
 // ValueErrors
 // ------------------------------------------------------------------
 export class ValueErrorsUnknownTypeError extends TypeBoxError {
-    schema;
     constructor(schema) {
         super('Unknown type');
         this.schema = schema;
@@ -109,7 +108,6 @@ function IsDefined(value) {
 // ValueErrorIterator
 // ------------------------------------------------------------------
 export class ValueErrorIterator {
-    iterator;
     constructor(iterator) {
         this.iterator = iterator;
     }

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

@@ -9,9 +9,9 @@ import { type TIndexPropertyKeys } from '../indexed/index.mjs';
 import { type TPickFromMappedKey } from './pick-from-mapped-key.mjs';
 import { type TPickFromMappedResult } from './pick-from-mapped-result.mjs';
 type FromIntersect<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? FromIntersect<R, K, [...Acc, TPick<L, K>]> : Acc;
-declare function FromIntersect<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K): FromIntersect<T, K, []>;
+declare function FromIntersect<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K): FromIntersect<T, K>;
 type FromUnion<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? FromUnion<R, K, [...Acc, TPick<L, K>]> : Acc;
-declare function FromUnion<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K): FromUnion<T, K, []>;
+declare function FromUnion<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K): FromUnion<T, K>;
 type FromProperties<T extends TProperties, K extends PropertyKey[], I extends PropertyKey = TupleToUnion<K>> = Evaluate<Pick<T, I & keyof T>>;
 declare function FromProperties<T extends TProperties, K extends PropertyKey[]>(T: T, K: K): never;
 export type TPick<T extends TProperties, K extends PropertyKey[]> = T extends TRecursive<infer S> ? TRecursive<TPick<S, K>> : T extends TIntersect<infer S> ? TIntersect<FromIntersect<S, K>> : T extends TUnion<infer S> ? TUnion<FromUnion<S, K>> : T extends TObject<infer S> ? TObject<FromProperties<S, K>> : TObject<{}>;

package/build/esm/type/template-literal/generate.d.mts

@@ -13,7 +13,7 @@ type TStringReduceBinary<L extends string[], R extends string[], Acc extends str
 type TStringReduceMany<T extends string[][]> = T extends [infer L extends string[], infer R extends string[], ...infer Rest extends string[][]] ? TStringReduceMany<[TStringReduceBinary<L, R>, ...Rest]> : T;
 type TStringReduce<T extends string[][], O = TStringReduceMany<T>> = 0 extends keyof O ? Assert<O[0], string[]> : [];
 type TFromTemplateLiteralUnionKinds<T extends TTemplateLiteralKind[]> = T extends [infer L extends TLiteral, ...infer R extends TLiteral[]] ? [`${L['const']}`, ...TFromTemplateLiteralUnionKinds<R>] : [];
-type TFromTemplateLiteralKinds<T extends TTemplateLiteralKind[], Acc extends TLiteralValue[][] = []> = T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] ? (L extends TLiteral<infer S extends TLiteralValue> ? TFromTemplateLiteralKinds<R, [...Acc, [S]]> : L extends TUnion<infer S extends TTemplateLiteralKind[]> ? TFromTemplateLiteralKinds<R, [...Acc, TFromTemplateLiteralUnionKinds<S>]> : L extends TBoolean ? TFromTemplateLiteralKinds<R, [...Acc, ['true', 'false']]> : Acc) : Acc;
+type TFromTemplateLiteralKinds<T extends TTemplateLiteralKind[], Acc extends TLiteralValue[][] = []> = T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] ? (L extends TTemplateLiteral<infer S extends TTemplateLiteralKind[]> ? TFromTemplateLiteralKinds<[...S, ...R], Acc> : L extends TLiteral<infer S extends TLiteralValue> ? TFromTemplateLiteralKinds<R, [...Acc, [S]]> : L extends TUnion<infer S extends TTemplateLiteralKind[]> ? TFromTemplateLiteralKinds<R, [...Acc, TFromTemplateLiteralUnionKinds<S>]> : L extends TBoolean ? TFromTemplateLiteralKinds<R, [...Acc, ['true', 'false']]> : Acc) : Acc;
 export declare function TemplateLiteralExpressionGenerate(expression: Expression): IterableIterator<string>;
 export type TTemplateLiteralGenerate<T extends TTemplateLiteral, F = TIsTemplateLiteralFinite<T>> = F extends true ? (T extends TTemplateLiteral<infer S extends TTemplateLiteralKind[]> ? TFromTemplateLiteralKinds<S> extends infer R extends string[][] ? TStringReduce<R> : [] : []) : [];
 /** Generates a tuple of strings from the given TemplateLiteral. Returns an empty tuple if infinite. */

package/build/esm/type/transform/transform.mjs

@@ -8,7 +8,6 @@ import { IsTransform } from '../guard/kind.mjs';
 // TransformBuilders
 // ------------------------------------------------------------------
 export class TransformDecodeBuilder {
-    schema;
     constructor(schema) {
         this.schema = schema;
     }
@@ -18,8 +17,6 @@ export class TransformDecodeBuilder {
 }
 // prettier-ignore
 export class TransformEncodeBuilder {
-    schema;
-    decode;
     constructor(schema, decode) {
         this.schema = schema;
         this.decode = decode;

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

@@ -1,6 +1,6 @@
 export { JsonTypeBuilder } from './json.mjs';
 import { JavaScriptTypeBuilder } from './javascript.mjs';
 /** JavaScript Type Builder with Static Resolution for TypeScript */
-declare const Type: JavaScriptTypeBuilder;
+declare const Type: InstanceType<typeof JavaScriptTypeBuilder>;
 export { JavaScriptTypeBuilder };
 export { Type };

package/build/esm/value/cast/cast.mjs

@@ -9,7 +9,6 @@ import { Deref } from '../deref/index.mjs';
 // Errors
 // ------------------------------------------------------------------
 export class ValueCastError extends TypeBoxError {
-    schema;
     constructor(schema, message) {
         super(message);
         this.schema = schema;

package/build/esm/value/check/check.mjs

@@ -19,7 +19,6 @@ import { IsSchema } from '../../type/guard/type.mjs';
 // Errors
 // ------------------------------------------------------------------
 export class ValueCheckUnknownTypeError extends TypeBoxError {
-    schema;
     constructor(schema) {
         super(`Unknown type`);
         this.schema = schema;

package/build/esm/value/create/create.mjs

@@ -11,7 +11,6 @@ import { TypeBoxError } from '../../type/error/index.mjs';
 // Errors
 // ------------------------------------------------------------------
 export class ValueCreateError extends TypeBoxError {
-    schema;
     constructor(schema, message) {
         super(message);
         this.schema = schema;

package/build/esm/value/delta/delta.mjs

@@ -26,14 +26,12 @@ export const Edit = Union([Insert, Update, Delete]);
 // Errors
 // ------------------------------------------------------------------
 export class ValueDeltaError extends TypeBoxError {
-    value;
     constructor(value, message) {
         super(message);
         this.value = value;
     }
 }
 export class ValueDeltaSymbolError extends ValueDeltaError {
-    value;
     constructor(value) {
         super(value, 'Cannot diff objects with symbol keys');
         this.value = value;

package/build/esm/value/deref/deref.mjs

@@ -1,7 +1,6 @@
 import { TypeBoxError } from '../../type/error/index.mjs';
 import { Kind } from '../../type/symbols/index.mjs';
 export class TypeDereferenceError extends TypeBoxError {
-    schema;
     constructor(schema) {
         super(`Unable to dereference schema with $id '${schema.$id}'`);
         this.schema = schema;

package/build/esm/value/hash/hash.mjs

@@ -4,7 +4,6 @@ import { TypeBoxError } from '../../type/error/index.mjs';
 // Errors
 // ------------------------------------------------------------------
 export class ValueHashError extends TypeBoxError {
-    value;
     constructor(value) {
         super(`Unable to hash value`);
         this.value = value;

package/build/esm/value/pointer/pointer.mjs

@@ -3,9 +3,6 @@ import { TypeBoxError } from '../../type/error/index.mjs';
 // Errors
 // ------------------------------------------------------------------
 export class ValuePointerRootSetError extends TypeBoxError {
-    value;
-    path;
-    update;
     constructor(value, path, update) {
         super('Cannot set root value');
         this.value = value;
@@ -14,8 +11,6 @@ export class ValuePointerRootSetError extends TypeBoxError {
     }
 }
 export class ValuePointerRootDeleteError extends TypeBoxError {
-    value;
-    path;
     constructor(value, path) {
         super('Cannot delete root value');
         this.value = value;

package/build/esm/value/transform/decode.mjs

@@ -17,9 +17,6 @@ import { IsTransform, IsSchema } from '../../type/guard/type.mjs';
 // thrown externally
 // prettier-ignore
 export class TransformDecodeCheckError extends TypeBoxError {
-    schema;
-    value;
-    error;
     constructor(schema, value, error) {
         super(`Unable to decode value as it does not match the expected schema`);
         this.schema = schema;
@@ -29,10 +26,6 @@ export class TransformDecodeCheckError extends TypeBoxError {
 }
 // prettier-ignore
 export class TransformDecodeError extends TypeBoxError {
-    schema;
-    path;
-    value;
-    error;
     constructor(schema, path, value, error) {
         super(error instanceof Error ? error.message : 'Unknown error');
         this.schema = schema;

package/build/esm/value/transform/encode.mjs

@@ -16,9 +16,6 @@ import { IsTransform, IsSchema } from '../../type/guard/type.mjs';
 // ------------------------------------------------------------------
 // prettier-ignore
 export class TransformEncodeCheckError extends TypeBoxError {
-    schema;
-    value;
-    error;
     constructor(schema, value, error) {
         super(`The encoded value does not match the expected schema`);
         this.schema = schema;
@@ -28,10 +25,6 @@ export class TransformEncodeCheckError extends TypeBoxError {
 }
 // prettier-ignore
 export class TransformEncodeError extends TypeBoxError {
-    schema;
-    path;
-    value;
-    error;
     constructor(schema, path, value, error) {
         super(`${error instanceof Error ? error.message : 'Unknown error'}`);
         this.schema = schema;

package/package.json

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