@origin-1/eslint-config 0.0.0

package/LICENSE

@@ -0,0 +1,13 @@
+Copyright Origin₁ (https://github.com/origin-1)
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,9 @@
+# @origin-1/eslint-config · [![npm version][npm badge]][npm url]
+
+ESLint configuration generator with [origin-1](https://github.com/origin-1) presets.
+
+[npm badge]:
+https://badge.fury.io/js/@origin-1%2Feslint-config.svg
+
+[npm url]:
+https://www.npmjs.com/package/@origin-1/eslint-config

package/index.d.ts

@@ -0,0 +1 @@
+export * from './lib/create-config';

package/index.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('./lib/create-config');

package/lib/create-config.d.ts

@@ -0,0 +1,16 @@
+import type { JSVersion } from './rules.js';
+import type { Linter } from 'eslint';
+export interface ConfigData extends Linter.HasRules {
+    env?: Record<string, boolean> | undefined;
+    globals?: Record<string, boolean | 'readonly' | 'readable' | 'writable' | 'writeable'> | undefined;
+    jsVersion?: JSVersion | undefined;
+    parserOptions?: Linter.ParserOptions | undefined;
+    plugins?: string[] | undefined;
+    tsVersion?: string | undefined;
+}
+export interface ConfigDataWithFiles extends ConfigData {
+    excludedFiles?: string | string[] | undefined;
+    files: string | string[];
+}
+export declare function createBaseConfig(configData: ConfigData): Linter.BaseConfig;
+export declare function createConfig(...configDataList: ConfigDataWithFiles[]): Linter.Config;

package/lib/create-config.js

@@ -0,0 +1,171 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConfig = exports.createBaseConfig = void 0;
+const rules_js_1 = require("./rules.js");
+const semver_1 = __importDefault(require("semver"));
+function cloneRuleEntry(ruleEntry) {
+    return structuredClone(ruleEntry);
+}
+function createBaseConfig(configData) {
+    const { plugins, rules } = createCommonEntries();
+    const baseOverride = createBaseOverride(configData);
+    const { env, parser, parserOptions, plugins: overridePlugins = [], rules: overrideRules } = baseOverride;
+    plugins.push(...overridePlugins);
+    Object.assign(rules, overrideRules);
+    const baseConfig = { env, parser, parserOptions, plugins, reportUnusedDisableDirectives: true, rules };
+    return baseConfig;
+}
+exports.createBaseConfig = createBaseConfig;
+function createBaseOverride(configData) {
+    const { plugins } = configData;
+    const lang = getLanguage(configData);
+    let ecmaVersion;
+    let envKey;
+    let parser;
+    const jsVersion = getJSVersion(configData);
+    if (jsVersion === 2015)
+        envKey = 'es6';
+    else if (jsVersion > 2015)
+        envKey = `es${jsVersion}`;
+    const tsVersion = getTSVersion(configData);
+    if (lang === 'ts') {
+        ecmaVersion = 'latest';
+        parser = '@typescript-eslint/parser';
+    }
+    else {
+        ecmaVersion = jsVersion;
+        parser = 'espree';
+    }
+    const env = envKey ? { [envKey]: true } : {};
+    Object.assign(env, configData.env);
+    const parserOptions = { ecmaVersion, ...configData.parserOptions };
+    const rules = {};
+    const setOverrideRule = (ruleName, ruleLangSettings) => {
+        if (ruleLangSettings != null) {
+            const ruleEntry = isVersionedList(ruleLangSettings) ?
+                findRuleEntry(ruleLangSettings, jsVersion, tsVersion) : ruleLangSettings;
+            if (ruleEntry != null)
+                rules[ruleName] = cloneRuleEntry(ruleEntry);
+        }
+    };
+    for (const [ruleName, ruleDef] of Object.entries(rules_js_1.RULES[rules_js_1.UNIQUE])) {
+        if (isJSTSEntry(ruleDef)) {
+            const ruleLangSettings = ruleDef[lang];
+            setOverrideRule(ruleName, ruleLangSettings);
+        }
+    }
+    for (const [ruleName, ruleDef] of Object.entries(rules_js_1.RULES[rules_js_1.HYBRID])) {
+        if (isRuleEntry(ruleDef)) {
+            if (lang === 'ts') {
+                rules[ruleName] = 'off';
+                rules[`@typescript-eslint/${ruleName}`] = cloneRuleEntry(ruleDef);
+            }
+            else
+                rules[ruleName] = cloneRuleEntry(ruleDef);
+        }
+        if (isJSTSEntry(ruleDef)) {
+            if (lang === 'ts') {
+                rules[ruleName] = 'off';
+                setOverrideRule(`@typescript-eslint/${ruleName}`, ruleDef.ts);
+            }
+            else
+                setOverrideRule(ruleName, ruleDef.js);
+        }
+    }
+    for (const [pluginName, definedPluginRules] of Object.entries(rules_js_1.RULES)) {
+        const rulePrefix = (0, rules_js_1.getRulePrefix)(pluginName);
+        for (const [ruleName, ruleDef] of Object.entries(definedPluginRules)) {
+            if (isJSTSEntry(ruleDef)) {
+                const ruleLangSettings = ruleDef[lang];
+                setOverrideRule(`${rulePrefix}/${ruleName}`, ruleLangSettings);
+            }
+        }
+    }
+    Object.assign(rules, configData.rules);
+    const baseOverride = { env, parser, parserOptions, plugins, rules };
+    return baseOverride;
+}
+function createCommonEntries() {
+    const plugins = [];
+    const rules = {};
+    for (const [ruleName, ruleDef] of Object.entries(rules_js_1.RULES[rules_js_1.UNIQUE])) {
+        if (isRuleEntry(ruleDef))
+            rules[ruleName] = cloneRuleEntry(ruleDef);
+    }
+    for (const [pluginName, definedPluginRules] of Object.entries(rules_js_1.RULES)) {
+        const rulePrefix = (0, rules_js_1.getRulePrefix)(pluginName);
+        plugins.push(rulePrefix);
+        for (const [ruleName, ruleDef] of Object.entries(definedPluginRules)) {
+            if (isRuleEntry(ruleDef))
+                rules[`${rulePrefix}/${ruleName}`] = cloneRuleEntry(ruleDef);
+        }
+    }
+    const commonEntries = { plugins, rules };
+    return commonEntries;
+}
+function createConfig(...configDataList) {
+    const { plugins, rules } = createCommonEntries();
+    const overrides = configDataList.map(createOverride);
+    const config = {
+        overrides,
+        parser: '@origin-1/eslint-config/no-parser',
+        plugins,
+        reportUnusedDisableDirectives: true,
+        root: true,
+        rules,
+    };
+    return config;
+}
+exports.createConfig = createConfig;
+function createOverride(configData) {
+    const baseOverride = createBaseOverride(configData);
+    const { excludedFiles, files } = configData;
+    const override = { ...baseOverride, excludedFiles, files };
+    return override;
+}
+function findRuleEntry(versionedList, jsVersion, tsVersion) {
+    let index = versionedList.length;
+    while (index--) {
+        const { minVersion, ruleEntry } = versionedList[index];
+        switch (typeof minVersion) {
+            case 'number':
+                if (jsVersion >= minVersion)
+                    return ruleEntry;
+                break;
+            case 'string':
+                if (tsVersion === 'latest' || semver_1.default.gte(tsVersion, minVersion))
+                    return ruleEntry;
+                break;
+            default:
+                return ruleEntry;
+        }
+    }
+}
+function getJSVersion(configData) {
+    const { jsVersion } = configData;
+    return Number.isInteger(jsVersion) ? jsVersion : 5;
+}
+function getLanguage(configData) {
+    return configData.tsVersion == null ? 'js' : 'ts';
+}
+function getTSVersion(configData) {
+    const { tsVersion } = configData;
+    if (tsVersion != null) {
+        const cleanVersion = semver_1.default.clean(tsVersion);
+        if (cleanVersion != null)
+            return cleanVersion;
+    }
+    return 'latest';
+}
+function isJSTSEntry(ruleSettings) {
+    return typeof ruleSettings === 'object' && 'js' in ruleSettings && 'ts' in ruleSettings;
+}
+function isRuleEntry(ruleSettings) {
+    return typeof ruleSettings === 'string' || Array.isArray(ruleSettings);
+}
+function isVersionedList(ruleLangSettings) {
+    return Array.isArray(ruleLangSettings) && 'versioned' in ruleLangSettings;
+}

package/lib/rules.js

@@ -0,0 +1,479 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULES = exports.getRulePrefix = exports.HYBRID = exports.UNIQUE = void 0;
+exports.UNIQUE = Symbol('Unique built-in rules');
+exports.HYBRID = Symbol('Hybrid rules');
+function beforeOrElse(version, before, else_) {
+    const beforeEntry = { minVersion: undefined, ruleEntry: before };
+    const elseEntry = { minVersion: version, ruleEntry: else_ };
+    const array = [beforeEntry, elseEntry];
+    const versionedList = Object.assign(array, { versioned: true });
+    return versionedList;
+}
+function getRulePrefix(pluginName) {
+    const rulePrefix = pluginName.replace(/^eslint-plugin-|\/eslint-plugin$/, '');
+    return rulePrefix;
+}
+exports.getRulePrefix = getRulePrefix;
+function jsts(jsEntry, tsEntry) {
+    return { js: jsEntry, ts: tsEntry };
+}
+function tsOnly(input) {
+    const output = Object.fromEntries(Object
+        .entries(input)
+        .map(([ruleName, tsEntry]) => [ruleName, jsts(undefined, tsEntry)]));
+    return output;
+}
+exports.RULES = {
+    [exports.UNIQUE]: {
+        // Problem
+        'array-callback-return': 'off',
+        'constructor-super': 'error',
+        'for-direction': 'error',
+        'getter-return': 'error',
+        'no-async-promise-executor': 'error',
+        'no-await-in-loop': 'off',
+        'no-class-assign': 'error',
+        'no-compare-neg-zero': 'error',
+        'no-cond-assign': 'off',
+        'no-const-assign': 'error',
+        'no-constant-binary-expression': 'error',
+        'no-constant-condition': 'error',
+        'no-constructor-return': 'off',
+        'no-control-regex': 'off',
+        'no-debugger': 'error',
+        'no-dupe-args': 'error',
+        'no-dupe-else-if': 'error',
+        'no-dupe-keys': 'error',
+        'no-duplicate-case': 'error',
+        // TypeScript has type only imports.
+        'no-duplicate-imports': jsts('error', 'off'),
+        'no-empty-character-class': 'error',
+        'no-empty-pattern': 'error',
+        'no-ex-assign': 'error',
+        'no-fallthrough': 'error',
+        'no-func-assign': 'error',
+        'no-import-assign': 'error',
+        'no-inner-declarations': 'error',
+        'no-invalid-regexp': 'error',
+        'no-irregular-whitespace': 'error',
+        'no-misleading-character-class': 'error',
+        'no-new-symbol': 'error',
+        'no-obj-calls': 'error',
+        'no-promise-executor-return': 'error',
+        'no-prototype-builtins': 'off',
+        'no-self-assign': 'error',
+        'no-self-compare': 'off',
+        'no-setter-return': 'error',
+        'no-sparse-arrays': 'off',
+        'no-template-curly-in-string': 'off',
+        'no-this-before-super': 'error',
+        'no-undef': jsts('error', 'off'),
+        'no-unexpected-multiline': 'off',
+        'no-unmodified-loop-condition': 'off',
+        'no-unreachable': 'error',
+        'no-unreachable-loop': 'error',
+        'no-unsafe-finally': 'error',
+        'no-unsafe-negation': 'error',
+        'no-unsafe-optional-chaining': 'error',
+        'no-unused-private-class-members': 'error',
+        'no-useless-backreference': 'error',
+        'require-atomic-updates': 'off',
+        'use-isnan': ['error', { enforceForSwitchCase: true }],
+        'valid-typeof': 'error',
+        // Suggestion
+        'accessor-pairs': ['error', { enforceForClassMembers: true }],
+        'arrow-body-style': 'error',
+        'block-scoped-var': 'off',
+        'camelcase': 'off',
+        'capitalized-comments': 'off',
+        'class-methods-use-this': 'off',
+        'complexity': 'off',
+        'consistent-return': 'off',
+        'consistent-this': 'off',
+        'curly': ['error', 'multi-or-nest'],
+        'default-case': 'off',
+        'default-case-last': 'off',
+        'eqeqeq': ['error', 'allow-null'],
+        'func-name-matching': 'off',
+        'func-names': ['error', 'never'],
+        'func-style': 'off',
+        'grouped-accessor-pairs': ['error', 'getBeforeSet'],
+        'guard-for-in': 'off',
+        'id-denylist': 'off',
+        'id-length': 'off',
+        'id-match': 'off',
+        'max-classes-per-file': 'off',
+        'max-depth': 'off',
+        'max-lines': 'off',
+        'max-lines-per-function': 'off',
+        'max-nested-callbacks': 'off',
+        'max-params': 'off',
+        'max-statements': 'off',
+        'multiline-comment-style': 'off',
+        'new-cap': ['error', { capIsNew: false }],
+        'no-alert': 'error',
+        'no-bitwise': 'off',
+        'no-caller': 'error',
+        'no-case-declarations': 'error',
+        'no-confusing-arrow': 'off',
+        'no-console': 'off',
+        'no-continue': 'off',
+        'no-delete-var': 'error',
+        'no-div-regex': 'error',
+        'no-else-return': 'error',
+        'no-empty': ['error', { allowEmptyCatch: true }],
+        'no-eq-null': 'off',
+        'no-eval': 'off',
+        'no-extend-native': 'error',
+        'no-extra-bind': 'error',
+        'no-extra-boolean-cast': 'error',
+        'no-extra-label': 'error',
+        'no-floating-decimal': 'error',
+        'no-global-assign': 'error',
+        'no-implicit-coercion': 'off',
+        'no-implicit-globals': 'off',
+        'no-inline-comments': 'off',
+        'no-iterator': 'error',
+        'no-label-var': 'error',
+        'no-labels': ['error', { allowLoop: true, allowSwitch: true }],
+        'no-lone-blocks': 'error',
+        'no-lonely-if': 'off',
+        'no-mixed-operators': 'off',
+        'no-multi-assign': 'off',
+        'no-multi-str': 'error',
+        'no-negated-condition': 'off',
+        'no-nested-ternary': 'off',
+        'no-new': 'off',
+        'no-new-func': 'off',
+        'no-new-object': 'error',
+        'no-new-wrappers': 'error',
+        'no-nonoctal-decimal-escape': 'error',
+        'no-octal': 'error',
+        'no-octal-escape': 'error',
+        'no-param-reassign': 'off',
+        'no-plusplus': 'off',
+        'no-proto': 'error',
+        'no-regex-spaces': 'off',
+        'no-restricted-exports': 'off',
+        'no-restricted-globals': 'error',
+        'no-restricted-properties': 'off',
+        'no-restricted-syntax': 'error',
+        'no-return-assign': ['error', 'always'],
+        'no-return-await': 'error',
+        'no-script-url': 'error',
+        'no-sequences': 'error',
+        'no-shadow-restricted-names': 'error',
+        'no-ternary': 'off',
+        'no-undef-init': 'error',
+        'no-undefined': 'off',
+        'no-underscore-dangle': 'off',
+        'no-unneeded-ternary': 'error',
+        'no-unused-labels': 'error',
+        'no-useless-call': 'error',
+        'no-useless-catch': 'error',
+        'no-useless-computed-key': 'error',
+        'no-useless-concat': 'error',
+        'no-useless-escape': 'error',
+        'no-useless-rename': 'error',
+        'no-useless-return': 'error',
+        'no-var': 'error',
+        'no-void': 'off',
+        'no-warning-comments': 'off',
+        'no-with': 'error',
+        'object-shorthand': 'error',
+        'one-var': ['error', 'never'],
+        'one-var-declaration-per-line': 'error',
+        'operator-assignment': 'error',
+        'prefer-arrow-callback': 'error',
+        'prefer-const': ['error', { ignoreReadBeforeAssign: true }],
+        'prefer-destructuring': 'error',
+        // Do not prefer the exponentiation operator in TypeScript, because that would result in
+        // getting the value of Math.pow upon every evaluation in ES5 transpiled code.
+        'prefer-exponentiation-operator': jsts('error', 'off'),
+        'prefer-named-capture-group': 'off',
+        'prefer-numeric-literals': 'error',
+        'prefer-object-has-own': 'error',
+        'prefer-object-spread': 'off',
+        'prefer-promise-reject-errors': 'off',
+        'prefer-regex-literals': 'off',
+        'prefer-rest-params': 'error',
+        'prefer-spread': 'error',
+        'prefer-template': 'error',
+        'quote-props': 'off',
+        'radix': 'error',
+        'require-unicode-regexp': 'off',
+        'require-yield': 'error',
+        'sort-imports': ['error', { ignoreDeclarationSort: true }],
+        'sort-keys': 'off',
+        'sort-vars': 'off',
+        'spaced-comment': 'error',
+        'strict': jsts(['error', 'global'], 'off'),
+        'symbol-description': 'off',
+        'vars-on-top': 'off',
+        'yoda': 'error',
+        // Layout
+        'array-bracket-newline': ['error', 'consistent'],
+        'array-bracket-spacing': 'error',
+        'array-element-newline': 'off',
+        'arrow-parens': ['error', 'as-needed'],
+        'arrow-spacing': 'error',
+        'block-spacing': 'error',
+        'comma-style': ['error', 'last', { exceptions: { ArrayExpression: true } }],
+        'computed-property-spacing': 'error',
+        'dot-location': ['error', 'property'],
+        'eol-last': 'error',
+        'function-call-argument-newline': ['error', 'consistent'],
+        'function-paren-newline': ['error', 'consistent'],
+        'generator-star-spacing': ['error', 'both'],
+        'implicit-arrow-linebreak': 'off',
+        'jsx-quotes': 'error',
+        'key-spacing': ['error', { mode: 'minimum' }],
+        'line-comment-position': 'off',
+        'linebreak-style': 'error',
+        // In TypeScript files, lines-around-comment doesn't work well at the start of a block.
+        'lines-around-comment': jsts(['error', { allowBlockStart: true, allowObjectStart: true }], 'off'),
+        'max-len': ['error', { code: 100 }],
+        'max-statements-per-line': 'error',
+        'multiline-ternary': 'off',
+        'new-parens': 'error',
+        'newline-per-chained-call': 'off',
+        'no-mixed-spaces-and-tabs': 'off',
+        'no-multi-spaces': 'off',
+        'no-multiple-empty-lines': ['error', { max: 1, maxBOF: 0, maxEOF: 0 }],
+        'no-tabs': 'error',
+        'no-trailing-spaces': 'error',
+        'no-whitespace-before-property': 'error',
+        'nonblock-statement-body-position': 'off',
+        'object-curly-newline': 'off',
+        'object-property-newline': ['error', { allowMultiplePropertiesPerLine: true }],
+        'operator-linebreak': ['error', 'after'],
+        'padded-blocks': ['error', 'never'],
+        'rest-spread-spacing': 'error',
+        'semi-spacing': 'error',
+        'semi-style': 'error',
+        'space-in-parens': 'error',
+        'space-unary-ops': 'error',
+        'switch-colon-spacing': ['error', { after: true, before: false }],
+        'template-curly-spacing': 'error',
+        'template-tag-spacing': ['error', 'always'],
+        'unicode-bom': 'error',
+        'wrap-iife': 'off',
+        'wrap-regex': 'off',
+        'yield-star-spacing': ['error', 'both'],
+    },
+    [exports.HYBRID]: {
+        // Problem
+        'no-dupe-class-members': 'error',
+        'no-loss-of-precision': 'error',
+        'no-unused-vars': jsts(beforeOrElse(2019, ['error', { ignoreRestSiblings: true, vars: 'local' }], ['error', { caughtErrors: 'all', ignoreRestSiblings: true, vars: 'local' }]), ['error', { caughtErrors: 'all', ignoreRestSiblings: true, vars: 'local' }]),
+        'no-use-before-define': 'off',
+        // Suggestion
+        'default-param-last': 'off',
+        'dot-notation': 'error',
+        'init-declarations': 'off',
+        'no-array-constructor': 'error',
+        'no-empty-function': 'off',
+        'no-extra-semi': 'error',
+        'no-implied-eval': 'off',
+        'no-invalid-this': 'off',
+        'no-loop-func': 'error',
+        'no-magic-numbers': 'off',
+        // Redeclarations are acceptable in TypeScript.
+        'no-redeclare': jsts(['error', { builtinGlobals: true }], 'off'),
+        'no-restricted-imports': 'off',
+        'no-shadow': 'off',
+        'no-throw-literal': 'error',
+        'no-unused-expressions': 'error',
+        'no-useless-constructor': 'error',
+        'require-await': 'error',
+        // Layout
+        'brace-style': ['error', 'allman'],
+        'comma-dangle': ['error', 'always-multiline'],
+        'comma-spacing': 'error',
+        'func-call-spacing': 'off',
+        // typescript-eslint rule is flawed.
+        'indent': jsts([
+            'error',
+            4,
+            {
+                CallExpression: { arguments: 'first' },
+                FunctionDeclaration: { parameters: 'first' },
+                FunctionExpression: { parameters: 'first' },
+                MemberExpression: 0,
+                VariableDeclarator: 0,
+                ignoredNodes: [
+                    'ArrowFunctionExpression',
+                    'ClassDeclaration[superClass]',
+                    'ConditionalExpression',
+                    'ImportDeclaration',
+                ],
+            },
+        ], 'off'),
+        'keyword-spacing': 'error',
+        'lines-between-class-members': 'off',
+        'no-extra-parens': 'error',
+        'object-curly-spacing': ['error', 'always'],
+        'padding-line-between-statements': [
+            'error',
+            {
+                blankLine: 'always',
+                prev: '*',
+                next: ['class', 'directive', 'export', 'function', 'import'],
+            },
+            {
+                blankLine: 'always',
+                prev: ['class', 'directive', 'export', 'function', 'import'],
+                next: '*',
+            },
+            { blankLine: 'any', prev: 'export', next: 'export' },
+            { blankLine: 'any', prev: 'import', next: 'import' },
+        ],
+        'quotes': ['error', 'single'],
+        'semi': 'error',
+        'space-before-blocks': 'error',
+        'space-before-function-paren': 'off',
+        // typescript-eslint rule does not handle well colons (":") in mapped types.
+        'space-infix-ops': jsts('error', 'off'),
+    },
+    '@typescript-eslint/eslint-plugin': tsOnly({
+        // Problem
+        'await-thenable': 'error',
+        'ban-ts-comment': 'off',
+        'class-literal-property-style': ['error', 'getters'],
+        'explicit-function-return-type': ['error', { allowTypedFunctionExpressions: false }],
+        'explicit-member-accessibility': 'error',
+        'explicit-module-boundary-types': 'error',
+        'no-confusing-non-null-assertion': 'error',
+        'no-confusing-void-expression': 'off',
+        'no-duplicate-enum-values': 'off',
+        'no-extra-non-null-assertion': 'error',
+        'no-floating-promises': 'error',
+        'no-for-in-array': 'error',
+        'no-invalid-void-type': 'off',
+        'no-misused-new': 'error',
+        'no-misused-promises': 'error',
+        'no-non-null-asserted-nullish-coalescing': 'error',
+        'no-non-null-asserted-optional-chain': 'error',
+        'no-non-null-assertion': 'off',
+        'no-require-imports': 'error',
+        'no-unsafe-argument': 'error',
+        'no-unsafe-assignment': 'error',
+        'no-unsafe-call': 'off',
+        'no-unsafe-member-access': 'error',
+        'no-unsafe-return': 'error',
+        'no-var-requires': 'error',
+        'parameter-properties': ['error', { prefer: 'parameter-property' }],
+        'prefer-reduce-type-parameter': 'error',
+        'prefer-ts-expect-error': 'error',
+        'require-array-sort-compare': 'off',
+        'restrict-plus-operands': 'off',
+        'restrict-template-expressions': 'off',
+        'return-await': 'error',
+        'unbound-method': 'off',
+        // Suggestion
+        'adjacent-overload-signatures': 'error',
+        'array-type': 'error',
+        'ban-tslint-comment': 'error',
+        'ban-types': 'off',
+        'consistent-generic-constructors': 'error',
+        'consistent-indexed-object-style': 'error',
+        'consistent-type-assertions': 'error',
+        'consistent-type-definitions': ['error', 'interface'],
+        'consistent-type-exports': 'error',
+        'consistent-type-imports': beforeOrElse('3.8.0', ['error', { prefer: 'no-type-imports' }], 'error'),
+        'member-delimiter-style': ['error', { singleline: { requireLast: true } }],
+        'member-ordering': 'error',
+        'method-signature-style': 'off',
+        'naming-convention': 'off',
+        'no-base-to-string': 'error',
+        'no-dynamic-delete': 'off',
+        'no-empty-interface': ['error', { allowSingleExtends: true }],
+        'no-explicit-any': 'off',
+        'no-extraneous-class': ['error', { allowConstructorOnly: true }],
+        'no-inferrable-types': 'error',
+        'no-meaningless-void-operator': ['error', { checkNever: true }],
+        'no-namespace': 'off',
+        'no-redundant-type-constituents': 'error',
+        'no-this-alias': 'off',
+        'no-type-alias': 'off',
+        'no-unnecessary-boolean-literal-compare': 'error',
+        'no-unnecessary-condition': 'error',
+        'no-unnecessary-qualifier': 'error',
+        'no-unnecessary-type-arguments': 'error',
+        'no-unnecessary-type-assertion': 'error',
+        'no-unnecessary-type-constraint': 'error',
+        'no-useless-empty-export': 'error',
+        'non-nullable-type-assertion-style': 'error',
+        'prefer-as-const': 'error',
+        'prefer-enum-initializers': 'off',
+        'prefer-for-of': 'error',
+        // https://github.com/typescript-eslint/typescript-eslint/issues/454
+        'prefer-function-type': 'off',
+        'prefer-includes': 'error',
+        'prefer-literal-enum-member': 'off',
+        'prefer-namespace-keyword': 'off',
+        'prefer-nullish-coalescing': 'error',
+        'prefer-optional-chain': 'error',
+        'prefer-readonly': 'error',
+        'prefer-readonly-parameter-types': 'off',
+        'prefer-regexp-exec': 'error',
+        'prefer-return-this-type': 'error',
+        'prefer-string-starts-ends-with': 'error',
+        'promise-function-async': ['error', { allowAny: true }],
+        'sort-type-union-intersection-members': 'off',
+        'strict-boolean-expressions': 'off',
+        'switch-exhaustiveness-check': 'error',
+        'triple-slash-reference': ['error', { lib: 'never' }],
+        'typedef': 'error',
+        'unified-signatures': 'error',
+        // Layout
+        'type-annotation-spacing': 'error',
+    }),
+    '@fasttime/eslint-plugin': {
+        // Layout
+        'nice-space-before-function-paren': 'error',
+        'no-spaces-in-call-expression': 'error',
+    },
+    'eslint-plugin-n': {
+        // Problem
+        'no-callback-literal': 'off',
+        'no-deprecated-api': 'error',
+        'no-exports-assign': 'error',
+        'no-extraneous-import': jsts('error', 'off'),
+        'no-extraneous-require': 'error',
+        'no-missing-import': 'off',
+        'no-missing-require': 'off',
+        'no-unpublished-bin': 'error',
+        'no-unpublished-import': 'error',
+        'no-unpublished-require': 'off',
+        'no-unsupported-features/es-builtins': 'off',
+        'no-unsupported-features/es-syntax': 'off',
+        'no-unsupported-features/node-builtins': 'off',
+        'process-exit-as-throw': 'error',
+        'shebang': 'off',
+        // Suggestion
+        'callback-return': 'off',
+        'exports-style': 'off',
+        'file-extension-in-import': 'off',
+        'global-require': 'off',
+        'handle-callback-err': 'error',
+        'no-mixed-requires': 'error',
+        'no-new-require': 'error',
+        'no-path-concat': 'error',
+        'no-process-env': 'off',
+        'no-process-exit': 'off',
+        'no-restricted-import': 'error',
+        'no-restricted-require': 'error',
+        'no-sync': 'off',
+        'prefer-global/buffer': 'error',
+        'prefer-global/console': 'error',
+        'prefer-global/process': 'error',
+        'prefer-global/text-decoder': 'error',
+        'prefer-global/text-encoder': 'error',
+        'prefer-global/url': 'error',
+        'prefer-global/url-search-params': 'error',
+        'prefer-promises/dns': 'error',
+        'prefer-promises/fs': 'off',
+    },
+};

package/no-parser.js

@@ -0,0 +1,7 @@
+'use strict';
+
+module.exports.parse =
+() =>
+{
+    throw Error('missing configuration for this file');
+};

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@origin-1/eslint-config",
+  "version": "0.0.0",
+  "description": "ESLint configuration generator with origin-1 presets",
+  "license": "ISC",
+  "author": "Francesco Trotta <ft@fasttime.org> (https://github.com/fasttime)",
+  "dependencies": {
+    "@fasttime/eslint-plugin": "0.6",
+    "@types/eslint": "8",
+    "@typescript-eslint/eslint-plugin": "5.30",
+    "@typescript-eslint/parser": "5.30",
+    "eslint-plugin-n": "15.2",
+    "semver": "7"
+  },
+  "peerDependencies": {
+    "eslint": "8"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "exports": {
+    ".": "./index.js",
+    "./no-parser": "./no-parser.js",
+    "./package.json": "./package.json"
+  }
+}