@alexlit/lint-kit 127.0.0 → 127.2.0

package/packages/config-eslint/node_modules/eslint/lib/rules/sort-imports.js

@@ -1,241 +0,0 @@
-/**
- * @fileoverview Rule to require sorting of import declarations
- * @author Christian Schuller
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Enforce sorted import declarations within modules",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/sort-imports"
-        },
-
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    ignoreCase: {
-                        type: "boolean",
-                        default: false
-                    },
-                    memberSyntaxSortOrder: {
-                        type: "array",
-                        items: {
-                            enum: ["none", "all", "multiple", "single"]
-                        },
-                        uniqueItems: true,
-                        minItems: 4,
-                        maxItems: 4
-                    },
-                    ignoreDeclarationSort: {
-                        type: "boolean",
-                        default: false
-                    },
-                    ignoreMemberSort: {
-                        type: "boolean",
-                        default: false
-                    },
-                    allowSeparatedGroups: {
-                        type: "boolean",
-                        default: false
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
-
-        fixable: "code",
-
-        messages: {
-            sortImportsAlphabetically: "Imports should be sorted alphabetically.",
-            sortMembersAlphabetically: "Member '{{memberName}}' of the import declaration should be sorted alphabetically.",
-            unexpectedSyntaxOrder: "Expected '{{syntaxA}}' syntax before '{{syntaxB}}' syntax."
-        }
-    },
-
-    create(context) {
-
-        const configuration = context.options[0] || {},
-            ignoreCase = configuration.ignoreCase || false,
-            ignoreDeclarationSort = configuration.ignoreDeclarationSort || false,
-            ignoreMemberSort = configuration.ignoreMemberSort || false,
-            memberSyntaxSortOrder = configuration.memberSyntaxSortOrder || ["none", "all", "multiple", "single"],
-            allowSeparatedGroups = configuration.allowSeparatedGroups || false,
-            sourceCode = context.sourceCode;
-        let previousDeclaration = null;
-
-        /**
-         * Gets the used member syntax style.
-         *
-         * import "my-module.js" --> none
-         * import * as myModule from "my-module.js" --> all
-         * import {myMember} from "my-module.js" --> single
-         * import {foo, bar} from  "my-module.js" --> multiple
-         * @param {ASTNode} node the ImportDeclaration node.
-         * @returns {string} used member parameter style, ["all", "multiple", "single"]
-         */
-        function usedMemberSyntax(node) {
-            if (node.specifiers.length === 0) {
-                return "none";
-            }
-            if (node.specifiers[0].type === "ImportNamespaceSpecifier") {
-                return "all";
-            }
-            if (node.specifiers.length === 1) {
-                return "single";
-            }
-            return "multiple";
-
-        }
-
-        /**
-         * Gets the group by member parameter index for given declaration.
-         * @param {ASTNode} node the ImportDeclaration node.
-         * @returns {number} the declaration group by member index.
-         */
-        function getMemberParameterGroupIndex(node) {
-            return memberSyntaxSortOrder.indexOf(usedMemberSyntax(node));
-        }
-
-        /**
-         * Gets the local name of the first imported module.
-         * @param {ASTNode} node the ImportDeclaration node.
-         * @returns {?string} the local name of the first imported module.
-         */
-        function getFirstLocalMemberName(node) {
-            if (node.specifiers[0]) {
-                return node.specifiers[0].local.name;
-            }
-            return null;
-
-        }
-
-        /**
-         * Calculates number of lines between two nodes. It is assumed that the given `left` node appears before
-         * the given `right` node in the source code. Lines are counted from the end of the `left` node till the
-         * start of the `right` node. If the given nodes are on the same line, it returns `0`, same as if they were
-         * on two consecutive lines.
-         * @param {ASTNode} left node that appears before the given `right` node.
-         * @param {ASTNode} right node that appears after the given `left` node.
-         * @returns {number} number of lines between nodes.
-         */
-        function getNumberOfLinesBetween(left, right) {
-            return Math.max(right.loc.start.line - left.loc.end.line - 1, 0);
-        }
-
-        return {
-            ImportDeclaration(node) {
-                if (!ignoreDeclarationSort) {
-                    if (
-                        previousDeclaration &&
-                        allowSeparatedGroups &&
-                        getNumberOfLinesBetween(previousDeclaration, node) > 0
-                    ) {
-
-                        // reset declaration sort
-                        previousDeclaration = null;
-                    }
-
-                    if (previousDeclaration) {
-                        const currentMemberSyntaxGroupIndex = getMemberParameterGroupIndex(node),
-                            previousMemberSyntaxGroupIndex = getMemberParameterGroupIndex(previousDeclaration);
-                        let currentLocalMemberName = getFirstLocalMemberName(node),
-                            previousLocalMemberName = getFirstLocalMemberName(previousDeclaration);
-
-                        if (ignoreCase) {
-                            previousLocalMemberName = previousLocalMemberName && previousLocalMemberName.toLowerCase();
-                            currentLocalMemberName = currentLocalMemberName && currentLocalMemberName.toLowerCase();
-                        }
-
-                        /*
-                         * When the current declaration uses a different member syntax,
-                         * then check if the ordering is correct.
-                         * Otherwise, make a default string compare (like rule sort-vars to be consistent) of the first used local member name.
-                         */
-                        if (currentMemberSyntaxGroupIndex !== previousMemberSyntaxGroupIndex) {
-                            if (currentMemberSyntaxGroupIndex < previousMemberSyntaxGroupIndex) {
-                                context.report({
-                                    node,
-                                    messageId: "unexpectedSyntaxOrder",
-                                    data: {
-                                        syntaxA: memberSyntaxSortOrder[currentMemberSyntaxGroupIndex],
-                                        syntaxB: memberSyntaxSortOrder[previousMemberSyntaxGroupIndex]
-                                    }
-                                });
-                            }
-                        } else {
-                            if (previousLocalMemberName &&
-                                currentLocalMemberName &&
-                                currentLocalMemberName < previousLocalMemberName
-                            ) {
-                                context.report({
-                                    node,
-                                    messageId: "sortImportsAlphabetically"
-                                });
-                            }
-                        }
-                    }
-
-                    previousDeclaration = node;
-                }
-
-                if (!ignoreMemberSort) {
-                    const importSpecifiers = node.specifiers.filter(specifier => specifier.type === "ImportSpecifier");
-                    const getSortableName = ignoreCase ? specifier => specifier.local.name.toLowerCase() : specifier => specifier.local.name;
-                    const firstUnsortedIndex = importSpecifiers.map(getSortableName).findIndex((name, index, array) => array[index - 1] > name);
-
-                    if (firstUnsortedIndex !== -1) {
-                        context.report({
-                            node: importSpecifiers[firstUnsortedIndex],
-                            messageId: "sortMembersAlphabetically",
-                            data: { memberName: importSpecifiers[firstUnsortedIndex].local.name },
-                            fix(fixer) {
-                                if (importSpecifiers.some(specifier =>
-                                    sourceCode.getCommentsBefore(specifier).length || sourceCode.getCommentsAfter(specifier).length)) {
-
-                                    // If there are comments in the ImportSpecifier list, don't rearrange the specifiers.
-                                    return null;
-                                }
-
-                                return fixer.replaceTextRange(
-                                    [importSpecifiers[0].range[0], importSpecifiers.at(-1).range[1]],
-                                    importSpecifiers
-
-                                        // Clone the importSpecifiers array to avoid mutating it
-                                        .slice()
-
-                                        // Sort the array into the desired order
-                                        .sort((specifierA, specifierB) => {
-                                            const aName = getSortableName(specifierA);
-                                            const bName = getSortableName(specifierB);
-
-                                            return aName > bName ? 1 : -1;
-                                        })
-
-                                        // Build a string out of the sorted list of import specifiers and the text between the originals
-                                        .reduce((sourceText, specifier, index) => {
-                                            const textAfterSpecifier = index === importSpecifiers.length - 1
-                                                ? ""
-                                                : sourceCode.getText().slice(importSpecifiers[index].range[1], importSpecifiers[index + 1].range[0]);
-
-                                            return sourceText + sourceCode.getText(specifier) + textAfterSpecifier;
-                                        }, "")
-                                );
-                            }
-                        });
-                    }
-                }
-            }
-        };
-    }
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/sort-keys.js

