@darksheep/eslint 4.1.3

package/src/plugins/node.js

@@ -0,0 +1,129 @@
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+
+import n from 'eslint-plugin-n';
+import {
+    getCommonFiles,
+    getModuleFiles,
+    getTypescriptFiles,
+    getExampleFiles,
+} from '../utilities/eslint-files.js';
+
+const script = n.configs['flat/recommended-script'];
+const module = n.configs['flat/recommended-module'];
+
+/** @type {import('eslint').Linter.RulesRecord} */
+const commonRules = {
+    'n/no-new-require': 'error',
+    'n/no-mixed-requires': 'error',
+
+    'n/callback-return': 'error',
+    'n/handle-callback-err': 'error',
+    'n/no-process-exit': 'warn',
+    'n/no-path-concat': 'error',
+
+    'n/no-callback-literal': 'off',
+    'n/no-exports-assign': 'off',
+
+    'n/global-require': [ 'error' ],
+    'n/no-unpublished-bin': 'error',
+    'n/no-unpublished-import': [ 'error', { ignoreTypeImport: true } ],
+    'n/no-unpublished-require': 'error',
+
+    'n/no-unsupported-features/es-builtins': 'error',
+    'n/no-unsupported-features/es-syntax': [ 'error', { ignores: [ 'modules' ] } ],
+    'n/no-unsupported-features/node-builtins': 'error',
+
+    'n/process-exit-as-throw': 'error',
+    'n/shebang': 'error',
+
+    'n/no-deprecated-api': 'error',
+
+    'n/exports-style': [ 'error', 'module.exports' ],
+    'n/file-extension-in-import': [ 'error', 'always' ],
+
+    'n/prefer-global/buffer': [ 'warn', 'always' ],
+    'n/prefer-global/console': [ 'warn', 'always' ],
+    'n/prefer-global/process': [ 'warn', 'always' ],
+    'n/prefer-global/text-decoder': [ 'warn', 'never' ],
+    'n/prefer-global/text-encoder': [ 'warn', 'never' ],
+    'n/prefer-global/url-search-params': [ 'warn', 'never' ],
+    'n/prefer-global/url': [ 'warn', 'never' ],
+    'n/prefer-promises/dns': 'warn',
+    'n/prefer-promises/fs': 'warn',
+};
+
+/**
+ * @param {string[]} globs A list of file globs whos extensions to get
+ * @returns {string[]}
+ */
+function toExt(globs) {
+    return globs.map((glob) => glob.slice(glob.lastIndexOf('.')));
+}
+
+/**
+ * Get ESLint config for the node plugin
+ * @param {URL} root root url
+ * @returns {Promise<import('eslint').Linter.FlatConfig[]>}
+ */
+export async function createEslintNodeConfigs(root) {
+    const commonFiles = await getCommonFiles(root);
+    const moduleFiles = await getModuleFiles(root);
+    const typescriptFiles = await getTypescriptFiles();
+    const exampleFiles = await getExampleFiles();
+    const rootDirectory = dirname(fileURLToPath(root));
+
+    return [
+        {
+            files: commonFiles,
+            ignores: exampleFiles,
+            plugins: { n },
+            languageOptions: {
+                globals: script?.languageOptions?.globals,
+                parserOptions: {
+                    sourceType: 'script',
+                    ecmaVersion: 2022,
+                },
+            },
+            settings: {
+                node: {
+                    tryExtensions: toExt(commonFiles),
+                    resolvePaths: rootDirectory,
+                },
+            },
+            rules: {
+                ...commonRules,
+                'n/no-sync': [ 'error', { allowAtRootLevel: true } ],
+                'n/no-extraneous-require': 'error',
+                'n/no-missing-require': 'error',
+
+                'n/no-unsupported-features/es-syntax': [ 'error', { ignores: [] } ],
+            },
+        },
+        {
+            files: [ ...typescriptFiles, ...moduleFiles ],
+            ignores: exampleFiles,
+            plugins: { n },
+            languageOptions: {
+                globals: module?.languageOptions?.globals,
+                parserOptions: {
+                    sourceType: 'module',
+                    ecmaVersion: 2022,
+                },
+            },
+            settings: {
+                node: {
+                    tryExtensions: toExt([ ...typescriptFiles, ...moduleFiles ]),
+                    resolvePaths: rootDirectory,
+                },
+            },
+            rules: {
+                ...commonRules,
+                'n/no-extraneous-import': 'error',
+                'n/no-missing-import': 'error',
+                'n/no-sync': [ 'error', { allowAtRootLevel: false } ],
+                'n/no-unsupported-features/es-syntax': [ 'error', { ignores: [ 'modules' ] } ],
+            },
+        },
+    ];
+}

