@sinclair/typebox 0.32.0-dev-18 → 0.32.0-dev-19

package/build/require/value/check/check.js

@@ -2,19 +2,26 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Check = exports.ValueCheckUnknownTypeError = void 0;
-const index_1 = require("../guard/index");
-const index_2 = require("../../system/index");
-const index_3 = require("../deref/index");
-const index_4 = require("../hash/index");
-const index_5 = require("../../type/symbols/index");
-const index_6 = require("../../type/keyof/index");
-const index_7 = require("../../type/extends/index");
+const index_1 = require("../../system/index");
+const index_2 = require("../deref/index");
+const index_3 = require("../hash/index");
+const index_4 = require("../../type/symbols/index");
+const index_5 = require("../../type/keyof/index");
+const index_6 = require("../../type/extends/index");
+const index_7 = require("../../type/registry/index");
+const index_8 = require("../../type/never/index");
+// ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
+// prettier-ignore
+const index_9 = require("../guard/index");
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
 const type_1 = require("../../type/guard/type");
-const index_8 = require("../../type/registry/index");
-const index_9 = require("../../type/never/index");
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Errors
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 class ValueCheckUnknownTypeError extends Error {
     constructor(schema) {
         super(`Unknown type`);
@@ -22,26 +29,26 @@ class ValueCheckUnknownTypeError extends Error {
     }
 }
 exports.ValueCheckUnknownTypeError = ValueCheckUnknownTypeError;
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // TypeGuards
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 function IsAnyOrUnknown(schema) {
-    return schema[index_5.Kind] === 'Any' || schema[index_5.Kind] === 'Unknown';
+    return schema[index_4.Kind] === 'Any' || schema[index_4.Kind] === 'Unknown';
 }
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Guards
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 function IsDefined(value) {
     return value !== undefined;
 }
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Types
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 function TAny(schema, references, value) {
     return true;
 }
 function TArray(schema, references, value) {
-    if (!(0, index_1.IsArray)(value))
+    if (!(0, index_9.IsArray)(value))
         return false;
     if (IsDefined(schema.minItems) && !(value.length >= schema.minItems)) {
         return false;
@@ -54,7 +61,7 @@ function TArray(schema, references, value) {
     }
     // prettier-ignore
     if (schema.uniqueItems === true && !((function () { const set = new Set(); for (const element of value) {
-        const hashed = (0, index_4.Hash)(element);
+        const hashed = (0, index_3.Hash)(element);
         if (set.has(hashed)) {
             return false;
         }
@@ -65,27 +72,27 @@ function TArray(schema, references, value) {
         return false;
     }
     // contains
-    if (!(IsDefined(schema.contains) || (0, index_1.IsNumber)(schema.minContains) || (0, index_1.IsNumber)(schema.maxContains))) {
+    if (!(IsDefined(schema.contains) || (0, index_9.IsNumber)(schema.minContains) || (0, index_9.IsNumber)(schema.maxContains))) {
         return true; // exit
     }
-    const containsSchema = IsDefined(schema.contains) ? schema.contains : (0, index_9.Never)();
+    const containsSchema = IsDefined(schema.contains) ? schema.contains : (0, index_8.Never)();
     const containsCount = value.reduce((acc, value) => (Visit(containsSchema, references, value) ? acc + 1 : acc), 0);
     if (containsCount === 0) {
         return false;
     }
-    if ((0, index_1.IsNumber)(schema.minContains) && containsCount < schema.minContains) {
+    if ((0, index_9.IsNumber)(schema.minContains) && containsCount < schema.minContains) {
         return false;
     }
-    if ((0, index_1.IsNumber)(schema.maxContains) && containsCount > schema.maxContains) {
+    if ((0, index_9.IsNumber)(schema.maxContains) && containsCount > schema.maxContains) {
         return false;
     }
     return true;
 }
 function TAsyncIterator(schema, references, value) {
-    return (0, index_1.IsAsyncIterator)(value);
+    return (0, index_9.IsAsyncIterator)(value);
 }
 function TBigInt(schema, references, value) {
-    if (!(0, index_1.IsBigInt)(value))
+    if (!(0, index_9.IsBigInt)(value))
         return false;
     if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
         return false;
@@ -105,13 +112,13 @@ function TBigInt(schema, references, value) {
     return true;
 }
 function TBoolean(schema, references, value) {
-    return (0, index_1.IsBoolean)(value);
+    return (0, index_9.IsBoolean)(value);
 }
 function TConstructor(schema, references, value) {
     return Visit(schema.returns, references, value.prototype);
 }
 function TDate(schema, references, value) {
-    if (!(0, index_1.IsDate)(value))
+    if (!(0, index_9.IsDate)(value))
         return false;
     if (IsDefined(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
         return false;
@@ -131,10 +138,10 @@ function TDate(schema, references, value) {
     return true;
 }
 function TFunction(schema, references, value) {
-    return (0, index_1.IsFunction)(value);
+    return (0, index_9.IsFunction)(value);
 }
 function TInteger(schema, references, value) {
-    if (!(0, index_1.IsInteger)(value)) {
+    if (!(0, index_9.IsInteger)(value)) {
         return false;
     }
     if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
@@ -157,12 +164,12 @@ function TInteger(schema, references, value) {
 function TIntersect(schema, references, value) {
     const check1 = schema.allOf.every((schema) => Visit(schema, references, value));
     if (schema.unevaluatedProperties === false) {
-        const keyPattern = new RegExp((0, index_6.KeyOfPattern)(schema));
+        const keyPattern = new RegExp((0, index_5.KeyOfPattern)(schema));
         const check2 = Object.getOwnPropertyNames(value).every((key) => keyPattern.test(key));
         return check1 && check2;
     }
-    else if ((0, type_1.TSchema)(schema.unevaluatedProperties)) {
-        const keyCheck = new RegExp((0, index_6.KeyOfPattern)(schema));
+    else if ((0, type_1.IsSchema)(schema.unevaluatedProperties)) {
+        const keyCheck = new RegExp((0, index_5.KeyOfPattern)(schema));
         const check2 = Object.getOwnPropertyNames(value).every((key) => keyCheck.test(key) || Visit(schema.unevaluatedProperties, references, value[key]));
         return check1 && check2;
     }
@@ -171,7 +178,7 @@ function TIntersect(schema, references, value) {
     }
 }
 function TIterator(schema, references, value) {
-    return (0, index_1.IsIterator)(value);
+    return (0, index_9.IsIterator)(value);
 }
 function TLiteral(schema, references, value) {
     return value === schema.const;
@@ -183,10 +190,10 @@ function TNot(schema, references, value) {
     return !Visit(schema.not, references, value);
 }
 function TNull(schema, references, value) {
-    return (0, index_1.IsNull)(value);
+    return (0, index_9.IsNull)(value);
 }
 function TNumber(schema, references, value) {
-    if (!index_2.TypeSystemPolicy.IsNumberLike(value))
+    if (!index_1.TypeSystemPolicy.IsNumberLike(value))
         return false;
     if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
         return false;
@@ -206,7 +213,7 @@ function TNumber(schema, references, value) {
     return true;
 }
 function TObject(schema, references, value) {
-    if (!index_2.TypeSystemPolicy.IsObjectLike(value))
+    if (!index_1.TypeSystemPolicy.IsObjectLike(value))
         return false;
     if (IsDefined(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
         return false;
@@ -221,12 +228,12 @@ function TObject(schema, references, value) {
             if (!Visit(property, references, value[knownKey])) {
                 return false;
             }
-            if (((0, index_7.ExtendsUndefinedCheck)(property) || IsAnyOrUnknown(property)) && !(knownKey in value)) {
+            if (((0, index_6.ExtendsUndefinedCheck)(property) || IsAnyOrUnknown(property)) && !(knownKey in value)) {
                 return false;
             }
         }
         else {
-            if (index_2.TypeSystemPolicy.IsExactOptionalProperty(value, knownKey) && !Visit(property, references, value[knownKey])) {
+            if (index_1.TypeSystemPolicy.IsExactOptionalProperty(value, knownKey) && !Visit(property, references, value[knownKey])) {
                 return false;
             }
         }
@@ -250,10 +257,10 @@ function TObject(schema, references, value) {
     }
 }
 function TPromise(schema, references, value) {
-    return (0, index_1.IsPromise)(value);
+    return (0, index_9.IsPromise)(value);
 }
 function TRecord(schema, references, value) {
-    if (!index_2.TypeSystemPolicy.IsRecordLike(value)) {
+    if (!index_1.TypeSystemPolicy.IsRecordLike(value)) {
         return false;
     }
     if (IsDefined(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
@@ -280,10 +287,10 @@ function TRecord(schema, references, value) {
     return check1 && check2 && check3;
 }
 function TRef(schema, references, value) {
-    return Visit((0, index_3.Deref)(schema, references), references, value);
+    return Visit((0, index_2.Deref)(schema, references), references, value);
 }
 function TString(schema, references, value) {
-    if (!(0, index_1.IsString)(value)) {
+    if (!(0, index_9.IsString)(value)) {
         return false;
     }
     if (IsDefined(schema.minLength)) {
@@ -300,24 +307,24 @@ function TString(schema, references, value) {
             return false;
     }
     if (IsDefined(schema.format)) {
-        if (!index_8.FormatRegistry.Has(schema.format))
+        if (!index_7.FormatRegistry.Has(schema.format))
             return false;
-        const func = index_8.FormatRegistry.Get(schema.format);
+        const func = index_7.FormatRegistry.Get(schema.format);
         return func(value);
     }
     return true;
 }
 function TSymbol(schema, references, value) {
-    return (0, index_1.IsSymbol)(value);
+    return (0, index_9.IsSymbol)(value);
 }
 function TTemplateLiteral(schema, references, value) {
-    return (0, index_1.IsString)(value) && new RegExp(schema.pattern).test(value);
+    return (0, index_9.IsString)(value) && new RegExp(schema.pattern).test(value);
 }
 function TThis(schema, references, value) {
-    return Visit((0, index_3.Deref)(schema, references), references, value);
+    return Visit((0, index_2.Deref)(schema, references), references, value);
 }
 function TTuple(schema, references, value) {
-    if (!(0, index_1.IsArray)(value)) {
+    if (!(0, index_9.IsArray)(value)) {
         return false;
     }
     if (schema.items === undefined && !(value.length === 0)) {
@@ -336,13 +343,13 @@ function TTuple(schema, references, value) {
     return true;
 }
 function TUndefined(schema, references, value) {
-    return (0, index_1.IsUndefined)(value);
+    return (0, index_9.IsUndefined)(value);
 }
 function TUnion(schema, references, value) {
     return schema.anyOf.some((inner) => Visit(inner, references, value));
 }
 function TUint8Array(schema, references, value) {
-    if (!(0, index_1.IsUint8Array)(value)) {
+    if (!(0, index_9.IsUint8Array)(value)) {
         return false;
     }
     if (IsDefined(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) {
@@ -357,18 +364,18 @@ function TUnknown(schema, references, value) {
     return true;
 }
 function TVoid(schema, references, value) {
-    return index_2.TypeSystemPolicy.IsVoidLike(value);
+    return index_1.TypeSystemPolicy.IsVoidLike(value);
 }
 function TKind(schema, references, value) {
-    if (!index_8.TypeRegistry.Has(schema[index_5.Kind]))
+    if (!index_7.TypeRegistry.Has(schema[index_4.Kind]))
         return false;
-    const func = index_8.TypeRegistry.Get(schema[index_5.Kind]);
+    const func = index_7.TypeRegistry.Get(schema[index_4.Kind]);
     return func(schema, value);
 }
 function Visit(schema, references, value) {
     const references_ = IsDefined(schema.$id) ? [...references, schema] : references;
     const schema_ = schema;
-    switch (schema_[index_5.Kind]) {
+    switch (schema_[index_4.Kind]) {
         case 'Any':
             return TAny(schema_, references_, value);
         case 'Array':
@@ -430,7 +437,7 @@ function Visit(schema, references, value) {
         case 'Void':
             return TVoid(schema_, references_, value);
         default:
-            if (!index_8.TypeRegistry.Has(schema_[index_5.Kind]))
+            if (!index_7.TypeRegistry.Has(schema_[index_4.Kind]))
                 throw new ValueCheckUnknownTypeError(schema_);
             return TKind(schema_, references_, value);
     }

package/build/require/value/clean/clean.js

@@ -2,51 +2,53 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Clean = void 0;
-const index_1 = require("../guard/index");
-const type_1 = require("../../type/guard/type");
-const index_2 = require("../../type/keyof/index");
-const index_3 = require("../check/index");
-const index_4 = require("../clone/index");
-const index_5 = require("../deref/index");
-const index_6 = require("../../type/symbols/index");
+const index_1 = require("../../type/keyof/index");
+const index_2 = require("../check/index");
+const index_3 = require("../clone/index");
+const index_4 = require("../deref/index");
+const index_5 = require("../../type/symbols/index");
 // ------------------------------------------------------------------
-// IsSchema
+// ValueGuard
 // ------------------------------------------------------------------
-function IsSchema(schema) {
-    return (0, type_1.TSchema)(schema);
-}
+// prettier-ignore
+const index_6 = require("../guard/index");
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
+const type_1 = require("../../type/guard/type");
 // ------------------------------------------------------------------
 // IsCheckable
 // ------------------------------------------------------------------
 function IsCheckable(schema) {
-    return (0, type_1.TSchema)(schema) && schema[index_6.Kind] !== 'Unsafe';
+    return (0, type_1.IsSchema)(schema) && schema[index_5.Kind] !== 'Unsafe';
 }
 // ------------------------------------------------------------------
 // Types
 // ------------------------------------------------------------------
 function TArray(schema, references, value) {
-    if (!(0, index_1.IsArray)(value))
+    if (!(0, index_6.IsArray)(value))
         return value;
     return value.map((value) => Visit(schema.items, references, value));
 }
 function TIntersect(schema, references, value) {
     const unevaluatedProperties = schema.unevaluatedProperties;
-    const intersections = schema.allOf.map((schema) => Visit(schema, references, (0, index_4.Clone)(value)));
-    const composite = intersections.reduce((acc, value) => ((0, index_1.IsObject)(value) ? { ...acc, ...value } : value), {});
-    if (!(0, index_1.IsObject)(value) || !(0, index_1.IsObject)(composite) || !IsSchema(unevaluatedProperties))
+    const intersections = schema.allOf.map((schema) => Visit(schema, references, (0, index_3.Clone)(value)));
+    const composite = intersections.reduce((acc, value) => ((0, index_6.IsObject)(value) ? { ...acc, ...value } : value), {});
+    if (!(0, index_6.IsObject)(value) || !(0, index_6.IsObject)(composite) || !(0, type_1.IsSchema)(unevaluatedProperties))
         return composite;
-    const knownkeys = (0, index_2.KeyOfPropertyKeys)(schema);
+    const knownkeys = (0, index_1.KeyOfPropertyKeys)(schema);
     for (const key of Object.getOwnPropertyNames(value)) {
         if (knownkeys.includes(key))
             continue;
-        if ((0, index_3.Check)(unevaluatedProperties, references, value[key])) {
+        if ((0, index_2.Check)(unevaluatedProperties, references, value[key])) {
             composite[key] = Visit(unevaluatedProperties, references, value[key]);
         }
     }
     return composite;
 }
 function TObject(schema, references, value) {
-    if (!(0, index_1.IsObject)(value) || (0, index_1.IsArray)(value))
+    if (!(0, index_6.IsObject)(value) || (0, index_6.IsArray)(value))
         return value; // Check IsArray for AllowArrayObject configuration
     const additionalProperties = schema.additionalProperties;
     for (const key of Object.getOwnPropertyNames(value)) {
@@ -54,7 +56,7 @@ function TObject(schema, references, value) {
             value[key] = Visit(schema.properties[key], references, value[key]);
             continue;
         }
-        if (IsSchema(additionalProperties) && (0, index_3.Check)(additionalProperties, references, value[key])) {
+        if ((0, type_1.IsSchema)(additionalProperties) && (0, index_2.Check)(additionalProperties, references, value[key])) {
             value[key] = Visit(additionalProperties, references, value[key]);
             continue;
         }
@@ -63,7 +65,7 @@ function TObject(schema, references, value) {
     return value;
 }
 function TRecord(schema, references, value) {
-    if (!(0, index_1.IsObject)(value))
+    if (!(0, index_6.IsObject)(value))
         return value;
     const additionalProperties = schema.additionalProperties;
     const propertyKeys = Object.keys(value);
@@ -74,7 +76,7 @@ function TRecord(schema, references, value) {
             value[key] = Visit(propertySchema, references, value[key]);
             continue;
         }
-        if (IsSchema(additionalProperties) && (0, index_3.Check)(additionalProperties, references, value[key])) {
+        if ((0, type_1.IsSchema)(additionalProperties) && (0, index_2.Check)(additionalProperties, references, value[key])) {
             value[key] = Visit(additionalProperties, references, value[key]);
             continue;
         }
@@ -83,15 +85,15 @@ function TRecord(schema, references, value) {
     return value;
 }
 function TRef(schema, references, value) {
-    return Visit((0, index_5.Deref)(schema, references), references, value);
+    return Visit((0, index_4.Deref)(schema, references), references, value);
 }
 function TThis(schema, references, value) {
-    return Visit((0, index_5.Deref)(schema, references), references, value);
+    return Visit((0, index_4.Deref)(schema, references), references, value);
 }
 function TTuple(schema, references, value) {
-    if (!(0, index_1.IsArray)(value))
+    if (!(0, index_6.IsArray)(value))
         return value;
-    if ((0, index_1.IsUndefined)(schema.items))
+    if ((0, index_6.IsUndefined)(schema.items))
         return [];
     const length = Math.min(value.length, schema.items.length);
     for (let i = 0; i < length; i++) {
@@ -104,16 +106,16 @@ function TTuple(schema, references, value) {
 }
 function TUnion(schema, references, value) {
     for (const inner of schema.anyOf) {
-        if (IsCheckable(inner) && (0, index_3.Check)(inner, value)) {
+        if (IsCheckable(inner) && (0, index_2.Check)(inner, value)) {
             return Visit(inner, references, value);
         }
     }
     return value;
 }
 function Visit(schema, references, value) {
-    const references_ = (0, index_1.IsString)(schema.$id) ? [...references, schema] : references;
+    const references_ = (0, index_6.IsString)(schema.$id) ? [...references, schema] : references;
     const schema_ = schema;
-    switch (schema_[index_6.Kind]) {
+    switch (schema_[index_5.Kind]) {
         case 'Array':
             return TArray(schema_, references_, value);
         case 'Intersect':

package/build/require/value/clone/clone.js

@@ -2,10 +2,13 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Clone = void 0;
+// ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
 const index_1 = require("../guard/index");
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Clonable
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 function ObjectType(value) {
     const keys = [...Object.getOwnPropertyNames(value), ...Object.getOwnPropertySymbols(value)];
     return keys.reduce((acc, key) => ({ ...acc, [key]: Clone(value[key]) }), {});
@@ -22,9 +25,9 @@ function DateType(value) {
 function ValueType(value) {
     return value;
 }
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Clone
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 /** Returns a clone of the given value */
 function Clone(value) {
     if ((0, index_1.IsArray)(value))