@schemashift/zod-valibot 0.8.0 → 0.10.0

package/dist/index.d.cts

@@ -55,4 +55,71 @@ declare class ZodToValibotTransformer {
     private transformCallChainFallback;
 }
 
-export { FACTORY_MAPPINGS, MODIFIER_METHODS, NUMBER_VALIDATION_MAPPINGS, OBJECT_METHODS, VALIDATION_MAPPINGS, ZodToValibotTransformer, createZodToValibotHandler };
+declare function createValibotToZodHandler(): TransformHandler;
+
+/**
+ * Valibot → Zod transformer.
+ *
+ * Converts Valibot's pipe-based API back to Zod's fluent method chain API.
+ * Uses AST-based import handling for safety, with text-based pipe expression
+ * transformation for the complex pipe-to-chain conversions.
+ *
+ * Valibot: v.pipe(v.string(), v.email(), v.minLength(5), v.maxLength(100))
+ * Zod:     z.string().email().min(5).max(100)
+ *
+ * Valibot: v.optional(v.string())
+ * Zod:     z.string().optional()
+ *
+ * Valibot: v.partial(v.object({ name: v.string() }))
+ * Zod:     z.object({ name: z.string() }).partial()
+ */
+declare class ValibotToZodTransformer {
+    private errors;
+    private warnings;
+    private stringLiteralRanges;
+    private commentRanges;
+    transform(sourceFile: SourceFile): TransformResult;
+    /**
+     * Collect string literal and comment ranges from the AST
+     * so text-based transforms can avoid modifying them.
+     */
+    private collectProtectedRanges;
+    /**
+     * Check if a position is inside a protected range (string literal or comment).
+     */
+    private isProtected;
+    /**
+     * AST-based import transformation.
+     * Replaces valibot imports with zod imports using the AST.
+     */
+    private transformImportsAST;
+    private transformTypeHelpers;
+    /**
+     * Transform Valibot wrapper functions to Zod method chains.
+     * v.optional(schema) → schema.optional()
+     * v.nullable(schema) → schema.nullable()
+     * v.nullish(schema) → schema.nullish()
+     * v.readonly(schema) → schema.readonly()
+     * v.partial(schema) → schema.partial()
+     * v.required(schema) → schema.required()
+     */
+    private transformWrappers;
+    /**
+     * Replace wrapper calls using balanced parenthesis matching.
+     * Skips matches inside string literals and comments.
+     */
+    private replaceWrapperCall;
+    /**
+     * Transform v.pipe(factory, ...validators) to factory.validator1().validator2()
+     * Skips matches inside string literals and comments.
+     */
+    private transformPipeExpressions;
+    /**
+     * Split arguments at top-level commas (not inside nested parens/brackets/braces).
+     */
+    private splitTopLevelArgs;
+    private convertPipeValidator;
+    private transformFactories;
+}
+
+export { FACTORY_MAPPINGS, MODIFIER_METHODS, NUMBER_VALIDATION_MAPPINGS, OBJECT_METHODS, VALIDATION_MAPPINGS, ValibotToZodTransformer, ZodToValibotTransformer, createValibotToZodHandler, createZodToValibotHandler };

package/dist/index.d.ts

@@ -55,4 +55,71 @@ declare class ZodToValibotTransformer {
     private transformCallChainFallback;
 }
 
