@intl-party/eslint-plugin 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 IntlParty Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,53 @@
+import * as _typescript_eslint_utils_ts_eslint from '@typescript-eslint/utils/ts-eslint';
+
+declare const plugin: {
+    meta: {
+        name: string;
+        version: string;
+    };
+    rules: {
+        "no-hardcoded-strings": _typescript_eslint_utils_ts_eslint.RuleModule<"hardcodedString" | "hardcodedStringInAttribute", [], _typescript_eslint_utils_ts_eslint.RuleListener>;
+        "no-missing-keys": _typescript_eslint_utils_ts_eslint.RuleModule<"missingTranslationKey" | "invalidTranslationKey", [], _typescript_eslint_utils_ts_eslint.RuleListener>;
+        "prefer-translation-hooks": _typescript_eslint_utils_ts_eslint.RuleModule<"preferUseTranslations" | "preferScopedTranslations", [], _typescript_eslint_utils_ts_eslint.RuleListener>;
+    };
+    configs: {
+        recommended: {
+            plugins: string[];
+            rules: {
+                "@intl-party/no-hardcoded-strings": string;
+                "@intl-party/no-missing-keys": string;
+                "@intl-party/prefer-translation-hooks": string;
+            };
+            settings: {
+                "intl-party": {
+                    translationFiles: string[];
+                    defaultLocale: string;
+                    namespaces: string[];
+                };
+            };
+        };
+        strict: {
+            plugins: string[];
+            rules: {
+                "@intl-party/no-hardcoded-strings": (string | {
+                    attributes: string[];
+                    minLength: number;
+                    ignorePattern: string;
+                })[];
+                "@intl-party/no-missing-keys": string;
+                "@intl-party/prefer-translation-hooks": (string | {
+                    allowDirectUsage: boolean;
+                })[];
+            };
+            settings: {
+                "intl-party": {
+                    translationFiles: string[];
+                    defaultLocale: string;
+                    namespaces: string[];
+                };
+            };
+        };
+    };
+};
+
+export { plugin as default };

package/dist/index.js

