typebox 1.0.68 → 1.0.70

package/build/schema/static/schema.d.mts

@@ -49,5 +49,7 @@ type TKeywordsIntersected<Schemas extends unknown[], Result extends unknown = un
 type TKeywordsEvaluated<Schema extends unknown, Result extends unknown = Schema extends object ? {
     [Key in keyof Schema]: Schema[Key];
 } : Schema> = Result;
-export type XStaticSchema<Stack extends string[], Root extends XSchema, Schema extends XSchema, Keywords extends unknown[] = TFromKeywords<Stack, Root, Schema>, Intersected extends unknown = TKeywordsIntersected<Keywords>, Evaluated extends unknown = TKeywordsEvaluated<Intersected>> = Evaluated;
+export type XStaticObject<Stack extends string[], Root extends XSchema, Schema extends XSchema, Keywords extends unknown[] = TFromKeywords<Stack, Root, Schema>, Intersected extends unknown = TKeywordsIntersected<Keywords>, Evaluated extends unknown = TKeywordsEvaluated<Intersected>> = Evaluated;
+export type XStaticBoolean<Schema extends boolean, Result extends unknown = Schema extends false ? never : unknown> = Result;
+export type XStaticSchema<Stack extends string[], Root extends XSchema, Schema extends XSchema, Result extends unknown = Schema extends boolean ? XStaticBoolean<Schema> : XStaticObject<Stack, Root, Schema>> = Result;
 export {};

package/build/system/memory/discard.mjs

@@ -1,5 +1,5 @@
 // deno-fmt-ignore-file
