create-packer 1.34.9 → 1.35.0

package/template/lib/react/node_modules/eslint/lib/cli-engine/formatters/tap.js

@@ -1,95 +0,0 @@
-/**
- * @fileoverview TAP reporter
- * @author Jonathan Kingston
- */
-"use strict";
-
-const yaml = require("js-yaml");
-
-//------------------------------------------------------------------------------
-// Helper Functions
-//------------------------------------------------------------------------------
-
-/**
- * Returns a canonical error level string based upon the error message passed in.
- * @param {Object} message Individual error message provided by eslint
- * @returns {string} Error level string
- */
-function getMessageType(message) {
-    if (message.fatal || message.severity === 2) {
-        return "error";
-    }
-    return "warning";
-}
-
-/**
- * Takes in a JavaScript object and outputs a TAP diagnostics string
- * @param {Object} diagnostic JavaScript object to be embedded as YAML into output.
- * @returns {string} diagnostics string with YAML embedded - TAP version 13 compliant
- */
-function outputDiagnostics(diagnostic) {
-    const prefix = "  ";
-    let output = `${prefix}---\n`;
-
-    output += prefix + yaml.dump(diagnostic).split("\n").join(`\n${prefix}`);
-    output += "...\n";
-    return output;
-}
-
-//------------------------------------------------------------------------------
-// Public Interface
-//------------------------------------------------------------------------------
-
-module.exports = function(results) {
-    let output = `TAP version 13\n1..${results.length}\n`;
-
-    results.forEach((result, id) => {
-        const messages = result.messages;
-        let testResult = "ok";
-        let diagnostics = {};
-
-        if (messages.length > 0) {
-            messages.forEach(message => {
-                const severity = getMessageType(message);
-                const diagnostic = {
-                    message: message.message,
-                    severity,
-                    data: {
-                        line: message.line || 0,
-                        column: message.column || 0,
-                        ruleId: message.ruleId || ""
-                    }
-                };
-
-                // This ensures a warning message is not flagged as error
-                if (severity === "error") {
-                    testResult = "not ok";
-                }
-
-                /*
-                 * If we have multiple messages place them under a messages key
-                 * The first error will be logged as message key
-                 * This is to adhere to TAP 13 loosely defined specification of having a message key
-                 */
-                if ("message" in diagnostics) {
-                    if (typeof diagnostics.messages === "undefined") {
-                        diagnostics.messages = [];
-                    }
-                    diagnostics.messages.push(diagnostic);
-                } else {
-                    diagnostics = diagnostic;
-                }
-            });
-        }
-
-        output += `${testResult} ${id + 1} - ${result.filePath}\n`;
-
-        // If we have an error include diagnostics
-        if (messages.length > 0) {
-            output += outputDiagnostics(diagnostics);
-        }
-
-    });
-
-    return output;
-};

package/template/lib/react/node_modules/eslint/lib/cli-engine/formatters/unix.js

@@ -1,58 +0,0 @@
-/**
- * @fileoverview unix-style formatter.
- * @author oshi-shinobu
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Helper Functions
-//------------------------------------------------------------------------------
-
-/**
- * Returns a canonical error level string based upon the error message passed in.
- * @param {Object} message Individual error message provided by eslint
- * @returns {string} Error level string
- */
-function getMessageType(message) {
-    if (message.fatal || message.severity === 2) {
-        return "Error";
-    }
-    return "Warning";
-
-}
-
-
-//------------------------------------------------------------------------------
-// Public Interface
-//------------------------------------------------------------------------------
-
-module.exports = function(results) {
-
-    let output = "",
-        total = 0;
-
-    results.forEach(result => {
-
-        const messages = result.messages;
-
-        total += messages.length;
-
-        messages.forEach(message => {
-
-            output += `${result.filePath}:`;
-            output += `${message.line || 0}:`;
-            output += `${message.column || 0}:`;
-            output += ` ${message.message} `;
-            output += `[${getMessageType(message)}${message.ruleId ? `/${message.ruleId}` : ""}]`;
-            output += "\n";
-
-        });
-
-    });
-
-    if (total > 0) {
-        output += `\n${total} problem${total !== 1 ? "s" : ""}`;
-    }
-
-    return output;
-};

