@the-stranger/eslint-plugin 2.0.2 → 2.1.0

package/src/lib/utils/optional-import-resolver.js

@@ -0,0 +1,168 @@
+import { getModuleRoot } from './get-module-root.js';
+export class ImportResolver {
+    allowSubpathMatch;
+    cache;
+    useCache;
+    constructor(options) {
+        this.useCache = options?.cache ?? true;
+        this.allowSubpathMatch = options?.allowSubpathMatch ?? true;
+        this.cache = new Map();
+    }
+    clear(specifier) {
+        if (specifier) {
+            this.cache.delete(specifier);
+        }
+        else {
+            this.cache.clear();
+        }
+    }
+    has(specifier) {
+        return this.cache.has(specifier);
+    }
+    async import(specifier) {
+        if (!this.useCache) {
+            return this.loadModule(specifier);
+        }
+        const cached = this.cache.get(specifier);
+        if (cached) {
+            return cached;
+        }
+        try {
+            const pending = this.loadModule(specifier);
+            this.cache.set(specifier, pending);
+            return pending;
+        }
+        catch (error) {
+            this.cache.delete(specifier);
+            throw error;
+        }
+    }
+    async importDefault(specifier) {
+        const result = await this.import(specifier);
+        if (!result.success) {
+            return;
+        }
+        return (result.module?.default ?? result.module);
+    }
+    async requireImport(specifier) {
+        const result = await this.import(specifier);
+        if (result.success) {
+            return result.module;
+        }
+        throw new Error(`Required dependency "${specifier}" is not installed.`);
+    }
+    /**
+     * Narrow unknown to a Node-like error shape.
+     * @param value the value
+     * @returns the error-like object, or undefined if the value is not an object of the expected shape
+     */
+    asNodeLikeError(value) {
+        if (typeof value !== 'object' || value === null) {
+            return;
+        }
+        const record = value;
+        const code = typeof record['code'] === 'string' ? record['code'] : undefined;
+        const message = typeof record['message'] === 'string' ? record['message'] : undefined;
+        return { code, message };
+    }
+    /**
+     * Extract the target from CommonJS-style error messages like:
+     * - Cannot find module 'pg'
+     * @param message the error message
+     * @returns the target, or undefined if the message doesn't match the expected pattern
+     */
+    extractCannotFindModuleTarget(message) {
+        const match = message.match(/Cannot find module ['"]([^'"]+)['"]/i);
+        return match?.[1];
+    }
+    /**
+     * Extract the quoted missing target from error messages like:
+     * - Cannot find package 'pg' imported from ...
+     * - Cannot find module 'pg' imported from ...
+     * @param message the error message
+     * @returns the target, or undefined if the message doesn't match the expected pattern
+     */
+    extractQuotedMissingTarget(message) {
+        const match = message.match(/Cannot find (?:package|module) ['"]([^'"]+)['"]/i);
+        return match?.[1];
+    }
+    /**
+     * Detect whether an import error means that the *requested* specifier is missing, as opposed to one of its transitive dependencies. This is necessarily heuristic because Node error shapes/messages vary by version.
+     * @param error the captured error
+     * @param specifier the value that was imported
+     * @returns true if the error is caused by the requested module; false otherwise
+     */
+    isRequestedModuleMissing(error, specifier) {
+        const err = this.asNodeLikeError(error);
+        if (!err) {
+            return false;
+        }
+        // Common Node loader errors for missing modules in ESM/CJS contexts.
+        const { code, message } = err;
+        if ((code !== 'ERR_MODULE_NOT_FOUND' && code !== 'MODULE_NOT_FOUND') || !message) {
+            return false;
+        }
+        const requestedPackageName = getModuleRoot(specifier);
+        // ESM-style message often includes:
+        //   Cannot find package 'pg' imported from ...
+        //
+        // or:
+        //   Cannot find module 'pg' imported from ...
+        //
+        // If the missing target in the message matches the requested package (or exact
+        // specifier where appropriate), we consider that a true "missing module".
+        const quotedTarget = this.extractQuotedMissingTarget(message);
+        if (quotedTarget) {
+            if (quotedTarget === specifier) {
+                return true;
+            }
+            if (quotedTarget === requestedPackageName) {
+                return true;
+            }
+            if (this.isSameOrSubpath(quotedTarget, requestedPackageName)) {
+                return true;
+            }
+            return false;
+        }
+        // Older/CommonJS-style message may look like:
+        //   Cannot find module 'pg'
+        const cjsTarget = this.extractCannotFindModuleTarget(message);
+        if (cjsTarget) {
+            if (cjsTarget === specifier) {
+                return true;
+            }
+            if (cjsTarget === requestedPackageName) {
+                return true;
+            }
+            if (this.isSameOrSubpath(cjsTarget, requestedPackageName)) {
+                return true;
+            }
+            return false;
+        }
+        return false;
+    }
+    /**
+     * Determine whether the target is the requested module, or a subpath of it.
+     * @param target the identified target specifier
+     * @param requested the requested module specifier
+     * @returns true if {@link target} is a subpath of {@link requested}; false otherwise
+     * @example
+     * isSubpathOfModule('@scope/pkg/subpath', '@scope/pkg') // -> true
+     */
+    isSameOrSubpath(target, requested) {
+        return (this.allowSubpathMatch &&
+            (target === requested || target.startsWith(`${requested}/`)));
+    }
+    async loadModule(specifier) {
+        try {
+            const mod = (await import(specifier));
+            return { module: mod, success: true };
+        }
+        catch (error) {
+            if (this.isRequestedModuleMissing(error, specifier)) {
+                return { module: undefined, success: false };
+            }
+            throw error;
+        }
+    }
+}

