@alexlit/lint-kit 127.0.0 → 127.2.0

package/packages/config-eslint/node_modules/eslint/lib/rules/radix.js

@@ -1,198 +0,0 @@
-/**
- * @fileoverview Rule to flag use of parseInt without a radix argument
- * @author James Allardice
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const MODE_ALWAYS = "always",
-    MODE_AS_NEEDED = "as-needed";
-
-const validRadixValues = new Set(Array.from({ length: 37 - 2 }, (_, index) => index + 2));
-
-/**
- * Checks whether a given variable is shadowed or not.
- * @param {eslint-scope.Variable} variable A variable to check.
- * @returns {boolean} `true` if the variable is shadowed.
- */
-function isShadowed(variable) {
-    return variable.defs.length >= 1;
-}
-
-/**
- * Checks whether a given node is a MemberExpression of `parseInt` method or not.
- * @param {ASTNode} node A node to check.
- * @returns {boolean} `true` if the node is a MemberExpression of `parseInt`
- *      method.
- */
-function isParseIntMethod(node) {
-    return (
-        node.type === "MemberExpression" &&
-        !node.computed &&
-        node.property.type === "Identifier" &&
-        node.property.name === "parseInt"
-    );
-}
-
-/**
- * Checks whether a given node is a valid value of radix or not.
- *
- * The following values are invalid.
- *
- * - A literal except integers between 2 and 36.
- * - undefined.
- * @param {ASTNode} radix A node of radix to check.
- * @returns {boolean} `true` if the node is valid.
- */
-function isValidRadix(radix) {
-    return !(
-        (radix.type === "Literal" && !validRadixValues.has(radix.value)) ||
-        (radix.type === "Identifier" && radix.name === "undefined")
-    );
-}
-
-/**
- * Checks whether a given node is a default value of radix or not.
- * @param {ASTNode} radix A node of radix to check.
- * @returns {boolean} `true` if the node is the literal node of `10`.
- */
-function isDefaultRadix(radix) {
-    return radix.type === "Literal" && radix.value === 10;
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Enforce the consistent use of the radix argument when using `parseInt()`",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/radix"
-        },
-
-        hasSuggestions: true,
-
-        schema: [
-            {
-                enum: ["always", "as-needed"]
-            }
-        ],
-
-        messages: {
-            missingParameters: "Missing parameters.",
-            redundantRadix: "Redundant radix parameter.",
-            missingRadix: "Missing radix parameter.",
-            invalidRadix: "Invalid radix parameter, must be an integer between 2 and 36.",
-            addRadixParameter10: "Add radix parameter `10` for parsing decimal numbers."
-        }
-    },
-
-    create(context) {
-        const mode = context.options[0] || MODE_ALWAYS;
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Checks the arguments of a given CallExpression node and reports it if it
-         * offends this rule.
-         * @param {ASTNode} node A CallExpression node to check.
-         * @returns {void}
-         */
-        function checkArguments(node) {
-            const args = node.arguments;
-
-            switch (args.length) {
-                case 0:
-                    context.report({
-                        node,
-                        messageId: "missingParameters"
-                    });
-                    break;
-
-                case 1:
-                    if (mode === MODE_ALWAYS) {
-                        context.report({
-                            node,
-                            messageId: "missingRadix",
-                            suggest: [
-                                {
-                                    messageId: "addRadixParameter10",
-                                    fix(fixer) {
-                                        const tokens = sourceCode.getTokens(node);
-                                        const lastToken = tokens.at(-1); // Parenthesis.
-                                        const secondToLastToken = tokens.at(-2); // May or may not be a comma.
-                                        const hasTrailingComma = secondToLastToken.type === "Punctuator" && secondToLastToken.value === ",";
-
-                                        return fixer.insertTextBefore(lastToken, hasTrailingComma ? " 10," : ", 10");
-                                    }
-                                }
-                            ]
-                        });
-                    }
-                    break;
-
-                default:
-                    if (mode === MODE_AS_NEEDED && isDefaultRadix(args[1])) {
-                        context.report({
-                            node,
-                            messageId: "redundantRadix"
-                        });
-                    } else if (!isValidRadix(args[1])) {
-                        context.report({
-                            node,
-                            messageId: "invalidRadix"
-                        });
-                    }
-                    break;
-            }
-        }
-
-        return {
-            "Program:exit"(node) {
-                const scope = sourceCode.getScope(node);
-                let variable;
-
-                // Check `parseInt()`
-                variable = astUtils.getVariableByName(scope, "parseInt");
-                if (variable && !isShadowed(variable)) {
-                    variable.references.forEach(reference => {
-                        const idNode = reference.identifier;
-
-                        if (astUtils.isCallee(idNode)) {
-                            checkArguments(idNode.parent);
-                        }
-                    });
-                }
-
-                // Check `Number.parseInt()`
-                variable = astUtils.getVariableByName(scope, "Number");
-                if (variable && !isShadowed(variable)) {
-                    variable.references.forEach(reference => {
-                        const parentNode = reference.identifier.parent;
-                        const maybeCallee = parentNode.parent.type === "ChainExpression"
-                            ? parentNode.parent
-                            : parentNode;
-
-                        if (isParseIntMethod(parentNode) && astUtils.isCallee(maybeCallee)) {
-                            checkArguments(maybeCallee.parent);
-                        }
-                    });
-                }
-            }
-        };
-    }
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/require-atomic-updates.js

