@shjjs/visual-ui 1.0.0

package/es/components/commons-babylon/index.vue2.mjs

@@ -0,0 +1,4 @@
+import f from "./index.vue.mjs";
+export {
+  f as default
+};

package/es/components/commons-echarts/compileAndRunEcharts.d.ts

@@ -0,0 +1,12 @@
+import { Ref } from 'vue';
+export declare const useEcharts: (basicOption: any, sources: any, useEvents: any) => {
+    iframeRef: Ref<HTMLCanvasElement>;
+    loadingStatus: Ref<boolean>;
+    renderingComponent: Ref<{
+        _iframe: HTMLElement;
+        fastEval(code: string): void;
+        loadScriptAsync(url: string): Promise<void>;
+        compileAndRunAsync(code: string): Promise<void>;
+    }>;
+    initEcharts: (code: string) => void;
+};

package/es/components/commons-echarts/compileAndRunEcharts.mjs

@@ -0,0 +1,116 @@
+var y = Object.defineProperty;
+var w = (i, r, a) => r in i ? y(i, r, { enumerable: !0, configurable: !0, writable: !0, value: a }) : i[r] = a;
+var p = (i, r, a) => w(i, typeof r != "symbol" ? r + "" : r, a);
+import { ref as s, onMounted as g } from "vue";
+import * as v from "echarts";
+import { nanoid as C } from "nanoid";
+const A = (i, r, a) => {
+  const l = s(), c = s(!1);
+  class f {
+    constructor() {
+      p(this, "_iframe");
+      this._iframe = l.value;
+    }
+    fastEval(n) {
+      const t = this._iframe.contentWindow.document.getElementsByTagName("head")[0], e = this._iframe.contentWindow.document.createElement("script");
+      e.setAttribute("type", "text/javascript");
+      const o = this._iframe.contentWindow.document.createElement("style");
+      o.innerHTML = `
+            *{
+                margin:0;
+                padding:0;
+            }
+            body, html {
+                height:100%;
+                overflow: hidden;
+                background-color: transparent;
+            }
+            #renderDom {
+                width:100%;
+                height:100%;
+                background-color: transparent;
+                outline: none !important;
+            }
+        `, e.innerHTML = `
+        try {
+            ${n};
+        } catch(e) {
+            handleException(e);
+        }`, t.innerHTML = "", t.appendChild(o), t.appendChild(e);
+    }
+    async loadScriptAsync(n) {
+      return new Promise((t) => {
+        const e = document.createElement("script");
+        e.src = n, e.onload = () => {
+          t();
+        }, document.head.appendChild(e);
+      });
+    }
+    async compileAndRunAsync(n) {
+      try {
+        if (n.includes("window.") || n.includes("parent.") || n.includes("top."))
+          return;
+        let t = "";
+        c.value = !0;
+        const e = this._iframe.contentWindow;
+        if (e.myChart) {
+          try {
+            e.myChart.dispose();
+          } catch {
+          }
+          e.myChart = null, e.option = null;
+        }
+        delete e.myChart, delete e.option, delete e.renderDom, delete e.initFunction;
+        let o = e.document.getElementById("renderDom");
+        if (o || (o = e.document.createElement("div"), o.id = "renderDom", e.document.body.appendChild(o)), e.echarts = v, !o || (e.renderDom = o, !n))
+          return;
+        t += `
+                        window.initFunction = async function() {
+                        window.myChart  = echarts.init(renderDom, null, {
+                          renderer: 'svg'
+                        });
+                        window.option;
+                    `, t += n, t += `
+
+                            option && myChart.setOption(option);`, t += `
+
+                        }`;
+        try {
+          this.fastEval(t);
+        } catch {
+        }
+        try {
+          await e.initFunction();
+        } catch {
+        }
+        if (!e.option)
+          return;
+        c.value = !1;
+      } catch {
+        c.value = !1;
+      }
+    }
+  }
+  const m = (u) => {
+    window.SHJDatasourceV2({
+      tId: C(),
+      sources: r,
+      callback: ({ data: n }) => {
+        try {
+          window.SHJParseEvent(a, "dataListener", n);
+          const t = `var echartsData = ${JSON.stringify(n[0].data[0].echartsData)};`;
+          d.value.compileAndRunAsync(t + `
+` + u);
+        } catch {
+          window.SHJParseEvent(a, "dataListener", null);
+        }
+      }
+    });
+  }, d = s();
+  return g(() => {
+    d.value = new f(), m(i.code);
+  }), { iframeRef: l, loadingStatus: c, renderingComponent: d, initEcharts: m };
+};
+export {
+  A as useEcharts
+};

