@neokapi/i18n-react-lint 0.1.0

package/dist/shared/t-import.js

@@ -0,0 +1,22 @@
+function collectTLocalNames(context) {
+  const names = /* @__PURE__ */ new Set();
+  const program = context.sourceCode.ast;
+  for (const stmt of program.body) {
+    if (!isRuntimeImport(stmt)) continue;
+    for (const spec of stmt.specifiers) {
+      if (spec.type === "ImportSpecifier" && spec.imported.type === "Identifier" && spec.imported.name === "t") {
+        names.add(spec.local.name);
+      }
+    }
+  }
+  return names;
+}
+function isRuntimeImport(node) {
+  if (node.type !== "ImportDeclaration") return false;
+  const src = node.source.value;
+  return typeof src === "string" && (src === "@neokapi/i18n-react/runtime" || src === "@neokapi/i18n-react");
+}
+export {
+  collectTLocalNames
+};
+//# sourceMappingURL=t-import.js.map

package/dist/shared/t-import.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/shared/t-import.ts"],
+  "sourcesContent": ["import type { Context } from \"@oxlint/plugins\";\nimport type { ImportDeclaration, Node, Program } from \"estree\";\n\n/**\n * Walks an ESTree program and returns the set of local identifier\n * names bound to the `t` function from `@neokapi/i18n-react/runtime`.\n *\n * Handles:\n *   import { t } from '@neokapi/i18n-react/runtime'\n *   import { t as translate } from '@neokapi/i18n-react/runtime'\n *\n * Returns a Set because a file could in principle import `t` twice\n * under different aliases, and we want to catch all of them.\n */\nexport function collectTLocalNames(context: Context): Set<string> {\n  const names = new Set<string>();\n  // Both ESLint and oxlint hand JS rules an ESTree-shaped AST at runtime.\n  // The oxlint types model the oxc AST, so bridge to ESTree node types here.\n  const program = context.sourceCode.ast as unknown as Program;\n  for (const stmt of program.body) {\n    if (!isRuntimeImport(stmt)) continue;\n    for (const spec of stmt.specifiers) {\n      if (\n        spec.type === \"ImportSpecifier\" &&\n        spec.imported.type === \"Identifier\" &&\n        spec.imported.name === \"t\"\n      ) {\n        names.add(spec.local.name);\n      }\n    }\n  }\n  return names;\n}\n\nfunction isRuntimeImport(node: Node): node is ImportDeclaration {\n  if (node.type !== \"ImportDeclaration\") return false;\n  const src = node.source.value;\n  return (\n    typeof src === \"string\" &&\n    (src === \"@neokapi/i18n-react/runtime\" || src === \"@neokapi/i18n-react\")\n  );\n}\n"],
+  "mappings": "AAcO,SAAS,mBAAmB,SAA+B;AAChE,QAAM,QAAQ,oBAAI,IAAY;AAG9B,QAAM,UAAU,QAAQ,WAAW;AACnC,aAAW,QAAQ,QAAQ,MAAM;AAC/B,QAAI,CAAC,gBAAgB,IAAI,EAAG;AAC5B,eAAW,QAAQ,KAAK,YAAY;AAClC,UACE,KAAK,SAAS,qBACd,KAAK,SAAS,SAAS,gBACvB,KAAK,SAAS,SAAS,KACvB;AACA,cAAM,IAAI,KAAK,MAAM,IAAI;AAAA,MAC3B;AAAA,IACF;AAAA,EACF;AACA,SAAO;AACT;AAEA,SAAS,gBAAgB,MAAuC;AAC9D,MAAI,KAAK,SAAS,oBAAqB,QAAO;AAC9C,QAAM,MAAM,KAAK,OAAO;AACxB,SACE,OAAO,QAAQ,aACd,QAAQ,iCAAiC,QAAQ;AAEtD;",
+  "names": []
+}