-export { FACTORY_MAPPINGS, MODIFIER_METHODS, NUMBER_VALIDATION_MAPPINGS, OBJECT_METHODS, VALIDATION_MAPPINGS, ZodToValibotTransformer, createZodToValibotHandler };
+declare function createValibotToZodHandler(): TransformHandler;
+
+/**
+ * Valibot → Zod transformer.
+ *
+ * Converts Valibot's pipe-based API back to Zod's fluent method chain API.
+ * Uses AST-based import handling for safety, with text-based pipe expression
+ * transformation for the complex pipe-to-chain conversions.
+ *
+ * Valibot: v.pipe(v.string(), v.email(), v.minLength(5), v.maxLength(100))
+ * Zod:     z.string().email().min(5).max(100)
+ *
+ * Valibot: v.optional(v.string())
+ * Zod:     z.string().optional()
+ *
+ * Valibot: v.partial(v.object({ name: v.string() }))
+ * Zod:     z.object({ name: z.string() }).partial()
+ */
+declare class ValibotToZodTransformer {
+    private errors;
+    private warnings;
+    private stringLiteralRanges;
+    private commentRanges;
+    transform(sourceFile: SourceFile): TransformResult;
+    /**
+     * Collect string literal and comment ranges from the AST
+     * so text-based transforms can avoid modifying them.
+     */
+    private collectProtectedRanges;
+    /**
+     * Check if a position is inside a protected range (string literal or comment).
+     */
+    private isProtected;
+    /**
+     * AST-based import transformation.
+     * Replaces valibot imports with zod imports using the AST.
+     */
+    private transformImportsAST;
+    private transformTypeHelpers;
+    /**
+     * Transform Valibot wrapper functions to Zod method chains.
+     * v.optional(schema) → schema.optional()
+     * v.nullable(schema) → schema.nullable()
+     * v.nullish(schema) → schema.nullish()
+     * v.readonly(schema) → schema.readonly()
+     * v.partial(schema) → schema.partial()
+     * v.required(schema) → schema.required()
+     */
+    private transformWrappers;
+    /**
+     * Replace wrapper calls using balanced parenthesis matching.
+     * Skips matches inside string literals and comments.
+     */
+    private replaceWrapperCall;
+    /**
+     * Transform v.pipe(factory, ...validators) to factory.validator1().validator2()
+     * Skips matches inside string literals and comments.
+     */
+    private transformPipeExpressions;
+    /**
+     * Split arguments at top-level commas (not inside nested parens/brackets/braces).
+     */
+    private splitTopLevelArgs;
+    private convertPipeValidator;
+    private transformFactories;
+}
+
+export { FACTORY_MAPPINGS, MODIFIER_METHODS, NUMBER_VALIDATION_MAPPINGS, OBJECT_METHODS, VALIDATION_MAPPINGS, ValibotToZodTransformer, ZodToValibotTransformer, createValibotToZodHandler, createZodToValibotHandler };

package/dist/index.js

@@ -443,13 +443,372 @@ function createZodToValibotHandler() {
     }
   };
 }
