@sinclair/typebox 0.32.0-dev-1 → 0.32.0-dev-2

package/cjs/type/guard/type.js

@@ -0,0 +1,515 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TSchema = exports.TKind = exports.TVoid = exports.TUnsafe = exports.TUnknown = exports.TUint8Array = exports.TUnion = exports.TUnionLiteral = exports.TUndefined = exports.TTuple = exports.TTransform = exports.TThis = exports.TTemplateLiteral = exports.TSymbol = exports.TString = exports.TRef = exports.TRecursive = exports.TRecord = exports.TPromise = exports.TObject = exports.TNumber = exports.TNull = exports.TNot = exports.TNever = exports.TLiteral = exports.TLiteralBoolean = exports.TLiteralNumber = exports.TLiteralString = exports.TKindOf = exports.TIterator = exports.TIntersect = exports.TInteger = exports.TFunction = exports.TDate = exports.TConstructor = exports.TBoolean = exports.TBigInt = exports.TAsyncIterator = exports.TArray = exports.TAny = exports.TOptional = exports.TReadonly = exports.TypeGuardUnknownTypeError = void 0;
+const ValueGuard = require("./value");
+const index_mjs_1 = require("../symbols/index");
+class TypeGuardUnknownTypeError extends Error {
+}
+exports.TypeGuardUnknownTypeError = TypeGuardUnknownTypeError;
+const KnownTypes = [
+    'Any',
+    'Array',
+    'AsyncIterator',
+    'BigInt',
+    'Boolean',
+    'Constructor',
+    'Date',
+    'Enum',
+    'Function',
+    'Integer',
+    'Intersect',
+    'Iterator',
+    'Literal',
+    'Not',
+    'Null',
+    'Number',
+    'Object',
+    'Promise',
+    'Record',
+    'Ref',
+    'String',
+    'Symbol',
+    'TemplateLiteral',
+    'This',
+    'Tuple',
+    'Undefined',
+    'Union',
+    'Uint8Array',
+    'Unknown',
+    'Void',
+];
+function IsPattern(value) {
+    try {
+        new RegExp(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function IsControlCharacterFree(value) {
+    if (!ValueGuard.IsString(value))
+        return false;
+    for (let i = 0; i < value.length; i++) {
+        const code = value.charCodeAt(i);
+        if ((code >= 7 && code <= 13) || code === 27 || code === 127) {
+            return false;
+        }
+    }
+    return true;
+}
+function IsAdditionalProperties(value) {
+    return IsOptionalBoolean(value) || (0, index_mjs_2.TSchema)(value);
+}
+function IsOptionalBigInt(value) {
+    return ValueGuard.IsUndefined(value) || ValueGuard.IsBigInt(value);
+}
+function IsOptionalNumber(value) {
+    return ValueGuard.IsUndefined(value) || ValueGuard.IsNumber(value);
+}
+function IsOptionalBoolean(value) {
+    return ValueGuard.IsUndefined(value) || ValueGuard.IsBoolean(value);
+}
+function IsOptionalString(value) {
+    return ValueGuard.IsUndefined(value) || ValueGuard.IsString(value);
+}
+function IsOptionalPattern(value) {
+    return ValueGuard.IsUndefined(value) || (ValueGuard.IsString(value) && IsControlCharacterFree(value) && IsPattern(value));
+}
+function IsOptionalFormat(value) {
+    return ValueGuard.IsUndefined(value) || (ValueGuard.IsString(value) && IsControlCharacterFree(value));
+}
+function IsOptionalSchema(value) {
+    return ValueGuard.IsUndefined(value) || (0, index_mjs_2.TSchema)(value);
+}
+// ------------------------------------------------------------------
+// Modifiers
+// ------------------------------------------------------------------
+/** Returns true if this value has a Readonly symbol */
+function TReadonly(schema) {
+    return ValueGuard.IsObject(schema) && schema[index_mjs_1.ReadonlyKind] === 'Readonly';
+}
+exports.TReadonly = TReadonly;
+/** Returns true if this value has a Optional symbol */
+function TOptional(schema) {
+    return ValueGuard.IsObject(schema) && schema[index_mjs_1.OptionalKind] === 'Optional';
+}
+exports.TOptional = TOptional;
+// ------------------------------------------------------------------
+// Types
+// ------------------------------------------------------------------
+/** Returns true if the given value is TAny */
+function TAny(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'Any') &&
+        IsOptionalString(schema.$id));
+}
+exports.TAny = TAny;
+/** Returns true if the given value is TArray */
+function TArray(schema) {
+    return (TKindOf(schema, 'Array') &&
+        schema.type === 'array' &&
+        IsOptionalString(schema.$id) &&
+        (0, index_mjs_2.TSchema)(schema.items) &&
+        IsOptionalNumber(schema.minItems) &&
+        IsOptionalNumber(schema.maxItems) &&
+        IsOptionalBoolean(schema.uniqueItems) &&
+        IsOptionalSchema(schema.contains) &&
+        IsOptionalNumber(schema.minContains) &&
+        IsOptionalNumber(schema.maxContains));
+}
+exports.TArray = TArray;
+/** Returns true if the given value is TAsyncIterator */
+function TAsyncIterator(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'AsyncIterator') &&
+        schema.type === 'AsyncIterator' &&
+        IsOptionalString(schema.$id) &&
+        (0, index_mjs_2.TSchema)(schema.items));
+}
+exports.TAsyncIterator = TAsyncIterator;
+/** Returns true if the given value is TBigInt */
+function TBigInt(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'BigInt') &&
+        schema.type === 'bigint' &&
+        IsOptionalString(schema.$id) &&
+        IsOptionalBigInt(schema.exclusiveMaximum) &&
+        IsOptionalBigInt(schema.exclusiveMinimum) &&
+        IsOptionalBigInt(schema.maximum) &&
+        IsOptionalBigInt(schema.minimum) &&
+        IsOptionalBigInt(schema.multipleOf));
+}
+exports.TBigInt = TBigInt;
+/** Returns true if the given value is TBoolean */
+function TBoolean(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'Boolean') &&
+        schema.type === 'boolean' &&
+        IsOptionalString(schema.$id));
+}
+exports.TBoolean = TBoolean;
+/** Returns true if the given value is TConstructor */
+function TConstructor(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'Constructor') &&
+        schema.type === 'Constructor' &&
+        IsOptionalString(schema.$id) &&
+        ValueGuard.IsArray(schema.parameters) &&
+        schema.parameters.every(schema => (0, index_mjs_2.TSchema)(schema)) &&
+        (0, index_mjs_2.TSchema)(schema.returns));
+}
+exports.TConstructor = TConstructor;
+/** Returns true if the given value is TDate */
+function TDate(schema) {
+    return (TKindOf(schema, 'Date') &&
+        schema.type === 'Date' &&
+        IsOptionalString(schema.$id) &&
+        IsOptionalNumber(schema.exclusiveMaximumTimestamp) &&
+        IsOptionalNumber(schema.exclusiveMinimumTimestamp) &&
+        IsOptionalNumber(schema.maximumTimestamp) &&
+        IsOptionalNumber(schema.minimumTimestamp) &&
+        IsOptionalNumber(schema.multipleOfTimestamp));
+}
+exports.TDate = TDate;
+/** Returns true if the given value is TFunction */
+function TFunction(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'Function') &&
+        schema.type === 'Function' &&
+        IsOptionalString(schema.$id) &&
+        ValueGuard.IsArray(schema.parameters) &&
+        schema.parameters.every(schema => (0, index_mjs_2.TSchema)(schema)) &&
+        (0, index_mjs_2.TSchema)(schema.returns));
+}
+exports.TFunction = TFunction;
+/** Returns true if the given value is TInteger */
+function TInteger(schema) {
+    return (TKindOf(schema, 'Integer') &&
+        schema.type === 'integer' &&
+        IsOptionalString(schema.$id) &&
+        IsOptionalNumber(schema.exclusiveMaximum) &&
+        IsOptionalNumber(schema.exclusiveMinimum) &&
+        IsOptionalNumber(schema.maximum) &&
+        IsOptionalNumber(schema.minimum) &&
+        IsOptionalNumber(schema.multipleOf));
+}
+exports.TInteger = TInteger;
+/** Returns true if the given value is TIntersect */
+function TIntersect(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'Intersect') &&
+        (ValueGuard.IsString(schema.type) && schema.type !== 'object' ? false : true) &&
+        ValueGuard.IsArray(schema.allOf) &&
+        schema.allOf.every(schema => (0, index_mjs_2.TSchema)(schema) && !TTransform(schema)) &&
+        IsOptionalString(schema.type) &&
+        (IsOptionalBoolean(schema.unevaluatedProperties) || IsOptionalSchema(schema.unevaluatedProperties)) &&
+        IsOptionalString(schema.$id));
+}
+exports.TIntersect = TIntersect;
+/** Returns true if the given value is TIterator */
+function TIterator(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'Iterator') &&
+        schema.type === 'Iterator' &&
+        IsOptionalString(schema.$id) &&
+        (0, index_mjs_2.TSchema)(schema.items));
+}
+exports.TIterator = TIterator;
+/** Returns true if the given value is a TKind with the given name. */
+function TKindOf(schema, kind) {
+    return ValueGuard.IsObject(schema) && index_mjs_1.Kind in schema && schema[index_mjs_1.Kind] === kind;
+}
+exports.TKindOf = TKindOf;
+/** Returns true if the given value is TLiteral<string> */
+function TLiteralString(schema) {
+    return (0, index_mjs_3.TLiteral)(schema) && ValueGuard.IsString(schema.const);
+}
+exports.TLiteralString = TLiteralString;
+/** Returns true if the given value is TLiteral<number> */
+function TLiteralNumber(schema) {
+    return (0, index_mjs_3.TLiteral)(schema) && ValueGuard.IsNumber(schema.const);
+}
+exports.TLiteralNumber = TLiteralNumber;
+/** Returns true if the given value is TLiteral<boolean> */
+function TLiteralBoolean(schema) {
+    return (0, index_mjs_3.TLiteral)(schema) && ValueGuard.IsBoolean(schema.const);
+}
+exports.TLiteralBoolean = TLiteralBoolean;
+/** Returns true if the given value is TLiteral */
+function TLiteral(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'Literal') &&
+        IsOptionalString(schema.$id) && (ValueGuard.IsBoolean(schema.const) ||
+        ValueGuard.IsNumber(schema.const) ||
+        ValueGuard.IsString(schema.const)));
+}
+exports.TLiteral = TLiteral;
+/** Returns true if the given value is TNever */
+function TNever(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'Never') &&
+        ValueGuard.IsObject(schema.not) &&
+        Object.getOwnPropertyNames(schema.not).length === 0);
+}
+exports.TNever = TNever;
+/** Returns true if the given value is TNot */
+function TNot(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'Not') &&
+        (0, index_mjs_2.TSchema)(schema.not));
+}
+exports.TNot = TNot;
+/** Returns true if the given value is TNull */
+function TNull(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'Null') &&
+        schema.type === 'null' &&
+        IsOptionalString(schema.$id));
+}
+exports.TNull = TNull;
+/** Returns true if the given value is TNumber */
+function TNumber(schema) {
+    return (TKindOf(schema, 'Number') &&
+        schema.type === 'number' &&
+        IsOptionalString(schema.$id) &&
+        IsOptionalNumber(schema.exclusiveMaximum) &&
+        IsOptionalNumber(schema.exclusiveMinimum) &&
+        IsOptionalNumber(schema.maximum) &&
+        IsOptionalNumber(schema.minimum) &&
+        IsOptionalNumber(schema.multipleOf));
+}
+exports.TNumber = TNumber;
+/** Returns true if the given value is TObject */
+function TObject(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'Object') &&
+        schema.type === 'object' &&
+        IsOptionalString(schema.$id) &&
+        ValueGuard.IsObject(schema.properties) &&
+        Object.entries(schema.properties).every(([key, schema]) => IsControlCharacterFree(key) && (0, index_mjs_2.TSchema)(schema)) &&
+        IsAdditionalProperties(schema.additionalProperties) &&
+        IsOptionalNumber(schema.minProperties) &&
+        IsOptionalNumber(schema.maxProperties));
+}
+exports.TObject = TObject;
+/** Returns true if the given value is TPromise */
+function TPromise(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'Promise') &&
+        schema.type === 'Promise' &&
+        IsOptionalString(schema.$id) &&
+        (0, index_mjs_2.TSchema)(schema.item));
+}
+exports.TPromise = TPromise;
+/** Returns true if the given value is TRecord */
+function TRecord(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'Record') &&
+        schema.type === 'object' &&
+        IsOptionalString(schema.$id) &&
+        IsAdditionalProperties(schema.additionalProperties) &&
+        ValueGuard.IsObject(schema.patternProperties) &&
+        ((schema) => {
+            const keys = Object.getOwnPropertyNames(schema.patternProperties);
+            return (keys.length === 1 &&
+                IsPattern(keys[0]) &&
+                ValueGuard.IsObject(schema.patternProperties) &&
+                (0, index_mjs_2.TSchema)(schema.patternProperties[keys[0]]));
+        })(schema));
+}
+exports.TRecord = TRecord;
+/** Returns true if this value is TRecursive */
+function TRecursive(schema) {
+    return ValueGuard.IsObject(schema) && index_mjs_1.Hint in schema && schema[index_mjs_1.Hint] === 'Recursive';
+}
+exports.TRecursive = TRecursive;
+/** Returns true if the given value is TRef */
+function TRef(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'Ref') &&
+        IsOptionalString(schema.$id) &&
+        ValueGuard.IsString(schema.$ref));
+}
+exports.TRef = TRef;
+/** Returns true if the given value is TString */
+function TString(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'String') &&
+        schema.type === 'string' &&
+        IsOptionalString(schema.$id) &&
+        IsOptionalNumber(schema.minLength) &&
+        IsOptionalNumber(schema.maxLength) &&
+        IsOptionalPattern(schema.pattern) &&
+        IsOptionalFormat(schema.format));
+}
+exports.TString = TString;
+/** Returns true if the given value is TSymbol */
+function TSymbol(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'Symbol') &&
+        schema.type === 'symbol' &&
+        IsOptionalString(schema.$id));
+}
+exports.TSymbol = TSymbol;
+/** Returns true if the given value is TTemplateLiteral */
+function TTemplateLiteral(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'TemplateLiteral') &&
+        schema.type === 'string' &&
+        ValueGuard.IsString(schema.pattern) &&
+        schema.pattern[0] === '^' &&
+        schema.pattern[schema.pattern.length - 1] === '$');
+}
+exports.TTemplateLiteral = TTemplateLiteral;
+/** Returns true if the given value is TThis */
+function TThis(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'This') &&
+        IsOptionalString(schema.$id) &&
+        ValueGuard.IsString(schema.$ref));
+}
+exports.TThis = TThis;
+/** Returns true of this value is TTransform */
+function TTransform(schema) {
+    return ValueGuard.IsObject(schema) && index_mjs_1.TransformKind in schema;
+}
+exports.TTransform = TTransform;
+/** Returns true if the given value is TTuple */
+function TTuple(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'Tuple') &&
+        schema.type === 'array' &&
+        IsOptionalString(schema.$id) &&
+        ValueGuard.IsNumber(schema.minItems) &&
+        ValueGuard.IsNumber(schema.maxItems) &&
+        schema.minItems === schema.maxItems &&
+        (( // empty
+        ValueGuard.IsUndefined(schema.items) &&
+            ValueGuard.IsUndefined(schema.additionalItems) &&
+            schema.minItems === 0) || (ValueGuard.IsArray(schema.items) &&
+            schema.items.every(schema => (0, index_mjs_2.TSchema)(schema)))));
+}
+exports.TTuple = TTuple;
+/** Returns true if the given value is TUndefined */
+function TUndefined(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'Undefined') &&
+        schema.type === 'undefined' &&
+        IsOptionalString(schema.$id));
+}
+exports.TUndefined = TUndefined;
+/** Returns true if the given value is TUnion<Literal<string | number>[]> */
+function TUnionLiteral(schema) {
+    return (0, index_mjs_4.TUnion)(schema) && schema.anyOf.every((schema) => TLiteralString(schema) || TLiteralNumber(schema));
+}
+exports.TUnionLiteral = TUnionLiteral;
+/** Returns true if the given value is TUnion */
+function TUnion(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'Union') &&
+        IsOptionalString(schema.$id) &&
+        ValueGuard.IsObject(schema) &&
+        ValueGuard.IsArray(schema.anyOf) &&
+        schema.anyOf.every(schema => (0, index_mjs_2.TSchema)(schema)));
+}
+exports.TUnion = TUnion;
+/** Returns true if the given value is TUint8Array */
+function TUint8Array(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'Uint8Array') &&
+        schema.type === 'Uint8Array' &&
+        IsOptionalString(schema.$id) &&
+        IsOptionalNumber(schema.minByteLength) &&
+        IsOptionalNumber(schema.maxByteLength));
+}
+exports.TUint8Array = TUint8Array;
+/** Returns true if the given value is TUnknown */
+function TUnknown(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'Unknown') &&
+        IsOptionalString(schema.$id));
+}
+exports.TUnknown = TUnknown;
+/** Returns true if the given value is a raw TUnsafe */
+function TUnsafe(schema) {
+    return TKindOf(schema, 'Unsafe');
+}
+exports.TUnsafe = TUnsafe;
+/** Returns true if the given value is TVoid */
+function TVoid(schema) {
+    // prettier-ignore
+    return (TKindOf(schema, 'Void') &&
+        schema.type === 'void' &&
+        IsOptionalString(schema.$id));
+}
+exports.TVoid = TVoid;
+/** Returns true if the given value is TKind */
+function TKind(schema) {
+    return ValueGuard.IsObject(schema) && index_mjs_1.Kind in schema && ValueGuard.IsString(schema[index_mjs_1.Kind]) && !KnownTypes.includes(schema[index_mjs_1.Kind]);
+}
+exports.TKind = TKind;
+/** Returns true if the given value is TSchema */
+function TSchema(schema) {
+    // prettier-ignore
+    return (ValueGuard.IsObject(schema)) && ((0, index_mjs_5.TAny)(schema) ||
+        (0, index_mjs_6.TArray)(schema) ||
+        (0, index_mjs_7.TBoolean)(schema) ||
+        (0, index_mjs_8.TBigInt)(schema) ||
+        (0, index_mjs_9.TAsyncIterator)(schema) ||
+        (0, index_mjs_10.TConstructor)(schema) ||
+        (0, index_mjs_11.TDate)(schema) ||
+        (0, index_mjs_12.TFunction)(schema) ||
+        (0, index_mjs_13.TInteger)(schema) ||
+        (0, index_mjs_14.TIntersect)(schema) ||
+        (0, index_mjs_15.TIterator)(schema) ||
+        (0, index_mjs_3.TLiteral)(schema) ||
+        (0, index_mjs_16.TNever)(schema) ||
+        (0, index_mjs_17.TNot)(schema) ||
+        (0, index_mjs_18.TNull)(schema) ||
+        (0, index_mjs_19.TNumber)(schema) ||
+        (0, index_mjs_20.TObject)(schema) ||
+        (0, index_mjs_21.TPromise)(schema) ||
+        (0, index_mjs_22.TRecord)(schema) ||
+        (0, index_mjs_23.TRef)(schema) ||
+        (0, index_mjs_24.TString)(schema) ||
+        (0, index_mjs_25.TSymbol)(schema) ||
+        (0, index_mjs_26.TTemplateLiteral)(schema) ||
+        (0, index_mjs_27.TThis)(schema) ||
+        (0, index_mjs_28.TTuple)(schema) ||
+        (0, index_mjs_29.TUndefined)(schema) ||
+        (0, index_mjs_4.TUnion)(schema) ||
+        (0, index_mjs_30.TUint8Array)(schema) ||
+        (0, index_mjs_31.TUnknown)(schema) ||
+        (0, index_mjs_32.TUnsafe)(schema) ||
+        (0, index_mjs_33.TVoid)(schema) ||
+        TKind(schema));
+}
+exports.TSchema = TSchema;

