less 3.10.1 → 3.11.1

package/packages/less/node_modules/eslint/lib/rules/no-regex-spaces.js

@@ -0,0 +1,116 @@
+/**
+ * @fileoverview Rule to count multiple spaces in regular expressions
+ * @author Matt DuVall <http://www.mattduvall.com/>
+ */
+
+"use strict";
+
+const astUtils = require("../util/ast-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        type: "suggestion",
+
+        docs: {
+            description: "disallow multiple spaces in regular expressions",
+            category: "Possible Errors",
+            recommended: true,
+            url: "https://eslint.org/docs/rules/no-regex-spaces"
+        },
+
+        schema: [],
+        fixable: "code"
+    },
+
+    create(context) {
+        const sourceCode = context.getSourceCode();
+
+        /**
+         * Validate regular expressions
+         * @param {ASTNode} node node to validate
+         * @param {string} value regular expression to validate
+         * @param {number} valueStart The start location of the regex/string literal. It will always be the case that
+         * `sourceCode.getText().slice(valueStart, valueStart + value.length) === value`
+         * @returns {void}
+         * @private
+         */
+        function checkRegex(node, value, valueStart) {
+            const multipleSpacesRegex = /( {2,})( [+*{?]|[^+*{?]|$)/u,
+                regexResults = multipleSpacesRegex.exec(value);
+
+            if (regexResults !== null) {
+                const count = regexResults[1].length;
+
+                context.report({
+                    node,
+                    message: "Spaces are hard to count. Use {{{count}}}.",
+                    data: { count },
+                    fix(fixer) {
+                        return fixer.replaceTextRange(
+                            [valueStart + regexResults.index, valueStart + regexResults.index + count],
+                            ` {${count}}`
+                        );
+                    }
+                });
+
+                /*
+                 * TODO: (platinumazure) Fix message to use rule message
+                 * substitution when api.report is fixed in lib/eslint.js.
+                 */
+            }
+        }
+
+        /**
+         * Validate regular expression literals
+         * @param {ASTNode} node node to validate
+         * @returns {void}
+         * @private
+         */
+        function checkLiteral(node) {
+            const token = sourceCode.getFirstToken(node),
+                nodeType = token.type,
+                nodeValue = token.value;
+
+            if (nodeType === "RegularExpression") {
+                checkRegex(node, nodeValue, token.range[0]);
+            }
+        }
+
+        /**
+         * Check if node is a string
+         * @param {ASTNode} node node to evaluate
+         * @returns {boolean} True if its a string
+         * @private
+         */
+        function isString(node) {
+            return node && node.type === "Literal" && typeof node.value === "string";
+        }
+
+        /**
+         * Validate strings passed to the RegExp constructor
+         * @param {ASTNode} node node to validate
+         * @returns {void}
+         * @private
+         */
+        function checkFunction(node) {
+            const scope = context.getScope();
+            const regExpVar = astUtils.getVariableByName(scope, "RegExp");
+            const shadowed = regExpVar && regExpVar.defs.length > 0;
+
+            if (node.callee.type === "Identifier" && node.callee.name === "RegExp" && isString(node.arguments[0]) && !shadowed) {
+                checkRegex(node, node.arguments[0].value, node.arguments[0].range[0] + 1);
+            }
+        }
+
+        return {
+            Literal: checkLiteral,
+            CallExpression: checkFunction,
+            NewExpression: checkFunction
+        };
+
+    }
+};

package/packages/less/node_modules/eslint/lib/rules/no-restricted-globals.js

@@ -0,0 +1,123 @@
+/**
+ * @fileoverview Restrict usage of specified globals.
+ * @author Benoît Zugmeyer
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const DEFAULT_MESSAGE_TEMPLATE = "Unexpected use of '{{name}}'.",
+    CUSTOM_MESSAGE_TEMPLATE = "Unexpected use of '{{name}}'. {{customMessage}}";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        type: "suggestion",
+
+        docs: {
+            description: "disallow specified global variables",
+            category: "Variables",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/no-restricted-globals"
+        },
+
+        schema: {
+            type: "array",
+            items: {
+                oneOf: [
+                    {
+                        type: "string"
+                    },
+                    {
+                        type: "object",
+                        properties: {
+                            name: { type: "string" },
+                            message: { type: "string" }
+                        },
+                        required: ["name"],
+                        additionalProperties: false
+                    }
+                ]
+            },
+            uniqueItems: true,
+            minItems: 0
+        }
+    },
+
+    create(context) {
+
+        // If no globals are restricted, we don't need to do anything
+        if (context.options.length === 0) {
+            return {};
+        }
+
+        const restrictedGlobalMessages = context.options.reduce((memo, option) => {
+            if (typeof option === "string") {
+                memo[option] = null;
+            } else {
+                memo[option.name] = option.message;
+            }
+
+            return memo;
+        }, {});
+
+        /**
+         * Report a variable to be used as a restricted global.
+         * @param {Reference} reference the variable reference
+         * @returns {void}
+         * @private
+         */
+        function reportReference(reference) {
+            const name = reference.identifier.name,
+                customMessage = restrictedGlobalMessages[name],
+                message = customMessage
+                    ? CUSTOM_MESSAGE_TEMPLATE
+                    : DEFAULT_MESSAGE_TEMPLATE;
+
+            context.report({
+                node: reference.identifier,
+                message,
+                data: {
+                    name,
+                    customMessage
+                }
+            });
+        }
+
+        /**
+         * Check if the given name is a restricted global name.
+         * @param {string} name name of a variable
+         * @returns {boolean} whether the variable is a restricted global or not
+         * @private
+         */
+        function isRestricted(name) {
+            return Object.prototype.hasOwnProperty.call(restrictedGlobalMessages, name);
+        }
+
+        return {
+            Program() {
+                const scope = context.getScope();
+
+                // Report variables declared elsewhere (ex: variables defined as "global" by eslint)
+                scope.variables.forEach(variable => {
+                    if (!variable.defs.length && isRestricted(variable.name)) {
+                        variable.references.forEach(reportReference);
+                    }
+                });
+
+                // Report variables not declared at all
+                scope.through.forEach(reference => {
+                    if (isRestricted(reference.identifier.name)) {
+                        reportReference(reference);
+                    }
+                });
+
+            }
+        };
+    }
+};