package/src/plugins/promise.js

@@ -0,0 +1,16 @@
+import promise from 'eslint-plugin-promise';
+
+/**
+ * Get ESLint config for the promise plugin
+ * @returns {import('eslint').Linter.FlatConfig[]}
+ */
+export function createEslintPromiseConfig() {
+    return [ {
+        plugins: { promise },
+        rules: {
+            ...promise.configs.recommended.rules,
+            'promise/catch-or-return': [ 'error', { allowFinally: true } ],
+            'promise/no-return-wrap': [ 'error', { allowReject: true } ],
+        },
+    } ];
+}

package/src/plugins/react.js

@@ -0,0 +1,128 @@
+import react from 'eslint-plugin-react';
+
+import { getPackageJson } from '../utilities/package.js';
+
+/** @type {import('eslint').Linter.RulesRecord} */
+const rules = {
+    'react/display-name': 2,
+    'react/jsx-key': 2,
+    'react/jsx-no-comment-textnodes': 2,
+    'react/jsx-no-duplicate-props': 2,
+    'react/jsx-no-target-blank': 2,
+    'react/jsx-no-undef': 2,
+    'react/jsx-uses-react': 2,
+    'react/jsx-uses-vars': 2,
+    'react/no-children-prop': 2,
+    'react/no-danger-with-children': 2,
+    'react/no-deprecated': 2,
+    'react/no-direct-mutation-state': 2,
+    'react/no-find-dom-node': 2,
+    'react/no-is-mounted': 2,
+    'react/no-render-return-value': 2,
+    'react/no-string-refs': 2,
+    'react/no-unescaped-entities': 2,
+    'react/no-unknown-property': 2,
+    'react/no-unsafe': 0,
+    'react/prop-types': 2,
+    'react/react-in-jsx-scope': 2,
+    'react/require-render-return': 2,
+
+    'react/boolean-prop-naming': 0,
+    'react/button-has-type': 0,
+    'react/default-props-match-prop-types': 0,
+    'react/destructuring-assignment': 0,
+    'react/forbid-component-props': 0,
+    'react/forbid-dom-props': 0,
+    'react/forbid-elements': 0,
+    'react/forbid-foreign-prop-types': 0,
+    'react/forbid-prop-types': 0,
+    'react/function-component-definition': 0,
+    'react/hook-use-state': 0,
+    'react/iframe-missing-sandbox': 0,
+    'react/jsx-boolean-value': 0,
+    'react/jsx-filename-extension': 0,
+    'react/jsx-handler-names': 0,
+    'react/jsx-max-depth': 0,
+    'react/jsx-no-bind': 0,
+    'react/jsx-no-constructed-context-values': 0,
+    'react/jsx-no-leaked-render': 0,
+    'react/jsx-no-literals': 0,
+    'react/jsx-no-script-url': 0,
+    'react/jsx-no-useless-fragment': 0,
+    'react/jsx-pascal-case': 0,
+    'react/jsx-fragments': 0,
+    'react/jsx-props-no-spreading': 0,
+    'react/no-invalid-html-attribute': 0,
+    'react/no-access-state-in-setstate': 0,
+    'react/no-adjacent-inline-elements': 0,
+    'react/no-array-index-key': 0,
+    'react/no-arrow-function-lifecycle': 0,
+    'react/no-danger': 0,
+    'react/no-did-mount-set-state': 0,
+    'react/no-did-update-set-state': 0,
+    'react/no-multi-comp': 0,
+    'react/no-namespace': 0,
+    'react/no-set-state': 0,
+    'react/no-redundant-should-component-update': 0,
+    'react/no-this-in-sfc': 0,
+    'react/no-typos': 0,
+    'react/no-unstable-nested-components': 0,
+    'react/no-unused-class-component-methods': 0,
+    'react/no-unused-prop-types': 0,
+    'react/no-unused-state': 0,
+    'react/no-object-type-as-default-prop': 0,
+    'react/no-will-update-set-state': 0,
+    'react/prefer-es6-class': 0,
+    'react/prefer-exact-props': 0,
+    'react/prefer-read-only-props': 0,
+    'react/prefer-stateless-function': 0,
+    'react/require-default-props': 0,
+    'react/require-optimization': 0,
+    'react/self-closing-comp': 0,
+    'react/sort-comp': 0,
+    'react/sort-default-props': 0,
+    'react/sort-prop-types': 0,
+    'react/state-in-constructor': 0,
+    'react/static-property-placement': 0,
+    'react/style-prop-object': 0,
+    'react/void-dom-elements-no-children': 0,
+};
+
+/**
+ * Get ESLint config for imports check
+ * @param {URL} root The root of the package being linted
+ * @returns {Promise<import('eslint').Linter.FlatConfig[]>}
+ */
+export async function createEslintReactConfig(root) {
+    const packageJson = await getPackageJson(root, 'react');
+
+    return [
+        {
+            files: [ '**/*.jsx' ],
+            languageOptions: {
+                parserOptions: {
+                    ecmaFeatures: { jsx: true },
+                },
+            },
+            settings: {
+                react: { version: packageJson?.version },
+            },
+            plugins: { react },
+            rules: rules,
+        },
+        {
+            files: [ '**/*.tsx' ],
+            languageOptions: {
+                parserOptions: {
+                    ecmaFeatures: { jsx: true },
+                    jsxPragma: null,
+                },
+            },
+            settings: {
+                react: { version: packageJson?.version },
+            },
+            plugins: { react },
+            rules: rules,
+        },
+    ];
+}

