source: frontend/node_modules/webpack/lib/asset/AssetBytesGenerator.js

/*
        MIT License http://www.opensource.org/licenses/mit-license.php
        Author Alexander Akait @alexander-akait
*/

"use strict";

const { RawSource } = require("webpack-sources");
const ConcatenationScope = require("../ConcatenationScope");
const Generator = require("../Generator");
const {
        ASSET_URL_TYPE,
        ASSET_URL_TYPES,
        CSS_TYPE,
        HTML_TYPE,
        JAVASCRIPT_AND_ASSET_URL_TYPES,
        JAVASCRIPT_TYPE,
        JAVASCRIPT_TYPES,
        NO_TYPES
} = require("../ModuleSourceTypeConstants");
const RuntimeGlobals = require("../RuntimeGlobals");

/** @typedef {import("webpack-sources").Source} Source */
/** @typedef {import("../Generator").GenerateContext} GenerateContext */
/** @typedef {import("../Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
/** @typedef {import("../Module").SourceType} SourceType */
/** @typedef {import("../Module").SourceTypes} SourceTypes */
/** @typedef {import("../ModuleGraph")} ModuleGraph */
/** @typedef {import("../NormalModule")} NormalModule */

class AssetSourceGenerator extends Generator {
        /**
         * Creates an instance of AssetSourceGenerator.
         * @param {ModuleGraph} moduleGraph the module graph
         */
        constructor(moduleGraph) {
                super();

                this._moduleGraph = moduleGraph;
        }

        /**
         * Generates generated code for this runtime module.
         * @param {NormalModule} module module for which the code should be generated
         * @param {GenerateContext} generateContext context for generate
         * @returns {Source | null} generated code
         */
        generate(
                module,
                { type, concatenationScope, getData, runtimeTemplate, runtimeRequirements }
        ) {
                const originalSource = module.originalSource();
                const data = getData ? getData() : undefined;

                switch (type) {
                        case JAVASCRIPT_TYPE: {
                                if (!originalSource) {
                                        return new RawSource("");
                                }

                                const encodedSource = originalSource.buffer().toString("base64");

                                runtimeRequirements.add(RuntimeGlobals.requireScope);
                                runtimeRequirements.add(RuntimeGlobals.toBinary);

                                /** @type {string} */
                                let sourceContent;
                                if (concatenationScope) {
                                        concatenationScope.registerNamespaceExport(
                                                ConcatenationScope.NAMESPACE_OBJECT_EXPORT
                                        );
                                        sourceContent = `${runtimeTemplate.renderConst()} ${
                                                ConcatenationScope.NAMESPACE_OBJECT_EXPORT
                                        } = ${RuntimeGlobals.toBinary}(${JSON.stringify(encodedSource)});`;
                                } else {
                                        runtimeRequirements.add(RuntimeGlobals.module);
                                        sourceContent = `${module.moduleArgument}.exports = ${RuntimeGlobals.toBinary}(${JSON.stringify(
                                                encodedSource
                                        )});`;
                                }
                                return new RawSource(sourceContent);
                        }
                        case ASSET_URL_TYPE: {
                                if (!originalSource) {
                                        return null;
                                }

                                const encodedSource = originalSource.buffer().toString("base64");

                                if (data) {
                                        data.set("url", {
                                                [type]: `data:application/octet-stream;base64,${encodedSource}`
                                        });
                                }
                                return null;
                        }
                        default:
                                return null;
                }
        }

        /**
         * Generates fallback output for the provided error condition.
         * @param {Error} error the error
         * @param {NormalModule} module module for which the code should be generated
         * @param {GenerateContext} generateContext context for generate
         * @returns {Source | null} generated code
         */
        generateError(error, module, generateContext) {
                switch (generateContext.type) {
                        case JAVASCRIPT_TYPE: {
                                return new RawSource(
                                        `throw new Error(${JSON.stringify(error.message)});`
                                );
                        }
                        default:
                                return null;
                }
        }

        /**
         * Returns the reason this module cannot be concatenated, when one exists.
         * @param {NormalModule} module module for which the bailout reason should be determined
         * @param {ConcatenationBailoutReasonContext} context context
         * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
         */
        getConcatenationBailoutReason(module, context) {
                return undefined;
        }

        /**
         * Returns the source types available for this module.
         * @param {NormalModule} module fresh module
         * @returns {SourceTypes} available types (do not mutate)
         */
        getTypes(module) {
                /** @type {Set<string>} */
                const sourceTypes = new Set();
                const connections = this._moduleGraph.getIncomingConnections(module);

                for (const connection of connections) {
                        if (!connection.originModule) {
                                continue;
                        }

                        sourceTypes.add(connection.originModule.type.split("/")[0]);
                }

                if (sourceTypes.size > 0) {
                        if (
                                sourceTypes.has(JAVASCRIPT_TYPE) &&
                                (sourceTypes.has(CSS_TYPE) || sourceTypes.has(HTML_TYPE))
                        ) {
                                return JAVASCRIPT_AND_ASSET_URL_TYPES;
                        } else if (sourceTypes.has(CSS_TYPE) || sourceTypes.has(HTML_TYPE)) {
                                return ASSET_URL_TYPES;
                        }
                        return JAVASCRIPT_TYPES;
                }

                return NO_TYPES;
        }

        /**
         * Returns the estimated size for the requested source type.
         * @param {NormalModule} module the module
         * @param {SourceType=} type source type
         * @returns {number} estimate size of the module
         */
        getSize(module, type) {
                const originalSource = module.originalSource();

                if (!originalSource) {
                        return 0;
                }

                // Example: m.exports="abcd"
                return originalSource.size() + 12;
        }
}

module.exports = AssetSourceGenerator;