@mrpalmer/eslint-plugin 1.0.0

package/lib/rules/sort-imports.js

@@ -0,0 +1,636 @@
+import { TSESTree } from '@typescript-eslint/utils';
+import { minimatch } from 'minimatch';
+import { reverse, findOutOfOrder, groupBy } from '../utils/array.js';
+import { findRootNode, findEndOfLineWithComments, findStartOfLineWithComments, } from '../utils/ast.js';
+import { createRule } from '../utils/create-rule.js';
+import { getSettings } from '../utils/settings.js';
+import { loadConfig } from '../utils/ts-config.js';
+import { importType, } from '../utils/import-type.js';
+const categories = {
+    import: 'import',
+    exports: 'exports',
+};
+const defaultGroups = [
+    'core',
+    'builtin',
+    'external',
+    'relative',
+    'sibling',
+    'index',
+];
+// REPORTING AND FIXING
+function isRequireExpression(expr) {
+    return (expr != null &&
+        expr.type === TSESTree.AST_NODE_TYPES.CallExpression &&
+        // eslint-disable-next-line eslint-plugin/no-property-in-node
+        'name' in expr.callee &&
+        expr.callee.name === 'require' &&
+        expr.arguments.length === 1 &&
+        expr.arguments[0].type === TSESTree.AST_NODE_TYPES.Literal);
+}
+function isSupportedRequireModule(node) {
+    if (node.type !== TSESTree.AST_NODE_TYPES.VariableDeclaration) {
+        return false;
+    }
+    if (node.declarations.length !== 1) {
+        return false;
+    }
+    const decl = node.declarations[0];
+    const isPlainRequire = (decl.id.type === TSESTree.AST_NODE_TYPES.Identifier ||
+        decl.id.type === TSESTree.AST_NODE_TYPES.ObjectPattern) &&
+        isRequireExpression(decl.init);
+    const isRequireWithMemberExpression = (decl.id.type === TSESTree.AST_NODE_TYPES.Identifier ||
+        decl.id.type === TSESTree.AST_NODE_TYPES.ObjectPattern) &&
+        decl.init != null &&
+        decl.init.type === TSESTree.AST_NODE_TYPES.CallExpression &&
+        decl.init.callee.type === TSESTree.AST_NODE_TYPES.MemberExpression &&
+        isRequireExpression(decl.init.callee.object);
+    return isPlainRequire || isRequireWithMemberExpression;
+}
+function isPlainImportModule(node) {
+    return node.type === TSESTree.AST_NODE_TYPES.ImportDeclaration;
+}
+function canCrossNodeWhileReorder(node) {
+    return isSupportedRequireModule(node) || isPlainImportModule(node);
+}
+function canReorderItems(firstNode, secondNode) {
+    const parent = firstNode.parent;
+    // eslint-disable-next-line eslint-plugin/no-property-in-node
+    if (!parent || !('body' in parent) || !Array.isArray(parent.body)) {
+        return false;
+    }
+    const body = parent.body;
+    const [firstIndex, secondIndex] = [
+        body.indexOf(firstNode),
+        body.indexOf(secondNode),
+    ].sort();
+    const nodesBetween = parent.body.slice(firstIndex, secondIndex + 1);
+    for (const nodeBetween of nodesBetween) {
+        if (!canCrossNodeWhileReorder(nodeBetween)) {
+            return false;
+        }
+    }
+    return true;
+}
+function makeImportDescription(node) {
+    if (node.type === 'export') {
+        if (node.node.exportKind === 'type') {
+            return 'type export';
+        }
+        return 'export';
+    }
+    if (node.node.importKind === 'type') {
+        return 'type import';
+    }
+    // @ts-expect-error - flow type
+    if (node.node.importKind === 'typeof') {
+        return 'typeof import';
+    }
+    return 'import';
+}
+function fixOutOfOrder(context, firstNode, secondNode, order, category) {
+    const isExports = category === categories.exports;
+    const { sourceCode } = context;
+    const firstRoot = findRootNode(firstNode.node);
+    const secondRoot = findRootNode(secondNode.node);
+    const firstRootStart = findStartOfLineWithComments(sourceCode, firstRoot);
+    const firstRootEnd = findEndOfLineWithComments(sourceCode, firstRoot);
+    const secondRootStart = findStartOfLineWithComments(sourceCode, secondRoot);
+    const secondRootEnd = findEndOfLineWithComments(sourceCode, secondRoot);
+    const firstDesc = makeImportDescription(firstNode);
+    const secondDesc = makeImportDescription(secondNode);
+    if (firstNode.displayName === secondNode.displayName &&
+        firstDesc === secondDesc) {
+        return;
+    }
+    const firstImport = `${firstDesc} of \`${firstNode.displayName}\``;
+    const secondImport = `\`${secondNode.displayName}\` ${secondDesc}`;
+    const messageOptions = {
+        messageId: 'order',
+        data: { firstImport, secondImport, order },
+    };
+    const canFix = isExports || canReorderItems(firstRoot, secondRoot);
+    let newCode = sourceCode.text.slice(secondRootStart, secondRootEnd);
+    if (!newCode.endsWith('\n')) {
+        newCode = `${newCode}\n`;
+    }
+    if (order === 'before') {
+        context.report({
+            node: secondNode.node,
+            ...messageOptions,
+            fix: canFix
+                ? (fixer) => fixer.replaceTextRange([firstRootStart, secondRootEnd], newCode + sourceCode.text.slice(firstRootStart, secondRootStart))
+                : null,
+        });
+    }
+    else {
+        context.report({
+            node: secondNode.node,
+            ...messageOptions,
+            fix: canFix
+                ? (fixer) => fixer.replaceTextRange([secondRootStart, firstRootEnd], sourceCode.text.slice(secondRootEnd, firstRootEnd) + newCode)
+                : null,
+        });
+    }
+}
+function reportOutOfOrder(context, imported, outOfOrder, order, category) {
+    for (const imp of outOfOrder) {
+        fixOutOfOrder(context, 
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        imported.find((importedItem) => importedItem.rank > imp.rank), imp, order, category);
+    }
+}
+const compareString = (a, b) => {
+    if (a < b) {
+        return -1;
+    }
+    if (a > b) {
+        return 1;
+    }
+    return 0;
+};
+/** Some parsers (languages without types) don't provide ImportKind */
+const DEFAULT_IMPORT_KIND = 'value';
+const RELATIVE_DOTS = new Set(['.', '..']);
+function getSorter() {
+    return function importsSorter(nodeA, nodeB) {
+        let result = 0;
+        if (!nodeA.sortableSource.includes('/') &&
+            !nodeB.sortableSource.includes('/')) {
+            result =
+                compareString(nodeA.sortableSource, nodeB.sortableSource) ||
+                    compareString(nodeA.originalSource, nodeB.originalSource);
+        }
+        else {
+            const A = nodeA.sortableSource.split('/');
+            const OA = nodeA.originalSource.split('/');
+            const B = nodeB.sortableSource.split('/');
+            const OB = nodeB.originalSource.split('/');
+            const a = A.length;
+            const b = B.length;
+            for (let i = 0; i < Math.min(a, b); i++) {
+                // Skip comparing the first path segment, if they are relative segments for both imports
+                const x = A[i];
+                const y = B[i];
+                if (i === 0 && RELATIVE_DOTS.has(x) && RELATIVE_DOTS.has(y)) {
+                    // If one is sibling and the other parent import, no need to compare at all, since the paths belong in different groups
+                    if (x !== y) {
+                        break;
+                    }
+                    continue;
+                }
+                result = compareString(x, y) || compareString(OA[i], OB[i]);
+                if (result) {
+                    break;
+                }
+            }
+            if (!result && a !== b) {
+                result = a < b ? -1 : 1;
+            }
+        }
+        // In case the paths are equal (result === 0), sort them by importKind
+        result ||= compareString(nodeA.node.importKind ?? DEFAULT_IMPORT_KIND, nodeB.node.importKind ?? DEFAULT_IMPORT_KIND);
+        return result;
+    };
+}
+function mutateRanksToAlphabetize(imported) {
+    const groupedByRanks = groupBy(imported, (item) => item.rank);
+    const sorterFn = getSorter();
+    // sort group keys so that they can be iterated on in order
+    const groupRanks = Object.keys(groupedByRanks).sort((a, b) => +a - +b);
+    // sort imports locally within their group
+    for (const groupRank of groupRanks) {
+        if (groupRank === '0') {
+            // don't sort side-effect imports
+            continue;
+        }
+        groupedByRanks[groupRank].sort(sorterFn);
+    }
+    // assign globally unique rank to each import
+    let newRank = 0;
+    const alphabetizedRanks = groupRanks.reduce((acc, groupRank) => {
+        for (const importedItem of groupedByRanks[groupRank]) {
+            acc[`${importedItem.value}|${importedItem.node.importKind}`] =
+                Number.parseInt(groupRank, 10) + newRank;
+            newRank += 1;
+        }
+        return acc;
+    }, {});
+    // mutate the original group-rank with alphabetized-rank
+    for (const importedItem of imported) {
+        importedItem.rank =
+            alphabetizedRanks[`${importedItem.value}|${importedItem.node.importKind}`];
+    }
+}
+function makeOutOfOrderReport(context, imported, category) {
+    const outOfOrder = findOutOfOrder(imported);
+    if (outOfOrder.length === 0) {
+        return;
+    }
+    // There are things to report. Try to minimize the number of reported errors.
+    const reversedImported = reverse(imported);
+    const reversedOrder = findOutOfOrder(reversedImported);
+    if (reversedOrder.length < outOfOrder.length) {
+        reportOutOfOrder(context, reversedImported, reversedOrder, 'after', category);
+        return;
+    }
+    reportOutOfOrder(context, imported, outOfOrder, 'before', category);
+}
+// DETECTING
+function computePathRank(ranks, pathGroups, path, maxPosition, isSideEffectOnly) {
+    for (const { pattern, patternOptions, group, position = 1, isSideEffect, } of pathGroups) {
+        if (minimatch(path, pattern, patternOptions ?? { nocomment: true }) &&
+            (isSideEffect == null || isSideEffect === isSideEffectOnly)) {
+            return ranks[group] + position / maxPosition;
+        }
+    }
+    return undefined;
+}
+function computeRank(settings, ranks, importEntry, isSideEffectOnly = false) {
+    let rank = typeof importEntry.value === 'string'
+        ? computePathRank(ranks.groups, ranks.pathGroups, importEntry.value, ranks.maxPosition, isSideEffectOnly)
+        : undefined;
+    if (rank === undefined) {
+        if (isSideEffectOnly) {
+            return ranks.groups.sideEffect;
+        }
+        const impType = importType(importEntry.value, settings);
+        rank = ranks.groups[impType];
+        if (rank === undefined &&
+            ranks.groups.core &&
+            impType.startsWith('core:')) {
+            rank = ranks.groups.core;
+        }
+        if (rank === undefined) {
+            return -1;
+        }
+    }
+    if (importEntry.type !== 'import') {
+        rank += 100;
+    }
+    return rank;
+}
+function registerNode(context, settings, importEntry, ranks, imported) {
+    const isSideEffectOnly = isSideEffectImport(importEntry.node, context.sourceCode);
+    const rank = computeRank(settings, ranks, importEntry, isSideEffectOnly);
+    if (rank !== -1) {
+        let importNode = importEntry.node;
+        if (importEntry.type === 'require' &&
+            importNode.parent?.parent?.type ===
+                TSESTree.AST_NODE_TYPES.VariableDeclaration) {
+            importNode = importNode.parent.parent;
+        }
+        imported.push({
+            ...importEntry,
+            rank,
+            index: imported.length,
+            sortableSource: transformSource(importEntry.value),
+            originalSource: String(importEntry.value),
+            isSideEffectOnly,
+            isMultiline: importNode.loc.end.line !== importNode.loc.start.line,
+        });
+    }
+}
+function isSideEffectImport(node, sourceCode) {
+    if (node.type !== TSESTree.AST_NODE_TYPES.ImportDeclaration) {
+        return false;
+    }
+    return (node.specifiers.length === 0 &&
+        node.importKind !== 'type' &&
+        !isPunctuator(sourceCode.getFirstToken(node, { skip: 1 }), '{'));
+}
+function isPunctuator(token, value) {
+    return (token &&
+        token.type === TSESTree.AST_TOKEN_TYPES.Punctuator &&
+        token.value === value);
+}
+function getRequireBlock(node) {
+    let n = node;
+    // Handle cases like `const baz = require('foo').bar.baz`
+    // and `const foo = require('foo')()`
+    while ((n.parent?.type === TSESTree.AST_NODE_TYPES.MemberExpression &&
+        n.parent.object === n) ||
+        (n.parent?.type === TSESTree.AST_NODE_TYPES.CallExpression &&
+            n.parent.callee === n)) {
+        n = n.parent;
+    }
+    if (n.parent?.type === TSESTree.AST_NODE_TYPES.VariableDeclarator &&
+        n.parent.parent.parent.type === TSESTree.AST_NODE_TYPES.Program) {
+        return n.parent.parent.parent;
+    }
+    return undefined;
+}
+const baseTypes = [
+    'sideEffect',
+    'core',
+    'builtin',
+    'external',
+    'internal',
+    'unknown',
+    'relative',
+    'sibling',
+    'index',
+];
+function transformSource(source) {
+    return (String(source)
+        .toLowerCase()
+        // Treat `.` as `./`, `..` as `../`, `../..` as `../../` etc.
+        .replace(/^[./]*\.$/, '$&/')
+        // Make `../` sort after `../../` but before `../a` etc.
+        // Why a comma? See the next comment.
+        .replace(/^[./]*\/$/, '$&,')
+        // Make `.` and `/` sort before any other punctuation.
+        // The default order is: _ - , x x x . x x x / x x x
+        // We’re changing it to: . / , x x x _ x x x - x x x
+        .replace(/[._-]/g, (char) => {
+        switch (char) {
+            case '.':
+                return '_';
+            case '_':
+                return '.';
+            case '-':
+                return '/';
+            default:
+                return char;
+        }
+    }));
+}
+// Creates an object with type-rank pairs.
+// Example: { index: 0, sibling: 1, parent: 1, external: 1, builtin: 2, internal: 2 }
+// Will throw an error if it contains a type that does not exist, or has a duplicate
+function convertGroupsToRanks(groups, types, coreModules) {
+    const coreIndex = groups.indexOf('core');
+    if (coreIndex !== -1 && coreModules) {
+        groups = groups.toSpliced(coreIndex + 1, 0, ...coreModules.map((module) => `core:${module}`));
+    }
+    const rankObject = groups.reduce((res, group, index) => {
+        for (const groupItem of [group].flat()) {
+            if (!types.has(groupItem) && !groupItem.startsWith('core:')) {
+                throw new Error(`Incorrect configuration of the rule: Unknown type \`${JSON.stringify(groupItem)}\``);
+            }
+            if (res[groupItem] !== undefined) {
+                throw new Error(`Incorrect configuration of the rule: \`${groupItem}\` is duplicated`);
+            }
+            res[groupItem] = index * 2;
+        }
+        return res;
+    }, {});
+    const omittedTypes = new Set(types);
+    Object.keys(rankObject)
+        .filter((key) => types.has(key))
+        .forEach((key) => {
+        omittedTypes.delete(key);
+    });
+    if (coreIndex === -1) {
+        omittedTypes.add('core');
+    }
+    const ranks = [...omittedTypes].reduce((res, type) => {
+        res[type] = groups.length * 2;
+        return res;
+    }, rankObject);
+    assertAllTypesRanked(ranks);
+    return { groups: ranks, omittedTypes: [...omittedTypes] };
+}
+function assertAllTypesRanked(ranks) {
+    const expectedTypes = new Set(baseTypes);
+    expectedTypes.delete('core');
+    for (const type of expectedTypes) {
+        if (ranks[type] === undefined) {
+            throw new Error(`Incorrect configuration of the rule: \`${type}\` is missing`);
+        }
+    }
+}
+function convertPathGroupsForRanks(pathGroups, tsconfigPathAliases) {
+    const after = {};
+    const before = {};
+    const tsconfigPathGroups = tsconfigPathAliases.map((alias) => ({
+        pattern: alias.replace(/\/\*$/, '/**/*'),
+        group: 'internal',
+    }));
+    const transformed = [...pathGroups, ...tsconfigPathGroups].map((pathGroup, index) => {
+        const { group, position: positionString } = pathGroup;
+        let position = 0;
+        if (positionString === 'after') {
+            after[group] ||= 1;
+            position = after[group]++;
+        }
+        else if (positionString === 'before') {
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            before[group] ||= [];
+            before[group].push(index);
+        }
+        return { ...pathGroup, position };
+    });
+    let maxPosition = 1;
+    for (const group of Object.keys(before)) {
+        const groupLength = before[group].length;
+        for (const [index, groupIndex] of before[group].entries()) {
+            transformed[groupIndex].position = -1 * (groupLength - index);
+        }
+        maxPosition = Math.max(maxPosition, groupLength);
+    }
+    for (const key of Object.keys(after)) {
+        const groupNextPosition = after[key];
+        maxPosition = Math.max(maxPosition, groupNextPosition - 1);
+    }
+    return {
+        pathGroups: transformed,
+        maxPosition: maxPosition > 10 ? 10 ** Math.ceil(Math.log10(maxPosition)) : 10,
+    };
+}
+function removeNewLineAfterImport(context, currentImport, previousImport) {
+    const { sourceCode } = context;
+    const prevRoot = findRootNode(previousImport.node);
+    const currRoot = findRootNode(currentImport.node);
+    const rangeToRemove = [
+        findEndOfLineWithComments(sourceCode, prevRoot),
+        findStartOfLineWithComments(sourceCode, currRoot),
+    ];
+    if (/^\s*$/.test(sourceCode.text.slice(rangeToRemove[0], rangeToRemove[1]))) {
+        return (fixer) => fixer.removeRange(rangeToRemove);
+    }
+    return undefined;
+}
+function makeNewlinesBetweenReport(context, imported) {
+    const getNumberOfEmptyLinesBetween = (currentImport, previousImport) => {
+        return context.sourceCode.lines
+            .slice(previousImport.node.loc.end.line, currentImport.node.loc.start.line - 1)
+            .filter((line) => line.trim().length === 0).length;
+    };
+    let previousImport = imported[0];
+    for (const currentImport of imported.slice(1)) {
+        const emptyLinesBetween = getNumberOfEmptyLinesBetween(currentImport, previousImport);
+        if (emptyLinesBetween > 0) {
+            context.report({
+                node: previousImport.node,
+                messageId: 'noLineBetweenImports',
+                fix: removeNewLineAfterImport(context, currentImport, previousImport),
+            });
+        }
+        previousImport = currentImport;
+    }
+}
+export default createRule({
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Ensure imports are sorted consistently.',
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    groups: {
+                        type: 'array',
+                    },
+                    pathGroups: {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                pattern: {
+                                    type: 'string',
+                                },
+                                patternOptions: {
+                                    type: 'object',
+                                },
+                                group: {
+                                    type: 'string',
+                                    // enum: baseTypes,
+                                },
+                                position: {
+                                    type: 'string',
+                                    enum: ['after', 'before'],
+                                },
+                                isSideEffect: {
+                                    type: 'boolean',
+                                },
+                            },
+                            additionalProperties: false,
+                            required: ['pattern', 'group'],
+                        },
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            error: '{{error}}',
+            noLineBetweenImports: 'There should be no empty line between import statements',
+            order: '{{secondImport}} should occur {{order}} {{firstImport}}',
+        },
+    },
+    defaultOptions: [
+        {
+            groups: defaultGroups,
+            pathGroups: [],
+        },
+    ],
+    create(context, [options]) {
+        const settings = getSettings(context);
+        const tsConfigPaths = loadConfig(settings)?.config.compilerOptions?.paths ?? {};
+        let ranks;
+        try {
+            const { pathGroups, maxPosition } = convertPathGroupsForRanks(options.pathGroups, Object.keys(tsConfigPaths));
+            const types = new Set(baseTypes);
+            pathGroups.forEach((group) => {
+                types.add(group.group);
+            });
+            const { groups, omittedTypes } = convertGroupsToRanks(['sideEffect', ...options.groups], types, settings['mrpalmer/coreModules']);
+            ranks = {
+                groups,
+                omittedTypes,
+                pathGroups,
+                maxPosition,
+            };
+        }
+        catch (error) {
+            // Malformed configuration
+            return {
+                Program(node) {
+                    context.report({
+                        node,
+                        messageId: 'error',
+                        data: {
+                            error: getErrorMessage(error) ?? 'Invalid configuration',
+                        },
+                    });
+                },
+            };
+        }
+        const importMap = new Map();
+        const exportMap = new Map();
+        function getBlockImports(node) {
+            let blockImports = importMap.get(node);
+            if (!blockImports) {
+                importMap.set(node, (blockImports = []));
+            }
+            return blockImports;
+        }
+        return {
+            ImportDeclaration(node) {
+                const name = node.source.value;
+                registerNode(context, settings, {
+                    node,
+                    value: name,
+                    displayName: name,
+                    type: 'import',
+                }, ranks, getBlockImports(node.parent));
+            },
+            CallExpression(node) {
+                if (!isStaticRequire(node)) {
+                    return;
+                }
+                const block = getRequireBlock(node);
+                const firstArg = node.arguments[0];
+                // eslint-disable-next-line eslint-plugin/no-property-in-node
+                if (!block || !('value' in firstArg)) {
+                    return;
+                }
+                const { value } = firstArg;
+                registerNode(context, settings, {
+                    node,
+                    value,
+                    displayName: value,
+                    type: 'require',
+                }, ranks, getBlockImports(block));
+            },
+            'Program:exit'() {
+                for (const imported of importMap.values()) {
+                    makeNewlinesBetweenReport(context, imported);
+                    mutateRanksToAlphabetize(imported);
+                    makeOutOfOrderReport(context, imported, categories.import);
+                }
+                for (const exported of exportMap.values()) {
+                    mutateRanksToAlphabetize(exported);
+                    makeOutOfOrderReport(context, exported, categories.exports);
+                }
+                importMap.clear();
+                exportMap.clear();
+            },
+        };
+    },
+});
+function getErrorMessage(error) {
+    if (typeof error === 'string') {
+        return error;
+    }
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === 'object' &&
+        error &&
+        'message' in error &&
+        typeof error.message === 'string') {
+        return error.message;
+    }
+    return undefined;
+}
+function isStaticRequire(node) {
+    return (node.callee.type === TSESTree.AST_NODE_TYPES.Identifier &&
+        node.callee.name === 'require' &&
+        node.arguments.length === 1 &&
+        node.arguments[0].type === TSESTree.AST_NODE_TYPES.Literal &&
+        typeof node.arguments[0].value === 'string');
+}

package/lib/rules/sort-named.d.ts

@@ -0,0 +1,8 @@
+import { type TSESLint } from '@typescript-eslint/utils';
+export interface Options {
+    ignoreCase?: boolean;
+    types?: NamedTypes;
+}
+declare const _default: TSESLint.RuleModule<"order", [Options], unknown, TSESLint.RuleListener>;
+export default _default;
+type NamedTypes = 'mixed' | 'types-first' | 'types-last';