package/dist/shared/translatable-attrs.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Attribute names that neokapi-i18n extracts. Keep in sync with
+ * packages/i18n-react's defaults (`translatableAttributes`) —
+ * duplicated rather than imported so this package stays usable
+ * without installing the full neokapi-i18n transform, and guarded by
+ * tests/attr-sync.test.ts which compares against the canonical set.
+ *
+ * Note the extractor scopes the React-convention bucket to PascalCase
+ * components; the lint vocabulary stays the union (a flagged concat
+ * in `label=` on an html element is still worth a look).
+ */
+export declare const TRANSLATABLE_ATTRS: ReadonlySet<string>;
+/**
+ * Object-literal keys we treat as "likely user-facing strings" when
+ * checking data-array patterns like `const ITEMS = [{ label: 'Foo' }]`.
+ * Intentionally narrower than TRANSLATABLE_ATTRS — must be a strong
+ * signal to keep false positives low.
+ *
+ * Explicitly excluded: `name`, `description`, `text`, `message`. Those
+ * overwhelmingly name backend / runtime data in real React apps
+ * (plugin.name, error.message, schema.description, file.name, …) that
+ * isn't authoring-time translatable, so flagging them fires mostly
+ * false positives. The remaining set skews strongly toward hardcoded
+ * UI copy.
+ */
+export declare const LIKELY_LABEL_KEYS: ReadonlySet<string>;

package/dist/shared/translatable-attrs.js

@@ -0,0 +1,41 @@
+const TRANSLATABLE_ATTRS = /* @__PURE__ */ new Set([
+  // HTML
+  "alt",
+  "title",
+  "placeholder",
+  // ARIA
+  "aria-label",
+  "aria-description",
+  "aria-placeholder",
+  "aria-roledescription",
+  "aria-valuetext",
+  // React conventions
+  "subtitle",
+  "description",
+  "label",
+  "heading",
+  "caption",
+  "helpText",
+  "helperText",
+  "errorMessage",
+  "hint",
+  "tooltip",
+  "emptyMessage",
+  "emptyStateText",
+  "filterPlaceholder"
+]);
+const LIKELY_LABEL_KEYS = /* @__PURE__ */ new Set([
+  "label",
+  "title",
+  "heading",
+  "caption",
+  "subtitle",
+  "tooltip",
+  "placeholder",
+  "summary"
+]);
+export {
+  LIKELY_LABEL_KEYS,
+  TRANSLATABLE_ATTRS
+};
+//# sourceMappingURL=translatable-attrs.js.map

package/dist/shared/translatable-attrs.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/shared/translatable-attrs.ts"],
+  "sourcesContent": ["/**\n * Attribute names that neokapi-i18n extracts. Keep in sync with\n * packages/i18n-react's defaults (`translatableAttributes`) \u2014\n * duplicated rather than imported so this package stays usable\n * without installing the full neokapi-i18n transform, and guarded by\n * tests/attr-sync.test.ts which compares against the canonical set.\n *\n * Note the extractor scopes the React-convention bucket to PascalCase\n * components; the lint vocabulary stays the union (a flagged concat\n * in `label=` on an html element is still worth a look).\n */\nexport const TRANSLATABLE_ATTRS: ReadonlySet<string> = new Set([\n  // HTML\n  \"alt\",\n  \"title\",\n  \"placeholder\",\n  // ARIA\n  \"aria-label\",\n  \"aria-description\",\n  \"aria-placeholder\",\n  \"aria-roledescription\",\n  \"aria-valuetext\",\n  // React conventions\n  \"subtitle\",\n  \"description\",\n  \"label\",\n  \"heading\",\n  \"caption\",\n  \"helpText\",\n  \"helperText\",\n  \"errorMessage\",\n  \"hint\",\n  \"tooltip\",\n  \"emptyMessage\",\n  \"emptyStateText\",\n  \"filterPlaceholder\",\n]);\n\n/**\n * Object-literal keys we treat as \"likely user-facing strings\" when\n * checking data-array patterns like `const ITEMS = [{ label: 'Foo' }]`.\n * Intentionally narrower than TRANSLATABLE_ATTRS \u2014 must be a strong\n * signal to keep false positives low.\n *\n * Explicitly excluded: `name`, `description`, `text`, `message`. Those\n * overwhelmingly name backend / runtime data in real React apps\n * (plugin.name, error.message, schema.description, file.name, \u2026) that\n * isn't authoring-time translatable, so flagging them fires mostly\n * false positives. The remaining set skews strongly toward hardcoded\n * UI copy.\n */\nexport const LIKELY_LABEL_KEYS: ReadonlySet<string> = new Set([\n  \"label\",\n  \"title\",\n  \"heading\",\n  \"caption\",\n  \"subtitle\",\n  \"tooltip\",\n  \"placeholder\",\n  \"summary\",\n]);\n"],
+  "mappings": "AAWO,MAAM,qBAA0C,oBAAI,IAAI;AAAA;AAAA,EAE7D;AAAA,EACA;AAAA,EACA;AAAA;AAAA,EAEA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA,EAEA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAeM,MAAM,oBAAyC,oBAAI,IAAI;AAAA,EAC5D;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;",
+  "names": []
+}

