@darksheep/eslint 4.1.3

package/src/plugins/typescript.js

@@ -0,0 +1,87 @@
+import { getTypescriptFiles } from '../utilities/eslint-files.js';
+import { getPackageJson } from '../utilities/package.js';
+
+/**
+ * @template {Object} T
+ * @param {T | { default: T }} target The module to optionally check for default exports
+ * @returns {T}
+ */
+function idef(target) {
+    return /** @type {{ default: T }} */ (target)?.default ?? target;
+}
+
+/**
+ * Get ESLint config for the typescript plugin
+ * @param {import('node:url').URL} root root url
+ * @returns {Promise<import('eslint').Linter.FlatConfig[]>}
+ */
+export async function createEslintTypescriptConfig(root) {
+    const packageJson = await getPackageJson(root, 'typescript');
+
+    // Typescript not installed
+    if (packageJson == null) {
+        return [];
+    }
+
+    const typescriptParser = idef(await import('@typescript-eslint/parser'));
+    const typescriptPlugin = idef(await import('@typescript-eslint/eslint-plugin'));
+
+    return [ {
+        files: await getTypescriptFiles(),
+        languageOptions: {
+            parser: /** @type {*} */ (typescriptParser),
+            sourceType: 'module',
+            parserOptions: {
+                warnOnUnsupportedTypeScriptVersion: false,
+            },
+        },
+        plugins: {
+            '@typescript-eslint': /** @type {*} */ (typescriptPlugin),
+        },
+        rules: {
+            // Rules that fight with typescript
+            'constructor-super': 'off',
+            'getter-return': 'off',
+            'no-const-assign': 'off',
+            'no-dupe-args': 'off',
+            'no-dupe-class-members': 'off',
+            'no-dupe-keys': 'off',
+            'no-func-assign': 'off',
+            'no-import-assign': 'off',
+            'no-new-symbol': 'off',
+            'no-obj-calls': 'off',
+            'no-redeclare': 'off',
+            'no-setter-return': 'off',
+            'no-this-before-super': 'off',
+            'no-undef': 'off',
+            'no-unreachable': 'off',
+            'no-unsafe-negation': 'off',
+            'no-array-constructor': 'off',
+            'no-loss-of-precision': 'off',
+
+            // Rules that prevert some commmon ts issues
+            'no-var': 'error',
+            'prefer-const': 'error',
+            'prefer-rest-params': 'error',
+            'prefer-spread': 'error',
+
+            // ts eslint recommended
+            '@typescript-eslint/ban-ts-comment': 'error',
+            '@typescript-eslint/ban-types': 'error',
+            '@typescript-eslint/no-array-constructor': 'error',
+            '@typescript-eslint/no-duplicate-enum-values': 'error',
+            '@typescript-eslint/no-explicit-any': 'error',
+            '@typescript-eslint/no-extra-non-null-assertion': 'error',
+            '@typescript-eslint/no-loss-of-precision': 'error',
+            '@typescript-eslint/no-misused-new': 'error',
+            '@typescript-eslint/no-namespace': [ 'error', { allowDeclarations: true } ],
+            '@typescript-eslint/no-non-null-asserted-optional-chain': 'error',
+            '@typescript-eslint/no-this-alias': 'error',
+            '@typescript-eslint/no-unnecessary-type-constraint': 'error',
+            '@typescript-eslint/no-unsafe-declaration-merging': 'error',
+            '@typescript-eslint/no-var-requires': 'error',
+            '@typescript-eslint/prefer-as-const': 'error',
+            '@typescript-eslint/triple-slash-reference': 'error',
+        },
+    } ];
+}

package/src/plugins/unicorn.js

