@sinclair/typebox 0.26.6 → 0.26.8

package/compiler/compiler.js

@@ -341,6 +341,10 @@ var TypeCompiler;
     }
     function* Record(schema, references, value) {
         yield IsRecordCheck(value);
+        if (IsNumber(schema.minProperties))
+            yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`;
+        if (IsNumber(schema.maxProperties))
+            yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`;
         const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0];
         const local = PushLocal(`new RegExp(/${keyPattern}/)`);
         yield `(Object.getOwnPropertyNames(${value}).every(key => ${local}.test(key)))`;

package/errors/errors.js

@@ -401,6 +401,12 @@ var ValueErrors;
         if (!IsRecordObject(value)) {
             return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected record object` };
         }
+        if (IsDefined(schema.minProperties) && !(globalThis.Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
+            yield { type: ValueErrorType.ObjectMinProperties, schema, path, value, message: `Expected object to have at least ${schema.minProperties} properties` };
+        }
+        if (IsDefined(schema.maxProperties) && !(globalThis.Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
+            yield { type: ValueErrorType.ObjectMaxProperties, schema, path, value, message: `Expected object to have less than ${schema.minProperties} properties` };
+        }
         const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0];
         const regex = new RegExp(keyPattern);
         if (!globalThis.Object.getOwnPropertyNames(value).every((key) => regex.test(key))) {

package/package.json

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

package/readme.md

@@ -444,12 +444,12 @@ The following table lists the Standard TypeBox types. These types are fully comp
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
-│ const A = Type.Object({        │ type A = {                  │ const T = {                    │
-│    x: Type.Number(),           │   x: number,                │   $ref: 'A'                    │
+│ const T = Type.Object({        │ type T = {                  │ const R = {                    │
+│    x: Type.Number(),           │   x: number,                │   $ref: 'T'                    │
 │    y: Type.Number()            │   y: number                 │ }                              │
 │ }, { $id: 'T' })               | }                           │                                │
 │                                │                             │                                │
-│ const T = Type.Ref(A)          │ type T = A                  │                                │
+│ const R = Type.Ref(T)          │ type R = T                  │                                │
 │                                │                             │                                │
 │                                │                             │                                │
 │                                │                             │                                │

package/typebox.d.ts

@@ -477,6 +477,8 @@ export declare namespace TypeGuard {
     function TUint8Array(schema: unknown): schema is TUint8Array;
     /** Returns true if the given schema is TUnknown */
     function TUnknown(schema: unknown): schema is TUnknown;
+    /** Returns true if the given schema is a raw TUnsafe */
+    function TUnsafe(schema: unknown): schema is TUnsafe<unknown>;
     /** Returns true if the given schema is TVoid */
     function TVoid(schema: unknown): schema is TVoid;
     /** Returns true if this schema has the ReadonlyOptional modifier */

package/typebox.js

@@ -513,6 +513,13 @@ var TypeGuard;
             IsOptionalString(schema.$id));
     }
     TypeGuard.TUnknown = TUnknown;
+    /** Returns true if the given schema is a raw TUnsafe */
+    function TUnsafe(schema) {
+        // prettier-ignore
+        return (TKind(schema) &&
+            schema[exports.Kind] === 'Unsafe');
+    }
+    TypeGuard.TUnsafe = TUnsafe;
     /** Returns true if the given schema is TVoid */
     function TVoid(schema) {
         // prettier-ignore
@@ -567,6 +574,7 @@ var TypeGuard;
                 TUnion(schema) ||
                 TUint8Array(schema) ||
                 TUnknown(schema) ||
+                TUnsafe(schema) ||
                 TVoid(schema) ||
                 (TKind(schema) && TypeRegistry.Has(schema[exports.Kind]))));
     }

package/value/check.js

@@ -291,6 +291,12 @@ var ValueCheck;
         if (!IsRecordObject(value)) {
             return false;
         }
+        if (IsDefined(schema.minProperties) && !(globalThis.Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
+            return false;
+        }
+        if (IsDefined(schema.maxProperties) && !(globalThis.Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
+            return false;
+        }
         const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0];
         const regex = new RegExp(keyPattern);
         if (!globalThis.Object.getOwnPropertyNames(value).every((key) => regex.test(key))) {