ai-localize-codemods 1.0.1 → 2.0.1

package/dist/index.mjs

@@ -1,19 +1,34 @@
 // src/react-codemod.ts
 import * as fs from "fs";
+import * as nodePath from "path";
 import * as parser from "@babel/parser";
 import traverse from "@babel/traverse";
 import generate from "@babel/generator";
 import * as t from "@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) {
@@ -57,58 +72,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)]);
+    };
     traverse(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;
         }
       }
     });
     traverse(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++;
       }
     });
@@ -123,25 +146,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 = generate(
       ast,
-      {
-        retainLines: false,
-        comments: true,
-        compact: false
-      },
+      { retainLines: false, comments: true, compact: false },
       this.content
     );
     return {
@@ -154,19 +173,22 @@ var ReactCodemod = class {
       replacedTexts
     };
   }
-  injectUseTranslationHook(ast) {
+  injectHook(ast) {
+    const hookName = this.hookName;
+    const translationFn = this.translationFn;
+    const namespace = this.namespace;
     traverse(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();
         }
       }
     });
@@ -176,28 +198,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");
@@ -207,14 +277,17 @@ function applyReactCodemod(filePath, texts, dryRun = false) {
 
 // src/vue-codemod.ts
 import * as fs2 from "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) {
@@ -231,14 +304,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);
@@ -269,9 +343,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");
@@ -281,14 +355,20 @@ function applyVueCodemod(filePath, texts, dryRun = false) {
 
 // src/angular-codemod.ts
 import * as fs3 from "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();
@@ -299,21 +379,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++;
@@ -341,9 +423,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");
@@ -414,8 +496,10 @@ async function batchReplaceCdnUrls(fileUrlMap, assets, dryRun = false) {
 import * as path2 from "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();
@@ -464,13 +548,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);
   }
 };
 export {
@@ -482,5 +567,6 @@ export {
   applyAngularCodemod,
   applyReactCodemod,
   applyVueCodemod,
-  batchReplaceCdnUrls
+  batchReplaceCdnUrls,
+  resolveImportSpecifier
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-localize-codemods",
-  "version": "1.0.1",
+  "version": "2.0.1",
   "description": "AST-based codemods to inject i18n wrappers into frontend source code",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -19,7 +19,7 @@
     "@babel/generator": "^7.23.9",
     "recast": "^0.23.4",
     "jscodeshift": "^0.15.2",
-    "ai-localize-shared": "1.0.1"
+    "ai-localize-shared": "2.0.1"
   },
   "devDependencies": {
     "@types/babel__generator": "^7.6.8",

package/src/angular-codemod.ts

@@ -1,25 +1,39 @@
 import * as fs from 'fs';
 
-import type { DetectedText } from 'ai-localize-shared';
+import type { DetectedText, CodemodConfig } from 'ai-localize-shared';
 import type { CodemodResult } from './react-codemod.js';
 
+const DEFAULT_TS_SERVICE = 'this.translateService.instant';
+const DEFAULT_TEMPLATE_PIPE = 'translate';
+
 /**
  * Angular ngx-translate codemod:
  * - In templates: wraps text with {{ 'key' | translate }}
  * - In TS: replaces string literals with this.translateService.instant('key')
+ *
+ * The pipe name used in templates can be overridden via
+ * `codemods.translationFunction` (default: "translate").
+ * The TS service call can be overridden via `codemods.hookName`
+ * (default: "this.translateService.instant").
  */
 export class AngularCodemod {
   private filePath: string;
   private content: string;
   private texts: DetectedText[];
+  private templatePipe: string;
+  private tsServiceCall: string;
 
-  constructor(filePath: string, content: string, texts: DetectedText[]) {
- this.filePath = filePath;
-    this.content = content;
+  constructor(filePath: string, content: string, texts: DetectedText[], codemodConfig?: CodemodConfig) {
+    this.filePath = filePath;
+  this.content = content;
     this.texts = texts;
+    // translationFunction maps to the Angular template pipe name
+    this.templatePipe = codemodConfig?.translationFunction ?? DEFAULT_TEMPLATE_PIPE;
+    // hookName maps to the TS service call expression
+this.tsServiceCall = codemodConfig?.hookName ?? DEFAULT_TS_SERVICE;
   }
 
-  transform(): CodemodResult {
+transform(): CodemodResult {
     if (this.texts.length === 0) return this.unchanged();
 
     const textKeyMap = new Map<string, string>();
@@ -30,26 +44,28 @@ export class AngularCodemod {
     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, '\\$&');
+for (const [text, key] of textKeyMap) {
+      const escaped = text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
       if (isTemplate) {
         // Template: >Some Text< => >{{ 'key' | translate }}<
-        const re = new RegExp(`(>\\s*)${escaped}(\\s*<)`, 'g');
-        transformedContent = transformedContent.replace(re, `$1{{ '${key}' | translate }}$2`);
+      const re = new RegExp(`(>\\s*)${escaped}(\\s*<)`, 'g');
+        transformedContent = transformedContent.replace(re, `$1{{ '${key}' | ${pipe} }}$2`);
         // attribute: [attr]="'Some Text'" => [attr]="'key' | translate"
         const attrRe = new RegExp(`\\[(?:placeholder|label|title|alt)\\]="'${escaped}'"`, 'g');
         transformedContent = transformedContent.replace(
-      attrRe,
-          `[placeholder]="'${key}' | translate"`
+attrRe,
+          `[placeholder]="'${key}' | ${pipe}"`
         );
       } else {
-   // TS file: 'Some Text' => this.translateService.instant('key')
-        const tsRe = new RegExp(`'${escaped}'`, 'g');
+        // TS file: 'Some Text' => this.translateService.instant('key')
+   const tsRe = new RegExp(`'${escaped}'`, 'g');
         transformedContent = transformedContent.replace(
           tsRe,
-  `this.translateService.instant('${key}')`
-        );
+          `${svc}('${key}')`
+   );
       }
       replacedTexts++;
     }
@@ -58,12 +74,12 @@ export class AngularCodemod {
 
     return {
       filePath: this.filePath,
-    originalContent: this.content,
+      originalContent: this.content,
       transformedContent,
       changed: true,
       injectedImport: false,
       injectedHook: false,
-   replacedTexts,
+      replacedTexts,
     };
   }
 
@@ -71,11 +87,11 @@ export class AngularCodemod {
     return {
       filePath: this.filePath,
       originalContent: this.content,
-    transformedContent: this.content,
-      changed: false,
+      transformedContent: this.content,
+    changed: false,
       injectedImport: false,
       injectedHook: false,
-      replacedTexts: 0,
+ replacedTexts: 0,
     };
   }
 }
@@ -83,10 +99,11 @@ export class AngularCodemod {
 export function applyAngularCodemod(
   filePath: string,
   texts: DetectedText[],
-  dryRun = false
+  dryRun = false,
+  codemodConfig?: CodemodConfig
 ): CodemodResult {
   const content = fs.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) {
     fs.writeFileSync(filePath, result.transformedContent, 'utf-8');