package/template/lib/react/node_modules/eslint/lib/cli-engine/formatters/visualstudio.js

@@ -1,63 +0,0 @@
-/**
- * @fileoverview Visual Studio compatible formatter
- * @author Ronald Pijnacker
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Helper Functions
-//------------------------------------------------------------------------------
-
-/**
- * Returns the severity of warning or error
- * @param {Object} message message object to examine
- * @returns {string} severity level
- * @private
- */
-function getMessageType(message) {
-    if (message.fatal || message.severity === 2) {
-        return "error";
-    }
-    return "warning";
-
-}
-
-
-//------------------------------------------------------------------------------
-// Public Interface
-//------------------------------------------------------------------------------
-
-module.exports = function(results) {
-
-    let output = "",
-        total = 0;
-
-    results.forEach(result => {
-
-        const messages = result.messages;
-
-        total += messages.length;
-
-        messages.forEach(message => {
-
-            output += result.filePath;
-            output += `(${message.line || 0}`;
-            output += message.column ? `,${message.column}` : "";
-            output += `): ${getMessageType(message)}`;
-            output += message.ruleId ? ` ${message.ruleId}` : "";
-            output += ` : ${message.message}`;
-            output += "\n";
-
-        });
-
-    });
-
-    if (total === 0) {
-        output += "no problems";
-    } else {
-        output += `\n${total} problem${total !== 1 ? "s" : ""}`;
-    }
-
-    return output;
-};

package/template/lib/react/node_modules/eslint/lib/cli-engine/hash.js

@@ -1,35 +0,0 @@
-/**
- * @fileoverview Defining the hashing function in one place.
- * @author Michael Ficarra
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const murmur = require("imurmurhash");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-//------------------------------------------------------------------------------
-// Private
-//------------------------------------------------------------------------------
-
-/**
- * hash the given string
- * @param {string} str the string to hash
- * @returns {string} the hash
- */
-function hash(str) {
-    return murmur(str).result().toString(36);
-}
-
-//------------------------------------------------------------------------------
-// Public Interface
-//------------------------------------------------------------------------------
-
-module.exports = hash;

package/template/lib/react/node_modules/eslint/lib/cli-engine/index.js

@@ -1,7 +0,0 @@
-"use strict";
-
-const { CLIEngine } = require("./cli-engine");
-
-module.exports = {
-    CLIEngine
-};

package/template/lib/react/node_modules/eslint/lib/cli-engine/lint-result-cache.js

