@ifc-lite/viewer 1.17.3 → 1.17.6

package/dist/assets/native-bridge-DUyLCMZS.js

@@ -0,0 +1,429 @@
+import { _ as $, __tla as __tla_0 } from "./exporters-CcPS9MK5.js";
+import "./bcf-DOG9_WPX.js";
+import "./zip-DBEtpeu6.js";
+import "./cesium-DUOzBlqv.js";
+import "./arrow-CZ5kQ26f.js";
+let K;
+let __tla = Promise.all([
+    (()=>{
+        try {
+            return __tla_0;
+        } catch  {}
+    })()
+]).then(async ()=>{
+    function W(t) {
+        if (t instanceof ArrayBuffer) return t;
+        if (t instanceof Uint8Array) return t.byteOffset === 0 && t.byteLength === t.buffer.byteLength && t.buffer instanceof ArrayBuffer ? t.buffer : t.slice().buffer;
+        if (Array.isArray(t)) return Uint8Array.from(t).buffer;
+        throw new Error(`Unsupported packed geometry shard payload: ${typeof t}`);
+    }
+    function P(t, i, r) {
+        const o = W(t), s = new Uint32Array(o, 0, 8), [c, a, n, m, d, p, y, e] = s;
+        if (c !== 1229341506) throw new Error("Invalid packed geometry cache shard magic");
+        if (a !== 1) throw new Error(`Unsupported packed geometry cache shard version: ${a}`);
+        const l = 11, h = 8, T = n * l, g = (h + T) * Uint32Array.BYTES_PER_ELEMENT, M = m * Float32Array.BYTES_PER_ELEMENT, L = d * Float32Array.BYTES_PER_ELEMENT, E = g, _ = E + M, I = _ + L, N = new Float32Array(o, E, m), U = new Float32Array(o, _, d), x = new Uint32Array(o, I, p), f = new DataView(o, h * Uint32Array.BYTES_PER_ELEMENT, T * Uint32Array.BYTES_PER_ELEMENT), C = [];
+        for(let w = 0; w < n; w += 1){
+            const u = w * l * Uint32Array.BYTES_PER_ELEMENT, D = f.getUint32(u, !0), v = f.getUint32(u + 4, !0), O = f.getUint32(u + 8, !0), S = f.getUint32(u + 12, !0), V = f.getUint32(u + 16, !0), A = f.getUint32(u + 20, !0), F = f.getUint32(u + 24, !0), z = [
+                f.getFloat32(u + 28, !0),
+                f.getFloat32(u + 32, !0),
+                f.getFloat32(u + 36, !0),
+                f.getFloat32(u + 40, !0)
+            ];
+            C.push({
+                expressId: D,
+                positions: N.subarray(v, v + O),
+                normals: U.subarray(S, S + V),
+                indices: x.subarray(A, A + F),
+                color: z
+            });
+        }
+        return {
+            meshes: C,
+            progress: {
+                processed: y,
+                total: e,
+                currentType: "cached"
+            },
+            nativeTelemetry: {
+                batchSequence: r,
+                payloadKind: "packed-cache-shard",
+                meshCount: n,
+                positionsLen: m,
+                normalsLen: d,
+                indicesLen: p,
+                chunkReadyTimeMs: 0,
+                packTimeMs: 0,
+                emitTimeMs: 0,
+                emittedTimeMs: 0,
+                jsReceivedTimeMs: i
+            }
+        };
+    }
+    function k(t) {
+        return {
+            expressId: t.expressId,
+            ifcType: t.ifcType,
+            positions: new Float32Array(t.positions),
+            normals: new Float32Array(t.normals),
+            indices: new Uint32Array(t.indices),
+            color: t.color
+        };
+    }
+    function Y(t) {
+        const i = Float32Array.from(t.positions), r = Float32Array.from(t.normals), o = Uint32Array.from(t.indices);
+        return t.meshes.map((s)=>({
+                expressId: s.expressId,
+                ifcType: s.ifcType,
+                positions: i.subarray(s.positionsOffset, s.positionsOffset + s.positionsLen),
+                normals: r.subarray(s.normalsOffset, s.normalsOffset + s.normalsLen),
+                indices: o.subarray(s.indicesOffset, s.indicesOffset + s.indicesLen),
+                color: s.color
+            }));
+    }
+    function b(t, i) {
+        if (t) return {
+            batchSequence: t.batchSequence,
+            payloadKind: t.payloadKind,
+            meshCount: t.meshCount,
+            positionsLen: t.positionsLen,
+            normalsLen: t.normalsLen,
+            indicesLen: t.indicesLen,
+            chunkReadyTimeMs: t.chunkReadyTimeMs,
+            packTimeMs: t.packTimeMs,
+            emitTimeMs: t.emitTimeMs,
+            emittedTimeMs: t.emittedTimeMs,
+            jsReceivedTimeMs: i
+        };
+    }
+    function R(t) {
+        return {
+            originShift: t.originShift,
+            originalBounds: t.originalBounds,
+            shiftedBounds: t.shiftedBounds,
+            hasLargeCoordinates: t.hasLargeCoordinates
+        };
+    }
+    const G = 4, q = 8192, X = 10;
+    function B() {
+        const t = globalThis.scheduler;
+        return typeof t?.yield == "function" ? t.yield() : new Promise((i)=>{
+            const r = new MessageChannel;
+            r.port1.onmessage = ()=>i(), r.port2.postMessage(null);
+        });
+    }
+    K = class {
+        initialized = !1;
+        invoke = null;
+        listen = null;
+        async init() {
+            if (this.initialized) return;
+            const i = globalThis;
+            if (!i.__TAURI_INTERNALS__?.invoke) throw new Error("Tauri API not available - this bridge should only be used in Tauri apps");
+            this.invoke = i.__TAURI_INTERNALS__.invoke;
+            try {
+                const r = await $(()=>import("./event-DIOks52T.js"), []);
+                this.listen = r.listen;
+            } catch  {
+                console.warn("[NativeBridge] Event API not available, streaming will be limited");
+            }
+            this.initialized = !0;
+        }
+        isInitialized() {
+            return this.initialized;
+        }
+        toNativeBuffer(i) {
+            if (i instanceof Uint8Array) return Array.from(i);
+            const r = new TextEncoder;
+            return Array.from(r.encode(i));
+        }
+        async drainDeferredBatches(i, r, o) {
+            let s = 0, c = 0, a = performance.now();
+            for(; i.length > 0;){
+                const n = i.shift(), m = n.type === "mesh-array" ? {
+                    meshes: n.meshes.map(k),
+                    progress: {
+                        processed: n.progress.processed,
+                        total: n.progress.total,
+                        currentType: n.progress.currentType
+                    },
+                    nativeTelemetry: b(n.telemetry, performance.now() - o)
+                } : {
+                    meshes: Y(n.payload),
+                    progress: {
+                        processed: n.payload.progress.processed,
+                        total: n.payload.progress.total,
+                        currentType: n.payload.progress.currentType
+                    },
+                    nativeTelemetry: b(n.payload.telemetry, performance.now() - o)
+                };
+                r.onBatch?.(m), s += 1, c += m.meshes.length, i.length > 0 && (s >= G || c >= q || performance.now() - a >= X) && (await B(), s = 0, c = 0, a = performance.now());
+            }
+        }
+        async processEventDrivenNativeStream(i, r, o, s) {
+            if (!this.listen) throw new Error(`Event API unavailable, ${i} requires Tauri event support`);
+            const c = [];
+            let a = null, n = null;
+            const m = ()=>{
+                a || (a = (async ()=>{
+                    try {
+                        await this.drainDeferredBatches(c, o, s);
+                    } catch (e) {
+                        n = e instanceof Error ? e : new Error(String(e));
+                    } finally{
+                        a = null, c.length > 0 && !n && m();
+                    }
+                })());
+            }, d = await this.listen("geometry-batch", (e)=>{
+                c.push({
+                    type: "mesh-array",
+                    meshes: e.payload.meshes,
+                    progress: e.payload.progress,
+                    telemetry: e.payload.telemetry
+                }), m();
+            }), p = await this.listen("geometry-packed-batch", (e)=>{
+                c.push({
+                    type: "packed",
+                    payload: e.payload
+                }), m();
+            }), y = await this.listen("geometry-color-update", (e)=>{
+                const l = new Map;
+                for (const h of e.payload.updates)l.set(h.expressId, h.color);
+                l.size > 0 && o.onColorUpdate?.(l);
+            });
+            try {
+                const e = await this.invoke(i, r), l = {
+                    totalMeshes: e.totalMeshes,
+                    totalVertices: e.totalVertices,
+                    totalTriangles: e.totalTriangles,
+                    parseTimeMs: e.parseTimeMs,
+                    entityScanTimeMs: e.entityScanTimeMs,
+                    lookupTimeMs: e.lookupTimeMs,
+                    preprocessTimeMs: e.preprocessTimeMs,
+                    geometryTimeMs: e.geometryTimeMs,
+                    totalTimeMs: e.totalTimeMs,
+                    firstChunkReadyTimeMs: e.firstChunkReadyTimeMs,
+                    firstChunkPackTimeMs: e.firstChunkPackTimeMs,
+                    firstChunkEmittedTimeMs: e.firstChunkEmittedTimeMs,
+                    firstChunkEmitTimeMs: e.firstChunkEmitTimeMs
+                };
+                for(; a;)await a;
+                if (n) throw n;
+                return l;
+            } finally{
+                d(), p(), y();
+            }
+        }
+        async processGeometry(i) {
+            (!this.initialized || !this.invoke) && await this.init();
+            const r = this.toNativeBuffer(i), o = await this.invoke("get_geometry", {
+                buffer: r
+            }), s = o.meshes.map(k), c = R(o.coordinateInfo);
+            return {
+                meshes: s,
+                totalVertices: o.totalVertices,
+                totalTriangles: o.totalTriangles,
+                coordinateInfo: c
+            };
+        }
+        async processGeometryPath(i) {
+            (!this.initialized || !this.invoke) && await this.init();
+            const r = await this.invoke("get_geometry_from_path", {
+                path: i
+            });
+            return {
+                meshes: r.meshes.map(k),
+                totalVertices: r.totalVertices,
+                totalTriangles: r.totalTriangles,
+                coordinateInfo: R(r.coordinateInfo)
+            };
+        }
+        async processGeometryStreaming(i, r) {
+            if ((!this.initialized || !this.invoke) && await this.init(), !this.listen) {
+                console.warn("[NativeBridge] Event API unavailable, falling back to non-streaming mode");
+                const e = await this.processGeometry(i), l = {
+                    totalMeshes: e.meshes.length,
+                    totalVertices: e.totalVertices,
+                    totalTriangles: e.totalTriangles,
+                    parseTimeMs: 0,
+                    entityScanTimeMs: 0,
+                    lookupTimeMs: 0,
+                    preprocessTimeMs: 0,
+                    geometryTimeMs: 0,
+                    totalTimeMs: 0,
+                    firstChunkReadyTimeMs: 0,
+                    firstChunkPackTimeMs: 0,
+                    firstChunkEmittedTimeMs: 0,
+                    firstChunkEmitTimeMs: 0
+                };
+                return r.onBatch?.({
+                    meshes: e.meshes,
+                    progress: {
+                        processed: e.meshes.length,
+                        total: e.meshes.length,
+                        currentType: "complete"
+                    }
+                }), r.onComplete?.(l), l;
+            }
+            const o = this.toNativeBuffer(i), s = performance.now(), c = [];
+            let a = null, n = null;
+            const m = ()=>{
+                a || (a = (async ()=>{
+                    try {
+                        await this.drainDeferredBatches(c, r, s);
+                    } catch (e) {
+                        n = e instanceof Error ? e : new Error(String(e));
+                    } finally{
+                        a = null, c.length > 0 && !n && m();
+                    }
+                })());
+            }, d = await this.listen("geometry-batch", (e)=>{
+                c.push({
+                    type: "mesh-array",
+                    meshes: e.payload.meshes,
+                    progress: e.payload.progress,
+                    telemetry: e.payload.telemetry
+                }), m();
+            }), p = await this.listen("geometry-packed-batch", (e)=>{
+                c.push({
+                    type: "packed",
+                    payload: e.payload
+                }), m();
+            }), y = await this.listen("geometry-color-update", (e)=>{
+                const l = new Map;
+                for (const h of e.payload.updates)l.set(h.expressId, h.color);
+                l.size > 0 && r.onColorUpdate?.(l);
+            });
+            try {
+                const e = await this.invoke("get_geometry_streaming", {
+                    buffer: o
+                }), l = {
+                    totalMeshes: e.totalMeshes,
+                    totalVertices: e.totalVertices,
+                    totalTriangles: e.totalTriangles,
+                    parseTimeMs: e.parseTimeMs,
+                    entityScanTimeMs: e.entityScanTimeMs,
+                    lookupTimeMs: e.lookupTimeMs,
+                    preprocessTimeMs: e.preprocessTimeMs,
+                    geometryTimeMs: e.geometryTimeMs,
+                    totalTimeMs: e.totalTimeMs,
+                    firstChunkReadyTimeMs: e.firstChunkReadyTimeMs,
+                    firstChunkPackTimeMs: e.firstChunkPackTimeMs,
+                    firstChunkEmittedTimeMs: e.firstChunkEmittedTimeMs,
+                    firstChunkEmitTimeMs: e.firstChunkEmitTimeMs
+                };
+                for(; a;)await a;
+                if (n) throw n;
+                return r.onComplete?.(l), l;
+            } catch (e) {
+                throw r.onError?.(e instanceof Error ? e : new Error(String(e))), e;
+            } finally{
+                d(), p(), y();
+            }
+        }
+        async processGeometryStreamingPath(i, r, o) {
+            (!this.initialized || !this.invoke) && await this.init();
+            const s = performance.now();
+            if (!o) throw new Error("Packed shard path streaming requires a cache key");
+            return this.processPackedShardPathStream(i, o, r, s);
+        }
+        async processGeometryStreamingCache(i, r) {
+            (!this.initialized || !this.invoke) && await this.init();
+            const o = performance.now();
+            try {
+                const s = await this.invoke("get_native_geometry_cache_manifest", {
+                    cacheKey: i
+                });
+                if (!s) throw new Error(`Native geometry cache manifest missing for ${i}`);
+                let c = 0;
+                for(let n = 0; n < s.shardCount; n += 1){
+                    const m = await this.invoke("get_native_geometry_cache_packed_shard", {
+                        cacheKey: i,
+                        shardIndex: n
+                    }), d = P(m, performance.now() - o, n + 1);
+                    c = d.progress.processed, r.onBatch?.(d), n + 1 < s.shardCount && await B();
+                }
+                const a = {
+                    totalMeshes: s.totalMeshes,
+                    totalVertices: s.totalVertices,
+                    totalTriangles: s.totalTriangles,
+                    parseTimeMs: 0,
+                    entityScanTimeMs: 0,
+                    lookupTimeMs: 0,
+                    preprocessTimeMs: 0,
+                    geometryTimeMs: Math.round(performance.now() - o),
+                    totalTimeMs: Math.round(performance.now() - o),
+                    firstChunkReadyTimeMs: 0,
+                    firstChunkPackTimeMs: 0,
+                    firstChunkEmittedTimeMs: 0,
+                    firstChunkEmitTimeMs: 0
+                };
+                return c !== s.totalMeshes && console.warn(`[NativeBridge] Cached packed shard stream mesh mismatch for ${i}: received=${c} expected=${s.totalMeshes}`), r.onComplete?.(a), a;
+            } catch (s) {
+                throw r.onError?.(s instanceof Error ? s : new Error(String(s))), s;
+            }
+        }
+        async processPackedShardPathStream(i, r, o, s) {
+            const c = this.invoke("get_geometry_streaming_from_path", {
+                path: i,
+                cacheKey: r,
+                preferPackedShards: !0
+            });
+            let a = 0, n = performance.now(), m = 0, d = null;
+            const p = this.listen ? await this.listen("native-shard-ready", ()=>{
+                if (d) {
+                    const h = d;
+                    d = null, h();
+                }
+            }) : null;
+            function y(h) {
+                return new Promise((T)=>{
+                    const g = setTimeout(T, h);
+                    d = ()=>{
+                        clearTimeout(g), T();
+                    };
+                });
+            }
+            try {
+                for(;;){
+                    const h = await this.invoke("get_native_geometry_cache_stream_status", {
+                        cacheKey: r
+                    });
+                    if (h?.failed) throw new Error(h.errorMessage ?? `Packed shard stream failed for ${r}`);
+                    const T = h?.readyShardCount ?? 0;
+                    for(; a < T;){
+                        const g = await this.invoke("get_native_geometry_cache_packed_shard", {
+                            cacheKey: r,
+                            shardIndex: a
+                        }), M = P(g, performance.now() - s, a + 1);
+                        m = Math.max(m, M.progress.processed), n = performance.now(), o.onBatch?.(M), a += 1;
+                    }
+                    if (h?.done && a >= T) break;
+                    if (performance.now() - n > 6e4) throw new Error(`Packed shard path stream stalled for ${r}: shards=${a}/${T} processed=${m}`);
+                    await y(50);
+                }
+            } finally{
+                p && p();
+            }
+            const e = await c, l = {
+                totalMeshes: e.totalMeshes,
+                totalVertices: e.totalVertices,
+                totalTriangles: e.totalTriangles,
+                parseTimeMs: e.parseTimeMs,
+                entityScanTimeMs: e.entityScanTimeMs,
+                lookupTimeMs: e.lookupTimeMs,
+                preprocessTimeMs: e.preprocessTimeMs,
+                geometryTimeMs: e.geometryTimeMs,
+                totalTimeMs: e.totalTimeMs,
+                firstChunkReadyTimeMs: e.firstChunkReadyTimeMs,
+                firstChunkPackTimeMs: e.firstChunkPackTimeMs,
+                firstChunkEmittedTimeMs: e.firstChunkEmittedTimeMs,
+                firstChunkEmitTimeMs: e.firstChunkEmitTimeMs
+            };
+            return o.onComplete?.(l), l;
+        }
+        getApi() {
+            return null;
+        }
+    };
+});
+export { K as NativeBridge, __tla };