@zod-utils/core 0.8.0 → 1.0.0

package/README.md

@@ -272,6 +272,157 @@ import { getFieldChecks, type ZodUnionCheck } from "@zod-utils/core";
 
 ---
 
+### `extractDiscriminatedSchema(schema, key, value)`
+
+Extract a specific variant from a discriminated union schema based on the discriminator field and value.
+
+```typescript
+import { extractDiscriminatedSchema } from "@zod-utils/core";
+import { z } from "zod";
+
+const userSchema = z.discriminatedUnion('mode', [
+  z.object({
+    mode: z.literal('create'),
+    name: z.string(),
+    age: z.number().optional(),
+  }),
+  z.object({
+    mode: z.literal('edit'),
+    id: z.number(),
+    name: z.string().optional(),
+    bio: z.string().optional(),
+  }),
+]);
+
+// Extract the 'create' variant
+const createSchema = extractDiscriminatedSchema({
+  schema: userSchema,
+  key: 'mode',
+  value: 'create',
+});
+// Returns: z.ZodObject with { mode, name, age }
+
+// Extract the 'edit' variant
+const editSchema = extractDiscriminatedSchema({
+  schema: userSchema,
+  key: 'mode',
+  value: 'edit',
+});
+// Returns: z.ZodObject with { mode, id, name, bio }
+```
+
+**Use with discriminated unions:** This is essential when working with `z.discriminatedUnion()` schemas, as it extracts the correct variant schema based on the discriminator value.
+
+---
+
+### `extractFieldFromSchema(schema, fieldName, discriminator?)`
+
+Extract a single field from a Zod object or discriminated union schema.
+
+```typescript
+import { extractFieldFromSchema } from "@zod-utils/core";
+import { z } from "zod";
+
+// Simple object schema
+const userSchema = z.object({
+  name: z.string(),
+  age: z.number(),
+  email: z.string().email(),
+});
+
+const nameField = extractFieldFromSchema({
+  schema: userSchema,
+  fieldName: 'name',
+});
+// Returns: ZodString
+
+// Discriminated union schema
+const formSchema = z.discriminatedUnion('mode', [
+  z.object({
+    mode: z.literal('create'),
+    name: z.string(),
+    age: z.number().optional(),
+  }),
+  z.object({
+    mode: z.literal('edit'),
+    id: z.number(),
+    name: z.string().optional(),
+  }),
+]);
+
+// Extract field from specific variant
+const idField = extractFieldFromSchema({
+  schema: formSchema,
+  fieldName: 'id',
+  discriminator: {
+    key: 'mode',
+    value: 'edit',
+  },
+});
+// Returns: ZodNumber
+
+// Without discriminator on discriminated union, returns undefined
+const fieldWithoutDiscriminator = extractFieldFromSchema({
+  schema: formSchema,
+  fieldName: 'name',
+});
+// Returns: undefined (need discriminator to know which variant)
+```
+
+**Discriminated union support:** When extracting fields from discriminated unions, you must provide the `discriminator` option with `key` and `value` to specify which variant to use.
+
+---
+
+### `getSchemaDefaults(schema, discriminator?)`
+
+**Updated:** Now supports discriminated union schemas with the `discriminator` option.
+
+```typescript
+import { getSchemaDefaults } from "@zod-utils/core";
+import { z } from "zod";
+
+// Discriminated union with defaults
+const formSchema = z.discriminatedUnion('mode', [
+  z.object({
+    mode: z.literal('create'),
+    name: z.string(),
+    age: z.number().default(18),
+  }),
+  z.object({
+    mode: z.literal('edit'),
+    id: z.number().default(1),
+    name: z.string().optional(),
+    bio: z.string().default('bio goes here'),
+  }),
+]);
+
+// Get defaults for 'create' mode
+const createDefaults = getSchemaDefaults(formSchema, {
+  discriminator: {
+    key: 'mode',
+    value: 'create',
+  },
+});
+// Returns: { age: 18 }
+
+// Get defaults for 'edit' mode
+const editDefaults = getSchemaDefaults(formSchema, {
+  discriminator: {
+    key: 'mode',
+    value: 'edit',
+  },
+});
+// Returns: { id: 1, bio: 'bio goes here' }
+
+// Without discriminator, returns empty object
+const noDefaults = getSchemaDefaults(formSchema);
+// Returns: {}
+```
+
+**Discriminator types:** The discriminator `value` can be a string, number, or boolean literal that matches the discriminator field type.
+
+---
+
 ## Type Utilities
 
 ### `Simplify<T>`

