eslint-plugin-route-intelligence 2.1.0

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import { ESLint, Rule } from 'eslint';
+
+declare const noBrokenRoute: Rule.RuleModule;
+declare const noInvalidRedirect: Rule.RuleModule;
+declare const noDeadPage: Rule.RuleModule;
+declare const preferRouteConstants: Rule.RuleModule;
+declare const detectRouteCycles: Rule.RuleModule;
+declare const plugin: ESLint.Plugin;
+
+export { plugin as default, detectRouteCycles, noBrokenRoute, noDeadPage, noInvalidRedirect, preferRouteConstants };

package/dist/index.js

@@ -0,0 +1,168 @@
+// src/index.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+function loadGraph(cwd) {
+  const paths = [
+    join(cwd, "ri-output", "graph.json"),
+    join(cwd, ".route-intelligence", "graph.json")
+  ];
+  for (const p of paths) {
+    if (existsSync(p)) {
+      return JSON.parse(readFileSync(p, "utf-8"));
+    }
+  }
+  return null;
+}
+function getKnownPaths(graph) {
+  return new Set(
+    graph.nodes.filter((n) => n.attributes.type === "route").map((n) => n.attributes.path)
+  );
+}
+var noBrokenRoute = {
+  meta: {
+    type: "problem",
+    docs: { description: "Disallow links to non-existent routes" },
+    schema: [],
+    messages: { broken: 'Route "{{path}}" does not exist in the routing graph' }
+  },
+  create(context) {
+    const graph = loadGraph(context.cwd);
+    if (!graph) return {};
+    const paths = getKnownPaths(graph);
+    return {
+      JSXAttribute(node) {
+        if (node.name.type !== "JSXIdentifier" || node.name.name !== "href") return;
+        const value = node.value;
+        if (!value || value.type !== "Literal" || typeof value.value !== "string") return;
+        const path = value.value;
+        if (path.startsWith("http") || path.startsWith("#")) return;
+        if (!paths.has(path) && !paths.has(path.replace(/\/$/, ""))) {
+          context.report({ node, messageId: "broken", data: { path } });
+        }
+      }
+    };
+  }
+};
+var noInvalidRedirect = {
+  meta: {
+    type: "problem",
+    docs: { description: "Disallow redirects to non-existent routes" },
+    schema: [],
+    messages: { invalid: 'Redirect target "{{path}}" does not exist' }
+  },
+  create(context) {
+    const graph = loadGraph(context.cwd);
+    if (!graph) return {};
+    const paths = getKnownPaths(graph);
+    return {
+      CallExpression(node) {
+        if (node.callee.type !== "Identifier") return;
+        if (node.callee.name !== "redirect" && node.callee.name !== "permanentRedirect") return;
+        const arg = node.arguments[0];
+        if (!arg || arg.type !== "Literal" || typeof arg.value !== "string") return;
+        if (!paths.has(arg.value)) {
+          context.report({ node, messageId: "invalid", data: { path: arg.value } });
+        }
+      }
+    };
+  }
+};
+var noDeadPage = {
+  meta: {
+    type: "suggestion",
+    docs: { description: "Warn when current file is a dead route" },
+    schema: [],
+    messages: { dead: "This page appears to be unreachable (dead route)" }
+  },
+  create(context) {
+    const graph = loadGraph(context.cwd);
+    if (!graph) return {};
+    const filename = context.filename.replace(/\\/g, "/");
+    const deadNode = graph.nodes.find(
+      (n) => n.attributes.isDead && n.attributes.filePath.replace(/\\/g, "/").includes(filename)
+    );
+    if (deadNode) {
+      return {
+        Program(node) {
+          context.report({ node, messageId: "dead" });
+        }
+      };
+    }
+    return {};
+  }
+};
+var preferRouteConstants = {
+  meta: {
+    type: "suggestion",
+    docs: { description: "Prefer route constants over string literals" },
+    schema: [],
+    messages: { prefer: 'Use a route constant instead of inline string "{{path}}"' }
+  },
+  create(context) {
+    return {
+      JSXAttribute(node) {
+        if (node.name.type !== "JSXIdentifier" || node.name.name !== "href") return;
+        const value = node.value;
+        if (!value || value.type !== "Literal" || typeof value.value !== "string") return;
+        if (value.value.startsWith("/")) {
+          context.report({ node, messageId: "prefer", data: { path: value.value } });
+        }
+      }
+    };
+  }
+};
+var detectRouteCycles = {
+  meta: {
+    type: "suggestion",
+    docs: { description: "Detect navigation that creates cycles" },
+    schema: [],
+    messages: { cycle: "Navigation may create a route cycle" }
+  },
+  create(context) {
+    const graph = loadGraph(context.cwd);
+    if (!graph) return {};
+    const edges = /* @__PURE__ */ new Map();
+    for (const edge of graph.edges) {
+      if (edge.attributes.type === "navigation" || edge.attributes.type === "conditional-navigation") {
+        const set = edges.get(edge.source) ?? /* @__PURE__ */ new Set();
+        set.add(edge.target);
+        edges.set(edge.source, set);
+      }
+    }
+    return {
+      CallExpression(node) {
+        if (node.callee.type !== "Identifier" && node.callee.type !== "MemberExpression") return;
+        const text = node.callee.type === "Identifier" ? node.callee.name : node.callee.type === "MemberExpression" && node.callee.property.type === "Identifier" ? node.callee.property.name : "";
+        if (!["push", "navigate", "redirect"].includes(text)) return;
+        const filename = context.filename;
+        const sourceNode = graph.nodes.find(
+          (n) => n.attributes.filePath.includes(filename.split(/[/\\]/).pop() ?? "")
+        );
+        if (!sourceNode) return;
+        const targets = edges.get(sourceNode.id);
+        if (targets?.has(sourceNode.id)) {
+          context.report({ node, messageId: "cycle" });
+        }
+      }
+    };
+  }
+};
+var plugin = {
+  meta: { name: "eslint-plugin-route-intelligence", version: "0.1.0" },
+  rules: {
+    "no-broken-route": noBrokenRoute,
+    "no-invalid-redirect": noInvalidRedirect,
+    "no-dead-page": noDeadPage,
+    "prefer-route-constants": preferRouteConstants,
+    "detect-route-cycles": detectRouteCycles
+  }
+};
+var index_default = plugin;
+export {
+  index_default as default,
+  detectRouteCycles,
+  noBrokenRoute,
+  noDeadPage,
+  noInvalidRedirect,
+  preferRouteConstants
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "eslint-plugin-route-intelligence",
+  "version": "2.1.0",
+  "description": "ESLint plugin for Route Intelligence",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "development": "./src/index.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@route-intelligence/shared": "*"
+  },
+  "peerDependencies": {
+    "eslint": ">=9"
+  },
+  "devDependencies": {
+    "@route-intelligence/tsconfig": "*",
+    "@types/estree-jsx": "^1.0.5",
+    "@types/node": "^22.15.32",
+    "eslint": "^9.29.0",
+    "tsup": "^8.4.0",
+    "typescript": "^5.8.3"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  }
+}