zodselect 1.3.1 → 1.4.0

package/dist/build-select-object.d.ts

@@ -1,19 +1,25 @@
-import { ZodArray, ZodCatch, ZodDefault, ZodLazy, ZodNullable, ZodObject, ZodOptional, ZodRawShape, ZodType, ZodUnion } from 'zod';
-import { UnionToIntersection } from './refine-schema.js';
+import { ZodArray, ZodCatch, ZodDefault, ZodIntersection, ZodLazy, ZodNonOptional, ZodNullable, ZodObject, ZodOptional, ZodPipe, ZodPrefault, ZodRawShape, ZodReadonly, ZodTransform, ZodType, ZodUnion } from 'zod';
 import { ZodSelect } from './select.js';
 type Depth = [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
 type FieldSelectAll<T, TDepth extends number> = TDepth extends 0 ? true : Unwrap<T> extends ZodArray<infer TItem> ? ItemSelectAll<TItem, Depth[TDepth]> : ItemSelectAll<T, Depth[TDepth]>;
-type ItemSelectAll<T, TDepth extends number> = Unwrap<T> extends ZodObject<infer TShape, any> ? ObjectSelectAll<TShape, TDepth> : Unwrap<T> extends ZodUnion<infer TOptions> ? [NotObject<TOptions[number]>] extends [never] ? UnionShape<TOptions> extends infer TShape extends ZodRawShape ? ObjectSelectAll<TShape, TDepth> : true : true : true;
+type ItemSelectAll<T, TDepth extends number> = Unwrap<T> extends ZodObject<infer TShape, any> ? ObjectSelectAll<TShape, TDepth> : Unwrap<T> extends ZodUnion<infer TOptions> ? [NotObject<TOptions[number]>] extends [never] ? VariantsSelectAll<TOptions[number], TDepth> : true : true;
+/** Every key of every member of the union `T`. */
+type KeysOfUnion<T> = T extends unknown ? keyof T : never;
+/** Select-all objects merged as {@link buildSelectObject} merges them: a key `true` in any of them is `true`, objects merge by key. */
+type MergeSelectAll<T> = [T] extends [never] ? never : true extends T ? true : {
+    [K in KeysOfUnion<T>]-?: MergeSelectAll<T extends unknown ? K extends keyof T ? T[K] : never : never>;
+};
 type NotObject<T> = T extends unknown ? Unwrap<T> extends ZodObject<any, any> ? never : T : never;
 type ObjectSelectAll<TShape extends ZodRawShape, TDepth extends number> = {
     [K in keyof TShape]-?: FieldSelectAll<TShape[K], TDepth>;
 };
-type ShapeOf<T> = T extends unknown ? Unwrap<T> extends ZodObject<infer TShape, any> ? TShape : never : never;
-/** The shapes of a union's object variants, merged; `unknown` when it has none. */
-type UnionShape<TOptions> = UnionToIntersection<TOptions extends readonly (infer TOption)[] ? ShapeOf<TOption> : never>;
-type Unwrap<T> = T extends ZodCatch<infer I> | ZodDefault<infer I> | ZodNullable<infer I> | ZodOptional<infer I> ? Unwrap<I> : T extends ZodLazy<infer I> ? Unwrap<I> : T;
+type Unwrap<T> = T extends ZodCatch<infer I> | ZodDefault<infer I> | ZodNonOptional<infer I> | ZodNullable<infer I> | ZodOptional<infer I> | ZodPrefault<infer I> | ZodReadonly<infer I> ? Unwrap<I> : T extends ZodLazy<infer I> ? Unwrap<I> : T extends ZodPipe<any, infer O> ? O extends ZodTransform ? T : Unwrap<O> : T;
+/** The select-all of each object variant in `T`, through intersections, merged. */
+type VariantsSelectAll<T, TDepth extends number> = MergeSelectAll<T extends unknown ? Unwrap<T> extends ZodObject<infer TShape, any> ? ObjectSelectAll<TShape, TDepth> : Unwrap<T> extends ZodIntersection<infer L, infer R> ? VariantsSelectAll<L | R, TDepth> : Unwrap<T> extends ZodUnion<infer TOptions> ? VariantsSelectAll<TOptions[number], TDepth> : never : never>;
 /** What {@link buildSelectObject} answers: nested for objects, unions of objects, and arrays of either; `true` for anything else. */
-export type ZodSelectAll<T extends ZodType<object> | ZodUnion> = Unwrap<T> extends ZodObject<infer TShape, any> ? ObjectSelectAll<TShape, 10> : {
+export type ZodSelectAll<T extends ZodType<object> | ZodUnion> = Unwrap<T> extends ZodObject<infer TShape, any> ? ObjectSelectAll<TShape, 10> : Unwrap<T> extends ZodIntersection | ZodUnion ? [VariantsSelectAll<T, 10>] extends [never] ? {
+    [K in keyof ZodSelect<T, true>]-?: true;
+} : VariantsSelectAll<T, 10> : {
     [K in keyof ZodSelect<T, true>]-?: true;
 };
 /**
@@ -25,7 +31,9 @@ export type ZodSelectAll<T extends ZodType<object> | ZodUnion> = Unwrap<T> exten
  * with any other variant, such as a name that is a string or a structured
  * name, remains `true`: its sub-fields would miss the plain value. Other arrays
  * and records remain `true`.
- * For union schemas the result is the merged set of keys across all variants.
+ * For union schemas the result is the merged set of keys across all variants,
+ * a key nested in one variant and plain in another selected whole.
+ * Past the depth limit, a field is selected whole.
  *
  * @example
  * ```ts

package/dist/build-select-object.js

@@ -1,5 +1,5 @@
-import { ZodCatch, ZodDefault, ZodLazy, ZodNullable, ZodOptional } from 'zod';
-import { getInnerType, isZodArray, isZodObject, isZodUnion } from './utilities.js';
+import { ZodLazy } from 'zod';
+import { getInnerType, isZodArray, isZodObject, isZodUnion, unwrapWrapper } from './utilities.js';
 /**
  * Produces a runtime select-all object for the given Zod schema.
  *
@@ -9,7 +9,9 @@ import { getInnerType, isZodArray, isZodObject, isZodUnion } from './utilities.j
  * with any other variant, such as a name that is a string or a structured
  * name, remains `true`: its sub-fields would miss the plain value. Other arrays
  * and records remain `true`.
- * For union schemas the result is the merged set of keys across all variants.
+ * For union schemas the result is the merged set of keys across all variants,
+ * a key nested in one variant and plain in another selected whole.
+ * Past the depth limit, a field is selected whole.
  *
  * @example
  * ```ts
@@ -23,14 +25,12 @@ export function buildSelectObject(schema) {
     return result;
 }
 /**
- * Unwraps optional/nullable/default/catch/lazy wrappers but NOT arrays.
+ * Unwraps optional/nullable/default/catch/readonly/pipe/lazy wrappers but NOT arrays.
  */
 function unwrapField(schema) {
-    if (schema instanceof ZodOptional
-        || schema instanceof ZodNullable
-        || schema instanceof ZodDefault
-        || schema instanceof ZodCatch) {
-        return unwrapField(schema.def.innerType);
+    const unwrapped = unwrapWrapper(schema);
+    if (unwrapped) {
+        return unwrapField(unwrapped);
     }
     if (schema instanceof ZodLazy) {
         return unwrapField(schema.def.getter());
@@ -39,22 +39,19 @@ function unwrapField(schema) {
 }
 const MAX_DEPTH = 10;
 function collectKeys(schema, result, depth = 0) {
-    if (depth >= MAX_DEPTH) {
-        return;
-    }
     schema = getInnerType(schema);
     if (isZodObject(schema)) {
         for (const key in schema.shape) {
             const field = unwrapField(schema.shape[key]);
             const fieldInner = isZodArray(field) ? unwrapField(field.def.element) : field;
-            if (isZodObject(fieldInner) || isUnionOfObjects(fieldInner)) {
+            let value = true;
+            if ((depth < MAX_DEPTH) && (isZodObject(fieldInner) || isUnionOfObjects(fieldInner))) {
                 const nested = {};
                 collectKeys(fieldInner, nested, depth + 1);
-                result[key] = nested;
-            }
-            else {
-                result[key] = true;
+                value = nested;
             }
+            const existing = result[key];
+            result[key] = (existing === undefined) ? value : mergeSelectValue(existing, value);
         }
     }
     else if (isZodUnion(schema)) {
@@ -70,3 +67,15 @@ function collectKeys(schema, result, depth = 0) {
 function isUnionOfObjects(schema) {
     return isZodUnion(schema) && schema.options.every(option => isZodObject(unwrapField(option)));
 }
+/** Two variants' selects of one key: `true` if either is, as sub-fields would miss a plain value; else their keys merged. */
+function mergeSelectValue(a, b) {
+    if ((a === true) || (b === true)) {
+        return true;
+    }
+    const merged = { ...a };
+    for (const [key, value] of Object.entries(b)) {
+        const existing = merged[key];
+        merged[key] = (existing === undefined) ? value : mergeSelectValue(existing, value);
+    }
+    return merged;
+}

package/dist/build-select-schema.js

@@ -15,6 +15,9 @@ function buildSelect(schema, cache = new Map()) {
     if (isZodObject(schema)) {
         const shape = {};
         let select;
+        // Stands in for this object while its fields are built, so a field that comes back to it, as a getter can,
+        // resolves. It is only read once parsing starts, after `result` below is set.
+        cache.set(schema, z.lazy(() => result));
         for (const key in schema.shape) {
             shape[key] = buildSelect(schema.shape[key], cache);
         }
@@ -58,48 +61,55 @@ function buildSelect(schema, cache = new Map()) {
         types = schema.def.options;
     }
     if (types) {
-        const hasLazy = types.some(item => isZodLazy(item));
-        if (hasLazy) {
-            return z.lazy(() => {
-                return buildSelectMerge(types, cache);
-            });
-        }
-        return buildSelectMerge(types, cache);
+        return mergeSelects(types.map(type => buildSelect(type, cache)));
     }
     return z.boolean().optional();
 }
-function buildSelectMerge(types, cache) {
-    const shape = {};
+export function buildSelectSchema(schema) {
+    const result = buildSelect(schema);
+    if (isZodLazy(result)) {
+        return result.def.getter().def.innerType.def.options[1];
+    }
+    return result.def.innerType.def.options[1];
+}
+/** A select for a value of any of the clauses' types: their object selects' keys, a key two of them share merged in turn. */
+function mergeClauses(clauses) {
+    const keySelects = {};
     let isStrict = false;
-    for (const cur of types) {
-        const select = buildSelect(cur, cache);
-        let clause;
-        if (isZodLazy(select)) {
-            clause = select.def.getter();
-        }
-        else {
-            clause = select;
-        }
+    for (const clause of clauses) {
         if (clause.def.innerType.def.type === 'union') {
             const obj = getInnerType(clause.def.innerType.def.options[1]);
             for (const key in obj.shape) {
-                shape[key] = obj.shape[key];
+                (keySelects[key] ??= []).push(obj.shape[key]);
             }
             if (!isZodObjectLoose(obj)) {
                 isStrict = true;
             }
         }
     }
+    const shape = {};
+    for (const [key, selects] of Object.entries(keySelects)) {
+        const distinct = [...new Set(selects)];
+        shape[key] = (distinct.length === 1) ? distinct[0] : mergeKeySelects(distinct);
+    }
     let result = z.object(shape);
     if (isStrict) {
         result = result.strict();
     }
     return z.union([z.boolean(), result]).optional();
 }
-export function buildSelectSchema(schema) {
-    const result = buildSelect(schema);
-    if (isZodLazy(result)) {
-        return result.def.getter().def.innerType.def.options[1];
+/** The selects of one key that several variants share: a plain boolean when none selects into an object. */
+function mergeKeySelects(selects) {
+    const isNested = (select) => isZodLazy(select) || (select.def.innerType.def.type === 'union');
+    if (!selects.some(isNested)) {
+        return selects[0];
     }
-    return result.def.innerType.def.options[1];
+    return mergeSelects(selects.filter(isNested));
+}
+/** Selects merged into one, lazily when any is lazy, as a recursive one may not be built yet. */
+function mergeSelects(selects) {
+    if (selects.some(select => isZodLazy(select))) {
+        return z.lazy(() => mergeClauses(selects.map(select => (isZodLazy(select) ? select.def.getter() : select))));
+    }
+    return mergeClauses(selects);
 }

package/dist/refine-schema.d.ts

@@ -26,7 +26,7 @@ type Push<T extends any[], V> = [...T, V];
 type ReapplyOptionalNullable<T, U extends z.ZodType> = T extends ZodOptional<ZodNullable<ZodType>> ? ZodOptional<ZodNullable<U>> : T extends ZodNullable<ZodOptional<ZodType>> ? ZodNullable<ZodOptional<U>> : T extends ZodOptional<ZodType> ? ZodOptional<U> : T extends ZodNullable<ZodType> ? ZodNullable<U> : U;
 export type RefinedSchema<T extends ZodType<object> | ZodUnion, TShape extends RefineSchema<T, TIsSimple>, TIsSimple extends boolean> = T extends ZodUnion ? RefinedUnionSchema<T, TShape> : T extends ZodType<object> ? RefinedTypeSchema<z.infer<T>, TShape> : never;
 export type RefinedTypeSchema<T extends object, TShape, TDepth extends number = 0> = TDepth extends keyof DepthLimit ? ZodObject<{
-    [K in keyof T & keyof TShape]: TShape[K] extends (schema: infer _S) => ZodType ? ReturnType<TShape[K]> : TShape[K] extends ZodType ? TShape[K] : TShape[K] extends boolean ? ZodifyField<T, K> : TShape[K] extends object ? Exclude<T[K], null | undefined> extends Array<infer U> ? [Extract<U, object>] extends [never] ? Zodify<T[K]> : ApplyOptionalNullable<T[K], z.ZodArray<RefinedVariants<Extract<U, object>, TShape[K], NextDepth<TDepth>>>> : [Extract<Exclude<T[K], null | undefined>, object>] extends [never] ? ZodNever : ApplyOptionalNullable<T[K], RefinedVariants<Extract<Exclude<T[K], null | undefined>, object>, TShape[K], NextDepth<TDepth>>> : ZodNever;
+    [K in keyof T & keyof TShape]: TShape[K] extends (schema: infer _S) => ZodType ? ReturnType<TShape[K]> : TShape[K] extends ZodType ? TShape[K] : TShape[K] extends boolean ? ZodifyField<T, K> : TShape[K] extends object ? Exclude<T[K], null | undefined> extends ReadonlyArray<infer U> ? [Extract<U, object>] extends [never] ? Zodify<T[K]> : ApplyOptionalNullable<T[K], z.ZodArray<RefinedVariants<Extract<U, object>, TShape[K], NextDepth<TDepth>>>> : [Extract<Exclude<T[K], null | undefined>, object>] extends [never] ? ZodNever : ApplyOptionalNullable<T[K], RefinedVariants<Extract<Exclude<T[K], null | undefined>, object>, TShape[K], NextDepth<TDepth>>> : ZodNever;
 }, core.$strip> : any;
 export type RefinedUnionSchema<T extends ZodUnion, TShape> = ZodUnion<T['options'] extends Readonly<[infer A, ...infer Rest]> ? Rest extends ZodType[] ? [
     ReapplyOptionalNullable<A, A extends ZodType<object> ? RefinedTypeSchema<z.infer<A>, TShape> : Extract<A, ZodType>>,
@@ -43,7 +43,7 @@ export type RefineObject<T extends object, TIsSimple extends boolean> = {
     [K in keyof T as string extends K ? never : number extends K ? never : symbol extends K ? never : K]?: RefineType<T[K], TIsSimple>;
 };
 export type RefineSchema<T extends ZodType<object> | ZodUnion, TIsSimple extends boolean> = T extends ZodUnion ? RefineZodUnion<T> : T extends ZodType<object> ? RefineObject<z.infer<T>, TIsSimple> : never;
-type RefineType<T, TIsSimple extends boolean> = IsTuple<TuplifyUnion<Exclude<T, null | undefined>>, ([Extract<Exclude<T, null | undefined>, object>] extends [never] ? never : RefineObject<Extract<Exclude<T, null | undefined>, object>, TIsSimple>) | Refinement<Zodify<T>, TIsSimple>, Exclude<T, null | undefined> extends string ? Refinement<ApplyOptionalNullable<T, ZodString>, TIsSimple> : Exclude<T, null | undefined> extends number ? Refinement<ApplyOptionalNullable<T, ZodNumber>, TIsSimple> : Exclude<T, null | undefined> extends boolean ? Refinement<ApplyOptionalNullable<T, ZodBoolean>, TIsSimple> : Exclude<T, null | undefined> extends Date ? Refinement<ApplyOptionalNullable<T, ZodDate>, TIsSimple> : Exclude<T, null | undefined> extends Array<infer U> ? [Extract<U, object>] extends [never] ? Refinement<Zodify<T>, TIsSimple> : Refinement<Zodify<T>, TIsSimple> | RefineObject<Extract<U, object>, TIsSimple> : Exclude<T, null | undefined> extends object ? IsJsonType<Exclude<T, null | undefined>, false, Refinement<Zodify<T>, TIsSimple> | RefineObject<Extract<T, object>, TIsSimple>, Refinement<Zodify<T>, TIsSimple>> : unknown extends Exclude<T, null | undefined> ? Refinement<Zodify<T>, TIsSimple> : never>;
+type RefineType<T, TIsSimple extends boolean> = IsTuple<TuplifyUnion<Exclude<T, null | undefined>>, ([Extract<Exclude<T, null | undefined>, object>] extends [never] ? never : RefineObject<Extract<Exclude<T, null | undefined>, object>, TIsSimple>) | Refinement<Zodify<T>, TIsSimple>, Exclude<T, null | undefined> extends string ? Refinement<ApplyOptionalNullable<T, ZodString>, TIsSimple> : Exclude<T, null | undefined> extends number ? Refinement<ApplyOptionalNullable<T, ZodNumber>, TIsSimple> : Exclude<T, null | undefined> extends boolean ? Refinement<ApplyOptionalNullable<T, ZodBoolean>, TIsSimple> : Exclude<T, null | undefined> extends Date ? Refinement<ApplyOptionalNullable<T, ZodDate>, TIsSimple> : Exclude<T, null | undefined> extends ReadonlyArray<infer U> ? [Extract<U, object>] extends [never] ? Refinement<Zodify<T>, TIsSimple> : Refinement<Zodify<T>, TIsSimple> | RefineObject<Extract<U, object>, TIsSimple> : Exclude<T, null | undefined> extends object ? IsJsonType<Exclude<T, null | undefined>, false, Refinement<Zodify<T>, TIsSimple> | RefineObject<Extract<T, object>, TIsSimple>, Refinement<Zodify<T>, TIsSimple>> : unknown extends Exclude<T, null | undefined> ? Refinement<Zodify<T>, TIsSimple> : never>;
 export type RefineZodTuple<T extends ZodTuple> = {
     [K in keyof UnionToIntersection<T['def']['items'][number] extends ZodObject<infer Shape extends ZodRawShape> ? Shape : object>]?: boolean;
 };
@@ -51,7 +51,7 @@ export type RefineZodUnion<T extends ZodUnion> = {
     [K in keyof UnionMergedShape<T>]?: UnionMergedShape<T>[K] extends ZodType ? UnionFieldType<UnionMergedShape<T>[K]> : boolean;
 };
 export type TuplifyUnion<T, TDepth extends number = 0, L = LastOf<T>, N = [T] extends [never] ? true : false> = TDepth extends 9 ? [] : true extends N ? [] : Push<TuplifyUnion<Exclude<T, L>, NextDepth<TDepth>>, InternalZodify<L>>;
-type UnionFieldType<T extends ZodType> = Exclude<z.infer<T>, null | undefined> extends Array<infer U> ? Exclude<U, null | undefined> extends object ? boolean | RefineObject<Extract<U, object>, true> : boolean : Exclude<z.infer<T>, null | undefined> extends object ? boolean | RefineObject<Exclude<z.infer<T>, null | undefined>, true> : boolean;
+type UnionFieldType<T extends ZodType> = Exclude<z.infer<T>, null | undefined> extends ReadonlyArray<infer U> ? Exclude<U, null | undefined> extends object ? boolean | RefineObject<Extract<U, object>, true> : boolean : Exclude<z.infer<T>, null | undefined> extends object ? boolean | RefineObject<Exclude<z.infer<T>, null | undefined>, true> : boolean;
 type UnionMergedShape<T extends ZodUnion> = UnionToIntersection<T['options'][number] extends ZodObject<infer Shape extends ZodRawShape> ? Shape : object>;
 export type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
 export type Zodify<T, TDepth extends number = 0> = ApplyOptionalNullable<T, IsAny<T, ZodAny, ZodifyLiteral<Exclude<T, null | undefined>, IsTuple<TuplifyUnion<Exclude<T, null | undefined>, TDepth>, ZodUnion<TuplifyUnion<Exclude<T, null | undefined>, TDepth>>, InternalZodify<Exclude<T, null | undefined>, TDepth>>>>>;

package/dist/refine-schema.js

@@ -1,5 +1,10 @@
 import { z } from 'zod';
-import { isZodArray, isZodCatch, isZodDefault, isZodLazy, isZodNullable, isZodObject, isZodOptional, isZodType, isZodUnion } from './utilities.js';
+import { getInnerType, isZodArray, isZodCatch, isZodDefault, isZodLazy, isZodNonOptional, isZodNullable, isZodObject, isZodOptional, isZodPipe, isZodPrefault, isZodReadonly, isZodTransform, isZodType, isZodUnion } from './utilities.js';
+/** Whether a value of `schema` can be an object, so that a nested select could pick within it. */
+function holdsObject(schema) {
+    const inner = getInnerType(schema);
+    return isZodObject(inner) || (isZodUnion(inner) && inner.options.some(option => holdsObject(option)));
+}
 /** `shape`'s fields of `schema`. A key the schema doesn't have, at any depth, is a type error. */
 export function refineSchema(schema, shape) {
     return refineSchemaUnchecked(schema, shape);
@@ -31,10 +36,26 @@ function refineSchemaField(fieldSchema, fieldShape) {
     else if (isZodNullable(fieldSchema)) {
         return refineSchemaField(fieldSchema.def.innerType, fieldShape).nullable();
     }
-    else if (isZodDefault(fieldSchema) || isZodCatch(fieldSchema)) {
+    else if (isZodDefault(fieldSchema) || isZodPrefault(fieldSchema) || isZodCatch(fieldSchema)) {
         // A default or catch is a whole value, which a picked part no longer fits, so it gives way to what it wraps.
         return refineSchemaField(fieldSchema.def.innerType, fieldShape);
     }
+    else if (isZodNonOptional(fieldSchema)) {
+        return refineSchemaField(fieldSchema.def.innerType, fieldShape).nonoptional();
+    }
+    else if (isZodReadonly(fieldSchema)) {
+        return refineSchemaField(fieldSchema.def.innerType, fieldShape).readonly();
+    }
+    else if (isZodPipe(fieldSchema)) {
+        if (!isZodTransform(fieldSchema.def.out)) {
+            return fieldSchema.def.in.pipe(refineSchemaField(fieldSchema.def.out, fieldShape));
+        }
+        // A transform's output has no schema to pick from, and picking its input by the output's keys would feed it
+        // a part it doesn't expect. Kept whole, it would hand back fields that weren't selected, so it is refused.
+        if (holdsObject(fieldSchema.def.in)) {
+            throw new Error('Cannot select fields within a transformed object: select it with `true`, or redefine it with a schema or function.');
+        }
+    }
     else if (isZodLazy(fieldSchema)) {
         return refineSchemaField(fieldSchema.def.getter(), fieldShape);
     }
@@ -49,7 +70,7 @@ export function refineSchemaUnchecked(schema, shape) {
         const refinedShape = {};
         const schemaShape = schema.shape;
         for (const key in shape) {
-            if (key in schemaShape && shape[key] !== false) {
+            if (Object.hasOwn(schemaShape, key) && shape[key] !== false) {
                 refinedShape[key] = refineSchemaField(schemaShape[key], shape[key]);
             }
         }

package/dist/select.d.ts

@@ -1,12 +1,12 @@
 import { z, ZodTuple, ZodType, ZodUnion } from 'zod';
 import { RefinedTypeSchema, RefinedUnionSchema, RefineObject, RefineZodTuple, RefineZodUnion } from './refine-schema.js';
-import { DeepMergeAll, IsEqual } from './types.js';
+import { DeepMergeAll } from './types.js';
 export type InferMergedType<T extends ZodType<object> | ZodUnion, U extends readonly ZodSelect<T>[] | undefined | ZodSelect<T>> = U extends undefined ? z.infer<T> : U extends readonly ZodSelect<T>[] ? DeepMergeAll<InferTuple<T, U>> : U extends ZodSelect<T> ? InferType<T, U> : never;
 type InferTuple<T extends ZodType<object> | ZodUnion, U extends readonly ZodSelect<T>[]> = {
     [K in keyof U]: InferType<T, U[K]>;
 };
 export type InferType<T extends ZodType<object> | ZodUnion, U extends ZodSelect<T>> = U extends ZodType<object> ? z.infer<U> : U extends ZodUnion ? z.infer<U> : T extends ZodUnion ? (U extends RefineZodUnion<T> ? z.infer<RefinedUnionSchema<T, U>> : z.infer<T>) : T extends ZodType<object> ? (U extends RefineObject<z.infer<T>, false> ? z.infer<RefinedTypeSchema<z.infer<T>, U>> : z.infer<T>) : z.infer<T>;
-export type MergeSelect<T extends ZodType<object> | ZodUnion, TSelect1 extends ZodSelect<T>, TSelect2 extends MultiSelect<T>> = TSelect2 extends undefined ? [TSelect1, T] : IsEqual<TSelect2, T, TSelect1, TSelect2 extends [ZodSelect<T>, ...ZodSelect<T>[]] ? [TSelect1, ...TSelect2] : [TSelect1, TSelect2]>;
+export type MergeSelect<T extends ZodType<object> | ZodUnion, TSelect1 extends ZodSelect<T>, TSelect2 extends MultiSelect<T>> = TSelect2 extends undefined ? [TSelect1, T] : TSelect2 extends [ZodSelect<T>, ...ZodSelect<T>[]] ? [TSelect1, ...TSelect2] : [TSelect1, TSelect2];
 export type MultiSelect<T extends ZodType<object> | ZodUnion> = [
     ZodSelect<T>,
     ...ZodSelect<T>[]

package/dist/types.d.ts

@@ -1,7 +1,12 @@
+/**
+ * `U` merged into `T`, as types: keys in both merge deeply when both sides are objects, and by their elements when
+ * both are arrays, kept `null` or `undefined` where a side may be; otherwise they widen to `T[K] | U[K]`.
+ */
 export type DeepMerge<T, U> = {
-    [K in keyof T | keyof U]: K extends keyof T ? K extends keyof U ? T[K] extends object ? U[K] extends object ? DeepMerge<T[K], U[K]> : T[K] | U[K] : T[K] | U[K] : T[K] : K extends keyof U ? U[K] : never;
+    [K in keyof T | keyof U]: K extends keyof T ? K extends keyof U ? DeepMergeValue<T[K], U[K]> : T[K] : K extends keyof U ? U[K] : never;
 };
 export type DeepMergeAll<T> = T extends readonly any[] ? T extends [infer First, ...infer Rest] ? Rest extends [] ? First : DeepMerge<First, DeepMergeAll<Rest>> : unknown : T;
+type DeepMergeValue<T, U> = [NonNullable<T>, NonNullable<U>] extends [infer A, infer B] ? [A] extends [never] ? T | U : [B] extends [never] ? T | U : [Extract<A | B, ((...args: never[]) => unknown) | Date>] extends [never] ? [A, B] extends [readonly (infer AItem)[], readonly (infer BItem)[]] ? DeepMergeValue<AItem, BItem>[] | Extract<T | U, null | undefined> : [A, B] extends [object, object] ? [Extract<A | B, readonly unknown[]>] extends [never] ? DeepMerge<A, B> | Extract<T | U, null | undefined> : T | U : T | U : T | U : never;
 export type IsAny<T, TTrue = true, TFalse = false> = 0 extends (1 & T) ? TTrue : TFalse;
 export type IsEqual<T, U, TTrue = true, TFalse = false> = (<V>() => V extends T ? 1 : 2) extends (<V>() => V extends U ? 1 : 2) ? TTrue : TFalse;
 export type IsJsonType<T, TDeep extends boolean = true, TTrue = true, TFalse = false> = T extends JsonType ? TTrue : T extends Function ? TFalse : T extends Array<infer U> ? TDeep extends false ? TTrue : IsJsonType<U, TDeep, TTrue, TFalse> : T extends object ? TDeep extends false ? TTrue : {

package/dist/utilities.d.ts

@@ -1,14 +1,24 @@
-import { ZodArray, ZodCatch, ZodDefault, ZodLazy, ZodNullable, ZodObject, ZodOptional, ZodRecord, ZodType, ZodUnion, ZodUnknown } from 'zod';
+import { ZodArray, ZodCatch, ZodDefault, ZodLazy, ZodNonOptional, ZodNullable, ZodObject, ZodOptional, ZodPipe, ZodPrefault, ZodReadonly, ZodRecord, ZodType, ZodUnion, ZodUnknown } from 'zod';
 export declare function getInnerType(schema: ZodType, unwrapLazy?: boolean): ZodType;
 export declare function isZodArray(obj: unknown): obj is ZodArray<ZodType>;
 export declare function isZodCatch(obj: unknown): obj is ZodCatch<ZodType>;
 export declare function isZodDefault(obj: unknown): obj is ZodDefault<ZodType>;
 export declare function isZodLazy(obj: unknown): obj is ZodLazy;
+export declare function isZodNonOptional(obj: unknown): obj is ZodNonOptional<ZodType>;
 export declare function isZodNullable(obj: unknown): obj is ZodNullable<ZodType>;
 export declare function isZodObject(obj: unknown, isLoose?: boolean): obj is ZodObject;
 export declare function isZodObjectLoose(obj: ZodObject): boolean;
 export declare function isZodOptional(obj: unknown): obj is ZodOptional<ZodType>;
+export declare function isZodPipe(obj: unknown): obj is ZodPipe;
+export declare function isZodPrefault(obj: unknown): obj is ZodPrefault<ZodType>;
+export declare function isZodReadonly(obj: unknown): obj is ZodReadonly<ZodType>;
 export declare function isZodRecord(obj: unknown): obj is ZodRecord;
+export declare function isZodTransform(obj: unknown): boolean;
 export declare function isZodType(obj: unknown): obj is ZodType;
 export declare function isZodUnion(obj: unknown): obj is ZodUnion<ZodType[]>;
 export declare function isZodUnknown(obj: unknown): obj is ZodUnknown;
+/**
+ * The schema a value-preserving wrapper holds: optional, nullable, default, prefault, catch, nonoptional, readonly,
+ * or a pipe's output side. `undefined` for anything else, including a pipe into a transform, whose output has no schema.
+ */
+export declare function unwrapWrapper(schema: ZodType): undefined | ZodType;

package/dist/utilities.js

@@ -1,10 +1,8 @@
-import { ZodArray, ZodCatch, ZodDefault, ZodLazy, ZodNullable, ZodOptional } from 'zod';
+import { ZodArray, ZodCatch, ZodDefault, ZodLazy, ZodNonOptional, ZodNullable, ZodOptional, ZodPipe, ZodPrefault, ZodReadonly } from 'zod';
 export function getInnerType(schema, unwrapLazy = true) {
-    if (schema instanceof ZodOptional
-        || schema instanceof ZodNullable
-        || schema instanceof ZodDefault
-        || schema instanceof ZodCatch) {
-        return getInnerType(schema.def.innerType, unwrapLazy);
+    const unwrapped = unwrapWrapper(schema);
+    if (unwrapped) {
+        return getInnerType(unwrapped, unwrapLazy);
     }
     if (schema instanceof ZodArray) {
         return getInnerType(schema.def.element, unwrapLazy);
@@ -26,6 +24,9 @@ export function isZodDefault(obj) {
 export function isZodLazy(obj) {
     return isZodType(obj) && (obj.def.type === 'lazy');
 }
+export function isZodNonOptional(obj) {
+    return isZodType(obj) && (obj.def.type === 'nonoptional');
+}
 export function isZodNullable(obj) {
     return isZodType(obj) && (obj.def.type === 'nullable');
 }
@@ -44,9 +45,21 @@ export function isZodObjectLoose(obj) {
 export function isZodOptional(obj) {
     return isZodType(obj) && (obj.def.type === 'optional');
 }
+export function isZodPipe(obj) {
+    return isZodType(obj) && (obj.def.type === 'pipe');
+}
+export function isZodPrefault(obj) {
+    return isZodType(obj) && (obj.def.type === 'prefault');
+}
+export function isZodReadonly(obj) {
+    return isZodType(obj) && (obj.def.type === 'readonly');
+}
 export function isZodRecord(obj) {
     return isZodType(obj) && (obj.def.type === 'record');
 }
+export function isZodTransform(obj) {
+    return isZodType(obj) && (obj.def.type === 'transform');
+}
 export function isZodType(obj) {
     return typeof obj === 'object' && obj !== null && 'def' in obj && 'safeParse' in obj && typeof obj.safeParse === 'function';
 }
@@ -56,3 +69,22 @@ export function isZodUnion(obj) {
 export function isZodUnknown(obj) {
     return isZodType(obj) && (obj.def.type === 'unknown');
 }
+/**
+ * The schema a value-preserving wrapper holds: optional, nullable, default, prefault, catch, nonoptional, readonly,
+ * or a pipe's output side. `undefined` for anything else, including a pipe into a transform, whose output has no schema.
+ */
+export function unwrapWrapper(schema) {
+    if (schema instanceof ZodOptional
+        || schema instanceof ZodNullable
+        || schema instanceof ZodDefault
+        || schema instanceof ZodPrefault
+        || schema instanceof ZodCatch
+        || schema instanceof ZodNonOptional
+        || schema instanceof ZodReadonly) {
+        return schema.def.innerType;
+    }
+    if (schema instanceof ZodPipe && !isZodTransform(schema.def.out)) {
+        return schema.def.out;
+    }
+    return undefined;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zodselect",
-  "version": "1.3.1",
+  "version": "1.4.0",
   "description": "Type-safe selection utility built on top of Zod. Allows for strongly typed field selection, schema merging, and runtime refinement for frontend or backend use.",
   "author": "SecureDataSystems",
   "license": "MIT",