source: frontend/node_modules/webpack/lib/sharing/resolveMatchedConfigs.js

/*
        MIT License http://www.opensource.org/licenses/mit-license.php
        Author Tobias Koppers @sokra
*/

"use strict";

const ModuleNotFoundError = require("../errors/ModuleNotFoundError");
const LazySet = require("../util/LazySet");

/** @typedef {import("enhanced-resolve").ResolveContext} ResolveContext */
/** @typedef {import("../Compilation")} Compilation */
/** @typedef {import("../Compilation").FileSystemDependencies} FileSystemDependencies */
/** @typedef {import("../ResolverFactory").ResolveOptionsWithDependencyType} ResolveOptionsWithDependencyType */

/**
 * Defines the matched configs item type used by this module.
 * @template T
 * @typedef {Map<string, T>} MatchedConfigsItem
 */

/**
 * Defines the matched configs type used by this module.
 * @template T
 * @typedef {object} MatchedConfigs
 * @property {MatchedConfigsItem<T>} resolved
 * @property {MatchedConfigsItem<T>} unresolved
 * @property {MatchedConfigsItem<T>} prefixed
 */

/** @type {ResolveOptionsWithDependencyType} */
const RESOLVE_OPTIONS = { dependencyType: "esm" };

/**
 * Returns resolved matchers.
 * @template T
 * @param {Compilation} compilation the compilation
 * @param {[string, T][]} configs to be processed configs
 * @returns {Promise<MatchedConfigs<T>>} resolved matchers
 */
module.exports.resolveMatchedConfigs = (compilation, configs) => {
        /** @type {MatchedConfigsItem<T>} */
        const resolved = new Map();
        /** @type {MatchedConfigsItem<T>} */
        const unresolved = new Map();
        /** @type {MatchedConfigsItem<T>} */
        const prefixed = new Map();
        /** @type {ResolveContext} */
        const resolveContext = {
                fileDependencies: new LazySet(),
                contextDependencies: new LazySet(),
                missingDependencies: new LazySet()
        };
        const resolver = compilation.resolverFactory.get("normal", RESOLVE_OPTIONS);
        const context = compilation.compiler.context;

        return Promise.all(
                // eslint-disable-next-line array-callback-return
                configs.map(([request, config]) => {
                        if (/^\.\.?(?:\/|$)/.test(request)) {
                                // relative request
                                return new Promise((resolve) => {
                                        resolver.resolve(
                                                {},
                                                context,
                                                request,
                                                resolveContext,
                                                (err, result) => {
                                                        if (err || result === false) {
                                                                err = err || new Error(`Can't resolve ${request}`);
                                                                compilation.errors.push(
                                                                        new ModuleNotFoundError(null, err, {
                                                                                name: `shared module ${request}`
                                                                        })
                                                                );
                                                                return resolve(null);
                                                        }
                                                        resolved.set(/** @type {string} */ (result), config);
                                                        resolve(null);
                                                }
                                        );
                                });
                        } else if (/^(?:\/|[a-z]:\\|\\\\)/i.test(request)) {
                                // absolute path
                                resolved.set(request, config);
                        } else if (request.endsWith("/")) {
                                // module request prefix
                                prefixed.set(request, config);
                        } else {
                                // module request
                                unresolved.set(request, config);
                        }
                })
        ).then(() => {
                compilation.contextDependencies.addAll(
                        /** @type {FileSystemDependencies} */
                        (resolveContext.contextDependencies)
                );
                compilation.fileDependencies.addAll(
                        /** @type {FileSystemDependencies} */
                        (resolveContext.fileDependencies)
                );
                compilation.missingDependencies.addAll(
                        /** @type {FileSystemDependencies} */
                        (resolveContext.missingDependencies)
                );
                return { resolved, unresolved, prefixed };
        });
};