@intl-party/eslint-plugin 1.0.0 → 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/README.md

@@ -0,0 +1,450 @@
+# @intl-party/eslint-plugin
+
+ESLint plugin for IntlParty - enforce best practices and catch common i18n issues in your code.
+
+## Features
+
+- 🚫 **No hardcoded strings** - Detect untranslated user-facing text
+- 🔍 **Missing translation keys** - Catch references to non-existent translation keys
+- ⚛️ **React hooks enforcement** - Prefer translation hooks over direct i18n usage
+- 📝 **Consistent patterns** - Enforce consistent translation patterns across your codebase
+- ⚙️ **Configurable rules** - Customize rules to fit your project needs
+
+## Installation
+
+```bash
+npm install --save-dev @intl-party/eslint-plugin
+# or
+pnpm add -D @intl-party/eslint-plugin
+# or
+yarn add --dev @intl-party/eslint-plugin
+```
+
+## Configuration
+
+### Basic Setup
+
+Add the plugin to your ESLint configuration:
+
+```javascript
+// .eslintrc.js
+module.exports = {
+  plugins: ["@intl-party"],
+  extends: ["@intl-party/recommended"],
+};
+```
+
+### Manual Configuration
+
+```javascript
+// .eslintrc.js
+module.exports = {
+  plugins: ["@intl-party"],
+  rules: {
+    "@intl-party/no-hardcoded-strings": "error",
+    "@intl-party/no-missing-keys": "error",
+    "@intl-party/prefer-translation-hooks": "warn",
+  },
+};
+```
+
+### TypeScript Configuration
+
+```javascript
+// .eslintrc.js
+module.exports = {
+  extends: ["@intl-party/recommended", "@intl-party/typescript"],
+  parserOptions: {
+    project: "./tsconfig.json",
+  },
+};
+```
+
+## Rules
+
+### `@intl-party/no-hardcoded-strings`
+
+Prevents hardcoded user-facing strings that should be translated.
+
+#### ❌ Incorrect
+
+```jsx
+function Welcome() {
+  return <h1>Welcome to our app!</h1>; // Hardcoded string
+}
+
+function Button() {
+  return <button>Click here</button>; // Hardcoded string
+}
+
+const message = "Hello world"; // Hardcoded string
+```
+
+#### ✅ Correct
+
+```jsx
+function Welcome() {
+  const t = useTranslations("common");
+  return <h1>{t("welcome")}</h1>;
+}
+
+function Button() {
+  const t = useTranslations("common");
+  return <button>{t("clickHere")}</button>;
+}
+
+const message = t("hello");
+```
+
+#### Configuration
+
+```javascript
+{
+  "@intl-party/no-hardcoded-strings": ["error", {
+    "ignorePatterns": [
+      "^\\d+$",           // Numbers
+      "^[A-Z_]+$",        // Constants
+      "^https?://",       // URLs
+      "className",        // CSS classes
+      "data-*"            // Data attributes
+    ],
+    "ignoreElements": ["script", "style"],
+    "ignoreAttributes": ["className", "id", "data-testid"]
+  }]
+}
+```
+
+### `@intl-party/no-missing-keys`
+
+Catches references to translation keys that don't exist in your translation files.
+
+#### ❌ Incorrect
+
+```jsx
+function Component() {
+  const t = useTranslations("common");
+  return <h1>{t("nonExistentKey")}</h1>; // Key doesn't exist
+}
+```
+
+#### ✅ Correct
+
+```jsx
+function Component() {
+  const t = useTranslations("common");
+  return <h1>{t("welcome")}</h1>; // Key exists in common namespace
+}
+```
+
+#### Configuration
+
+```javascript
+{
+  "@intl-party/no-missing-keys": ["error", {
+    "translationsPath": "./messages",
+    "defaultLocale": "en",
+    "namespaces": ["common", "navigation"],
+    "checkDynamicKeys": false
+  }]
+}
+```
+
+### `@intl-party/prefer-translation-hooks`
+
+Encourages using translation hooks instead of direct i18n instance usage in React components.
+
+#### ❌ Incorrect
+
+```jsx
+function Component() {
+  const { i18n } = useI18nContext();
+  return <h1>{i18n.t("welcome")}</h1>; // Direct i18n usage
+}
+```
+
+#### ✅ Correct
+
+```jsx
+function Component() {
+  const t = useTranslations("common");
+  return <h1>{t("welcome")}</h1>; // Using translation hook
+}
+```
+
+#### Configuration
+
+```javascript
+{
+  "@intl-party/prefer-translation-hooks": ["warn", {
+    "allowedMethods": ["formatDate", "formatNumber"],
+    "ignoreServerComponents": true
+  }]
+}
+```
+
+## Configuration Presets
+
+### Recommended Preset
+
+```javascript
+// Balanced rules for most projects
+{
+  "extends": ["@intl-party/recommended"]
+}
+```
+
+Includes:
+
+- `@intl-party/no-hardcoded-strings`: `error`
+- `@intl-party/no-missing-keys`: `error`
+- `@intl-party/prefer-translation-hooks`: `warn`
+
+### Strict Preset
+
+```javascript
+// Stricter rules for high-quality i18n
+{
+  "extends": ["@intl-party/strict"]
+}
+```
+
+Includes all recommended rules plus:
+
+- Stricter hardcoded string detection
+- Enforcement of namespace consistency
+- Required translation comments
+
+### TypeScript Preset
+
+```javascript
+// Additional rules for TypeScript projects
+{
+  "extends": [
+    "@intl-party/recommended",
+    "@intl-party/typescript"
+  ]
+}
+```
+
+Includes type-aware rules and TypeScript-specific checks.
+
+## Advanced Configuration
+
+### Project-Specific Settings
+
+```javascript
+// .eslintrc.js
+module.exports = {
+  plugins: ["@intl-party"],
+  settings: {
+    "intl-party": {
+      // Path to translation files
+      translationsPath: "./src/locales",
+
+      // Default locale for key validation
+      defaultLocale: "en",
+
+      // Available namespaces
+      namespaces: ["common", "navigation", "forms"],
+
+      // Translation file pattern
+      filePattern: "{locale}/{namespace}.json",
+
+      // Ignore patterns for hardcoded strings
+      ignorePatterns: [
+        "^[A-Z_]+$", // Constants
+        "^\\d+$", // Numbers
+        "^https?://", // URLs
+        "^mailto:", // Email links
+        "^tel:", // Phone links
+      ],
+
+      // Elements to ignore for hardcoded strings
+      ignoreElements: ["script", "style", "code", "pre"],
+
+      // Attributes to ignore
+      ignoreAttributes: ["className", "id", "data-*", "aria-*"],
+    },
+  },
+  rules: {
+    "@intl-party/no-hardcoded-strings": "error",
+    "@intl-party/no-missing-keys": "error",
+    "@intl-party/prefer-translation-hooks": "warn",
+  },
+};
+```
+
+### Framework-Specific Configuration
+
+#### Next.js
+
+```javascript
+// .eslintrc.js
+module.exports = {
+  extends: ["next/core-web-vitals", "@intl-party/recommended"],
+  settings: {
+    "intl-party": {
+      translationsPath: "./messages",
+      framework: "nextjs",
+    },
+  },
+};
+```
+
+#### React
+
+```javascript
+// .eslintrc.js
+module.exports = {
+  extends: ["react-app", "@intl-party/recommended"],
+  settings: {
+    "intl-party": {
+      translationsPath: "./src/translations",
+      framework: "react",
+    },
+  },
+};
+```
+
+## Integration with Build Tools
+
+### CI/CD Integration
+
+```yaml
+# .github/workflows/lint.yml
+name: Lint
+on: [push, pull_request]
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+      - run: npm ci
+      - run: npm run lint
+      - run: npm run lint:i18n # Custom script for i18n-specific linting
+```
+
+### Pre-commit Hooks
+
+```json
+// package.json
+{
+  "husky": {
+    "hooks": {
+      "pre-commit": "lint-staged"
+    }
+  },
+  "lint-staged": {
+    "**/*.{js,jsx,ts,tsx}": [
+      "eslint --fix",
+      "eslint --ext .js,.jsx,.ts,.tsx --config .eslintrc.i18n.js"
+    ]
+  }
+}
+```
+
+### Custom Scripts
+
+```json
+// package.json
+{
+  "scripts": {
+    "lint": "eslint src/",
+    "lint:i18n": "eslint src/ --config .eslintrc.i18n.js",
+    "lint:fix": "eslint src/ --fix"
+  }
+}
+```
+
+## Troubleshooting
+
+### Common Issues
+
+1. **False positives for hardcoded strings**
+   - Add patterns to `ignorePatterns` in rule configuration
+   - Use `eslint-disable-next-line` comments for specific cases
+
+2. **Missing key errors for dynamic keys**
+   - Set `checkDynamicKeys: false` in rule configuration
+   - Use template strings for predictable patterns
+
+3. **Performance issues with large translation files**
+   - Use `translationsPath` setting to optimize file loading
+   - Consider splitting large translation files
+
+### Debug Mode
+
+Enable debug logging to troubleshoot rule issues:
+
+```bash
+DEBUG=eslint-plugin-intl-party eslint src/
+```
+
+### Custom Rule Configuration
+
+```javascript
+// For specific files or patterns
+{
+  "overrides": [
+    {
+      "files": ["**/*.test.{js,jsx,ts,tsx}"],
+      "rules": {
+        "@intl-party/no-hardcoded-strings": "off"
+      }
+    },
+    {
+      "files": ["**/admin/**"],
+      "rules": {
+        "@intl-party/no-missing-keys": "warn"
+      }
+    }
+  ]
+}
+```
+
+## Examples
+
+### Real-world Configuration
+
+```javascript
+// .eslintrc.js for a Next.js project
+module.exports = {
+  extends: ["next/core-web-vitals", "@intl-party/recommended"],
+  settings: {
+    "intl-party": {
+      translationsPath: "./messages",
+      defaultLocale: "en",
+      namespaces: ["common", "navigation", "forms", "errors"],
+      ignorePatterns: [
+        "^[A-Z_]+$",
+        "^\\d+(\\.\\d+)?$",
+        "^#[0-9a-fA-F]{3,6}$",
+        "^rgb\\(",
+        "^https?://",
+        "^mailto:",
+        "^\\+\\d",
+      ],
+    },
+  },
+  overrides: [
+    {
+      files: ["**/*.test.{js,jsx,ts,tsx}", "**/*.stories.{js,jsx,ts,tsx}"],
+      rules: {
+        "@intl-party/no-hardcoded-strings": "off",
+      },
+    },
+    {
+      files: ["**/admin/**", "**/cms/**"],
+      rules: {
+        "@intl-party/no-hardcoded-strings": "warn",
+      },
+    },
+  ],
+};
+```
+
+## License
+
+MIT © IntlParty

