decidim 0.26.0 → 0.27.0.rc1

data/packages/webpacker/node_modules/eslint/lib/rules/space-in-parens.js

@@ -0,0 +1,282 @@
+/**
+ * @fileoverview Disallows or enforces spaces inside of parentheses.
+ * @author Jonathan Rajavuori
+ */
+"use strict";
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../shared/types').Rule} */
+module.exports = {
+    meta: {
+        type: "layout",
+
+        docs: {
+            description: "enforce consistent spacing inside parentheses",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/space-in-parens"
+        },
+
+        fixable: "whitespace",
+
+        schema: [
+            {
+                enum: ["always", "never"]
+            },
+            {
+                type: "object",
+                properties: {
+                    exceptions: {
+                        type: "array",
+                        items: {
+                            enum: ["{}", "[]", "()", "empty"]
+                        },
+                        uniqueItems: true
+                    }
+                },
+                additionalProperties: false
+            }
+        ],
+
+        messages: {
+            missingOpeningSpace: "There must be a space after this paren.",
+            missingClosingSpace: "There must be a space before this paren.",
+            rejectedOpeningSpace: "There should be no space after this paren.",
+            rejectedClosingSpace: "There should be no space before this paren."
+        }
+    },
+
+    create(context) {
+        const ALWAYS = context.options[0] === "always",
+            exceptionsArrayOptions = (context.options[1] && context.options[1].exceptions) || [],
+            options = {};
+
+        let exceptions;
+
+        if (exceptionsArrayOptions.length) {
+            options.braceException = exceptionsArrayOptions.includes("{}");
+            options.bracketException = exceptionsArrayOptions.includes("[]");
+            options.parenException = exceptionsArrayOptions.includes("()");
+            options.empty = exceptionsArrayOptions.includes("empty");
+        }
+
+        /**
+         * Produces an object with the opener and closer exception values
+         * @returns {Object} `openers` and `closers` exception values
+         * @private
+         */
+        function getExceptions() {
+            const openers = [],
+                closers = [];
+
+            if (options.braceException) {
+                openers.push("{");
+                closers.push("}");
+            }
+
+            if (options.bracketException) {
+                openers.push("[");
+                closers.push("]");
+            }
+
+            if (options.parenException) {
+                openers.push("(");
+                closers.push(")");
+            }
+
+            if (options.empty) {
+                openers.push(")");
+                closers.push("(");
+            }
+
+            return {
+                openers,
+                closers
+            };
+        }
+
+        //--------------------------------------------------------------------------
+        // Helpers
+        //--------------------------------------------------------------------------
+        const sourceCode = context.getSourceCode();
+
+        /**
+         * Determines if a token is one of the exceptions for the opener paren
+         * @param {Object} token The token to check
+         * @returns {boolean} True if the token is one of the exceptions for the opener paren
+         */
+        function isOpenerException(token) {
+            return exceptions.openers.includes(token.value);
+        }
+
+        /**
+         * Determines if a token is one of the exceptions for the closer paren
+         * @param {Object} token The token to check
+         * @returns {boolean} True if the token is one of the exceptions for the closer paren
+         */
+        function isCloserException(token) {
+            return exceptions.closers.includes(token.value);
+        }
+
+        /**
+         * Determines if an opening paren is immediately followed by a required space
+         * @param {Object} openingParenToken The paren token
+         * @param {Object} tokenAfterOpeningParen The token after it
+         * @returns {boolean} True if the opening paren is missing a required space
+         */
+        function openerMissingSpace(openingParenToken, tokenAfterOpeningParen) {
+            if (sourceCode.isSpaceBetweenTokens(openingParenToken, tokenAfterOpeningParen)) {
+                return false;
+            }
+
+            if (!options.empty && astUtils.isClosingParenToken(tokenAfterOpeningParen)) {
+                return false;
+            }
+
+            if (ALWAYS) {
+                return !isOpenerException(tokenAfterOpeningParen);
+            }
+            return isOpenerException(tokenAfterOpeningParen);
+        }
+
+        /**
+         * Determines if an opening paren is immediately followed by a disallowed space
+         * @param {Object} openingParenToken The paren token
+         * @param {Object} tokenAfterOpeningParen The token after it
+         * @returns {boolean} True if the opening paren has a disallowed space
+         */
+        function openerRejectsSpace(openingParenToken, tokenAfterOpeningParen) {
+            if (!astUtils.isTokenOnSameLine(openingParenToken, tokenAfterOpeningParen)) {
+                return false;
+            }
+
+            if (tokenAfterOpeningParen.type === "Line") {
+                return false;
+            }
+
+            if (!sourceCode.isSpaceBetweenTokens(openingParenToken, tokenAfterOpeningParen)) {
+                return false;
+            }
+
+            if (ALWAYS) {
+                return isOpenerException(tokenAfterOpeningParen);
+            }
+            return !isOpenerException(tokenAfterOpeningParen);
+        }
+
+        /**
+         * Determines if a closing paren is immediately preceded by a required space
+         * @param {Object} tokenBeforeClosingParen The token before the paren
+         * @param {Object} closingParenToken The paren token
+         * @returns {boolean} True if the closing paren is missing a required space
+         */
+        function closerMissingSpace(tokenBeforeClosingParen, closingParenToken) {
+            if (sourceCode.isSpaceBetweenTokens(tokenBeforeClosingParen, closingParenToken)) {
+                return false;
+            }
+
+            if (!options.empty && astUtils.isOpeningParenToken(tokenBeforeClosingParen)) {
+                return false;
+            }
+
+            if (ALWAYS) {
+                return !isCloserException(tokenBeforeClosingParen);
+            }
+            return isCloserException(tokenBeforeClosingParen);
+        }
+
+        /**
+         * Determines if a closer paren is immediately preceded by a disallowed space
+         * @param {Object} tokenBeforeClosingParen The token before the paren
+         * @param {Object} closingParenToken The paren token
+         * @returns {boolean} True if the closing paren has a disallowed space
+         */
+        function closerRejectsSpace(tokenBeforeClosingParen, closingParenToken) {
+            if (!astUtils.isTokenOnSameLine(tokenBeforeClosingParen, closingParenToken)) {
+                return false;
+            }
+
+            if (!sourceCode.isSpaceBetweenTokens(tokenBeforeClosingParen, closingParenToken)) {
+                return false;
+            }
+
+            if (ALWAYS) {
+                return isCloserException(tokenBeforeClosingParen);
+            }
+            return !isCloserException(tokenBeforeClosingParen);
+        }
+
+        //--------------------------------------------------------------------------
+        // Public
+        //--------------------------------------------------------------------------
+
+        return {
+            Program: function checkParenSpaces(node) {
+                exceptions = getExceptions();
+                const tokens = sourceCode.tokensAndComments;
+
+                tokens.forEach((token, i) => {
+                    const prevToken = tokens[i - 1];
+                    const nextToken = tokens[i + 1];
+
+                    // if token is not an opening or closing paren token, do nothing
+                    if (!astUtils.isOpeningParenToken(token) && !astUtils.isClosingParenToken(token)) {
+                        return;
+                    }
+
+                    // if token is an opening paren and is not followed by a required space
+                    if (token.value === "(" && openerMissingSpace(token, nextToken)) {
+                        context.report({
+                            node,
+                            loc: token.loc,
+                            messageId: "missingOpeningSpace",
+                            fix(fixer) {
+                                return fixer.insertTextAfter(token, " ");
+                            }
+                        });
+                    }
+
+                    // if token is an opening paren and is followed by a disallowed space
+                    if (token.value === "(" && openerRejectsSpace(token, nextToken)) {
+                        context.report({
+                            node,
+                            loc: { start: token.loc.end, end: nextToken.loc.start },
+                            messageId: "rejectedOpeningSpace",
+                            fix(fixer) {
+                                return fixer.removeRange([token.range[1], nextToken.range[0]]);
+                            }
+                        });
+                    }
+
+                    // if token is a closing paren and is not preceded by a required space
+                    if (token.value === ")" && closerMissingSpace(prevToken, token)) {
+                        context.report({
+                            node,
+                            loc: token.loc,
+                            messageId: "missingClosingSpace",
+                            fix(fixer) {
+                                return fixer.insertTextBefore(token, " ");
+                            }
+                        });
+                    }
+
+                    // if token is a closing paren and is preceded by a disallowed space
+                    if (token.value === ")" && closerRejectsSpace(prevToken, token)) {
+                        context.report({
+                            node,
+                            loc: { start: prevToken.loc.end, end: token.loc.start },
+                            messageId: "rejectedClosingSpace",
+                            fix(fixer) {
+                                return fixer.removeRange([prevToken.range[1], token.range[0]]);
+                            }
+                        });
+                    }
+                });
+            }
+        };
+    }
+};

