decidim 0.27.1 → 0.27.2

data/packages/webpacker/node_modules/eslint/lib/rules/no-useless-return.js

@@ -1,305 +0,0 @@
-/**
- * @fileoverview Disallow redundant return statements
- * @author Teddy Katz
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils"),
-    FixTracker = require("./utils/fix-tracker");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Removes the given element from the array.
- * @param {Array} array The source array to remove.
- * @param {any} element The target item to remove.
- * @returns {void}
- */
-function remove(array, element) {
-    const index = array.indexOf(element);
-
-    if (index !== -1) {
-        array.splice(index, 1);
-    }
-}
-
-/**
- * Checks whether it can remove the given return statement or not.
- * @param {ASTNode} node The return statement node to check.
- * @returns {boolean} `true` if the node is removable.
- */
-function isRemovable(node) {
-    return astUtils.STATEMENT_LIST_PARENTS.has(node.parent.type);
-}
-
-/**
- * Checks whether the given return statement is in a `finally` block or not.
- * @param {ASTNode} node The return statement node to check.
- * @returns {boolean} `true` if the node is in a `finally` block.
- */
-function isInFinally(node) {
-    for (
-        let currentNode = node;
-        currentNode && currentNode.parent && !astUtils.isFunction(currentNode);
-        currentNode = currentNode.parent
-    ) {
-        if (currentNode.parent.type === "TryStatement" && currentNode.parent.finalizer === currentNode) {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "disallow redundant return statements",
-            recommended: false,
-            url: "https://eslint.org/docs/rules/no-useless-return"
-        },
-
-        fixable: "code",
-        schema: [],
-
-        messages: {
-            unnecessaryReturn: "Unnecessary return statement."
-        }
-    },
-
-    create(context) {
-        const segmentInfoMap = new WeakMap();
-        const usedUnreachableSegments = new WeakSet();
-        const sourceCode = context.getSourceCode();
-        let scopeInfo = null;
-
-        /**
-         * Checks whether the given segment is terminated by a return statement or not.
-         * @param {CodePathSegment} segment The segment to check.
-         * @returns {boolean} `true` if the segment is terminated by a return statement, or if it's still a part of unreachable.
-         */
-        function isReturned(segment) {
-            const info = segmentInfoMap.get(segment);
-
-            return !info || info.returned;
-        }
-
-        /**
-         * Collects useless return statements from the given previous segments.
-         *
-         * A previous segment may be an unreachable segment.
-         * In that case, the information object of the unreachable segment is not
-         * initialized because `onCodePathSegmentStart` event is not notified for
-         * unreachable segments.
-         * This goes to the previous segments of the unreachable segment recursively
-         * if the unreachable segment was generated by a return statement. Otherwise,
-         * this ignores the unreachable segment.
-         *
-         * This behavior would simulate code paths for the case that the return
-         * statement does not exist.
-         * @param {ASTNode[]} uselessReturns The collected return statements.
-         * @param {CodePathSegment[]} prevSegments The previous segments to traverse.
-         * @param {WeakSet<CodePathSegment>} [providedTraversedSegments] A set of segments that have already been traversed in this call
-         * @returns {ASTNode[]} `uselessReturns`.
-         */
-        function getUselessReturns(uselessReturns, prevSegments, providedTraversedSegments) {
-            const traversedSegments = providedTraversedSegments || new WeakSet();
-
-            for (const segment of prevSegments) {
-                if (!segment.reachable) {
-                    if (!traversedSegments.has(segment)) {
-                        traversedSegments.add(segment);
-                        getUselessReturns(
-                            uselessReturns,
-                            segment.allPrevSegments.filter(isReturned),
-                            traversedSegments
-                        );
-                    }
-                    continue;
-                }
-
-                uselessReturns.push(...segmentInfoMap.get(segment).uselessReturns);
-            }
-
-            return uselessReturns;
-        }
-
-        /**
-         * Removes the return statements on the given segment from the useless return
-         * statement list.
-         *
-         * This segment may be an unreachable segment.
-         * In that case, the information object of the unreachable segment is not
-         * initialized because `onCodePathSegmentStart` event is not notified for
-         * unreachable segments.
-         * This goes to the previous segments of the unreachable segment recursively
-         * if the unreachable segment was generated by a return statement. Otherwise,
-         * this ignores the unreachable segment.
-         *
-         * This behavior would simulate code paths for the case that the return
-         * statement does not exist.
-         * @param {CodePathSegment} segment The segment to get return statements.
-         * @returns {void}
-         */
-        function markReturnStatementsOnSegmentAsUsed(segment) {
-            if (!segment.reachable) {
-                usedUnreachableSegments.add(segment);
-                segment.allPrevSegments
-                    .filter(isReturned)
-                    .filter(prevSegment => !usedUnreachableSegments.has(prevSegment))
-                    .forEach(markReturnStatementsOnSegmentAsUsed);
-                return;
-            }
-
-            const info = segmentInfoMap.get(segment);
-
-            for (const node of info.uselessReturns) {
-                remove(scopeInfo.uselessReturns, node);
-            }
-            info.uselessReturns = [];
-        }
-
-        /**
-         * Removes the return statements on the current segments from the useless
-         * return statement list.
-         *
-         * This function will be called at every statement except FunctionDeclaration,
-         * BlockStatement, and BreakStatement.
-         *
-         * - FunctionDeclarations are always executed whether it's returned or not.
-         * - BlockStatements do nothing.
-         * - BreakStatements go the next merely.
-         * @returns {void}
-         */
-        function markReturnStatementsOnCurrentSegmentsAsUsed() {
-            scopeInfo
-                .codePath
-                .currentSegments
-                .forEach(markReturnStatementsOnSegmentAsUsed);
-        }
-
-        //----------------------------------------------------------------------
-        // Public
-        //----------------------------------------------------------------------
-
-        return {
-
-            // Makes and pushs a new scope information.
-            onCodePathStart(codePath) {
-                scopeInfo = {
-                    upper: scopeInfo,
-                    uselessReturns: [],
-                    codePath
-                };
-            },
-
-            // Reports useless return statements if exist.
-            onCodePathEnd() {
-                for (const node of scopeInfo.uselessReturns) {
-                    context.report({
-                        node,
-                        loc: node.loc,
-                        messageId: "unnecessaryReturn",
-                        fix(fixer) {
-                            if (isRemovable(node) && !sourceCode.getCommentsInside(node).length) {
-
-                                /*
-                                 * Extend the replacement range to include the
-                                 * entire function to avoid conflicting with
-                                 * no-else-return.
-                                 * https://github.com/eslint/eslint/issues/8026
-                                 */
-                                return new FixTracker(fixer, sourceCode)
-                                    .retainEnclosingFunction(node)
-                                    .remove(node);
-                            }
-                            return null;
-                        }
-                    });
-                }
-
-                scopeInfo = scopeInfo.upper;
-            },
-
-            /*
-             * Initializes segments.
-             * NOTE: This event is notified for only reachable segments.
-             */
-            onCodePathSegmentStart(segment) {
-                const info = {
-                    uselessReturns: getUselessReturns([], segment.allPrevSegments),
-                    returned: false
-                };
-
-                // Stores the info.
-                segmentInfoMap.set(segment, info);
-            },
-
-            // Adds ReturnStatement node to check whether it's useless or not.
-            ReturnStatement(node) {
-                if (node.argument) {
-                    markReturnStatementsOnCurrentSegmentsAsUsed();
-                }
-                if (
-                    node.argument ||
-                    astUtils.isInLoop(node) ||
-                    isInFinally(node) ||
-
-                    // Ignore `return` statements in unreachable places (https://github.com/eslint/eslint/issues/11647).
-                    !scopeInfo.codePath.currentSegments.some(s => s.reachable)
-                ) {
-                    return;
-                }
-
-                for (const segment of scopeInfo.codePath.currentSegments) {
-                    const info = segmentInfoMap.get(segment);
-
-                    if (info) {
-                        info.uselessReturns.push(node);
-                        info.returned = true;
-                    }
-                }
-                scopeInfo.uselessReturns.push(node);
-            },
-
-            /*
-             * Registers for all statement nodes except FunctionDeclaration, BlockStatement, BreakStatement.
-             * Removes return statements of the current segments from the useless return statement list.
-             */
-            ClassDeclaration: markReturnStatementsOnCurrentSegmentsAsUsed,
-            ContinueStatement: markReturnStatementsOnCurrentSegmentsAsUsed,
-            DebuggerStatement: markReturnStatementsOnCurrentSegmentsAsUsed,
-            DoWhileStatement: markReturnStatementsOnCurrentSegmentsAsUsed,
-            EmptyStatement: markReturnStatementsOnCurrentSegmentsAsUsed,
-            ExpressionStatement: markReturnStatementsOnCurrentSegmentsAsUsed,
-            ForInStatement: markReturnStatementsOnCurrentSegmentsAsUsed,
-            ForOfStatement: markReturnStatementsOnCurrentSegmentsAsUsed,
-            ForStatement: markReturnStatementsOnCurrentSegmentsAsUsed,
-            IfStatement: markReturnStatementsOnCurrentSegmentsAsUsed,
-            ImportDeclaration: markReturnStatementsOnCurrentSegmentsAsUsed,
-            LabeledStatement: markReturnStatementsOnCurrentSegmentsAsUsed,
-            SwitchStatement: markReturnStatementsOnCurrentSegmentsAsUsed,
-            ThrowStatement: markReturnStatementsOnCurrentSegmentsAsUsed,
-            TryStatement: markReturnStatementsOnCurrentSegmentsAsUsed,
-            VariableDeclaration: markReturnStatementsOnCurrentSegmentsAsUsed,
-            WhileStatement: markReturnStatementsOnCurrentSegmentsAsUsed,
-            WithStatement: markReturnStatementsOnCurrentSegmentsAsUsed,
-            ExportNamedDeclaration: markReturnStatementsOnCurrentSegmentsAsUsed,
-            ExportDefaultDeclaration: markReturnStatementsOnCurrentSegmentsAsUsed,
-            ExportAllDeclaration: markReturnStatementsOnCurrentSegmentsAsUsed
-        };
-    }
-};

