@mrpalmer/eslint-plugin 1.0.0

package/lib/utils/import-path-options.js

@@ -0,0 +1,98 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createPathsMatcher } from 'get-tsconfig';
+export function getImportPathOptions({ originalPath, filePath, tsconfig, }) {
+    const options = new Set([originalPath]);
+    if (isRelative(originalPath)) {
+        options.add(formatRelativeImportPath(filePath, originalPath));
+    }
+    // if there's no tsconfig, we can't use aliases
+    if (!tsconfig) {
+        return options;
+    }
+    const pathsMatcher = createPathsMatcher(tsconfig);
+    const { baseUrl, paths } = tsconfig.config.compilerOptions ?? {};
+    const baseUrlAbsolutePath = path.resolve(path.dirname(tsconfig.path), baseUrl ?? '.');
+    // see if there's a relative path match
+    const relativeMatch = resolveAlias(originalPath, pathsMatcher);
+    if (relativeMatch) {
+        const relative = formatRelativeImportPath(filePath, relativeMatch);
+        options.add(relative);
+        // check if there's a better alias match
+        if (paths) {
+            const aliases = findAliases({
+                filePath,
+                originalImportPath: relative,
+                baseUrlAbsolutePath,
+                paths,
+                pathsMatcher,
+            });
+            for (const alias of aliases) {
+                options.add(alias);
+            }
+        }
+    }
+    if (!paths) {
+        return options;
+    }
+    // see if there's an alias match
+    if (isRelative(originalPath)) {
+        const aliases = findAliases({
+            filePath,
+            originalImportPath: originalPath,
+            baseUrlAbsolutePath,
+            paths,
+            pathsMatcher,
+        });
+        for (const alias of aliases) {
+            options.add(alias);
+        }
+    }
+    return options;
+}
+function isRelative(testPath) {
+    return /^\.{1,2}\//.test(testPath);
+}
+function formatRelativeImportPath(currentFile, relativePath) {
+    const currentDir = path.dirname(currentFile);
+    const absolutePath = path.resolve(currentDir, relativePath);
+    const relative = path.relative(currentDir, absolutePath);
+    return isRelative(relative) ? relative : `./${relative}`;
+}
+function findAliases({ filePath, originalImportPath, baseUrlAbsolutePath, paths, pathsMatcher, }) {
+    const options = new Set();
+    const directory = path.dirname(filePath);
+    const absolutePath = path.resolve(directory, originalImportPath);
+    const relativeToBase = path.relative(baseUrlAbsolutePath, absolutePath);
+    for (const alias of Object.keys(paths)) {
+        const prefix = alias.replace(/\/\*$/, '');
+        const tryPaths = paths[alias];
+        for (const tryPath of tryPaths) {
+            const partialPath = tryPath === '*' ? '' : tryPath.replace(/\/\*$/, '');
+            const relative = path.relative(partialPath, relativeToBase);
+            if (!relative.startsWith('..')) {
+                const alias = path.join(prefix, relative);
+                if (resolveAlias(alias, pathsMatcher) != null) {
+                    options.add(path.join(prefix, relative));
+                }
+            }
+        }
+    }
+    return options;
+}
+const importExtensionMappings = {
+    '': ['.js', '.ts', '.jsx', '.tsx'],
+    '.js': ['.ts', '.js'],
+};
+function fileExistsAtPath(filePath) {
+    const { ext } = path.parse(filePath);
+    const candidateExtensions = importExtensionMappings[ext] ?? [ext];
+    return candidateExtensions.some((ext) => fs.existsSync(filePath + ext));
+}
+function resolveAlias(importPath, matcher) {
+    if (!matcher) {
+        return undefined;
+    }
+    const matches = matcher(importPath);
+    return matches.find((match) => fileExistsAtPath(match));
+}

package/lib/utils/import-type.d.ts

@@ -0,0 +1,3 @@
+import type { LiteralNodeValue, PluginSettings } from '../types.js';
+export type ImportType = Exclude<ReturnType<typeof importType>, `core:${string}`>;
+export declare function importType(name: LiteralNodeValue, settings: PluginSettings): "relative" | "unknown" | "internal" | "absolute" | "builtin" | `core:${string}` | "index" | "sibling" | "external";

package/lib/utils/import-type.js