package/src/lib/utils/optional-import.d.ts

@@ -0,0 +1,47 @@
+export declare class OptionalImport<TModule = unknown> {
+    readonly moduleSpecifier: string;
+    private matchSubpaths?;
+    private missing?;
+    private module?;
+    private readonly moduleRoot;
+    private nodeRequire?;
+    constructor(specifier: string, options?: ImportResolverOptions);
+    /**
+     * Import the module if it can be resolved.
+     * @returns the module
+     */
+    load(): Promise<TModule | undefined>;
+    loadDefault(): Promise<TModule | undefined>;
+    require(): TModule | undefined;
+    resolve(): string | undefined;
+    /**
+     * Extract the target specifier from an error message.
+     * @param message the error message
+     * @returns the assumed target, or undefined if the message doesn't match any of the expected patterns
+     */
+    private static extractMissingTarget;
+    /**
+     * Detect whether an import error indicates that the requested specifier is missing, as opposed to one of its transitive dependencies. This is necessarily heuristic because Node error shapes/messages vary by version.
+     * @param error the captured error
+     * @returns true if the error is caused by attempting to import this module; false otherwise
+     */
+    private isMissingImportError;
+    /**
+     * Determine whether the target is the requested module, or a subpath of it.
+     * @param target the identified target specifier
+     * @returns true if {@link target} is a subpath of this module; false otherwise
+     */
+    private isSameOrSubpath;
+}
+export interface ImportResolverOptions {
+    /**
+     * Treat package subpaths as belonging to the same package.
+     * @default true
+     */
+    allowSubpathMatch?: boolean;
+    /**
+     * Cache resolved promises/results for each specifier.
+     * @default true
+     */
+    cache?: boolean;
+}

package/src/lib/utils/optional-import.js

