@tanstack/eslint-plugin-router 1.20.3-alpha.1

package/dist/esm/rules/create-route-property-order/create-route-property-order.rule.js

@@ -0,0 +1,103 @@
+import { ESLintUtils, AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { getDocsUrl } from "../../utils/get-docs-url.js";
+import { detectTanstackRouterImports } from "../../utils/detect-router-imports.js";
+import { sortDataByOrder } from "./create-route-property-order.utils.js";
+import { createRouteFunctions, createRouteFunctionsIndirect, sortRules } from "./constants.js";
+const createRule = ESLintUtils.RuleCreator(getDocsUrl);
+const createRouteFunctionSet = new Set(createRouteFunctions);
+function isCreateRouteFunction(node) {
+  return createRouteFunctionSet.has(node);
+}
+const name = "create-route-property-order";
+const rule = createRule({
+  name,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Ensure correct order of inference sensitive properties for createRoute functions",
+      recommended: "error"
+    },
+    messages: {
+      invalidOrder: "Invalid order of properties for `{{function}}`."
+    },
+    schema: [],
+    hasSuggestions: true,
+    fixable: "code"
+  },
+  defaultOptions: [],
+  create: detectTanstackRouterImports((context) => {
+    return {
+      CallExpression(node) {
+        if (node.callee.type !== AST_NODE_TYPES.Identifier) {
+          return;
+        }
+        const createRouteFunction = node.callee.name;
+        if (!isCreateRouteFunction(createRouteFunction)) {
+          return;
+        }
+        let args = node.arguments;
+        if (createRouteFunctionsIndirect.includes(createRouteFunction)) {
+          if (node.parent.type === AST_NODE_TYPES.CallExpression) {
+            args = node.parent.arguments;
+          } else {
+            return;
+          }
+        }
+        const argument = args[0];
+        if (argument === void 0 || argument.type !== "ObjectExpression") {
+          return;
+        }
+        const allProperties = argument.properties;
+        if (allProperties.length < 2) {
+          return;
+        }
+        const properties = allProperties.flatMap((p) => {
+          if (p.type === AST_NODE_TYPES.Property && p.key.type === AST_NODE_TYPES.Identifier) {
+            return { name: p.key.name, property: p };
+          } else if (p.type === AST_NODE_TYPES.SpreadElement) {
+            if (p.argument.type === AST_NODE_TYPES.Identifier) {
+              return { name: p.argument.name, property: p };
+            } else {
+              throw new Error("Unsupported spread element");
+            }
+          }
+          return [];
+        });
+        const sortedProperties = sortDataByOrder(properties, sortRules, "name");
+        if (sortedProperties === null) {
+          return;
+        }
+        context.report({
+          node: argument,
+          data: { function: node.callee.name },
+          messageId: "invalidOrder",
+          fix(fixer) {
+            const sourceCode = context.sourceCode;
+            const text = sortedProperties.reduce(
+              (sourceText, specifier, index) => {
+                let text2 = "";
+                if (index < allProperties.length - 1) {
+                  text2 = sourceCode.getText().slice(
+                    allProperties[index].range[1],
+                    allProperties[index + 1].range[0]
+                  );
+                }
+                return sourceText + sourceCode.getText(specifier.property) + text2;
+              },
+              ""
+            );
+            return fixer.replaceTextRange(
+              [allProperties[0].range[0], allProperties.at(-1).range[1]],
+              text
+            );
+          }
+        });
+      }
+    };
+  })
+});
+export {
+  name,
+  rule
+};
+//# sourceMappingURL=create-route-property-order.rule.js.map