@@ -0,0 +1,58 @@
+import { makeCompat } from '../utilities/make-compat.js';
+
+/**
+ * Get ESLint config for the unicorn plugin
+ * @param {import('node:url').URL} root root url
+ * @returns {Promise<import('eslint').Linter.FlatConfig[]>}
+ */
+export async function createEslintUnicornConfig(root) {
+    return makeCompat(root).config({
+        plugins: [ 'unicorn' ],
+        rules: {
+            /*
+             * Sanity checks
+            */
+            'unicorn/better-regex': 'off',
+            'unicorn/no-empty-file': 'warn',
+            'unicorn/no-unsafe-regex': 'off',
+            'unicorn/no-zero-fractions': 'error',
+            'unicorn/no-unreadable-array-destructuring': 'error',
+            'unicorn/no-useless-undefined': 'error',
+            'unicorn/no-abusive-eslint-disable': 'warn',
+
+            /*
+             *  Error management
+             */
+            'unicorn/catch-error-name': 'error',
+            'unicorn/custom-error-definition': 'off',
+            'unicorn/throw-new-error': 'error',
+            'unicorn/error-message': 'error',
+            'unicorn/prefer-type-error': 'error',
+
+            // This breaks babel
+            'unicorn/prefer-optional-catch-binding': 'off',
+
+            /*
+             *  Best practice
+             */
+            'unicorn/consistent-destructuring': 'off',
+            'unicorn/escape-case': 'error',
+            'unicorn/filename-case': 'off',
+            'unicorn/no-console-spaces': 'error',
+            'unicorn/no-keyword-prefix': 'warn',
+            'unicorn/no-nested-ternary': 'warn',
+            'unicorn/no-new-array': 'error',
+            'unicorn/no-useless-promise-resolve-reject': 'error',
+            'unicorn/no-useless-switch-case': 'error',
+            'unicorn/prefer-add-event-listener': 'error',
+            'unicorn/prefer-default-parameters': 'error',
+            'unicorn/prefer-export-from': 'warn',
+            'unicorn/prefer-native-coercion-functions': 'error',
+            'unicorn/prefer-node-protocol': 'warn',
+            'unicorn/prefer-reflect-apply': 'warn',
+            'unicorn/prefer-regexp-test': 'warn',
+            'unicorn/require-array-join-separator': 'error',
+            'unicorn/text-encoding-identifier-case': 'error',
+        },
+    });
+}

package/src/plugins/unused-imports.js

@@ -0,0 +1,52 @@
+import unused from 'eslint-plugin-unused-imports';
+
+import {
+    getModuleFiles,
+    getTypescriptFiles,
+} from '../utilities/eslint-files.js';
+
+/**
+ * Get ESLint config for the unused import plugin
+ * @param {import('node:url').URL} root root url
+ * @returns {Promise<import('eslint').Linter.FlatConfig[]>}
+ */
+export async function createEslintUnusedImportsConfig(root) {
+    return [
+        {
+            files: await getModuleFiles(root),
+            plugins: { 'unused-imports': unused },
+            rules: {
+                'no-unused-vars': 'off',
+                '@typescript-eslint/no-unused-vars': 'off',
+
+                'unused-imports/no-unused-imports': 'error',
+                'unused-imports/no-unused-vars': [
+                    'error', {
+                        argsIgnorePattern: '^_',
+                        varsIgnorePattern: '^_',
+                        args: 'after-used',
+                        vars: 'local',
+                    },
+                ],
+            },
+        },
+        {
+            files: await getTypescriptFiles(),
+            plugins: { 'unused-imports': unused },
+            rules: {
+                'no-unused-vars': 'off',
+                '@typescript-eslint/no-unused-vars': 'off',
+
+                'unused-imports/no-unused-imports-ts': 'error',
+                'unused-imports/no-unused-vars-ts': [
+                    'error', {
+                        argsIgnorePattern: '^_',
+                        varsIgnorePattern: '^_',
+                        args: 'after-used',
+                        vars: 'local',
+                    },
+                ],
+            },
+        },
+    ];
+}

package/src/types.d.ts

