eslint-plugin-stamhoofd 2.133.0 → 2.135.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "eslint-plugin-stamhoofd",
-    "version": "2.133.0",
+    "version": "2.135.0",
     "type": "module",
     "main": "./src/index.js",
     "sideEffects": false,
@@ -30,5 +30,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "65d5f0a31f87b8e3b7a23349f08cf7943ef15bda"
+    "gitHead": "df20ecb0e4b10af877d2e37e92e39100afe342e8"
 }

package/src/index.js

@@ -13,10 +13,12 @@ import node from './configs/node.js';
 import typescript from './configs/typescript.js';
 import asyncComponentWithProperties from './rules/async-component-with-properties.js';
 import asyncRouteComponents from './rules/async-route-components.js';
+import preferDefineRoute from './rules/prefer-define-route.js';
 
 const rules = {
     'async-component-with-properties': asyncComponentWithProperties,
     'async-route-components': asyncRouteComponents,
+    'prefer-define-route': preferDefineRoute,
 };
 const stamhoofdPlugin = {
     rules,
@@ -163,6 +165,7 @@ export default {
                         ],
                     }],
                     'stamhoofd/async-route-components': 'error',
+                    'stamhoofd/prefer-define-route': 'warn',
                     // TODO: restore to 'error' once the existing dependency cycles are resolved.
                     'import/no-cycle': ['warn', { maxDepth: 100, ignoreExternal: false, allowUnsafeDynamicCyclicDependency: true }],
                     // Disallow importing from barrel files (index files that only re-export).

package/src/rules/prefer-define-route.js

@@ -0,0 +1,79 @@
+const navigationPackage = '@simonbackx/vue-app-navigation';
+
+function unwrapExpression(node) {
+    while (
+        node?.type === 'TSAsExpression'
+        || node?.type === 'TSNonNullExpression'
+        || node?.type === 'TSSatisfiesExpression'
+        || node?.type === 'TSTypeAssertion'
+        || node?.type === 'ChainExpression'
+    ) {
+        node = node.expression;
+    }
+
+    return node;
+}
+
+function findVariable(sourceCode, identifier) {
+    let scope = sourceCode.getScope(identifier);
+
+    while (scope) {
+        const variable = scope.set.get(identifier.name);
+        if (variable) {
+            return variable;
+        }
+        scope = scope.upper;
+    }
+
+    return null;
+}
+
+function getImportedName(variable) {
+    const definition = variable?.defs.find(def => def.type === 'ImportBinding');
+    const importDeclaration = definition?.parent;
+
+    if (importDeclaration?.type !== 'ImportDeclaration' || importDeclaration.source.value !== navigationPackage) {
+        return null;
+    }
+
+    if (definition.node.type !== 'ImportSpecifier') {
+        return null;
+    }
+
+    return definition.node.imported.name ?? definition.node.imported.value;
+}
+
+function isDefineRoutes(sourceCode, node) {
+    if (node.type !== 'Identifier') {
+        return false;
+    }
+
+    return getImportedName(findVariable(sourceCode, node)) === 'defineRoutes';
+}
+
+export default {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer defineRoute over defineRoutes for better type safety.',
+        },
+        schema: [],
+        messages: {
+            preferDefineRoute: 'Prefer defineRoute over defineRoutes: defineRoutes is typed as Route<any>[] and loses type safety. Call defineRoute for each route instead.',
+        },
+    },
+    create(context) {
+        const sourceCode = context.sourceCode;
+
+        return {
+            CallExpression(node) {
+                if (isDefineRoutes(sourceCode, unwrapExpression(node.callee))) {
+                    context.report({
+                        node: node.callee,
+                        messageId: 'preferDefineRoute',
+                    });
+                }
+            },
+        };
+    },
+};