@sinclair/typebox 0.26.0 → 0.26.2

package/compiler/compiler.js

@@ -298,8 +298,6 @@ var TypeCompiler;
     }
     function* Object(schema, references, value) {
         yield IsObjectCheck(value);
-        if (!index_2.TypeSystem.AllowArrayObjects)
-            yield `!Array.isArray(${value})`;
         if (IsNumber(schema.minProperties))
             yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`;
         if (IsNumber(schema.maxProperties))

package/package.json

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

package/readme.md

@@ -229,13 +229,13 @@ The following table lists the Standard TypeBox types. These types are fully comp
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Null()          │ type T = null               │ const T = {                    │
-│                                │                             │    type: 'null'                │
+│                                │                             │   type: 'null'                 │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Literal(42)     │ type T = 42                 │ const T = {                    │
-│                                │                             │    const: 42,                  │
-│                                │                             │    type: 'number'              │
+│                                │                             │   const: 42,                   │
+│                                │                             │   type: 'number'               │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
@@ -326,19 +326,16 @@ The following table lists the Standard TypeBox types. These types are fully comp
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Composite([     │ type T = {                  │ const T = {                    │
-│   Type.Object({                │   x: number | string        │   type: 'object',              │
-│     x: Type.Number()           │   y: number                 │   properties: {                │
-│   }),                          │ }                           │     x: {                       │
-│   Type.Object({                │                             │       anyOf: [                 │
-│     x: Type.String()           │                             │         { type: 'number' },    │
-│     y: Type.Number()           │                             │         { type: 'string' }     │
-│   })                           │                             │       ]                        │
-│ ])                             │                             │     },                         │
-│                                │                             │     y: {                       │
+│   Type.Object({                │   x: number                 │   type: 'object',              │
+│     x: Type.Number()           │   y: number                 │   required: ['x', 'y'],        │
+│   }),                          │ }                           │   properties: {                │
+│   Type.Object({                │                             │     x: {                       │
+│     y: Type.Number()           │                             │       type: 'number'           │
+│   })                           │                             │     },                         │
+│ ])                             │                             │     y: {                       │
 │                                │                             │       type: 'number'           │
 │                                │                             │     }                          │
-│                                │                             │   },                           │
-│                                │                             │   required: ['x', 'y']         │
+│                                │                             │   }                            │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤

package/typebox.d.ts

@@ -83,16 +83,18 @@ 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 TCompositeUnion<Left extends TSchema, Right extends TSchema> = Ensure<TUnion<[Left, Right]>>;
-export type TCompositeUnionLeft<T extends TObject, Acc extends TProperties> = {
-    [K in keyof T['properties']]: K extends keyof Acc ? TCompositeUnion<T['properties'][K], Acc[K]> : T['properties'][K];
+export type TCompositeEvaluateArray<T extends readonly TSchema[], P extends unknown[]> = {
+    [K in keyof T]: T[K] extends TSchema ? Static<T[K], P> : never;
 };
-export type TCompositeUnionRight<T extends TObject, Acc extends TProperties> = {
-    [K in keyof Acc]: K extends keyof T['properties'] ? TCompositeUnion<T['properties'][K], Acc[K]> : Acc[K];
+export type TCompositeArray<T extends readonly TObject[]> = {
+    [K in keyof T]: T[K] extends TObject<infer P> ? P : {};
 };
-export type TCompositeUnionObject<T extends TObject, Acc extends TProperties> = Evaluate<TCompositeUnionLeft<T, Acc> & TCompositeUnionRight<T, Acc>>;
-export type TCompositeProperties<T extends TObject[], Acc extends TProperties> = T extends [...infer L, infer R] ? TCompositeProperties<Assert<L, TObject[]>, TCompositeUnionObject<Assert<R, TObject>, Acc>> : T extends [] ? Acc : never;
-export type TComposite<T extends TObject[] = TObject[]> = Ensure<TObject<TCompositeProperties<T, {}>>>;
+export type TCompositeProperties<I extends unknown, T extends readonly any[]> = Evaluate<T extends [infer A, ...infer B] ? TCompositeProperties<I & A, B> : I extends object ? I : {}>;
+export interface TComposite<T extends TObject[] = TObject[]> extends TObject {
+    [Hint]: 'Composite';
+    static: Evaluate<TCompositeProperties<unknown, TCompositeEvaluateArray<T, this['params']>>>;
+    properties: TCompositeProperties<unknown, TCompositeArray<T>>;
+}
 export type TConstructorParameterArray<T extends readonly TSchema[], P extends unknown[]> = [...{
     [K in keyof T]: Static<Assert<T[K], TSchema>, P>;
 }];
@@ -169,7 +171,7 @@ export type TKeyOfTuple<T extends TSchema> = {
 } extends infer U ? UnionToTuple<Exclude<{
     [K in keyof U]: U[K];
 }[keyof U], undefined>> : never;
-export type TKeyOf<T extends TSchema = TSchema> = (T extends TIntersect ? TKeyOfTuple<T> : T extends TUnion ? TKeyOfTuple<T> : T extends TObject ? TKeyOfTuple<T> : [
+export type TKeyOf<T extends TSchema = TSchema> = (T extends TComposite ? TKeyOfTuple<T> : T extends TIntersect ? TKeyOfTuple<T> : T extends TUnion ? TKeyOfTuple<T> : T extends TObject ? TKeyOfTuple<T> : [
 ]) extends infer R ? TUnionResult<Assert<R, TSchema[]>> : never;
 export type TLiteralValue = string | number | boolean;
 export interface TLiteral<T extends TLiteralValue = TLiteralValue> extends TSchema {
@@ -180,13 +182,7 @@ export interface TLiteral<T extends TLiteralValue = TLiteralValue> extends TSche
 export interface TNever extends TSchema {
     [Kind]: 'Never';
     static: never;
-    allOf: [{
-        type: 'boolean';
-        const: false;
-    }, {
-        type: 'boolean';
-        const: true;
-    }];
+    not: {};
 }
 export type TNotStatic<_ extends TSchema = TSchema, T extends TSchema = TSchema> = Static<T>;
 export interface TNot<Not extends TSchema = TSchema, T extends TSchema = TSchema> extends TSchema {
@@ -241,22 +237,25 @@ export type TOmitArray<T extends TSchema[], K extends keyof any> = Assert<{
     [K2 in keyof T]: TOmit<Assert<T[K2], TSchema>, K>;
 }, TSchema[]>;
 export type TOmitProperties<T extends TProperties, K extends keyof any> = Evaluate<Assert<Omit<T, K>, TProperties>>;
-export type TOmit<T extends TSchema, K extends keyof any> = 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, K extends keyof any> = T extends TComposite<infer S> ? TComposite<TOmitArray<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 TParameters<T extends TFunction> = TTuple<T['parameters']>;
+export type TPartialObjectArray<T extends TObject[]> = Assert<{
+    [K in keyof T]: TPartial<Assert<T[K], TObject>>;
+}, TObject[]>;
 export type TPartialArray<T extends TSchema[]> = Assert<{
     [K in keyof T]: TPartial<Assert<T[K], TSchema>>;
 }, TSchema[]>;
 export type TPartialProperties<T extends TProperties> = Evaluate<Assert<{
     [K in keyof T]: T[K] extends TReadonlyOptional<infer U> ? TReadonlyOptional<U> : T[K] extends TReadonly<infer U> ? TReadonlyOptional<U> : T[K] extends TOptional<infer U> ? TOptional<U> : TOptional<T[K]>;
 }, TProperties>>;
-export type TPartial<T extends TSchema> = 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 TPartial<T extends TSchema> = T extends TComposite<infer S> ? TComposite<TPartialArray<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<Assert<T[K2], TSchema>, 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]: Assert<R[K], TSchema> extends TSchema ? R[K] : never;
 }) : never;
-export type TPick<T extends TSchema, K extends keyof any> = 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 TPick<T extends TSchema, K extends keyof any> = T extends TComposite<infer S> ? TComposite<TPickArray<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 TPromiseStatic<T extends TSchema, P extends unknown[]> = Promise<Static<T, P>>;
 export interface TPromise<T extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Promise';
@@ -304,7 +303,7 @@ export type TRequiredArray<T extends TSchema[]> = Assert<{
 export type TRequiredProperties<T extends TProperties> = Evaluate<Assert<{
     [K in keyof T]: T[K] extends TReadonlyOptional<infer U> ? TReadonly<U> : T[K] extends TReadonly<infer U> ? TReadonly<U> : T[K] extends TOptional<infer U> ? U : T[K];
 }, TProperties>>;
-export type TRequired<T extends TSchema> = T extends TIntersect<infer S> ? TIntersect<TRequiredArray<S>> : T extends TUnion<infer S> ? TUnion<TRequiredArray<S>> : T extends TObject<infer S> ? TObject<TRequiredProperties<S>> : T;
+export type TRequired<T extends TSchema> = T extends TComposite<infer S> ? TComposite<TRequiredArray<S>> : T extends TIntersect<infer S> ? TIntersect<TRequiredArray<S>> : T extends TUnion<infer S> ? TUnion<TRequiredArray<S>> : T extends TObject<infer S> ? TObject<TRequiredProperties<S>> : T;
 export type StringFormatOption = 'date-time' | 'time' | 'date' | 'email' | 'idn-email' | 'hostname' | 'idn-hostname' | 'ipv4' | 'ipv6' | 'uri' | 'uri-reference' | 'iri' | 'uuid' | 'iri-reference' | 'uri-template' | 'json-pointer' | 'relative-json-pointer' | 'regex';
 export interface StringOptions<Format extends string> extends SchemaOptions {
     minLength?: number;
@@ -503,7 +502,7 @@ export declare namespace TypeExtends {
 }
 /** Specialized Clone for Types */
 export declare namespace TypeClone {
-    /** Clones a type. This function will omit non-self referential identifiers on the cloned type. */
+    /** Clones a type. */
     function Clone<T extends TSchema>(schema: T, options: SchemaOptions): T;
 }
 export declare namespace ObjectMap {
@@ -531,15 +530,15 @@ 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]` Creates a Composite object type that will union any overlapping properties of the given object array */
-    Composite<T extends TObject[]>(schemas: [...T], options?: ObjectOptions): TComposite<T>;
+    /** `[Standard]` Creates a Composite object type. */
+    Composite<T extends TObject[]>(objects: [...T], options?: ObjectOptions): TComposite<T>;
     /** `[Standard]` Creates a Enum type */
     Enum<T extends Record<string, string | number>>(item: T, options?: SchemaOptions): TEnum<T>;
     /** `[Standard]` A conditional type expression that will return the true type if the left type extends the right */
     Extends<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema>(left: L, right: R, trueType: T, falseType: U, options?: SchemaOptions): TExtends<L, R, T, U>;
     /** `[Standard]` Excludes from the left type any type that is not assignable to the right */
     Exclude<L extends TSchema, R extends TSchema>(left: L, right: R, options?: SchemaOptions): TExclude<L, R>;
-    /** `[Standard]` Extracts from left left any type that is assignable to the right */
+    /** `[Standard]` Extracts from the left type any type that is assignable to the right */
     Extract<L extends TSchema, R extends TSchema>(left: L, right: R, options?: SchemaOptions): TExtract<L, R>;
     /** `[Standard]` Creates an Integer type */
     Integer(options?: NumericOptions<number>): TInteger;

package/typebox.js

@@ -1347,7 +1347,7 @@ var TypeClone;
             return Object(value);
         return value;
     }
