@zod-utils/core 0.1.0

package/README.md

@@ -0,0 +1,196 @@
+# @zod-utils/core
+
+[![npm version](https://img.shields.io/npm/v/@zod-utils/core.svg)](https://www.npmjs.com/package/@zod-utils/core)
+[![npm downloads](https://img.shields.io/npm/dm/@zod-utils/core.svg)](https://www.npmjs.com/package/@zod-utils/core)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.0-blue.svg)](https://www.typescriptlang.org/)
+[![CI](https://github.com/thu-san/zod-utils/workflows/CI/badge.svg)](https://github.com/thu-san/zod-utils/actions)
+
+Pure TypeScript utilities for Zod schema manipulation and default extraction. No React dependencies.
+
+## Installation
+
+```bash
+npm install @zod-utils/core zod
+```
+
+## Features
+
+- 🎯 **Extract defaults** - Get default values from Zod schemas
+- ✅ **Check required fields** - Determine if fields are required
+- 🔧 **Schema utilities** - Unwrap and manipulate schema types
+- 📦 **Zero dependencies** - Only requires Zod as a peer dependency
+- 🌐 **Universal** - Works in Node.js, browsers, and any TypeScript project
+
+## API Reference
+
+### `getSchemaDefaults(schema)`
+
+Extract all default values from a Zod object schema. Recursively handles nested objects.
+
+```typescript
+import { getSchemaDefaults } from '@zod-utils/core';
+import { z } from 'zod';
+
+const schema = z.object({
+  name: z.string().default('John Doe'),
+  age: z.number().default(25),
+  email: z.string().email(), // no default - skipped
+  settings: z.object({
+    theme: z.string().default('light'),
+    notifications: z.boolean().default(true),
+  }),
+  tags: z.array(z.string()).default([]),
+});
+
+const defaults = getSchemaDefaults(schema);
+// {
+//   name: 'John Doe',
+//   age: 25,
+//   settings: { theme: 'light', notifications: true },
+//   tags: []
+// }
+```
+
+**Handles:**
+- Nested objects at any depth
+- Optional fields with defaults: `.optional().default(value)`
+- Arrays with defaults: `.array().default([])`
+- Skips fields without defaults
+
+---
+
+### `checkIfFieldIsRequired(field)`
+
+Check if a Zod field is required (not optional/nullable and doesn't accept empty values).
+
+```typescript
+import { checkIfFieldIsRequired } from '@zod-utils/core';
+import { z } from 'zod';
+
+const requiredField = z.string();
+const optionalField = z.string().optional();
+const emptyStringAllowed = z.string().min(0);
+
+checkIfFieldIsRequired(requiredField);     // true
+checkIfFieldIsRequired(optionalField);     // false
+checkIfFieldIsRequired(emptyStringAllowed); // false
+```
+
+---
+
+### `getPrimitiveType(field, options?)`
+
+Get the primitive type of a Zod field by unwrapping optional/nullable wrappers.
+
+```typescript
+import { getPrimitiveType } from '@zod-utils/core';
+import { z } from 'zod';
+
+const field = z.string().optional().nullable();
+const primitive = getPrimitiveType(field);
+// Returns the underlying string schema
+
+// Options
+getPrimitiveType(z.array(z.string()), { unwrapArrays: false }); // Stops at array
+getPrimitiveType(z.array(z.string()), { unwrapArrays: true });  // Continues unwrapping
+```
+
+---
+
+### `removeDefault(field)`
+
+Remove default values from a Zod field.
+
+```typescript
+import { removeDefault } from '@zod-utils/core';
+import { z } from 'zod';
+
+const withDefault = z.string().default('hello');
+const withoutDefault = removeDefault(withDefault);
+
+withDefault.parse(undefined);     // 'hello'
+withoutDefault.parse(undefined);  // throws error
+```
+
+---
+
+### `extractDefault(field)`
+
+Extract the default value from a Zod field (recursively unwraps optional/nullable).
+
+```typescript
+import { extractDefault } from '@zod-utils/core';
+import { z } from 'zod';
+
+const field = z.string().optional().default('hello');
+extractDefault(field); // 'hello'
+
+const noDefault = z.string();
+extractDefault(noDefault); // undefined
+```
+
+---
+
+### `getUnwrappedType(field)`
+
+Get the unwrapped type without going through defaults. Useful for detecting nested objects/arrays.
+
+```typescript
+import { getUnwrappedType } from '@zod-utils/core';
+import { z } from 'zod';
+
+const field = z.object({ name: z.string() }).optional().default({});
+const unwrapped = getUnwrappedType(field);
+// Returns the ZodObject (preserves the default wrapper)
+```
+
+---
+
+## Type Utilities
+
+### `MakeOptionalAndNullable<T>`
+
+Make all properties optional and nullable. Useful for form input types.
+
+```typescript
+import type { MakeOptionalAndNullable } from '@zod-utils/core';
+
+type User = {
+  name: string;
+  age: number;
+};
+
+type FormInput = MakeOptionalAndNullable<User>;
+// { name?: string | null; age?: number | null; }
+```
+
+### `Simplify<T>`
+
+Simplify complex types for better IDE hints.
+
+```typescript
+import type { Simplify } from '@zod-utils/core';
+
+type Complex = { a: string } & { b: number };
+type Simple = Simplify<Complex>;
+// { a: string; b: number }
+```
+
+### `PickArrayObject<T>`
+
+Extract the element type from an array.
+
+```typescript
+import type { PickArrayObject } from '@zod-utils/core';
+
+type Users = Array<{ name: string }>;
+type User = PickArrayObject<Users>;
+// { name: string }
+```
+
+---
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,79 @@
+import * as z from 'zod';
+
+/**
+ * Get the primitive type of a Zod field by unwrapping optional/nullable wrappers
+ * @param field - The Zod field to unwrap
+ * @param options - Options for unwrapping
+ * @param options.unwrapArrays - If true, continues unwrapping arrays. If false (default), stops at arrays
+ * @returns The unwrapped primitive type
+ */
+declare const getPrimitiveType: <T extends z.ZodTypeAny>(field: T, options?: {
+    unwrapArrays?: boolean;
+}) => z.ZodTypeAny;
+/**
+ * Remove default values from a Zod field
+ * @param field - The Zod field to remove defaults from
+ * @returns The field without defaults
+ */
+declare function removeDefault(field: z.ZodType): z.ZodType;
+/**
+ * Check if a Zod field is required (not optional/nullable and doesn't accept empty values)
+ * @param field - The Zod field to check
+ * @returns True if the field is required
+ */
+declare const checkIfFieldIsRequired: <T extends z.ZodTypeAny>(field: T) => boolean;
+
+/**
+ * Extract the default value from a Zod field (recursively unwraps optional/nullable)
+ * @param field - The Zod field to extract default from
+ * @returns The default value if present, undefined otherwise
+ */
+declare function extractDefault(field: z.ZodTypeAny): any;
+/**
+ * Get the unwrapped type without going through defaults
+ * Useful for detecting nested objects/arrays while preserving defaults
+ * @param field - The Zod field to unwrap
+ * @returns The unwrapped type
+ */
+declare function getUnwrappedType(field: z.ZodTypeAny): z.ZodTypeAny;
+/**
+ * Extract all default values from a Zod object schema
+ * Recursively handles nested objects and only returns fields with defaults
+ * @param schema - The Zod object schema to extract defaults from
+ * @returns Partial object with only fields that have defaults
+ *
+ * @example
+ * ```ts
+ * const schema = z.object({
+ *   name: z.string().default('John'),
+ *   age: z.number(), // no default - skipped
+ *   settings: z.object({
+ *     theme: z.string().default('light')
+ *   })
+ * });
+ *
+ * getSchemaDefaults(schema);
+ * // Returns: { name: 'John', settings: { theme: 'light' } }
+ * ```
+ */
+declare function getSchemaDefaults<T extends z.ZodObject<any>>(schema: T): Partial<z.infer<T>>;
+
+/**
+ * Extract the element type from an array or undefined
+ */
+type PickArrayObject<TArray extends unknown[] | undefined> = NonNullable<TArray>[number];
+/**
+ * Simplify complex types for better IDE hints
+ */
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+/**
+ * Make all properties optional and nullable
+ * Useful for form input types where fields can be empty
+ */
+type MakeOptionalAndNullable<T> = {
+    [K in keyof T]?: T[K] | null;
+};
+
+export { type MakeOptionalAndNullable, type PickArrayObject, type Simplify, checkIfFieldIsRequired, extractDefault, getPrimitiveType, getSchemaDefaults, getUnwrappedType, removeDefault };

package/dist/index.d.ts

@@ -0,0 +1,79 @@
+import * as z from 'zod';
+
+/**
+ * Get the primitive type of a Zod field by unwrapping optional/nullable wrappers
+ * @param field - The Zod field to unwrap
+ * @param options - Options for unwrapping
+ * @param options.unwrapArrays - If true, continues unwrapping arrays. If false (default), stops at arrays
+ * @returns The unwrapped primitive type
+ */
+declare const getPrimitiveType: <T extends z.ZodTypeAny>(field: T, options?: {
+    unwrapArrays?: boolean;
+}) => z.ZodTypeAny;
+/**
+ * Remove default values from a Zod field
+ * @param field - The Zod field to remove defaults from
+ * @returns The field without defaults
+ */
+declare function removeDefault(field: z.ZodType): z.ZodType;
+/**
+ * Check if a Zod field is required (not optional/nullable and doesn't accept empty values)
+ * @param field - The Zod field to check
+ * @returns True if the field is required
+ */
+declare const checkIfFieldIsRequired: <T extends z.ZodTypeAny>(field: T) => boolean;
+
+/**
+ * Extract the default value from a Zod field (recursively unwraps optional/nullable)
+ * @param field - The Zod field to extract default from
+ * @returns The default value if present, undefined otherwise
+ */
+declare function extractDefault(field: z.ZodTypeAny): any;
+/**
+ * Get the unwrapped type without going through defaults
+ * Useful for detecting nested objects/arrays while preserving defaults
+ * @param field - The Zod field to unwrap
+ * @returns The unwrapped type
+ */
+declare function getUnwrappedType(field: z.ZodTypeAny): z.ZodTypeAny;
+/**
+ * Extract all default values from a Zod object schema
+ * Recursively handles nested objects and only returns fields with defaults
+ * @param schema - The Zod object schema to extract defaults from
+ * @returns Partial object with only fields that have defaults
+ *
+ * @example
+ * ```ts
+ * const schema = z.object({
+ *   name: z.string().default('John'),
+ *   age: z.number(), // no default - skipped
+ *   settings: z.object({
+ *     theme: z.string().default('light')
+ *   })
+ * });
+ *
+ * getSchemaDefaults(schema);
+ * // Returns: { name: 'John', settings: { theme: 'light' } }
+ * ```
+ */
+declare function getSchemaDefaults<T extends z.ZodObject<any>>(schema: T): Partial<z.infer<T>>;
+
+/**
+ * Extract the element type from an array or undefined
+ */
+type PickArrayObject<TArray extends unknown[] | undefined> = NonNullable<TArray>[number];
+/**
+ * Simplify complex types for better IDE hints
+ */
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+/**
+ * Make all properties optional and nullable
+ * Useful for form input types where fields can be empty
+ */
+type MakeOptionalAndNullable<T> = {
+    [K in keyof T]?: T[K] | null;
+};
+
+export { type MakeOptionalAndNullable, type PickArrayObject, type Simplify, checkIfFieldIsRequired, extractDefault, getPrimitiveType, getSchemaDefaults, getUnwrappedType, removeDefault };

package/dist/index.js

@@ -0,0 +1,106 @@
+'use strict';
+
+var z = require('zod');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var z__namespace = /*#__PURE__*/_interopNamespace(z);
+
+// src/schema.ts
+var getPrimitiveType = (field, options) => {
+  var _a;
+  const unwrapArrays = (_a = options == null ? void 0 : options.unwrapArrays) != null ? _a : false;
+  if (!unwrapArrays && field.type === "array") {
+    return field;
+  }
+  if ("unwrap" in field && typeof field.unwrap === "function") {
+    return getPrimitiveType(field.unwrap(), options);
+  }
+  return field;
+};
+function removeDefault(field) {
+  if (field instanceof z__namespace.ZodDefault) {
+    return field.unwrap();
+  }
+  if ("innerType" in field.def) {
+    const inner = removeDefault(field.def.innerType);
+    if (field instanceof z__namespace.ZodOptional) {
+      return inner.optional();
+    }
+    if (field instanceof z__namespace.ZodNullable) {
+      return inner.nullable();
+    }
+  }
+  return field;
+}
+var checkIfFieldIsRequired = (field) => {
+  const undefinedResult = field.safeParse(void 0).success;
+  const nullResult = field.safeParse(null).success;
+  const primitiveType = getPrimitiveType(field);
+  const emptyStringResult = primitiveType.type === "string" && field.safeParse("").success;
+  const emptyArrayResult = primitiveType.type === "array" && field.safeParse([]).success;
+  return !undefinedResult && !nullResult && !emptyStringResult && !emptyArrayResult;
+};
+function extractDefault(field) {
+  if (field instanceof z__namespace.ZodDefault) {
+    const defaultValue = field._def.defaultValue;
+    return typeof defaultValue === "function" ? defaultValue() : defaultValue;
+  }
+  if ("unwrap" in field && typeof field.unwrap === "function") {
+    return extractDefault(field.unwrap());
+  }
+  return void 0;
+}
+function getUnwrappedType(field) {
+  if (field instanceof z__namespace.ZodDefault) {
+    return field;
+  }
+  if ("unwrap" in field && typeof field.unwrap === "function") {
+    return getUnwrappedType(field.unwrap());
+  }
+  return field;
+}
+function getSchemaDefaults(schema) {
+  const defaults = {};
+  for (const key in schema.shape) {
+    const field = schema.shape[key];
+    const defaultValue = extractDefault(field);
+    if (defaultValue !== void 0) {
+      defaults[key] = defaultValue;
+      continue;
+    }
+    const unwrapped = getUnwrappedType(field);
+    if (unwrapped instanceof z__namespace.ZodObject) {
+      const nestedDefaults = getSchemaDefaults(unwrapped);
+      if (Object.keys(nestedDefaults).length > 0) {
+        defaults[key] = nestedDefaults;
+      }
+    }
+  }
+  return defaults;
+}
+
+exports.checkIfFieldIsRequired = checkIfFieldIsRequired;
+exports.extractDefault = extractDefault;
+exports.getPrimitiveType = getPrimitiveType;
+exports.getSchemaDefaults = getSchemaDefaults;
+exports.getUnwrappedType = getUnwrappedType;
+exports.removeDefault = removeDefault;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/schema.ts","../src/defaults.ts"],"names":["z","z2"],"mappings":"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","file":"index.js","sourcesContent":["import * as z from 'zod';\n\n/**\n * Get the primitive type of a Zod field by unwrapping optional/nullable wrappers\n * @param field - The Zod field to unwrap\n * @param options - Options for unwrapping\n * @param options.unwrapArrays - If true, continues unwrapping arrays. If false (default), stops at arrays\n * @returns The unwrapped primitive type\n */\nexport const getPrimitiveType = <T extends z.ZodTypeAny>(\n  field: T,\n  options?: {\n    unwrapArrays?: boolean;\n  },\n): z.ZodTypeAny => {\n  const unwrapArrays = options?.unwrapArrays ?? false;\n\n  if (!unwrapArrays && field.type === 'array') {\n    return field;\n  }\n\n  if ('unwrap' in field && typeof field.unwrap === 'function') {\n    return getPrimitiveType(field.unwrap(), options);\n  }\n\n  return field;\n};\n\n/**\n * Remove default values from a Zod field\n * @param field - The Zod field to remove defaults from\n * @returns The field without defaults\n */\nexport function removeDefault(field: z.ZodType): z.ZodType {\n  if (field instanceof z.ZodDefault) {\n    return field.unwrap() as z.ZodType;\n  }\n\n  if ('innerType' in field.def) {\n    const inner = removeDefault(field.def.innerType as z.ZodType);\n    // Reconstruct the wrapper with the modified inner type\n    if (field instanceof z.ZodOptional) {\n      return inner.optional();\n    }\n    if (field instanceof z.ZodNullable) {\n      return inner.nullable();\n    }\n  }\n\n  return field;\n}\n\n/**\n * Check if a Zod field is required (not optional/nullable and doesn't accept empty values)\n * @param field - The Zod field to check\n * @returns True if the field is required\n */\nexport const checkIfFieldIsRequired = <T extends z.ZodTypeAny>(field: T) => {\n  // Check with defaults intact - if a field has a default, it's not required\n  const undefinedResult = field.safeParse(undefined).success;\n  const nullResult = field.safeParse(null).success;\n\n  const primitiveType = getPrimitiveType(field);\n\n  const emptyStringResult =\n    primitiveType.type === 'string' && field.safeParse('').success;\n\n  const emptyArrayResult =\n    primitiveType.type === 'array' && field.safeParse([]).success;\n\n  return (\n    !undefinedResult && !nullResult && !emptyStringResult && !emptyArrayResult\n  );\n};\n","import * as z from 'zod';\n\n/**\n * Extract the default value from a Zod field (recursively unwraps optional/nullable)\n * @param field - The Zod field to extract default from\n * @returns The default value if present, undefined otherwise\n */\nexport function extractDefault(field: z.ZodTypeAny): any {\n  if (field instanceof z.ZodDefault) {\n    const defaultValue = field._def.defaultValue;\n    return typeof defaultValue === 'function' ? defaultValue() : defaultValue;\n  }\n\n  if ('unwrap' in field && typeof field.unwrap === 'function') {\n    return extractDefault(field.unwrap());\n  }\n\n  return undefined;\n}\n\n/**\n * Get the unwrapped type without going through defaults\n * Useful for detecting nested objects/arrays while preserving defaults\n * @param field - The Zod field to unwrap\n * @returns The unwrapped type\n */\nexport function getUnwrappedType(field: z.ZodTypeAny): z.ZodTypeAny {\n  if (field instanceof z.ZodDefault) {\n    // Don't unwrap defaults - we want to preserve them\n    return field;\n  }\n\n  if ('unwrap' in field && typeof field.unwrap === 'function') {\n    return getUnwrappedType(field.unwrap());\n  }\n\n  return field;\n}\n\n/**\n * Extract all default values from a Zod object schema\n * Recursively handles nested objects and only returns fields with defaults\n * @param schema - The Zod object schema to extract defaults from\n * @returns Partial object with only fields that have defaults\n *\n * @example\n * ```ts\n * const schema = z.object({\n *   name: z.string().default('John'),\n *   age: z.number(), // no default - skipped\n *   settings: z.object({\n *     theme: z.string().default('light')\n *   })\n * });\n *\n * getSchemaDefaults(schema);\n * // Returns: { name: 'John', settings: { theme: 'light' } }\n * ```\n */\nexport function getSchemaDefaults<T extends z.ZodObject<any>>(\n  schema: T,\n): Partial<z.infer<T>> {\n  const defaults: Record<string, any> = {};\n\n  for (const key in schema.shape) {\n    const field = schema.shape[key];\n\n    // First, check if this field has an explicit default value\n    const defaultValue = extractDefault(field);\n    if (defaultValue !== undefined) {\n      defaults[key] = defaultValue;\n      continue;\n    }\n\n    // If no explicit default, check if it's a nested object with defaults\n    const unwrapped = getUnwrappedType(field);\n    if (unwrapped instanceof z.ZodObject) {\n      const nestedDefaults = getSchemaDefaults(unwrapped);\n      if (Object.keys(nestedDefaults).length > 0) {\n        defaults[key] = nestedDefaults;\n      }\n    }\n  }\n\n  return defaults as Partial<z.infer<T>>;\n}\n"]}

package/dist/index.mjs

@@ -0,0 +1,79 @@
+import * as z from 'zod';
+
+// src/schema.ts
+var getPrimitiveType = (field, options) => {
+  var _a;
+  const unwrapArrays = (_a = options == null ? void 0 : options.unwrapArrays) != null ? _a : false;
+  if (!unwrapArrays && field.type === "array") {
+    return field;
+  }
+  if ("unwrap" in field && typeof field.unwrap === "function") {
+    return getPrimitiveType(field.unwrap(), options);
+  }
+  return field;
+};
+function removeDefault(field) {
+  if (field instanceof z.ZodDefault) {
+    return field.unwrap();
+  }
+  if ("innerType" in field.def) {
+    const inner = removeDefault(field.def.innerType);
+    if (field instanceof z.ZodOptional) {
+      return inner.optional();
+    }
+    if (field instanceof z.ZodNullable) {
+      return inner.nullable();
+    }
+  }
+  return field;
+}
+var checkIfFieldIsRequired = (field) => {
+  const undefinedResult = field.safeParse(void 0).success;
+  const nullResult = field.safeParse(null).success;
+  const primitiveType = getPrimitiveType(field);
+  const emptyStringResult = primitiveType.type === "string" && field.safeParse("").success;
+  const emptyArrayResult = primitiveType.type === "array" && field.safeParse([]).success;
+  return !undefinedResult && !nullResult && !emptyStringResult && !emptyArrayResult;
+};
+function extractDefault(field) {
+  if (field instanceof z.ZodDefault) {
+    const defaultValue = field._def.defaultValue;
+    return typeof defaultValue === "function" ? defaultValue() : defaultValue;
+  }
+  if ("unwrap" in field && typeof field.unwrap === "function") {
+    return extractDefault(field.unwrap());
+  }
+  return void 0;
+}
+function getUnwrappedType(field) {
+  if (field instanceof z.ZodDefault) {
+    return field;
+  }
+  if ("unwrap" in field && typeof field.unwrap === "function") {
+    return getUnwrappedType(field.unwrap());
+  }
+  return field;
+}
+function getSchemaDefaults(schema) {
+  const defaults = {};
+  for (const key in schema.shape) {
+    const field = schema.shape[key];
+    const defaultValue = extractDefault(field);
+    if (defaultValue !== void 0) {
+      defaults[key] = defaultValue;
+      continue;
+    }
+    const unwrapped = getUnwrappedType(field);
+    if (unwrapped instanceof z.ZodObject) {
+      const nestedDefaults = getSchemaDefaults(unwrapped);
+      if (Object.keys(nestedDefaults).length > 0) {
+        defaults[key] = nestedDefaults;
+      }
+    }
+  }
+  return defaults;
+}
+
+export { checkIfFieldIsRequired, extractDefault, getPrimitiveType, getSchemaDefaults, getUnwrappedType, removeDefault };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/schema.ts","../src/defaults.ts"],"names":["z2"],"mappings":"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","file":"index.mjs","sourcesContent":["import * as z from 'zod';\n\n/**\n * Get the primitive type of a Zod field by unwrapping optional/nullable wrappers\n * @param field - The Zod field to unwrap\n * @param options - Options for unwrapping\n * @param options.unwrapArrays - If true, continues unwrapping arrays. If false (default), stops at arrays\n * @returns The unwrapped primitive type\n */\nexport const getPrimitiveType = <T extends z.ZodTypeAny>(\n  field: T,\n  options?: {\n    unwrapArrays?: boolean;\n  },\n): z.ZodTypeAny => {\n  const unwrapArrays = options?.unwrapArrays ?? false;\n\n  if (!unwrapArrays && field.type === 'array') {\n    return field;\n  }\n\n  if ('unwrap' in field && typeof field.unwrap === 'function') {\n    return getPrimitiveType(field.unwrap(), options);\n  }\n\n  return field;\n};\n\n/**\n * Remove default values from a Zod field\n * @param field - The Zod field to remove defaults from\n * @returns The field without defaults\n */\nexport function removeDefault(field: z.ZodType): z.ZodType {\n  if (field instanceof z.ZodDefault) {\n    return field.unwrap() as z.ZodType;\n  }\n\n  if ('innerType' in field.def) {\n    const inner = removeDefault(field.def.innerType as z.ZodType);\n    // Reconstruct the wrapper with the modified inner type\n    if (field instanceof z.ZodOptional) {\n      return inner.optional();\n    }\n    if (field instanceof z.ZodNullable) {\n      return inner.nullable();\n    }\n  }\n\n  return field;\n}\n\n/**\n * Check if a Zod field is required (not optional/nullable and doesn't accept empty values)\n * @param field - The Zod field to check\n * @returns True if the field is required\n */\nexport const checkIfFieldIsRequired = <T extends z.ZodTypeAny>(field: T) => {\n  // Check with defaults intact - if a field has a default, it's not required\n  const undefinedResult = field.safeParse(undefined).success;\n  const nullResult = field.safeParse(null).success;\n\n  const primitiveType = getPrimitiveType(field);\n\n  const emptyStringResult =\n    primitiveType.type === 'string' && field.safeParse('').success;\n\n  const emptyArrayResult =\n    primitiveType.type === 'array' && field.safeParse([]).success;\n\n  return (\n    !undefinedResult && !nullResult && !emptyStringResult && !emptyArrayResult\n  );\n};\n","import * as z from 'zod';\n\n/**\n * Extract the default value from a Zod field (recursively unwraps optional/nullable)\n * @param field - The Zod field to extract default from\n * @returns The default value if present, undefined otherwise\n */\nexport function extractDefault(field: z.ZodTypeAny): any {\n  if (field instanceof z.ZodDefault) {\n    const defaultValue = field._def.defaultValue;\n    return typeof defaultValue === 'function' ? defaultValue() : defaultValue;\n  }\n\n  if ('unwrap' in field && typeof field.unwrap === 'function') {\n    return extractDefault(field.unwrap());\n  }\n\n  return undefined;\n}\n\n/**\n * Get the unwrapped type without going through defaults\n * Useful for detecting nested objects/arrays while preserving defaults\n * @param field - The Zod field to unwrap\n * @returns The unwrapped type\n */\nexport function getUnwrappedType(field: z.ZodTypeAny): z.ZodTypeAny {\n  if (field instanceof z.ZodDefault) {\n    // Don't unwrap defaults - we want to preserve them\n    return field;\n  }\n\n  if ('unwrap' in field && typeof field.unwrap === 'function') {\n    return getUnwrappedType(field.unwrap());\n  }\n\n  return field;\n}\n\n/**\n * Extract all default values from a Zod object schema\n * Recursively handles nested objects and only returns fields with defaults\n * @param schema - The Zod object schema to extract defaults from\n * @returns Partial object with only fields that have defaults\n *\n * @example\n * ```ts\n * const schema = z.object({\n *   name: z.string().default('John'),\n *   age: z.number(), // no default - skipped\n *   settings: z.object({\n *     theme: z.string().default('light')\n *   })\n * });\n *\n * getSchemaDefaults(schema);\n * // Returns: { name: 'John', settings: { theme: 'light' } }\n * ```\n */\nexport function getSchemaDefaults<T extends z.ZodObject<any>>(\n  schema: T,\n): Partial<z.infer<T>> {\n  const defaults: Record<string, any> = {};\n\n  for (const key in schema.shape) {\n    const field = schema.shape[key];\n\n    // First, check if this field has an explicit default value\n    const defaultValue = extractDefault(field);\n    if (defaultValue !== undefined) {\n      defaults[key] = defaultValue;\n      continue;\n    }\n\n    // If no explicit default, check if it's a nested object with defaults\n    const unwrapped = getUnwrappedType(field);\n    if (unwrapped instanceof z.ZodObject) {\n      const nestedDefaults = getSchemaDefaults(unwrapped);\n      if (Object.keys(nestedDefaults).length > 0) {\n        defaults[key] = nestedDefaults;\n      }\n    }\n  }\n\n  return defaults as Partial<z.infer<T>>;\n}\n"]}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@zod-utils/core",
+  "version": "0.1.0",
+  "description": "Pure TypeScript utilities for Zod schema manipulation and default extraction",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": ["dist", "README.md"],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "type-check": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "zod",
+    "schema",
+    "validation",
+    "typescript",
+    "defaults",
+    "utilities"
+  ],
+  "author": "thu-san",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/thu-san/zod-utils.git",
+    "directory": "packages/core"
+  },
+  "bugs": {
+    "url": "https://github.com/thu-san/zod-utils/issues"
+  },
+  "homepage": "https://github.com/thu-san/zod-utils/tree/main/packages/core#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "zod": "^4.0.0"
+  },
+  "devDependencies": {
+    "@vitest/coverage-v8": "^2.1.0",
+    "tsup": "^8.3.5",
+    "typescript": "^5",
+    "vitest": "^2.1.0",
+    "zod": "^4.1.12"
+  }
+}