package/src/plugins/regexp.js

@@ -0,0 +1,13 @@
+import { makeCompat } from '../utilities/make-compat.js';
+
+/**
+ * Get ESLint config for the regexp plugin
+ * @param {import('node:url').URL} root root url
+ * @returns {import('eslint').Linter.FlatConfig[]}
+ */
+export function createEslintRegexpConfig(root) {
+    return makeCompat(root).config({
+        plugins: [ 'regexp' ],
+        extends: [ 'plugin:regexp/recommended' ],
+    });
+}

package/src/plugins/sca.js

@@ -0,0 +1,41 @@
+import sca from '../custom/index.js';
+import {
+    getCommonFiles,
+    getModuleFiles,
+    getTypescriptFiles,
+} from '../utilities/eslint-files.js';
+
+/**
+ * Get ESLint config for the sca plugin
+ * @param {URL} root The root url of the package we are linting
+ * @returns {Promise<import('eslint').Linter.FlatConfig[]>}
+ */
+export async function createEslintSCAConfig(root) {
+    return [
+        {
+            files: [
+                ...await getCommonFiles(root),
+                ...await getModuleFiles(root),
+            ],
+            plugins: { sca },
+            rules: {
+                'sca/loose-types': [
+                    'error',
+                    {
+                        allowConditionalExpressionCallExpression: true,
+                        allowLogicalExpressionCallExpression: true,
+                    },
+                ],
+                'sca/no-useless-expression': 'error',
+                'sca/sequence-expression': 'error',
+            },
+        },
+        {
+            files: await getTypescriptFiles(),
+            plugins: { sca },
+            rules: {
+                'sca/sequence-expression': 'error',
+            },
+        },
+    ];
+}

package/src/plugins/security.js

@@ -0,0 +1,15 @@
+import security from 'eslint-plugin-security';
+
+/**
+ * Get ESLint config for the security plugin
+ * @returns {import('eslint').Linter.FlatConfig[]}
+ */
+export function createEslintSecurityConfig() {
+    return [ {
+        ...security.configs.recommended,
+        plugins: { security },
+        rules: {
+            'security/detect-non-literal-fs-filename': 0,
+        },
+    } ];
+}

package/src/plugins/sonarjs.js

