@origin-1/eslint-config 0.14.0 → 0.16.0

package/index.js

@@ -13,11 +13,6 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const patch_tslib_js_1 = __importDefault(require("./patch-tslib.js"));
-(0, patch_tslib_js_1.default)(require);
 __exportStar(require("./lib/create-config.js"), exports);
 __exportStar(require("./lib/normalize-version.js"), exports);

package/lib/create-config.d.ts

@@ -1,19 +1,23 @@
 import { type JSVersion, type TSVersion } from './normalize-version.js';
 import type { Linter } from 'eslint';
-export interface ConfigData extends Linter.HasRules {
+export interface ConfigData extends Linter.HasRules, LanguageConfigData {
     env?: Linter.BaseConfig['env'];
     extends?: string | string[] | undefined;
     globals?: Linter.BaseConfig['globals'];
-    jsVersion?: JSVersion | undefined;
     parser?: string | undefined;
     parserOptions?: Linter.ParserOptions | undefined;
     plugins?: string[] | undefined;
     processor?: string | undefined;
-    tsVersion?: TSVersion | undefined;
 }
 export interface ConfigDataWithFiles extends ConfigData {
     excludedFiles?: string | string[] | undefined;
     files: string | string[];
 }
+export type FlatConfigData = Linter.FlatConfig & LanguageConfigData;
+export interface LanguageConfigData {
+    jsVersion?: JSVersion | undefined;
+    tsVersion?: TSVersion | undefined;
+}
 export declare function createBaseConfig(configData: ConfigData): Linter.BaseConfig;
 export declare function createConfig(...configDataList: ConfigDataWithFiles[]): Linter.Config;
+export declare function createFlatConfig(...configDataList: FlatConfigData[]): Promise<Linter.FlatConfig[]>;

package/lib/create-config.js

@@ -3,10 +3,65 @@ 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;
+exports.createFlatConfig = exports.createConfig = exports.createBaseConfig = void 0;
 const normalize_version_js_1 = require("./normalize-version.js");
 const rules_js_1 = require("./rules.js");
 const semver_1 = __importDefault(require("semver"));
+function addLanguageRules(lang, jsVersion, tsVersion, rules, rulePrefixes) {
+    const setOverrideRule = (ruleKey, ruleLangSettings) => {
+        const ruleEntry = isVersionedList(ruleLangSettings) ?
+            findRuleEntry(ruleLangSettings, jsVersion, tsVersion) : ruleLangSettings;
+        rules[ruleKey] = cloneRuleEntry(ruleEntry);
+    };
+    for (const [ruleName, ruleSettings] of ruleSettingsFor(rules_js_1.RULES[rules_js_1.UNIQUE])) {
+        if (isJSTSEntry(ruleSettings)) {
+            const ruleLangSettings = ruleSettings[lang];
+            setOverrideRule(ruleName, ruleLangSettings);
+        }
+    }
+    for (const [ruleName, ruleSettings] of ruleSettingsFor(rules_js_1.RULES[rules_js_1.HYBRID])) {
+        if (isRuleEntry(ruleSettings)) {
+            if (lang === 'ts') {
+                rules[ruleName] = 'off';
+                const typescriptESLintRuleKey = (0, rules_js_1.getRuleKey)('@typescript-eslint', ruleName);
+                rules[typescriptESLintRuleKey] = cloneRuleEntry(ruleSettings);
+            }
+            else
+                rules[ruleName] = cloneRuleEntry(ruleSettings);
+        }
+        if (isJSTSEntry(ruleSettings)) {
+            if (lang === 'ts') {
+                rules[ruleName] = 'off';
+                const typescriptESLintRuleKey = (0, rules_js_1.getRuleKey)('@typescript-eslint', ruleName);
+                setOverrideRule(typescriptESLintRuleKey, ruleSettings.ts);
+            }
+            else
+                setOverrideRule(ruleName, ruleSettings.js);
+        }
+    }
+    for (const [pluginName, pluginSettings] of Object.entries(rules_js_1.RULES)) {
+        if (isPluginSettingsForLang(pluginSettings)) {
+            if (lang !== pluginSettings[rules_js_1.FOR_LANG])
+                continue;
+            const rulePrefix = (0, rules_js_1.getRulePrefix)(pluginName);
+            rulePrefixes.push(rulePrefix);
+            for (const [ruleName, ruleSettings] of ruleSettingsFor(pluginSettings)) {
+                const ruleKey = (0, rules_js_1.getRuleKey)(rulePrefix, ruleName);
+                setOverrideRule(ruleKey, ruleSettings);
+            }
+        }
+        else {
+            const rulePrefix = (0, rules_js_1.getRulePrefix)(pluginName);
+            for (const [ruleName, ruleSettings] of ruleSettingsFor(pluginSettings)) {
+                if (isJSTSEntry(ruleSettings)) {
+                    const ruleKey = (0, rules_js_1.getRuleKey)(rulePrefix, ruleName);
+                    const ruleLangSettings = ruleSettings[lang];
+                    setOverrideRule(ruleKey, ruleLangSettings);
+                }
+            }
+        }
+    }
+}
 function cloneRuleEntry(ruleEntry) {
     return structuredClone(ruleEntry);
 }
@@ -68,64 +123,11 @@ function createBaseOverride(configData) {
     Object.assign(env, configData.env);
     const parserOptions = { ecmaVersion, ...configData.parserOptions };
     const rules = {};
+    if (lang != null)
+        addLanguageRules(lang, jsVersion, tsVersion, rules, plugins);
     const baseOverride = { env, parserOptions, plugins, rules };
     if (parser != null)
         baseOverride.parser = parser;
-    if (lang != null) {
-        const setOverrideRule = (ruleKey, ruleLangSettings) => {
-            const ruleEntry = isVersionedList(ruleLangSettings) ?
-                findRuleEntry(ruleLangSettings, jsVersion, tsVersion) : ruleLangSettings;
-            rules[ruleKey] = cloneRuleEntry(ruleEntry);
-        };
-        for (const [ruleName, ruleSettings] of ruleSettingsFor(rules_js_1.RULES[rules_js_1.UNIQUE])) {
-            if (isJSTSEntry(ruleSettings)) {
-                const ruleLangSettings = ruleSettings[lang];
-                setOverrideRule(ruleName, ruleLangSettings);
-            }
-        }
-        for (const [ruleName, ruleSettings] of ruleSettingsFor(rules_js_1.RULES[rules_js_1.HYBRID])) {
-            if (isRuleEntry(ruleSettings)) {
-                if (lang === 'ts') {
-                    rules[ruleName] = 'off';
-                    const typescriptESLintRuleKey = (0, rules_js_1.getRuleKey)('@typescript-eslint', ruleName);
-                    rules[typescriptESLintRuleKey] = cloneRuleEntry(ruleSettings);
-                }
-                else
-                    rules[ruleName] = cloneRuleEntry(ruleSettings);
-            }
-            if (isJSTSEntry(ruleSettings)) {
-                if (lang === 'ts') {
-                    rules[ruleName] = 'off';
-                    const typescriptESLintRuleKey = (0, rules_js_1.getRuleKey)('@typescript-eslint', ruleName);
-                    setOverrideRule(typescriptESLintRuleKey, ruleSettings.ts);
-                }
-                else
-                    setOverrideRule(ruleName, ruleSettings.js);
-            }
-        }
-        for (const [pluginName, pluginSettings] of Object.entries(rules_js_1.RULES)) {
-            if (isPluginSettingsForLang(pluginSettings)) {
-                if (lang !== pluginSettings[rules_js_1.FOR_LANG])
-                    continue;
-                const rulePrefix = (0, rules_js_1.getRulePrefix)(pluginName);
-                plugins.push(rulePrefix);
-                for (const [ruleName, ruleSettings] of ruleSettingsFor(pluginSettings)) {
-                    const ruleKey = (0, rules_js_1.getRuleKey)(rulePrefix, ruleName);
-                    setOverrideRule(ruleKey, ruleSettings);
-                }
-            }
-            else {
-                const rulePrefix = (0, rules_js_1.getRulePrefix)(pluginName);
-                for (const [ruleName, ruleSettings] of ruleSettingsFor(pluginSettings)) {
-                    if (isJSTSEntry(ruleSettings)) {
-                        const ruleKey = (0, rules_js_1.getRuleKey)(rulePrefix, ruleName);
-                        const ruleLangSettings = ruleSettings[lang];
-                        setOverrideRule(ruleKey, ruleLangSettings);
-                    }
-                }
-            }
-        }
-    }
     Object.assign(rules, configData.rules);
     return baseOverride;
 }
@@ -166,23 +168,69 @@ function createConfig(...configDataList) {
     return config;
 }
 exports.createConfig = createConfig;
+async function createFlatConfig(...configDataList) {
+    const promises = configDataList.map(createSingleFlatConfig);
+    return Promise.all(promises);
+}
+exports.createFlatConfig = createFlatConfig;
 function createOverride(configData) {
     const baseOverride = createBaseOverride(configData);
     const { excludedFiles, extends: extends_, files, globals, processor } = configData;
     const override = { ...baseOverride, excludedFiles, extends: extends_, files, globals, processor };
     return override;
 }
+async function createSingleFlatConfig(configData) {
+    const { jsVersion: rawJSVersion, tsVersion: rawTSVersion, ...config } = configData;
+    if (rawJSVersion != null && rawTSVersion != null)
+        throw TypeError('`jsVersion` and `tsVersion` cannot be specified at the same time');
+    const lang = getLanguage(configData);
+    if (lang != null) {
+        const languageOptions = { ...config.languageOptions };
+        let { ecmaVersion, parser } = languageOptions;
+        let jsVersion;
+        let tsVersion;
+        switch (lang) {
+            case 'js':
+                jsVersion = (0, normalize_version_js_1.normalizeJSVersion)(rawJSVersion);
+                ecmaVersion ??= jsVersion;
+                parser ??= await importParser('espree');
+                break;
+            case 'ts':
+                tsVersion = (0, normalize_version_js_1.normalizeTSVersion)(rawTSVersion);
+                ecmaVersion ??= 'latest';
+                parser ??= await importParser('@typescript-eslint/parser');
+                break;
+        }
+        languageOptions.ecmaVersion = ecmaVersion;
+        languageOptions.parser = parser;
+        const linterOptions = { ...config.linterOptions };
+        linterOptions.reportUnusedDisableDirectives ??= true;
+        const plugins = {};
+        const { plugins: rulePrefixes, rules } = createCommonEntries();
+        addLanguageRules(lang, jsVersion, tsVersion, rules, rulePrefixes);
+        const pluginPromises = rulePrefixes.map(importPlugin);
+        const pluginList = await Promise.all(pluginPromises);
+        rulePrefixes.forEach((rulePrefix, index) => {
+            plugins[rulePrefix] = pluginList[index];
+        });
+        config.languageOptions = languageOptions;
+        config.linterOptions = linterOptions;
+        config.plugins = Object.assign(plugins, config.plugins);
+        config.rules = Object.assign(rules, config.rules);
+    }
+    return config;
+}
 function findRuleEntry(versionedList, jsVersion, tsVersion) {
     let index = versionedList.length;
     while (index--) {
         const { minVersion, ruleEntry } = versionedList[index];
         switch (typeof minVersion) {
             case 'number':
-                if (jsVersion >= minVersion)
+                if (jsVersion != null && jsVersion >= minVersion)
                     return ruleEntry;
                 break;
             case 'string':
-                if (tsVersion === 'latest' || semver_1.default.gte(tsVersion, minVersion))
+                if (tsVersion != null && (tsVersion === 'latest' || semver_1.default.gte(tsVersion, minVersion)))
                     return ruleEntry;
                 break;
             default:
@@ -196,6 +244,15 @@ function getLanguage(configData) {
     if (configData.jsVersion != null)
         return 'js';
 }
+async function importParser(parserName) {
+    const parser = await import(parserName);
+    return parser;
+}
+async function importPlugin(pluginName) {
+    const pkgName = pluginName.startsWith('@') ? `${pluginName}/eslint-plugin` : `eslint-plugin-${pluginName}`;
+    const { default: plugin } = await import(pkgName);
+    return plugin;
+}
 function isJSTSEntry(ruleSettings) {
     return typeof ruleSettings === 'object' && 'js' in ruleSettings && 'ts' in ruleSettings;
 }

package/lib/rules.js

@@ -87,7 +87,6 @@ exports.RULES = {
         'block-scoped-var': 'off',
         'camelcase': 'off',
         'capitalized-comments': 'off',
-        'class-methods-use-this': 'off',
         'complexity': 'off',
         'consistent-return': 'off',
         'consistent-this': 'off',
@@ -162,7 +161,7 @@ exports.RULES = {
         'no-restricted-properties': 'off',
         'no-restricted-syntax': ['error'],
         'no-return-assign': ['error', 'always'],
-        'no-return-await': ['error'],
+        'no-return-await': 'off',
         'no-script-url': ['error'],
         'no-sequences': ['error'],
         'no-shadow-restricted-names': ['error'],
@@ -266,6 +265,7 @@ exports.RULES = {
         'no-loss-of-precision': ['error'],
         'no-unused-vars': beforeJSOrElse(2019, ['error', { ignoreRestSiblings: true, vars: 'local' }], ['error', { caughtErrors: 'all', ignoreRestSiblings: true, vars: 'local' }]),
         'no-use-before-define': 'off',
+        'class-methods-use-this': 'off',
         'default-param-last': 'off',
         'dot-notation': ['error'],
         'init-declarations': 'off',
@@ -351,7 +351,7 @@ exports.RULES = {
         'no-import-type-side-effects': 'off',
         'no-invalid-void-type': 'off',
         'no-misused-new': ['error'],
-        'no-misused-promises': ['error'],
+        'no-misused-promises': ['error', { checksVoidReturn: false }],
         'no-mixed-enums': ['error'],
         'no-non-null-asserted-nullish-coalescing': ['error'],
         'no-non-null-asserted-optional-chain': ['error'],
@@ -396,7 +396,6 @@ exports.RULES = {
         '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'],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@origin-1/eslint-config",
-  "version": "0.14.0",
+  "version": "0.16.0",
   "description": "ESLint configuration generator with Origin₁ presets",
   "homepage": "https://github.com/origin-1/eslint-config#readme",
   "license": "ISC",
@@ -12,18 +12,17 @@
   },
   "peerDependencies": {
     "@origin-1/eslint-plugin": ">=0.13",
-    "@typescript-eslint/eslint-plugin": "^5.58",
-    "@typescript-eslint/parser": "^5.58",
+    "@typescript-eslint/eslint-plugin": "^6.2.0",
+    "@typescript-eslint/parser": "^6.2.0",
     "eslint": "^8.37",
-    "eslint-plugin-n": "15"
+    "eslint-plugin-n": "16"
   },
   "engines": {
-    "node": ">=18.1"
+    "node": ">=18"
   },
   "exports": {
     ".": "./index.js",
     "./no-parser": "./no-parser.js",
-    "./package.json": "./package.json",
-    "./patch-tslib": "./patch-tslib.js"
+    "./package.json": "./package.json"
   }
 }

package/patch-tslib.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const node_module_1 = require("node:module");
-function patchTslib(require) {
-    let tsutilsPath;
-    const { resolve } = require;
-    try {
-        tsutilsPath = resolve('tsutils');
-    }
-    catch {
-        return;
-    }
-    const tsutilsRequire = (0, node_module_1.createRequire)(tsutilsPath);
-    const originalGlobal = globalThis.global;
-    globalThis.global = {};
-    try {
-        tsutilsRequire('tslib');
-    }
-    finally {
-        globalThis.global = originalGlobal;
-    }
-}
-exports.default = patchTslib;