@dvukovic/style-guide 0.16.0 → 0.18.0

package/dist/eslint/plugins/dvukovic.d.ts

@@ -1,2 +1,4 @@
 /** @type {import("@eslint/config-helpers").Config} */
 export const dvukovic: import("@eslint/config-helpers").Config;
+/** @type {import("@eslint/config-helpers").Config} */
+export const dvukovicNextjs: import("@eslint/config-helpers").Config;

package/dist/eslint/rules/nextjs-export-name/nextjs-export-name.d.ts

@@ -0,0 +1,19 @@
+export namespace nextjsExportName {
+    function create(context: any): {
+        ExportDefaultDeclaration?: undefined;
+    } | {
+        ExportDefaultDeclaration(node: any): void;
+    };
+    namespace meta {
+        namespace docs {
+            let description: string;
+        }
+        let fixable: string;
+        namespace messages {
+            let anonymous: string;
+            let mismatch: string;
+        }
+        let schema: never[];
+        let type: string;
+    }
+}

package/dist/eslint/rules/no-cross-module-imports/no-cross-module-imports.d.ts

@@ -0,0 +1,30 @@
+export namespace noCrossModuleImports {
+    function create(context: any): {
+        CallExpression?: undefined;
+        ImportDeclaration?: undefined;
+        ImportExpression?: undefined;
+    } | {
+        CallExpression(node: any): void;
+        ImportDeclaration(node: any): void;
+        ImportExpression(node: any): void;
+    };
+    namespace meta {
+        namespace docs {
+            let description: string;
+        }
+        namespace messages {
+            let noCrossModuleImports: string;
+        }
+        let schema: {
+            additionalProperties: boolean;
+            properties: {
+                modulesDirectory: {
+                    default: string;
+                    type: string;
+                };
+            };
+            type: string;
+        }[];
+        let type: string;
+    }
+}

package/dist/eslint/rules/no-instanceof-error/no-instanceof-error.d.ts

