@rexeus/typeweaver-zod-to-ts 0.2.0 → 0.3.0

package/dist/index.cjs

@@ -0,0 +1,384 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  TsTypeNode: () => TsTypeNode,
+  TsTypePrinter: () => TsTypePrinter
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/TsTypeGenerator.ts
+var import_typescript = require("typescript");
+var import_core = require("zod/v4/core");
+var TsTypeNode = class _TsTypeNode {
+  static fromZod(zodType) {
+    if (zodType instanceof import_core.$ZodString) {
+      return _TsTypeNode.fromZodString(zodType);
+    }
+    if (zodType instanceof import_core.$ZodNumber) {
+      return _TsTypeNode.fromZodNumber(zodType);
+    }
+    if (zodType instanceof import_core.$ZodBigInt) {
+      return _TsTypeNode.fromZodBigInt(zodType);
+    }
+    if (zodType instanceof import_core.$ZodBoolean) {
+      return _TsTypeNode.fromZodBoolean(zodType);
+    }
+    if (zodType instanceof import_core.$ZodDate) {
+      return _TsTypeNode.fromZodDate(zodType);
+    }
+    if (zodType instanceof import_core.$ZodSymbol) {
+      return _TsTypeNode.fromZodSymbol(zodType);
+    }
+    if (zodType instanceof import_core.$ZodUndefined) {
+      return _TsTypeNode.fromZodUndefined(zodType);
+    }
+    if (zodType instanceof import_core.$ZodNullable) {
+      return _TsTypeNode.fromZodNullable(zodType);
+    }
+    if (zodType instanceof import_core.$ZodNull) {
+      return _TsTypeNode.fromZodNull(zodType);
+    }
+    if (zodType instanceof import_core.$ZodAny) {
+      return _TsTypeNode.fromZodAny(zodType);
+    }
+    if (zodType instanceof import_core.$ZodUnknown) {
+      return _TsTypeNode.fromZodUnknown(zodType);
+    }
+    if (zodType instanceof import_core.$ZodNever) {
+      return _TsTypeNode.fromZodNever(zodType);
+    }
+    if (zodType instanceof import_core.$ZodVoid) {
+      return _TsTypeNode.fromZodVoid(zodType);
+    }
+    if (zodType instanceof import_core.$ZodArray) {
+      return _TsTypeNode.fromZodArray(zodType);
+    }
+    if (zodType instanceof import_core.$ZodObject) {
+      return _TsTypeNode.fromZodObject(zodType);
+    }
+    if (zodType instanceof import_core.$ZodUnion) {
+      return _TsTypeNode.fromZodUnion(zodType);
+    }
+    if (zodType instanceof import_core.$ZodIntersection) {
+      return _TsTypeNode.fromZodIntersection(zodType);
+    }
+    if (zodType instanceof import_core.$ZodTuple) {
+      return _TsTypeNode.fromZodTuple(zodType);
+    }
+    if (zodType instanceof import_core.$ZodRecord) {
+      return _TsTypeNode.fromZodRecord(zodType);
+    }
+    if (zodType instanceof import_core.$ZodMap) {
+      return _TsTypeNode.fromZodMap(zodType);
+    }
+    if (zodType instanceof import_core.$ZodSet) {
+      return _TsTypeNode.fromZodSet(zodType);
+    }
+    if (zodType instanceof import_core.$ZodLiteral) {
+      if (!_TsTypeNode) {
+        throw new Error("ZodLiteral has no values");
+      }
+      return _TsTypeNode.fromZodLiteral(zodType);
+    }
+    if (zodType instanceof import_core.$ZodEnum) {
+      return _TsTypeNode.fromZodEnum(zodType);
+    }
+    if (zodType instanceof import_core.$ZodPromise) {
+      return _TsTypeNode.fromZodPromise(zodType);
+    }
+    if (zodType instanceof import_core.$ZodLazy) {
+      return _TsTypeNode.fromZodLazy(zodType);
+    }
+    if (zodType instanceof import_core.$ZodOptional) {
+      return _TsTypeNode.fromZodOptional(zodType);
+    }
+    if (zodType instanceof import_core.$ZodDefault) {
+      return _TsTypeNode.fromZodDefault(zodType);
+    }
+    if (zodType instanceof import_core.$ZodTemplateLiteral) {
+      return _TsTypeNode.fromZodTemplateLiteral(zodType);
+    }
+    if (zodType instanceof import_core.$ZodCustom) {
+      return _TsTypeNode.fromZodCustom(zodType);
+    }
+    if (zodType instanceof import_core.$ZodTransform) {
+      return _TsTypeNode.fromZodTransform(zodType);
+    }
+    if (zodType instanceof import_core.$ZodNonOptional) {
+      return _TsTypeNode.fromZodNonOptional(zodType);
+    }
+    if (zodType instanceof import_core.$ZodReadonly) {
+      return _TsTypeNode.fromZodReadonly(zodType);
+    }
+    if (zodType instanceof import_core.$ZodNaN) {
+      return _TsTypeNode.fromZodNaN(zodType);
+    }
+    if (zodType instanceof import_core.$ZodPipe) {
+      return _TsTypeNode.fromZodPipe(zodType);
+    }
+    if (zodType instanceof import_core.$ZodSuccess) {
+      return _TsTypeNode.fromZodSuccess(zodType);
+    }
+    if (zodType instanceof import_core.$ZodCatch) {
+      return _TsTypeNode.fromZodCatch(zodType);
+    }
+    if (zodType instanceof import_core.$ZodFile) {
+      return _TsTypeNode.fromZodFile(zodType);
+    }
+    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.UnknownKeyword);
+  }
+  static fromZodString(_zodString) {
+    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.StringKeyword);
+  }
+  static fromZodNumber(_zodNumber) {
+    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.NumberKeyword);
+  }
+  static fromZodBigInt(_zodBigInt) {
+    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.BigIntKeyword);
+  }
+  static fromZodBoolean(_zodBoolean) {
+    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.BooleanKeyword);
+  }
+  static fromZodDate(_zodDate) {
+    return import_typescript.factory.createTypeReferenceNode(import_typescript.factory.createIdentifier("Date"));
+  }
+  static fromZodSymbol(_zodSymbol) {
+    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.SymbolKeyword);
+  }
+  static fromZodUndefined(_zodUndefined) {
+    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.UndefinedKeyword);
+  }
+  static fromZodNullable(zodNullable) {
+    const innerType = _TsTypeNode.fromZod(zodNullable._zod.def.innerType);
+    return import_typescript.factory.createUnionTypeNode([
+      innerType,
+      import_typescript.factory.createLiteralTypeNode(import_typescript.factory.createNull())
+    ]);
+  }
+  static fromZodNull(_zodNull) {
+    return import_typescript.factory.createLiteralTypeNode(import_typescript.factory.createNull());
+  }
+  static fromZodAny(_zodAny) {
+    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.AnyKeyword);
+  }
+  static fromZodUnknown(_zodUnknown) {
+    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.UnknownKeyword);
+  }
+  static fromZodNever(_zodNever) {
+    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.NeverKeyword);
+  }
+  static fromZodVoid(_zodVoid) {
+    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.VoidKeyword);
+  }
+  static fromZodArray(zodArray) {
+    const innerType = _TsTypeNode.fromZod(zodArray._zod.def.element);
+    return import_typescript.factory.createArrayTypeNode(innerType);
+  }
+  static fromZodObject(zodObject) {
+    const entries = Object.entries(zodObject._zod.def.shape);
+    const members = entries.map(([key, nextZodNode]) => {
+      const type = _TsTypeNode.fromZod(nextZodNode);
+      if (!nextZodNode._zod?.def) {
+        console.warn(
+          `Zod node for key "${key}" does not have a _zod.def property. This may indicate an issue with the Zod schema.`,
+          {
+            key
+          }
+        );
+      }
+      const { type: nextZodNodeTypeName } = nextZodNode._zod?.def ?? {};
+      const isOptional = nextZodNodeTypeName === "optional";
+      const propertySignature = import_typescript.factory.createPropertySignature(
+        void 0,
+        _TsTypeNode.createTsAstPropertyKey(key),
+        isOptional ? import_typescript.factory.createToken(import_typescript.SyntaxKind.QuestionToken) : void 0,
+        type
+      );
+      return propertySignature;
+    });
+    return import_typescript.factory.createTypeLiteralNode(members);
+  }
+  static fromZodUnion(zodUnion) {
+    const options = zodUnion._zod.def.options.map(_TsTypeNode.fromZod);
+    return import_typescript.factory.createUnionTypeNode(options);
+  }
+  static fromZodIntersection(zodIntersection) {
+    const left = _TsTypeNode.fromZod(zodIntersection._zod.def.left);
+    const right = _TsTypeNode.fromZod(zodIntersection._zod.def.right);
+    return import_typescript.factory.createIntersectionTypeNode([left, right]);
+  }
+  static fromZodTuple(zodTuple) {
+    const elements = zodTuple._zod.def.items.map(_TsTypeNode.fromZod);
+    return import_typescript.factory.createTupleTypeNode(elements);
+  }
+  static fromZodRecord(zodRecord) {
+    const keyType = _TsTypeNode.fromZod(zodRecord._zod.def.keyType);
+    const valueType = _TsTypeNode.fromZod(zodRecord._zod.def.valueType);
+    return import_typescript.factory.createTypeReferenceNode(import_typescript.factory.createIdentifier("Record"), [
+      keyType,
+      valueType
+    ]);
+  }
+  static fromZodMap(zodMap) {
+    const keyType = _TsTypeNode.fromZod(zodMap._zod.def.keyType);
+    const valueType = _TsTypeNode.fromZod(zodMap._zod.def.valueType);
+    return import_typescript.factory.createTypeReferenceNode(import_typescript.factory.createIdentifier("Map"), [
+      keyType,
+      valueType
+    ]);
+  }
+  static fromZodSet(zodSet) {
+    const innerType = _TsTypeNode.fromZod(zodSet._zod.def.valueType);
+    return import_typescript.factory.createTypeReferenceNode(import_typescript.factory.createIdentifier("Set"), [
+      innerType
+    ]);
+  }
+  static fromZodLiteral(zodLiteral) {
+    if (zodLiteral._zod.def.values.length === 0) {
+      throw new Error("ZodLiteral has no values");
+    }
+    const value = zodLiteral._zod.def.values[0];
+    if (typeof value === "string") {
+      return import_typescript.factory.createLiteralTypeNode(import_typescript.factory.createStringLiteral(value));
+    }
+    if (typeof value === "number") {
+      return import_typescript.factory.createLiteralTypeNode(import_typescript.factory.createNumericLiteral(value));
+    }
+    if (typeof value === "boolean") {
+      return import_typescript.factory.createLiteralTypeNode(
+        value ? import_typescript.factory.createTrue() : import_typescript.factory.createFalse()
+      );
+    }
+    if (typeof value === "bigint") {
+      return import_typescript.factory.createLiteralTypeNode(
+        import_typescript.factory.createBigIntLiteral(value.toString())
+      );
+    }
+    if (value === null) {
+      return import_typescript.factory.createLiteralTypeNode(import_typescript.factory.createNull());
+    }
+    if (value === void 0) {
+      return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.UndefinedKeyword);
+    }
+    throw new Error(`Unsupported literal type: ${typeof value}`);
+  }
+  static fromZodEnum(zodEnum) {
+    const entries = Object.entries(zodEnum._zod.def.entries);
+    const types = entries.map(([key, value]) => {
+      return import_typescript.factory.createLiteralTypeNode(import_typescript.factory.createStringLiteral(key));
+    });
+    return import_typescript.factory.createUnionTypeNode(types);
+  }
+  static fromZodPromise(zodPromise) {
+    const innerType = _TsTypeNode.fromZod(zodPromise._zod.def.innerType);
+    return import_typescript.factory.createTypeReferenceNode(
+      import_typescript.factory.createIdentifier("Promise"),
+      [innerType]
+    );
+  }
+  static fromZodLazy(_zodLazy) {
+    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.UnknownKeyword);
+  }
+  static fromZodOptional(zodOptional) {
+    const innerType = _TsTypeNode.fromZod(zodOptional._zod.def.innerType);
+    return import_typescript.factory.createUnionTypeNode([
+      innerType,
+      import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.UndefinedKeyword)
+    ]);
+  }
+  static fromZodDefault(zodDefault) {
+    const innerType = _TsTypeNode.fromZod(zodDefault._zod.def.innerType);
+    const filteredNodes = [];
+    innerType.forEachChild((node) => {
+      if (node.kind !== import_typescript.SyntaxKind.UndefinedKeyword) {
+        filteredNodes.push(node);
+      }
+    });
+    innerType.types = filteredNodes;
+    return innerType;
+  }
+  static fromZodTemplateLiteral(_zodTemplateLiteral) {
+    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.UnknownKeyword);
+  }
+  static fromZodCustom(_zodCustom) {
+    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.UnknownKeyword);
+  }
+  static fromZodTransform(_zodTransform) {
+    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.UnknownKeyword);
+  }
+  static fromZodNonOptional(_zodNonOptional) {
+    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.UnknownKeyword);
+  }
+  static fromZodReadonly(_zodReadonly) {
+    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.UnknownKeyword);
+  }
+  static fromZodNaN(_zodNaN) {
+    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.UnknownKeyword);
+  }
+  static fromZodPipe(_zodPipe) {
+    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.UnknownKeyword);
+  }
+  static fromZodSuccess(_zodSuccess) {
+    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.UnknownKeyword);
+  }
+  static fromZodCatch(_zodCatch) {
+    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.UnknownKeyword);
+  }
+  static fromZodFile(_zodFile) {
+    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.UnknownKeyword);
+  }
+  /**
+   * Returns a TypeScript AST node representing the property key.
+   * If the key is a valid JavaScript identifier, returns an Identifier node.
+   * Otherwise, returns a StringLiteral node.
+   *
+   * @param {string} key - The property key to convert.
+   * @returns {Identifier | StringLiteral} The corresponding AST node for the property key.
+   */
+  static createTsAstPropertyKey(key) {
+    if (/^[$A-Z_a-z][\w$]*$/.test(key)) {
+      return import_typescript.factory.createIdentifier(key);
+    }
+    return import_typescript.factory.createStringLiteral(key);
+  }
+};
+
+// src/TsTypePrinter.ts
+var import_typescript2 = require("typescript");
+var TsTypePrinter = class {
+  static print(tsType) {
+    const sourceFile = (0, import_typescript2.createSourceFile)(
+      "print.ts",
+      "",
+      import_typescript2.ScriptTarget.Latest,
+      false,
+      import_typescript2.ScriptKind.TS
+    );
+    const printer = (0, import_typescript2.createPrinter)();
+    return printer.printNode(import_typescript2.EmitHint.Unspecified, tsType, sourceFile);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TsTypeNode,
+  TsTypePrinter
+});

