@darksheep/eslint 4.1.3

package/src/custom/no-useless-expression.js

@@ -0,0 +1,28 @@
+const selector = [
+    // test || false, false || test
+    'LogicalExpression[operator="||"] > [type=/Literal$/]',
+    // true && test, test && true
+    'LogicalExpression[operator="&&"] > [type=/Literal$/]',
+].join(', ');
+
+/** @type {import('eslint').Rule.RuleModule} */
+const rule = {
+    meta: { type: 'suggestion' },
+
+    create: function (context) {
+        return {
+            /**
+             * @param {import('estree').Literal} node The AST function node
+             * @returns {void}
+             */
+            [selector]: (node) => {
+                context.report({
+                    node: node,
+                    message: 'Unexpected Literal in LogicalExpression',
+                });
+            },
+        };
+    },
+};
+
+export default rule;

package/src/custom/sequence-expression.js

@@ -0,0 +1,21 @@
+/** @type {import('eslint').Rule.RuleModule} */
+const rule = {
+    meta: { type: 'suggestion' },
+
+    create: function (context) {
+        return {
+            /**
+             * @param {import('estree').SequenceExpression} node The AST function node
+             * @returns {void}
+             */
+            SequenceExpression: (node) => {
+                context.report({
+                    node: node,
+                    message: 'Unexpected use of a SequenceExpression',
+                });
+            },
+        };
+    },
+};
+
+export default rule;

package/src/index.js

