@noctcore/eslint-plugin-contracts 0.3.0 → 0.4.0

package/dist/index.js

@@ -9,13 +9,14 @@ var recommended = {
   "noctcore-contracts/restrict-throw-to-taxonomy": "error",
   "noctcore-contracts/schema-enum-field-consistency": "error",
   "noctcore-contracts/fetch-must-check-ok": "error",
-  // Config-required / heuristic rules ship inert. `require-registered-keys` and
-  // `env-var-schema-parity` do nothing until their `sinks` / `schema` options are
-  // set; `require-schema-parse-at-boundary` is a conservative syntactic slice of a
+  // Config-required / heuristic rules ship inert. `require-registered-keys`,
+  // `env-var-schema-parity` and `translation-key-exists` do nothing until their
+  // `sinks` / `schema` / `catalogs` options are set; `require-schema-parse-at-boundary` is a conservative syntactic slice of a
   // type-aware concern. Enable them explicitly once configured for your project.
   "noctcore-contracts/require-registered-keys": "off",
   "noctcore-contracts/env-var-schema-parity": "off",
-  "noctcore-contracts/require-schema-parse-at-boundary": "off"
+  "noctcore-contracts/require-schema-parse-at-boundary": "off",
+  "noctcore-contracts/translation-key-exists": "off"
 };
 
 // src/rules/env-var-schema-parity.ts