@@ -1,203 +0,0 @@
-/**
- * @fileoverview Utility for caching lint results.
- * @author Kevin Partington
- */
-"use strict";
-
-//-----------------------------------------------------------------------------
-// Requirements
-//-----------------------------------------------------------------------------
-
-const assert = require("assert");
-const fs = require("fs");
-const fileEntryCache = require("file-entry-cache");
-const stringify = require("json-stable-stringify-without-jsonify");
-const pkg = require("../../package.json");
-const hash = require("./hash");
-
-const debug = require("debug")("eslint:lint-result-cache");
-
-//-----------------------------------------------------------------------------
-// Helpers
-//-----------------------------------------------------------------------------
-
-const configHashCache = new WeakMap();
-const nodeVersion = process && process.version;
-
-const validCacheStrategies = ["metadata", "content"];
-const invalidCacheStrategyErrorMessage = `Cache strategy must be one of: ${validCacheStrategies
-    .map(strategy => `"${strategy}"`)
-    .join(", ")}`;
-
-/**
- * Tests whether a provided cacheStrategy is valid
- * @param {string} cacheStrategy The cache strategy to use
- * @returns {boolean} true if `cacheStrategy` is one of `validCacheStrategies`; false otherwise
- */
-function isValidCacheStrategy(cacheStrategy) {
-    return (
-        validCacheStrategies.includes(cacheStrategy)
-    );
-}
-
-/**
- * Calculates the hash of the config
- * @param {ConfigArray} config The config.
- * @returns {string} The hash of the config
- */
-function hashOfConfigFor(config) {
-    if (!configHashCache.has(config)) {
-        configHashCache.set(config, hash(`${pkg.version}_${nodeVersion}_${stringify(config)}`));
-    }
-
-    return configHashCache.get(config);
-}
-
-//-----------------------------------------------------------------------------
-// Public Interface
-//-----------------------------------------------------------------------------
-
-/**
- * Lint result cache. This wraps around the file-entry-cache module,
- * transparently removing properties that are difficult or expensive to
- * serialize and adding them back in on retrieval.
- */
-class LintResultCache {
-
-    /**
-     * Creates a new LintResultCache instance.
-     * @param {string} cacheFileLocation The cache file location.
-     * @param {"metadata" | "content"} cacheStrategy The cache strategy to use.
-     */
-    constructor(cacheFileLocation, cacheStrategy) {
-        assert(cacheFileLocation, "Cache file location is required");
-        assert(cacheStrategy, "Cache strategy is required");
-        assert(
-            isValidCacheStrategy(cacheStrategy),
-            invalidCacheStrategyErrorMessage
-        );
-
-        debug(`Caching results to ${cacheFileLocation}`);
-
-        const useChecksum = cacheStrategy === "content";
-
-        debug(
-            `Using "${cacheStrategy}" strategy to detect changes`
-        );
-
-        this.fileEntryCache = fileEntryCache.create(
-            cacheFileLocation,
-            void 0,
-            useChecksum
-        );
-        this.cacheFileLocation = cacheFileLocation;
-    }
-
-    /**
-     * Retrieve cached lint results for a given file path, if present in the
-     * cache. If the file is present and has not been changed, rebuild any
-     * missing result information.
-     * @param {string} filePath The file for which to retrieve lint results.
-     * @param {ConfigArray} config The config of the file.
-     * @returns {Object|null} The rebuilt lint results, or null if the file is
-     *   changed or not in the filesystem.
-     */
-    getCachedLintResults(filePath, config) {
-
-        /*
-         * Cached lint results are valid if and only if:
-         * 1. The file is present in the filesystem
-         * 2. The file has not changed since the time it was previously linted
-         * 3. The ESLint configuration has not changed since the time the file
-         *    was previously linted
-         * If any of these are not true, we will not reuse the lint results.
-         */
-        const fileDescriptor = this.fileEntryCache.getFileDescriptor(filePath);
-        const hashOfConfig = hashOfConfigFor(config);
-        const changed =
-            fileDescriptor.changed ||
-            fileDescriptor.meta.hashOfConfig !== hashOfConfig;
-
-        if (fileDescriptor.notFound) {
-            debug(`File not found on the file system: ${filePath}`);
-            return null;
-        }
-
-        if (changed) {
-            debug(`Cache entry not found or no longer valid: ${filePath}`);
-            return null;
-        }
-
-        const cachedResults = fileDescriptor.meta.results;
-
-        // Just in case, not sure if this can ever happen.
-        if (!cachedResults) {
-            return cachedResults;
-        }
-
-        /*
-         * Shallow clone the object to ensure that any properties added or modified afterwards
-         * will not be accidentally stored in the cache file when `reconcile()` is called.
-         * https://github.com/eslint/eslint/issues/13507
-         * All intentional changes to the cache file must be done through `setCachedLintResults()`.
-         */
-        const results = { ...cachedResults };
-
-        // If source is present but null, need to reread the file from the filesystem.
-        if (results.source === null) {
-            debug(`Rereading cached result source from filesystem: ${filePath}`);
-            results.source = fs.readFileSync(filePath, "utf-8");
-        }
-
-        return results;
-    }
-
-    /**
-     * Set the cached lint results for a given file path, after removing any
-     * information that will be both unnecessary and difficult to serialize.
-     * Avoids caching results with an "output" property (meaning fixes were
-     * applied), to prevent potentially incorrect results if fixes are not
-     * written to disk.
-     * @param {string} filePath The file for which to set lint results.
-     * @param {ConfigArray} config The config of the file.
-     * @param {Object} result The lint result to be set for the file.
-     * @returns {void}
-     */
-    setCachedLintResults(filePath, config, result) {
-        if (result && Object.prototype.hasOwnProperty.call(result, "output")) {
-            return;
-        }
-
-        const fileDescriptor = this.fileEntryCache.getFileDescriptor(filePath);
-
-        if (fileDescriptor && !fileDescriptor.notFound) {
-            debug(`Updating cached result: ${filePath}`);
-
-            // Serialize the result, except that we want to remove the file source if present.
-            const resultToSerialize = Object.assign({}, result);
-
-            /*
-             * Set result.source to null.
-             * In `getCachedLintResults`, if source is explicitly null, we will
-             * read the file from the filesystem to set the value again.
-             */
-            if (Object.prototype.hasOwnProperty.call(resultToSerialize, "source")) {
-                resultToSerialize.source = null;
-            }
-
-            fileDescriptor.meta.results = resultToSerialize;
-            fileDescriptor.meta.hashOfConfig = hashOfConfigFor(config);
-        }
-    }
-
-    /**
-     * Persists the in-memory cache to disk.
-     * @returns {void}
-     */
-    reconcile() {
-        debug(`Persisting cached results: ${this.cacheFileLocation}`);
-        this.fileEntryCache.reconcile();
-    }
-}
-
-module.exports = LintResultCache;

