zephyr-xpack-internal/dist/xpack-extract/mut-webpack-federated-remotes-config.js

Xpack internals for Zephyr

"use strict";
var __webpack_require__ = {};
(()=>{
    __webpack_require__.d = (exports1, getters, values)=>{
        var define = (defs, kind)=>{
            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
                enumerable: true,
                [kind]: defs[key]
            });
        };
        define(getters, "get");
        define(values, "value");
    };
})();
(()=>{
    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
})();
(()=>{
    __webpack_require__.r = (exports1)=>{
        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
            value: 'Module'
        });
        Object.defineProperty(exports1, '__esModule', {
            value: true
        });
    };
})();
var __webpack_exports__ = {};
__webpack_require__.r(__webpack_exports__);
__webpack_require__.d(__webpack_exports__, {
    mutWebpackFederatedRemotesConfig: ()=>mutWebpackFederatedRemotesConfig
});
const external_zephyr_agent_namespaceObject = require("zephyr-agent");
const external_zephyr_edge_contract_namespaceObject = require("zephyr-edge-contract");
const external_extract_federated_dependency_pairs_js_namespaceObject = require("./extract-federated-dependency-pairs.js");
const external_index_js_namespaceObject = require("./index.js");
const external_is_legacy_mf_plugin_js_namespaceObject = require("./is-legacy-mf-plugin.js");
const external_iterate_federated_remote_config_js_namespaceObject = require("./iterate-federated-remote-config.js");
const external_runtime_plugin_insert_js_namespaceObject = require("./runtime-plugin-insert.js");
function mutWebpackFederatedRemotesConfig(zephyr_engine, config, resolvedDependencyPairs, delegate_module_template = external_index_js_namespaceObject.xpack_delegate_module_template) {
    if (zephyr_engine.env?.target === 'tap-app') return void external_zephyr_agent_namespaceObject.ze_log.remotes('Skipping Module Federation remote rewrites for tap-app output.');
    if (!resolvedDependencyPairs?.length) return void external_zephyr_agent_namespaceObject.ze_log.remotes("No resolved dependency pairs found, skipping...");
    external_zephyr_agent_namespaceObject.ze_log.remotes(`Processing ${resolvedDependencyPairs.length} resolved dependencies`);
    (0, external_iterate_federated_remote_config_js_namespaceObject.iterateFederatedRemoteConfig)(config, (remotesConfig, plugin)=>{
        const remotes = remotesConfig?.remotes;
        if (!remotes) return void external_zephyr_agent_namespaceObject.ze_log.remotes(`No remotes found for plugin: ${JSON.stringify(remotesConfig, null, 2)}`, 'skipping...');
        let runtimePluginInserted = false;
        const isRepack = 'repack' === zephyr_engine.builder;
        if (!(0, external_is_legacy_mf_plugin_js_namespaceObject.isLegacyMFPlugin)(plugin) && !isRepack) runtimePluginInserted = (0, external_runtime_plugin_insert_js_namespaceObject.runtimePluginInsert)(plugin);
        const library_type = remotesConfig.library?.type ?? 'var';
        external_zephyr_agent_namespaceObject.ze_log.remotes(`Library type: ${library_type}`);
        const remoteEntries = (0, external_extract_federated_dependency_pairs_js_namespaceObject.parseRemotesAsEntries)(remotes);
        remoteEntries.forEach((remote)=>{
            const [remote_name, remote_version] = remote;
            const dep_match = resolvedDependencyPairs.find((dep)=>{
                const nameMatch = dep.name === remote_name;
                const versionMatch = 'latest' === dep.version || '*' === dep.version || 'string' == typeof remote_version && remote_version.startsWith(`${remote_name}@`) || dep.version === remote_version;
                return nameMatch && versionMatch;
            });
            external_zephyr_agent_namespaceObject.ze_log.remotes(`remote_name: ${remote_name}, remote_version: ${remote_version}`);
            if (!dep_match) return void external_zephyr_agent_namespaceObject.ze_log.remotes(`Resolved dependency pair not found for remote: ${JSON.stringify(remote, null, 2)}`, 'skipping...');
            const resolved_dep = {
                ...dep_match
            };
            const remote_entry_url = resolved_dep.remote_entry_url;
            const [v_app] = remote_version.includes('@') ? remote_version.split('@') : [
                remote_name
            ];
            external_zephyr_agent_namespaceObject.ze_log.remotes(`v_app: ${v_app}`);
            if (v_app) {
                resolved_dep.remote_entry_url = [
                    v_app,
                    remote_entry_url
                ].join('@');
                external_zephyr_agent_namespaceObject.ze_log.remotes(`Adding version to remote entry url: ${remote_entry_url}`);
            }
            resolved_dep.library_type = library_type;
            resolved_dep.name = (0, external_zephyr_edge_contract_namespaceObject.normalize_app_name)(remote_name);
            let remote_final_value = resolved_dep.remote_entry_url;
            if (!runtimePluginInserted && !isRepack) remote_final_value = (0, external_index_js_namespaceObject.createMfRuntimeCode)(zephyr_engine, resolved_dep, delegate_module_template);
            if (Array.isArray(remotes)) {
                let remoteIndex = -1;
                for(let i = 0; i < remotes.length; i++){
                    const entry = remotes[i];
                    if ('string' == typeof entry) {
                        if (entry === remote_name || entry.startsWith(`${remote_name}@`)) {
                            remoteIndex = i;
                            break;
                        }
                    }
                }
                if (-1 === remoteIndex) return;
                const nx_remote_value = remote_final_value.startsWith('promise') ? remote_final_value : remote_entry_url;
                remotes.splice(remoteIndex, 1, [
                    remote_name,
                    nx_remote_value
                ]);
                return;
            }
            remotes[remote_name] = remote_final_value;
        });
        external_zephyr_agent_namespaceObject.ze_log.remotes(`Set runtime code for remotes: ${remotes}`);
    });
}
exports.mutWebpackFederatedRemotesConfig = __webpack_exports__.mutWebpackFederatedRemotesConfig;
for(var __rspack_i in __webpack_exports__)if (-1 === [
    "mutWebpackFederatedRemotesConfig"
].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
Object.defineProperty(exports, '__esModule', {
    value: true
});

//# sourceMappingURL=mut-webpack-federated-remotes-config.js.map