package/dist/index.d.cts

@@ -0,0 +1,58 @@
+import { TypeNode } from 'typescript';
+import { $ZodType } from 'zod/v4/core';
+
+declare class TsTypeNode {
+    static fromZod(zodType: $ZodType): TypeNode;
+    private static fromZodString;
+    private static fromZodNumber;
+    private static fromZodBigInt;
+    private static fromZodBoolean;
+    private static fromZodDate;
+    private static fromZodSymbol;
+    private static fromZodUndefined;
+    private static fromZodNullable;
+    private static fromZodNull;
+    private static fromZodAny;
+    private static fromZodUnknown;
+    private static fromZodNever;
+    private static fromZodVoid;
+    private static fromZodArray;
+    private static fromZodObject;
+    private static fromZodUnion;
+    private static fromZodIntersection;
+    private static fromZodTuple;
+    private static fromZodRecord;
+    private static fromZodMap;
+    private static fromZodSet;
+    private static fromZodLiteral;
+    private static fromZodEnum;
+    private static fromZodPromise;
+    private static fromZodLazy;
+    private static fromZodOptional;
+    private static fromZodDefault;
+    private static fromZodTemplateLiteral;
+    private static fromZodCustom;
+    private static fromZodTransform;
+    private static fromZodNonOptional;
+    private static fromZodReadonly;
+    private static fromZodNaN;
+    private static fromZodPipe;
+    private static fromZodSuccess;
+    private static fromZodCatch;
+    private static fromZodFile;
+    /**
+     * Returns a TypeScript AST node representing the property key.
+     * If the key is a valid JavaScript identifier, returns an Identifier node.
+     * Otherwise, returns a StringLiteral node.
+     *
+     * @param {string} key - The property key to convert.
+     * @returns {Identifier | StringLiteral} The corresponding AST node for the property key.
+     */
+    private static createTsAstPropertyKey;
+}
+
+declare class TsTypePrinter {
+    static print(tsType: TypeNode): string;
+}
+
+export { TsTypeNode, TsTypePrinter };