@@ -0,0 +1,86 @@
+import { pathToFileURL, URL } from 'node:url';
+
+import { createEslintIgnoresConfig } from './configs/eslint-ignores.js';
+import { createEslintBaseConfig } from './configs/eslint-base.js';
+import { createEslintRecommendsConfig } from './configs/eslint-recommended.js';
+import { createEslintComplexityConfig } from './configs/eslint-complexity.js';
+import { createStyleConfigs } from './configs/eslint-style.js';
+
+import { createEslintCommentsConfig } from './plugins/eslint-comments.js';
+import { createEslintImportConfig } from './plugins/import.js';
+import { createEslintJestConfig } from './plugins/jest.js';
+import { createEslintJSDocConfig } from './plugins/jsdoc.js';
+import { createEslintJsonConfig } from './plugins/json.js';
+import { createEslintJsxA11yConfig } from './plugins/jsx-a11y.js';
+import { createEslintNodeConfigs } from './plugins/node.js';
+import { createEslintPromiseConfig } from './plugins/promise.js';
+import { createEslintReactConfig } from './plugins/react.js';
+import { createEslintRegexpConfig } from './plugins/regexp.js';
+import { createEslintSCAConfig } from './plugins/sca.js';
+import { createEslintSecurityConfig } from './plugins/security.js';
+import { createEslintSonarJSConfig } from './plugins/sonarjs.js';
+import { createEslintStyleConfig } from './plugins/style.js';
+import { createEslintTypescriptConfig } from './plugins/typescript.js';
+import { createEslintUnicornConfig } from './plugins/unicorn.js';
+import { createEslintUnusedImportsConfig } from './plugins/unused-imports.js';
+
+const configBuilders = [
+    createEslintIgnoresConfig,
+    createEslintRecommendsConfig,
+    createEslintBaseConfig,
+    createEslintComplexityConfig,
+    createStyleConfigs,
+    createEslintCommentsConfig,
+    createEslintImportConfig,
+    createEslintNodeConfigs,
+    createEslintJsonConfig,
+    createEslintPromiseConfig,
+    createEslintTypescriptConfig,
+    createEslintReactConfig,
+    createEslintJsxA11yConfig,
+    createEslintSecurityConfig,
+    createEslintUnicornConfig,
+    createEslintRegexpConfig,
+    createEslintSCAConfig,
+    createEslintSonarJSConfig,
+    createEslintStyleConfig,
+    createEslintJestConfig,
+    createEslintUnusedImportsConfig,
+    createEslintJSDocConfig,
+];
+
+/**
+ * @param {URL} root The root url object for the project config
+ * @returns {Promise<import('eslint').Linter.FlatConfig[]>}
+ */
+async function createConfigUrl(root) {
+    const configs = await Promise.all(
+        configBuilders.map((builder) => builder(root)),
+    );
+
+    return configs.flat();
+}
+
+/**
+ * @param {string | URL} root root url
+ * @returns {Promise<import('eslint').Linter.FlatConfig[]>}
+ */
+export async function createConfig(root) {
+    if (root instanceof URL) {
+        return createConfigUrl(root);
+    }
+
+    if (typeof root !== 'string') {
+        throw new TypeError('Invalid file root');
+    }
+
+    root = root
+        // This is to remove: file:/ or file:///
+        .replace(/^file:\/*/, '/')
+        // This is prevent ?time=<stamp>
+        .replace(/\?.*$/, '');
+
+    return createConfigUrl(pathToFileURL(root));
+}
+
+export * from 'eslint';

package/src/plugins/eslint-comments.js

@@ -0,0 +1,27 @@
+import eslintComments from '@eslint-community/eslint-plugin-eslint-comments';
+
+/**
+ * Get ESLint config for comments check
+ * @returns {import('eslint').Linter.FlatConfig[]}
+ */
+export function createEslintCommentsConfig() {
+    return [
+        {
+            plugins: {
+                'eslint-comments': eslintComments,
+            },
+            rules: {
+                'eslint-comments/disable-enable-pair': [ 'error', { allowWholeFile: true } ],
+                'eslint-comments/no-aggregating-enable': 'error',
+                'eslint-comments/no-duplicate-disable': 'error',
+                'eslint-comments/no-unlimited-disable': 'error',
+                'eslint-comments/no-unused-disable': 'error',
+                'eslint-comments/no-unused-enable': 'error',
+
+                'line-comment-position': 'off',
+                'multiline-comment-style': 'off',
+                'no-inline-comments': 'off',
+            },
+        },
+    ];
+}

package/src/plugins/import.js

@@ -0,0 +1,139 @@
+import importPlugin from 'eslint-plugin-import';
+
+import {
+    getModuleFiles,
+    getTypescriptFiles,
+} from '../utilities/eslint-files.js';
+
+/** @type {import('eslint').Linter.RulesRecord} */
+const rules = {
+    /*
+     *Static analysis
+     */
+    'import/no-unresolved': 'off',
+    'import/named': 'error',
+    'import/default': 'warn',
+    'import/namespace': [
+        'error',
+        { allowComputed: true },
+    ],
+    'import/no-restricted-paths': 'off',
+    'import/no-absolute-path': 'error',
+    'import/no-dynamic-require': 'error',
+    'import/no-internal-modules': 'off',
+    'import/no-webpack-loader-syntax': 'off',
+    'import/no-self-import': 'error',
+    'import/no-cycle': [
+        'error',
+        { ignoreExternal: true },
+    ],
+    'import/no-useless-path-segments': 'error',
+    'import/no-relative-parent-imports': 'off',
+
+    /*
+     * Helpful warnings
+     */
+    'import/export': 'error',
+    'import/no-named-as-default': 'error',
+    'import/no-named-as-default-member': 'error',
+    'import/no-deprecated': 'error',
+    'import/no-mutable-exports': 'warn',
+
+    // For some reason this seems to be broken :thinking:
+    // 'import/no-unused-modules': [ 'warn', { unusedExports: true } ],
+
+    /*
+     * Module systems
+     */
+    'import/unambiguous': 'error',
+    'import/no-commonjs': 'error',
+    'import/no-amd': 'error',
+    'import/no-nodejs-modules': 'off',
+    'import/no-extraneous-dependencies': 'off',
+
+    /*
+     * Import Style
+     */
+    'import/first': 'error',
+    'import/exports-last': 'warn',
+    'import/no-duplicates': 'error',
+    'import/no-namespace': 'off',
+    'import/extensions': 'off',
+    'import/order': [
+        'error', {
+            groups: [
+                'builtin',
+                'external',
+                [
+                    'internal',
+                    'sibling',
+                    'parent',
+                ],
+                'index',
+            ],
+        },
+    ],
+    'import/newline-after-import': 'error',
+    // Breaks babel.
+    'import/prefer-default-export': 'off',
+    'import/max-dependencies': 'off',
+    'import/no-unassigned-import': 'error',
+    'import/no-named-default': 'off',
+    'import/no-default-export': 'off',
+    'import/no-named-export': 'off',
+    // Breaks babel.
+    'import/no-anonymous-default-export': 'off',
+    // This is sometimes painful
+    'import/group-exports': 'off',
+    'import/dynamic-import-chunkname': 'off',
+};
+
+/**
+ * Get ESLint config for imports check
+ * @param {import('node:url').URL} root The root of the eslint config directory
+ * @returns {Promise<import('eslint').Linter.FlatConfig[]>}
+ */
+export async function createEslintImportConfig(root) {
+    return [
+        {
+            files: await getModuleFiles(root),
+            plugins: { import: importPlugin },
+            languageOptions: {
+                parserOptions: {
+                    sourceType: 'module',
+                    ecmaVersion: 2022,
+                },
+            },
+            settings: {
+                'import/parsers': {
+                    espree: [ '.js', '.cjs', '.mjs', '.jsx' ],
+                },
+                'import/resolver': {
+                    node: true,
+                },
+            },
+            rules: rules,
+        },
+        {
+            files: await getTypescriptFiles(),
+            plugins: { import: importPlugin },
+            languageOptions: {
+                parserOptions: {
+                    sourceType: 'module',
+                    ecmaVersion: 2022,
+                },
+            },
+            settings: {
+                ...importPlugin.configs.typescript.settings,
+
+                'import/resolver': {
+                    typescript: {
+                        alwaysTryTypes: true,
+                    },
+                },
+
+            },
+            rules: importPlugin.configs.typescript.rules,
+        },
+    ];
+}

package/src/plugins/jest.js

@@ -0,0 +1,124 @@
+import jest from 'eslint-plugin-jest';
+import { getPackageJson } from '../utilities/package.js';
+import { expandGlob } from '../utilities/expand-glob.js';
+
+const { globals } = jest.environments.globals;
+
+/**
+ * Get ESLint config jest plugin
+ * @param {import('node:url').URL} root root url
+ * @returns {Promise<import('eslint').Linter.FlatConfig[]>}
+ */
+export async function createEslintJestConfig(root) {
+    const packageJson = await getPackageJson(root, 'jest');
+
+    // Jest not installed
+    if (packageJson == null) {
+        return [];
+    }
+
+    return [
+        {
+            files: expandGlob('**/*.{test,spec}.{js,ts}'),
+            plugins: { jest },
+            languageOptions: { globals },
+            settings: {
+                jest: { version: packageJson?.version },
+                // node: { allowModules: [ '@jest/globals' ] },
+            },
+            rules: {
+                'max-lines': 'off',
+                'max-lines-per-function': 'off',
+                'max-nested-callbacks': 'off',
+                'class-methods-use-this': 'off',
+
+                'i6-custom-rules/moment/no-date': 'off',
+                'import/no-webpack-loader-syntax': 'off',
+                'import/first': 'off',
+                // 'node/no-extraneous-import': 'off',
+                'sonarjs/no-duplicate-string': 'off',
+
+                'jest/consistent-test-it': [
+                    'error', {
+                        fn: 'test',
+                        withinDescribe: 'test',
+                    },
+                ],
+                'jest/expect-expect': [
+                    'error',
+                    { assertFunctionNames: [ 'expect' ] },
+                ],
+                'jest/lowercase-name': 'off',
+                'jest/no-alias-methods': 'error',
+
+                'jest/no-commented-out-tests': 'error',
+                'jest/no-disabled-tests': 'warn',
+                'jest/no-focused-tests': 'warn',
+
+                'jest/no-duplicate-hooks': 'error',
+                'jest/no-export': 'error',
+                'jest/no-hooks': 'off',
+                'jest/no-identical-title': 'error',
+                'jest/no-jasmine-globals': 'error',
+                'jest/no-large-snapshots': 'off',
+                'jest/no-mocks-import': 'error',
+                'jest/prefer-snapshot-hint': 'off',
+
+                'jest/no-conditional-expect': 'error',
+                'jest/no-conditional-in-test': 'warn',
+                'jest/no-deprecated-functions': 'error',
+                'jest/no-restricted-jest-methods': 'off',
+                'jest/no-restricted-matchers': [
+                    'error',
+                    {
+                        toBeTruthy: 'Avoid `toBeTruthy`',
+                        toBeFalsy: 'Avoid `toBeFalsy`',
+                        resolves: 'Use `expect(await promise)` instead.',
+                    },
+                ],
+
+                'jest/no-done-callback': 'error',
+                'jest/no-standalone-expect': 'error',
+                'jest/no-test-prefixes': 'error',
+                'jest/no-test-return-statement': 'error',
+                'jest/prefer-called-with': 'warn',
+                'jest/prefer-expect-assertions': [ 'warn', { onlyFunctionsWithAsyncKeyword: true } ],
+                'jest/prefer-comparison-matcher': 'warn',
+                'jest/prefer-equality-matcher': 'warn',
+                'jest/prefer-hooks-in-order': 'warn',
+                'jest/prefer-hooks-on-top': 'warn',
+                'jest/prefer-to-be': 'warn',
+                'jest/prefer-to-contain': 'warn',
+                'jest/prefer-to-have-length': 'warn',
+                'jest/prefer-todo': 'warn',
+                'jest/require-to-throw-message': 'error',
+                'jest/require-top-level-describe': 'error',
+                'jest/valid-describe-callback': 'error',
+                'jest/valid-expect': 'error',
+                'jest/valid-expect-in-promise': 'error',
+                'jest/valid-title': 'error',
+
+                'jest/prefer-spy-on': 'warn',
+                'jest/prefer-strict-equal': 'error',
+            },
+        },
+        {
+            files: [
+                '**/jest.{js,ts}',
+                '**/jest/**/*.{js,ts}',
+                '**/__mocks__/**/*.{js,ts}',
+                '**/test/**/*.{js,ts}',
+                '**/spec/**/*.{js,ts}',
+                '**/*.spec.ts',
+                '**/*.test.ts',
+            ],
+            languageOptions: {
+                globals: {
+                    __filename: true,
+                    __dirname: true,
+                    ...globals,
+                },
+            },
+        },
+    ];
+}

package/src/plugins/jsdoc.js

@@ -0,0 +1,70 @@
+import jsdoc from 'eslint-plugin-jsdoc';
+
+import { getTypescriptFiles } from '../utilities/eslint-files.js';
+import { getPackageJson } from '../utilities/package.js';
+
+/**
+ * Get ESLint config for js docs
+ * @param {URL} root The root of the package being linted
+ * @returns {Promise<import('eslint').Linter.FlatConfig[]>}
+ */
+export async function createEslintJSDocConfig(root) {
+    const tsPackage = await getPackageJson(root, 'typescript');
+    const typeChecks = tsPackage == null ? 'warn' : 'off';
+
+    return [
+        {
+            plugins: { jsdoc },
+            settings: {
+                jsdoc: {
+                    mode: 'typescript',
+                    // Prefer 'Object' over 'object'
+                    preferredTypes: { object: 'Object' },
+                },
+            },
+            rules: {
+                'jsdoc/check-access': 'warn',
+                'jsdoc/check-alignment': 'warn',
+                'jsdoc/check-param-names': 'warn',
+                'jsdoc/check-property-names': 'warn',
+                'jsdoc/check-tag-names': 'warn',
+                'jsdoc/check-values': 'warn',
+                'jsdoc/empty-tags': 'warn',
+                'jsdoc/implements-on-classes': 'error',
+                'jsdoc/informative-docs': 'warn',
+                'jsdoc/no-defaults': 'warn',
+                'jsdoc/no-multi-asterisks': 'warn',
+                'jsdoc/require-jsdoc': [ 1, { publicOnly: true } ],
+                'jsdoc/require-param': 'warn',
+                'jsdoc/require-param-description': 'warn',
+                'jsdoc/require-param-name': 'warn',
+                'jsdoc/require-param-type': 'warn',
+                'jsdoc/require-property': 'warn',
+                'jsdoc/require-property-description': 'warn',
+                'jsdoc/require-property-name': 'warn',
+                'jsdoc/require-property-type': 'warn',
+                'jsdoc/require-returns': 'warn',
+                'jsdoc/require-returns-check': 'warn',
+                'jsdoc/require-returns-type': 'warn',
+
+                'jsdoc/check-types': typeChecks,
+                'jsdoc/no-undefined-types': typeChecks,
+                'jsdoc/valid-types': typeChecks,
+            },
+        },
+        {
+            files: await getTypescriptFiles(),
+            rules: {
+                'jsdoc/no-types': 'warn',
+                'jsdoc/check-types': 'off',
+                'jsdoc/no-undefined-types': 'off',
+                'jsdoc/valid-types': 'off',
+                'jsdoc/require-returns': 'off',
+                'jsdoc/require-param-type': 'off',
+                'jsdoc/require-property-type': 'off',
+                'jsdoc/require-returns-type': 'off',
+
+            },
+        },
+    ];
+}

package/src/plugins/json.js

@@ -0,0 +1,37 @@
+import jsoncPlugin from 'eslint-plugin-jsonc';
+import jsoncParser from 'jsonc-eslint-parser';
+
+import { getJsonFiles } from '../utilities/eslint-files.js';
+
+/**
+ * Get ESLint config for imports check
+ * @returns {Promise<import('eslint').Linter.FlatConfig[]>}
+ */
+export async function createEslintJsonConfig() {
+    return [
+        {
+            files: await getJsonFiles(),
+            languageOptions: {
+                parser: /** @type {*} */ (jsoncParser),
+            },
+            plugins: {
+                jsonc: /** @type {*} */ (jsoncPlugin),
+            },
+        },
+        {
+            files: [ '**/*.json' ],
+            rules: /** @type {import('eslint').Linter.RulesRecord} */
+                (jsoncPlugin.configs['recommended-with-json'].rules),
+        },
+        {
+            files: [ '**/*.jsonc' ],
+            rules: /** @type {import('eslint').Linter.RulesRecord} */
+                (jsoncPlugin.configs['recommended-with-jsonc'].rules),
+        },
+        {
+            files: [ '**/*.json5' ],
+            rules: /** @type {import('eslint').Linter.RulesRecord} */
+                (jsoncPlugin.configs['recommended-with-json5'].rules),
+        },
+    ];
+}

package/src/plugins/jsx-a11y.js

@@ -0,0 +1,100 @@
+import jsxa11y from 'eslint-plugin-jsx-a11y';
+
+/** @type {import('eslint').Linter.RulesRecord} */
+const rules = {
+    'jsx-a11y/alt-text': 'error',
+    'jsx-a11y/anchor-ambiguous-text': 'off',
+    // TODO: error
+    'jsx-a11y/anchor-has-content': 'error',
+    'jsx-a11y/anchor-is-valid': 'error',
+    'jsx-a11y/aria-activedescendant-has-tabindex': 'error',
+    'jsx-a11y/aria-props': 'error',
+    'jsx-a11y/aria-proptypes': 'error',
+    'jsx-a11y/aria-role': 'error',
+    'jsx-a11y/aria-unsupported-elements': 'error',
+    'jsx-a11y/autocomplete-valid': 'error',
+    'jsx-a11y/click-events-have-key-events': 'error',
+    'jsx-a11y/control-has-associated-label': [ 'off', {
+        ignoreElements: [ 'audio', 'canvas', 'embed', 'input', 'textarea', 'tr', 'video' ],
+        ignoreRoles: [ 'grid', 'listbox', 'menu', 'menubar', 'radiogroup', 'row', 'tablist', 'toolbar', 'tree', 'treegrid' ],
+        includeRoles: [ 'alert', 'dialog' ],
+    } ],
+    'jsx-a11y/heading-has-content': 'error',
+    'jsx-a11y/html-has-lang': 'error',
+    'jsx-a11y/iframe-has-title': 'error',
+    'jsx-a11y/img-redundant-alt': 'error',
+    'jsx-a11y/interactive-supports-focus': [ 'error', {
+        tabbable: [ 'button', 'checkbox', 'link', 'searchbox', 'spinbutton', 'switch', 'textbox' ],
+    } ],
+    'jsx-a11y/label-has-associated-control': 'error',
+    'jsx-a11y/label-has-for': 'off',
+    'jsx-a11y/media-has-caption': 'error',
+    'jsx-a11y/mouse-events-have-key-events': 'error',
+    'jsx-a11y/no-access-key': 'error',
+    'jsx-a11y/no-autofocus': 'error',
+    'jsx-a11y/no-distracting-elements': 'error',
+    'jsx-a11y/no-interactive-element-to-noninteractive-role': [ 'error', {
+        tr: [ 'none', 'presentation' ],
+        canvas: [ 'img' ],
+    } ],
+    'jsx-a11y/no-noninteractive-element-interactions': [ 'error', {
+        handlers: [ 'onClick', 'onError', 'onLoad', 'onMouseDown', 'onMouseUp', 'onKeyPress', 'onKeyDown', 'onKeyUp' ],
+        alert: [ 'onKeyUp', 'onKeyDown', 'onKeyPress' ],
+        body: [ 'onError', 'onLoad' ],
+        dialog: [ 'onKeyUp', 'onKeyDown', 'onKeyPress' ],
+        iframe: [ 'onError', 'onLoad' ],
+        img: [ 'onError', 'onLoad' ],
+    } ],
+    'jsx-a11y/no-noninteractive-element-to-interactive-role': [ 'error', {
+        ul: [ 'listbox', 'menu', 'menubar', 'radiogroup', 'tablist', 'tree', 'treegrid' ],
+        ol: [ 'listbox', 'menu', 'menubar', 'radiogroup', 'tablist', 'tree', 'treegrid' ],
+        li: [ 'menuitem', 'option', 'row', 'tab', 'treeitem' ],
+        table: [ 'grid' ],
+        td: [ 'gridcell' ],
+        fieldset: [ 'radiogroup', 'presentation' ],
+    } ],
+    'jsx-a11y/no-noninteractive-tabindex': [ 'error', {
+        tags: [],
+        roles: [ 'tabpanel' ],
+        allowExpressionValues: true,
+    } ],
+    'jsx-a11y/no-redundant-roles': 'error',
+    'jsx-a11y/no-static-element-interactions': [ 'error', {
+        allowExpressionValues: true,
+        handlers: [ 'onClick', 'onMouseDown', 'onMouseUp', 'onKeyPress', 'onKeyDown', 'onKeyUp' ],
+    } ],
+    'jsx-a11y/role-has-required-aria-props': 'error',
+    'jsx-a11y/role-supports-aria-props': 'error',
+    'jsx-a11y/scope': 'error',
+    'jsx-a11y/tabindex-no-positive': 'error',
+};
+
+/**
+ * Get ESLint config for imports check
+ * @returns {Promise<import('eslint').Linter.FlatConfig[]>}
+ */
+export async function createEslintJsxA11yConfig() {
+    return [
+        {
+            files: [ '**/*.jsx' ],
+            languageOptions: {
+                parserOptions: {
+                    ecmaFeatures: { jsx: true },
+                },
+            },
+            plugins: { 'jsx-a11y': jsxa11y },
+            rules: rules,
+        },
+        {
+            files: [ '**/*.tsx' ],
+            languageOptions: {
+                parserOptions: {
+                    ecmaFeatures: { jsx: true },
+                    jsxPragma: null, // for @typescript/eslint-parser
+                },
+            },
+            plugins: { 'jsx-a11y': jsxa11y },
+            rules: rules,
+        },
+    ];
+}