package/dist/shared/translate-no.d.ts

@@ -0,0 +1,12 @@
+/**
+ * W3C `translate="no"` is the standard hint for "don't try to
+ * translate this subtree". neokapi-i18n's extractor already respects
+ * it (walker.ts early-returns from the element), and the lint rules
+ * should too — otherwise a developer using the HTML-standard escape
+ * hatch still gets noisy warnings for dynamic / code-like content.
+ *
+ * The helper walks up through the parent chain from an arbitrary
+ * starting node (attribute, expression container, whatever) and
+ * returns true as soon as it finds a JSX ancestor with the attribute.
+ */
+export declare function hasTranslateNoAncestor(start: unknown): boolean;

package/dist/shared/translate-no.js

@@ -0,0 +1,27 @@
+function hasTranslateNoAncestor(start) {
+  let cursor = start;
+  while (cursor) {
+    if (cursor.type === "JSXElement") {
+      const open = cursor.openingElement ?? cursor.opening;
+      if (hasTranslateNoAttr(open)) return true;
+    }
+    cursor = cursor.parent;
+  }
+  return false;
+}
+function hasTranslateNoAttr(opening) {
+  const attrs = opening?.attributes;
+  if (!Array.isArray(attrs)) return false;
+  for (const a of attrs) {
+    const attr = a;
+    if (attr.type !== "JSXAttribute") continue;
+    if (attr.name?.type !== "JSXIdentifier" || attr.name.name !== "translate") continue;
+    const v = attr.value;
+    if (v?.type === "Literal" && v.value === "no") return true;
+  }
+  return false;
+}
+export {
+  hasTranslateNoAncestor
+};
+//# sourceMappingURL=translate-no.js.map