package/es/components/commons-echarts/index.d.ts

@@ -0,0 +1,38 @@
+export declare const ZvCommonsEcharts: import("../../utils/typescript").SFCWithInstall<import("vue").DefineComponent<{
+    basicOption: {
+        type: any;
+        required: true;
+    };
+    sources: {
+        type: any;
+        required: true;
+    };
+    useEvents: {
+        type: ArrayConstructor;
+        required: true;
+    };
+}, {
+    props: any;
+    iframeRef: import("vue").Ref<HTMLCanvasElement>;
+    renderingComponent: import("vue").Ref<{
+        _iframe: HTMLElement;
+        fastEval(code: string): void;
+        loadScriptAsync(url: string): Promise<void>;
+        compileAndRunAsync(code: string): Promise<void>;
+    }>;
+    initEcharts: (code: string) => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    basicOption: {
+        type: any;
+        required: true;
+    };
+    sources: {
+        type: any;
+        required: true;
+    };
+    useEvents: {
+        type: ArrayConstructor;
+        required: true;
+    };
+}>>, {}, {}>> & Record<string, any>;
+export default ZvCommonsEcharts;

package/es/components/commons-echarts/index.mjs

@@ -0,0 +1,7 @@
+import o from "./index.vue.mjs";
+import { withInstall as t } from "../../utils/install.mjs";
+const s = t(o);
+export {
+  s as ZvCommonsEcharts,
+  s as default
+};

package/es/components/commons-echarts/index.vue.d.ts

@@ -0,0 +1,38 @@
+declare const _sfc_main: import("vue").DefineComponent<{
+    basicOption: {
+        type: any;
+        required: true;
+    };
+    sources: {
+        type: any;
+        required: true;
+    };
+    useEvents: {
+        type: ArrayConstructor;
+        required: true;
+    };
+}, {
+    props: any;
+    iframeRef: import("vue").Ref<HTMLCanvasElement>;
+    renderingComponent: import("vue").Ref<{
+        _iframe: HTMLElement;
+        fastEval(code: string): void;
+        loadScriptAsync(url: string): Promise<void>;
+        compileAndRunAsync(code: string): Promise<void>;
+    }>;
+    initEcharts: (code: string) => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    basicOption: {
+        type: any;
+        required: true;
+    };
+    sources: {
+        type: any;
+        required: true;
+    };
+    useEvents: {
+        type: ArrayConstructor;
+        required: true;
+    };
+}>>, {}, {}>;
+export default _sfc_main;

package/es/components/commons-echarts/index.vue.mjs

@@ -0,0 +1,41 @@
+import { defineComponent as a, watch as i, openBlock as l, createElementBlock as m, createElementVNode as u } from "vue";
+import { cloneDeep as c, isEqual as n } from "lodash";
+import { useEcharts as h } from "./compileAndRunEcharts.mjs";
+const _ = { class: "zerov-widget" }, b = a({ name: "zv-commons-echarts" }), w = /* @__PURE__ */ a({
+  ...b,
+  props: {
+    basicOption: {},
+    sources: {},
+    useEvents: {}
+  },
+  setup(p, { expose: f }) {
+    const e = p, { iframeRef: d, renderingComponent: r, initEcharts: o } = h(e.basicOption, e.sources, e.useEvents);
+    return i(() => c(e.basicOption), (s, t) => {
+      !n(s, t) && r.value && o(s.code);
+    }, {
+      deep: !0
+    }), i(() => c(e.sources), (s, t) => {
+      !n(s, t) && r.value && o(e.basicOption.code);
+    }, { deep: !0 }), f({
+      refreshData: () => {
+        o(e.basicOption.code);
+      },
+      refreshView: () => {
+        o(e.basicOption.code);
+      },
+      refresh: () => {
+        o(e.basicOption.code);
+      }
+    }), (s, t) => (l(), m("div", _, [
+      u("iframe", {
+        ref_key: "iframeRef",
+        ref: d,
+        style: { width: "100%", height: "100%", border: "0" },
+        sandbox: "allow-scripts allow-same-origin"
+      }, null, 512)
+    ]));
+  }
+});
+export {
+  w as default
+};

