@sinclair/typebox 0.27.7 → 0.27.9

package/typebox.d.ts

@@ -134,17 +134,13 @@ export interface TEnum<T extends Record<string, string | number> = Record<string
     anyOf: TLiteral<string | number>[];
 }
 export type TExtends<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema> = (Static<L> extends Static<R> ? T : U) extends infer O ? UnionToTuple<O> extends [infer X, infer Y] ? TUnion<[Assert<X, TSchema>, Assert<Y, TSchema>]> : Assert<O, TSchema> : never;
-export type TExcludeTemplateLiteralResult<T extends string> = TUnionResult<Assert<UnionToTuple<{
-    [K in T]: TLiteral<K>;
-}[T]>, TSchema[]>>;
+export type TExcludeTemplateLiteralResult<T extends string> = TString;
 export type TExcludeTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = Exclude<Static<T>, Static<U>> extends infer S ? TExcludeTemplateLiteralResult<Assert<S, string>> : never;
 export type TExcludeArray<T extends TSchema[], U extends TSchema> = Assert<UnionToTuple<{
     [K in keyof T]: Static<Assert<T[K], TSchema>> extends Static<U> ? never : T[K];
 }[number]>, TSchema[]> extends infer R ? TUnionResult<Assert<R, TSchema[]>> : never;
 export type TExclude<T extends TSchema, U extends TSchema> = T extends TTemplateLiteral ? TExcludeTemplateLiteral<T, U> : T extends TUnion<infer S> ? TExcludeArray<S, U> : T extends U ? TNever : T;
-export type TExtractTemplateLiteralResult<T extends string> = TUnionResult<Assert<UnionToTuple<{
-    [K in T]: TLiteral<K>;
-}[T]>, TSchema[]>>;
+export type TExtractTemplateLiteralResult<T extends string> = TString;
 export type TExtractTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = Extract<Static<T>, Static<U>> extends infer S ? TExtractTemplateLiteralResult<Assert<S, string>> : never;
 export type TExtractArray<T extends TSchema[], U extends TSchema> = Assert<UnionToTuple<{
     [K in keyof T]: Static<Assert<T[K], TSchema>> extends Static<U> ? T[K] : never;
@@ -377,9 +373,7 @@ export type TUnionOfLiteralArray<T extends TLiteral<string>[]> = {
 }[number];
 export type TUnionOfLiteral<T extends TUnion<TLiteral<string>[]>> = TUnionOfLiteralArray<T['anyOf']>;
 export type TUnionResult<T extends TSchema[]> = T extends [] ? TNever : T extends [infer S] ? S : TUnion<T>;
-export type TUnionTemplateLiteral<T extends TTemplateLiteral, S extends string = Static<T>> = Ensure<TUnionResult<Assert<UnionToTuple<{
-    [K in S]: TLiteral<K>;
-}[S]>, TLiteral[]>>>;
+export type TUnionTemplateLiteral<T extends TTemplateLiteral, S extends string = Static<T>> = (string);
 export interface TUnion<T extends TSchema[] = TSchema[]> extends TSchema {
     [Kind]: 'Union';
     static: {

package/typebox.js

@@ -1394,20 +1394,26 @@ var TypeClone;
 var ObjectMap;
 (function (ObjectMap) {
     function Intersect(schema, callback) {
+        // prettier-ignore
         return exports.Type.Intersect(schema.allOf.map((inner) => Visit(inner, callback)), { ...schema });
     }
     function Union(schema, callback) {
+        // prettier-ignore
         return exports.Type.Union(schema.anyOf.map((inner) => Visit(inner, callback)), { ...schema });
     }
     function Object(schema, callback) {
         return callback(schema);
     }
     function Visit(schema, callback) {
-        if (TypeGuard.TIntersect(schema))
+        // There are cases where users need to map objects with unregistered kinds. Using a TypeGuard here would
+        // prevent sub schema mapping as unregistered kinds will not pass TSchema checks. This is notable in the
+        // case of TObject where unregistered property kinds cause the TObject check to fail. As mapping is only
+        // used for composition, we use explicit checks instead.
+        if (schema[exports.Kind] === 'Intersect')
             return Intersect(schema, callback);
-        if (TypeGuard.TUnion(schema))
+        if (schema[exports.Kind] === 'Union')
             return Union(schema, callback);
-        if (TypeGuard.TObject(schema))
+        if (schema[exports.Kind] === 'Object')
             return Object(schema, callback);
         return schema;
     }

package/value/convert.js

@@ -140,7 +140,7 @@ var ValueConvert;
         return IsStringNumeric(value) ? globalThis.BigInt(parseInt(value)) : IsNumber(value) ? globalThis.BigInt(value | 0) : IsValueFalse(value) ? 0 : IsValueTrue(value) ? 1 : value;
     }
     function TryConvertString(value) {
-        return IsValueToString(value) ? value.toString() : IsSymbol(value) && value.description !== undefined ? value.description.toString() : value;
+        return IsValueToString(value) ? value.toString() : value;
     }
     function TryConvertNumber(value) {
         return IsStringNumeric(value) ? parseFloat(value) : IsValueTrue(value) ? 1 : IsValueFalse(value) ? 0 : value;