@darksheep/eslint 4.1.3

package/LICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+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 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.
+
+For more information, please refer to <https://unlicense.org>

package/README.md

@@ -0,0 +1,34 @@
+# eslint
+
+### Creating your `eslint.config.js` file
+
+If you're using `"type": "module"` in your `package.json` you create a file like this:
+```js
+import { createConfig } from '@darksheep/eslint';
+export default await createConfig(import.meta.url);
+```
+
+If you're using `"type": "commonjs"` or you have not defined `type` in your `package.json` you create a file like this:
+```js
+module.exports = (async () => {
+  const { createConfig } = await import('@darksheep/eslint');
+  return createConfig(__dirname);
+})();
+```
+
+In your terminal you can run:
+```shell
+cat << EOF > eslint.config.js
+import { createConfig } from '@darksheep/eslint';
+export default await createConfig(import.meta.url);
+EOF
+```
+
+```shell
+cat << EOF > eslint.config.js
+module.exports = (async () => {
+  const { createConfig } = await import('@darksheep/eslint');
+  return createConfig(__dirname);
+})();
+EOF
+```

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@darksheep/eslint",
+  "version": "4.1.3",
+  "type": "module",
+  "packageManager": "yarn@4.1.0",
+  "bin": "./src/bin/eslint.cjs",
+  "exports": {
+    ".": "./src/index.js"
+  },
+  "files": [
+    "src"
+  ],
+  "engines": {
+    "node": "^20 || ^21"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pickles-and-beans/eslint.git"
+  },
+  "scripts": {
+    "githooks": "git config core.hooksPath .githooks"
+  },
+  "devDependencies": {
+    "@types/eslint": "~8.56.0",
+    "@types/eslint__eslintrc": "~2.1.1",
+    "@types/eslint__js": "~8.42.3",
+    "@types/estree": "~1.0.2",
+    "@types/node": "~20.11.0",
+    "type-fest": "~4.10.0",
+    "typescript": "~5.3.2"
+  },
+  "dependencies": {
+    "@eslint-community/eslint-plugin-eslint-comments": "~4.1.0",
+    "@eslint/eslintrc": "~3.0.0",
+    "@eslint/js": "~8.56.0",
+    "@stylistic/eslint-plugin": "~1.6.0",
+    "@typescript-eslint/eslint-plugin": "~7.0.0",
+    "@typescript-eslint/parser": "~7.0.0",
+    "editorconfig": "~2.0.0",
+    "eslint": "~8.56.0",
+    "eslint-import-resolver-typescript": "~3.6.1",
+    "eslint-plugin-import": "~2.29.0",
+    "eslint-plugin-jest": "~27.6.0",
+    "eslint-plugin-jsdoc": "~48.0.0",
+    "eslint-plugin-jsonc": "~2.13.0",
+    "eslint-plugin-jsx-a11y": "~6.8.0",
+    "eslint-plugin-n": "~17.0.0-0",
+    "eslint-plugin-promise": "~6.1.1",
+    "eslint-plugin-react": "~7.33.2",
+    "eslint-plugin-regexp": "~2.2.0",
+    "eslint-plugin-security": "~2.1.0",
+    "eslint-plugin-sonarjs": "~0.24.0",
+    "eslint-plugin-unicorn": "~51.0.0",
+    "eslint-plugin-unused-imports": "~3.0.0",
+    "jsonc-eslint-parser": "~2.4.0"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
+  }
+}

package/src/bin/eslint.cjs

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+
+const path = require('node:path');
+
+const ESLINT_BIN_PATH = path.resolve(
+  require.resolve('eslint'), // eslint api
+  '../..', // eslint package root
+  'bin/eslint.js', // eslint cli
+);
+
+require(ESLINT_BIN_PATH);

package/src/configs/eslint-base.js

