@ioai/robot_viewer 0.0.0-stage → 1.1.1

package/dist/usd-viewer/bindings/emHdBindings.worker.js

@@ -0,0 +1,124 @@
+"use strict";
+var Module = {};
+var ENVIRONMENT_IS_NODE =
+  typeof process == "object" &&
+  typeof process.versions == "object" &&
+  typeof process.versions.node == "string";
+if (ENVIRONMENT_IS_NODE) {
+  var nodeWorkerThreads = require("worker_threads");
+  var parentPort = nodeWorkerThreads.parentPort;
+  parentPort.on("message", (data) => onmessage({ data: data }));
+  var fs = require("fs");
+  Object.assign(global, {
+    self: global,
+    require: require,
+    Module: Module,
+    location: { href: __filename },
+    Worker: nodeWorkerThreads.Worker,
+    importScripts: (f) =>
+      (0, eval)(fs.readFileSync(f, "utf8") + "//# sourceURL=" + f),
+    postMessage: (msg) => parentPort.postMessage(msg),
+    performance: global.performance || { now: Date.now },
+  });
+}
+var initializedJS = false;
+function threadPrintErr() {
+  var text = Array.prototype.slice.call(arguments).join(" ");
+  if (ENVIRONMENT_IS_NODE) {
+    fs.writeSync(2, text + "\n");
+    return;
+  }
+  console.error(text);
+}
+function threadAlert() {
+  var text = Array.prototype.slice.call(arguments).join(" ");
+  postMessage({
+    cmd: "alert",
+    text: text,
+    threadId: Module["_pthread_self"](),
+  });
+}
+var err = threadPrintErr;
+self.alert = threadAlert;
+Module["instantiateWasm"] = (info, receiveInstance) => {
+  var module = Module["wasmModule"];
+  Module["wasmModule"] = null;
+  var instance = new WebAssembly.Instance(module, info);
+  return receiveInstance(instance);
+};
+self.onunhandledrejection = (e) => {
+  throw e.reason || e;
+};
+function handleMessage(e) {
+  try {
+    if (e.data.cmd === "load") {
+      let messageQueue = [];
+      self.onmessage = (e) => messageQueue.push(e);
+      // self.addEventListener("message", e => console.log("\x1B[1;mworker received message: " + e.data.cmd + "\x1B[0m"));
+      self.startWorker = (instance) => {
+        Module = instance;
+        postMessage({ cmd: "loaded" });
+        for (let msg of messageQueue) {
+          handleMessage(msg);
+        }
+        self.onmessage = handleMessage;
+      };
+      Module["wasmModule"] = e.data.wasmModule;
+      for (const handler of e.data.handlers) {
+        Module[handler] = (...args) => {
+          postMessage({ cmd: "callHandler", handler: handler, args: args });
+        };
+      }
+      Module["wasmMemory"] = e.data.wasmMemory;
+      Module["buffer"] = Module["wasmMemory"].buffer;
+      Module["ENVIRONMENT_IS_PTHREAD"] = true;
+      if (typeof e.data.urlOrBlob == "string") {
+        importScripts(e.data.urlOrBlob);
+      } else {
+        var objectUrl = URL.createObjectURL(e.data.urlOrBlob);
+        importScripts(objectUrl);
+        URL.revokeObjectURL(objectUrl);
+      }
+      getUsdModule(Module);
+    } else if (e.data.cmd === "run") {
+      Module["__emscripten_thread_init"](e.data.pthread_ptr, 0, 0, 1);
+      Module["__emscripten_thread_mailbox_await"](e.data.pthread_ptr);
+      Module["establishStackSpace"]();
+      Module["PThread"].receiveObjectTransfer(e.data);
+      Module["PThread"].threadInitTLS();
+      if (!initializedJS) {
+        Module["__embind_initialize_bindings"]();
+        initializedJS = true;
+      }
+      try {
+        Module["invokeEntryPoint"](e.data.start_routine, e.data.arg);
+      } catch (ex) {
+        if (ex != "unwind") {
+          throw ex;
+        }
+      }
+    } else if (e.data.cmd === "cancel") {
+      if (Module["_pthread_self"]()) {
+        Module["__emscripten_thread_exit"](-1);
+      }
+    } else if (e.data.target === "setimmediate") {
+    } else if (e.data.cmd === "checkMailbox") {
+      if (initializedJS) {
+        Module["checkMailbox"]();
+      }
+    } 
+    else if (e.data.cmd === "callHandlerAsyncResult") {
+      // ignore, handled elsewhere
+    }
+    else if (e.data.cmd) {
+      err(`worker.js received unknown command ${e.data.cmd}`);
+      err(e.data);
+    }
+  } catch (ex) {
+    if (Module["__emscripten_thread_crashed"]) {
+      Module["__emscripten_thread_crashed"]();
+    }
+    throw ex;
+  }
+}
+self.onmessage = handleMessage;

package/dist/usd-viewer/error-handler.js

@@ -0,0 +1,57 @@
+// USD Viewer error handler wrapper
+// Capture and forward all errors to parent window
+
+(function() {
+    console.log('[USD Error Handler] Error handler loaded');
+
+    // Capture all errors
+    window.addEventListener('error', (event) => {
+        console.error('[USD Error Handler] Error captured:', event.error || event.message);
+        try {
+            parent.postMessage({
+                type: 'USD_ERROR',
+                error: event.error?.message || event.message || 'Unknown error'
+            }, '*');
+        } catch (e) {
+            console.error('[USD Error Handler] Failed to send error message:', e);
+        }
+    }, true);
+
+    // Capture Promise rejections
+    window.addEventListener('unhandledrejection', (event) => {
+        console.error('[USD Error Handler] Promise rejection:', event.reason);
+        try {
+            parent.postMessage({
+                type: 'USD_ERROR',
+                error: event.reason?.message || String(event.reason) || 'Promise rejection'
+            }, '*');
+        } catch (e) {
+            console.error('[USD Error Handler] Failed to send error message:', e);
+        }
+    });
+
+    // Wrap original message handler, add error handling
+    const originalAddEventListener = window.addEventListener;
+    window.addEventListener = function(type, listener, ...args) {
+        if (type === 'message') {
+            const wrappedListener = async function(event) {
+                try {
+                    await listener.call(this, event);
+                } catch (e) {
+                    console.error('[USD Error Handler] Message handler error:', e);
+                    try {
+                        parent.postMessage({
+                            type: 'USD_ERROR',
+                            error: e.message || 'Message processing failed'
+                        }, '*');
+                    } catch (err) {
+                        console.error('[USD Error Handler] Failed to send error message:', err);
+                    }
+                }
+            };
+            return originalAddEventListener.call(this, type, wrappedListener, ...args);
+        }
+        return originalAddEventListener.call(this, type, listener, ...args);
+    };
+})();
+