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

package/build/require/errors/errors.js

@@ -133,8 +133,8 @@ function Create(type, schema, path, value) {
 // --------------------------------------------------------------------------
 // Types
 // --------------------------------------------------------------------------
-function* TAny(schema, references, path, value) { }
-function* TArray(schema, references, path, value) {
+function* FromAny(schema, references, path, value) { }
+function* FromArray(schema, references, path, value) {
     if (!(0, index_8.IsArray)(value)) {
         return yield Create(ValueErrorType.Array, schema, path, value);
     }
@@ -175,11 +175,11 @@ function* TArray(schema, references, path, value) {
         yield Create(ValueErrorType.ArrayMaxContains, schema, path, value);
     }
 }
-function* TAsyncIterator(schema, references, path, value) {
+function* FromAsyncIterator(schema, references, path, value) {
     if (!(0, index_8.IsAsyncIterator)(value))
         yield Create(ValueErrorType.AsyncIterator, schema, path, value);
 }
-function* TBigInt(schema, references, path, value) {
+function* FromBigInt(schema, references, path, value) {
     if (!(0, index_8.IsBigInt)(value))
         return yield Create(ValueErrorType.BigInt, schema, path, value);
     if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
@@ -198,14 +198,14 @@ function* TBigInt(schema, references, path, value) {
         yield Create(ValueErrorType.BigIntMultipleOf, schema, path, value);
     }
 }
-function* TBoolean(schema, references, path, value) {
+function* FromBoolean(schema, references, path, value) {
     if (!(0, index_8.IsBoolean)(value))
         yield Create(ValueErrorType.Boolean, schema, path, value);
 }
-function* TConstructor(schema, references, path, value) {
+function* FromConstructor(schema, references, path, value) {
     yield* Visit(schema.returns, references, path, value.prototype);
 }
-function* TDate(schema, references, path, value) {
+function* FromDate(schema, references, path, value) {
     if (!(0, index_8.IsDate)(value))
         return yield Create(ValueErrorType.Date, schema, path, value);
     if (IsDefined(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
@@ -224,11 +224,11 @@ function* TDate(schema, references, path, value) {
         yield Create(ValueErrorType.DateMultipleOfTimestamp, schema, path, value);
     }
 }
-function* TFunction(schema, references, path, value) {
+function* FromFunction(schema, references, path, value) {
     if (!(0, index_8.IsFunction)(value))
         yield Create(ValueErrorType.Function, schema, path, value);
 }
-function* TInteger(schema, references, path, value) {
+function* FromInteger(schema, references, path, value) {
     if (!(0, index_8.IsInteger)(value))
         return yield Create(ValueErrorType.Integer, schema, path, value);
     if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
@@ -247,7 +247,7 @@ function* TInteger(schema, references, path, value) {
         yield Create(ValueErrorType.IntegerMultipleOf, schema, path, value);
     }
 }
-function* TIntersect(schema, references, path, value) {
+function* FromIntersect(schema, references, path, value) {
     for (const inner of schema.allOf) {
         const next = Visit(inner, references, path, value).next();
         if (!next.done) {
@@ -274,26 +274,26 @@ function* TIntersect(schema, references, path, value) {
         }
     }
 }
-function* TIterator(schema, references, path, value) {
+function* FromIterator(schema, references, path, value) {
     if (!(0, index_8.IsIterator)(value))
         yield Create(ValueErrorType.Iterator, schema, path, value);
 }
-function* TLiteral(schema, references, path, value) {
+function* FromLiteral(schema, references, path, value) {
     if (!(value === schema.const))
         yield Create(ValueErrorType.Literal, schema, path, value);
 }
-function* TNever(schema, references, path, value) {
+function* FromNever(schema, references, path, value) {
     yield Create(ValueErrorType.Never, schema, path, value);
 }
-function* TNot(schema, references, path, value) {
+function* FromNot(schema, references, path, value) {
     if (Visit(schema.not, references, path, value).next().done === true)
         yield Create(ValueErrorType.Not, schema, path, value);
 }
-function* TNull(schema, references, path, value) {
+function* FromNull(schema, references, path, value) {
     if (!(0, index_8.IsNull)(value))
         yield Create(ValueErrorType.Null, schema, path, value);
 }
-function* TNumber(schema, references, path, value) {
+function* FromNumber(schema, references, path, value) {
     if (!index_1.TypeSystemPolicy.IsNumberLike(value))
         return yield Create(ValueErrorType.Number, schema, path, value);
     if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
@@ -312,7 +312,7 @@ function* TNumber(schema, references, path, value) {
         yield Create(ValueErrorType.NumberMultipleOf, schema, path, value);
     }
 }
-function* TObject(schema, references, path, value) {
+function* FromObject(schema, references, path, value) {
     if (!index_1.TypeSystemPolicy.IsObjectLike(value))
         return yield Create(ValueErrorType.Object, schema, path, value);
     if (IsDefined(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
@@ -358,11 +358,11 @@ function* TObject(schema, references, path, value) {
         }
     }
 }
-function* TPromise(schema, references, path, value) {
+function* FromPromise(schema, references, path, value) {
     if (!(0, index_8.IsPromise)(value))
         yield Create(ValueErrorType.Promise, schema, path, value);
 }
-function* TRecord(schema, references, path, value) {
+function* FromRecord(schema, references, path, value) {
     if (!index_1.TypeSystemPolicy.IsRecordLike(value))
         return yield Create(ValueErrorType.Object, schema, path, value);
     if (IsDefined(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
@@ -391,10 +391,10 @@ function* TRecord(schema, references, path, value) {
         }
     }
 }
-function* TRef(schema, references, path, value) {
+function* FromRef(schema, references, path, value) {
     yield* Visit((0, index_4.Deref)(schema, references), references, path, value);
 }
-function* TString(schema, references, path, value) {
+function* FromString(schema, references, path, value) {
     if (!(0, index_8.IsString)(value))
         return yield Create(ValueErrorType.String, schema, path, value);
     if (IsDefined(schema.minLength) && !(value.length >= schema.minLength)) {
@@ -421,11 +421,11 @@ function* TString(schema, references, path, value) {
         }
     }
 }
-function* TSymbol(schema, references, path, value) {
+function* FromSymbol(schema, references, path, value) {
     if (!(0, index_8.IsSymbol)(value))
         yield Create(ValueErrorType.Symbol, schema, path, value);
 }
-function* TTemplateLiteral(schema, references, path, value) {
+function* FromTemplateLiteral(schema, references, path, value) {
     if (!(0, index_8.IsString)(value))
         return yield Create(ValueErrorType.String, schema, path, value);
     const regex = new RegExp(schema.pattern);
@@ -433,10 +433,10 @@ function* TTemplateLiteral(schema, references, path, value) {
         yield Create(ValueErrorType.StringPattern, schema, path, value);
     }
 }
-function* TThis(schema, references, path, value) {
+function* FromThis(schema, references, path, value) {
     yield* Visit((0, index_4.Deref)(schema, references), references, path, value);
 }
-function* TTuple(schema, references, path, value) {
+function* FromTuple(schema, references, path, value) {
     if (!(0, index_8.IsArray)(value))
         return yield Create(ValueErrorType.Tuple, schema, path, value);
     if (schema.items === undefined && !(value.length === 0)) {
@@ -452,11 +452,11 @@ function* TTuple(schema, references, path, value) {
         yield* Visit(schema.items[i], references, `${path}/${i}`, value[i]);
     }
 }
-function* TUndefined(schema, references, path, value) {
+function* FromUndefined(schema, references, path, value) {
     if (!(0, index_8.IsUndefined)(value))
         yield Create(ValueErrorType.Undefined, schema, path, value);
 }
-function* TUnion(schema, references, path, value) {
+function* FromUnion(schema, references, path, value) {
     let count = 0;
     for (const subschema of schema.anyOf) {
         const errors = [...Visit(subschema, references, path, value)];
@@ -468,7 +468,7 @@ function* TUnion(schema, references, path, value) {
         yield Create(ValueErrorType.Union, schema, path, value);
     }
 }
-function* TUint8Array(schema, references, path, value) {
+function* FromUint8Array(schema, references, path, value) {
     if (!(0, index_8.IsUint8Array)(value))
         return yield Create(ValueErrorType.Uint8Array, schema, path, value);
     if (IsDefined(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) {
@@ -478,12 +478,12 @@ function* TUint8Array(schema, references, path, value) {
         yield Create(ValueErrorType.Uint8ArrayMinByteLength, schema, path, value);
     }
 }
-function* TUnknown(schema, references, path, value) { }
-function* TVoid(schema, references, path, value) {
+function* FromUnknown(schema, references, path, value) { }
+function* FromVoid(schema, references, path, value) {
     if (!index_1.TypeSystemPolicy.IsVoidLike(value))
         yield Create(ValueErrorType.Void, schema, path, value);
 }
-function* TKind(schema, references, path, value) {
+function* FromKind(schema, references, path, value) {
     const check = index_3.TypeRegistry.Get(schema[index_6.Kind]);
     if (!check(schema, value))
         yield Create(ValueErrorType.Kind, schema, path, value);
@@ -493,69 +493,69 @@ function* Visit(schema, references, path, value) {
     const schema_ = schema;
     switch (schema_[index_6.Kind]) {
         case 'Any':
-            return yield* TAny(schema_, references_, path, value);
+            return yield* FromAny(schema_, references_, path, value);
         case 'Array':
-            return yield* TArray(schema_, references_, path, value);
+            return yield* FromArray(schema_, references_, path, value);
         case 'AsyncIterator':
-            return yield* TAsyncIterator(schema_, references_, path, value);
+            return yield* FromAsyncIterator(schema_, references_, path, value);
         case 'BigInt':
-            return yield* TBigInt(schema_, references_, path, value);
+            return yield* FromBigInt(schema_, references_, path, value);
         case 'Boolean':
-            return yield* TBoolean(schema_, references_, path, value);
+            return yield* FromBoolean(schema_, references_, path, value);
         case 'Constructor':
-            return yield* TConstructor(schema_, references_, path, value);
+            return yield* FromConstructor(schema_, references_, path, value);
         case 'Date':
-            return yield* TDate(schema_, references_, path, value);
+            return yield* FromDate(schema_, references_, path, value);
         case 'Function':
-            return yield* TFunction(schema_, references_, path, value);
+            return yield* FromFunction(schema_, references_, path, value);
         case 'Integer':
-            return yield* TInteger(schema_, references_, path, value);
+            return yield* FromInteger(schema_, references_, path, value);
         case 'Intersect':
-            return yield* TIntersect(schema_, references_, path, value);
+            return yield* FromIntersect(schema_, references_, path, value);
         case 'Iterator':
-            return yield* TIterator(schema_, references_, path, value);
+            return yield* FromIterator(schema_, references_, path, value);
         case 'Literal':
-            return yield* TLiteral(schema_, references_, path, value);
+            return yield* FromLiteral(schema_, references_, path, value);
         case 'Never':
-            return yield* TNever(schema_, references_, path, value);
+            return yield* FromNever(schema_, references_, path, value);
         case 'Not':
-            return yield* TNot(schema_, references_, path, value);
+            return yield* FromNot(schema_, references_, path, value);
         case 'Null':
-            return yield* TNull(schema_, references_, path, value);
+            return yield* FromNull(schema_, references_, path, value);
         case 'Number':
-            return yield* TNumber(schema_, references_, path, value);
+            return yield* FromNumber(schema_, references_, path, value);
         case 'Object':
-            return yield* TObject(schema_, references_, path, value);
+            return yield* FromObject(schema_, references_, path, value);
         case 'Promise':
-            return yield* TPromise(schema_, references_, path, value);
+            return yield* FromPromise(schema_, references_, path, value);
         case 'Record':
-            return yield* TRecord(schema_, references_, path, value);
+            return yield* FromRecord(schema_, references_, path, value);
         case 'Ref':
-            return yield* TRef(schema_, references_, path, value);
+            return yield* FromRef(schema_, references_, path, value);
         case 'String':
-            return yield* TString(schema_, references_, path, value);
+            return yield* FromString(schema_, references_, path, value);
         case 'Symbol':
-            return yield* TSymbol(schema_, references_, path, value);
+            return yield* FromSymbol(schema_, references_, path, value);
         case 'TemplateLiteral':
-            return yield* TTemplateLiteral(schema_, references_, path, value);
+            return yield* FromTemplateLiteral(schema_, references_, path, value);
         case 'This':
-            return yield* TThis(schema_, references_, path, value);
+            return yield* FromThis(schema_, references_, path, value);
         case 'Tuple':
-            return yield* TTuple(schema_, references_, path, value);
+            return yield* FromTuple(schema_, references_, path, value);
         case 'Undefined':
-            return yield* TUndefined(schema_, references_, path, value);
+            return yield* FromUndefined(schema_, references_, path, value);
         case 'Union':
-            return yield* TUnion(schema_, references_, path, value);
+            return yield* FromUnion(schema_, references_, path, value);
         case 'Uint8Array':
-            return yield* TUint8Array(schema_, references_, path, value);
+            return yield* FromUint8Array(schema_, references_, path, value);
         case 'Unknown':
-            return yield* TUnknown(schema_, references_, path, value);
+            return yield* FromUnknown(schema_, references_, path, value);
         case 'Void':
-            return yield* TVoid(schema_, references_, path, value);
+            return yield* FromVoid(schema_, references_, path, value);
         default:
             if (!index_3.TypeRegistry.Has(schema_[index_6.Kind]))
                 throw new ValueErrorsUnknownTypeError(schema);
-            return yield* TKind(schema_, references_, path, value);
+            return yield* FromKind(schema_, references_, path, value);
     }
 }
 /** Returns an iterator for each error in this value. */

package/build/require/index.d.ts

@@ -7,7 +7,7 @@ export { Any, type TAny } from './type/any/index';
 export { Array, type TArray, type ArrayOptions } from './type/array/index';
 export { AsyncIterator, type TAsyncIterator } from './type/async-iterator/index';
 export { Awaited, type TAwaited } from './type/awaited/index';
-export { BigInt, type TBigInt, BigIntOptions } from './type/bigint/index';
+export { BigInt, type TBigInt, type BigIntOptions } from './type/bigint/index';
 export { Boolean, type TBoolean } from './type/boolean/index';
 export { Composite, type TComposite } from './type/composite/index';
 export { Const, type TConst } from './type/const/index';
@@ -36,12 +36,12 @@ export { Null, type TNull } from './type/null/index';
 export { Number, type TNumber, type NumberOptions } from './type/number/index';
 export { Object, type TObject, type TProperties, type ObjectOptions } from './type/object/index';
 export { Omit, type TOmit, type TOmitFromMappedKey } from './type/omit/index';
-export { Optional, type TOptional } from './type/optional/index';
+export { Optional, OptionalFromMappedResult, type TOptional, type TOptionalWithFlag, type TOptionalFromMappedResult } from './type/optional/index';
 export { Parameters, type TParameters } from './type/parameters/index';
 export { Partial, PartialFromMappedResult, type TPartial, type TPartialFromMappedResult } from './type/partial/index';
 export { Pick, type TPick, type TPickFromMappedKey } from './type/pick/index';
 export { Promise, type TPromise } from './type/promise/index';
-export { Readonly, type TReadonly } from './type/readonly/index';
+export { Readonly, ReadonlyFromMappedResult, type TReadonly, type TReadonlyWithFlag, type TReadonlyFromMappedResult } from './type/readonly/index';
 export { ReadonlyOptional, type TReadonlyOptional } from './type/readonly-optional/index';
 export { Record, type TRecord } from './type/record/index';
 export { Recursive, type TRecursive, type TThis } from './type/recursive/index';
@@ -54,9 +54,9 @@ export { type TSchema, type TKind, type SchemaOptions, type TAnySchema } from '.
 export { type Static, type StaticDecode, type StaticEncode } from './type/static/index';
 export { Strict } from './type/strict/index';
 export { String, type TString, type StringOptions, type StringFormatOption, type StringContentEncodingOption } from './type/string/index';
-export { Symbol, type TSymbol, type SymbolValue } from './type/symbol/index';
-export { TemplateLiteral, IsTemplateLiteralFinite, TemplateLiteralParse, TemplateLiteralParseExact, TemplateLiteralGenerate, type TTemplateLiteral, type TTemplateLiteralKind } from './type/template-literal/index';
-export { Transform, type TTransform, type TransformOptions, type TransformFunction, TransformDecodeBuilder, TransformEncodeBuilder } from './type/transform/index';
+export { Symbol, type TSymbol, type TSymbolValue as SymbolValue } from './type/symbol/index';
+export { TemplateLiteral, IsTemplateLiteralFinite, IsTemplateLiteralExpressionFinite, TemplateLiteralParse, TemplateLiteralParseExact, TemplateLiteralGenerate, TemplateLiteralExpressionGenerate, type TTemplateLiteral, type TIsTemplateLiteralFinite, type TTemplateLiteralGenerate, type TTemplateLiteralKind, } from './type/template-literal/index';
+export { Transform, TransformDecodeBuilder, TransformEncodeBuilder, type TTransform, type TransformOptions, type TransformFunction } from './type/transform/index';
 export { Tuple, type TTuple } from './type/tuple/index';
 export { Uint8Array, type TUint8Array, type Uint8ArrayOptions } from './type/uint8array/index';
 export { Undefined, type TUndefined } from './type/undefined/index';

package/build/require/index.js

@@ -2,8 +2,8 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Lowercase = exports.Capitalize = exports.IntrinsicFromMappedKey = exports.Intrinsic = exports.Iterator = exports.IntersectEvaluated = exports.Intersect = exports.Integer = exports.InstanceType = exports.IndexFromMappedKey = exports.IndexPropertyKeys = exports.Index = exports.Increment = exports.Function = exports.Extract = exports.ExtendsUndefinedCheck = exports.ExtendsResult = exports.ExtendsCheck = exports.Extends = exports.Exclude = exports.Enum = exports.Deref = exports.Date = exports.ConstructorParameters = exports.Constructor = exports.Const = exports.Composite = exports.Boolean = exports.BigInt = exports.Awaited = exports.AsyncIterator = exports.Array = exports.Any = exports.CloneRest = exports.CloneType = exports.ValueGuard = exports.TypeGuard = exports.FormatRegistry = exports.TypeRegistry = exports.PatternStringExact = exports.PatternString = exports.PatternNumberExact = exports.PatternNumber = exports.PatternBooleanExact = exports.PatternBoolean = exports.TransformKind = exports.OptionalKind = exports.ReadonlyKind = exports.Hint = exports.Kind = void 0;
-exports.Type = exports.Void = exports.Unsafe = exports.Unknown = exports.UnionEvaluated = exports.Union = exports.Undefined = exports.Uint8Array = exports.Tuple = exports.TransformEncodeBuilder = exports.TransformDecodeBuilder = exports.Transform = exports.TemplateLiteralGenerate = exports.TemplateLiteralParseExact = exports.TemplateLiteralParse = exports.IsTemplateLiteralFinite = exports.TemplateLiteral = exports.Symbol = exports.String = exports.Strict = exports.ReturnType = exports.Rest = exports.Required = exports.RegExp = exports.Ref = exports.Recursive = exports.Record = exports.ReadonlyOptional = exports.Readonly = exports.Promise = exports.Pick = exports.PartialFromMappedResult = exports.Partial = exports.Parameters = exports.Optional = exports.Omit = exports.Object = exports.Number = exports.Null = exports.Not = exports.Never = exports.MappedResult = exports.MappedKey = exports.Mapped = exports.Literal = exports.KeyOfPattern = exports.KeyOfPropertyKeys = exports.KeyOf = exports.Uppercase = exports.Uncapitalize = void 0;
-exports.JavaScriptTypeBuilder = exports.JsonTypeBuilder = void 0;
+exports.UnionEvaluated = exports.Union = exports.Undefined = exports.Uint8Array = exports.Tuple = exports.TransformEncodeBuilder = exports.TransformDecodeBuilder = exports.Transform = exports.TemplateLiteralExpressionGenerate = exports.TemplateLiteralGenerate = exports.TemplateLiteralParseExact = exports.TemplateLiteralParse = exports.IsTemplateLiteralExpressionFinite = exports.IsTemplateLiteralFinite = exports.TemplateLiteral = exports.Symbol = exports.String = exports.Strict = exports.ReturnType = exports.Rest = exports.Required = exports.RegExp = exports.Ref = exports.Recursive = exports.Record = exports.ReadonlyOptional = exports.ReadonlyFromMappedResult = exports.Readonly = exports.Promise = exports.Pick = exports.PartialFromMappedResult = exports.Partial = exports.Parameters = exports.OptionalFromMappedResult = exports.Optional = exports.Omit = exports.Object = exports.Number = exports.Null = exports.Not = exports.Never = exports.MappedResult = exports.MappedKey = exports.Mapped = exports.Literal = exports.KeyOfPattern = exports.KeyOfPropertyKeys = exports.KeyOf = exports.Uppercase = exports.Uncapitalize = void 0;
+exports.JavaScriptTypeBuilder = exports.JsonTypeBuilder = exports.Type = exports.Void = exports.Unsafe = exports.Unknown = void 0;
 // ------------------------------------------------------------------
 // Infrastructure
 // ------------------------------------------------------------------
@@ -115,6 +115,7 @@ var index_37 = require("./type/omit/index");
 Object.defineProperty(exports, "Omit", { enumerable: true, get: function () { return index_37.Omit; } });
 var index_38 = require("./type/optional/index");
 Object.defineProperty(exports, "Optional", { enumerable: true, get: function () { return index_38.Optional; } });
+Object.defineProperty(exports, "OptionalFromMappedResult", { enumerable: true, get: function () { return index_38.OptionalFromMappedResult; } });
 var index_39 = require("./type/parameters/index");
 Object.defineProperty(exports, "Parameters", { enumerable: true, get: function () { return index_39.Parameters; } });
 var index_40 = require("./type/partial/index");
@@ -126,6 +127,7 @@ var index_42 = require("./type/promise/index");
 Object.defineProperty(exports, "Promise", { enumerable: true, get: function () { return index_42.Promise; } });
 var index_43 = require("./type/readonly/index");
 Object.defineProperty(exports, "Readonly", { enumerable: true, get: function () { return index_43.Readonly; } });
+Object.defineProperty(exports, "ReadonlyFromMappedResult", { enumerable: true, get: function () { return index_43.ReadonlyFromMappedResult; } });
 var index_44 = require("./type/readonly-optional/index");
 Object.defineProperty(exports, "ReadonlyOptional", { enumerable: true, get: function () { return index_44.ReadonlyOptional; } });
 var index_45 = require("./type/record/index");
@@ -151,9 +153,11 @@ Object.defineProperty(exports, "Symbol", { enumerable: true, get: function () {
 var index_55 = require("./type/template-literal/index");
 Object.defineProperty(exports, "TemplateLiteral", { enumerable: true, get: function () { return index_55.TemplateLiteral; } });
 Object.defineProperty(exports, "IsTemplateLiteralFinite", { enumerable: true, get: function () { return index_55.IsTemplateLiteralFinite; } });
+Object.defineProperty(exports, "IsTemplateLiteralExpressionFinite", { enumerable: true, get: function () { return index_55.IsTemplateLiteralExpressionFinite; } });
 Object.defineProperty(exports, "TemplateLiteralParse", { enumerable: true, get: function () { return index_55.TemplateLiteralParse; } });
 Object.defineProperty(exports, "TemplateLiteralParseExact", { enumerable: true, get: function () { return index_55.TemplateLiteralParseExact; } });
 Object.defineProperty(exports, "TemplateLiteralGenerate", { enumerable: true, get: function () { return index_55.TemplateLiteralGenerate; } });
+Object.defineProperty(exports, "TemplateLiteralExpressionGenerate", { enumerable: true, get: function () { return index_55.TemplateLiteralExpressionGenerate; } });
 var index_56 = require("./type/transform/index");
 Object.defineProperty(exports, "Transform", { enumerable: true, get: function () { return index_56.Transform; } });
 Object.defineProperty(exports, "TransformDecodeBuilder", { enumerable: true, get: function () { return index_56.TransformDecodeBuilder; } });

package/build/require/type/indexed/indexed-property-keys.d.ts

@@ -1,10 +1,10 @@
-import { type TTemplateLiteral, TemplateLiteralGenerate, IsTemplateLiteralFinite } from '../template-literal/index';
+import { type TTemplateLiteral, TTemplateLiteralGenerate } from '../template-literal/index';
 import { type TLiteral, type TLiteralValue } from '../literal/index';
 import { type TInteger } from '../integer/index';
 import { type TNumber } from '../number/index';
 import { type TSchema } from '../schema/index';
 import { type TUnion } from '../union/index';
-type FromTemplateLiteral<T extends TTemplateLiteral, F = IsTemplateLiteralFinite<T>> = (F extends true ? TemplateLiteralGenerate<T> extends infer R extends string[] ? R : [] : []);
+type FromTemplateLiteral<T extends TTemplateLiteral, R extends string[] = TTemplateLiteralGenerate<T>> = (R);
 declare function FromTemplateLiteral<T extends TTemplateLiteral>(T: T): FromTemplateLiteral<T>;
 type FromUnion<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [...TIndexPropertyKeys<L>, ...FromUnion<R>] : []);
 declare function FromUnion<T extends TSchema[]>(T: T): FromUnion<T>;

package/build/require/type/indexed/indexed-property-keys.js

@@ -10,14 +10,8 @@ const index_1 = require("../template-literal/index");
 const type_1 = require("../guard/type");
 // prettier-ignore
 function FromTemplateLiteral(T) {
-    const E = (0, index_1.TemplateLiteralParseExact)(T.pattern);
-    const F = (0, index_1.IsTemplateLiteralFinite)(E);
-    const S = (0, index_1.TemplateLiteralToUnion)(T);
-    return (F === true
-        ? (0, type_1.IsUnionLiteral)(S)
-            ? S.anyOf.map(S => S.const.toString())
-            : []
-        : []);
+    const R = (0, index_1.TemplateLiteralGenerate)(T);
+    return R.map(S => S.toString());
 }
 // prettier-ignore
 function FromUnion(T) {
@@ -28,7 +22,8 @@ function FromUnion(T) {
 }
 // prettier-ignore
 function FromLiteral(T) {
-    return ([T.toString()]);
+    return ([T.toString()] // TS 5.4 observes TLiteralValue as not having a toString()
+    );
 }
 /** Returns a tuple of PropertyKeys derived from the given TSchema */
 // prettier-ignore

package/build/require/type/intrinsic/intrinsic.js

@@ -32,10 +32,10 @@ function FromTemplateLiteral(schema, mode, options) {
     // note: template literals require special runtime handling as they are encoded in string patterns.
     // This diverges from the mapped type which would otherwise map on the template literal kind.
     const expression = (0, index_1.TemplateLiteralParseExact)(schema.pattern);
-    const finite = (0, index_1.IsTemplateLiteralFinite)(expression);
+    const finite = (0, index_1.IsTemplateLiteralExpressionFinite)(expression);
     if (!finite)
         return { ...schema, pattern: FromLiteralValue(schema.pattern, mode) };
-    const strings = [...(0, index_1.TemplateLiteralGenerate)(expression)];
+    const strings = [...(0, index_1.TemplateLiteralExpressionGenerate)(expression)];
     const literals = strings.map((value) => (0, index_2.Literal)(value));
     const mapped = FromRest(literals, mode);
     const union = (0, index_3.Union)(mapped);

package/build/require/type/optional/index.d.ts

@@ -1 +1,2 @@
+export * from './optional-from-mapped-result';
 export * from './optional';

package/build/require/type/optional/index.js

@@ -15,4 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./optional-from-mapped-result"), exports);
 __exportStar(require("./optional"), exports);

package/build/require/type/optional/optional-from-mapped-result.d.ts

@@ -0,0 +1,12 @@
+import type { TProperties } from '../object/index';
+import { type TMappedResult } from '../mapped/index';
+import { type TOptionalWithFlag } from './optional';
+type FromProperties<K extends TProperties, F extends boolean> = ({
+    [K2 in keyof K]: TOptionalWithFlag<K[K2], F>;
+});
+declare function FromProperties<K extends TProperties, F extends boolean>(K: K, F: F): FromProperties<K, F>;
+type FromMappedResult<K extends TMappedResult, F extends boolean> = (FromProperties<K['properties'], F>);
+declare function FromMappedResult<K extends TMappedResult, F extends boolean>(K: K, F: F): FromMappedResult<K, F>;
+export type TOptionalFromMappedResult<T extends TMappedResult, F extends boolean, P extends TProperties = FromMappedResult<T, F>> = (TMappedResult<P>);
+export declare function OptionalFromMappedResult<T extends TMappedResult, F extends boolean, P extends TProperties = FromMappedResult<T, F>>(T: T, F: F): TMappedResult<P>;
+export {};

package/build/require/type/optional/optional-from-mapped-result.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptionalFromMappedResult = void 0;
+const index_1 = require("../mapped/index");
+const optional_1 = require("./optional");
+// prettier-ignore
+function FromProperties(K, F) {
+    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
+        return { ...Acc, [K2]: (0, optional_1.Optional)(K[K2], F) };
+    }, {});
+}
+// prettier-ignore
+function FromMappedResult(K, F) {
+    return FromProperties(K.properties, F);
+}
+// prettier-ignore
+function OptionalFromMappedResult(T, F) {
+    const P = FromMappedResult(T, F);
+    return (0, index_1.MappedResult)(P);
+}
+exports.OptionalFromMappedResult = OptionalFromMappedResult;

package/build/require/type/optional/optional.d.ts

@@ -1,7 +1,24 @@
 import type { TSchema } from '../schema/index';
+import type { Ensure } from '../helpers/index';
 import { OptionalKind } from '../symbols/index';
+import type { TMappedResult } from '../mapped/index';
+import { type TOptionalFromMappedResult } from './optional-from-mapped-result';
+type RemoveOptional<T extends TSchema> = T extends TOptional<infer S> ? S : T;
+declare function RemoveOptional<T extends TSchema>(schema: T): Record<PropertyKey, any>;
+type AddOptional<T extends TSchema> = T extends TOptional<infer S> ? TOptional<S> : Ensure<TOptional<T>>;
+declare function AddOptional<T extends TSchema>(schema: T): T & {
+    [OptionalKind]: string;
+};
+export type TOptionalWithFlag<T extends TSchema, F extends boolean> = F extends false ? RemoveOptional<T> : AddOptional<T>;
 export type TOptional<T extends TSchema> = T & {
     [OptionalKind]: 'Optional';
 };
-/** `[Json]` Creates an Optional property */
-export declare function Optional<T extends TSchema>(schema: T): TOptional<T>;
+/** `[Json]` Creates a Optional property */
+export declare function Optional<T extends TMappedResult, F extends boolean>(schema: T, enable: F): TOptionalFromMappedResult<T, F>;
+/** `[Json]` Creates a Optional property */
+export declare function Optional<T extends TSchema, F extends boolean>(schema: T, enable: F): TOptionalWithFlag<T, F>;
+/** `[Json]` Creates a Optional property */
+export declare function Optional<T extends TMappedResult>(schema: T): TOptionalFromMappedResult<T, true>;
+/** `[Json]` Creates a Optional property */
+export declare function Optional<T extends TSchema>(schema: T): TOptionalWithFlag<T, true>;
+export {};

package/build/require/type/optional/optional.js

@@ -4,8 +4,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Optional = void 0;
 const index_1 = require("../symbols/index");
 const type_1 = require("../clone/type");
-/** `[Json]` Creates an Optional property */
-function Optional(schema) {
+const index_2 = require("../discard/index");
+const optional_from_mapped_result_1 = require("./optional-from-mapped-result");
+const type_2 = require("../guard/type");
+function RemoveOptional(schema) {
+    return (0, index_2.Discard)((0, type_1.CloneType)(schema), [index_1.OptionalKind]);
+}
+function AddOptional(schema) {
     return { ...(0, type_1.CloneType)(schema), [index_1.OptionalKind]: 'Optional' };
 }
+// prettier-ignore
+function OptionalWithFlag(schema, F) {
+    return (F === false
+        ? RemoveOptional(schema)
+        : AddOptional(schema));
+}
+/** `[Json]` Creates a Optional property */
+function Optional(schema, enable) {
+    const F = enable ?? true;
+    return (0, type_2.IsMappedResult)(schema) ? (0, optional_from_mapped_result_1.OptionalFromMappedResult)(schema, F) : OptionalWithFlag(schema, F);
+}
 exports.Optional = Optional;

package/build/require/type/readonly/index.d.ts

@@ -1 +1,2 @@
+export * from './readonly-from-mapped-result';
 export * from './readonly';

package/build/require/type/readonly/index.js

@@ -15,4 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./readonly-from-mapped-result"), exports);
 __exportStar(require("./readonly"), exports);

package/build/require/type/readonly/readonly-from-mapped-result.d.ts

@@ -0,0 +1,12 @@
+import type { TProperties } from '../object/index';
+import { type TMappedResult } from '../mapped/index';
+import { type TReadonlyWithFlag } from './readonly';
+type FromProperties<K extends TProperties, F extends boolean> = ({
+    [K2 in keyof K]: TReadonlyWithFlag<K[K2], F>;
+});
+declare function FromProperties<K extends TProperties, F extends boolean>(K: K, F: F): FromProperties<K, F>;
+type FromMappedResult<K extends TMappedResult, F extends boolean> = (FromProperties<K['properties'], F>);
+declare function FromMappedResult<K extends TMappedResult, F extends boolean>(K: K, F: F): FromMappedResult<K, F>;
+export type TReadonlyFromMappedResult<T extends TMappedResult, F extends boolean, P extends TProperties = FromMappedResult<T, F>> = (TMappedResult<P>);
+export declare function ReadonlyFromMappedResult<T extends TMappedResult, F extends boolean, P extends TProperties = FromMappedResult<T, F>>(T: T, F: F): TMappedResult<P>;
+export {};

package/build/require/type/readonly/readonly-from-mapped-result.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReadonlyFromMappedResult = void 0;
+const index_1 = require("../mapped/index");
+const readonly_1 = require("./readonly");
+// prettier-ignore
+function FromProperties(K, F) {
+    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
+        return { ...Acc, [K2]: (0, readonly_1.Readonly)(K[K2], F) };
+    }, {});
+}
+// prettier-ignore
+function FromMappedResult(K, F) {
+    return FromProperties(K.properties, F);
+}
+// prettier-ignore
+function ReadonlyFromMappedResult(T, F) {
+    const P = FromMappedResult(T, F);
+    return (0, index_1.MappedResult)(P);
+}
+exports.ReadonlyFromMappedResult = ReadonlyFromMappedResult;

package/build/require/type/readonly/readonly.d.ts

@@ -1,7 +1,24 @@
 import type { TSchema } from '../schema/index';
+import type { Ensure } from '../helpers/index';
 import { ReadonlyKind } from '../symbols/index';
+import type { TMappedResult } from '../mapped/index';
+import { type TReadonlyFromMappedResult } from './readonly-from-mapped-result';
+type RemoveReadonly<T extends TSchema> = T extends TReadonly<infer S> ? S : T;
+declare function RemoveReadonly<T extends TSchema>(schema: T): Record<PropertyKey, any>;
+type AddReadonly<T extends TSchema> = T extends TReadonly<infer S> ? TReadonly<S> : Ensure<TReadonly<T>>;
+declare function AddReadonly<T extends TSchema>(schema: T): T & {
+    [ReadonlyKind]: string;
+};
+export type TReadonlyWithFlag<T extends TSchema, F extends boolean> = F extends false ? RemoveReadonly<T> : AddReadonly<T>;
 export type TReadonly<T extends TSchema> = T & {
     [ReadonlyKind]: 'Readonly';
 };
 /** `[Json]` Creates a Readonly property */
-export declare function Readonly<T extends TSchema>(schema: T): TReadonly<T>;
+export declare function Readonly<T extends TMappedResult, F extends boolean>(schema: T, enable: F): TReadonlyFromMappedResult<T, F>;
+/** `[Json]` Creates a Readonly property */
+export declare function Readonly<T extends TSchema, F extends boolean>(schema: T, enable: F): TReadonlyWithFlag<T, F>;
+/** `[Json]` Creates a Readonly property */
+export declare function Readonly<T extends TMappedResult>(schema: T): TReadonlyFromMappedResult<T, true>;
+/** `[Json]` Creates a Readonly property */
+export declare function Readonly<T extends TSchema>(schema: T): TReadonlyWithFlag<T, true>;
+export {};