package/packages/less/node_modules/eslint/lib/rules/no-restricted-imports.js

@@ -0,0 +1,282 @@
+/**
+ * @fileoverview Restrict usage of specified node imports.
+ * @author Guy Ellis
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const DEFAULT_MESSAGE_TEMPLATE = "'{{importSource}}' import is restricted from being used.";
+const CUSTOM_MESSAGE_TEMPLATE = "'{{importSource}}' import is restricted from being used. {{customMessage}}";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+const ignore = require("ignore");
+
+const arrayOfStrings = {
+    type: "array",
+    items: { type: "string" },
+    uniqueItems: true
+};
+
+const arrayOfStringsOrObjects = {
+    type: "array",
+    items: {
+        anyOf: [
+            { type: "string" },
+            {
+                type: "object",
+                properties: {
+                    name: { type: "string" },
+                    message: {
+                        type: "string",
+                        minLength: 1
+                    },
+                    importNames: {
+                        type: "array",
+                        items: {
+                            type: "string"
+                        }
+                    }
+                },
+                additionalProperties: false,
+                required: ["name"]
+            }
+        ]
+    },
+    uniqueItems: true
+};
+
+module.exports = {
+    meta: {
+        type: "suggestion",
+
+        docs: {
+            description: "disallow specified modules when loaded by `import`",
+            category: "ECMAScript 6",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/no-restricted-imports"
+        },
+
+        schema: {
+            anyOf: [
+                arrayOfStringsOrObjects,
+                {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            paths: arrayOfStringsOrObjects,
+                            patterns: arrayOfStrings
+                        },
+                        additionalProperties: false
+                    },
+                    additionalItems: false
+                }
+            ]
+        }
+    },
+
+    create(context) {
+        const options = Array.isArray(context.options) ? context.options : [];
+        const isPathAndPatternsObject =
+            typeof options[0] === "object" &&
+            (Object.prototype.hasOwnProperty.call(options[0], "paths") || Object.prototype.hasOwnProperty.call(options[0], "patterns"));
+
+        const restrictedPaths = (isPathAndPatternsObject ? options[0].paths : context.options) || [];
+        const restrictedPatterns = (isPathAndPatternsObject ? options[0].patterns : []) || [];
+
+        const restrictedPathMessages = restrictedPaths.reduce((memo, importSource) => {
+            if (typeof importSource === "string") {
+                memo[importSource] = { message: null };
+            } else {
+                memo[importSource.name] = {
+                    message: importSource.message,
+                    importNames: importSource.importNames
+                };
+            }
+            return memo;
+        }, {});
+
+        // if no imports are restricted we don"t need to check
+        if (Object.keys(restrictedPaths).length === 0 && restrictedPatterns.length === 0) {
+            return {};
+        }
+
+        const restrictedPatternsMatcher = ignore().add(restrictedPatterns);
+
+        /**
+         * Checks to see if "*" is being used to import everything.
+         * @param {Set.<string>} importNames - Set of import names that are being imported
+         * @returns {boolean} whether everything is imported or not
+         */
+        function isEverythingImported(importNames) {
+            return importNames.has("*");
+        }
+
+        /**
+         * Report a restricted path.
+         * @param {node} node representing the restricted path reference
+         * @returns {void}
+         * @private
+         */
+        function reportPath(node) {
+            const importSource = node.source.value.trim();
+            const customMessage = restrictedPathMessages[importSource] && restrictedPathMessages[importSource].message;
+            const message = customMessage
+                ? CUSTOM_MESSAGE_TEMPLATE
+                : DEFAULT_MESSAGE_TEMPLATE;
+
+            context.report({
+                node,
+                message,
+                data: {
+                    importSource,
+                    customMessage
+                }
+            });
+        }
+
+        /**
+         * Report a restricted path specifically for patterns.
+         * @param {node} node - representing the restricted path reference
+         * @returns {void}
+         * @private
+         */
+        function reportPathForPatterns(node) {
+            const importSource = node.source.value.trim();
+
+            context.report({
+                node,
+                message: "'{{importSource}}' import is restricted from being used by a pattern.",
+                data: {
+                    importSource
+                }
+            });
+        }
+
+        /**
+         * Report a restricted path specifically when using the '*' import.
+         * @param {string} importSource - path of the import
+         * @param {node} node - representing the restricted path reference
+         * @returns {void}
+         * @private
+         */
+        function reportPathForEverythingImported(importSource, node) {
+            const importNames = restrictedPathMessages[importSource].importNames;
+
+            context.report({
+                node,
+                message: "* import is invalid because '{{importNames}}' from '{{importSource}}' is restricted.",
+                data: {
+                    importSource,
+                    importNames
+                }
+            });
+        }
+
+        /**
+         * Check if the given importSource is restricted because '*' is being imported.
+         * @param {string} importSource - path of the import
+         * @param {Set.<string>} importNames - Set of import names that are being imported
+         * @returns {boolean} whether the path is restricted
+         * @private
+         */
+        function isRestrictedForEverythingImported(importSource, importNames) {
+            return Object.prototype.hasOwnProperty.call(restrictedPathMessages, importSource) &&
+                restrictedPathMessages[importSource].importNames &&
+                isEverythingImported(importNames);
+        }
+
+        /**
+         * Check if the given importNames are restricted given a list of restrictedImportNames.
+         * @param {Set.<string>} importNames - Set of import names that are being imported
+         * @param {string[]} restrictedImportNames - array of import names that are restricted for this import
+         * @returns {boolean} whether the objectName is restricted
+         * @private
+         */
+        function isRestrictedObject(importNames, restrictedImportNames) {
+            return restrictedImportNames.some(restrictedObjectName => (
+                importNames.has(restrictedObjectName)
+            ));
+        }
+
+        /**
+         * Check if the given importSource is a restricted path.
+         * @param {string} importSource - path of the import
+         * @param {Set.<string>} importNames - Set of import names that are being imported
+         * @returns {boolean} whether the variable is a restricted path or not
+         * @private
+         */
+        function isRestrictedPath(importSource, importNames) {
+            let isRestricted = false;
+
+            if (Object.prototype.hasOwnProperty.call(restrictedPathMessages, importSource)) {
+                if (restrictedPathMessages[importSource].importNames) {
+                    isRestricted = isRestrictedObject(importNames, restrictedPathMessages[importSource].importNames);
+                } else {
+                    isRestricted = true;
+                }
+            }
+
+            return isRestricted;
+        }
+
+        /**
+         * Check if the given importSource is restricted by a pattern.
+         * @param {string} importSource - path of the import
+         * @returns {boolean} whether the variable is a restricted pattern or not
+         * @private
+         */
+        function isRestrictedPattern(importSource) {
+            return restrictedPatterns.length > 0 && restrictedPatternsMatcher.ignores(importSource);
+        }
+
+        /**
+         * Checks a node to see if any problems should be reported.
+         * @param {ASTNode} node The node to check.
+         * @returns {void}
+         * @private
+         */
+        function checkNode(node) {
+            const importSource = node.source.value.trim();
+            const importNames = node.specifiers ? node.specifiers.reduce((set, specifier) => {
+                if (specifier.type === "ImportDefaultSpecifier") {
+                    set.add("default");
+                } else if (specifier.type === "ImportNamespaceSpecifier") {
+                    set.add("*");
+                } else if (specifier.imported) {
+                    set.add(specifier.imported.name);
+                } else if (specifier.local) {
+                    set.add(specifier.local.name);
+                }
+                return set;
+            }, new Set()) : new Set();
+
+            if (isRestrictedForEverythingImported(importSource, importNames)) {
+                reportPathForEverythingImported(importSource, node);
+            }
+
+            if (isRestrictedPath(importSource, importNames)) {
+                reportPath(node);
+            }
+            if (isRestrictedPattern(importSource)) {
+                reportPathForPatterns(node);
+            }
+        }
+
+        return {
+            ImportDeclaration: checkNode,
+            ExportNamedDeclaration(node) {
+                if (node.source) {
+                    checkNode(node);
+                }
+            },
+            ExportAllDeclaration: checkNode
+        };
+    }
+};