package/es/components/commons-echarts/index.vue2.mjs

@@ -0,0 +1,4 @@
+import f from "./index.vue.mjs";
+export {
+  f as default
+};

package/es/components/commons-gaussian-splatting-view/index.d.ts

@@ -0,0 +1,92 @@
+export declare const ZvCommonsGaussianSplattingView: import("../../utils/typescript").SFCWithInstall<import("vue").DefineComponent<{
+    basicOption: {
+        type: any;
+        required: true;
+    };
+    basicEvents: {
+        type: any;
+        required: true;
+    };
+}, {
+    props: any;
+    useBabylonScene: (basicOption: any, basicEvents: any) => {
+        canvasRef: import("vue").Ref<any>;
+        babylon: import("vue").Ref<{
+            scene: import("@babylonjs/core").Scene;
+            engine: import("@babylonjs/core").Engine;
+            gs: import("@babylonjs/core").GaussianSplattingMesh;
+            canvas: HTMLCanvasElement;
+            option: any;
+            events: any;
+            createScene(): import("@babylonjs/core").Scene;
+            setGSSize(optionMeshs: any): void;
+            updateScene(sceneOption: any): void;
+            createCamera(cameraOption: any, scene: import("@babylonjs/core").Scene): void;
+            updateCamera(cameraOption: any): void;
+            run(): any;
+            dispose(): void;
+        }>;
+        Babylon: {
+            new (canvas: HTMLCanvasElement, option: any, events: any): {
+                scene: import("@babylonjs/core").Scene;
+                engine: import("@babylonjs/core").Engine;
+                gs: import("@babylonjs/core").GaussianSplattingMesh;
+                canvas: HTMLCanvasElement;
+                option: any;
+                events: any;
+                createScene(): import("@babylonjs/core").Scene;
+                setGSSize(optionMeshs: any): void;
+                updateScene(sceneOption: any): void;
+                createCamera(cameraOption: any, scene: import("@babylonjs/core").Scene): void;
+                updateCamera(cameraOption: any): void;
+                run(): any;
+                dispose(): void;
+            };
+        };
+        babylonLoadingStatus: import("vue").Ref<boolean>;
+    };
+    babylon: import("vue").Ref<{
+        scene: import("@babylonjs/core").Scene;
+        engine: import("@babylonjs/core").Engine;
+        gs: import("@babylonjs/core").GaussianSplattingMesh;
+        canvas: HTMLCanvasElement;
+        option: any;
+        events: any;
+        createScene(): import("@babylonjs/core").Scene;
+        setGSSize(optionMeshs: any): void;
+        updateScene(sceneOption: any): void;
+        createCamera(cameraOption: any, scene: import("@babylonjs/core").Scene): void;
+        updateCamera(cameraOption: any): void;
+        run(): any;
+        dispose(): void;
+    }>;
+    Babylon: {
+        new (canvas: HTMLCanvasElement, option: any, events: any): {
+            scene: import("@babylonjs/core").Scene;
+            engine: import("@babylonjs/core").Engine;
+            gs: import("@babylonjs/core").GaussianSplattingMesh;
+            canvas: HTMLCanvasElement;
+            option: any;
+            events: any;
+            createScene(): import("@babylonjs/core").Scene;
+            setGSSize(optionMeshs: any): void;
+            updateScene(sceneOption: any): void;
+            createCamera(cameraOption: any, scene: import("@babylonjs/core").Scene): void;
+            updateCamera(cameraOption: any): void;
+            run(): any;
+            dispose(): void;
+        };
+    };
+    canvasRef: import("vue").Ref<any>;
+    babylonLoadingStatus: import("vue").Ref<boolean>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    basicOption: {
+        type: any;
+        required: true;
+    };
+    basicEvents: {
+        type: any;
+        required: true;
+    };
+}>>, {}, {}>> & Record<string, any>;
+export default ZvCommonsGaussianSplattingView;

package/es/components/commons-gaussian-splatting-view/index.mjs

