decidim 0.26.2 → 0.27.0.rc2

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

@@ -0,0 +1,150 @@
+/**
+ * @fileoverview A rule to disallow `this` keywords outside of classes or class-like objects.
+ * @author Toru Nagashima
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Determines if the given code path is a code path with lexical `this` binding.
+ * That is, if `this` within the code path refers to `this` of surrounding code path.
+ * @param {CodePath} codePath Code path.
+ * @param {ASTNode} node Node that started the code path.
+ * @returns {boolean} `true` if it is a code path with lexical `this` binding.
+ */
+function isCodePathWithLexicalThis(codePath, node) {
+    return codePath.origin === "function" && node.type === "ArrowFunctionExpression";
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../shared/types').Rule} */
+module.exports = {
+    meta: {
+        type: "suggestion",
+
+        docs: {
+            description: "disallow `this` keywords outside of classes or class-like objects",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/no-invalid-this"
+        },
+
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    capIsConstructor: {
+                        type: "boolean",
+                        default: true
+                    }
+                },
+                additionalProperties: false
+            }
+        ],
+
+        messages: {
+            unexpectedThis: "Unexpected 'this'."
+        }
+    },
+
+    create(context) {
+        const options = context.options[0] || {};
+        const capIsConstructor = options.capIsConstructor !== false;
+        const stack = [],
+            sourceCode = context.getSourceCode();
+
+        /**
+         * Gets the current checking context.
+         *
+         * The return value has a flag that whether or not `this` keyword is valid.
+         * The flag is initialized when got at the first time.
+         * @returns {{valid: boolean}}
+         *   an object which has a flag that whether or not `this` keyword is valid.
+         */
+        stack.getCurrent = function() {
+            const current = this[this.length - 1];
+
+            if (!current.init) {
+                current.init = true;
+                current.valid = !astUtils.isDefaultThisBinding(
+                    current.node,
+                    sourceCode,
+                    { capIsConstructor }
+                );
+            }
+            return current;
+        };
+
+        return {
+
+            onCodePathStart(codePath, node) {
+                if (isCodePathWithLexicalThis(codePath, node)) {
+                    return;
+                }
+
+                if (codePath.origin === "program") {
+                    const scope = context.getScope();
+                    const features = context.parserOptions.ecmaFeatures || {};
+
+                    stack.push({
+                        init: true,
+                        node,
+                        valid: !(
+                            scope.isStrict ||
+                            node.sourceType === "module" ||
+                            (features.globalReturn && scope.childScopes[0].isStrict)
+                        )
+                    });
+
+                    return;
+                }
+
+                /*
+                 * `init: false` means that `valid` isn't determined yet.
+                 * Most functions don't use `this`, and the calculation for `valid`
+                 * is relatively costly, so we'll calculate it lazily when the first
+                 * `this` within the function is traversed. A special case are non-strict
+                 * functions, because `this` refers to the global object and therefore is
+                 * always valid, so we can set `init: true` right away.
+                 */
+                stack.push({
+                    init: !context.getScope().isStrict,
+                    node,
+                    valid: true
+                });
+            },
+
+            onCodePathEnd(codePath, node) {
+                if (isCodePathWithLexicalThis(codePath, node)) {
+                    return;
+                }
+
+                stack.pop();
+            },
+
+            // Reports if `this` of the current context is invalid.
+            ThisExpression(node) {
+                const current = stack.getCurrent();
+
+                if (current && !current.valid) {
+                    context.report({
+                        node,
+                        messageId: "unexpectedThis"
+                    });
+                }
+            }
+        };
+    }
+};

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

