eslint-plugin-stamhoofd 2.134.0 → 2.136.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "eslint-plugin-stamhoofd",
-    "version": "2.134.0",
+    "version": "2.136.0",
     "type": "module",
     "main": "./src/index.js",
     "sideEffects": false,
@@ -30,5 +30,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "42955365bcf0bcfd0815998c1039e23d6ee1d6c6"
+    "gitHead": "0adab3f0a2aac8470c58ac717c3d96a824e5f935"
 }

package/src/index.js

@@ -13,11 +13,13 @@ 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 noPackageSelfImport from './rules/no-package-self-import.js';
 import preferDefineRoute from './rules/prefer-define-route.js';
 
 const rules = {
     'async-component-with-properties': asyncComponentWithProperties,
     'async-route-components': asyncRouteComponents,
+    'no-package-self-import': noPackageSelfImport,
     'prefer-define-route': preferDefineRoute,
 };
 const stamhoofdPlugin = {
@@ -72,6 +74,17 @@ const baseRules = [
             'import/no-relative-packages': 'error',
         },
     },
+    {
+        plugins: {
+            stamhoofd: stamhoofdPlugin,
+        },
+        rules: {
+            // Importing a package's own name from inside that package resolves through its
+            // "exports" (the built dist for some packages), which duplicates modules and
+            // breaks tsc project references. Use a relative or '#' subpath import instead.
+            'stamhoofd/no-package-self-import': 'error',
+        },
+    },
 
     stylistic.configs.customize({
         // the following options are the default values

package/src/rules/no-package-self-import.js

@@ -0,0 +1,104 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+// Directory → name of the nearest package.json with a "name" field (null if none).
+const packageNameCache = new Map();
+
+function findOwnPackageName(startDir) {
+    const unresolvedDirs = [];
+    let dir = startDir;
+    let name = null;
+
+    while (true) {
+        if (packageNameCache.has(dir)) {
+            name = packageNameCache.get(dir);
+            break;
+        }
+        unresolvedDirs.push(dir);
+
+        try {
+            const parsed = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf8'));
+            if (typeof parsed.name === 'string' && parsed.name !== '') {
+                name = parsed.name;
+                break;
+            }
+        } catch {
+            // No (or invalid) package.json in this directory: keep walking up.
+        }
+
+        const parent = path.dirname(dir);
+        if (parent === dir) {
+            break;
+        }
+        dir = parent;
+    }
+
+    for (const visited of unresolvedDirs) {
+        packageNameCache.set(visited, name);
+    }
+
+    return name;
+}
+
+function getImportedPackageName(specifier) {
+    if (specifier.startsWith('.') || specifier.startsWith('/') || specifier.startsWith('#')) {
+        // Relative, absolute or subpath ("imports") specifiers never target a package by name.
+        return null;
+    }
+
+    const parts = specifier.split('/');
+    if (specifier.startsWith('@')) {
+        return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : null;
+    }
+    return parts[0];
+}
+
+export default {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Forbid a package from importing itself by its own package name.',
+        },
+        schema: [],
+        messages: {
+            noPackageSelfImport: 'Do not import \'{{specifier}}\' from inside {{packageName}} itself. Self-name imports resolve through the package "exports" (the built dist for some packages), which duplicates modules and breaks tsc project references. Use a relative or \'#\' subpath import instead.',
+        },
+    },
+    create(context) {
+        const filename = path.resolve(context.cwd, context.filename);
+        const ownPackageName = findOwnPackageName(path.dirname(filename));
+
+        if (ownPackageName === null) {
+            return {};
+        }
+
+        function checkSource(source) {
+            if (!source || source.type !== 'Literal' || typeof source.value !== 'string') {
+                return;
+            }
+
+            if (getImportedPackageName(source.value) === ownPackageName) {
+                context.report({
+                    node: source,
+                    messageId: 'noPackageSelfImport',
+                    data: { specifier: source.value, packageName: ownPackageName },
+                });
+            }
+        }
+
+        return {
+            ImportDeclaration(node) {
+                checkSource(node.source);
+            },
+            ExportNamedDeclaration(node) {
+                checkSource(node.source);
+            },
+            ExportAllDeclaration(node) {
+                checkSource(node.source);
+            },
+            ImportExpression(node) {
+                checkSource(node.source);
+            },
+        };
+    },
+};