@@ -0,0 +1,124 @@
+/** @type {import('eslint').Linter.RulesRecord} */
+const rules = {
+    'no-else-return': 'error',
+
+    'radix': 'error',
+    'prefer-exponentiation-operator': 'error',
+
+    'class-methods-use-this': 'off',
+    'no-eval': 'error',
+    'no-extend-native': 'error',
+    'no-implicit-coercion': 'error',
+    'no-implied-eval': 'error',
+    'no-invalid-this': 'error',
+    'no-new-func': 'error',
+    'no-process-env': 'off',
+    'no-proto': 'error',
+    'no-script-url': 'error',
+    'no-unexpected-multiline': 'error',
+    'no-void': 'error',
+
+    'no-caller': 'error',
+    'no-empty': [ 'error', { allowEmptyCatch: true } ],
+    'no-empty-function': [ 'error', { allow: [ 'arrowFunctions' ] } ],
+    'no-labels': 'error',
+    'no-lone-blocks': 'error',
+    'no-loop-func': 'error',
+    'no-misleading-character-class': 'error',
+    'no-new-wrappers': 'error',
+    'no-new': 'error',
+    'no-undef': [ 'error', { typeof: true } ],
+    'no-use-before-define': 'off',
+
+    'arrow-body-style': [ 'error', 'as-needed' ],
+    'constructor-super': 'error',
+    'no-class-assign': 'error',
+    'no-const-assign': 'error',
+    'no-dupe-class-members': 'error',
+    'no-duplicate-imports': 'error',
+    'no-new-symbol': 'error',
+    'no-restricted-imports': 'error',
+    'no-this-before-super': 'error',
+    'no-useless-computed-key': 'error',
+    'no-useless-constructor': 'error',
+    'no-useless-rename': 'error',
+    'no-var': 'error',
+    'object-shorthand': [ 'error', 'consistent-as-needed' ],
+    'prefer-arrow-callback': [
+        'error',
+        {
+            allowNamedFunctions: false,
+            allowUnboundThis: true,
+        },
+    ],
+    'prefer-const': 'error',
+    'prefer-destructuring': [
+        'error',
+        { array: false, object: true },
+        { enforceForRenamedProperties: false },
+    ],
+    'prefer-numeric-literals': 'error',
+    'prefer-rest-params': 'error',
+    'prefer-spread': 'error',
+    'prefer-template': 'error',
+    'require-yield': 'error',
+    'sort-imports': 'off',
+    'symbol-description': 'error',
+
+    'eqeqeq': [ 'error', 'always', { null: 'ignore' } ],
+    'no-extra-bind': 'error',
+    'no-useless-call': 'error',
+    'no-useless-catch': 'error',
+    'no-useless-concat': 'error',
+    'no-useless-escape': 'error',
+    'no-useless-return': 'error',
+    'no-multi-str': 'error',
+    'no-octal': 'error',
+    'no-octal-escape': 'error',
+    'no-return-assign': 'error',
+    'no-return-await': 'error',
+    'prefer-promise-reject-errors': 'error',
+    'require-await': 'off',
+
+    'no-shadow-restricted-names': 'error',
+    'no-undefined': 'off',
+
+    'func-name-matching': [ 'error', 'never' ],
+    'func-style': [
+        'error',
+        'declaration',
+        { allowArrowFunctions: true },
+    ],
+    'consistent-this': [ 'error', 'that' ],
+    'no-array-constructor': 'error',
+    'no-lonely-if': 'error',
+    'no-negated-condition': 'error',
+    'no-new-object': 'error',
+    'no-nested-ternary': 'warn',
+    'no-unneeded-ternary': 'warn',
+
+    'one-var': [
+        'error',
+        'never',
+    ],
+    'operator-assignment': [ 'error', 'always' ],
+
+    'yoda': 'error',
+
+    'prefer-object-spread': 'error',
+};
+
+/**
+ * Get the ESLint base config
+ * @returns {Promise<import('eslint').Linter.FlatConfig[]>}
+ */
+export async function createEslintBaseConfig() {
+    return [ {
+        linterOptions: {
+            noInlineConfig: false,
+            reportUnusedDisableDirectives: true,
+        },
+
+        rules: rules,
+    } ];
+}

package/src/configs/eslint-complexity.js