@@ -556,8 +557,8 @@ var fetchMustCheckOkRule = createRule({
     }
     return {
       CallExpression(node) {
-        const path2 = calleePath(node.callee);
-        if (path2 === null || !fetchFunctions.has(path2)) {
+        const path3 = calleePath(node.callee);
+        if (path3 === null || !fetchFunctions.has(path3)) {
           return;
         }
         const parent = skipAwait(node.parent);
@@ -1056,11 +1057,11 @@ var requireRegisteredKeysRule = createRule({
     const registryHint = registry ? ` (import it from '${registry}')` : "";
     return {
       CallExpression(node) {
-        const path2 = calleePath2(node.callee);
-        if (path2 === null) {
+        const path3 = calleePath2(node.callee);
+        if (path3 === null) {
           return;
         }
-        const indexes = sinkMap.get(path2);
+        const indexes = sinkMap.get(path3);
         if (indexes === void 0) {
           return;
         }
@@ -1070,7 +1071,7 @@ var requireRegisteredKeysRule = createRule({
             context.report({
               node: arg,
               messageId: "unregisteredKey",
-              data: { callee: path2, value: `'${arg.value}'`, registryHint }
+              data: { callee: path3, value: `'${arg.value}'`, registryHint }
             });
           }
         }
@@ -1371,10 +1372,689 @@ var schemaEnumFieldConsistencyRule = createRule({
   }
 });
 
+// src/i18n/catalogs.ts
+import { readFileSync as readFileSync2, statSync } from "fs";
+import path2 from "path";
+var NS_PLACEHOLDER = "{ns}";
+var SAFE_NAMESPACE = /^(?!\.{1,2}$)[^/\\\0]+$/u;
+var fileCache = /* @__PURE__ */ new Map();
+function readCatalogFile(absolute) {
+  let mtimeMs;
+  try {
+    const stats = statSync(absolute);
+    if (!stats.isFile()) return { kind: "missing" };
+    mtimeMs = stats.mtimeMs;
+  } catch {
+    return { kind: "missing" };
+  }
+  const cached = fileCache.get(absolute);
+  if (cached !== void 0 && cached.mtimeMs === mtimeMs) {
+    return cached.value.ok ? { kind: "ok", entry: cached } : { kind: "invalid", reason: cached.value.reason };
+  }
+  let value;
+  try {
+    value = { ok: true, json: JSON.parse(readFileSync2(absolute, "utf8")) };
+  } catch (error) {
+    value = { ok: false, reason: error instanceof Error ? error.message : String(error) };
+  }
+  const entry = { mtimeMs, value, flattened: /* @__PURE__ */ new Map() };
+  fileCache.set(absolute, entry);
+  return value.ok ? { kind: "ok", entry } : { kind: "invalid", reason: value.reason };
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object";
+}
+function descend(json, keyPath) {
+  if (keyPath === void 0 || keyPath === "") return json;
+  let current = json;
+  for (const segment of keyPath.split(".")) {
+    if (!isRecord(current) || !Object.hasOwn(current, segment)) return void 0;
+    current = current[segment];
+  }
+  return current;
+}
+function flatten(root, keySeparator, label) {
+  const leaves = /* @__PURE__ */ new Set();
+  const branches = /* @__PURE__ */ new Set();
+  const visit = (value, prefix) => {
+    if (!isRecord(value)) {
+      leaves.add(prefix);
+      return;
+    }
+    branches.add(prefix);
+    if (keySeparator === false) return;
+    for (const [key, child] of Object.entries(value)) {
+      visit(child, `${prefix}${keySeparator}${key}`);
+    }
+  };
+  for (const [key, child] of Object.entries(root)) {
+    if (keySeparator === false) {
+      (isRecord(child) ? branches : leaves).add(key);
+    } else {
+      visit(child, key);
+    }
+  }
+  return { label, leaves, branches };
+}
+function loadSource(cwd, file, keyPath, keySeparator) {
+  const absolute = path2.isAbsolute(file) ? file : path2.resolve(cwd, file);
+  const read = readCatalogFile(absolute);
+  if (read.kind === "missing") return { kind: "absent" };
+  if (read.kind === "invalid") return { kind: "error", reason: `${file}: ${read.reason}` };
+  const cacheKey = `${keyPath ?? ""}\0${keySeparator === false ? "" : keySeparator}`;
+  const cached = read.entry.flattened.get(cacheKey);
+  if (cached !== void 0) {
+    return cached === null ? { kind: "absent" } : { kind: "ok", catalog: cached };
+  }
+  const subtree = read.entry.value.ok ? descend(read.entry.value.json, keyPath) : void 0;
+  const label = keyPath ? `${file}#${keyPath}` : file;
+  const catalog = isRecord(subtree) ? flatten(subtree, keySeparator, label) : null;
+  read.entry.flattened.set(cacheKey, catalog);
+  return catalog === null ? { kind: "absent" } : { kind: "ok", catalog };
+}
+function catalogsForNamespace(namespace, sources, settings) {
+  const catalogs = [];
+  const errors = [];
+  for (const source of sources) {
+    const templated = source.file.includes(NS_PLACEHOLDER) || (source.keyPath?.includes(NS_PLACEHOLDER) ?? false);
+    if (templated) {
+      if (!SAFE_NAMESPACE.test(namespace)) continue;
+      const file = source.file.replaceAll(NS_PLACEHOLDER, namespace);
+      const keyPath = source.keyPath?.replaceAll(NS_PLACEHOLDER, namespace);
+      const load2 = loadSource(settings.cwd, file, keyPath, settings.keySeparator);
+      if (load2.kind === "ok") catalogs.push(load2.catalog);
+      else if (load2.kind === "error") errors.push(load2.reason);
+      continue;
+    }
+    if ((source.namespace ?? settings.defaultNamespace) !== namespace) continue;
+    const load = loadSource(settings.cwd, source.file, source.keyPath, settings.keySeparator);
+    if (load.kind === "ok") catalogs.push(load.catalog);
+    else if (load.kind === "error") errors.push(load.reason);
+    else {
+      const where = source.keyPath ? `${source.file}#${source.keyPath}` : source.file;
+      errors.push(`${where}: not found or not a JSON object`);
+    }
+  }
+  return { catalogs, errors };
+}
+var PLURAL_CATEGORIES = ["zero", "one", "two", "few", "many", "other"];
+function catalogHasKey(catalog, key, lookup) {
+  if (catalog.leaves.has(key)) return true;
+  if (lookup.returnObjects && catalog.branches.has(key)) return true;
+  if (lookup.plural) {
+    const sep = lookup.pluralSeparator;
+    for (const category of PLURAL_CATEGORIES) {
+      if (catalog.leaves.has(`${key}${sep}${category}`)) return true;
+      if (catalog.leaves.has(`${key}${sep}ordinal${sep}${category}`)) return true;
+    }
+  }
+  if (lookup.context) {
+    const variant = `${key}${lookup.contextSeparator}`;
+    for (const leaf of catalog.leaves) {
+      if (leaf.startsWith(variant)) return true;
+    }
+  }
+  return false;
+}
+function catalogHasPrefix(catalog, prefix) {
+  for (const leaf of catalog.leaves) {
+    if (leaf.startsWith(prefix)) return true;
+  }
+  for (const branch of catalog.branches) {
+    if (branch.startsWith(prefix)) return true;
+  }
+  return false;
+}
+
+// src/i18n/translationUsage.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES11 } from "@typescript-eslint/utils";
+var UNRESOLVED = "unresolved";
+var MAX_DEPTH = 8;
+function unwrap(node) {
+  let current = node;
+  while (current.type === AST_NODE_TYPES11.TSAsExpression || current.type === AST_NODE_TYPES11.TSSatisfiesExpression || current.type === AST_NODE_TYPES11.TSNonNullExpression) {
+    current = current.expression;
+  }
+  return current;
+}
+function staticString(node) {
+  const inner = unwrap(node);
+  if (inner.type === AST_NODE_TYPES11.Literal && typeof inner.value === "string") return inner.value;
+  if (inner.type === AST_NODE_TYPES11.TemplateLiteral && inner.expressions.length === 0) {
+    return inner.quasis[0]?.value.cooked ?? null;
+  }
+  return null;
+}
+function propertyName2(property) {
+  if (property.computed) return staticString(property.key);
+  if (property.key.type === AST_NODE_TYPES11.Identifier) return property.key.name;
+  return staticString(property.key);
+}
+function targetIdentifier(node) {
+  if (node.type === AST_NODE_TYPES11.Identifier) return node;
+  if (node.type === AST_NODE_TYPES11.AssignmentPattern && node.left.type === AST_NODE_TYPES11.Identifier) {
+    return node.left;
+  }
+  return null;
+}
+function createTranslationVisitor(context, settings, onUsage) {
+  const sourceCode = context.sourceCode;
+  const defaultBinding = { namespaces: [settings.defaultNamespace], keyPrefix: null };
+  function resolveVariable(identifier) {
+    let scope = sourceCode.getScope(identifier);
+    while (scope !== null) {
+      const variable = scope.set.get(identifier.name);
+      if (variable !== void 0) return variable;
+      scope = scope.upper;
+    }
+    return null;
+  }
+  function typedStringLiteral(node) {
+    const services = sourceCode.parserServices;
+    const program = services?.program;
+    const map = services?.esTreeNodeToTSNodeMap;
+    if (!program || !map) return null;
+    const type = program.getTypeChecker().getTypeAtLocation(map.get(node));
+    return type.isStringLiteral() ? type.value : null;
+  }
+  function resolveNamespaces(node, depth = 0) {
+    if (node === void 0) return defaultBinding.namespaces;
+    const inner = unwrap(node);
+    const literal = staticString(inner);
+    if (literal !== null) return [literal];
+    if (inner.type === AST_NODE_TYPES11.Literal && inner.value === null) return defaultBinding.namespaces;
+    if (inner.type === AST_NODE_TYPES11.ArrayExpression) {
+      const namespaces = [];
+      for (const element of inner.elements) {
+        if (element === null || element.type === AST_NODE_TYPES11.SpreadElement) return UNRESOLVED;
+        const value2 = staticString(element) ?? resolveIdentifierString(element, depth);
+        if (value2 === null) return UNRESOLVED;
+        namespaces.push(value2);
+      }
+      return namespaces.length > 0 ? namespaces : defaultBinding.namespaces;
+    }
+    if (inner.type === AST_NODE_TYPES11.Identifier && inner.name === "undefined") return defaultBinding.namespaces;
+    const value = resolveIdentifierString(inner, depth);
+    return value === null ? UNRESOLVED : [value];
+  }
+  function resolveIdentifierString(node, depth) {
+    if (node.type !== AST_NODE_TYPES11.Identifier || depth > MAX_DEPTH) return null;
+    if (Object.hasOwn(settings.namespaceIdentifiers, node.name)) {
+      return settings.namespaceIdentifiers[node.name] ?? null;
+    }
+    const definition = resolveVariable(node)?.defs[0];
+    if (definition?.type === "Variable" && definition.parent.kind === "const" && definition.node.id.type === AST_NODE_TYPES11.Identifier && definition.node.init !== null) {
+      const init = unwrap(definition.node.init);
+      const literal = staticString(init);
+      if (literal !== null) return literal;
+      const chained = resolveIdentifierString(init, depth + 1);
+      if (chained !== null) return chained;
+    }
+    return typedStringLiteral(node);
+  }
+  function isHookCall(node) {
+    return node.type === AST_NODE_TYPES11.CallExpression && node.callee.type === AST_NODE_TYPES11.Identifier && settings.hooks.has(node.callee.name);
+  }
+  function isInstance(node) {
+    return node.type === AST_NODE_TYPES11.Identifier && settings.instances.has(node.name);
+  }
+  function staticPrefix(node) {
+    if (node === void 0) return null;
+    const inner = unwrap(node);
+    if (inner.type === AST_NODE_TYPES11.Identifier && inner.name === "undefined") return null;
+    if (inner.type === AST_NODE_TYPES11.Literal && inner.value === null) return null;
+    return staticString(inner) ?? UNRESOLVED;
+  }
+  function bindingFromHook(call) {
+    const [nsArg, optionsArg] = call.arguments;
+    const namespaces = resolveNamespaces(nsArg);
+    if (namespaces === UNRESOLVED) return UNRESOLVED;
+    let keyPrefix = null;
+    if (optionsArg !== void 0) {
+      const options = unwrap(optionsArg);
+      if (options.type !== AST_NODE_TYPES11.ObjectExpression) return UNRESOLVED;
+      for (const property of options.properties) {
+        if (property.type !== AST_NODE_TYPES11.Property) return UNRESOLVED;
+        if (propertyName2(property) !== "keyPrefix") continue;
+        const prefix = staticPrefix(property.value);
+        if (prefix === UNRESOLVED) return UNRESOLVED;
+        keyPrefix = prefix;
+      }
+    }
+    return { namespaces, keyPrefix };
+  }
+  function bindingFromGetFixedT(call) {
+    const [, nsArg, prefixArg] = call.arguments;
+    const namespaces = resolveNamespaces(nsArg);
+    if (namespaces === UNRESOLVED) return UNRESOLVED;
+    const keyPrefix = staticPrefix(prefixArg);
+    if (keyPrefix === UNRESOLVED) return UNRESOLVED;
+    return { namespaces, keyPrefix };
+  }
+  function isGetFixedT(node) {
+    return node.type === AST_NODE_TYPES11.CallExpression && node.callee.type === AST_NODE_TYPES11.MemberExpression && !node.callee.computed && node.callee.property.type === AST_NODE_TYPES11.Identifier && node.callee.property.name === "getFixedT" && isInstance(node.callee.object);
+  }
+  function hookCallOf(identifier) {
+    const definition = resolveVariable(identifier)?.defs[0];
+    if (definition?.type !== "Variable" || definition.node.id.type !== AST_NODE_TYPES11.Identifier) return null;
+    const init = definition.node.init === null ? null : unwrap(definition.node.init);
+    return init !== null && isHookCall(init) ? init : null;
+  }
+  function bindingOfTSource(object) {
+    const inner = unwrap(object);
+    if (isHookCall(inner)) return bindingFromHook(inner);
+    if (inner.type === AST_NODE_TYPES11.Identifier) {
+      const hook = hookCallOf(inner);
+      if (hook !== null) return bindingFromHook(hook);
+      if (isInstance(inner)) return defaultBinding;
+    }
+    return null;
+  }
+  function bindingFromType(annotation) {
+    const type = annotation?.typeAnnotation;
+    if (type?.type !== AST_NODE_TYPES11.TSTypeReference) return null;
+    const name = type.typeName.type === AST_NODE_TYPES11.Identifier ? type.typeName.name : type.typeName.type === AST_NODE_TYPES11.TSQualifiedName ? type.typeName.right.name : null;
+    if (name === null || !settings.typeNames.has(name)) return null;
+    const [nsType, prefixType] = type.typeArguments?.params ?? [];
+    const literalOf = (node) => node.type === AST_NODE_TYPES11.TSLiteralType ? staticString(node.literal) : null;
+    let namespaces = defaultBinding.namespaces;
+    if (nsType !== void 0) {
+      if (nsType.type === AST_NODE_TYPES11.TSTupleType) {
+        const values = nsType.elementTypes.map(literalOf);
+        if (values.length === 0 || values.some((value) => value === null)) return UNRESOLVED;
+        namespaces = values;
+      } else {
+        const value = literalOf(nsType);
+        if (value === null) return UNRESOLVED;
+        namespaces = [value];
+      }
+    }
+    let keyPrefix = null;
+    if (prefixType !== void 0) {
+      keyPrefix = literalOf(prefixType);
+      if (keyPrefix === null) return UNRESOLVED;
+    }
+    return { namespaces, keyPrefix };
+  }
+  function bindingFromDeclarator(declarator, name, depth) {
+    if (declarator.init === null) return null;
+    const init = unwrap(declarator.init);
+    const id = declarator.id;
+    if (id.type === AST_NODE_TYPES11.Identifier) {
+      if (isGetFixedT(init)) return bindingFromGetFixedT(init);
+      if (init.type === AST_NODE_TYPES11.MemberExpression && !init.computed && init.property.type === AST_NODE_TYPES11.Identifier && init.property.name === "t") {
+        return bindingOfTSource(init.object);
+      }
+      if (init.type === AST_NODE_TYPES11.Identifier) return bindingOfIdentifier(init, depth + 1);
+      return null;
+    }
+    if (id.type === AST_NODE_TYPES11.ObjectPattern) {
+      for (const property of id.properties) {
+        if (property.type !== AST_NODE_TYPES11.Property || targetIdentifier(property.value) !== name) continue;
+        return propertyName2(property) === "t" ? bindingOfTSource(init) : null;
+      }
+      return null;
+    }
+    if (id.type === AST_NODE_TYPES11.ArrayPattern) {
+      const first = id.elements[0];
+      if (first && targetIdentifier(first) === name && isHookCall(init)) return bindingFromHook(init);
+    }
+    return null;
+  }
+  function bindingOfIdentifier(identifier, depth = 0) {
+    if (depth > MAX_DEPTH) return null;
+    const variable = resolveVariable(identifier);
+    if (variable === null) {
+      return settings.functions.has(identifier.name) ? defaultBinding : null;
+    }
+    const definition = variable.defs[0];
+    if (definition === void 0) return null;
+    switch (definition.type) {
+      case "ImportBinding": {
+        const specifier = definition.node;
+        if (specifier.type !== AST_NODE_TYPES11.ImportSpecifier) return null;
+        const imported = specifier.imported.type === AST_NODE_TYPES11.Identifier ? specifier.imported.name : specifier.imported.value;
+        return settings.functions.has(imported) ? defaultBinding : null;
+      }
+      case "Parameter": {
+        const name = definition.name;
+        if (name.type !== AST_NODE_TYPES11.Identifier) return null;
+        const typed = bindingFromType(name.typeAnnotation);
+        if (typed !== null) return typed;
+        return settings.functions.has(name.name) ? UNRESOLVED : null;
+      }
+      case "Variable":
+        return definition.name.type === AST_NODE_TYPES11.Identifier ? bindingFromDeclarator(definition.node, definition.name, depth) : null;
+      default:
+        return null;
+    }
+  }
+  function bindingOfCallee(callee) {
+    if (callee.type === AST_NODE_TYPES11.Identifier) return bindingOfIdentifier(callee);
+    if (callee.type === AST_NODE_TYPES11.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES11.Identifier && callee.property.name === "t") {
+      return bindingOfTSource(callee.object);
+    }
+    return null;
+  }
+  function readCallOptions(node) {
+    const none = { namespaces: null, plural: false, context: false, returnObjects: false };
+    if (node === void 0) return none;
+    const inner = unwrap(node);
+    if (inner.type !== AST_NODE_TYPES11.ObjectExpression) return UNRESOLVED;
+    let namespaces = null;
+    let plural = false;
+    let context2 = false;
+    let returnObjects = false;
+    for (const property of inner.properties) {
+      if (property.type !== AST_NODE_TYPES11.Property) return UNRESOLVED;
+      const name = propertyName2(property);
+      if (name === null || name === "keyPrefix") return UNRESOLVED;
+      if (name === "ns") {
+        const resolved = resolveNamespaces(property.value);
+        if (resolved === UNRESOLVED) return UNRESOLVED;
+        namespaces = resolved;
+      } else if (name === "count") {
+        plural = true;
+      } else if (name === "context") {
+        context2 = true;
+      } else if (name === "returnObjects") {
+        const value = unwrap(property.value);
+        returnObjects = !(value.type === AST_NODE_TYPES11.Literal && value.value === false);
+      }
+    }
+    return { namespaces, plural, context: context2, returnObjects };
+  }
+  function qualify(raw, binding, optionNamespaces) {
+    const { nsSeparator, keySeparator } = settings;
+    if (nsSeparator !== false && raw.includes(nsSeparator)) {
+      if (binding.keyPrefix !== null) return null;
+      const [head = "", ...rest] = raw.split(nsSeparator);
+      if (head !== "" && rest.length > 0) {
+        return { namespaces: [head], key: rest.join(keySeparator === false ? nsSeparator : keySeparator) };
+      }
+    }
+    const namespaces = optionNamespaces ?? binding.namespaces;
+    if (binding.keyPrefix === null || binding.keyPrefix === "") return { namespaces, key: raw };
+    return { namespaces, key: `${binding.keyPrefix}${keySeparator === false ? "" : keySeparator}${raw}` };
+  }
+  function emit(node, keyNode, binding, options) {
+    const inner = unwrap(keyNode);
+    const raws = [];
+    const single = staticString(inner);
+    if (single !== null) {
+      raws.push(single);
+    } else if (inner.type === AST_NODE_TYPES11.ArrayExpression && inner.elements.length > 0) {
+      for (const element of inner.elements) {
+        const value = element === null || element.type === AST_NODE_TYPES11.SpreadElement ? null : staticString(element);
+        if (value === null) {
+          onUsage({ kind: "dynamic", node });
+          return;
+        }
+        raws.push(value);
+      }
+    } else if (inner.type === AST_NODE_TYPES11.TemplateLiteral) {
+      const head = inner.quasis[0]?.value.cooked ?? "";
+      const qualified = head === "" ? null : qualify(head, binding, options.namespaces);
+      if (qualified === null) {
+        onUsage({ kind: "dynamic", node });
+      } else {
+        onUsage({ kind: "prefix", node, namespaces: qualified.namespaces, prefix: qualified.key });
+      }
+      return;
+    } else {
+      onUsage({ kind: "dynamic", node });
+      return;
+    }
+    let namespaces = null;
+    const keys = [];
+    for (const raw of raws) {
+      const qualified = qualify(raw, binding, options.namespaces);
+      if (qualified === null || raw === "") {
+        onUsage({ kind: "unresolved", node });
+        return;
+      }
+      if (namespaces !== null && namespaces.join("\0") !== qualified.namespaces.join("\0")) {
+        onUsage({ kind: "unresolved", node });
+        return;
+      }
+      namespaces = qualified.namespaces;
+      keys.push(qualified.key);
+    }
+    onUsage({
+      kind: "key",
+      node,
+      namespaces: namespaces ?? binding.namespaces,
+      keys,
+      plural: options.plural,
+      context: options.context,
+      returnObjects: options.returnObjects
+    });
+  }
+  function jsxAttributeValue(attribute) {
+    const value = attribute.value;
+    if (value === null) return null;
+    if (value.type === AST_NODE_TYPES11.JSXExpressionContainer) {
+      return value.expression.type === AST_NODE_TYPES11.JSXEmptyExpression ? null : value.expression;
+    }
+    return value;
+  }
+  return {
+    CallExpression(node) {
+      const binding = bindingOfCallee(node.callee);
+      if (binding === null) return;
+      const [keyArg, secondArg, thirdArg] = node.arguments;
+      if (keyArg === void 0) return;
+      if (binding === UNRESOLVED) {
+        onUsage({ kind: "unresolved", node: keyArg });
+        return;
+      }
+      const optionsArg = secondArg !== void 0 && staticString(secondArg) !== null ? thirdArg : secondArg;
+      const options = readCallOptions(optionsArg);
+      if (options === UNRESOLVED) {
+        onUsage({ kind: "unresolved", node: keyArg });
+        return;
+      }
+      emit(keyArg, keyArg, binding, options);
+    },
+    JSXOpeningElement(node) {
+      if (node.name.type !== AST_NODE_TYPES11.JSXIdentifier || !settings.transComponents.has(node.name.name)) return;
+      const attributes = /* @__PURE__ */ new Map();
+      for (const attribute of node.attributes) {
+        if (attribute.type === AST_NODE_TYPES11.JSXSpreadAttribute) {
+          onUsage({ kind: "unresolved", node });
+          return;
+        }
+        if (attribute.name.type === AST_NODE_TYPES11.JSXIdentifier) attributes.set(attribute.name.name, attribute);
+      }
+      const keyAttribute = attributes.get("i18nKey");
+      const keyNode = keyAttribute === void 0 ? null : jsxAttributeValue(keyAttribute);
+      if (keyNode === null) return;
+      let binding = defaultBinding;
+      const tAttribute = attributes.get("t");
+      const tNode = tAttribute === void 0 ? null : jsxAttributeValue(tAttribute);
+      if (tNode !== null) {
+        binding = tNode.type === AST_NODE_TYPES11.Identifier ? bindingOfIdentifier(tNode) : UNRESOLVED;
+      }
+      let namespaces = null;
+      const nsAttribute = attributes.get("ns");
+      const nsNode = nsAttribute === void 0 ? null : jsxAttributeValue(nsAttribute);
+      if (nsNode !== null) {
+        const resolved = resolveNamespaces(nsNode);
+        if (resolved === UNRESOLVED) binding = UNRESOLVED;
+        else namespaces = resolved;
+      }
+      if (binding === null || binding === UNRESOLVED) {
+        onUsage({ kind: "unresolved", node: keyNode });
+        return;
+      }
+      emit(keyNode, keyNode, binding, {
+        namespaces,
+        plural: attributes.has("count"),
+        context: attributes.has("context"),
+        returnObjects: false
+      });
+    }
+  };
+}
+
+// src/rules/translation-key-exists.ts
+var RULE_NAME11 = "translation-key-exists";
+var stringList = { type: "array", items: { type: "string", minLength: 1 }, uniqueItems: true };
+var separator = { oneOf: [{ type: "string", minLength: 1 }, { type: "boolean", enum: [false] }] };
+var optionSchema9 = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    catalogs: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["file"],
+        properties: {
+          file: { type: "string", minLength: 1 },
+          namespace: { type: "string", minLength: 1 },
+          keyPath: { type: "string", minLength: 1 }
+        }
+      }
+    },
+    defaultNamespace: { type: "string", minLength: 1 },
+    fallbackNamespaces: stringList,
+    hooks: stringList,
+    instances: stringList,
+    functions: stringList,
+    typeNames: stringList,
+    transComponents: stringList,
+    namespaceIdentifiers: { type: "object", additionalProperties: { type: "string", minLength: 1 } },
+    nsSeparator: separator,
+    keySeparator: separator,
+    pluralSeparator: { type: "string", minLength: 1 },
+    contextSeparator: { type: "string", minLength: 1 },
+    dynamicKeys: { type: "string", enum: ["ignore", "check-prefix"] }
+  }
+};
+var TRANSLATION_DEFAULTS = {
+  defaultNamespace: "translation",
+  hooks: ["useTranslation"],
+  instances: ["i18n", "i18next"],
+  functions: ["t"],
+  typeNames: ["TFunction"],
+  transComponents: ["Trans"],
+  nsSeparator: ":",
+  keySeparator: ".",
+  pluralSeparator: "_",
+  contextSeparator: "_"
+};
+function translationSettingsOf(options) {
+  return {
+    hooks: new Set(options.hooks ?? TRANSLATION_DEFAULTS.hooks),
+    instances: new Set(options.instances ?? TRANSLATION_DEFAULTS.instances),
+    functions: new Set(options.functions ?? TRANSLATION_DEFAULTS.functions),
+    typeNames: new Set(options.typeNames ?? TRANSLATION_DEFAULTS.typeNames),
+    transComponents: new Set(options.transComponents ?? TRANSLATION_DEFAULTS.transComponents),
+    namespaceIdentifiers: options.namespaceIdentifiers ?? {},
+    defaultNamespace: options.defaultNamespace ?? TRANSLATION_DEFAULTS.defaultNamespace,
+    nsSeparator: options.nsSeparator ?? TRANSLATION_DEFAULTS.nsSeparator,
+    keySeparator: options.keySeparator ?? TRANSLATION_DEFAULTS.keySeparator
+  };
+}
+var translationKeyExistsRule = createRule({
+  name: RULE_NAME11,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Require every static i18next / react-i18next translation key (`t(...)`, `i18n.t(...)`, `<Trans i18nKey>`) to exist in the catalog of the namespace in scope."
+    },
+    schema: [optionSchema9],
+    messages: {
+      missingKey: "Translation key `{{key}}` does not exist in namespace `{{namespace}}` ({{catalogs}}). It renders as the raw key at runtime: fix the key or add it to the catalog.",
+      missingKeyPrefix: "No key in namespace `{{namespace}}` ({{catalogs}}) starts with `{{prefix}}`, so this template key can never resolve.",
+      unknownNamespace: "Namespace `{{namespace}}` has no catalog in the rule configuration. Fix the namespace name or add a `catalogs` entry for it.",
+      catalogUnreadable: "Translation catalog could not be loaded: {{reason}}."
+    }
+  },
+  defaultOptions: [{}],
+  create(context, [options]) {
+    const sources = options.catalogs ?? [];
+    if (sources.length === 0) {
+      return {};
+    }
+    const settings = translationSettingsOf(options);
+    const fallbackNamespaces = options.fallbackNamespaces ?? [];
+    const catalogSettings = {
+      cwd: context.cwd,
+      defaultNamespace: settings.defaultNamespace,
+      keySeparator: settings.keySeparator
+    };
+    const lookupBase = {
+      pluralSeparator: options.pluralSeparator ?? TRANSLATION_DEFAULTS.pluralSeparator,
+      contextSeparator: options.contextSeparator ?? TRANSLATION_DEFAULTS.contextSeparator
+    };
+    const checkPrefix = options.dynamicKeys === "check-prefix";
+    const resolved = /* @__PURE__ */ new Map();
+    const reportedErrors = /* @__PURE__ */ new Set();
+    function catalogsOf(namespace) {
+      let entry = resolved.get(namespace);
+      if (entry === void 0) {
+        entry = catalogsForNamespace(namespace, sources, catalogSettings);
+        resolved.set(namespace, entry);
+      }
+      return entry;
+    }
+    function searched(node, namespaces) {
+      const catalogs = [];
+      for (const namespace of [...namespaces, ...fallbackNamespaces]) {
+        const entry = catalogsOf(namespace);
+        for (const reason of entry.errors) {
+          if (!reportedErrors.has(reason)) {
+            reportedErrors.add(reason);
+            context.report({ node, messageId: "catalogUnreadable", data: { reason } });
+          }
+        }
+        if (entry.errors.length > 0) return null;
+        catalogs.push(...entry.catalogs);
+      }
+      if (catalogs.length === 0) {
+        context.report({ node, messageId: "unknownNamespace", data: { namespace: namespaces.join("`, `") } });
+        return null;
+      }
+      return catalogs;
+    }
+    const labels = (catalogs) => catalogs.map((catalog) => catalog.label).join(", ");
+    return createTranslationVisitor(context, settings, (usage) => {
+      if (usage.kind === "key") {
+        const catalogs = searched(usage.node, usage.namespaces);
+        if (catalogs === null) return;
+        const lookup = { ...lookupBase, plural: usage.plural, context: usage.context, returnObjects: usage.returnObjects };
+        const found = usage.keys.some((key) => catalogs.some((catalog) => catalogHasKey(catalog, key, lookup)));
+        if (!found) {
+          context.report({
+            node: usage.node,
+            messageId: "missingKey",
+            data: { key: usage.keys.join("` | `"), namespace: usage.namespaces.join("`, `"), catalogs: labels(catalogs) }
+          });
+        }
+        return;
+      }
+      if (usage.kind === "prefix" && checkPrefix) {
+        const catalogs = searched(usage.node, usage.namespaces);
+        if (catalogs === null) return;
+        if (!catalogs.some((catalog) => catalogHasPrefix(catalog, usage.prefix))) {
+          context.report({
+            node: usage.node,
+            messageId: "missingKeyPrefix",
+            data: { prefix: usage.prefix, namespace: usage.namespaces.join("`, `"), catalogs: labels(catalogs) }
+          });
+        }
+      }
+    });
+  }
+});
+
 // src/rules/wire-message-naming.ts
-var RULE_NAME11 = "wire-message-naming";
+var RULE_NAME12 = "wire-message-naming";
 var DEFAULT_ROLE_SUFFIXES = ["Event", "Command", "Query"];
-var optionSchema9 = {
+var optionSchema10 = {
   type: "object",
   additionalProperties: false,
   properties: {
@@ -1415,14 +2095,14 @@ function typeLiteralNode(obj) {
   return null;
 }
 var wireMessageNamingRule = createRule({
-  name: RULE_NAME11,
+  name: RULE_NAME12,
   meta: {
     type: "problem",
     docs: {
       description: "A message-schema const ending in a role suffix (default Event/Command/Query) whose zod object declares `type: z.literal(...)` must set that literal to kebab-case(const name minus its role suffix)."
     },
     fixable: "code",
-    schema: [optionSchema9],
+    schema: [optionSchema10],
     messages: {
       typeMismatch: "Wire `type` literal '{{actual}}' for `{{name}}` must be '{{expected}}' \u2014 kebab-case of the const name minus its role suffix."
     }
@@ -1458,11 +2138,11 @@ var wireMessageNamingRule = createRule({
 });
 
 // src/rules/zod-schema-naming.ts
-var RULE_NAME12 = "zod-schema-naming";
+var RULE_NAME13 = "zod-schema-naming";
 var SCHEMA_NAME = /^[A-Z][A-Za-z0-9]*Schema$/;
 var SUFFIX = "Schema";
 var DEFAULT_ROLE_SUFFIXES2 = [];
-var optionSchema10 = {
+var optionSchema11 = {
   type: "object",
   additionalProperties: false,
   properties: {
@@ -1495,13 +2175,13 @@ function rootIdentifierName(node) {
   return null;
 }
 var zodSchemaNamingRule = createRule({
-  name: RULE_NAME12,
+  name: RULE_NAME13,
   meta: {
     type: "problem",
     docs: {
       description: "Every exported zod schema is a PascalCase const suffixed `Schema`, paired with a same-named inferred type (`export type Foo = z.infer<typeof FooSchema>`)."
     },
-    schema: [optionSchema10],
+    schema: [optionSchema11],
     messages: {
       schemaNaming: "Exported zod schema `{{name}}` must be a PascalCase const ending in `Schema` (e.g. `FooSchema`).",
       missingType: "Schema `{{name}}` has no sibling `export type {{base}} = z.infer<typeof {{name}}>`. Export the inferred type instead of hand-authoring a duplicate."
@@ -1564,7 +2244,8 @@ var rules = {
   "env-var-schema-parity": envVarSchemaParityRule,
   "require-schema-parse-at-boundary": requireSchemaParseAtBoundaryRule,
   "schema-enum-field-consistency": schemaEnumFieldConsistencyRule,
-  "fetch-must-check-ok": fetchMustCheckOkRule
+  "fetch-must-check-ok": fetchMustCheckOkRule,
+  "translation-key-exists": translationKeyExistsRule
 };
 
 // src/index.ts