@@ -0,0 +1,118 @@
+/* eslint no-duplicate-imports: 0 */
+
+type WithRequired<T, K extends keyof T> = T & { [P in K]-?: T[P] };
+
+declare module '@eslint-community/eslint-plugin-eslint-comments' {
+    import type { ESLint } from 'eslint';
+    export default {} as ESLint.Plugin;
+}
+
+declare module 'eslint-plugin-import' {
+    import type { ESLint, Linter } from 'eslint';
+    export default {} as {
+        rules: Required<ESLint.Plugin['rules']>;
+        configs: {
+            'recommended': {
+                plugins: Required<ESLint.ConfigData['plugins']>;
+                rules: Linter.RulesRecord;
+                parserOptions: Required<ESLint.ConfigData['parserOptions']>;
+            };
+            'errors': {
+                plugins: Required<ESLint.ConfigData['plugins']>;
+                rules: Linter.RulesRecord;
+            };
+            'warnings': {
+                plugins: Required<ESLint.ConfigData['plugins']>;
+                rules: Linter.RulesRecord;
+            };
+            'stage-0': {
+                plugins: Required<ESLint.ConfigData['plugins']>;
+                rules: Linter.RulesRecord;
+            };
+            'react': {
+                settings: Required<ESLint.ConfigData['settings']>;
+                parserOptions: Required<ESLint.ConfigData['parserOptions']>;
+            };
+            'react-native': {
+                settings: Required<ESLint.ConfigData['settings']>;
+            };
+            'electron': {
+                settings: Required<ESLint.ConfigData['settings']>;
+            };
+            'typescript': {
+                settings: Required<ESLint.ConfigData['settings']>;
+                rules: Linter.RulesRecord;
+            };
+        };
+    };
+}
+
+declare module 'eslint-plugin-jest' {
+    import type { ESLint } from 'eslint';
+    export default {} as WithRequired<ESLint.Plugin, 'environments'>;
+}
+
+declare module 'eslint-plugin-jsdoc' {
+    import type { ESLint } from 'eslint';
+    export default {} as WithRequired<ESLint.Plugin, 'environments'>;
+}
+
+declare module '@stylistic/eslint-plugin' {
+    import type { ESLint } from 'eslint';
+    export default {} as WithRequired<ESLint.Plugin, 'environments'>;
+}
+
+declare module 'eslint-plugin-jsx-a11y' {
+    import type { ESLint } from 'eslint';
+    export default {} as ESLint.Plugin;
+}
+
+declare module 'eslint-plugin-promise' {
+    import type { ESLint } from 'eslint';
+    export default {} as {
+        rules: Required<ESLint.Plugin['rules']>;
+        configs: {
+            recommended: WithRequired<ESLint.ConfigData, 'plugins' | 'rules'>;
+        };
+    };
+}
+
+declare module 'eslint-plugin-react' {
+    import type { ESLint } from 'eslint';
+    export default {} as ESLint.Plugin;
+}
+
+declare module 'eslint-plugin-security' {
+    import type { ESLint } from 'eslint';
+    export default {} as {
+        rules: Required<ESLint.Plugin['rules']>;
+        configs: {
+            recommended: WithRequired<ESLint.ConfigData, 'plugins' | 'rules'>;
+        };
+    };
+}
+
+declare module 'eslint-plugin-unused-imports' {
+    import type { ESLint } from 'eslint';
+    export default {} as ESLint.Plugin;
+}
+
+declare module 'eslint-plugin-n' {
+    import type { ESLint, Linter } from 'eslint';
+    export default {} as {
+        meta: {
+            name: string;
+            version: string;
+        };
+        rules: Required<ESLint.Plugin['rules']>;
+        configs: {
+            'recommended-module': ESLint.ConfigData;
+            'recommended-script': ESLint.ConfigData;
+            'recommended': ESLint.ConfigData;
+            'flat/recommended-module': Linter.FlatConfig;
+            'flat/recommended-script': Linter.FlatConfig;
+            'flat/recommended': Linter.FlatConfig;
+            'flat/mixed-esm-and-cjs': Linter.FlatConfig;
+        };
+    };
+}

package/src/utilities/editorconfig.js