package/packages/less/node_modules/eslint/lib/rules/no-restricted-modules.js

@@ -0,0 +1,180 @@
+/**
+ * @fileoverview Restrict usage of specified node modules.
+ * @author Christian Schulz
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const DEFAULT_MESSAGE_TEMPLATE = "'{{moduleName}}' module is restricted from being used.";
+const CUSTOM_MESSAGE_TEMPLATE = "'{{moduleName}}' module is restricted from being used. {{customMessage}}";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+const ignore = require("ignore");
+
+const arrayOfStrings = {
+    type: "array",
+    items: { type: "string" },
+    uniqueItems: true
+};
+
+const arrayOfStringsOrObjects = {
+    type: "array",
+    items: {
+        anyOf: [
+            { type: "string" },
+            {
+                type: "object",
+                properties: {
+                    name: { type: "string" },
+                    message: {
+                        type: "string",
+                        minLength: 1
+                    }
+                },
+                additionalProperties: false,
+                required: ["name"]
+            }
+        ]
+    },
+    uniqueItems: true
+};
+
+module.exports = {
+    meta: {
+        type: "suggestion",
+
+        docs: {
+            description: "disallow specified modules when loaded by `require`",
+            category: "Node.js and CommonJS",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/no-restricted-modules"
+        },
+
+        schema: {
+            anyOf: [
+                arrayOfStringsOrObjects,
+                {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            paths: arrayOfStringsOrObjects,
+                            patterns: arrayOfStrings
+                        },
+                        additionalProperties: false
+                    },
+                    additionalItems: false
+                }
+            ]
+        }
+    },
+
+    create(context) {
+        const options = Array.isArray(context.options) ? context.options : [];
+        const isPathAndPatternsObject =
+            typeof options[0] === "object" &&
+            (Object.prototype.hasOwnProperty.call(options[0], "paths") || Object.prototype.hasOwnProperty.call(options[0], "patterns"));
+
+        const restrictedPaths = (isPathAndPatternsObject ? options[0].paths : context.options) || [];
+        const restrictedPatterns = (isPathAndPatternsObject ? options[0].patterns : []) || [];
+
+        const restrictedPathMessages = restrictedPaths.reduce((memo, importName) => {
+            if (typeof importName === "string") {
+                memo[importName] = null;
+            } else {
+                memo[importName.name] = importName.message;
+            }
+            return memo;
+        }, {});
+
+        // if no imports are restricted we don"t need to check
+        if (Object.keys(restrictedPaths).length === 0 && restrictedPatterns.length === 0) {
+            return {};
+        }
+
+        const ig = ignore().add(restrictedPatterns);
+
+
+        /**
+         * Function to check if a node is a string literal.
+         * @param {ASTNode} node The node to check.
+         * @returns {boolean} If the node is a string literal.
+         */
+        function isString(node) {
+            return node && node.type === "Literal" && typeof node.value === "string";
+        }
+
+        /**
+         * Function to check if a node is a require call.
+         * @param {ASTNode} node The node to check.
+         * @returns {boolean} If the node is a require call.
+         */
+        function isRequireCall(node) {
+            return node.callee.type === "Identifier" && node.callee.name === "require";
+        }
+
+        /**
+         * Report a restricted path.
+         * @param {node} node representing the restricted path reference
+         * @returns {void}
+         * @private
+         */
+        function reportPath(node) {
+            const moduleName = node.arguments[0].value.trim();
+            const customMessage = restrictedPathMessages[moduleName];
+            const message = customMessage
+                ? CUSTOM_MESSAGE_TEMPLATE
+                : DEFAULT_MESSAGE_TEMPLATE;
+
+            context.report({
+                node,
+                message,
+                data: {
+                    moduleName,
+                    customMessage
+                }
+            });
+        }
+
+        /**
+         * Check if the given name is a restricted path name
+         * @param {string} name name of a variable
+         * @returns {boolean} whether the variable is a restricted path or not
+         * @private
+         */
+        function isRestrictedPath(name) {
+            return Object.prototype.hasOwnProperty.call(restrictedPathMessages, name);
+        }
+
+        return {
+            CallExpression(node) {
+                if (isRequireCall(node)) {
+
+                    // node has arguments and first argument is string
+                    if (node.arguments.length && isString(node.arguments[0])) {
+                        const moduleName = node.arguments[0].value.trim();
+
+                        // check if argument value is in restricted modules array
+                        if (isRestrictedPath(moduleName)) {
+                            reportPath(node);
+                        }
+
+                        if (restrictedPatterns.length > 0 && ig.ignores(moduleName)) {
+                            context.report({
+                                node,
+                                message: "'{{moduleName}}' module is restricted from being used by a pattern.",
+                                data: { moduleName }
+                            });
+                        }
+                    }
+                }
+            }
+        };
+    }
+};