data/packages/webpacker/node_modules/eslint/lib/rules/space-infix-ops.js

@@ -0,0 +1,195 @@
+/**
+ * @fileoverview Require spaces around infix operators
+ * @author Michael Ficarra
+ */
+"use strict";
+
+const { isEqToken } = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../shared/types').Rule} */
+module.exports = {
+    meta: {
+        type: "layout",
+
+        docs: {
+            description: "require spacing around infix operators",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/space-infix-ops"
+        },
+
+        fixable: "whitespace",
+
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    int32Hint: {
+                        type: "boolean",
+                        default: false
+                    }
+                },
+                additionalProperties: false
+            }
+        ],
+
+        messages: {
+            missingSpace: "Operator '{{operator}}' must be spaced."
+        }
+    },
+
+    create(context) {
+        const int32Hint = context.options[0] ? context.options[0].int32Hint === true : false;
+        const sourceCode = context.getSourceCode();
+
+        /**
+         * Returns the first token which violates the rule
+         * @param {ASTNode} left The left node of the main node
+         * @param {ASTNode} right The right node of the main node
+         * @param {string} op The operator of the main node
+         * @returns {Object} The violator token or null
+         * @private
+         */
+        function getFirstNonSpacedToken(left, right, op) {
+            const operator = sourceCode.getFirstTokenBetween(left, right, token => token.value === op);
+            const prev = sourceCode.getTokenBefore(operator);
+            const next = sourceCode.getTokenAfter(operator);
+
+            if (!sourceCode.isSpaceBetweenTokens(prev, operator) || !sourceCode.isSpaceBetweenTokens(operator, next)) {
+                return operator;
+            }
+
+            return null;
+        }
+
+        /**
+         * Reports an AST node as a rule violation
+         * @param {ASTNode} mainNode The node to report
+         * @param {Object} culpritToken The token which has a problem
+         * @returns {void}
+         * @private
+         */
+        function report(mainNode, culpritToken) {
+            context.report({
+                node: mainNode,
+                loc: culpritToken.loc,
+                messageId: "missingSpace",
+                data: {
+                    operator: culpritToken.value
+                },
+                fix(fixer) {
+                    const previousToken = sourceCode.getTokenBefore(culpritToken);
+                    const afterToken = sourceCode.getTokenAfter(culpritToken);
+                    let fixString = "";
+
+                    if (culpritToken.range[0] - previousToken.range[1] === 0) {
+                        fixString = " ";
+                    }
+
+                    fixString += culpritToken.value;
+
+                    if (afterToken.range[0] - culpritToken.range[1] === 0) {
+                        fixString += " ";
+                    }
+
+                    return fixer.replaceText(culpritToken, fixString);
+                }
+            });
+        }
+
+        /**
+         * Check if the node is binary then report
+         * @param {ASTNode} node node to evaluate
+         * @returns {void}
+         * @private
+         */
+        function checkBinary(node) {
+            const leftNode = (node.left.typeAnnotation) ? node.left.typeAnnotation : node.left;
+            const rightNode = node.right;
+
+            // search for = in AssignmentPattern nodes
+            const operator = node.operator || "=";
+
+            const nonSpacedNode = getFirstNonSpacedToken(leftNode, rightNode, operator);
+
+            if (nonSpacedNode) {
+                if (!(int32Hint && sourceCode.getText(node).endsWith("|0"))) {
+                    report(node, nonSpacedNode);
+                }
+            }
+        }
+
+        /**
+         * Check if the node is conditional
+         * @param {ASTNode} node node to evaluate
+         * @returns {void}
+         * @private
+         */
+        function checkConditional(node) {
+            const nonSpacedConsequentNode = getFirstNonSpacedToken(node.test, node.consequent, "?");
+            const nonSpacedAlternateNode = getFirstNonSpacedToken(node.consequent, node.alternate, ":");
+
+            if (nonSpacedConsequentNode) {
+                report(node, nonSpacedConsequentNode);
+            }
+
+            if (nonSpacedAlternateNode) {
+                report(node, nonSpacedAlternateNode);
+            }
+        }
+
+        /**
+         * Check if the node is a variable
+         * @param {ASTNode} node node to evaluate
+         * @returns {void}
+         * @private
+         */
+        function checkVar(node) {
+            const leftNode = (node.id.typeAnnotation) ? node.id.typeAnnotation : node.id;
+            const rightNode = node.init;
+
+            if (rightNode) {
+                const nonSpacedNode = getFirstNonSpacedToken(leftNode, rightNode, "=");
+
+                if (nonSpacedNode) {
+                    report(node, nonSpacedNode);
+                }
+            }
+        }
+
+        return {
+            AssignmentExpression: checkBinary,
+            AssignmentPattern: checkBinary,
+            BinaryExpression: checkBinary,
+            LogicalExpression: checkBinary,
+            ConditionalExpression: checkConditional,
+            VariableDeclarator: checkVar,
+
+            PropertyDefinition(node) {
+                if (!node.value) {
+                    return;
+                }
+
+                /*
+                 * Because of computed properties and type annotations, some
+                 * tokens may exist between `node.key` and `=`.
+                 * Therefore, find the `=` from the right.
+                 */
+                const operatorToken = sourceCode.getTokenBefore(node.value, isEqToken);
+                const leftToken = sourceCode.getTokenBefore(operatorToken);
+                const rightToken = sourceCode.getTokenAfter(operatorToken);
+
+                if (
+                    !sourceCode.isSpaceBetweenTokens(leftToken, operatorToken) ||
+                    !sourceCode.isSpaceBetweenTokens(operatorToken, rightToken)
+                ) {
+                    report(node, operatorToken);
+                }
+            }
+        };
+
+    }
+};