@@ -0,0 +1,28 @@
+import eslintSonarJS from 'eslint-plugin-sonarjs';
+import { makeCompat } from '../utilities/make-compat.js';
+
+/**
+ * Get ESLint config for the sonar plugin
+ * @param {import('node:url').URL} root root url
+ * @returns {import('eslint').Linter.FlatConfig[]}
+ */
+export function createEslintSonarJSConfig(root) {
+    return makeCompat(root).config({
+        plugins: [
+            'sonarjs',
+        ],
+        rules: {
+            ...eslintSonarJS.configs.recommended.rules,
+            'sonarjs/cognitive-complexity': 'error',
+        },
+        extends: [ 'plugin:sonarjs/recommended' ],
+        overrides: [
+            {
+                files: [ '*.test.*' ],
+                rules: {
+                    'sonarjs/no-duplicate-string': 'off',
+                },
+            },
+        ],
+    });
+}

package/src/plugins/style.js

@@ -0,0 +1,249 @@
+/* eslint max-lines-per-function: 0 */
+import stylistic from '@stylistic/eslint-plugin';
+
+/**
+ * Get ESLint config for the sonar plugin
+ * @returns {import('eslint').Linter.FlatConfig[]}
+ */
+export function createEslintStyleConfig() {
+    return [ {
+        plugins: { style: stylistic },
+        rules: {
+            // Require or disallow newline at the end of files
+            // 'style/eol-last': [ 'error' ],
+            // Enforce consistent indentation
+            // 'style/indent': [ 'error' ],
+            // Indentation for binary operators
+            // 'style/indent-binary-ops': [ 'error' ],
+            // Enforce consistent linebreak style
+            // 'style/linebreak-style': [ 'error' ],
+            // Disallow trailing whitespace at the end of lines
+            // 'style/no-trailing-spaces': [ 'error' ],
+            // Enforce JSX indentation
+            // 'style/jsx-indent': [ 'off' ],
+
+            // Enforce linebreaks after opening and before closing array brackets
+            'style/array-bracket-newline': [ 'error', 'consistent' ],
+            // Enforce consistent spacing inside array brackets
+            'style/array-bracket-spacing': [ 'error', 'always' ],
+            // Enforce line breaks after each array element
+            'style/array-element-newline': [ 'error', 'consistent' ],
+            // Require parentheses around arrow function arguments
+            'style/arrow-parens': [ 'error', 'always' ],
+            // Enforce consistent spacing before and after the arrow in arrow functions
+            'style/arrow-spacing': [ 'error' ],
+            // Disallow or enforce spaces inside of blocks after opening block and before closing block
+            'style/block-spacing': [ 'error' ],
+            // Enforce consistent brace style for blocks
+            'style/brace-style': [ 'error', '1tbs' ],
+            // Require or disallow trailing commas
+            'style/comma-dangle': [ 'error', 'always-multiline' ],
+            // Enforce consistent spacing before and after commas
+            'style/comma-spacing': [ 'error', { before: false, after: true } ],
+            // Enforce consistent comma style
+            'style/comma-style': [ 'error', 'last' ],
+            // Enforce consistent spacing inside computed property brackets
+            'style/computed-property-spacing': [ 'error', 'never' ],
+            // Enforce consistent newlines before and after dots
+            'style/dot-location': [ 'error', 'property' ],
+            // Require or disallow spacing between function identifiers and their invocations. Alias of `function-call-spacing`.
+            'style/func-call-spacing': [ 'error', 'never' ],
+            // Enforce line breaks between arguments of a function call
+            'style/function-call-argument-newline': [ 'error', 'consistent' ],
+            // Require or disallow spacing between function identifiers and their invocations
+            'style/function-call-spacing': [ 'error' ],
+            // Enforce consistent line breaks inside function parentheses
+            'style/function-paren-newline': [ 'error', 'consistent' ],
+            // Enforce consistent spacing around `*` operators in generator functions
+            'style/generator-star-spacing': [ 'error', 'both' ],
+            // Enforce the location of arrow function bodies
+            'style/implicit-arrow-linebreak': [ 'error', 'beside' ],
+            // Enforce the consistent use of either double or single quotes in JSX attributes
+            'style/jsx-quotes': [ 'error' ],
+            // Enforce consistent spacing between keys and values in object literal properties
+            'style/key-spacing': [ 'error', { beforeColon: false, afterColon: true } ],
+            // Enforce consistent spacing before and after keywords
+            'style/keyword-spacing': [ 'error', { before: true, after: true } ],
+            // Require empty lines around comments
+            'style/lines-around-comment': [ 'off' ],
+            // Require or disallow an empty line between class members
+            'style/lines-between-class-members': [
+                'error',
+                'always',
+                { exceptAfterSingleLine: true },
+            ],
+            // Enforce a maximum line length
+            'style/max-len': [ 'off' ],
+            //     'warn',
+            //     {
+            //         code: 100,
+            //         ignoreComments: true,
+            //         ignoreRegExpLiterals: true,
+            //         ignoreStrings: true,
+            //         ignoreTemplateLiterals: true,
+            //         ignoreUrls: true,
+            //     },
+            // ]
+            // Enforce a maximum number of statements allowed per line
+            'style/max-statements-per-line': [ 'error' ],
+            // Enforce newlines between operands of ternary expressions
+            'style/multiline-ternary': [ 'error', 'always-multiline' ],
+            // Enforce or disallow parentheses when invoking a constructor with no arguments
+            'style/new-parens': [ 'error' ],
+            // Require a newline after each call in a method chain
+            'style/newline-per-chained-call': [ 'error' ],
+            // Disallow arrow functions where they could be confused with comparisons
+            'style/no-confusing-arrow': [ 'warn', { allowParens: true } ],
+            // Disallow unnecessary parentheses
+            'style/no-extra-parens': [ 'off' ],
+            // Disallow unnecessary semicolons
+            'style/no-extra-semi': [ 'error' ],
+            // Disallow leading or trailing decimal points in numeric literals
+            'style/no-floating-decimal': [ 'error' ],
+            // Disallow mixed binary operators
+            'style/no-mixed-operators': [ 'error' ],
+            // Disallow mixed spaces and tabs for indentation
+            'style/no-mixed-spaces-and-tabs': [ 'error' ],
+            // Disallow multiple spaces
+            'style/no-multi-spaces': [ 'error' ],
+            // Disallow multiple empty lines
+            'style/no-multiple-empty-lines': [
+                'error',
+                {
+                    max: 1,
+                    maxBOF: 1,
+                    maxEOF: 1,
+                },
+            ],
+            // Disallow all tabs
+            'style/no-tabs': [ 'error' ],
+            // Disallow whitespace before properties
+            'style/no-whitespace-before-property': [ 'error' ],
+            // Enforce the location of single-line statements
+            'style/nonblock-statement-body-position': [ 'error' ],
+            // Enforce consistent line breaks after opening and before closing braces
+            'style/object-curly-newline': [ 'error', { consistent: true } ],
+            // Enforce consistent spacing inside braces
+            'style/object-curly-spacing': [ 'error', 'always' ],
+            // Enforce placing object properties on separate lines
+            'style/object-property-newline': [ 'error', { allowAllPropertiesOnSameLine: true } ],
+            // Require or disallow newlines around variable declarations
+            'style/one-var-declaration-per-line': [ 'error', 'initializations' ],
+            // Enforce consistent linebreak style for operators
+            'style/operator-linebreak': [
+                'error',
+                'after',
+                {
+                    overrides: {
+                        '?': 'before',
+                        ':': 'before',
+                    },
+                },
+            ],
+            // Require or disallow padding within blocks
+            'style/padded-blocks': [ 'error', 'never' ],
+            // Require or disallow padding lines between statements
+            'style/padding-line-between-statements': [ 'off' ],
+            // Require quotes around object literal property names
+            'style/quote-props': [ 'error', 'consistent-as-needed' ],
+            // Enforce the consistent use of either backticks, double, or single quotes
+            'style/quotes': [
+                'error',
+                'single',
+                {
+                    allowTemplateLiterals: true,
+                    avoidEscape: true,
+                },
+            ],
+            // Enforce spacing between rest and spread operators and their expressions
+            'style/rest-spread-spacing': [ 'error', 'never' ],
+            // Require or disallow semicolons instead of ASI
+            'style/semi': [ 'error', 'always' ],
+            // Enforce consistent spacing before and after semicolons
+            'style/semi-spacing': [ 'error' ],
+            // Enforce location of semicolons
+            'style/semi-style': [ 'error', 'last' ],
+            // Enforce consistent spacing before blocks
+            'style/space-before-blocks': [ 'error' ],
+            // Enforce consistent spacing before `function` definition opening parenthesis
+            'style/space-before-function-paren': [
+                'error',
+                {
+                    anonymous: 'always',
+                    named: 'never',
+                    asyncArrow: 'always',
+                },
+            ],
+            // Enforce consistent spacing inside parentheses
+            'style/space-in-parens': [ 'error', 'never' ],
+            // Require spacing around infix operators
+            'style/space-infix-ops': [ 'error' ],
+            // Enforce consistent spacing before or after unary operators
+            'style/space-unary-ops': [ 'error' ],
+            // Enforce consistent spacing after the `//` or `/*` in a comment
+            'style/spaced-comment': [ 'error', 'always', { markers: [ '?' ] } ],
+            // Enforce spacing around colons of switch statements
+            'style/switch-colon-spacing': [ 'error' ],
+            // Require or disallow spacing around embedded expressions of template strings
+            'style/template-curly-spacing': [ 'error' ],
+            // Require or disallow spacing between template tags and their literals
+            'style/template-tag-spacing': [ 'error' ],
+            // Require parentheses around immediate `function` invocations
+            'style/wrap-iife': [
+                'error',
+                'inside',
+                { functionPrototypeMethods: true },
+            ],
+            // Require parenthesis around regex literals
+            'style/wrap-regex': [ 'error' ],
+            // Require or disallow spacing around the `*` in `yield*` expressions
+            'style/yield-star-spacing': [ 'error', 'both' ],
+
+            // Require a specific member delimiter style for interfaces and type literals
+            'style/member-delimiter-style': [ 'error' ],
+            // Require consistent spacing around type annotations
+            'style/type-annotation-spacing': [ 'error' ],
+
+            // Enforce or disallow spaces inside of curly braces in JSX attributes and expressions
+            'style/jsx-child-element-spacing': [ 'off' ],
+            // Enforce closing bracket location in JSX
+            'style/jsx-closing-bracket-location': [ 'off' ],
+            // Enforce closing tag location for multiline JSX
+            'style/jsx-closing-tag-location': [ 'off' ],
+            // Disallow unnecessary JSX expressions when literals alone are sufficient or enforce JSX expressions on literals in JSX children or attributes
+            'style/jsx-curly-brace-presence': [ 'off' ],
+            // Enforce consistent linebreaks in curly braces in JSX attributes and expressions
+            'style/jsx-curly-newline': [ 'off' ],
+            // Enforce or disallow spaces inside of curly braces in JSX attributes and expressions
+            'style/jsx-curly-spacing': [ 'off' ],
+            // Enforce or disallow spaces around equal signs in JSX attributes
+            'style/jsx-equals-spacing': [ 'off' ],
+            // Enforce proper position of the first property in JSX
+            'style/jsx-first-prop-new-line': [ 'off' ],
+            // Enforce props indentation in JSX
+            'style/jsx-indent-props': [ 'off' ],
+            // Enforce maximum of props on a single line in JSX
+            'style/jsx-max-props-per-line': [ 'off' ],
+            // Require or prevent a new line after jsx elements and expressions.
+            'style/jsx-newline': [ 'off' ],
+            // Require one JSX element per line
+            'style/jsx-one-expression-per-line': [ 'off' ],
+            // Disallow multiple spaces between inline JSX props
+            'style/jsx-props-no-multi-spaces': [ 'off' ],
+            // Disallow extra closing tags for components without children
+            'style/jsx-self-closing-comp': [ 'off' ],
+            // Enforce props alphabetical sorting
+            'style/jsx-sort-props': [ 'off' ],
+            // Enforce whitespace in and around the JSX opening and closing brackets
+            'style/jsx-tag-spacing': [ 'off' ],
+            // Disallow missing parentheses around multiline JSX
+            'style/jsx-wrap-multilines': [ 'off' ],
+
+            // Enforces consistent spacing inside TypeScript type generics
+            'style/type-generic-spacing': [ 'error' ],
+            // Expect space before the type declaration in the named tuple
+            'style/type-named-tuple-spacing': [ 'error' ],
+
+        },
+    } ];
+}