@@ -0,0 +1,142 @@
+import { createRequire } from 'node:module';
+import { getModuleRoot } from './get-module-root.js';
+export class OptionalImport {
+    moduleSpecifier;
+    matchSubpaths;
+    missing;
+    module;
+    moduleRoot;
+    nodeRequire;
+    constructor(specifier, options) {
+        this.moduleSpecifier = specifier;
+        this.moduleRoot = getModuleRoot(this.moduleSpecifier);
+        this.matchSubpaths = options?.allowSubpathMatch;
+    }
+    /**
+     * Import the module if it can be resolved.
+     * @returns the module
+     */
+    async load() {
+        if (this.module !== undefined || this.missing) {
+            return this.module;
+        }
+        try {
+            const m = (await import(this.moduleSpecifier));
+            this.module = m;
+            this.missing = false;
+            return this.module;
+        }
+        catch (error) {
+            if (this.isMissingImportError(error)) {
+                this.missing = true;
+                return;
+            }
+            // if (!Error.isError())
+            throw error;
+        }
+    }
+    async loadDefault() {
+        const m = (await this.load());
+        if (m !== undefined) {
+            return (m?.default ?? m);
+        }
+        return;
+    }
+    require() {
+        if (this.module !== undefined || this.missing) {
+            return this.module;
+        }
+        if (!this.nodeRequire) {
+            this.nodeRequire = createRequire(import.meta.url);
+        }
+        try {
+            const m = this.nodeRequire(this.moduleSpecifier);
+            this.module = m;
+            this.missing = false;
+            return this.module;
+        }
+        catch (error) {
+            if (this.isMissingImportError(error)) {
+                this.missing = true;
+                return;
+            }
+            throw error;
+        }
+    }
+    resolve() {
+        if (this.missing) {
+            return;
+        }
+        if (!this.nodeRequire) {
+            this.nodeRequire = createRequire(import.meta.url);
+        }
+        try {
+            return this.nodeRequire.resolve(this.moduleSpecifier);
+        }
+        catch (error) {
+            if (this.isMissingImportError(error)) {
+                this.missing = true;
+                return;
+            }
+            throw error;
+        }
+    }
+    /**
+     * Extract the target specifier from an error message.
+     * @param message the error message
+     * @returns the assumed target, or undefined if the message doesn't match any of the expected patterns
+     */
+    static extractMissingTarget(message) {
+        const esmExp = /Cannot find (?:package|module) ['"]([^'"]+)['"]/i;
+        const cjsExp = /Cannot find module ['"]([^'"]+)['"]/i;
+        if (esmExp.test(message)) {
+            return esmExp.exec(message)?.[1];
+        }
+        else if (cjsExp.test(message)) {
+            return cjsExp.exec(message)?.[1];
+        }
+        else {
+            return;
+        }
+    }
+    /**
+     * Detect whether an import error indicates that the requested specifier is missing, as opposed to one of its transitive dependencies. This is necessarily heuristic because Node error shapes/messages vary by version.
+     * @param error the captured error
+     * @returns true if the error is caused by attempting to import this module; false otherwise
+     */
+    isMissingImportError(error) {
+        if (this.missing !== undefined) {
+            return this.missing;
+        }
+        if (!isNodeError(error)) {
+            return;
+        }
+        const { code, message } = error;
+        if ((code !== 'ERR_MODULE_NOT_FOUND' && code !== 'MODULE_NOT_FOUND') || !message) {
+            return false;
+        }
+        const target = OptionalImport.extractMissingTarget(message);
+        if (target) {
+            return this.isSameOrSubpath(target);
+        }
+        return false;
+    }
+    /**
+     * Determine whether the target is the requested module, or a subpath of it.
+     * @param target the identified target specifier
+     * @returns true if {@link target} is a subpath of this module; false otherwise
+     */
+    isSameOrSubpath(target) {
+        return (target === this.moduleSpecifier ||
+            (this.matchSubpaths === true && target.startsWith(`${this.moduleRoot}/`)));
+    }
+}
+function isNodeError(value) {
+    if (value === null || typeof value !== 'object') {
+        return false;
+    }
+    const keys = ['code', 'message'];
+    const has = (prop) => value[prop] === undefined ||
+        typeof value[prop] === 'string';
+    return keys.every(e => has(e));
+}

package/src/lib/utils/options.d.ts

@@ -0,0 +1,3 @@
+import { type ConfigOptions, type Options } from '@the-stranger/eslint-config';
+export declare function disableExcept<K extends keyof ConfigOptions>(config: Options, ...keys: K[]): import("eslint/config").Config[];
+export declare function disableOptionsExcept<K extends keyof ConfigOptions>(config: Options, ...keys: K[]): Options;

package/src/lib/utils/options.js

