less 3.10.1 → 3.11.1

package/packages/less/node_modules/eslint/lib/config/config-rule.js

@@ -0,0 +1,319 @@
+/**
+ * @fileoverview Create configurations for a rule
+ * @author Ian VanSchooten
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const Rules = require("../rules"),
+    builtInRules = require("../built-in-rules-index");
+
+const rules = new Rules();
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Wrap all of the elements of an array into arrays.
+ * @param   {*[]}     xs Any array.
+ * @returns {Array[]}    An array of arrays.
+ */
+function explodeArray(xs) {
+    return xs.reduce((accumulator, x) => {
+        accumulator.push([x]);
+        return accumulator;
+    }, []);
+}
+
+/**
+ * Mix two arrays such that each element of the second array is concatenated
+ * onto each element of the first array.
+ *
+ * For example:
+ * combineArrays([a, [b, c]], [x, y]); // -> [[a, x], [a, y], [b, c, x], [b, c, y]]
+ *
+ * @param   {Array} arr1 The first array to combine.
+ * @param   {Array} arr2 The second array to combine.
+ * @returns {Array}      A mixture of the elements of the first and second arrays.
+ */
+function combineArrays(arr1, arr2) {
+    const res = [];
+
+    if (arr1.length === 0) {
+        return explodeArray(arr2);
+    }
+    if (arr2.length === 0) {
+        return explodeArray(arr1);
+    }
+    arr1.forEach(x1 => {
+        arr2.forEach(x2 => {
+            res.push([].concat(x1, x2));
+        });
+    });
+    return res;
+}
+
+/**
+ * Group together valid rule configurations based on object properties
+ *
+ * e.g.:
+ * groupByProperty([
+ *     {before: true},
+ *     {before: false},
+ *     {after: true},
+ *     {after: false}
+ * ]);
+ *
+ * will return:
+ * [
+ *     [{before: true}, {before: false}],
+ *     [{after: true}, {after: false}]
+ * ]
+ *
+ * @param   {Object[]} objects Array of objects, each with one property/value pair
+ * @returns {Array[]}          Array of arrays of objects grouped by property
+ */
+function groupByProperty(objects) {
+    const groupedObj = objects.reduce((accumulator, obj) => {
+        const prop = Object.keys(obj)[0];
+
+        accumulator[prop] = accumulator[prop] ? accumulator[prop].concat(obj) : [obj];
+        return accumulator;
+    }, {});
+
+    return Object.keys(groupedObj).map(prop => groupedObj[prop]);
+}
+
+
+//------------------------------------------------------------------------------
+// Private
+//------------------------------------------------------------------------------
+
+/**
+ * Configuration settings for a rule.
+ *
+ * A configuration can be a single number (severity), or an array where the first
+ * element in the array is the severity, and is the only required element.
+ * Configs may also have one or more additional elements to specify rule
+ * configuration or options.
+ *
+ * @typedef {array|number} ruleConfig
+ * @param {number}  0  The rule's severity (0, 1, 2).
+ */
+
+/**
+ * Object whose keys are rule names and values are arrays of valid ruleConfig items
+ * which should be linted against the target source code to determine error counts.
+ * (a ruleConfigSet.ruleConfigs).
+ *
+ * e.g. rulesConfig = {
+ *     "comma-dangle": [2, [2, "always"], [2, "always-multiline"], [2, "never"]],
+ *     "no-console": [2]
+ * }
+ * @typedef rulesConfig
+ */
+
+
+/**
+ * Create valid rule configurations by combining two arrays,
+ * with each array containing multiple objects each with a
+ * single property/value pair and matching properties.
+ *
+ * e.g.:
+ * combinePropertyObjects(
+ *     [{before: true}, {before: false}],
+ *     [{after: true}, {after: false}]
+ * );
+ *
+ * will return:
+ * [
+ *     {before: true, after: true},
+ *     {before: true, after: false},
+ *     {before: false, after: true},
+ *     {before: false, after: false}
+ * ]
+ *
+ * @param   {Object[]} objArr1 Single key/value objects, all with the same key
+ * @param   {Object[]} objArr2 Single key/value objects, all with another key
+ * @returns {Object[]}         Combined objects for each combination of input properties and values
+ */
+function combinePropertyObjects(objArr1, objArr2) {
+    const res = [];
+
+    if (objArr1.length === 0) {
+        return objArr2;
+    }
+    if (objArr2.length === 0) {
+        return objArr1;
+    }
+    objArr1.forEach(obj1 => {
+        objArr2.forEach(obj2 => {
+            const combinedObj = {};
+            const obj1Props = Object.keys(obj1);
+            const obj2Props = Object.keys(obj2);
+
+            obj1Props.forEach(prop1 => {
+                combinedObj[prop1] = obj1[prop1];
+            });
+            obj2Props.forEach(prop2 => {
+                combinedObj[prop2] = obj2[prop2];
+            });
+            res.push(combinedObj);
+        });
+    });
+    return res;
+}
+
+/**
+ * Creates a new instance of a rule configuration set
+ *
+ * A rule configuration set is an array of configurations that are valid for a
+ * given rule.  For example, the configuration set for the "semi" rule could be:
+ *
+ * ruleConfigSet.ruleConfigs // -> [[2], [2, "always"], [2, "never"]]
+ *
+ * Rule configuration set class
+ */
+class RuleConfigSet {
+
+    /**
+     * @param {ruleConfig[]} configs Valid rule configurations
+     */
+    constructor(configs) {
+
+        /**
+         * Stored valid rule configurations for this instance
+         * @type {array}
+         */
+        this.ruleConfigs = configs || [];
+    }
+
+    /**
+     * Add a severity level to the front of all configs in the instance.
+     * This should only be called after all configs have been added to the instance.
+     *
+     * @returns {void}
+     */
+    addErrorSeverity() {
+        const severity = 2;
+
+        this.ruleConfigs = this.ruleConfigs.map(config => {
+            config.unshift(severity);
+            return config;
+        });
+
+        // Add a single config at the beginning consisting of only the severity
+        this.ruleConfigs.unshift(severity);
+    }
+
+    /**
+     * Add rule configs from an array of strings (schema enums)
+     * @param  {string[]} enums Array of valid rule options (e.g. ["always", "never"])
+     * @returns {void}
+     */
+    addEnums(enums) {
+        this.ruleConfigs = this.ruleConfigs.concat(combineArrays(this.ruleConfigs, enums));
+    }
+
+    /**
+     * Add rule configurations from a schema object
+     * @param  {Object} obj Schema item with type === "object"
+     * @returns {boolean} true if at least one schema for the object could be generated, false otherwise
+     */
+    addObject(obj) {
+        const objectConfigSet = {
+            objectConfigs: [],
+            add(property, values) {
+                for (let idx = 0; idx < values.length; idx++) {
+                    const optionObj = {};
+
+                    optionObj[property] = values[idx];
+                    this.objectConfigs.push(optionObj);
+                }
+            },
+
+            combine() {
+                this.objectConfigs = groupByProperty(this.objectConfigs).reduce((accumulator, objArr) => combinePropertyObjects(accumulator, objArr), []);
+            }
+        };
+
+        /*
+         * The object schema could have multiple independent properties.
+         * If any contain enums or booleans, they can be added and then combined
+         */
+        Object.keys(obj.properties).forEach(prop => {
+            if (obj.properties[prop].enum) {
+                objectConfigSet.add(prop, obj.properties[prop].enum);
+            }
+            if (obj.properties[prop].type && obj.properties[prop].type === "boolean") {
+                objectConfigSet.add(prop, [true, false]);
+            }
+        });
+        objectConfigSet.combine();
+
+        if (objectConfigSet.objectConfigs.length > 0) {
+            this.ruleConfigs = this.ruleConfigs.concat(combineArrays(this.ruleConfigs, objectConfigSet.objectConfigs));
+            return true;
+        }
+
+        return false;
+    }
+}
+
+/**
+ * Generate valid rule configurations based on a schema object
+ * @param   {Object} schema  A rule's schema object
+ * @returns {Array[]}        Valid rule configurations
+ */
+function generateConfigsFromSchema(schema) {
+    const configSet = new RuleConfigSet();
+
+    if (Array.isArray(schema)) {
+        for (const opt of schema) {
+            if (opt.enum) {
+                configSet.addEnums(opt.enum);
+            } else if (opt.type && opt.type === "object") {
+                if (!configSet.addObject(opt)) {
+                    break;
+                }
+
+            // TODO (IanVS): support oneOf
+            } else {
+
+                // If we don't know how to fill in this option, don't fill in any of the following options.
+                break;
+            }
+        }
+    }
+    configSet.addErrorSeverity();
+    return configSet.ruleConfigs;
+}
+
+/**
+ * Generate possible rule configurations for all of the core rules
+ * @returns {rulesConfig} Hash of rule names and arrays of possible configurations
+ */
+function createCoreRuleConfigs() {
+    return Object.keys(builtInRules).reduce((accumulator, id) => {
+        const rule = rules.get(id);
+        const schema = (typeof rule === "function") ? rule.schema : rule.meta.schema;
+
+        accumulator[id] = generateConfigsFromSchema(schema);
+        return accumulator;
+    }, {});
+}
+
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+module.exports = {
+    generateConfigsFromSchema,
+    createCoreRuleConfigs
+};

