less 3.10.1 → 3.11.1

package/packages/less/node_modules/eslint/lib/rules/prefer-object-spread.js

@@ -0,0 +1,265 @@
+/**
+ * @fileoverview Prefers object spread property over Object.assign
+ * @author Sharmila Jesupaul
+ * See LICENSE file in root directory for full license.
+ */
+
+"use strict";
+
+const { CALL, ReferenceTracker } = require("eslint-utils");
+const {
+    isCommaToken,
+    isOpeningParenToken,
+    isClosingParenToken,
+    isParenthesised
+} = require("../util/ast-utils");
+
+const ANY_SPACE = /\s/u;
+
+/**
+ * Helper that checks if the Object.assign call has array spread
+ * @param {ASTNode} node - The node that the rule warns on
+ * @returns {boolean} - Returns true if the Object.assign call has array spread
+ */
+function hasArraySpread(node) {
+    return node.arguments.some(arg => arg.type === "SpreadElement");
+}
+
+/**
+ * Helper that checks if the node needs parentheses to be valid JS.
+ * The default is to wrap the node in parentheses to avoid parsing errors.
+ * @param {ASTNode} node - The node that the rule warns on
+ * @param {Object} sourceCode - in context sourcecode object
+ * @returns {boolean} - Returns true if the node needs parentheses
+ */
+function needsParens(node, sourceCode) {
+    const parent = node.parent;
+
+    switch (parent.type) {
+        case "VariableDeclarator":
+        case "ArrayExpression":
+        case "ReturnStatement":
+        case "CallExpression":
+        case "Property":
+            return false;
+        case "AssignmentExpression":
+            return parent.left === node && !isParenthesised(sourceCode, node);
+        default:
+            return !isParenthesised(sourceCode, node);
+    }
+}
+
+/**
+ * Determines if an argument needs parentheses. The default is to not add parens.
+ * @param {ASTNode} node - The node to be checked.
+ * @param {Object} sourceCode - in context sourcecode object
+ * @returns {boolean} True if the node needs parentheses
+ */
+function argNeedsParens(node, sourceCode) {
+    switch (node.type) {
+        case "AssignmentExpression":
+        case "ArrowFunctionExpression":
+        case "ConditionalExpression":
+            return !isParenthesised(sourceCode, node);
+        default:
+            return false;
+    }
+}
+
+/**
+ * Get the parenthesis tokens of a given ObjectExpression node.
+ * This incldues the braces of the object literal and enclosing parentheses.
+ * @param {ASTNode} node The node to get.
+ * @param {Token} leftArgumentListParen The opening paren token of the argument list.
+ * @param {SourceCode} sourceCode The source code object to get tokens.
+ * @returns {Token[]} The parenthesis tokens of the node. This is sorted by the location.
+ */
+function getParenTokens(node, leftArgumentListParen, sourceCode) {
+    const parens = [sourceCode.getFirstToken(node), sourceCode.getLastToken(node)];
+    let leftNext = sourceCode.getTokenBefore(node);
+    let rightNext = sourceCode.getTokenAfter(node);
+
+    // Note: don't include the parens of the argument list.
+    while (
+        leftNext &&
+        rightNext &&
+        leftNext.range[0] > leftArgumentListParen.range[0] &&
+        isOpeningParenToken(leftNext) &&
+        isClosingParenToken(rightNext)
+    ) {
+        parens.push(leftNext, rightNext);
+        leftNext = sourceCode.getTokenBefore(leftNext);
+        rightNext = sourceCode.getTokenAfter(rightNext);
+    }
+
+    return parens.sort((a, b) => a.range[0] - b.range[0]);
+}
+
+/**
+ * Get the range of a given token and around whitespaces.
+ * @param {Token} token The token to get range.
+ * @param {SourceCode} sourceCode The source code object to get tokens.
+ * @returns {number} The end of the range of the token and around whitespaces.
+ */
+function getStartWithSpaces(token, sourceCode) {
+    const text = sourceCode.text;
+    let start = token.range[0];
+
+    // If the previous token is a line comment then skip this step to avoid commenting this token out.
+    {
+        const prevToken = sourceCode.getTokenBefore(token, { includeComments: true });
+
+        if (prevToken && prevToken.type === "Line") {
+            return start;
+        }
+    }
+
+    // Detect spaces before the token.
+    while (ANY_SPACE.test(text[start - 1] || "")) {
+        start -= 1;
+    }
+
+    return start;
+}
+
+/**
+ * Get the range of a given token and around whitespaces.
+ * @param {Token} token The token to get range.
+ * @param {SourceCode} sourceCode The source code object to get tokens.
+ * @returns {number} The start of the range of the token and around whitespaces.
+ */
+function getEndWithSpaces(token, sourceCode) {
+    const text = sourceCode.text;
+    let end = token.range[1];
+
+    // Detect spaces after the token.
+    while (ANY_SPACE.test(text[end] || "")) {
+        end += 1;
+    }
+
+    return end;
+}
+
+/**
+ * Autofixes the Object.assign call to use an object spread instead.
+ * @param {ASTNode|null} node - The node that the rule warns on, i.e. the Object.assign call
+ * @param {string} sourceCode - sourceCode of the Object.assign call
+ * @returns {Function} autofixer - replaces the Object.assign with a spread object.
+ */
+function defineFixer(node, sourceCode) {
+    return function *(fixer) {
+        const leftParen = sourceCode.getTokenAfter(node.callee, isOpeningParenToken);
+        const rightParen = sourceCode.getLastToken(node);
+
+        // Remove the callee `Object.assign`
+        yield fixer.remove(node.callee);
+
+        // Replace the parens of argument list to braces.
+        if (needsParens(node, sourceCode)) {
+            yield fixer.replaceText(leftParen, "({");
+            yield fixer.replaceText(rightParen, "})");
+        } else {
+            yield fixer.replaceText(leftParen, "{");
+            yield fixer.replaceText(rightParen, "}");
+        }
+
+        // Process arguments.
+        for (const argNode of node.arguments) {
+            const innerParens = getParenTokens(argNode, leftParen, sourceCode);
+            const left = innerParens.shift();
+            const right = innerParens.pop();
+
+            if (argNode.type === "ObjectExpression") {
+                const maybeTrailingComma = sourceCode.getLastToken(argNode, 1);
+                const maybeArgumentComma = sourceCode.getTokenAfter(right);
+
+                /*
+                 * Make bare this object literal.
+                 * And remove spaces inside of the braces for better formatting.
+                 */
+                for (const innerParen of innerParens) {
+                    yield fixer.remove(innerParen);
+                }
+                const leftRange = [left.range[0], getEndWithSpaces(left, sourceCode)];
+                const rightRange = [
+                    Math.max(getStartWithSpaces(right, sourceCode), leftRange[1]), // Ensure ranges don't overlap
+                    right.range[1]
+                ];
+
+                yield fixer.removeRange(leftRange);
+                yield fixer.removeRange(rightRange);
+
+                // Remove the comma of this argument if it's duplication.
+                if (
+                    (argNode.properties.length === 0 || isCommaToken(maybeTrailingComma)) &&
+                    isCommaToken(maybeArgumentComma)
+                ) {
+                    yield fixer.remove(maybeArgumentComma);
+                }
+            } else {
+
+                // Make spread.
+                if (argNeedsParens(argNode, sourceCode)) {
+                    yield fixer.insertTextBefore(left, "...(");
+                    yield fixer.insertTextAfter(right, ")");
+                } else {
+                    yield fixer.insertTextBefore(left, "...");
+                }
+            }
+        }
+    };
+}
+
+module.exports = {
+    meta: {
+        type: "suggestion",
+
+        docs: {
+            description:
+                "disallow using Object.assign with an object literal as the first argument and prefer the use of object spread instead.",
+            category: "Stylistic Issues",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/prefer-object-spread"
+        },
+
+        schema: [],
+        fixable: "code",
+
+        messages: {
+            useSpreadMessage: "Use an object spread instead of `Object.assign` eg: `{ ...foo }`.",
+            useLiteralMessage: "Use an object literal instead of `Object.assign`. eg: `{ foo: bar }`."
+        }
+    },
+
+    create(context) {
+        const sourceCode = context.getSourceCode();
+
+        return {
+            Program() {
+                const scope = context.getScope();
+                const tracker = new ReferenceTracker(scope);
+                const trackMap = {
+                    Object: {
+                        assign: { [CALL]: true }
+                    }
+                };
+
+                // Iterate all calls of `Object.assign` (only of the global variable `Object`).
+                for (const { node } of tracker.iterateGlobalReferences(trackMap)) {
+                    if (
+                        node.arguments.length >= 1 &&
+                        node.arguments[0].type === "ObjectExpression" &&
+                        !hasArraySpread(node)
+                    ) {
+                        const messageId = node.arguments.length === 1
+                            ? "useLiteralMessage"
+                            : "useSpreadMessage";
+                        const fix = defineFixer(node, sourceCode);
+
+                        context.report({ node, messageId, fix });
+                    }
+                }
+            }
+        };
+    }
+};