@@ -0,0 +1,88 @@
+import { isBuiltin } from 'node:module';
+import path from 'node:path';
+import { minimatch } from 'minimatch';
+export function importType(name, settings) {
+    if (typeof name !== 'string') {
+        return 'unknown';
+    }
+    if (isInternalRegexMatch(name, settings)) {
+        return 'internal';
+    }
+    if (isAbsolute(name)) {
+        return 'absolute';
+    }
+    if (isBuiltIn(name)) {
+        return 'builtin';
+    }
+    const coreModulePattern = findCoreModule(name, settings);
+    if (coreModulePattern) {
+        return `core:${coreModulePattern}`;
+    }
+    if (isRelativeToParent(name)) {
+        return 'relative';
+    }
+    if (isIndex(name)) {
+        return 'index';
+    }
+    if (isRelativeToSibling(name)) {
+        return 'sibling';
+    }
+    if (isExternalLookingName(name)) {
+        return 'external';
+    }
+    return 'unknown';
+}
+function isInternalRegexMatch(name, settings) {
+    const internalScope = settings['mrpalmer/internalRegex'];
+    return internalScope && new RegExp(internalScope).test(name);
+}
+function isAbsolute(name) {
+    return typeof name === 'string' && path.isAbsolute(name);
+}
+function isBuiltIn(name) {
+    const base = baseModule(name);
+    return isBuiltin(base);
+}
+function findCoreModule(name, settings) {
+    const base = baseModule(name);
+    const coreModules = settings['mrpalmer/coreModules'] ?? [];
+    return coreModules.find((pattern) => minimatch(base, pattern, { nocomment: true }));
+}
+function baseModule(name) {
+    if (isScoped(name)) {
+        const [scope, pkg] = name.split('/');
+        return `${scope}/${pkg}`;
+    }
+    const [pkg] = name.split('/');
+    return pkg;
+}
+const scopedRegExp = /^@([^/]+)\/([^/]+)/;
+function isScoped(name) {
+    return !!name && scopedRegExp.test(name);
+}
+function isRelativeToParent(name) {
+    return /^\.\.\/?/.test(name);
+}
+const indexFiles = new Set(['.', './', './index', './index.js']);
+function isIndex(name) {
+    return indexFiles.has(name);
+}
+function isRelativeToSibling(name) {
+    return name.startsWith('./');
+}
+const packageNameSpecialCharsRegExp = /[~'!()*]/;
+function isExternalLookingName(name) {
+    if (!name || name.trim() !== name || /^[._-]/.test(name) || /\s/.test(name)) {
+        return false;
+    }
+    const match = scopedRegExp.exec(name);
+    if (match) {
+        const [, user, pkg] = match;
+        return encodeURIComponent(user) === user && isExternalLookingName(pkg);
+    }
+    else {
+        const [pkg] = name.split('/');
+        return (!packageNameSpecialCharsRegExp.test(pkg) &&
+            encodeURIComponent(pkg) === pkg);
+    }
+}

package/lib/utils/settings.d.ts

@@ -0,0 +1,3 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+import type { PluginSettings } from '../types.js';
+export declare function getSettings(context: TSESLint.RuleContext<string, unknown[]>): PluginSettings;

package/lib/utils/settings.js

@@ -0,0 +1,20 @@
+export function getSettings(context) {
+    const settings = context.settings;
+    return {
+        'mrpalmer/tsconfig': normalizeSetting(settings['mrpalmer/tsconfig'], isString),
+        'mrpalmer/coreModules': normalizeSetting(settings['mrpalmer/coreModules'], isArrayOfStrings),
+        'mrpalmer/internalRegex': normalizeSetting(settings['mrpalmer/internalRegex'], isString),
+    };
+}
+function normalizeSetting(setting, test) {
+    if (setting == null) {
+        return undefined;
+    }
+    return test(setting) ? setting : undefined;
+}
+function isString(value) {
+    return typeof value === 'string';
+}
+function isArrayOfStrings(value) {
+    return Array.isArray(value) && value.every(isString);
+}

package/lib/utils/shortest-path.d.ts

@@ -0,0 +1,2 @@
+import type { Options as ShortenPathRuleOptions } from '../rules/shorten-paths.js';
+export declare function getShortestPath(paths: Set<string>, options: Readonly<ShortenPathRuleOptions>): string | undefined;

package/lib/utils/shortest-path.js

@@ -0,0 +1,45 @@
+export function getShortestPath(paths, options) {
+    // if there's only one path, return it
+    if (paths.size === 1) {
+        return paths.values().next().value;
+    }
+    const { breakTies } = options[0];
+    const sortedPaths = [...paths].sort(bySegmentCount);
+    const shortestLength = countSegments(sortedPaths[0]);
+    const ties = sortedPaths
+        .filter((path) => countSegments(path) === shortestLength)
+        .toSorted(byCharacterCount);
+    if (ties.length === 1) {
+        return ties[0];
+    }
+    const candidates = ties.filter(breakTies === 'alias' ? isAlias : isRelative);
+    if (candidates.length === 0) {
+        // if there are no candidates, it means there are multiple 'shortest' paths
+        // but none of them match the user's preference. fall back to the shortest
+        // by character count
+        return ties[0];
+    }
+    // at this point, there's either exactly one choice, or multiple choices that
+    // match the user's preference. just pick the shortest by character count
+    // (which is the first one in the array because the ties were already sorted)
+    return candidates[0];
+}
+function bySegmentCount(a, b) {
+    const aSegments = countSegments(a);
+    const bSegments = countSegments(b);
+    return aSegments - bSegments;
+}
+function byCharacterCount(a, b) {
+    const aLength = a.length;
+    const bLength = b.length;
+    return aLength - bLength;
+}
+function countSegments(path) {
+    return path.split('/').length;
+}
+function isRelative(path) {
+    return /^\.{1,2}\//.test(path);
+}
+function isAlias(path) {
+    return !isRelative(path);
+}

package/lib/utils/ts-config.d.ts

@@ -0,0 +1,16 @@
+import { createPathsMatcher } from 'get-tsconfig';
+import type { PluginSettings } from '../types.js';
+export { createPathsMatcher };
+export declare function loadConfig(settings: PluginSettings): {
+    path: string;
+    config: {
+        compilerOptions?: import("get-tsconfig").TsConfigJson.CompilerOptions | undefined;
+        watchOptions?: import("get-tsconfig").TsConfigJson.WatchOptions | undefined;
+        typeAcquisition?: import("get-tsconfig").TsConfigJson.TypeAcquisition | undefined;
+        compileOnSave?: boolean | undefined;
+        files?: string[] | undefined;
+        exclude?: string[] | undefined;
+        include?: string[] | undefined;
+        references?: import("get-tsconfig").TsConfigJson.References[] | undefined;
+    };
+} | undefined;

package/lib/utils/ts-config.js

@@ -0,0 +1,54 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createPathsMatcher, parseTsconfig } from 'get-tsconfig';
+export { createPathsMatcher };
+export function loadConfig(settings) {
+    const eslintConfigPath = findUp([
+        'eslint.config.js',
+        'eslint.config.mjs',
+        'eslint.config.cjs',
+    ]);
+    if (!eslintConfigPath || !fs.existsSync(eslintConfigPath)) {
+        return undefined;
+    }
+    const configFilePath = path.resolve(path.dirname(eslintConfigPath), getRelativeConfigFilePath(settings));
+    if (!fs.existsSync(configFilePath)) {
+        return undefined;
+    }
+    const config = parseTsconfig(configFilePath);
+    return { path: configFilePath, config };
+}
+function getRelativeConfigFilePath(settings) {
+    return settings['mrpalmer/tsconfig'] ?? 'tsconfig.json';
+}
+function findUp(filenames) {
+    let directory = process.cwd();
+    const { root: stopAt } = path.parse(directory);
+    while (directory !== stopAt) {
+        const found = firstExistingPath(filenames, directory);
+        if (found) {
+            return path.resolve(directory, found);
+        }
+        directory = path.dirname(directory);
+    }
+    return undefined;
+}
+function firstExistingPath(paths, directory) {
+    for (const p of paths) {
+        try {
+            const stat = fs.statSync(path.resolve(directory, p), {
+                throwIfNoEntry: false,
+            });
+            if (!stat) {
+                continue;
+            }
+            if (stat.isFile()) {
+                return p;
+            }
+        }
+        catch {
+            // do nothing
+        }
+    }
+    return undefined;
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@mrpalmer/eslint-plugin",
+  "version": "1.0.0",
+  "description": "Custom ESLint rules for Mike Palmer's projects",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./lib/index.js",
+  "files": [
+    "lib"
+  ],
+  "dependencies": {
+    "@typescript-eslint/utils": "^8.29.1",
+    "get-tsconfig": "^4.10.0",
+    "minimatch": "^10.0.1"
+  },
+  "peerDependencies": {
+    "eslint": "^9.0.0"
+  },
+  "engines": {
+    "node": ">=20",
+    "npm": ">=8",
+    "yarn": ">=1"
+  }
+}