package/packages/less/node_modules/eslint/lib/config/config-validator.js

@@ -0,0 +1,279 @@
+/**
+ * @fileoverview Validates configs.
+ * @author Brandon Mills
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const path = require("path"),
+    ajv = require("../util/ajv"),
+    lodash = require("lodash"),
+    configSchema = require("../../conf/config-schema.js"),
+    util = require("util");
+
+const ruleValidators = new WeakMap();
+
+//------------------------------------------------------------------------------
+// Private
+//------------------------------------------------------------------------------
+let validateSchema;
+
+// Defitions for deprecation warnings.
+const deprecationWarningMessages = {
+    ESLINT_LEGACY_ECMAFEATURES: "The 'ecmaFeatures' config file property is deprecated, and has no effect.",
+    ESLINT_LEGACY_OBJECT_REST_SPREAD: "The 'parserOptions.ecmaFeatures.experimentalObjectRestSpread' option is deprecated. Use 'parserOptions.ecmaVersion' instead."
+};
+const severityMap = {
+    error: 2,
+    warn: 1,
+    off: 0
+};
+
+/**
+ * Gets a complete options schema for a rule.
+ * @param {{create: Function, schema: (Array|null)}} rule A new-style rule object
+ * @returns {Object} JSON Schema for the rule's options.
+ */
+function getRuleOptionsSchema(rule) {
+    const schema = rule.schema || rule.meta && rule.meta.schema;
+
+    // Given a tuple of schemas, insert warning level at the beginning
+    if (Array.isArray(schema)) {
+        if (schema.length) {
+            return {
+                type: "array",
+                items: schema,
+                minItems: 0,
+                maxItems: schema.length
+            };
+        }
+        return {
+            type: "array",
+            minItems: 0,
+            maxItems: 0
+        };
+
+    }
+
+    // Given a full schema, leave it alone
+    return schema || null;
+}
+
+/**
+ * Validates a rule's severity and returns the severity value. Throws an error if the severity is invalid.
+ * @param {options} options The given options for the rule.
+ * @returns {number|string} The rule's severity value
+ */
+function validateRuleSeverity(options) {
+    const severity = Array.isArray(options) ? options[0] : options;
+    const normSeverity = typeof severity === "string" ? severityMap[severity.toLowerCase()] : severity;
+
+    if (normSeverity === 0 || normSeverity === 1 || normSeverity === 2) {
+        return normSeverity;
+    }
+
+    throw new Error(`\tSeverity should be one of the following: 0 = off, 1 = warn, 2 = error (you passed '${util.inspect(severity).replace(/'/gu, "\"").replace(/\n/gu, "")}').\n`);
+
+}
+
+/**
+ * Validates the non-severity options passed to a rule, based on its schema.
+ * @param {{create: Function}} rule The rule to validate
+ * @param {Array} localOptions The options for the rule, excluding severity
+ * @returns {void}
+ */
+function validateRuleSchema(rule, localOptions) {
+    if (!ruleValidators.has(rule)) {
+        const schema = getRuleOptionsSchema(rule);
+
+        if (schema) {
+            ruleValidators.set(rule, ajv.compile(schema));
+        }
+    }
+
+    const validateRule = ruleValidators.get(rule);
+
+    if (validateRule) {
+        validateRule(localOptions);
+        if (validateRule.errors) {
+            throw new Error(validateRule.errors.map(
+                error => `\tValue ${JSON.stringify(error.data)} ${error.message}.\n`
+            ).join(""));
+        }
+    }
+}
+
+/**
+ * Validates a rule's options against its schema.
+ * @param {{create: Function}|null} rule The rule that the config is being validated for
+ * @param {string} ruleId The rule's unique name.
+ * @param {Array|number} options The given options for the rule.
+ * @param {string|null} source The name of the configuration source to report in any errors. If null or undefined,
+ * no source is prepended to the message.
+ * @returns {void}
+ */
+function validateRuleOptions(rule, ruleId, options, source = null) {
+    if (!rule) {
+        return;
+    }
+    try {
+        const severity = validateRuleSeverity(options);
+
+        if (severity !== 0) {
+            validateRuleSchema(rule, Array.isArray(options) ? options.slice(1) : []);
+        }
+    } catch (err) {
+        const enhancedMessage = `Configuration for rule "${ruleId}" is invalid:\n${err.message}`;
+
+        if (typeof source === "string") {
+            throw new Error(`${source}:\n\t${enhancedMessage}`);
+        } else {
+            throw new Error(enhancedMessage);
+        }
+    }
+}
+
+/**
+ * Validates an environment object
+ * @param {Object} environment The environment config object to validate.
+ * @param {Environments} envContext Env context
+ * @param {string} source The name of the configuration source to report in any errors.
+ * @returns {void}
+ */
+function validateEnvironment(environment, envContext, source = null) {
+
+    // not having an environment is ok
+    if (!environment) {
+        return;
+    }
+
+    Object.keys(environment).forEach(env => {
+        if (!envContext.get(env)) {
+            const message = `${source}:\n\tEnvironment key "${env}" is unknown\n`;
+
+            throw new Error(message);
+        }
+    });
+}
+
+/**
+ * Validates a rules config object
+ * @param {Object} rulesConfig The rules config object to validate.
+ * @param {function(string): {create: Function}} ruleMapper A mapper function from strings to loaded rules
+ * @param {string} source The name of the configuration source to report in any errors.
+ * @returns {void}
+ */
+function validateRules(rulesConfig, ruleMapper, source = null) {
+    if (!rulesConfig) {
+        return;
+    }
+
+    Object.keys(rulesConfig).forEach(id => {
+        validateRuleOptions(ruleMapper(id), id, rulesConfig[id], source);
+    });
+}
+
+/**
+ * Formats an array of schema validation errors.
+ * @param {Array} errors An array of error messages to format.
+ * @returns {string} Formatted error message
+ */
+function formatErrors(errors) {
+    return errors.map(error => {
+        if (error.keyword === "additionalProperties") {
+            const formattedPropertyPath = error.dataPath.length ? `${error.dataPath.slice(1)}.${error.params.additionalProperty}` : error.params.additionalProperty;
+
+            return `Unexpected top-level property "${formattedPropertyPath}"`;
+        }
+        if (error.keyword === "type") {
+            const formattedField = error.dataPath.slice(1);
+            const formattedExpectedType = Array.isArray(error.schema) ? error.schema.join("/") : error.schema;
+            const formattedValue = JSON.stringify(error.data);
+
+            return `Property "${formattedField}" is the wrong type (expected ${formattedExpectedType} but got \`${formattedValue}\`)`;
+        }
+
+        const field = error.dataPath[0] === "." ? error.dataPath.slice(1) : error.dataPath;
+
+        return `"${field}" ${error.message}. Value: ${JSON.stringify(error.data)}`;
+    }).map(message => `\t- ${message}.\n`).join("");
+}
+
+/**
+ * Emits a deprecation warning containing a given filepath. A new deprecation warning is emitted
+ * for each unique file path, but repeated invocations with the same file path have no effect.
+ * No warnings are emitted if the `--no-deprecation` or `--no-warnings` Node runtime flags are active.
+ * @param {string} source The name of the configuration source to report the warning for.
+ * @param {string} errorCode The warning message to show.
+ * @returns {void}
+ */
+const emitDeprecationWarning = lodash.memoize((source, errorCode) => {
+    const rel = path.relative(process.cwd(), source);
+    const message = deprecationWarningMessages[errorCode];
+
+    process.emitWarning(
+        `${message} (found in "${rel}")`,
+        "DeprecationWarning",
+        errorCode
+    );
+});
+
+/**
+ * Validates the top level properties of the config object.
+ * @param {Object} config The config object to validate.
+ * @param {string} source The name of the configuration source to report in any errors.
+ * @returns {void}
+ */
+function validateConfigSchema(config, source = null) {
+    validateSchema = validateSchema || ajv.compile(configSchema);
+
+    if (!validateSchema(config)) {
+        throw new Error(`ESLint configuration in ${source} is invalid:\n${formatErrors(validateSchema.errors)}`);
+    }
+
+    if (Object.hasOwnProperty.call(config, "ecmaFeatures")) {
+        emitDeprecationWarning(source, "ESLINT_LEGACY_ECMAFEATURES");
+    }
+
+    if (
+        (config.parser || "espree") === "espree" &&
+        config.parserOptions &&
+        config.parserOptions.ecmaFeatures &&
+        config.parserOptions.ecmaFeatures.experimentalObjectRestSpread
+    ) {
+        emitDeprecationWarning(source, "ESLINT_LEGACY_OBJECT_REST_SPREAD");
+    }
+}
+
+/**
+ * Validates an entire config object.
+ * @param {Object} config The config object to validate.
+ * @param {function(string): {create: Function}} ruleMapper A mapper function from rule IDs to defined rules
+ * @param {Environments} envContext The env context
+ * @param {string} source The name of the configuration source to report in any errors.
+ * @returns {void}
+ */
+function validate(config, ruleMapper, envContext, source = null) {
+    validateConfigSchema(config, source);
+    validateRules(config.rules, ruleMapper, source);
+    validateEnvironment(config.env, envContext, source);
+
+    for (const override of config.overrides || []) {
+        validateRules(override.rules, ruleMapper, source);
+        validateEnvironment(override.env, envContext, source);
+    }
+}
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+module.exports = {
+    getRuleOptionsSchema,
+    validate,
+    validateRuleOptions
+};