package/dist/index.d.mts

@@ -1,5 +1,6 @@
 import * as z from 'zod';
-import { $ZodCheckLessThanDef, $ZodCheckGreaterThanDef, $ZodCheckMultipleOfDef, $ZodCheckNumberFormatDef, $ZodCheckBigIntFormatDef, $ZodCheckMaxSizeDef, $ZodCheckMinSizeDef, $ZodCheckSizeEqualsDef, $ZodCheckMaxLengthDef, $ZodCheckMinLengthDef, $ZodCheckLengthEqualsDef, $ZodCheckStringFormatDef, $ZodCheckRegexDef, $ZodCheckLowerCaseDef, $ZodCheckUpperCaseDef, $ZodCheckIncludesDef, $ZodCheckStartsWithDef, $ZodCheckEndsWithDef, $ZodCheckPropertyDef, $ZodCheckMimeTypeDef, $ZodCheckOverwriteDef } from 'zod/v4/core';
+import { util, z as z$1 } from 'zod';
+import { $InferUnionOutput, $ZodCheckLessThanDef, $ZodCheckGreaterThanDef, $ZodCheckMultipleOfDef, $ZodCheckNumberFormatDef, $ZodCheckBigIntFormatDef, $ZodCheckMaxSizeDef, $ZodCheckMinSizeDef, $ZodCheckSizeEqualsDef, $ZodCheckMaxLengthDef, $ZodCheckMinLengthDef, $ZodCheckLengthEqualsDef, $ZodCheckStringFormatDef, $ZodCheckRegexDef, $ZodCheckLowerCaseDef, $ZodCheckUpperCaseDef, $ZodCheckIncludesDef, $ZodCheckStartsWithDef, $ZodCheckEndsWithDef, $ZodCheckPropertyDef, $ZodCheckMimeTypeDef, $ZodCheckOverwriteDef } from 'zod/v4/core';
 
 /**
  * Simplifies complex TypeScript types for better IDE hover tooltips and error messages.
@@ -51,8 +52,9 @@ type Simplify<T> = {
  * This function traverses through wrapper types (like `ZodOptional`, `ZodNullable`, `ZodUnion`) to find
  * the underlying `ZodDefault` and returns its default value. If no default is found, returns `undefined`.
  *
- * **Union handling:** For union types, extracts the default from the first option. If the first option
- * has no default, returns `undefined` (defaults in other union options are not checked).
+ * **Union handling:** For union types, strips nullish types (null/undefined) first. If only one type
+ * remains after stripping, extracts the default from that type. If multiple non-nullish types remain,
+ * returns `undefined` (does not extract from any option).
  *
  * @template T - The Zod type to extract default from
  * @param field - The Zod field to extract default from
@@ -75,19 +77,19 @@ type Simplify<T> = {
  * ```
  *
  * @example
- * Union with default in first option
+ * Union with only nullish types stripped to single type
  * ```typescript
- * const field = z.union([z.string().default('hello'), z.number()]);
+ * const field = z.union([z.string().default('hello'), z.null()]);
  * const defaultValue = extractDefault(field);
- * // Result: 'hello' (extracts from first union option)
+ * // Result: 'hello' (null stripped, leaving only string)
  * ```
  *
  * @example
- * Union with default in second option
+ * Union with multiple non-nullish types
  * ```typescript
- * const field = z.union([z.string(), z.number().default(42)]);
+ * const field = z.union([z.string().default('hello'), z.number()]);
  * const defaultValue = extractDefault(field);
- * // Result: undefined (only checks first option)
+ * // Result: undefined (multiple non-nullish types - no default extracted)
  * ```
  *
  * @example
@@ -99,6 +101,7 @@ type Simplify<T> = {
  * ```
  *
  * @see {@link getSchemaDefaults} for extracting defaults from entire schemas
+ * @see {@link tryStripNullishOnly} for union nullish stripping logic
  * @since 0.1.0
  */
 declare function extractDefault<T extends z.ZodTypeAny>(field: T): z.infer<T> | undefined;
