decidim 0.26.4 → 0.26.7

data/packages/webpacker/node_modules/eslint/lib/rules/vars-on-top.js

@@ -1,157 +0,0 @@
-/**
- * @fileoverview Rule to enforce var declarations are only at the top of a function.
- * @author Danny Fritz
- * @author Gyandeep Singh
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "require `var` declarations be placed at the top of their containing scope",
-            recommended: false,
-            url: "https://eslint.org/docs/rules/vars-on-top"
-        },
-
-        schema: [],
-        messages: {
-            top: "All 'var' declarations must be at the top of the function scope."
-        }
-    },
-
-    create(context) {
-
-        //--------------------------------------------------------------------------
-        // Helpers
-        //--------------------------------------------------------------------------
-
-        /**
-         * Has AST suggesting a directive.
-         * @param {ASTNode} node any node
-         * @returns {boolean} whether the given node structurally represents a directive
-         */
-        function looksLikeDirective(node) {
-            return node.type === "ExpressionStatement" &&
-                node.expression.type === "Literal" && typeof node.expression.value === "string";
-        }
-
-        /**
-         * Check to see if its a ES6 import declaration
-         * @param {ASTNode} node any node
-         * @returns {boolean} whether the given node represents a import declaration
-         */
-        function looksLikeImport(node) {
-            return node.type === "ImportDeclaration" || node.type === "ImportSpecifier" ||
-                node.type === "ImportDefaultSpecifier" || node.type === "ImportNamespaceSpecifier";
-        }
-
-        /**
-         * Checks whether a given node is a variable declaration or not.
-         * @param {ASTNode} node any node
-         * @returns {boolean} `true` if the node is a variable declaration.
-         */
-        function isVariableDeclaration(node) {
-            return (
-                node.type === "VariableDeclaration" ||
-                (
-                    node.type === "ExportNamedDeclaration" &&
-                    node.declaration &&
-                    node.declaration.type === "VariableDeclaration"
-                )
-            );
-        }
-
-        /**
-         * Checks whether this variable is on top of the block body
-         * @param {ASTNode} node The node to check
-         * @param {ASTNode[]} statements collection of ASTNodes for the parent node block
-         * @returns {boolean} True if var is on top otherwise false
-         */
-        function isVarOnTop(node, statements) {
-            const l = statements.length;
-            let i = 0;
-
-            // Skip over directives and imports. Static blocks don't have either.
-            if (node.parent.type !== "StaticBlock") {
-                for (; i < l; ++i) {
-                    if (!looksLikeDirective(statements[i]) && !looksLikeImport(statements[i])) {
-                        break;
-                    }
-                }
-            }
-
-            for (; i < l; ++i) {
-                if (!isVariableDeclaration(statements[i])) {
-                    return false;
-                }
-                if (statements[i] === node) {
-                    return true;
-                }
-            }
-
-            return false;
-        }
-
-        /**
-         * Checks whether variable is on top at the global level
-         * @param {ASTNode} node The node to check
-         * @param {ASTNode} parent Parent of the node
-         * @returns {void}
-         */
-        function globalVarCheck(node, parent) {
-            if (!isVarOnTop(node, parent.body)) {
-                context.report({ node, messageId: "top" });
-            }
-        }
-
-        /**
-         * Checks whether variable is on top at functional block scope level
-         * @param {ASTNode} node The node to check
-         * @returns {void}
-         */
-        function blockScopeVarCheck(node) {
-            const { parent } = node;
-
-            if (
-                parent.type === "BlockStatement" &&
-                /Function/u.test(parent.parent.type) &&
-                isVarOnTop(node, parent.body)
-            ) {
-                return;
-            }
-
-            if (
-                parent.type === "StaticBlock" &&
-                isVarOnTop(node, parent.body)
-            ) {
-                return;
-            }
-
-            context.report({ node, messageId: "top" });
-        }
-
-        //--------------------------------------------------------------------------
-        // Public API
-        //--------------------------------------------------------------------------
-
-        return {
-            "VariableDeclaration[kind='var']"(node) {
-                if (node.parent.type === "ExportNamedDeclaration") {
-                    globalVarCheck(node.parent, node.parent.parent);
-                } else if (node.parent.type === "Program") {
-                    globalVarCheck(node, node.parent);
-                } else {
-                    blockScopeVarCheck(node);
-                }
-            }
-        };
-
-    }
-};

