ai-localize-codemods 1.0.1 → 2.0.1

package/dist/index.js

@@ -38,26 +38,42 @@ __export(index_exports, {
   applyAngularCodemod: () => applyAngularCodemod,
   applyReactCodemod: () => applyReactCodemod,
   applyVueCodemod: () => applyVueCodemod,
-  batchReplaceCdnUrls: () => batchReplaceCdnUrls
+  batchReplaceCdnUrls: () => batchReplaceCdnUrls,
+  resolveImportSpecifier: () => resolveImportSpecifier
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/react-codemod.ts
 var fs = __toESM(require("fs"));
+var nodePath = __toESM(require("path"));
 var parser = __toESM(require("@babel/parser"));
 var import_traverse = __toESM(require("@babel/traverse"));
 var import_generator = __toESM(require("@babel/generator"));
 var t = __toESM(require("@babel/types"));
-var USE_TRANSLATION_IMPORT = "react-i18next";
-var USE_TRANSLATION_HOOK = "useTranslation";
+var DEFAULT_IMPORT_PACKAGE = "react-i18next";
+var DEFAULT_HOOK_NAME = "useTranslation";
+var DEFAULT_TRANSLATION_FN = "t";
+var DEFAULT_ACCESSOR_STYLE = "function";
 var ReactCodemod = class {
   filePath;
   content;
   texts;
-  constructor(filePath, content, texts) {
+  /** Resolved import specifier string (may differ per file for local paths) */
+  importSpecifier;
+  hookName;
+  translationFn;
+  namespace;
+  accessorStyle;
+  constructor(filePath, content, texts, codemodConfig, cwd = process.cwd()) {
     this.filePath = filePath;
     this.content = content;
     this.texts = texts;
+    this.hookName = codemodConfig?.hookName ?? DEFAULT_HOOK_NAME;
+    this.translationFn = codemodConfig?.translationFunction ?? DEFAULT_TRANSLATION_FN;
+    this.namespace = codemodConfig?.namespace;
+    this.accessorStyle = codemodConfig?.accessorStyle ?? DEFAULT_ACCESSOR_STYLE;
+    const pkg = codemodConfig?.importPackage ?? DEFAULT_IMPORT_PACKAGE;
+    this.importSpecifier = resolveImportSpecifier(pkg, filePath, cwd);
   }
   transform() {
     if (this.texts.length === 0) {
@@ -101,58 +117,66 @@ var ReactCodemod = class {
       textKeyMap.set(dt.text, dt.suggestedKey);
     }
     let replacedTexts = 0;
-    let hasUseTranslationImport = false;
-    let hasUseTranslationHook = false;
+    let hasImport = false;
+    let hasHook = false;
     let injectedImport = false;
     let injectedHook = false;
+    const translationFn = this.translationFn;
+    const hookName = this.hookName;
+    const importSpecifier2 = this.importSpecifier;
+    const accessorStyle = this.accessorStyle;
+    const buildTranslationExpr = (key) => {
+      if (accessorStyle === "bracket") {
+        return t.memberExpression(
+          t.identifier(translationFn),
+          t.stringLiteral(key),
+          true
+          /* computed */
+        );
+      }
+      return t.callExpression(t.identifier(translationFn), [t.stringLiteral(key)]);
+    };
     (0, import_traverse.default)(ast, {
-      ImportDeclaration(nodePath) {
-        if (nodePath.node.source.value === USE_TRANSLATION_IMPORT) {
-          hasUseTranslationImport = true;
+      ImportDeclaration(nodePath2) {
+        if (nodePath2.node.source.value === importSpecifier2) {
+          hasImport = true;
         }
       },
-      // Check if useTranslation hook already destructured
-      VariableDeclarator(nodePath) {
-        const id = nodePath.node.id;
+      VariableDeclarator(nodePath2) {
+        const id = nodePath2.node.id;
         if (t.isObjectPattern(id) && id.properties.some(
-          (p) => t.isObjectProperty(p) && t.isIdentifier(p.key) && p.key.name === "t"
+          (p) => t.isObjectProperty(p) && t.isIdentifier(p.key) && p.key.name === translationFn
         )) {
-          hasUseTranslationHook = true;
+          hasHook = true;
         }
       }
     });
     (0, import_traverse.default)(ast, {
-      JSXText(nodePath) {
-        const text = nodePath.node.value.trim();
+      JSXText(nodePath2) {
+        const text = nodePath2.node.value.trim();
         if (!text) return;
         const key = textKeyMap.get(text);
         if (!key) return;
-        const tCall = t.jsxExpressionContainer(
-          t.callExpression(t.identifier("t"), [t.stringLiteral(key)])
-        );
-        nodePath.replaceWith(tCall);
+        nodePath2.replaceWith(t.jsxExpressionContainer(buildTranslationExpr(key)));
         replacedTexts++;
       },
-      StringLiteral(nodePath) {
-        const text = nodePath.node.value;
+      StringLiteral(nodePath2) {
+        const text = nodePath2.node.value;
         const key = textKeyMap.get(text);
         if (!key) return;
-        if (t.isImportDeclaration(nodePath.parent)) return;
-        if (t.isObjectProperty(nodePath.parent) && nodePath.parent.key === nodePath.node) return;
-        if (t.isJSXAttribute(nodePath.parent)) return;
-        const tCall = t.callExpression(t.identifier("t"), [t.stringLiteral(key)]);
-        nodePath.replaceWith(tCall);
+        if (t.isImportDeclaration(nodePath2.parent)) return;
+        if (t.isObjectProperty(nodePath2.parent) && nodePath2.parent.key === nodePath2.node) return;
+        if (t.isJSXAttribute(nodePath2.parent)) return;
+        nodePath2.replaceWith(buildTranslationExpr(key));
         replacedTexts++;
       },
-      JSXAttribute(nodePath) {
-        const valueNode = nodePath.node.value;
+      JSXAttribute(nodePath2) {
+        const valueNode = nodePath2.node.value;
         if (!t.isStringLiteral(valueNode)) return;
         const text = valueNode.value;
         const key = textKeyMap.get(text);
         if (!key) return;
-        nodePath.node.value = t.jsxExpressionContainer(
-          t.callExpression(t.identifier("t"), [t.stringLiteral(key)])
-        );
+        nodePath2.node.value = t.jsxExpressionContainer(buildTranslationExpr(key));
         replacedTexts++;
       }
     });
@@ -167,25 +191,21 @@ var ReactCodemod = class {
         replacedTexts: 0
       };
     }
-    if (!hasUseTranslationImport) {
+    if (!hasImport) {
       const importDecl = t.importDeclaration(
-        [t.importSpecifier(t.identifier(USE_TRANSLATION_HOOK), t.identifier(USE_TRANSLATION_HOOK))],
-        t.stringLiteral(USE_TRANSLATION_IMPORT)
+        [t.importSpecifier(t.identifier(hookName), t.identifier(hookName))],
+        t.stringLiteral(importSpecifier2)
       );
       ast.program.body.unshift(importDecl);
       injectedImport = true;
     }
-    if (!hasUseTranslationHook) {
-      this.injectUseTranslationHook(ast);
+    if (!hasHook) {
+      this.injectHook(ast);
       injectedHook = true;
     }
     const output = (0, import_generator.default)(
       ast,
-      {
-        retainLines: false,
-        comments: true,
-        compact: false
-      },
+      { retainLines: false, comments: true, compact: false },
       this.content
     );
     return {
@@ -198,19 +218,22 @@ var ReactCodemod = class {
       replacedTexts
     };
   }
-  injectUseTranslationHook(ast) {
+  injectHook(ast) {
+    const hookName = this.hookName;
+    const translationFn = this.translationFn;
+    const namespace = this.namespace;
     (0, import_traverse.default)(ast, {
-      FunctionDeclaration(nodePath) {
-        if (!isReactComponent(nodePath.node.id?.name)) return;
-        injectHookIntoBody(nodePath.node.body);
-        nodePath.stop();
+      FunctionDeclaration(nodePath2) {
+        if (!isReactComponent(nodePath2.node.id?.name)) return;
+        injectHookIntoBody(nodePath2.node.body, hookName, translationFn, namespace);
+        nodePath2.stop();
       },
-      ArrowFunctionExpression(nodePath) {
-        if (!isReactComponentParent(nodePath)) return;
-        const body = nodePath.node.body;
+      ArrowFunctionExpression(nodePath2) {
+        if (!isReactComponentParent(nodePath2)) return;
+        const body = nodePath2.node.body;
         if (t.isBlockStatement(body)) {
-          injectHookIntoBody(body);
-          nodePath.stop();
+          injectHookIntoBody(body, hookName, translationFn, namespace);
+          nodePath2.stop();
         }
       }
     });
@@ -220,28 +243,76 @@ function isReactComponent(name) {
   if (!name) return false;
   return /^[A-Z]/.test(name);
 }
-function isReactComponentParent(nodePath) {
-  const parent = nodePath.parent;
+function isReactComponentParent(nodePath2) {
+  const parent = nodePath2.parent;
   if (t.isVariableDeclarator(parent)) {
     const id = parent.id;
     if (t.isIdentifier(id) && /^[A-Z]/.test(id.name)) return true;
   }
   return false;
 }
-function injectHookIntoBody(body) {
+function injectHookIntoBody(body, hookName, translationFn, namespace) {
+  const hookArgs = namespace ? [t.stringLiteral(namespace)] : [];
   const hookDecl = t.variableDeclaration("const", [
     t.variableDeclarator(
       t.objectPattern([
-        t.objectProperty(t.identifier("t"), t.identifier("t"), false, true)
+        t.objectProperty(t.identifier(translationFn), t.identifier(translationFn), false, true)
       ]),
-      t.callExpression(t.identifier("useTranslation"), [])
+      t.callExpression(t.identifier(hookName), hookArgs)
     )
   ]);
   body.body.unshift(hookDecl);
 }
-function applyReactCodemod(filePath, texts, dryRun = false) {
+function resolveImportSpecifier(importPackage, filePath, cwd) {
+  if (isNpmPackage(importPackage)) {
+    return importPackage;
+  }
+  let absoluteHookPath;
+  if (nodePath.isAbsolute(importPackage)) {
+    absoluteHookPath = importPackage;
+  } else {
+    absoluteHookPath = nodePath.resolve(cwd, importPackage);
+  }
+  const fileDir = nodePath.dirname(filePath);
+  let rel = nodePath.relative(fileDir, absoluteHookPath).replace(/\\/g, "/");
+  if (!rel.startsWith(".")) {
+    rel = `./${rel}`;
+  }
+  return rel;
+}
+function isNpmPackage(pkg) {
+  if (pkg.startsWith(".") || pkg.startsWith("/")) return false;
+  if (pkg.startsWith("@") && pkg.includes("/")) {
+    if (pkg.startsWith("@/")) return false;
+    return true;
+  }
+  if (!pkg.includes("/")) return true;
+  const firstSegment = pkg.split("/")[0].toLowerCase();
+  const sourceDirectories = /* @__PURE__ */ new Set([
+    "src",
+    "app",
+    "lib",
+    "hooks",
+    "utils",
+    "pages",
+    "components",
+    "features",
+    "shared",
+    "common",
+    "locales",
+    "i18n",
+    "services",
+    "store",
+    "helpers",
+    "core",
+    "modules"
+  ]);
+  if (sourceDirectories.has(firstSegment)) return false;
+  return true;
+}
+function applyReactCodemod(filePath, texts, dryRun = false, codemodConfig, cwd = process.cwd()) {
   const content = fs.readFileSync(filePath, "utf-8");
-  const codemod = new ReactCodemod(filePath, content, texts);
+  const codemod = new ReactCodemod(filePath, content, texts, codemodConfig, cwd);
   const result = codemod.transform();
   if (result.changed && !dryRun) {
     fs.writeFileSync(filePath, result.transformedContent, "utf-8");
@@ -251,14 +322,17 @@ function applyReactCodemod(filePath, texts, dryRun = false) {
 
 // src/vue-codemod.ts
 var fs2 = __toESM(require("fs"));
+var DEFAULT_TRANSLATION_FN2 = "$t";
 var VueCodemod = class {
   filePath;
   content;
   texts;
-  constructor(filePath, content, texts) {
+  translationFn;
+  constructor(filePath, content, texts, codemodConfig) {
     this.filePath = filePath;
     this.content = content;
     this.texts = texts;
+    this.translationFn = codemodConfig?.translationFunction ?? DEFAULT_TRANSLATION_FN2;
   }
   transform() {
     if (this.texts.length === 0) {
@@ -275,14 +349,15 @@ var VueCodemod = class {
     }
     let transformedContent = this.content;
     let replacedTexts = 0;
+    const fn = this.translationFn;
     if (templateMatch) {
       let template = templateMatch[1];
       for (const [text, key] of textKeyMap) {
         const escaped = text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
         const re = new RegExp(`(>\\s*)${escaped}(\\s*<)`, "g");
-        template = template.replace(re, `$1{{ $t('${key}') }}$2`);
+        template = template.replace(re, `$1{{ ${fn}('${key}') }}$2`);
         const attrRe = new RegExp(`((?:title|placeholder|alt|label)=)"(${escaped})"`, "g");
-        template = template.replace(attrRe, `:$1"$t('${key}')"`);
+        template = template.replace(attrRe, `:$1"${fn}('${key}')"`);
         replacedTexts++;
       }
       transformedContent = transformedContent.replace(templateMatch[1], template);
@@ -313,9 +388,9 @@ var VueCodemod = class {
     };
   }
 };
-function applyVueCodemod(filePath, texts, dryRun = false) {
+function applyVueCodemod(filePath, texts, dryRun = false, codemodConfig) {
   const content = fs2.readFileSync(filePath, "utf-8");
-  const codemod = new VueCodemod(filePath, content, texts);
+  const codemod = new VueCodemod(filePath, content, texts, codemodConfig);
   const result = codemod.transform();
   if (result.changed && !dryRun) {
     fs2.writeFileSync(filePath, result.transformedContent, "utf-8");
@@ -325,14 +400,20 @@ function applyVueCodemod(filePath, texts, dryRun = false) {
 
 // src/angular-codemod.ts
 var fs3 = __toESM(require("fs"));
+var DEFAULT_TS_SERVICE = "this.translateService.instant";
+var DEFAULT_TEMPLATE_PIPE = "translate";
 var AngularCodemod = class {
   filePath;
   content;
   texts;
-  constructor(filePath, content, texts) {
+  templatePipe;
+  tsServiceCall;
+  constructor(filePath, content, texts, codemodConfig) {
     this.filePath = filePath;
     this.content = content;
     this.texts = texts;
+    this.templatePipe = codemodConfig?.translationFunction ?? DEFAULT_TEMPLATE_PIPE;
+    this.tsServiceCall = codemodConfig?.hookName ?? DEFAULT_TS_SERVICE;
   }
   transform() {
     if (this.texts.length === 0) return this.unchanged();
@@ -343,21 +424,23 @@ var AngularCodemod = class {
     let transformedContent = this.content;
     let replacedTexts = 0;
     const isTemplate = this.filePath.endsWith(".html");
+    const pipe = this.templatePipe;
+    const svc = this.tsServiceCall;
     for (const [text, key] of textKeyMap) {
       const escaped = text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
       if (isTemplate) {
         const re = new RegExp(`(>\\s*)${escaped}(\\s*<)`, "g");
-        transformedContent = transformedContent.replace(re, `$1{{ '${key}' | translate }}$2`);
+        transformedContent = transformedContent.replace(re, `$1{{ '${key}' | ${pipe} }}$2`);
         const attrRe = new RegExp(`\\[(?:placeholder|label|title|alt)\\]="'${escaped}'"`, "g");
         transformedContent = transformedContent.replace(
           attrRe,
-          `[placeholder]="'${key}' | translate"`
+          `[placeholder]="'${key}' | ${pipe}"`
         );
       } else {
         const tsRe = new RegExp(`'${escaped}'`, "g");
         transformedContent = transformedContent.replace(
           tsRe,
-          `this.translateService.instant('${key}')`
+          `${svc}('${key}')`
         );
       }
       replacedTexts++;
@@ -385,9 +468,9 @@ var AngularCodemod = class {
     };
   }
 };
-function applyAngularCodemod(filePath, texts, dryRun = false) {
+function applyAngularCodemod(filePath, texts, dryRun = false, codemodConfig) {
   const content = fs3.readFileSync(filePath, "utf-8");
-  const codemod = new AngularCodemod(filePath, content, texts);
+  const codemod = new AngularCodemod(filePath, content, texts, codemodConfig);
   const result = codemod.transform();
   if (result.changed && !dryRun) {
     fs3.writeFileSync(filePath, result.transformedContent, "utf-8");
@@ -458,8 +541,10 @@ async function batchReplaceCdnUrls(fileUrlMap, assets, dryRun = false) {
 var path2 = __toESM(require("path"));
 var CodemodRunner = class {
   config;
-  constructor(config) {
+  cwd;
+  constructor(config, cwd = process.cwd()) {
     this.config = config;
+    this.cwd = cwd;
   }
   async run(detectedTexts, options = {}) {
     const startTime = Date.now();
@@ -508,13 +593,14 @@ var CodemodRunner = class {
   }
   applyCodemod(filePath, texts, framework, dryRun) {
     const ext = path2.extname(filePath).toLowerCase();
+    const codemodConfig = this.config.codemods;
     if (ext === ".vue") {
-      return applyVueCodemod(filePath, texts, dryRun);
+      return applyVueCodemod(filePath, texts, dryRun, codemodConfig);
     }
     if (framework === "angular" || framework === "angular-ngx" || framework === "angular-i18n") {
-      return applyAngularCodemod(filePath, texts, dryRun);
+      return applyAngularCodemod(filePath, texts, dryRun, codemodConfig);
     }
-    return applyReactCodemod(filePath, texts, dryRun);
+    return applyReactCodemod(filePath, texts, dryRun, codemodConfig, this.cwd);
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
@@ -527,5 +613,6 @@ var CodemodRunner = class {
   applyAngularCodemod,
   applyReactCodemod,
   applyVueCodemod,
-  batchReplaceCdnUrls
+  batchReplaceCdnUrls,
+  resolveImportSpecifier
 });