@intl-party/eslint-plugin 1.0.2 → 1.1.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 IntlParty Team
+Copyright (c) 2025-2026 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
@@ -18,4 +18,4 @@ 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.
+SOFTWARE.

package/dist/index.d.ts

@@ -7,6 +7,8 @@ interface PreferTranslationHooksOptions {
 interface NoMissingKeysOptions {
     translationFiles?: string[];
     defaultLocale?: string;
+    configPath?: string;
+    cacheTimeout?: number;
 }
 
 interface NoHardcodedStringsOptions {

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -27,7 +37,7 @@ 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) => `https://github.com/RodrigoEspinosa/intl-party/blob/main/packages/eslint-plugin/docs/rules/${name}.md`
 )({
   name: "no-hardcoded-strings",
   meta: {
@@ -162,8 +172,297 @@ var noHardcodedStrings = import_utils.ESLintUtils.RuleCreator(
 
 // src/rules/no-missing-keys.ts
 var import_utils2 = require("@typescript-eslint/utils");
+
+// src/utils/translation-utils.ts
+var import_promises = __toESM(require("fs/promises"));
+var import_node_path = __toESM(require("path"));
+var translationCache = /* @__PURE__ */ new Map();
+var TranslationUtils = class {
+  constructor(options = {}) {
+    this.options = {
+      defaultLocale: "en",
+      cacheTimeout: 5 * 60 * 1e3,
+      // 5 minutes
+      ...options
+    };
+    this.cacheTimeout = this.options.cacheTimeout;
+  }
+  /**
+   * Load translations from configuration or provided files
+   */
+  async loadTranslations() {
+    const cacheKey = this.getCacheKey();
+    const now = Date.now();
+    const cached = translationCache.get(cacheKey);
+    if (cached && now - cached.timestamp < this.cacheTimeout) {
+      return cached.translations;
+    }
+    let translations;
+    try {
+      translations = await this.loadFromConfig();
+    } catch {
+      translations = await this.loadFromFiles();
+    }
+    translationCache.set(cacheKey, {
+      translations,
+      timestamp: now,
+      locales: Object.keys(translations),
+      namespaces: this.extractNamespaces(translations)
+    });
+    return translations;
+  }
+  /**
+   * Get all available translation keys for a specific locale and namespace
+   */
+  async getTranslationKeys(locale, namespace) {
+    const translations = await this.loadTranslations();
+    const keys = /* @__PURE__ */ new Set();
+    if (namespace) {
+      const namespaceTranslations = translations[locale]?.[namespace] || {};
+      this.collectKeys(namespaceTranslations, "", keys);
+    } else {
+      const localeTranslations = translations[locale] || {};
+      for (const nsTranslations of Object.values(localeTranslations)) {
+        this.collectKeys(nsTranslations, "", keys);
+      }
+    }
+    return keys;
+  }
+  /**
+   * Check if a translation key exists
+   */
+  async hasTranslationKey(locale, key, namespace) {
+    const keys = await this.getTranslationKeys(locale, namespace);
+    return keys.has(key);
+  }
+  /**
+   * Get all available locales
+   */
+  async getLocales() {
+    const translations = await this.loadTranslations();
+    return Object.keys(translations);
+  }
+  /**
+   * Get all available namespaces for a locale
+   */
+  async getNamespaces(locale) {
+    const translations = await this.loadTranslations();
+    return Object.keys(translations[locale] || {});
+  }
+  /**
+   * Validate translation key format
+   */
+  isValidTranslationKey(key) {
+    return /^[a-zA-Z][a-zA-Z0-9._-]*$/.test(key);
+  }
+  /**
+   * Extract namespace from a translation key
+   */
+  extractNamespace(key) {
+    if (key.includes(".")) {
+      return key.split(".")[0];
+    }
+    return null;
+  }
+  /**
+   * Get the base key (without namespace) from a translation key
+   */
+  getBaseKey(key) {
+    if (key.includes(".")) {
+      return key.split(".").slice(1).join(".");
+    }
+    return key;
+  }
+  getCacheKey() {
+    return `${this.options.configPath || "default"}-${this.options.defaultLocale}`;
+  }
+  async loadFromConfig() {
+    const configFiles = [
+      this.options.configPath,
+      "intl-party.config.js",
+      "intl-party.config.ts",
+      "intl-party.config.json"
+    ].filter(Boolean);
+    for (const configFile of configFiles) {
+      if (configFile && await this.pathExists(configFile)) {
+        try {
+          let config;
+          if (configFile.endsWith(".json")) {
+            const content = await import_promises.default.readFile(configFile, "utf-8");
+            config = JSON.parse(content);
+          } else {
+            delete require.cache[import_node_path.default.resolve(configFile)];
+            config = require(import_node_path.default.resolve(configFile));
+            if (config.default) {
+              config = config.default;
+            }
+          }
+          return await this.loadFromConfigObject(config);
+        } catch (error) {
+          continue;
+        }
+      }
+    }
+    throw new Error("No valid configuration found");
+  }
+  async loadFromConfigObject(config) {
+    const {
+      locales = ["en"],
+      defaultLocale = "en",
+      messages = "./messages"
+    } = config;
+    const translations = {};
+    for (const locale of locales) {
+      translations[locale] = {};
+      const messagesPath = typeof messages === "string" ? messages : "./messages";
+      if (await this.pathExists(messagesPath)) {
+        const localePath = import_node_path.default.join(messagesPath, locale);
+        if (await this.pathExists(localePath)) {
+          const files = await import_promises.default.readdir(localePath);
+          for (const file of files) {
+            if (file.endsWith(".json")) {
+              const namespace = import_node_path.default.basename(file, ".json");
+              const filePath = import_node_path.default.join(localePath, file);
+              try {
+                const content = await this.readJson(filePath);
+                translations[locale][namespace] = content;
+              } catch {
+                translations[locale][namespace] = {};
+              }
+            }
+          }
+        }
+      }
+    }
+    return translations;
+  }
+  async loadFromFiles() {
+    const { translationFiles = [], defaultLocale = "en" } = this.options;
+    if (translationFiles.length === 0) {
+      return await this.autoDetectTranslations();
+    }
+    const translations = {};
+    for (const filePath of translationFiles) {
+      try {
+        const content = await this.readJson(filePath);
+        const { locale, namespace } = this.parseFilePath(filePath);
+        if (!translations[locale]) {
+          translations[locale] = {};
+        }
+        translations[locale][namespace] = content;
+      } catch {
+        continue;
+      }
+    }
+    return translations;
+  }
+  async autoDetectTranslations() {
+    const translations = {};
+    const commonPaths = [
+      "messages",
+      "locales",
+      "i18n",
+      "public/locales",
+      "src/locales",
+      "src/translations"
+    ];
+    for (const basePath of commonPaths) {
+      if (await this.pathExists(basePath)) {
+        try {
+          const entries = await import_promises.default.readdir(basePath);
+          for (const entry of entries) {
+            const entryPath = import_node_path.default.join(basePath, entry);
+            const stat = await import_promises.default.stat(entryPath);
+            if (stat.isDirectory()) {
+              const locale = entry;
+              translations[locale] = {};
+              const files = await import_promises.default.readdir(entryPath);
+              for (const file of files) {
+                if (file.endsWith(".json")) {
+                  const namespace = import_node_path.default.basename(file, ".json");
+                  const filePath = import_node_path.default.join(entryPath, file);
+                  try {
+                    const content = await this.readJson(filePath);
+                    translations[locale][namespace] = content;
+                  } catch {
+                    translations[locale][namespace] = {};
+                  }
+                }
+              }
+            }
+          }
+          if (Object.keys(translations).length > 0) {
+            break;
+          }
+        } catch {
+          continue;
+        }
+      }
+    }
+    return translations;
+  }
+  parseFilePath(filePath) {
+    const parts = filePath.split(import_node_path.default.sep);
+    const fileName = parts[parts.length - 1];
+    const namespace = import_node_path.default.basename(fileName, ".json");
+    let locale = this.options.defaultLocale;
+    for (let i = parts.length - 2; i >= 0; i--) {
+      const part = parts[i];
+      if (/^[a-z]{2}(-[A-Z]{2})?$/.test(part)) {
+        locale = part;
+        break;
+      }
+    }
+    return { locale, namespace };
+  }
+  collectKeys(obj, prefix, keys) {
+    for (const [key, value] of Object.entries(obj)) {
+      const fullKey = prefix ? `${prefix}.${key}` : key;
+      if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        this.collectKeys(value, fullKey, keys);
+      } else {
+        keys.add(fullKey);
+      }
+    }
+  }
+  extractNamespaces(translations) {
+    const namespaces = /* @__PURE__ */ new Set();
+    for (const localeTranslations of Object.values(translations)) {
+      for (const namespace of Object.keys(localeTranslations)) {
+        namespaces.add(namespace);
+      }
+    }
+    return Array.from(namespaces);
+  }
+  /**
+   * Clear the translation cache
+   */
+  clearCache() {
+    translationCache.clear();
+  }
+  /**
+   * Check if a path exists (replacement for fs-extra's pathExists)
+   */
+  async pathExists(filePath) {
+    try {
+      await import_promises.default.access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Read and parse JSON file (replacement for fs-extra's readJson)
+   */
+  async readJson(filePath) {
+    const content = await import_promises.default.readFile(filePath, "utf-8");
+    return JSON.parse(content);
+  }
+};
+
+// src/rules/no-missing-keys.ts
 var noMissingKeys = import_utils2.ESLintUtils.RuleCreator(
-  (name) => `https://github.com/intl-party/intl-party/blob/main/packages/eslint-plugin/docs/rules/${name}.md`
+  (name) => `https://github.com/RodrigoEspinosa/intl-party/blob/main/packages/eslint-plugin/docs/rules/${name}.md`
 )({
   name: "no-missing-keys",
   meta: {
@@ -185,6 +484,15 @@ var noMissingKeys = import_utils2.ESLintUtils.RuleCreator(
             type: "string",
             default: "en",
             description: "Default locale to check keys against"
+          },
+          configPath: {
+            type: "string",
+            description: "Path to intl-party configuration file"
+          },
+          cacheTimeout: {
+            type: "number",
+            default: 3e5,
+            description: "Cache timeout in milliseconds (default: 5 minutes)"
           }
         },
         additionalProperties: false
@@ -197,12 +505,23 @@ var noMissingKeys = import_utils2.ESLintUtils.RuleCreator(
   },
   defaultOptions: [{}],
   create(context, [options]) {
-    const { translationFiles = [], defaultLocale = "en" } = options || {};
-    const translationKeys = /* @__PURE__ */ new Set();
+    const {
+      translationFiles = [],
+      defaultLocale = "en",
+      configPath,
+      cacheTimeout = 3e5
+    } = options || {};
+    const translationUtils = new TranslationUtils({
+      translationFiles,
+      defaultLocale,
+      configPath,
+      cacheTimeout
+    });
+    const fileTranslationCache = /* @__PURE__ */ new Map();
     function isValidTranslationKey(key) {
-      return /^[a-zA-Z][a-zA-Z0-9._-]*$/.test(key);
+      return translationUtils.isValidTranslationKey(key);
     }
-    function checkTranslationCall(node) {
+    async 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)) {
@@ -213,16 +532,69 @@ var noMissingKeys = import_utils2.ESLintUtils.RuleCreator(
           });
           return;
         }
+        try {
+          const namespace = translationUtils.extractNamespace(key);
+          const baseKey = translationUtils.getBaseKey(key);
+          const hasKey = await translationUtils.hasTranslationKey(
+            defaultLocale,
+            namespace ? baseKey : key,
+            namespace || void 0
+          );
+          if (!hasKey) {
+            context.report({
+              node: node.arguments[0],
+              messageId: "missingTranslationKey",
+              data: { key }
+            });
+          }
+        } catch (error) {
+        }
       }
     }
     function checkUseTranslationsCall(node) {
-      if (node.callee.type === "Identifier" && node.callee.name === "useTranslations") {
+      if (node.callee.type === "Identifier" && node.callee.name === "useTranslations" && node.arguments.length > 0 && node.arguments[0].type === "Literal" && typeof node.arguments[0].value === "string") {
+        const namespace = node.arguments[0].value;
+        translationUtils.getNamespaces(defaultLocale).then((namespaces) => {
+          if (!namespaces.includes(namespace)) {
+            context.report({
+              node: node.arguments[0],
+              messageId: "missingTranslationKey",
+              data: { key: namespace }
+            });
+          }
+        }).catch(() => {
+        });
+      }
+    }
+    function checkTemplateLiteral(node) {
+      for (const quasi of node.quasis) {
+        const text = quasi.value.raw;
+        const keyMatches = text.match(/[a-zA-Z][a-zA-Z0-9._-]*/g);
+        if (keyMatches) {
+          for (const potentialKey of keyMatches) {
+            if (isValidTranslationKey(potentialKey)) {
+              translationUtils.hasTranslationKey(defaultLocale, potentialKey).then((hasKey) => {
+                if (!hasKey) {
+                  context.report({
+                    node: quasi,
+                    messageId: "missingTranslationKey",
+                    data: { key: potentialKey }
+                  });
+                }
+              }).catch(() => {
+              });
+            }
+          }
+        }
       }
     }
     return {
       CallExpression(node) {
         checkTranslationCall(node);
         checkUseTranslationsCall(node);
+      },
+      TemplateLiteral(node) {
+        checkTemplateLiteral(node);
       }
     };
   }
@@ -231,7 +603,7 @@ var noMissingKeys = import_utils2.ESLintUtils.RuleCreator(
 // 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) => `https://github.com/RodrigoEspinosa/intl-party/blob/main/packages/eslint-plugin/docs/rules/${name}.md`
 )({
   name: "prefer-translation-hooks",
   meta: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intl-party/eslint-plugin",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "ESLint plugin for IntlParty - detect hardcoded strings and enforce i18n best practices",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -15,10 +15,15 @@
     "typescript",
     "hardcoded-strings"
   ],
-  "author": "IntlParty Team",
+  "author": "RodrigoEspinosa",
   "license": "MIT",
+  "homepage": "https://github.com/RodrigoEspinosa/intl-party#readme",
+  "bugs": {
+    "url": "https://github.com/RodrigoEspinosa/intl-party/issues"
+  },
   "dependencies": {
-    "@typescript-eslint/utils": "^6.15.0"
+    "@typescript-eslint/utils": "^6.15.0",
+    "fs-extra": "^11.2.0"
   },
   "devDependencies": {
     "@types/eslint": "^8.56.0",
@@ -37,9 +42,12 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/intl-party/intl-party.git",
+    "url": "https://github.com/RodrigoEspinosa/intl-party.git",
     "directory": "packages/eslint-plugin"
   },
+  "engines": {
+    "node": ">=18.0.0"
+  },
   "scripts": {
     "build": "tsup src/index.ts --format cjs --dts",
     "dev": "tsup src/index.ts --format cjs --dts --watch",