data/packages/webpacker/node_modules/eslint/lib/rules/no-var.js

@@ -1,334 +0,0 @@
-/**
- * @fileoverview Rule to check for the usage of var.
- * @author Jamund Ferguson
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Check whether a given variable is a global variable or not.
- * @param {eslint-scope.Variable} variable The variable to check.
- * @returns {boolean} `true` if the variable is a global variable.
- */
-function isGlobal(variable) {
-    return Boolean(variable.scope) && variable.scope.type === "global";
-}
-
-/**
- * Finds the nearest function scope or global scope walking up the scope
- * hierarchy.
- * @param {eslint-scope.Scope} scope The scope to traverse.
- * @returns {eslint-scope.Scope} a function scope or global scope containing the given
- *      scope.
- */
-function getEnclosingFunctionScope(scope) {
-    let currentScope = scope;
-
-    while (currentScope.type !== "function" && currentScope.type !== "global") {
-        currentScope = currentScope.upper;
-    }
-    return currentScope;
-}
-
-/**
- * Checks whether the given variable has any references from a more specific
- * function expression (i.e. a closure).
- * @param {eslint-scope.Variable} variable A variable to check.
- * @returns {boolean} `true` if the variable is used from a closure.
- */
-function isReferencedInClosure(variable) {
-    const enclosingFunctionScope = getEnclosingFunctionScope(variable.scope);
-
-    return variable.references.some(reference =>
-        getEnclosingFunctionScope(reference.from) !== enclosingFunctionScope);
-}
-
-/**
- * Checks whether the given node is the assignee of a loop.
- * @param {ASTNode} node A VariableDeclaration node to check.
- * @returns {boolean} `true` if the declaration is assigned as part of loop
- *      iteration.
- */
-function isLoopAssignee(node) {
-    return (node.parent.type === "ForOfStatement" || node.parent.type === "ForInStatement") &&
-        node === node.parent.left;
-}
-
-/**
- * Checks whether the given variable declaration is immediately initialized.
- * @param {ASTNode} node A VariableDeclaration node to check.
- * @returns {boolean} `true` if the declaration has an initializer.
- */
-function isDeclarationInitialized(node) {
-    return node.declarations.every(declarator => declarator.init !== null);
-}
-
-const SCOPE_NODE_TYPE = /^(?:Program|BlockStatement|SwitchStatement|ForStatement|ForInStatement|ForOfStatement)$/u;
-
-/**
- * Gets the scope node which directly contains a given node.
- * @param {ASTNode} node A node to get. This is a `VariableDeclaration` or
- *      an `Identifier`.
- * @returns {ASTNode} A scope node. This is one of `Program`, `BlockStatement`,
- *      `SwitchStatement`, `ForStatement`, `ForInStatement`, and
- *      `ForOfStatement`.
- */
-function getScopeNode(node) {
-    for (let currentNode = node; currentNode; currentNode = currentNode.parent) {
-        if (SCOPE_NODE_TYPE.test(currentNode.type)) {
-            return currentNode;
-        }
-    }
-
-    /* istanbul ignore next : unreachable */
-    return null;
-}
-
-/**
- * Checks whether a given variable is redeclared or not.
- * @param {eslint-scope.Variable} variable A variable to check.
- * @returns {boolean} `true` if the variable is redeclared.
- */
-function isRedeclared(variable) {
-    return variable.defs.length >= 2;
-}
-
-/**
- * Checks whether a given variable is used from outside of the specified scope.
- * @param {ASTNode} scopeNode A scope node to check.
- * @returns {Function} The predicate function which checks whether a given
- *      variable is used from outside of the specified scope.
- */
-function isUsedFromOutsideOf(scopeNode) {
-
-    /**
-     * Checks whether a given reference is inside of the specified scope or not.
-     * @param {eslint-scope.Reference} reference A reference to check.
-     * @returns {boolean} `true` if the reference is inside of the specified
-     *      scope.
-     */
-    function isOutsideOfScope(reference) {
-        const scope = scopeNode.range;
-        const id = reference.identifier.range;
-
-        return id[0] < scope[0] || id[1] > scope[1];
-    }
-
-    return function(variable) {
-        return variable.references.some(isOutsideOfScope);
-    };
-}
-
-/**
- * Creates the predicate function which checks whether a variable has their references in TDZ.
- *
- * The predicate function would return `true`:
- *
- * - if a reference is before the declarator. E.g. (var a = b, b = 1;)(var {a = b, b} = {};)
- * - if a reference is in the expression of their default value.  E.g. (var {a = a} = {};)
- * - if a reference is in the expression of their initializer.  E.g. (var a = a;)
- * @param {ASTNode} node The initializer node of VariableDeclarator.
- * @returns {Function} The predicate function.
- * @private
- */
-function hasReferenceInTDZ(node) {
-    const initStart = node.range[0];
-    const initEnd = node.range[1];
-
-    return variable => {
-        const id = variable.defs[0].name;
-        const idStart = id.range[0];
-        const defaultValue = (id.parent.type === "AssignmentPattern" ? id.parent.right : null);
-        const defaultStart = defaultValue && defaultValue.range[0];
-        const defaultEnd = defaultValue && defaultValue.range[1];
-
-        return variable.references.some(reference => {
-            const start = reference.identifier.range[0];
-            const end = reference.identifier.range[1];
-
-            return !reference.init && (
-                start < idStart ||
-                (defaultValue !== null && start >= defaultStart && end <= defaultEnd) ||
-                (start >= initStart && end <= initEnd)
-            );
-        });
-    };
-}
-
-/**
- * Checks whether a given variable has name that is allowed for 'var' declarations,
- * but disallowed for `let` declarations.
- * @param {eslint-scope.Variable} variable The variable to check.
- * @returns {boolean} `true` if the variable has a disallowed name.
- */
-function hasNameDisallowedForLetDeclarations(variable) {
-    return variable.name === "let";
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "require `let` or `const` instead of `var`",
-            recommended: false,
-            url: "https://eslint.org/docs/rules/no-var"
-        },
-
-        schema: [],
-        fixable: "code",
-
-        messages: {
-            unexpectedVar: "Unexpected var, use let or const instead."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.getSourceCode();
-
-        /**
-         * Checks whether the variables which are defined by the given declarator node have their references in TDZ.
-         * @param {ASTNode} declarator The VariableDeclarator node to check.
-         * @returns {boolean} `true` if one of the variables which are defined by the given declarator node have their references in TDZ.
-         */
-        function hasSelfReferenceInTDZ(declarator) {
-            if (!declarator.init) {
-                return false;
-            }
-            const variables = context.getDeclaredVariables(declarator);
-
-            return variables.some(hasReferenceInTDZ(declarator.init));
-        }
-
-        /**
-         * Checks whether it can fix a given variable declaration or not.
-         * It cannot fix if the following cases:
-         *
-         * - A variable is a global variable.
-         * - A variable is declared on a SwitchCase node.
-         * - A variable is redeclared.
-         * - A variable is used from outside the scope.
-         * - A variable is used from a closure within a loop.
-         * - A variable might be used before it is assigned within a loop.
-         * - A variable might be used in TDZ.
-         * - A variable is declared in statement position (e.g. a single-line `IfStatement`)
-         * - A variable has name that is disallowed for `let` declarations.
-         *
-         * ## A variable is declared on a SwitchCase node.
-         *
-         * If this rule modifies 'var' declarations on a SwitchCase node, it
-         * would generate the warnings of 'no-case-declarations' rule. And the
-         * 'eslint:recommended' preset includes 'no-case-declarations' rule, so
-         * this rule doesn't modify those declarations.
-         *
-         * ## A variable is redeclared.
-         *
-         * The language spec disallows redeclarations of `let` declarations.
-         * Those variables would cause syntax errors.
-         *
-         * ## A variable is used from outside the scope.
-         *
-         * The language spec disallows accesses from outside of the scope for
-         * `let` declarations. Those variables would cause reference errors.
-         *
-         * ## A variable is used from a closure within a loop.
-         *
-         * A `var` declaration within a loop shares the same variable instance
-         * across all loop iterations, while a `let` declaration creates a new
-         * instance for each iteration. This means if a variable in a loop is
-         * referenced by any closure, changing it from `var` to `let` would
-         * change the behavior in a way that is generally unsafe.
-         *
-         * ## A variable might be used before it is assigned within a loop.
-         *
-         * Within a loop, a `let` declaration without an initializer will be
-         * initialized to null, while a `var` declaration will retain its value
-         * from the previous iteration, so it is only safe to change `var` to
-         * `let` if we can statically determine that the variable is always
-         * assigned a value before its first access in the loop body. To keep
-         * the implementation simple, we only convert `var` to `let` within
-         * loops when the variable is a loop assignee or the declaration has an
-         * initializer.
-         * @param {ASTNode} node A variable declaration node to check.
-         * @returns {boolean} `true` if it can fix the node.
-         */
-        function canFix(node) {
-            const variables = context.getDeclaredVariables(node);
-            const scopeNode = getScopeNode(node);
-
-            if (node.parent.type === "SwitchCase" ||
-                node.declarations.some(hasSelfReferenceInTDZ) ||
-                variables.some(isGlobal) ||
-                variables.some(isRedeclared) ||
-                variables.some(isUsedFromOutsideOf(scopeNode)) ||
-                variables.some(hasNameDisallowedForLetDeclarations)
-            ) {
-                return false;
-            }
-
-            if (astUtils.isInLoop(node)) {
-                if (variables.some(isReferencedInClosure)) {
-                    return false;
-                }
-                if (!isLoopAssignee(node) && !isDeclarationInitialized(node)) {
-                    return false;
-                }
-            }
-
-            if (
-                !isLoopAssignee(node) &&
-                !(node.parent.type === "ForStatement" && node.parent.init === node) &&
-                !astUtils.STATEMENT_LIST_PARENTS.has(node.parent.type)
-            ) {
-
-                // If the declaration is not in a block, e.g. `if (foo) var bar = 1;`, then it can't be fixed.
-                return false;
-            }
-
-            return true;
-        }
-
-        /**
-         * Reports a given variable declaration node.
-         * @param {ASTNode} node A variable declaration node to report.
-         * @returns {void}
-         */
-        function report(node) {
-            context.report({
-                node,
-                messageId: "unexpectedVar",
-
-                fix(fixer) {
-                    const varToken = sourceCode.getFirstToken(node, { filter: t => t.value === "var" });
-
-                    return canFix(node)
-                        ? fixer.replaceText(varToken, "let")
-                        : null;
-                }
-            });
-        }
-
-        return {
-            "VariableDeclaration:exit"(node) {
-                if (node.kind === "var") {
-                    report(node);
-                }
-            }
-        };
-    }
-};

data/packages/webpacker/node_modules/eslint/lib/rules/no-void.js

@@ -1,64 +0,0 @@
-/**
- * @fileoverview Rule to disallow use of void operator.
- * @author Mike Sidorov
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "disallow `void` operators",
-            recommended: false,
-            url: "https://eslint.org/docs/rules/no-void"
-        },
-
-        messages: {
-            noVoid: "Expected 'undefined' and instead saw 'void'."
-        },
-
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    allowAsStatement: {
-                        type: "boolean",
-                        default: false
-                    }
-                },
-                additionalProperties: false
-            }
-        ]
-    },
-
-    create(context) {
-        const allowAsStatement =
-            context.options[0] && context.options[0].allowAsStatement;
-
-        //--------------------------------------------------------------------------
-        // Public
-        //--------------------------------------------------------------------------
-
-        return {
-            'UnaryExpression[operator="void"]'(node) {
-                if (
-                    allowAsStatement &&
-                    node.parent &&
-                    node.parent.type === "ExpressionStatement"
-                ) {
-                    return;
-                }
-                context.report({
-                    node,
-                    messageId: "noVoid"
-                });
-            }
-        };
-    }
-};