webr-serviceworker.js

"use strict";
(() => {
  var __create = Object.create;
  var __defProp = Object.defineProperty;
  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
  var __getOwnPropNames = Object.getOwnPropertyNames;
  var __getProtoOf = Object.getPrototypeOf;
  var __hasOwnProp = Object.prototype.hasOwnProperty;
  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
  }) : x)(function(x) {
    if (typeof require !== "undefined")
      return require.apply(this, arguments);
    throw new Error('Dynamic require of "' + x + '" is not supported');
  });
  var __copyProps = (to, from, except, desc) => {
    if (from && typeof from === "object" || typeof from === "function") {
      for (let key of __getOwnPropNames(from))
        if (!__hasOwnProp.call(to, key) && key !== except)
          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
    }
    return to;
  };
  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
    mod
  ));

  // webR/compat.ts
  var IN_NODE = typeof process !== "undefined" && process.release && process.release.name === "node";
  var loadScript;
  if (globalThis.document) {
    loadScript = (url) => new Promise((resolve, reject) => {
      const script = document.createElement("script");
      script.src = url;
      script.onload = () => resolve();
      script.onerror = reject;
      document.head.appendChild(script);
    });
  } else if (globalThis.importScripts) {
    loadScript = async (url) => {
      try {
        globalThis.importScripts(url);
      } catch (e) {
        if (e instanceof TypeError) {
          await Promise.resolve().then(() => __toESM(__require(url)));
        } else {
          throw e;
        }
      }
    };
  } else if (IN_NODE) {
    loadScript = async (url) => {
      const nodePathMod = (await Promise.resolve().then(() => __toESM(__require("path")))).default;
      await Promise.resolve().then(() => __toESM(__require(nodePathMod.resolve(url))));
    };
  } else {
    throw new Error("Cannot determine runtime environment");
  }

  // webR/utils.ts
  function promiseHandles() {
    const out = {
      resolve: (_value) => {
      },
      reject: (_reason) => {
      },
      promise: null
    };
    const promise = new Promise((resolve, reject) => {
      out.resolve = resolve;
      out.reject = reject;
    });
    out.promise = promise;
    return out;
  }

  // webR/chan/message.ts
  var encoder = new TextEncoder();
  var decoder = new TextDecoder("utf-8");
  function encodeData(data) {
    return encoder.encode(JSON.stringify(data));
  }
  function decodeData(data) {
    return JSON.parse(decoder.decode(data));
  }

  // webR/chan/serviceworker.ts
  var requests = {};
  function handleInstall() {
    console.log("webR service worker installed");
    self.skipWaiting();
  }
  function handleActivate(event) {
    console.log("webR service worker activating");
    event.waitUntil(self.clients.claim());
  }
  var sendRequest = async (clientId, uuid) => {
    const client = await self.clients.get(clientId);
    if (!client) {
      throw new Error("Service worker client not found");
    }
    if (!(uuid in requests)) {
      requests[uuid] = promiseHandles();
      client.postMessage({ type: "request", data: uuid });
    }
    const response = await requests[uuid].promise;
    const headers = { "Cross-Origin-Embedder-Policy": "require-corp" };
    return new Response(encodeData(response), { headers });
  };
  var handleFetch = (event) => {
    const wasmMatch = /__wasm__\/webr-fetch-request\//.exec(event.request.url);
    if (!wasmMatch) {
      return;
    }
    const requestBody = event.request.arrayBuffer();
    const requestReponse = requestBody.then(async (body) => {
      const data = decodeData(new Uint8Array(body));
      return await sendRequest(data.clientId, data.uuid);
    });
    event.waitUntil(requestReponse);
    event.respondWith(requestReponse);
  };
  function handleMessage(event) {
    switch (event.data.type) {
      case "register-client-main": {
        self.clients.claim();
        const source = event.source;
        self.clients.get(source.id).then((client) => {
          if (!client) {
            throw new Error("Can't respond to client in service worker message handler");
          }
          client.postMessage({
            type: "registration-successful",
            clientId: source.id
          });
        });
        break;
      }
      case "wasm-webr-fetch-response": {
        if (event.data.uuid in requests) {
          requests[event.data.uuid].resolve(event.data.response);
          delete requests[event.data.uuid];
        }
        break;
      }
      default:
        throw new Error(`Unknown service worker message type: ${event.data.type}`);
    }
  }
  self.addEventListener("install", handleInstall);
  self.addEventListener("activate", handleActivate);
  self.addEventListener("fetch", handleFetch);
  self.addEventListener("message", handleMessage);
})();
//# sourceMappingURL=webr-serviceworker.js.map