@grafana/create-plugin 6.3.0-canary.2314.19540598852.0 → 6.3.0-canary.2320.19631436862.0

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+# v6.2.2 (Fri Nov 21 2025)
+
+#### 🐛 Bug Fix
+
+- fix(deps): update dependency glob to v11.1.0 [security] [#2308](https://github.com/grafana/plugin-tools/pull/2308) ([@renovate-sh-app[bot]](https://github.com/renovate-sh-app[bot]))
+
+#### Authors: 1
+
+- [@renovate-sh-app[bot]](https://github.com/renovate-sh-app[bot])
+
+---
+
 # v6.2.1 (Thu Nov 20 2025)
 
 #### 🐛 Bug Fix

package/dist/codemods/additions/additions.js

@@ -3,6 +3,11 @@ var defaultAdditions = [
     name: "example-addition",
     description: "Adds an example addition to the plugin",
     scriptPath: import.meta.resolve("./scripts/example-addition.js")
+  },
+  {
+    name: "i18n",
+    description: "Adds internationalization (i18n) support to the plugin",
+    scriptPath: import.meta.resolve("./scripts/i18n/index.js")
   }
 ];
 

package/dist/codemods/additions/scripts/i18n/code-generation.js

@@ -0,0 +1,122 @@
+import * as recast from 'recast';
+import * as babelParser from 'recast/parsers/babel-ts.js';
+import { additionsDebug } from '../../../utils.js';
+
+const { builders } = recast.types;
+function addI18nInitialization(context, needsBackwardCompatibility) {
+  const moduleTsPath = context.doesFileExist("src/module.ts") ? "src/module.ts" : context.doesFileExist("src/module.tsx") ? "src/module.tsx" : null;
+  if (!moduleTsPath) {
+    additionsDebug("No module.ts or module.tsx found, skipping i18n initialization");
+    return;
+  }
+  const moduleContent = context.getFile(moduleTsPath);
+  if (!moduleContent) {
+    return;
+  }
+  if (moduleContent.includes("initPluginTranslations")) {
+    additionsDebug("i18n already initialized in module file");
+    return;
+  }
+  try {
+    const ast = recast.parse(moduleContent, {
+      parser: babelParser
+    });
+    const imports = [];
+    imports.push(
+      builders.importDeclaration(
+        [builders.importSpecifier(builders.identifier("initPluginTranslations"))],
+        builders.literal("@grafana/i18n")
+      )
+    );
+    imports.push(
+      builders.importDeclaration(
+        [builders.importDefaultSpecifier(builders.identifier("pluginJson"))],
+        builders.literal("plugin.json")
+      )
+    );
+    if (needsBackwardCompatibility) {
+      imports.push(
+        builders.importDeclaration(
+          [builders.importSpecifier(builders.identifier("config"))],
+          builders.literal("@grafana/runtime")
+        )
+      );
+      imports.push(
+        builders.importDeclaration(
+          [builders.importDefaultSpecifier(builders.identifier("semver"))],
+          builders.literal("semver")
+        )
+      );
+      imports.push(
+        builders.importDeclaration(
+          [builders.importSpecifier(builders.identifier("loadResources"))],
+          builders.literal("./loadResources")
+        )
+      );
+    }
+    const firstImportIndex = ast.program.body.findIndex((node) => node.type === "ImportDeclaration");
+    if (firstImportIndex !== -1) {
+      ast.program.body.splice(firstImportIndex + 1, 0, ...imports);
+    } else {
+      ast.program.body.unshift(...imports);
+    }
+    const i18nInitCode = needsBackwardCompatibility ? `// Before Grafana version 12.1.0 the plugin is responsible for loading translation resources
+// In Grafana version 12.1.0 and later Grafana is responsible for loading translation resources
+const loaders = semver.lt(config?.buildInfo?.version, '12.1.0') ? [loadResources] : [];
+
+await initPluginTranslations(pluginJson.id, loaders);` : `await initPluginTranslations(pluginJson.id);`;
+    const initAst = recast.parse(i18nInitCode, {
+      parser: babelParser
+    });
+    const lastImportIndex = ast.program.body.findLastIndex((node) => node.type === "ImportDeclaration");
+    if (lastImportIndex !== -1) {
+      ast.program.body.splice(lastImportIndex + 1, 0, ...initAst.program.body);
+    } else {
+      ast.program.body.unshift(...initAst.program.body);
+    }
+    const output = recast.print(ast, {
+      tabWidth: 2,
+      trailingComma: true,
+      lineTerminator: "\n"
+    }).code;
+    context.updateFile(moduleTsPath, output);
+    additionsDebug(`Updated ${moduleTsPath} with i18n initialization`);
+  } catch (error) {
+    additionsDebug("Error updating module file:", error);
+  }
+}
+function createLoadResourcesFile(context) {
+  const loadResourcesPath = "src/loadResources.ts";
+  if (context.doesFileExist(loadResourcesPath)) {
+    additionsDebug("loadResources.ts already exists, skipping");
+    return;
+  }
+  const pluginJsonRaw = context.getFile("src/plugin.json");
+  if (!pluginJsonRaw) {
+    additionsDebug("Cannot create loadResources.ts without plugin.json");
+    return;
+  }
+  const loadResourcesContent = `import { LANGUAGES, ResourceLoader, Resources } from '@grafana/i18n';
+import pluginJson from 'plugin.json';
+
+const resources = LANGUAGES.reduce<Record<string, () => Promise<{ default: Resources }>>>((acc, lang) => {
+  acc[lang.code] = async () => await import(\`./locales/\${lang.code}/\${pluginJson.id}.json\`);
+  return acc;
+}, {});
+
+export const loadResources: ResourceLoader = async (resolvedLanguage: string) => {
+  try {
+    const translation = await resources[resolvedLanguage]();
+    return translation.default;
+  } catch (error) {
+    // This makes sure that the plugin doesn't crash when the resolved language in Grafana isn't supported by the plugin
+    console.error(\`The plugin '\${pluginJson.id}' doesn't support the language '\${resolvedLanguage}'\`, error);
+    return {};
+  }
+};
+`;
+  context.addFile(loadResourcesPath, loadResourcesContent);
+  additionsDebug("Created src/loadResources.ts for backward compatibility");
+}
+
+export { addI18nInitialization, createLoadResourcesFile };

package/dist/codemods/additions/scripts/i18n/config-updates.js

@@ -0,0 +1,113 @@
+import { coerce, gte } from 'semver';
+import { parseDocument, stringify } from 'yaml';
+import { additionsDebug } from '../../../utils.js';
+
+function updateDockerCompose(context) {
+  if (!context.doesFileExist("docker-compose.yaml")) {
+    additionsDebug("docker-compose.yaml not found, skipping");
+    return;
+  }
+  const composeContent = context.getFile("docker-compose.yaml");
+  if (!composeContent) {
+    return;
+  }
+  try {
+    const composeDoc = parseDocument(composeContent);
+    const currentEnv = composeDoc.getIn(["services", "grafana", "environment"]);
+    if (!currentEnv) {
+      additionsDebug("No environment section found in docker-compose.yaml, skipping");
+      return;
+    }
+    if (typeof currentEnv === "object") {
+      const envMap = currentEnv;
+      const toggleValue = envMap.get("GF_FEATURE_TOGGLES_ENABLE");
+      if (toggleValue) {
+        const toggleStr = toggleValue.toString();
+        if (toggleStr.includes("localizationForPlugins")) {
+          additionsDebug("localizationForPlugins already in GF_FEATURE_TOGGLES_ENABLE");
+          return;
+        }
+        composeDoc.setIn(
+          ["services", "grafana", "environment", "GF_FEATURE_TOGGLES_ENABLE"],
+          `${toggleStr},localizationForPlugins`
+        );
+      } else {
+        composeDoc.setIn(["services", "grafana", "environment", "GF_FEATURE_TOGGLES_ENABLE"], "localizationForPlugins");
+      }
+      context.updateFile("docker-compose.yaml", stringify(composeDoc));
+      additionsDebug("Updated docker-compose.yaml with localizationForPlugins feature toggle");
+    }
+  } catch (error) {
+    additionsDebug("Error updating docker-compose.yaml:", error);
+  }
+}
+function updatePluginJson(context, locales, needsBackwardCompatibility) {
+  if (!context.doesFileExist("src/plugin.json")) {
+    additionsDebug("src/plugin.json not found, skipping");
+    return;
+  }
+  const pluginJsonRaw = context.getFile("src/plugin.json");
+  if (!pluginJsonRaw) {
+    return;
+  }
+  try {
+    const pluginJson = JSON.parse(pluginJsonRaw);
+    const existingLanguages = Array.isArray(pluginJson.languages) ? pluginJson.languages : [];
+    const mergedLanguages = [.../* @__PURE__ */ new Set([...existingLanguages, ...locales])];
+    pluginJson.languages = mergedLanguages;
+    if (!pluginJson.dependencies) {
+      pluginJson.dependencies = {};
+    }
+    const currentGrafanaDep = pluginJson.dependencies.grafanaDependency || ">=11.0.0";
+    const targetVersion = needsBackwardCompatibility ? "11.0.0" : "12.1.0";
+    const minVersion = coerce(targetVersion);
+    const currentVersion = coerce(currentGrafanaDep.replace(/^[><=]+/, ""));
+    if (!currentVersion || !minVersion || !gte(currentVersion, minVersion)) {
+      pluginJson.dependencies.grafanaDependency = `>=${targetVersion}`;
+      additionsDebug(`Updated grafanaDependency to >=${targetVersion}`);
+    }
+    context.updateFile("src/plugin.json", JSON.stringify(pluginJson, null, 2));
+    additionsDebug("Updated src/plugin.json with languages:", locales);
+  } catch (error) {
+    additionsDebug("Error updating src/plugin.json:", error);
+  }
+}
+function createI18nextConfig(context) {
+  if (context.doesFileExist("i18next.config.ts")) {
+    additionsDebug("i18next.config.ts already exists, skipping");
+    return;
+  }
+  const pluginJsonRaw = context.getFile("src/plugin.json");
+  if (!pluginJsonRaw) {
+    additionsDebug("Cannot create i18next.config.ts without plugin.json");
+    return;
+  }
+  try {
+    const pluginJson = JSON.parse(pluginJsonRaw);
+    const pluginId = pluginJson.id;
+    if (!pluginId) {
+      additionsDebug("No plugin ID found in plugin.json");
+      return;
+    }
+    const i18nextConfig = `import { defineConfig } from 'i18next-cli';
+import pluginJson from './src/plugin.json';
+
+export default defineConfig({
+  locales: pluginJson.languages,
+  extract: {
+    input: ['src/**/*.{tsx,ts}'],
+    output: 'src/locales/{{language}}/{{namespace}}.json',
+    defaultNS: pluginJson.id,
+    functions: ['t', '*.t'],
+    transComponents: ['Trans'],
+  },
+});
+`;
+    context.addFile("i18next.config.ts", i18nextConfig);
+    additionsDebug("Created i18next.config.ts");
+  } catch (error) {
+    additionsDebug("Error creating i18next.config.ts:", error);
+  }
+}
+
+export { createI18nextConfig, updateDockerCompose, updatePluginJson };

package/dist/codemods/additions/scripts/i18n/index.js

@@ -0,0 +1,49 @@
+import * as v from 'valibot';
+import { additionsDebug } from '../../../utils.js';
+import { updateDockerCompose, updatePluginJson, createI18nextConfig } from './config-updates.js';
+import { addI18nInitialization, createLoadResourcesFile } from './code-generation.js';
+import { addI18nDependency, addSemverDependency, updateEslintConfig, addI18nextCli } from './tooling.js';
+import { checkNeedsBackwardCompatibility, createLocaleFiles } from './utils.js';
+
+const schema = v.object(
+  {
+    locales: v.pipe(
+      v.union([v.string(), v.array(v.string())]),
+      v.transform((input) => {
+        return typeof input === "string" ? input.split(",").map((s) => s.trim()) : input;
+      }),
+      v.array(
+        v.pipe(
+          v.string(),
+          v.regex(/^[a-z]{2}-[A-Z]{2}$/, "Locale must be in format xx-XX (e.g., en-US, es-ES, sv-SE)")
+        ),
+        'Please provide a comma-separated list of all supported locales, e.g., "en-US,es-ES,sv-SE"'
+      ),
+      v.minLength(1, 'Please provide a comma-separated list of all supported locales, e.g., "en-US,es-ES,sv-SE"')
+    )
+  },
+  'Please provide a comma-separated list of all supported locales, e.g., "en-US,es-ES,sv-SE"'
+);
+function i18nAddition(context, options) {
+  const { locales } = options;
+  additionsDebug("Adding i18n support with locales:", locales);
+  const needsBackwardCompatibility = checkNeedsBackwardCompatibility(context);
+  additionsDebug("Needs backward compatibility:", needsBackwardCompatibility);
+  updateDockerCompose(context);
+  updatePluginJson(context, locales, needsBackwardCompatibility);
+  createLocaleFiles(context, locales);
+  addI18nDependency(context);
+  if (needsBackwardCompatibility) {
+    addSemverDependency(context);
+  }
+  updateEslintConfig(context);
+  addI18nInitialization(context, needsBackwardCompatibility);
+  if (needsBackwardCompatibility) {
+    createLoadResourcesFile(context);
+  }
+  addI18nextCli(context);
+  createI18nextConfig(context);
+  return context;
+}
+
+export { i18nAddition as default, schema };

package/dist/codemods/additions/scripts/i18n/tooling.js

@@ -0,0 +1,119 @@
+import * as recast from 'recast';
+import * as babelParser from 'recast/parsers/babel-ts.js';
+import { addDependenciesToPackageJson, additionsDebug } from '../../../utils.js';
+
+const { builders } = recast.types;
+function addI18nDependency(context) {
+  addDependenciesToPackageJson(context, { "@grafana/i18n": "12.2.2" }, {});
+  additionsDebug("Added @grafana/i18n dependency version 12.2.2");
+}
+function addSemverDependency(context) {
+  addDependenciesToPackageJson(context, { semver: "^7.6.0" }, { "@types/semver": "^7.5.0" });
+  additionsDebug("Added semver dependency");
+}
+function addI18nextCli(context) {
+  addDependenciesToPackageJson(context, {}, { "i18next-cli": "^1.1.1" });
+  const packageJsonRaw = context.getFile("package.json");
+  if (!packageJsonRaw) {
+    return;
+  }
+  try {
+    const packageJson = JSON.parse(packageJsonRaw);
+    if (!packageJson.scripts) {
+      packageJson.scripts = {};
+    }
+    if (!packageJson.scripts["i18n-extract"]) {
+      packageJson.scripts["i18n-extract"] = "i18next-cli extract --sync-primary";
+      context.updateFile("package.json", JSON.stringify(packageJson, null, 2));
+      additionsDebug("Added i18n-extract script to package.json");
+    } else {
+      additionsDebug("i18n-extract script already exists, skipping");
+    }
+  } catch (error) {
+    additionsDebug("Error adding i18n-extract script:", error);
+  }
+}
+function updateEslintConfig(context) {
+  if (!context.doesFileExist("eslint.config.mjs")) {
+    additionsDebug("eslint.config.mjs not found, skipping");
+    return;
+  }
+  const eslintConfigRaw = context.getFile("eslint.config.mjs");
+  if (!eslintConfigRaw) {
+    return;
+  }
+  if (eslintConfigRaw.includes("@grafana/i18n/eslint-plugin")) {
+    additionsDebug("ESLint i18n rule already configured");
+    return;
+  }
+  try {
+    const ast = recast.parse(eslintConfigRaw, {
+      parser: babelParser
+    });
+    const imports = ast.program.body.filter((node) => node.type === "ImportDeclaration");
+    const lastImport = imports[imports.length - 1];
+    if (lastImport) {
+      const pluginImport = builders.importDeclaration(
+        [builders.importDefaultSpecifier(builders.identifier("grafanaI18nPlugin"))],
+        builders.literal("@grafana/i18n/eslint-plugin")
+      );
+      const lastImportIndex = ast.program.body.indexOf(lastImport);
+      ast.program.body.splice(lastImportIndex + 1, 0, pluginImport);
+    }
+    recast.visit(ast, {
+      visitCallExpression(path) {
+        if (path.node.callee.name === "defineConfig" && path.node.arguments[0]?.type === "ArrayExpression") {
+          const configArray = path.node.arguments[0];
+          const i18nConfig = builders.objectExpression([
+            builders.property("init", builders.identifier("name"), builders.literal("grafana/i18n-rules")),
+            builders.property(
+              "init",
+              builders.identifier("plugins"),
+              builders.objectExpression([
+                builders.property("init", builders.literal("@grafana/i18n"), builders.identifier("grafanaI18nPlugin"))
+              ])
+            ),
+            builders.property(
+              "init",
+              builders.identifier("rules"),
+              builders.objectExpression([
+                builders.property(
+                  "init",
+                  builders.literal("@grafana/i18n/no-untranslated-strings"),
+                  builders.arrayExpression([
+                    builders.literal("error"),
+                    builders.objectExpression([
+                      builders.property(
+                        "init",
+                        builders.identifier("calleesToIgnore"),
+                        builders.arrayExpression([builders.literal("^css$"), builders.literal("use[A-Z].*")])
+                      )
+                    ])
+                  ])
+                ),
+                builders.property(
+                  "init",
+                  builders.literal("@grafana/i18n/no-translation-top-level"),
+                  builders.literal("error")
+                )
+              ])
+            )
+          ]);
+          configArray.elements.push(i18nConfig);
+        }
+        this.traverse(path);
+      }
+    });
+    const output = recast.print(ast, {
+      tabWidth: 2,
+      trailingComma: true,
+      lineTerminator: "\n"
+    }).code;
+    context.updateFile("eslint.config.mjs", output);
+    additionsDebug("Updated eslint.config.mjs with i18n linting rules");
+  } catch (error) {
+    additionsDebug("Error updating eslint.config.mjs:", error);
+  }
+}
+
+export { addI18nDependency, addI18nextCli, addSemverDependency, updateEslintConfig };

package/dist/codemods/additions/scripts/i18n/utils.js

@@ -0,0 +1,50 @@
+import { coerce, gte } from 'semver';
+import { additionsDebug } from '../../../utils.js';
+
+function checkNeedsBackwardCompatibility(context) {
+  const pluginJsonRaw = context.getFile("src/plugin.json");
+  if (!pluginJsonRaw) {
+    return false;
+  }
+  try {
+    const pluginJson = JSON.parse(pluginJsonRaw);
+    const currentGrafanaDep = pluginJson.dependencies?.grafanaDependency || ">=11.0.0";
+    const minVersion = coerce("12.1.0");
+    const currentVersion = coerce(currentGrafanaDep.replace(/^[><=]+/, ""));
+    if (currentVersion && minVersion && gte(currentVersion, minVersion)) {
+      return false;
+    }
+    return true;
+  } catch (error) {
+    additionsDebug("Error checking backward compatibility:", error);
+    return true;
+  }
+}
+function createLocaleFiles(context, locales) {
+  const pluginJsonRaw = context.getFile("src/plugin.json");
+  if (!pluginJsonRaw) {
+    additionsDebug("Cannot create locale files without plugin.json");
+    return;
+  }
+  try {
+    const pluginJson = JSON.parse(pluginJsonRaw);
+    const pluginId = pluginJson.id;
+    if (!pluginId) {
+      additionsDebug("No plugin ID found in plugin.json");
+      return;
+    }
+    for (const locale of locales) {
+      const localePath = `src/locales/${locale}/${pluginId}.json`;
+      if (!context.doesFileExist(localePath)) {
+        context.addFile(localePath, JSON.stringify({}, null, 2));
+        additionsDebug(`Created ${localePath}`);
+      } else {
+        additionsDebug(`${localePath} already exists, skipping`);
+      }
+    }
+  } catch (error) {
+    additionsDebug("Error creating locale files:", error);
+  }
+}
+
+export { checkNeedsBackwardCompatibility, createLocaleFiles };

package/dist/codemods/utils.js

@@ -205,6 +205,6 @@ function sortObjectByKeys(obj) {
   return Object.keys(obj).sort().reduce((acc, key) => ({ ...acc, [key]: obj[key] }), {});
 }
 const migrationsDebug = debug.extend("migrations");
-debug.extend("additions");
+const additionsDebug = debug.extend("additions");
 
-export { addDependenciesToPackageJson, flushChanges, formatFiles, installNPMDependencies, isVersionGreater, migrationsDebug, printChanges, readJsonFile, removeDependenciesFromPackageJson };
+export { addDependenciesToPackageJson, additionsDebug, flushChanges, formatFiles, installNPMDependencies, isVersionGreater, migrationsDebug, printChanges, readJsonFile, removeDependenciesFromPackageJson };

package/dist/constants.js

@@ -1,13 +1,13 @@
 import { fileURLToPath } from 'node:url';
 import path from 'node:path';
 
-const __dirname = fileURLToPath(new URL(".", import.meta.url));
+const __dirname$1 = fileURLToPath(new URL(".", import.meta.url));
 const IS_DEV = process.env.CREATE_PLUGIN_DEV !== void 0;
 const EXPORT_PATH_PREFIX = process.cwd();
-path.join(__dirname, "dist");
-const TEMPLATES_DIR = path.join(__dirname, "..", "templates");
+path.join(__dirname$1, "dist");
+const TEMPLATES_DIR = path.join(__dirname$1, "..", "templates");
 const PARTIALS_DIR = path.join(TEMPLATES_DIR, "_partials");
-path.join(__dirname, "..", "fixtures");
+path.join(__dirname$1, "..", "fixtures");
 const TEMPLATE_PATHS = {
   app: path.join(TEMPLATES_DIR, "app"),
   scenesapp: path.join(TEMPLATES_DIR, "scenes-app"),

package/dist/libs/version/src/index.js

@@ -2,9 +2,9 @@ import { findUpSync } from 'find-up';
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 
-const __dirname = fileURLToPath(new URL(".", import.meta.url));
+const __dirname$1 = fileURLToPath(new URL(".", import.meta.url));
 function getVersion() {
-  const packageJsonPath = findUpSync("package.json", { cwd: __dirname });
+  const packageJsonPath = findUpSync("package.json", { cwd: __dirname$1 });
   if (!packageJsonPath) {
     throw `Could not find package.json`;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grafana/create-plugin",
-  "version": "6.3.0-canary.2314.19540598852.0",
+  "version": "6.3.0-canary.2320.19631436862.0",
   "repository": {
     "directory": "packages/create-plugin",
     "url": "https://github.com/grafana/plugin-tools"
@@ -32,7 +32,7 @@
     "debug": "^4.3.4",
     "enquirer": "^2.4.1",
     "find-up": "^8.0.0",
-    "glob": "^11.0.0",
+    "glob": "^11.1.0",
     "handlebars": "^4.7.8",
     "jsonc-parser": "^3.3.1",
     "minimist": "^1.2.8",
@@ -61,5 +61,5 @@
   "engines": {
     "node": ">=20"
   },
-  "gitHead": "45cfdfb7b4869737a8f7f437da9028de3e618024"
+  "gitHead": "7076bccb19de370a195a80655558f600ee067d25"
 }

package/src/codemods/AGENTS.md

@@ -0,0 +1,25 @@
+# Create Plugin Codemods Guide
+
+This guide provides specific instructions for working with migrations and additions in the create-plugin package.
+
+## Agent Behavior
+
+- Refer to current migrations and additions typescript files found in @./additions/scripts and @./migrations/scripts
+- When creating a new migration add it to the exported migrations object in @./migrations/migrations.ts
+- Always refer to @./context.ts to know what methods are available on the context class
+- Always check for file existence using the @./context.ts class before attempting to do anything with it
+- Never write files with any 3rd party npm library. Use the context for all file operations
+- Always return the context for the next migration
+- Test thoroughly using the provided utils in @./test-utils.ts where necessary
+- Each migration must be idempotent and must include a test case that uses the `.toBeIdempotent` custom matcher found in @../../vitest.setup.ts
+- Keep migrations focused on one task
+- Never attempt to read or write files outside the current working directory
+
+## Naming Conventions
+
+- Each migration lives under @./migrations/scripts
+- Migration filenames follow the format: `NNN-migration-title` where migration-title is, at the most, a three word summary of what the migration does and NNN is the next number in sequence based on the current file name in @./migrations/scripts
+- Each migration must have:
+  - `NNN-migration-title.ts` - main migration logic
+  - `NNN-migration-title.test.ts` - migration logic tests
+- Each migration should export a default function named "migrate"

package/src/codemods/additions/additions.ts

@@ -6,4 +6,9 @@ export default [
     description: 'Adds an example addition to the plugin',
     scriptPath: import.meta.resolve('./scripts/example-addition.js'),
   },
+  {
+    name: 'i18n',
+    description: 'Adds internationalization (i18n) support to the plugin',
+    scriptPath: import.meta.resolve('./scripts/i18n/index.js'),
+  },
 ] satisfies Codemod[];