package/dist/index.d.ts

@@ -1,14 +1,32 @@
 import * as _typescript_eslint_utils_ts_eslint from '@typescript-eslint/utils/ts-eslint';
 
+interface PreferTranslationHooksOptions {
+    allowDirectUsage?: boolean;
+}
+
+interface NoMissingKeysOptions {
+    translationFiles?: string[];
+    defaultLocale?: string;
+    configPath?: string;
+    cacheTimeout?: number;
+}
+
+interface NoHardcodedStringsOptions {
+    attributes?: string[];
+    ignorePattern?: string;
+    minLength?: number;
+    allowedStrings?: string[];
+}
+
 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>;
+        "no-hardcoded-strings": _typescript_eslint_utils_ts_eslint.RuleModule<"hardcodedString" | "hardcodedStringInAttribute", [NoHardcodedStringsOptions], _typescript_eslint_utils_ts_eslint.RuleListener>;
+        "no-missing-keys": _typescript_eslint_utils_ts_eslint.RuleModule<"missingTranslationKey" | "invalidTranslationKey", [NoMissingKeysOptions], _typescript_eslint_utils_ts_eslint.RuleListener>;
+        "prefer-translation-hooks": _typescript_eslint_utils_ts_eslint.RuleModule<"preferUseTranslations" | "preferScopedTranslations", [PreferTranslationHooksOptions], _typescript_eslint_utils_ts_eslint.RuleListener>;
     };
     configs: {
         recommended: {

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,14 +37,14 @@ 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: {
     type: "problem",
     docs: {
       description: "Disallow hardcoded strings in JSX elements and specific attributes",
-      recommended: "warn"
+      recommended: "recommended"
     },
     fixable: "code",
     schema: [
@@ -77,7 +87,7 @@ var noHardcodedStrings = import_utils.ESLintUtils.RuleCreator(
     }
   },
   defaultOptions: [{}],
-  create(context, [options = {}]) {
+  create(context, [options]) {
     const {
       attributes = [
         "placeholder",
@@ -89,7 +99,7 @@ var noHardcodedStrings = import_utils.ESLintUtils.RuleCreator(
       ignorePattern,
       minLength = 3,
       allowedStrings = []
-    } = options;
+    } = options || {};
     const ignoreRegex = ignorePattern ? new RegExp(ignorePattern) : null;
     function isHardcodedString(value) {
       if (value.length < minLength) return false;
@@ -117,17 +127,18 @@ var noHardcodedStrings = import_utils.ESLintUtils.RuleCreator(
     }
     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)) {
+        const literalValue = node.value.value;
         context.report({
           node: node.value,
           messageId: "hardcodedStringInAttribute",
           data: {
-            text: node.value.value,
+            text: literalValue,
             attribute: node.name.name
           },
           fix(fixer) {
             return fixer.replaceText(
               node.value,
-              `{t('${generateTranslationKey(node.value.value)}')}`
+              `{t('${generateTranslationKey(literalValue)}')}`
             );
           }
         });
@@ -161,15 +172,304 @@ 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: {
     type: "problem",
     docs: {
       description: "Ensure all translation keys exist in translation files",
-      recommended: "error"
+      recommended: "recommended"
     },
     schema: [
       {
@@ -184,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
@@ -195,13 +504,24 @@ var noMissingKeys = import_utils2.ESLintUtils.RuleCreator(
     }
   },
   defaultOptions: [{}],
-  create(context, [options = {}]) {
-    const { translationFiles = [], defaultLocale = "en" } = options;
-    const translationKeys = /* @__PURE__ */ new Set();
+  create(context, [options]) {
+    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)) {
@@ -212,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);
       }
     };
   }
@@ -230,14 +603,14 @@ 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: {
     type: "suggestion",
     docs: {
       description: "Prefer using translation hooks over direct i18n instance usage in React components",
-      recommended: "warn"
+      recommended: "recommended"
     },
     fixable: "code",
     schema: [
@@ -259,8 +632,8 @@ var preferTranslationHooks = import_utils3.ESLintUtils.RuleCreator(
     }
   },
   defaultOptions: [{}],
-  create(context, [options = {}]) {
-    const { allowDirectUsage = false } = options;
+  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({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intl-party/eslint-plugin",
-  "version": "1.0.0",
+  "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,14 +42,17 @@
   },
   "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",
-    "test": "vitest",
-    "test:watch": "vitest --watch",
+    "test": "vitest --run",
+    "test:watch": "vitest",
     "lint": "eslint src --ext .ts",
     "typecheck": "tsc --noEmit",
     "clean": "rm -rf dist"