@kbve/droid 0.0.6 → 0.1.1

package/lib/workers/tools.d.ts

@@ -0,0 +1,4 @@
+import { VirtualNode } from '../types/modules';
+export declare function dispatchAsync(fn: () => void): void;
+export declare function renderVNode(vnode: VirtualNode): HTMLElement;
+//# sourceMappingURL=tools.d.ts.map

package/lib/workers/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../../../../../packages/npm/droid/src/lib/workers/tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,IAAI,QAM3C;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,WAAW,GAAG,WAAW,CAiD3D"}

package/lib/workers/validate.d.ts

@@ -0,0 +1,15 @@
+export type UIMessageType = 'toast' | 'toast-remove' | 'tooltip-open' | 'tooltip-close' | 'modal-open' | 'modal-close';
+export interface ValidatedWorkerMessage {
+    type: UIMessageType;
+    payload: unknown;
+}
+/**
+ * Validate a UI message payload BEFORE postMessage to main thread.
+ * Returns the validated message or throws with a descriptive error.
+ *
+ * Usage (inside worker):
+ *   const msg = validateUIMessage('toast', rawPayload);
+ *   emitFromWorker(msg); // guaranteed valid
+ */
+export declare function validateUIMessage(type: UIMessageType, payload: unknown): ValidatedWorkerMessage;
+//# sourceMappingURL=validate.d.ts.map

package/lib/workers/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../../../../packages/npm/droid/src/lib/workers/validate.ts"],"names":[],"mappings":"AAOA,MAAM,MAAM,aAAa,GACtB,OAAO,GACP,cAAc,GACd,cAAc,GACd,eAAe,GACf,YAAY,GACZ,aAAa,CAAC;AAQjB,MAAM,WAAW,sBAAsB;IACtC,IAAI,EAAE,aAAa,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAChC,IAAI,EAAE,aAAa,EACnB,OAAO,EAAE,OAAO,GACd,sBAAsB,CA0BxB"}

package/lib/workers/ws-worker.d.ts

@@ -0,0 +1,11 @@
+declare const wsInstanceAPI: {
+    connect(url: string): Promise<void>;
+    send(payload: Uint8Array): Promise<void>;
+    close(): Promise<void>;
+    onMessage(callback: (data: string | ArrayBuffer) => void): void;
+    onStatus(callback: (status: string) => void): void;
+    getStatus(): Promise<string>;
+};
+export type WSInstance = typeof wsInstanceAPI;
+export {};
+//# sourceMappingURL=ws-worker.d.ts.map

package/lib/workers/ws-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ws-worker.d.ts","sourceRoot":"","sources":["../../../../../../packages/npm/droid/src/lib/workers/ws-worker.ts"],"names":[],"mappings":"AAkFA,QAAA,MAAM,aAAa;iBACC,MAAM;kBAiEL,UAAU;;wBAqBV,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,KAAK,IAAI;uBAIrC,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI;iBAIxB,OAAO,CAAC,MAAM,CAAC;CAUlC,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,OAAO,aAAa,CAAC"}

package/lib/workers/ws-worker.js

