@rexeus/typeweaver-zod-to-ts 0.3.1 → 0.4.0

package/dist/index.cjs

@@ -1,197 +1,173 @@
-"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);
+'use strict';
 
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  TsTypeNode: () => TsTypeNode,
-  TsTypePrinter: () => TsTypePrinter
-});
-module.exports = __toCommonJS(index_exports);
+var typescript = require('typescript');
+var core = require('zod/v4/core');
 
 // 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) {
+    if (zodType instanceof core.$ZodString) {
       return _TsTypeNode.fromZodString(zodType);
     }
-    if (zodType instanceof import_core.$ZodNumber) {
+    if (zodType instanceof core.$ZodNumber) {
       return _TsTypeNode.fromZodNumber(zodType);
     }
-    if (zodType instanceof import_core.$ZodBigInt) {
+    if (zodType instanceof core.$ZodBigInt) {
       return _TsTypeNode.fromZodBigInt(zodType);
     }
-    if (zodType instanceof import_core.$ZodBoolean) {
+    if (zodType instanceof core.$ZodBoolean) {
       return _TsTypeNode.fromZodBoolean(zodType);
     }
-    if (zodType instanceof import_core.$ZodDate) {
+    if (zodType instanceof core.$ZodDate) {
       return _TsTypeNode.fromZodDate(zodType);
     }
-    if (zodType instanceof import_core.$ZodSymbol) {
+    if (zodType instanceof core.$ZodSymbol) {
       return _TsTypeNode.fromZodSymbol(zodType);
     }
-    if (zodType instanceof import_core.$ZodUndefined) {
+    if (zodType instanceof core.$ZodUndefined) {
       return _TsTypeNode.fromZodUndefined(zodType);
     }
-    if (zodType instanceof import_core.$ZodNullable) {
+    if (zodType instanceof core.$ZodNullable) {
       return _TsTypeNode.fromZodNullable(zodType);
     }
-    if (zodType instanceof import_core.$ZodNull) {
+    if (zodType instanceof core.$ZodNull) {
       return _TsTypeNode.fromZodNull(zodType);
     }
-    if (zodType instanceof import_core.$ZodAny) {
+    if (zodType instanceof core.$ZodAny) {
       return _TsTypeNode.fromZodAny(zodType);
     }
-    if (zodType instanceof import_core.$ZodUnknown) {
+    if (zodType instanceof core.$ZodUnknown) {
       return _TsTypeNode.fromZodUnknown(zodType);
     }
-    if (zodType instanceof import_core.$ZodNever) {
+    if (zodType instanceof core.$ZodNever) {
       return _TsTypeNode.fromZodNever(zodType);
     }
-    if (zodType instanceof import_core.$ZodVoid) {
+    if (zodType instanceof core.$ZodVoid) {
       return _TsTypeNode.fromZodVoid(zodType);
     }
-    if (zodType instanceof import_core.$ZodArray) {
+    if (zodType instanceof core.$ZodArray) {
       return _TsTypeNode.fromZodArray(zodType);
     }
-    if (zodType instanceof import_core.$ZodObject) {
+    if (zodType instanceof core.$ZodObject) {
       return _TsTypeNode.fromZodObject(zodType);
     }
-    if (zodType instanceof import_core.$ZodUnion) {
+    if (zodType instanceof core.$ZodUnion) {
       return _TsTypeNode.fromZodUnion(zodType);
     }
-    if (zodType instanceof import_core.$ZodIntersection) {
+    if (zodType instanceof core.$ZodIntersection) {
       return _TsTypeNode.fromZodIntersection(zodType);
     }
-    if (zodType instanceof import_core.$ZodTuple) {
+    if (zodType instanceof core.$ZodTuple) {
       return _TsTypeNode.fromZodTuple(zodType);
     }
-    if (zodType instanceof import_core.$ZodRecord) {
+    if (zodType instanceof core.$ZodRecord) {
       return _TsTypeNode.fromZodRecord(zodType);
     }
-    if (zodType instanceof import_core.$ZodMap) {
+    if (zodType instanceof core.$ZodMap) {
       return _TsTypeNode.fromZodMap(zodType);
     }
-    if (zodType instanceof import_core.$ZodSet) {
+    if (zodType instanceof core.$ZodSet) {
       return _TsTypeNode.fromZodSet(zodType);
     }
-    if (zodType instanceof import_core.$ZodLiteral) {
+    if (zodType instanceof core.$ZodLiteral) {
       if (!_TsTypeNode) {
         throw new Error("ZodLiteral has no values");
       }
       return _TsTypeNode.fromZodLiteral(zodType);
     }
-    if (zodType instanceof import_core.$ZodEnum) {
+    if (zodType instanceof core.$ZodEnum) {
       return _TsTypeNode.fromZodEnum(zodType);
     }
-    if (zodType instanceof import_core.$ZodPromise) {
+    if (zodType instanceof core.$ZodPromise) {
       return _TsTypeNode.fromZodPromise(zodType);
     }
-    if (zodType instanceof import_core.$ZodLazy) {
+    if (zodType instanceof core.$ZodLazy) {
       return _TsTypeNode.fromZodLazy(zodType);
     }
-    if (zodType instanceof import_core.$ZodOptional) {
+    if (zodType instanceof core.$ZodOptional) {
       return _TsTypeNode.fromZodOptional(zodType);
     }
-    if (zodType instanceof import_core.$ZodDefault) {
+    if (zodType instanceof core.$ZodDefault) {
       return _TsTypeNode.fromZodDefault(zodType);
     }
-    if (zodType instanceof import_core.$ZodTemplateLiteral) {
+    if (zodType instanceof core.$ZodTemplateLiteral) {
       return _TsTypeNode.fromZodTemplateLiteral(zodType);
     }
-    if (zodType instanceof import_core.$ZodCustom) {
+    if (zodType instanceof core.$ZodCustom) {
       return _TsTypeNode.fromZodCustom(zodType);
     }
-    if (zodType instanceof import_core.$ZodTransform) {
+    if (zodType instanceof core.$ZodTransform) {
       return _TsTypeNode.fromZodTransform(zodType);
     }
-    if (zodType instanceof import_core.$ZodNonOptional) {
+    if (zodType instanceof core.$ZodNonOptional) {
       return _TsTypeNode.fromZodNonOptional(zodType);
     }
-    if (zodType instanceof import_core.$ZodReadonly) {
+    if (zodType instanceof core.$ZodReadonly) {
       return _TsTypeNode.fromZodReadonly(zodType);
     }
-    if (zodType instanceof import_core.$ZodNaN) {
+    if (zodType instanceof core.$ZodNaN) {
       return _TsTypeNode.fromZodNaN(zodType);
     }
-    if (zodType instanceof import_core.$ZodPipe) {
+    if (zodType instanceof core.$ZodPipe) {
       return _TsTypeNode.fromZodPipe(zodType);
     }
-    if (zodType instanceof import_core.$ZodSuccess) {
+    if (zodType instanceof core.$ZodSuccess) {
       return _TsTypeNode.fromZodSuccess(zodType);
     }
-    if (zodType instanceof import_core.$ZodCatch) {
+    if (zodType instanceof core.$ZodCatch) {
       return _TsTypeNode.fromZodCatch(zodType);
     }
-    if (zodType instanceof import_core.$ZodFile) {
+    if (zodType instanceof core.$ZodFile) {
       return _TsTypeNode.fromZodFile(zodType);
     }
-    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.UnknownKeyword);
+    return typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.UnknownKeyword);
   }
   static fromZodString(_zodString) {
-    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.StringKeyword);
+    return typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.StringKeyword);
   }
   static fromZodNumber(_zodNumber) {
-    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.NumberKeyword);
+    return typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.NumberKeyword);
   }
   static fromZodBigInt(_zodBigInt) {
-    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.BigIntKeyword);
+    return typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.BigIntKeyword);
   }
   static fromZodBoolean(_zodBoolean) {
-    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.BooleanKeyword);
+    return typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.BooleanKeyword);
   }
   static fromZodDate(_zodDate) {
-    return import_typescript.factory.createTypeReferenceNode(import_typescript.factory.createIdentifier("Date"));
+    return typescript.factory.createTypeReferenceNode(typescript.factory.createIdentifier("Date"));
   }
   static fromZodSymbol(_zodSymbol) {
-    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.SymbolKeyword);
+    return typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.SymbolKeyword);
   }
   static fromZodUndefined(_zodUndefined) {
-    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.UndefinedKeyword);
+    return typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.UndefinedKeyword);
   }
   static fromZodNullable(zodNullable) {
     const innerType = _TsTypeNode.fromZod(zodNullable._zod.def.innerType);
-    return import_typescript.factory.createUnionTypeNode([
+    return typescript.factory.createUnionTypeNode([
       innerType,
-      import_typescript.factory.createLiteralTypeNode(import_typescript.factory.createNull())
+      typescript.factory.createLiteralTypeNode(typescript.factory.createNull())
     ]);
   }
   static fromZodNull(_zodNull) {
-    return import_typescript.factory.createLiteralTypeNode(import_typescript.factory.createNull());
+    return typescript.factory.createLiteralTypeNode(typescript.factory.createNull());
   }
   static fromZodAny(_zodAny) {
-    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.AnyKeyword);
+    return typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.AnyKeyword);
   }
   static fromZodUnknown(_zodUnknown) {
-    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.UnknownKeyword);
+    return typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.UnknownKeyword);
   }
   static fromZodNever(_zodNever) {
-    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.NeverKeyword);
+    return typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.NeverKeyword);
   }
   static fromZodVoid(_zodVoid) {
-    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.VoidKeyword);
+    return typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.VoidKeyword);
   }
   static fromZodArray(zodArray) {
     const innerType = _TsTypeNode.fromZod(zodArray._zod.def.element);
-    return import_typescript.factory.createArrayTypeNode(innerType);
+    return typescript.factory.createArrayTypeNode(innerType);
   }
   static fromZodObject(zodObject) {
     const entries = Object.entries(zodObject._zod.def.shape);
@@ -207,33 +183,33 @@ var TsTypeNode = class _TsTypeNode {
       }
       const { type: nextZodNodeTypeName } = nextZodNode._zod?.def ?? {};
       const isOptional = nextZodNodeTypeName === "optional";
-      const propertySignature = import_typescript.factory.createPropertySignature(
+      const propertySignature = typescript.factory.createPropertySignature(
         void 0,
         _TsTypeNode.createTsAstPropertyKey(key),
-        isOptional ? import_typescript.factory.createToken(import_typescript.SyntaxKind.QuestionToken) : void 0,
+        isOptional ? typescript.factory.createToken(typescript.SyntaxKind.QuestionToken) : void 0,
         type
       );
       return propertySignature;
     });
-    return import_typescript.factory.createTypeLiteralNode(members);
+    return typescript.factory.createTypeLiteralNode(members);
   }
   static fromZodUnion(zodUnion) {
     const options = zodUnion._zod.def.options.map(_TsTypeNode.fromZod);
-    return import_typescript.factory.createUnionTypeNode(options);
+    return 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]);
+    return typescript.factory.createIntersectionTypeNode([left, right]);
   }
   static fromZodTuple(zodTuple) {
     const elements = zodTuple._zod.def.items.map(_TsTypeNode.fromZod);
-    return import_typescript.factory.createTupleTypeNode(elements);
+    return 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"), [
+    return typescript.factory.createTypeReferenceNode(typescript.factory.createIdentifier("Record"), [
       keyType,
       valueType
     ]);
@@ -241,14 +217,14 @@ var TsTypeNode = class _TsTypeNode {
   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"), [
+    return typescript.factory.createTypeReferenceNode(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"), [
+    return typescript.factory.createTypeReferenceNode(typescript.factory.createIdentifier("Set"), [
       innerType
     ]);
   }
@@ -258,58 +234,58 @@ var TsTypeNode = class _TsTypeNode {
     }
     const value = zodLiteral._zod.def.values[0];
     if (typeof value === "string") {
-      return import_typescript.factory.createLiteralTypeNode(import_typescript.factory.createStringLiteral(value));
+      return typescript.factory.createLiteralTypeNode(typescript.factory.createStringLiteral(value));
     }
     if (typeof value === "number") {
-      return import_typescript.factory.createLiteralTypeNode(import_typescript.factory.createNumericLiteral(value));
+      return typescript.factory.createLiteralTypeNode(typescript.factory.createNumericLiteral(value));
     }
     if (typeof value === "boolean") {
-      return import_typescript.factory.createLiteralTypeNode(
-        value ? import_typescript.factory.createTrue() : import_typescript.factory.createFalse()
+      return typescript.factory.createLiteralTypeNode(
+        value ? typescript.factory.createTrue() : typescript.factory.createFalse()
       );
     }
     if (typeof value === "bigint") {
-      return import_typescript.factory.createLiteralTypeNode(
-        import_typescript.factory.createBigIntLiteral(value.toString())
+      return typescript.factory.createLiteralTypeNode(
+        typescript.factory.createBigIntLiteral(value.toString())
       );
     }
     if (value === null) {
-      return import_typescript.factory.createLiteralTypeNode(import_typescript.factory.createNull());
+      return typescript.factory.createLiteralTypeNode(typescript.factory.createNull());
     }
     if (value === void 0) {
-      return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.UndefinedKeyword);
+      return typescript.factory.createKeywordTypeNode(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 typescript.factory.createLiteralTypeNode(typescript.factory.createStringLiteral(key));
     });
-    return import_typescript.factory.createUnionTypeNode(types);
+    return 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"),
+    return typescript.factory.createTypeReferenceNode(
+      typescript.factory.createIdentifier("Promise"),
       [innerType]
     );
   }
   static fromZodLazy(_zodLazy) {
-    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.UnknownKeyword);
+    return typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.UnknownKeyword);
   }
   static fromZodOptional(zodOptional) {
     const innerType = _TsTypeNode.fromZod(zodOptional._zod.def.innerType);
-    return import_typescript.factory.createUnionTypeNode([
+    return typescript.factory.createUnionTypeNode([
       innerType,
-      import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.UndefinedKeyword)
+      typescript.factory.createKeywordTypeNode(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) {
+      if (node.kind !== typescript.SyntaxKind.UndefinedKeyword) {
         filteredNodes.push(node);
       }
     });
@@ -317,34 +293,34 @@ var TsTypeNode = class _TsTypeNode {
     return innerType;
   }
   static fromZodTemplateLiteral(_zodTemplateLiteral) {
-    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.UnknownKeyword);
+    return typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.UnknownKeyword);
   }
   static fromZodCustom(_zodCustom) {
-    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.UnknownKeyword);
+    return typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.UnknownKeyword);
   }
   static fromZodTransform(_zodTransform) {
-    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.UnknownKeyword);
+    return typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.UnknownKeyword);
   }
   static fromZodNonOptional(_zodNonOptional) {
-    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.UnknownKeyword);
+    return typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.UnknownKeyword);
   }
   static fromZodReadonly(_zodReadonly) {
-    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.UnknownKeyword);
+    return typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.UnknownKeyword);
   }
   static fromZodNaN(_zodNaN) {
-    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.UnknownKeyword);
+    return typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.UnknownKeyword);
   }
   static fromZodPipe(_zodPipe) {
-    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.UnknownKeyword);
+    return typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.UnknownKeyword);
   }
   static fromZodSuccess(_zodSuccess) {
-    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.UnknownKeyword);
+    return typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.UnknownKeyword);
   }
   static fromZodCatch(_zodCatch) {
-    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.UnknownKeyword);
+    return typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.UnknownKeyword);
   }
   static fromZodFile(_zodFile) {
-    return import_typescript.factory.createKeywordTypeNode(import_typescript.SyntaxKind.UnknownKeyword);
+    return typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.UnknownKeyword);
   }
   /**
    * Returns a TypeScript AST node representing the property key.
@@ -356,29 +332,24 @@ var TsTypeNode = class _TsTypeNode {
    */
   static createTsAstPropertyKey(key) {
     if (/^[$A-Z_a-z][\w$]*$/.test(key)) {
-      return import_typescript.factory.createIdentifier(key);
+      return typescript.factory.createIdentifier(key);
     }
-    return import_typescript.factory.createStringLiteral(key);
+    return typescript.factory.createStringLiteral(key);
   }
 };
