xpe 0.0.0-alpha.1 → 1.0.0

package/dist/kernel/effect.js

@@ -0,0 +1,529 @@
+import { getExternalStyleSheets, getExternalScripts } from "./entry.js";
+import { getSandboxById, rawAppendChild, rawElementContains, rawElementRemoveChild, rawHeadInsertBefore, rawBodyInsertBefore, rawInsertAdjacentElement, rawDocumentQuerySelector, rawAddEventListener, rawRemoveEventListener, } from "./common.js";
+import { isFunction, isHijackingTag, warn, nextTick, getCurUrl, getAbsolutePath, execHooks, isScriptElement, setTagToScript, getTagFromScript, setAttrsToElement, } from "./utils.js";
+import { insertScriptToIframe, patchElementEffect } from "./iframe.js";
+import { getPatchStyleElements } from "./shadow.js";
+import { getCssLoader, getEffectLoaders, isMatchUrl } from "./plugin.js";
+import { XPE_SCRIPT_ID, XPE_DATA_FLAG, XPE_TIPS_REPEAT_RENDER, XPE_TIPS_NO_SCRIPT } from "./constant.js";
+import { parseTagAttributes } from "./template.js";
+import { getXpeRawDocumentHead } from "./xpe-bridge.js";
+function patchCustomEvent(e, elementGetter) {
+    Object.defineProperties(e, {
+        srcElement: {
+            get: elementGetter,
+        },
+        target: {
+            get: elementGetter,
+        },
+    });
+    return e;
+}
+/**
+ * 手动触发事件回调
+ */
+function manualInvokeElementEvent(element, event) {
+    const customEvent = new CustomEvent(event);
+    const patchedEvent = patchCustomEvent(customEvent, () => element);
+    if (isFunction(element[`on${event}`])) {
+        element[`on${event}`](patchedEvent);
+    }
+    else {
+        element.dispatchEvent(patchedEvent);
+    }
+}
+function getActiveSandboxContext(sandboxId) {
+    const sandbox = getSandboxById(sandboxId);
+    const iframeWindow = sandbox?.iframe?.contentWindow;
+    const iframeDocument = sandbox?.iframe?.contentDocument;
+    if (!sandbox || sandbox.isDestroyed() || !iframeWindow || !iframeDocument)
+        return null;
+    return { sandbox, iframeWindow, iframeDocument };
+}
+/**
+ * 样式元素的css变量处理，每个stylesheetElement单独节流
+ */
+function handleStylesheetElementPatch(stylesheetElement, sandbox) {
+    if (!stylesheetElement.innerHTML || sandbox.degrade)
+        return;
+    const patcher = () => {
+        try {
+            if (sandbox.isDestroyed() || !stylesheetElement.sheet || !sandbox.shadowRoot)
+                return;
+            const shadowHead = sandbox.shadowRoot.head;
+            const shadowHost = sandbox.shadowRoot.host;
+            if (!shadowHead || !shadowHost)
+                return;
+            const [hostStyleSheetElement, fontStyleSheetElement] = getPatchStyleElements([stylesheetElement.sheet]);
+            if (hostStyleSheetElement) {
+                shadowHead.appendChild(hostStyleSheetElement);
+            }
+            if (fontStyleSheetElement) {
+                shadowHost.appendChild(fontStyleSheetElement);
+            }
+        }
+        finally {
+            stylesheetElement._patcher = undefined;
+        }
+    };
+    if (stylesheetElement._patcher) {
+        clearTimeout(stylesheetElement._patcher);
+    }
+    stylesheetElement._patcher = setTimeout(patcher, 50);
+}
+/**
+ * 劫持处理样式元素的属性
+ * @internal 仅出于可测性导出，外部不应直接调用
+ */
+export function patchStylesheetElement(stylesheetElement, cssLoader, sandbox, curUrl) {
+    if (stylesheetElement._hasPatchStyle)
+        return;
+    const innerHTMLDesc = Object.getOwnPropertyDescriptor(Element.prototype, "innerHTML");
+    const innerTextDesc = Object.getOwnPropertyDescriptor(HTMLElement.prototype, "innerText");
+    const textContentDesc = Object.getOwnPropertyDescriptor(Node.prototype, "textContent");
+    const RawInsertRule = stylesheetElement.sheet?.insertRule;
+    // 这个地方将cssRule加到innerHTML中去，防止子应用切换之后丢失
+    function patchSheetInsertRule() {
+        if (!RawInsertRule)
+            return;
+        stylesheetElement.sheet.insertRule = (rule, index) => {
+            innerHTMLDesc ? (stylesheetElement.innerHTML += rule) : (stylesheetElement.innerText += rule);
+            return RawInsertRule.call(stylesheetElement.sheet, rule, index);
+        };
+    }
+    patchSheetInsertRule();
+    if (innerHTMLDesc) {
+        Object.defineProperties(stylesheetElement, {
+            innerHTML: {
+                get: function () {
+                    return innerHTMLDesc.get.call(stylesheetElement);
+                },
+                set: function (code) {
+                    innerHTMLDesc.set.call(stylesheetElement, cssLoader(code, "", curUrl));
+                    nextTick(() => handleStylesheetElementPatch(this, sandbox));
+                },
+            },
+        });
+    }
+    Object.defineProperties(stylesheetElement, {
+        innerText: {
+            get: function () {
+                return innerTextDesc.get.call(stylesheetElement);
+            },
+            set: function (code) {
+                innerTextDesc.set.call(stylesheetElement, cssLoader(code, "", curUrl));
+                nextTick(() => handleStylesheetElementPatch(this, sandbox));
+            },
+        },
+        textContent: {
+            get: function () {
+                return textContentDesc.get.call(stylesheetElement);
+            },
+            set: function (code) {
+                textContentDesc.set.call(stylesheetElement, cssLoader(code, "", curUrl));
+                nextTick(() => handleStylesheetElementPatch(this, sandbox));
+            },
+        },
+        appendChild: {
+            value: function (node) {
+                nextTick(() => handleStylesheetElementPatch(this, sandbox));
+                if (node.nodeType === Node.TEXT_NODE) {
+                    const res = rawAppendChild.call(stylesheetElement, stylesheetElement.ownerDocument.createTextNode(cssLoader(node.textContent, "", curUrl)));
+                    // 当appendChild之后，样式元素的sheet对象发生改变，要重新patch
+                    patchSheetInsertRule();
+                    return res;
+                }
+                else
+                    return rawAppendChild.call(stylesheetElement, node);
+            },
+        },
+        insertAdjacentElement: {
+            value: function (position, element) {
+                if (element.nodeName === "STYLE") {
+                    // vite dev server 第一个 css 通过 head.appendChild 插入，后续每个 css 都走
+                    // lastInsertedStyle.insertAdjacentElement("afterend", style)，hot update 时
+                    // 直接 style.textContent = newContent。被 insertAdjacentElement 插入的 style
+                    // 必须获得与"第一个 style"完全一致的劫持能力，否则：
+                    //   1) 当前内容里的资源相对路径不会被 cssLoader 改写（@font-face 失效）；
+                    //   2) 后续 textContent / innerHTML / appendChild / sheet.insertRule
+                    //      绕过 XPE runtime，hot update 全部脱管；
+                    //   3) 链式 insertAdjacentElement 创建的下游 style 直接走原生实现。
+                    // 因此这里必须复用与 case "STYLE" 完全一致的处理流程：先用 cssLoader 改写
+                    // 当前内容，再 patchStylesheetElement 把劫持递归装到新 style 上。
+                    const stylesheetElement = element;
+                    const content = stylesheetElement.innerHTML;
+                    if (content)
+                        stylesheetElement.innerHTML = cssLoader(content, "", curUrl);
+                    const res = rawInsertAdjacentElement.call(this, position, element);
+                    sandbox.styleSheetElements.push(stylesheetElement);
+                    patchStylesheetElement(stylesheetElement, cssLoader, sandbox, curUrl);
+                    handleStylesheetElementPatch(stylesheetElement, sandbox);
+                    return res;
+                }
+                else
+                    return rawInsertAdjacentElement.call(this, position, element);
+            },
+        },
+        _hasPatchStyle: { get: () => true },
+    });
+}
+// href 延迟赋值的兜底超时（毫秒）：超过该时间仍未拿到 href，则放弃监听并触发 error，
+// 防止「href 永不到达」时 observer 闭包长期钉住子应用上下文。沿用 tinymce maxLoadTime 量级。
+const DEFER_STYLE_HREF_TIMEOUT = 5000;
+/**
+ * 处理「先 appendChild(link) 后 setAttribute('href')」的延迟 href 场景。
+ *
+ * 通过 MutationObserver 监听 href 属性赋值，命中后走传入的 loadStyleSheet 完成加载。
+ * 生命周期管理（避免内存泄漏）：
+ *   1. 命中 / 超时 / 子应用已销毁 时立即 disconnect 并从 sandbox 出队；
+ *   2. observer 登记到 sandbox.deferredStyleObservers，destroy 阶段统一兜底 disconnect；
+ *   3. 回调内通过 sandboxId 动态获取 sandbox，不捕获 sandbox/iframe，子应用销毁后闭包不再 pin 上下文。
+ */
+export function deferStyleSheetByHref(opts) {
+    let { element } = opts;
+    const { sandboxId, iframeWindow, loadStyleSheet } = opts;
+    // 部分环境（jsdom / 老浏览器）可能不支持 MutationObserver，直接放弃延迟处理
+    const MutationObserverCtor = iframeWindow.MutationObserver;
+    if (typeof MutationObserverCtor !== "function")
+        return;
+    let settled = false;
+    let timer = null;
+    const observer = new MutationObserverCtor(() => {
+        if (settled)
+            return;
+        const attrHref = element?.getAttribute("href");
+        if (!attrHref)
+            return;
+        const realHref = element.href || attrHref;
+        const target = element;
+        finalize(() => target && loadStyleSheet(realHref, target));
+    });
+    // 统一收尾：disconnect + 出队 + 清理定时器，再执行收尾动作
+    function finalize(action) {
+        if (settled)
+            return;
+        settled = true;
+        if (timer !== null) {
+            clearTimeout(timer);
+            timer = null;
+        }
+        try {
+            observer.disconnect();
+        }
+        catch (_) {
+            /* noop */
+        }
+        // 动态获取 sandbox，子应用销毁后直接放手，闭包不再钉住上下文
+        const sandbox = getSandboxById(sandboxId);
+        const observers = sandbox?.deferredStyleObservers;
+        if (Array.isArray(observers)) {
+            const index = observers.indexOf(observer);
+            if (index !== -1)
+                observers.splice(index, 1);
+        }
+        if (sandbox)
+            action?.();
+        element = null;
+    }
+    const sandbox = getSandboxById(sandboxId);
+    // 子应用已不存在则无需监听
+    if (!sandbox || !Array.isArray(sandbox.deferredStyleObservers))
+        return;
+    sandbox.deferredStyleObservers.push(observer);
+    observer.observe(element, { attributes: true, attributeFilter: ["href"] });
+    // 超时兜底：长时间没等到 href，放弃监听并触发 error，让上游（如 tinymce）的失败回调收尾
+    timer = setTimeout(() => {
+        const target = element;
+        finalize();
+        if (target)
+            manualInvokeElementEvent(target, "error");
+    }, DEFER_STYLE_HREF_TIMEOUT);
+}
+function rewriteAppendOrInsertChild(opts) {
+    return function appendChildOrInsertBefore(newChild, refChild) {
+        let element = newChild;
+        const { rawDOMAppendOrInsertBefore, sandboxId } = opts;
+        const activeContext = getActiveSandboxContext(sandboxId);
+        if (!activeContext) {
+            return rawDOMAppendOrInsertBefore.call(this, element, refChild);
+        }
+        const { sandbox, iframeWindow, iframeDocument } = activeContext;
+        const { styleSheetElements, replace, fetch, plugins, lifecycles, proxyLocation, fiber } = sandbox;
+        if (!isHijackingTag(element.tagName) || !sandboxId) {
+            const res = rawDOMAppendOrInsertBefore.call(this, element, refChild);
+            patchElementEffect(element, iframeWindow);
+            execHooks(plugins, "appendOrInsertElementHook", element, iframeWindow);
+            return res;
+        }
+        const curUrl = getCurUrl(proxyLocation);
+        // TODO 过滤可以开放
+        if (element.tagName) {
+            switch (element.tagName?.toUpperCase()) {
+                case "LINK": {
+                    const { href, rel, type } = element;
+                    const styleFlag = rel === "stylesheet" || type === "text/css" || href.endsWith(".css");
+                    // 非 stylesheet 不做处理
+                    if (!styleFlag) {
+                        const res = rawDOMAppendOrInsertBefore.call(this, element, refChild);
+                        execHooks(plugins, "appendOrInsertElementHook", element, iframeWindow);
+                        return res;
+                    }
+                    // 拉取 css 内容并以 <style> 注入子应用、回调 link 的 load/error 事件。
+                    // 抽成闭包以便「append 时已有 href」与「append 后才 setAttribute('href')」两条路径复用。
+                    const loadStyleSheet = (realHref, linkElement) => {
+                        const attrHref = linkElement.getAttribute("href");
+                        const styleHref = attrHref ? getAbsolutePath(attrHref, proxyLocation.href) : realHref;
+                        const exclude = isMatchUrl(styleHref, getEffectLoaders("cssExcludes", plugins));
+                        if (!styleHref || exclude)
+                            return;
+                        getExternalStyleSheets([{ src: styleHref, ignore: isMatchUrl(styleHref, getEffectLoaders("cssIgnores", plugins)) }], fetch, lifecycles.loadError).forEach(({ src, ignore, contentPromise }) => contentPromise.then((content) => {
+                            const latestContext = getActiveSandboxContext(sandboxId);
+                            if (!latestContext)
+                                return;
+                            // 处理 ignore 样式
+                            const rawAttrs = parseTagAttributes(linkElement.outerHTML);
+                            if (ignore && src) {
+                                // 忽略的元素应该直接把对应元素插入，而不是用新的 link 标签进行替代插入，保证 element 的上下文正常
+                                rawDOMAppendOrInsertBefore.call(this, linkElement, refChild);
+                            }
+                            else {
+                                // 记录js插入样式，子应用重新激活时恢复
+                                const stylesheetElement = latestContext.iframeDocument.createElement("style");
+                                // 处理css-loader插件
+                                const cssLoader = getCssLoader({ plugins, replace });
+                                stylesheetElement.innerHTML = cssLoader(content, src, curUrl);
+                                latestContext.sandbox.styleSheetElements.push(stylesheetElement);
+                                setAttrsToElement(stylesheetElement, rawAttrs);
+                                rawDOMAppendOrInsertBefore.call(this, stylesheetElement, refChild);
+                                // 处理样式补丁
+                                handleStylesheetElementPatch(stylesheetElement, latestContext.sandbox);
+                                manualInvokeElementEvent(linkElement, "load");
+                            }
+                            if (element === linkElement)
+                                element = null;
+                        }, () => {
+                            manualInvokeElementEvent(linkElement, "error");
+                            if (element === linkElement)
+                                element = null;
+                        }));
+                    };
+                    if (href) {
+                        // 排除css
+                        if (!isMatchUrl(href, getEffectLoaders("cssExcludes", plugins))) {
+                            loadStyleSheet(href, element);
+                        }
+                    }
+                    else {
+                        // 部分库（如 tinymce 的 StyleSheetLoader）先 appendChild(link) 再
+                        // setAttribute('href', url)。此时 href 为空，若直接丢弃则该样式永远不会被加载，
+                        // 后续在游离 link 上设置 href 也不会触发浏览器加载，skin.min.css 等资源缺失。
+                        // 这里监听 href 的后续赋值，拿到真实 href 后再走与上面完全一致的加载流程。
+                        deferStyleSheetByHref({ element, sandboxId, iframeWindow, loadStyleSheet });
+                    }
+                    const comment = iframeDocument.createComment(`dynamic link ${href} replaced by xpe`);
+                    return rawDOMAppendOrInsertBefore.call(this, comment, refChild);
+                }
+                case "STYLE": {
+                    const stylesheetElement = newChild;
+                    styleSheetElements.push(stylesheetElement);
+                    const content = stylesheetElement.innerHTML;
+                    const cssLoader = getCssLoader({ plugins, replace });
+                    content && (stylesheetElement.innerHTML = cssLoader(content, "", curUrl));
+                    const res = rawDOMAppendOrInsertBefore.call(this, element, refChild);
+                    // 处理样式补丁
+                    patchStylesheetElement(stylesheetElement, cssLoader, sandbox, curUrl);
+                    handleStylesheetElementPatch(stylesheetElement, sandbox);
+                    execHooks(plugins, "appendOrInsertElementHook", element, iframeWindow);
+                    return res;
+                }
+                case "SCRIPT": {
+                    setTagToScript(element);
+                    const { src, text, type, crossOrigin } = element;
+                    // 排除js
+                    if (src && !isMatchUrl(src, getEffectLoaders("jsExcludes", plugins))) {
+                        const execScript = (scriptResult) => {
+                            // 假如子应用被连续渲染两次，两次渲染会导致处理流程的交叉污染
+                            const latestContext = getActiveSandboxContext(sandboxId);
+                            if (!latestContext)
+                                return warn(XPE_TIPS_REPEAT_RENDER);
+                            const onload = () => {
+                                manualInvokeElementEvent(element, "load");
+                                element = null;
+                            };
+                            insertScriptToIframe({ ...scriptResult, onload }, latestContext.iframeWindow, element);
+                        };
+                        const scriptOptions = {
+                            src,
+                            module: type === "module",
+                            crossorigin: crossOrigin !== null,
+                            crossoriginType: crossOrigin || "",
+                            ignore: isMatchUrl(src, getEffectLoaders("jsIgnores", plugins)),
+                            attrs: parseTagAttributes(element.outerHTML),
+                        };
+                        getExternalScripts([scriptOptions], fetch, lifecycles.loadError, fiber).forEach((scriptResult) => {
+                            sandbox.dynamicScriptExecStack = sandbox.dynamicScriptExecStack.then(() => scriptResult.contentPromise.then((content) => {
+                                if (sandbox.isDestroyed() || sandbox.execQueue === null)
+                                    return warn(XPE_TIPS_REPEAT_RENDER);
+                                const execQueueLength = sandbox.execQueue?.length;
+                                sandbox.execQueue.push(() => fiber
+                                    ? sandbox.requestIdleCallback(() => {
+                                        execScript({ ...scriptResult, content });
+                                    })
+                                    : execScript({ ...scriptResult, content }));
+                                // 同步脚本如果都执行完了，需要手动触发执行
+                                if (!execQueueLength)
+                                    sandbox.execQueue.shift()();
+                            }, () => {
+                                manualInvokeElementEvent(element, "error");
+                                element = null;
+                            }));
+                        });
+                    }
+                    else {
+                        const execQueueLength = sandbox.execQueue?.length;
+                        sandbox.execQueue.push(() => fiber
+                            ? sandbox.requestIdleCallback(() => {
+                                const latestContext = getActiveSandboxContext(sandboxId);
+                                if (!latestContext)
+                                    return warn(XPE_TIPS_REPEAT_RENDER);
+                                insertScriptToIframe({ src: null, content: text, attrs: parseTagAttributes(element.outerHTML) }, latestContext.iframeWindow, element);
+                            })
+                            : (() => {
+                                const latestContext = getActiveSandboxContext(sandboxId);
+                                if (!latestContext)
+                                    return warn(XPE_TIPS_REPEAT_RENDER);
+                                insertScriptToIframe({ src: null, content: text, attrs: parseTagAttributes(element.outerHTML) }, latestContext.iframeWindow, element);
+                            })());
+                        if (!execQueueLength)
+                            sandbox.execQueue.shift()();
+                    }
+                    // inline script never trigger the onload and onerror event
+                    const comment = iframeDocument.createComment(`dynamic script ${src} replaced by xpe`);
+                    return rawDOMAppendOrInsertBefore.call(this, comment, refChild);
+                }
+                // 修正子应用内部iframe的window.parent指向
+                case "IFRAME": {
+                    // 嵌套的子应用的js-iframe需要插入子应用的js-iframe内部
+                    if (element.getAttribute(XPE_DATA_FLAG) === "") {
+                        return rawAppendChild.call(rawDocumentQuerySelector.call(this.ownerDocument, "html"), element);
+                    }
+                    const res = rawDOMAppendOrInsertBefore.call(this, element, refChild);
+                    execHooks(plugins, "appendOrInsertElementHook", element, iframeWindow);
+                    return res;
+                }
+                default: {
+                    // 命中 isHijackingTag 但不属于 LINK/STYLE/SCRIPT/IFRAME 的标签，
+                    // 仍需真正插入节点并返回，否则返回 undefined 会让调用方拿不到插入结果、
+                    // 丢失节点（appendChild/insertBefore 约定返回被插入的节点）。
+                    const res = rawDOMAppendOrInsertBefore.call(this, element, refChild);
+                    execHooks(plugins, "appendOrInsertElementHook", element, iframeWindow);
+                    return res;
+                }
+            }
+        }
+    };
+}
+function findScriptElementFromIframe(rawElement, sandboxId) {
+    const xpeTag = getTagFromScript(rawElement);
+    const activeContext = getActiveSandboxContext(sandboxId);
+    if (!activeContext)
+        return { targetScript: null, rawHead: null };
+    const rawHead = getXpeRawDocumentHead(activeContext.iframeWindow);
+    const targetScript = rawHead.querySelector(`script[${XPE_SCRIPT_ID}='${xpeTag}']`);
+    if (targetScript === null) {
+        warn(XPE_TIPS_NO_SCRIPT, `<script ${XPE_SCRIPT_ID}='${xpeTag}'/>`);
+    }
+    return { targetScript, rawHead };
+}
+function rewriteContains(opts) {
+    return function contains(other) {
+        const element = other;
+        const { rawElementContains, sandboxId } = opts;
+        if (element && isScriptElement(element)) {
+            const { targetScript } = findScriptElementFromIframe(element, sandboxId);
+            return targetScript !== null;
+        }
+        return rawElementContains(element);
+    };
+}
+function rewriteRemoveChild(opts) {
+    return function removeChild(child) {
+        const element = child;
+        const { rawElementRemoveChild, sandboxId } = opts;
+        if (element && isScriptElement(element)) {
+            const { targetScript, rawHead } = findScriptElementFromIframe(element, sandboxId);
+            if (targetScript !== null && rawHead) {
+                return rawHead.removeChild(targetScript);
+            }
+            return null;
+        }
+        return rawElementRemoveChild(element);
+    };
+}
+/**
+ * 记录head和body的事件，等重新渲染复用head和body时需要清空事件
+ */
+function patchEventListener(element) {
+    const listenerMap = new Map();
+    element._cacheListeners = listenerMap;
+    element.addEventListener = (type, listener, options) => {
+        const listeners = listenerMap.get(type) || [];
+        listenerMap.set(type, [...listeners, listener]);
+        return rawAddEventListener.call(element, type, listener, options);
+    };
+    element.removeEventListener = (type, listener, options) => {
+        const typeListeners = listenerMap.get(type);
+        const index = typeListeners?.indexOf(listener);
+        if (typeListeners?.length && index !== undefined && index !== -1) {
+            typeListeners.splice(index, 1);
+        }
+        return rawRemoveEventListener.call(element, type, listener, options);
+    };
+}
+/**
+ * 清空head和body的绑定的事件
+ */
+export function removeEventListener(element) {
+    const listenerMap = element._cacheListeners;
+    [...listenerMap.entries()].forEach(([type, listeners]) => {
+        listeners.forEach((listener) => rawRemoveEventListener.call(element, type, listener));
+    });
+}
+/**
+ * patch head and body in render
+ * intercept appendChild and insertBefore
+ */
+export function patchRenderEffect(render, id, degrade) {
+    // 降级场景dom渲染在iframe中，iframe移动后事件自动销毁，不需要记录
+    if (!degrade) {
+        patchEventListener(render.head);
+        patchEventListener(render.body);
+    }
+    render.head.appendChild = rewriteAppendOrInsertChild({
+        rawDOMAppendOrInsertBefore: rawAppendChild,
+        sandboxId: id,
+    });
+    render.head.insertBefore = rewriteAppendOrInsertChild({
+        rawDOMAppendOrInsertBefore: rawHeadInsertBefore,
+        sandboxId: id,
+    });
+    render.head.removeChild = rewriteRemoveChild({
+        rawElementRemoveChild: rawElementRemoveChild.bind(render.head),
+        sandboxId: id,
+    });
+    render.head.contains = rewriteContains({
+        rawElementContains: rawElementContains.bind(render.head),
+        sandboxId: id,
+    });
+    render.contains = rewriteContains({
+        rawElementContains: rawElementContains.bind(render),
+        sandboxId: id,
+    });
+    render.body.appendChild = rewriteAppendOrInsertChild({
+        rawDOMAppendOrInsertBefore: rawAppendChild,
+        sandboxId: id,
+    });
+    render.body.insertBefore = rewriteAppendOrInsertChild({
+        rawDOMAppendOrInsertBefore: rawBodyInsertBefore,
+        sandboxId: id,
+    });
+}

