@tanstack/eslint-plugin-router 1.58.0

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

@@ -0,0 +1,28 @@
+function sortDataByOrder(data, orderArray, key) {
+  const orderMap = new Map(orderArray.map((item, index) => [item, index]));
+  const inOrderArray = data.filter((item) => orderMap.has(item[key])).sort((a, b) => {
+    const indexA = orderMap.get(a[key]);
+    const indexB = orderMap.get(b[key]);
+    return indexA - indexB;
+  });
+  const inOrderIterator = inOrderArray.values();
+  let wasResorted = false;
+  const result = data.map((item) => {
+    if (orderMap.has(item[key])) {
+      const sortedItem = inOrderIterator.next().value;
+      if (sortedItem[key] !== item[key]) {
+        wasResorted = true;
+      }
+      return sortedItem;
+    }
+    return item;
+  });
+  if (!wasResorted) {
+    return null;
+  }
+  return result;
+}
+export {
+  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  orderArray: Array<T[TKey]> | ReadonlyArray<T[TKey]>,\n  key: TKey,\n): Array<T> | null {\n  const orderMap = new Map(orderArray.map((item, index) => [item, index]))\n\n  // Separate items that are in orderArray from those that are not\n  const inOrderArray = data\n    .filter((item) => orderMap.has(item[key]))\n    .sort((a, b) => {\n      const indexA = orderMap.get(a[key])!\n      const indexB = orderMap.get(b[key])!\n\n      return indexA - indexB\n    })\n\n  const inOrderIterator = inOrderArray.values()\n\n  // `as boolean` is needed to avoid TS incorrectly inferring that wasResorted is always `true`\n  let wasResorted = false as boolean\n\n  const result = data.map((item) => {\n    if (orderMap.has(item[key])) {\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"],"names":[],"mappings":"AAAgB,SAAA,gBACd,MACA,YACA,KACiB;AACjB,QAAM,WAAW,IAAI,IAAI,WAAW,IAAI,CAAC,MAAM,UAAU,CAAC,MAAM,KAAK,CAAC,CAAC;AAGvE,QAAM,eAAe,KAClB,OAAO,CAAC,SAAS,SAAS,IAAI,KAAK,GAAG,CAAC,CAAC,EACxC,KAAK,CAAC,GAAG,MAAM;AACd,UAAM,SAAS,SAAS,IAAI,EAAE,GAAG,CAAC;AAClC,UAAM,SAAS,SAAS,IAAI,EAAE,GAAG,CAAC;AAElC,WAAO,SAAS;AAAA,EAAA,CACjB;AAEG,QAAA,kBAAkB,aAAa;AAGrC,MAAI,cAAc;AAElB,QAAM,SAAS,KAAK,IAAI,CAAC,SAAS;AAChC,QAAI,SAAS,IAAI,KAAK,GAAG,CAAC,GAAG;AACrB,YAAA,aAAa,gBAAgB,KAAA,EAAO;AAC1C,UAAI,WAAW,GAAG,MAAM,KAAK,GAAG,GAAG;AACnB,sBAAA;AAAA,MAChB;AACO,aAAA;AAAA,IACT;AACO,WAAA;AAAA,EAAA,CACR;AAED,MAAI,CAAC,aAAa;AACT,WAAA;AAAA,EACT;AACO,SAAA;AACT;"}

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 { name, rule } 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,CAAA;AAErE,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,UACvC;AAEO,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,UACvC;AAEO,iBAAA;AAAA,QAAA,CACR;AAAA,MACH;AAAA,IAAA;AAGF,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,QACxD;AAAA,MACF;AAAA,IAAA;AAIF,UAAM,mBAAmB,OAAO,SAAS,oBAAoB,OAAO;AACpE,UAAM,2BAAkD,CAAA;AAExD,UAAM,UAAU,IAAI;AAAA,MAClB,OAAO,KAAK,qBAAqB,EAAE,OAAO,OAAO,KAAK,gBAAgB,CAAC;AAAA,IAAA;AAKjE,YAAA,QAAQ,CAAC,gBAAgB;AACN,+BAAA,WAAW,IAAI,CAAC,SAAS;;AAChD,YAAI,eAAe,uBAAuB;AAClB,sCAAA,iBAAA,+CAAe;AAAA,QACvC;AAEM,cAAA,eAAe,iBAAiB,WAAW;AACjD,YAAI,iBAAiB,QAAW;AAC9B,iBAAO,aAAa,IAAI;AAAA,QAC1B;AAEO,eAAA;AAAA,MAAA;AAAA,IACT,CACD;AAEM,WAAA;AAAA,EAAA;AAEX;"}

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.58.0",
+  "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.3.0"
+  },
+  "devDependencies": {
+    "@typescript-eslint/rule-tester": "^8.3.0",
+    "combinate": "^1.1.11",
+    "eslint": "^9.9.1"
+  },
+  "peerDependencies": {
+    "eslint": "^8.57.0 || ^9.0.0"
+  },
+  "scripts": {}
+}

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