package/dist/index.js

@@ -1,121 +1,159 @@
-import { factory, SyntaxKind, createSourceFile, ScriptTarget, ScriptKind, createPrinter, EmitHint } from 'typescript';
-import { $ZodString, $ZodNumber, $ZodBigInt, $ZodBoolean, $ZodDate, $ZodSymbol, $ZodUndefined, $ZodNullable, $ZodNull, $ZodAny, $ZodUnknown, $ZodNever, $ZodVoid, $ZodArray, $ZodObject, $ZodUnion, $ZodIntersection, $ZodTuple, $ZodRecord, $ZodMap, $ZodSet, $ZodLiteral, $ZodEnum, $ZodPromise, $ZodLazy, $ZodOptional, $ZodDefault, $ZodTemplateLiteral, $ZodCustom, $ZodTransform, $ZodNonOptional, $ZodReadonly, $ZodNaN, $ZodPipe, $ZodSuccess, $ZodCatch, $ZodFile } from 'zod/v4/core';
-
-class TsTypeNode {
+// src/TsTypeGenerator.ts
+import { factory, SyntaxKind } from "typescript";
+import {
+  $ZodAny,
+  $ZodArray,
+  $ZodBigInt,
+  $ZodBoolean,
+  $ZodCatch,
+  $ZodCustom,
+  $ZodDate,
+  $ZodDefault,
+  $ZodEnum,
+  $ZodFile,
+  $ZodIntersection,
+  $ZodLazy,
+  $ZodLiteral,
+  $ZodMap,
+  $ZodNaN,
+  $ZodNever,
+  $ZodNonOptional,
+  $ZodNull,
+  $ZodNullable,
+  $ZodNumber,
+  $ZodObject,
+  $ZodOptional,
+  $ZodPipe,
+  $ZodPromise,
+  $ZodReadonly,
+  $ZodRecord,
+  $ZodSet,
+  $ZodString,
+  $ZodSuccess,
+  $ZodSymbol,
+  $ZodTemplateLiteral,
+  $ZodTransform,
+  $ZodTuple,
+  $ZodUndefined,
+  $ZodUnion,
+  $ZodUnknown,
+  $ZodVoid
+} from "zod/v4/core";
+var TsTypeNode = class _TsTypeNode {
   static fromZod(zodType) {
     if (zodType instanceof $ZodString) {
-      return TsTypeNode.fromZodString(zodType);
+      return _TsTypeNode.fromZodString(zodType);
     }
     if (zodType instanceof $ZodNumber) {
-      return TsTypeNode.fromZodNumber(zodType);
+      return _TsTypeNode.fromZodNumber(zodType);
     }
     if (zodType instanceof $ZodBigInt) {
-      return TsTypeNode.fromZodBigInt(zodType);
+      return _TsTypeNode.fromZodBigInt(zodType);
     }
     if (zodType instanceof $ZodBoolean) {
-      return TsTypeNode.fromZodBoolean(zodType);
+      return _TsTypeNode.fromZodBoolean(zodType);
     }
     if (zodType instanceof $ZodDate) {
-      return TsTypeNode.fromZodDate(zodType);
+      return _TsTypeNode.fromZodDate(zodType);
     }
     if (zodType instanceof $ZodSymbol) {
-      return TsTypeNode.fromZodSymbol(zodType);
+      return _TsTypeNode.fromZodSymbol(zodType);
     }
     if (zodType instanceof $ZodUndefined) {
-      return TsTypeNode.fromZodUndefined(zodType);
+      return _TsTypeNode.fromZodUndefined(zodType);
     }
     if (zodType instanceof $ZodNullable) {
-      return TsTypeNode.fromZodNullable(zodType);
+      return _TsTypeNode.fromZodNullable(zodType);
     }
     if (zodType instanceof $ZodNull) {
-      return TsTypeNode.fromZodNull(zodType);
+      return _TsTypeNode.fromZodNull(zodType);
     }
     if (zodType instanceof $ZodAny) {
-      return TsTypeNode.fromZodAny(zodType);
+      return _TsTypeNode.fromZodAny(zodType);
     }
     if (zodType instanceof $ZodUnknown) {
-      return TsTypeNode.fromZodUnknown(zodType);
+      return _TsTypeNode.fromZodUnknown(zodType);
     }
     if (zodType instanceof $ZodNever) {
-      return TsTypeNode.fromZodNever(zodType);
+      return _TsTypeNode.fromZodNever(zodType);
     }
     if (zodType instanceof $ZodVoid) {
-      return TsTypeNode.fromZodVoid(zodType);
+      return _TsTypeNode.fromZodVoid(zodType);
     }
     if (zodType instanceof $ZodArray) {
-      return TsTypeNode.fromZodArray(zodType);
+      return _TsTypeNode.fromZodArray(zodType);
     }
     if (zodType instanceof $ZodObject) {
-      return TsTypeNode.fromZodObject(zodType);
+      return _TsTypeNode.fromZodObject(zodType);
     }
     if (zodType instanceof $ZodUnion) {
-      return TsTypeNode.fromZodUnion(zodType);
+      return _TsTypeNode.fromZodUnion(zodType);
     }
     if (zodType instanceof $ZodIntersection) {
-      return TsTypeNode.fromZodIntersection(zodType);
+      return _TsTypeNode.fromZodIntersection(zodType);
     }
     if (zodType instanceof $ZodTuple) {
-      return TsTypeNode.fromZodTuple(zodType);
+      return _TsTypeNode.fromZodTuple(zodType);
     }
     if (zodType instanceof $ZodRecord) {
-      return TsTypeNode.fromZodRecord(zodType);
+      return _TsTypeNode.fromZodRecord(zodType);
     }
     if (zodType instanceof $ZodMap) {
-      return TsTypeNode.fromZodMap(zodType);
+      return _TsTypeNode.fromZodMap(zodType);
     }
     if (zodType instanceof $ZodSet) {
-      return TsTypeNode.fromZodSet(zodType);
+      return _TsTypeNode.fromZodSet(zodType);
     }
     if (zodType instanceof $ZodLiteral) {
-      if (!TsTypeNode) {
+      if (!_TsTypeNode) {
         throw new Error("ZodLiteral has no values");
       }
-      return TsTypeNode.fromZodLiteral(zodType);
+      return _TsTypeNode.fromZodLiteral(zodType);
     }
     if (zodType instanceof $ZodEnum) {
-      return TsTypeNode.fromZodEnum(zodType);
+      return _TsTypeNode.fromZodEnum(zodType);
     }
     if (zodType instanceof $ZodPromise) {
-      return TsTypeNode.fromZodPromise(zodType);
+      return _TsTypeNode.fromZodPromise(zodType);
     }
     if (zodType instanceof $ZodLazy) {
-      return TsTypeNode.fromZodLazy(zodType);
+      return _TsTypeNode.fromZodLazy(zodType);
     }
     if (zodType instanceof $ZodOptional) {
-      return TsTypeNode.fromZodOptional(zodType);
+      return _TsTypeNode.fromZodOptional(zodType);
     }
     if (zodType instanceof $ZodDefault) {
-      return TsTypeNode.fromZodDefault(zodType);
+      return _TsTypeNode.fromZodDefault(zodType);
     }
     if (zodType instanceof $ZodTemplateLiteral) {
-      return TsTypeNode.fromZodTemplateLiteral(zodType);
+      return _TsTypeNode.fromZodTemplateLiteral(zodType);
     }
     if (zodType instanceof $ZodCustom) {
-      return TsTypeNode.fromZodCustom(zodType);
+      return _TsTypeNode.fromZodCustom(zodType);
     }
     if (zodType instanceof $ZodTransform) {
-      return TsTypeNode.fromZodTransform(zodType);
+      return _TsTypeNode.fromZodTransform(zodType);
     }
     if (zodType instanceof $ZodNonOptional) {
-      return TsTypeNode.fromZodNonOptional(zodType);
+      return _TsTypeNode.fromZodNonOptional(zodType);
     }
     if (zodType instanceof $ZodReadonly) {
-      return TsTypeNode.fromZodReadonly(zodType);
+      return _TsTypeNode.fromZodReadonly(zodType);
     }
     if (zodType instanceof $ZodNaN) {
-      return TsTypeNode.fromZodNaN(zodType);
+      return _TsTypeNode.fromZodNaN(zodType);
     }
     if (zodType instanceof $ZodPipe) {
-      return TsTypeNode.fromZodPipe(zodType);
+      return _TsTypeNode.fromZodPipe(zodType);
     }
     if (zodType instanceof $ZodSuccess) {
-      return TsTypeNode.fromZodSuccess(zodType);
+      return _TsTypeNode.fromZodSuccess(zodType);
     }
     if (zodType instanceof $ZodCatch) {
-      return TsTypeNode.fromZodCatch(zodType);
+      return _TsTypeNode.fromZodCatch(zodType);
     }
     if (zodType instanceof $ZodFile) {
-      return TsTypeNode.fromZodFile(zodType);
+      return _TsTypeNode.fromZodFile(zodType);
     }
     return factory.createKeywordTypeNode(SyntaxKind.UnknownKeyword);
   }
@@ -141,7 +179,7 @@ class TsTypeNode {
     return factory.createKeywordTypeNode(SyntaxKind.UndefinedKeyword);
   }
   static fromZodNullable(zodNullable) {
-    const innerType = TsTypeNode.fromZod(zodNullable._zod.def.innerType);
+    const innerType = _TsTypeNode.fromZod(zodNullable._zod.def.innerType);
     return factory.createUnionTypeNode([
       innerType,
       factory.createLiteralTypeNode(factory.createNull())
@@ -163,13 +201,13 @@ class TsTypeNode {
     return factory.createKeywordTypeNode(SyntaxKind.VoidKeyword);
   }
   static fromZodArray(zodArray) {
-    const innerType = TsTypeNode.fromZod(zodArray._zod.def.element);
+    const innerType = _TsTypeNode.fromZod(zodArray._zod.def.element);
     return factory.createArrayTypeNode(innerType);
   }
   static fromZodObject(zodObject) {
     const entries = Object.entries(zodObject._zod.def.shape);
     const members = entries.map(([key, nextZodNode]) => {
-      const type = TsTypeNode.fromZod(nextZodNode);
+      const type = _TsTypeNode.fromZod(nextZodNode);
       if (!nextZodNode._zod?.def) {
         console.warn(
           `Zod node for key "${key}" does not have a _zod.def property. This may indicate an issue with the Zod schema.`,
@@ -182,7 +220,7 @@ class TsTypeNode {
       const isOptional = nextZodNodeTypeName === "optional";
       const propertySignature = factory.createPropertySignature(
         void 0,
-        TsTypeNode.createTsAstPropertyKey(key),
+        _TsTypeNode.createTsAstPropertyKey(key),
         isOptional ? factory.createToken(SyntaxKind.QuestionToken) : void 0,
         type
       );
@@ -191,36 +229,36 @@ class TsTypeNode {
     return factory.createTypeLiteralNode(members);
   }
   static fromZodUnion(zodUnion) {
-    const options = zodUnion._zod.def.options.map(TsTypeNode.fromZod);
+    const options = zodUnion._zod.def.options.map(_TsTypeNode.fromZod);
     return factory.createUnionTypeNode(options);
   }
   static fromZodIntersection(zodIntersection) {
-    const left = TsTypeNode.fromZod(zodIntersection._zod.def.left);
-    const right = TsTypeNode.fromZod(zodIntersection._zod.def.right);
+    const left = _TsTypeNode.fromZod(zodIntersection._zod.def.left);
+    const right = _TsTypeNode.fromZod(zodIntersection._zod.def.right);
     return factory.createIntersectionTypeNode([left, right]);
   }
   static fromZodTuple(zodTuple) {
-    const elements = zodTuple._zod.def.items.map(TsTypeNode.fromZod);
+    const elements = zodTuple._zod.def.items.map(_TsTypeNode.fromZod);
     return factory.createTupleTypeNode(elements);
   }
   static fromZodRecord(zodRecord) {
-    const keyType = TsTypeNode.fromZod(zodRecord._zod.def.keyType);
-    const valueType = TsTypeNode.fromZod(zodRecord._zod.def.valueType);
+    const keyType = _TsTypeNode.fromZod(zodRecord._zod.def.keyType);
+    const valueType = _TsTypeNode.fromZod(zodRecord._zod.def.valueType);
     return factory.createTypeReferenceNode(factory.createIdentifier("Record"), [
       keyType,
       valueType
     ]);
   }
   static fromZodMap(zodMap) {
-    const keyType = TsTypeNode.fromZod(zodMap._zod.def.keyType);
-    const valueType = TsTypeNode.fromZod(zodMap._zod.def.valueType);
+    const keyType = _TsTypeNode.fromZod(zodMap._zod.def.keyType);
+    const valueType = _TsTypeNode.fromZod(zodMap._zod.def.valueType);
     return factory.createTypeReferenceNode(factory.createIdentifier("Map"), [
       keyType,
       valueType
     ]);
   }
   static fromZodSet(zodSet) {
-    const innerType = TsTypeNode.fromZod(zodSet._zod.def.valueType);
+    const innerType = _TsTypeNode.fromZod(zodSet._zod.def.valueType);
     return factory.createTypeReferenceNode(factory.createIdentifier("Set"), [
       innerType
     ]);
@@ -262,7 +300,7 @@ class TsTypeNode {
     return factory.createUnionTypeNode(types);
   }
   static fromZodPromise(zodPromise) {
-    const innerType = TsTypeNode.fromZod(zodPromise._zod.def.innerType);
+    const innerType = _TsTypeNode.fromZod(zodPromise._zod.def.innerType);
     return factory.createTypeReferenceNode(
       factory.createIdentifier("Promise"),
       [innerType]
@@ -272,14 +310,14 @@ class TsTypeNode {
     return factory.createKeywordTypeNode(SyntaxKind.UnknownKeyword);
   }
   static fromZodOptional(zodOptional) {
-    const innerType = TsTypeNode.fromZod(zodOptional._zod.def.innerType);
+    const innerType = _TsTypeNode.fromZod(zodOptional._zod.def.innerType);
     return factory.createUnionTypeNode([
       innerType,
       factory.createKeywordTypeNode(SyntaxKind.UndefinedKeyword)
     ]);
   }
   static fromZodDefault(zodDefault) {
-    const innerType = TsTypeNode.fromZod(zodDefault._zod.def.innerType);
+    const innerType = _TsTypeNode.fromZod(zodDefault._zod.def.innerType);
     const filteredNodes = [];
     innerType.forEachChild((node) => {
       if (node.kind !== SyntaxKind.UndefinedKeyword) {
@@ -333,9 +371,17 @@ class TsTypeNode {
     }
     return factory.createStringLiteral(key);
   }
-}
+};
 
-class TsTypePrinter {
+// src/TsTypePrinter.ts
+import {
+  createPrinter,
+  createSourceFile,
+  EmitHint,
+  ScriptKind,
+  ScriptTarget
+} from "typescript";
+var TsTypePrinter = class {
   static print(tsType) {
     const sourceFile = createSourceFile(
       "print.ts",
@@ -347,6 +393,8 @@ class TsTypePrinter {
     const printer = createPrinter();
     return printer.printNode(EmitHint.Unspecified, tsType, sourceFile);
   }
-}
-
-export { TsTypeNode, TsTypePrinter };
+};
+export {
+  TsTypeNode,
+  TsTypePrinter
+};

package/package.json

@@ -1,14 +1,21 @@
 {
   "name": "@rexeus/typeweaver-zod-to-ts",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Transforms Zod v4 schemas into precise TypeScript shapes. Powered by Typeweaver 🧵✨",
   "type": "module",
-  "main": "dist/index.js",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
     }
   },
   "files": [
@@ -41,15 +48,15 @@
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "zod": "^4.1.11"
+    "zod": "^4.3.5"
   },
   "devDependencies": {
-    "zod": "^4.1.11"
+    "zod": "^4.3.5"
   },
   "scripts": {
     "typecheck": "tsc --noEmit",
     "format": "prettier --write .",
-    "build": "pkgroll --clean-dist && cp ../../LICENSE ../../NOTICE ./dist/",
+    "build": "tsup && cp ../../LICENSE ../../NOTICE ./dist/",
     "preversion": "npm run build"
   }
 }