@@ -0,0 +1,7 @@
+import t from "./index.vue.mjs";
+import { withInstall as o } from "../../utils/install.mjs";
+const m = o(t);
+export {
+  m as ZvCommonsGaussianSplattingView,
+  m as default
+};

package/es/components/commons-gaussian-splatting-view/index.vue.d.ts

@@ -0,0 +1,93 @@
+import { Scene, Engine, GaussianSplattingMesh } from '@babylonjs/core';
+declare const _sfc_main: import("vue").DefineComponent<{
+    basicOption: {
+        type: any;
+        required: true;
+    };
+    basicEvents: {
+        type: any;
+        required: true;
+    };
+}, {
+    props: any;
+    useBabylonScene: (basicOption: any, basicEvents: any) => {
+        canvasRef: import("vue").Ref<any>;
+        babylon: import("vue").Ref<{
+            scene: Scene;
+            engine: Engine;
+            gs: GaussianSplattingMesh;
+            canvas: HTMLCanvasElement;
+            option: any;
+            events: any;
+            createScene(): Scene;
+            setGSSize(optionMeshs: any): void;
+            updateScene(sceneOption: any): void;
+            createCamera(cameraOption: any, scene: Scene): void;
+            updateCamera(cameraOption: any): void;
+            run(): any;
+            dispose(): void;
+        }>;
+        Babylon: {
+            new (canvas: HTMLCanvasElement, option: any, events: any): {
+                scene: Scene;
+                engine: Engine;
+                gs: GaussianSplattingMesh;
+                canvas: HTMLCanvasElement;
+                option: any;
+                events: any;
+                createScene(): Scene;
+                setGSSize(optionMeshs: any): void;
+                updateScene(sceneOption: any): void;
+                createCamera(cameraOption: any, scene: Scene): void;
+                updateCamera(cameraOption: any): void;
+                run(): any;
+                dispose(): void;
+            };
+        };
+        babylonLoadingStatus: import("vue").Ref<boolean>;
+    };
+    babylon: import("vue").Ref<{
+        scene: Scene;
+        engine: Engine;
+        gs: GaussianSplattingMesh;
+        canvas: HTMLCanvasElement;
+        option: any;
+        events: any;
+        createScene(): Scene;
+        setGSSize(optionMeshs: any): void;
+        updateScene(sceneOption: any): void;
+        createCamera(cameraOption: any, scene: Scene): void;
+        updateCamera(cameraOption: any): void;
+        run(): any;
+        dispose(): void;
+    }>;
+    Babylon: {
+        new (canvas: HTMLCanvasElement, option: any, events: any): {
+            scene: Scene;
+            engine: Engine;
+            gs: GaussianSplattingMesh;
+            canvas: HTMLCanvasElement;
+            option: any;
+            events: any;
+            createScene(): Scene;
+            setGSSize(optionMeshs: any): void;
+            updateScene(sceneOption: any): void;
+            createCamera(cameraOption: any, scene: Scene): void;
+            updateCamera(cameraOption: any): void;
+            run(): any;
+            dispose(): void;
+        };
+    };
+    canvasRef: import("vue").Ref<any>;
+    babylonLoadingStatus: import("vue").Ref<boolean>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    basicOption: {
+        type: any;
+        required: true;
+    };
+    basicEvents: {
+        type: any;
+        required: true;
+    };
+}>>, {}, {}>;
+export default _sfc_main;

package/es/components/commons-gaussian-splatting-view/index.vue.mjs

@@ -0,0 +1,7 @@
+import o from "./index.vue2.mjs";
+/* empty css            */
+import t from "../../_virtual/_plugin-vue_export-helper.mjs";
+const m = /* @__PURE__ */ t(o, [["__scopeId", "data-v-f24d6214"]]);
+export {
+  m as default
+};

package/es/components/commons-gaussian-splatting-view/index.vue2.mjs