@@ -0,0 +1,259 @@
+/**
+ * @fileoverview Rule to disallow whitespace that is not a tab or space, whitespace inside strings and comments are allowed
+ * @author Jonathan Kingston
+ * @author Christophe Porteneuve
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Constants
+//------------------------------------------------------------------------------
+
+const ALL_IRREGULARS = /[\f\v\u0085\ufeff\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u202f\u205f\u3000\u2028\u2029]/u;
+const IRREGULAR_WHITESPACE = /[\f\v\u0085\ufeff\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u202f\u205f\u3000]+/mgu;
+const IRREGULAR_LINE_TERMINATORS = /[\u2028\u2029]/mgu;
+const LINE_BREAK = astUtils.createGlobalLinebreakMatcher();
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../shared/types').Rule} */
+module.exports = {
+    meta: {
+        type: "problem",
+
+        docs: {
+            description: "disallow irregular whitespace",
+            recommended: true,
+            url: "https://eslint.org/docs/rules/no-irregular-whitespace"
+        },
+
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    skipComments: {
+                        type: "boolean",
+                        default: false
+                    },
+                    skipStrings: {
+                        type: "boolean",
+                        default: true
+                    },
+                    skipTemplates: {
+                        type: "boolean",
+                        default: false
+                    },
+                    skipRegExps: {
+                        type: "boolean",
+                        default: false
+                    }
+                },
+                additionalProperties: false
+            }
+        ],
+
+        messages: {
+            noIrregularWhitespace: "Irregular whitespace not allowed."
+        }
+    },
+
+    create(context) {
+
+        // Module store of errors that we have found
+        let errors = [];
+
+        // Lookup the `skipComments` option, which defaults to `false`.
+        const options = context.options[0] || {};
+        const skipComments = !!options.skipComments;
+        const skipStrings = options.skipStrings !== false;
+        const skipRegExps = !!options.skipRegExps;
+        const skipTemplates = !!options.skipTemplates;
+
+        const sourceCode = context.getSourceCode();
+        const commentNodes = sourceCode.getAllComments();
+
+        /**
+         * Removes errors that occur inside the given node
+         * @param {ASTNode} node to check for matching errors.
+         * @returns {void}
+         * @private
+         */
+        function removeWhitespaceError(node) {
+            const locStart = node.loc.start;
+            const locEnd = node.loc.end;
+
+            errors = errors.filter(({ loc: { start: errorLocStart } }) => (
+                errorLocStart.line < locStart.line ||
+                errorLocStart.line === locStart.line && errorLocStart.column < locStart.column ||
+                errorLocStart.line === locEnd.line && errorLocStart.column >= locEnd.column ||
+                errorLocStart.line > locEnd.line
+            ));
+        }
+
+        /**
+         * Checks identifier or literal nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors
+         * @param {ASTNode} node to check for matching errors.
+         * @returns {void}
+         * @private
+         */
+        function removeInvalidNodeErrorsInIdentifierOrLiteral(node) {
+            const shouldCheckStrings = skipStrings && (typeof node.value === "string");
+            const shouldCheckRegExps = skipRegExps && Boolean(node.regex);
+
+            if (shouldCheckStrings || shouldCheckRegExps) {
+
+                // If we have irregular characters remove them from the errors list
+                if (ALL_IRREGULARS.test(node.raw)) {
+                    removeWhitespaceError(node);
+                }
+            }
+        }
+
+        /**
+         * Checks template string literal nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors
+         * @param {ASTNode} node to check for matching errors.
+         * @returns {void}
+         * @private
+         */
+        function removeInvalidNodeErrorsInTemplateLiteral(node) {
+            if (typeof node.value.raw === "string") {
+                if (ALL_IRREGULARS.test(node.value.raw)) {
+                    removeWhitespaceError(node);
+                }
+            }
+        }
+
+        /**
+         * Checks comment nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors
+         * @param {ASTNode} node to check for matching errors.
+         * @returns {void}
+         * @private
+         */
+        function removeInvalidNodeErrorsInComment(node) {
+            if (ALL_IRREGULARS.test(node.value)) {
+                removeWhitespaceError(node);
+            }
+        }
+
+        /**
+         * Checks the program source for irregular whitespace
+         * @param {ASTNode} node The program node
+         * @returns {void}
+         * @private
+         */
+        function checkForIrregularWhitespace(node) {
+            const sourceLines = sourceCode.lines;
+
+            sourceLines.forEach((sourceLine, lineIndex) => {
+                const lineNumber = lineIndex + 1;
+                let match;
+
+                while ((match = IRREGULAR_WHITESPACE.exec(sourceLine)) !== null) {
+                    errors.push({
+                        node,
+                        messageId: "noIrregularWhitespace",
+                        loc: {
+                            start: {
+                                line: lineNumber,
+                                column: match.index
+                            },
+                            end: {
+                                line: lineNumber,
+                                column: match.index + match[0].length
+                            }
+                        }
+                    });
+                }
+            });
+        }
+
+        /**
+         * Checks the program source for irregular line terminators
+         * @param {ASTNode} node The program node
+         * @returns {void}
+         * @private
+         */
+        function checkForIrregularLineTerminators(node) {
+            const source = sourceCode.getText(),
+                sourceLines = sourceCode.lines,
+                linebreaks = source.match(LINE_BREAK);
+            let lastLineIndex = -1,
+                match;
+
+            while ((match = IRREGULAR_LINE_TERMINATORS.exec(source)) !== null) {
+                const lineIndex = linebreaks.indexOf(match[0], lastLineIndex + 1) || 0;
+
+                errors.push({
+                    node,
+                    messageId: "noIrregularWhitespace",
+                    loc: {
+                        start: {
+                            line: lineIndex + 1,
+                            column: sourceLines[lineIndex].length
+                        },
+                        end: {
+                            line: lineIndex + 2,
+                            column: 0
+                        }
+                    }
+                });
+
+                lastLineIndex = lineIndex;
+            }
+        }
+
+        /**
+         * A no-op function to act as placeholder for comment accumulation when the `skipComments` option is `false`.
+         * @returns {void}
+         * @private
+         */
+        function noop() {}
+
+        const nodes = {};
+
+        if (ALL_IRREGULARS.test(sourceCode.getText())) {
+            nodes.Program = function(node) {
+
+                /*
+                 * As we can easily fire warnings for all white space issues with
+                 * all the source its simpler to fire them here.
+                 * This means we can check all the application code without having
+                 * to worry about issues caused in the parser tokens.
+                 * When writing this code also evaluating per node was missing out
+                 * connecting tokens in some cases.
+                 * We can later filter the errors when they are found to be not an
+                 * issue in nodes we don't care about.
+                 */
+                checkForIrregularWhitespace(node);
+                checkForIrregularLineTerminators(node);
+            };
+
+            nodes.Identifier = removeInvalidNodeErrorsInIdentifierOrLiteral;
+            nodes.Literal = removeInvalidNodeErrorsInIdentifierOrLiteral;
+            nodes.TemplateElement = skipTemplates ? removeInvalidNodeErrorsInTemplateLiteral : noop;
+            nodes["Program:exit"] = function() {
+                if (skipComments) {
+
+                    // First strip errors occurring in comment nodes.
+                    commentNodes.forEach(removeInvalidNodeErrorsInComment);
+                }
+
+                // If we have any errors remaining report on them
+                errors.forEach(error => context.report(error));
+            };
+        } else {
+            nodes.Program = noop;
+        }
+
+        return nodes;
+    }
+};

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

