@sinclair/typebox 0.28.6 → 0.28.8

package/package.json

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

package/readme.md

@@ -959,7 +959,7 @@ type T = Static<typeof T>                            // type T = 'A' | 'B' | 'C'
 
 <a name='types-guards'></a>
 
-### Type Gaurds
+### Type Guards
 
 TypeBox provides a `TypeGuard` module that can be used for reflection and asserting values as types.
 

package/typebox.d.ts

@@ -96,20 +96,11 @@ export interface TBoolean extends TSchema {
 }
 export type TConstructorParameters<T extends TConstructor<TSchema[], TSchema>> = TTuple<T['parameters']>;
 export type TInstanceType<T extends TConstructor<TSchema[], TSchema>> = T['returns'];
-export type TCompositeIsOptional<T extends TSchema> = T extends TOptional<T> | TReadonlyOptional<T> ? true : false;
-export type TCompositeOptional<T extends TSchema[]> = T extends [infer L, ...infer R] ? TCompositeIsOptional<AssertType<L>> extends false ? false : TCompositeOptional<AssertRest<R>> : true;
-export type TCompositeKeyOfUnion1<T extends TObject> = keyof T['properties'];
-export type TCompositeKeyOfUnion2<T extends TObject[]> = T extends [infer L, ...infer R] ? TCompositeKeyOfUnion1<Assert<L, TObject>> | TCompositeKeyOfUnion2<Assert<R, TObject[]>> : never;
-export type TCompositeKeyOf<T extends TObject[]> = UnionToTuple<TCompositeKeyOfUnion2<T>>;
-export type TCompositePropertiesWithKey1<T extends TObject, K extends Key> = K extends keyof T['properties'] ? [T['properties'][K]] : [];
-export type TCompositePropertiesWithKey2<T extends TObject[], K extends Key> = T extends [infer L, ...infer R] ? [...TCompositePropertiesWithKey1<Assert<L, TObject>, K>, ...TCompositePropertiesWithKey2<Assert<R, TObject[]>, K>] : [];
-export type TCompositeObjectProperty<T extends TObject[], K extends Key> = TCompositePropertiesWithKey2<T, K> extends infer S ? TCompositeOptional<AssertRest<S>> extends true ? {
-    [_ in K]: TOptional<IntersectType<AssertRest<S>>>;
-} : {
-    [_ in K]: IntersectType<AssertRest<S>>;
-} : {};
-export type TCompositeObjectsWithKeys<T extends TObject[], K extends Key[]> = K extends [infer L, ...infer R] ? L extends Key ? TCompositeObjectProperty<T, L> & TCompositeObjectsWithKeys<T, Assert<R, Key[]>> : {} : {};
-export type TComposite<T extends TObject[]> = Ensure<TObject<Evaluate<TCompositeObjectsWithKeys<T, Assert<TCompositeKeyOf<T>, Key[]>>>>>;
+export type TCompositeReduce<T extends TIntersect<TObject[]>, K extends string[]> = K extends [infer L, ...infer R] ? {
+    [_ in Assert<L, string>]: TIndexType<T, Assert<L, string>>;
+} & TCompositeReduce<T, Assert<R, string[]>> : {};
+export type TCompositeSelect<T extends TIntersect<TObject[]>> = UnionToTuple<keyof Static<T>> extends infer K ? Evaluate<TCompositeReduce<T, Assert<K, string[]>>> : {};
+export type TComposite<T extends TObject[]> = TIntersect<T> extends infer R ? TObject<TCompositeSelect<Assert<R, TIntersect<TObject[]>>>> : TObject<{}>;
 export type TConstructorParameterArray<T extends readonly TSchema[], P extends unknown[]> = [...{
     [K in keyof T]: Static<AssertType<T[K]>, P>;
 }];
@@ -203,7 +194,7 @@ export interface TIntersect<T extends TSchema[] = TSchema[]> extends TSchema, In
     allOf: [...T];
 }
 export type TKeyOfProperties<T extends TSchema> = Static<T> extends infer S ? UnionToTuple<{
-    [K in keyof S]: TLiteral<`${Assert<K, TLiteralValue>}`>;
+    [K in keyof S]: TLiteral<Assert<K, TLiteralValue>>;
 }[keyof S]> : [];
 export type TKeyOfIndicesArray<T extends TSchema[]> = UnionToTuple<keyof T & `${number}`>;
 export type TKeyOfIndices<T extends TSchema[]> = AssertRest<TKeyOfIndicesArray<T> extends infer R ? {

package/typebox.js

@@ -1440,7 +1440,8 @@ var IndexedAccessor;
         return exports.Type.Never();
     }
     function Resolve(schema, keys, options = {}) {
-        return exports.Type.Union(keys.map((key) => Visit(schema, key.toString())));
+        // prettier-ignore
+        return exports.Type.Union(keys.map((key) => Visit(schema, key.toString())), options);
     }
     IndexedAccessor.Resolve = Resolve;
 })(IndexedAccessor = exports.IndexedAccessor || (exports.IndexedAccessor = {}));
@@ -1900,44 +1901,10 @@ class StandardTypeBuilder extends TypeBuilder {
     }
     /** `[Standard]` Creates a Composite object type. */
     Composite(objects, options) {
-        const isOptionalAll = (objects, key) => objects.every((object) => !(key in object.properties) || IsOptional(object.properties[key]));
-        const IsOptional = (schema) => TypeGuard.TOptional(schema) || TypeGuard.TReadonlyOptional(schema);
-        const [required, optional] = [new Set(), new Set()];
-        for (const object of objects) {
-            for (const key of globalThis.Object.getOwnPropertyNames(object.properties)) {
-                if (isOptionalAll(objects, key))
-                    optional.add(key);
-            }
-        }
-        for (const object of objects) {
-            for (const key of globalThis.Object.getOwnPropertyNames(object.properties)) {
-                if (!optional.has(key))
-                    required.add(key);
-            }
-        }
-        const properties = {};
-        for (const object of objects) {
-            for (const [key, schema] of Object.entries(object.properties)) {
-                const property = TypeClone.Clone(schema, {});
-                if (!optional.has(key))
-                    delete property[exports.Modifier];
-                if (key in properties) {
-                    properties[key] = TypeGuard.TIntersect(properties[key]) ? this.Intersect([...properties[key].allOf, property]) : this.Intersect([properties[key], property]);
-                }
-                else {
-                    properties[key] = property;
-                }
-            }
-        }
-        for (const key of globalThis.Object.getOwnPropertyNames(properties)) {
-            properties[key] = optional.has(key) ? this.Optional(properties[key]) : properties[key];
-        }
-        if (required.size > 0) {
-            return this.Create({ ...options, [exports.Kind]: 'Object', type: 'object', properties, required: [...required] });
-        }
-        else {
-            return this.Create({ ...options, [exports.Kind]: 'Object', type: 'object', properties });
-        }
+        const intersect = exports.Type.Intersect(objects, {});
+        const keys = KeyResolver.ResolveKeys(intersect, { includePatterns: false });
+        const properties = keys.reduce((acc, key) => ({ ...acc, [key]: exports.Type.Index(intersect, [key]) }), {});
+        return exports.Type.Object(properties, options);
     }
     /** `[Standard]` Creates a Enum type */
     Enum(item, options = {}) {