@@ -0,0 +1,146 @@
+var k = Object.defineProperty;
+var A = (l, i, h) => i in l ? k(l, i, { enumerable: !0, configurable: !0, writable: !0, value: h }) : l[i] = h;
+var b = (l, i, h) => A(l, typeof i != "symbol" ? i + "" : i, h);
+import { defineComponent as M, watch as r, openBlock as E, createElementBlock as x, createElementVNode as G, normalizeClass as P, unref as B, createCommentVNode as V, ref as y, onMounted as F, onBeforeUnmount as N } from "vue";
+import "@babylonjs/loaders/glTF";
+import { useResizeObserver as q } from "@vueuse/core";
+import { Vector3 as m, Engine as Z, Scene as j, Color4 as v, Color3 as _, GaussianSplattingMesh as H, ArcRotateCamera as J, Tools as w } from "@babylonjs/core";
+import { cloneDeep as u, isEqual as c } from "lodash";
+import { hex2Color4 as D, hex2Color3 as T } from "../../utils/babylon/ColorConvert.mjs";
+const K = { class: "zerov-widget" }, Q = {
+  key: 0,
+  ref: "babylonLoadingRef",
+  class: "babylon-loading"
+}, X = M({ name: "zv-commons-gaussian-splatting-view" }), ne = /* @__PURE__ */ M({
+  ...X,
+  props: {
+    basicOption: {},
+    basicEvents: {}
+  },
+  setup(l) {
+    const i = l, h = (s, a) => {
+      const d = y(), S = y(!0);
+      class U {
+        // eslint-disable-next-line no-useless-constructor
+        constructor(e) {
+          // optional, but needed due to interface definitions
+          b(this, "loadingUIBackgroundColor");
+          this.loadingUIText = e;
+        }
+        displayLoadingUI() {
+          d.value && (S.value = !0);
+        }
+        hideLoadingUI() {
+          d.value && (S.value = !1);
+        }
+      }
+      class L {
+        constructor(e, n, o) {
+          b(this, "scene");
+          b(this, "engine");
+          b(this, "gs");
+          this.canvas = e, this.option = n, this.events = o;
+          try {
+            this.engine = new Z(this.canvas, !0, {}, !1), this.engine.loadingScreen = new U(""), window.addEventListener("resize", () => {
+              this.engine.resize();
+            }), this.scene = this.createScene();
+          } catch {
+          }
+        }
+        createScene() {
+          return this.engine.displayLoadingUI(), this.scene = new j(this.engine), this.option.scene.colorShow ? this.scene.clearColor = D(this.option.scene.color, new v(0, 0, 0, 0)) : this.scene.clearColor = new v(0, 0, 0, 0), this.scene.fogEnabled = this.option.scene.fogEnabled, this.scene.fogMode = this.option.scene.fogMode || 1, this.scene.fogColor = T(this.option.scene.fogColor, new _(1, 1, 1)), this.scene.fogEnd = this.option.scene.fogEnd || 60, this.scene.fogStart = this.option.scene.fogStart || 1, this.scene.fogDensity = this.option.scene.fogDensity || 0.1, this.createCamera(this.option.camera, this.scene), this.gs = new H("", null, this.scene), this.gs.loadFileAsync(this.option.meshs.url).then(() => {
+            this.setGSSize(this.option.meshs), setTimeout(() => {
+              this.engine.hideLoadingUI();
+            }, 100);
+          }), this.scene;
+        }
+        setGSSize(e) {
+          if (e.autoSize) {
+            const o = this.gs.getBoundingInfo().boundingBox, f = 0.7 / (Math.max(
+              o.maximumWorld.x - o.minimumWorld.x,
+              o.maximumWorld.y - o.minimumWorld.y,
+              o.maximumWorld.z - o.minimumWorld.z
+            ) || 1);
+            this.gs.scaling = new m(f, f, f);
+            const W = o.centerWorld;
+            this.gs.position = this.gs.position.subtract(W.multiplyByFloats(f, f, f)), this.gs.rotation = new m(0, 0, 0);
+          } else {
+            const { position: n, scaling: o, rotation: p } = e;
+            this.gs.position.set(n[0] || 0, n[1] || 0, n[2] || 0), this.gs.scaling.set(o[0] || 1, o[1] || 1, o[2] || 1), this.gs.rotation = new m(p[0] || 0, p[1] || 0, p[2] || 0);
+          }
+        }
+        updateScene(e) {
+          e.colorShow ? this.scene.clearColor = D(e.color, new v(1, 1, 1, 1)) : this.scene.clearColor = new v(0, 0, 0, 0), this.scene.fogEnabled = e.fogEnabled, this.scene.fogMode = e.fogMode || 1, this.scene.fogColor = T(e.fogColor, new _(1, 1, 1)), this.scene.fogEnd = e.fogEnd || 60, this.scene.fogStart = e.fogStart || 1, this.scene.fogDensity = e.fogDensity || 0.1;
+        }
+        createCamera(e, n) {
+          const o = new J("", w.ToRadians(e.alpha || 90), w.ToRadians(e.beta || 75), e.radius || 1, new m(...e.target), n);
+          o.attachControl(d.value, !0), o.useAutoRotationBehavior = e.autoRotation, o.wheelDeltaPercentage = e.wheelDeltaPercentage || 0.01, o.zoomToMouseLocation = e.zoomToMouseLocation, o.lowerRadiusLimit = e.lowerRadiusLimit, o.upperRadiusLimit = e.upperRadiusLimit, o.minZ = 0.01;
+        }
+        updateCamera(e) {
+          const n = this.scene.activeCamera;
+          n && (e.radius && (n.radius = e.radius), n.beta = w.ToRadians(e.beta), n.alpha = w.ToRadians(e.alpha), n.useAutoRotationBehavior = e.autoRotation, n.zoomToMouseLocation = e.zoomToMouseLocation, n.wheelDeltaPercentage = e.wheelDeltaPercentage || 0.01, n.lowerRadiusLimit = e.lowerRadiusLimit, n.upperRadiusLimit = e.upperRadiusLimit, n.target = new m(...e.target));
+        }
+        run() {
+          return this.engine.runRenderLoop(() => {
+            this.scene.render();
+          }), this;
+        }
+        dispose() {
+          this.scene && this.engine && (this.scene.dispose(), this.engine.dispose(), this.gs.dispose(), this.gs = null);
+        }
+      }
+      const g = y();
+      return F(() => {
+        s.meshs && (g.value = new L(d.value, s, a).run(), q(d.value, (z) => {
+          g.value && g.value.engine.resize();
+        }));
+      }), N(() => {
+        g.value && g.value.dispose();
+      }), {
+        canvasRef: d,
+        babylon: g,
+        Babylon: L,
+        babylonLoadingStatus: S
+      };
+    }, { babylon: t, Babylon: I, canvasRef: C, babylonLoadingStatus: R } = h(i.basicOption, i.basicEvents);
+    return r(() => u(i.basicOption.scene), (s, a) => {
+      !c(s, a) && t.value && t.value.updateScene(s);
+    }, {
+      deep: !0
+    }), r(() => u(i.basicOption.meshs.url), (s, a) => {
+      !c(s, a) && t.value && (t.value.dispose(), t.value = new I(C.value, i.basicOption, i.basicEvents).run());
+    }, {
+      deep: !0
+    }), r(() => u(i.basicOption.meshs.position), (s, a) => {
+      !c(s, a) && t.value && t.value.gs && t.value.gs.position.set(s[0], s[1], s[2]);
+    }, {
+      deep: !0
+    }), r(() => u(i.basicOption.meshs.scaling), (s, a) => {
+      !c(s, a) && t.value && t.value.gs && t.value.gs.scaling.set(s[0], s[1], s[2]);
+    }, {
+      deep: !0
+    }), r(() => u(i.basicOption.meshs.rotation), (s, a) => {
+      !c(s, a) && t.value && t.value.gs && (t.value.gs.rotation = new m(s[0], s[1], s[2]));
+    }, {
+      deep: !0
+    }), r(() => u(i.basicOption.meshs.autoSize), (s, a) => {
+      !c(s, a) && t.value && t.value.gs && t.value.setGSSize(i.basicOption.meshs);
+    }, {
+      deep: !0
+    }), r(() => u(i.basicOption.camera), (s, a) => {
+      !c(s, a) && t.value && t.value.updateCamera(s);
+    }, {
+      deep: !0
+    }), (s, a) => (E(), x("div", K, [
+      G("canvas", {
+        ref_key: "canvasRef",
+        ref: C,
+        class: P(["widget", { show: !B(R) }])
+      }, null, 2),
+      B(R) ? (E(), x("div", Q, " 正在加载模型... ", 512)) : V("", !0)
+    ]));
+  }
+});
+export {
+  ne as default
+};