@@ -0,0 +1,28 @@
+/**
+ * Get the ESLint config for complexity checks
+ * @returns {import('eslint').Linter.FlatConfig[]}
+ */
+export function createEslintComplexityConfig() {
+    return [ { rules: {
+        'max-depth': [ 'error', 4 ],
+        'complexity': 'off',
+        'max-lines': [
+            'warn',
+            {
+                max: 512,
+                skipBlankLines: true,
+                skipComments: true,
+            },
+        ],
+        'max-lines-per-function': [
+            'warn',
+            {
+                max: 120,
+                skipBlankLines: true,
+                skipComments: true,
+            },
+        ],
+        'max-nested-callbacks': [ 'warn', 3 ],
+        'max-params': [ 'error', 5 ],
+    } } ];
+}

package/src/configs/eslint-ignores.js

@@ -0,0 +1,51 @@
+import * as fs from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { findUp } from '../utilities/filesystem.js';
+
+/**
+ * @param {import('node:url').URL} root root url
+ * @returns {Promise<string[]>}
+ */
+async function getGitignore(root) {
+    const rootPath = fileURLToPath(root);
+    const gitPath = await findUp(rootPath, '.git');
+    const path = resolve(gitPath ?? rootPath, '..', '.gitignore');
+
+    try {
+        const raw = await fs.readFile(path, 'utf8');
+
+        return raw
+            .split(/\r?\n|\r/)
+            .filter(Boolean);
+    } catch (error) {
+        if (/** @type {NodeJS.ErrnoException} */ (error).code === 'ENOENT') {
+            return [];
+        }
+
+        throw error;
+    }
+}
+
+/**
+ * Get basic ESLint ignores config
+ * @param {import('node:url').URL} root root url
+ * @returns {Promise<import('eslint').Linter.FlatConfig[]>}
+ */
+export async function createEslintIgnoresConfig(root) {
+    const ignores = await getGitignore(root);
+
+    return [ {
+        ignores: [
+            ...ignores,
+
+            // Some things we always want to ignore
+            '.yarn/',
+            '.pnp.cjs',
+            '.pnp.loader.mjs',
+            '.git/',
+            'coverage/',
+            'node_modules/',
+        ],
+    } ];
+}

package/src/configs/eslint-recommended.js

@@ -0,0 +1,9 @@
+import js from '@eslint/js';
+
+/**
+ * Get recommended ESLint config
+ * @returns {Promise<import('eslint').Linter.FlatConfig[]>}
+ */
+export async function createEslintRecommendsConfig() {
+    return [ js.configs.recommended ];
+}

package/src/configs/eslint-style.js

@@ -0,0 +1,23 @@
+import { createEditorOverrides } from '../utilities/editorconfig.js';
+
+/** @type {import('eslint').Linter.RulesRecord} */
+const rules = {
+    'dot-notation': 'error',
+    'curly': 'error',
+    'unicode-bom': [ 'error', 'never' ],
+
+    'no-div-regex': 'error',
+    'no-control-regex': 'error',
+};
+
+/**
+ * Get basic ESLint style config
+ * @param {import('node:url').URL} root root url
+ * @returns {Promise<import('eslint').Linter.FlatConfig[]>}
+ */
+export async function createStyleConfigs(root) {
+    return [
+        { rules },
+        ...await createEditorOverrides(root),
+    ];
+}

package/src/custom/index.js

@@ -0,0 +1,11 @@
+import noUselessExpression from './no-useless-expression.js';
+import looseTypes from './loose-types.js';
+import sequenceExpression from './sequence-expression.js';
+
+export default {
+    rules: {
+        'loose-types': looseTypes,
+        'no-useless-expression': noUselessExpression,
+        'sequence-expression': sequenceExpression,
+    },
+};

package/src/custom/instance-of-array.js