package/dist/esm/rules/create-route-property-order/create-route-property-order.rule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-route-property-order.rule.js","sources":["../../../../src/rules/create-route-property-order/create-route-property-order.rule.ts"],"sourcesContent":["import { AST_NODE_TYPES, ESLintUtils } from '@typescript-eslint/utils'\n\nimport { getDocsUrl } from '../../utils/get-docs-url'\nimport { detectTanstackRouterImports } from '../../utils/detect-router-imports'\nimport { sortDataByOrder } from './create-route-property-order.utils'\nimport {\n  createRouteFunctions,\n  createRouteFunctionsIndirect,\n  sortRules,\n} from './constants'\nimport type { CreateRouteFunction } from './constants'\nimport type { ExtraRuleDocs } from '../../types'\n\nconst createRule = ESLintUtils.RuleCreator<ExtraRuleDocs>(getDocsUrl)\n\nconst createRouteFunctionSet = new Set(createRouteFunctions)\nfunction isCreateRouteFunction(node: any): node is CreateRouteFunction {\n  return createRouteFunctionSet.has(node)\n}\n\nexport const name = 'create-route-property-order'\n\nexport const rule = createRule({\n  name,\n  meta: {\n    type: 'problem',\n    docs: {\n      description:\n        'Ensure correct order of inference sensitive properties for createRoute functions',\n      recommended: 'error',\n    },\n    messages: {\n      invalidOrder: 'Invalid order of properties for `{{function}}`.',\n    },\n    schema: [],\n    hasSuggestions: true,\n    fixable: 'code',\n  },\n  defaultOptions: [],\n\n  create: detectTanstackRouterImports((context) => {\n    return {\n      CallExpression(node) {\n        if (node.callee.type !== AST_NODE_TYPES.Identifier) {\n          return\n        }\n        const createRouteFunction = node.callee.name\n        if (!isCreateRouteFunction(createRouteFunction)) {\n          return\n        }\n        let args = node.arguments\n        if (createRouteFunctionsIndirect.includes(createRouteFunction as any)) {\n          if (node.parent.type === AST_NODE_TYPES.CallExpression) {\n            args = node.parent.arguments\n          } else {\n            return\n          }\n        }\n\n        const argument = args[0]\n        if (argument === undefined || argument.type !== 'ObjectExpression') {\n          return\n        }\n\n        const allProperties = argument.properties\n        // no need to sort if there is at max 1 property\n        if (allProperties.length < 2) {\n          return\n        }\n\n        const properties = allProperties.flatMap((p) => {\n          if (\n            p.type === AST_NODE_TYPES.Property &&\n            p.key.type === AST_NODE_TYPES.Identifier\n          ) {\n            return { name: p.key.name, property: p }\n          } else if (p.type === AST_NODE_TYPES.SpreadElement) {\n            if (p.argument.type === AST_NODE_TYPES.Identifier) {\n              return { name: p.argument.name, property: p }\n            } else {\n              throw new Error('Unsupported spread element')\n            }\n          }\n          return []\n        })\n\n        const sortedProperties = sortDataByOrder(properties, sortRules, 'name')\n        if (sortedProperties === null) {\n          return\n        }\n        context.report({\n          node: argument,\n          data: { function: node.callee.name },\n          messageId: 'invalidOrder',\n          fix(fixer) {\n            const sourceCode = context.sourceCode\n\n            const text = sortedProperties.reduce(\n              (sourceText, specifier, index) => {\n                let text = ''\n                if (index < allProperties.length - 1) {\n                  text = sourceCode\n                    .getText()\n                    .slice(\n                      allProperties[index]!.range[1],\n                      allProperties[index + 1]!.range[0],\n                    )\n                }\n                return (\n                  sourceText + sourceCode.getText(specifier.property) + text\n                )\n              },\n              '',\n            )\n            return fixer.replaceTextRange(\n              [allProperties[0]!.range[0], allProperties.at(-1)!.range[1]],\n              text,\n            )\n          },\n        })\n      },\n    }\n  }),\n})\n"],"names":["text"],"mappings":";;;;;AAaA,MAAM,aAAa,YAAY,YAA2B,UAAU;AAEpE,MAAM,yBAAyB,IAAI,IAAI,oBAAoB;AAC3D,SAAS,sBAAsB,MAAwC;AAC9D,SAAA,uBAAuB,IAAI,IAAI;AACxC;AAEO,MAAM,OAAO;AAEb,MAAM,OAAO,WAAW;AAAA,EAC7B;AAAA,EACA,MAAM;AAAA,IACJ,MAAM;AAAA,IACN,MAAM;AAAA,MACJ,aACE;AAAA,MACF,aAAa;AAAA,IACf;AAAA,IACA,UAAU;AAAA,MACR,cAAc;AAAA,IAChB;AAAA,IACA,QAAQ,CAAC;AAAA,IACT,gBAAgB;AAAA,IAChB,SAAS;AAAA,EACX;AAAA,EACA,gBAAgB,CAAC;AAAA,EAEjB,QAAQ,4BAA4B,CAAC,YAAY;AACxC,WAAA;AAAA,MACL,eAAe,MAAM;AACnB,YAAI,KAAK,OAAO,SAAS,eAAe,YAAY;AAClD;AAAA,QAAA;AAEI,cAAA,sBAAsB,KAAK,OAAO;AACpC,YAAA,CAAC,sBAAsB,mBAAmB,GAAG;AAC/C;AAAA,QAAA;AAEF,YAAI,OAAO,KAAK;AACZ,YAAA,6BAA6B,SAAS,mBAA0B,GAAG;AACrE,cAAI,KAAK,OAAO,SAAS,eAAe,gBAAgB;AACtD,mBAAO,KAAK,OAAO;AAAA,UAAA,OACd;AACL;AAAA,UAAA;AAAA,QACF;AAGI,cAAA,WAAW,KAAK,CAAC;AACvB,YAAI,aAAa,UAAa,SAAS,SAAS,oBAAoB;AAClE;AAAA,QAAA;AAGF,cAAM,gBAAgB,SAAS;AAE3B,YAAA,cAAc,SAAS,GAAG;AAC5B;AAAA,QAAA;AAGF,cAAM,aAAa,cAAc,QAAQ,CAAC,MAAM;AAE5C,cAAA,EAAE,SAAS,eAAe,YAC1B,EAAE,IAAI,SAAS,eAAe,YAC9B;AACA,mBAAO,EAAE,MAAM,EAAE,IAAI,MAAM,UAAU,EAAE;AAAA,UAC9B,WAAA,EAAE,SAAS,eAAe,eAAe;AAClD,gBAAI,EAAE,SAAS,SAAS,eAAe,YAAY;AACjD,qBAAO,EAAE,MAAM,EAAE,SAAS,MAAM,UAAU,EAAE;AAAA,YAAA,OACvC;AACC,oBAAA,IAAI,MAAM,4BAA4B;AAAA,YAAA;AAAA,UAC9C;AAEF,iBAAO,CAAC;AAAA,QAAA,CACT;AAED,cAAM,mBAAmB,gBAAgB,YAAY,WAAW,MAAM;AACtE,YAAI,qBAAqB,MAAM;AAC7B;AAAA,QAAA;AAEF,gBAAQ,OAAO;AAAA,UACb,MAAM;AAAA,UACN,MAAM,EAAE,UAAU,KAAK,OAAO,KAAK;AAAA,UACnC,WAAW;AAAA,UACX,IAAI,OAAO;AACT,kBAAM,aAAa,QAAQ;AAE3B,kBAAM,OAAO,iBAAiB;AAAA,cAC5B,CAAC,YAAY,WAAW,UAAU;AAChC,oBAAIA,QAAO;AACP,oBAAA,QAAQ,cAAc,SAAS,GAAG;AACpCA,0BAAO,WACJ,QAAA,EACA;AAAA,oBACC,cAAc,KAAK,EAAG,MAAM,CAAC;AAAA,oBAC7B,cAAc,QAAQ,CAAC,EAAG,MAAM,CAAC;AAAA,kBACnC;AAAA,gBAAA;AAEJ,uBACE,aAAa,WAAW,QAAQ,UAAU,QAAQ,IAAIA;AAAAA,cAE1D;AAAA,cACA;AAAA,YACF;AACA,mBAAO,MAAM;AAAA,cACX,CAAC,cAAc,CAAC,EAAG,MAAM,CAAC,GAAG,cAAc,GAAG,EAAE,EAAG,MAAM,CAAC,CAAC;AAAA,cAC3D;AAAA,YACF;AAAA,UAAA;AAAA,QACF,CACD;AAAA,MAAA;AAAA,IAEL;AAAA,EACD,CAAA;AACH,CAAC;"}

package/dist/esm/rules/create-route-property-order/create-route-property-order.utils.d.ts

@@ -0,0 +1,2 @@
+export declare function sortDataByOrder<T, TKey extends keyof T>(data: Array<T> | ReadonlyArray<T>, orderRules: ReadonlyArray<Readonly<[ReadonlyArray<T[TKey]>, ReadonlyArray<T[TKey]>]>>, key: TKey): Array<T> | null;
+export declare function getCheckedProperties<T>(orderRules: ReadonlyArray<ReadonlyArray<ReadonlyArray<T>>>): ReadonlyArray<T>;

package/dist/esm/rules/create-route-property-order/create-route-property-order.utils.js

@@ -0,0 +1,51 @@
+function sortDataByOrder(data, orderRules, key) {
+  const getSubsetIndex = (item, subsets) => {
+    var _a;
+    for (let i = 0; i < subsets.length; i++) {
+      if ((_a = subsets[i]) == null ? void 0 : _a.includes(item)) {
+        return i;
+      }
+    }
+    return null;
+  };
+  const orderSets = orderRules.reduce(
+    (sets, [A, B]) => [...sets, A, B],
+    []
+  );
+  const inOrderArray = data.filter(
+    (item) => getSubsetIndex(item[key], orderSets) !== null
+  );
+  let wasResorted = false;
+  const sortedArray = inOrderArray.sort((a, b) => {
+    const aKey = a[key], bKey = b[key];
+    const aSubsetIndex = getSubsetIndex(aKey, orderSets);
+    const bSubsetIndex = getSubsetIndex(bKey, orderSets);
+    if (aSubsetIndex !== null && bSubsetIndex !== null && aSubsetIndex !== bSubsetIndex) {
+      return aSubsetIndex - bSubsetIndex;
+    }
+    return 0;
+  });
+  const inOrderIterator = sortedArray.values();
+  const result = data.map((item) => {
+    if (getSubsetIndex(item[key], orderSets) !== null) {
+      const sortedItem = inOrderIterator.next().value;
+      if (sortedItem[key] !== item[key]) {
+        wasResorted = true;
+      }
+      return sortedItem;
+    }
+    return item;
+  });
+  if (!wasResorted) {
+    return null;
+  }
+  return result;
+}
+function getCheckedProperties(orderRules) {
+  return [...new Set(orderRules.flat(2))];
+}
+export {
+  getCheckedProperties,
+  sortDataByOrder
+};
+//# sourceMappingURL=create-route-property-order.utils.js.map

package/dist/esm/rules/create-route-property-order/create-route-property-order.utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-route-property-order.utils.js","sources":["../../../../src/rules/create-route-property-order/create-route-property-order.utils.ts"],"sourcesContent":["export function sortDataByOrder<T, TKey extends keyof T>(\n  data: Array<T> | ReadonlyArray<T>,\n  orderRules: ReadonlyArray<\n    Readonly<[ReadonlyArray<T[TKey]>, ReadonlyArray<T[TKey]>]>\n  >,\n  key: TKey,\n): Array<T> | null {\n  const getSubsetIndex = (\n    item: T[TKey],\n    subsets: ReadonlyArray<ReadonlyArray<T[TKey]> | Array<T[TKey]>>,\n  ): number | null => {\n    for (let i = 0; i < subsets.length; i++) {\n      if (subsets[i]?.includes(item)) {\n        return i\n      }\n    }\n    return null\n  }\n\n  const orderSets = orderRules.reduce(\n    (sets, [A, B]) => [...sets, A, B],\n    [] as Array<ReadonlyArray<T[TKey]> | Array<T[TKey]>>,\n  )\n\n  const inOrderArray = data.filter(\n    (item) => getSubsetIndex(item[key], orderSets) !== null,\n  )\n\n  let wasResorted = false as boolean\n\n  // Sort by the relative order defined by the rules\n  const sortedArray = inOrderArray.sort((a, b) => {\n    const aKey = a[key],\n      bKey = b[key]\n    const aSubsetIndex = getSubsetIndex(aKey, orderSets)\n    const bSubsetIndex = getSubsetIndex(bKey, orderSets)\n\n    // If both items belong to different subsets, sort by their subset order\n    if (\n      aSubsetIndex !== null &&\n      bSubsetIndex !== null &&\n      aSubsetIndex !== bSubsetIndex\n    ) {\n      return aSubsetIndex - bSubsetIndex\n    }\n\n    // If both items belong to the same subset or neither is in the subset, keep their relative order\n    return 0\n  })\n\n  const inOrderIterator = sortedArray.values()\n  const result = data.map((item) => {\n    if (getSubsetIndex(item[key], orderSets) !== null) {\n      const sortedItem = inOrderIterator.next().value!\n      if (sortedItem[key] !== item[key]) {\n        wasResorted = true\n      }\n      return sortedItem\n    }\n    return item\n  })\n\n  if (!wasResorted) {\n    return null\n  }\n  return result\n}\n\nexport function getCheckedProperties<T>(\n  orderRules: ReadonlyArray<ReadonlyArray<ReadonlyArray<T>>>,\n): ReadonlyArray<T> {\n  return [...new Set<T>(orderRules.flat(2))]\n}\n"],"names":[],"mappings":"AAAgB,SAAA,gBACd,MACA,YAGA,KACiB;AACX,QAAA,iBAAiB,CACrB,MACA,YACkB;AAVN;AAWZ,aAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;AACvC,WAAI,aAAQ,CAAC,MAAT,mBAAY,SAAS,OAAO;AACvB,eAAA;AAAA,MAAA;AAAA,IACT;AAEK,WAAA;AAAA,EACT;AAEA,QAAM,YAAY,WAAW;AAAA,IAC3B,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,MAAM,GAAG,CAAC;AAAA,IAChC,CAAA;AAAA,EACF;AAEA,QAAM,eAAe,KAAK;AAAA,IACxB,CAAC,SAAS,eAAe,KAAK,GAAG,GAAG,SAAS,MAAM;AAAA,EACrD;AAEA,MAAI,cAAc;AAGlB,QAAM,cAAc,aAAa,KAAK,CAAC,GAAG,MAAM;AAC9C,UAAM,OAAO,EAAE,GAAG,GAChB,OAAO,EAAE,GAAG;AACR,UAAA,eAAe,eAAe,MAAM,SAAS;AAC7C,UAAA,eAAe,eAAe,MAAM,SAAS;AAGnD,QACE,iBAAiB,QACjB,iBAAiB,QACjB,iBAAiB,cACjB;AACA,aAAO,eAAe;AAAA,IAAA;AAIjB,WAAA;AAAA,EAAA,CACR;AAEK,QAAA,kBAAkB,YAAY,OAAO;AAC3C,QAAM,SAAS,KAAK,IAAI,CAAC,SAAS;AAChC,QAAI,eAAe,KAAK,GAAG,GAAG,SAAS,MAAM,MAAM;AAC3C,YAAA,aAAa,gBAAgB,KAAA,EAAO;AAC1C,UAAI,WAAW,GAAG,MAAM,KAAK,GAAG,GAAG;AACnB,sBAAA;AAAA,MAAA;AAET,aAAA;AAAA,IAAA;AAEF,WAAA;AAAA,EAAA,CACR;AAED,MAAI,CAAC,aAAa;AACT,WAAA;AAAA,EAAA;AAEF,SAAA;AACT;AAEO,SAAS,qBACd,YACkB;AACX,SAAA,CAAC,GAAG,IAAI,IAAO,WAAW,KAAK,CAAC,CAAC,CAAC;AAC3C;"}

package/dist/esm/rules.d.ts

@@ -0,0 +1,3 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+import { ExtraRuleDocs } from './types.js';
+export declare const rules: Record<string, ESLintUtils.RuleModule<string, ReadonlyArray<unknown>, ExtraRuleDocs, ESLintUtils.RuleListener>>;

package/dist/esm/rules.js

@@ -0,0 +1,8 @@
+import { rule, name } from "./rules/create-route-property-order/create-route-property-order.rule.js";
+const rules = {
+  [name]: rule
+};
+export {
+  rules
+};
+//# sourceMappingURL=rules.js.map

package/dist/esm/rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rules.js","sources":["../../src/rules.ts"],"sourcesContent":["import * as createRoutePropertyOrder from './rules/create-route-property-order/create-route-property-order.rule'\nimport type { ESLintUtils } from '@typescript-eslint/utils'\nimport type { ExtraRuleDocs } from './types'\n\nexport const rules: Record<\n  string,\n  ESLintUtils.RuleModule<\n    string,\n    ReadonlyArray<unknown>,\n    ExtraRuleDocs,\n    ESLintUtils.RuleListener\n  >\n> = {\n  [createRoutePropertyOrder.name]: createRoutePropertyOrder.rule,\n}\n"],"names":["createRoutePropertyOrder.name","createRoutePropertyOrder.rule"],"mappings":";AAIO,MAAM,QAQT;AAAA,EACF,CAACA,IAA6B,GAAGC;AACnC;"}

package/dist/esm/types.d.ts

@@ -0,0 +1,3 @@
+export type ExtraRuleDocs = {
+    recommended: 'strict' | 'error' | 'warn';
+};

package/dist/esm/utils/detect-router-imports.d.ts

@@ -0,0 +1,11 @@
+import { TSESTree, ESLintUtils } from '@typescript-eslint/utils';
+type Create = Parameters<ReturnType<typeof ESLintUtils.RuleCreator>>[0]['create'];
+type Context = Parameters<Create>[0];
+type Options = Parameters<Create>[1];
+type Helpers = {
+    isSpecificTanstackRouterImport: (node: TSESTree.Identifier, source: string) => boolean;
+    isTanstackRouterImport: (node: TSESTree.Identifier) => boolean;
+};
+type EnhancedCreate = (context: Context, options: Options, helpers: Helpers) => ReturnType<Create>;
+export declare function detectTanstackRouterImports(create: EnhancedCreate): Create;
+export {};

package/dist/esm/utils/detect-router-imports.js

@@ -0,0 +1,54 @@
+import { TSESTree } from "@typescript-eslint/utils";
+function detectTanstackRouterImports(create) {
+  return (context, optionsWithDefault) => {
+    const tanstackRouterImportSpecifiers = [];
+    const helpers = {
+      isSpecificTanstackRouterImport(node, source) {
+        return !!tanstackRouterImportSpecifiers.find((specifier) => {
+          if (specifier.type === TSESTree.AST_NODE_TYPES.ImportSpecifier && specifier.parent.type === TSESTree.AST_NODE_TYPES.ImportDeclaration && specifier.parent.source.value === source) {
+            return node.name === specifier.local.name;
+          }
+          return false;
+        });
+      },
+      isTanstackRouterImport(node) {
+        return !!tanstackRouterImportSpecifiers.find((specifier) => {
+          if (specifier.type === TSESTree.AST_NODE_TYPES.ImportSpecifier) {
+            return node.name === specifier.local.name;
+          }
+          return false;
+        });
+      }
+    };
+    const detectionInstructions = {
+      ImportDeclaration(node) {
+        if (node.specifiers.length > 0 && node.importKind === "value" && node.source.value.startsWith("@tanstack/") && node.source.value.endsWith("-router")) {
+          tanstackRouterImportSpecifiers.push(...node.specifiers);
+        }
+      }
+    };
+    const ruleInstructions = create(context, optionsWithDefault, helpers);
+    const enhancedRuleInstructions = {};
+    const allKeys = new Set(
+      Object.keys(detectionInstructions).concat(Object.keys(ruleInstructions))
+    );
+    allKeys.forEach((instruction) => {
+      enhancedRuleInstructions[instruction] = (node) => {
+        var _a;
+        if (instruction in detectionInstructions) {
+          (_a = detectionInstructions[instruction]) == null ? void 0 : _a.call(detectionInstructions, node);
+        }
+        const ruleFunction = ruleInstructions[instruction];
+        if (ruleFunction !== void 0) {
+          return ruleFunction(node);
+        }
+        return void 0;
+      };
+    });
+    return enhancedRuleInstructions;
+  };
+}
+export {
+  detectTanstackRouterImports
+};
+//# sourceMappingURL=detect-router-imports.js.map

package/dist/esm/utils/detect-router-imports.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect-router-imports.js","sources":["../../../src/utils/detect-router-imports.ts"],"sourcesContent":["import { TSESTree } from '@typescript-eslint/utils'\nimport type { ESLintUtils, TSESLint } from '@typescript-eslint/utils'\n\ntype Create = Parameters<\n  ReturnType<typeof ESLintUtils.RuleCreator>\n>[0]['create']\n\ntype Context = Parameters<Create>[0]\ntype Options = Parameters<Create>[1]\ntype Helpers = {\n  isSpecificTanstackRouterImport: (\n    node: TSESTree.Identifier,\n    source: string,\n  ) => boolean\n  isTanstackRouterImport: (node: TSESTree.Identifier) => boolean\n}\n\ntype EnhancedCreate = (\n  context: Context,\n  options: Options,\n  helpers: Helpers,\n) => ReturnType<Create>\n\nexport function detectTanstackRouterImports(create: EnhancedCreate): Create {\n  return (context, optionsWithDefault) => {\n    const tanstackRouterImportSpecifiers: Array<TSESTree.ImportClause> = []\n\n    const helpers: Helpers = {\n      isSpecificTanstackRouterImport(node, source) {\n        return !!tanstackRouterImportSpecifiers.find((specifier) => {\n          if (\n            specifier.type === TSESTree.AST_NODE_TYPES.ImportSpecifier &&\n            specifier.parent.type ===\n              TSESTree.AST_NODE_TYPES.ImportDeclaration &&\n            specifier.parent.source.value === source\n          ) {\n            return node.name === specifier.local.name\n          }\n\n          return false\n        })\n      },\n      isTanstackRouterImport(node) {\n        return !!tanstackRouterImportSpecifiers.find((specifier) => {\n          if (specifier.type === TSESTree.AST_NODE_TYPES.ImportSpecifier) {\n            return node.name === specifier.local.name\n          }\n\n          return false\n        })\n      },\n    }\n\n    const detectionInstructions: TSESLint.RuleListener = {\n      ImportDeclaration(node) {\n        if (\n          node.specifiers.length > 0 &&\n          node.importKind === 'value' &&\n          node.source.value.startsWith('@tanstack/') &&\n          node.source.value.endsWith('-router')\n        ) {\n          tanstackRouterImportSpecifiers.push(...node.specifiers)\n        }\n      },\n    }\n\n    // Call original rule definition\n    const ruleInstructions = create(context, optionsWithDefault, helpers)\n    const enhancedRuleInstructions: TSESLint.RuleListener = {}\n\n    const allKeys = new Set(\n      Object.keys(detectionInstructions).concat(Object.keys(ruleInstructions)),\n    )\n\n    // Iterate over ALL instructions keys so we can override original rule instructions\n    // to prevent their execution if conditions to report errors are not met.\n    allKeys.forEach((instruction) => {\n      enhancedRuleInstructions[instruction] = (node) => {\n        if (instruction in detectionInstructions) {\n          detectionInstructions[instruction]?.(node)\n        }\n\n        const ruleFunction = ruleInstructions[instruction]\n        if (ruleFunction !== undefined) {\n          return ruleFunction(node)\n        }\n\n        return undefined\n      }\n    })\n\n    return enhancedRuleInstructions\n  }\n}\n"],"names":[],"mappings":";AAuBO,SAAS,4BAA4B,QAAgC;AACnE,SAAA,CAAC,SAAS,uBAAuB;AACtC,UAAM,iCAA+D,CAAC;AAEtE,UAAM,UAAmB;AAAA,MACvB,+BAA+B,MAAM,QAAQ;AAC3C,eAAO,CAAC,CAAC,+BAA+B,KAAK,CAAC,cAAc;AAC1D,cACE,UAAU,SAAS,SAAS,eAAe,mBAC3C,UAAU,OAAO,SACf,SAAS,eAAe,qBAC1B,UAAU,OAAO,OAAO,UAAU,QAClC;AACO,mBAAA,KAAK,SAAS,UAAU,MAAM;AAAA,UAAA;AAGhC,iBAAA;AAAA,QAAA,CACR;AAAA,MACH;AAAA,MACA,uBAAuB,MAAM;AAC3B,eAAO,CAAC,CAAC,+BAA+B,KAAK,CAAC,cAAc;AAC1D,cAAI,UAAU,SAAS,SAAS,eAAe,iBAAiB;AACvD,mBAAA,KAAK,SAAS,UAAU,MAAM;AAAA,UAAA;AAGhC,iBAAA;AAAA,QAAA,CACR;AAAA,MAAA;AAAA,IAEL;AAEA,UAAM,wBAA+C;AAAA,MACnD,kBAAkB,MAAM;AACtB,YACE,KAAK,WAAW,SAAS,KACzB,KAAK,eAAe,WACpB,KAAK,OAAO,MAAM,WAAW,YAAY,KACzC,KAAK,OAAO,MAAM,SAAS,SAAS,GACpC;AAC+B,yCAAA,KAAK,GAAG,KAAK,UAAU;AAAA,QAAA;AAAA,MACxD;AAAA,IAEJ;AAGA,UAAM,mBAAmB,OAAO,SAAS,oBAAoB,OAAO;AACpE,UAAM,2BAAkD,CAAC;AAEzD,UAAM,UAAU,IAAI;AAAA,MAClB,OAAO,KAAK,qBAAqB,EAAE,OAAO,OAAO,KAAK,gBAAgB,CAAC;AAAA,IACzE;AAIQ,YAAA,QAAQ,CAAC,gBAAgB;AACN,+BAAA,WAAW,IAAI,CAAC,SAAS;;AAChD,YAAI,eAAe,uBAAuB;AAClB,sCAAA,iBAAA,+CAAe;AAAA,QAAI;AAGrC,cAAA,eAAe,iBAAiB,WAAW;AACjD,YAAI,iBAAiB,QAAW;AAC9B,iBAAO,aAAa,IAAI;AAAA,QAAA;AAGnB,eAAA;AAAA,MACT;AAAA,IAAA,CACD;AAEM,WAAA;AAAA,EACT;AACF;"}

package/dist/esm/utils/get-docs-url.d.ts

@@ -0,0 +1 @@
+export declare const getDocsUrl: (ruleName: string) => string;

package/dist/esm/utils/get-docs-url.js

@@ -0,0 +1,5 @@
+const getDocsUrl = (ruleName) => `https://tanstack.com/router/latest/docs/eslint/${ruleName}`;
+export {
+  getDocsUrl
+};
+//# sourceMappingURL=get-docs-url.js.map

package/dist/esm/utils/get-docs-url.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-docs-url.js","sources":["../../../src/utils/get-docs-url.ts"],"sourcesContent":["export const getDocsUrl = (ruleName: string): string =>\n  `https://tanstack.com/router/latest/docs/eslint/${ruleName}`\n"],"names":[],"mappings":"AAAO,MAAM,aAAa,CAAC,aACzB,kDAAkD,QAAQ;"}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@tanstack/eslint-plugin-router",
+  "version": "1.20.3-alpha.1",
+  "description": "ESLint plugin for TanStack Router",
+  "author": "Manuel Schiller",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TanStack/router.git",
+    "directory": "packages/eslint-plugin-router"
+  },
+  "homepage": "https://tanstack.com/router",
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/tannerlinsley"
+  },
+  "type": "module",
+  "types": "dist/esm/index.d.ts",
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/esm/index.js",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.cts",
+        "default": "./dist/cjs/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "src"
+  ],
+  "dependencies": {
+    "@typescript-eslint/utils": "^8.23.0"
+  },
+  "devDependencies": {
+    "@typescript-eslint/rule-tester": "^8.23.0",
+    "combinate": "^1.1.11",
+    "eslint": "^9.22.0"
+  },
+  "peerDependencies": {
+    "eslint": "^8.57.0 || ^9.0.0"
+  },
+  "scripts": {}
+}

package/src/__tests__/create-route-property-order.rule.test.ts

@@ -0,0 +1,199 @@
+import { RuleTester } from '@typescript-eslint/rule-tester'
+import combinate from 'combinate'
+
+import {
+  name,
+  rule,
+} from '../rules/create-route-property-order/create-route-property-order.rule'
+import {
+  checkedProperties,
+  createRouteFunctionsDirect,
+  createRouteFunctionsIndirect,
+} from '../rules/create-route-property-order/constants'
+import {
+  generateInterleavedCombinations,
+  generatePartialCombinations,
+  generatePermutations,
+  normalizeIndent,
+} from './test-utils'
+
+const ruleTester = new RuleTester()
+
+// reduce the number of test cases by only testing a subset of the checked properties
+const testedCheckedProperties = [
+  checkedProperties[0]!,
+  checkedProperties[1]!,
+  checkedProperties[2]!,
+  checkedProperties[3]!,
+]
+type TestedCheckedProperties = (typeof testedCheckedProperties)[number]
+const orderIndependentProps = ['gcTime', '...foo'] as const
+type OrderIndependentProps = (typeof orderIndependentProps)[number]
+
+// reduce the number of test cases by only testing the first function of createRouteFunctionsDirect
+const testedCreateRouteFunctions = [
+  ...createRouteFunctionsIndirect,
+  createRouteFunctionsDirect[0],
+]
+type TestedCreateRouteFunction = (typeof testedCreateRouteFunctions)[number]
+
+interface TestCase {
+  createRouteFunction: TestedCreateRouteFunction
+  properties: Array<TestedCheckedProperties | OrderIndependentProps>
+}
+
+const validTestMatrix = combinate({
+  createRouteFunction: testedCreateRouteFunctions,
+  properties: generatePartialCombinations(testedCheckedProperties, 2),
+})
+
+export function generateInvalidPermutations(
+  arr: ReadonlyArray<TestedCheckedProperties>,
+): Array<{
+  invalid: Array<TestedCheckedProperties>
+  valid: Array<TestedCheckedProperties>
+}> {
+  const combinations = generatePartialCombinations(arr, 2)
+  const allPermutations: Array<{
+    invalid: Array<TestedCheckedProperties>
+    valid: Array<TestedCheckedProperties>
+  }> = []
+
+  for (const combination of combinations) {
+    const permutations = generatePermutations(combination)
+    // skip the first permutation as it matches the original combination
+    const invalidPermutations = permutations.slice(1)
+
+    if (
+      combination.includes('params') &&
+      combination.includes('validateSearch')
+    ) {
+      if (
+        combination.indexOf('params') < combination.indexOf('validateSearch')
+      ) {
+        // since we ignore the relative order of 'params' and 'validateSearch', we skip this combination (but keep the other one where `validateSearch` is before `params`)
+        continue
+      }
+    }
+
+    allPermutations.push(
+      ...invalidPermutations.map((p) => {
+        // ignore the relative order of 'params' and 'validateSearch'
+        const correctedValid = [...combination].sort((a, b) => {
+          if (
+            (a === 'params' && b === 'validateSearch') ||
+            (a === 'validateSearch' && b === 'params')
+          ) {
+            return p.indexOf(a) - p.indexOf(b)
+          }
+          return checkedProperties.indexOf(a) - checkedProperties.indexOf(b)
+        })
+        return { invalid: p, valid: correctedValid }
+      }),
+    )
+  }
+
+  return allPermutations
+}
+
+const invalidPermutations = generateInvalidPermutations(testedCheckedProperties)
+
+type Interleaved = TestedCheckedProperties | OrderIndependentProps
+const interleavedInvalidPermutations: Array<{
+  invalid: Array<Interleaved>
+  valid: Array<Interleaved>
+}> = []
+for (const invalidPermutation of invalidPermutations) {
+  const invalid = generateInterleavedCombinations(
+    invalidPermutation.invalid,
+    orderIndependentProps,
+  )
+  const valid = generateInterleavedCombinations(
+    invalidPermutation.valid,
+    orderIndependentProps,
+  )
+
+  for (let i = 0; i < invalid.length; i++) {
+    interleavedInvalidPermutations.push({
+      invalid: invalid[i]!,
+      valid: valid[i]!,
+    })
+  }
+}
+
+const invalidTestMatrix = combinate({
+  createRouteFunction: testedCreateRouteFunctions,
+  properties: interleavedInvalidPermutations,
+})
+
+function getCode({ createRouteFunction, properties }: TestCase) {
+  let invocation = ''
+  switch (createRouteFunction) {
+    case 'createFileRoute': {
+      invocation = `('/_layout/hello/foo/$id')`
+      break
+    }
+    case 'createRootRouteWithContext': {
+      invocation = normalizeIndent`
+      <{
+          queryClient: QueryClient
+       }>()`
+      break
+    }
+  }
+  function getPropertyCode(
+    property: TestedCheckedProperties | OrderIndependentProps,
+  ) {
+    if (property.startsWith('...')) {
+      return property
+    }
+    return `${property}: () => null`
+  }
+  return `
+    import { ${createRouteFunction} } from '@tanstack/react-router'
+
+    const Route = ${createRouteFunction}${invocation}({
+        ${properties.map(getPropertyCode).join(',\n        ')}
+    })
+  `
+}
+
+const validTestCases = validTestMatrix.map(
+  ({ createRouteFunction, properties }) => ({
+    name: `should pass when order is correct for ${createRouteFunction} with order: ${properties.join(', ')}`,
+    code: getCode({ createRouteFunction, properties }),
+  }),
+)
+
+invalidTestMatrix.push({
+  createRouteFunction: 'createFileRoute',
+  properties: {
+    invalid: ['loader', 'loaderDeps'],
+    valid: ['loaderDeps', 'loader'],
+  },
+})
+
+invalidTestMatrix.push({
+  createRouteFunction: 'createFileRoute',
+  properties: { invalid: ['head', 'loader'], valid: ['loader', 'head'] },
+})
+
+const invalidTestCases = invalidTestMatrix.map(
+  ({ createRouteFunction, properties }) => ({
+    name: `incorrect property order is detected for ${createRouteFunction} with order: ${properties.invalid.join(', ')}`,
+    code: getCode({
+      createRouteFunction,
+      properties: properties.invalid,
+    }),
+    errors: [{ messageId: 'invalidOrder' }],
+    output: getCode({
+      createRouteFunction,
+      properties: properties.valid,
+    }),
+  }),
+)
+
+ruleTester.run(name, rule, {
+  valid: validTestCases,
+  invalid: invalidTestCases,
+})