@sinclair/typebox 0.24.18 → 0.24.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.24.18",
+  "version": "0.24.19",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "json-schema",

package/readme.md

@@ -492,28 +492,28 @@ Use `Type.Recursive(...)` to create recursive types.
 
 ```typescript
 const Node = Type.Recursive(Node => Type.Object({    // const Node = {
-  id: Type.String(),                                 //   $id: "Node",
-  nodes: Type.Array(Node)                            //   type: "object",
+  id: Type.String(),                                 //   $id: 'Node',
+  nodes: Type.Array(Node)                            //   type: 'object',
 }), { $id: 'Node' })                                 //   properties: {
                                                      //     id: {
-                                                     //       "type": "string"
+                                                     //       type: 'string'
                                                      //     },
                                                      //     nodes: {
-                                                     //       type: "array",
+                                                     //       type: 'array',
                                                      //       items: {
-                                                     //         $ref: "Node"
+                                                     //         $ref: 'Node'
                                                      //       }
                                                      //     }
                                                      //   },
                                                      //   required: [
-                                                     //     "id",
-                                                     //     "nodes"
+                                                     //     'id',
+                                                     //     'nodes'
                                                      //   ]
                                                      // }
 
 type Node = Static<typeof Node>                      // type Node = {
                                                      //   id: string
-                                                     //   nodes: ...[]
+                                                     //   nodes: Node[]
                                                      // }
 
 function test(node: Node) {
@@ -650,7 +650,7 @@ The following table shows the TypeBox mappings between TypeScript and JSON schem
 │   Type.Union([                 │   'a' | 'b' | 'c',          │   anyOf: [{                    │
 │     Type.Literal('a'),         │   'a'                       │     const: 'b',                │
 │     Type.Literal('b'),         │ >                           │     type: 'string'             │
-│     Type.Literal('c'),         │                             │   }, {                         │
+│     Type.Literal('c')          │                             │   }, {                         │
 │   ]),                          │                             │     const: 'c',                │
 │   Type.Union([                 │                             │     type: 'string'             │
 │     Type.Literal('a')          │                             │   }]                           │

package/typebox.d.ts

@@ -107,9 +107,12 @@ export interface TIntersect<T extends TObject[] = TObject[]> extends TObject {
     static: IntersectReduce<unknown, IntersectEvaluate<T, this['params']>>;
     properties: Record<keyof IntersectReduce<unknown, IntersectEvaluate<T, this['params']>>, TSchema>;
 }
-declare type UnionToIntersect<U> = (U extends unknown ? (arg: U) => 0 : never) extends (arg: infer I) => 0 ? I : never;
-declare type UnionLast<U> = UnionToIntersect<U extends unknown ? (x: U) => 0 : never> extends (x: infer L) => 0 ? L : never;
-declare type UnionToTuple<U, L = UnionLast<U>> = [U] extends [never] ? [] : [...UnionToTuple<Exclude<U, L>>, L];
+export declare type UnionToIntersect<U> = (U extends unknown ? (arg: U) => 0 : never) extends (arg: infer I) => 0 ? I : never;
+export declare type UnionLast<U> = UnionToIntersect<U extends unknown ? (x: U) => 0 : never> extends (x: infer L) => 0 ? L : never;
+export declare type UnionToTuple<U, L = UnionLast<U>> = [U] extends [never] ? [] : [...UnionToTuple<Exclude<U, L>>, L];
+export declare type UnionStringLiteralToTuple<T> = T extends TUnion<infer L> ? {
+    [I in keyof L]: L[I] extends TLiteral<infer C> ? C : never;
+} : never;
 export declare type TKeyOf<T extends TObject> = {
     [K in ObjectPropertyKeys<T>]: TLiteral<K>;
 } extends infer R ? UnionToTuple<R[keyof R]> : never;
@@ -324,13 +327,17 @@ export declare class TypeBuilder {
     /** Creates an object type with the given properties */
     Object<T extends TProperties>(properties: T, options?: ObjectOptions): TObject<T>;
     /** Creates a new object whose properties are omitted from the given object */
-    Omit<T extends TObject, Properties extends Array<ObjectPropertyKeys<T>>>(schema: T, keys: [...Properties], options?: ObjectOptions): TOmit<T, Properties>;
+    Omit<T extends TObject, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: ObjectOptions): TOmit<T, UnionStringLiteralToTuple<K>>;
+    /** Creates a new object whose properties are omitted from the given object */
+    Omit<T extends TObject, K extends ObjectPropertyKeys<T>[]>(schema: T, keys: [...K], options?: ObjectOptions): TOmit<T, K>;
     /** Creates a tuple type from this functions parameters */
     Parameters<T extends TFunction<any[], any>>(schema: T, options?: SchemaOptions): TParameters<T>;
     /** Creates an object type whose properties are all optional */
     Partial<T extends TObject>(schema: T, options?: ObjectOptions): TPartial<T>;
-    /** Creates a new object whose properties are picked from the given object */
-    Pick<T extends TObject, Properties extends Array<ObjectPropertyKeys<T>>>(schema: T, keys: [...Properties], options?: ObjectOptions): TPick<T, Properties>;
+    /** Creates a object whose properties are picked from the given object */
+    Pick<T extends TObject, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: ObjectOptions): TPick<T, UnionStringLiteralToTuple<K>>;
+    /** Creates a object whose properties are picked from the given object */
+    Pick<T extends TObject, K extends ObjectPropertyKeys<T>[]>(schema: T, keys: [...K], options?: ObjectOptions): TPick<T, K>;
     /** Creates a promise type. This type cannot be represented in schema. */
     Promise<T extends TSchema>(item: T, options?: SchemaOptions): TPromise<T>;
     /** Creates an object whose properties are derived from the given string literal union. */
@@ -372,4 +379,3 @@ export declare class TypeBuilder {
 }
 /** JSON Schema Type Builder with Static Type Resolution for TypeScript */
 export declare const Type: TypeBuilder;
-export {};

package/typebox.js

@@ -179,10 +179,11 @@ class TypeBuilder {
     }
     /** Creates a new object whose properties are omitted from the given object */
     Omit(schema, keys, options = {}) {
+        const select = keys[exports.Kind] === 'Union' ? keys.anyOf.map((schema) => schema.const) : keys;
         const next = { ...this.Clone(schema), ...options, [exports.Hint]: 'Omit' };
-        next.required = next.required ? next.required.filter((key) => !keys.includes(key)) : undefined;
+        next.required = next.required ? next.required.filter((key) => !select.includes(key)) : undefined;
         for (const key of Object.keys(next.properties)) {
-            if (keys.includes(key))
+            if (select.includes(key))
                 delete next.properties[key];
         }
         return this.Create(next);
@@ -215,12 +216,13 @@ class TypeBuilder {
         }
         return this.Create(next);
     }
-    /** Creates a new object whose properties are picked from the given object */
+    /** Creates a object whose properties are picked from the given object */
     Pick(schema, keys, options = {}) {
+        const select = keys[exports.Kind] === 'Union' ? keys.anyOf.map((schema) => schema.const) : keys;
         const next = { ...this.Clone(schema), ...options, [exports.Hint]: 'Pick' };
-        next.required = next.required ? next.required.filter((key) => keys.includes(key)) : undefined;
+        next.required = next.required ? next.required.filter((key) => select.includes(key)) : undefined;
         for (const key of Object.keys(next.properties)) {
-            if (!keys.includes(key))
+            if (!select.includes(key))
                 delete next.properties[key];
         }
         return this.Create(next);