data/packages/webpacker/node_modules/eslint/lib/rules/wrap-iife.js

@@ -1,204 +0,0 @@
-/**
- * @fileoverview Rule to flag when IIFE is not wrapped in parens
- * @author Ilya Volodin
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-const eslintUtils = require("eslint-utils");
-
-//----------------------------------------------------------------------
-// Helpers
-//----------------------------------------------------------------------
-
-/**
- * Check if the given node is callee of a `NewExpression` node
- * @param {ASTNode} node node to check
- * @returns {boolean} True if the node is callee of a `NewExpression` node
- * @private
- */
-function isCalleeOfNewExpression(node) {
-    const maybeCallee = node.parent.type === "ChainExpression"
-        ? node.parent
-        : node;
-
-    return (
-        maybeCallee.parent.type === "NewExpression" &&
-        maybeCallee.parent.callee === maybeCallee
-    );
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "layout",
-
-        docs: {
-            description: "require parentheses around immediate `function` invocations",
-            recommended: false,
-            url: "https://eslint.org/docs/rules/wrap-iife"
-        },
-
-        schema: [
-            {
-                enum: ["outside", "inside", "any"]
-            },
-            {
-                type: "object",
-                properties: {
-                    functionPrototypeMethods: {
-                        type: "boolean",
-                        default: false
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
-
-        fixable: "code",
-        messages: {
-            wrapInvocation: "Wrap an immediate function invocation in parentheses.",
-            wrapExpression: "Wrap only the function expression in parens.",
-            moveInvocation: "Move the invocation into the parens that contain the function."
-        }
-    },
-
-    create(context) {
-
-        const style = context.options[0] || "outside";
-        const includeFunctionPrototypeMethods = context.options[1] && context.options[1].functionPrototypeMethods;
-
-        const sourceCode = context.getSourceCode();
-
-        /**
-         * Check if the node is wrapped in any (). All parens count: grouping parens and parens for constructs such as if()
-         * @param {ASTNode} node node to evaluate
-         * @returns {boolean} True if it is wrapped in any parens
-         * @private
-         */
-        function isWrappedInAnyParens(node) {
-            return astUtils.isParenthesised(sourceCode, node);
-        }
-
-        /**
-         * Check if the node is wrapped in grouping (). Parens for constructs such as if() don't count
-         * @param {ASTNode} node node to evaluate
-         * @returns {boolean} True if it is wrapped in grouping parens
-         * @private
-         */
-        function isWrappedInGroupingParens(node) {
-            return eslintUtils.isParenthesized(1, node, sourceCode);
-        }
-
-        /**
-         * Get the function node from an IIFE
-         * @param {ASTNode} node node to evaluate
-         * @returns {ASTNode} node that is the function expression of the given IIFE, or null if none exist
-         */
-        function getFunctionNodeFromIIFE(node) {
-            const callee = astUtils.skipChainExpression(node.callee);
-
-            if (callee.type === "FunctionExpression") {
-                return callee;
-            }
-
-            if (includeFunctionPrototypeMethods &&
-                callee.type === "MemberExpression" &&
-                callee.object.type === "FunctionExpression" &&
-                (astUtils.getStaticPropertyName(callee) === "call" || astUtils.getStaticPropertyName(callee) === "apply")
-            ) {
-                return callee.object;
-            }
-
-            return null;
-        }
-
-
-        return {
-            CallExpression(node) {
-                const innerNode = getFunctionNodeFromIIFE(node);
-
-                if (!innerNode) {
-                    return;
-                }
-
-                const isCallExpressionWrapped = isWrappedInAnyParens(node),
-                    isFunctionExpressionWrapped = isWrappedInAnyParens(innerNode);
-
-                if (!isCallExpressionWrapped && !isFunctionExpressionWrapped) {
-                    context.report({
-                        node,
-                        messageId: "wrapInvocation",
-                        fix(fixer) {
-                            const nodeToSurround = style === "inside" ? innerNode : node;
-
-                            return fixer.replaceText(nodeToSurround, `(${sourceCode.getText(nodeToSurround)})`);
-                        }
-                    });
-                } else if (style === "inside" && !isFunctionExpressionWrapped) {
-                    context.report({
-                        node,
-                        messageId: "wrapExpression",
-                        fix(fixer) {
-
-                            // The outer call expression will always be wrapped at this point.
-
-                            if (isWrappedInGroupingParens(node) && !isCalleeOfNewExpression(node)) {
-
-                                /*
-                                 * Parenthesize the function expression and remove unnecessary grouping parens around the call expression.
-                                 * Replace the range between the end of the function expression and the end of the call expression.
-                                 * for example, in `(function(foo) {}(bar))`, the range `(bar))` should get replaced with `)(bar)`.
-                                 */
-
-                                const parenAfter = sourceCode.getTokenAfter(node);
-
-                                return fixer.replaceTextRange(
-                                    [innerNode.range[1], parenAfter.range[1]],
-                                    `)${sourceCode.getText().slice(innerNode.range[1], parenAfter.range[0])}`
-                                );
-                            }
-
-                            /*
-                             * Call expression is wrapped in mandatory parens such as if(), or in necessary grouping parens.
-                             * These parens cannot be removed, so just parenthesize the function expression.
-                             */
-
-                            return fixer.replaceText(innerNode, `(${sourceCode.getText(innerNode)})`);
-                        }
-                    });
-                } else if (style === "outside" && !isCallExpressionWrapped) {
-                    context.report({
-                        node,
-                        messageId: "moveInvocation",
-                        fix(fixer) {
-
-                            /*
-                             * The inner function expression will always be wrapped at this point.
-                             * It's only necessary to replace the range between the end of the function expression
-                             * and the call expression. For example, in `(function(foo) {})(bar)`, the range `)(bar)`
-                             * should get replaced with `(bar))`.
-                             */
-                            const parenAfter = sourceCode.getTokenAfter(innerNode);
-
-                            return fixer.replaceTextRange(
-                                [parenAfter.range[0], node.range[1]],
-                                `${sourceCode.getText().slice(parenAfter.range[1], node.range[1])})`
-                            );
-                        }
-                    });
-                }
-            }
-        };
-
-    }
-};

data/packages/webpacker/node_modules/eslint/lib/rules/wrap-regex.js

@@ -1,59 +0,0 @@
-/**
- * @fileoverview Rule to flag when regex literals are not wrapped in parens
- * @author Matt DuVall <http://www.mattduvall.com>
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "layout",
-
-        docs: {
-            description: "require parenthesis around regex literals",
-            recommended: false,
-            url: "https://eslint.org/docs/rules/wrap-regex"
-        },
-
-        schema: [],
-        fixable: "code",
-
-        messages: {
-            requireParens: "Wrap the regexp literal in parens to disambiguate the slash."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.getSourceCode();
-
-        return {
-
-            Literal(node) {
-                const token = sourceCode.getFirstToken(node),
-                    nodeType = token.type;
-
-                if (nodeType === "RegularExpression") {
-                    const beforeToken = sourceCode.getTokenBefore(node);
-                    const afterToken = sourceCode.getTokenAfter(node);
-                    const ancestors = context.getAncestors();
-                    const grandparent = ancestors[ancestors.length - 1];
-
-                    if (grandparent.type === "MemberExpression" && grandparent.object === node &&
-                        !(beforeToken && beforeToken.value === "(" && afterToken && afterToken.value === ")")) {
-                        context.report({
-                            node,
-                            messageId: "requireParens",
-                            fix: fixer => fixer.replaceText(node, `(${sourceCode.getText(node)})`)
-                        });
-                    }
-                }
-            }
-        };
-
-    }
-};

data/packages/webpacker/node_modules/eslint/lib/rules/yield-star-spacing.js

@@ -1,127 +0,0 @@
-/**
- * @fileoverview Rule to check the spacing around the * in yield* expressions.
- * @author Bryan Smith
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "layout",
-
-        docs: {
-            description: "require or disallow spacing around the `*` in `yield*` expressions",
-            recommended: false,
-            url: "https://eslint.org/docs/rules/yield-star-spacing"
-        },
-
-        fixable: "whitespace",
-
-        schema: [
-            {
-                oneOf: [
-                    {
-                        enum: ["before", "after", "both", "neither"]
-                    },
-                    {
-                        type: "object",
-                        properties: {
-                            before: { type: "boolean" },
-                            after: { type: "boolean" }
-                        },
-                        additionalProperties: false
-                    }
-                ]
-            }
-        ],
-        messages: {
-            missingBefore: "Missing space before *.",
-            missingAfter: "Missing space after *.",
-            unexpectedBefore: "Unexpected space before *.",
-            unexpectedAfter: "Unexpected space after *."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.getSourceCode();
-
-        const mode = (function(option) {
-            if (!option || typeof option === "string") {
-                return {
-                    before: { before: true, after: false },
-                    after: { before: false, after: true },
-                    both: { before: true, after: true },
-                    neither: { before: false, after: false }
-                }[option || "after"];
-            }
-            return option;
-        }(context.options[0]));
-
-        /**
-         * Checks the spacing between two tokens before or after the star token.
-         * @param {string} side Either "before" or "after".
-         * @param {Token} leftToken `function` keyword token if side is "before", or
-         *     star token if side is "after".
-         * @param {Token} rightToken Star token if side is "before", or identifier
-         *     token if side is "after".
-         * @returns {void}
-         */
-        function checkSpacing(side, leftToken, rightToken) {
-            if (sourceCode.isSpaceBetweenTokens(leftToken, rightToken) !== mode[side]) {
-                const after = leftToken.value === "*";
-                const spaceRequired = mode[side];
-                const node = after ? leftToken : rightToken;
-                let messageId = "";
-
-                if (spaceRequired) {
-                    messageId = side === "before" ? "missingBefore" : "missingAfter";
-                } else {
-                    messageId = side === "before" ? "unexpectedBefore" : "unexpectedAfter";
-                }
-
-                context.report({
-                    node,
-                    messageId,
-                    fix(fixer) {
-                        if (spaceRequired) {
-                            if (after) {
-                                return fixer.insertTextAfter(node, " ");
-                            }
-                            return fixer.insertTextBefore(node, " ");
-                        }
-                        return fixer.removeRange([leftToken.range[1], rightToken.range[0]]);
-                    }
-                });
-            }
-        }
-
-        /**
-         * Enforces the spacing around the star if node is a yield* expression.
-         * @param {ASTNode} node A yield expression node.
-         * @returns {void}
-         */
-        function checkExpression(node) {
-            if (!node.delegate) {
-                return;
-            }
-
-            const tokens = sourceCode.getFirstTokens(node, 3);
-            const yieldToken = tokens[0];
-            const starToken = tokens[1];
-            const nextToken = tokens[2];
-
-            checkSpacing("before", yieldToken, starToken);
-            checkSpacing("after", starToken, nextToken);
-        }
-
-        return {
-            YieldExpression: checkExpression
-        };
-
-    }
-};