@sinclair/typebox 0.33.22 → 0.34.1

package/build/cjs/type/omit/omit.js

@@ -4,61 +4,72 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Omit = Omit;
 const type_1 = require("../create/type");
 const discard_1 = require("../discard/discard");
-const index_1 = require("../intersect/index");
-const index_2 = require("../union/index");
-const index_3 = require("../object/index");
-const index_4 = require("../indexed/index");
+const symbols_1 = require("../symbols/symbols");
+const index_1 = require("../computed/index");
+const index_2 = require("../literal/index");
+const index_3 = require("../indexed/index");
+const index_4 = require("../intersect/index");
+const index_5 = require("../union/index");
+const index_6 = require("../object/index");
+// ------------------------------------------------------------------
+// Mapped
+// ------------------------------------------------------------------
 const omit_from_mapped_key_1 = require("./omit-from-mapped-key");
 const omit_from_mapped_result_1 = require("./omit-from-mapped-result");
-const symbols_1 = require("../symbols/symbols");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
 const kind_1 = require("../guard/kind");
+const value_1 = require("../guard/value");
 // prettier-ignore
-function FromIntersect(T, K) {
-    return T.map((T) => OmitResolve(T, K));
+function FromIntersect(types, propertyKeys) {
+    return types.map((type) => OmitResolve(type, propertyKeys));
 }
 // prettier-ignore
-function FromUnion(T, K) {
-    return T.map((T) => OmitResolve(T, K));
+function FromUnion(types, propertyKeys) {
+    return types.map((type) => OmitResolve(type, propertyKeys));
 }
 // ------------------------------------------------------------------
 // FromProperty
 // ------------------------------------------------------------------
 // prettier-ignore
-function FromProperty(T, K) {
-    const { [K]: _, ...R } = T;
+function FromProperty(properties, key) {
+    const { [key]: _, ...R } = properties;
     return R;
 }
 // prettier-ignore
-function FromProperties(T, K) {
-    return K.reduce((T, K2) => FromProperty(T, K2), T);
+function FromProperties(properties, propertyKeys) {
+    return propertyKeys.reduce((T, K2) => FromProperty(T, K2), properties);
 }
 // prettier-ignore
-function FromObject(T, K) {
-    const options = (0, discard_1.Discard)(T, [symbols_1.TransformKind, '$id', 'required', 'properties']);
-    const properties = FromProperties(T['properties'], K);
-    return (0, index_3.Object)(properties, options);
+function FromObject(properties, propertyKeys) {
+    const options = (0, discard_1.Discard)(properties, [symbols_1.TransformKind, '$id', 'required', 'properties']);
+    const omittedProperties = FromProperties(properties['properties'], propertyKeys);
+    return (0, index_6.Object)(omittedProperties, options);
+}
+// 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.Union)(result);
 }
-// ------------------------------------------------------------------
-// OmitResolve
-// ------------------------------------------------------------------
 // prettier-ignore
-function OmitResolve(T, K) {
-    return ((0, kind_1.IsIntersect)(T) ? (0, index_1.Intersect)(FromIntersect(T.allOf, K)) :
-        (0, kind_1.IsUnion)(T) ? (0, index_2.Union)(FromUnion(T.anyOf, K)) :
-            (0, kind_1.IsObject)(T) ? FromObject(T, K) :
-                (0, index_3.Object)({}));
+function OmitResolve(properties, propertyKeys) {
+    return ((0, kind_1.IsIntersect)(properties) ? (0, index_4.Intersect)(FromIntersect(properties.allOf, propertyKeys)) :
+        (0, kind_1.IsUnion)(properties) ? (0, index_5.Union)(FromUnion(properties.anyOf, propertyKeys)) :
+            (0, kind_1.IsObject)(properties) ? FromObject(properties, propertyKeys) :
+                (0, index_6.Object)({}));
 }
-function Omit(T, K, options) {
-    // mapped
-    if ((0, kind_1.IsMappedKey)(K))
-        return (0, omit_from_mapped_key_1.OmitFromMappedKey)(T, K, options);
-    if ((0, kind_1.IsMappedResult)(T))
-        return (0, omit_from_mapped_result_1.OmitFromMappedResult)(T, K, options);
-    // non-mapped
-    const I = (0, kind_1.IsSchema)(K) ? (0, index_4.IndexPropertyKeys)(K) : K;
-    // special: mapping types require overridable options
-    return (0, type_1.CreateType)({ ...OmitResolve(T, I), ...options });
+/** `[Json]` Constructs a type whose keys are picked from the given type */
+// prettier-ignore
+function Omit(type, key, options) {
+    const typeKey = (0, value_1.IsArray)(key) ? UnionFromPropertyKeys(key) : key;
+    const propertyKeys = (0, kind_1.IsSchema)(key) ? (0, index_3.IndexPropertyKeys)(key) : key;
+    const isTypeRef = (0, kind_1.IsRef)(type);
+    const isKeyRef = (0, kind_1.IsRef)(key);
+    return ((0, kind_1.IsMappedResult)(type) ? (0, omit_from_mapped_result_1.OmitFromMappedResult)(type, propertyKeys, options) :
+        (0, kind_1.IsMappedKey)(key) ? (0, omit_from_mapped_key_1.OmitFromMappedKey)(type, key, options) :
+            (isTypeRef && isKeyRef) ? (0, index_1.Computed)('Omit', [type, typeKey], options) :
+                (!isTypeRef && isKeyRef) ? (0, index_1.Computed)('Omit', [type, typeKey], options) :
+                    (isTypeRef && !isKeyRef) ? (0, index_1.Computed)('Omit', [type, typeKey], options) :
+                        (0, type_1.CreateType)({ ...OmitResolve(type, propertyKeys), ...options }));
 }

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

@@ -2,21 +2,25 @@ import type { TSchema, SchemaOptions } from '../schema/index';
 import type { Evaluate, Ensure } from '../helpers/index';
 import type { TMappedResult } from '../mapped/index';
 import { type TReadonlyOptional } from '../readonly-optional/index';
+import { type TComputed } from '../computed/index';
 import { type TOptional } from '../optional/index';
 import { type TReadonly } from '../readonly/index';
 import { type TRecursive } from '../recursive/index';
 import { type TObject, type TProperties } from '../object/index';
 import { type TIntersect } from '../intersect/index';
 import { type TUnion } from '../union/index';
+import { type TRef } from '../ref/index';
 import { type TPartialFromMappedResult } from './partial-from-mapped-result';
-type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Acc, TPartial<L>]> : Acc);
-type TFromProperties<T extends TProperties> = Evaluate<{
-    [K in keyof T]: T[K] extends (TReadonlyOptional<infer S>) ? TReadonlyOptional<S> : T[K] extends (TReadonly<infer S>) ? TReadonlyOptional<S> : T[K] extends (TOptional<infer S>) ? TOptional<S> : TOptional<T[K]>;
+type TFromComputed<Target extends string, Parameters extends TSchema[]> = Ensure<TComputed<'Partial', [TComputed<Target, Parameters>]>>;
+type TFromRef<Ref extends string> = Ensure<TComputed<'Partial', [TRef<Ref>]>>;
+type TFromProperties<Properties extends TProperties> = Evaluate<{
+    [K in keyof Properties]: Properties[K] extends (TReadonlyOptional<infer S>) ? TReadonlyOptional<S> : Properties[K] extends (TReadonly<infer S>) ? TReadonlyOptional<S> : Properties[K] extends (TOptional<infer S>) ? TOptional<S> : TOptional<Properties[K]>;
 }>;
-type TFromObject<T extends TObject, Properties extends TProperties = T['properties']> = Ensure<TObject<(TFromProperties<Properties>)>>;
-export type TPartial<T extends TSchema> = (T extends TRecursive<infer S extends TSchema> ? TRecursive<TPartial<S>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<TFromRest<S>> : T extends TUnion<infer S extends TSchema[]> ? TUnion<TFromRest<S>> : T extends TObject<infer S extends TProperties> ? TFromObject<TObject<S>> : TObject<{}>);
+type TFromObject<Type extends TObject, Properties extends TProperties = Type['properties']> = Ensure<TObject<(TFromProperties<Properties>)>>;
+type TFromRest<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Result, TPartial<L>]> : Result);
+export type TPartial<T extends TSchema> = (T extends TRecursive<infer Type extends TSchema> ? TRecursive<TPartial<Type>> : T extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TFromComputed<Target, Parameters> : T extends TRef<infer Ref extends string> ? TFromRef<Ref> : T extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromRest<Types>> : T extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromRest<Types>> : T extends TObject<infer Properties extends TProperties> ? TFromObject<TObject<Properties>> : TObject<{}>);
 /** `[Json]` Constructs a type where all properties are optional */
-export declare function Partial<T extends TMappedResult>(T: T, options?: SchemaOptions): TPartialFromMappedResult<T>;
+export declare function Partial<MappedResult extends TMappedResult>(type: MappedResult, options?: SchemaOptions): TPartialFromMappedResult<MappedResult>;
 /** `[Json]` Constructs a type where all properties are optional */
-export declare function Partial<T extends TSchema>(T: T, options?: SchemaOptions): TPartial<T>;
+export declare function Partial<Type extends TSchema>(type: Type, options?: SchemaOptions): TPartial<Type>;
 export {};

package/build/cjs/type/partial/partial.js

@@ -3,51 +3,63 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Partial = Partial;
 const type_1 = require("../create/type");
-const index_1 = require("../optional/index");
-const index_2 = require("../object/index");
-const index_3 = require("../intersect/index");
-const index_4 = require("../union/index");
-const index_5 = require("../discard/index");
-const index_6 = require("../symbols/index");
+const index_1 = require("../computed/index");
+const index_2 = require("../optional/index");
+const index_3 = require("../object/index");
+const index_4 = require("../intersect/index");
+const index_5 = require("../union/index");
+const index_6 = require("../ref/index");
+const index_7 = require("../discard/index");
+const index_8 = require("../symbols/index");
 const partial_from_mapped_result_1 = require("./partial-from-mapped-result");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
 const kind_1 = require("../guard/kind");
 // prettier-ignore
-function FromRest(T) {
-    return T.map(L => PartialResolve(L));
+function FromComputed(target, parameters) {
+    return (0, index_1.Computed)('Partial', [(0, index_1.Computed)(target, parameters)]);
 }
 // prettier-ignore
-function FromProperties(T) {
-    const Acc = {};
-    for (const K of globalThis.Object.getOwnPropertyNames(T))
-        Acc[K] = (0, index_1.Optional)(T[K]);
-    return Acc;
+function FromRef($ref) {
+    return (0, index_1.Computed)('Partial', [(0, index_6.Ref)($ref)]);
+}
+// prettier-ignore
+function FromProperties(properties) {
+    const partialProperties = {};
+    for (const K of globalThis.Object.getOwnPropertyNames(properties))
+        partialProperties[K] = (0, index_2.Optional)(properties[K]);
+    return partialProperties;
 }
 // prettier-ignore
 function FromObject(T) {
-    const options = (0, index_5.Discard)(T, [index_6.TransformKind, '$id', 'required', 'properties']);
+    const options = (0, index_7.Discard)(T, [index_8.TransformKind, '$id', 'required', 'properties']);
     const properties = FromProperties(T['properties']);
-    return (0, index_2.Object)(properties, options);
+    return (0, index_3.Object)(properties, options);
+}
+// prettier-ignore
+function FromRest(types) {
+    return types.map(type => PartialResolve(type));
 }
 // ------------------------------------------------------------------
 // PartialResolve
 // ------------------------------------------------------------------
 // prettier-ignore
-function PartialResolve(T) {
-    return ((0, kind_1.IsIntersect)(T) ? (0, index_3.Intersect)(FromRest(T.allOf)) :
-        (0, kind_1.IsUnion)(T) ? (0, index_4.Union)(FromRest(T.anyOf)) :
-            (0, kind_1.IsObject)(T) ? FromObject(T) :
-                (0, index_2.Object)({}));
+function PartialResolve(type) {
+    return ((0, kind_1.IsComputed)(type) ? FromComputed(type.target, type.parameters) :
+        (0, kind_1.IsRef)(type) ? FromRef(type.$ref) :
+            (0, kind_1.IsIntersect)(type) ? (0, index_4.Intersect)(FromRest(type.allOf)) :
+                (0, kind_1.IsUnion)(type) ? (0, index_5.Union)(FromRest(type.anyOf)) :
+                    (0, kind_1.IsObject)(type) ? FromObject(type) :
+                        (0, index_3.Object)({}));
 }
 /** `[Json]` Constructs a type where all properties are optional */
-function Partial(T, options) {
-    if ((0, kind_1.IsMappedResult)(T)) {
-        return (0, partial_from_mapped_result_1.PartialFromMappedResult)(T, options);
+function Partial(type, options) {
+    if ((0, kind_1.IsMappedResult)(type)) {
+        return (0, partial_from_mapped_result_1.PartialFromMappedResult)(type, options);
     }
     else {
         // special: mapping types require overridable options
-        return (0, type_1.CreateType)({ ...PartialResolve(T), ...options });
+        return (0, type_1.CreateType)({ ...PartialResolve(type), ...options });
     }
 }

package/build/cjs/type/pick/pick-from-mapped-key.d.ts

@@ -2,11 +2,11 @@ import type { TSchema, SchemaOptions } from '../schema/index';
 import type { TProperties } from '../object/index';
 import { type TMappedResult, type TMappedKey } from '../mapped/index';
 import { type TPick } from './pick';
-type TFromPropertyKey<T extends TSchema, K extends PropertyKey> = {
-    [_ in K]: TPick<T, [K]>;
+type TFromPropertyKey<Type extends TSchema, Key extends PropertyKey> = {
+    [_ in Key]: TPick<Type, [Key]>;
 };
-type TFromPropertyKeys<T extends TSchema, K extends PropertyKey[], Acc extends TProperties = {}> = (K extends [infer LK extends PropertyKey, ...infer RK extends PropertyKey[]] ? TFromPropertyKeys<T, RK, Acc & TFromPropertyKey<T, LK>> : Acc);
-type TFromMappedKey<T extends TSchema, K extends TMappedKey> = (TFromPropertyKeys<T, K['keys']>);
-export type TPickFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = TFromMappedKey<T, K>> = (TMappedResult<P>);
-export declare function PickFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = TFromMappedKey<T, K>>(T: T, K: K, options?: SchemaOptions): TMappedResult<P>;
+type TFromPropertyKeys<Type extends TSchema, PropertyKeys extends PropertyKey[], Result extends TProperties = {}> = (PropertyKeys extends [infer LeftKey extends PropertyKey, ...infer RightKeys extends PropertyKey[]] ? TFromPropertyKeys<Type, RightKeys, Result & TFromPropertyKey<Type, LeftKey>> : Result);
+type TFromMappedKey<Type extends TSchema, MappedKey extends TMappedKey> = (TFromPropertyKeys<Type, MappedKey['keys']>);
+export type TPickFromMappedKey<Type extends TSchema, MappedKey extends TMappedKey, Properties extends TProperties = TFromMappedKey<Type, MappedKey>> = (TMappedResult<Properties>);
+export declare function PickFromMappedKey<Type extends TSchema, MappedKey extends TMappedKey, Properties extends TProperties = TFromMappedKey<Type, MappedKey>>(type: Type, mappedKey: MappedKey, options?: SchemaOptions): TMappedResult<Properties>;
 export {};

package/build/cjs/type/pick/pick-from-mapped-key.js

@@ -6,23 +6,23 @@ const index_1 = require("../mapped/index");
 const pick_1 = require("./pick");
 const value_1 = require("../clone/value");
 // prettier-ignore
-function FromPropertyKey(T, K, options) {
+function FromPropertyKey(type, key, options) {
     return {
-        [K]: (0, pick_1.Pick)(T, [K], (0, value_1.Clone)(options))
+        [key]: (0, pick_1.Pick)(type, [key], (0, value_1.Clone)(options))
     };
 }
 // prettier-ignore
-function FromPropertyKeys(T, K, options) {
-    return K.reduce((Acc, LK) => {
-        return { ...Acc, ...FromPropertyKey(T, LK, options) };
+function FromPropertyKeys(type, propertyKeys, options) {
+    return propertyKeys.reduce((result, leftKey) => {
+        return { ...result, ...FromPropertyKey(type, leftKey, options) };
     }, {});
 }
 // prettier-ignore
-function FromMappedKey(T, K, options) {
-    return FromPropertyKeys(T, K.keys, options);
+function FromMappedKey(type, mappedKey, options) {
+    return FromPropertyKeys(type, mappedKey.keys, options);
 }
 // prettier-ignore
-function PickFromMappedKey(T, K, options) {
-    const P = FromMappedKey(T, K, options);
-    return (0, index_1.MappedResult)(P);
+function PickFromMappedKey(type, mappedKey, options) {
+    const properties = FromMappedKey(type, mappedKey, options);
+    return (0, index_1.MappedResult)(properties);
 }

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

@@ -3,10 +3,10 @@ import type { Ensure, Evaluate } from '../helpers/index';
 import type { TProperties } from '../object/index';
 import { type TMappedResult } from '../mapped/index';
 import { type TPick } from './pick';
-type TFromProperties<P extends TProperties, K extends PropertyKey[]> = ({
-    [K2 in keyof P]: TPick<P[K2], K>;
+type TFromProperties<Properties extends TProperties, PropertyKeys extends PropertyKey[]> = ({
+    [K2 in keyof Properties]: TPick<Properties[K2], PropertyKeys>;
 });
-type TFromMappedResult<R extends TMappedResult, K extends PropertyKey[]> = (Evaluate<TFromProperties<R['properties'], K>>);
-export type TPickFromMappedResult<T extends TMappedResult, K extends PropertyKey[], P extends TProperties = TFromMappedResult<T, K>> = (Ensure<TMappedResult<P>>);
-export declare function PickFromMappedResult<R extends TMappedResult, K extends PropertyKey[], P extends TProperties = TFromMappedResult<R, K>>(R: R, K: [...K], options?: SchemaOptions): TMappedResult<P>;
+type TFromMappedResult<MappedResult extends TMappedResult, PropertyKeys extends PropertyKey[]> = (Evaluate<TFromProperties<MappedResult['properties'], PropertyKeys>>);
+export type TPickFromMappedResult<MappedResult extends TMappedResult, PropertyKeys extends PropertyKey[], Properties extends TProperties = TFromMappedResult<MappedResult, PropertyKeys>> = (Ensure<TMappedResult<Properties>>);
+export declare function PickFromMappedResult<MappedResult extends TMappedResult, PropertyKeys extends PropertyKey[], Properties extends TProperties = TFromMappedResult<MappedResult, PropertyKeys>>(mappedResult: MappedResult, propertyKeys: [...PropertyKeys], options?: SchemaOptions): TMappedResult<Properties>;
 export {};

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

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

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

@@ -1,26 +1,36 @@
 import type { TSchema, SchemaOptions } from '../schema/index';
 import type { TupleToUnion, Evaluate, Ensure } from '../helpers/index';
 import { type TRecursive } from '../recursive/index';
+import { type TComputed } from '../computed/index';
 import { type TIntersect } from '../intersect/index';
-import { type TUnion } from '../union/index';
+import { type TLiteral, type TLiteralValue } from '../literal/index';
 import { type TObject, type TProperties } from '../object/index';
-import type { TMappedKey, TMappedResult } from '../mapped/index';
+import { type TUnion } from '../union/index';
+import { type TMappedKey, type TMappedResult } from '../mapped/index';
+import { type TRef } from '../ref/index';
 import { type TIndexPropertyKeys } from '../indexed/index';
 import { type TPickFromMappedKey } from './pick-from-mapped-key';
 import { type TPickFromMappedResult } from './pick-from-mapped-result';
-type FromIntersect<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? FromIntersect<R, K, [...Acc, TPick<L, K>]> : Acc;
-declare function FromIntersect<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K): FromIntersect<T, K>;
-type FromUnion<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? FromUnion<R, K, [...Acc, TPick<L, K>]> : Acc;
-declare function FromUnion<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K): FromUnion<T, K>;
-type TFromProperties<T extends TProperties, K extends PropertyKey[], I extends PropertyKey = TupleToUnion<K>> = Evaluate<Pick<T, I & keyof T>>;
-type TFromObject<T extends TObject, K extends PropertyKey[], Properties extends TProperties = T['properties']> = Ensure<TObject<(TFromProperties<Properties, K>)>>;
-export type TPick<T extends TProperties, K extends PropertyKey[]> = T extends TRecursive<infer S extends TSchema> ? TRecursive<TPick<S, K>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<FromIntersect<S, K>> : T extends TUnion<infer S extends TSchema[]> ? TUnion<FromUnion<S, K>> : T extends TObject<infer S extends TProperties> ? TFromObject<TObject<S>, K> : TObject<{}>;
-/** `[Json]` Constructs a type whose keys are picked from the given type */
-export declare function Pick<T extends TMappedResult, K extends PropertyKey[]>(T: T, K: [...K], options?: SchemaOptions): TPickFromMappedResult<T, K>;
-/** `[Json]` Constructs a type whose keys are picked from the given type */
-export declare function Pick<T extends TSchema, K extends TMappedKey>(T: T, K: K, options?: SchemaOptions): TPickFromMappedKey<T, K>;
+type TFromIntersect<Types extends TSchema[], PropertyKeys extends PropertyKey[], Result extends TSchema[] = []> = Types extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromIntersect<R, PropertyKeys, [...Result, TPick<L, PropertyKeys>]> : Result;
+type TFromUnion<Types extends TSchema[], PropertyKeys extends PropertyKey[], Result extends TSchema[] = []> = Types extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromUnion<R, PropertyKeys, [...Result, TPick<L, PropertyKeys>]> : Result;
+type TFromProperties<Properties extends TProperties, PropertyKeys extends PropertyKey[], UnionKeys extends PropertyKey = TupleToUnion<PropertyKeys>> = (Evaluate<Pick<Properties, UnionKeys & keyof Properties>>);
+type TFromObject<Type extends TObject, Key extends PropertyKey[], Properties extends TProperties = Type['properties']> = Ensure<TObject<(TFromProperties<Properties, Key>)>>;
+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]> : TUnion<Result>);
+export type TPickResolve<Properties extends TProperties, PropertyKeys extends PropertyKey[]> = (Properties extends TRecursive<infer Types extends TSchema> ? TRecursive<TPickResolve<Types, PropertyKeys>> : Properties extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromIntersect<Types, PropertyKeys>> : Properties extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromUnion<Types, PropertyKeys>> : Properties extends TObject<infer Types extends TProperties> ? TFromObject<TObject<Types>, PropertyKeys> : TObject<{}>);
+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 TPick<Type extends TSchema, Key extends TSchema | PropertyKey[], IsTypeRef extends boolean = Type extends TRef ? true : false, IsKeyRef extends boolean = Key extends TRef ? true : false> = (Type extends TMappedResult ? TPickFromMappedResult<Type, TResolvePropertyKeys<Key>> : Key extends TMappedKey ? TPickFromMappedKey<Type, Key> : [
+    IsTypeRef,
+    IsKeyRef
+] extends [true, true] ? TComputed<'Pick', [Type, TResolveTypeKey<Key>]> : [
+    IsTypeRef,
+    IsKeyRef
+] extends [false, true] ? TComputed<'Pick', [Type, TResolveTypeKey<Key>]> : [
+    IsTypeRef,
+    IsKeyRef
+] extends [true, false] ? TComputed<'Pick', [Type, TResolveTypeKey<Key>]> : TPickResolve<Type, TResolvePropertyKeys<Key>>);
 /** `[Json]` Constructs a type whose keys are picked from the given type */
-export declare function Pick<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TPick<T, I>;
+export declare function Pick<Type extends TSchema, Key extends PropertyKey[]>(type: Type, key: readonly [...Key], options?: SchemaOptions): TPick<Type, Key>;
 /** `[Json]` Constructs a type whose keys are picked from the given type */
-export declare function Pick<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TPick<T, K>;
+export declare function Pick<Type extends TSchema, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TPick<Type, Key>;
 export {};

package/build/cjs/type/pick/pick.js

@@ -4,56 +4,67 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Pick = Pick;
 const type_1 = require("../create/type");
 const discard_1 = require("../discard/discard");
-const index_1 = require("../intersect/index");
-const index_2 = require("../union/index");
-const index_3 = require("../object/index");
-const index_4 = require("../indexed/index");
-const pick_from_mapped_key_1 = require("./pick-from-mapped-key");
-const pick_from_mapped_result_1 = require("./pick-from-mapped-result");
+const index_1 = require("../computed/index");
+const index_2 = require("../intersect/index");
+const index_3 = require("../literal/index");
+const index_4 = require("../object/index");
+const index_5 = require("../union/index");
+const index_6 = require("../indexed/index");
 const symbols_1 = require("../symbols/symbols");
 // ------------------------------------------------------------------
-// TypeGuard
+// Guards
 // ------------------------------------------------------------------
 const kind_1 = require("../guard/kind");
-function FromIntersect(T, K) {
-    return T.map((T) => PickResolve(T, K));
+const guard_1 = require("src/value/guard");
+// ------------------------------------------------------------------
+// Infrastructure
+// ------------------------------------------------------------------
+const pick_from_mapped_key_1 = require("./pick-from-mapped-key");
+const pick_from_mapped_result_1 = require("./pick-from-mapped-result");
+function FromIntersect(types, propertyKeys) {
+    return types.map((type) => PickResolve(type, propertyKeys));
 }
 // prettier-ignore
-function FromUnion(T, K) {
-    return T.map((T) => PickResolve(T, K));
+function FromUnion(types, propertyKeys) {
+    return types.map((type) => PickResolve(type, propertyKeys));
 }
 // prettier-ignore
-function FromProperties(T, K) {
-    const Acc = {};
-    for (const K2 of K)
-        if (K2 in T)
-            Acc[K2] = T[K2];
-    return Acc;
+function FromProperties(properties, propertyKeys) {
+    const result = {};
+    for (const K2 of propertyKeys)
+        if (K2 in properties)
+            result[K2] = properties[K2];
+    return result;
 }
 // prettier-ignore
 function FromObject(T, K) {
     const options = (0, discard_1.Discard)(T, [symbols_1.TransformKind, '$id', 'required', 'properties']);
     const properties = FromProperties(T['properties'], K);
-    return (0, index_3.Object)(properties, options);
+    return (0, index_4.Object)(properties, options);
 }
-// ------------------------------------------------------------------
-// PickResolve
-// ------------------------------------------------------------------
 // prettier-ignore
-function PickResolve(T, K) {
-    return ((0, kind_1.IsIntersect)(T) ? (0, index_1.Intersect)(FromIntersect(T.allOf, K)) :
-        (0, kind_1.IsUnion)(T) ? (0, index_2.Union)(FromUnion(T.anyOf, K)) :
-            (0, kind_1.IsObject)(T) ? FromObject(T, K) :
-                (0, index_3.Object)({}));
+function UnionFromPropertyKeys(propertyKeys) {
+    const result = propertyKeys.reduce((result, key) => (0, kind_1.IsLiteralValue)(key) ? [...result, (0, index_3.Literal)(key)] : result, []);
+    return (0, index_5.Union)(result);
 }
-function Pick(T, K, options) {
-    // mapped
-    if ((0, kind_1.IsMappedKey)(K))
-        return (0, pick_from_mapped_key_1.PickFromMappedKey)(T, K, options);
-    if ((0, kind_1.IsMappedResult)(T))
-        return (0, pick_from_mapped_result_1.PickFromMappedResult)(T, K, options);
-    // non-mapped
-    const I = (0, kind_1.IsSchema)(K) ? (0, index_4.IndexPropertyKeys)(K) : K;
-    // special: mapping types require overridable options
-    return (0, type_1.CreateType)({ ...PickResolve(T, I), ...options });
+// prettier-ignore
+function PickResolve(properties, propertyKeys) {
+    return ((0, kind_1.IsIntersect)(properties) ? (0, index_2.Intersect)(FromIntersect(properties.allOf, propertyKeys)) :
+        (0, kind_1.IsUnion)(properties) ? (0, index_5.Union)(FromUnion(properties.anyOf, propertyKeys)) :
+            (0, kind_1.IsObject)(properties) ? FromObject(properties, propertyKeys) :
+                (0, index_4.Object)({}));
+}
+/** `[Json]` Constructs a type whose keys are picked from the given type */
+// prettier-ignore
+function Pick(type, key, options) {
+    const typeKey = (0, guard_1.IsArray)(key) ? UnionFromPropertyKeys(key) : key;
+    const propertyKeys = (0, kind_1.IsSchema)(key) ? (0, index_6.IndexPropertyKeys)(key) : key;
+    const isTypeRef = (0, kind_1.IsRef)(type);
+    const isKeyRef = (0, kind_1.IsRef)(key);
+    return ((0, kind_1.IsMappedResult)(type) ? (0, pick_from_mapped_result_1.PickFromMappedResult)(type, propertyKeys, options) :
+        (0, kind_1.IsMappedKey)(key) ? (0, pick_from_mapped_key_1.PickFromMappedKey)(type, key, options) :
+            (isTypeRef && isKeyRef) ? (0, index_1.Computed)('Pick', [type, typeKey], options) :
+                (!isTypeRef && isKeyRef) ? (0, index_1.Computed)('Pick', [type, typeKey], options) :
+                    (isTypeRef && !isKeyRef) ? (0, index_1.Computed)('Pick', [type, typeKey], options) :
+                        (0, type_1.CreateType)({ ...PickResolve(type, propertyKeys), ...options }));
 }

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

@@ -2,6 +2,7 @@ import type { TSchema } from '../schema/index';
 import type { Static } from '../static/index';
 import type { Evaluate, Ensure, Assert } from '../helpers/index';
 import { type TAny } from '../any/index';
+import { type TComputed } from '../computed/index';
 import { type TObject, type TProperties, type TAdditionalProperties, type ObjectOptions } from '../object/index';
 import { type TLiteral, type TLiteralValue } from '../literal/index';
 import { type TNever } from '../never/index';
@@ -11,6 +12,7 @@ import { type TString } from '../string/index';
 import { type TInteger } from '../integer/index';
 import { type TNumber } from '../number/index';
 import { type TEnum } from '../enum/index';
+import { type TRef } from '../ref/index';
 import { TIsTemplateLiteralFinite, type TTemplateLiteral } from '../template-literal/index';
 import { Kind } from '../symbols/index';
 type TFromTemplateLiteralKeyInfinite<K extends TTemplateLiteral, T extends TSchema> = Ensure<TRecord<K, T>>;
@@ -50,7 +52,7 @@ export interface TRecord<K extends TSchema = TSchema, T extends TSchema = TSchem
     };
     additionalProperties: TAdditionalProperties;
 }
-export type TRecordOrObject<K extends TSchema, T extends TSchema> = K extends TTemplateLiteral ? TFromTemplateLiteralKey<K, T> : K extends TEnum<infer S> ? TFromEnumKey<S, T> : K extends TUnion<infer S> ? TFromUnionKey<S, T> : K extends TLiteral<infer S> ? TFromLiteralKey<S, T> : K extends TInteger ? TFromIntegerKey<K, T> : K extends TNumber ? TFromNumberKey<K, T> : K extends TRegExp ? TFromRegExpKey<K, T> : K extends TString ? TFromStringKey<K, T> : K extends TAny ? TFromAnyKey<K, T> : K extends TNever ? TFromNeverKey<K, T> : TNever;
+export type TRecordOrObject<Key extends TSchema, Type extends TSchema> = Type extends TRef ? TComputed<'Record', [Key, Type]> : Key extends TRef ? TComputed<'Record', [Key, Type]> : Key extends TTemplateLiteral ? TFromTemplateLiteralKey<Key, Type> : Key extends TEnum<infer S> ? TFromEnumKey<S, Type> : Key extends TUnion<infer S> ? TFromUnionKey<S, Type> : Key extends TLiteral<infer S> ? TFromLiteralKey<S, 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<K extends TSchema, T extends TSchema>(K: K, T: T, options?: ObjectOptions): TRecordOrObject<K, T>;
+export declare function Record<Key extends TSchema, Type extends TSchema>(key: Key, type: Type, options?: ObjectOptions): TRecordOrObject<Key, Type>;
 export {};