create-packer 1.34.4 → 1.34.6

package/template/lib/react/node_modules/eslint/lib/shared/config-validator.js

@@ -0,0 +1,347 @@
+/*
+ * STOP!!! DO NOT MODIFY.
+ *
+ * This file is part of the ongoing work to move the eslintrc-style config
+ * system into the @eslint/eslintrc package. This file needs to remain
+ * unchanged in order for this work to proceed.
+ *
+ * If you think you need to change this file, please contact @nzakas first.
+ *
+ * Thanks in advance for your cooperation.
+ */
+
+/**
+ * @fileoverview Validates configs.
+ * @author Brandon Mills
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const
+    util = require("util"),
+    configSchema = require("../../conf/config-schema"),
+    BuiltInRules = require("../rules"),
+    {
+        Legacy: {
+            ConfigOps,
+            environments: BuiltInEnvironments
+        }
+    } = require("@eslint/eslintrc"),
+    { emitDeprecationWarning } = require("./deprecation-warnings");
+
+const ajv = require("./ajv")();
+const ruleValidators = new WeakMap();
+const noop = Function.prototype;
+
+//------------------------------------------------------------------------------
+// Private
+//------------------------------------------------------------------------------
+let validateSchema;
+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) {
+    if (!rule) {
+        return null;
+    }
+
+    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.
+ * @throws {Error} Wrong severity value.
+ * @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
+ * @throws {Error} Any rule validation errors.
+ * @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.
+ * @throws {Error} Upon any bad rule configuration.
+ * @returns {void}
+ */
+function validateRuleOptions(rule, ruleId, options, source = null) {
+    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 {string} source The name of the configuration source to report in any errors.
+ * @param {(envId:string) => Object} [getAdditionalEnv] A map from strings to loaded environments.
+ * @returns {void}
+ */
+function validateEnvironment(
+    environment,
+    source,
+    getAdditionalEnv = noop
+) {
+
+    // not having an environment is ok
+    if (!environment) {
+        return;
+    }
+
+    Object.keys(environment).forEach(id => {
+        const env = getAdditionalEnv(id) || BuiltInEnvironments.get(id) || null;
+
+        if (!env) {
+            const message = `${source}:\n\tEnvironment key "${id}" is unknown\n`;
+
+            throw new Error(message);
+        }
+    });
+}
+
+/**
+ * Validates a rules config object
+ * @param {Object} rulesConfig The rules config object to validate.
+ * @param {string} source The name of the configuration source to report in any errors.
+ * @param {(ruleId:string) => Object} getAdditionalRule A map from strings to loaded rules
+ * @returns {void}
+ */
+function validateRules(
+    rulesConfig,
+    source,
+    getAdditionalRule = noop
+) {
+    if (!rulesConfig) {
+        return;
+    }
+
+    Object.keys(rulesConfig).forEach(id => {
+        const rule = getAdditionalRule(id) || BuiltInRules.get(id) || null;
+
+        validateRuleOptions(rule, id, rulesConfig[id], source);
+    });
+}
+
+/**
+ * Validates a `globals` section of a config file
+ * @param {Object} globalsConfig The `globals` section
+ * @param {string|null} source The name of the configuration source to report in the event of an error.
+ * @returns {void}
+ */
+function validateGlobals(globalsConfig, source = null) {
+    if (!globalsConfig) {
+        return;
+    }
+
+    Object.entries(globalsConfig)
+        .forEach(([configuredGlobal, configuredValue]) => {
+            try {
+                ConfigOps.normalizeConfigGlobal(configuredValue);
+            } catch (err) {
+                throw new Error(`ESLint configuration of global '${configuredGlobal}' in ${source} is invalid:\n${err.message}`);
+            }
+        });
+}
+
+/**
+ * Validate `processor` configuration.
+ * @param {string|undefined} processorName The processor name.
+ * @param {string} source The name of config file.
+ * @param {(id:string) => Processor} getProcessor The getter of defined processors.
+ * @throws {Error} For invalid processor configuration.
+ * @returns {void}
+ */
+function validateProcessor(processorName, source, getProcessor) {
+    if (processorName && !getProcessor(processorName)) {
+        throw new Error(`ESLint configuration of processor in '${source}' is invalid: '${processorName}' was not found.`);
+    }
+}
+
+/**
+ * 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("");
+}
+
+/**
+ * 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.
+ * @throws {Error} For any config invalid per the schema.
+ * @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");
+    }
+}
+
+/**
+ * Validates an entire config object.
+ * @param {Object} config The config object to validate.
+ * @param {string} source The name of the configuration source to report in any errors.
+ * @param {(ruleId:string) => Object} [getAdditionalRule] A map from strings to loaded rules.
+ * @param {(envId:string) => Object} [getAdditionalEnv] A map from strings to loaded envs.
+ * @returns {void}
+ */
+function validate(config, source, getAdditionalRule, getAdditionalEnv) {
+    validateConfigSchema(config, source);
+    validateRules(config.rules, source, getAdditionalRule);
+    validateEnvironment(config.env, source, getAdditionalEnv);
+    validateGlobals(config.globals, source);
+
+    for (const override of config.overrides || []) {
+        validateRules(override.rules, source, getAdditionalRule);
+        validateEnvironment(override.env, source, getAdditionalEnv);
+        validateGlobals(config.globals, source);
+    }
+}
+
+const validated = new WeakSet();
+
+/**
+ * Validate config array object.
+ * @param {ConfigArray} configArray The config array to validate.
+ * @returns {void}
+ */
+function validateConfigArray(configArray) {
+    const getPluginEnv = Map.prototype.get.bind(configArray.pluginEnvironments);
+    const getPluginProcessor = Map.prototype.get.bind(configArray.pluginProcessors);
+    const getPluginRule = Map.prototype.get.bind(configArray.pluginRules);
+
+    // Validate.
+    for (const element of configArray) {
+        if (validated.has(element)) {
+            continue;
+        }
+        validated.add(element);
+
+        validateEnvironment(element.env, element.name, getPluginEnv);
+        validateGlobals(element.globals, element.name);
+        validateProcessor(element.processor, element.name, getPluginProcessor);
+        validateRules(element.rules, element.name, getPluginRule);
+    }
+}
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+module.exports = {
+    getRuleOptionsSchema,
+    validate,
+    validateConfigArray,
+    validateConfigSchema,
+    validateRuleOptions
+};

package/template/lib/react/node_modules/eslint/lib/shared/deprecation-warnings.js

@@ -0,0 +1,58 @@
+/**
+ * @fileoverview Provide the function that emits deprecation warnings.
+ * @author Toru Nagashima <http://github.com/mysticatea>
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const path = require("path");
+
+//------------------------------------------------------------------------------
+// Private
+//------------------------------------------------------------------------------
+
+// Definitions for deprecation warnings.
+const deprecationWarningMessages = {
+    ESLINT_LEGACY_ECMAFEATURES:
+        "The 'ecmaFeatures' config file property is deprecated and has no effect."
+};
+
+const sourceFileErrorCache = new Set();
+
+/**
+ * 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}
+ */
+function emitDeprecationWarning(source, errorCode) {
+    const cacheKey = JSON.stringify({ source, errorCode });
+
+    if (sourceFileErrorCache.has(cacheKey)) {
+        return;
+    }
+
+    sourceFileErrorCache.add(cacheKey);
+
+    const rel = path.relative(process.cwd(), source);
+    const message = deprecationWarningMessages[errorCode];
+
+    process.emitWarning(
+        `${message} (found in "${rel}")`,
+        "DeprecationWarning",
+        errorCode
+    );
+}
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+module.exports = {
+    emitDeprecationWarning
+};

package/template/lib/react/node_modules/eslint/lib/shared/directives.js

@@ -0,0 +1,15 @@
+/**
+ * @fileoverview Common utils for directives.
+ *
+ * This file contains only shared items for directives.
+ * If you make a utility for rules, please see `../rules/utils/ast-utils.js`.
+ *
+ * @author gfyoung <https://github.com/gfyoung>
+ */
+"use strict";
+
+const directivesPattern = /^(eslint(?:-env|-enable|-disable(?:(?:-next)?-line)?)?|exported|globals?)(?:\s|$)/u;
+
+module.exports = {
+    directivesPattern
+};

package/template/lib/react/node_modules/eslint/lib/shared/logging.js

@@ -0,0 +1,30 @@
+/**
+ * @fileoverview Handle logging for ESLint
+ * @author Gyandeep Singh
+ */
+
+"use strict";
+
+/* eslint no-console: "off" -- Logging util */
+
+/* c8 ignore next */
+module.exports = {
+
+    /**
+     * Cover for console.log
+     * @param {...any} args The elements to log.
+     * @returns {void}
+     */
+    info(...args) {
+        console.log(...args);
+    },
+
+    /**
+     * Cover for console.error
+     * @param {...any} args The elements to log.
+     * @returns {void}
+     */
+    error(...args) {
+        console.error(...args);
+    }
+};

package/template/lib/react/node_modules/eslint/lib/shared/relative-module-resolver.js

@@ -0,0 +1,50 @@
+/*
+ * STOP!!! DO NOT MODIFY.
+ *
+ * This file is part of the ongoing work to move the eslintrc-style config
+ * system into the @eslint/eslintrc package. This file needs to remain
+ * unchanged in order for this work to proceed.
+ *
+ * If you think you need to change this file, please contact @nzakas first.
+ *
+ * Thanks in advance for your cooperation.
+ */
+
+/**
+ * Utility for resolving a module relative to another module
+ * @author Teddy Katz
+ */
+
+"use strict";
+
+const { createRequire } = require("module");
+
+module.exports = {
+
+    /**
+     * Resolves a Node module relative to another module
+     * @param {string} moduleName The name of a Node module, or a path to a Node module.
+     * @param {string} relativeToPath An absolute path indicating the module that `moduleName` should be resolved relative to. This must be
+     * a file rather than a directory, but the file need not actually exist.
+     * @throws {Error} Any error from `module.createRequire` or its `resolve`.
+     * @returns {string} The absolute path that would result from calling `require.resolve(moduleName)` in a file located at `relativeToPath`
+     */
+    resolve(moduleName, relativeToPath) {
+        try {
+            return createRequire(relativeToPath).resolve(moduleName);
+        } catch (error) {
+
+            // This `if` block is for older Node.js than 12.0.0. We can remove this block in the future.
+            if (
+                typeof error === "object" &&
+                error !== null &&
+                error.code === "MODULE_NOT_FOUND" &&
+                !error.requireStack &&
+                error.message.includes(moduleName)
+            ) {
+                error.message += `\nRequire stack:\n- ${relativeToPath}`;
+            }
+            throw error;
+        }
+    }
+};

package/template/lib/react/node_modules/eslint/lib/shared/runtime-info.js

@@ -0,0 +1,167 @@
+/**
+ * @fileoverview Utility to get information about the execution environment.
+ * @author Kai Cataldo
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const path = require("path");
+const spawn = require("cross-spawn");
+const os = require("os");
+const log = require("../shared/logging");
+const packageJson = require("../../package.json");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Generates and returns execution environment information.
+ * @returns {string} A string that contains execution environment information.
+ */
+function environment() {
+    const cache = new Map();
+
+    /**
+     * Checks if a path is a child of a directory.
+     * @param {string} parentPath The parent path to check.
+     * @param {string} childPath The path to check.
+     * @returns {boolean} Whether or not the given path is a child of a directory.
+     */
+    function isChildOfDirectory(parentPath, childPath) {
+        return !path.relative(parentPath, childPath).startsWith("..");
+    }
+
+    /**
+     * Synchronously executes a shell command and formats the result.
+     * @param {string} cmd The command to execute.
+     * @param {Array} args The arguments to be executed with the command.
+     * @throws {Error} As may be collected by `cross-spawn.sync`.
+     * @returns {string} The version returned by the command.
+     */
+    function execCommand(cmd, args) {
+        const key = [cmd, ...args].join(" ");
+
+        if (cache.has(key)) {
+            return cache.get(key);
+        }
+
+        const process = spawn.sync(cmd, args, { encoding: "utf8" });
+
+        if (process.error) {
+            throw process.error;
+        }
+
+        const result = process.stdout.trim();
+
+        cache.set(key, result);
+        return result;
+    }
+
+    /**
+     * Normalizes a version number.
+     * @param {string} versionStr The string to normalize.
+     * @returns {string} The normalized version number.
+     */
+    function normalizeVersionStr(versionStr) {
+        return versionStr.startsWith("v") ? versionStr : `v${versionStr}`;
+    }
+
+    /**
+     * Gets bin version.
+     * @param {string} bin The bin to check.
+     * @throws {Error} As may be collected by `cross-spawn.sync`.
+     * @returns {string} The normalized version returned by the command.
+     */
+    function getBinVersion(bin) {
+        const binArgs = ["--version"];
+
+        try {
+            return normalizeVersionStr(execCommand(bin, binArgs));
+        } catch (e) {
+            log.error(`Error finding ${bin} version running the command \`${bin} ${binArgs.join(" ")}\``);
+            throw e;
+        }
+    }
+
+    /**
+     * Gets installed npm package version.
+     * @param {string} pkg The package to check.
+     * @param {boolean} global Whether to check globally or not.
+     * @throws {Error} As may be collected by `cross-spawn.sync`.
+     * @returns {string} The normalized version returned by the command.
+     */
+    function getNpmPackageVersion(pkg, { global = false } = {}) {
+        const npmBinArgs = ["bin", "-g"];
+        const npmLsArgs = ["ls", "--depth=0", "--json", pkg];
+
+        if (global) {
+            npmLsArgs.push("-g");
+        }
+
+        try {
+            const parsedStdout = JSON.parse(execCommand("npm", npmLsArgs));
+
+            /*
+             * Checking globally returns an empty JSON object, while local checks
+             * include the name and version of the local project.
+             */
+            if (Object.keys(parsedStdout).length === 0 || !(parsedStdout.dependencies && parsedStdout.dependencies.eslint)) {
+                return "Not found";
+            }
+
+            const [, processBinPath] = process.argv;
+            let npmBinPath;
+
+            try {
+                npmBinPath = execCommand("npm", npmBinArgs);
+            } catch (e) {
+                log.error(`Error finding npm binary path when running command \`npm ${npmBinArgs.join(" ")}\``);
+                throw e;
+            }
+
+            const isGlobal = isChildOfDirectory(npmBinPath, processBinPath);
+            let pkgVersion = parsedStdout.dependencies.eslint.version;
+
+            if ((global && isGlobal) || (!global && !isGlobal)) {
+                pkgVersion += " (Currently used)";
+            }
+
+            return normalizeVersionStr(pkgVersion);
+        } catch (e) {
+            log.error(`Error finding ${pkg} version running the command \`npm ${npmLsArgs.join(" ")}\``);
+            throw e;
+        }
+    }
+
+    return [
+        "Environment Info:",
+        "",
+        `Node version: ${getBinVersion("node")}`,
+        `npm version: ${getBinVersion("npm")}`,
+        `Local ESLint version: ${getNpmPackageVersion("eslint", { global: false })}`,
+        `Global ESLint version: ${getNpmPackageVersion("eslint", { global: true })}`,
+        `Operating System: ${os.platform()} ${os.release()}`
+    ].join("\n");
+}
+
+/**
+ * Returns version of currently executing ESLint.
+ * @returns {string} The version from the currently executing ESLint's package.json.
+ */
+function version() {
+    return `v${packageJson.version}`;
+}
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+module.exports = {
+    environment,
+    version
+};