@@ -0,0 +1,16 @@
+export namespace noInstanceofError {
+    function create(context: any): {
+        BinaryExpression(node: any): void;
+    };
+    namespace meta {
+        namespace docs {
+            let description: string;
+        }
+        let fixable: string;
+        namespace messages {
+            let forbidden: string;
+        }
+        let schema: never[];
+        let type: string;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@dvukovic/style-guide",
-    "version": "0.16.0",
+    "version": "0.18.0",
     "description": "My own style guide",
     "repository": {
         "type": "git",

package/src/cli/generators/eslint.js

@@ -31,6 +31,8 @@ export function generateESLintConfig(options) {
     }
 
     if (framework === "next") {
+        imports.push("react")
+        configs.push("react()")
         imports.push("next")
         configs.push("next()")
         ignores.push("out")

package/src/cli/generators/scripts.js

@@ -26,11 +26,13 @@ export function generateScripts(tools, packageManager) {
     if (tools.includes("cspell")) {
         scripts["lint:cspell"] = "cspell --no-progress --no-summary --unique '**'"
         lintParts.push(`${runner} lint:cspell`)
+        fixParts.push(`${runner} lint:cspell`)
     }
 
     if (tools.includes("knip")) {
         scripts["lint:knip"] = "knip --cache"
         lintParts.push(`${runner} lint:knip`)
+        fixParts.push(`${runner} lint:knip`)
     }
 
     if (lintParts.length > 0) {

package/src/eslint/configs/next.js

@@ -1,7 +1,8 @@
 import { ALL_JS_TS_FILES } from "../file-patterns.js"
+import { dvukovicNextjs } from "../plugins/dvukovic.js"
 import { next as nextPlugin } from "../plugins/next.js"
 
-export const nextConfig = [nextPlugin]
+export const nextConfig = [nextPlugin, dvukovicNextjs]
 
 /**
  * Next.js framework configuration

package/src/eslint/plugins/dvukovic.js

@@ -1,21 +1,41 @@
 import { documentTodos } from "../rules/document-todos/document-todos.js"
+import { nextjsExportName } from "../rules/nextjs-export-name/nextjs-export-name.js"
 import { noCommentedOutCode } from "../rules/no-commented-out-code/no-commented-out-code.js"
+import { noCrossModuleImports } from "../rules/no-cross-module-imports/no-cross-module-imports.js"
+import { noInstanceofError } from "../rules/no-instanceof-error/no-instanceof-error.js"
 import { noT } from "../rules/no-t/no-t.js"
 
+const dvukovicPlugin = {
+    rules: {
+        "document-todos": documentTodos,
+        "nextjs-export-name": nextjsExportName,
+        "no-commented-out-code": noCommentedOutCode,
+        "no-cross-module-imports": noCrossModuleImports,
+        "no-instanceof-error": noInstanceofError,
+        "no-t": noT,
+    },
+}
+
 /** @type {import("@eslint/config-helpers").Config} */
 export const dvukovic = {
     plugins: {
-        dvukovic: {
-            rules: {
-                "document-todos": documentTodos,
-                "no-commented-out-code": noCommentedOutCode,
-                "no-t": noT,
-            },
-        },
+        dvukovic: dvukovicPlugin,
     },
     rules: {
         "dvukovic/document-todos": ["error", { url: "http" }],
         "dvukovic/no-commented-out-code": "error",
+        "dvukovic/no-instanceof-error": "error",
         "dvukovic/no-t": "error",
     },
 }
+
+/** @type {import("@eslint/config-helpers").Config} */
+export const dvukovicNextjs = {
+    plugins: {
+        dvukovic: dvukovicPlugin,
+    },
+    rules: {
+        "dvukovic/nextjs-export-name": "error",
+        "dvukovic/no-cross-module-imports": "error",
+    },
+}

package/src/eslint/rules/nextjs-export-name/nextjs-export-name.js

@@ -0,0 +1,130 @@
+import path from "node:path"
+
+const SPECIAL_FILES = new Map([
+    ["page", "Page"],
+    ["layout", "Layout"],
+    ["loading", "Loading"],
+    ["error", "Error"],
+    ["not-found", "NotFound"],
+    ["template", "Template"],
+    ["default", "Default"],
+    ["global-error", "GlobalError"],
+])
+
+function getExpectedName(filename) {
+    const basename = path.basename(filename)
+    const nameWithoutExtension = basename.replace(/\.[^.]+$/, "")
+
+    return SPECIAL_FILES.get(nameWithoutExtension) ?? null
+}
+
+export const nextjsExportName = {
+    create(context) {
+        const expectedName = getExpectedName(context.filename)
+
+        if (!expectedName) {
+            return {}
+        }
+
+        return {
+            ExportDefaultDeclaration(node) {
+                const declaration = node.declaration
+
+                if (
+                    declaration.type === "FunctionDeclaration" ||
+                    declaration.type === "ClassDeclaration"
+                ) {
+                    if (!declaration.id) {
+                        context.report({
+                            data: { expectedName },
+                            messageId: "anonymous",
+                            node,
+                        })
+
+                        return
+                    }
+
+                    if (declaration.id.name !== expectedName) {
+                        context.report({
+                            data: {
+                                actualName: declaration.id.name,
+                                expectedName,
+                            },
+                            fix(fixer) {
+                                return fixer.replaceText(declaration.id, expectedName)
+                            },
+                            messageId: "mismatch",
+                            node,
+                        })
+                    }
+
+                    return
+                }
+
+                if (declaration.type === "Identifier") {
+                    const scope = context.sourceCode.getScope(node)
+                    const variable = scope.set.get(declaration.name)
+
+                    if (!variable) {
+                        return
+                    }
+
+                    const definition = variable.defs[0]
+
+                    if (!definition) {
+                        return
+                    }
+
+                    if (declaration.name !== expectedName) {
+                        context.report({
+                            data: {
+                                actualName: declaration.name,
+                                expectedName,
+                            },
+                            fix(fixer) {
+                                const replaced = new Set()
+                                const fixes = []
+
+                                if (definition.name) {
+                                    fixes.push(fixer.replaceText(definition.name, expectedName))
+                                    replaced.add(definition.name.range[0])
+                                }
+
+                                const unreplacedReferences = variable.references.filter(
+                                    (reference) => {
+                                        return !replaced.has(reference.identifier.range[0])
+                                    },
+                                )
+
+                                for (const reference of unreplacedReferences) {
+                                    fixes.push(
+                                        fixer.replaceText(reference.identifier, expectedName),
+                                    )
+                                }
+
+                                return fixes
+                            },
+                            messageId: "mismatch",
+                            node,
+                        })
+                    }
+                }
+            },
+        }
+    },
+    meta: {
+        docs: {
+            description:
+                "Enforces that default exports in Next.js special files match the expected PascalCase name derived from the filename.",
+        },
+        fixable: "code",
+        messages: {
+            anonymous:
+                "Default export in this file must be a named function. Expected name: `{{ expectedName }}`.",
+            mismatch:
+                "Default export `{{ actualName }}` does not match the expected name `{{ expectedName }}` for this file.",
+        },
+        schema: [],
+        type: "problem",
+    },
+}

package/src/eslint/rules/no-cross-module-imports/no-cross-module-imports.js

@@ -0,0 +1,110 @@
+import path from "node:path"
+
+const DEFAULT_MODULES_DIRECTORY = "src/modules"
+
+function getModuleName(filePath, modulesDirectory) {
+    const normalizedPath = filePath.replaceAll("\\", "/")
+    const normalizedModulesDirectory = modulesDirectory.replaceAll("\\", "/")
+
+    const modulesIndex = normalizedPath.indexOf(`${normalizedModulesDirectory}/`)
+
+    if (modulesIndex === -1) {
+        return null
+    }
+
+    const afterModules = normalizedPath.slice(modulesIndex + normalizedModulesDirectory.length + 1)
+
+    const moduleName = afterModules.split("/")[0]
+
+    return moduleName ?? null
+}
+
+export const noCrossModuleImports = {
+    create(context) {
+        const modulesDirectory = context.options[0]?.modulesDirectory ?? DEFAULT_MODULES_DIRECTORY
+
+        const currentModule = getModuleName(context.filename, modulesDirectory)
+
+        if (!currentModule) {
+            return {}
+        }
+
+        function checkImportSource(node, source) {
+            if (!source || typeof source !== "string") {
+                return
+            }
+
+            if (!source.startsWith(".")) {
+                return
+            }
+
+            const resolvedPath = path.resolve(path.dirname(context.filename), source)
+            const targetModule = getModuleName(resolvedPath, modulesDirectory)
+
+            if (!targetModule) {
+                return
+            }
+
+            if (targetModule !== currentModule) {
+                context.report({
+                    data: {
+                        currentModule,
+                        targetModule,
+                    },
+                    messageId: "noCrossModuleImports",
+                    node,
+                })
+            }
+        }
+
+        return {
+            CallExpression(node) {
+                // eslint-disable-next-line baseline-js/use-baseline -- false positive: AST node property, not Function.arguments
+                if (node.callee.name !== "require" || node.arguments.length === 0) {
+                    return
+                }
+
+                const argument = node.arguments[0] // eslint-disable-line baseline-js/use-baseline -- false positive: AST node property, not Function.arguments
+
+                if (argument.type !== "Literal" || typeof argument.value !== "string") {
+                    return
+                }
+
+                checkImportSource(node, argument.value)
+            },
+            ImportDeclaration(node) {
+                checkImportSource(node, node.source.value)
+            },
+            ImportExpression(node) {
+                if (node.source.type !== "Literal" || typeof node.source.value !== "string") {
+                    return
+                }
+
+                checkImportSource(node, node.source.value)
+            },
+        }
+    },
+    meta: {
+        docs: {
+            description:
+                "Prevents importing from one module into another inside the modules directory to enforce module isolation.",
+        },
+        messages: {
+            noCrossModuleImports:
+                'Importing from module "{{targetModule}}" is not allowed inside module "{{currentModule}}".',
+        },
+        schema: [
+            {
+                additionalProperties: false,
+                properties: {
+                    modulesDirectory: {
+                        default: DEFAULT_MODULES_DIRECTORY,
+                        type: "string",
+                    },
+                },
+                type: "object",
+            },
+        ],
+        type: "problem",
+    },
+}

package/src/eslint/rules/no-instanceof-error/no-instanceof-error.js

@@ -0,0 +1,36 @@
+export const noInstanceofError = {
+    create(context) {
+        return {
+            BinaryExpression(node) {
+                if (
+                    node.operator === "instanceof" &&
+                    node.right.type === "Identifier" &&
+                    node.right.name === "Error"
+                ) {
+                    context.report({
+                        fix(fixer) {
+                            const leftText = context.sourceCode.getText(node.left)
+
+                            return fixer.replaceText(node, `Error.isError(${leftText})`)
+                        },
+                        messageId: "forbidden",
+                        node,
+                    })
+                }
+            },
+        }
+    },
+    meta: {
+        docs: {
+            description:
+                "Forbids `instanceof Error` in favor of `Error.isError()` which works across realms.",
+        },
+        fixable: "code",
+        messages: {
+            forbidden:
+                "Use `Error.isError()` instead of `instanceof Error`. It works across realms where `instanceof` fails.",
+        },
+        schema: [],
+        type: "problem",
+    },
+}