@@ -1,19 +1,14 @@
-/**
- * @license
- * Copyright 2019 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-const T = Symbol("Comlink.proxy"), N = Symbol("Comlink.endpoint"), H = Symbol("Comlink.releaseProxy"), k = Symbol("Comlink.finalizer"), h = Symbol("Comlink.thrown"), C = (e) => typeof e == "object" && e !== null || typeof e == "function", I = {
-  canHandle: (e) => C(e) && e[T],
+const L = /* @__PURE__ */ Symbol("Comlink.proxy"), $ = /* @__PURE__ */ Symbol("Comlink.endpoint"), B = /* @__PURE__ */ Symbol("Comlink.releaseProxy"), R = /* @__PURE__ */ Symbol("Comlink.finalizer"), k = /* @__PURE__ */ Symbol("Comlink.thrown"), z = (e) => typeof e == "object" && e !== null || typeof e == "function", Y = {
+  canHandle: (e) => z(e) && e[L],
   serialize(e) {
     const { port1: t, port2: n } = new MessageChannel();
-    return M(e, t), [n, [n]];
+    return H(e, t), [n, [n]];
   },
   deserialize(e) {
-    return e.start(), D(e);
+    return e.start(), v(e);
   }
-}, L = {
-  canHandle: (e) => C(e) && h in e,
+}, q = {
+  canHandle: (e) => z(e) && k in e,
   serialize({ value: e }) {
     let t;
     return e instanceof Error ? t = {
@@ -28,48 +23,48 @@ const T = Symbol("Comlink.proxy"), N = Symbol("Comlink.endpoint"), H = Symbol("C
   deserialize(e) {
     throw e.isError ? Object.assign(new Error(e.value.message), e.value) : e.value;
   }
-}, R = /* @__PURE__ */ new Map([
-  ["proxy", I],
-  ["throw", L]
+}, D = /* @__PURE__ */ new Map([
+  ["proxy", Y],
+  ["throw", q]
 ]);
-function V(e, t) {
+function J(e, t) {
   for (const n of e)
     if (t === n || n === "*" || n instanceof RegExp && n.test(t))
       return !0;
   return !1;
 }
-function M(e, t = globalThis, n = ["*"]) {
-  t.addEventListener("message", function y(r) {
-    if (!r || !r.data)
+function H(e, t = globalThis, n = ["*"]) {
+  t.addEventListener("message", function d(o) {
+    if (!o || !o.data)
       return;
-    if (!V(n, r.origin)) {
-      console.warn(`Invalid origin '${r.origin}' for comlink proxy`);
+    if (!J(n, o.origin)) {
+      console.warn(`Invalid origin '${o.origin}' for comlink proxy`);
       return;
     }
-    const { id: a, type: g, path: c } = Object.assign({ path: [] }, r.data), u = (r.data.argumentList || []).map(d);
+    const { id: a, type: g, path: l } = Object.assign({ path: [] }, o.data), u = (o.data.argumentList || []).map(y);
     let s;
     try {
-      const o = c.slice(0, -1).reduce((i, w) => i[w], e), f = c.reduce((i, w) => i[w], e);
+      const c = l.slice(0, -1).reduce((i, b) => i[b], e), f = l.reduce((i, b) => i[b], e);
       switch (g) {
         case "GET":
           s = f;
           break;
         case "SET":
-          o[c.slice(-1)[0]] = d(r.data.value), s = !0;
+          c[l.slice(-1)[0]] = y(o.data.value), s = !0;
           break;
         case "APPLY":
-          s = f.apply(o, u);
+          s = f.apply(c, u);
           break;
         case "CONSTRUCT":
           {
             const i = new f(...u);
-            s = Y(i);
+            s = te(i);
           }
           break;
         case "ENDPOINT":
           {
-            const { port1: i, port2: w } = new MessageChannel();
-            M(e, w), s = G(i, [i]);
+            const { port1: i, port2: b } = new MessageChannel();
+            H(e, b), s = ee(i, [i]);
           }
           break;
         case "RELEASE":
@@ -78,31 +73,31 @@ function M(e, t = globalThis, n = ["*"]) {
         default:
           return;
       }
-    } catch (o) {
-      s = { value: o, [h]: 0 };
+    } catch (c) {
+      s = { value: c, [k]: 0 };
     }
-    Promise.resolve(s).catch((o) => ({ value: o, [h]: 0 })).then((o) => {
-      const [f, i] = S(o);
-      t.postMessage(Object.assign(Object.assign({}, f), { id: a }), i), g === "RELEASE" && (t.removeEventListener("message", y), O(t), k in e && typeof e[k] == "function" && e[k]());
-    }).catch((o) => {
-      const [f, i] = S({
+    Promise.resolve(s).catch((c) => ({ value: c, [k]: 0 })).then((c) => {
+      const [f, i] = P(c);
+      t.postMessage(Object.assign(Object.assign({}, f), { id: a }), i), g === "RELEASE" && (t.removeEventListener("message", d), F(t), R in e && typeof e[R] == "function" && e[R]());
+    }).catch((c) => {
+      const [f, i] = P({
         value: new TypeError("Unserializable return value"),
-        [h]: 0
+        [k]: 0
       });
       t.postMessage(Object.assign(Object.assign({}, f), { id: a }), i);
     });
   }), t.start && t.start();
 }
-function _(e) {
+function X(e) {
   return e.constructor.name === "MessagePort";
 }
-function O(e) {
-  _(e) && e.close();
+function F(e) {
+  X(e) && e.close();
 }
-function D(e, t) {
+function v(e, t) {
   const n = /* @__PURE__ */ new Map();
-  return e.addEventListener("message", function(r) {
-    const { data: a } = r;
+  return e.addEventListener("message", function(o) {
+    const { data: a } = o;
     if (!a || !a.id)
       return;
     const g = n.get(a.id);
@@ -112,112 +107,112 @@ function D(e, t) {
       } finally {
         n.delete(a.id);
       }
-  }), P(e, n, [], t);
+  }), _(e, n, [], t);
 }
-function b(e) {
+function h(e) {
   if (e)
     throw new Error("Proxy has been released and is not useable");
 }
-function W(e) {
+function V(e) {
   return m(e, /* @__PURE__ */ new Map(), {
     type: "RELEASE"
   }).then(() => {
-    O(e);
+    F(e);
   });
 }
-const E = /* @__PURE__ */ new WeakMap(), p = "FinalizationRegistry" in globalThis && new FinalizationRegistry((e) => {
-  const t = (E.get(e) || 0) - 1;
-  E.set(e, t), t === 0 && W(e);
+const C = /* @__PURE__ */ new WeakMap(), O = "FinalizationRegistry" in globalThis && new FinalizationRegistry((e) => {
+  const t = (C.get(e) || 0) - 1;
+  C.set(e, t), t === 0 && V(e);
 });
-function F(e, t) {
-  const n = (E.get(t) || 0) + 1;
-  E.set(t, n), p && p.register(e, t, e);
+function K(e, t) {
+  const n = (C.get(t) || 0) + 1;
+  C.set(t, n), O && O.register(e, t, e);
 }
-function j(e) {
-  p && p.unregister(e);
+function Q(e) {
+  O && O.unregister(e);
 }
-function P(e, t, n = [], y = function() {
+function _(e, t, n = [], d = function() {
 }) {
-  let r = !1;
-  const a = new Proxy(y, {
-    get(g, c) {
-      if (b(r), c === H)
+  let o = !1;
+  const a = new Proxy(d, {
+    get(g, l) {
+      if (h(o), l === B)
         return () => {
-          j(a), W(e), t.clear(), r = !0;
+          Q(a), V(e), t.clear(), o = !0;
         };
-      if (c === "then") {
+      if (l === "then") {
         if (n.length === 0)
           return { then: () => a };
         const u = m(e, t, {
           type: "GET",
           path: n.map((s) => s.toString())
-        }).then(d);
+        }).then(y);
         return u.then.bind(u);
       }
-      return P(e, t, [...n, c]);
+      return _(e, t, [...n, l]);
     },
-    set(g, c, u) {
-      b(r);
-      const [s, o] = S(u);
+    set(g, l, u) {
+      h(o);
+      const [s, c] = P(u);
       return m(e, t, {
         type: "SET",
-        path: [...n, c].map((f) => f.toString()),
+        path: [...n, l].map((f) => f.toString()),
         value: s
-      }, o).then(d);
+      }, c).then(y);
     },
-    apply(g, c, u) {
-      b(r);
+    apply(g, l, u) {
+      h(o);
       const s = n[n.length - 1];
-      if (s === N)
+      if (s === $)
         return m(e, t, {
           type: "ENDPOINT"
-        }).then(d);
+        }).then(y);
       if (s === "bind")
-        return P(e, t, n.slice(0, -1));
-      const [o, f] = x(u);
+        return _(e, t, n.slice(0, -1));
+      const [c, f] = I(u);
       return m(e, t, {
         type: "APPLY",
         path: n.map((i) => i.toString()),
-        argumentList: o
-      }, f).then(d);
+        argumentList: c
+      }, f).then(y);
     },
-    construct(g, c) {
-      b(r);
-      const [u, s] = x(c);
+    construct(g, l) {
+      h(o);
+      const [u, s] = I(l);
       return m(e, t, {
         type: "CONSTRUCT",
-        path: n.map((o) => o.toString()),
+        path: n.map((c) => c.toString()),
         argumentList: u
-      }, s).then(d);
+      }, s).then(y);
     }
   });
-  return F(a, e), a;
+  return K(a, e), a;
 }
-function U(e) {
+function Z(e) {
   return Array.prototype.concat.apply([], e);
 }
-function x(e) {
-  const t = e.map(S);
-  return [t.map((n) => n[0]), U(t.map((n) => n[1]))];
+function I(e) {
+  const t = e.map(P);
+  return [t.map((n) => n[0]), Z(t.map((n) => n[1]))];
 }
-const z = /* @__PURE__ */ new WeakMap();
-function G(e, t) {
-  return z.set(e, t), e;
+const U = /* @__PURE__ */ new WeakMap();
+function ee(e, t) {
+  return U.set(e, t), e;
 }
-function Y(e) {
-  return Object.assign(e, { [T]: !0 });
+function te(e) {
+  return Object.assign(e, { [L]: !0 });
 }
-function S(e) {
-  for (const [t, n] of R)
+function P(e) {
+  for (const [t, n] of D)
     if (n.canHandle(e)) {
-      const [y, r] = n.serialize(e);
+      const [d, o] = n.serialize(e);
       return [
         {
           type: "HANDLER",
           name: t,
-          value: y
+          value: d
         },
-        r
+        o
       ];
     }
   return [
@@ -225,50 +220,114 @@ function S(e) {
       type: "RAW",
       value: e
     },
-    z.get(e) || []
+    U.get(e) || []
   ];
 }
-function d(e) {
+function y(e) {
   switch (e.type) {
     case "HANDLER":
-      return R.get(e.name).deserialize(e.value);
+      return D.get(e.name).deserialize(e.value);
     case "RAW":
       return e.value;
   }
 }
-function m(e, t, n, y) {
-  return new Promise((r) => {
-    const a = q();
-    t.set(a, r), e.start && e.start(), e.postMessage(Object.assign({ id: a }, n), y);
+function m(e, t, n, d) {
+  return new Promise((o) => {
+    const a = ne();
+    t.set(a, o), e.start && e.start(), e.postMessage(Object.assign({ id: a }, n), d);
   });
 }
-function q() {
+function ne() {
   return new Array(4).fill(0).map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16)).join("-");
 }
-let l = null, A = null;
-const v = {
+let r = null, W = null, j = null, M = null, N = 0;
+const re = 3e4, oe = 6e4;
+let A = null, E = 0, p = null;
+const T = 5, se = 3e3;
+function ae() {
+  w(), M = setInterval(() => {
+    if (!r || r.readyState !== WebSocket.OPEN) {
+      w();
+      return;
+    }
+    if (N > 0 && Date.now() - N > oe) {
+      console.warn("[WS] Heartbeat timeout — closing connection"), w(), r.close(1001, "Heartbeat timeout");
+      return;
+    }
+    try {
+      r.send(JSON.stringify({ type: "ping" }));
+    } catch (e) {
+      console.error("[WS] Failed to send heartbeat:", e);
+    }
+  }, re);
+}
+function w() {
+  M && (clearInterval(M), M = null);
+}
+function S(e) {
+  j?.(e);
+}
+function ce() {
+  if (!p || E >= T) {
+    E >= T && (console.error(
+      `[WS] Max reconnect attempts (${T}) reached`
+    ), S("failed"));
+    return;
+  }
+  E++, console.log(
+    `[WS] Reconnecting (${E}/${T})...`
+  ), S("reconnecting"), A = setTimeout(() => {
+    p && G.connect(p);
+  }, se);
+}
+const G = {
   async connect(e) {
-    l || (l = new WebSocket(e), l.binaryType = "arraybuffer", l.onopen = () => console.log("[WS] Connected:", e), l.onmessage = (t) => {
+    r && r.readyState === WebSocket.OPEN || (r && (r.onclose = null, r.close(), r = null), p = e, r = new WebSocket(e), r.binaryType = "arraybuffer", r.onopen = () => {
+      console.log("[WS] Connected:", e), E = 0, N = Date.now(), ae(), S("connected");
+    }, r.onmessage = (t) => {
       try {
-        console.log("[WS] Received binary message"), t.data instanceof ArrayBuffer && A?.(t.data);
+        if (typeof t.data == "string")
+          try {
+            if (JSON.parse(t.data).type === "pong") {
+              N = Date.now();
+              return;
+            }
+          } catch {
+          }
+        t.data instanceof ArrayBuffer, W?.(t.data);
       } catch (n) {
         console.error("[WS] Failed to forward message", n);
       }
-    }, l.onerror = (t) => console.error("[WS] Error:", t), l.onclose = () => {
-      console.log("[WS] Disconnected"), l = null;
+    }, r.onerror = (t) => {
+      console.error("[WS] Error:", t), S("error");
+    }, r.onclose = (t) => {
+      console.log("[WS] Disconnected:", t.code, t.reason), r = null, w(), S("disconnected"), t.code !== 1e3 && ce();
     });
   },
   async send(e) {
-    l?.readyState === WebSocket.OPEN ? l.send(e) : console.warn("[WS] Tried to send while disconnected");
+    r?.readyState === WebSocket.OPEN ? r.send(e) : console.warn("[WS] Tried to send while disconnected");
   },
   async close() {
-    l?.close(), l = null;
+    A && (clearTimeout(A), A = null), w(), E = 0, p = null, r?.close(1e3, "Client request"), r = null, S("disconnected");
   },
   onMessage(e) {
-    A = e;
+    W = e;
+  },
+  onStatus(e) {
+    j = e;
+  },
+  async getStatus() {
+    return r ? {
+      [WebSocket.CONNECTING]: "connecting",
+      [WebSocket.OPEN]: "connected",
+      [WebSocket.CLOSING]: "closing",
+      [WebSocket.CLOSED]: "disconnected"
+    }[r.readyState] || "unknown" : "disconnected";
   }
-};
+}, x = /* @__PURE__ */ new Set();
 self.onconnect = (e) => {
-  const t = e.ports[0];
-  t.start(), M(v, t);
+  const t = e.ports[0], n = x.size === 0;
+  x.add(t), t.start(), t.postMessage({ type: n ? "first-connect" : "reconnect" }), t.addEventListener("message", (d) => {
+    d.data?.type === "close" && x.delete(t);
+  }), H(G, t);
 };