@sinclair/typebox 0.34.9 → 0.34.11

package/build/cjs/compiler/compiler.js

@@ -13,10 +13,11 @@ const index_8 = require("../type/registry/index");
 const index_9 = require("../type/keyof/index");
 const extends_undefined_1 = require("../type/extends/extends-undefined");
 const index_10 = require("../type/never/index");
+const index_11 = require("../type/ref/index");
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-const index_11 = require("../value/guard/index");
+const index_12 = require("../value/guard/index");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -211,17 +212,17 @@ var TypeCompiler;
     function* FromArray(schema, references, value) {
         yield `Array.isArray(${value})`;
         const [parameter, accumulator] = [CreateParameter('value', 'any'), CreateParameter('acc', 'number')];
-        if ((0, index_11.IsNumber)(schema.maxItems))
+        if ((0, index_12.IsNumber)(schema.maxItems))
             yield `${value}.length <= ${schema.maxItems}`;
-        if ((0, index_11.IsNumber)(schema.minItems))
+        if ((0, index_12.IsNumber)(schema.minItems))
             yield `${value}.length >= ${schema.minItems}`;
         const elementExpression = CreateExpression(schema.items, references, 'value');
         yield `${value}.every((${parameter}) => ${elementExpression})`;
-        if ((0, type_1.IsSchema)(schema.contains) || (0, index_11.IsNumber)(schema.minContains) || (0, index_11.IsNumber)(schema.maxContains)) {
+        if ((0, type_1.IsSchema)(schema.contains) || (0, index_12.IsNumber)(schema.minContains) || (0, index_12.IsNumber)(schema.maxContains)) {
             const containsSchema = (0, type_1.IsSchema)(schema.contains) ? schema.contains : (0, index_10.Never)();
             const checkExpression = CreateExpression(containsSchema, references, 'value');
-            const checkMinContains = (0, index_11.IsNumber)(schema.minContains) ? [`(count >= ${schema.minContains})`] : [];
-            const checkMaxContains = (0, index_11.IsNumber)(schema.maxContains) ? [`(count <= ${schema.maxContains})`] : [];
+            const checkMinContains = (0, index_12.IsNumber)(schema.minContains) ? [`(count >= ${schema.minContains})`] : [];
+            const checkMaxContains = (0, index_12.IsNumber)(schema.maxContains) ? [`(count <= ${schema.maxContains})`] : [];
             const checkCount = `const count = value.reduce((${accumulator}, ${parameter}) => ${checkExpression} ? acc + 1 : acc, 0)`;
             const check = [`(count > 0)`, ...checkMinContains, ...checkMaxContains].join(' && ');
             yield `((${parameter}) => { ${checkCount}; return ${check}})(${value})`;
@@ -237,15 +238,15 @@ var TypeCompiler;
     }
     function* FromBigInt(schema, references, value) {
         yield `(typeof ${value} === 'bigint')`;
-        if ((0, index_11.IsBigInt)(schema.exclusiveMaximum))
+        if ((0, index_12.IsBigInt)(schema.exclusiveMaximum))
             yield `${value} < BigInt(${schema.exclusiveMaximum})`;
-        if ((0, index_11.IsBigInt)(schema.exclusiveMinimum))
+        if ((0, index_12.IsBigInt)(schema.exclusiveMinimum))
             yield `${value} > BigInt(${schema.exclusiveMinimum})`;
-        if ((0, index_11.IsBigInt)(schema.maximum))
+        if ((0, index_12.IsBigInt)(schema.maximum))
             yield `${value} <= BigInt(${schema.maximum})`;
-        if ((0, index_11.IsBigInt)(schema.minimum))
+        if ((0, index_12.IsBigInt)(schema.minimum))
             yield `${value} >= BigInt(${schema.minimum})`;
-        if ((0, index_11.IsBigInt)(schema.multipleOf))
+        if ((0, index_12.IsBigInt)(schema.multipleOf))
             yield `(${value} % BigInt(${schema.multipleOf})) === 0`;
     }
     function* FromBoolean(schema, references, value) {
@@ -256,36 +257,37 @@ var TypeCompiler;
     }
     function* FromDate(schema, references, value) {
         yield `(${value} instanceof Date) && Number.isFinite(${value}.getTime())`;
-        if ((0, index_11.IsNumber)(schema.exclusiveMaximumTimestamp))
+        if ((0, index_12.IsNumber)(schema.exclusiveMaximumTimestamp))
             yield `${value}.getTime() < ${schema.exclusiveMaximumTimestamp}`;
-        if ((0, index_11.IsNumber)(schema.exclusiveMinimumTimestamp))
+        if ((0, index_12.IsNumber)(schema.exclusiveMinimumTimestamp))
             yield `${value}.getTime() > ${schema.exclusiveMinimumTimestamp}`;
-        if ((0, index_11.IsNumber)(schema.maximumTimestamp))
+        if ((0, index_12.IsNumber)(schema.maximumTimestamp))
             yield `${value}.getTime() <= ${schema.maximumTimestamp}`;
-        if ((0, index_11.IsNumber)(schema.minimumTimestamp))
+        if ((0, index_12.IsNumber)(schema.minimumTimestamp))
             yield `${value}.getTime() >= ${schema.minimumTimestamp}`;
-        if ((0, index_11.IsNumber)(schema.multipleOfTimestamp))
+        if ((0, index_12.IsNumber)(schema.multipleOfTimestamp))
             yield `(${value}.getTime() % ${schema.multipleOfTimestamp}) === 0`;
     }
     function* FromFunction(schema, references, value) {
         yield `(typeof ${value} === 'function')`;
     }
     function* FromImport(schema, references, value) {
-        const definitions = globalThis.Object.values(schema.$defs);
-        const target = schema.$defs[schema.$ref];
-        yield* Visit(target, [...references, ...definitions], value);
+        const members = globalThis.Object.getOwnPropertyNames(schema.$defs).reduce((result, key) => {
+            return [...result, schema.$defs[key]];
+        }, []);
+        yield* Visit((0, index_11.Ref)(schema.$ref), [...references, ...members], value);
     }
     function* FromInteger(schema, references, value) {
         yield `Number.isInteger(${value})`;
-        if ((0, index_11.IsNumber)(schema.exclusiveMaximum))
+        if ((0, index_12.IsNumber)(schema.exclusiveMaximum))
             yield `${value} < ${schema.exclusiveMaximum}`;
-        if ((0, index_11.IsNumber)(schema.exclusiveMinimum))
+        if ((0, index_12.IsNumber)(schema.exclusiveMinimum))
             yield `${value} > ${schema.exclusiveMinimum}`;
-        if ((0, index_11.IsNumber)(schema.maximum))
+        if ((0, index_12.IsNumber)(schema.maximum))
             yield `${value} <= ${schema.maximum}`;
-        if ((0, index_11.IsNumber)(schema.minimum))
+        if ((0, index_12.IsNumber)(schema.minimum))
             yield `${value} >= ${schema.minimum}`;
-        if ((0, index_11.IsNumber)(schema.multipleOf))
+        if ((0, index_12.IsNumber)(schema.multipleOf))
             yield `(${value} % ${schema.multipleOf}) === 0`;
     }
     function* FromIntersect(schema, references, value) {
@@ -327,22 +329,22 @@ var TypeCompiler;
     }
     function* FromNumber(schema, references, value) {
         yield Policy.IsNumberLike(value);
-        if ((0, index_11.IsNumber)(schema.exclusiveMaximum))
+        if ((0, index_12.IsNumber)(schema.exclusiveMaximum))
             yield `${value} < ${schema.exclusiveMaximum}`;
-        if ((0, index_11.IsNumber)(schema.exclusiveMinimum))
+        if ((0, index_12.IsNumber)(schema.exclusiveMinimum))
             yield `${value} > ${schema.exclusiveMinimum}`;
-        if ((0, index_11.IsNumber)(schema.maximum))
+        if ((0, index_12.IsNumber)(schema.maximum))
             yield `${value} <= ${schema.maximum}`;
-        if ((0, index_11.IsNumber)(schema.minimum))
+        if ((0, index_12.IsNumber)(schema.minimum))
             yield `${value} >= ${schema.minimum}`;
-        if ((0, index_11.IsNumber)(schema.multipleOf))
+        if ((0, index_12.IsNumber)(schema.multipleOf))
             yield `(${value} % ${schema.multipleOf}) === 0`;
     }
     function* FromObject(schema, references, value) {
         yield Policy.IsObjectLike(value);
-        if ((0, index_11.IsNumber)(schema.minProperties))
+        if ((0, index_12.IsNumber)(schema.minProperties))
             yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`;
-        if ((0, index_11.IsNumber)(schema.maxProperties))
+        if ((0, index_12.IsNumber)(schema.maxProperties))
             yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`;
         const knownKeys = Object.getOwnPropertyNames(schema.properties);
         for (const knownKey of knownKeys) {
@@ -378,9 +380,9 @@ var TypeCompiler;
     }
     function* FromRecord(schema, references, value) {
         yield Policy.IsRecordLike(value);
-        if ((0, index_11.IsNumber)(schema.minProperties))
+        if ((0, index_12.IsNumber)(schema.minProperties))
             yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`;
-        if ((0, index_11.IsNumber)(schema.maxProperties))
+        if ((0, index_12.IsNumber)(schema.maxProperties))
             yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`;
         const [patternKey, patternSchema] = Object.entries(schema.patternProperties)[0];
         const variable = CreateVariable(`${new RegExp(patternKey)}`);
@@ -392,29 +394,25 @@ var TypeCompiler;
     function* FromRef(schema, references, value) {
         const target = (0, index_5.Deref)(schema, references);
         // Reference: If we have seen this reference before we can just yield and return the function call.
-        // If this isn't the case we defer to visit to generate and set the _recursion_end_for_ for subsequent
-        // passes. This operation is very awkward as we are using the functions state to store values to
-        // enable self referential types to terminate. This needs to be refactored.
-        const recursiveEnd = `_recursion_end_for_${schema.$ref}`;
-        if (state.functions.has(recursiveEnd))
+        // If this isn't the case we defer to visit to generate and set the function for subsequent passes.
+        if (state.functions.has(schema.$ref))
             return yield `${CreateFunctionName(schema.$ref)}(${value})`;
-        state.functions.set(recursiveEnd, ''); // terminate recursion here by setting the name.
         yield* Visit(target, references, value);
     }
     function* FromRegExp(schema, references, value) {
         const variable = CreateVariable(`${new RegExp(schema.source, schema.flags)};`);
         yield `(typeof ${value} === 'string')`;
-        if ((0, index_11.IsNumber)(schema.maxLength))
+        if ((0, index_12.IsNumber)(schema.maxLength))
             yield `${value}.length <= ${schema.maxLength}`;
-        if ((0, index_11.IsNumber)(schema.minLength))
+        if ((0, index_12.IsNumber)(schema.minLength))
             yield `${value}.length >= ${schema.minLength}`;
         yield `${variable}.test(${value})`;
     }
     function* FromString(schema, references, value) {
         yield `(typeof ${value} === 'string')`;
-        if ((0, index_11.IsNumber)(schema.maxLength))
+        if ((0, index_12.IsNumber)(schema.maxLength))
             yield `${value}.length <= ${schema.maxLength}`;
-        if ((0, index_11.IsNumber)(schema.minLength))
+        if ((0, index_12.IsNumber)(schema.minLength))
             yield `${value}.length >= ${schema.minLength}`;
         if (schema.pattern !== undefined) {
             const variable = CreateVariable(`${new RegExp(schema.pattern)};`);
@@ -455,9 +453,9 @@ var TypeCompiler;
     }
     function* FromUint8Array(schema, references, value) {
         yield `${value} instanceof Uint8Array`;
-        if ((0, index_11.IsNumber)(schema.maxByteLength))
+        if ((0, index_12.IsNumber)(schema.maxByteLength))
             yield `(${value}.length <= ${schema.maxByteLength})`;
-        if ((0, index_11.IsNumber)(schema.minByteLength))
+        if ((0, index_12.IsNumber)(schema.minByteLength))
             yield `(${value}.length >= ${schema.minByteLength})`;
     }
     function* FromUnknown(schema, references, value) {
@@ -472,17 +470,21 @@ var TypeCompiler;
         yield `kind('${schema[index_7.Kind]}', ${instance}, ${value})`;
     }
     function* Visit(schema, references, value, useHoisting = true) {
-        const references_ = (0, index_11.IsString)(schema.$id) ? [...references, schema] : references;
+        const references_ = (0, index_12.IsString)(schema.$id) ? [...references, schema] : references;
         const schema_ = schema;
         // --------------------------------------------------------------
         // Hoisting
         // --------------------------------------------------------------
-        if (useHoisting && (0, index_11.IsString)(schema.$id)) {
+        if (useHoisting && (0, index_12.IsString)(schema.$id)) {
             const functionName = CreateFunctionName(schema.$id);
             if (state.functions.has(functionName)) {
                 return yield `${functionName}(${value})`;
             }
             else {
+                // Note: In the case of cyclic types, we need to create a 'functions' record
+                // to prevent infinitely re-visiting the CreateFunction. Subsequent attempts
+                // to visit will be caught by the above condition.
+                state.functions.set(functionName, '<deferred>');
                 const functionCode = CreateFunction(functionName, schema, references, 'value', false);
                 state.functions.set(functionName, functionCode);
                 return yield `${functionName}(${value})`;
@@ -607,7 +609,7 @@ var TypeCompiler;
         const functions = [...state.functions.values()];
         const variables = [...state.variables.values()];
         // prettier-ignore
-        const checkFunction = (0, index_11.IsString)(schema.$id) // ensure top level schemas with $id's are hoisted
+        const checkFunction = (0, index_12.IsString)(schema.$id) // ensure top level schemas with $id's are hoisted
             ? `return function check(${parameter})${returns} {\n  return ${CreateFunctionName(schema.$id)}(value)\n}`
             : `return ${functionCode}`;
         return [...variables, ...functions, checkFunction].join('\n');
@@ -616,8 +618,8 @@ var TypeCompiler;
     function Code(...args) {
         const defaults = { language: 'javascript' };
         // prettier-ignore
-        const [schema, references, options] = (args.length === 2 && (0, index_11.IsArray)(args[1]) ? [args[0], args[1], defaults] :
-            args.length === 2 && !(0, index_11.IsArray)(args[1]) ? [args[0], [], args[1]] :
+        const [schema, references, options] = (args.length === 2 && (0, index_12.IsArray)(args[1]) ? [args[0], args[1], defaults] :
+            args.length === 2 && !(0, index_12.IsArray)(args[1]) ? [args[0], [], args[1]] :
                 args.length === 3 ? [args[0], args[1], args[2]] :
                     args.length === 1 ? [args[0], [], defaults] :
                         [null, [], defaults]);

package/build/cjs/syntax/runtime.d.ts

@@ -48,7 +48,7 @@ export declare const Module: Runtime.Module<{
     Iterator: Runtime.ITuple<Types.TIterator<Types.TSchema>>;
     Awaited: Runtime.ITuple<Types.TSchema>;
     Array: Runtime.ITuple<Types.TArray<Types.TSchema>>;
-    Record: Runtime.ITuple<Types.TSchema>;
+    Record: Runtime.ITuple<Types.TNever>;
     Promise: Runtime.ITuple<Types.TPromise<Types.TSchema>>;
     ConstructorParameters: Runtime.ITuple<Types.TTuple<Types.TSchema[]>>;
     FunctionParameters: Runtime.ITuple<Types.TTuple<Types.TSchema[]>>;

package/build/cjs/type/indexed/indexed-from-mapped-result.js

@@ -9,8 +9,7 @@ const index_2 = require("./index");
 function FromProperties(type, properties, options) {
     const result = {};
     for (const K2 of Object.getOwnPropertyNames(properties)) {
-        const keys = (0, indexed_property_keys_1.IndexPropertyKeys)(properties[K2]);
-        result[K2] = (0, index_2.Index)(type, keys, options);
+        result[K2] = (0, index_2.Index)(type, (0, indexed_property_keys_1.IndexPropertyKeys)(properties[K2]), options);
     }
     return result;
 }

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

@@ -4,11 +4,11 @@ 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 TFromTemplateLiteral<TemplateLiteral extends TTemplateLiteral, Result extends string[] = TTemplateLiteralGenerate<TemplateLiteral>> = Result;
+type TFromTemplateLiteral<TemplateLiteral extends TTemplateLiteral, Keys extends string[] = TTemplateLiteralGenerate<TemplateLiteral>> = (Keys);
 type TFromUnion<Types extends TSchema[], Result extends string[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromUnion<Right, [...Result, ...TIndexPropertyKeys<Left>]> : Result);
 type TFromLiteral<LiteralValue extends TLiteralValue> = (LiteralValue extends PropertyKey ? [`${LiteralValue}`] : []);
-export type TIndexPropertyKeys<Type extends TSchema, Result extends PropertyKey[] = (Type extends TTemplateLiteral ? TFromTemplateLiteral<Type> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : Type extends TLiteral<infer LiteralValue extends TLiteralValue> ? TFromLiteral<LiteralValue> : Type extends TNumber ? ['[number]'] : Type extends TInteger ? ['[number]'] : [
-])> = Result;
+export type TIndexPropertyKeys<Type extends TSchema> = (Type extends TTemplateLiteral ? TFromTemplateLiteral<Type> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : Type extends TLiteral<infer Value extends TLiteralValue> ? TFromLiteral<Value> : Type extends TNumber ? ['[number]'] : Type extends TInteger ? ['[number]'] : [
+]);
 /** Returns a tuple of PropertyKeys derived from the given TSchema */
 export declare function IndexPropertyKeys<Type extends TSchema>(type: Type): TIndexPropertyKeys<Type>;
 export {};

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

@@ -9,19 +9,19 @@ const index_1 = require("../template-literal/index");
 const kind_1 = require("../guard/kind");
 // prettier-ignore
 function FromTemplateLiteral(templateLiteral) {
-    const result = (0, index_1.TemplateLiteralGenerate)(templateLiteral);
-    return result.map(S => S.toString());
+    const keys = (0, index_1.TemplateLiteralGenerate)(templateLiteral);
+    return keys.map(key => key.toString());
 }
 // prettier-ignore
-function FromUnion(type) {
+function FromUnion(types) {
     const result = [];
-    for (const left of type)
-        result.push(...IndexPropertyKeys(left));
+    for (const type of types)
+        result.push(...IndexPropertyKeys(type));
     return result;
 }
 // prettier-ignore
-function FromLiteral(T) {
-    return ([T.toString()] // TS 5.4 observes TLiteralValue as not having a toString()
+function FromLiteral(literalValue) {
+    return ([literalValue.toString()] // TS 5.4 observes TLiteralValue as not having a toString()
     );
 }
 /** Returns a tuple of PropertyKeys derived from the given TSchema */

package/build/cjs/type/indexed/indexed.d.ts

@@ -1,54 +1,52 @@
 import { type TSchema, SchemaOptions } from '../schema/index';
-import { type TComputed } from '../computed/index';
-import { type TLiteral, type TLiteralValue } from '../literal/index';
-import { type TObject, type TProperties } from '../object/index';
 import { type Assert } from '../helpers/index';
+import { type TComputed } from '../computed/index';
 import { type TNever } from '../never/index';
-import { type TRecursive } from '../recursive/index';
+import { type TArray } from '../array/index';
 import { type TIntersect } from '../intersect/index';
-import { TMappedResult, type TMappedKey } from '../mapped/index';
+import { type TMappedResult, type TMappedKey } from '../mapped/index';
+import { type TObject, type TProperties } from '../object/index';
 import { type TUnion } from '../union/index';
-import { type TTuple } from '../tuple/index';
-import { type TArray } from '../array/index';
+import { type TRecursive } from '../recursive/index';
 import { type TRef } from '../ref/index';
+import { type TTuple } from '../tuple/index';
 import { type TIntersectEvaluated } from '../intersect/index';
 import { type TUnionEvaluated } from '../union/index';
 import { type TIndexPropertyKeys } from './indexed-property-keys';
 import { type TIndexFromMappedKey } from './indexed-from-mapped-key';
 import { type TIndexFromMappedResult } from './indexed-from-mapped-result';
-type TFromRest<T extends TSchema[], K extends PropertyKey, Result extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, K, [...Result, Assert<TIndexFromPropertyKey<L, K>, TSchema>]> : Result);
+type TFromRest<Types extends TSchema[], Key extends PropertyKey, Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromRest<Right, Key, [...Result, Assert<TIndexFromPropertyKey<Left, Key>, TSchema>]> : Result);
 type TFromIntersectRest<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TNever ? TFromIntersectRest<Right, [...Result]> : TFromIntersectRest<Right, [...Result, Left]> : Result);
 type TFromIntersect<Types extends TSchema[], Key extends PropertyKey> = (TIntersectEvaluated<TFromIntersectRest<TFromRest<Types, Key>>>);
 type TFromUnionRest<Types extends TSchema[], Result extends TSchema[] = []> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TNever ? [] : TFromUnionRest<Right, [Left, ...Result]> : Result;
 type TFromUnion<Types extends TSchema[], Key extends PropertyKey> = (TUnionEvaluated<TFromUnionRest<TFromRest<Types, Key>>>);
-type TFromTuple<Types extends TSchema[], Key extends PropertyKey, Result extends TSchema = (Key extends '[number]' ? TUnionEvaluated<Types> : Key extends keyof Types ? Types[Key] extends infer Type extends TSchema ? Type : TNever : TNever)> = Result;
+type TFromTuple<Types extends TSchema[], Key extends PropertyKey> = (Key extends keyof Types ? Types[Key] : Key extends '[number]' ? TUnionEvaluated<Types> : TNever);
 type TFromArray<Type extends TSchema, Key extends PropertyKey> = (Key extends '[number]' ? Type : TNever);
-type AssertPropertyKey<T extends unknown> = Assert<T, string | number>;
-type TFromProperty<Properties extends TProperties, Key extends PropertyKey, Result extends TSchema = (Key extends keyof Properties ? Properties[Key] : `${AssertPropertyKey<Key>}` extends `${AssertPropertyKey<keyof Properties>}` ? Properties[AssertPropertyKey<Key>] : TNever)> = Result;
-export type TIndexFromPropertyKey<Type extends TSchema, Key extends PropertyKey> = (Type extends TRecursive<infer S extends TSchema> ? TIndexFromPropertyKey<S, Key> : Type extends TIntersect<infer S extends TSchema[]> ? TFromIntersect<S, Key> : Type extends TUnion<infer S extends TSchema[]> ? TFromUnion<S, Key> : Type extends TTuple<infer S extends TSchema[]> ? TFromTuple<S, Key> : Type extends TArray<infer S extends TSchema> ? TFromArray<S, Key> : Type extends TObject<infer S extends TProperties> ? TFromProperty<S, Key> : TNever);
-export declare function IndexFromPropertyKey<Type extends TSchema, Key extends PropertyKey>(type: Type, key: Key): TIndexFromPropertyKey<Type, Key>;
+type AssertPropertyKey<T> = Assert<T, string | number>;
+type TFromProperty<Properties extends TProperties, Key extends PropertyKey> = (Key extends keyof Properties ? Properties[Key] : `${AssertPropertyKey<Key>}` extends `${AssertPropertyKey<keyof Properties>}` ? Properties[AssertPropertyKey<Key>] : TNever);
+export type TIndexFromPropertyKey<Type extends TSchema, Key extends PropertyKey> = (Type extends TRecursive<infer Type extends TSchema> ? TIndexFromPropertyKey<Type, Key> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Types, Key> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types, Key> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Types, Key> : Type extends TArray<infer Type extends TSchema> ? TFromArray<Type, Key> : Type extends TObject<infer Properties extends TProperties> ? TFromProperty<Properties, Key> : TNever);
+export declare function IndexFromPropertyKey<Type extends TSchema, Key extends PropertyKey>(type: Type, propertyKey: Key): TIndexFromPropertyKey<Type, Key>;
 export type TIndexFromPropertyKeys<Type extends TSchema, PropertyKeys extends PropertyKey[], Result extends TSchema[] = []> = (PropertyKeys extends [infer Left extends PropertyKey, ...infer Right extends PropertyKey[]] ? TIndexFromPropertyKeys<Type, Right, [...Result, Assert<TIndexFromPropertyKey<Type, Left>, TSchema>]> : Result);
 export declare function IndexFromPropertyKeys<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, propertyKeys: [...PropertyKeys]): TIndexFromPropertyKeys<Type, PropertyKeys>;
-type TFromType<Type extends TSchema, PropertyKeys extends PropertyKey[], Result extends TSchema[] = TIndexFromPropertyKeys<Type, PropertyKeys>> = TUnionEvaluated<Result>;
-type TUnionFromPropertyKeys<PropertyKeys extends PropertyKey[], Result extends TLiteral[] = []> = (PropertyKeys extends [infer Key extends PropertyKey, ...infer Rest extends PropertyKey[]] ? Key extends TLiteralValue ? TUnionFromPropertyKeys<Rest, [...Result, TLiteral<Key>]> : TUnionFromPropertyKeys<Rest, [...Result]> : TUnionEvaluated<Result>);
-type TResolvePropertyKeys<Key extends TSchema | PropertyKey[]> = Key extends TSchema ? TIndexPropertyKeys<Key> : Key;
-type TResolveTypeKey<Key extends TSchema | PropertyKey[]> = Key extends PropertyKey[] ? TUnionFromPropertyKeys<Key> : Key;
-export type TIndex<Type extends TSchema, Key extends TSchema | PropertyKey[], IsTypeRef extends boolean = Type extends TRef ? true : false, IsKeyRef extends boolean = Key extends TRef ? true : false> = (Key extends TMappedResult ? TIndexFromMappedResult<Type, Key> : Key extends TMappedKey ? TIndexFromMappedKey<Type, Key> : [
-    IsTypeRef,
-    IsKeyRef
-] extends [true, true] ? TComputed<'Index', [Type, TResolveTypeKey<Key>]> : [
-    IsTypeRef,
-    IsKeyRef
-] extends [false, true] ? TComputed<'Index', [Type, TResolveTypeKey<Key>]> : [
-    IsTypeRef,
-    IsKeyRef
-] extends [true, false] ? TComputed<'Index', [Type, TResolveTypeKey<Key>]> : TFromType<Type, TResolvePropertyKeys<Key>>);
-/** `[Json]` Returns an Indexed property type for the given keys */
-export declare function Index<Type extends TSchema, Key extends PropertyKey[]>(type: Type, key: readonly [...Key], options?: SchemaOptions): TIndex<Type, Key>;
-/** `[Json]` Returns an Indexed property type for the given keys */
-export declare function Index<Type extends TSchema, Key extends TMappedKey>(type: Type, key: Key, options?: SchemaOptions): TIndex<Type, Key>;
-/** `[Json]` Returns an Indexed property type for the given keys */
-export declare function Index<Type extends TSchema, Key extends TMappedResult>(type: Type, key: Key, options?: SchemaOptions): TIndex<Type, Key>;
-/** `[Json]` Returns an Indexed property type for the given keys */
-export declare function Index<Type extends TSchema, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TIndex<Type, Key>;
+type FromSchema<Type extends TSchema, PropertyKeys extends PropertyKey[]> = (TUnionEvaluated<TIndexFromPropertyKeys<Type, PropertyKeys>>);
+declare function FromSchema<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, propertyKeys: [...PropertyKeys]): FromSchema<Type, PropertyKeys>;
+export type TIndexFromComputed<Type extends TSchema, Key extends TSchema> = (TComputed<'Index', [Type, Key]>);
+export declare function IndexFromComputed<Type extends TSchema, Key extends TSchema>(type: Type, key: Key): TIndexFromComputed<Type, Key>;
+export type TIndex<Type extends TSchema, PropertyKeys extends PropertyKey[]> = (FromSchema<Type, PropertyKeys>);
+/** `[Json]` Returns an Indexed property type for the given keys */
+export declare function Index<Type extends TRef, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TIndexFromComputed<Type, Key>;
+/** `[Json]` Returns an Indexed property type for the given keys */
+export declare function Index<Type extends TSchema, Key extends TRef>(type: Type, key: Key, options?: SchemaOptions): TIndexFromComputed<Type, Key>;
+/** `[Json]` Returns an Indexed property type for the given keys */
+export declare function Index<Type extends TRef, Key extends TRef>(type: Type, key: Key, options?: SchemaOptions): TIndexFromComputed<Type, Key>;
+/** `[Json]` Returns an Indexed property type for the given keys */
+export declare function Index<Type extends TSchema, MappedResult extends TMappedResult>(type: Type, mappedResult: MappedResult, options?: SchemaOptions): TIndexFromMappedResult<Type, MappedResult>;
+/** `[Json]` Returns an Indexed property type for the given keys */
+export declare function Index<Type extends TSchema, MappedResult extends TMappedResult>(type: Type, mappedResult: MappedResult, options?: SchemaOptions): TIndexFromMappedResult<Type, MappedResult>;
+/** `[Json]` Returns an Indexed property type for the given keys */
+export declare function Index<Type extends TSchema, MappedKey extends TMappedKey>(type: Type, mappedKey: MappedKey, options?: SchemaOptions): TIndexFromMappedKey<Type, MappedKey>;
+/** `[Json]` Returns an Indexed property type for the given keys */
+export declare function Index<Type extends TSchema, Key extends TSchema, PropertyKeys extends PropertyKey[] = TIndexPropertyKeys<Key>>(T: Type, K: Key, options?: SchemaOptions): TIndex<Type, PropertyKeys>;
+/** `[Json]` Returns an Indexed property type for the given keys */
+export declare function Index<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, propertyKeys: readonly [...PropertyKeys], options?: SchemaOptions): TIndex<Type, PropertyKeys>;
 export {};

package/build/cjs/type/indexed/indexed.js

@@ -3,31 +3,28 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IndexFromPropertyKey = IndexFromPropertyKey;
 exports.IndexFromPropertyKeys = IndexFromPropertyKeys;
+exports.IndexFromComputed = IndexFromComputed;
 exports.Index = Index;
 const type_1 = require("../create/type");
-const index_1 = require("../computed/index");
-const index_2 = require("../literal/index");
+const index_1 = require("../error/index");
+const index_2 = require("../computed/index");
 const index_3 = require("../never/index");
 const index_4 = require("../intersect/index");
 const index_5 = require("../union/index");
-// ------------------------------------------------------------------
-// Infrastructure
-// ------------------------------------------------------------------
 const indexed_property_keys_1 = require("./indexed-property-keys");
 const indexed_from_mapped_key_1 = require("./indexed-from-mapped-key");
 const indexed_from_mapped_result_1 = require("./indexed-from-mapped-result");
 // ------------------------------------------------------------------
-// KindGuard
+// TypeGuard
 // ------------------------------------------------------------------
 const kind_1 = require("../guard/kind");
-const value_1 = require("../guard/value");
 // prettier-ignore
 function FromRest(types, key) {
-    return types.map(left => IndexFromPropertyKey(left, key));
+    return types.map(type => IndexFromPropertyKey(type, key));
 }
 // prettier-ignore
 function FromIntersectRest(types) {
-    return types.filter(left => !(0, kind_1.IsNever)(left));
+    return types.filter(type => !(0, kind_1.IsNever)(type));
 }
 // prettier-ignore
 function FromIntersect(types, key) {
@@ -45,53 +42,57 @@ function FromUnion(types, key) {
 }
 // prettier-ignore
 function FromTuple(types, key) {
-    return (key === '[number]' ? (0, index_5.UnionEvaluated)(types) :
-        key in types ? types[key] :
+    return (key in types ? types[key] :
+        key === '[number]' ? (0, index_5.UnionEvaluated)(types) :
             (0, index_3.Never)());
 }
 // prettier-ignore
 function FromArray(type, key) {
-    // ... ?
-    return (key === '[number]' ? type : (0, index_3.Never)());
+    return (key === '[number]'
+        ? type
+        : (0, index_3.Never)());
 }
 // prettier-ignore
-function FromProperty(properties, key) {
-    return (key in properties ? properties[key] : (0, index_3.Never)());
+function FromProperty(properties, propertyKey) {
+    return (propertyKey in properties ? properties[propertyKey] : (0, index_3.Never)());
 }
 // prettier-ignore
-function IndexFromPropertyKey(type, key) {
-    return ((0, kind_1.IsIntersect)(type) ? FromIntersect(type.allOf, key) :
-        (0, kind_1.IsUnion)(type) ? FromUnion(type.anyOf, key) :
-            (0, kind_1.IsTuple)(type) ? FromTuple(type.items ?? [], key) :
-                (0, kind_1.IsArray)(type) ? FromArray(type.items, key) :
-                    (0, kind_1.IsObject)(type) ? FromProperty(type.properties, key) :
+function IndexFromPropertyKey(type, propertyKey) {
+    return ((0, kind_1.IsIntersect)(type) ? FromIntersect(type.allOf, propertyKey) :
+        (0, kind_1.IsUnion)(type) ? FromUnion(type.anyOf, propertyKey) :
+            (0, kind_1.IsTuple)(type) ? FromTuple(type.items ?? [], propertyKey) :
+                (0, kind_1.IsArray)(type) ? FromArray(type.items, propertyKey) :
+                    (0, kind_1.IsObject)(type) ? FromProperty(type.properties, propertyKey) :
                         (0, index_3.Never)());
 }
 // prettier-ignore
 function IndexFromPropertyKeys(type, propertyKeys) {
-    return propertyKeys.map(left => IndexFromPropertyKey(type, left));
+    return propertyKeys.map(propertyKey => IndexFromPropertyKey(type, propertyKey));
 }
 // prettier-ignore
-function FromType(type, propertyKeys) {
-    const result = IndexFromPropertyKeys(type, propertyKeys);
-    return (0, index_5.UnionEvaluated)(result);
+function FromSchema(type, propertyKeys) {
+    return ((0, index_5.UnionEvaluated)(IndexFromPropertyKeys(type, propertyKeys)));
 }
 // prettier-ignore
-function UnionFromPropertyKeys(propertyKeys) {
-    const result = propertyKeys.reduce((result, key) => (0, kind_1.IsLiteralValue)(key) ? [...result, (0, index_2.Literal)(key)] : result, []);
-    return (0, index_5.UnionEvaluated)(result);
+function IndexFromComputed(type, key) {
+    return (0, index_2.Computed)('Index', [type, key]);
 }
 /** `[Json]` Returns an Indexed property type for the given keys */
-// prettier-ignore
 function Index(type, key, options) {
-    const typeKey = (0, value_1.IsArray)(key) ? UnionFromPropertyKeys(key) : key;
-    const propertyKeys = (0, kind_1.IsSchema)(key) ? (0, indexed_property_keys_1.IndexPropertyKeys)(key) : key;
-    const isTypeRef = (0, kind_1.IsRef)(type);
-    const isKeyRef = (0, kind_1.IsRef)(key);
-    return ((0, kind_1.IsMappedResult)(key) ? (0, indexed_from_mapped_result_1.IndexFromMappedResult)(type, key, options) :
-        (0, kind_1.IsMappedKey)(key) ? (0, indexed_from_mapped_key_1.IndexFromMappedKey)(type, key, options) :
-            (isTypeRef && isKeyRef) ? (0, index_1.Computed)('Index', [type, typeKey], options) :
-                (!isTypeRef && isKeyRef) ? (0, index_1.Computed)('Index', [type, typeKey], options) :
-                    (isTypeRef && !isKeyRef) ? (0, index_1.Computed)('Index', [type, typeKey], options) :
-                        (0, type_1.CreateType)(FromType(type, propertyKeys), options));
+    // computed-type
+    if ((0, kind_1.IsRef)(type) || (0, kind_1.IsRef)(key)) {
+        const error = `Index types using Ref parameters require both Type and Key to be of TSchema`;
+        if (!(0, kind_1.IsSchema)(type) || !(0, kind_1.IsSchema)(key))
+            throw new index_1.TypeBoxError(error);
+        return (0, index_2.Computed)('Index', [type, key]);
+    }
+    // mapped-types
+    if ((0, kind_1.IsMappedResult)(key))
+        return (0, indexed_from_mapped_result_1.IndexFromMappedResult)(type, key, options);
+    if ((0, kind_1.IsMappedKey)(key))
+        return (0, indexed_from_mapped_key_1.IndexFromMappedKey)(type, key, options);
+    // prettier-ignore
+    return (0, type_1.CreateType)((0, kind_1.IsSchema)(key)
+        ? FromSchema(type, (0, indexed_property_keys_1.IndexPropertyKeys)(key))
+        : FromSchema(type, key), options);
 }

package/build/cjs/type/module/compute.d.ts

@@ -5,8 +5,8 @@ import { type TAwaited } from '../awaited/index';
 import { type TAsyncIterator } from '../async-iterator/index';
 import { TComputed } from '../computed/index';
 import { type TConstructor } from '../constructor/index';
-import { type TIndex } from '../indexed/index';
-import { TEnum, TEnumRecord } from '../enum/index';
+import { type TIndex, type TIndexPropertyKeys } from '../indexed/index';
+import { TEnum, type TEnumRecord } from '../enum/index';
 import { type TFunction } from '../function/index';
 import { type TIntersect, type TIntersectEvaluated } from '../intersect/index';
 import { type TIterator } from '../iterator/index';
@@ -26,7 +26,7 @@ import { type TUnion, type TUnionEvaluated } from '../union/index';
 type TDerefParameters<ModuleProperties extends TProperties, Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TRef<infer Key extends string> ? TDerefParameters<ModuleProperties, Right, [...Result, TDeref<ModuleProperties, Key>]> : TDerefParameters<ModuleProperties, Right, [...Result, TFromType<ModuleProperties, Left>]> : Result);
 type TDeref<ModuleProperties extends TProperties, Ref extends string, Result extends TSchema = (Ref extends keyof ModuleProperties ? ModuleProperties[Ref] extends TRef<infer Ref2 extends string> ? TDeref<ModuleProperties, Ref2> : TFromType<ModuleProperties, ModuleProperties[Ref]> : TNever)> = Result;
 type TFromAwaited<Parameters extends TSchema[]> = (Parameters extends [infer T0 extends TSchema] ? TAwaited<T0> : never);
-type TFromIndex<Parameters extends TSchema[]> = (Parameters extends [infer T0 extends TSchema, infer T1 extends TSchema] ? TIndex<T0, T1> : never);
+type TFromIndex<Parameters extends TSchema[]> = (Parameters extends [infer T0 extends TSchema, infer T1 extends TSchema] ? TIndex<T0, TIndexPropertyKeys<T1>> extends infer Result extends TSchema ? Result : never : never);
 type TFromKeyOf<Parameters extends TSchema[]> = (Parameters extends [infer T0 extends TSchema] ? TKeyOf<T0> : never);
 type TFromPartial<Parameters extends TSchema[]> = (Parameters extends [infer T0 extends TSchema] ? TPartial<T0> : never);
 type TFromOmit<Parameters extends TSchema[]> = (Parameters extends [infer T0 extends TSchema, infer T1 extends TSchema] ? TOmit<T0, T1> : never);

package/build/cjs/type/module/compute.js

@@ -133,9 +133,6 @@ function FromType(moduleProperties, type) {
             // Traveral
             KindGuard.IsArray(type) ? (0, index_1.CreateType)(FromArray(moduleProperties, type.items), type) :
                 KindGuard.IsAsyncIterator(type) ? (0, index_1.CreateType)(FromAsyncIterator(moduleProperties, type.items), type) :
-                    // Note: The 'as never' is required due to excessive resolution of TIndex. In fact TIndex, TPick, TOmit and
-                    // all need re-implementation to remove the PropertyKey[] selector. Reimplementation of these types should
-                    // be a priority as there is a potential for the current inference to break on TS compiler changes.
                     KindGuard.IsComputed(type) ? (0, index_1.CreateType)(FromComputed(moduleProperties, type.target, type.parameters)) :
                         KindGuard.IsConstructor(type) ? (0, index_1.CreateType)(FromConstructor(moduleProperties, type.parameters, type.returns), type) :
                             KindGuard.IsFunction(type) ? (0, index_1.CreateType)(FromFunction(moduleProperties, type.parameters, type.returns), type) :

package/build/cjs/type/module/infer.d.ts

@@ -37,7 +37,9 @@ type InferProperties<ModuleProperties extends TProperties, Properties extends TP
 }>;
 type TInferObject<ModuleProperties extends TProperties, Properties extends TProperties> = (InferProperties<ModuleProperties, Properties>);
 type TInferTuple<ModuleProperties extends TProperties, Types extends TSchema[], Result extends unknown[] = []> = (Types extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TInferTuple<ModuleProperties, R, [...Result, TInfer<ModuleProperties, L>]> : Result);
-type TInferRecord<ModuleProperties extends TProperties, Key extends TSchema, Type extends TSchema, InferredKey extends PropertyKey = TInfer<ModuleProperties, Key> extends infer Key extends PropertyKey ? Key : never, InferedType extends unknown = TInfer<ModuleProperties, Type>> = Record<InferredKey, InferedType>;
+type TInferRecord<ModuleProperties extends TProperties, Key extends TSchema, Type extends TSchema, InferredKey extends PropertyKey = TInfer<ModuleProperties, Key> extends infer Key extends PropertyKey ? Key : never, InferedType extends unknown = TInfer<ModuleProperties, Type>> = Ensure<{
+    [_ in InferredKey]: InferedType;
+}>;
 type TInferRef<ModuleProperties extends TProperties, Ref extends string> = (Ref extends keyof ModuleProperties ? TInfer<ModuleProperties, ModuleProperties[Ref]> : unknown);
 type TInferUnion<ModuleProperties extends TProperties, Types extends TSchema[], Result extends unknown = never> = (Types extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TInferUnion<ModuleProperties, R, Result | TInfer<ModuleProperties, L>> : Result);
 type TInfer<ModuleProperties extends TProperties, Type extends TSchema> = (Type extends TArray<infer Type extends TSchema> ? TInferArray<ModuleProperties, Type> : Type extends TAsyncIterator<infer Type extends TSchema> ? TInferAsyncIterator<ModuleProperties, Type> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TInferConstructor<ModuleProperties, Parameters, InstanceType> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TInferFunction<ModuleProperties, Parameters, ReturnType> : Type extends TIntersect<infer Types extends TSchema[]> ? TInferIntersect<ModuleProperties, Types> : Type extends TIterator<infer Type extends TSchema> ? TInferIterator<ModuleProperties, Type> : Type extends TObject<infer Properties extends TProperties> ? TInferObject<ModuleProperties, Properties> : Type extends TRecord<infer Key extends TSchema, infer Type extends TSchema> ? TInferRecord<ModuleProperties, Key, Type> : Type extends TRef<infer Ref extends string> ? TInferRef<ModuleProperties, Ref> : Type extends TTuple<infer Types extends TSchema[]> ? TInferTuple<ModuleProperties, Types> : Type extends TEnum<infer _ extends TEnumRecord> ? Static<Type> : Type extends TUnion<infer Types extends TSchema[]> ? TInferUnion<ModuleProperties, Types> : Static<Type>);

package/build/cjs/type/record/record.d.ts

@@ -52,7 +52,7 @@ export interface TRecord<Key extends TSchema = TSchema, Type extends TSchema = T
     };
     additionalProperties: TAdditionalProperties;
 }
-export type TRecordOrObject<Key extends TSchema, Type extends TSchema> = (Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TComputed<'Record', [Key, TComputed<Target, Parameters>]> : Key extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TComputed<'Record', [TComputed<Target, Parameters>, Type]> : Key extends TRef<infer Ref extends string> ? TComputed<'Record', [TRef<Ref>, Type]> : Key extends TTemplateLiteral ? TFromTemplateLiteralKey<Key, Type> : Key extends TEnum<infer Enum extends TEnumRecord> ? TFromEnumKey<Enum, Type> : Key extends TUnion<infer Types extends TSchema[]> ? TFromUnionKey<Types, Type> : Key extends TLiteral<infer Value extends TLiteralValue> ? TFromLiteralKey<Value, Type> : Key extends TInteger ? TFromIntegerKey<Key, Type> : Key extends TNumber ? TFromNumberKey<Key, Type> : Key extends TRegExp ? TFromRegExpKey<Key, Type> : Key extends TString ? TFromStringKey<Key, Type> : Key extends TAny ? TFromAnyKey<Key, Type> : Key extends TNever ? TFromNeverKey<Key, Type> : Key);
+export type TRecordOrObject<Key extends TSchema, Type extends TSchema> = (Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TComputed<'Record', [Key, TComputed<Target, Parameters>]> : Key extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TComputed<'Record', [TComputed<Target, Parameters>, Type]> : Key extends TRef<infer Ref extends string> ? TComputed<'Record', [TRef<Ref>, Type]> : Key extends TTemplateLiteral ? TFromTemplateLiteralKey<Key, Type> : Key extends TEnum<infer Enum extends TEnumRecord> ? TFromEnumKey<Enum, Type> : Key extends TUnion<infer Types extends TSchema[]> ? TFromUnionKey<Types, Type> : Key extends TLiteral<infer Value extends TLiteralValue> ? TFromLiteralKey<Value, Type> : Key extends TInteger ? TFromIntegerKey<Key, Type> : Key extends TNumber ? TFromNumberKey<Key, Type> : Key extends TRegExp ? TFromRegExpKey<Key, Type> : Key extends TString ? TFromStringKey<Key, Type> : Key extends TAny ? TFromAnyKey<Key, Type> : Key extends TNever ? TFromNeverKey<Key, Type> : TNever);
 /** `[Json]` Creates a Record type */
 export declare function Record<Key extends TSchema, Type extends TSchema>(key: Key, type: Type, options?: ObjectOptions): TRecordOrObject<Key, Type>;
 export {};