zephyr-rspack-plugin/dist/rspack-plugin/with-zephyr.mjs

Repack plugin for Zephyr

import "node:module";
import { ZephyrEngine, assertZephyrBuildTarget, getGlobal, handleGlobalError } from "zephyr-agent";
import { coordinateXPackCompilers, extractFederatedDependencyPairs, extractLibraryType, makeCopyOfModuleFederationOptions, mutWebpackFederatedRemotesConfig } from "zephyr-xpack-internal";
import { ZeRspackPlugin } from "./ze-rspack-plugin.mjs";
function mergeResolvedDependencies(previous, current) {
    const merged = new Map();
    for (const dependency of [
        ...previous,
        ...current
    ])merged.set(`${dependency.application_uid}\0${dependency.name}`, dependency);
    return [
        ...merged.values()
    ];
}
function resolveBuildTarget(options) {
    const target = options?.target;
    if (void 0 !== target) assertZephyrBuildTarget(target, 'withZephyr({ target })');
    return target;
}
function applyBuildTarget(engine, target) {
    if (void 0 !== target) engine.env.target = target;
}
function withZephyr(zephyrPluginOptions) {
    const target = resolveBuildTarget(zephyrPluginOptions);
    return async (config)=>{
        if (getGlobal().NX_GRAPH_CREATION) return config;
        if (!Array.isArray(config)) return await _zephyr_configuration(config, {
            ...zephyrPluginOptions,
            target
        });
        if (0 === config.length) return config;
        const engine = await ZephyrEngine.create({
            builder: 'rspack',
            context: config[0]?.context,
            target
        });
        applyBuildTarget(engine, target);
        try {
            const { coordinator, compilers } = coordinateXPackCompilers(engine, config, {
                snapshotType: zephyrPluginOptions?.snapshotType,
                entrypoint: zephyrPluginOptions?.entrypoint
            });
            for (const [index, item] of config.entries())await _zephyr_configuration(item, {
                ...zephyrPluginOptions,
                target,
                __engine: engine,
                __coordinator: coordinator,
                __participant: compilers[index]?.participant,
                __assetPrefix: compilers[index]?.assetPrefix
            });
        } catch (error) {
            if (engine.hasActiveBuild) engine.build_failed();
            throw error;
        }
        return config;
    };
}
async function _zephyr_configuration(config, _zephyrOptions) {
    let zephyr_engine;
    try {
        const target = resolveBuildTarget(_zephyrOptions);
        zephyr_engine = _zephyrOptions?.__engine ?? await ZephyrEngine.create({
            builder: 'rspack',
            context: config.context,
            target
        });
        applyBuildTarget(zephyr_engine, target);
        const dependencyPairs = extractFederatedDependencyPairs(config);
        const previousDependencies = zephyr_engine.federated_dependencies ?? [];
        const resolved_dependency_pairs = await zephyr_engine.resolve_remote_dependencies(dependencyPairs, extractLibraryType(config.output?.library));
        zephyr_engine.federated_dependencies = mergeResolvedDependencies(previousDependencies, resolved_dependency_pairs ?? []);
        mutWebpackFederatedRemotesConfig(zephyr_engine, config, resolved_dependency_pairs);
        (config.plugins ??= []).push(new ZeRspackPlugin({
            zephyr_engine,
            mfConfig: makeCopyOfModuleFederationOptions(config),
            wait_for_index_html: _zephyrOptions?.wait_for_index_html,
            hooks: _zephyrOptions?.hooks,
            coordinator: _zephyrOptions?.__coordinator,
            participant: _zephyrOptions?.__participant,
            assetPrefix: _zephyrOptions?.__assetPrefix
        }));
    } catch (error) {
        if (_zephyrOptions?.__coordinator) throw error;
        if (zephyr_engine?.hasActiveBuild !== false) zephyr_engine?.build_failed();
        handleGlobalError(error);
    }
    return config;
}
export { withZephyr };

//# sourceMappingURL=with-zephyr.mjs.map