zephyr-xpack-internal/dist/xpack-extract/runtime-plugin.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__);
const globalCacheKey = '__ZEPHYR_MANIFEST_CACHE__';
const _global = "u" > typeof window ? window : globalThis;
function getGlobalManifestCache() {
    if (!_global[globalCacheKey]) _global[globalCacheKey] = new Map();
    return _global[globalCacheKey];
}
const manifestFileName = 'zephyr-manifest.json';
function toHttpUrl(value) {
    if (!value) return;
    try {
        const url = new URL(value);
        return 'http:' === url.protocol || 'https:' === url.protocol ? url : void 0;
    } catch  {
        return;
    }
}
function getCurrentScriptSrc() {
    if ("u" < typeof document || !document.currentScript) return;
    return document.currentScript.src || void 0;
}
function getDocumentBaseUrl() {
    if ("u" < typeof document || 'function' != typeof document.querySelector) return;
    if (!document.querySelector('base[href]')) return;
    try {
        return toHttpUrl(new URL('.', document.baseURI).href);
    } catch  {
        return;
    }
}
function resolveManifestUrl(scriptUrl) {
    const script = toHttpUrl(scriptUrl);
    const documentBase = getDocumentBaseUrl();
    if (documentBase && (!script || script.origin === documentBase.origin)) return `${documentBase.href}${manifestFileName}`;
    if (script) return `${script.origin}/${manifestFileName}`;
    return `/${manifestFileName}`;
}
function createZephyrRuntimePlugin(options = {}) {
    const defaultManifestUrl = resolveManifestUrl(getCurrentScriptSrc());
    const { manifestUrl = defaultManifestUrl } = options;
    let processedRemotes;
    async function fetchManifest(url) {
        try {
            const response = await fetch(url);
            if (!response.ok) return;
            const manifest = await response.json().catch(()=>void 0);
            if (!manifest) return void console.error('[Zephyr] Failed to parse manifest JSON');
            return manifest;
        } catch (error) {
            console.error('[Zephyr] Unexpected error fetching manifest:', error);
            return;
        }
    }
    const manifestCache = getGlobalManifestCache();
    if (!manifestCache.has(manifestUrl)) manifestCache.set(manifestUrl, fetchManifest(manifestUrl));
    const zephyrManifestPromise = manifestCache.get(manifestUrl);
    const plugin = {
        name: 'zephyr-runtime-remote-resolver',
        async beforeRequest (args) {
            const zephyrManifest = await zephyrManifestPromise;
            if (!processedRemotes) processedRemotes = identifyRemotes(args, zephyrManifest);
            const remoteName = args.id.split('/')[0];
            if (!processedRemotes[remoteName]) return args;
            const resolvedEntry = getResolvedRemoteEntry(processedRemotes[remoteName]);
            const targetRemote = args.options.remotes.find((remote)=>hasEntry(remote) && (remote.name === remoteName || remote.alias === remoteName));
            if (!targetRemote) return args;
            targetRemote.entry = resolvedEntry.url;
            if (resolvedEntry.isManifest) delete targetRemote.type;
            else if (resolvedEntry.libraryType) targetRemote.type = resolvedEntry.libraryType;
            return args;
        }
    };
    return plugin;
}
function identifyRemotes(args, zephyrManifest) {
    const identifiedRemotes = {};
    if (!zephyrManifest) return identifiedRemotes;
    if (!args.options.remotes.length) return identifiedRemotes;
    const { dependencies } = zephyrManifest;
    const remotes = args.options.remotes;
    remotes.forEach((remote)=>{
        const resolvedRemote = dependencies[remote.name] ?? dependencies[remote.alias ?? ''];
        if (resolvedRemote) {
            identifiedRemotes[remote.name] = resolvedRemote;
            if (remote.alias && remote.alias !== remote.name) identifiedRemotes[remote.alias] = resolvedRemote;
        }
    });
    return identifiedRemotes;
}
function hasEntry(remote) {
    return null != remote && 'object' == typeof remote && 'entry' in remote && 'string' == typeof remote.entry;
}
function getResolvedRemoteEntry(resolvedRemote) {
    const _window = "u" > typeof window ? window : globalThis;
    const sessionEdgeURL = _window.sessionStorage?.getItem(resolvedRemote.application_uid);
    let edgeUrl = sessionEdgeURL ?? resolvedRemote.manifest_url ?? resolvedRemote.remote_entry_url;
    edgeUrl = stripRemoteNamePrefix(edgeUrl);
    const pathname = edgeUrl.split(/[?#]/, 1)[0];
    const isManifest = pathname.endsWith('.json');
    return {
        url: edgeUrl,
        isManifest,
        libraryType: isManifest ? void 0 : resolvedRemote.library_type
    };
}
function stripRemoteNamePrefix(entry) {
    if (/^(?:https?:)?\/\//.test(entry)) return entry;
    const absoluteUrlIndex = entry.search(/https?:\/\//);
    if (absoluteUrlIndex > 0) return entry.slice(absoluteUrlIndex);
    const separatorIndex = entry.lastIndexOf('@');
    if (-1 !== separatorIndex) return entry.slice(separatorIndex + 1);
    return entry;
}
const __rspack_default_export = createZephyrRuntimePlugin;
__webpack_require__.d(__webpack_exports__, {
    createZephyrRuntimePlugin: ()=>createZephyrRuntimePlugin,
    resolveManifestUrl: ()=>resolveManifestUrl
}, {
    default: __rspack_default_export
});
exports.createZephyrRuntimePlugin = __webpack_exports__.createZephyrRuntimePlugin;
exports["default"] = __webpack_exports__["default"];
exports.resolveManifestUrl = __webpack_exports__.resolveManifestUrl;
for(var __rspack_i in __webpack_exports__)if (-1 === [
    "createZephyrRuntimePlugin",
    "default",
    "resolveManifestUrl"
].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
Object.defineProperty(exports, '__esModule', {
    value: true
});

//# sourceMappingURL=runtime-plugin.js.map