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

package/build/import/type/type/json.d.mts

@@ -22,10 +22,10 @@ import { type TMappedKey } from '../mapped/index.mjs';
 import { type TNumber, type NumberOptions } from '../number/index.mjs';
 import { type TObject, type TProperties, type ObjectOptions } from '../object/index.mjs';
 import { type TOmit, type TOmitFromMappedKey } from '../omit/index.mjs';
-import { type TOptional } from '../optional/index.mjs';
+import { type TOptionalWithFlag, type TOptionalFromMappedResult } from '../optional/index.mjs';
 import { type TPartial, type TPartialFromMappedResult } from '../partial/index.mjs';
 import { type TPick, type TPickFromMappedKey } from '../pick/index.mjs';
-import { type TReadonly } from '../readonly/index.mjs';
+import { type TReadonlyWithFlag, type TReadonlyFromMappedResult } from '../readonly/index.mjs';
 import { type TReadonlyOptional } from '../readonly-optional/index.mjs';
 import { type TRecordOrObject } from '../record/index.mjs';
 import { type TRecursive, type TThis } from '../recursive/index.mjs';
@@ -34,7 +34,7 @@ import { type TRequired, type TRequiredFromMappedResult } from '../required/inde
 import { type TRest } from '../rest/index.mjs';
 import { type TSchema, type SchemaOptions } from '../schema/index.mjs';
 import { type TString, type StringOptions } from '../string/index.mjs';
-import { type TTemplateLiteral, type TTemplateLiteralKind, type TemplateLiteralSyntax } from '../template-literal/index.mjs';
+import { type TTemplateLiteral, type TTemplateLiteralKind, type TTemplateLiteralSyntax } from '../template-literal/index.mjs';
 import { TransformDecodeBuilder } from '../transform/index.mjs';
 import { type TTuple } from '../tuple/index.mjs';
 import { Union } from '../union/index.mjs';
