@sinclair/typebox 0.30.0-dev-4 → 0.30.0-dev-5

package/package.json

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

package/readme.md

@@ -63,7 +63,7 @@ type T = Static<typeof T>                            // type T = {
 
 ## Overview
 
-TypeBox is a runtime type builder that creates in-memory JSON Schema objects that can be statically inferred as TypeScript types. The schemas produced by this library are designed to match the static type assertion rules of the TypeScript compiler. TypeBox enables one to create a unified type that can be statically checked by TypeScript and runtime asserted using standard JSON Schema validation.
+TypeBox is a runtime type builder that creates in-memory JSON Schema objects that can be statically inferred as TypeScript types. The schemas produced by this library are designed to match the static type assertion rules of the TypeScript language. TypeBox allows one to create a unified type that can be statically checked by TypeScript and runtime asserted using standard JSON Schema validation.
 
 This library is designed to enable JSON schema to compose with the same flexibility as TypeScript's type system. It can be used as a simple tool to build up complex schemas or integrated into REST or RPC services to help validate data received over the wire.
 
@@ -72,6 +72,7 @@ License MIT
 ## Contents
 - [Install](#install)
 - [Overview](#overview)
+- [Features](#features)
 - [Usage](#usage)
 - [Types](#types)
   - [Standard](#types-standard)
@@ -102,7 +103,6 @@ License MIT
   - [Errors](#values-errors)
   - [Mutate](#values-mutate)
   - [Pointer](#values-pointer)
-  - [Transform](#values-transform)
 - [TypeCheck](#typecheck)
   - [Ajv](#typecheck-ajv)
   - [TypeCompiler](#typecheck-typecompiler)
@@ -110,7 +110,7 @@ License MIT
   - [Types](#typesystem-types)
   - [Formats](#typesystem-formats)
   - [Policies](#typesystem-policies)
-- [Workbench](#workbench)
+- [Transform](#Transform)
 - [Ecosystem](#ecosystem)
 - [Benchmark](#benchmark)
   - [Compile](#benchmark-compile)
@@ -1457,13 +1457,13 @@ TypeSystem.AllowArrayObjects = true
 TypeSystem.AllowNaN = true
 ```
 
-<a name='workbench'></a>
+<a name='transform'></a>
 
-## Workbench
+## TypeBox Transform
 
-TypeBox offers a web based code generation tool that can be used to convert TypeScript types into TypeBox types as well as a variety of other runtime type representations.
+TypeBox offers a small web based code generation tool that can be used to convert TypeScript types into TypeBox types as well as a variety of other runtime type representations.
 
-[Workbench Link Here](https://sinclairzx81.github.io/typebox-workbench/)
+[TypeBox Transform Link Here](https://sinclairzx81.github.io/typebox-transform/)
 
 <a name='ecosystem'></a>
 
@@ -1586,11 +1586,11 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '128.3 kb' │ ' 58.0 kb' │  '2.21 x'   │
-│ typebox/errors       │ '110.5 kb' │ ' 49.5 kb' │  '2.23 x'   │
-│ typebox/system       │ ' 75.4 kb' │ ' 31.2 kb' │  '2.42 x'   │
-│ typebox/value        │ '179.7 kb' │ ' 78.7 kb' │  '2.28 x'   │
-│ typebox              │ ' 74.3 kb' │ ' 30.7 kb' │  '2.42 x'   │
+│ 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'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```
 

package/typebox.d.ts

@@ -104,6 +104,8 @@ export interface TAsyncIterator<T extends TSchema = TSchema> extends TSchema {
     type: 'AsyncIterator';
     items: T;
 }
+export type TAwaitedRest<T extends TSchema[]> = T extends [infer L, ...infer R] ? [TAwaited<AssertType<L>>, ...TAwaitedRest<AssertRest<R>>] : [];
+export type TAwaited<T extends TSchema> = T extends TIntersect<infer S> ? TIntersect<TAwaitedRest<S>> : T extends TUnion<infer S> ? TUnion<TAwaitedRest<S>> : T extends TPromise<infer S> ? TAwaited<S> : T;
 export interface TBigInt extends TSchema, NumericOptions<bigint> {
     [Kind]: 'BigInt';
     static: bigint;
@@ -276,11 +278,11 @@ export interface TObject<T extends TProperties = TProperties> extends TSchema, O
     properties: T;
     required?: string[];
 }
-export type TOmitArray<T extends TSchema[], K extends keyof any> = AssertRest<{
+export type TOmitProperties<T extends TProperties, K extends keyof any> = Evaluate<AssertProperties<Omit<T, K>>>;
+export type TOmitRest<T extends TSchema[], K extends keyof any> = AssertRest<{
     [K2 in keyof T]: TOmit<AssertType<T[K2]>, K>;
 }>;
-export type TOmitProperties<T extends TProperties, K extends keyof any> = Evaluate<AssertProperties<Omit<T, K>>>;
-export type TOmit<T extends TSchema = TSchema, K extends keyof any = keyof any> = T extends TRecursive<infer S> ? TRecursive<TOmit<S, K>> : T extends TIntersect<infer S> ? TIntersect<TOmitArray<S, K>> : T extends TUnion<infer S> ? TUnion<TOmitArray<S, K>> : T extends TObject<infer S> ? TObject<TOmitProperties<S, K>> : T;
+export type TOmit<T extends TSchema = TSchema, K extends keyof any = keyof any> = T extends TRecursive<infer S> ? TRecursive<TOmit<S, K>> : T extends TIntersect<infer S> ? TIntersect<TOmitRest<S, K>> : T extends TUnion<infer S> ? TUnion<TOmitRest<S, K>> : T extends TObject<infer S> ? TObject<TOmitProperties<S, K>> : T;
 export type TParameters<T extends TFunction> = Ensure<TTuple<T['parameters']>>;
 export type TPartialObjectArray<T extends TObject[]> = AssertRest<{
     [K in keyof T]: TPartial<AssertType<T[K], TObject>>;
@@ -292,13 +294,13 @@ export type TPartialProperties<T extends TProperties> = Evaluate<AssertPropertie
     [K in keyof T]: TOptional<T[K]>;
 }>>;
 export type TPartial<T extends TSchema> = T extends TRecursive<infer S> ? TRecursive<TPartial<S>> : T extends TIntersect<infer S> ? TIntersect<TPartialArray<S>> : T extends TUnion<infer S> ? TUnion<TPartialArray<S>> : T extends TObject<infer S> ? TObject<TPartialProperties<S>> : T;
-export type TPickArray<T extends TSchema[], K extends keyof any> = {
-    [K2 in keyof T]: TPick<AssertType<T[K2]>, K>;
-};
 export type TPickProperties<T extends TProperties, K extends keyof any> = Pick<T, Assert<Extract<K, keyof T>, keyof T>> extends infer R ? ({
     [K in keyof R]: AssertType<R[K]> extends TSchema ? R[K] : never;
 }) : never;
-export type TPick<T extends TSchema = TSchema, K extends keyof any = keyof any> = T extends TRecursive<infer S> ? TRecursive<TPick<S, K>> : T extends TIntersect<infer S> ? TIntersect<TPickArray<S, K>> : T extends TUnion<infer S> ? TUnion<TPickArray<S, K>> : T extends TObject<infer S> ? TObject<TPickProperties<S, K>> : T;
+export type TPickRest<T extends TSchema[], K extends keyof any> = {
+    [K2 in keyof T]: TPick<AssertType<T[K2]>, K>;
+};
+export type TPick<T extends TSchema = TSchema, K extends keyof any = keyof any> = T extends TRecursive<infer S> ? TRecursive<TPick<S, K>> : T extends TIntersect<infer S> ? TIntersect<TPickRest<S, K>> : T extends TUnion<infer S> ? TUnion<TPickRest<S, K>> : T extends TObject<infer S> ? TObject<TPickProperties<S, K>> : T;
 export interface TPromise<T extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Promise';
     static: Promise<Static<T, this['params']>>;
@@ -685,6 +687,8 @@ export declare class StandardTypeBuilder extends TypeBuilder {
     Array<T extends TSchema>(items: T, options?: ArrayOptions): TArray<T>;
     /** `[Standard]` Creates a Boolean type */
     Boolean(options?: SchemaOptions): TBoolean;
+    /** `[Standard]` Maps a literal strings first character to uppercase */
+    Capitalize<T extends TLiteral<string>>(schema: T, options?: SchemaOptions): TLiteral<Capitalize<T['const']>>;
     /** `[Standard]` Creates a Composite object type. */
     Composite<T extends TObject[]>(objects: [...T], options?: ObjectOptions): TComposite<T>;
     /** `[Standard]` Creates a Enum type */
@@ -720,6 +724,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]` Maps a literal string to lowercase */
+    Lowercase<T extends TLiteral<string>>(schema: T, options?: SchemaOptions): TLiteral<Lowercase<T['const']>>;
     /** `[Standard]` Creates a Never type */
     Never(options?: SchemaOptions): TNever;
     /** `[Standard]` Creates a Not type */
@@ -780,6 +786,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]` Maps a literal strings first character to lowercase */
+    Uncapitalize<T extends TLiteral<string>>(schema: T, options?: SchemaOptions): TLiteral<Uncapitalize<T['const']>>;
     /** `[Standard]` Creates a Union type */
     Union(anyOf: [], options?: SchemaOptions): TNever;
     /** `[Standard]` Creates a Union type */
@@ -792,10 +800,14 @@ export declare class StandardTypeBuilder extends TypeBuilder {
     Unknown(options?: SchemaOptions): TUnknown;
     /** `[Standard]` Creates a Unsafe type that infers for the generic argument */
     Unsafe<T>(options?: UnsafeOptions): TUnsafe<T>;
+    /** `[Standard]` Maps a literal string to uppercase */
+    Uppercase<T extends TLiteral<string>>(schema: T, options?: SchemaOptions): TLiteral<Uppercase<T['const']>>;
 }
 export declare class ExtendedTypeBuilder extends StandardTypeBuilder {
     /** `[Extended]` Creates a AsyncIterator type */
     AsyncIterator<T extends TSchema>(items: T, options?: SchemaOptions): TAsyncIterator<T>;
+    /** `[Extended]` Recursively unwraps Promise from the given type. */
+    Awaited<T extends TSchema>(schema: T, options?: SchemaOptions): TAwaited<T>;
     /** `[Extended]` Creates a BigInt type */
     BigInt(options?: NumericOptions<bigint>): TBigInt;
     /** `[Extended]` Extracts the ConstructorParameters from the given Constructor type */

package/typebox.js

@@ -222,12 +222,12 @@ var TypeGuard;
             schema.type === 'array' &&
             IsOptionalString(schema.$id) &&
             TSchema(schema.items) &&
-            IsOptionalSchema(schema.contains) &&
-            IsOptionalNumber(schema.minContains) &&
-            IsOptionalNumber(schema.maxContains) &&
             IsOptionalNumber(schema.minItems) &&
             IsOptionalNumber(schema.maxItems) &&
-            IsOptionalBoolean(schema.uniqueItems));
+            IsOptionalBoolean(schema.uniqueItems) &&
+            IsOptionalSchema(schema.contains) &&
+            IsOptionalNumber(schema.minContains) &&
+            IsOptionalNumber(schema.maxContains));
     }
     TypeGuard.TArray = TArray;
     /** Returns true if the given schema is TAsyncIterator */
@@ -1952,6 +1952,11 @@ class StandardTypeBuilder extends TypeBuilder {
     Boolean(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Boolean', type: 'boolean' });
     }
+    /** `[Standard]` Maps a literal strings first character to uppercase */
+    Capitalize(schema, options = {}) {
+        const [first, rest] = [schema.const.slice(0, 1), schema.const.slice(1)];
+        return exports.Type.Literal(`${first.toUpperCase()}${rest}`, options);
+    }
     /** `[Standard]` Creates a Composite object type. */
     Composite(objects, options) {
         const intersect = exports.Type.Intersect(objects, {});
@@ -2070,6 +2075,10 @@ class StandardTypeBuilder extends TypeBuilder {
     Literal(value, options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Literal', const: value, type: typeof value });
     }
+    /** `[Standard]` Maps a literal string to lowercase */
+    Lowercase(schema, options = {}) {
+        return exports.Type.Literal(schema.const.toLowerCase(), options);
+    }
     /** `[Standard]` Creates a Never type */
     Never(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Never', not: {} });
@@ -2237,6 +2246,11 @@ class StandardTypeBuilder extends TypeBuilder {
             { ...options, [exports.Kind]: 'Tuple', type: 'array', minItems, maxItems });
         return this.Create(schema);
     }
+    /** `[Standard]` Maps a literal strings first character to lowercase */
+    Uncapitalize(schema, options = {}) {
+        const [first, rest] = [schema.const.slice(0, 1), schema.const.slice(1)];
+        return exports.Type.Literal(`${first.toLocaleLowerCase()}${rest}`, options);
+    }
     Union(union, options = {}) {
         if (TypeGuard.TTemplateLiteral(union)) {
             return TemplateLiteralResolver.Resolve(union);
@@ -2259,6 +2273,10 @@ class StandardTypeBuilder extends TypeBuilder {
     Unsafe(options = {}) {
         return this.Create({ ...options, [exports.Kind]: options[exports.Kind] || 'Unsafe' });
     }
+    /** `[Standard]` Maps a literal string to uppercase */
+    Uppercase(schema, options = {}) {
+        return exports.Type.Literal(schema.const.toUpperCase(), options);
+    }
 }
 exports.StandardTypeBuilder = StandardTypeBuilder;
 // --------------------------------------------------------------------------
@@ -2269,6 +2287,20 @@ class ExtendedTypeBuilder extends StandardTypeBuilder {
     AsyncIterator(items, options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'AsyncIterator', type: 'AsyncIterator', items: TypeClone.Clone(items) });
     }
+    /** `[Extended]` Recursively unwraps Promise from the given type. */
+    Awaited(schema, options = {}) {
+        const AwaitedRest = (rest) => {
+            if (rest.length === 0)
+                return rest;
+            const [L, ...R] = rest;
+            return [this.Awaited(L), ...AwaitedRest(R)];
+        };
+        // prettier-ignore
+        return (TypeGuard.TIntersect(schema) ? exports.Type.Intersect(AwaitedRest(schema.allOf)) :
+            TypeGuard.TUnion(schema) ? exports.Type.Union(AwaitedRest(schema.anyOf)) :
+                TypeGuard.TPromise(schema) ? this.Awaited(schema.item) :
+                    TypeClone.Clone(schema, options));
+    }
     /** `[Extended]` Creates a BigInt type */
     BigInt(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'BigInt', type: 'bigint' });

package/value/convert.js

@@ -280,7 +280,7 @@ function TUnknown(schema, references, value) {
 function TVoid(schema, references, value) {
     return value;
 }
-function TUserDefined(schema, references, value) {
+function TKind(schema, references, value) {
     return value;
 }
 function Visit(schema, references, value) {
@@ -348,7 +348,7 @@ function Visit(schema, references, value) {
         default:
             if (!Types.TypeRegistry.Has(schema_[Types.Kind]))
                 throw new ValueConvertUnknownTypeError(schema_);
-            return TUserDefined(schema_, references_, value);
+            return TKind(schema_, references_, value);
     }
 }
 /** Converts any type mismatched values to their target type if a reasonable conversion is possible. */