package/cjs/type/indexed/indexed-key.js

@@ -0,0 +1,65 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexedKeyResolve = void 0;
+const index_mjs_1 = require("../template-literal/index");
+const type_mjs_1 = require("../guard/type");
+// prettier-ignore
+function FromTemplateLiteral(T) {
+    const E = (0, index_mjs_1.TemplateLiteralParseExact)(T.pattern);
+    const F = (0, index_mjs_1.IsTemplateLiteralFinite)(E);
+    const S = (0, index_mjs_1.TemplateLiteralToUnion)(T);
+    return (F === true
+        ? (0, type_mjs_1.TUnionLiteral)(S)
+            ? S.anyOf.map(S => S.const.toString())
+            : []
+        : []);
+}
+// prettier-ignore
+function FromUnion(T) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? [...IndexedKeyResolve(L), ...FromUnion(R)]
+        : []);
+}
+// prettier-ignore
+function FromLiteral(T) {
+    return ([T.toString()]);
+}
+/** Resolves Indexer String Keys form the given Schema. Th */
+// prettier-ignore
+function IndexedKeyResolve(T) {
+    return [...new Set(((0, type_mjs_1.TTemplateLiteral)(T) ? FromTemplateLiteral(T) :
+            (0, type_mjs_1.TUnion)(T) ? FromUnion(T.anyOf) :
+                (0, type_mjs_1.TLiteral)(T) ? FromLiteral(T.const) :
+                    (0, type_mjs_1.TNumber)(T) ? ['[number]'] :
+                        (0, type_mjs_1.TInteger)(T) ? ['[number]'] :
+                            []))];
+}
+exports.IndexedKeyResolve = IndexedKeyResolve;