@@ -0,0 +1,367 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/rules/no-hardcoded-strings.ts
+var import_utils = require("@typescript-eslint/utils");
+var noHardcodedStrings = import_utils.ESLintUtils.RuleCreator(
+  (name) => `https://github.com/intl-party/intl-party/blob/main/packages/eslint-plugin/docs/rules/${name}.md`
+)({
+  name: "no-hardcoded-strings",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow hardcoded strings in JSX elements and specific attributes",
+      recommended: "warn"
+    },
+    fixable: "code",
+    schema: [
+      {
+        type: "object",
+        properties: {
+          attributes: {
+            type: "array",
+            items: { type: "string" },
+            default: [
+              "placeholder",
+              "title",
+              "aria-label",
+              "aria-description",
+              "alt"
+            ]
+          },
+          ignorePattern: {
+            type: "string",
+            description: "Regex pattern for strings to ignore"
+          },
+          minLength: {
+            type: "number",
+            default: 3,
+            description: "Minimum string length to check"
+          },
+          allowedStrings: {
+            type: "array",
+            items: { type: "string" },
+            default: [],
+            description: "Array of specific strings that are allowed"
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      hardcodedString: 'Hardcoded string "{{text}}" should be translated using t() function',
+      hardcodedStringInAttribute: 'Hardcoded string "{{text}}" in {{attribute}} attribute should be translated using t() function'
+    }
+  },
+  defaultOptions: [{}],
+  create(context, [options = {}]) {
+    const {
+      attributes = [
+        "placeholder",
+        "title",
+        "aria-label",
+        "aria-description",
+        "alt"
+      ],
+      ignorePattern,
+      minLength = 3,
+      allowedStrings = []
+    } = options;
+    const ignoreRegex = ignorePattern ? new RegExp(ignorePattern) : null;
+    function isHardcodedString(value) {
+      if (value.length < minLength) return false;
+      if (allowedStrings.includes(value)) return false;
+      if (ignoreRegex && ignoreRegex.test(value)) return false;
+      if (/^(https?:\/\/|\/|\.\/|\.\.\/)/.test(value)) return false;
+      if (/^[a-z-]+$/.test(value) && value.includes("-")) return false;
+      if (/^[A-Z_][A-Z0-9_]*$/.test(value)) return false;
+      if (/^\d+(\.\d+)?(px|em|rem|%|vh|vw)$/.test(value)) return false;
+      const technicalWords = [
+        "div",
+        "span",
+        "button",
+        "input",
+        "form",
+        "header",
+        "footer",
+        "nav",
+        "main",
+        "section",
+        "article"
+      ];
+      if (technicalWords.includes(value.toLowerCase())) return false;
+      return true;
+    }
+    function checkJSXAttribute(node) {
+      if (node.name.type === "JSXIdentifier" && attributes.includes(node.name.name) && node.value?.type === "Literal" && typeof node.value.value === "string" && isHardcodedString(node.value.value)) {
+        context.report({
+          node: node.value,
+          messageId: "hardcodedStringInAttribute",
+          data: {
+            text: node.value.value,
+            attribute: node.name.name
+          },
+          fix(fixer) {
+            return fixer.replaceText(
+              node.value,
+              `{t('${generateTranslationKey(node.value.value)}')}`
+            );
+          }
+        });
+      }
+    }
+    function checkJSXText(node) {
+      const text = node.value.trim();
+      if (text && isHardcodedString(text)) {
+        context.report({
+          node,
+          messageId: "hardcodedString",
+          data: { text },
+          fix(fixer) {
+            return fixer.replaceText(
+              node,
+              `{t('${generateTranslationKey(text)}')}`
+            );
+          }
+        });
+      }
+    }
+    function generateTranslationKey(text) {
+      return text.toLowerCase().replace(/[^a-z0-9\s]/g, "").replace(/\s+/g, "_").substring(0, 50);
+    }
+    return {
+      JSXAttribute: checkJSXAttribute,
+      JSXText: checkJSXText
+    };
+  }
+});
+
+// src/rules/no-missing-keys.ts
+var import_utils2 = require("@typescript-eslint/utils");
+var noMissingKeys = import_utils2.ESLintUtils.RuleCreator(
+  (name) => `https://github.com/intl-party/intl-party/blob/main/packages/eslint-plugin/docs/rules/${name}.md`
+)({
+  name: "no-missing-keys",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Ensure all translation keys exist in translation files",
+      recommended: "error"
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          translationFiles: {
+            type: "array",
+            items: { type: "string" },
+            description: "Paths to translation files to check against"
+          },
+          defaultLocale: {
+            type: "string",
+            default: "en",
+            description: "Default locale to check keys against"
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      missingTranslationKey: 'Translation key "{{key}}" is missing from translation files',
+      invalidTranslationKey: 'Translation key "{{key}}" has invalid format'
+    }
+  },
+  defaultOptions: [{}],
+  create(context, [options = {}]) {
+    const { translationFiles = [], defaultLocale = "en" } = options;
+    const translationKeys = /* @__PURE__ */ new Set();
+    function isValidTranslationKey(key) {
+      return /^[a-zA-Z][a-zA-Z0-9._-]*$/.test(key);
+    }
+    function checkTranslationCall(node) {
+      if (node.callee.type === "Identifier" && node.callee.name === "t" && node.arguments.length > 0 && node.arguments[0].type === "Literal" && typeof node.arguments[0].value === "string") {
+        const key = node.arguments[0].value;
+        if (!isValidTranslationKey(key)) {
+          context.report({
+            node: node.arguments[0],
+            messageId: "invalidTranslationKey",
+            data: { key }
+          });
+          return;
+        }
+      }
+    }
+    function checkUseTranslationsCall(node) {
+      if (node.callee.type === "Identifier" && node.callee.name === "useTranslations") {
+      }
+    }
+    return {
+      CallExpression(node) {
+        checkTranslationCall(node);
+        checkUseTranslationsCall(node);
+      }
+    };
+  }
+});
+
+// src/rules/prefer-translation-hooks.ts
+var import_utils3 = require("@typescript-eslint/utils");
+var preferTranslationHooks = import_utils3.ESLintUtils.RuleCreator(
+  (name) => `https://github.com/intl-party/intl-party/blob/main/packages/eslint-plugin/docs/rules/${name}.md`
+)({
+  name: "prefer-translation-hooks",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Prefer using translation hooks over direct i18n instance usage in React components",
+      recommended: "warn"
+    },
+    fixable: "code",
+    schema: [
+      {
+        type: "object",
+        properties: {
+          allowDirectUsage: {
+            type: "boolean",
+            default: false,
+            description: "Allow direct i18n instance usage"
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      preferUseTranslations: "Prefer using useTranslations() hook instead of direct i18n.t() usage",
+      preferScopedTranslations: 'Consider using scoped translations for namespace "{{namespace}}"'
+    }
+  },
+  defaultOptions: [{}],
+  create(context, [options = {}]) {
+    const { allowDirectUsage = false } = options;
+    function checkMemberExpression(node) {
+      if (node.object.type === "Identifier" && node.object.name === "i18n" && node.property.type === "Identifier" && node.property.name === "t" && !allowDirectUsage) {
+        context.report({
+          node,
+          messageId: "preferUseTranslations",
+          fix(fixer) {
+            return fixer.replaceText(node, "t");
+          }
+        });
+      }
+    }
+    function checkCallExpression(node) {
+      if (node.callee.type === "Identifier" && node.callee.name === "t" && node.arguments.length > 0 && node.arguments[0].type === "Literal" && typeof node.arguments[0].value === "string") {
+        const key = node.arguments[0].value;
+        const namespacedKey = key.split(".");
+        if (namespacedKey.length > 1) {
+          const namespace = namespacedKey[0];
+          context.report({
+            node,
+            messageId: "preferScopedTranslations",
+            data: { namespace }
+          });
+        }
+      }
+    }
+    return {
+      MemberExpression: checkMemberExpression,
+      CallExpression: checkCallExpression
+    };
+  }
+});
+
+// src/configs/recommended.ts
+var recommended = {
+  plugins: ["@intl-party"],
+  rules: {
+    "@intl-party/no-hardcoded-strings": "warn",
+    "@intl-party/no-missing-keys": "error",
+    "@intl-party/prefer-translation-hooks": "warn"
+  },
+  settings: {
+    "intl-party": {
+      // Default settings
+      translationFiles: ["./translations/**/*.json"],
+      defaultLocale: "en",
+      namespaces: ["common"]
+    }
+  }
+};
+
+// src/configs/strict.ts
+var strict = {
+  plugins: ["@intl-party"],
+  rules: {
+    "@intl-party/no-hardcoded-strings": [
+      "error",
+      {
+        attributes: [
+          "placeholder",
+          "title",
+          "aria-label",
+          "aria-description",
+          "alt",
+          "label"
+        ],
+        minLength: 2,
+        ignorePattern: "^[A-Z_][A-Z0-9_]*$"
+        // Ignore constants
+      }
+    ],
+    "@intl-party/no-missing-keys": "error",
+    "@intl-party/prefer-translation-hooks": [
+      "error",
+      {
+        allowDirectUsage: false
+      }
+    ]
+  },
+  settings: {
+    "intl-party": {
+      translationFiles: ["./translations/**/*.json"],
+      defaultLocale: "en",
+      namespaces: ["common"]
+    }
+  }
+};
+
+// src/index.ts
+var plugin = {
+  meta: {
+    name: "@intl-party/eslint-plugin",
+    version: "0.1.0"
+  },
+  rules: {
+    "no-hardcoded-strings": noHardcodedStrings,
+    "no-missing-keys": noMissingKeys,
+    "prefer-translation-hooks": preferTranslationHooks
+  },
+  configs: {
+    recommended,
+    strict
+  }
+};
+var index_default = plugin;

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@intl-party/eslint-plugin",
+  "version": "1.0.0",
+  "description": "ESLint plugin for IntlParty - detect hardcoded strings and enforce i18n best practices",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "eslint",
+    "eslint-plugin",
+    "i18n",
+    "internationalization",
+    "typescript",
+    "hardcoded-strings"
+  ],
+  "author": "IntlParty Team",
+  "license": "MIT",
+  "dependencies": {
+    "@typescript-eslint/utils": "^6.15.0"
+  },
+  "devDependencies": {
+    "@types/eslint": "^8.56.0",
+    "@types/node": "^20.10.0",
+    "@typescript-eslint/eslint-plugin": "^6.15.0",
+    "@typescript-eslint/parser": "^6.15.0",
+    "@typescript-eslint/rule-tester": "^6.15.0",
+    "eslint": "^8.55.0",
+    "jsdom": "^23.0.1",
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.0",
+    "vitest": "^1.0.0"
+  },
+  "peerDependencies": {
+    "eslint": ">=8.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/intl-party/intl-party.git",
+    "directory": "packages/eslint-plugin"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs --dts",
+    "dev": "tsup src/index.ts --format cjs --dts --watch",
+    "test": "vitest",
+    "test:watch": "vitest --watch",
+    "lint": "eslint src --ext .ts",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  }
+}