@@ -0,0 +1,72 @@
+/**
+ * @param {import('eslint').Rule.RuleContext} context ESLint rule context
+ * @returns {import('eslint').Rule.RuleListener}
+ */
+const preferInstance = (context) => ({
+    /**
+     * @param {import('estree').CallExpression} node The AST function node
+     * @returns {void}
+     */
+    'CallExpression[callee.object.name = "Array"][callee.property.name = "isArray"]': (node) => {
+        const message = 'Use `instanceof Array` instead of `Array.isArray()`';
+
+        if (node.arguments.length !== 1) {
+            return context.report({ node, message });
+        }
+
+        const left = context.sourceCode.getText(node.arguments[0]);
+        /** @type {import('eslint').Rule.ReportFixer} */
+        const fix = (fixer) => fixer.replaceText(node, `${left} instanceof Array`);
+
+        context.report({ node, message, fix });
+    },
+});
+
+/**
+ * @param {import('eslint').Rule.RuleContext} context ESLint rule context
+ * @returns {import('eslint').Rule.RuleListener}
+ */
+const preferIsArray = (context) => ({
+    /**
+     * @param {import('estree').BinaryExpression} node The AST function node
+     * @returns {void}
+     */
+    'BinaryExpression[operator="instanceof"][right.type="Identifier"][right.name="Array"]': (node) => {
+        const message = 'Use `Array.isArray()` instead of `instanceof Array`';
+
+        const argument = context.sourceCode.getText(node.left);
+        /** @type {import('eslint').Rule.ReportFixer} */
+        const fix = (fixer) => fixer.replaceText(node, `Array.isArray(${argument})`);
+
+        context.report({ node, message, fix });
+    },
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+const rule = {
+    meta: {
+        type: 'suggestion',
+        fixable: 'code',
+        schema: [
+            {
+                type: 'string',
+                enum: [
+                    'instanceof',
+                    'isarray',
+                ],
+            },
+        ],
+    },
+
+    create: function (context) {
+        const [ option = 'instanceof' ] = context.options;
+
+        if (option === 'instanceof') {
+            return preferInstance(context);
+        }
+
+        return preferIsArray(context);
+    },
+};
+
+export default rule;

package/src/custom/loose-types.js

@@ -0,0 +1,204 @@
+/**
+ * @param {string} optionName name of the property option
+ * @param {import('eslint').Rule.RuleContext} context ESLint rule context
+ * @param {string} message error message on report
+ * @returns {(node: import('eslint').Rule.Node) => void}
+ */
+function createReporter(optionName, context, message) {
+    const [ options ] = context.options;
+
+    /**
+     * @param {(
+     *   import('eslint').Rule.Node |
+     *   import('estree').Identifier |
+     *   import('estree').MemberExpression |
+     *   import('estree').ChainExpression |
+     *   import('estree').CallExpression |
+     *   import('estree').LogicalExpression |
+     *   import('estree').UnaryExpression
+     * )} node The AST function node
+     *
+     * @returns {void}
+     */
+    function validateNode(node) {
+        if (options?.[optionName] !== true) {
+            context.report({ node, message });
+        }
+    }
+
+    return validateNode;
+}
+
+/** @type {import('eslint').Rule.RuleModule} */
+const rule = {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Prevent accidental implicit coercion in Expressions',
+            recommended: true,
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    allowConditionalExpressionCallExpression: { type: 'boolean' },
+                    allowConditionalExpressionIdentifier: { type: 'boolean' },
+                    allowConditionalExpressionMemberExpression: { type: 'boolean' },
+                    allowConditionalExpressionChainExpression: { type: 'boolean' },
+
+                    allowLogicalExpressionCallExpression: { type: 'boolean' },
+                    allowLogicalExpressionIdentifier: { type: 'boolean' },
+                    allowLogicalExpressionMemberExpression: { type: 'boolean' },
+                    allowLogicalExpressionChainExpression: { type: 'boolean' },
+
+                    allowNegatedUnaryExpression: { type: 'boolean' },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+
+    create: function (context) {
+        return {
+            /*
+             *  var b = a ? 'hello' : 'there';
+             *  if (a) return 'hello';
+             */
+            'Identifier.test': createReporter(
+                'allowConditionalExpressionIdentifier',
+                context,
+                'Unexpected Identifier as Conditional',
+            ),
+
+            /*
+             *  var b = object.key ? 'hello' : 'there';
+             *  if (object.key) return 'hello';
+             */
+            'MemberExpression.test': createReporter(
+                'allowConditionalExpressionMemberExpression',
+                context,
+                'Unexpected MemberExpression as Conditional',
+            ),
+
+            /*
+             *  var b = object?.key ? 'hello' : 'there';
+             *  if (object?.key) return 'hello';
+             */
+            'ChainExpression.test': createReporter(
+                'allowConditionalExpressionChainExpression',
+                context,
+                'Unexpected ChainExpression as Conditional',
+            ),
+
+            /*
+             *  var b = a() ? 'hello' : 'there';
+             *  if (a()) return 'hello';
+             *
+             *  var b = object.key() ? 'hello' : 'there';
+             *  if (object.key()) return 'hello';
+             */
+            'CallExpression.test': createReporter(
+                'allowConditionalExpressionCallExpression',
+                context,
+                'Unexpected CallExpression as Conditional',
+            ),
+
+            /*
+             *  one === 1 && two
+             *  one === 1 || two
+             */
+            'LogicalExpression[operator="&&"] > Identifier.right, LogicalExpression[operator="||"] > Identifier.right': createReporter(
+                'allowLogicalExpressionIdentifier',
+                context,
+                'Unexpected Identifier as right hand of LogicalExpression',
+            ),
+
+            /*
+             *  one === 1 && two()
+             *  one === 1 || two()
+             *
+             *  one === 1 && object.two()
+             *  one === 1 || object.two()
+             */
+            'LogicalExpression[operator="&&"] > CallExpression.right, LogicalExpression[operator="||"] > CallExpression.right': createReporter(
+                'allowLogicalExpressionCallExpression',
+                context,
+                'Unexpected CallExpression as right hand of LogicalExpression',
+            ),
+
+            /*
+             *  one === 1 && object.two
+             *  one === 1 || object.two
+             */
+            'LogicalExpression[operator="&&"] > MemberExpression.right, LogicalExpression[operator="||"] > MemberExpression.right': createReporter(
+                'allowLogicalExpressionMemberExpression',
+                context,
+                'Unexpected MemberExpression as right hand of LogicalExpression',
+            ),
+
+            /*
+             *  one === 1 && object?.two
+             *  one === 1 || object?.two
+             */
+            'LogicalExpression[operator="&&"] > ChainExpression.right, LogicalExpression[operator="||"] > ChainExpression.right': createReporter(
+                'allowLogicalExpressionChainExpression',
+                context,
+                'Unexpected ChainExpression as right hand of LogicalExpression',
+            ),
+
+            /*
+             *  one && two === 2
+             *  one || two === 2
+             */
+            'LogicalExpression[operator="&&"] > Identifier.left, LogicalExpression[operator="||"] > Identifier.left': createReporter(
+                'allowLogicalExpressionIdentifier',
+                context,
+                'Unexpected Identifier as left hand of LogicalExpression',
+            ),
+
+            /*
+             *  one() && two === 2
+             *  one() || two === 2
+             *
+             *  object.one() && two === 2
+             *  object.one() || two === 2
+             *
+             *  object?.one() && two === 2
+             *  object?.one() || two === 2
+             */
+            'LogicalExpression[operator="&&"] > CallExpression.left, LogicalExpression[operator="||"] > CallExpression.left': createReporter(
+                'allowLogicalExpressionCallExpression',
+                context,
+                'Unexpected CallExpression as left hand of LogicalExpression',
+            ),
+
+            /*
+             *  object.one && two === 2
+             *  object.one || two === 2
+             */
+            'LogicalExpression[operator="&&"] > MemberExpression.left, LogicalExpression[operator="||"] > MemberExpression.left': createReporter(
+                'allowLogicalExpressionMemberExpression',
+                context,
+                'Unexpected MemberExpression as left hand of LogicalExpression',
+            ),
+
+            /*
+             *  object?.one && two === 2
+             *  object?.one || two === 2
+             */
+            'LogicalExpression[operator="&&"] > ChainExpression.left, LogicalExpression[operator="||"] > ChainExpression.left': createReporter(
+                'allowLogicalExpressionChainExpression',
+                context,
+                'Unexpected ChainExpression as left hand of LogicalExpression',
+            ),
+
+            'UnaryExpression[operator="!"]': createReporter(
+                'allowNegatedUnaryExpression',
+                context,
+                'Unexpected "!" UnaryExpression',
+            ),
+        };
+    },
+};
+
+export default rule;