package/template/lib/react/node_modules/eslint/lib/cli-engine/load-rules.js

@@ -1,46 +0,0 @@
-/**
- * @fileoverview Module for loading rules from files and directories.
- * @author Michael Ficarra
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const fs = require("fs"),
-    path = require("path");
-
-const rulesDirCache = {};
-
-//------------------------------------------------------------------------------
-// Public Interface
-//------------------------------------------------------------------------------
-
-/**
- * Load all rule modules from specified directory.
- * @param {string} relativeRulesDir Path to rules directory, may be relative.
- * @param {string} cwd Current working directory
- * @returns {Object} Loaded rule modules.
- */
-module.exports = function(relativeRulesDir, cwd) {
-    const rulesDir = path.resolve(cwd, relativeRulesDir);
-
-    // cache will help performance as IO operation are expensive
-    if (rulesDirCache[rulesDir]) {
-        return rulesDirCache[rulesDir];
-    }
-
-    const rules = Object.create(null);
-
-    fs.readdirSync(rulesDir).forEach(file => {
-        if (path.extname(file) !== ".js") {
-            return;
-        }
-        rules[file.slice(0, -3)] = require(path.join(rulesDir, file));
-    });
-    rulesDirCache[rulesDir] = rules;
-
-    return rules;
-};

package/template/lib/react/node_modules/eslint/lib/cli-engine/xml-escape.js

@@ -1,34 +0,0 @@
-/**
- * @fileoverview XML character escaper
- * @author George Chung
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Public Interface
-//------------------------------------------------------------------------------
-
-/**
- * Returns the escaped value for a character
- * @param {string} s string to examine
- * @returns {string} severity level
- * @private
- */
-module.exports = function(s) {
-    return (`${s}`).replace(/[<>&"'\x00-\x1F\x7F\u0080-\uFFFF]/gu, c => { // eslint-disable-line no-control-regex -- Converting controls to entities
-        switch (c) {
-            case "<":
-                return "&lt;";
-            case ">":
-                return "&gt;";
-            case "&":
-                return "&amp;";
-            case "\"":
-                return "&quot;";
-            case "'":
-                return "&apos;";
-            default:
-                return `&#${c.charCodeAt(0)};`;
-        }
-    });
-};