@ethisyscore/eslint-plugin-coreconnect 1.71.3 → 1.71.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ethisyscore/eslint-plugin-coreconnect",
-  "version": "1.71.3",
+  "version": "1.71.4",
   "description": "ESLint rules enforcing EthisysCore plugin frontend conventions. Published so a new rule reaches every plugin on a version bump, rather than being copied into each scaffold and drifting.",
   "type": "module",
   "main": "src/index.js",

package/src/rules/componentDeclarations.js

@@ -85,9 +85,18 @@ export function looksLikeComponent(init) {
  * @param {string} options.messageId
  * @param {string} options.description
  * @param {string} options.message
+ * @param {{ source: string, name: string }} options.canonical The promoted component this rule
+ *   points people at. A local declaration that COMPOSES it is exempt - see below.
  * @returns {import("eslint").Rule.RuleModule}
  */
-export function createNoLocalComponentRule({ pattern, messageId, description, message }) {
+export function createNoLocalComponentRule({ pattern, messageId, description, message, canonical }) {
+  // Fail at construction, not on the first source file that happens to contain an import. Without
+  // this a fifth rule added without a `canonical` line throws a TypeError from inside the
+  // ImportDeclaration visitor, which surfaces as an opaque lint crash on an arbitrary file.
+  if (!canonical?.source || !canonical?.name) {
+    throw new Error(`${messageId}: createNoLocalComponentRule needs canonical { source, name }`);
+  }
+
   return {
     meta: {
       type: "problem",
@@ -96,7 +105,49 @@ export function createNoLocalComponentRule({ pattern, messageId, description, me
       schema: [],
     },
     create(context) {
-      const check = (idNode) => {
+      const sourceCode = context.sourceCode;
+
+      /**
+       * Local names bound to the canonical export, so `import { DateInput as Picker }` still counts.
+       */
+      const canonicalNames = new Set();
+
+      /**
+       * The scope variables those names declare.
+       *
+       * Names alone are not enough. An identifier spelled like the canonical import may resolve to
+       * something else entirely - `({ DateInput }) => <DateInput />` uses a destructured PROP - and
+       * counting it granted the exemption to a component that composes nothing. That made the rule
+       * bypassable by accident: any wrapper taking a prop named after the component would quietly
+       * stop being checked. Comparing the resolved variable is what closes it.
+       */
+      const canonicalVariables = new Set();
+
+      /** Source positions where the canonical binding is used. */
+      const canonicalUses = [];
+
+      /** Matching declarations, judged at `Program:exit` once the uses above are known. */
+      const candidates = [];
+
+      /**
+       * A WRAPPER, not a re-implementation.
+       *
+       * The false positive this closes. Each of these rules exists to stop a plugin hand-rolling a
+       * primitive that `plugin-ui` already ships, and every one of them documents that importing the
+       * promoted component and rendering it is the compliant outcome. But the test is a name suffix,
+       * so it also fired on components that do exactly that: `legal`'s `DateField` (a pass-through
+       * that maps `error?: string` onto `error` + `helperText`) and `projects`' `PeriodDateInput`
+       * (adds commit-on-change), both of which render the SDK's `DateInput`. Two repos hit it the
+       * day the rule turned on, and every future wrapper would too.
+       *
+       * Range containment is what keeps this narrow: only the declaration whose own body reaches the
+       * canonical binding is exempt, so a file that legitimately wraps it AND hand-rolls a second
+       * one next door still reports the second.
+       */
+      const composesCanonical = (node) =>
+        canonicalUses.some((at) => at >= node.range[0] && at <= node.range[1]);
+
+      const check = (idNode, declarationNode) => {
         if (!idNode || idNode.type !== "Identifier") {
           return;
         }
@@ -104,15 +155,79 @@ export function createNoLocalComponentRule({ pattern, messageId, description, me
           return;
         }
 
-        context.report({ node: idNode, messageId, data: { name: idNode.name } });
+        candidates.push({ idNode, declarationNode });
+      };
+
+      /**
+       * The nearest binding of `name` visible from `scope`.
+       *
+       * Resolved by walking the scope chain rather than reading the import variable's `references`,
+       * because whether a JSX element name counts as a reference depends on the parser: the
+       * TypeScript parser's scope manager records one, plain espree does not - which is why
+       * `jsx-uses-vars` exists at all. This asks the question the same way under both.
+       */
+      const resolveByName = (scope, name) => {
+        for (let current = scope; current; current = current.upper) {
+          const found = current.variables.find((variable) => variable.name === name);
+          if (found) {
+            return found;
+          }
+        }
+        return null;
+      };
+
+      const noteCanonicalUse = (node) => {
+        if (!canonicalNames.has(node.name)) {
+          return;
+        }
+
+        const resolved = resolveByName(sourceCode.getScope(node), node.name);
+        if (resolved && !canonicalVariables.has(resolved)) {
+          return;
+        }
+
+        canonicalUses.push(node.range[0]);
       };
 
       return {
-        FunctionDeclaration: (node) => check(node.id),
-        ClassDeclaration: (node) => check(node.id),
+        ImportDeclaration: (node) => {
+          if (node.source.value !== canonical.source) {
+            return;
+          }
+          const declared = sourceCode.getDeclaredVariables(node);
+          for (const specifier of node.specifiers) {
+            if (
+              specifier.type === "ImportSpecifier" &&
+              specifier.imported.type === "Identifier" &&
+              specifier.imported.name === canonical.name
+            ) {
+              canonicalNames.add(specifier.local.name);
+              const variable = declared.find((candidate) =>
+                candidate.defs.some((def) => def.name === specifier.local),
+              );
+              if (variable) {
+                canonicalVariables.add(variable);
+              }
+            }
+          }
+        },
+        // Both node types are needed: `<DateInput />` is a JSXIdentifier, while `styled(DateInput)`,
+        // `React.createElement(DateInput)` and passing it as a prop are plain Identifiers.
+        Identifier: noteCanonicalUse,
+        JSXIdentifier: noteCanonicalUse,
+        FunctionDeclaration: (node) => check(node.id, node),
+        ClassDeclaration: (node) => check(node.id, node),
         VariableDeclarator: (node) => {
           if (looksLikeComponent(node.init)) {
-            check(node.id);
+            check(node.id, node);
+          }
+        },
+        "Program:exit": () => {
+          for (const { idNode, declarationNode } of candidates) {
+            if (composesCanonical(declarationNode)) {
+              continue;
+            }
+            context.report({ node: idNode, messageId, data: { name: idNode.name } });
           }
         },
       };

package/src/rules/no-local-data-grid.js

@@ -22,6 +22,7 @@ export default createNoLocalComponentRule({
   // Anchored at the end so `DataGridProps`, `useDataGridState` and a `ProjectsDataGridColumns`
   // helper are left alone; the shared helper's guard keeps hooks out of it.
   pattern: /(PersistentDataGrid|DataGridPagination|GridStatePersistence)$/,
+  canonical: { source: "@ethisyscore/plugin-ui/components/data-grid", name: "PersistentDataGrid" },
   messageId: "noLocalDataGrid",
   description:
     "Disallow a locally-declared persistent data grid - import from @ethisyscore/plugin-ui/components/data-grid",

package/src/rules/no-local-date-input.js

@@ -23,6 +23,7 @@ export default createNoLocalComponentRule({
   // Anchored at the end so `DateInputProps` and `DateRangeFilter` are left alone; the shared helper
   // excludes hooks, so `useDatePicker` and `useDateInputValidation` do not match either.
   pattern: /Date(Time)?(Input|Picker|Field)$/,
+  canonical: { source: "@ethisyscore/plugin-ui/components/date", name: "DateInput" },
   messageId: "noLocalDateInput",
   description:
     "Disallow a locally-declared date input - import DateInput from @ethisyscore/plugin-ui/components/date",

package/src/rules/no-local-empty-state.js

@@ -17,6 +17,7 @@ export default createNoLocalComponentRule({
   // Loose enough to catch the names the same panel gets rewritten under, while the shared helper's
   // hook guard keeps `useEmptyState` out of it.
   pattern: /(EmptyState|NoResults|NoData|BlankSlate)$/,
+  canonical: { source: "@ethisyscore/plugin-ui/components/shared", name: "EmptyState" },
   messageId: "noLocalEmptyState",
   description:
     "Disallow a locally-declared empty state - import EmptyState from @ethisyscore/plugin-ui/components/shared",

package/src/rules/no-local-search-input.js

@@ -19,6 +19,7 @@ export default createNoLocalComponentRule({
   // composes the shared input is a legitimate local component; a component that IS the search field
   // is not. Hook names are excluded by the shared helper.
   pattern: /Search(Input|Bar|Field)$/,
+  canonical: { source: "@ethisyscore/plugin-ui/components/ui", name: "DebouncedSearchInput" },
   messageId: "noLocalSearchInput",
   description:
     "Disallow a locally-declared search input - import DebouncedSearchInput from @ethisyscore/plugin-ui",