source: imaps-frontend/node_modules/webpack/lib/library/ModuleLibraryPlugin.js@ 79a0317

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

"use strict";

const { ConcatSource } = require("webpack-sources");
const RuntimeGlobals = require("../RuntimeGlobals");
const Template = require("../Template");
const propertyAccess = require("../util/propertyAccess");
const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");

/** @typedef {import("webpack-sources").Source} Source */
/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
/** @typedef {import("../Chunk")} Chunk */
/** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
/** @typedef {import("../Compiler")} Compiler */
/** @typedef {import("../Module")} Module */
/** @typedef {import("../javascript/JavascriptModulesPlugin").StartupRenderContext} StartupRenderContext */
/** @typedef {import("../util/Hash")} Hash */
/** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */

/**
 * @typedef {object} ModuleLibraryPluginOptions
 * @property {LibraryType} type
 */

/**
 * @typedef {object} ModuleLibraryPluginParsed
 * @property {string} name
 */

/**
 * @typedef {ModuleLibraryPluginParsed} T
 * @extends {AbstractLibraryPlugin<ModuleLibraryPluginParsed>}
 */
class ModuleLibraryPlugin extends AbstractLibraryPlugin {
        /**
         * @param {ModuleLibraryPluginOptions} options the plugin options
         */
        constructor(options) {
                super({
                        pluginName: "ModuleLibraryPlugin",
                        type: options.type
                });
        }

        /**
         * @param {LibraryOptions} library normalized library option
         * @returns {T | false} preprocess as needed by overriding
         */
        parseOptions(library) {
                const { name } = library;
                if (name) {
                        throw new Error(
                                `Library name must be unset. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
                        );
                }
                const _name = /** @type {string} */ (name);
                return {
                        name: _name
                };
        }

        /**
         * @param {Source} source source
         * @param {Module} module module
         * @param {StartupRenderContext} renderContext render context
         * @param {LibraryContext<T>} libraryContext context
         * @returns {Source} source with library export
         */
        renderStartup(
                source,
                module,
                { moduleGraph, chunk },
                { options, compilation }
        ) {
                const result = new ConcatSource(source);
                const exportsInfo = moduleGraph.getExportsInfo(module);
                const exports = [];
                const isAsync = moduleGraph.isAsync(module);
                if (isAsync) {
                        result.add(
                                `${RuntimeGlobals.exports} = await ${RuntimeGlobals.exports};\n`
                        );
                }
                for (const exportInfo of exportsInfo.orderedExports) {
                        if (!exportInfo.provided) continue;
                        const varName = `${RuntimeGlobals.exports}${Template.toIdentifier(
                                exportInfo.name
                        )}`;
                        result.add(
                                `var ${varName} = ${RuntimeGlobals.exports}${propertyAccess([
                                        /** @type {string} */
                                        (exportInfo.getUsedName(exportInfo.name, chunk.runtime))
                                ])};\n`
                        );
                        exports.push(`${varName} as ${exportInfo.name}`);
                }
                if (exports.length > 0) {
                        result.add(`export { ${exports.join(", ")} };\n`);
                }
                return result;
        }
}

module.exports = ModuleLibraryPlugin;