@@ -0,0 +1,52 @@
+/**
+ * @fileoverview Rule to flag usage of __iterator__ property
+ * @author Ian Christian Myers
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const { getStaticPropertyName } = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../shared/types').Rule} */
+module.exports = {
+    meta: {
+        type: "suggestion",
+
+        docs: {
+            description: "disallow the use of the `__iterator__` property",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/no-iterator"
+        },
+
+        schema: [],
+
+        messages: {
+            noIterator: "Reserved name '__iterator__'."
+        }
+    },
+
+    create(context) {
+
+        return {
+
+            MemberExpression(node) {
+
+                if (getStaticPropertyName(node) === "__iterator__") {
+                    context.report({
+                        node,
+                        messageId: "noIterator"
+                    });
+                }
+            }
+        };
+
+    }
+};

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

@@ -0,0 +1,79 @@
+/**
+ * @fileoverview Rule to flag labels that are the same as an identifier
+ * @author Ian Christian Myers
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../shared/types').Rule} */
+module.exports = {
+    meta: {
+        type: "suggestion",
+
+        docs: {
+            description: "disallow labels that share a name with a variable",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/no-label-var"
+        },
+
+        schema: [],
+
+        messages: {
+            identifierClashWithLabel: "Found identifier with same name as label."
+        }
+    },
+
+    create(context) {
+
+        //--------------------------------------------------------------------------
+        // Helpers
+        //--------------------------------------------------------------------------
+
+        /**
+         * Check if the identifier is present inside current scope
+         * @param {Object} scope current scope
+         * @param {string} name To evaluate
+         * @returns {boolean} True if its present
+         * @private
+         */
+        function findIdentifier(scope, name) {
+            return astUtils.getVariableByName(scope, name) !== null;
+        }
+
+        //--------------------------------------------------------------------------
+        // Public API
+        //--------------------------------------------------------------------------
+
+        return {
+
+            LabeledStatement(node) {
+
+                // Fetch the innermost scope.
+                const scope = context.getScope();
+
+                /*
+                 * Recursively find the identifier walking up the scope, starting
+                 * with the innermost scope.
+                 */
+                if (findIdentifier(scope, node.label.name)) {
+                    context.report({
+                        node,
+                        messageId: "identifierClashWithLabel"
+                    });
+                }
+            }
+
+        };
+
+    }
+};

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

