eslint-plugin-n 15.1.0 → 15.2.2

package/README.md

@@ -93,7 +93,7 @@ $ npm install --save-dev eslint eslint-plugin-n
 | Rule ID | Description |    |
 |:--------|:------------|:--:|
 | [n/callback-return](./docs/rules/callback-return.md) | require `return` statements after callbacks |  |
-| [n/exports-style](./docs/rules/exports-style.md) | enforce either `module.exports` or `exports` |  |
+| [n/exports-style](./docs/rules/exports-style.md) | enforce either `module.exports` or `exports` | ✒️ |
 | [n/file-extension-in-import](./docs/rules/file-extension-in-import.md) | enforce the style of file extensions in `import` declarations | ✒️ |
 | [n/global-require](./docs/rules/global-require.md) | require `require()` calls to be placed at top-level module scope |  |
 | [n/no-mixed-requires](./docs/rules/no-mixed-requires.md) | disallow `require` calls to be mixed with regular variable declarations |  |
@@ -167,7 +167,7 @@ Those preset config:
 
 ## 📰 Changelog
 
--   [GitHub Releases](https://github.com/weiran-zsd/eslint-plugin-n/releases)
+-   [GitHub Releases](https://github.com/weiran-zsd/eslint-plugin-node/releases)
 
 ## ❤️ Contributing
 

package/lib/rules/exports-style.js

@@ -139,6 +139,90 @@ function getExportsNodes(scope) {
     return variable.references.map(reference => reference.identifier)
 }
 
+function getReplacementForProperty(property, sourceCode) {
+    if (property.type !== "Property" || property.kind !== "init") {
+        // We don't have a nice syntax for adding these directly on the exports object. Give up on fixing the whole thing:
+        // property.kind === 'get':
+        //   module.exports = { get foo() { ... } }
+        // property.kind === 'set':
+        //   module.exports = { set foo() { ... } }
+        // property.type === 'SpreadElement':
+        //   module.exports = { ...foo }
+        return null
+    }
+
+    let fixedValue = sourceCode.getText(property.value)
+    if (property.method) {
+        fixedValue = `function${
+            property.value.generator ? "*" : ""
+        } ${fixedValue}`
+        if (property.value.async) {
+            fixedValue = `async ${fixedValue}`
+        }
+    }
+    const lines = sourceCode
+        .getCommentsBefore(property)
+        .map(comment => sourceCode.getText(comment))
+    if (property.key.type === "Literal" || property.computed) {
+        // String or dynamic key:
+        // module.exports = { [ ... ]: ... } or { "foo": ... }
+        lines.push(
+            `exports[${sourceCode.getText(property.key)}] = ${fixedValue};`
+        )
+    } else if (property.key.type === "Identifier") {
+        // Regular identifier:
+        // module.exports = { foo: ... }
+        lines.push(`exports.${property.key.name} = ${fixedValue};`)
+    } else {
+        // Some other unknown property type. Conservatively give up on fixing the whole thing.
+        return null
+    }
+    lines.push(
+        ...sourceCode
+            .getCommentsAfter(property)
+            .map(comment => sourceCode.getText(comment))
+    )
+    return lines.join("\n")
+}
+
+// Check for a top level module.exports = { ... }
+function isModuleExportsObjectAssignment(node) {
+    return (
+        node.parent.type === "AssignmentExpression" &&
+        node.parent.parent.type === "ExpressionStatement" &&
+        node.parent.parent.parent.type === "Program" &&
+        node.parent.right.type === "ObjectExpression"
+    )
+}
+
+// Check for module.exports.foo or module.exports.bar reference or assignment
+function isModuleExportsReference(node) {
+    return (
+        node.parent.type === "MemberExpression" && node.parent.object === node
+    )
+}
+
+function fixModuleExports(node, sourceCode, fixer) {
+    if (isModuleExportsReference(node)) {
+        return fixer.replaceText(node, "exports")
+    }
+    if (!isModuleExportsObjectAssignment(node)) {
+        return null
+    }
+    const statements = []
+    const properties = node.parent.right.properties
+    for (const property of properties) {
+        const statement = getReplacementForProperty(property, sourceCode)
+        if (statement) {
+            statements.push(statement)
+        } else {
+            // No replacement available, give up on the whole thing
+            return null
+        }
+    }
+    return fixer.replaceText(node.parent, statements.join("\n\n"))
+}
+
 module.exports = {
     meta: {
         docs: {
@@ -148,7 +232,7 @@ module.exports = {
             url: "https://github.com/weiran-zsd/eslint-plugin-node/blob/HEAD/docs/rules/exports-style.md",
         },
         type: "suggestion",
-        fixable: null,
+        fixable: "code",
         schema: [
             {
                 //
@@ -253,6 +337,9 @@ module.exports = {
                     loc: getLocation(node),
                     message:
                         "Unexpected access to 'module.exports'. Use 'exports' instead.",
+                    fix(fixer) {
+                        return fixModuleExports(node, sourceCode, fixer)
+                    },
                 })
             }
 

package/lib/rules/file-extension-in-import.js

@@ -6,6 +6,7 @@
 
 const path = require("path")
 const fs = require("fs")
+const mapTypescriptExtension = require("../util/map-typescript-extension")
 const visitImport = require("../util/visit-import")
 const packageNamePattern = /^(?:@[^/\\]+[/\\])?[^/\\]+$/u
 const corePackageOverridePattern =
@@ -78,23 +79,30 @@ module.exports = {
 
             // Get extension.
             const originalExt = path.extname(name)
-            const resolvedExt = path.extname(filePath)
             const existingExts = getExistingExtensions(filePath)
-            const ext = resolvedExt || existingExts.join(" or ")
+            const ext = path.extname(filePath) || existingExts.join(" or ")
             const style = overrideStyle[ext] || defaultStyle
 
             // Verify.
             if (style === "always" && ext !== originalExt) {
+                const fileExtensionToAdd = mapTypescriptExtension(
+                    context,
+                    filePath,
+                    ext
+                )
                 context.report({
                     node,
                     messageId: "requireExt",
-                    data: { ext },
+                    data: { ext: fileExtensionToAdd },
                     fix(fixer) {
                         if (existingExts.length !== 1) {
                             return null
                         }
                         const index = node.range[1] - 1
-                        return fixer.insertTextBeforeRange([index, index], ext)
+                        return fixer.insertTextBeforeRange(
+                            [index, index],
+                            fileExtensionToAdd
+                        )
                     },
                 })
             } else if (style === "never" && ext === originalExt) {

package/lib/util/check-existence.js

@@ -4,8 +4,11 @@
  */
 "use strict"
 
+const path = require("path")
 const exists = require("./exists")
 const getAllowModules = require("./get-allow-modules")
+const isTypescript = require("./is-typescript")
+const mapTypescriptExtension = require("../util/map-typescript-extension")
 
 /**
  * Checks whether or not each requirement target exists.
@@ -17,7 +20,7 @@ const getAllowModules = require("./get-allow-modules")
  * @param {ImportTarget[]} targets - A list of target information to check.
  * @returns {void}
  */
-module.exports = function checkForExistence(context, targets) {
+module.exports = function checkExistence(context, targets) {
     const allowed = new Set(getAllowModules(context))
 
     for (const target of targets) {
@@ -25,8 +28,20 @@ module.exports = function checkForExistence(context, targets) {
             target.moduleName != null &&
             !allowed.has(target.moduleName) &&
             target.filePath == null
-        const missingFile =
-            target.moduleName == null && !exists(target.filePath)
+
+        let missingFile = target.moduleName == null && !exists(target.filePath)
+        if (missingFile && isTypescript(context)) {
+            const parsed = path.parse(target.filePath)
+            const reversedExt = mapTypescriptExtension(
+                context,
+                target.filePath,
+                parsed.ext,
+                true
+            )
+            const reversedPath =
+                path.resolve(parsed.dir, parsed.name) + reversedExt
+            missingFile = target.moduleName == null && !exists(reversedPath)
+        }
 
         if (missingModule || missingFile) {
             context.report({

package/lib/util/is-typescript.js

@@ -0,0 +1,16 @@
+"use strict"
+
+const path = require("path")
+
+const typescriptExtensions = [".ts", ".cts", ".mts"]
+
+/**
+ * Determine if the context source file is typescript.
+ *
+ * @param {RuleContext} context - A context
+ * @returns {boolean}
+ */
+module.exports = function isTypescript(context) {
+    const sourceFileExt = path.extname(context.getPhysicalFilename())
+    return typescriptExtensions.includes(sourceFileExt)
+}

package/lib/util/map-typescript-extension.js

@@ -0,0 +1,49 @@
+"use strict"
+
+const path = require("path")
+const isTypescript = require("../util/is-typescript")
+
+const mapping = {
+    ".ts": ".js",
+    ".cts": ".cjs",
+    ".mts": ".mjs",
+}
+
+const reverseMapping = {
+    ".js": ".ts",
+    ".cjs": ".cts",
+    ".mjs": ".mts",
+}
+
+/**
+ * Maps the typescript file extension that should be added in an import statement,
+ * based on the given file extension of the referenced file OR fallsback to the original given extension.
+ *
+ * For example, in typescript, when referencing another typescript from a typescript file,
+ * a .js extension should be used instead of the original .ts extension of the referenced file.
+ *
+ * @param {RuleContext} context
+ * @param {string} filePath The filePath of the import
+ * @param {string} fallbackExtension The non-typescript fallback
+ * @param {boolean} reverse Execute a reverse path mapping
+ * @returns {string} The file extension to append to the import statement.
+ */
+module.exports = function mapTypescriptExtension(
+    context,
+    filePath,
+    fallbackExtension,
+    reverse = false
+) {
+    const ext = path.extname(filePath)
+    if (reverse) {
+        if (isTypescript(context) && ext in reverseMapping) {
+            return reverseMapping[ext]
+        }
+    } else {
+        if (isTypescript(context) && ext in mapping) {
+            return mapping[ext]
+        }
+    }
+
+    return fallbackExtension
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "eslint-plugin-n",
-    "version": "15.1.0",
+    "version": "15.2.2",
     "description": "Additional ESLint's rules for Node.js",
     "engines": {
         "node": ">=12.22.0"
@@ -13,35 +13,34 @@
         "eslint": ">=7.0.0"
     },
     "dependencies": {
-        "builtins": "^4.0.0",
+        "builtins": "^5.0.1",
         "eslint-plugin-es": "^4.1.0",
         "eslint-utils": "^3.0.0",
         "ignore": "^5.1.1",
-        "is-core-module": "^2.3.0",
-        "minimatch": "^3.0.4",
+        "is-core-module": "^2.9.0",
+        "minimatch": "^3.1.2",
         "resolve": "^1.10.1",
-        "semver": "^6.3.0"
+        "semver": "^7.3.7"
     },
     "devDependencies": {
-        "@mysticatea/eslint-plugin": "^13.0.0",
         "codecov": "^3.3.0",
-        "esbuild": "^0.14.14",
-        "eslint": "^8.3.0",
-        "eslint-config-prettier": "^8.3.0",
+        "esbuild": "^0.14.39",
+        "eslint": "^8.15.0",
+        "eslint-config-prettier": "^8.5.0",
         "eslint-plugin-eslint-plugin": "^4.0.1",
         "eslint-plugin-n": "file:.",
-        "fast-glob": "^2.2.6",
-        "globals": "^11.12.0",
-        "husky": "^7.0.4",
+        "fast-glob": "^3.2.11",
+        "globals": "^13.14.0",
+        "husky": "^8.0.1",
         "import-meta-resolve": "^1.1.1",
-        "lint-staged": "^12.3.1",
-        "mocha": "^6.1.4",
-        "nyc": "^14.0.0",
+        "lint-staged": "^12.4.1",
+        "mocha": "^10.0.0",
+        "nyc": "^15.1.0",
         "opener": "^1.5.1",
-        "prettier": "^2.5.1",
+        "prettier": "^2.6.2",
         "punycode": "^2.1.1",
-        "release-it": "^14.11.6",
-        "rimraf": "^2.6.3"
+        "release-it": "^15.0.0",
+        "rimraf": "^3.0.2"
     },
     "scripts": {
         "build": "node scripts/update",