package/packages/less/node_modules/eslint/lib/rules/prefer-promise-reject-errors.js

@@ -0,0 +1,129 @@
+/**
+ * @fileoverview restrict values that can be used as Promise rejection reasons
+ * @author Teddy Katz
+ */
+"use strict";
+
+const astUtils = require("../util/ast-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        type: "suggestion",
+
+        docs: {
+            description: "require using Error objects as Promise rejection reasons",
+            category: "Best Practices",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/prefer-promise-reject-errors"
+        },
+
+        fixable: null,
+
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    allowEmptyReject: { type: "boolean", default: false }
+                },
+                additionalProperties: false
+            }
+        ]
+    },
+
+    create(context) {
+
+        const ALLOW_EMPTY_REJECT = context.options.length && context.options[0].allowEmptyReject;
+
+        //----------------------------------------------------------------------
+        // Helpers
+        //----------------------------------------------------------------------
+
+        /**
+         * Checks the argument of a reject() or Promise.reject() CallExpression, and reports it if it can't be an Error
+         * @param {ASTNode} callExpression A CallExpression node which is used to reject a Promise
+         * @returns {void}
+         */
+        function checkRejectCall(callExpression) {
+            if (!callExpression.arguments.length && ALLOW_EMPTY_REJECT) {
+                return;
+            }
+            if (
+                !callExpression.arguments.length ||
+                !astUtils.couldBeError(callExpression.arguments[0]) ||
+                callExpression.arguments[0].type === "Identifier" && callExpression.arguments[0].name === "undefined"
+            ) {
+                context.report({
+                    node: callExpression,
+                    message: "Expected the Promise rejection reason to be an Error."
+                });
+            }
+        }
+
+        /**
+         * Determines whether a function call is a Promise.reject() call
+         * @param {ASTNode} node A CallExpression node
+         * @returns {boolean} `true` if the call is a Promise.reject() call
+         */
+        function isPromiseRejectCall(node) {
+            return node.callee.type === "MemberExpression" &&
+                node.callee.object.type === "Identifier" && node.callee.object.name === "Promise" &&
+                node.callee.property.type === "Identifier" && node.callee.property.name === "reject";
+        }
+
+        //----------------------------------------------------------------------
+        // Public
+        //----------------------------------------------------------------------
+
+        return {
+
+            // Check `Promise.reject(value)` calls.
+            CallExpression(node) {
+                if (isPromiseRejectCall(node)) {
+                    checkRejectCall(node);
+                }
+            },
+
+            /*
+             * Check for `new Promise((resolve, reject) => {})`, and check for reject() calls.
+             * This function is run on "NewExpression:exit" instead of "NewExpression" to ensure that
+             * the nodes in the expression already have the `parent` property.
+             */
+            "NewExpression:exit"(node) {
+                if (
+                    node.callee.type === "Identifier" && node.callee.name === "Promise" &&
+                    node.arguments.length && astUtils.isFunction(node.arguments[0]) &&
+                    node.arguments[0].params.length > 1 && node.arguments[0].params[1].type === "Identifier"
+                ) {
+                    context.getDeclaredVariables(node.arguments[0])
+
+                        /*
+                         * Find the first variable that matches the second parameter's name.
+                         * If the first parameter has the same name as the second parameter, then the variable will actually
+                         * be "declared" when the first parameter is evaluated, but then it will be immediately overwritten
+                         * by the second parameter. It's not possible for an expression with the variable to be evaluated before
+                         * the variable is overwritten, because functions with duplicate parameters cannot have destructuring or
+                         * default assignments in their parameter lists. Therefore, it's not necessary to explicitly account for
+                         * this case.
+                         */
+                        .find(variable => variable.name === node.arguments[0].params[1].name)
+
+                        // Get the references to that variable.
+                        .references
+
+                        // Only check the references that read the parameter's value.
+                        .filter(ref => ref.isRead())
+
+                        // Only check the references that are used as the callee in a function call, e.g. `reject(foo)`.
+                        .filter(ref => ref.identifier.parent.type === "CallExpression" && ref.identifier === ref.identifier.parent.callee)
+
+                        // Check the argument of the function call to determine whether it's an Error.
+                        .forEach(ref => checkRejectCall(ref.identifier.parent));
+                }
+            }
+        };
+    }
+};