@@ -47,9 +47,21 @@ export declare class JsonTypeBuilder {
     /** `[Json]` Creates a Readonly and Optional property */
     ReadonlyOptional<T extends TSchema>(schema: T): TReadonlyOptional<T>;
     /** `[Json]` Creates a Readonly property */
-    Readonly<T extends TSchema>(schema: T): TReadonly<T>;
-    /** `[Json]` Creates an Optional property */
-    Optional<T extends TSchema>(schema: T): TOptional<T>;
+    Readonly<T extends TMappedResult, F extends boolean>(schema: T, enable: F): TReadonlyFromMappedResult<T, F>;
+    /** `[Json]` Creates a Readonly property */
+    Readonly<T extends TSchema, F extends boolean>(schema: T, enable: F): TReadonlyWithFlag<T, F>;
+    /** `[Json]` Creates a Optional property */
+    Readonly<T extends TMappedResult>(schema: T): TReadonlyFromMappedResult<T, true>;
+    /** `[Json]` Creates a Readonly property */
+    Readonly<T extends TSchema>(schema: T): TReadonlyWithFlag<T, true>;
+    /** `[Json]` Creates a Optional property */
+    Optional<T extends TMappedResult, F extends boolean>(schema: T, enable: F): TOptionalFromMappedResult<T, F>;
+    /** `[Json]` Creates a Optional property */
+    Optional<T extends TSchema, F extends boolean>(schema: T, enable: F): TOptionalWithFlag<T, F>;
+    /** `[Json]` Creates a Optional property */
+    Optional<T extends TMappedResult>(schema: T): TOptionalFromMappedResult<T, true>;
+    /** `[Json]` Creates a Optional property */
+    Optional<T extends TSchema>(schema: T): TOptionalWithFlag<T, true>;
     /** `[Json]` Creates an Any type */
     Any(options?: SchemaOptions): TAny;
     /** `[Json]` Creates an Array type */
@@ -145,7 +157,7 @@ export declare class JsonTypeBuilder {
     /** `[Json]` Creates a String type */
     String(options?: StringOptions): TString;
     /** `[Json]` Creates a TemplateLiteral type from template dsl string */
-    TemplateLiteral<T extends string>(syntax: T, options?: SchemaOptions): TemplateLiteralSyntax<T>;
+    TemplateLiteral<T extends string>(syntax: T, options?: SchemaOptions): TTemplateLiteralSyntax<T>;
     /** `[Json]` Creates a TemplateLiteral type */
     TemplateLiteral<T extends TTemplateLiteralKind[]>(kinds: [...T], options?: SchemaOptions): TTemplateLiteral<T>;
     /** `[Json]` Creates a Transform type */

package/build/import/type/type/json.mjs

@@ -56,12 +56,12 @@ export class JsonTypeBuilder {
         return ReadonlyOptional(schema);
     }
     /** `[Json]` Creates a Readonly property */
-    Readonly(schema) {
-        return Readonly(schema);
+    Readonly(schema, enable) {
+        return Readonly(schema, enable ?? true);
     }
-    /** `[Json]` Creates an Optional property */
-    Optional(schema) {
-        return Optional(schema);
+    /** `[Json]` Creates a Optional property */
+    Optional(schema, enable) {
+        return Optional(schema, enable ?? true);
     }
     // ------------------------------------------------------------------------
     // Types

package/build/import/value/cast/cast.mjs

@@ -94,7 +94,7 @@ function Default(schema, references, value) {
 // ------------------------------------------------------------------
 // Cast
 // ------------------------------------------------------------------
-function TArray(schema, references, value) {
+function FromArray(schema, references, value) {
     if (Check(schema, references, value))
         return Clone(value);
     const created = IsArray(value) ? Clone(value) : Create(schema, references);
@@ -108,7 +108,7 @@ function TArray(schema, references, value) {
         throw new ValueCastArrayUniqueItemsTypeError(schema, unique);
     return unique;
 }
-function TConstructor(schema, references, value) {
+function FromConstructor(schema, references, value) {
     if (Check(schema, references, value))
         return Create(schema, references);
     const required = new Set(schema.returns.required || []);
@@ -120,15 +120,15 @@ function TConstructor(schema, references, value) {
     }
     return result;
 }
-function TIntersect(schema, references, value) {
+function FromIntersect(schema, references, value) {
     const created = Create(schema, references);
     const mapped = IsPlainObject(created) && IsPlainObject(value) ? { ...created, ...value } : value;
     return Check(schema, references, mapped) ? mapped : Create(schema, references);
 }
-function TNever(schema, references, value) {
+function FromNever(schema, references, value) {
     throw new ValueCastNeverTypeError(schema);
 }
-function TObject(schema, references, value) {
+function FromObject(schema, references, value) {
     if (Check(schema, references, value))
         return value;
     if (value === null || typeof value !== 'object')
@@ -151,7 +151,7 @@ function TObject(schema, references, value) {
     }
     return result;
 }
-function TRecord(schema, references, value) {
+function FromRecord(schema, references, value) {
     if (Check(schema, references, value))
         return Clone(value);
     if (value === null || typeof value !== 'object' || Array.isArray(value) || value instanceof Date)
@@ -164,13 +164,13 @@ function TRecord(schema, references, value) {
     }
     return result;
 }
-function TRef(schema, references, value) {
+function FromRef(schema, references, value) {
     return Visit(Deref(schema, references), references, value);
 }
-function TThis(schema, references, value) {
+function FromThis(schema, references, value) {
     return Visit(Deref(schema, references), references, value);
 }
-function TTuple(schema, references, value) {
+function FromTuple(schema, references, value) {
     if (Check(schema, references, value))
         return Clone(value);
     if (!IsArray(value))
@@ -179,7 +179,7 @@ function TTuple(schema, references, value) {
         return [];
     return schema.items.map((schema, index) => Visit(schema, references, value[index]));
 }
-function TUnion(schema, references, value) {
+function FromUnion(schema, references, value) {
     return Check(schema, references, value) ? Clone(value) : CastUnion(schema, references, value);
 }
 function Visit(schema, references, value) {
@@ -190,25 +190,25 @@ function Visit(schema, references, value) {
         // Structural
         // --------------------------------------------------------------
         case 'Array':
-            return TArray(schema_, references_, value);
+            return FromArray(schema_, references_, value);
         case 'Constructor':
-            return TConstructor(schema_, references_, value);
+            return FromConstructor(schema_, references_, value);
         case 'Intersect':
-            return TIntersect(schema_, references_, value);
+            return FromIntersect(schema_, references_, value);
         case 'Never':
-            return TNever(schema_, references_, value);
+            return FromNever(schema_, references_, value);
         case 'Object':
-            return TObject(schema_, references_, value);
+            return FromObject(schema_, references_, value);
         case 'Record':
-            return TRecord(schema_, references_, value);
+            return FromRecord(schema_, references_, value);
         case 'Ref':
-            return TRef(schema_, references_, value);
+            return FromRef(schema_, references_, value);
         case 'This':
-            return TThis(schema_, references_, value);
+            return FromThis(schema_, references_, value);
         case 'Tuple':
-            return TTuple(schema_, references_, value);
+            return FromTuple(schema_, references_, value);
         case 'Union':
-            return TUnion(schema_, references_, value);
+            return FromUnion(schema_, references_, value);
         // --------------------------------------------------------------
         // DefaultClone
         // --------------------------------------------------------------

package/build/import/value/check/check.mjs

@@ -40,10 +40,10 @@ function IsDefined(value) {
 // ------------------------------------------------------------------
 // Types
 // ------------------------------------------------------------------
-function TAny(schema, references, value) {
+function FromAny(schema, references, value) {
     return true;
 }
-function TArray(schema, references, value) {
+function FromArray(schema, references, value) {
     if (!IsArray(value))
         return false;
     if (IsDefined(schema.minItems) && !(value.length >= schema.minItems)) {
@@ -84,10 +84,10 @@ function TArray(schema, references, value) {
     }
     return true;
 }
-function TAsyncIterator(schema, references, value) {
+function FromAsyncIterator(schema, references, value) {
     return IsAsyncIterator(value);
 }
-function TBigInt(schema, references, value) {
+function FromBigInt(schema, references, value) {
     if (!IsBigInt(value))
         return false;
     if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
@@ -107,13 +107,13 @@ function TBigInt(schema, references, value) {
     }
     return true;
 }
-function TBoolean(schema, references, value) {
+function FromBoolean(schema, references, value) {
     return IsBoolean(value);
 }
-function TConstructor(schema, references, value) {
+function FromConstructor(schema, references, value) {
     return Visit(schema.returns, references, value.prototype);
 }
-function TDate(schema, references, value) {
+function FromDate(schema, references, value) {
     if (!IsDate(value))
         return false;
     if (IsDefined(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
@@ -133,10 +133,10 @@ function TDate(schema, references, value) {
     }
     return true;
 }
-function TFunction(schema, references, value) {
+function FromFunction(schema, references, value) {
     return IsFunction(value);
 }
-function TInteger(schema, references, value) {
+function FromInteger(schema, references, value) {
     if (!IsInteger(value)) {
         return false;
     }
@@ -157,7 +157,7 @@ function TInteger(schema, references, value) {
     }
     return true;
 }
-function TIntersect(schema, references, value) {
+function FromIntersect(schema, references, value) {
     const check1 = schema.allOf.every((schema) => Visit(schema, references, value));
     if (schema.unevaluatedProperties === false) {
         const keyPattern = new RegExp(KeyOfPattern(schema));
@@ -173,22 +173,22 @@ function TIntersect(schema, references, value) {
         return check1;
     }
 }
-function TIterator(schema, references, value) {
+function FromIterator(schema, references, value) {
     return IsIterator(value);
 }
-function TLiteral(schema, references, value) {
+function FromLiteral(schema, references, value) {
     return value === schema.const;
 }
-function TNever(schema, references, value) {
+function FromNever(schema, references, value) {
     return false;
 }
-function TNot(schema, references, value) {
+function FromNot(schema, references, value) {
     return !Visit(schema.not, references, value);
 }
-function TNull(schema, references, value) {
+function FromNull(schema, references, value) {
     return IsNull(value);
 }
-function TNumber(schema, references, value) {
+function FromNumber(schema, references, value) {
     if (!TypeSystemPolicy.IsNumberLike(value))
         return false;
     if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
@@ -208,7 +208,7 @@ function TNumber(schema, references, value) {
     }
     return true;
 }
-function TObject(schema, references, value) {
+function FromObject(schema, references, value) {
     if (!TypeSystemPolicy.IsObjectLike(value))
         return false;
     if (IsDefined(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
@@ -252,10 +252,10 @@ function TObject(schema, references, value) {
         return true;
     }
 }
-function TPromise(schema, references, value) {
+function FromPromise(schema, references, value) {
     return IsPromise(value);
 }
-function TRecord(schema, references, value) {
+function FromRecord(schema, references, value) {
     if (!TypeSystemPolicy.IsRecordLike(value)) {
         return false;
     }
@@ -282,10 +282,10 @@ function TRecord(schema, references, value) {
         : true;
     return check1 && check2 && check3;
 }
-function TRef(schema, references, value) {
+function FromRef(schema, references, value) {
     return Visit(Deref(schema, references), references, value);
 }
-function TString(schema, references, value) {
+function FromString(schema, references, value) {
     if (!IsString(value)) {
         return false;
     }
@@ -310,16 +310,16 @@ function TString(schema, references, value) {
     }
     return true;
 }
-function TSymbol(schema, references, value) {
+function FromSymbol(schema, references, value) {
     return IsSymbol(value);
 }
-function TTemplateLiteral(schema, references, value) {
+function FromTemplateLiteral(schema, references, value) {
     return IsString(value) && new RegExp(schema.pattern).test(value);
 }
-function TThis(schema, references, value) {
+function FromThis(schema, references, value) {
     return Visit(Deref(schema, references), references, value);
 }
-function TTuple(schema, references, value) {
+function FromTuple(schema, references, value) {
     if (!IsArray(value)) {
         return false;
     }
@@ -338,13 +338,13 @@ function TTuple(schema, references, value) {
     }
     return true;
 }
-function TUndefined(schema, references, value) {
+function FromUndefined(schema, references, value) {
     return IsUndefined(value);
 }
-function TUnion(schema, references, value) {
+function FromUnion(schema, references, value) {
     return schema.anyOf.some((inner) => Visit(inner, references, value));
 }
-function TUint8Array(schema, references, value) {
+function FromUint8Array(schema, references, value) {
     if (!IsUint8Array(value)) {
         return false;
     }
@@ -356,13 +356,13 @@ function TUint8Array(schema, references, value) {
     }
     return true;
 }
-function TUnknown(schema, references, value) {
+function FromUnknown(schema, references, value) {
     return true;
 }
-function TVoid(schema, references, value) {
+function FromVoid(schema, references, value) {
     return TypeSystemPolicy.IsVoidLike(value);
 }
-function TKind(schema, references, value) {
+function FromKind(schema, references, value) {
     if (!TypeRegistry.Has(schema[Kind]))
         return false;
     const func = TypeRegistry.Get(schema[Kind]);
@@ -373,69 +373,69 @@ function Visit(schema, references, value) {
     const schema_ = schema;
     switch (schema_[Kind]) {
         case 'Any':
-            return TAny(schema_, references_, value);
+            return FromAny(schema_, references_, value);
         case 'Array':
-            return TArray(schema_, references_, value);
+            return FromArray(schema_, references_, value);
         case 'AsyncIterator':
-            return TAsyncIterator(schema_, references_, value);
+            return FromAsyncIterator(schema_, references_, value);
         case 'BigInt':
-            return TBigInt(schema_, references_, value);
+            return FromBigInt(schema_, references_, value);
         case 'Boolean':
-            return TBoolean(schema_, references_, value);
+            return FromBoolean(schema_, references_, value);
         case 'Constructor':
-            return TConstructor(schema_, references_, value);
+            return FromConstructor(schema_, references_, value);
         case 'Date':
-            return TDate(schema_, references_, value);
+            return FromDate(schema_, references_, value);
         case 'Function':
-            return TFunction(schema_, references_, value);
+            return FromFunction(schema_, references_, value);
         case 'Integer':
-            return TInteger(schema_, references_, value);
+            return FromInteger(schema_, references_, value);
         case 'Intersect':
-            return TIntersect(schema_, references_, value);
+            return FromIntersect(schema_, references_, value);
         case 'Iterator':
-            return TIterator(schema_, references_, value);
+            return FromIterator(schema_, references_, value);
         case 'Literal':
-            return TLiteral(schema_, references_, value);
+            return FromLiteral(schema_, references_, value);
         case 'Never':
-            return TNever(schema_, references_, value);
+            return FromNever(schema_, references_, value);
         case 'Not':
-            return TNot(schema_, references_, value);
+            return FromNot(schema_, references_, value);
         case 'Null':
-            return TNull(schema_, references_, value);
+            return FromNull(schema_, references_, value);
         case 'Number':
-            return TNumber(schema_, references_, value);
+            return FromNumber(schema_, references_, value);
         case 'Object':
-            return TObject(schema_, references_, value);
+            return FromObject(schema_, references_, value);
         case 'Promise':
-            return TPromise(schema_, references_, value);
+            return FromPromise(schema_, references_, value);
         case 'Record':
-            return TRecord(schema_, references_, value);
+            return FromRecord(schema_, references_, value);
         case 'Ref':
-            return TRef(schema_, references_, value);
+            return FromRef(schema_, references_, value);
         case 'String':
-            return TString(schema_, references_, value);
+            return FromString(schema_, references_, value);
         case 'Symbol':
-            return TSymbol(schema_, references_, value);
+            return FromSymbol(schema_, references_, value);
         case 'TemplateLiteral':
-            return TTemplateLiteral(schema_, references_, value);
+            return FromTemplateLiteral(schema_, references_, value);
         case 'This':
-            return TThis(schema_, references_, value);
+            return FromThis(schema_, references_, value);
         case 'Tuple':
-            return TTuple(schema_, references_, value);
+            return FromTuple(schema_, references_, value);
         case 'Undefined':
-            return TUndefined(schema_, references_, value);
+            return FromUndefined(schema_, references_, value);
         case 'Union':
-            return TUnion(schema_, references_, value);
+            return FromUnion(schema_, references_, value);
         case 'Uint8Array':
-            return TUint8Array(schema_, references_, value);
+            return FromUint8Array(schema_, references_, value);
         case 'Unknown':
-            return TUnknown(schema_, references_, value);
+            return FromUnknown(schema_, references_, value);
         case 'Void':
-            return TVoid(schema_, references_, value);
+            return FromVoid(schema_, references_, value);
         default:
             if (!TypeRegistry.Has(schema_[Kind]))
                 throw new ValueCheckUnknownTypeError(schema_);
-            return TKind(schema_, references_, value);
+            return FromKind(schema_, references_, value);
     }
 }
 /** Returns true if the value matches the given type. */

package/build/import/value/clean/clean.mjs

@@ -22,12 +22,12 @@ function IsCheckable(schema) {
 // ------------------------------------------------------------------
 // Types
 // ------------------------------------------------------------------
-function TArray(schema, references, value) {
+function FromArray(schema, references, value) {
     if (!IsArray(value))
         return value;
     return value.map((value) => Visit(schema.items, references, value));
 }
-function TIntersect(schema, references, value) {
+function FromIntersect(schema, references, value) {
     const unevaluatedProperties = schema.unevaluatedProperties;
     const intersections = schema.allOf.map((schema) => Visit(schema, references, Clone(value)));
     const composite = intersections.reduce((acc, value) => (IsObject(value) ? { ...acc, ...value } : value), {});
@@ -43,7 +43,7 @@ function TIntersect(schema, references, value) {
     }
     return composite;
 }
-function TObject(schema, references, value) {
+function FromObject(schema, references, value) {
     if (!IsObject(value) || IsArray(value))
         return value; // Check IsArray for AllowArrayObject configuration
     const additionalProperties = schema.additionalProperties;
@@ -60,7 +60,7 @@ function TObject(schema, references, value) {
     }
     return value;
 }
-function TRecord(schema, references, value) {
+function FromRecord(schema, references, value) {
     if (!IsObject(value))
         return value;
     const additionalProperties = schema.additionalProperties;
@@ -80,13 +80,13 @@ function TRecord(schema, references, value) {
     }
     return value;
 }
-function TRef(schema, references, value) {
+function FromRef(schema, references, value) {
     return Visit(Deref(schema, references), references, value);
 }
-function TThis(schema, references, value) {
+function FromThis(schema, references, value) {
     return Visit(Deref(schema, references), references, value);
 }
-function TTuple(schema, references, value) {
+function FromTuple(schema, references, value) {
     if (!IsArray(value))
         return value;
     if (IsUndefined(schema.items))
@@ -100,7 +100,7 @@ function TTuple(schema, references, value) {
         ? value.slice(0, length)
         : value;
 }
-function TUnion(schema, references, value) {
+function FromUnion(schema, references, value) {
     for (const inner of schema.anyOf) {
         if (IsCheckable(inner) && Check(inner, value)) {
             return Visit(inner, references, value);
@@ -113,21 +113,21 @@ function Visit(schema, references, value) {
     const schema_ = schema;
     switch (schema_[Kind]) {
         case 'Array':
-            return TArray(schema_, references_, value);
+            return FromArray(schema_, references_, value);
         case 'Intersect':
-            return TIntersect(schema_, references_, value);
+            return FromIntersect(schema_, references_, value);
         case 'Object':
-            return TObject(schema_, references_, value);
+            return FromObject(schema_, references_, value);
         case 'Record':
-            return TRecord(schema_, references_, value);
+            return FromRecord(schema_, references_, value);
         case 'Ref':
-            return TRef(schema_, references_, value);
+            return FromRef(schema_, references_, value);
         case 'This':
-            return TThis(schema_, references_, value);
+            return FromThis(schema_, references_, value);
         case 'Tuple':
-            return TTuple(schema_, references_, value);
+            return FromTuple(schema_, references_, value);
         case 'Union':
-            return TUnion(schema_, references_, value);
+            return FromUnion(schema_, references_, value);
         default:
             return value;
     }