@@ -0,0 +1,153 @@
+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],
+]
+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<T>(
+  arr: ReadonlyArray<T>,
+): Array<{ invalid: Array<T>; valid: Array<T> }> {
+  const combinations = generatePartialCombinations(arr, 2)
+  const allPermutations: Array<{ invalid: Array<T>; valid: Array<T> }> = []
+
+  for (const combination of combinations) {
+    const permutations = generatePermutations(combination)
+    // skip the first permutation as it matches the original combination
+    const invalidPermutations = permutations.slice(1)
+    allPermutations.push(
+      ...invalidPermutations.map((p) => ({ invalid: p, valid: combination })),
+    )
+  }
+
+  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 }),
+  }),
+)
+
+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,
+})

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

@@ -0,0 +1,58 @@
+import { describe, expect, test } from 'vitest'
+import { sortDataByOrder } from '../rules/create-route-property-order/create-route-property-order.utils'
+
+describe('create-route-property-order utils', () => {
+  describe('sortDataByOrder', () => {
+    const testCases = [
+      {
+        data: [{ key: 'a' }, { key: 'c' }, { key: 'b' }],
+        orderArray: ['a', 'b', 'c'],
+        key: 'key',
+        expected: [{ key: 'a' }, { key: 'b' }, { key: 'c' }],
+      },
+      {
+        data: [{ key: 'b' }, { key: 'a' }, { key: 'c' }],
+        orderArray: ['a', 'b', 'c'],
+        key: 'key',
+        expected: [{ key: 'a' }, { key: 'b' }, { key: 'c' }],
+      },
+      {
+        data: [{ key: 'a' }, { key: 'b' }, { key: 'c' }],
+        orderArray: ['a', 'b', 'c'],
+        key: 'key',
+        expected: null,
+      },
+      {
+        data: [{ key: 'a' }, { key: 'b' }, { key: 'c' }, { key: 'd' }],
+        orderArray: ['a', 'b', 'c'],
+        key: 'key',
+        expected: null,
+      },
+      {
+        data: [{ key: 'a' }, { key: 'b' }, { key: 'd' }, { key: 'c' }],
+        orderArray: ['a', 'b', 'c'],
+        key: 'key',
+        expected: null,
+      },
+      {
+        data: [{ key: 'd' }, { key: 'a' }, { key: 'b' }, { key: 'c' }],
+        orderArray: ['a', 'b', 'c'],
+        key: 'key',
+        expected: null,
+      },
+      {
+        data: [{ key: 'd' }, { key: 'b' }, { key: 'a' }, { key: 'c' }],
+        orderArray: ['a', 'b', 'c'],
+        key: 'key',
+        expected: [{ key: 'd' }, { key: 'a' }, { key: 'b' }, { key: 'c' }],
+      },
+    ] as const
+    test.each(testCases)(
+      '$data $orderArray $key $expected',
+      ({ data, orderArray, key, expected }) => {
+        const sortedData = sortDataByOrder(data, orderArray, key)
+        expect(sortedData).toEqual(expected)
+      },
+    )
+  })
+})