@@ -1,331 +0,0 @@
-/**
- * @fileoverview disallow assignments that can lead to race conditions due to usage of `await` or `yield`
- * @author Teddy Katz
- * @author Toru Nagashima
- */
-"use strict";
-
-/**
- * Make the map from identifiers to each reference.
- * @param {escope.Scope} scope The scope to get references.
- * @param {Map<Identifier, escope.Reference>} [outReferenceMap] The map from identifier nodes to each reference object.
- * @returns {Map<Identifier, escope.Reference>} `referenceMap`.
- */
-function createReferenceMap(scope, outReferenceMap = new Map()) {
-    for (const reference of scope.references) {
-        if (reference.resolved === null) {
-            continue;
-        }
-
-        outReferenceMap.set(reference.identifier, reference);
-    }
-    for (const childScope of scope.childScopes) {
-        if (childScope.type !== "function") {
-            createReferenceMap(childScope, outReferenceMap);
-        }
-    }
-
-    return outReferenceMap;
-}
-
-/**
- * Get `reference.writeExpr` of a given reference.
- * If it's the read reference of MemberExpression in LHS, returns RHS in order to address `a.b = await a`
- * @param {escope.Reference} reference The reference to get.
- * @returns {Expression|null} The `reference.writeExpr`.
- */
-function getWriteExpr(reference) {
-    if (reference.writeExpr) {
-        return reference.writeExpr;
-    }
-    let node = reference.identifier;
-
-    while (node) {
-        const t = node.parent.type;
-
-        if (t === "AssignmentExpression" && node.parent.left === node) {
-            return node.parent.right;
-        }
-        if (t === "MemberExpression" && node.parent.object === node) {
-            node = node.parent;
-            continue;
-        }
-
-        break;
-    }
-
-    return null;
-}
-
-/**
- * Checks if an expression is a variable that can only be observed within the given function.
- * @param {Variable|null} variable The variable to check
- * @param {boolean} isMemberAccess If `true` then this is a member access.
- * @returns {boolean} `true` if the variable is local to the given function, and is never referenced in a closure.
- */
-function isLocalVariableWithoutEscape(variable, isMemberAccess) {
-    if (!variable) {
-        return false; // A global variable which was not defined.
-    }
-
-    // If the reference is a property access and the variable is a parameter, it handles the variable is not local.
-    if (isMemberAccess && variable.defs.some(d => d.type === "Parameter")) {
-        return false;
-    }
-
-    const functionScope = variable.scope.variableScope;
-
-    return variable.references.every(reference =>
-        reference.from.variableScope === functionScope);
-}
-
-/**
- * Represents segment information.
- */
-class SegmentInfo {
-    constructor() {
-        this.info = new WeakMap();
-    }
-
-    /**
-     * Initialize the segment information.
-     * @param {PathSegment} segment The segment to initialize.
-     * @returns {void}
-     */
-    initialize(segment) {
-        const outdatedReadVariables = new Set();
-        const freshReadVariables = new Set();
-
-        for (const prevSegment of segment.prevSegments) {
-            const info = this.info.get(prevSegment);
-
-            if (info) {
-                info.outdatedReadVariables.forEach(Set.prototype.add, outdatedReadVariables);
-                info.freshReadVariables.forEach(Set.prototype.add, freshReadVariables);
-            }
-        }
-
-        this.info.set(segment, { outdatedReadVariables, freshReadVariables });
-    }
-
-    /**
-     * Mark a given variable as read on given segments.
-     * @param {PathSegment[]} segments The segments that it read the variable on.
-     * @param {Variable} variable The variable to be read.
-     * @returns {void}
-     */
-    markAsRead(segments, variable) {
-        for (const segment of segments) {
-            const info = this.info.get(segment);
-
-            if (info) {
-                info.freshReadVariables.add(variable);
-
-                // If a variable is freshly read again, then it's no more out-dated.
-                info.outdatedReadVariables.delete(variable);
-            }
-        }
-    }
-
-    /**
-     * Move `freshReadVariables` to `outdatedReadVariables`.
-     * @param {PathSegment[]} segments The segments to process.
-     * @returns {void}
-     */
-    makeOutdated(segments) {
-        for (const segment of segments) {
-            const info = this.info.get(segment);
-
-            if (info) {
-                info.freshReadVariables.forEach(Set.prototype.add, info.outdatedReadVariables);
-                info.freshReadVariables.clear();
-            }
-        }
-    }
-
-    /**
-     * Check if a given variable is outdated on the current segments.
-     * @param {PathSegment[]} segments The current segments.
-     * @param {Variable} variable The variable to check.
-     * @returns {boolean} `true` if the variable is outdated on the segments.
-     */
-    isOutdated(segments, variable) {
-        for (const segment of segments) {
-            const info = this.info.get(segment);
-
-            if (info && info.outdatedReadVariables.has(variable)) {
-                return true;
-            }
-        }
-        return false;
-    }
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "problem",
-
-        docs: {
-            description: "Disallow assignments that can lead to race conditions due to usage of `await` or `yield`",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/require-atomic-updates"
-        },
-
-        fixable: null,
-
-        schema: [{
-            type: "object",
-            properties: {
-                allowProperties: {
-                    type: "boolean",
-                    default: false
-                }
-            },
-            additionalProperties: false
-        }],
-
-        messages: {
-            nonAtomicUpdate: "Possible race condition: `{{value}}` might be reassigned based on an outdated value of `{{value}}`.",
-            nonAtomicObjectUpdate: "Possible race condition: `{{value}}` might be assigned based on an outdated state of `{{object}}`."
-        }
-    },
-
-    create(context) {
-        const allowProperties = !!context.options[0] && context.options[0].allowProperties;
-
-        const sourceCode = context.sourceCode;
-        const assignmentReferences = new Map();
-        const segmentInfo = new SegmentInfo();
-        let stack = null;
-
-        return {
-            onCodePathStart(codePath, node) {
-                const scope = sourceCode.getScope(node);
-                const shouldVerify =
-                    scope.type === "function" &&
-                    (scope.block.async || scope.block.generator);
-
-                stack = {
-                    upper: stack,
-                    codePath,
-                    referenceMap: shouldVerify ? createReferenceMap(scope) : null,
-                    currentSegments: new Set()
-                };
-            },
-            onCodePathEnd() {
-                stack = stack.upper;
-            },
-
-            // Initialize the segment information.
-            onCodePathSegmentStart(segment) {
-                segmentInfo.initialize(segment);
-                stack.currentSegments.add(segment);
-            },
-
-            onUnreachableCodePathSegmentStart(segment) {
-                stack.currentSegments.add(segment);
-            },
-
-            onUnreachableCodePathSegmentEnd(segment) {
-                stack.currentSegments.delete(segment);
-            },
-
-            onCodePathSegmentEnd(segment) {
-                stack.currentSegments.delete(segment);
-            },
-
-
-            // Handle references to prepare verification.
-            Identifier(node) {
-                const { referenceMap } = stack;
-                const reference = referenceMap && referenceMap.get(node);
-
-                // Ignore if this is not a valid variable reference.
-                if (!reference) {
-                    return;
-                }
-                const variable = reference.resolved;
-                const writeExpr = getWriteExpr(reference);
-                const isMemberAccess = reference.identifier.parent.type === "MemberExpression";
-
-                // Add a fresh read variable.
-                if (reference.isRead() && !(writeExpr && writeExpr.parent.operator === "=")) {
-                    segmentInfo.markAsRead(stack.currentSegments, variable);
-                }
-
-                /*
-                 * Register the variable to verify after ESLint traversed the `writeExpr` node
-                 * if this reference is an assignment to a variable which is referred from other closure.
-                 */
-                if (writeExpr &&
-                    writeExpr.parent.right === writeExpr && // ← exclude variable declarations.
-                    !isLocalVariableWithoutEscape(variable, isMemberAccess)
-                ) {
-                    let refs = assignmentReferences.get(writeExpr);
-
-                    if (!refs) {
-                        refs = [];
-                        assignmentReferences.set(writeExpr, refs);
-                    }
-
-                    refs.push(reference);
-                }
-            },
-
-            /*
-             * Verify assignments.
-             * If the reference exists in `outdatedReadVariables` list, report it.
-             */
-            ":expression:exit"(node) {
-
-                // referenceMap exists if this is in a resumable function scope.
-                if (!stack.referenceMap) {
-                    return;
-                }
-
-                // Mark the read variables on this code path as outdated.
-                if (node.type === "AwaitExpression" || node.type === "YieldExpression") {
-                    segmentInfo.makeOutdated(stack.currentSegments);
-                }
-
-                // Verify.
-                const references = assignmentReferences.get(node);
-
-                if (references) {
-                    assignmentReferences.delete(node);
-
-                    for (const reference of references) {
-                        const variable = reference.resolved;
-
-                        if (segmentInfo.isOutdated(stack.currentSegments, variable)) {
-                            if (node.parent.left === reference.identifier) {
-                                context.report({
-                                    node: node.parent,
-                                    messageId: "nonAtomicUpdate",
-                                    data: {
-                                        value: variable.name
-                                    }
-                                });
-                            } else if (!allowProperties) {
-                                context.report({
-                                    node: node.parent,
-                                    messageId: "nonAtomicObjectUpdate",
-                                    data: {
-                                        value: sourceCode.getText(node.parent.left),
-                                        object: variable.name
-                                    }
-                                });
-                            }
-
-                        }
-                    }
-                }
-            }
-        };
-    }
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/require-await.js