package/cjs/type/indexed/indexed-type.js

@@ -0,0 +1,106 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexedTypeResolve = void 0;
+const index_mjs_1 = require("../never/index");
+const index_mjs_2 = require("../intersect/index");
+const index_mjs_3 = require("../union/index");
+const type_mjs_1 = require("../guard/type");
+// prettier-ignore
+function FromRest(T, K) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? [FromKey(L, K), ...FromRest(R, K)]
+        : []);
+}
+// prettier-ignore
+function FromIntersectRest(T) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? (0, type_mjs_1.TNever)(L)
+            ? [...FromIntersectRest(R)]
+            : [L, ...FromIntersectRest(R)]
+        : []);
+}
+// prettier-ignore
+function FromIntersect(T, K) {
+    return ((0, index_mjs_2.IntersectResolve)(FromIntersectRest(FromRest(T, K))));
+}
+// prettier-ignore
+function FromUnionRest(T, S = T) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? (0, type_mjs_1.TNever)(L)
+            ? []
+            : FromUnionRest(R, S)
+        : S);
+}
+// prettier-ignore
+function FromUnion(T, K) {
+    return ((0, index_mjs_3.UnionResolve)(FromUnionRest(FromRest(T, K))));
+}
+// prettier-ignore
+function FromTuple(T, K) {
+    return (K in T ? T[K] :
+        K === '[number]' ? (0, index_mjs_3.UnionResolve)(T) :
+            (0, index_mjs_1.Never)());
+}
+// prettier-ignore
+function FromArray(T, K) {
+    return (K === '[number]'
+        ? T
+        : (0, index_mjs_1.Never)());
+}
+// prettier-ignore
+function FromProperty(T, K) {
+    return (K in T
+        ? T[K]
+        : (0, index_mjs_1.Never)());
+}
+// prettier-ignore
+function FromKey(T, K) {
+    return ((0, type_mjs_1.TIntersect)(T) ? FromIntersect(T.allOf, K) :
+        (0, type_mjs_1.TUnion)(T) ? FromUnion(T.anyOf, K) :
+            (0, type_mjs_1.TTuple)(T) ? FromTuple(T.items ?? [], K) :
+                (0, type_mjs_1.TArray)(T) ? FromArray(T.items, K) :
+                    (0, type_mjs_1.TObject)(T) ? FromProperty(T.properties, K) :
+                        (0, index_mjs_1.Never)());
+}
+// prettier-ignore
+function FromKeys(T, K) {
+    const [L, ...R] = K;
+    return (K.length > 0
+        ? [FromKey(T, L), ...FromKeys(T, R)]
+        : []);
+}
+// prettier-ignore
+function IndexedTypeResolve(T, K) {
+    return ((0, index_mjs_3.UnionResolve)(FromKeys(T, K)));
+}
+exports.IndexedTypeResolve = IndexedTypeResolve;