@r-universe/webr 2023.6.21 → 2023.8.26

package/dist/webr-worker.js

@@ -1936,6 +1936,19 @@ var require_XMLHttpRequest = __commonJS({
   }
 });
 
+// webR/error.ts
+var WebRError = class extends Error {
+  constructor(msg) {
+    super(msg);
+    this.name = this.constructor.name;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var WebRWorkerError = class extends WebRError {
+};
+var WebRChannelError = class extends WebRError {
+};
+
 // webR/compat.ts
 var IN_NODE = typeof process !== "undefined" && process.release && process.release.name === "node";
 var loadScript;
@@ -1965,7 +1978,7 @@ if (globalThis.document) {
     await Promise.resolve().then(() => __toESM(require(nodePathMod.resolve(url))));
   };
 } else {
-  throw new Error("Cannot determine runtime environment");
+  throw new WebRError("Cannot determine runtime environment");
 }
 
 // webR/utils.ts
@@ -2025,7 +2038,7 @@ function isCrossOrigin(urlString) {
 function throwUnreachable(context) {
   let msg = "Reached the unreachable";
   msg = msg + (context ? ": " + context : ".");
-  throw new Error(msg);
+  throw new WebRError(msg);
 }
 
 // webR/chan/task-common.ts
@@ -2208,9 +2221,11 @@ function newSyncRequest(msg, data) {
 }
 
 // webR/payload.ts
-function webRPayloadError(payload) {
-  const e = new Error(payload.obj.message);
-  e.name = payload.obj.name;
+function webRPayloadAsError(payload) {
+  const e = new WebRWorkerError(payload.obj.message);
+  if (payload.obj.name !== "Error") {
+    e.name = payload.obj.name;
+  }
   e.stack = payload.obj.stack;
   return e;
 }
@@ -2263,7 +2278,7 @@ var ChannelMain = class {
       const payload = msg.data.resp;
       __privateGet(this, _parked).delete(uuid);
       if (payload.payloadType === "err") {
-        handles.reject(webRPayloadError(payload));
+        handles.reject(webRPayloadAsError(payload));
       } else {
         handles.resolve(payload);
       }
@@ -2500,12 +2515,12 @@ var SharedBufferChannelMain = class extends ChannelMain {
               break;
             }
             default:
-              throw new TypeError(`Unsupported request type '${payload.type}'.`);
+              throw new WebRChannelError(`Unsupported request type '${payload.type}'.`);
           }
           return;
         }
         case "request":
-          throw new TypeError(
+          throw new WebRChannelError(
             "Can't send messages of type 'request' from a worker. Please Use 'sync-request' instead."
           );
       }
@@ -2535,7 +2550,7 @@ var SharedBufferChannelMain = class extends ChannelMain {
   }
   interrupt() {
     if (!__privateGet(this, _interruptBuffer)) {
-      throw new Error("Failed attempt to interrupt before initialising interruptBuffer");
+      throw new WebRChannelError("Failed attempt to interrupt before initialising interruptBuffer");
     }
     this.inputQueue.reset();
     __privateGet(this, _interruptBuffer)[0] = 1;
@@ -2649,7 +2664,7 @@ var ServiceWorkerChannelMain = class extends ChannelMain {
           return;
         }
         case "request":
-          throw new TypeError(
+          throw new WebRChannelError(
             "Can't send messages of type 'request' from a worker.Use service worker fetch request instead."
           );
       }
@@ -2689,7 +2704,7 @@ var ServiceWorkerChannelMain = class extends ChannelMain {
   activeRegistration() {
     var _a;
     if (!((_a = __privateGet(this, _registration)) == null ? void 0 : _a.active)) {
-      throw new Error("Attempted to obtain a non-existent active registration.");
+      throw new WebRChannelError("Attempted to obtain a non-existent active registration.");
     }
     return __privateGet(this, _registration).active;
   }
@@ -2731,7 +2746,7 @@ onMessageFromServiceWorker_fn = async function(event) {
     const uuid = event.data.data;
     const message = __privateGet(this, _syncMessageCache).get(uuid);
     if (!message) {
-      throw new Error("Request not found during service worker XHR request");
+      throw new WebRChannelError("Request not found during service worker XHR request");
     }
     __privateGet(this, _syncMessageCache).delete(uuid);
     switch (message.type) {
@@ -2756,7 +2771,7 @@ onMessageFromServiceWorker_fn = async function(event) {
         break;
       }
       default:
-        throw new TypeError(`Unsupported request type '${message.type}'.`);
+        throw new WebRChannelError(`Unsupported request type '${message.type}'.`);
     }
     return;
   }
@@ -2772,19 +2787,20 @@ handleEventsFromWorker_fn2 = function(worker) {
   }
 };
 _onMessageFromWorker2 = new WeakMap();
-var _ep2, _mainThreadId, _location, _dispatch2, _interrupt2;
+var _ep2, _mainThreadId, _location, _lastInterruptReq, _dispatch2, _interrupt2;
 var ServiceWorkerChannelWorker = class {
   constructor(data) {
     __privateAdd(this, _ep2, void 0);
     __privateAdd(this, _mainThreadId, void 0);
     __privateAdd(this, _location, void 0);
+    __privateAdd(this, _lastInterruptReq, Date.now());
     __privateAdd(this, _dispatch2, () => 0);
     __privateAdd(this, _interrupt2, () => {
     });
     this.onMessageFromMainThread = () => {
     };
     if (!data.clientId || !data.location) {
-      throw Error("Can't start service worker channel");
+      throw new WebRChannelError("Can't start service worker channel");
     }
     __privateSet(this, _mainThreadId, data.clientId);
     __privateSet(this, _location, data.location);
@@ -2845,10 +2861,13 @@ var ServiceWorkerChannelWorker = class {
     __privateSet(this, _interrupt2, interrupt);
   }
   handleInterrupt() {
-    const response = this.syncRequest({ type: "interrupt" });
-    const interrupted = response.data.resp;
-    if (interrupted) {
-      __privateGet(this, _interrupt2).call(this);
+    if (Date.now() > __privateGet(this, _lastInterruptReq) + 1e3) {
+      __privateSet(this, _lastInterruptReq, Date.now());
+      const response = this.syncRequest({ type: "interrupt" });
+      const interrupted = response.data.resp;
+      if (interrupted) {
+        __privateGet(this, _interrupt2).call(this);
+      }
     }
   }
   setDispatchHandler(dispatch2) {
@@ -2858,6 +2877,7 @@ var ServiceWorkerChannelWorker = class {
 _ep2 = new WeakMap();
 _mainThreadId = new WeakMap();
 _location = new WeakMap();
+_lastInterruptReq = new WeakMap();
 _dispatch2 = new WeakMap();
 _interrupt2 = new WeakMap();
 
@@ -2874,7 +2894,7 @@ function newChannelWorker(msg) {
     case ChannelType.ServiceWorker:
       return new ServiceWorkerChannelWorker(msg.data);
     default:
-      throw new Error("Unknown worker channel type recieved");
+      throw new WebRChannelError("Unknown worker channel type recieved");
   }
 }
 
@@ -4456,7 +4476,9 @@ function init(config) {
     if (IN_NODE) {
       globalThis.FS = Module.FS;
     }
-    Module.createLazyFilesystem();
+    if (_config.createLazyFilesystem) {
+      Module.createLazyFilesystem();
+    }
     Module.FS.mkdirTree(_config.homedir);
     Module.ENV.HOME = _config.homedir;
     Module.FS.chdir(_config.homedir);
@@ -4518,9 +4540,6 @@ function init(config) {
   Module.setPrompt = (prompt) => {
     chan == null ? void 0 : chan.write({ type: "prompt", data: prompt });
   };
-  Module.canvasExec = (op) => {
-    chan == null ? void 0 : chan.write({ type: "canvasExec", data: op });
-  };
   globalThis.Module = Module;
   setTimeout(() => {
     const scriptSrc = `${_config.baseUrl}R.bin.js`;