@@ -1,147 +0,0 @@
-/**
- * @fileoverview Rule to disallow async functions which have no `await` expression.
- * @author Toru Nagashima
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Capitalize the 1st letter of the given text.
- * @param {string} text The text to capitalize.
- * @returns {string} The text that the 1st letter was capitalized.
- */
-function capitalizeFirstLetter(text) {
-    return text[0].toUpperCase() + text.slice(1);
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow async functions which have no `await` expression",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/require-await"
-        },
-
-        schema: [],
-
-        messages: {
-            missingAwait: "{{name}} has no 'await' expression.",
-            removeAsync: "Remove 'async'."
-        },
-
-        hasSuggestions: true
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-        let scopeInfo = null;
-
-        /**
-         * Push the scope info object to the stack.
-         * @returns {void}
-         */
-        function enterFunction() {
-            scopeInfo = {
-                upper: scopeInfo,
-                hasAwait: false
-            };
-        }
-
-        /**
-         * Pop the top scope info object from the stack.
-         * Also, it reports the function if needed.
-         * @param {ASTNode} node The node to report.
-         * @returns {void}
-         */
-        function exitFunction(node) {
-            if (!node.generator && node.async && !scopeInfo.hasAwait && !astUtils.isEmptyFunction(node)) {
-
-                /*
-                 * If the function belongs to a method definition or
-                 * property, then the function's range may not include the
-                 * `async` keyword and we should look at the parent instead.
-                 */
-                const nodeWithAsyncKeyword =
-                    (node.parent.type === "MethodDefinition" && node.parent.value === node) ||
-                    (node.parent.type === "Property" && node.parent.method && node.parent.value === node)
-                        ? node.parent
-                        : node;
-
-                const asyncToken = sourceCode.getFirstToken(nodeWithAsyncKeyword, token => token.value === "async");
-                const asyncRange = [asyncToken.range[0], sourceCode.getTokenAfter(asyncToken, { includeComments: true }).range[0]];
-
-                /*
-                 * Removing the `async` keyword can cause parsing errors if the current
-                 * statement is relying on automatic semicolon insertion. If ASI is currently
-                 * being used, then we should replace the `async` keyword with a semicolon.
-                 */
-                const nextToken = sourceCode.getTokenAfter(asyncToken);
-                const addSemiColon =
-                    nextToken.type === "Punctuator" &&
-                    (nextToken.value === "[" || nextToken.value === "(") &&
-                    (nodeWithAsyncKeyword.type === "MethodDefinition" || astUtils.isStartOfExpressionStatement(nodeWithAsyncKeyword)) &&
-                    astUtils.needsPrecedingSemicolon(sourceCode, nodeWithAsyncKeyword);
-
-                context.report({
-                    node,
-                    loc: astUtils.getFunctionHeadLoc(node, sourceCode),
-                    messageId: "missingAwait",
-                    data: {
-                        name: capitalizeFirstLetter(
-                            astUtils.getFunctionNameWithKind(node)
-                        )
-                    },
-                    suggest: [{
-                        messageId: "removeAsync",
-                        fix: fixer => fixer.replaceTextRange(asyncRange, addSemiColon ? ";" : "")
-                    }]
-                });
-            }
-
-            scopeInfo = scopeInfo.upper;
-        }
-
-        return {
-            FunctionDeclaration: enterFunction,
-            FunctionExpression: enterFunction,
-            ArrowFunctionExpression: enterFunction,
-            "FunctionDeclaration:exit": exitFunction,
-            "FunctionExpression:exit": exitFunction,
-            "ArrowFunctionExpression:exit": exitFunction,
-
-            AwaitExpression() {
-                if (!scopeInfo) {
-                    return;
-                }
-
-                scopeInfo.hasAwait = true;
-            },
-            ForOfStatement(node) {
-                if (!scopeInfo) {
-                    return;
-                }
-
-                if (node.await) {
-                    scopeInfo.hasAwait = true;
-                }
-            }
-        };
-    }
-};