@@ -0,0 +1,210 @@
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { parseBuffer } from 'editorconfig';
+import { findUp } from './filesystem.js';
+import { expandGlob } from './expand-glob.js';
+
+/**
+ * @typedef {Object} RuleSet
+ * @property {string} EOL end of line
+ * @property {string} LF line feed
+ * @property {string} TRAIL trailing spaces
+ * @property {string} INDENT indent size
+ * @property {string} [INDENT_BINARY] indent binary ops size
+ */
+
+/**
+ * @param {import('editorconfig').SectionBody} input Raw editor config converted into an object
+ * @param {RuleSet} RULES The rules used to create eslint rules options
+ * @returns {import('eslint').Linter.RulesRecord}
+ */
+function convert(input, RULES) {
+    /** @type {import('eslint').Linter.RulesRecord} */
+    const output = {};
+
+    if (input?.end_of_line === 'lf') {
+        output[RULES.LF] = [ 'error', 'unix' ];
+    }
+
+    if (input?.end_of_line === 'crlf') {
+        output[RULES.LF] = [ 'error', 'windows' ];
+    }
+
+    if (input?.trim_trailing_whitespace === 'true') {
+        output[RULES.TRAIL] = 'error';
+    }
+
+    if (input?.trim_trailing_whitespace === 'false') {
+        output[RULES.TRAIL] = 'off';
+    }
+
+    if (input?.insert_final_newline === 'true') {
+        output[RULES.EOL] = [ 'error', 'always' ];
+    }
+
+    if (input?.insert_final_newline === 'false') {
+        output[RULES.EOL] = [ 'error', 'never' ];
+    }
+
+    if (input?.indent_style === 'space') {
+        const size = Number.parseInt(input?.indent_size ?? 4, 10);
+        output[RULES.INDENT] = [ 'error', size, { SwitchCase: 1 } ];
+        if (RULES.INDENT_BINARY != null) {
+            output[RULES.INDENT_BINARY] = [ 'error', size ];
+        }
+    }
+
+    if (input?.indent_style === 'tab') {
+        output[RULES.INDENT] = [ 'error', 'tab', { SwitchCase: 1 } ];
+        if (RULES.INDENT_BINARY != null) {
+            output[RULES.INDENT_BINARY] = [ 'error', 'tab' ];
+        }
+    }
+
+    return output;
+}
+
+/** @type {[string[], RuleSet][]} */
+const extToRules = [
+    [
+        [ '.js', '.cjs', '.mjs', '.ts', '.cts', '.mts', '.jsx', '.tsx' ],
+        {
+            EOL: 'style/eol-last',
+            LF: 'style/linebreak-style',
+            TRAIL: 'style/no-trailing-spaces',
+            INDENT: 'style/indent',
+            INDENT_BINARY: 'style/indent-binary-ops',
+        },
+    ],
+    [
+        [ '.json', '.jsonc', '.json5' ], {
+            EOL: 'style/eol-last',
+            LF: 'style/linebreak-style',
+            TRAIL: 'style/no-trailing-spaces',
+            INDENT: 'jsonc/indent',
+        },
+    ],
+];
+
+/**
+ * Do any of the provided files match a js file?
+ * @param {string[]} files The list of files to check
+ * @param {string[]} extensions The allowed file extensions
+ * @returns {string[]}
+ */
+function filterMatchingFiles(files, extensions) {
+    return files.filter((file) => {
+        if (file.endsWith('*')) {
+            return true;
+        }
+
+        for (const extension of extensions) {
+            if (file.endsWith(extension)) {
+                return true;
+            }
+        }
+        return false;
+    });
+}
+
+/**
+ * Do any of the provided files match a js file?
+ * @param {string[] | null | undefined} one The list of files to check
+ * @param {string[] | null | undefined} two The allowed file extensions
+ * @returns {boolean}
+ */
+function equal(one, two) {
+    if (one == null && two == null) {
+        return true;
+    }
+    if (one == null || two == null) {
+        return false;
+    }
+
+    if (
+        Array.isArray(one) === false ||
+        Array.isArray(two) === false ||
+        one.length !== two.length
+    ) {
+        return false;
+    }
+
+    for (const element of one) {
+        if (two.includes(element) === false) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+/**
+ * @param {import('eslint').Linter.FlatConfig[]} configs  [description]
+ * @param {import('eslint').Linter.FlatConfig} config  [description]
+ */
+function addOrMergeConfig(configs, config) {
+    for (const previous of configs) {
+        if (equal(
+            /** @type {string[]} */ (previous.files),
+            /** @type {string[]} */ (config.files),
+        )) {
+            previous.rules = {
+                ...previous.rules,
+                ...config.rules,
+            };
+
+            return;
+        }
+    }
+    configs.push(config);
+}
+
+/**
+ * @param {import('node:url').URL} root root url
+ * @returns {Promise<import('eslint').Linter.FlatConfig[]>}
+ */
+export async function createEditorOverrides(root) {
+    const eslintConfigPath = resolve(fileURLToPath(root), 'eslint.config.js');
+    const path = await findUp(eslintConfigPath, '.editorconfig');
+    if (path == null) {
+        return [];
+    }
+
+    const editorconfig = parseBuffer(await readFile(path));
+
+    /** @type {import('eslint').Linter.FlatConfig[]} */
+    const configs = [];
+    for (const [ name, body ] of editorconfig) {
+        if (name === null) {
+            continue;
+        }
+
+        const allFiles = expandGlob(name);
+        if (allFiles == null) {
+            continue;
+        }
+
+        for (const [ extensions, rules ] of extToRules) {
+            const files = filterMatchingFiles(allFiles, extensions);
+            if (files.length === 0) {
+                continue;
+            }
+
+            if (files.includes('*')) {
+                addOrMergeConfig(configs, {
+                    files: extensions.map((extension) => `**/*${extension}`),
+                    rules: convert(body, rules),
+                });
+            } else {
+                addOrMergeConfig(configs, {
+                    files: files.map((file) => `**/${file}`),
+                    rules: convert(body, rules),
+                });
+            }
+        }
+    }
+
+    return configs;
+}

package/src/utilities/eslint-files.js

@@ -0,0 +1,65 @@
+import { getPackageJson } from './package.js';
+import { expandGlob } from './expand-glob.js';
+
+/**
+ * @param {string[]} files  [description]
+ * @param {string} type  [description]
+ * @param {string} target  [description]
+ * @returns {string[]}
+ */
+function getFiles(files, type, target) {
+    if (type === target) {
+        return [ '**/*.js', '**/*.jsx', ...files ];
+    }
+
+    return files;
+}
+
+/**
+ * Get a list of globs for common js files
+ * @returns {Promise<string[]>}
+ */
+export async function getJsonFiles() {
+    return [ '**/*.json', '**/*.jsonc', '**/*.json5' ];
+}
+
+/**
+ * Get a list of globs for common js files
+ * @param {import('node:url').URL} root root url
+ * @returns {Promise<string[]>}
+ */
+export async function getCommonFiles(root) {
+    const { type = 'commonjs' } = await getPackageJson(root) ?? {};
+
+    return getFiles([ '**/*.cjs' ], type, 'commonjs');
+}
+
+/**
+ * Get a list of globs for module files
+ * @param {import('node:url').URL} root root url
+ * @returns {Promise<string[]>}
+ */
+export async function getModuleFiles(root) {
+    const { type = 'commonjs' } = await getPackageJson(root) ?? {};
+    return getFiles([ '**/*.mjs' ], type, 'module');
+}
+
+/**
+ * Get a list of globs for typescript files
+ * @returns {Promise<string[]>}
+ */
+export async function getTypescriptFiles() {
+    return [ '**/*.ts', '**/*.tsx' ];
+}
+
+/**
+ * Get a list of possible example files
+ * @returns {Promise<string[]>}
+ */
+export async function getExampleFiles() {
+    return [
+        ...expandGlob('**/example.{ts,js,tsx,jsx,mts,cts,mjs,cjs}'),
+        ...expandGlob('**/{example,examples}/*'),
+        ...expandGlob('**/{example,examples}/**/*'),
+    ];
+}

package/src/utilities/expand-glob.js

@@ -0,0 +1,49 @@
+const globNumRegex = /\{\d+\.\.\d+\}/;
+const globEachRegex = /\{[\w.-]+(?:,[\w.-]+)+\}/;
+
+/**
+ * @param {string} input The glob to process
+ * @returns {string[]}
+ */
+export function expandGlob(input) {
+    const globNumMatch = input.match(globNumRegex);
+    if (typeof globNumMatch?.index === 'number') {
+        const first = input.slice(0, globNumMatch.index);
+        const each = globNumMatch[0];
+        const last = input.slice(globNumMatch.index + each.length);
+
+        const [ a, b ] = each
+            .slice(1, -1)
+            .split('..')
+            .map((number) => Number.parseInt(number, 10));
+
+        const start = a > b ? b : a;
+        const end = a < b ? b : a;
+
+        const output = [];
+        for (let i = start; i <= end; i++) {
+            output.push(`${first}${i}${last}`);
+        }
+
+        return output.map(expandGlob).flat();
+    }
+
+    const globEachMatch = input.match(globEachRegex);
+    if (typeof globEachMatch?.index === 'number') {
+        const first = input.slice(0, globEachMatch.index);
+        const each = globEachMatch[0];
+        const last = input.slice(globEachMatch.index + each.length);
+
+        const output = each
+            .slice(1, -1).split(',')
+            .map((part) => `${first}${part}${last}`);
+
+        if (output.length > 1) {
+            return output.map(expandGlob).flat();
+        }
+
+        return output;
+    }
+
+    return [ input ];
+}