@@ -114,8 +117,8 @@ declare function extractDefault<T extends z.ZodTypeAny>(field: T): z.infer<T> |
  * **Component handling:** For form inputs without explicit defaults (like `z.string()` or `z.number()`),
  * use the `?? ''` pattern in your components: `<Input value={field.value ?? ''} />`
  *
- * @template T - The Zod object schema type
- * @param schema - The Zod object schema to extract defaults from
+ * @template TSchema - The Zod object schema type
+ * @param targetSchema - The Zod object schema to extract defaults from
  * @returns A partial object containing only fields with explicit default values
  *
  * @example
@@ -174,7 +177,21 @@ declare function extractDefault<T extends z.ZodTypeAny>(field: T): z.infer<T> |
  * @see {@link extractDefault} for extracting defaults from individual fields
  * @since 0.1.0
  */
-declare function getSchemaDefaults<T extends z.ZodObject>(schema: T): Simplify<Partial<z.infer<T>>>;
+declare function getSchemaDefaults<TSchema extends z.ZodObject | z.ZodDiscriminatedUnion, TDiscriminatorKey extends keyof z.infer<TSchema> & string, TDiscriminatorValue extends z.infer<TSchema>[TDiscriminatorKey] & util.Literal>(schema: TSchema, options?: {
+    discriminator?: {
+        key: TDiscriminatorKey;
+        value: TDiscriminatorValue;
+    };
+}): Simplify<Partial<z.infer<TSchema>>>;
+
+declare function extractFieldFromSchema<TSchema extends z$1.ZodObject | z$1.ZodDiscriminatedUnion, TName extends keyof Extract<Required<z$1.infer<TSchema>>, Record<TDiscriminatorKey, TDiscriminatorValue>>, TDiscriminatorKey extends keyof z$1.infer<TSchema> & string, TDiscriminatorValue extends z$1.infer<TSchema>[TDiscriminatorKey] & util.Literal>({ schema, fieldName, discriminator, }: {
+    schema: TSchema;
+    fieldName: TName;
+    discriminator?: {
+        key: TDiscriminatorKey;
+        value: TDiscriminatorValue;
+    };
+}): z$1.ZodType<unknown, unknown, z$1.core.$ZodTypeInternals<unknown, unknown>> | undefined;
 
 /**
  * Type representing a Zod type that has an unwrap method
@@ -204,83 +221,53 @@ type Unwrappable = {
  */
 declare function canUnwrap(field: z.ZodTypeAny): field is z.ZodTypeAny & Unwrappable;
 /**
- * Unwraps a ZodUnion type and returns the first field and all union options.
+ * Attempts to strip nullish types from a union and return the single remaining type.
  *
- * This function extracts the individual type options from a union type.
- * By default, it filters out `ZodNull` and `ZodUndefined` types, returning only
- * the meaningful type options. You can disable this filtering to get all options.
+ * This function filters out `ZodNull` and `ZodUndefined` from union types. If exactly
+ * one type remains after filtering, it returns that unwrapped type. Otherwise, it returns
+ * `false` to indicate the union couldn't be simplified to a single type.
  *
- * @template T - The Zod type to unwrap
- * @param field - The Zod field (union or single type)
- * @param options - Configuration options
- * @param options.filterNullish - Whether to filter out null and undefined types (default: true)
- * @returns Object with `field` (first option) and `union` (all options array)
+ * @param field - The Zod field to process
+ * @returns The unwrapped type if only one remains, otherwise `false`
  *
  * @example
- * Basic union unwrapping
+ * Union with only nullish types filtered - returns single type
  * ```typescript
- * const field = z.union([z.string(), z.number()]);
- * const result = unwrapUnion(field);
- * // Result: { field: z.string(), union: [z.string(), z.number()] }
+ * const field = z.union([z.string(), z.null(), z.undefined()]);
+ * const result = tryStripNullishOnly(field);
+ * // Result: z.string() (unwrapped)
  * ```
  *
  * @example
- * Union with null (filtered by default)
+ * Union with multiple non-nullish types - returns false
  * ```typescript
- * const field = z.union([z.string(), z.null()]);
- * const result = unwrapUnion(field);
- * // Result: { field: z.string(), union: [z.string()] }
- * ```
- *
- * @example
- * Union with null (keep all options)
- * ```typescript
- * const field = z.union([z.string(), z.null()]);
- * const result = unwrapUnion(field, { filterNullish: false });
- * // Result: { field: z.string(), union: [z.string(), z.null()] }
+ * const field = z.union([z.string(), z.number()]);
+ * const result = tryStripNullishOnly(field);
+ * // Result: false (cannot simplify to single type)
  * ```
  *
  * @example
- * Non-union type (returns single field)
+ * Non-union type - returns false
  * ```typescript
  * const field = z.string();
- * const result = unwrapUnion(field);
- * // Result: { field: z.string(), union: [z.string()] }
- * ```
- *
- * @example
- * Nullable as union
- * ```typescript
- * const field = z.string().nullable(); // This is z.union([z.string(), z.null()])
- * const result = unwrapUnion(field);
- * // Result: { field: z.string(), union: [z.string()] } (null filtered out)
- * ```
- *
- * @example
- * Using the first field for type checking
- * ```typescript
- * const field = z.union([z.string(), z.number()]);
- * const { field: firstField, union } = unwrapUnion(field);
- * if (firstField instanceof z.ZodString) {
- *   console.log('First type is string');
- * }
+ * const result = tryStripNullishOnly(field);
+ * // Result: false (not a union)
  * ```
  *
  * @see {@link getPrimitiveType} for unwrapping wrapper types
- * @since 0.1.0
+ * @since 0.5.0
  */