package/dist/shared/translate-no.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/shared/translate-no.ts"],
+  "sourcesContent": ["/**\n * W3C `translate=\"no\"` is the standard hint for \"don't try to\n * translate this subtree\". neokapi-i18n's extractor already respects\n * it (walker.ts early-returns from the element), and the lint rules\n * should too \u2014 otherwise a developer using the HTML-standard escape\n * hatch still gets noisy warnings for dynamic / code-like content.\n *\n * The helper walks up through the parent chain from an arbitrary\n * starting node (attribute, expression container, whatever) and\n * returns true as soon as it finds a JSX ancestor with the attribute.\n */\nexport function hasTranslateNoAncestor(start: unknown): boolean {\n  let cursor = start as\n    | {\n        type?: string;\n        parent?: unknown;\n        // ESLint (acorn-jsx) calls it `openingElement`; SWC calls it\n        // `opening`. Accept both so the helper works under either\n        // AST provider.\n        openingElement?: unknown;\n        opening?: unknown;\n      }\n    | undefined;\n  while (cursor) {\n    if (cursor.type === \"JSXElement\") {\n      const open = cursor.openingElement ?? cursor.opening;\n      if (hasTranslateNoAttr(open)) return true;\n    }\n    cursor = cursor.parent as typeof cursor;\n  }\n  return false;\n}\n\nfunction hasTranslateNoAttr(opening: unknown): boolean {\n  const attrs = (opening as { attributes?: unknown[] } | undefined)?.attributes;\n  if (!Array.isArray(attrs)) return false;\n  for (const a of attrs) {\n    const attr = a as {\n      type?: string;\n      name?: { type?: string; name?: string };\n      value?: { type?: string; value?: unknown };\n    };\n    if (attr.type !== \"JSXAttribute\") continue;\n    if (attr.name?.type !== \"JSXIdentifier\" || attr.name.name !== \"translate\") continue;\n    const v = attr.value;\n    if (v?.type === \"Literal\" && v.value === \"no\") return true;\n  }\n  return false;\n}\n"],
+  "mappings": "AAWO,SAAS,uBAAuB,OAAyB;AAC9D,MAAI,SAAS;AAWb,SAAO,QAAQ;AACb,QAAI,OAAO,SAAS,cAAc;AAChC,YAAM,OAAO,OAAO,kBAAkB,OAAO;AAC7C,UAAI,mBAAmB,IAAI,EAAG,QAAO;AAAA,IACvC;AACA,aAAS,OAAO;AAAA,EAClB;AACA,SAAO;AACT;AAEA,SAAS,mBAAmB,SAA2B;AACrD,QAAM,QAAS,SAAoD;AACnE,MAAI,CAAC,MAAM,QAAQ,KAAK,EAAG,QAAO;AAClC,aAAW,KAAK,OAAO;AACrB,UAAM,OAAO;AAKb,QAAI,KAAK,SAAS,eAAgB;AAClC,QAAI,KAAK,MAAM,SAAS,mBAAmB,KAAK,KAAK,SAAS,YAAa;AAC3E,UAAM,IAAI,KAAK;AACf,QAAI,GAAG,SAAS,aAAa,EAAE,UAAU,KAAM,QAAO;AAAA,EACxD;AACA,SAAO;AACT;",
+  "names": []
+}

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@neokapi/i18n-react-lint",
+  "version": "0.1.0",
+  "private": false,
+  "description": "Authoring-time lint rules for neokapi-i18n. Same rule objects run under ESLint and oxlint (via jsPlugins). Catches unextractable patterns (t(variable), string concat in translatable attrs, label strings hidden in data arrays) that the build-time extractor can't see.",
+  "keywords": [
+    "eslint",
+    "i18n",
+    "neokapi-i18n",
+    "lint",
+    "oxlint",
+    "react"
+  ],
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./eslint": {
+      "types": "./dist/eslint.d.ts",
+      "default": "./dist/eslint.js"
+    },
+    "./oxlint": {
+      "types": "./dist/oxlint.d.ts",
+      "default": "./dist/oxlint.js"
+    },
+    "./recommended": {
+      "types": "./dist/configs/recommended.d.ts",
+      "default": "./dist/configs/recommended.js"
+    },
+    "./recommended-strict": {
+      "types": "./dist/configs/recommended-strict.d.ts",
+      "default": "./dist/configs/recommended-strict.js"
+    }
+  },
+  "devDependencies": {
+    "@oxlint/plugins": "^1.73.0",
+    "@types/estree": "^1.0.0",
+    "@types/node": "^25.9.2",
+    "esbuild": "^0.28.1",
+    "eslint": "^10.7.0",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.10"
+  },
+  "peerDependencies": {
+    "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0"
+  },
+  "peerDependenciesMeta": {
+    "eslint": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "build": "node build.mjs",
+    "test": "vp test",
+    "test:watch": "vp test watch",
+    "typecheck": "vp check --no-fmt --no-lint",
+    "lint": "vp lint",
+    "fmt": "vp fmt --write src/ tests/",
+    "fmt:check": "vp fmt --check src/ tests/",
+    "check": "vp run typecheck && vp run lint && vp run fmt:check && vp run test"
+  }
+}