package/src/__tests__/test-utils.test.ts

@@ -0,0 +1,104 @@
+import { describe, expect, test } from 'vitest'
+import {
+  expectArrayEqualIgnoreOrder,
+  generateInterleavedCombinations,
+  generatePartialCombinations,
+  generatePermutations,
+} from './test-utils'
+
+describe('test-utils', () => {
+  describe('generatePermutations', () => {
+    const testCases = [
+      {
+        input: ['a', 'b', 'c'],
+        expected: [
+          ['a', 'b', 'c'],
+          ['a', 'c', 'b'],
+          ['b', 'a', 'c'],
+          ['b', 'c', 'a'],
+          ['c', 'a', 'b'],
+          ['c', 'b', 'a'],
+        ],
+      },
+      {
+        input: ['a', 'b'],
+        expected: [
+          ['a', 'b'],
+          ['b', 'a'],
+        ],
+      },
+      {
+        input: ['a'],
+        expected: [['a']],
+      },
+    ]
+    test.each(testCases)('$input $expected', ({ input, expected }) => {
+      const permutations = generatePermutations(input)
+      expect(permutations).toEqual(expected)
+    })
+  })
+
+  describe('generatePartialCombinations', () => {
+    const testCases = [
+      {
+        input: ['a', 'b', 'c'],
+        minLength: 2,
+        expected: [
+          ['a', 'b'],
+          ['a', 'c'],
+          ['b', 'c'],
+          ['a', 'b', 'c'],
+        ],
+      },
+      {
+        input: ['a', 'b'],
+        expected: [['a', 'b']],
+        minLength: 2,
+      },
+      {
+        input: ['a'],
+        expected: [],
+        minLength: 2,
+      },
+      {
+        input: ['a'],
+        expected: [['a']],
+        minLength: 1,
+      },
+      {
+        input: ['a'],
+        expected: [[], ['a']],
+        minLength: 0,
+      },
+    ]
+    test.each(testCases)(
+      '$input $minLength $expected ',
+      ({ input, minLength, expected }) => {
+        const combinations = generatePartialCombinations(input, minLength)
+        expectArrayEqualIgnoreOrder(combinations, expected)
+      },
+    )
+  })
+
+  describe('generateInterleavedCombinations', () => {
+    const testCases = [
+      {
+        data: ['a', 'b'],
+        additional: ['x'],
+        expected: [
+          ['a', 'b'],
+          ['x', 'a', 'b'],
+          ['a', 'x', 'b'],
+          ['a', 'b', 'x'],
+        ],
+      },
+    ]
+    test.each(testCases)(
+      '$input $expected',
+      ({ data, additional, expected }) => {
+        const combinations = generateInterleavedCombinations(data, additional)
+        expectArrayEqualIgnoreOrder(combinations, expected)
+      },
+    )
+  })
+})

package/src/__tests__/test-utils.ts

