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

Xpack internals for Zephyr

import "node:module";
import { ze_log } from "zephyr-agent";
import { normalize_app_name } from "zephyr-edge-contract";
import { parseRemotesAsEntries } from "./extract-federated-dependency-pairs.mjs";
import { createMfRuntimeCode, xpack_delegate_module_template } from "./index.mjs";
import { isLegacyMFPlugin } from "./is-legacy-mf-plugin.mjs";
import { iterateFederatedRemoteConfig } from "./iterate-federated-remote-config.mjs";
import { runtimePluginInsert } from "./runtime-plugin-insert.mjs";
function mutWebpackFederatedRemotesConfig(zephyr_engine, config, resolvedDependencyPairs, delegate_module_template = xpack_delegate_module_template) {
    if (zephyr_engine.env?.target === 'tap-app') return void ze_log.remotes('Skipping Module Federation remote rewrites for tap-app output.');
    if (!resolvedDependencyPairs?.length) return void ze_log.remotes("No resolved dependency pairs found, skipping...");
    ze_log.remotes(`Processing ${resolvedDependencyPairs.length} resolved dependencies`);
    iterateFederatedRemoteConfig(config, (remotesConfig, plugin)=>{
        const remotes = remotesConfig?.remotes;
        if (!remotes) return void ze_log.remotes(`No remotes found for plugin: ${JSON.stringify(remotesConfig, null, 2)}`, 'skipping...');
        let runtimePluginInserted = false;
        const isRepack = 'repack' === zephyr_engine.builder;
        if (!isLegacyMFPlugin(plugin) && !isRepack) runtimePluginInserted = runtimePluginInsert(plugin);
        const library_type = remotesConfig.library?.type ?? 'var';
        ze_log.remotes(`Library type: ${library_type}`);
        const remoteEntries = 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;
            });
            ze_log.remotes(`remote_name: ${remote_name}, remote_version: ${remote_version}`);
            if (!dep_match) return void 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
            ];
            ze_log.remotes(`v_app: ${v_app}`);
            if (v_app) {
                resolved_dep.remote_entry_url = [
                    v_app,
                    remote_entry_url
                ].join('@');
                ze_log.remotes(`Adding version to remote entry url: ${remote_entry_url}`);
            }
            resolved_dep.library_type = library_type;
            resolved_dep.name = normalize_app_name(remote_name);
            let remote_final_value = resolved_dep.remote_entry_url;
            if (!runtimePluginInserted && !isRepack) remote_final_value = 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;
        });
        ze_log.remotes(`Set runtime code for remotes: ${remotes}`);
    });
}
export { mutWebpackFederatedRemotesConfig };

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