zodvex 0.7.1-beta.3 → 0.7.1-beta.4

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,7 +470,8 @@ function transformImports(file) {
 }
 function transformClassRefs(file) {
   let count = 0;
-  const neededImports = /* @__PURE__ */ new Set();
+  const runtimeImports = /* @__PURE__ */ new Set();
+  const typeOnlyImports = /* @__PURE__ */ new Set();
   const propAccesses = file.getDescendantsOfKind(SyntaxKind.PropertyAccessExpression);
   for (const pa of propAccesses) {
     if (pa.wasForgotten()) continue;
@@ -414,7 +479,7 @@ function transformClassRefs(file) {
     const replacement = CLASS_RENAMES[text];
     if (!replacement) continue;
     pa.replaceWithText(replacement);
-    neededImports.add(replacement);
+    runtimeImports.add(replacement);
     count++;
   }
   const qualNames = file.getDescendantsOfKind(SyntaxKind.QualifiedName);
@@ -424,33 +489,59 @@ function transformClassRefs(file) {
     const replacement = CLASS_RENAMES[text];
     if (!replacement) continue;
     qn.replaceWithText(replacement);
-    neededImports.add(replacement);
+    if (!runtimeImports.has(replacement)) {
+      typeOnlyImports.add(replacement);
+    }
     count++;
   }
-  if (neededImports.size > 0) {
+  for (const name of runtimeImports) {
+    typeOnlyImports.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 (runtimeImports.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, runtimeImports);
     } 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, runtimeImports);
+      } else {
+        file.addImportDeclaration({
+          moduleSpecifier: "zod/v4/core",
+          namedImports: [...runtimeImports].sort()
+        });
+      }
+    }
+  }
+  if (typeOnlyImports.size > 0) {
+    const existingTypeImport = file.getImportDeclaration(
+      (d) => d.getModuleSpecifierValue() === "zod/v4/core" && d.isTypeOnly()
+    );
+    if (existingTypeImport) {
+      addToExistingImport(existingTypeImport, typeOnlyImports);
+    } else {
+      const internalTypeImport = file.getImportDeclaration(
+        (d) => d.getModuleSpecifierValue().endsWith("/zod-core") && d.isTypeOnly()
+      );
+      if (internalTypeImport) {
+        addToExistingImport(internalTypeImport, typeOnlyImports);
       } else {
         file.addImportDeclaration({
           moduleSpecifier: "zod/v4/core",
-          namedImports: [...neededImports].sort()
+          namedImports: [...typeOnlyImports].sort(),
+          isTypeOnly: true
         });
       }
     }
@@ -463,19 +554,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 +578,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 +611,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, CLASS_RENAMES;
 var init_transforms = __esm({
   "../zod-to-mini/src/transforms.ts"() {
     WRAPPER_METHODS = ["optional", "nullable"];
@@ -560,7 +657,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,6 +668,11 @@ 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
@@ -598,7 +700,8 @@ var init_transforms = __esm({
       "z.ZodDiscriminatedUnion": "$ZodDiscriminatedUnion",
       "z.ZodLazy": "$ZodLazy",
       "z.ZodPipe": "$ZodPipe",
-      "z.ZodTransform": "$ZodTransform"
+      "z.ZodTransform": "$ZodTransform",
+      "z.ZodReadonly": "$ZodReadonly"
     };
   }
 });