@@ -0,0 +1,108 @@
+import { expect } from 'vitest'
+
+export function generatePermutations<T>(arr: Array<T>): Array<Array<T>> {
+  if (arr.length <= 1) {
+    return [arr]
+  }
+
+  const result: Array<Array<T>> = []
+  for (let i = 0; i < arr.length; i++) {
+    const rest = arr.slice(0, i).concat(arr.slice(i + 1))
+    const restPermutations = generatePermutations(rest)
+    for (const perm of restPermutations) {
+      result.push([arr[i]!, ...perm])
+    }
+  }
+
+  return result
+}
+
+export function generatePartialCombinations<T>(
+  arr: ReadonlyArray<T>,
+  minLength: number,
+): Array<Array<T>> {
+  const result: Array<Array<T>> = []
+
+  function backtrack(start: number, current: Array<T>) {
+    if (current.length > minLength - 1) {
+      result.push([...current])
+    }
+    for (let i = start; i < arr.length; i++) {
+      current.push(arr[i]!)
+      backtrack(i + 1, current)
+      current.pop()
+    }
+  }
+  backtrack(0, [])
+  return result
+}
+
+export function expectArrayEqualIgnoreOrder<T>(a: Array<T>, b: Array<T>) {
+  expect([...a].sort()).toEqual([...b].sort())
+}
+
+export function normalizeIndent(template: TemplateStringsArray) {
+  const codeLines = template[0]?.split('\n') ?? ['']
+  const leftPadding = codeLines[1]?.match(/\s+/)?.[0] ?? ''
+  return codeLines.map((line) => line.slice(leftPadding.length)).join('\n')
+}
+
+export function generateInterleavedCombinations<
+  TData,
+  TAdditional,
+  TResult extends TData | TAdditional,
+>(
+  data: Array<TData> | ReadonlyArray<TData>,
+  additional: Array<TAdditional> | ReadonlyArray<TAdditional>,
+): Array<Array<TResult>> {
+  const result: Array<Array<TResult>> = []
+
+  function getSubsets(array: Array<TAdditional>): Array<Array<TAdditional>> {
+    return array.reduce(
+      (subsets, value) => {
+        return subsets.concat(subsets.map((set) => [...set, value]))
+      },
+      [[]] as Array<Array<TAdditional>>,
+    )
+  }
+
+  function insertAtPositions(
+    data: Array<TResult>,
+    subset: Array<TResult>,
+  ): Array<Array<TResult>> {
+    const combinations: Array<Array<TResult>> = []
+
+    const recurse = (
+      currentData: Array<TResult>,
+      currentSubset: Array<TResult>,
+      start: number,
+    ): void => {
+      if (currentSubset.length === 0) {
+        combinations.push([...currentData])
+        return
+      }
+
+      for (let i = start; i <= currentData.length; i++) {
+        const newData = [
+          ...currentData.slice(0, i),
+          currentSubset[0]!,
+          ...currentData.slice(i),
+        ]
+        recurse(newData, currentSubset.slice(1), i + 1)
+      }
+    }
+
+    recurse(data, subset, 0)
+    return combinations
+  }
+
+  const subsets = getSubsets(additional as Array<TAdditional>)
+
+  subsets.forEach((subset) => {
+    result.push(
+      ...insertAtPositions(data as Array<TResult>, subset as Array<TResult>),
+    )
+  })
+
+  return result
+}

package/src/index.ts

@@ -0,0 +1,43 @@
+import { rules } from './rules'
+import type { ESLint, Linter } from 'eslint'
+import type { RuleModule } from '@typescript-eslint/utils/ts-eslint'
+
+type RuleKey = keyof typeof rules
+
+interface Plugin extends Omit<ESLint.Plugin, 'rules'> {
+  rules: Record<RuleKey, RuleModule<any, any, any>>
+  configs: {
+    recommended: ESLint.ConfigData
+    'flat/recommended': Array<Linter.FlatConfig>
+  }
+}
+
+const plugin: Plugin = {
+  meta: {
+    name: '@tanstack/eslint-plugin-router',
+  },
+  configs: {} as Plugin['configs'],
+  rules,
+}
+
+// Assign configs here so we can reference `plugin`
+Object.assign(plugin.configs, {
+  recommended: {
+    plugins: ['@tanstack/eslint-plugin-router'],
+    rules: {
+      '@tanstack/router/create-route-property-order': 'warn',
+    },
+  },
+  'flat/recommended': [
+    {
+      plugins: {
+        '@tanstack/router': plugin,
+      },
+      rules: {
+        '@tanstack/router/create-route-property-order': 'warn',
+      },
+    },
+  ],
+})
+
+export default plugin