@trackunit/eslint-plugin-trackunit 0.6.98-alpha-7bd3cf90b54.0 → 0.6.98

package/src/lib/rules/no-dynamic-translation-key/no-dynamic-translation-key.d.ts

@@ -0,0 +1,23 @@
+/**
+ * ESLint rule that discourages building i18next translation keys dynamically
+ * with template strings (e.g. `t(`pages.categories.${category}`)`).
+ *
+ * Dynamic keys are impossible to analyse statically: they defeat the typed
+ * translation-key safety and make it impossible to tell which keys in a
+ * `translation.json` are actually used. Mapping the value to an explicit key
+ * with a `switch` statement or a `Record` keeps keys statically analysable and
+ * lets `no-unused-translation-key` detect orphaned translations.
+ *
+ * @example
+ * // Bad
+ * t(`pages.categories.${category}`);
+ * <Trans i18nKey={`pages.categories.${category}`} />;
+ *
+ * // Good
+ * const categoryKey: Record<Category, TranslationKeys> = { ... };
+ * t(categoryKey[category]);
+ */
+import { ESLintUtils } from "@typescript-eslint/utils";
+export declare const noDynamicTranslationKey: ESLintUtils.RuleModule<"dynamicKey", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};

package/src/lib/rules/no-dynamic-translation-key/no-dynamic-translation-key.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noDynamicTranslationKey = void 0;
+/**
+ * ESLint rule that discourages building i18next translation keys dynamically
+ * with template strings (e.g. `t(`pages.categories.${category}`)`).
+ *
+ * Dynamic keys are impossible to analyse statically: they defeat the typed
+ * translation-key safety and make it impossible to tell which keys in a
+ * `translation.json` are actually used. Mapping the value to an explicit key
+ * with a `switch` statement or a `Record` keeps keys statically analysable and
+ * lets `no-unused-translation-key` detect orphaned translations.
+ *
+ * @example
+ * // Bad
+ * t(`pages.categories.${category}`);
+ * <Trans i18nKey={`pages.categories.${category}`} />;
+ *
+ * // Good
+ * const categoryKey: Record<Category, TranslationKeys> = { ... };
+ * t(categoryKey[category]);
+ */
+const utils_1 = require("@typescript-eslint/utils");
+const createRule = utils_1.ESLintUtils.RuleCreator(name => `https://github.com/trackunit/manager/blob/main/libs/eslint/plugin-trackunit/src/lib/rules/${name}/${name}.ts`);
+/** A template literal that actually interpolates a value, e.g. `foo.${bar}` (not a plain `foo`). */
+const isInterpolatedTemplate = (node) => node.type === utils_1.AST_NODE_TYPES.TemplateLiteral && node.expressions.length > 0;
+/** A call to the translation function: either a bare `t(...)` or a member call like `i18n.t(...)`. */
+const isTranslationCallee = (callee) => {
+    if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return callee.name === "t";
+    }
+    return (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        !callee.computed &&
+        callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+        callee.property.name === "t");
+};
+exports.noDynamicTranslationKey = createRule({
+    name: "no-dynamic-translation-key",
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Disallow building i18next translation keys dynamically with template strings; map values to explicit keys with a switch or Record instead.",
+        },
+        messages: {
+            dynamicKey: "Avoid building translation keys dynamically with template strings. Map the value to an explicit key using a switch statement or a Record so keys stay statically analysable and unused keys can be detected.",
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            CallExpression(node) {
+                if (!isTranslationCallee(node.callee)) {
+                    return;
+                }
+                const [firstArg] = node.arguments;
+                if (firstArg && isInterpolatedTemplate(firstArg)) {
+                    context.report({ node: firstArg, messageId: "dynamicKey" });
+                }
+            },
+            JSXAttribute(node) {
+                if (node.name.type !== utils_1.AST_NODE_TYPES.JSXIdentifier || node.name.name !== "i18nKey") {
+                    return;
+                }
+                const { value } = node;
+                if (value?.type === utils_1.AST_NODE_TYPES.JSXExpressionContainer && isInterpolatedTemplate(value.expression)) {
+                    context.report({ node: value.expression, messageId: "dynamicKey" });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-dynamic-translation-key.js.map

package/src/lib/rules/no-template-strings-in-classname-prop/no-template-strings-in-classname-prop.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.noTemplateStringsInClassName = void 0;
+const css_classname_utils_1 = require("@trackunit/css-classname-utils");
 const utils_1 = require("@typescript-eslint/utils");
-const classname_utils_1 = require("../../utils/classname-utils");
 const createRule = utils_1.ESLintUtils.RuleCreator(name => `https://github.com/trackunit/manager/blob/main/libs/eslint/plugin-trackunit/src/lib/rules/${name}.ts`);
 /**
  * ESLint rule to disallow template strings in className prop.
@@ -40,7 +40,7 @@ exports.noTemplateStringsInClassName = createRule({
              */
             JSXAttribute(node) {
                 // Check if this is a classname attribute (className or class)
-                if (node.name.type !== utils_1.AST_NODE_TYPES.JSXIdentifier || !(0, classname_utils_1.isClassnameAttribute)(node.name.name)) {
+                if (node.name.type !== utils_1.AST_NODE_TYPES.JSXIdentifier || !(0, css_classname_utils_1.isClassnameAttribute)(node.name.name)) {
                     return;
                 }
                 // Check if the value is a template literal in a JSX expression container
@@ -50,7 +50,7 @@ exports.noTemplateStringsInClassName = createRule({
                 }
             },
             VariableDeclarator(node) {
-                const locations = (0, classname_utils_1.findClassnameStringsInVariable)(node);
+                const locations = (0, css_classname_utils_1.findClassnameStringsInVariable)(node);
                 for (const location of locations) {
                     if (location.fixNode.type === utils_1.AST_NODE_TYPES.TemplateLiteral) {
                         context.report({ node: location.reportNode, messageId: "templateStringInClassName" });

package/src/lib/rules/no-unused-translation-key/no-unused-translation-key.d.ts

@@ -0,0 +1,24 @@
+/**
+ * ESLint rule that reports translation keys defined in a library's
+ * `locales/en/translation.json` that are never referenced anywhere in that
+ * library's source.
+ *
+ * Each library owns its own namespaced translations (see docs/tech/I18N.md), so
+ * a key is considered used when it appears quoted anywhere in the owning
+ * library's `.ts`/`.tsx` files ("conservative-anywhere" matching). Keys reached
+ * through a dynamic template (`` t(`prefix.${x}`) ``) are kept via the static
+ * text bookending the interpolation, and i18next plural forms are kept whenever
+ * their base key is referenced. A dynamic template keeps every key under its
+ * prefix, so keys behind one cannot be reported until the call site uses a
+ * static key — what the companion `no-dynamic-translation-key` rule asks for.
+ *
+ * Matching is a heuristic over source text: this rule is `warn`-only and has no
+ * fixer, so a key it reports is a candidate for review rather than for deletion.
+ *
+ * Runs only on `**\/locales/en/translation.json` — the English file is the
+ * source of truth; other languages are managed by Crowdin.
+ */
+import { ESLintUtils } from "@typescript-eslint/utils";
+export declare const noUnusedTranslationKey: ESLintUtils.RuleModule<"unusedKey", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};

package/src/lib/rules/no-unused-translation-key/no-unused-translation-key.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noUnusedTranslationKey = void 0;
+const tslib_1 = require("tslib");
+/**
+ * ESLint rule that reports translation keys defined in a library's
+ * `locales/en/translation.json` that are never referenced anywhere in that
+ * library's source.
+ *
+ * Each library owns its own namespaced translations (see docs/tech/I18N.md), so
+ * a key is considered used when it appears quoted anywhere in the owning
+ * library's `.ts`/`.tsx` files ("conservative-anywhere" matching). Keys reached
+ * through a dynamic template (`` t(`prefix.${x}`) ``) are kept via the static
+ * text bookending the interpolation, and i18next plural forms are kept whenever
+ * their base key is referenced. A dynamic template keeps every key under its
+ * prefix, so keys behind one cannot be reported until the call site uses a
+ * static key — what the companion `no-dynamic-translation-key` rule asks for.
+ *
+ * Matching is a heuristic over source text: this rule is `warn`-only and has no
+ * fixer, so a key it reports is a candidate for review rather than for deletion.
+ *
+ * Runs only on `**\/locales/en/translation.json` — the English file is the
+ * source of truth; other languages are managed by Crowdin.
+ */
+const utils_1 = require("@typescript-eslint/utils");
+const path = tslib_1.__importStar(require("path"));
+const file_utils_1 = require("../../utils/file-utils");
+const used_strings_1 = require("./used-strings");
+const createRule = utils_1.ESLintUtils.RuleCreator(name => `https://github.com/trackunit/manager/blob/main/libs/eslint/plugin-trackunit/src/lib/rules/${name}/${name}.ts`);
+const TRANSLATION_FILE_SUFFIX = "/locales/en/translation.json";
+const parseTranslationObject = (raw) => {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        return null;
+    }
+    return { ...parsed };
+};
+exports.noUnusedTranslationKey = createRule({
+    name: "no-unused-translation-key",
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Report translation keys in a library's locales/en/translation.json that are never referenced in that library's source.",
+        },
+        messages: {
+            unusedKey: 'Translation key "{{key}}" is not referenced anywhere in this library and can be removed.',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            Program: () => {
+                const filePath = context.filename.replace(/\\/g, "/");
+                if (!filePath.endsWith(TRANSLATION_FILE_SUFFIX)) {
+                    return;
+                }
+                const projectJsonPath = (0, file_utils_1.findNearestFile)(context.filename, "project.json");
+                if (!projectJsonPath) {
+                    return;
+                }
+                const raw = context.sourceCode.getText();
+                const translations = parseTranslationObject(raw);
+                if (!translations) {
+                    return;
+                }
+                const used = (0, used_strings_1.getUsedTranslationStrings)(path.dirname(projectJsonPath));
+                const lines = raw.split("\n");
+                for (const key of Object.keys(translations)) {
+                    if ((0, used_strings_1.isTranslationKeyUsed)(used, key)) {
+                        continue;
+                    }
+                    const keyToken = `"${key}"`;
+                    const lineIndex = lines.findIndex(text => text.includes(`${keyToken}:`));
+                    const line = lineIndex >= 0 ? lineIndex + 1 : 1;
+                    const startColumn = lineIndex >= 0 ? Math.max(lines[lineIndex]?.indexOf(keyToken) ?? 0, 0) : 0;
+                    context.report({
+                        messageId: "unusedKey",
+                        data: { key },
+                        loc: {
+                            start: { line, column: startColumn },
+                            end: { line, column: startColumn + keyToken.length },
+                        },
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-unused-translation-key.js.map

package/src/lib/rules/no-unused-translation-key/used-strings.d.ts

@@ -0,0 +1,43 @@
+/** The static parts surrounding the interpolation(s) in a dynamically built key. */
+export type DynamicPattern = {
+    /** Static text before the first `${...}` (empty for leading interpolation). */
+    prefix: string;
+    /** Static text after the last `${...}` (empty for trailing interpolation). */
+    suffix: string;
+};
+/**
+ * What a library's source says about the translation keys it uses.
+ *
+ * - `sourceText` — the library's `.ts`/`.tsx` files concatenated. A key is used when it appears in
+ *   this text wrapped in quotes. Searching for the key itself puts no constraints on what a key may
+ *   contain, so keys with spaces (`machine.types.Air Compressor`), empty segments (`a..b`) and
+ *   punctuation (`p&pMigrated`) all match. Matching is deliberately broad ("conservative-anywhere"):
+ *   a key counts as used wherever it appears, including as a prop passed to a child component
+ *   (e.g. `titleKey="a.b"`).
+ * - `dynamicPatterns` — the static bookends of a dynamically built key, e.g.
+ *   `` t(`pages.categories.${x}`) `` contributes `{ prefix: "pages.categories.", suffix: "" }` and
+ *   `` t(`${root}.title`) `` contributes `{ prefix: "", suffix: ".title" }`. A key is treated as used
+ *   when it both starts with the prefix and ends with the suffix of some pattern — the smallest set of
+ *   keys the interpolation could possibly produce.
+ */
+export type UsedStrings = {
+    sourceText: string;
+    dynamicPatterns: Array<DynamicPattern>;
+};
+/**
+ * Build the used-strings summary from already-read source file contents.
+ *
+ * Kept free of filesystem access so the ESLint rule and the
+ * `devtools/translations/remove-unused-translation-keys` script share one implementation of what
+ * "used" means, each doing its own IO.
+ */
+export declare const buildUsedStrings: (contents: Array<string>) => UsedStrings;
+/**
+ * Read a library's `.ts`/`.tsx` source, keeping the raw text plus any dynamic key patterns it builds.
+ */
+export declare const getUsedTranslationStrings: (projectDir: string) => UsedStrings;
+/**
+ * Whether a translation key is referenced by the scanned source — quoted verbatim, through a dynamic
+ * template's static bookends, or as the plural form of a referenced base key.
+ */
+export declare const isTranslationKeyUsed: (used: UsedStrings, key: string) => boolean;

package/src/lib/rules/no-unused-translation-key/used-strings.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTranslationKeyUsed = exports.getUsedTranslationStrings = exports.buildUsedStrings = void 0;
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+const EXCLUDED_DIRS = new Set(["node_modules", "dist", "generated", "coverage", ".git"]);
+const SCANNED_EXTENSIONS = [".ts", ".tsx"];
+/**
+ * The plural (and optional ordinal) suffix i18next appends to a base key at runtime: `entityCount`
+ * resolves to `entityCount_one` or `entityCount_other` depending on the `count` option. Source code
+ * only ever mentions the base key, so a suffixed key is used whenever its base key is.
+ */
+const PLURAL_SUFFIX_REGEX = /_(?:ordinal_)?(?:zero|one|two|few|many|other|plural)$/;
+/** A template literal passed directly to `t(`/`.t(` or an `i18nKey={` attribute. */
+const TRANSLATION_TEMPLATE_REGEX = /(?:\bt\(\s*|i18nKey=\{\s*)`([^`]*)`/g;
+/** Any template literal — catches keys built through a variable, e.g. `const k = `a.b.${x}`; t(k)`. */
+const ANY_TEMPLATE_REGEX = /`([^`]*)`/g;
+/**
+ * Record the dynamic-key pattern for a template body, if applicable.
+ *
+ * `trusted` templates (written directly inside `t(...)`/`i18nKey={...}`) always contribute a pattern —
+ * including a bare `${x}` (empty prefix and suffix), which acts as a wildcard for libraries whose whole
+ * key is dynamic (e.g. `t(`${category}`)`). Untrusted templates (any other backtick string, e.g. one
+ * assigned to a variable then passed to `t`) only contribute when they look like a namespaced key — a
+ * dot in the prefix or suffix — so unrelated templates like `${count}` or `hello ${name}` don't
+ * wildcard-disable detection.
+ */
+const recordTemplatePattern = (body, trusted, patterns) => {
+    const interpolationStart = body.indexOf("${");
+    if (interpolationStart === -1) {
+        // A backtick string with no interpolation is a plain key; sourceText already covers it.
+        return;
+    }
+    const prefix = body.slice(0, interpolationStart);
+    const lastInterpolationEnd = body.lastIndexOf("}");
+    const suffix = lastInterpolationEnd === -1 ? "" : body.slice(lastInterpolationEnd + 1);
+    if (!trusted && !prefix.includes(".") && !suffix.includes(".")) {
+        return;
+    }
+    patterns.set(JSON.stringify([prefix, suffix]), { prefix, suffix });
+};
+const collectSourceFiles = (dir, files = []) => {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return files;
+    }
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (!EXCLUDED_DIRS.has(entry.name)) {
+                collectSourceFiles(fullPath, files);
+            }
+        }
+        else if (SCANNED_EXTENSIONS.some(ext => entry.name.endsWith(ext))) {
+            files.push(fullPath);
+        }
+    }
+    return files;
+};
+/**
+ * Build the used-strings summary from already-read source file contents.
+ *
+ * Kept free of filesystem access so the ESLint rule and the
+ * `devtools/translations/remove-unused-translation-keys` script share one implementation of what
+ * "used" means, each doing its own IO.
+ */
+const buildUsedStrings = (contents) => {
+    const patterns = new Map();
+    for (const content of contents) {
+        let translationTemplate;
+        while ((translationTemplate = TRANSLATION_TEMPLATE_REGEX.exec(content)) !== null) {
+            recordTemplatePattern(translationTemplate[1] ?? "", true, patterns);
+        }
+        let anyTemplate;
+        while ((anyTemplate = ANY_TEMPLATE_REGEX.exec(content)) !== null) {
+            recordTemplatePattern(anyTemplate[1] ?? "", false, patterns);
+        }
+    }
+    return { sourceText: contents.join("\n"), dynamicPatterns: [...patterns.values()] };
+};
+exports.buildUsedStrings = buildUsedStrings;
+/**
+ * Read a library's `.ts`/`.tsx` source, keeping the raw text plus any dynamic key patterns it builds.
+ */
+const getUsedTranslationStrings = (projectDir) => {
+    const contents = [];
+    for (const file of collectSourceFiles(projectDir)) {
+        try {
+            contents.push(fs.readFileSync(file, "utf8"));
+        }
+        catch {
+            continue;
+        }
+    }
+    return (0, exports.buildUsedStrings)(contents);
+};
+exports.getUsedTranslationStrings = getUsedTranslationStrings;
+/** Whether the key appears in the source as a quoted string, in any of the three quote styles. */
+const isQuotedInSource = (sourceText, key) => sourceText.includes(`"${key}"`) || sourceText.includes(`'${key}'`) || sourceText.includes(`\`${key}\``);
+/**
+ * Whether a translation key is referenced by the scanned source — quoted verbatim, through a dynamic
+ * template's static bookends, or as the plural form of a referenced base key.
+ */
+const isTranslationKeyUsed = (used, key) => {
+    const isReferenced = (candidate) => isQuotedInSource(used.sourceText, candidate) ||
+        used.dynamicPatterns.some(({ prefix, suffix }) => candidate.startsWith(prefix) && candidate.endsWith(suffix));
+    return isReferenced(key) || (PLURAL_SUFFIX_REGEX.test(key) && isReferenced(key.replace(PLURAL_SUFFIX_REGEX, "")));
+};
+exports.isTranslationKeyUsed = isTranslationKeyUsed;
+//# sourceMappingURL=used-strings.js.map

package/src/lib/rules/require-classname-alternatives/require-classname-alternatives.js

@@ -1,26 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.requireClassnameAlternatives = void 0;
+const css_classname_utils_1 = require("@trackunit/css-classname-utils");
 const utils_1 = require("@typescript-eslint/utils");
-const classname_utils_1 = require("../../utils/classname-utils");
 const createRule = utils_1.ESLintUtils.RuleCreator(name => `https://github.com/trackunit/manager/blob/main/libs/eslint/plugin-trackunit/src/lib/rules/${name}.ts`);
-/**
- * Replace a specific pattern in a string with its replacement.
- * Handles both prefix-based patterns (e.g., bg-red-500 -> bg-danger-500)
- * and exact matches.
- */
-function replacePattern(value, oldPattern, newPattern, hasPrefixes) {
-    if (hasPrefixes) {
-        // With prefixes, replace -oldPattern- with -newPattern-
-        const pattern = new RegExp(`-${oldPattern}(-|$|/)`, "g");
-        return value.replace(pattern, `-${newPattern}$1`);
-    }
-    else {
-        // Without prefixes, replace exact word boundaries
-        const pattern = new RegExp(`(^|\\s)${oldPattern}($|\\s)`, "g");
-        return value.replace(pattern, `$1${newPattern}$2`);
-    }
-}
 /**
  * Build a regex pattern that matches class names based on configuration.
  *
@@ -118,8 +101,8 @@ exports.requireClassnameAlternatives = createRule({
             let result = value;
             for (const [pattern, alts] of Object.entries(alternatives)) {
                 const singleAlternative = alts.length === 1 ? alts[0] : undefined;
-                if (singleAlternative) {
-                    result = replacePattern(result, pattern, singleAlternative, hasPrefixes);
+                if (singleAlternative !== undefined) {
+                    result = (0, css_classname_utils_1.replaceClassToken)(result, pattern, singleAlternative, { prefixes });
                 }
             }
             return result;
@@ -175,7 +158,7 @@ exports.requireClassnameAlternatives = createRule({
                         if (typeof originalValue !== "string") {
                             return null;
                         }
-                        const fixedValue = replacePattern(originalValue, oldPattern, newPattern, hasPrefixes);
+                        const fixedValue = (0, css_classname_utils_1.replaceClassToken)(originalValue, oldPattern, newPattern, { prefixes });
                         const raw = stringLiteralNode.raw;
                         const quote = raw.charAt(0);
                         return fixer.replaceText(stringLiteralNode, `${quote}${fixedValue}${quote}`);
@@ -187,7 +170,7 @@ exports.requireClassnameAlternatives = createRule({
                                 ? quasi.value.raw.includes(`-${oldPattern}`)
                                 : quasi.value.raw.includes(oldPattern);
                             if (containsPattern) {
-                                const fixedRaw = replacePattern(quasi.value.raw, oldPattern, newPattern, hasPrefixes);
+                                const fixedRaw = (0, css_classname_utils_1.replaceClassToken)(quasi.value.raw, oldPattern, newPattern, { prefixes });
                                 const rangeStart = quasi.range[0] + (quasi.tail ? 1 : 0);
                                 const rangeEnd = quasi.range[1] - (quasi.tail ? 1 : 0);
                                 fixes.push(fixer.replaceTextRange([rangeStart, rangeEnd], quasi.tail ? fixedRaw : fixedRaw + (quasi.value.raw.endsWith(" ") ? "" : "")));
@@ -222,7 +205,7 @@ exports.requireClassnameAlternatives = createRule({
                     if (!patternIsAutoFixable) {
                         suggest = patternAlternatives.map(alternative => ({
                             messageId: "suggestReplacement",
-                            data: { replacement: replacePattern(usage.match, usage.pattern, alternative, hasPrefixes) },
+                            data: { replacement: (0, css_classname_utils_1.replaceClassToken)(usage.match, usage.pattern, alternative, { prefixes }) },
                             fix: createSuggestionFixer(stringLiteralNode, usage.pattern, alternative),
                         }));
                     }
@@ -254,19 +237,19 @@ exports.requireClassnameAlternatives = createRule({
         }
         return {
             JSXAttribute(node) {
-                const locations = (0, classname_utils_1.findClassnameStringsInAttribute)(node);
+                const locations = (0, css_classname_utils_1.findClassnameStringsInAttribute)(node);
                 for (const location of locations) {
                     checkAndReport(location.reportNode, location.value, location.fixNode);
                 }
             },
             CallExpression(node) {
-                const locations = (0, classname_utils_1.findClassnameStringsInCall)(node);
+                const locations = (0, css_classname_utils_1.findClassnameStringsInCall)(node);
                 for (const location of locations) {
                     checkAndReport(location.reportNode, location.value, location.fixNode);
                 }
             },
             VariableDeclarator(node) {
-                const locations = (0, classname_utils_1.findClassnameStringsInVariable)(node);
+                const locations = (0, css_classname_utils_1.findClassnameStringsInVariable)(node);
                 for (const location of locations) {
                     checkAndReport(location.reportNode, location.value, location.fixNode);
                 }

package/src/lib/rules-map.d.ts

@@ -25,6 +25,9 @@ export declare const rulesMap: {
     "no-deprecated-graphql-fields": ESLintUtils.RuleModule<"deprecatedFieldUsed", [], unknown, ESLintUtils.RuleListener> & {
         name: string;
     };
+    "no-dynamic-translation-key": ESLintUtils.RuleModule<"dynamicKey", [], unknown, ESLintUtils.RuleListener> & {
+        name: string;
+    };
     "no-internal-graphql-when-tagged-with-gql-public": ESLintUtils.RuleModule<"internalGraphqlFileFound", [], unknown, ESLintUtils.RuleListener> & {
         name: string;
     };
@@ -34,6 +37,9 @@ export declare const rulesMap: {
     "no-template-strings-in-classname-prop": ESLintUtils.RuleModule<"templateStringInClassName", [], unknown, ESLintUtils.RuleListener> & {
         name: string;
     };
+    "no-unused-translation-key": ESLintUtils.RuleModule<"unusedKey", [], unknown, ESLintUtils.RuleListener> & {
+        name: string;
+    };
     "require-classname-alternatives": ESLintUtils.RuleModule<"bannedClassAutoFix" | "bannedClassSuggest" | "suggestReplacement", [({
         alternatives: Record<string, Array<string>>;
         prefixes?: Array<string>;

package/src/lib/rules-map.js

@@ -5,11 +5,13 @@ const component_name_matches_filename_1 = require("./rules/component-name-matche
 const cva_merge_base_classes_as_array_1 = require("./rules/cva-merge-base-classes-as-array/cva-merge-base-classes-as-array");
 const design_guideline_button_icon_size_match_1 = require("./rules/design-guideline-button-icon-size-match/design-guideline-button-icon-size-match");
 const no_deprecated_graphql_fields_1 = require("./rules/no-deprecated-graphql-fields/no-deprecated-graphql-fields");
+const no_dynamic_translation_key_1 = require("./rules/no-dynamic-translation-key/no-dynamic-translation-key");
 const no_internal_barrel_files_1 = require("./rules/no-internal-barrel-files/no-internal-barrel-files");
 const no_internal_graphql_when_tagged_with_gql_public_1 = require("./rules/no-internal-graphql-when-tagged-with-gql-public/no-internal-graphql-when-tagged-with-gql-public");
 const no_jest_mock_trackunit_react_core_hooks_1 = require("./rules/no-jest-mock-trackunit-react-core-hooks/no-jest-mock-trackunit-react-core-hooks");
 const no_template_strings_in_classname_prop_1 = require("./rules/no-template-strings-in-classname-prop/no-template-strings-in-classname-prop");
 const no_typescript_assertion_1 = require("./rules/no-typescript-assertion/no-typescript-assertion");
+const no_unused_translation_key_1 = require("./rules/no-unused-translation-key/no-unused-translation-key");
 const one_component_per_file_1 = require("./rules/one-component-per-file/one-component-per-file");
 const prefer_destructured_imports_1 = require("./rules/prefer-destructured-imports/prefer-destructured-imports");
 const prefer_event_specific_callback_naming_1 = require("./rules/prefer-event-specific-callback-naming/prefer-event-specific-callback-naming");
@@ -27,9 +29,11 @@ exports.rulesMap = {
     "no-internal-barrel-files": no_internal_barrel_files_1.noInternalBarrelFiles,
     "no-typescript-assertion": no_typescript_assertion_1.noTypescriptAssertion,
     "no-deprecated-graphql-fields": no_deprecated_graphql_fields_1.noDeprecatedGraphqlFields,
+    "no-dynamic-translation-key": no_dynamic_translation_key_1.noDynamicTranslationKey,
     "no-internal-graphql-when-tagged-with-gql-public": no_internal_graphql_when_tagged_with_gql_public_1.noInternalGraphqlWhenTaggedWithGqlPublic,
     "design-guideline-button-icon-size-match": design_guideline_button_icon_size_match_1.designGuidelineButtonIconSizeMatch,
     "no-template-strings-in-classname-prop": no_template_strings_in_classname_prop_1.noTemplateStringsInClassName,
+    "no-unused-translation-key": no_unused_translation_key_1.noUnusedTranslationKey,
     "require-classname-alternatives": require_classname_alternatives_1.requireClassnameAlternatives,
     "no-jest-mock-trackunit-react-core-hooks": no_jest_mock_trackunit_react_core_hooks_1.noJestMockTrackunitReactCoreHooks,
     "prefer-destructured-imports": prefer_destructured_imports_1.preferDestructuredImports,