@sinclair/typebox 0.34.0 → 0.34.2

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

@@ -5,80 +5,93 @@ exports.IndexFromPropertyKey = IndexFromPropertyKey;
 exports.IndexFromPropertyKeys = IndexFromPropertyKeys;
 exports.Index = Index;
 const type_1 = require("../create/type");
-const index_1 = require("../never/index");
-const index_2 = require("../intersect/index");
-const index_3 = require("../union/index");
+const index_1 = require("../computed/index");
+const index_2 = require("../literal/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");
 // ------------------------------------------------------------------
-// TypeGuard
+// KindGuard
 // ------------------------------------------------------------------
 const kind_1 = require("../guard/kind");
+const value_1 = require("../guard/value");
 // prettier-ignore
-function FromRest(T, K) {
-    return T.map(L => IndexFromPropertyKey(L, K));
+function FromRest(types, key) {
+    return types.map(left => IndexFromPropertyKey(left, key));
 }
 // prettier-ignore
-function FromIntersectRest(T) {
-    return T.filter(L => !(0, kind_1.IsNever)(L));
+function FromIntersectRest(types) {
+    return types.filter(left => !(0, kind_1.IsNever)(left));
 }
 // prettier-ignore
-function FromIntersect(T, K) {
-    return ((0, index_2.IntersectEvaluated)(FromIntersectRest(FromRest(T, K))));
+function FromIntersect(types, key) {
+    return ((0, index_4.IntersectEvaluated)(FromIntersectRest(FromRest(types, key))));
 }
 // prettier-ignore
-function FromUnionRest(T) {
-    return (T.some(L => (0, kind_1.IsNever)(L))
+function FromUnionRest(types) {
+    return (types.some(L => (0, kind_1.IsNever)(L))
         ? []
-        : T);
+        : types);
 }
 // prettier-ignore
-function FromUnion(T, K) {
-    return ((0, index_3.UnionEvaluated)(FromUnionRest(FromRest(T, K))));
+function FromUnion(types, key) {
+    return ((0, index_5.UnionEvaluated)(FromUnionRest(FromRest(types, key))));
 }
 // prettier-ignore
-function FromTuple(T, K) {
-    return (K in T ? T[K] :
-        K === '[number]' ? (0, index_3.UnionEvaluated)(T) :
-            (0, index_1.Never)());
+function FromTuple(types, key) {
+    return (key === '[number]' ? (0, index_5.UnionEvaluated)(types) :
+        key in types ? types[key] :
+            (0, index_3.Never)());
 }
 // prettier-ignore
-function FromArray(T, K) {
-    return (K === '[number]'
-        ? T
-        : (0, index_1.Never)());
+function FromArray(type, key) {
+    // ... ?
+    return (key === '[number]' ? type : (0, index_3.Never)());
 }
 // prettier-ignore
-function FromProperty(T, K) {
-    return (K in T ? T[K] : (0, index_1.Never)());
+function FromProperty(properties, key) {
+    return (key in properties ? properties[key] : (0, index_3.Never)());
 }
 // prettier-ignore
-function IndexFromPropertyKey(T, K) {
-    return ((0, kind_1.IsIntersect)(T) ? FromIntersect(T.allOf, K) :
-        (0, kind_1.IsUnion)(T) ? FromUnion(T.anyOf, K) :
-            (0, kind_1.IsTuple)(T) ? FromTuple(T.items ?? [], K) :
-                (0, kind_1.IsArray)(T) ? FromArray(T.items, K) :
-                    (0, kind_1.IsObject)(T) ? FromProperty(T.properties, K) :
-                        (0, index_1.Never)());
+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) :
+                        (0, index_3.Never)());
 }
 // prettier-ignore
-function IndexFromPropertyKeys(T, K) {
-    return K.map(L => IndexFromPropertyKey(T, L));
+function IndexFromPropertyKeys(type, propertyKeys) {
+    return propertyKeys.map(left => IndexFromPropertyKey(type, left));
 }
 // prettier-ignore
-function FromSchema(T, K) {
-    return ((0, index_3.UnionEvaluated)(IndexFromPropertyKeys(T, K)));
+function FromType(type, propertyKeys) {
+    const result = IndexFromPropertyKeys(type, propertyKeys);
+    return (0, index_5.UnionEvaluated)(result);
+}
+// 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);
 }
 /** `[Json]` Returns an Indexed property type for the given keys */
-function Index(T, K, options) {
-    // mapped-types
-    if ((0, kind_1.IsMappedResult)(K))
-        return (0, indexed_from_mapped_result_1.IndexFromMappedResult)(T, K, options);
-    if ((0, kind_1.IsMappedKey)(K))
-        return (0, indexed_from_mapped_key_1.IndexFromMappedKey)(T, K, options);
-    // prettier-ignore
-    return (0, type_1.CreateType)((0, kind_1.IsSchema)(K)
-        ? FromSchema(T, (0, indexed_property_keys_1.IndexPropertyKeys)(K))
-        : FromSchema(T, K), options);
+// 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));
 }

package/build/cjs/type/intersect/intersect-evaluated.d.ts

@@ -3,11 +3,11 @@ import { type TNever } from '../never/index';
 import { type TOptional } from '../optional/index';
 import type { TReadonly } from '../readonly/index';
 import { TIntersect, IntersectOptions } from './intersect-type';
-type TIsIntersectOptional<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TOptional<TSchema> ? TIsIntersectOptional<R> : false : true);
-type TRemoveOptionalFromType<T extends TSchema> = (T extends TReadonly<infer S extends TSchema> ? TReadonly<TRemoveOptionalFromType<S>> : T extends TOptional<infer S extends TSchema> ? TRemoveOptionalFromType<S> : T);
-type TRemoveOptionalFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TOptional<infer S extends TSchema> ? TRemoveOptionalFromRest<R, [...Acc, TRemoveOptionalFromType<S>]> : TRemoveOptionalFromRest<R, [...Acc, L]> : Acc);
-type TResolveIntersect<T extends TSchema[]> = (TIsIntersectOptional<T> extends true ? TOptional<TIntersect<TRemoveOptionalFromRest<T>>> : TIntersect<TRemoveOptionalFromRest<T>>);
-export type TIntersectEvaluated<T extends TSchema[]> = (T extends [] ? TNever : T extends [TSchema] ? T[0] : TResolveIntersect<T>);
+type TIsIntersectOptional<Types extends TSchema[]> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TOptional<TSchema> ? TIsIntersectOptional<Right> : false : true);
+type TRemoveOptionalFromType<Type extends TSchema> = (Type extends TReadonly<infer Type extends TSchema> ? TReadonly<TRemoveOptionalFromType<Type>> : Type extends TOptional<infer Type extends TSchema> ? TRemoveOptionalFromType<Type> : Type);
+type TRemoveOptionalFromRest<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TOptional<infer Type extends TSchema> ? TRemoveOptionalFromRest<Right, [...Result, TRemoveOptionalFromType<Type>]> : TRemoveOptionalFromRest<Right, [...Result, Left]> : Result);
+type TResolveIntersect<Types extends TSchema[]> = (TIsIntersectOptional<Types> extends true ? TOptional<TIntersect<TRemoveOptionalFromRest<Types>>> : TIntersect<TRemoveOptionalFromRest<Types>>);
+export type TIntersectEvaluated<Types extends TSchema[]> = (Types extends [TSchema] ? Types[0] : Types extends [] ? TNever : TResolveIntersect<Types>);
 /** `[Json]` Creates an evaluated Intersect type */
-export declare function IntersectEvaluated<T extends TSchema[], R = TIntersectEvaluated<T>>(T: [...T], options?: IntersectOptions): R;
+export declare function IntersectEvaluated<Types extends TSchema[], Result extends TSchema = TIntersectEvaluated<Types>>(types: [...Types], options?: IntersectOptions): Result;
 export {};

package/build/cjs/type/intersect/intersect-evaluated.js

@@ -13,30 +13,30 @@ const intersect_create_1 = require("./intersect-create");
 // ------------------------------------------------------------------
 const kind_1 = require("../guard/kind");
 // prettier-ignore
-function IsIntersectOptional(T) {
-    return T.every(L => (0, kind_1.IsOptional)(L));
+function IsIntersectOptional(types) {
+    return types.every(left => (0, kind_1.IsOptional)(left));
 }
 // prettier-ignore
-function RemoveOptionalFromType(T) {
-    return ((0, index_2.Discard)(T, [index_1.OptionalKind]));
+function RemoveOptionalFromType(type) {
+    return ((0, index_2.Discard)(type, [index_1.OptionalKind]));
 }
 // prettier-ignore
-function RemoveOptionalFromRest(T) {
-    return T.map(L => (0, kind_1.IsOptional)(L) ? RemoveOptionalFromType(L) : L);
+function RemoveOptionalFromRest(types) {
+    return types.map(left => (0, kind_1.IsOptional)(left) ? RemoveOptionalFromType(left) : left);
 }
 // prettier-ignore
-function ResolveIntersect(T, options) {
-    return (IsIntersectOptional(T)
-        ? (0, index_4.Optional)((0, intersect_create_1.IntersectCreate)(RemoveOptionalFromRest(T), options))
-        : (0, intersect_create_1.IntersectCreate)(RemoveOptionalFromRest(T), options));
+function ResolveIntersect(types, options) {
+    return (IsIntersectOptional(types)
+        ? (0, index_4.Optional)((0, intersect_create_1.IntersectCreate)(RemoveOptionalFromRest(types), options))
+        : (0, intersect_create_1.IntersectCreate)(RemoveOptionalFromRest(types), options));
 }
 /** `[Json]` Creates an evaluated Intersect type */
-function IntersectEvaluated(T, options = {}) {
-    if (T.length === 0)
+function IntersectEvaluated(types, options = {}) {
+    if (types.length === 1)
+        return (0, type_1.CreateType)(types[0], options);
+    if (types.length === 0)
         return (0, index_3.Never)(options);
-    if (T.length === 1)
-        return (0, type_1.CreateType)(T[0], options);
-    if (T.some((schema) => (0, kind_1.IsTransform)(schema)))
+    if (types.some((schema) => (0, kind_1.IsTransform)(schema)))
         throw new Error('Cannot intersect transform types');
-    return ResolveIntersect(T, options);
+    return ResolveIntersect(types, options);
 }

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

@@ -1,6 +1,6 @@
 import type { TSchema } from '../schema/index';
 import { type TNever } from '../never/index';
 import { TIntersect, IntersectOptions } from './intersect-type';
-export type Intersect<T extends TSchema[]> = (T extends [] ? TNever : T extends [TSchema] ? T[0] : TIntersect<T>);
+export type Intersect<Types extends TSchema[]> = (Types extends [TSchema] ? Types[0] : Types extends [] ? TNever : TIntersect<Types>);
 /** `[Json]` Creates an evaluated Intersect type */
-export declare function Intersect<T extends TSchema[]>(T: [...T], options?: IntersectOptions): Intersect<T>;
+export declare function Intersect<Types extends TSchema[]>(types: [...Types], options?: IntersectOptions): Intersect<Types>;

package/build/cjs/type/intersect/intersect.js

@@ -10,12 +10,12 @@ const intersect_create_1 = require("./intersect-create");
 // ------------------------------------------------------------------
 const kind_1 = require("../guard/kind");
 /** `[Json]` Creates an evaluated Intersect type */
-function Intersect(T, options) {
-    if (T.length === 0)
+function Intersect(types, options) {
+    if (types.length === 1)
+        return (0, type_1.CreateType)(types[0], options);
+    if (types.length === 0)
         return (0, index_1.Never)(options);
-    if (T.length === 1)
-        return (0, type_1.CreateType)(T[0], options);
-    if (T.some((schema) => (0, kind_1.IsTransform)(schema)))
+    if (types.some((schema) => (0, kind_1.IsTransform)(schema)))
         throw new Error('Cannot intersect transform types');
-    return (0, intersect_create_1.IntersectCreate)(T, options);
+    return (0, intersect_create_1.IntersectCreate)(types, options);
 }

package/build/cjs/type/keyof/keyof-from-mapped-result.d.ts

@@ -2,11 +2,11 @@ import type { SchemaOptions } from '../schema/index';
 import type { Ensure, Evaluate } from '../helpers/index';
 import type { TProperties } from '../object/index';
 import { type TMappedResult } from '../mapped/index';
-import { type TKeyOf } from './keyof';
-type TFromProperties<K extends TProperties> = ({
-    [K2 in keyof K]: TKeyOf<K[K2]>;
+import { type TKeyOfFromType } from './keyof';
+type TFromProperties<Properties extends TProperties> = ({
+    [K2 in keyof Properties]: TKeyOfFromType<Properties[K2]>;
 });
-type TFromMappedResult<R extends TMappedResult> = (Evaluate<TFromProperties<R['properties']>>);
-export type TKeyOfFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>> = (Ensure<TMappedResult<P>>);
-export declare function KeyOfFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>>(R: R, options?: SchemaOptions): TMappedResult<P>;
+type TFromMappedResult<MappedResult extends TMappedResult> = (Evaluate<TFromProperties<MappedResult['properties']>>);
+export type TKeyOfFromMappedResult<MappedResult extends TMappedResult, Properties extends TProperties = TFromMappedResult<MappedResult>> = (Ensure<TMappedResult<Properties>>);
+export declare function KeyOfFromMappedResult<MappedResult extends TMappedResult, Properties extends TProperties = TFromMappedResult<MappedResult>>(mappedResult: MappedResult, options?: SchemaOptions): TMappedResult<Properties>;
 export {};

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

@@ -6,18 +6,18 @@ const index_1 = require("../mapped/index");
 const keyof_1 = require("./keyof");
 const value_1 = require("../clone/value");
 // prettier-ignore
-function FromProperties(K, options) {
-    const Acc = {};
-    for (const K2 of globalThis.Object.getOwnPropertyNames(K))
-        Acc[K2] = (0, keyof_1.KeyOf)(K[K2], (0, value_1.Clone)(options));
-    return Acc;
+function FromProperties(properties, options) {
+    const result = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(properties))
+        result[K2] = (0, keyof_1.KeyOf)(properties[K2], (0, value_1.Clone)(options));
+    return result;
 }
 // prettier-ignore
-function FromMappedResult(R, options) {
-    return FromProperties(R.properties, options);
+function FromMappedResult(mappedResult, options) {
+    return FromProperties(mappedResult.properties, options);
 }
 // prettier-ignore
-function KeyOfFromMappedResult(R, options) {
-    const P = FromMappedResult(R, options);
-    return (0, index_1.MappedResult)(P);
+function KeyOfFromMappedResult(mappedResult, options) {
+    const properties = FromMappedResult(mappedResult, options);
+    return (0, index_1.MappedResult)(properties);
 }

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

@@ -7,18 +7,18 @@ import type { TTuple } from '../tuple/index';
 import type { TArray } from '../array/index';
 import type { TObject, TProperties } from '../object/index';
 import { type TSetUnionMany, type TSetIntersectMany } from '../sets/index';
-type TFromRest<T extends TSchema[], Acc extends PropertyKey[][] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Acc, TKeyOfPropertyKeys<L>]> : Acc);
-type TFromIntersect<T extends TSchema[], C extends PropertyKey[][] = TFromRest<T>, R extends PropertyKey[] = TSetUnionMany<C>> = R;
-type TFromUnion<T extends TSchema[], C extends PropertyKey[][] = TFromRest<T>, R extends PropertyKey[] = TSetIntersectMany<C>> = R;
-type TFromTuple<T extends TSchema[], I extends string = ZeroString, Acc extends PropertyKey[] = []> = T extends [infer _ extends TSchema, ...infer R extends TSchema[]] ? TFromTuple<R, TIncrement<I>, [...Acc, I]> : Acc;
+type TFromRest<Types extends TSchema[], Result extends PropertyKey[][] = []> = (Types extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Result, TKeyOfPropertyKeys<L>]> : Result);
+type TFromIntersect<Types extends TSchema[], PropertyKeysArray extends PropertyKey[][] = TFromRest<Types>, PropertyKeys extends PropertyKey[] = TSetUnionMany<PropertyKeysArray>> = PropertyKeys;
+type TFromUnion<Types extends TSchema[], PropertyKeysArray extends PropertyKey[][] = TFromRest<Types>, PropertyKeys extends PropertyKey[] = TSetIntersectMany<PropertyKeysArray>> = PropertyKeys;
+type TFromTuple<Types extends TSchema[], Indexer extends string = ZeroString, Acc extends PropertyKey[] = []> = Types extends [infer _ extends TSchema, ...infer R extends TSchema[]] ? TFromTuple<R, TIncrement<Indexer>, [...Acc, Indexer]> : Acc;
 type TFromArray<_ extends TSchema> = ([
     '[number]'
 ]);
-type TFromProperties<T extends TProperties> = (UnionToTuple<keyof T>);
-export type TKeyOfPropertyKeys<T extends TSchema> = (T extends TRecursive<infer S> ? TKeyOfPropertyKeys<S> : T extends TIntersect<infer S> ? TFromIntersect<S> : T extends TUnion<infer S> ? TFromUnion<S> : T extends TTuple<infer S> ? TFromTuple<S> : T extends TArray<infer S> ? TFromArray<S> : T extends TObject<infer S> ? TFromProperties<S> : [
+type TFromProperties<Properties extends TProperties> = (UnionToTuple<keyof Properties>);
+export type TKeyOfPropertyKeys<Type extends TSchema> = (Type extends TRecursive<infer Type extends TSchema> ? TKeyOfPropertyKeys<Type> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Types> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Types> : Type extends TArray<infer Type extends TSchema> ? TFromArray<Type> : Type extends TObject<infer Properties extends TProperties> ? TFromProperties<Properties> : [
 ]);
 /** Returns a tuple of PropertyKeys derived from the given TSchema. */
-export declare function KeyOfPropertyKeys<T extends TSchema>(T: T): TKeyOfPropertyKeys<T>;
+export declare function KeyOfPropertyKeys<Type extends TSchema>(type: Type): TKeyOfPropertyKeys<Type>;
 /** Returns a regular expression pattern derived from the given TSchema */
 export declare function KeyOfPattern(schema: TSchema): string;
 export {};

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

@@ -9,27 +9,27 @@ const index_1 = require("../sets/index");
 // ------------------------------------------------------------------
 const kind_1 = require("../guard/kind");
 // prettier-ignore
-function FromRest(T) {
-    const Acc = [];
-    for (const L of T)
-        Acc.push(KeyOfPropertyKeys(L));
-    return Acc;
+function FromRest(types) {
+    const result = [];
+    for (const L of types)
+        result.push(KeyOfPropertyKeys(L));
+    return result;
 }
 // prettier-ignore
-function FromIntersect(T) {
-    const C = FromRest(T);
-    const R = (0, index_1.SetUnionMany)(C);
-    return R;
+function FromIntersect(types) {
+    const propertyKeysArray = FromRest(types);
+    const propertyKeys = (0, index_1.SetUnionMany)(propertyKeysArray);
+    return propertyKeys;
 }
 // prettier-ignore
-function FromUnion(T) {
-    const C = FromRest(T);
-    const R = (0, index_1.SetIntersectMany)(C);
-    return R;
+function FromUnion(types) {
+    const propertyKeysArray = FromRest(types);
+    const propertyKeys = (0, index_1.SetIntersectMany)(propertyKeysArray);
+    return propertyKeys;
 }
 // prettier-ignore
-function FromTuple(T) {
-    return T.map((_, I) => I.toString());
+function FromTuple(types) {
+    return types.map((_, indexer) => indexer.toString());
 }
 // prettier-ignore
 function FromArray(_) {
@@ -55,13 +55,13 @@ function FromPatternProperties(patternProperties) {
 }
 /** Returns a tuple of PropertyKeys derived from the given TSchema. */
 // prettier-ignore
-function KeyOfPropertyKeys(T) {
-    return ((0, kind_1.IsIntersect)(T) ? FromIntersect(T.allOf) :
-        (0, kind_1.IsUnion)(T) ? FromUnion(T.anyOf) :
-            (0, kind_1.IsTuple)(T) ? FromTuple(T.items ?? []) :
-                (0, kind_1.IsArray)(T) ? FromArray(T.items) :
-                    (0, kind_1.IsObject)(T) ? FromProperties(T.properties) :
-                        (0, kind_1.IsRecord)(T) ? FromPatternProperties(T.patternProperties) :
+function KeyOfPropertyKeys(type) {
+    return ((0, kind_1.IsIntersect)(type) ? FromIntersect(type.allOf) :
+        (0, kind_1.IsUnion)(type) ? FromUnion(type.anyOf) :
+            (0, kind_1.IsTuple)(type) ? FromTuple(type.items ?? []) :
+                (0, kind_1.IsArray)(type) ? FromArray(type.items) :
+                    (0, kind_1.IsObject)(type) ? FromProperties(type.properties) :
+                        (0, kind_1.IsRecord)(type) ? FromPatternProperties(type.patternProperties) :
                             []);
 }
 // ----------------------------------------------------------------

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

@@ -4,13 +4,18 @@ import type { TMappedResult } from '../mapped/index';
 import type { SchemaOptions } from '../schema/index';
 import { type TLiteral, type TLiteralValue } from '../literal/index';
 import { type TNumber } from '../number/index';
+import { TComputed } from '../computed/index';
+import { type TRef } from '../ref/index';
 import { type TKeyOfPropertyKeys } from './keyof-property-keys';
 import { type TUnionEvaluated } from '../union/index';
 import { type TKeyOfFromMappedResult } from './keyof-from-mapped-result';
-export type TKeyOfPropertyKeysToRest<T extends PropertyKey[], Acc extends TSchema[] = []> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? L extends '[number]' ? TKeyOfPropertyKeysToRest<R, [...Acc, TNumber]> : TKeyOfPropertyKeysToRest<R, [...Acc, TLiteral<Assert<L, TLiteralValue>>]> : Acc);
-export declare function KeyOfPropertyKeysToRest<T extends PropertyKey[]>(T: [...T]): TKeyOfPropertyKeysToRest<T>;
-export type TKeyOf<T extends TSchema, K extends PropertyKey[] = TKeyOfPropertyKeys<T>, S extends TSchema[] = TKeyOfPropertyKeysToRest<K>, U = TUnionEvaluated<S>> = (Ensure<U>);
+type TFromComputed<Target extends string, Parameters extends TSchema[]> = Ensure<TComputed<'KeyOf', [TComputed<Target, Parameters>]>>;
+type TFromRef<Ref extends string> = Ensure<TComputed<'KeyOf', [TRef<Ref>]>>;
+/** `[Internal]` Used by KeyOfFromMappedResult */
+export type TKeyOfFromType<Type extends TSchema, PropertyKeys extends PropertyKey[] = TKeyOfPropertyKeys<Type>, PropertyKeyTypes extends TSchema[] = TKeyOfPropertyKeysToRest<PropertyKeys>, Result = TUnionEvaluated<PropertyKeyTypes>> = Ensure<Result>;
+export type TKeyOfPropertyKeysToRest<PropertyKeys extends PropertyKey[], Result extends TSchema[] = []> = (PropertyKeys extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? L extends '[number]' ? TKeyOfPropertyKeysToRest<R, [...Result, TNumber]> : TKeyOfPropertyKeysToRest<R, [...Result, TLiteral<Assert<L, TLiteralValue>>]> : Result);
+export declare function KeyOfPropertyKeysToRest<PropertyKeys extends PropertyKey[]>(propertyKeys: [...PropertyKeys]): TKeyOfPropertyKeysToRest<PropertyKeys>;
+export type TKeyOf<Type extends TSchema> = (Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TFromComputed<Target, Parameters> : Type extends TRef<infer Ref extends string> ? TFromRef<Ref> : Type extends TMappedResult ? TKeyOfFromMappedResult<Type> : TKeyOfFromType<Type>);
 /** `[Json]` Creates a KeyOf type */
-export declare function KeyOf<T extends TMappedResult>(T: T, options?: SchemaOptions): TKeyOfFromMappedResult<T>;
-/** `[Json]` Creates a KeyOf type */
-export declare function KeyOf<T extends TSchema>(T: T, options?: SchemaOptions): TKeyOf<T>;
+export declare function KeyOf<Type extends TSchema>(type: Type, options?: SchemaOptions): TKeyOf<Type>;
+export {};

package/build/cjs/type/keyof/keyof.js

@@ -6,26 +6,35 @@ exports.KeyOf = KeyOf;
 const type_1 = require("../create/type");
 const index_1 = require("../literal/index");
 const index_2 = require("../number/index");
+const index_3 = require("../computed/index");
+const index_4 = require("../ref/index");
 const keyof_property_keys_1 = require("./keyof-property-keys");
-const index_3 = require("../union/index");
+const index_5 = require("../union/index");
 const keyof_from_mapped_result_1 = require("./keyof-from-mapped-result");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
 const kind_1 = require("../guard/kind");
 // prettier-ignore
-function KeyOfPropertyKeysToRest(T) {
-    return T.map(L => L === '[number]' ? (0, index_2.Number)() : (0, index_1.Literal)(L));
+function FromComputed(target, parameters) {
+    return (0, index_3.Computed)('KeyOf', [(0, index_3.Computed)(target, parameters)]);
+}
+// prettier-ignore
+function FromRef($ref) {
+    return (0, index_3.Computed)('KeyOf', [(0, index_4.Ref)($ref)]);
+}
+// prettier-ignore
+function KeyOfFromType(type, options) {
+    const propertyKeys = (0, keyof_property_keys_1.KeyOfPropertyKeys)(type);
+    const propertyKeyTypes = KeyOfPropertyKeysToRest(propertyKeys);
+    const result = (0, index_5.UnionEvaluated)(propertyKeyTypes);
+    return (0, type_1.CreateType)(result, options);
+}
+// prettier-ignore
+function KeyOfPropertyKeysToRest(propertyKeys) {
+    return propertyKeys.map(L => L === '[number]' ? (0, index_2.Number)() : (0, index_1.Literal)(L));
 }
 /** `[Json]` Creates a KeyOf type */
-function KeyOf(T, options) {
-    if ((0, kind_1.IsMappedResult)(T)) {
-        return (0, keyof_from_mapped_result_1.KeyOfFromMappedResult)(T, options);
-    }
-    else {
-        const K = (0, keyof_property_keys_1.KeyOfPropertyKeys)(T);
-        const S = KeyOfPropertyKeysToRest(K);
-        const U = (0, index_3.UnionEvaluated)(S);
-        return (0, type_1.CreateType)(U, options);
-    }
+function KeyOf(type, options) {
+    return ((0, kind_1.IsComputed)(type) ? FromComputed(type.target, type.parameters) : (0, kind_1.IsRef)(type) ? FromRef(type.$ref) : (0, kind_1.IsMappedResult)(type) ? (0, keyof_from_mapped_result_1.KeyOfFromMappedResult)(type, options) : KeyOfFromType(type, options));
 }

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

@@ -0,0 +1,54 @@
+import { Ensure, Evaluate } from '../helpers/index';
+import { type TSchema } from '../schema/index';
+import { type TArray } from '../array/index';
+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 { type TFunction } from '../function/index';
+import { type TIntersect, type TIntersectEvaluated } from '../intersect/index';
+import { type TIterator } from '../iterator/index';
+import { type TKeyOf } from '../keyof/index';
+import { type TObject, type TProperties } from '../object/index';
+import { type TOmit } from '../omit/index';
+import { type TPick } from '../pick/index';
+import { type TNever } from '../never/index';
+import { TPartial } from '../partial/index';
+import { type TRecordOrObject } from '../record/index';
+import { type TRef } from '../ref/index';
+import { TRequired } from '../required/index';
+import { type TTuple } from '../tuple/index';
+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 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);
+type TFromPick<Parameters extends TSchema[]> = (Parameters extends [infer T0 extends TSchema, infer T1 extends TSchema] ? TPick<T0, T1> : never);
+type TFromRecord<Parameters extends TSchema[]> = (Parameters extends [infer T0 extends TSchema, infer T1 extends TSchema] ? TRecordOrObject<T0, T1> : never);
+type TFromRequired<Parameters extends TSchema[]> = (Parameters extends [infer T0 extends TSchema] ? TRequired<T0> : never);
+type TFromComputed<ModuleProperties extends TProperties, Target extends string, Parameters extends TSchema[], Dereferenced extends TSchema[] = TDerefParameters<ModuleProperties, Parameters>> = (Target extends 'Awaited' ? TFromAwaited<Dereferenced> : Target extends 'Index' ? TFromIndex<Dereferenced> : Target extends 'KeyOf' ? TFromKeyOf<Dereferenced> : Target extends 'Partial' ? TFromPartial<Dereferenced> : Target extends 'Omit' ? TFromOmit<Dereferenced> : Target extends 'Pick' ? TFromPick<Dereferenced> : Target extends 'Record' ? TFromRecord<Dereferenced> : Target extends 'Required' ? TFromRequired<Dereferenced> : TNever);
+type TFromObject<ModuleProperties extends TProperties, Properties extends TProperties> = Ensure<TObject<Evaluate<{
+    [Key in keyof Properties]: TFromType<ModuleProperties, Properties[Key]>;
+}>>>;
+type TFromConstructor<ModuleProperties extends TProperties, Parameters extends TSchema[], InstanceType extends TSchema> = (TConstructor<TFromRest<ModuleProperties, Parameters>, TFromType<ModuleProperties, InstanceType>>);
+type TFromFunction<ModuleProperties extends TProperties, Parameters extends TSchema[], ReturnType extends TSchema> = Ensure<Ensure<TFunction<TFromRest<ModuleProperties, Parameters>, TFromType<ModuleProperties, ReturnType>>>>;
+type TFromTuple<ModuleProperties extends TProperties, Types extends TSchema[]> = (Ensure<TTuple<TFromRest<ModuleProperties, Types>>>);
+type TFromIntersect<ModuleProperties extends TProperties, Types extends TSchema[]> = (Ensure<TIntersectEvaluated<TFromRest<ModuleProperties, Types>>>);
+type TFromUnion<ModuleProperties extends TProperties, Types extends TSchema[]> = (Ensure<TUnionEvaluated<TFromRest<ModuleProperties, Types>>>);
+type TFromArray<ModuleProperties extends TProperties, Type extends TSchema> = (Ensure<TArray<TFromType<ModuleProperties, Type>>>);
+type TFromAsyncIterator<ModuleProperties extends TProperties, Type extends TSchema> = (TAsyncIterator<TFromType<ModuleProperties, Type>>);
+type TFromIterator<ModuleProperties extends TProperties, Type extends TSchema> = (TIterator<TFromType<ModuleProperties, Type>>);
+type TFromRest<ModuleProperties extends TProperties, Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromRest<ModuleProperties, Right, [...Result, TFromType<ModuleProperties, Left>]> : Result);
+export type TFromType<ModuleProperties extends TProperties, Type extends TSchema> = (Type extends TComputed<infer T extends string, infer S extends TSchema[]> ? TFromComputed<ModuleProperties, T, S> : Type extends TObject<infer S extends TProperties> ? TFromObject<ModuleProperties, S> : Type extends TConstructor<infer S extends TSchema[], infer R extends TSchema> ? TFromConstructor<ModuleProperties, S, R> : Type extends TFunction<infer S extends TSchema[], infer R extends TSchema> ? TFromFunction<ModuleProperties, S, R> : Type extends TTuple<infer S extends TSchema[]> ? TFromTuple<ModuleProperties, S> : Type extends TIntersect<infer S extends TSchema[]> ? TFromIntersect<ModuleProperties, S> : Type extends TUnion<infer S extends TSchema[]> ? TFromUnion<ModuleProperties, S> : Type extends TArray<infer S extends TSchema> ? TFromArray<ModuleProperties, S> : Type extends TAsyncIterator<infer S extends TSchema> ? TFromAsyncIterator<ModuleProperties, S> : Type extends TIterator<infer S extends TSchema> ? TFromIterator<ModuleProperties, S> : Type);
+export declare function FromType<ModuleProperties extends TProperties, Type extends TSchema>(moduleProperties: ModuleProperties, type: Type): TFromType<ModuleProperties, Type>;
+export type TComputeType<ModuleProperties extends TProperties, Key extends PropertyKey> = (Key extends keyof ModuleProperties ? TFromType<ModuleProperties, ModuleProperties[Key]> : TNever);
+export declare function ComputeType<ModuleProperties extends TProperties, Key extends PropertyKey>(moduleProperties: ModuleProperties, key: Key): TComputeType<ModuleProperties, Key>;
+export type TComputeModuleProperties<ModuleProperties extends TProperties> = Evaluate<{
+    [Key in keyof ModuleProperties]: TComputeType<ModuleProperties, Key>;
+}>;
+export declare function ComputeModuleProperties<ModuleProperties extends TProperties>(moduleProperties: ModuleProperties): TComputeModuleProperties<ModuleProperties>;
+export {};