-    /** Clones a type. This function will omit non-self referential identifiers on the cloned type. */
+    /** Clones a type. */
     function Clone(schema, options) {
         return { ...Visit(schema), ...options };
     }
@@ -1465,15 +1465,48 @@ class StandardTypeBuilder extends TypeBuilder {
     Boolean(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Boolean', type: 'boolean' });
     }
-    /** `[Standard]` Creates a Composite object type that will union any overlapping properties of the given object array */
-    Composite(schemas, options) {
+    /** `[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 schemas) {
-            for (const [key, property] of globalThis.Object.entries(object.properties)) {
-                properties[key] = key in properties ? this.Union([properties[key], property]) : TypeClone.Clone(property, {});
+        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) {
+                    const left = TypeExtends.Extends(properties[key], property) !== TypeExtendsResult.False;
+                    const right = TypeExtends.Extends(property, properties[key]) !== TypeExtendsResult.False;
+                    if (!left && !right)
+                        properties[key] = exports.Type.Never();
+                    if (!left && right)
+                        properties[key] = property;
+                }
+                else {
+                    properties[key] = property;
+                }
             }
         }
-        return this.Object(properties, options);
+        if (required.size > 0) {
+            return this.Create({ ...options, [exports.Kind]: 'Object', [exports.Hint]: 'Composite', type: 'object', properties, required: [...required] });
+        }
+        else {
+            return this.Create({ ...options, [exports.Kind]: 'Object', [exports.Hint]: 'Composite', type: 'object', properties });
+        }
     }
     /** `[Standard]` Creates a Enum type */
     Enum(item, options = {}) {
@@ -1503,7 +1536,7 @@ class StandardTypeBuilder extends TypeBuilder {
             return (TypeExtends.Extends(left, right) !== TypeExtendsResult.False ? this.Never(options) : TypeClone.Clone(left, options));
         }
     }
-    /** `[Standard]` Extracts from left left any type that is assignable to the right */
+    /** `[Standard]` Extracts from the left type any type that is assignable to the right */
     Extract(left, right, options = {}) {
         if (TypeGuard.TUnion(left)) {
             const narrowed = left.anyOf.filter((inner) => TypeExtends.Extends(inner, right) !== TypeExtendsResult.False);

package/value/check.js

@@ -237,10 +237,10 @@ var ValueCheck;
         if (!IsObject(value)) {
             return false;
         }
-        if (IsNumber(schema.minProperties) && !(globalThis.Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
+        if (IsDefined(schema.minProperties) && !(globalThis.Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
             return false;
         }
-        if (IsNumber(schema.maxProperties) && !(globalThis.Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
+        if (IsDefined(schema.maxProperties) && !(globalThis.Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
             return false;
         }
         const knownKeys = globalThis.Object.getOwnPropertyNames(schema.properties);