@sinclair/typebox 0.30.0 → 0.30.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.30.0",
+  "version": "0.30.2",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

package/readme.md

@@ -84,6 +84,7 @@ License MIT
   - [Recursive](#types-recursive)
   - [Conditional](#types-conditional)
   - [Template Literal](#types-template-literal)
+  - [Intrinsic String](#types-intrinsic-string)
   - [Indexed](#types-indexed)
   - [Negated](#types-negated)
   - [Rest](#types-rest)
@@ -486,6 +487,30 @@ The following table lists the Standard TypeBox types. These types are fully comp
 │ ])                             │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Uncapitalize(   │ type T = Uncapitalize<      │ const T = {                    │
+│   Type.Literal('Hello')        │   'Hello'                   │    type: 'string',             │
+│ )                              │ >                           │    const: 'hello'              │
+│                                │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Capitalize(     │ type T = Capitalize<        │ const T = {                    │
+│   Type.Literal('hello')        │   'hello'                   │    type: 'string',             │
+│ )                              │ >                           │    const: 'Hello'              │
+│                                │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Uppercase(      │ type T = Uppercase<         │ const T = {                    │
+│   Type.Literal('hello')        │   'hello'                   │    type: 'string',             │
+│ )                              │ >                           │    const: 'HELLO'              │
+│                                │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Lowercase(      │ type T = Lowercase<         │ const T = {                    │
+│   Type.Literal('HELLO')        │   'HELLO'                   │    type: 'string',             │
+│ )                              │ >                           │    const: 'hello'              │
+│                                │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Object({        │ type T = {                  │ const R = {                    │
 │    x: Type.Number(),           │   x: number,                │   $ref: 'T'                    │
 │    y: Type.Number()            │   y: number                 │ }                              │
@@ -851,6 +876,34 @@ const R = Type.Record(T, Type.String())              // const R = {
                                                      // }
 ```
 
+<a name='types-intrinsic-string'></a>
+
+### Intrinsic String Types
+
+TypeBox supports a set of intrinsic string mapping functions which can be used on string literals. These functions match the TypeScript string intrinsic types `Uppercase`, `Lowercase`, `Capitalize` and `Uncapitalize`. These functions are supported for literal strings, template literals and union types. The following shows the literal string usage.
+
+```typescript
+// TypeScript
+
+type A = Uncapitalize<'HELLO'>                      // type A = 'hELLO'
+
+type B = Capitalize<'hello'>                        // type B = 'Hello'
+
+type C = Uppercase<'hello'>                         // type C = 'HELLO'
+
+type D = Lowercase<'HELLO'>                         // type D = 'hello'
+
+// TypeBox
+
+const A = Type.Uncapitalize(Type.Literal('HELLO')) // const A: TLiteral<'hELLO'>
+
+const B = Type.Capitalize(Type.Literal('hello'))   // const B: TLiteral<'Hello'>
+
+const C = Type.Uppercase(Type.Literal('hello'))    // const C: TLiteral<'HELLO'>
+
+const D = Type.Lowercase(Type.Literal('HELLO'))    // const D: TLiteral<'hello'>
+```
+
 <a name='types-indexed'></a>
 
 ### Indexed Access Types
@@ -1586,11 +1639,11 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '129.4 kb' │ ' 58.6 kb' │  '2.21 x'   │
-│ typebox/errors       │ '111.6 kb' │ ' 50.1 kb' │  '2.23 x'   │
-│ typebox/system       │ ' 76.5 kb' │ ' 31.7 kb' │  '2.41 x'   │
-│ typebox/value        │ '180.7 kb' │ ' 79.3 kb' │  '2.28 x'   │
-│ typebox              │ ' 75.4 kb' │ ' 31.3 kb' │  '2.41 x'   │
+│ typebox/compiler     │ '131.4 kb' │ ' 59.4 kb' │  '2.21 x'   │
+│ typebox/errors       │ '113.6 kb' │ ' 50.9 kb' │  '2.23 x'   │
+│ typebox/system       │ ' 78.5 kb' │ ' 32.5 kb' │  '2.42 x'   │
+│ typebox/value        │ '182.8 kb' │ ' 80.0 kb' │  '2.28 x'   │
+│ typebox              │ ' 77.4 kb' │ ' 32.0 kb' │  '2.42 x'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```
 

package/typebox.d.ts

@@ -198,6 +198,11 @@ export type TIndexType<T extends TSchema, K extends TPropertyKey> = T extends TR
 export type TIndexRestMany<T extends TSchema, K extends TPropertyKey[]> = K extends [infer L, ...infer R] ? [TIndexType<T, Assert<L, TPropertyKey>>, ...TIndexRestMany<T, Assert<R, TPropertyKey[]>>] : [
 ];
 export type TIndex<T extends TSchema, K extends TPropertyKey[]> = T extends TRecursive<infer S> ? TIndex<S, K> : T extends TIntersect ? UnionType<Flat<TIndexRestMany<T, K>>> : T extends TUnion ? UnionType<Flat<TIndexRestMany<T, K>>> : T extends TObject ? UnionType<Flat<TIndexRestMany<T, K>>> : T extends TTuple ? UnionType<Flat<TIndexRestMany<T, K>>> : TNever;
+export type TIntrinsicMode = 'Uppercase' | 'Lowercase' | 'Capitalize' | 'Uncapitalize';
+export type TIntrinsicTemplateLiteral<T extends TTemplateLiteralKind[], M extends TIntrinsicMode> = M extends ('Lowercase' | 'Uppercase') ? T extends [infer L, ...infer R] ? [TIntrinsic<AssertType<L>, M>, ...TIntrinsicTemplateLiteral<AssertRest<R>, M>] : T : M extends ('Capitalize' | 'Uncapitalize') ? T extends [infer L, ...infer R] ? [TIntrinsic<AssertType<L>, M>, ...R] : T : T;
+export type TIntrinsicLiteral<T, M extends TIntrinsicMode> = T extends string ? M extends 'Uncapitalize' ? Uncapitalize<T> : M extends 'Capitalize' ? Capitalize<T> : M extends 'Uppercase' ? Uppercase<T> : M extends 'Lowercase' ? Lowercase<T> : string : T;
+export type TIntrinsicRest<T extends TSchema[], M extends TIntrinsicMode> = T extends [infer L, ...infer R] ? [TIntrinsic<AssertType<L>, M>, ...TIntrinsicRest<AssertRest<R>, M>] : [];
+export type TIntrinsic<T extends TSchema, M extends TIntrinsicMode> = T extends TTemplateLiteral<infer S> ? TTemplateLiteral<TIntrinsicTemplateLiteral<S, M>> : T extends TUnion<infer S> ? TUnion<TIntrinsicRest<S, M>> : T extends TLiteral<infer S> ? TLiteral<TIntrinsicLiteral<S, M>> : T;
 export interface TInteger extends TSchema, NumericOptions<number> {
     [Kind]: 'Integer';
     static: number;
@@ -626,6 +631,10 @@ export declare namespace TypeClone {
 export declare namespace IndexedAccessor {
     function Resolve(schema: TSchema, keys: TPropertyKey[], options?: SchemaOptions): TSchema;
 }
+export declare namespace Intrinsic {
+    /** Applies an intrinsic string manipulation to the given type. */
+    function Map<T extends TSchema, M extends TIntrinsicMode>(schema: T, mode: M): TIntrinsic<T, M>;
+}
 export declare namespace ObjectMap {
     function Map<T = TSchema>(schema: TSchema, callback: (object: TObject) => TObject, options: SchemaOptions): T;
 }
@@ -705,8 +714,8 @@ export declare class StandardTypeBuilder extends TypeBuilder {
     Array<T extends TSchema>(schema: T, options?: ArrayOptions): TArray<T>;
     /** `[Standard]` Creates a Boolean type */
     Boolean(options?: SchemaOptions): TBoolean;
-    /** `[Standard]` Capitalize a LiteralString type */
-    Capitalize<T extends TLiteral<string>>(schema: T, options?: SchemaOptions): TLiteral<Capitalize<T['const']>>;
+    /** `[Standard]` Intrinsic function to Capitalize LiteralString types */
+    Capitalize<T extends TSchema>(schema: T, options?: SchemaOptions): TIntrinsic<T, 'Capitalize'>;
     /** `[Standard]` Creates a Composite object type */
     Composite<T extends TObject[]>(objects: [...T], options?: ObjectOptions): TComposite<T>;
     /** `[Standard]` Creates a Enum type */
@@ -743,8 +752,8 @@ export declare class StandardTypeBuilder extends TypeBuilder {
     KeyOf<T extends TSchema>(schema: T, options?: SchemaOptions): TKeyOf<T>;
     /** `[Standard]` Creates a Literal type */
     Literal<T extends TLiteralValue>(value: T, options?: SchemaOptions): TLiteral<T>;
-    /** `[Standard]` Lowercase a LiteralString type */
-    Lowercase<T extends TLiteral<string>>(schema: T, options?: SchemaOptions): TLiteral<Lowercase<T['const']>>;
+    /** `[Standard]` Intrinsic function to Lowercase LiteralString types */
+    Lowercase<T extends TSchema>(schema: T, options?: SchemaOptions): TIntrinsic<T, 'Lowercase'>;
     /** `[Standard]` Creates a Never type */
     Never(options?: SchemaOptions): TNever;
     /** `[Standard]` Creates a Not type */
@@ -805,8 +814,8 @@ export declare class StandardTypeBuilder extends TypeBuilder {
     TemplateLiteral<T extends TTemplateLiteralKind[]>(kinds: [...T], options?: SchemaOptions): TTemplateLiteral<T>;
     /** `[Standard]` Creates a Tuple type */
     Tuple<T extends TSchema[]>(items: [...T], options?: SchemaOptions): TTuple<T>;
-    /** `[Standard]` Uncapitalize a LiteralString type */
-    Uncapitalize<T extends TLiteral<string>>(schema: T, options?: SchemaOptions): TLiteral<Uncapitalize<T['const']>>;
+    /** `[Standard]` Intrinsic function to Uncapitalize LiteralString types */
+    Uncapitalize<T extends TSchema>(schema: T, options?: SchemaOptions): TIntrinsic<T, 'Uncapitalize'>;
     /** `[Standard]` Creates a Union type */
     Union(anyOf: [], options?: SchemaOptions): TNever;
     /** `[Standard]` Creates a Union type */
@@ -819,8 +828,8 @@ export declare class StandardTypeBuilder extends TypeBuilder {
     Unknown(options?: SchemaOptions): TUnknown;
     /** `[Standard]` Creates a Unsafe type that will infers as the generic argument T */
     Unsafe<T>(options?: UnsafeOptions): TUnsafe<T>;
-    /** `[Standard]` Uppercase a LiteralString type */
-    Uppercase<T extends TLiteral<string>>(schema: T, options?: SchemaOptions): TLiteral<Uppercase<T['const']>>;
+    /** `[Standard]` Intrinsic function to Uppercase LiteralString types */
+    Uppercase<T extends TSchema>(schema: T, options?: SchemaOptions): TIntrinsic<T, 'Uppercase'>;
 }
 export declare class ExtendedTypeBuilder extends StandardTypeBuilder {
     /** `[Extended]` Creates a AsyncIterator type */

package/typebox.js

@@ -27,7 +27,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Type = exports.StandardType = exports.ExtendedTypeBuilder = exports.StandardTypeBuilder = exports.TypeBuilder = exports.TemplateLiteralDslParser = exports.TemplateLiteralGenerator = exports.TemplateLiteralFinite = exports.TemplateLiteralParser = exports.TemplateLiteralParserError = exports.TemplateLiteralResolver = exports.TemplateLiteralPattern = exports.UnionResolver = exports.KeyArrayResolver = exports.KeyResolver = exports.ObjectMap = exports.IndexedAccessor = exports.TypeClone = exports.TypeExtends = exports.TypeExtendsResult = exports.ExtendsUndefined = exports.TypeGuard = exports.TypeGuardUnknownTypeError = exports.ValueGuard = exports.FormatRegistry = exports.TypeRegistry = exports.PatternStringExact = exports.PatternNumberExact = exports.PatternBooleanExact = exports.PatternString = exports.PatternNumber = exports.PatternBoolean = exports.Kind = exports.Hint = exports.Optional = exports.Readonly = void 0;
+exports.Type = exports.StandardType = exports.ExtendedTypeBuilder = exports.StandardTypeBuilder = exports.TypeBuilder = exports.TemplateLiteralDslParser = exports.TemplateLiteralGenerator = exports.TemplateLiteralFinite = exports.TemplateLiteralParser = exports.TemplateLiteralParserError = exports.TemplateLiteralResolver = exports.TemplateLiteralPattern = exports.UnionResolver = exports.KeyArrayResolver = exports.KeyResolver = exports.ObjectMap = exports.Intrinsic = exports.IndexedAccessor = exports.TypeClone = exports.TypeExtends = exports.TypeExtendsResult = exports.ExtendsUndefined = exports.TypeGuard = exports.TypeGuardUnknownTypeError = exports.ValueGuard = exports.FormatRegistry = exports.TypeRegistry = exports.PatternStringExact = exports.PatternNumberExact = exports.PatternBooleanExact = exports.PatternString = exports.PatternNumber = exports.PatternBoolean = exports.Kind = exports.Hint = exports.Optional = exports.Readonly = void 0;
 // --------------------------------------------------------------------------
 // Symbols
 // --------------------------------------------------------------------------
@@ -477,7 +477,14 @@ var TypeGuard;
     TypeGuard.TRef = TRef;
     /** Returns true if the given schema is TString */
     function TString(schema) {
-        return (TKindOf(schema, 'String') && schema.type === 'string' && IsOptionalString(schema.$id) && IsOptionalNumber(schema.minLength) && IsOptionalNumber(schema.maxLength) && IsOptionalPattern(schema.pattern) && IsOptionalFormat(schema.format));
+        // prettier-ignore
+        return (TKindOf(schema, 'String') &&
+            schema.type === 'string' &&
+            IsOptionalString(schema.$id) &&
+            IsOptionalNumber(schema.minLength) &&
+            IsOptionalNumber(schema.maxLength) &&
+            IsOptionalPattern(schema.pattern) &&
+            IsOptionalFormat(schema.format));
     }
     TypeGuard.TString = TString;
     /** Returns true if the given schema is TSymbol */
@@ -1448,6 +1455,67 @@ var IndexedAccessor;
     IndexedAccessor.Resolve = Resolve;
 })(IndexedAccessor || (exports.IndexedAccessor = IndexedAccessor = {}));
 // --------------------------------------------------------------------------
+// Intrinsic
+// --------------------------------------------------------------------------
+var Intrinsic;
+(function (Intrinsic) {
+    function Uncapitalize(value) {
+        const [first, rest] = [value.slice(0, 1), value.slice(1)];
+        return `${first.toLowerCase()}${rest}`;
+    }
+    function Capitalize(value) {
+        const [first, rest] = [value.slice(0, 1), value.slice(1)];
+        return `${first.toUpperCase()}${rest}`;
+    }
+    function Uppercase(value) {
+        return value.toUpperCase();
+    }
+    function Lowercase(value) {
+        return value.toLowerCase();
+    }
+    function IntrinsicTemplateLiteral(schema, mode) {
+        // note: template literals require special runtime handling as they are encoded in string patterns.
+        // This diverges from the mapped type which would otherwise map on the template literal kind.
+        const expression = TemplateLiteralParser.ParseExact(schema.pattern);
+        const finite = TemplateLiteralFinite.Check(expression);
+        if (!finite)
+            return { ...schema, pattern: IntrinsicLiteral(schema.pattern, mode) };
+        const strings = [...TemplateLiteralGenerator.Generate(expression)];
+        const literals = strings.map((value) => exports.Type.Literal(value));
+        const mapped = IntrinsicRest(literals, mode);
+        const union = exports.Type.Union(mapped);
+        return exports.Type.TemplateLiteral([union]);
+    }
+    function IntrinsicLiteral(value, mode) {
+        // prettier-ignore
+        return typeof value === 'string' ? (mode === 'Uncapitalize' ? Uncapitalize(value) :
+            mode === 'Capitalize' ? Capitalize(value) :
+                mode === 'Uppercase' ? Uppercase(value) :
+                    mode === 'Lowercase' ? Lowercase(value) :
+                        value) : value.toString();
+    }
+    function IntrinsicRest(schema, mode) {
+        if (schema.length === 0)
+            return [];
+        const [L, ...R] = schema;
+        return [Map(L, mode), ...IntrinsicRest(R, mode)];
+    }
+    function Visit(schema, mode) {
+        if (TypeGuard.TTemplateLiteral(schema))
+            return IntrinsicTemplateLiteral(schema, mode);
+        if (TypeGuard.TUnion(schema))
+            return exports.Type.Union(IntrinsicRest(schema.anyOf, mode));
+        if (TypeGuard.TLiteral(schema))
+            return exports.Type.Literal(IntrinsicLiteral(schema.const, mode));
+        return schema;
+    }
+    /** Applies an intrinsic string manipulation to the given type. */
+    function Map(schema, mode) {
+        return Visit(schema, mode);
+    }
+    Intrinsic.Map = Map;
+})(Intrinsic || (exports.Intrinsic = Intrinsic = {}));
+// --------------------------------------------------------------------------
 // ObjectMap
 // --------------------------------------------------------------------------
 var ObjectMap;
@@ -1952,10 +2020,9 @@ class StandardTypeBuilder extends TypeBuilder {
     Boolean(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Boolean', type: 'boolean' });
     }
-    /** `[Standard]` Capitalize a LiteralString type */
+    /** `[Standard]` Intrinsic function to Capitalize LiteralString types */
     Capitalize(schema, options = {}) {
-        const [first, rest] = [schema.const.slice(0, 1), schema.const.slice(1)];
-        return exports.Type.Literal(`${first.toUpperCase()}${rest}`, options);
+        return { ...Intrinsic.Map(TypeClone.Clone(schema), 'Capitalize'), ...options };
     }
     /** `[Standard]` Creates a Composite object type */
     Composite(objects, options) {
@@ -2076,9 +2143,9 @@ class StandardTypeBuilder extends TypeBuilder {
     Literal(value, options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Literal', const: value, type: typeof value });
     }
-    /** `[Standard]` Lowercase a LiteralString type */
+    /** `[Standard]` Intrinsic function to Lowercase LiteralString types */
     Lowercase(schema, options = {}) {
-        return exports.Type.Literal(schema.const.toLowerCase(), options);
+        return { ...Intrinsic.Map(TypeClone.Clone(schema), 'Lowercase'), ...options };
     }
     /** `[Standard]` Creates a Never type */
     Never(options = {}) {
@@ -2249,10 +2316,9 @@ class StandardTypeBuilder extends TypeBuilder {
             { ...options, [exports.Kind]: 'Tuple', type: 'array', minItems, maxItems });
         return this.Create(schema);
     }
-    /** `[Standard]` Uncapitalize a LiteralString type */
+    /** `[Standard]` Intrinsic function to Uncapitalize LiteralString types */
     Uncapitalize(schema, options = {}) {
-        const [first, rest] = [schema.const.slice(0, 1), schema.const.slice(1)];
-        return exports.Type.Literal(`${first.toLocaleLowerCase()}${rest}`, options);
+        return { ...Intrinsic.Map(TypeClone.Clone(schema), 'Uncapitalize'), ...options };
     }
     /** `[Standard]` Creates a Union type */
     Union(union, options = {}) {
@@ -2277,9 +2343,9 @@ class StandardTypeBuilder extends TypeBuilder {
     Unsafe(options = {}) {
         return this.Create({ ...options, [exports.Kind]: options[exports.Kind] || 'Unsafe' });
     }
-    /** `[Standard]` Uppercase a LiteralString type */
+    /** `[Standard]` Intrinsic function to Uppercase LiteralString types */
     Uppercase(schema, options = {}) {
-        return exports.Type.Literal(schema.const.toUpperCase(), options);
+        return { ...Intrinsic.Map(TypeClone.Clone(schema), 'Uppercase'), ...options };
     }
 }
 exports.StandardTypeBuilder = StandardTypeBuilder;