@mtcute/web 0.17.0 → 0.18.0

package/worker.js

@@ -0,0 +1,111 @@
+import { TelegramWorker as TelegramWorker$1, TelegramWorkerPort as TelegramWorkerPort$1 } from "@mtcute/core/worker.js";
+import { WebPlatform } from "./platform.js";
+let _registered = false;
+class TelegramWorker extends TelegramWorker$1 {
+  registerWorker(handler) {
+    if (_registered) {
+      throw new Error("TelegramWorker must be created only once");
+    }
+    _registered = true;
+    if (typeof SharedWorkerGlobalScope !== "undefined" && self instanceof SharedWorkerGlobalScope) {
+      const connections = [];
+      const broadcast = (message) => {
+        for (const port of connections) {
+          port.postMessage(message);
+        }
+      };
+      self.onconnect = (event) => {
+        const port = event.ports[0];
+        connections.push(port);
+        const respond = port.postMessage.bind(port);
+        const onClose = () => {
+          port.close();
+          const idx = connections.indexOf(port);
+          if (idx >= 0) {
+            connections.splice(connections.indexOf(port), 1);
+          }
+        };
+        const onTimeout = () => {
+          console.warn("some connection timed out!");
+          respond({ __type__: "timeout" });
+          onClose();
+        };
+        let timeout = setTimeout(onTimeout, 6e4);
+        port.addEventListener("message", (message) => {
+          if (message.data.__type__ === "close") {
+            onClose();
+            return;
+          }
+          if (message.data.__type__ === "ping") {
+            clearTimeout(timeout);
+            timeout = setTimeout(onTimeout, 6e4);
+            return;
+          }
+          handler(message.data, respond);
+        });
+        port.start();
+      };
+      return broadcast;
+    }
+    if (typeof WorkerGlobalScope !== "undefined" && self instanceof WorkerGlobalScope) {
+      const respond = self.postMessage.bind(self);
+      self.addEventListener("message", (message) => handler(message.data, respond));
+      return respond;
+    }
+    throw new Error("TelegramWorker must be created from a worker");
+  }
+}
+const platform = /* @__PURE__ */ new WebPlatform();
+class TelegramWorkerPort extends TelegramWorkerPort$1 {
+  constructor(options) {
+    super({
+      worker: options.worker,
+      platform
+    });
+  }
+  connectToWorker(worker, handler) {
+    if (worker instanceof Worker) {
+      const send = worker.postMessage.bind(worker);
+      const messageHandler = (ev) => {
+        handler(ev.data);
+      };
+      worker.addEventListener("message", messageHandler);
+      return [
+        send,
+        () => {
+          worker.removeEventListener("message", messageHandler);
+        }
+      ];
+    }
+    if (worker instanceof SharedWorker) {
+      const send = worker.port.postMessage.bind(worker.port);
+      const pingInterval = setInterval(() => {
+        worker.port.postMessage({ __type__: "ping" });
+      }, 1e4);
+      const messageHandler = (ev) => {
+        if (ev.data.__type__ === "timeout") {
+          location.reload();
+          return;
+        }
+        handler(ev.data);
+      };
+      worker.port.addEventListener("message", messageHandler);
+      worker.port.start();
+      let cancelBeforeExit;
+      const close = () => {
+        clearInterval(pingInterval);
+        worker.port.postMessage({ __type__: "close" });
+        worker.port.removeEventListener("message", messageHandler);
+        worker.port.close();
+        cancelBeforeExit();
+      };
+      cancelBeforeExit = platform.beforeExit(close);
+      return [send, close];
+    }
+    throw new Error("Only workers and shared workers are supported");
+  }
+}
+export {
+  TelegramWorker,
+  TelegramWorkerPort
+};

package/common-internals-web/base64.d.ts

@@ -1,2 +0,0 @@
-export declare function base64Encode(buf: Uint8Array, url?: boolean): string;
-export declare function base64Decode(string: string, url?: boolean): Uint8Array;

package/common-internals-web/hex.d.ts

@@ -1,2 +0,0 @@
-export declare function hexEncode(buf: Uint8Array): string;
-export declare function hexDecode(string: string): Uint8Array;

package/common-internals-web/utf8.d.ts

@@ -1,3 +0,0 @@
-export declare function utf8ByteLength(str: string): number;
-export declare function utf8Decode(buf: Uint8Array): string;
-export declare function utf8Encode(str: string): Uint8Array;