+
+// src/valibot-to-zod-transformer.ts
+import { SyntaxKind } from "ts-morph";
+var VALIBOT_TO_ZOD_FACTORY = {
+  "v.string": "z.string",
+  "v.number": "z.number",
+  "v.boolean": "z.boolean",
+  "v.date": "z.date",
+  "v.bigint": "z.bigint",
+  "v.symbol": "z.symbol",
+  "v.undefined_": "z.undefined",
+  "v.null_": "z.null",
+  "v.void_": "z.void",
+  "v.any": "z.any",
+  "v.unknown": "z.unknown",
+  "v.never": "z.never",
+  "v.nan": "z.nan",
+  "v.literal": "z.literal",
+  "v.picklist": "z.enum",
+  "v.enum_": "z.nativeEnum",
+  "v.array": "z.array",
+  "v.object": "z.object",
+  "v.record": "z.record",
+  "v.tuple": "z.tuple",
+  "v.union": "z.union",
+  "v.variant": "z.discriminatedUnion",
+  "v.intersect": "z.intersection",
+  "v.lazy": "z.lazy",
+  "v.promise": "z.promise",
+  "v.instance": "z.instanceof"
+};
+var PIPE_TO_CHAIN = {
+  "v.email": ".email",
+  "v.url": ".url",
+  "v.uuid": ".uuid",
+  "v.cuid2": ".cuid2",
+  "v.ulid": ".ulid",
+  "v.regex": ".regex",
+  "v.ip": ".ip",
+  "v.isoDateTime": ".datetime",
+  "v.isoDate": ".date",
+  "v.isoTime": ".time",
+  "v.emoji": ".emoji",
+  "v.includes": ".includes",
+  "v.startsWith": ".startsWith",
+  "v.endsWith": ".endsWith",
+  "v.trim": ".trim",
+  "v.toLowerCase": ".toLowerCase",
+  "v.toUpperCase": ".toUpperCase",
+  "v.minLength": ".min",
+  "v.maxLength": ".max",
+  "v.length": ".length",
+  "v.minValue": ".min",
+  "v.maxValue": ".max",
+  "v.integer": ".int",
+  "v.finite": ".finite",
+  "v.safeInteger": ".safe",
+  "v.multipleOf": ".multipleOf",
+  "v.nonEmpty": ".nonempty"
+};
+var ValibotToZodTransformer = class {
+  errors = [];
+  warnings = [];
+  stringLiteralRanges = [];
+  commentRanges = [];
+  transform(sourceFile) {
+    this.errors = [];
+    this.warnings = [];
+    this.stringLiteralRanges = [];
+    this.commentRanges = [];
+    const filePath = sourceFile.getFilePath();
+    const originalCode = sourceFile.getFullText();
+    try {
+      this.collectProtectedRanges(sourceFile);
+      this.transformImportsAST(sourceFile);
+      let text = sourceFile.getFullText();
+      text = this.transformTypeHelpers(text);
+      text = this.transformWrappers(text);
+      text = this.transformPipeExpressions(text);
+      text = this.transformFactories(text);
+      sourceFile.replaceWithText(text);
+      return {
+        success: this.errors.length === 0,
+        filePath,
+        originalCode,
+        transformedCode: sourceFile.getFullText(),
+        errors: this.errors,
+        warnings: this.warnings
+      };
+    } catch (error) {
+      this.errors.push({
+        message: error instanceof Error ? error.message : "Unknown error"
+      });
+      return {
+        success: false,
+        filePath,
+        originalCode,
+        errors: this.errors,
+        warnings: this.warnings
+      };
+    }
+  }
+  /**
+   * Collect string literal and comment ranges from the AST
+   * so text-based transforms can avoid modifying them.
+   */
+  collectProtectedRanges(sourceFile) {
+    this.stringLiteralRanges = [];
+    this.commentRanges = [];
+    sourceFile.forEachDescendant((node) => {
+      if (node.getKind() === SyntaxKind.StringLiteral || node.getKind() === SyntaxKind.TemplateExpression || node.getKind() === SyntaxKind.NoSubstitutionTemplateLiteral) {
+        this.stringLiteralRanges.push({
+          start: node.getStart(),
+          end: node.getEnd()
+        });
+      }
+    });
+    const text = sourceFile.getFullText();
+    const commentRegex = /\/\/[^\n]*|\/\*[\s\S]*?\*\//g;
+    for (const match of text.matchAll(commentRegex)) {
+      if (match.index !== void 0) {
+        this.commentRanges.push({
+          start: match.index,
+          end: match.index + match[0].length
+        });
+      }
+    }
+  }
+  /**
+   * Check if a position is inside a protected range (string literal or comment).
+   */
+  isProtected(position) {
+    for (const range of this.stringLiteralRanges) {
+      if (position >= range.start && position < range.end) return true;
+    }
+    for (const range of this.commentRanges) {
+      if (position >= range.start && position < range.end) return true;
+    }
+    return false;
+  }
+  /**
+   * AST-based import transformation.
+   * Replaces valibot imports with zod imports using the AST.
+   */
+  transformImportsAST(sourceFile) {
+    const imports = sourceFile.getImportDeclarations();
+    const valibotImports = [];
+    for (const imp of imports) {
+      const moduleSpecifier = imp.getModuleSpecifierValue();
+      if (moduleSpecifier === "valibot") {
+        valibotImports.push(imp);
+      }
+    }
+    for (const imp of valibotImports) {
+      imp.setModuleSpecifier("zod");
+      const namespaceImport = imp.getNamespaceImport();
+      if (namespaceImport) {
+        imp.removeNamespaceImport();
+        imp.addNamedImport("z");
+      } else {
+        const namedImports = imp.getNamedImports();
+        for (const named of namedImports) {
+          named.remove();
+        }
+        imp.addNamedImport("z");
+      }
+    }
+  }
+  transformTypeHelpers(text) {
+    text = text.replace(/\bv\.InferOutput</g, "z.infer<");
+    text = text.replace(/\bv\.InferInput</g, "z.input<");
+    return text;
+  }
+  /**
+   * Transform Valibot wrapper functions to Zod method chains.
+   * v.optional(schema) → schema.optional()
+   * v.nullable(schema) → schema.nullable()
+   * v.nullish(schema) → schema.nullish()
+   * v.readonly(schema) → schema.readonly()
+   * v.partial(schema) → schema.partial()
+   * v.required(schema) → schema.required()
+   */
+  transformWrappers(text) {
+    const twoArgWrappers = [
+      {
+        prefix: "v.optional",
+        transform: (schema, value) => `${schema}.default(${value})`
+      },
+      {
+        prefix: "v.fallback",
+        transform: (schema, value) => `${schema}.catch(${value})`
+      }
+    ];
+    const singleArgWrappers = [
+      { prefix: "v.optional", suffix: ".optional()" },
+      { prefix: "v.nullable", suffix: ".nullable()" },
+      { prefix: "v.nullish", suffix: ".nullish()" },
+      { prefix: "v.readonly", suffix: ".readonly()" },
+      { prefix: "v.partial", suffix: ".partial()" },
+      { prefix: "v.required", suffix: ".required()" },
+      { prefix: "v.strict", suffix: ".strict()" }
+    ];
+    for (const { prefix, transform } of twoArgWrappers) {
+      text = this.replaceWrapperCall(text, prefix, (args) => {
+        if (args.length >= 2) {
+          return transform(args[0] ?? "", args[1] ?? "");
+        }
+        return null;
+      });
+    }
+    for (const { prefix, suffix } of singleArgWrappers) {
+      text = this.replaceWrapperCall(text, prefix, (args) => {
+        if (args.length === 1) {
+          return `${args[0] ?? ""}${suffix}`;
+        }
+        return null;
+      });
+    }
+    return text;
+  }
+  /**
+   * Replace wrapper calls using balanced parenthesis matching.
+   * Skips matches inside string literals and comments.
+   */
+  replaceWrapperCall(text, prefix, replacer) {
+    const pattern = new RegExp(`\\b${prefix.replace(".", "\\.")}\\(`, "g");
+    let result = text;
+    let offset = 0;
+    for (const match of text.matchAll(pattern)) {
+      const matchIdx = match.index ?? 0;
+      if (this.isProtected(matchIdx)) continue;
+      const startIdx = matchIdx + offset;
+      const openParen = startIdx + prefix.length;
+      let depth = 1;
+      let i = openParen + 1;
+      const current = result;
+      while (i < current.length && depth > 0) {
+        if (current[i] === "(") depth++;
+        else if (current[i] === ")") depth--;
+        i++;
+      }
+      if (depth !== 0) continue;
+      const innerContent = current.substring(openParen + 1, i - 1);
+      const args = this.splitTopLevelArgs(innerContent);
+      const replacement = replacer(args);
+      if (replacement === null) continue;
+      const before = current.substring(0, startIdx);
+      const after = current.substring(i);
+      result = before + replacement + after;
+      offset += replacement.length - (i - startIdx);
+    }
+    return result;
+  }
+  /**
+   * Transform v.pipe(factory, ...validators) to factory.validator1().validator2()
+   * Skips matches inside string literals and comments.
+   */
+  transformPipeExpressions(text) {
+    const pipePattern = /\bv\.pipe\(/g;
+    let result = text;
+    let offset = 0;
+    for (const match of text.matchAll(pipePattern)) {
+      const matchIdx = match.index ?? 0;
+      if (this.isProtected(matchIdx)) continue;
+      const startIdx = matchIdx + offset;
+      const openParen = startIdx + "v.pipe".length;
+      let depth = 1;
+      let i = openParen + 1;
+      const current = result;
+      while (i < current.length && depth > 0) {
+        if (current[i] === "(") depth++;
+        else if (current[i] === ")") depth--;
+        i++;
+      }
+      if (depth !== 0) continue;
+      const innerContent = current.substring(openParen + 1, i - 1);
+      const args = this.splitTopLevelArgs(innerContent);
+      if (args.length === 0) continue;
+      let zodExpr = args[0] ?? "";
+      for (let j = 1; j < args.length; j++) {
+        const validator = (args[j] ?? "").trim();
+        zodExpr = this.convertPipeValidator(zodExpr, validator);
+      }
+      const before = current.substring(0, startIdx);
+      const after = current.substring(i);
+      result = before + zodExpr + after;
+      offset += zodExpr.length - (i - startIdx);
+    }
+    return result;
+  }
+  /**
+   * Split arguments at top-level commas (not inside nested parens/brackets/braces).
+   */
+  splitTopLevelArgs(text) {
+    const args = [];
+    let depth = 0;
+    let current = "";
+    for (const char of text) {
+      if (char === "(" || char === "[" || char === "{") depth++;
+      else if (char === ")" || char === "]" || char === "}") depth--;
+      if (char === "," && depth === 0) {
+        args.push(current.trim());
+        current = "";
+      } else {
+        current += char;
+      }
+    }
+    if (current.trim()) {
+      args.push(current.trim());
+    }
+    return args;
+  }
+  convertPipeValidator(base, validator) {
+    for (const [valibotFn, zodMethod] of Object.entries(PIPE_TO_CHAIN)) {
+      const fnCall = `${valibotFn}(`;
+      if (validator.startsWith(fnCall)) {
+        const argsStr = validator.substring(fnCall.length, validator.length - 1);
+        return argsStr ? `${base}${zodMethod}(${argsStr})` : `${base}${zodMethod}()`;
+      }
+      if (validator === `${valibotFn}()`) {
+        return `${base}${zodMethod}()`;
+      }
+    }
+    if (validator.startsWith("v.transform(")) {
+      const args = validator.substring("v.transform(".length, validator.length - 1);
+      return `${base}.transform(${args})`;
+    }
+    if (validator.startsWith("v.check(")) {
+      const args = validator.substring("v.check(".length, validator.length - 1);
+      return `${base}.refine(${args})`;
+    }
+    if (validator.startsWith("v.brand(")) {
+      const args = validator.substring("v.brand(".length, validator.length - 1);
+      return `${base}.brand(${args})`;
+    }
+    this.warnings.push(`Unknown Valibot pipe validator: ${validator} \u2014 kept as-is`);
+    return `${base} /* TODO(schemashift): convert ${validator} */`;
+  }
+  transformFactories(text) {
+    for (const [valibotFactory, zodFactory] of Object.entries(VALIBOT_TO_ZOD_FACTORY)) {
+      const escaped = valibotFactory.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const regex = new RegExp(`\\b${escaped}\\(`, "g");
+      text = text.replace(regex, `${zodFactory}(`);
+    }
+    return text;
+  }
+};
+
+// src/valibot-to-zod-handler.ts
+function createValibotToZodHandler() {
+  const transformer = new ValibotToZodTransformer();
+  return {
+    transform(sourceFile, _options) {
+      return transformer.transform(sourceFile);
+    }
+  };
+}
 export {
   FACTORY_MAPPINGS,
   MODIFIER_METHODS,
   NUMBER_VALIDATION_MAPPINGS,
   OBJECT_METHODS,
   VALIDATION_MAPPINGS,
+  ValibotToZodTransformer,
   ZodToValibotTransformer,
+  createValibotToZodHandler,
   createZodToValibotHandler
 };
 //# sourceMappingURL=index.js.map