-declare function unwrapUnion<T extends z.ZodTypeAny>(field: T, options?: {
-    filterNullish?: boolean;
-}): {
-    field: z.ZodTypeAny;
-    union: z.ZodTypeAny[];
-};
+declare function tryStripNullishOnly(field: z.ZodTypeAny): z.ZodType | false;
 /**
  * Gets the underlying primitive type of a Zod field by recursively unwrapping wrapper types.
  *
  * This function removes wrapper layers (optional, nullable, default) to reveal the base type.
  * **Important:** It stops at array types without unwrapping them, treating arrays as primitives.
  *
+ * **Union handling:** For union types, strips nullish types (null/undefined) first. If only one
+ * type remains after stripping, unwraps to that type. If multiple non-nullish types remain,
+ * returns the union as-is (does not unwrap).
+ *
  * @template T - The Zod type to unwrap
  * @param field - The Zod field to unwrap
  * @returns The unwrapped primitive Zod type
@@ -309,7 +296,24 @@ declare function unwrapUnion<T extends z.ZodTypeAny>(field: T, options?: {
  * // Result: z.number()
  * ```
  *
+ * @example
+ * Union with only nullish types stripped to single type
+ * ```typescript
+ * const field = z.union([z.string(), z.null()]);
+ * const primitive = getPrimitiveType(field);
+ * // Result: z.string() (null stripped, leaving only string)
+ * ```
+ *
+ * @example
+ * Union with multiple non-nullish types
+ * ```typescript
+ * const field = z.union([z.string(), z.number()]);
+ * const primitive = getPrimitiveType(field);
+ * // Result: z.union([z.string(), z.number()]) (returned as-is)
+ * ```
+ *
  * @see {@link canUnwrap} for checking if a field can be unwrapped
+ * @see {@link tryStripNullishOnly} for union nullish stripping logic
  * @since 0.1.0
  */
 declare const getPrimitiveType: <T extends z.ZodType>(field: T) => z.ZodTypeAny;
@@ -521,5 +525,167 @@ type ZodUnionCheck = $ZodCheckLessThanDef | $ZodCheckGreaterThanDef | $ZodCheckM
  * @since 0.4.0
  */
 declare function getFieldChecks<T extends z.ZodTypeAny>(field: T): Array<ZodUnionCheck>;