package/packages/less/node_modules/eslint/lib/rules/prefer-reflect.js

@@ -0,0 +1,123 @@
+/**
+ * @fileoverview Rule to suggest using "Reflect" api over Function/Object methods
+ * @author Keith Cirkel <http://keithcirkel.co.uk>
+ * @deprecated in ESLint v3.9.0
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        type: "suggestion",
+
+        docs: {
+            description: "require `Reflect` methods where applicable",
+            category: "ECMAScript 6",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/prefer-reflect"
+        },
+
+        deprecated: true,
+
+        replacedBy: [],
+
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    exceptions: {
+                        type: "array",
+                        items: {
+                            enum: [
+                                "apply",
+                                "call",
+                                "delete",
+                                "defineProperty",
+                                "getOwnPropertyDescriptor",
+                                "getPrototypeOf",
+                                "setPrototypeOf",
+                                "isExtensible",
+                                "getOwnPropertyNames",
+                                "preventExtensions"
+                            ]
+                        },
+                        uniqueItems: true
+                    }
+                },
+                additionalProperties: false
+            }
+        ]
+    },
+
+    create(context) {
+        const existingNames = {
+            apply: "Function.prototype.apply",
+            call: "Function.prototype.call",
+            defineProperty: "Object.defineProperty",
+            getOwnPropertyDescriptor: "Object.getOwnPropertyDescriptor",
+            getPrototypeOf: "Object.getPrototypeOf",
+            setPrototypeOf: "Object.setPrototypeOf",
+            isExtensible: "Object.isExtensible",
+            getOwnPropertyNames: "Object.getOwnPropertyNames",
+            preventExtensions: "Object.preventExtensions"
+        };
+
+        const reflectSubsitutes = {
+            apply: "Reflect.apply",
+            call: "Reflect.apply",
+            defineProperty: "Reflect.defineProperty",
+            getOwnPropertyDescriptor: "Reflect.getOwnPropertyDescriptor",
+            getPrototypeOf: "Reflect.getPrototypeOf",
+            setPrototypeOf: "Reflect.setPrototypeOf",
+            isExtensible: "Reflect.isExtensible",
+            getOwnPropertyNames: "Reflect.getOwnPropertyNames",
+            preventExtensions: "Reflect.preventExtensions"
+        };
+
+        const exceptions = (context.options[0] || {}).exceptions || [];
+
+        /**
+         * Reports the Reflect violation based on the `existing` and `substitute`
+         * @param {Object} node The node that violates the rule.
+         * @param {string} existing The existing method name that has been used.
+         * @param {string} substitute The Reflect substitute that should be used.
+         * @returns {void}
+         */
+        function report(node, existing, substitute) {
+            context.report({
+                node,
+                message: "Avoid using {{existing}}, instead use {{substitute}}.",
+                data: {
+                    existing,
+                    substitute
+                }
+            });
+        }
+
+        return {
+            CallExpression(node) {
+                const methodName = (node.callee.property || {}).name;
+                const isReflectCall = (node.callee.object || {}).name === "Reflect";
+                const hasReflectSubsitute = Object.prototype.hasOwnProperty.call(reflectSubsitutes, methodName);
+                const userConfiguredException = exceptions.indexOf(methodName) !== -1;
+
+                if (hasReflectSubsitute && !isReflectCall && !userConfiguredException) {
+                    report(node, existingNames[methodName], reflectSubsitutes[methodName]);
+                }
+            },
+            UnaryExpression(node) {
+                const isDeleteOperator = node.operator === "delete";
+                const targetsIdentifier = node.argument.type === "Identifier";
+                const userConfiguredException = exceptions.indexOf("delete") !== -1;
+
+                if (isDeleteOperator && !targetsIdentifier && !userConfiguredException) {
+                    report(node, "the delete keyword", "Reflect.deleteProperty");
+                }
+            }
+        };
+
+    }
+};