@@ -0,0 +1,24 @@
+import { configure, } from '@the-stranger/eslint-config';
+export function disableExcept(config, ...keys) {
+    return configure(disableOptionsExcept(config, ...keys));
+}
+export function disableOptionsExcept(config, ...keys) {
+    const configKeys = [
+        'json',
+        'source',
+        'nx',
+        'tests',
+        'toml',
+        'yaml',
+    ];
+    const keySet = new Set(keys);
+    for (const key of configKeys) {
+        if (keySet.has(key)) {
+            config[key] ??= true;
+        }
+        else {
+            config[key] = false;
+        }
+    }
+    return config;
+}

package/src/utils.d.ts

@@ -1,4 +1,2 @@
-export { namer, objectNamer, type Named } from './lib/namer.js';
-export { FilePatterns, getFilePatterns } from './lib/patterns.js';
-export { setRuleLevel } from './lib/severity.js';
-//# sourceMappingURL=utils.d.ts.map
+export { configure, type ConfigOptions } from '@the-stranger/eslint-config';
+export { FilePatterns, getFilePatterns, setSeverity } from '@the-stranger/eslint-utils';

package/src/utils.js

@@ -1,3 +1,2 @@
-export { namer, objectNamer } from './lib/namer.js';
-export { FilePatterns, getFilePatterns } from './lib/patterns.js';
-export { setRuleLevel } from './lib/severity.js';
+export { configure } from '@the-stranger/eslint-config';
+export { FilePatterns, getFilePatterns, setSeverity } from '@the-stranger/eslint-utils';

package/src/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../packages/eslint-plugin/src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAA;AAChD,OAAO,EAAE,IAAI,EAAE,MAAM,eAAe,CAAA"}

package/src/lib/configs/index.d.ts

@@ -1,17 +0,0 @@
-import type { Linter } from 'eslint';
-interface Configs {
-    base: Linter.Config[];
-    jsdoc: Linter.Config[];
-    jsonc: Linter.Config[];
-    n: Linter.Config[];
-    perfectionist: Linter.Config[];
-    promise: Linter.Config[];
-    recommended: Linter.Config[];
-    regexp: Linter.Config[];
-    ts: Linter.Config[];
-    unicorn: Linter.Config[];
-    yml: Linter.Config[];
-}
-export declare const configs: Configs;
-export {};
-//# sourceMappingURL=index.d.ts.map

package/src/lib/configs/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../packages/eslint-plugin/src/lib/configs/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAyBpC,UAAU,OAAO;IACf,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,CAAA;IACrB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,CAAA;IACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,CAAA;IACtB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,CAAA;IAClB,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,CAAA;IAC9B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,CAAA;IACxB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,CAAA;IAC5B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,CAAA;IACvB,EAAE,EAAE,MAAM,CAAC,MAAM,EAAE,CAAA;IACnB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,CAAA;IACxB,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,CAAA;CACrB;AAED,eAAO,MAAM,OAAO,EAAE,OAIrB,CAAA"}

package/src/lib/configs/index.js

@@ -1,26 +0,0 @@
-import { extendConfig } from '../extend-config.js';
-import jsdoc from './jsdoc.js';
-import jsonc from './jsonc.js';
-import n from './n.js';
-import perfectionist from './perfectionist.js';
-import promise from './promise.js';
-import regexp from './regexp.js';
-import ts from './typescript-eslint.js';
-import unicorn from './unicorn.js';
-import yml from './yml.js';
-const recommendedConfigs = {
-    jsdoc,
-    jsonc,
-    n,
-    perfectionist,
-    promise,
-    regexp,
-    ts,
-    unicorn,
-    yml,
-};
-export const configs = {
-    ...recommendedConfigs,
-    base: extendConfig(),
-    recommended: extendConfig(...Object.values(recommendedConfigs)),
-};

package/src/lib/configs/jest.d.ts

@@ -1,4 +0,0 @@
-import type { Linter } from 'eslint';
-declare const _default: Linter.Config[];
-export default _default;
-//# sourceMappingURL=jest.d.ts.map

package/src/lib/configs/jest.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"jest.d.ts","sourceRoot":"","sources":["../../../../../../packages/eslint-plugin/src/lib/configs/jest.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;wBA6B/B,MAAM,CAAC,MAAM,EAAE;AAxBpB,wBAwBoB"}