+/**
+ * Recursively extracts the exact schema type from a discriminated union based on the discriminator value.
+ *
+ * This advanced TypeScript utility type walks through a union's options tuple at compile-time,
+ * checking each schema against the discriminator field and value, and returns the exact matching
+ * schema type (not a union of all options).
+ *
+ * **How it works:**
+ * 1. Extracts the options tuple from the union using `infer Options`
+ * 2. Destructure into head (`First`) and tail (`Rest`) using tuple pattern matching
+ * 3. Checks if `First` is a ZodObject with the matching discriminator field and value
+ * 4. If match found, returns `First` (the exact schema type)
+ * 5. If no match, recursively processes `Rest` until a match is found or list is exhausted
+ *
+ * **Type narrowing magic:**
+ * - Input: `z.discriminatedUnion('type', [SchemaA, SchemaB, SchemaC])`
+ * - Discriminator value: `'a'` (matches SchemaA)
+ * - Output: `SchemaA` (exact type, not `SchemaA | SchemaB | SchemaC`)
+ *
+ * @template TSchema - The ZodUnion or ZodDiscriminatedUnion type
+ * @template TDiscriminatorKey - The discriminator field name (e.g., "type", "mode")
+ * @template TDiscriminatorValue - The specific discriminator value (e.g., "create", "edit")
+ * @returns The exact matching schema type, or `never` if no match found
+ *
+ * @example
+ * ```typescript
+ * const schema = z.discriminatedUnion('mode', [
+ *   z.object({ mode: z.literal('create'), name: z.string() }),
+ *   z.object({ mode: z.literal('edit'), id: z.number() }),
+ * ]);
+ *
+ * // Exact type: z.object({ mode: z.literal('create'), name: z.string() })
+ * type CreateSchema = ExtractZodUnionMember<typeof schema, 'mode', 'create'>;
+ * ```
+ */
+type ExtractZodUnionMember<TSchema extends z.ZodUnion | z.ZodDiscriminatedUnion, TDiscriminatorKey extends keyof z.infer<TSchema> & string, TDiscriminatorValue extends z.infer<TSchema>[TDiscriminatorKey] & util.Literal> = TSchema extends z.ZodUnion<infer Options> ? Options extends readonly [
+    infer First extends z.ZodTypeAny,
+    ...infer Rest extends z.ZodTypeAny[]
+] ? First extends z.ZodObject<infer Shape> ? TDiscriminatorKey extends keyof Shape ? Shape[TDiscriminatorKey] extends z.ZodLiteral<TDiscriminatorValue> ? First : Rest extends [] ? never : TDiscriminatorValue extends $InferUnionOutput<Rest[number]>[TDiscriminatorKey] ? ExtractZodUnionMember<z.ZodUnion<Rest>, TDiscriminatorKey, TDiscriminatorValue> : never : Rest extends [] ? never : TDiscriminatorValue extends $InferUnionOutput<Rest[number]>[TDiscriminatorKey] ? ExtractZodUnionMember<z.ZodUnion<Rest>, TDiscriminatorKey, TDiscriminatorValue> : never : never : never : never;
+/**
+ * Extracts a specific schema option from a discriminated union based on the discriminator field value.
+ *
+ * This function finds and returns the **exact matching schema** from a `ZodDiscriminatedUnion` by
+ * comparing the discriminator field value. It's used internally by {@link getSchemaDefaults} to
+ * extract defaults from the correct schema variant in a discriminated union.
+ *
+ * **Key feature:** Returns the **exact schema type**, not a union of all options, thanks to the
+ * {@link ExtractZodUnionMember} recursive type utility. This enables precise type narrowing at
+ * compile-time based on the discriminator value.
+ *
+ * **How it works:**
+ * 1. Iterates through all options in the discriminated union at runtime
+ * 2. For each option, validates it's a ZodObject and checks if the discriminator field matches
+ * 3. Returns the first matching schema with its exact type narrowed at compile-time
+ * 4. Returns `undefined` if no match found or if option is not a ZodObject
+ *
+ * @template TSchema - The ZodUnion or ZodDiscriminatedUnion schema type
+ * @template TDiscriminatorKey - The discriminator field name (string key of the inferred union type)
+ * @template TDiscriminatorValue - The specific discriminator value to match (literal type)
+ * @param params - Parameters object
+ * @param params.schema - The discriminated union schema to search
+ * @param params.discriminatorKey - The discriminator field name (e.g., "mode", "type")
+ * @param params.discriminatorValue - The discriminator value to match (e.g., "create", "edit")
+ * @returns The exact matching schema option (with precise type), or `undefined` if not found
+ *
+ * @example
+ * Basic discriminated union - create/edit mode
+ * ```typescript
+ * const userSchema = z.discriminatedUnion('mode', [
+ *   z.object({
+ *     mode: z.literal('create'),
+ *     name: z.string(),
+ *     age: z.number().optional(),
+ *   }),
+ *   z.object({
+ *     mode: z.literal('edit'),
+ *     id: z.number(),
+ *     name: z.string().optional(),
+ *   }),
+ * ]);
+ *
+ * // Extract the "create" schema
+ * const createSchema = extractDiscriminatedSchema({
+ *   schema: userSchema,
+ *   discriminatorKey: 'mode',
+ *   discriminatorValue: 'create',
+ * });
+ * // Result: z.object({ mode: z.literal('create'), name: z.string(), age: z.number().optional() })
+ *
+ * // Extract the "edit" schema
+ * const editSchema = extractDiscriminatedSchema({
+ *   schema: userSchema,
+ *   discriminatorKey: 'mode',
+ *   discriminatorValue: 'edit',
+ * });
+ * // Result: z.object({ mode: z.literal('edit'), id: z.number(), name: z.string().optional() })
+ * ```
+ *
+ * @example
+ * Type-based discrimination
+ * ```typescript
+ * const eventSchema = z.discriminatedUnion('type', [
+ *   z.object({ type: z.literal('click'), x: z.number(), y: z.number() }),
+ *   z.object({ type: z.literal('keypress'), key: z.string() }),
+ * ]);
+ *
+ * const clickSchema = extractDiscriminatedSchema({
+ *   schema: eventSchema,
+ *   discriminatorKey: 'type',
+ *   discriminatorValue: 'click',
+ * });
+ * // Result: z.object({ type: z.literal('click'), x: z.number(), y: z.number() })
+ * ```
+ *
+ * @example
+ * Invalid discriminator value
+ * ```typescript
+ * const schema = z.discriminatedUnion('mode', [
+ *   z.object({ mode: z.literal('create'), name: z.string() }),
+ * ]);
+ *
+ * const result = extractDiscriminatedSchema({
+ *   schema,
+ *   discriminatorKey: 'mode',
+ *   discriminatorValue: 'invalid', // doesn't match any option
+ * });
+ * // Result: undefined
+ * ```
+ *
+ * @example
+ * Type narrowing demonstration
+ * ```typescript
+ * const schema = z.discriminatedUnion('mode', [
+ *   z.object({ mode: z.literal('create'), name: z.string(), age: z.number() }),
+ *   z.object({ mode: z.literal('edit'), id: z.number(), bio: z.string() }),
+ * ]);
+ *
+ * const createSchema = extractDiscriminatedSchema({
+ *   schema,
+ *   discriminatorKey: 'mode',
+ *   discriminatorValue: 'create',
+ * });
+ *
+ * // Type is EXACTLY: z.object({ mode: z.literal('create'), name: z.string(), age: z.number() })
+ * // NOT: z.object({ mode: ..., ... }) | z.object({ mode: ..., ... }) | undefined
+ *
+ * if (createSchema) {
+ *   createSchema.shape.age;  // ✅ TypeScript knows 'age' exists
+ *   createSchema.shape.name; // ✅ TypeScript knows 'name' exists
+ *   // createSchema.shape.id;   // ❌ TypeScript error: 'id' doesn't exist on 'create' schema
+ * }
+ * ```
+ *
+ * @see {@link getSchemaDefaults} for usage with discriminated unions
+ * @see {@link ExtractZodUnionMember} for the type-level extraction logic
+ * @since 0.6.0
+ */
+declare const extractDiscriminatedSchema: <TSchema extends z.ZodUnion | z.ZodDiscriminatedUnion, TDiscriminatorKey extends keyof z.infer<TSchema> & string, TDiscriminatorValue extends z.infer<TSchema>[TDiscriminatorKey] & util.Literal>({ schema, key, value, }: {
+    schema: TSchema;
+    key: TDiscriminatorKey;
+    value: TDiscriminatorValue;
+}) => ExtractZodUnionMember<TSchema, TDiscriminatorKey, TDiscriminatorValue> | undefined;
 
-export { type Simplify, type ZodUnionCheck, canUnwrap, extractDefault, getFieldChecks, getPrimitiveType, getSchemaDefaults, removeDefault, requiresValidInput, unwrapUnion };
+export { type Simplify, type ZodUnionCheck, canUnwrap, extractDefault, extractDiscriminatedSchema, extractFieldFromSchema, getFieldChecks, getPrimitiveType, getSchemaDefaults, removeDefault, requiresValidInput, tryStripNullishOnly };