package/packages/less/node_modules/eslint/lib/config/environments.js

@@ -0,0 +1,84 @@
+/**
+ * @fileoverview Environments manager
+ * @author Nicholas C. Zakas
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const envs = require("../../conf/environments");
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+class Environments {
+
+    /**
+     * create env context
+     */
+    constructor() {
+        this._environments = new Map();
+
+        this.load();
+    }
+
+    /**
+     * Loads the default environments.
+     * @returns {void}
+     * @private
+     */
+    load() {
+        Object.keys(envs).forEach(envName => {
+            this._environments.set(envName, envs[envName]);
+        });
+    }
+
+    /**
+     * Gets the environment with the given name.
+     * @param {string} name The name of the environment to retrieve.
+     * @returns {Object?} The environment object or null if not found.
+     */
+    get(name) {
+        return this._environments.get(name) || null;
+    }
+
+    /**
+     * Gets all the environment present
+     * @returns {Object} The environment object for each env name
+     */
+    getAll() {
+        return Array.from(this._environments).reduce((coll, env) => {
+            coll[env[0]] = env[1];
+            return coll;
+        }, {});
+    }
+
+    /**
+     * Defines an environment.
+     * @param {string} name The name of the environment.
+     * @param {Object} env The environment settings.
+     * @returns {void}
+     */
+    define(name, env) {
+        this._environments.set(name, env);
+    }
+
+    /**
+     * Imports all environments from a plugin.
+     * @param {Object} plugin The plugin object.
+     * @param {string} pluginName The name of the plugin.
+     * @returns {void}
+     */
+    importPlugin(plugin, pluginName) {
+        if (plugin.environments) {
+            Object.keys(plugin.environments).forEach(envName => {
+                this.define(`${pluginName}/${envName}`, plugin.environments[envName]);
+            });
+        }
+    }
+}
+
+module.exports = Environments;