package/packages/less/node_modules/eslint/lib/rules/prefer-rest-params.js

@@ -0,0 +1,114 @@
+/**
+ * @fileoverview Rule to
+ * @author Toru Nagashima
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Gets the variable object of `arguments` which is defined implicitly.
+ * @param {eslint-scope.Scope} scope - A scope to get.
+ * @returns {eslint-scope.Variable} The found variable object.
+ */
+function getVariableOfArguments(scope) {
+    const variables = scope.variables;
+
+    for (let i = 0; i < variables.length; ++i) {
+        const variable = variables[i];
+
+        if (variable.name === "arguments") {
+
+            /*
+             * If there was a parameter which is named "arguments", the implicit "arguments" is not defined.
+             * So does fast return with null.
+             */
+            return (variable.identifiers.length === 0) ? variable : null;
+        }
+    }
+
+    /* istanbul ignore next : unreachable */
+    return null;
+}
+
+/**
+ * Checks if the given reference is not normal member access.
+ *
+ * - arguments         .... true    // not member access
+ * - arguments[i]      .... true    // computed member access
+ * - arguments[0]      .... true    // computed member access
+ * - arguments.length  .... false   // normal member access
+ *
+ * @param {eslint-scope.Reference} reference - The reference to check.
+ * @returns {boolean} `true` if the reference is not normal member access.
+ */
+function isNotNormalMemberAccess(reference) {
+    const id = reference.identifier;
+    const parent = id.parent;
+
+    return !(
+        parent.type === "MemberExpression" &&
+        parent.object === id &&
+        !parent.computed
+    );
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        type: "suggestion",
+
+        docs: {
+            description: "require rest parameters instead of `arguments`",
+            category: "ECMAScript 6",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/prefer-rest-params"
+        },
+
+        schema: []
+    },
+
+    create(context) {
+
+        /**
+         * Reports a given reference.
+         *
+         * @param {eslint-scope.Reference} reference - A reference to report.
+         * @returns {void}
+         */
+        function report(reference) {
+            context.report({
+                node: reference.identifier,
+                loc: reference.identifier.loc,
+                message: "Use the rest parameters instead of 'arguments'."
+            });
+        }
+
+        /**
+         * Reports references of the implicit `arguments` variable if exist.
+         *
+         * @returns {void}
+         */
+        function checkForArguments() {
+            const argumentsVar = getVariableOfArguments(context.getScope());
+
+            if (argumentsVar) {
+                argumentsVar
+                    .references
+                    .filter(isNotNormalMemberAccess)
+                    .forEach(report);
+            }
+        }
+
+        return {
+            "FunctionDeclaration:exit": checkForArguments,
+            "FunctionExpression:exit": checkForArguments
+        };
+    }
+};