package/dist/kernel/entry.d.ts

@@ -0,0 +1,43 @@
+import { ScriptObject, ScriptBaseObject, StyleObject } from "./template.js";
+import RuntimeSandbox from "./sandbox.js";
+import { plugin, loadErrorHandler } from "./runtime-engine.js";
+export type ScriptResultList = (ScriptBaseObject & {
+    contentPromise: Promise<string>;
+})[];
+export type StyleResultList = {
+    src: string;
+    contentPromise: Promise<string>;
+    ignore?: boolean;
+}[];
+interface htmlParseResult {
+    template: string;
+    assetPublicPath: string;
+    getExternalScripts(): ScriptResultList;
+    getExternalStyleSheets(): StyleResultList;
+}
+type ImportEntryOpts = {
+    fetch?: typeof window.fetch;
+    fiber?: boolean;
+    plugins?: Array<plugin>;
+    loadError?: loadErrorHandler;
+};
+export declare const styleCache: Record<string, any>;
+export declare const scriptCache: Record<string, any>;
+export declare const embedHTMLCache: Record<string, any>;
+/**
+ * 清空资源缓存：不传 host 时全清；传单个/数组 host 时按 url 前缀清。
+ * 用于热更新或多 host 子应用切换时主动失效，避免缓存命中已变更资源。
+ */
+export declare function clearAssetsCache(host?: string | string[]): void;
+/**
+ * 处理css-loader
+ */
+export declare function processCssLoader(sandbox: RuntimeSandbox, template: string, getExternalStyleSheets: () => StyleResultList): Promise<string>;
+export declare function getExternalStyleSheets(styles: StyleObject[], fetch: (input: RequestInfo, init?: RequestInit) => Promise<Response>, loadError: loadErrorHandler): StyleResultList;
+export declare function getExternalScripts(scripts: ScriptObject[], fetch: (input: RequestInfo, init?: RequestInit) => Promise<Response>, loadError: loadErrorHandler, fiber: boolean): ScriptResultList;
+export default function importHTML(params: {
+    url: string;
+    html?: string;
+    opts: ImportEntryOpts;
+}): Promise<htmlParseResult>;
+export {};