@kbve/droid 0.0.4 → 0.0.6

package/lib/workers/canvas-worker.js

@@ -0,0 +1,303 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const A = Symbol("Comlink.proxy"), F = Symbol("Comlink.endpoint"), O = Symbol("Comlink.releaseProxy"), k = Symbol("Comlink.finalizer"), d = Symbol("Comlink.thrown"), C = (t) => typeof t == "object" && t !== null || typeof t == "function", z = {
+  canHandle: (t) => C(t) && t[A],
+  serialize(t) {
+    const { port1: e, port2: r } = new MessageChannel();
+    return S(t, e), [r, [r]];
+  },
+  deserialize(t) {
+    return t.start(), H(t);
+  }
+}, N = {
+  canHandle: (t) => C(t) && d in t,
+  serialize({ value: t }) {
+    let e;
+    return t instanceof Error ? e = {
+      isError: !0,
+      value: {
+        message: t.message,
+        name: t.name,
+        stack: t.stack
+      }
+    } : e = { isError: !1, value: t }, [e, []];
+  },
+  deserialize(t) {
+    throw t.isError ? Object.assign(new Error(t.value.message), t.value) : t.value;
+  }
+}, P = /* @__PURE__ */ new Map([
+  ["proxy", z],
+  ["throw", N]
+]);
+function W(t, e) {
+  for (const r of t)
+    if (e === r || r === "*" || r instanceof RegExp && r.test(e))
+      return !0;
+  return !1;
+}
+function S(t, e = globalThis, r = ["*"]) {
+  e.addEventListener("message", function l(n) {
+    if (!n || !n.data)
+      return;
+    if (!W(r, n.origin)) {
+      console.warn(`Invalid origin '${n.origin}' for comlink proxy`);
+      return;
+    }
+    const { id: s, type: m, path: c } = Object.assign({ path: [] }, n.data), u = (n.data.argumentList || []).map(h);
+    let a;
+    try {
+      const o = c.slice(0, -1).reduce((i, y) => i[y], t), f = c.reduce((i, y) => i[y], t);
+      switch (m) {
+        case "GET":
+          a = f;
+          break;
+        case "SET":
+          o[c.slice(-1)[0]] = h(n.data.value), a = !0;
+          break;
+        case "APPLY":
+          a = f.apply(o, u);
+          break;
+        case "CONSTRUCT":
+          {
+            const i = new f(...u);
+            a = $(i);
+          }
+          break;
+        case "ENDPOINT":
+          {
+            const { port1: i, port2: y } = new MessageChannel();
+            S(t, y), a = _(i, [i]);
+          }
+          break;
+        case "RELEASE":
+          a = void 0;
+          break;
+        default:
+          return;
+      }
+    } catch (o) {
+      a = { value: o, [d]: 0 };
+    }
+    Promise.resolve(a).catch((o) => ({ value: o, [d]: 0 })).then((o) => {
+      const [f, i] = b(o);
+      e.postMessage(Object.assign(Object.assign({}, f), { id: s }), i), m === "RELEASE" && (e.removeEventListener("message", l), R(e), k in t && typeof t[k] == "function" && t[k]());
+    }).catch((o) => {
+      const [f, i] = b({
+        value: new TypeError("Unserializable return value"),
+        [d]: 0
+      });
+      e.postMessage(Object.assign(Object.assign({}, f), { id: s }), i);
+    });
+  }), e.start && e.start();
+}
+function D(t) {
+  return t.constructor.name === "MessagePort";
+}
+function R(t) {
+  D(t) && t.close();
+}
+function H(t, e) {
+  const r = /* @__PURE__ */ new Map();
+  return t.addEventListener("message", function(n) {
+    const { data: s } = n;
+    if (!s || !s.id)
+      return;
+    const m = r.get(s.id);
+    if (m)
+      try {
+        m(s);
+      } finally {
+        r.delete(s.id);
+      }
+  }), M(t, r, [], e);
+}
+function w(t) {
+  if (t)
+    throw new Error("Proxy has been released and is not useable");
+}
+function v(t) {
+  return g(t, /* @__PURE__ */ new Map(), {
+    type: "RELEASE"
+  }).then(() => {
+    R(t);
+  });
+}
+const E = /* @__PURE__ */ new WeakMap(), x = "FinalizationRegistry" in globalThis && new FinalizationRegistry((t) => {
+  const e = (E.get(t) || 0) - 1;
+  E.set(t, e), e === 0 && v(t);
+});
+function L(t, e) {
+  const r = (E.get(e) || 0) + 1;
+  E.set(e, r), x && x.register(t, e, t);
+}
+function U(t) {
+  x && x.unregister(t);
+}
+function M(t, e, r = [], l = function() {
+}) {
+  let n = !1;
+  const s = new Proxy(l, {
+    get(m, c) {
+      if (w(n), c === O)
+        return () => {
+          U(s), v(t), e.clear(), n = !0;
+        };
+      if (c === "then") {
+        if (r.length === 0)
+          return { then: () => s };
+        const u = g(t, e, {
+          type: "GET",
+          path: r.map((a) => a.toString())
+        }).then(h);
+        return u.then.bind(u);
+      }
+      return M(t, e, [...r, c]);
+    },
+    set(m, c, u) {
+      w(n);
+      const [a, o] = b(u);
+      return g(t, e, {
+        type: "SET",
+        path: [...r, c].map((f) => f.toString()),
+        value: a
+      }, o).then(h);
+    },
+    apply(m, c, u) {
+      w(n);
+      const a = r[r.length - 1];
+      if (a === F)
+        return g(t, e, {
+          type: "ENDPOINT"
+        }).then(h);
+      if (a === "bind")
+        return M(t, e, r.slice(0, -1));
+      const [o, f] = p(u);
+      return g(t, e, {
+        type: "APPLY",
+        path: r.map((i) => i.toString()),
+        argumentList: o
+      }, f).then(h);
+    },
+    construct(m, c) {
+      w(n);
+      const [u, a] = p(c);
+      return g(t, e, {
+        type: "CONSTRUCT",
+        path: r.map((o) => o.toString()),
+        argumentList: u
+      }, a).then(h);
+    }
+  });
+  return L(s, t), s;
+}
+function V(t) {
+  return Array.prototype.concat.apply([], t);
+}
+function p(t) {
+  const e = t.map(b);
+  return [e.map((r) => r[0]), V(e.map((r) => r[1]))];
+}
+const T = /* @__PURE__ */ new WeakMap();
+function _(t, e) {
+  return T.set(t, e), t;
+}
+function $(t) {
+  return Object.assign(t, { [A]: !0 });
+}
+function b(t) {
+  for (const [e, r] of P)
+    if (r.canHandle(t)) {
+      const [l, n] = r.serialize(t);
+      return [
+        {
+          type: "HANDLER",
+          name: e,
+          value: l
+        },
+        n
+      ];
+    }
+  return [
+    {
+      type: "RAW",
+      value: t
+    },
+    T.get(t) || []
+  ];
+}
+function h(t) {
+  switch (t.type) {
+    case "HANDLER":
+      return P.get(t.name).deserialize(t.value);
+    case "RAW":
+      return t.value;
+  }
+}
+function g(t, e, r, l) {
+  return new Promise((n) => {
+    const s = j();
+    e.set(s, n), t.start && t.start(), t.postMessage(Object.assign({ id: s }, r), l);
+  });
+}
+function j() {
+  return new Array(4).fill(0).map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16)).join("-");
+}
+const q = {
+  bindings: /* @__PURE__ */ new Map(),
+  async bindCanvas(t, e, r = "animated") {
+    const l = e.getContext("2d");
+    if (!l) {
+      console.error(`[CanvasWorker] Failed to get 2D context for panel ${t}`);
+      return;
+    }
+    console.log(`[CanvasWorker] Successfully bound canvas for panel ${t} with mode ${r}`), this.bindings.set(t, { ctx: l, canvas: e, panelId: t, mode: r }), this.startAnimation(t);
+  },
+  startAnimation(t) {
+    const e = this.bindings.get(t);
+    if (e)
+      switch (e.mode) {
+        case "static":
+          this.drawStatic(e);
+          break;
+        case "animated":
+          this.drawAnimated(e);
+          break;
+        case "dynamic":
+          this.drawDynamic(e);
+          break;
+        default:
+          console.warn(`[CanvasWorker] Unknown draw mode for panel ${t}`);
+      }
+  },
+  drawStatic(t) {
+    t.ctx.fillStyle = "gray", t.ctx.fillRect(0, 0, t.canvas.width, t.canvas.height);
+  },
+  drawAnimated(t) {
+    let e = 0;
+    const r = () => {
+      e = (e + 1) % 360, t.ctx.fillStyle = `hsl(${e}, 100%, 50%)`, t.ctx.fillRect(0, 0, t.canvas.width, t.canvas.height), t.animationFrame = requestAnimationFrame(r);
+    };
+    r();
+  },
+  drawDynamic(t) {
+    let e = 0;
+    const r = () => {
+      e += 0.05, t.ctx.clearRect(0, 0, t.canvas.width, t.canvas.height), t.ctx.beginPath(), t.ctx.arc(
+        t.canvas.width / 2 + Math.sin(e) * 50,
+        t.canvas.height / 2 + Math.cos(e) * 50,
+        30,
+        0,
+        Math.PI * 2
+      ), t.ctx.fillStyle = "orange", t.ctx.fill(), t.animationFrame = requestAnimationFrame(r);
+    };
+    r();
+  },
+  async unbindCanvas(t) {
+    const e = this.bindings.get(t);
+    e?.animationFrame && cancelAnimationFrame(e.animationFrame), this.bindings.delete(t), console.log(`[CanvasWorker] Unbound canvas for panel ${t}`);
+  }
+};
+S(q);