repoburg 1.3.87 → 1.3.91

package/backend/node_modules/@eslint/eslintrc/lib/config-array/config-array.js

@@ -0,0 +1,523 @@
+/**
+ * @fileoverview `ConfigArray` class.
+ *
+ * `ConfigArray` class expresses the full of a configuration. It has the entry
+ * config file, base config files that were extended, loaded parsers, and loaded
+ * plugins.
+ *
+ * `ConfigArray` class provides three properties and two methods.
+ *
+ * - `pluginEnvironments`
+ * - `pluginProcessors`
+ * - `pluginRules`
+ *      The `Map` objects that contain the members of all plugins that this
+ *      config array contains. Those map objects don't have mutation methods.
+ *      Those keys are the member ID such as `pluginId/memberName`.
+ * - `isRoot()`
+ *      If `true` then this configuration has `root:true` property.
+ * - `extractConfig(filePath)`
+ *      Extract the final configuration for a given file. This means merging
+ *      every config array element which that `criteria` property matched. The
+ *      `filePath` argument must be an absolute path.
+ *
+ * `ConfigArrayFactory` provides the loading logic of config files.
+ *
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ */
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+import { ExtractedConfig } from "./extracted-config.js";
+import { IgnorePattern } from "./ignore-pattern.js";
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+// Define types for VSCode IntelliSense.
+/** @typedef {import("../../shared/types").Environment} Environment */
+/** @typedef {import("../../shared/types").GlobalConf} GlobalConf */
+/** @typedef {import("../../shared/types").RuleConf} RuleConf */
+/** @typedef {import("../../shared/types").Rule} Rule */
+/** @typedef {import("../../shared/types").Plugin} Plugin */
+/** @typedef {import("../../shared/types").Processor} Processor */
+/** @typedef {import("./config-dependency").DependentParser} DependentParser */
+/** @typedef {import("./config-dependency").DependentPlugin} DependentPlugin */
+/** @typedef {import("./override-tester")["OverrideTester"]} OverrideTester */
+
+/**
+ * @typedef {Object} ConfigArrayElement
+ * @property {string} name The name of this config element.
+ * @property {string} filePath The path to the source file of this config element.
+ * @property {InstanceType<OverrideTester>|null} criteria The tester for the `files` and `excludedFiles` of this config element.
+ * @property {Record<string, boolean>|undefined} env The environment settings.
+ * @property {Record<string, GlobalConf>|undefined} globals The global variable settings.
+ * @property {IgnorePattern|undefined} ignorePattern The ignore patterns.
+ * @property {boolean|undefined} noInlineConfig The flag that disables directive comments.
+ * @property {DependentParser|undefined} parser The parser loader.
+ * @property {Object|undefined} parserOptions The parser options.
+ * @property {Record<string, DependentPlugin>|undefined} plugins The plugin loaders.
+ * @property {string|undefined} processor The processor name to refer plugin's processor.
+ * @property {boolean|undefined} reportUnusedDisableDirectives The flag to report unused `eslint-disable` comments.
+ * @property {boolean|undefined} root The flag to express root.
+ * @property {Record<string, RuleConf>|undefined} rules The rule settings
+ * @property {Object|undefined} settings The shared settings.
+ * @property {"config" | "ignore" | "implicit-processor"} type The element type.
+ */
+
+/**
+ * @typedef {Object} ConfigArrayInternalSlots
+ * @property {Map<string, ExtractedConfig>} cache The cache to extract configs.
+ * @property {ReadonlyMap<string, Environment>|null} envMap The map from environment ID to environment definition.
+ * @property {ReadonlyMap<string, Processor>|null} processorMap The map from processor ID to environment definition.
+ * @property {ReadonlyMap<string, Rule>|null} ruleMap The map from rule ID to rule definition.
+ */
+
+/** @type {WeakMap<ConfigArray, ConfigArrayInternalSlots>} */
+const internalSlotsMap = new class extends WeakMap {
+    get(key) {
+        let value = super.get(key);
+
+        if (!value) {
+            value = {
+                cache: new Map(),
+                envMap: null,
+                processorMap: null,
+                ruleMap: null
+            };
+            super.set(key, value);
+        }
+
+        return value;
+    }
+}();
+
+/**
+ * Get the indices which are matched to a given file.
+ * @param {ConfigArrayElement[]} elements The elements.
+ * @param {string} filePath The path to a target file.
+ * @returns {number[]} The indices.
+ */
+function getMatchedIndices(elements, filePath) {
+    const indices = [];
+
+    for (let i = elements.length - 1; i >= 0; --i) {
+        const element = elements[i];
+
+        if (!element.criteria || (filePath && element.criteria.test(filePath))) {
+            indices.push(i);
+        }
+    }
+
+    return indices;
+}
+
+/**
+ * Check if a value is a non-null object.
+ * @param {any} x The value to check.
+ * @returns {boolean} `true` if the value is a non-null object.
+ */
+function isNonNullObject(x) {
+    return typeof x === "object" && x !== null;
+}
+
+/**
+ * Merge two objects.
+ *
+ * Assign every property values of `y` to `x` if `x` doesn't have the property.
+ * If `x`'s property value is an object, it does recursive.
+ * @param {Object} target The destination to merge
+ * @param {Object|undefined} source The source to merge.
+ * @returns {void}
+ */
+function mergeWithoutOverwrite(target, source) {
+    if (!isNonNullObject(source)) {
+        return;
+    }
+
+    for (const key of Object.keys(source)) {
+        if (key === "__proto__") {
+            continue;
+        }
+
+        if (isNonNullObject(target[key])) {
+            mergeWithoutOverwrite(target[key], source[key]);
+        } else if (target[key] === void 0) {
+            if (isNonNullObject(source[key])) {
+                target[key] = Array.isArray(source[key]) ? [] : {};
+                mergeWithoutOverwrite(target[key], source[key]);
+            } else if (source[key] !== void 0) {
+                target[key] = source[key];
+            }
+        }
+    }
+}
+
+/**
+ * The error for plugin conflicts.
+ */
+class PluginConflictError extends Error {
+
+    /**
+     * Initialize this error object.
+     * @param {string} pluginId The plugin ID.
+     * @param {{filePath:string, importerName:string}[]} plugins The resolved plugins.
+     */
+    constructor(pluginId, plugins) {
+        super(`Plugin "${pluginId}" was conflicted between ${plugins.map(p => `"${p.importerName}"`).join(" and ")}.`);
+        this.messageTemplate = "plugin-conflict";
+        this.messageData = { pluginId, plugins };
+    }
+}
+
+/**
+ * Merge plugins.
+ * `target`'s definition is prior to `source`'s.
+ * @param {Record<string, DependentPlugin>} target The destination to merge
+ * @param {Record<string, DependentPlugin>|undefined} source The source to merge.
+ * @returns {void}
+ */
+function mergePlugins(target, source) {
+    if (!isNonNullObject(source)) {
+        return;
+    }
+
+    for (const key of Object.keys(source)) {
+        if (key === "__proto__") {
+            continue;
+        }
+        const targetValue = target[key];
+        const sourceValue = source[key];
+
+        // Adopt the plugin which was found at first.
+        if (targetValue === void 0) {
+            if (sourceValue.error) {
+                throw sourceValue.error;
+            }
+            target[key] = sourceValue;
+        } else if (sourceValue.filePath !== targetValue.filePath) {
+            throw new PluginConflictError(key, [
+                {
+                    filePath: targetValue.filePath,
+                    importerName: targetValue.importerName
+                },
+                {
+                    filePath: sourceValue.filePath,
+                    importerName: sourceValue.importerName
+                }
+            ]);
+        }
+    }
+}
+
+/**
+ * Merge rule configs.
+ * `target`'s definition is prior to `source`'s.
+ * @param {Record<string, Array>} target The destination to merge
+ * @param {Record<string, RuleConf>|undefined} source The source to merge.
+ * @returns {void}
+ */
+function mergeRuleConfigs(target, source) {
+    if (!isNonNullObject(source)) {
+        return;
+    }
+
+    for (const key of Object.keys(source)) {
+        if (key === "__proto__") {
+            continue;
+        }
+        const targetDef = target[key];
+        const sourceDef = source[key];
+
+        // Adopt the rule config which was found at first.
+        if (targetDef === void 0) {
+            if (Array.isArray(sourceDef)) {
+                target[key] = [...sourceDef];
+            } else {
+                target[key] = [sourceDef];
+            }
+
+        /*
+         * If the first found rule config is severity only and the current rule
+         * config has options, merge the severity and the options.
+         */
+        } else if (
+            targetDef.length === 1 &&
+            Array.isArray(sourceDef) &&
+            sourceDef.length >= 2
+        ) {
+            targetDef.push(...sourceDef.slice(1));
+        }
+    }
+}
+
+/**
+ * Create the extracted config.
+ * @param {ConfigArray} instance The config elements.
+ * @param {number[]} indices The indices to use.
+ * @returns {ExtractedConfig} The extracted config.
+ */
+function createConfig(instance, indices) {
+    const config = new ExtractedConfig();
+    const ignorePatterns = [];
+
+    // Merge elements.
+    for (const index of indices) {
+        const element = instance[index];
+
+        // Adopt the parser which was found at first.
+        if (!config.parser && element.parser) {
+            if (element.parser.error) {
+                throw element.parser.error;
+            }
+            config.parser = element.parser;
+        }
+
+        // Adopt the processor which was found at first.
+        if (!config.processor && element.processor) {
+            config.processor = element.processor;
+        }
+
+        // Adopt the noInlineConfig which was found at first.
+        if (config.noInlineConfig === void 0 && element.noInlineConfig !== void 0) {
+            config.noInlineConfig = element.noInlineConfig;
+            config.configNameOfNoInlineConfig = element.name;
+        }
+
+        // Adopt the reportUnusedDisableDirectives which was found at first.
+        if (config.reportUnusedDisableDirectives === void 0 && element.reportUnusedDisableDirectives !== void 0) {
+            config.reportUnusedDisableDirectives = element.reportUnusedDisableDirectives;
+        }
+
+        // Collect ignorePatterns
+        if (element.ignorePattern) {
+            ignorePatterns.push(element.ignorePattern);
+        }
+
+        // Merge others.
+        mergeWithoutOverwrite(config.env, element.env);
+        mergeWithoutOverwrite(config.globals, element.globals);
+        mergeWithoutOverwrite(config.parserOptions, element.parserOptions);
+        mergeWithoutOverwrite(config.settings, element.settings);
+        mergePlugins(config.plugins, element.plugins);
+        mergeRuleConfigs(config.rules, element.rules);
+    }
+
+    // Create the predicate function for ignore patterns.
+    if (ignorePatterns.length > 0) {
+        config.ignores = IgnorePattern.createIgnore(ignorePatterns.reverse());
+    }
+
+    return config;
+}
+
+/**
+ * Collect definitions.
+ * @template T, U
+ * @param {string} pluginId The plugin ID for prefix.
+ * @param {Record<string,T>} defs The definitions to collect.
+ * @param {Map<string, U>} map The map to output.
+ * @param {function(T): U} [normalize] The normalize function for each value.
+ * @returns {void}
+ */
+function collect(pluginId, defs, map, normalize) {
+    if (defs) {
+        const prefix = pluginId && `${pluginId}/`;
+
+        for (const [key, value] of Object.entries(defs)) {
+            map.set(
+                `${prefix}${key}`,
+                normalize ? normalize(value) : value
+            );
+        }
+    }
+}
+
+/**
+ * Normalize a rule definition.
+ * @param {Function|Rule} rule The rule definition to normalize.
+ * @returns {Rule} The normalized rule definition.
+ */
+function normalizePluginRule(rule) {
+    return typeof rule === "function" ? { create: rule } : rule;
+}
+
+/**
+ * Delete the mutation methods from a given map.
+ * @param {Map<any, any>} map The map object to delete.
+ * @returns {void}
+ */
+function deleteMutationMethods(map) {
+    Object.defineProperties(map, {
+        clear: { configurable: true, value: void 0 },
+        delete: { configurable: true, value: void 0 },
+        set: { configurable: true, value: void 0 }
+    });
+}
+
+/**
+ * Create `envMap`, `processorMap`, `ruleMap` with the plugins in the config array.
+ * @param {ConfigArrayElement[]} elements The config elements.
+ * @param {ConfigArrayInternalSlots} slots The internal slots.
+ * @returns {void}
+ */
+function initPluginMemberMaps(elements, slots) {
+    const processed = new Set();
+
+    slots.envMap = new Map();
+    slots.processorMap = new Map();
+    slots.ruleMap = new Map();
+
+    for (const element of elements) {
+        if (!element.plugins) {
+            continue;
+        }
+
+        for (const [pluginId, value] of Object.entries(element.plugins)) {
+            const plugin = value.definition;
+
+            if (!plugin || processed.has(pluginId)) {
+                continue;
+            }
+            processed.add(pluginId);
+
+            collect(pluginId, plugin.environments, slots.envMap);
+            collect(pluginId, plugin.processors, slots.processorMap);
+            collect(pluginId, plugin.rules, slots.ruleMap, normalizePluginRule);
+        }
+    }
+
+    deleteMutationMethods(slots.envMap);
+    deleteMutationMethods(slots.processorMap);
+    deleteMutationMethods(slots.ruleMap);
+}
+
+/**
+ * Create `envMap`, `processorMap`, `ruleMap` with the plugins in the config array.
+ * @param {ConfigArray} instance The config elements.
+ * @returns {ConfigArrayInternalSlots} The extracted config.
+ */
+function ensurePluginMemberMaps(instance) {
+    const slots = internalSlotsMap.get(instance);
+
+    if (!slots.ruleMap) {
+        initPluginMemberMaps(instance, slots);
+    }
+
+    return slots;
+}
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+/**
+ * The Config Array.
+ *
+ * `ConfigArray` instance contains all settings, parsers, and plugins.
+ * You need to call `ConfigArray#extractConfig(filePath)` method in order to
+ * extract, merge and get only the config data which is related to an arbitrary
+ * file.
+ * @extends {Array<ConfigArrayElement>}
+ */
+class ConfigArray extends Array {
+
+    /**
+     * Get the plugin environments.
+     * The returned map cannot be mutated.
+     * @type {ReadonlyMap<string, Environment>} The plugin environments.
+     */
+    get pluginEnvironments() {
+        return ensurePluginMemberMaps(this).envMap;
+    }
+
+    /**
+     * Get the plugin processors.
+     * The returned map cannot be mutated.
+     * @type {ReadonlyMap<string, Processor>} The plugin processors.
+     */
+    get pluginProcessors() {
+        return ensurePluginMemberMaps(this).processorMap;
+    }
+
+    /**
+     * Get the plugin rules.
+     * The returned map cannot be mutated.
+     * @returns {ReadonlyMap<string, Rule>} The plugin rules.
+     */
+    get pluginRules() {
+        return ensurePluginMemberMaps(this).ruleMap;
+    }
+
+    /**
+     * Check if this config has `root` flag.
+     * @returns {boolean} `true` if this config array is root.
+     */
+    isRoot() {
+        for (let i = this.length - 1; i >= 0; --i) {
+            const root = this[i].root;
+
+            if (typeof root === "boolean") {
+                return root;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Extract the config data which is related to a given file.
+     * @param {string} filePath The absolute path to the target file.
+     * @returns {ExtractedConfig} The extracted config data.
+     */
+    extractConfig(filePath) {
+        const { cache } = internalSlotsMap.get(this);
+        const indices = getMatchedIndices(this, filePath);
+        const cacheKey = indices.join(",");
+
+        if (!cache.has(cacheKey)) {
+            cache.set(cacheKey, createConfig(this, indices));
+        }
+
+        return cache.get(cacheKey);
+    }
+
+    /**
+     * Check if a given path is an additional lint target.
+     * @param {string} filePath The absolute path to the target file.
+     * @returns {boolean} `true` if the file is an additional lint target.
+     */
+    isAdditionalTargetPath(filePath) {
+        for (const { criteria, type } of this) {
+            if (
+                type === "config" &&
+                criteria &&
+                !criteria.endsWithWildcard &&
+                criteria.test(filePath)
+            ) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+
+/**
+ * Get the used extracted configs.
+ * CLIEngine will use this method to collect used deprecated rules.
+ * @param {ConfigArray} instance The config array object to get.
+ * @returns {ExtractedConfig[]} The used extracted configs.
+ * @private
+ */
+function getUsedExtractedConfigs(instance) {
+    const { cache } = internalSlotsMap.get(instance);
+
+    return Array.from(cache.values());
+}
+
+
+export {
+    ConfigArray,
+    getUsedExtractedConfigs
+};

package/backend/node_modules/@eslint/eslintrc/lib/config-array/config-dependency.js

@@ -0,0 +1,124 @@
+/**
+ * @fileoverview `ConfigDependency` class.
+ *
+ * `ConfigDependency` class expresses a loaded parser or plugin.
+ *
+ * If the parser or plugin was loaded successfully, it has `definition` property
+ * and `filePath` property. Otherwise, it has `error` property.
+ *
+ * When `JSON.stringify()` converted a `ConfigDependency` object to a JSON, it
+ * omits `definition` property.
+ *
+ * `ConfigArrayFactory` creates `ConfigDependency` objects when it loads parsers
+ * or plugins.
+ *
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ */
+
+import util from "util";
+
+/**
+ * The class is to store parsers or plugins.
+ * This class hides the loaded object from `JSON.stringify()` and `console.log`.
+ * @template T
+ */
+class ConfigDependency {
+
+    /**
+     * Initialize this instance.
+     * @param {Object} data The dependency data.
+     * @param {T} [data.definition] The dependency if the loading succeeded.
+     * @param {T} [data.original] The original, non-normalized dependency if the loading succeeded.
+     * @param {Error} [data.error] The error object if the loading failed.
+     * @param {string} [data.filePath] The actual path to the dependency if the loading succeeded.
+     * @param {string} data.id The ID of this dependency.
+     * @param {string} data.importerName The name of the config file which loads this dependency.
+     * @param {string} data.importerPath The path to the config file which loads this dependency.
+     */
+    constructor({
+        definition = null,
+        original = null,
+        error = null,
+        filePath = null,
+        id,
+        importerName,
+        importerPath
+    }) {
+
+        /**
+         * The loaded dependency if the loading succeeded.
+         * @type {T|null}
+         */
+        this.definition = definition;
+
+        /**
+         * The original dependency as loaded directly from disk if the loading succeeded.
+         * @type {T|null}
+         */
+        this.original = original;
+
+        /**
+         * The error object if the loading failed.
+         * @type {Error|null}
+         */
+        this.error = error;
+
+        /**
+         * The loaded dependency if the loading succeeded.
+         * @type {string|null}
+         */
+        this.filePath = filePath;
+
+        /**
+         * The ID of this dependency.
+         * @type {string}
+         */
+        this.id = id;
+
+        /**
+         * The name of the config file which loads this dependency.
+         * @type {string}
+         */
+        this.importerName = importerName;
+
+        /**
+         * The path to the config file which loads this dependency.
+         * @type {string}
+         */
+        this.importerPath = importerPath;
+    }
+
+    // eslint-disable-next-line jsdoc/require-description
+    /**
+     * @returns {Object} a JSON compatible object.
+     */
+    toJSON() {
+        const obj = this[util.inspect.custom]();
+
+        // Display `error.message` (`Error#message` is unenumerable).
+        if (obj.error instanceof Error) {
+            obj.error = { ...obj.error, message: obj.error.message };
+        }
+
+        return obj;
+    }
+
+    // eslint-disable-next-line jsdoc/require-description
+    /**
+     * @returns {Object} an object to display by `console.log()`.
+     */
+    [util.inspect.custom]() {
+        const {
+            definition: _ignore1, // eslint-disable-line no-unused-vars
+            original: _ignore2, // eslint-disable-line no-unused-vars
+            ...obj
+        } = this;
+
+        return obj;
+    }
+}
+
+/** @typedef {ConfigDependency<import("../../shared/types").Parser>} DependentParser */
+/** @typedef {ConfigDependency<import("../../shared/types").Plugin>} DependentPlugin */
+
+export { ConfigDependency };