@netless/appliance-plugin 1.1.42 → 1.1.43-beta.0

package/dist/index-CV8YaU3F.mjs

@@ -0,0 +1,931 @@
+var A = Object.defineProperty;
+var x = (n, e, t) => e in n ? A(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t;
+var c = (n, e, t) => x(n, typeof e != "symbol" ? e + "" : e, t);
+import { E as b, a as l, b as C, c as v, d as L, O as $, V as B, S as V } from "./index-NG5kKK1W.mjs";
+import { isEqual as T, isString as U, clone as D, throttle as H } from "lodash";
+import "white-web-sdk";
+import "clipper-lib";
+import "lz-string";
+import "lineclip";
+import "xss";
+import "rbush";
+import "react-dom";
+import "react";
+import { g as P } from "./markmap-runtime-Cg3OxuZ2.mjs";
+class _ {
+  constructor() {
+    c(this, "threadEngine");
+  }
+  registerBackgroundThread(e) {
+    return this.threadEngine = e, this;
+  }
+}
+class z extends _ {
+  constructor() {
+    super(...arguments);
+    c(this, "emitEventType", b.CopyNode);
+  }
+  async consume(t) {
+    const { msgType: s, dataType: r, emitEventType: a } = t;
+    if (s === l.FullWork && r === C.Local && a === this.emitEventType)
+      return this.consumeForLocalWorker(t), !0;
+  }
+  async consumeForLocalWorker(t) {
+    var r;
+    const { workId: s } = t;
+    s && await ((r = this.threadEngine) == null ? void 0 : r.consumeFull(t));
+  }
+}
+class G {
+  constructor(e) {
+    c(this, "builders", /* @__PURE__ */ new Map());
+    this.builders = new Map(e.map((t) => [t, this.build(t)]));
+  }
+  build(e) {
+    switch (e) {
+      case b.CopyNode:
+        return new z();
+    }
+  }
+  registerForBackgroundThread(e) {
+    return this.builders.forEach((t) => {
+      t && t.registerBackgroundThread(e);
+    }), this;
+  }
+  async consumeForBackgroundThread(e) {
+    for (const t of this.builders.values())
+      if (await (t == null ? void 0 : t.consume(e)))
+        return !0;
+    return !1;
+  }
+}
+async function X(n) {
+  const e = n.querySelectorAll("img"), t = Array.from(e).map((a) => {
+    if (!a.crossOrigin && a.src && !a.src.startsWith("data:") && (a.crossOrigin = "anonymous", a.complete)) {
+      const o = a.src;
+      a.src = "", a.src = o;
+    }
+    return a.complete && a.crossOrigin ? Promise.resolve() : new Promise((o) => {
+      a.onload = () => {
+        o(void 0);
+      }, a.onerror = () => {
+        o(void 0);
+      };
+    });
+  });
+  return n.querySelectorAll("svg").forEach((a) => {
+    a.querySelectorAll("image").forEach((i) => {
+      i.href && !i.href.baseVal.startsWith("data:") && (i.getAttribute("crossorigin") || i.setAttribute("crossorigin", "anonymous"), t.push(
+        new Promise((d) => {
+          const h = new Image();
+          h.crossOrigin = "anonymous", h.onload = () => {
+            d(void 0);
+          }, h.onerror = () => {
+            d(void 0);
+          }, h.src = i.href.baseVal;
+        })
+      ));
+    });
+  }), await Promise.all(t);
+}
+async function Y(n) {
+  const s = Date.now();
+  let r = !1;
+  for (; Date.now() - s < 5e3; ) {
+    const a = n.querySelectorAll("path");
+    if (a.length > 0 && (r = Array.from(a).some((o) => {
+      const i = o.getAttribute("d") || "";
+      return i !== "M0,0C0,0,0,0,0,0" && i.length > 10;
+    }), r))
+      break;
+    await new Promise((o) => setTimeout(o, 50));
+  }
+}
+async function j(n) {
+  const e = n.querySelectorAll("svg");
+  if (!e.length)
+    return;
+  const t = [];
+  for (let s = 0; s < e.length; s++) {
+    const r = e[s];
+    t.push(Y(r));
+  }
+  await Promise.all(t);
+}
+async function E(n) {
+  if (n.querySelectorAll("svg[data-type='mermaid']").length > 0) {
+    const s = Date.now();
+    let r = !1;
+    for (; Date.now() - s < 5e3 && !r; ) {
+      const a = n.querySelectorAll("foreignObject");
+      if (a.length > 0) {
+        let o = !0;
+        for (const i of Array.from(a)) {
+          const d = parseFloat(i.getAttribute("width") || "0"), h = parseFloat(i.getAttribute("height") || "0");
+          if (i.querySelector(".mermaid-container") && (d < 50 || h < 50)) {
+            o = !1;
+            break;
+          }
+        }
+        if (o) {
+          r = !0;
+          break;
+        }
+      } else
+        r = !0;
+      await new Promise((o) => setTimeout(o, 50));
+    }
+  }
+}
+async function K(n, e = {}) {
+  const { width: t = n.offsetWidth, height: s = n.offsetHeight } = e, r = n.offsetWidth || t, a = n.offsetHeight || s;
+  try {
+    const { loadSvgToImageLib: o, getSvgToImageLib: i } = await import("./svgToImageLoader-DZz5bAo4.mjs");
+    let d = i();
+    if (!d)
+      try {
+        d = await o();
+      } catch (u) {
+        return console.error("[loadSvgToImageLib] error: ", u), null;
+      }
+    const h = n.style.width, f = n.style.height, y = n.style.display;
+    n.style.width || (n.style.width = `${r}px`), n.style.height || (n.style.height = `${a}px`), (!n.style.display || n.style.display === "none") && (n.style.display = "block");
+    try {
+      await new Promise((p) => {
+        requestAnimationFrame(() => {
+          requestAnimationFrame(() => {
+            p();
+          });
+        });
+      });
+      const u = await d.toPng(n, {
+        width: r,
+        height: a,
+        quality: 1
+      });
+      return n.style.width = h, n.style.height = f, n.style.display = y, new Promise((p) => {
+        const m = new Image();
+        m.crossOrigin = "anonymous", m.onload = () => {
+          p(m);
+        }, m.onerror = () => {
+          p(null);
+        }, m.src = u;
+      });
+    } catch (u) {
+      return n.style.width = h, n.style.height = f, n.style.display = y, console.error("[divToImageElement] error: ", u), null;
+    }
+  } catch (o) {
+    return console.error("[divToImageElement] error: ", o), null;
+  }
+}
+class Z {
+  constructor(e) {
+    c(this, "toolsType", v.BackgroundSVG);
+    c(this, "vNodes");
+    c(this, "workOptions");
+    c(this, "workId");
+    c(this, "markmapInstance", null);
+    c(this, "isDestroyed", !1);
+    c(this, "element");
+    c(this, "manager");
+    c(this, "scenePath");
+    c(this, "trackBackgroundImageLoad");
+    c(this, "reloadSourceUrl");
+    const {
+      vNodes: t,
+      workId: s,
+      toolsOpt: r,
+      manager: a,
+      scenePath: o,
+      trackBackgroundImageLoad: i = !0
+    } = e;
+    this.workId = s, this.vNodes = t, this.workOptions = r, this.manager = a, this.scenePath = o, this.trackBackgroundImageLoad = i, this.element = this.createElement(), this.manager.fullLayer.appendChild(this.element), this.vNodes.setInfo(this.workId, {
+      workShape: this
+    });
+  }
+  get fullLayer() {
+    return this.manager.fullLayer;
+  }
+  get collector() {
+    return this.manager.master.control.collector;
+  }
+  async init() {
+    await this.render();
+  }
+  createElement() {
+    const { type: e } = this.workOptions;
+    let t;
+    return e === L.markmap ? (t = document.createElementNS("http://www.w3.org/2000/svg", "svg"), t.classList.add("svg")) : (t = document.createElement("img"), t.classList.add("img")), t.id = this.workId, t.setAttribute("data-id", this.workId), t;
+  }
+  async render(e) {
+    this.isDestroyed || !this.element || !this.element.parentNode || (this.updateElementPosition(e), await this.updateSvg(e));
+  }
+  isSameSize(e) {
+    const { width: t, height: s } = e, { width: r, height: a } = this.workOptions, o = t * this.manager.camera.scale, i = s * this.manager.camera.scale, d = r * this.manager.camera.scale, h = a * this.manager.camera.scale;
+    return o === d && i === h;
+  }
+  isSamePosition(e) {
+    const { centerX: t, centerY: s } = e, { centerX: r, centerY: a } = this.workOptions, o = this.manager.getPagePoint(r, a), i = this.manager.getPagePoint(t, s);
+    return T(i, o);
+  }
+  isSameZIndex(e) {
+    const { zIndex: t } = e, { zIndex: s } = this.workOptions;
+    return t === s;
+  }
+  isSameState(e) {
+    const { state: t } = e, { state: s } = this.workOptions;
+    return T(t, s);
+  }
+  isSameData(e) {
+    const { data: t } = e, { data: s } = this.workOptions;
+    return T(t, s);
+  }
+  updateElementPosition(e) {
+    if (this.isDestroyed || !this.element || !this.fullLayer)
+      return;
+    const { centerX: t, centerY: s, width: r, height: a, zIndex: o } = this.workOptions, i = this.manager.getPagePoint(t, s), d = r * this.manager.camera.scale, h = a * this.manager.camera.scale;
+    (!e || e && !this.isSameSize(e)) && (this.element.setAttribute("width", `${d}`), this.element.setAttribute("height", `${h}`), this.element.style.width = `${d}px`, this.element.style.height = `${h}px`), (!e || e && !this.isSamePosition(e)) && (this.element.style.left = `${i.x}px`, this.element.style.top = `${i.y}px`), (!e || e && !this.isSameZIndex(e)) && (this.element.style.zIndex = (o || 0).toString());
+  }
+  async updateSvg(e) {
+    const { type: t, state: s } = this.workOptions;
+    if (t === L.markmap) {
+      const r = P(), { data: a } = this.workOptions;
+      if (this.markmapInstance || (this.markmapInstance = r.createMarkmap(
+        this.element,
+        this.manager.markmapOptions
+      ), this.markmapInstance.handleClick = async (d, h) => {
+        var u, p, m;
+        (u = this.markmapInstance) == null || u.toggleNode(h);
+        const f = this.serializeData((p = this.markmapInstance) == null ? void 0 : p.state.data);
+        this.setWorkOptions(
+          {
+            ...this.workOptions,
+            state: f
+          },
+          !1
+        ), r.checkNodeHasMermaid(h) && await r.renderMermaidAfterDOMUpdate(
+          this.element,
+          this.workId
+        ), this.scenePath && this.collector && ((m = this.collector) == null || m.dispatch({
+          type: l.UpdateNode,
+          workId: this.workId,
+          opt: this.workOptions,
+          isSync: !0,
+          viewId: this.manager.viewId,
+          scenePath: this.scenePath
+        }));
+      }), e && this.isSameState(e) && this.isSameSize(e) && this.isSameData(e))
+        return;
+      const o = r.transform(this.workId, a);
+      let { root: i } = o;
+      a && r.hasMermaidCodeBlock(a) && (i = r.injectMermaidHtml(i, a, this.workId));
+      try {
+        s && Array.isArray(s) && this.transformState(s, i), await this.markmapInstance.setData(i), !this.isDestroyed && this.element && this.fullLayer && this.markmapInstance && (window.markmapInstance = this.markmapInstance, a && r.hasMermaidCodeBlock(a) && await r.renderMermaidAfterDOMUpdate(
+          this.element,
+          this.workId
+        ), await this.fit(
+          !e || e && !this.isSameData(e)
+        ));
+      } catch (d) {
+        console.error("[updateSvg] error: ", d);
+      }
+    } else {
+      const { src: r, crossOrigin: a } = this.workOptions, o = this.reloadSourceUrl ?? r;
+      if (this.element.crossOrigin = U(a) ? a : "anonymous", !this.trackBackgroundImageLoad) {
+        this.element.src = o, await new Promise((i, d) => {
+          this.element.onload = () => i(), this.element.onerror = () => d();
+        });
+        return;
+      }
+      await this.manager.master.control.backgroundImageLoadCoordinator.load({
+        viewId: this.manager.viewId,
+        scenePath: this.scenePath,
+        resourceId: this.workId,
+        src: o,
+        image: this.element,
+        isActive: () => !this.isDestroyed && this.manager.master.control.viewContainerManager.getCurScenePath(
+          this.manager.viewId
+        ) === this.scenePath,
+        onReloadUrl: (i) => {
+          this.reloadSourceUrl = i;
+        }
+      });
+    }
+  }
+  async fit(e = !0) {
+    var t;
+    if (!this.isDestroyed && this.element && this.fullLayer && this.markmapInstance) {
+      const s = P();
+      e && this.element && await s.waitForImagesInForeignObjects(
+        this.element
+      ), await ((t = this.markmapInstance) == null ? void 0 : t.fit()), this.element && s.isSafari() && s.hasMermaidSvg(this.element) && (await E(this.element), await s.transformMermaidSvgToMarkmapSvg(
+        this.element
+      ));
+    }
+  }
+  serializeData(e) {
+    var r;
+    const t = [e], s = [];
+    for (; t.length > 0; ) {
+      const a = t.pop();
+      a && (a != null && a.children && t.push(...a.children), s.push(((r = a == null ? void 0 : a.payload) == null ? void 0 : r.fold) || 0));
+    }
+    return s;
+  }
+  transformState(e, t) {
+    const s = [t];
+    for (; s.length > 0; ) {
+      const r = s.pop();
+      r && (r != null && r.children && s.push(...r.children), r.payload ? r.payload.fold = e.shift() : e.shift());
+    }
+  }
+  async updateCamera() {
+    this.updateElementPosition(), await this.fit(!1);
+  }
+  async setWorkOptions(e, t = !0) {
+    if (!T(this.workOptions, e)) {
+      const s = D(this.workOptions), r = "src" in this.workOptions ? this.workOptions.src : void 0, a = "src" in e ? e.src : void 0;
+      r !== a && (this.reloadSourceUrl = void 0), this.workOptions = e, t && await this.render(s);
+    }
+  }
+  destroy() {
+    this.isDestroyed = !0, this.reloadSourceUrl = void 0, this.trackBackgroundImageLoad && this.manager.master.control.backgroundImageLoadCoordinator.cancelResource(
+      this.manager.viewId,
+      this.scenePath,
+      this.workId
+    ), this.element.remove();
+  }
+  getRectFromLayer() {
+    const e = this.element.getBoundingClientRect();
+    return {
+      x: e.x,
+      y: e.y,
+      w: e.width,
+      h: e.height
+    };
+  }
+}
+function q(n) {
+  const { toolsType: e, ...t } = n;
+  switch (e) {
+    case v.BackgroundSVG:
+      return new Z(t);
+    default:
+      return;
+  }
+}
+class W {
+  constructor(e) {
+    c(this, "viewId");
+    c(this, "fullLayer");
+    c(this, "curNodeMap");
+    this.viewId = e, this.curNodeMap = new $();
+  }
+  init(e) {
+    this.fullLayer = e;
+  }
+  get(e) {
+    return this.curNodeMap.get(e);
+  }
+  setInfo(e, t) {
+    const s = this.curNodeMap.get(
+      e
+    ) || {
+      name: e,
+      workShape: t.workShape
+    };
+    t.workShape && (s.workShape = t.workShape), this.curNodeMap.set(e, s);
+  }
+  getNodeRectFormShape(e) {
+    const t = this.curNodeMap.get(e);
+    if (t && t.workShape)
+      return t.workShape.getRectFromLayer();
+  }
+  delete(e) {
+    const t = this.curNodeMap.get(e);
+    t && t.workShape.destroy(), this.curNodeMap.delete(e);
+  }
+  clear() {
+    for (const e of this.curNodeMap.values())
+      e.workShape.destroy();
+    this.curNodeMap.clear();
+  }
+}
+class Q {
+  constructor(e, t) {
+    c(this, "opt");
+    c(this, "viewId");
+    c(this, "fullLayer");
+    c(this, "vNodes");
+    c(this, "master");
+    c(this, "cameraOpt");
+    c(this, "methodBuilder");
+    c(this, "destroyed", !1);
+    c(this, "updateCamera", H(async (e) => {
+      if (this.destroyed) return;
+      const { cameraOpt: t } = e;
+      t && !T(this.cameraOpt, t) && await this.setCameraOpt(t);
+    }, 100));
+    this.viewId = e, this.opt = t, this.master = t.master, this.fullLayer = t.container, this.methodBuilder = new G([
+      b.CopyNode
+    ]).registerForBackgroundThread(this), this.vNodes = new W(e), this.vNodes.init(this.fullLayer);
+  }
+  get camera() {
+    return this.cameraOpt || {
+      scale: 1,
+      centerX: 0,
+      centerY: 0,
+      width: 0,
+      height: 0
+    };
+  }
+  get view() {
+    var e;
+    return (e = this.master.control.viewContainerManager.getView(this.viewId)) == null ? void 0 : e.viewData;
+  }
+  get markmapOptions() {
+    return this.master.control.pluginOptions.extras.markmap.options;
+  }
+  getPagePoint(e, t) {
+    const { scale: s, centerX: r, centerY: a, width: o, height: i } = this.camera;
+    return {
+      x: (e - r) * s + o / 2,
+      y: (t - a) * s + i / 2
+    };
+  }
+  async setCameraOpt(e) {
+    if (!this.destroyed) {
+      this.cameraOpt = e;
+      for (const t of this.vNodes.curNodeMap.values()) {
+        if (this.destroyed) return;
+        const { workShape: s } = t;
+        s && await s.updateCamera();
+      }
+    }
+  }
+  clearAll() {
+    this.vNodes.clear();
+  }
+  canUseFullLayer(e) {
+    return e === v.BackgroundSVG;
+  }
+  async consumeFull(e) {
+    if (this.destroyed) return;
+    const { toolsType: t, opt: s, workId: r, scenePath: a } = e;
+    if (r != null && r.toString() && t && this.canUseFullLayer(t))
+      switch (t) {
+        case v.BackgroundSVG:
+          await this.setFullWork({
+            toolsType: t,
+            opt: s,
+            workId: r,
+            scenePath: a
+          });
+          break;
+      }
+  }
+  async setFullWork(e) {
+    const { workId: t, opt: s, toolsType: r, scenePath: a } = e;
+    if (t && s && r && a) {
+      const o = t.toString();
+      let i;
+      const d = this.vNodes.get(o);
+      return !d || !d.workShape ? (i = this.createWorkShapeNode({
+        toolsOpt: s,
+        toolsType: v.BackgroundSVG,
+        workId: o,
+        scenePath: a
+      }), i && await i.init()) : (i = d.workShape, await i.setWorkOptions(s)), i;
+    }
+  }
+  createWorkShapeNode(e) {
+    return q({
+      ...e,
+      vNodes: this.vNodes,
+      manager: this
+    });
+  }
+  removeWork(e) {
+    const { workId: t } = e, s = t == null ? void 0 : t.toString();
+    s && this.removeNode(s);
+  }
+  removeNode(e) {
+    this.vNodes.delete(e);
+  }
+  async on(e) {
+    if (!this.destroyed && !await this.methodBuilder.consumeForBackgroundThread(e)) {
+      if (this.destroyed) return;
+      const { msgType: t, toolsType: s } = e;
+      switch (t) {
+        case l.Destroy: {
+          this.destroy();
+          break;
+        }
+        case l.Clear: {
+          this.clearAll();
+          break;
+        }
+        case l.UpdateCamera: {
+          this.updateCamera(e);
+          break;
+        }
+        case l.UpdateTools: {
+          this.toggleFullLayer(s === v.Clicker);
+          break;
+        }
+        case l.BackgroundSVGUpdate:
+        case l.UpdateNode:
+        case l.FullWork: {
+          s && this.canUseFullLayer(s) && await this.consumeFull(e);
+          break;
+        }
+        case l.BackgroundSVGDelete: {
+          this.removeWork(e);
+          break;
+        }
+      }
+    }
+  }
+  toggleFullLayer(e) {
+    this.destroyed || this.fullLayer.classList.toggle(
+      "appliance-plugin-background-svg-active",
+      e
+    );
+  }
+  destroy() {
+    this.destroyed || (this.destroyed = !0, this.updateCamera.cancel(), this.vNodes.clear());
+  }
+}
+class J {
+  constructor(e, t) {
+    c(this, "viewId");
+    c(this, "fullLayer");
+    c(this, "master");
+    c(this, "vNodes");
+    c(this, "cameraOpt");
+    c(this, "opt");
+    c(this, "workShapes", /* @__PURE__ */ new Map());
+    c(this, "destroyed", !1);
+    c(this, "activeRequest");
+    this.viewId = e, this.opt = t, this.master = t.master, this.fullLayer = t.container, this.vNodes = new W(e), this.vNodes.init(this.fullLayer);
+  }
+  get camera() {
+    return this.cameraOpt || {
+      scale: 1,
+      centerX: 0,
+      centerY: 0,
+      width: 0,
+      height: 0
+    };
+  }
+  get view() {
+    var e;
+    return (e = this.master.control.viewContainerManager.getView(this.viewId)) == null ? void 0 : e.viewData;
+  }
+  get markmapOptions() {
+    return this.master.control.pluginOptions.extras.markmap.options;
+  }
+  reportRequestFailure(e, t, s, r, a) {
+    const o = r instanceof Error ? r.message : String(r);
+    try {
+      this.opt.post({
+        sp: [
+          {
+            type: l.ReportError,
+            viewId: this.viewId,
+            scenePath: s,
+            requestId: t,
+            reportBusiness: e,
+            reportStage: a,
+            reportError: o,
+            reportString: `[BackgroundSnapshotThread] ${e} failed; stage=${a}; requestId=${t || "unknown"}; error=${o}`
+          }
+        ]
+      });
+    } catch (i) {
+      console.error(
+        `[BackgroundSnapshotThread] ${e} failure report failed`,
+        i
+      );
+    }
+  }
+  createOffscreenCanvas(e) {
+    const { width: t, height: s } = e.canvasOpt, r = new OffscreenCanvas(
+      e.canvasOpt.width,
+      e.canvasOpt.height
+    );
+    r.width = t, r.height = s;
+  }
+  async setCameraOpt(e) {
+    if (!this.destroyed) {
+      this.cameraOpt = e;
+      for (const t of this.vNodes.curNodeMap.values()) {
+        if (this.destroyed) return;
+        const { workShape: s } = t;
+        s && await s.updateCamera();
+      }
+    }
+  }
+  getPagePoint(e, t) {
+    const { scale: s, centerX: r, centerY: a, width: o, height: i } = this.camera;
+    return {
+      x: (e - r) * s + o / 2,
+      y: (t - a) * s + i / 2
+    };
+  }
+  async getSnapshot(e) {
+    var o;
+    if (this.destroyed) return;
+    const { scenePath: t, scenes: s, cameraOpt: r, requestId: a } = e;
+    this.activeRequest = { business: "snapshot", scenePath: t, requestId: a };
+    try {
+      if (!(t && s && r))
+        throw new Error("snapshot input is incomplete");
+      await this.setCameraOpt(r);
+      for (const [d, h] of Object.entries(s)) {
+        if (this.destroyed) return;
+        if (h != null && h.type && (h == null ? void 0 : h.toolsType) === v.BackgroundSVG)
+          switch (h == null ? void 0 : h.type) {
+            case l.UpdateNode:
+            case l.FullWork: {
+              const { opt: f } = h, y = {
+                ...h,
+                opt: f,
+                workId: d,
+                msgType: l.FullWork,
+                dataType: C.Service,
+                viewId: this.viewId,
+                scenePath: t,
+                requestId: a
+              };
+              await this.runFullWork(y);
+              break;
+            }
+            default:
+              break;
+          }
+      }
+      if (await E(this.fullLayer), this.destroyed || (await X(this.fullLayer), this.destroyed) || (await j(this.fullLayer), this.destroyed)) return;
+      const i = await K(this.fullLayer);
+      if (!this.destroyed && i)
+        this.opt.post({
+          sp: [
+            {
+              type: l.Snapshot,
+              scenePath: t,
+              imageElement: i,
+              viewId: this.viewId,
+              index: 1,
+              requestId: a
+            }
+          ]
+        });
+      else if (!this.destroyed)
+        throw new Error("snapshot image element is empty");
+    } catch (i) {
+      this.destroyed || this.reportRequestFailure(
+        "snapshot",
+        a,
+        t,
+        i,
+        "render"
+      );
+    } finally {
+      ((o = this.activeRequest) == null ? void 0 : o.requestId) === a && (this.activeRequest = void 0);
+    }
+  }
+  createWorkShapeNode(e) {
+    return q({
+      ...e,
+      vNodes: this.vNodes,
+      manager: this,
+      trackBackgroundImageLoad: !1
+    });
+  }
+  async setFullWork(e) {
+    const { workId: t, opt: s, toolsType: r, scenePath: a } = e;
+    if (t && s && r && a) {
+      const o = t.toString();
+      let i;
+      const d = this.vNodes.get(o);
+      return !d || !d.workShape ? (i = this.createWorkShapeNode({
+        toolsOpt: s,
+        toolsType: v.BackgroundSVG,
+        workId: o,
+        scenePath: a
+      }), i && await i.init()) : (i = d.workShape, await i.setWorkOptions(s)), i;
+    }
+  }
+  async runFullWork(e) {
+    if (this.destroyed) return;
+    const { toolsType: t, opt: s, workId: r, scenePath: a } = e;
+    await this.setFullWork({
+      toolsType: t,
+      opt: s,
+      workId: r,
+      scenePath: a
+    });
+  }
+  destroy(e) {
+    this.destroyed || (e && this.activeRequest && this.reportRequestFailure(
+      "snapshot",
+      this.activeRequest.requestId,
+      this.activeRequest.scenePath,
+      new Error(`snapshot request ${e}`),
+      e
+    ), this.activeRequest = void 0, this.destroyed = !0, this.fullLayer.innerHTML = "", this.fullLayer.style.width = "", this.fullLayer.style.height = "");
+  }
+}
+class ue {
+  constructor(e) {
+    c(this, "backgroundThreadMap", /* @__PURE__ */ new Map());
+    c(this, "snapshotThreadsByRequest", /* @__PURE__ */ new Map());
+    c(this, "destroyed", !1);
+    c(this, "master");
+    c(this, "post", (e) => {
+      if (this.destroyed) return;
+      const { sp: t } = e;
+      t && this.master.collectorSyncData(t);
+    });
+    this.master = e, this.backgroundThreadMap = /* @__PURE__ */ new Map();
+  }
+  createBackgroundThread(e, t) {
+    return new Q(e, t);
+  }
+  createSnapshotThread(e, t) {
+    return new J(e, t);
+  }
+  getSnapshotRequestKey(e) {
+    return e.requestId || `${e.viewId}\0${e.scenePath || ""}\0${e.msgType}`;
+  }
+  disposeSnapshotThread(e, t, s) {
+    const r = this.snapshotThreadsByRequest.get(e);
+    if (!(!r || r.thread !== t)) {
+      this.snapshotThreadsByRequest.delete(e);
+      try {
+        t.destroy(s);
+      } finally {
+        r.surface.remove();
+      }
+    }
+  }
+  async consume(e) {
+    var t, s, r, a, o;
+    if (!this.destroyed)
+      for (const i of e.values()) {
+        if (this.destroyed) return;
+        const {
+          msgType: d,
+          viewId: h,
+          layerOpt: f,
+          offscreenCanvasOpt: y,
+          cameraOpt: u,
+          tasksqueue: p
+        } = i;
+        if (d === l.Console) {
+          console.log(this);
+          continue;
+        }
+        if (d === l.Init) {
+          const g = (t = this.master.control.viewContainerManager.getView(h)) == null ? void 0 : t.displayer, S = (s = g == null ? void 0 : g.backgroundContainerRef) == null ? void 0 : s.current;
+          if (g && S && f && y) {
+            const w = this.backgroundThreadMap.get(h);
+            w == null || w.destroy();
+            const k = this.createBackgroundThread(h, {
+              displayer: g,
+              container: S,
+              layerOpt: f,
+              master: this.master,
+              canvasOpt: y,
+              post: this.post
+            });
+            this.backgroundThreadMap.set(h, k), k && u && await k.setCameraOpt(u);
+          }
+          continue;
+        }
+        if (d === l.Snapshot) {
+          const g = (r = this.master.control.viewContainerManager.getView(h)) == null ? void 0 : r.displayer, w = (o = ((a = this.master.control.viewContainerManager.mainView) == null ? void 0 : a.displayer).backgroundSnapshotContainerRef) == null ? void 0 : o.current;
+          if (g && w && u) {
+            const k = this.getSnapshotRequestKey(i), N = this.snapshotThreadsByRequest.get(k);
+            N && this.disposeSnapshotThread(k, N.thread, "replaced");
+            const I = document.createElement("div");
+            I.style.width = `${u.width}px`, I.style.height = `${u.height}px`, w.append(I);
+            const F = {
+              ...B.defaultLayerOpt,
+              offscreen: !1,
+              width: u.width,
+              height: u.height
+            }, R = {
+              ...B.defaultScreenCanvasOpt,
+              width: u.width,
+              height: u.height
+            }, O = this.createSnapshotThread(h, {
+              displayer: g,
+              container: I,
+              layerOpt: F,
+              master: this.master,
+              canvasOpt: R,
+              post: this.post
+            });
+            this.snapshotThreadsByRequest.set(k, {
+              thread: O,
+              surface: I
+            }), O.getSnapshot(i).catch((M) => {
+              this.master.Logger.error(
+                `[Appliance]: background snapshot render failed; viewId=${h}; error=${M instanceof Error ? M.message : String(M)}`
+              );
+            }).finally(() => {
+              this.disposeSnapshotThread(k, O);
+            });
+            continue;
+          }
+          this.post({
+            sp: [
+              {
+                type: l.ReportError,
+                viewId: h,
+                scenePath: i.scenePath,
+                requestId: i.requestId,
+                reportBusiness: "snapshot",
+                reportStage: "surface-unavailable",
+                reportError: "background snapshot surface is unavailable",
+                reportString: `[BackgroundThreadManager] snapshot surface is unavailable; viewId=${h}; requestId=${i.requestId || "unknown"}`
+              }
+            ]
+          });
+        }
+        if (d === l.TasksQueue && (p != null && p.size)) {
+          for (const [g, S] of this.backgroundThreadMap.entries()) {
+            const w = p.get(g);
+            w && await S.on(w);
+          }
+          continue;
+        }
+        if (h === V) {
+          for (const g of this.backgroundThreadMap.values())
+            await g.on(i);
+          d === l.Destroy && this.backgroundThreadMap.clear();
+          continue;
+        }
+        const m = this.backgroundThreadMap.get(h);
+        m && (await m.on(i), d === l.Destroy && this.backgroundThreadMap.get(h) === m && this.backgroundThreadMap.delete(h));
+      }
+  }
+  async consumeTargetOne(e, t) {
+    if (this.destroyed) return;
+    const s = this.backgroundThreadMap.get(e);
+    s && await s.on(t);
+  }
+  discardView(e) {
+    for (const [s, r] of [
+      ...this.snapshotThreadsByRequest.entries()
+    ])
+      r.thread.viewId === e && this.disposeSnapshotThread(
+        s,
+        r.thread,
+        "view-destroyed"
+      );
+    const t = this.backgroundThreadMap.get(e);
+    try {
+      t == null || t.destroy();
+    } catch (s) {
+      this.master.Logger.error(
+        `[Appliance]: BackgroundThread View discard failed; viewId=${e}; error=${s instanceof Error ? s.message : String(s)}`
+      );
+    }
+    this.backgroundThreadMap.delete(e);
+  }
+  destroy() {
+    if (this.destroyed) return;
+    const e = [];
+    for (const [t, s] of [
+      ...this.snapshotThreadsByRequest.entries()
+    ])
+      try {
+        this.disposeSnapshotThread(
+          t,
+          s.thread,
+          "manager-destroyed"
+        );
+      } catch (r) {
+        e.push(
+          `snapshot-thread: ${r instanceof Error ? r.message : String(r)}`
+        );
+      }
+    this.snapshotThreadsByRequest.clear(), this.destroyed = !0;
+    for (const t of this.backgroundThreadMap.values())
+      try {
+        t.destroy();
+      } catch (s) {
+        e.push(
+          `background-thread: ${s instanceof Error ? s.message : String(s)}`
+        );
+      }
+    this.backgroundThreadMap.clear(), e.length && this.master.Logger.error(
+      `[Appliance]: BackgroundThread destroy completed with cleanup errors: ${e.join("; ")}`
+    );
+  }
+}
+export {
+  ue as BackgroundThreadManagerImpl
+};