zephyr-xpack-internal/dist/xpack-extract/create-mf-runtime-code.js

Xpack internals for Zephyr

"use strict";
var __webpack_modules__ = {};
var __webpack_module_cache__ = {};
function __webpack_require__(moduleId) {
    var cachedModule = __webpack_module_cache__[moduleId];
    if (void 0 !== cachedModule) return cachedModule.exports;
    var module = __webpack_module_cache__[moduleId] = {
        exports: {}
    };
    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
    return module.exports;
}
(()=>{
    __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 replaceRuntimeValue = (source, token, value)=>source.split(`'${token}'`).join(JSON.stringify(value)).split(`"${token}"`).join(JSON.stringify(value));
function createMfRuntimeCode(zephyr_engine, deps, delegate_module_template) {
    const fnReplace = delegate_module_template.toString();
    const strStart = new RegExp(/^function[\W\S]+return new Promise/);
    const strNewStart = "promise new Promise";
    const strEnd = new RegExp(/;[^)}]+}$/);
    const promiseNewPromise = fnReplace.replace(strStart, strNewStart).replace(strEnd, '');
    const { application_uid, remote_entry_url, default_url, name, library_type } = deps;
    if ('repack' === zephyr_engine.builder) return remote_entry_url;
    return [
        [
            '__APPLICATION_UID__',
            application_uid
        ],
        [
            '__REMOTE_ENTRY_URL__',
            remote_entry_url
        ],
        [
            '__REMOTE_NAME__',
            name
        ],
        [
            '__DEFAULT_URL__',
            default_url
        ],
        [
            '__LIBRARY_TYPE__',
            library_type
        ]
    ].reduce((source, [token, value])=>replaceRuntimeValue(source, token, value), promiseNewPromise);
}
function xpack_delegate_module_template() {
    return new Promise((resolve, reject)=>{
        const _windows = "u" > typeof window ? window : globalThis;
        const runtime_timeout_ms = 15000;
        const candidate_timeout_ms = 5000;
        let settled = false;
        const timeout = setTimeout(()=>{
            settleReject(new Error(`Zephyr: timed out loading remote entry after ${runtime_timeout_ms}ms`));
        }, runtime_timeout_ms);
        function settleResolve(value) {
            if (settled) return;
            settled = true;
            clearTimeout(timeout);
            resolve(value);
        }
        function settleReject(error) {
            if (settled) return;
            settled = true;
            clearTimeout(timeout);
            reject(error);
        }
        let sessionEdgeURL = null;
        try {
            sessionEdgeURL = _windows.sessionStorage?.getItem('__APPLICATION_UID__') ?? null;
        } catch  {}
        const remote_entry_url = '__REMOTE_ENTRY_URL__';
        const default_url = '__DEFAULT_URL__';
        const library_type = '__LIBRARY_TYPE__';
        const configured_remote_name = '__REMOTE_NAME__';
        const _win = _windows;
        function parseRemote(candidate) {
            const separator = candidate.indexOf('@');
            const possibleUrl = candidate.slice(separator + 1);
            if (separator > 0 && (/^(?:https?:)?\/\//.test(possibleUrl) || possibleUrl.startsWith('/'))) return {
                name: candidate.slice(0, separator),
                url: possibleUrl
            };
            return {
                name: configured_remote_name,
                url: candidate
            };
        }
        const candidates = [
            sessionEdgeURL,
            remote_entry_url,
            default_url
        ].filter((candidate)=>Boolean(candidate)).map(parseRemote).filter((candidate, index, entries)=>entries.findIndex((entry)=>entry.name === candidate.name && entry.url === candidate.url) === index);
        async function withLoadTimeout(promise, remoteName) {
            let loadTimeout;
            const timeoutPromise = new Promise((_resolve, rejectLoad)=>{
                loadTimeout = setTimeout(()=>rejectLoad(new Error(`Zephyr: timed out loading remote ${remoteName} after ${candidate_timeout_ms}ms`)), candidate_timeout_ms);
            });
            try {
                return await Promise.race([
                    promise,
                    timeoutPromise
                ]);
            } finally{
                if (loadTimeout) clearTimeout(loadTimeout);
            }
        }
        async function loadRemote() {
            let lastError;
            for (const candidate of candidates){
                if (void 0 !== _win[candidate.name]) return _win[candidate.name];
                try {
                    if ('function' == typeof __webpack_require__.l && 'module' !== library_type) {
                        const loadedContainer = new Promise((resolveLoaded, rejectLoaded)=>{
                            __webpack_require__.l(candidate.url, ()=>{
                                const container = _win[candidate.name];
                                if (void 0 === container) return void rejectLoaded(new Error(`Zephyr: remote ${candidate.name} loaded without exposing a container`));
                                resolveLoaded(container);
                            }, candidate.name, candidate.name);
                        });
                        return await withLoadTimeout(loadedContainer, candidate.name);
                    }
                    const imported = await withLoadTimeout(new Function('url', 'return import(url)')(candidate.url), candidate.name);
                    return void 0 !== _win[candidate.name] ? _win[candidate.name] : imported;
                } catch (error) {
                    lastError = error;
                }
            }
            const message = `Zephyr: no loadable remote entry for ${configured_remote_name} (${remote_entry_url})`;
            throw new Error(lastError instanceof Error ? `${message}: ${lastError.message}` : message);
        }
        loadRemote().then(settleResolve, settleReject);
    });
}
__webpack_require__.d(__webpack_exports__, {
    createMfRuntimeCode: ()=>createMfRuntimeCode,
    xpack_delegate_module_template: ()=>xpack_delegate_module_template
});
exports.createMfRuntimeCode = __webpack_exports__.createMfRuntimeCode;
exports.xpack_delegate_module_template = __webpack_exports__.xpack_delegate_module_template;
for(var __rspack_i in __webpack_exports__)if (-1 === [
    "createMfRuntimeCode",
    "xpack_delegate_module_template"
].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
Object.defineProperty(exports, '__esModule', {
    value: true
});

//# sourceMappingURL=create-mf-runtime-code.js.map