package/src/lib/configs/jest.js

@@ -1,27 +0,0 @@
-import jest from 'eslint-plugin-jest';
-import { namer } from '../namer.js';
-import { FilePatterns, getFilePatterns } from '../patterns.js';
-export default [
-    jest.configs['flat/recommended'],
-    jest.configs['flat/style'],
-    {
-        files: getFilePatterns(FilePatterns.test),
-        name: namer('jest'),
-        rules: {
-            'jest/consistent-test-it': ['error', { fn: 'it' }],
-            'jest/no-confusing-set-timeout': 'error',
-            'jest/prefer-each': 'warn',
-            'jest/prefer-equality-matcher': 'error',
-            'jest/prefer-expect-resolves': 'warn',
-            'jest/prefer-hooks-in-order': 'error',
-            'jest/prefer-hooks-on-top': 'warn',
-            'jest/prefer-importing-jest-globals': 'error',
-            'jest/prefer-jest-mocked': 'warn',
-            'jest/prefer-lowercase-title': 'warn',
-            'jest/prefer-mock-promise-shorthand': 'warn',
-            'jest/prefer-spy-on': 'warn',
-            'jest/prefer-strict-equal': 'warn',
-            'jest/valid-title': ['warn', { disallowedWords: ['should'] }],
-        },
-    },
-];

package/src/lib/configs/jsdoc.d.ts

@@ -1,5 +0,0 @@
-import type { Linter } from 'eslint';
-export declare const DOCUSAURUS_TAGS: string[];
-declare const _default: Linter.Config[];
-export default _default;
-//# sourceMappingURL=jsdoc.d.ts.map

package/src/lib/configs/jsdoc.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"jsdoc.d.ts","sourceRoot":"","sources":["../../../../../../packages/eslint-plugin/src/lib/configs/jsdoc.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAMpC,eAAO,MAAM,eAAe,UAAe,CAAA;wBA2CtC,MAAM,CAAC,MAAM,EAAE;AAzCpB,wBAyCoB"}

package/src/lib/configs/jsdoc.js

@@ -1,44 +0,0 @@
-import jsdoc from 'eslint-plugin-jsdoc';
-import { namer } from '../namer.js';
-import { FilePatterns, getFilePatterns } from '../patterns.js';
-// tags used by docusaurus to generate docs from jsdoc comments
-export const DOCUSAURUS_TAGS = ['document'];
-export default [
-    {
-        name: namer('jsdoc'),
-        plugins: { jsdoc },
-        rules: {
-            'jsdoc/require-jsdoc': 'off',
-            'jsdoc/require-returns': [
-                'error',
-                {
-                    checkGetters: false,
-                },
-            ],
-        },
-        settings: {
-            jsdoc: {
-                tagNamePreference: {
-                    augments: 'extends',
-                },
-            },
-        },
-    },
-    {
-        extends: [jsdoc.configs['flat/recommended-typescript']],
-        files: getFilePatterns(FilePatterns.ts),
-        name: namer('jsdoc/typescript'),
-    },
-    {
-        extends: [jsdoc.configs['flat/recommended']],
-        files: getFilePatterns(FilePatterns.js),
-        name: namer('jsdoc/javascript'),
-    },
-    {
-        files: getFilePatterns(FilePatterns.source),
-        name: namer('jsdoc/docusaurus'),
-        rules: {
-            'jsdoc/check-tag-names': ['warn', { definedTags: DOCUSAURUS_TAGS }],
-        },
-    },
-];

package/src/lib/configs/jsonc.d.ts

@@ -1,4 +0,0 @@
-import type { Linter } from 'eslint';
-declare const _default: Linter.Config[];
-export default _default;
-//# sourceMappingURL=jsonc.d.ts.map

package/src/lib/configs/jsonc.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"jsonc.d.ts","sourceRoot":"","sources":["../../../../../../packages/eslint-plugin/src/lib/configs/jsonc.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;wBAwI/B,MAAM,CAAC,MAAM,EAAE;AApIpB,wBAoIoB"}