@@ -1,230 +0,0 @@
-/**
- * @fileoverview Rule to require object keys to be sorted
- * @author Toru Nagashima
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils"),
-    naturalCompare = require("natural-compare");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Gets the property name of the given `Property` node.
- *
- * - If the property's key is an `Identifier` node, this returns the key's name
- *   whether it's a computed property or not.
- * - If the property has a static name, this returns the static name.
- * - Otherwise, this returns null.
- * @param {ASTNode} node The `Property` node to get.
- * @returns {string|null} The property name or null.
- * @private
- */
-function getPropertyName(node) {
-    const staticName = astUtils.getStaticPropertyName(node);
-
-    if (staticName !== null) {
-        return staticName;
-    }
-
-    return node.key.name || null;
-}
-
-/**
- * Functions which check that the given 2 names are in specific order.
- *
- * Postfix `I` is meant insensitive.
- * Postfix `N` is meant natural.
- * @private
- */
-const isValidOrders = {
-    asc(a, b) {
-        return a <= b;
-    },
-    ascI(a, b) {
-        return a.toLowerCase() <= b.toLowerCase();
-    },
-    ascN(a, b) {
-        return naturalCompare(a, b) <= 0;
-    },
-    ascIN(a, b) {
-        return naturalCompare(a.toLowerCase(), b.toLowerCase()) <= 0;
-    },
-    desc(a, b) {
-        return isValidOrders.asc(b, a);
-    },
-    descI(a, b) {
-        return isValidOrders.ascI(b, a);
-    },
-    descN(a, b) {
-        return isValidOrders.ascN(b, a);
-    },
-    descIN(a, b) {
-        return isValidOrders.ascIN(b, a);
-    }
-};
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Require object keys to be sorted",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/sort-keys"
-        },
-
-        schema: [
-            {
-                enum: ["asc", "desc"]
-            },
-            {
-                type: "object",
-                properties: {
-                    caseSensitive: {
-                        type: "boolean",
-                        default: true
-                    },
-                    natural: {
-                        type: "boolean",
-                        default: false
-                    },
-                    minKeys: {
-                        type: "integer",
-                        minimum: 2,
-                        default: 2
-                    },
-                    allowLineSeparatedGroups: {
-                        type: "boolean",
-                        default: false
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
-
-        messages: {
-            sortKeys: "Expected object keys to be in {{natural}}{{insensitive}}{{order}}ending order. '{{thisName}}' should be before '{{prevName}}'."
-        }
-    },
-
-    create(context) {
-
-        // Parse options.
-        const order = context.options[0] || "asc";
-        const options = context.options[1];
-        const insensitive = options && options.caseSensitive === false;
-        const natural = options && options.natural;
-        const minKeys = options && options.minKeys;
-        const allowLineSeparatedGroups = options && options.allowLineSeparatedGroups || false;
-        const isValidOrder = isValidOrders[
-            order + (insensitive ? "I" : "") + (natural ? "N" : "")
-        ];
-
-        // The stack to save the previous property's name for each object literals.
-        let stack = null;
-        const sourceCode = context.sourceCode;
-
-        return {
-            ObjectExpression(node) {
-                stack = {
-                    upper: stack,
-                    prevNode: null,
-                    prevBlankLine: false,
-                    prevName: null,
-                    numKeys: node.properties.length
-                };
-            },
-
-            "ObjectExpression:exit"() {
-                stack = stack.upper;
-            },
-
-            SpreadElement(node) {
-                if (node.parent.type === "ObjectExpression") {
-                    stack.prevName = null;
-                }
-            },
-
-            Property(node) {
-                if (node.parent.type === "ObjectPattern") {
-                    return;
-                }
-
-                const prevName = stack.prevName;
-                const numKeys = stack.numKeys;
-                const thisName = getPropertyName(node);
-
-                // Get tokens between current node and previous node
-                const tokens = stack.prevNode && sourceCode
-                    .getTokensBetween(stack.prevNode, node, { includeComments: true });
-
-                let isBlankLineBetweenNodes = stack.prevBlankLine;
-
-                if (tokens) {
-
-                    // check blank line between tokens
-                    tokens.forEach((token, index) => {
-                        const previousToken = tokens[index - 1];
-
-                        if (previousToken && (token.loc.start.line - previousToken.loc.end.line > 1)) {
-                            isBlankLineBetweenNodes = true;
-                        }
-                    });
-
-                    // check blank line between the current node and the last token
-                    if (!isBlankLineBetweenNodes && (node.loc.start.line - tokens.at(-1).loc.end.line > 1)) {
-                        isBlankLineBetweenNodes = true;
-                    }
-
-                    // check blank line between the first token and the previous node
-                    if (!isBlankLineBetweenNodes && (tokens[0].loc.start.line - stack.prevNode.loc.end.line > 1)) {
-                        isBlankLineBetweenNodes = true;
-                    }
-                }
-
-                stack.prevNode = node;
-
-                if (thisName !== null) {
-                    stack.prevName = thisName;
-                }
-
-                if (allowLineSeparatedGroups && isBlankLineBetweenNodes) {
-                    stack.prevBlankLine = thisName === null;
-                    return;
-                }
-
-                if (prevName === null || thisName === null || numKeys < minKeys) {
-                    return;
-                }
-
-                if (!isValidOrder(prevName, thisName)) {
-                    context.report({
-                        node,
-                        loc: node.key.loc,
-                        messageId: "sortKeys",
-                        data: {
-                            thisName,
-                            prevName,
-                            order,
-                            insensitive: insensitive ? "insensitive " : "",
-                            natural: natural ? "natural " : ""
-                        }
-                    });
-                }
-            }
-        };
-    }
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/sort-vars.js

@@ -1,104 +0,0 @@
-/**
- * @fileoverview Rule to require sorting of variables within a single Variable Declaration block
- * @author Ilya Volodin
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Require variables within the same declaration block to be sorted",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/sort-vars"
-        },
-
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    ignoreCase: {
-                        type: "boolean",
-                        default: false
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
-
-        fixable: "code",
-
-        messages: {
-            sortVars: "Variables within the same declaration block should be sorted alphabetically."
-        }
-    },
-
-    create(context) {
-
-        const configuration = context.options[0] || {},
-            ignoreCase = configuration.ignoreCase || false,
-            sourceCode = context.sourceCode;
-
-        return {
-            VariableDeclaration(node) {
-                const idDeclarations = node.declarations.filter(decl => decl.id.type === "Identifier");
-                const getSortableName = ignoreCase ? decl => decl.id.name.toLowerCase() : decl => decl.id.name;
-                const unfixable = idDeclarations.some(decl => decl.init !== null && decl.init.type !== "Literal");
-                let fixed = false;
-
-                idDeclarations.slice(1).reduce((memo, decl) => {
-                    const lastVariableName = getSortableName(memo),
-                        currentVariableName = getSortableName(decl);
-
-                    if (currentVariableName < lastVariableName) {
-                        context.report({
-                            node: decl,
-                            messageId: "sortVars",
-                            fix(fixer) {
-                                if (unfixable || fixed) {
-                                    return null;
-                                }
-                                return fixer.replaceTextRange(
-                                    [idDeclarations[0].range[0], idDeclarations.at(-1).range[1]],
-                                    idDeclarations
-
-                                        // Clone the idDeclarations array to avoid mutating it
-                                        .slice()
-
-                                        // Sort the array into the desired order
-                                        .sort((declA, declB) => {
-                                            const aName = getSortableName(declA);
-                                            const bName = getSortableName(declB);
-
-                                            return aName > bName ? 1 : -1;
-                                        })
-
-                                        // Build a string out of the sorted list of identifier declarations and the text between the originals
-                                        .reduce((sourceText, identifier, index) => {
-                                            const textAfterIdentifier = index === idDeclarations.length - 1
-                                                ? ""
-                                                : sourceCode.getText().slice(idDeclarations[index].range[1], idDeclarations[index + 1].range[0]);
-
-                                            return sourceText + sourceCode.getText(identifier) + textAfterIdentifier;
-                                        }, "")
-
-                                );
-                            }
-                        });
-                        fixed = true;
-                        return memo;
-                    }
-                    return decl;
-
-                }, idDeclarations[0]);
-            }
-        };
-    }
-};