-import { Metrics } from "./metrics.mjs";
+import { Metrics } from './metrics.mjs';
 import { Clone } from './clone.mjs';
 /** Discards multiple property keys from the given object value */
 export function Discard(value, propertyKeys) {

package/build/system/memory/update.mjs

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Settings } from '../settings/index.mjs';
-import { Metrics } from "./metrics.mjs";
+import { Metrics } from './metrics.mjs';
 import { Clone } from './clone.mjs';
 /**
  * Updates a value with new properties while preserving property enumerability. Use this function to modify

package/build/type/engine/evaluate/distribute.d.mts

@@ -5,8 +5,8 @@ import { type TObject } from '../../types/object.mjs';
 import { type TTuple } from '../../types/tuple.mjs';
 import { type TComposite } from './composite.mjs';
 import { type TNarrow } from './narrow.mjs';
-import { type TEvaluateType } from "./evaluate.mjs";
-import { type TEvaluateIntersect } from "./evaluate.mjs";
+import { type TEvaluateType } from './evaluate.mjs';
+import { type TEvaluateIntersect } from './evaluate.mjs';
 type TCanDistribute<Type extends TSchema> = Type extends TObject | TTuple ? true : false;
 type TDistributeNormalize<Type extends TSchema> = Type extends TIntersect<infer Types extends TSchema[]> ? TEvaluateIntersect<Types> : Type;
 type TDistributeOperation<Left extends TSchema, Right extends TSchema, NormalLeft extends TSchema = TDistributeNormalize<Left>, NormalRight extends TSchema = TDistributeNormalize<Right>, IsObjectLeft extends boolean = TCanDistribute<NormalLeft>, IsObjectRight extends boolean = TCanDistribute<NormalRight>, Result extends TSchema = ([

package/build/type/engine/evaluate/distribute.mjs

@@ -8,8 +8,8 @@ import { IsObject } from '../../types/object.mjs';
 import { IsTuple } from '../../types/tuple.mjs';
 import { Composite } from './composite.mjs';
 import { Narrow } from './narrow.mjs';
-import { EvaluateType } from "./evaluate.mjs";
-import { EvaluateIntersect } from "./evaluate.mjs";
+import { EvaluateType } from './evaluate.mjs';
+import { EvaluateIntersect } from './evaluate.mjs';
 function CanDistribute(type) {
     return IsObject(type) || IsTuple(type);
 }

package/build/type/engine/evaluate/evaluate.d.mts

@@ -1,11 +1,14 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TIntersect } from '../../types/intersect.mjs';
-import { type TUnion } from '../../types/union.mjs';
 import { type TDistribute } from './distribute.mjs';
 import { type TBroaden } from './broaden.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TNever } from '../../types/never.mjs';
 export type TEvaluateIntersect<Types extends TSchema[], Distribution extends TSchema[] = TDistribute<Types>, Result extends TSchema = TBroaden<Distribution>> = Result;
 export declare function EvaluateIntersect<Types extends TSchema[]>(types: [...Types]): TEvaluateIntersect<Types>;
 export type TEvaluateUnion<Types extends TSchema[], Result extends TSchema = TBroaden<Types>> = Result;
 export declare function EvaluateUnion<Types extends TSchema[]>(types: [...Types]): TEvaluateUnion<Types>;
 export type TEvaluateType<Type extends TSchema, Result extends TSchema = (Type extends TIntersect<infer Types extends TSchema[]> ? TEvaluateIntersect<Types> : Type extends TUnion<infer Types extends TSchema[]> ? TEvaluateUnion<Types> : Type)> = Result;
 export declare function EvaluateType<Type extends TSchema>(type: Type): TEvaluateType<Type>;
+export type TEvaluateUnionFast<Types extends TSchema[], Result extends TSchema = (Types extends [infer Type extends TSchema] ? Type : Types extends [] ? TNever : TUnion<Types>)> = Result;
+export declare function EvaluateUnionFast<Types extends TSchema[]>(types: [...Types]): TEvaluateUnionFast<Types>;

package/build/type/engine/evaluate/evaluate.mjs

@@ -1,8 +1,10 @@
 // deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
 import { IsIntersect } from '../../types/intersect.mjs';
-import { IsUnion } from '../../types/union.mjs';
 import { Distribute } from './distribute.mjs';
 import { Broaden } from './broaden.mjs';
+import { Union, IsUnion } from '../../types/union.mjs';
+import { Never } from '../../types/never.mjs';
 export function EvaluateIntersect(types) {
     const distribution = Distribute(types);
     const result = Broaden(distribution);
@@ -17,3 +19,9 @@ export function EvaluateType(type) {
         IsUnion(type) ? EvaluateUnion(type.anyOf) :
             type);
 }
+export function EvaluateUnionFast(types) {
+    const result = (Guard.IsEqual(types.length, 1) ? types[0] :
+        Guard.IsEqual(types.length, 0) ? Never() :
+            Union(types));
+    return result;
+}

package/build/type/engine/evaluate/narrow.d.mts

@@ -1,5 +1,5 @@
 import { TSchema } from '../../types/schema.mjs';
-import { TNever } from "../../types/never.mjs";
-import { TCompare, TCompareResult, ResultLeftInside, ResultRightInside, ResultEqual } from "./compare.mjs";
+import { TNever } from '../../types/never.mjs';
+import { TCompare, TCompareResult, ResultLeftInside, ResultRightInside, ResultEqual } from './compare.mjs';
 export type TNarrow<Left extends TSchema, Right extends TSchema, Result extends TCompareResult = TCompare<Left, Right>> = (Result extends typeof ResultLeftInside ? Left : Result extends typeof ResultRightInside ? Right : Result extends typeof ResultEqual ? Right : TNever);
 export declare function Narrow<Left extends TSchema, Right extends TSchema>(left: Left, right: Right): TNarrow<Left, Right>;

package/build/type/engine/evaluate/narrow.mjs

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../../guard/index.mjs';
-import { Never } from "../../types/never.mjs";
-import { Compare, ResultLeftInside, ResultRightInside, ResultEqual } from "./compare.mjs";
+import { Never } from '../../types/never.mjs';
+import { Compare, ResultLeftInside, ResultRightInside, ResultEqual } from './compare.mjs';
 export function Narrow(left, right) {
     const result = Compare(left, right);
     return (Guard.IsEqual(result, ResultLeftInside) ? left :

package/build/type/engine/indexed/from-tuple.d.mts

@@ -2,12 +2,12 @@ import { type TSchema } from '../../types/schema.mjs';
 import { type TLiteral } from '../../types/literal.mjs';
 import { type TNumber } from '../../types/number.mjs';
 import { type TInteger } from '../../types/integer.mjs';
-import { type TEvaluateUnion } from '../evaluate/evaluate.mjs';
+import { type TEvaluateUnionFast } from '../evaluate/evaluate.mjs';
 import { type TExtends, ExtendsResult } from '../../extends/index.mjs';
 import { type TFormatArrayIndexer } from './array-indexer.mjs';
 type TIndexElementsWithIndexer<Types extends TSchema[], Indexer extends TSchema, Result extends TSchema[] = []> = (Types extends [...infer Left extends TSchema[], infer Right extends TSchema] ? TExtends<{}, TLiteral<Left['length']>, Indexer> extends ExtendsResult.TExtendsTrueLike ? TIndexElementsWithIndexer<Left, Indexer, [Right, ...Result]> : TIndexElementsWithIndexer<Left, Indexer, Result> : Result);
-type TFromTupleWithIndexer<Types extends TSchema[], Indexer extends TSchema, ArrayIndexer extends TSchema = TFormatArrayIndexer<Indexer>, Elements extends TSchema[] = TIndexElementsWithIndexer<Types, ArrayIndexer>, Result extends TSchema = TEvaluateUnion<Elements>> = Result;
-type TFromTupleWithoutIndexer<Types extends TSchema[], Result extends TSchema = TEvaluateUnion<Types>> = Result;
+type TFromTupleWithIndexer<Types extends TSchema[], Indexer extends TSchema, ArrayIndexer extends TSchema = TFormatArrayIndexer<Indexer>, Elements extends TSchema[] = TIndexElementsWithIndexer<Types, ArrayIndexer>, Result extends TSchema = TEvaluateUnionFast<Elements>> = Result;
+type TFromTupleWithoutIndexer<Types extends TSchema[], Result extends TSchema = TEvaluateUnionFast<Types>> = Result;
 export type TFromTuple<Types extends TSchema[], Indexer extends TSchema, Result extends TSchema = (Indexer extends TNumber | TInteger ? TFromTupleWithoutIndexer<Types> : TFromTupleWithIndexer<Types, Indexer>)> = Result;
 export declare function FromTuple<Types extends TSchema[], Indexer extends TSchema>(types: [...Types], indexer: Indexer): TFromTuple<Types, Indexer>;
 export {};

package/build/type/engine/indexed/from-tuple.mjs

@@ -2,7 +2,7 @@
 import { Literal } from '../../types/literal.mjs';
 import { IsNumber } from '../../types/number.mjs';
 import { IsInteger } from '../../types/integer.mjs';
-import { EvaluateUnion } from '../evaluate/evaluate.mjs';
+import { EvaluateUnionFast } from '../evaluate/evaluate.mjs';
 import { Extends, ExtendsResult } from '../../extends/index.mjs';
 import { FormatArrayIndexer } from './array-indexer.mjs';
 function IndexElementsWithIndexer(types, indexer) {
@@ -16,10 +16,10 @@ function IndexElementsWithIndexer(types, indexer) {
 function FromTupleWithIndexer(types, indexer) {
     const formattedArrayIndexer = FormatArrayIndexer(indexer);
     const elements = IndexElementsWithIndexer(types, formattedArrayIndexer);
-    return EvaluateUnion(elements);
+    return EvaluateUnionFast(elements);
 }
 function FromTupleWithoutIndexer(types) {
-    return EvaluateUnion(types);
+    return EvaluateUnionFast(types);
 }
 export function FromTuple(types, indexer) {
     return (IsNumber(indexer) || IsInteger(indexer)

package/build/type/engine/keyof/from-object.d.mts

@@ -3,8 +3,8 @@ import { type TSchema } from '../../types/index.mjs';
 import { type TUnionToTuple } from '../helpers/index.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TLiteral, type TLiteralValue } from '../../types/literal.mjs';
-import { type TEvaluateUnion } from '../evaluate/evaluate.mjs';
+import { type TEvaluateUnionFast } from '../evaluate/evaluate.mjs';
 type TFromPropertyKeys<Keys extends PropertyKey[], Result extends TSchema[] = []> = (Keys extends [infer Left extends PropertyKey, ...infer Right extends PropertyKey[]] ? Left extends TLiteralValue ? TFromPropertyKeys<Right, [...Result, TLiteral<Left>]> : TUnreachable : Result);
-export type TFromObject<Properties extends TProperties, PropertyKeys extends PropertyKey[] = TUnionToTuple<keyof Properties>, Variants extends TSchema[] = TFromPropertyKeys<PropertyKeys>, Result extends TSchema = TEvaluateUnion<Variants>> = Result;
+export type TFromObject<Properties extends TProperties, PropertyKeys extends PropertyKey[] = TUnionToTuple<keyof Properties>, Variants extends TSchema[] = TFromPropertyKeys<PropertyKeys>, Result extends TSchema = TEvaluateUnionFast<Variants>> = Result;
 export declare function FromObject<Properties extends TProperties>(properties: Properties): TFromObject<Properties>;
 export {};

package/build/type/engine/keyof/from-object.mjs

@@ -3,7 +3,7 @@ import { Unreachable } from '../../../system/unreachable/index.mjs';
 import { Guard } from '../../../guard/index.mjs';
 import { Literal, IsLiteralValue } from '../../types/literal.mjs';
 import { ConvertToIntegerKey } from '../helpers/keys.mjs';
-import { EvaluateUnion } from '../evaluate/evaluate.mjs';
+import { EvaluateUnionFast } from '../evaluate/evaluate.mjs';
 function FromPropertyKeys(keys) {
     const result = keys.reduce((result, left) => {
         return IsLiteralValue(left)
@@ -15,6 +15,6 @@ function FromPropertyKeys(keys) {
 export function FromObject(properties) {
     const propertyKeys = Guard.Keys(properties);
     const variants = FromPropertyKeys(propertyKeys);
-    const result = EvaluateUnion(variants);
+    const result = EvaluateUnionFast(variants);
     return result;
 }

package/build/type/engine/keyof/from-tuple.d.mts

@@ -1,5 +1,5 @@
 import { type TSchema } from '../../types/index.mjs';
 import { type TLiteral } from '../../types/literal.mjs';
-import { type TEvaluateUnion } from '../evaluate/evaluate.mjs';
-export type TFromTuple<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [...infer Left extends TSchema[], infer _ extends TSchema] ? TFromTuple<Left, [TLiteral<Left['length']>, ...Result]> : TEvaluateUnion<Result>);
+import { type TEvaluateUnionFast } from '../evaluate/evaluate.mjs';
+export type TFromTuple<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [...infer Left extends TSchema[], infer _ extends TSchema] ? TFromTuple<Left, [TLiteral<Left['length']>, ...Result]> : TEvaluateUnionFast<Result>);
 export declare function FromTuple<Types extends TSchema[]>(types: [...Types]): TFromTuple<Types>;

package/build/type/engine/keyof/from-tuple.mjs

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { Literal } from '../../types/literal.mjs';
-import { EvaluateUnion } from '../evaluate/evaluate.mjs';
+import { EvaluateUnionFast } from '../evaluate/evaluate.mjs';
 export function FromTuple(types) {
     const result = types.map((_, index) => Literal(index));
-    return EvaluateUnion(result);
+    return EvaluateUnionFast(result);
 }

package/build/type/types/record.d.mts

@@ -6,7 +6,9 @@ import { type TNumber } from './number.mjs';
 import { type TString } from './string.mjs';
 import { type TDeferred } from './deferred.mjs';
 import { type TInstantiate } from '../engine/instantiate.mjs';
-export type StaticRecord<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Key extends string, Value extends TSchema, StaticValue extends unknown = StaticType<Stack, Direction, Context, This, Value>, Result extends Record<PropertyKey, unknown> = (Key extends TStringKey ? Record<string, StaticValue> : Key extends TIntegerKey ? Record<number, StaticValue> : Key extends TNumberKey ? Record<number, StaticValue> : Record<string, StaticValue>)> = Result;
+import { type TTemplateLiteralStatic } from '../engine/template-literal/index.mjs';
+type StaticPropertyKey<Key extends string, Result extends PropertyKey = (Key extends TStringKey ? string : Key extends TIntegerKey ? number : Key extends TNumberKey ? number : Key extends `^${string}$` ? TTemplateLiteralStatic<Key> : string)> = Result;
+export type StaticRecord<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Key extends string, Value extends TSchema, StaticKey extends PropertyKey = StaticPropertyKey<Key>, StaticValue extends unknown = StaticType<Stack, Direction, Context, This, Value>> = Record<StaticKey, StaticValue>;
 export type TStringKey = typeof StringKey;
 export type TIntegerKey = typeof IntegerKey;
 export type TNumberKey = typeof NumberKey;
@@ -42,3 +44,4 @@ export type TRecordValue<Type extends TRecord, Result extends TSchema = Type['pa
 export declare function RecordValue<Type extends TRecord>(type: Type): TRecordValue<Type>;
 export declare function IsRecord(value: unknown): value is TRecord;
 export declare function RecordOptions(type: TRecord): TObjectOptions;
+export {};

package/build/value/create/from-type.mjs

@@ -14,7 +14,7 @@ import { FromFunction } from './from-function.mjs';
 import { FromInteger } from './from-integer.mjs';
 import { FromIntersect } from './from-intersect.mjs';
 import { FromIterator } from './from-iterator.mjs';
-import { FromLiteral } from "./from-literal.mjs";
+import { FromLiteral } from './from-literal.mjs';
 import { FromNever } from './from-never.mjs';
 import { FromNull } from './from-null.mjs';
 import { FromNumber } from './from-number.mjs';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
-  "version": "1.0.68",
+  "version": "1.0.70",
   "keywords": [
     "typescript",
     "jsonschema"