@mtcute/web 0.28.2 → 0.29.0

package/README.md

@@ -31,16 +31,16 @@ You can also use this package with web workers to offload most of the heavy lift
 // worker.ts
 import { BaseTelegramClient, TelegramWorker } from '@mtcute/web'
 
-// main.ts
-import { TelegramClient, TelegramWorkerPort } from '@mtcute/web'
-
 const client = new BaseTelegramClient({
     apiId: 12345,
     apiHash: 'abcdef',
     storage: 'my-account'
 })
 
-new TelegramWorker({ client })
+new TelegramWorker({ client }).mount()
+
+// main.ts
+import { TelegramClient, TelegramWorkerPort } from '@mtcute/web'
 
 const worker = new Worker(new URL('./worker.ts', import.meta.url), { type: 'module' }) // or SharedWorker
 const port = new TelegramWorkerPort({ worker })
@@ -49,3 +49,5 @@ const tg = new TelegramClient({ client: port })
 const self = await tg.start()
 console.log(`✨ logged in as ${user.displayName}`)
 ```
+
+`port.destroy()` only releases that port. Use `port.unsafeForceDestroy()` if you need to tear down the shared worker-side client.

package/package.json

@@ -1,13 +1,14 @@
 {
     "name": "@mtcute/web",
     "type": "module",
-    "version": "0.28.2",
+    "version": "0.29.0",
     "description": "Meta-package for the web platform",
     "license": "MIT",
     "dependencies": {
-        "@mtcute/core": "^0.28.2",
-        "@mtcute/wasm": "^0.27.8",
-        "@fuman/net": "0.0.19"
+        "@mtcute/core": "^0.29.0",
+        "@mtcute/wasm": "^0.29.0",
+        "@fuman/net": "0.0.19",
+        "@fuman/utils": "0.0.19"
     },
     "exports": {
         ".": {

package/worker.cjs

@@ -5,57 +5,86 @@ if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WAR
 }
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const utils = require("@fuman/utils");
 const worker_js = require("@mtcute/core/worker.js");
 const platform$1 = require("./platform.cjs");
 let _broadcast;
 const _sharedHandlers = /* @__PURE__ */ new Set();
+function isWorkerInboundMessage(message) {
+  if (!message || typeof message !== "object") return false;
+  const data = message;
+  if (typeof data._mtcuteWorkerId !== "string") return false;
+  if (typeof data.connectionId !== "string") return false;
+  return true;
+}
+function setupSharedWorker() {
+  if (_broadcast) return _broadcast;
+  utils.unsafeCastType(self);
+  const ports = /* @__PURE__ */ new Map();
+  const knownConnectionIds = /* @__PURE__ */ new WeakMap();
+  const addConnection = (port, connectionId) => {
+    ports.set(connectionId, port);
+    const known = knownConnectionIds.get(port);
+    if (known) {
+      known.add(connectionId);
+      return;
+    }
+    knownConnectionIds.set(port, /* @__PURE__ */ new Set([connectionId]));
+  };
+  const cleanupConnection = (port, connectionId) => {
+    ports.delete(connectionId);
+    const known = knownConnectionIds.get(port);
+    if (!known) return;
+    known.delete(connectionId);
+    if (!known.size) {
+      knownConnectionIds.delete(port);
+    }
+  };
+  const broadcast = (message) => {
+    if ("connectionId" in message) {
+      const port = ports.get(message.connectionId);
+      if (!port) return;
+      port.postMessage(message);
+      if (message.type === "connection_expired") {
+        cleanupConnection(port, message.connectionId);
+      }
+      return;
+    }
+    for (const port of ports.values()) {
+      port.postMessage(message);
+    }
+  };
+  self.onconnect = (event) => {
+    const port = event.ports[0];
+    const respond = (message) => {
+      port.postMessage(message);
+      if ("connectionId" in message && message.type === "connection_expired") {
+        cleanupConnection(port, message.connectionId);
+      }
+    };
+    port.addEventListener("message", (message) => {
+      const data = message.data;
+      if (!isWorkerInboundMessage(data)) return;
+      if (data.type === "connect") {
+        addConnection(port, data.connectionId);
+      } else if (data.type === "release") {
+        cleanupConnection(port, data.connectionId);
+      }
+      for (const handler of _sharedHandlers) {
+        handler(data, respond);
+      }
+    });
+    port.start();
+  };
+  _broadcast = broadcast;
+  return broadcast;
+}
 class TelegramWorker extends worker_js.TelegramWorker {
   registerWorker(handler) {
     if (typeof SharedWorkerGlobalScope !== "undefined" && self instanceof SharedWorkerGlobalScope) {
-      if (!_broadcast) {
-        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;
-            }
-            for (const handler2 of _sharedHandlers) {
-              handler2(message.data, respond);
-            }
-          });
-          port.start();
-        };
-        _broadcast = broadcast;
-      }
+      const broadcast = setupSharedWorker();
       _sharedHandlers.add(handler);
-      return [_broadcast, () => _sharedHandlers.delete(handler)];
+      return [broadcast, () => _sharedHandlers.delete(handler)];
     }
     if (typeof WorkerGlobalScope !== "undefined" && self instanceof WorkerGlobalScope) {
       const respond = self.postMessage.bind(self);
@@ -76,12 +105,11 @@ class TelegramWorkerPort extends worker_js.TelegramWorkerPort {
     });
   }
   connectToWorker(worker, handler) {
-    if (worker instanceof Worker) {
+    if (worker instanceof Worker || worker instanceof MessagePort) {
       const send = worker.postMessage.bind(worker);
-      const messageHandler = (ev) => {
-        handler(ev.data);
-      };
+      const messageHandler = (ev) => handler(ev.data);
       worker.addEventListener("message", messageHandler);
+      if (worker instanceof MessagePort) worker.start();
       return [
         send,
         () => {
@@ -91,27 +119,14 @@ class TelegramWorkerPort extends worker_js.TelegramWorkerPort {
     }
     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");

package/worker.js

@@ -1,54 +1,83 @@
+import { unsafeCastType } from "@fuman/utils";
 import { TelegramWorker as TelegramWorker$1, TelegramWorkerPort as TelegramWorkerPort$1 } from "@mtcute/core/worker.js";
 import { WebPlatform } from "./platform.js";
 let _broadcast;
 const _sharedHandlers = /* @__PURE__ */ new Set();
+function isWorkerInboundMessage(message) {
+  if (!message || typeof message !== "object") return false;
+  const data = message;
+  if (typeof data._mtcuteWorkerId !== "string") return false;
+  if (typeof data.connectionId !== "string") return false;
+  return true;
+}
+function setupSharedWorker() {
+  if (_broadcast) return _broadcast;
+  unsafeCastType(self);
+  const ports = /* @__PURE__ */ new Map();
+  const knownConnectionIds = /* @__PURE__ */ new WeakMap();
+  const addConnection = (port, connectionId) => {
+    ports.set(connectionId, port);
+    const known = knownConnectionIds.get(port);
+    if (known) {
+      known.add(connectionId);
+      return;
+    }
+    knownConnectionIds.set(port, /* @__PURE__ */ new Set([connectionId]));
+  };
+  const cleanupConnection = (port, connectionId) => {
+    ports.delete(connectionId);
+    const known = knownConnectionIds.get(port);
+    if (!known) return;
+    known.delete(connectionId);
+    if (!known.size) {
+      knownConnectionIds.delete(port);
+    }
+  };
+  const broadcast = (message) => {
+    if ("connectionId" in message) {
+      const port = ports.get(message.connectionId);
+      if (!port) return;
+      port.postMessage(message);
+      if (message.type === "connection_expired") {
+        cleanupConnection(port, message.connectionId);
+      }
+      return;
+    }
+    for (const port of ports.values()) {
+      port.postMessage(message);
+    }
+  };
+  self.onconnect = (event) => {
+    const port = event.ports[0];
+    const respond = (message) => {
+      port.postMessage(message);
+      if ("connectionId" in message && message.type === "connection_expired") {
+        cleanupConnection(port, message.connectionId);
+      }
+    };
+    port.addEventListener("message", (message) => {
+      const data = message.data;
+      if (!isWorkerInboundMessage(data)) return;
+      if (data.type === "connect") {
+        addConnection(port, data.connectionId);
+      } else if (data.type === "release") {
+        cleanupConnection(port, data.connectionId);
+      }
+      for (const handler of _sharedHandlers) {
+        handler(data, respond);
+      }
+    });
+    port.start();
+  };
+  _broadcast = broadcast;
+  return broadcast;
+}
 class TelegramWorker extends TelegramWorker$1 {
   registerWorker(handler) {
     if (typeof SharedWorkerGlobalScope !== "undefined" && self instanceof SharedWorkerGlobalScope) {
-      if (!_broadcast) {
-        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;
-            }
-            for (const handler2 of _sharedHandlers) {
-              handler2(message.data, respond);
-            }
-          });
-          port.start();
-        };
-        _broadcast = broadcast;
-      }
+      const broadcast = setupSharedWorker();
       _sharedHandlers.add(handler);
-      return [_broadcast, () => _sharedHandlers.delete(handler)];
+      return [broadcast, () => _sharedHandlers.delete(handler)];
     }
     if (typeof WorkerGlobalScope !== "undefined" && self instanceof WorkerGlobalScope) {
       const respond = self.postMessage.bind(self);
@@ -69,12 +98,11 @@ class TelegramWorkerPort extends TelegramWorkerPort$1 {
     });
   }
   connectToWorker(worker, handler) {
-    if (worker instanceof Worker) {
+    if (worker instanceof Worker || worker instanceof MessagePort) {
       const send = worker.postMessage.bind(worker);
-      const messageHandler = (ev) => {
-        handler(ev.data);
-      };
+      const messageHandler = (ev) => handler(ev.data);
       worker.addEventListener("message", messageHandler);
+      if (worker instanceof MessagePort) worker.start();
       return [
         send,
         () => {
@@ -84,27 +112,14 @@ class TelegramWorkerPort extends TelegramWorkerPort$1 {
     }
     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");

package/worker.shared.fixture.d.cts

@@ -0,0 +1 @@
+export {};

package/worker.shared.fixture.d.ts

@@ -0,0 +1 @@
+export {};

package/worker.test.d.cts

@@ -0,0 +1 @@
+export {};

package/worker.test.d.ts

@@ -0,0 +1 @@
+export {};