eslint-plugin-n 14.0.0

package/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Toru Nagashima
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,189 @@
+# eslint-plugin-n
+
+> forked from [eslint-plugin-node](https://www.npmjs.com/package/eslint-plugin-node) v11.1.0. as the original repository seems [unmaintained](https://github.com/mysticatea/eslint-plugin-node/issues/300).
+
+[![npm version](https://img.shields.io/npm/v/eslint-plugin-node.svg)](https://www.npmjs.com/package/eslint-plugin-node)
+[![Downloads/month](https://img.shields.io/npm/dm/eslint-plugin-node.svg)](http://www.npmtrends.com/eslint-plugin-node)
+[![Build Status](https://github.com/mysticatea/eslint-plugin-node/workflows/CI/badge.svg)](https://github.com/mysticatea/eslint-plugin-node/actions)
+[![Coverage Status](https://codecov.io/gh/mysticatea/eslint-plugin-node/branch/master/graph/badge.svg)](https://codecov.io/gh/mysticatea/eslint-plugin-node)
+[![Dependency Status](https://david-dm.org/mysticatea/eslint-plugin-node.svg)](https://david-dm.org/mysticatea/eslint-plugin-node)
+
+Additional ESLint's rules for Node.js
+
+## 💿 Install & Usage
+
+```
+$ npm install --save-dev eslint eslint-plugin-node
+```
+
+- Requires Node.js `>=8.10.0`
+- Requires ESLint `>=5.16.0`
+
+**Note:** It recommends a use of [the "engines" field of package.json](https://docs.npmjs.com/files/package.json#engines). The "engines" field is used by `node/no-unsupported-features/*` rules.
+
+**.eslintrc.json** (An example)
+
+```jsonc
+{
+    "extends": [
+        "eslint:recommended",
+        "plugin:node/recommended"
+    ],
+    "parserOptions": {
+        // Only ESLint 6.2.0 and later support ES2020.
+        "ecmaVersion": 2020
+    },
+    "rules": {
+        "node/exports-style": ["error", "module.exports"],
+        "node/file-extension-in-import": ["error", "always"],
+        "node/prefer-global/buffer": ["error", "always"],
+        "node/prefer-global/console": ["error", "always"],
+        "node/prefer-global/process": ["error", "always"],
+        "node/prefer-global/url-search-params": ["error", "always"],
+        "node/prefer-global/url": ["error", "always"],
+        "node/prefer-promises/dns": "error",
+        "node/prefer-promises/fs": "error"
+    }
+}
+```
+
+**package.json** (An example)
+
+```json
+{
+    "name": "your-module",
+    "version": "1.0.0",
+    "type": "commonjs",
+    "engines": {
+        "node": ">=8.10.0"
+    }
+}
+```
+
+## 📖 Rules
+
+- ⭐️ - the mark of recommended rules.
+- ✒️ - the mark of fixable rules.
+
+<!--RULES_TABLE_START-->
+### Possible Errors
+
+| Rule ID | Description |    |
+|:--------|:------------|:--:|
+| [node/handle-callback-err](./docs/rules/handle-callback-err.md) | require error handling in callbacks |  |
+| [node/no-callback-literal](./docs/rules/no-callback-literal.md) | ensure Node.js-style error-first callback pattern is followed |  |
+| [node/no-exports-assign](./docs/rules/no-exports-assign.md) | disallow the assignment to `exports` | ⭐️ |
+| [node/no-extraneous-import](./docs/rules/no-extraneous-import.md) | disallow `import` declarations which import extraneous modules | ⭐️ |
+| [node/no-extraneous-require](./docs/rules/no-extraneous-require.md) | disallow `require()` expressions which import extraneous modules | ⭐️ |
+| [node/no-missing-import](./docs/rules/no-missing-import.md) | disallow `import` declarations which import non-existence modules | ⭐️ |
+| [node/no-missing-require](./docs/rules/no-missing-require.md) | disallow `require()` expressions which import non-existence modules | ⭐️ |
+| [node/no-new-require](./docs/rules/no-new-require.md) | disallow `new` operators with calls to `require` |  |
+| [node/no-path-concat](./docs/rules/no-path-concat.md) | disallow string concatenation with `__dirname` and `__filename` |  |
+| [node/no-process-exit](./docs/rules/no-process-exit.md) | disallow the use of `process.exit()` |  |
+| [node/no-unpublished-bin](./docs/rules/no-unpublished-bin.md) | disallow `bin` files that npm ignores | ⭐️ |
+| [node/no-unpublished-import](./docs/rules/no-unpublished-import.md) | disallow `import` declarations which import private modules | ⭐️ |
+| [node/no-unpublished-require](./docs/rules/no-unpublished-require.md) | disallow `require()` expressions which import private modules | ⭐️ |
+| [node/no-unsupported-features/es-builtins](./docs/rules/no-unsupported-features/es-builtins.md) | disallow unsupported ECMAScript built-ins on the specified version | ⭐️ |
+| [node/no-unsupported-features/es-syntax](./docs/rules/no-unsupported-features/es-syntax.md) | disallow unsupported ECMAScript syntax on the specified version | ⭐️ |
+| [node/no-unsupported-features/node-builtins](./docs/rules/no-unsupported-features/node-builtins.md) | disallow unsupported Node.js built-in APIs on the specified version | ⭐️ |
+| [node/process-exit-as-throw](./docs/rules/process-exit-as-throw.md) | make `process.exit()` expressions the same code path as `throw` | ⭐️ |
+| [node/shebang](./docs/rules/shebang.md) | suggest correct usage of shebang | ⭐️✒️ |
+
+### Best Practices
+
+| Rule ID | Description |    |
+|:--------|:------------|:--:|
+| [node/no-deprecated-api](./docs/rules/no-deprecated-api.md) | disallow deprecated APIs | ⭐️ |
+
+### Stylistic Issues
+
+| Rule ID | Description |    |
+|:--------|:------------|:--:|
+| [node/callback-return](./docs/rules/callback-return.md) | require `return` statements after callbacks |  |
+| [node/exports-style](./docs/rules/exports-style.md) | enforce either `module.exports` or `exports` |  |
+| [node/file-extension-in-import](./docs/rules/file-extension-in-import.md) | enforce the style of file extensions in `import` declarations | ✒️ |
+| [node/global-require](./docs/rules/global-require.md) | require `require()` calls to be placed at top-level module scope |  |
+| [node/no-mixed-requires](./docs/rules/no-mixed-requires.md) | disallow `require` calls to be mixed with regular variable declarations |  |
+| [node/no-process-env](./docs/rules/no-process-env.md) | disallow the use of `process.env` |  |
+| [node/no-restricted-import](./docs/rules/no-restricted-import.md) | disallow specified modules when loaded by `import` declarations |  |
+| [node/no-restricted-require](./docs/rules/no-restricted-require.md) | disallow specified modules when loaded by `require` |  |
+| [node/no-sync](./docs/rules/no-sync.md) | disallow synchronous methods |  |
+| [node/prefer-global/buffer](./docs/rules/prefer-global/buffer.md) | enforce either `Buffer` or `require("buffer").Buffer` |  |
+| [node/prefer-global/console](./docs/rules/prefer-global/console.md) | enforce either `console` or `require("console")` |  |
+| [node/prefer-global/process](./docs/rules/prefer-global/process.md) | enforce either `process` or `require("process")` |  |
+| [node/prefer-global/text-decoder](./docs/rules/prefer-global/text-decoder.md) | enforce either `TextDecoder` or `require("util").TextDecoder` |  |
+| [node/prefer-global/text-encoder](./docs/rules/prefer-global/text-encoder.md) | enforce either `TextEncoder` or `require("util").TextEncoder` |  |
+| [node/prefer-global/url-search-params](./docs/rules/prefer-global/url-search-params.md) | enforce either `URLSearchParams` or `require("url").URLSearchParams` |  |
+| [node/prefer-global/url](./docs/rules/prefer-global/url.md) | enforce either `URL` or `require("url").URL` |  |
+| [node/prefer-promises/dns](./docs/rules/prefer-promises/dns.md) | enforce `require("dns").promises` |  |
+| [node/prefer-promises/fs](./docs/rules/prefer-promises/fs.md) | enforce `require("fs").promises` |  |
+
+### Deprecated rules
+
+These rules have been deprecated in accordance with the [deprecation policy](https://eslint.org/docs/user-guide/rule-deprecation), and replaced by newer rules:
+
+| Rule ID | Replaced by |
+|:--------|:------------|
+| [node/no-hide-core-modules](./docs/rules/no-hide-core-modules.md) | (nothing) |
+| [node/no-unsupported-features](./docs/rules/no-unsupported-features.md) | [node/no-unsupported-features/es-syntax](./docs/rules/no-unsupported-features/es-syntax.md) and [node/no-unsupported-features/es-builtins](./docs/rules/no-unsupported-features/es-builtins.md) |
+
+<!--RULES_TABLE_END-->
+
+## 🔧 Configs
+
+This plugin provides three configs:
+
+- `plugin:node/recommended` considers both CommonJS and ES Modules. If [`"type":"module"` field](https://medium.com/@nodejs/announcing-a-new-experimental-modules-1be8d2d6c2ff#b023) existed in package.json then it considers files as ES Modules. Otherwise it considers files as CommonJS. In addition, it considers `*.mjs` files as ES Modules and `*.cjs` files as CommonJS.
+- `plugin:node/recommended-module` considers all files as ES Modules.
+- `plugin:node/recommended-script` considers all files as CommonJS.
+
+Those preset config:
+
+- enable [no-process-exit](http://eslint.org/docs/rules/no-process-exit) rule because [the official document](https://nodejs.org/api/process.html#process_process_exit_code) does not recommend a use of `process.exit()`.
+- enable plugin rules which are given :star: in the above table.
+- add `{ecmaVersion: 2019}` and etc into `parserOptions`.
+- add proper globals into `globals`.
+- add this plugin into `plugins`.
+
+## 👫 FAQ
+
+- Q: The `no-missing-import` / `no-missing-require` rules don't work with nested folders in SublimeLinter-eslint
+- A: See [context.getFilename() in rule returns relative path](https://github.com/roadhump/SublimeLinter-eslint#contextgetfilename-in-rule-returns-relative-path) in the SublimeLinter-eslint FAQ.
+
+## 🚥 Semantic Versioning Policy
+
+`eslint-plugin-node` follows [semantic versioning](http://semver.org/) and [ESLint's Semantic Versioning Policy](https://github.com/eslint/eslint#semantic-versioning-policy).
+
+- Patch release (intended to not break your lint build)
+    - A bug fix in a rule that results in it reporting fewer errors.
+    - Improvements to documentation.
+    - Non-user-facing changes such as refactoring code, adding, deleting, or modifying tests, and increasing test coverage.
+    - Re-releasing after a failed release (i.e., publishing a release that doesn't work for anyone).
+- Minor release (might break your lint build)
+    - A bug fix in a rule that results in it reporting more errors.
+    - A new rule is created.
+    - A new option to an existing rule is created.
+    - An existing rule is deprecated.
+- Major release (likely to break your lint build)
+    - A support for old Node version is dropped.
+    - A support for old ESLint version is dropped.
+    - An existing rule is changed in it reporting more errors.
+    - An existing rule is removed.
+    - An existing option of a rule is removed.
+    - An existing config is updated.
+
+## 📰 Changelog
+
+- [GitHub Releases](https://github.com/mysticatea/eslint-plugin-node/releases)
+
+## ❤️ Contributing
+
+Welcome contributing!
+
+Please use GitHub's Issues/PRs.
+
+### Development Tools
+
+- `npm test` runs tests and measures coverage.
+- `npm run coverage` shows the coverage result of `npm test` command.
+- `npm run clean` removes the coverage result of `npm test` command.

package/lib/configs/_commons.js

@@ -0,0 +1,76 @@
+"use strict"
+
+module.exports = {
+    commonGlobals: {
+        // ECMAScript
+        ArrayBuffer: "readonly",
+        Atomics: "readonly",
+        BigInt: "readonly",
+        BigInt64Array: "readonly",
+        BigUint64Array: "readonly",
+        DataView: "readonly",
+        Float32Array: "readonly",
+        Float64Array: "readonly",
+        Int16Array: "readonly",
+        Int32Array: "readonly",
+        Int8Array: "readonly",
+        Map: "readonly",
+        Promise: "readonly",
+        Proxy: "readonly",
+        Reflect: "readonly",
+        Set: "readonly",
+        SharedArrayBuffer: "readonly",
+        Symbol: "readonly",
+        Uint16Array: "readonly",
+        Uint32Array: "readonly",
+        Uint8Array: "readonly",
+        Uint8ClampedArray: "readonly",
+        WeakMap: "readonly",
+        WeakSet: "readonly",
+
+        // ECMAScript (experimental)
+        globalThis: "readonly",
+
+        // ECMA-402
+        Intl: "readonly",
+
+        // Web Standard
+        TextDecoder: "readonly",
+        TextEncoder: "readonly",
+        URL: "readonly",
+        URLSearchParams: "readonly",
+        WebAssembly: "readonly",
+        clearInterval: "readonly",
+        clearTimeout: "readonly",
+        console: "readonly",
+        queueMicrotask: "readonly",
+        setInterval: "readonly",
+        setTimeout: "readonly",
+
+        // Node.js
+        Buffer: "readonly",
+        GLOBAL: "readonly",
+        clearImmediate: "readonly",
+        global: "readonly",
+        process: "readonly",
+        root: "readonly",
+        setImmediate: "readonly",
+    },
+    commonRules: {
+        "n/no-deprecated-api": "error",
+        "n/no-extraneous-import": "error",
+        "n/no-extraneous-require": "error",
+        "n/no-exports-assign": "error",
+        "n/no-missing-import": "error",
+        "n/no-missing-require": "error",
+        "n/no-process-exit": "error",
+        "n/no-unpublished-bin": "error",
+        "n/no-unpublished-import": "error",
+        "n/no-unpublished-require": "error",
+        "n/no-unsupported-features/es-builtins": "error",
+        "n/no-unsupported-features/es-syntax": "error",
+        "n/no-unsupported-features/node-builtins": "error",
+        "n/process-exit-as-throw": "error",
+        "n/shebang": "error",
+    },
+}

package/lib/configs/recommended-module.js

@@ -0,0 +1,27 @@
+"use strict"
+
+const { commonGlobals, commonRules } = require("./_commons")
+
+module.exports = {
+    globals: {
+        ...commonGlobals,
+        __dirname: "off",
+        __filename: "off",
+        exports: "off",
+        module: "off",
+        require: "off",
+    },
+    parserOptions: {
+        ecmaFeatures: { globalReturn: false },
+        ecmaVersion: 2019,
+        sourceType: "module",
+    },
+    plugins: ["n"],
+    rules: {
+        ...commonRules,
+        "n/no-unsupported-features/es-syntax": [
+            "error",
+            { ignores: ["modules"] },
+        ],
+    },
+}

package/lib/configs/recommended-script.js

@@ -0,0 +1,24 @@
+"use strict"
+
+const { commonGlobals, commonRules } = require("./_commons")
+
+module.exports = {
+    globals: {
+        ...commonGlobals,
+        __dirname: "readonly",
+        __filename: "readonly",
+        exports: "writable",
+        module: "readonly",
+        require: "readonly",
+    },
+    parserOptions: {
+        ecmaFeatures: { globalReturn: true },
+        ecmaVersion: 2019,
+        sourceType: "script",
+    },
+    plugins: ["n"],
+    rules: {
+        ...commonRules,
+        "n/no-unsupported-features/es-syntax": ["error", { ignores: [] }],
+    },
+}

package/lib/configs/recommended.js

@@ -0,0 +1,18 @@
+"use strict"
+
+const getPackageJson = require("../util/get-package-json")
+const moduleConfig = require("./recommended-module")
+const scriptConfig = require("./recommended-script")
+
+module.exports = () => {
+    const packageJson = getPackageJson()
+    const isModule = (packageJson && packageJson.type) === "module"
+
+    return {
+        ...(isModule ? moduleConfig : scriptConfig),
+        overrides: [
+            { files: ["*.cjs", ".*.cjs"], ...scriptConfig },
+            { files: ["*.mjs", ".*.mjs"], ...moduleConfig },
+        ],
+    }
+}

package/lib/index.js

@@ -0,0 +1,55 @@
+/* DON'T EDIT THIS FILE. This is generated by 'scripts/update-lib-index.js' */
+"use strict"
+
+module.exports = {
+    configs: {
+        "recommended-module": require("./configs/recommended-module"),
+        "recommended-script": require("./configs/recommended-script"),
+        get recommended() {
+            return require("./configs/recommended")()
+        },
+    },
+    rules: {
+        "callback-return": require("./rules/callback-return"),
+        "exports-style": require("./rules/exports-style"),
+        "file-extension-in-import": require("./rules/file-extension-in-import"),
+        "global-require": require("./rules/global-require"),
+        "handle-callback-err": require("./rules/handle-callback-err"),
+        "no-callback-literal": require("./rules/no-callback-literal"),
+        "no-deprecated-api": require("./rules/no-deprecated-api"),
+        "no-exports-assign": require("./rules/no-exports-assign"),
+        "no-extraneous-import": require("./rules/no-extraneous-import"),
+        "no-extraneous-require": require("./rules/no-extraneous-require"),
+        "no-missing-import": require("./rules/no-missing-import"),
+        "no-missing-require": require("./rules/no-missing-require"),
+        "no-mixed-requires": require("./rules/no-mixed-requires"),
+        "no-new-require": require("./rules/no-new-require"),
+        "no-path-concat": require("./rules/no-path-concat"),
+        "no-process-env": require("./rules/no-process-env"),
+        "no-process-exit": require("./rules/no-process-exit"),
+        "no-restricted-import": require("./rules/no-restricted-import"),
+        "no-restricted-require": require("./rules/no-restricted-require"),
+        "no-sync": require("./rules/no-sync"),
+        "no-unpublished-bin": require("./rules/no-unpublished-bin"),
+        "no-unpublished-import": require("./rules/no-unpublished-import"),
+        "no-unpublished-require": require("./rules/no-unpublished-require"),
+        "no-unsupported-features/es-builtins": require("./rules/no-unsupported-features/es-builtins"),
+        "no-unsupported-features/es-syntax": require("./rules/no-unsupported-features/es-syntax"),
+        "no-unsupported-features/node-builtins": require("./rules/no-unsupported-features/node-builtins"),
+        "prefer-global/buffer": require("./rules/prefer-global/buffer"),
+        "prefer-global/console": require("./rules/prefer-global/console"),
+        "prefer-global/process": require("./rules/prefer-global/process"),
+        "prefer-global/text-decoder": require("./rules/prefer-global/text-decoder"),
+        "prefer-global/text-encoder": require("./rules/prefer-global/text-encoder"),
+        "prefer-global/url-search-params": require("./rules/prefer-global/url-search-params"),
+        "prefer-global/url": require("./rules/prefer-global/url"),
+        "prefer-promises/dns": require("./rules/prefer-promises/dns"),
+        "prefer-promises/fs": require("./rules/prefer-promises/fs"),
+        "process-exit-as-throw": require("./rules/process-exit-as-throw"),
+        "shebang": require("./rules/shebang"),
+
+        // Deprecated rules.
+        "no-hide-core-modules": require("./rules/no-hide-core-modules"),
+        "no-unsupported-features": require("./rules/no-unsupported-features"),
+    },
+}

package/lib/rules/callback-return.js

@@ -0,0 +1,185 @@
+/**
+ * @author Jamund Ferguson
+ * See LICENSE file in root directory for full license.
+ */
+"use strict"
+
+module.exports = {
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "require `return` statements after callbacks",
+            category: "Stylistic Issues",
+            recommended: false,
+            url:
+                "https://github.com/mysticatea/eslint-plugin-node/blob/HEAD/docs/rules/callback-return.md",
+        },
+        schema: [
+            {
+                type: "array",
+                items: { type: "string" },
+            },
+        ],
+        fixable: null,
+        messages: {
+            missingReturn: "Expected return with your callback function.",
+        },
+    },
+
+    create(context) {
+        const callbacks = context.options[0] || ["callback", "cb", "next"]
+        const sourceCode = context.getSourceCode()
+
+        /**
+         * Find the closest parent matching a list of types.
+         * @param {ASTNode} node The node whose parents we are searching
+         * @param {Array} types The node types to match
+         * @returns {ASTNode} The matched node or undefined.
+         */
+        function findClosestParentOfType(node, types) {
+            if (!node.parent) {
+                return null
+            }
+            if (types.indexOf(node.parent.type) === -1) {
+                return findClosestParentOfType(node.parent, types)
+            }
+            return node.parent
+        }
+
+        /**
+         * Check to see if a node contains only identifers
+         * @param {ASTNode} node The node to check
+         * @returns {boolean} Whether or not the node contains only identifers
+         */
+        function containsOnlyIdentifiers(node) {
+            if (node.type === "Identifier") {
+                return true
+            }
+
+            if (node.type === "MemberExpression") {
+                if (node.object.type === "Identifier") {
+                    return true
+                }
+                if (node.object.type === "MemberExpression") {
+                    return containsOnlyIdentifiers(node.object)
+                }
+            }
+
+            return false
+        }
+
+        /**
+         * Check to see if a CallExpression is in our callback list.
+         * @param {ASTNode} node The node to check against our callback names list.
+         * @returns {boolean} Whether or not this function matches our callback name.
+         */
+        function isCallback(node) {
+            return (
+                containsOnlyIdentifiers(node.callee) &&
+                callbacks.indexOf(sourceCode.getText(node.callee)) > -1
+            )
+        }
+
+        /**
+         * Determines whether or not the callback is part of a callback expression.
+         * @param {ASTNode} node The callback node
+         * @param {ASTNode} parentNode The expression node
+         * @returns {boolean} Whether or not this is part of a callback expression
+         */
+        function isCallbackExpression(node, parentNode) {
+            // ensure the parent node exists and is an expression
+            if (!parentNode || parentNode.type !== "ExpressionStatement") {
+                return false
+            }
+
+            // cb()
+            if (parentNode.expression === node) {
+                return true
+            }
+
+            // special case for cb && cb() and similar
+            if (
+                parentNode.expression.type === "BinaryExpression" ||
+                parentNode.expression.type === "LogicalExpression"
+            ) {
+                if (parentNode.expression.right === node) {
+                    return true
+                }
+            }
+
+            return false
+        }
+
+        return {
+            CallExpression(node) {
+                // if we're not a callback we can return
+                if (!isCallback(node)) {
+                    return
+                }
+
+                // find the closest block, return or loop
+                const closestBlock =
+                    findClosestParentOfType(node, [
+                        "BlockStatement",
+                        "ReturnStatement",
+                        "ArrowFunctionExpression",
+                    ]) || {}
+
+                // if our parent is a return we know we're ok
+                if (closestBlock.type === "ReturnStatement") {
+                    return
+                }
+
+                // arrow functions don't always have blocks and implicitly return
+                if (closestBlock.type === "ArrowFunctionExpression") {
+                    return
+                }
+
+                // block statements are part of functions and most if statements
+                if (closestBlock.type === "BlockStatement") {
+                    // find the last item in the block
+                    const lastItem =
+                        closestBlock.body[closestBlock.body.length - 1]
+
+                    // if the callback is the last thing in a block that might be ok
+                    if (isCallbackExpression(node, lastItem)) {
+                        const parentType = closestBlock.parent.type
+
+                        // but only if the block is part of a function
+                        if (
+                            parentType === "FunctionExpression" ||
+                            parentType === "FunctionDeclaration" ||
+                            parentType === "ArrowFunctionExpression"
+                        ) {
+                            return
+                        }
+                    }
+
+                    // ending a block with a return is also ok
+                    if (lastItem.type === "ReturnStatement") {
+                        // but only if the callback is immediately before
+                        if (
+                            isCallbackExpression(
+                                node,
+                                closestBlock.body[closestBlock.body.length - 2]
+                            )
+                        ) {
+                            return
+                        }
+                    }
+                }
+
+                // as long as you're the child of a function at this point you should be asked to return
+                if (
+                    findClosestParentOfType(node, [
+                        "FunctionDeclaration",
+                        "FunctionExpression",
+                        "ArrowFunctionExpression",
+                    ])
+                ) {
+                    context.report({ node, messageId: "missingReturn" })
+                }
+            },
+        }
+    },
+}