@@ -0,0 +1,149 @@
+/**
+ * @fileoverview Disallow Labeled Statements
+ * @author Nicholas C. Zakas
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../shared/types').Rule} */
+module.exports = {
+    meta: {
+        type: "suggestion",
+
+        docs: {
+            description: "disallow labeled statements",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/no-labels"
+        },
+
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    allowLoop: {
+                        type: "boolean",
+                        default: false
+                    },
+                    allowSwitch: {
+                        type: "boolean",
+                        default: false
+                    }
+                },
+                additionalProperties: false
+            }
+        ],
+
+        messages: {
+            unexpectedLabel: "Unexpected labeled statement.",
+            unexpectedLabelInBreak: "Unexpected label in break statement.",
+            unexpectedLabelInContinue: "Unexpected label in continue statement."
+        }
+    },
+
+    create(context) {
+        const options = context.options[0];
+        const allowLoop = options && options.allowLoop;
+        const allowSwitch = options && options.allowSwitch;
+        let scopeInfo = null;
+
+        /**
+         * Gets the kind of a given node.
+         * @param {ASTNode} node A node to get.
+         * @returns {string} The kind of the node.
+         */
+        function getBodyKind(node) {
+            if (astUtils.isLoop(node)) {
+                return "loop";
+            }
+            if (node.type === "SwitchStatement") {
+                return "switch";
+            }
+            return "other";
+        }
+
+        /**
+         * Checks whether the label of a given kind is allowed or not.
+         * @param {string} kind A kind to check.
+         * @returns {boolean} `true` if the kind is allowed.
+         */
+        function isAllowed(kind) {
+            switch (kind) {
+                case "loop": return allowLoop;
+                case "switch": return allowSwitch;
+                default: return false;
+            }
+        }
+
+        /**
+         * Checks whether a given name is a label of a loop or not.
+         * @param {string} label A name of a label to check.
+         * @returns {boolean} `true` if the name is a label of a loop.
+         */
+        function getKind(label) {
+            let info = scopeInfo;
+
+            while (info) {
+                if (info.label === label) {
+                    return info.kind;
+                }
+                info = info.upper;
+            }
+
+            /* istanbul ignore next: syntax error */
+            return "other";
+        }
+
+        //--------------------------------------------------------------------------
+        // Public
+        //--------------------------------------------------------------------------
+
+        return {
+            LabeledStatement(node) {
+                scopeInfo = {
+                    label: node.label.name,
+                    kind: getBodyKind(node.body),
+                    upper: scopeInfo
+                };
+            },
+
+            "LabeledStatement:exit"(node) {
+                if (!isAllowed(scopeInfo.kind)) {
+                    context.report({
+                        node,
+                        messageId: "unexpectedLabel"
+                    });
+                }
+
+                scopeInfo = scopeInfo.upper;
+            },
+
+            BreakStatement(node) {
+                if (node.label && !isAllowed(getKind(node.label.name))) {
+                    context.report({
+                        node,
+                        messageId: "unexpectedLabelInBreak"
+                    });
+                }
+            },
+
+            ContinueStatement(node) {
+                if (node.label && !isAllowed(getKind(node.label.name))) {
+                    context.report({
+                        node,
+                        messageId: "unexpectedLabelInContinue"
+                    });
+                }
+            }
+        };
+
+    }
+};