-
-// src/TsTypePrinter.ts
-var import_typescript2 = require("typescript");
 var TsTypePrinter = class {
   static print(tsType) {
-    const sourceFile = (0, import_typescript2.createSourceFile)(
+    const sourceFile = typescript.createSourceFile(
       "print.ts",
       "",
-      import_typescript2.ScriptTarget.Latest,
+      typescript.ScriptTarget.Latest,
       false,
-      import_typescript2.ScriptKind.TS
+      typescript.ScriptKind.TS
     );
-    const printer = (0, import_typescript2.createPrinter)();
-    return printer.printNode(import_typescript2.EmitHint.Unspecified, tsType, sourceFile);
+    const printer = typescript.createPrinter();
+    return printer.printNode(typescript.EmitHint.Unspecified, tsType, sourceFile);
   }
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  TsTypeNode,
-  TsTypePrinter
-});
+
+exports.TsTypeNode = TsTypeNode;
+exports.TsTypePrinter = TsTypePrinter;

package/dist/index.js

@@ -1,44 +1,7 @@
+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';
+
 // 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) {
@@ -372,15 +335,6 @@ var TsTypeNode = class _TsTypeNode {
     return factory.createStringLiteral(key);
   }
 };
-
-// src/TsTypePrinter.ts
-import {
-  createPrinter,
-  createSourceFile,
-  EmitHint,
-  ScriptKind,
-  ScriptTarget
-} from "typescript";
 var TsTypePrinter = class {
   static print(tsType) {
     const sourceFile = createSourceFile(
@@ -394,7 +348,5 @@ var TsTypePrinter = class {
     return printer.printNode(EmitHint.Unspecified, tsType, sourceFile);
   }
 };
-export {
-  TsTypeNode,
-  TsTypePrinter
-};
+
+export { TsTypeNode, TsTypePrinter };

package/dist/metafile-cjs.json

@@ -0,0 +1 @@
+{"inputs":{"../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.6_tsx@4.21.0_typescript@5.9.3/node_modules/tsup/assets/cjs_shims.js":{"bytes":569,"imports":[],"format":"esm"},"src/TsTypeGenerator.ts":{"bytes":14164,"imports":[{"path":"typescript","kind":"import-statement","external":true},{"path":"zod/v4/core","kind":"import-statement","external":true},{"path":"/home/runner/work/typeweaver/typeweaver/node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.6_tsx@4.21.0_typescript@5.9.3/node_modules/tsup/assets/cjs_shims.js","kind":"import-statement","external":true}],"format":"esm"},"src/TsTypePrinter.ts":{"bytes":477,"imports":[{"path":"typescript","kind":"import-statement","external":true},{"path":"/home/runner/work/typeweaver/typeweaver/node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.6_tsx@4.21.0_typescript@5.9.3/node_modules/tsup/assets/cjs_shims.js","kind":"import-statement","external":true}],"format":"esm"},"src/index.ts":{"bytes":68,"imports":[{"path":"src/TsTypeGenerator.ts","kind":"import-statement","original":"./TsTypeGenerator"},{"path":"src/TsTypePrinter.ts","kind":"import-statement","original":"./TsTypePrinter"},{"path":"/home/runner/work/typeweaver/typeweaver/node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.6_tsx@4.21.0_typescript@5.9.3/node_modules/tsup/assets/cjs_shims.js","kind":"import-statement","external":true}],"format":"esm"}},"outputs":{"dist/index.cjs":{"imports":[{"path":"typescript","kind":"import-statement","external":true},{"path":"zod/v4/core","kind":"import-statement","external":true},{"path":"typescript","kind":"import-statement","external":true}],"exports":["TsTypeNode","TsTypePrinter"],"entryPoint":"src/index.ts","inputs":{"src/TsTypeGenerator.ts":{"bytesInOutput":12275},"src/index.ts":{"bytesInOutput":0},"src/TsTypePrinter.ts":{"bytesInOutput":413}},"bytes":12781}}}

package/dist/metafile-esm.json

@@ -0,0 +1 @@
+{"inputs":{"../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.6_tsx@4.21.0_typescript@5.9.3/node_modules/tsup/assets/esm_shims.js":{"bytes":322,"imports":[{"path":"node:path","kind":"import-statement","external":true},{"path":"node:url","kind":"import-statement","external":true}],"format":"esm"},"src/TsTypeGenerator.ts":{"bytes":14164,"imports":[{"path":"typescript","kind":"import-statement","external":true},{"path":"zod/v4/core","kind":"import-statement","external":true},{"path":"/home/runner/work/typeweaver/typeweaver/node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.6_tsx@4.21.0_typescript@5.9.3/node_modules/tsup/assets/esm_shims.js","kind":"import-statement","external":true}],"format":"esm"},"src/TsTypePrinter.ts":{"bytes":477,"imports":[{"path":"typescript","kind":"import-statement","external":true},{"path":"/home/runner/work/typeweaver/typeweaver/node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.6_tsx@4.21.0_typescript@5.9.3/node_modules/tsup/assets/esm_shims.js","kind":"import-statement","external":true}],"format":"esm"},"src/index.ts":{"bytes":68,"imports":[{"path":"src/TsTypeGenerator.ts","kind":"import-statement","original":"./TsTypeGenerator"},{"path":"src/TsTypePrinter.ts","kind":"import-statement","original":"./TsTypePrinter"},{"path":"/home/runner/work/typeweaver/typeweaver/node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.6_tsx@4.21.0_typescript@5.9.3/node_modules/tsup/assets/esm_shims.js","kind":"import-statement","external":true}],"format":"esm"}},"outputs":{"dist/index.js":{"imports":[{"path":"typescript","kind":"import-statement","external":true},{"path":"zod/v4/core","kind":"import-statement","external":true},{"path":"typescript","kind":"import-statement","external":true}],"exports":["TsTypeNode","TsTypePrinter"],"entryPoint":"src/index.ts","inputs":{"src/TsTypeGenerator.ts":{"bytesInOutput":12275},"src/index.ts":{"bytesInOutput":0},"src/TsTypePrinter.ts":{"bytesInOutput":413}},"bytes":12781}}}

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@rexeus/typeweaver-zod-to-ts",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "Transforms Zod v4 schemas into precise TypeScript shapes. Powered by Typeweaver 🧵✨",
   "type": "module",
+  "sideEffects": false,
   "main": "dist/index.cjs",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -48,10 +49,10 @@
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "zod": "^4.3.5"
+    "zod": "^4.3.0"
   },
   "devDependencies": {
-    "zod": "^4.3.5"
+    "zod": "^4.3.6"
   },
   "scripts": {
     "typecheck": "tsc --noEmit",