zodvex 0.7.1-beta.3 → 0.7.1-beta.5

package/dist/cli/index.js

@@ -341,6 +341,11 @@ function transformMethods(file, typeChecker) {
       count++;
       continue;
     }
+    if (method === "unwrap" && call.getArguments().length === 0) {
+      call.replaceWithText(`${obj}._zod.def.innerType`);
+      count++;
+      continue;
+    }
     if (CHECK_WRAP_METHODS.includes(method)) {
       const argsStr = args.join(", ");
       call.replaceWithText(`${obj}.check(z.${method}(${argsStr}))`);
@@ -378,6 +383,65 @@ function transformConstructorReplacements(file) {
   }
   return count;
 }
+function isZodSchemaByTypePA(pa, typeChecker) {
+  const receiver = pa.getExpression();
+  try {
+    const type = typeChecker.getTypeAtLocation(receiver);
+    if (type.isAny()) return null;
+    return type.getProperties().some((p) => p.getName() === "_zod");
+  } catch {
+    return null;
+  }
+}
+function transformPropertyAccessors(file, typeChecker) {
+  let count = 0;
+  const propAccesses = file.getDescendantsOfKind(SyntaxKind.PropertyAccessExpression).reverse();
+  for (const pa of propAccesses) {
+    if (pa.wasForgotten()) continue;
+    const propName = pa.getName();
+    const replacement = INTERNAL_PROPERTY_ACCESSORS[propName];
+    if (!replacement) continue;
+    const receiver = pa.getExpression();
+    const receiverText = receiver.getText();
+    if (NAMESPACE_IDENTIFIERS.has(receiverText.trim())) continue;
+    if (receiverText.includes("._zod.def.") || receiverText.endsWith("._zod.def")) continue;
+    let isSchema;
+    if (typeChecker) {
+      const typeResult = isZodSchemaByTypePA(pa, typeChecker);
+      isSchema = typeResult === true || typeResult === null && isLikelySchemaExpr(receiverText);
+    } else {
+      isSchema = isLikelySchemaExpr(receiverText);
+    }
+    if (!isSchema) continue;
+    pa.replaceWithText(`${receiverText}.${replacement}`);
+    count++;
+  }
+  return count;
+}
+function findInternalPropertyAccess(file, typeChecker) {
+  const results = [];
+  const propAccesses = file.getDescendantsOfKind(SyntaxKind.PropertyAccessExpression);
+  for (const pa of propAccesses) {
+    if (pa.wasForgotten()) continue;
+    const propName = pa.getName();
+    if (!(propName in INTERNAL_PROPERTY_ACCESSORS)) continue;
+    const receiver = pa.getExpression();
+    const receiverText = receiver.getText();
+    if (NAMESPACE_IDENTIFIERS.has(receiverText.trim())) continue;
+    if (receiverText.includes("._zod.def.") || receiverText.endsWith("._zod.def")) continue;
+    if (isLikelySchemaExpr(receiverText)) continue;
+    if (typeChecker) {
+      const typeResult = isZodSchemaByTypePA(pa, typeChecker);
+      if (typeResult === false) continue;
+    }
+    results.push({
+      line: pa.getStartLineNumber(),
+      property: propName,
+      text: pa.getText().slice(0, 80)
+    });
+  }
+  return results;
+}
 function findObjectOnlyMethods(file) {
   const results = [];
   const calls = file.getDescendantsOfKind(SyntaxKind.CallExpression);
@@ -406,51 +470,92 @@ function transformImports(file) {
 }
 function transformClassRefs(file) {
   let count = 0;
-  const neededImports = /* @__PURE__ */ new Set();
+  const runtimeCoreImports = /* @__PURE__ */ new Set();
+  const typeOnlyCoreImports = /* @__PURE__ */ new Set();
   const propAccesses = file.getDescendantsOfKind(SyntaxKind.PropertyAccessExpression);
   for (const pa of propAccesses) {
     if (pa.wasForgotten()) continue;
     const text = pa.getText();
-    const replacement = CLASS_RENAMES[text];
-    if (!replacement) continue;
-    pa.replaceWithText(replacement);
-    neededImports.add(replacement);
-    count++;
+    const miniReplacement = MINI_CLASS_RENAMES[text];
+    if (miniReplacement) {
+      pa.replaceWithText(miniReplacement);
+      count++;
+      continue;
+    }
+    const coreReplacement = CORE_CLASS_RENAMES[text];
+    if (coreReplacement) {
+      pa.replaceWithText(coreReplacement);
+      runtimeCoreImports.add(coreReplacement);
+      count++;
+    }
   }
   const qualNames = file.getDescendantsOfKind(SyntaxKind.QualifiedName);
   for (const qn of qualNames) {
     if (qn.wasForgotten()) continue;
     const text = qn.getText();
-    const replacement = CLASS_RENAMES[text];
-    if (!replacement) continue;
-    qn.replaceWithText(replacement);
-    neededImports.add(replacement);
-    count++;
+    const miniReplacement = MINI_CLASS_RENAMES[text];
+    if (miniReplacement) {
+      qn.replaceWithText(miniReplacement);
+      count++;
+      continue;
+    }
+    const coreReplacement = CORE_CLASS_RENAMES[text];
+    if (coreReplacement) {
+      qn.replaceWithText(coreReplacement);
+      if (!runtimeCoreImports.has(coreReplacement)) {
+        typeOnlyCoreImports.add(coreReplacement);
+      }
+      count++;
+    }
   }
-  if (neededImports.size > 0) {
+  for (const name of runtimeCoreImports) {
+    typeOnlyCoreImports.delete(name);
+  }
+  const addToExistingImport = (imp, names) => {
+    if (!imp) return;
+    for (const name of names) {
+      if (!imp.getNamedImports().some((n) => n.getName() === name)) {
+        imp.addNamedImport(name);
+      }
+    }
+  };
+  if (runtimeCoreImports.size > 0) {
     const existingCoreImport = file.getImportDeclaration(
-      (d) => d.getModuleSpecifierValue() === "zod/v4/core"
+      (d) => d.getModuleSpecifierValue() === "zod/v4/core" && !d.isTypeOnly()
     );
     if (existingCoreImport) {
-      for (const name of neededImports) {
-        if (!existingCoreImport.getNamedImports().some((n) => n.getName() === name)) {
-          existingCoreImport.addNamedImport(name);
-        }
-      }
+      addToExistingImport(existingCoreImport, runtimeCoreImports);
     } else {
       const internalImport = file.getImportDeclaration(
-        (d) => d.getModuleSpecifierValue().endsWith("/zod-core")
+        (d) => d.getModuleSpecifierValue().endsWith("/zod-core") && !d.isTypeOnly()
       );
       if (internalImport) {
-        for (const name of neededImports) {
-          if (!internalImport.getNamedImports().some((n) => n.getName() === name)) {
-            internalImport.addNamedImport(name);
-          }
-        }
+        addToExistingImport(internalImport, runtimeCoreImports);
+      } else {
+        file.addImportDeclaration({
+          moduleSpecifier: "zod/v4/core",
+          namedImports: [...runtimeCoreImports].sort()
+        });
+      }
+    }
+  }
+  if (typeOnlyCoreImports.size > 0) {
+    const existingTypeImport = file.getImportDeclaration(
+      (d) => d.getModuleSpecifierValue() === "zod/v4/core" && d.isTypeOnly()
+    );
+    if (existingTypeImport) {
+      addToExistingImport(existingTypeImport, typeOnlyCoreImports);
+    } else {
+      const internalTypeImport = file.getImportDeclaration(
+        (d) => d.getModuleSpecifierValue().endsWith("/zod-core") && d.isTypeOnly()
+      );
+      if (internalTypeImport) {
+        addToExistingImport(internalTypeImport, typeOnlyCoreImports);
       } else {
         file.addImportDeclaration({
           moduleSpecifier: "zod/v4/core",
-          namedImports: [...neededImports].sort()
+          namedImports: [...typeOnlyCoreImports].sort(),
+          isTypeOnly: true
         });
       }
     }
@@ -463,19 +568,23 @@ function transformFile(file, typeChecker) {
   let wrappers = 0;
   let checks = 0;
   let methods = 0;
+  let propertyAccessors = 0;
   for (let i = 0; i < 10; i++) {
     const cr = transformConstructorReplacements(file);
     const w = transformWrappers(file);
     const c = transformChecks(file);
     const m = transformMethods(file, typeChecker);
+    const pa = transformPropertyAccessors(file, typeChecker);
     constructorReplacements += cr;
     wrappers += w;
     checks += c;
     methods += m;
-    if (cr + w + c + m === 0) break;
+    propertyAccessors += pa;
+    if (cr + w + c + m + pa === 0) break;
   }
   const classRefs = transformClassRefs(file);
   const objectOnlyWarnings = findObjectOnlyMethods(file);
+  const propertyAccessWarnings = findInternalPropertyAccess(file, typeChecker);
   const imports = 0;
   return {
     filePath,
@@ -483,10 +592,12 @@ function transformFile(file, typeChecker) {
     wrappers,
     checks,
     methods,
+    propertyAccessors,
     imports,
     classRefs,
     objectOnlyWarnings,
-    totalChanges: constructorReplacements + wrappers + checks + methods + classRefs
+    propertyAccessWarnings,
+    totalChanges: constructorReplacements + wrappers + checks + methods + propertyAccessors + classRefs
   };
 }
 function transformCode(code, options) {
@@ -514,7 +625,7 @@ function transformCode(code, options) {
     return { code, changed: false };
   }
 }
-var WRAPPER_METHODS, NAMESPACE_IDENTIFIERS, ZOD_ONLY_CHECK_METHODS, AMBIGUOUS_CHECK_METHODS, STRING_RENAME, NUMBER_RENAME, UNCONDITIONAL_TOP_LEVEL, AMBIGUOUS_TOP_LEVEL, RENAMED_METHODS, TRANSFORM_METHOD, CHECK_WRAP_METHODS, CONSTRUCTOR_REPLACEMENTS, WARN_METHODS, CLASS_RENAMES;
+var WRAPPER_METHODS, NAMESPACE_IDENTIFIERS, ZOD_ONLY_CHECK_METHODS, AMBIGUOUS_CHECK_METHODS, STRING_RENAME, NUMBER_RENAME, UNCONDITIONAL_TOP_LEVEL, AMBIGUOUS_TOP_LEVEL, RENAMED_METHODS, TRANSFORM_METHOD, CHECK_WRAP_METHODS, CONSTRUCTOR_REPLACEMENTS, INTERNAL_PROPERTY_ACCESSORS, WARN_METHODS, MINI_CLASS_RENAMES, CORE_CLASS_RENAMES;
 var init_transforms = __esm({
   "../zod-to-mini/src/transforms.ts"() {
     WRAPPER_METHODS = ["optional", "nullable"];
@@ -560,7 +671,7 @@ var init_transforms = __esm({
       min: "gte",
       max: "lte"
     };
-    UNCONDITIONAL_TOP_LEVEL = ["pipe", "brand"];
+    UNCONDITIONAL_TOP_LEVEL = ["pipe", "brand", "parse", "safeParse"];
     AMBIGUOUS_TOP_LEVEL = ["partial", "extend", "catchall", "omit", "pick"];
     RENAMED_METHODS = /* @__PURE__ */ new Map([
       ["default", "_default"]
@@ -571,34 +682,42 @@ var init_transforms = __esm({
       passthrough: "looseObject",
       strict: "strictObject"
     };
+    INTERNAL_PROPERTY_ACCESSORS = {
+      shape: "_zod.def.shape",
+      element: "_zod.def.element",
+      options: "_zod.def.options"
+    };
     WARN_METHODS = [
       "merge"
       // use z.extend() or spread
     ];
-    CLASS_RENAMES = {
+    MINI_CLASS_RENAMES = {
+      "z.ZodType": "z.ZodMiniType",
+      "z.ZodTypeAny": "z.ZodMiniType",
+      "z.ZodObject": "z.ZodMiniObject",
+      "z.ZodArray": "z.ZodMiniArray",
+      "z.ZodString": "z.ZodMiniString",
+      "z.ZodNumber": "z.ZodMiniNumber",
+      "z.ZodBoolean": "z.ZodMiniBoolean",
+      "z.ZodOptional": "z.ZodMiniOptional",
+      "z.ZodNullable": "z.ZodMiniNullable",
+      "z.ZodUnion": "z.ZodMiniUnion",
+      "z.ZodEnum": "z.ZodMiniEnum",
+      "z.ZodLiteral": "z.ZodMiniLiteral",
+      "z.ZodCodec": "z.ZodMiniCodec",
+      "z.ZodCustom": "z.ZodMiniCustom",
+      "z.ZodDefault": "z.ZodMiniDefault",
+      "z.ZodRecord": "z.ZodMiniRecord",
+      "z.ZodTuple": "z.ZodMiniTuple",
+      "z.ZodDiscriminatedUnion": "z.ZodMiniDiscriminatedUnion",
+      "z.ZodLazy": "z.ZodMiniLazy",
+      "z.ZodPipe": "z.ZodMiniPipe",
+      "z.ZodTransform": "z.ZodMiniTransform",
+      "z.ZodReadonly": "z.ZodMiniReadonly"
+    };
+    CORE_CLASS_RENAMES = {
       "z.ZodError": "$ZodError",
-      "z.ZodType": "$ZodType",
-      "z.ZodTypeAny": "$ZodType",
-      "z.ZodRawShape": "$ZodShape",
-      "z.ZodObject": "$ZodObject",
-      "z.ZodArray": "$ZodArray",
-      "z.ZodString": "$ZodString",
-      "z.ZodNumber": "$ZodNumber",
-      "z.ZodBoolean": "$ZodBoolean",
-      "z.ZodOptional": "$ZodOptional",
-      "z.ZodNullable": "$ZodNullable",
-      "z.ZodUnion": "$ZodUnion",
-      "z.ZodEnum": "$ZodEnum",
-      "z.ZodLiteral": "$ZodLiteral",
-      "z.ZodCodec": "$ZodCodec",
-      "z.ZodCustom": "$ZodCustom",
-      "z.ZodDefault": "$ZodDefault",
-      "z.ZodRecord": "$ZodRecord",
-      "z.ZodTuple": "$ZodTuple",
-      "z.ZodDiscriminatedUnion": "$ZodDiscriminatedUnion",
-      "z.ZodLazy": "$ZodLazy",
-      "z.ZodPipe": "$ZodPipe",
-      "z.ZodTransform": "$ZodTransform"
+      "z.ZodRawShape": "$ZodShape"
     };
   }
 });