comlink-adapters/dist/comlink-adapters.js

Implementation of comlink adapters for different application platforms

import { transferHandlers as g, proxyMarker as M, expose as y, wrap as S } from "comlink";
const x = "__COMLINK_MESSAGE_CHANNEL__", h = "__COMLINK_MESSAGE_PORT_MARKER__", l = "message", f = "Only message event is supported", p = "__PROXY_MESSAGE_CHANNEL_MARKER__", _ = (e) => typeof e == "object" && e !== null || typeof e == "function", R = () => new Array(4).fill(0).map(
  () => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16)
).join("-"), N = (e, t) => !t.length || !e ? e : (e == null ? void 0 : e.value) === h ? (e.value = t[0], e) : typeof e == "object" ? JSON.parse(JSON.stringify(e), (n, r) => r && r === h ? t[0] : r) : e, u = /* @__PURE__ */ new Map(), C = (e) => ({
  canHandle: (n) => _(n) && n[M],
  serialize(n) {
    if (e) {
      const { port1: s, port2: o } = new e();
      return y(
        n,
        A(
          s,
          e
        )
      ), [
        h,
        [o]
      ];
    }
    const { port1: r, port2: a } = new MessageChannel();
    return y(n, r), [h, [a]];
  },
  deserialize(n) {
    n.start();
    const r = n instanceof MessagePort ? n : A(
      n,
      e
    );
    return S(r);
  }
}), G = (e) => ({
  canHandle: (n) => !!(n && typeof n == "object" && Reflect.get(n, "start") && Reflect.get(n, "postMessage")),
  serialize(n) {
    if (e) {
      const { port1: r, port2: a } = new e();
      return H(n, r), [
        h,
        [a]
      ];
    }
    return [h, [n]];
  },
  deserialize(n) {
    return n.start(), n;
  }
}), v = (e) => {
  u.has("proxy") || u.set(
    "proxy",
    C(e)
  ), u.has("messagePort") || u.set(
    "messagePort",
    G(e)
  ), g.set(
    "messagePort",
    u.get("messagePort")
  ), g.set("proxy", u.get("proxy"));
}, H = (e, t) => {
  e.addEventListener("message", (n) => {
    t.postMessage(n.data, []);
  }), e.addEventListener("close", () => {
    t.close();
  }), t.addListener("message", (n) => {
    e.postMessage(n.data, []);
  }), t.addListener("close", () => {
    e.close();
  }), e.start(), t.start();
};
function A(e, t) {
  v(t);
  const n = /* @__PURE__ */ new WeakMap();
  return {
    start: () => e.start(),
    // transfer is MessagePortMain[]
    postMessage: (r, a) => {
      e.postMessage(r, a || []);
    },
    addEventListener: (r, a) => {
      if (r !== l)
        throw new Error(f);
      const s = (o) => {
        const i = N(
          o.data,
          o.ports
        );
        "handleEvent" in a ? a.handleEvent({
          data: i,
          ports: o.ports
        }) : a({
          data: i,
          ports: o.ports
        });
      };
      e.addListener(l, s), n.set(a, s);
    },
    removeEventListener: (r, a) => {
      if (r !== l)
        throw new Error(f);
      const s = n.get(a);
      s && (e.removeListener(l, s), n.delete(a));
    }
  };
}
function V(e) {
  v();
  const t = /* @__PURE__ */ new WeakMap(), { ipcRenderer: n, channelName: r = x } = e;
  return {
    postMessage: (a, s) => {
      n.postMessage(r, a, s);
    },
    addEventListener: (a, s) => {
      if (a !== l)
        throw new Error(f);
      const o = (i, ...c) => {
        const { ports: E } = i, d = N(
          c[0],
          E
        );
        "handleEvent" in s ? s.handleEvent({
          data: d,
          ports: E
        }) : s({
          data: d,
          ports: E
        });
      };
      n.on(r, o), t.set(s, o);
    },
    removeEventListener: (a, s) => {
      if (a !== l)
        throw new Error(f);
      const o = t.get(s);
      o && (n.removeListener(r, o), t.delete(s));
    }
  };
}
function X(e) {
  const {
    sender: t,
    ipcMain: n,
    messageChannelConstructor: r,
    channelName: a = x
  } = e;
  v(r);
  const s = /* @__PURE__ */ new WeakMap();
  return {
    postMessage: (o, i) => {
      t.postMessage(a, o, i);
    },
    addEventListener: (o, i) => {
      if (o !== l)
        throw new Error(f);
      const c = (E, ...d) => {
        const { ports: T } = E, P = N(d[0], T);
        "handleEvent" in i ? i.handleEvent({
          data: P,
          ports: T
        }) : i({ data: P, ports: T });
      };
      n.on(a, c), s.set(i, c);
    },
    removeEventListener: (o, i) => {
      if (o !== l)
        throw new Error(f);
      const c = s.get(i);
      c && (n.removeListener(a, c), s.delete(i));
    }
  };
}
const I = {
  canHandle: (e) => _(e) && e[M],
  serialize() {
    return [null, []];
  },
  deserialize() {
    return function() {
      throw new Error("Operation not supported");
    };
  }
};
function Y(e) {
  g.set("proxy", I);
  const t = /* @__PURE__ */ new WeakMap();
  return {
    postMessage: (n, r) => {
      globalThis.parent.postMessage(
        {
          pluginMessage: n
        },
        {
          targetOrigin: (e == null ? void 0 : e.origin) || "*",
          transfer: r
        }
      );
    },
    addEventListener: (n, r) => {
      if (n !== l)
        throw new Error(f);
      const a = (s) => {
        const { ports: o, data: i } = s;
        "handleEvent" in r ? r.handleEvent({
          data: i.pluginMessage,
          ports: o
        }) : r({
          data: i.pluginMessage,
          ports: o
        });
      };
      globalThis.addEventListener(l, a), t.set(r, a);
    },
    removeEventListener: (n, r) => {
      if (n !== l)
        throw new Error(f);
      const a = t.get(r);
      a && (globalThis.removeEventListener(l, a), t.delete(r));
    }
  };
}
function F(e) {
  g.set("proxy", I);
  const t = /* @__PURE__ */ new WeakMap();
  return {
    // not supported transfer
    postMessage: (n, r) => {
      figma.ui.postMessage(n, { origin: (e == null ? void 0 : e.origin) || "*" });
    },
    addEventListener: (n, r) => {
      if (n !== l)
        throw new Error(f);
      const a = async (s, o) => {
        (!(e != null && e.checkProps) || await (e == null ? void 0 : e.checkProps(o))) && ("handleEvent" in r ? r.handleEvent({
          data: s,
          ports: []
        }) : r({
          data: s,
          ports: []
        }));
      };
      figma.ui.on(l, a), t.set(r, a);
    },
    removeEventListener: (n, r) => {
      if (n !== l)
        throw new Error(f);
      const a = t.get(r);
      a && (figma.ui.off(l, a), t.delete(r));
    }
  };
}
const k = {
  canHandle: (e) => _(e) && e[M],
  serialize() {
    return [null, []];
  },
  deserialize() {
    return function() {
      throw new Error("Operation not supported");
    };
  }
};
function q(e) {
  g.set("proxy", k);
  const t = /* @__PURE__ */ new WeakMap();
  return {
    start: () => {
    },
    postMessage: (n, r) => {
      e.postMessage(n);
    },
    addEventListener: (n, r) => {
      if (n !== l)
        throw new Error(f);
      const a = (s, o) => {
        "handleEvent" in r ? r.handleEvent({
          data: s,
          ports: []
        }) : r({
          data: s,
          ports: []
        });
      };
      e.onMessage.addListener(a), t.set(r, a);
    },
    removeEventListener: (n, r) => {
      if (n !== l)
        throw new Error(f);
      t.get(r) && t.delete(r);
    }
  };
}
function Q(e) {
  const { tabId: t = 0, extensionId: n = "" } = e || {};
  g.set("proxy", k);
  const r = /* @__PURE__ */ new Set(), a = (s, o, i) => {
    if (!(!s || !r.size))
      for (const c of r.values())
        "handleEvent" in c ? c.handleEvent({
          data: s,
          ports: []
        }) : c({
          data: s,
          ports: []
        });
  };
  return n ? chrome.runtime.onMessageExternal.addListener(a) : chrome.runtime.onMessage.addListener(a), {
    start: () => {
    },
    postMessage: (s, o) => {
      if (t) {
        chrome.tabs.sendMessage(t, s);
        return;
      }
      if (n) {
        chrome.runtime.sendMessage(n, s);
        return;
      }
      chrome.runtime.sendMessage(s);
    },
    addEventListener: (s, o) => {
      if (s !== l)
        throw new Error(f);
      r.add(o);
    },
    removeEventListener: (s, o) => {
      if (s !== l)
        throw new Error(f);
      r.has(o) && r.delete(o);
    }
  };
}
const m = /* @__PURE__ */ new Map(), W = (e) => ({
  canHandle: (n) => _(n) && n[M],
  serialize(n) {
    const r = R();
    return y(
      n,
      O({
        socket: e,
        messageChannel: r
      })
    ), [
      { [p]: r },
      []
    ];
  },
  deserialize(n) {
    return S(
      O({
        socket: e,
        messageChannel: Reflect.get(
          n,
          p
        )
      })
    );
  }
}), $ = (e) => {
  m.has(e) || (m.set(
    e,
    W(e)
  ), e.on("disconnect", () => {
    m.has(e) && m.delete(e);
  })), g.set("proxy", m.get(e));
};
function O(e) {
  const t = /* @__PURE__ */ new WeakMap(), { socket: n, messageChannel: r = x } = e;
  return $(n), {
    postMessage: (a, s) => {
      n.emit(r, a);
    },
    addEventListener: (a, s) => {
      if (a !== l)
        throw new Error(f);
      const o = (i) => {
        "handleEvent" in s ? s.handleEvent({
          data: i,
          ports: []
        }) : s({
          data: i,
          ports: []
        });
      };
      n.on(r, o), t.set(s, o);
    },
    removeEventListener: (a, s) => {
      if (a !== l)
        throw new Error(f);
      const o = t.get(s);
      o && (n.off(r, o), t.delete(s));
    }
  };
}
const w = /* @__PURE__ */ new Map(), K = (e) => ({
  canHandle: (n) => _(n) && n[M],
  serialize(n) {
    const r = R();
    return y(
      n,
      b({
        webSocket: e,
        messageChannel: r
      })
    ), [
      { [p]: r },
      []
    ];
  },
  deserialize(n) {
    return S(
      b({
        webSocket: e,
        messageChannel: Reflect.get(
          n,
          p
        )
      })
    );
  }
}), j = (e) => {
  if (!w.has(e)) {
    w.set(e, K(e));
    const t = () => {
      w.has(e) && w.delete(e);
    };
    e.addEventListener("close", t);
  }
  g.set("proxy", w.get(e));
};
function b(e) {
  const { webSocket: t, messageChannel: n } = e, r = t, a = /* @__PURE__ */ new WeakMap(), s = n || x;
  return j(r), {
    postMessage: (o, i) => {
      r.send(JSON.stringify({ message: o, __channel__: s }));
    },
    addEventListener: (o, i) => {
      const c = (E) => {
        let d = null;
        try {
          d = JSON.parse(E.data);
        } catch {
          d = E.data;
        }
        !d || !d.__channel__ || !d.message || d.__channel__ !== s || ("handleEvent" in i ? i.handleEvent({ data: d.message }) : i({ data: d.message }));
      };
      r.addEventListener("message", c), a.set(i, c);
    },
    removeEventListener: (o, i) => {
      const c = a.get(i);
      c && (r.removeEventListener("message", c), a.delete(i));
    },
    start: () => {
    }
  };
}
const L = /* @__PURE__ */ new Map(), D = (e) => ({
  canHandle: (n) => _(n) && n[M],
  serialize(n) {
    const r = R();
    return y(
      n,
      z({
        nodeProcess: e,
        messageChannel: r
      })
    ), [
      { [p]: r },
      []
    ];
  },
  deserialize(n) {
    return S(
      z({
        nodeProcess: e,
        messageChannel: Reflect.get(
          n,
          p
        )
      })
    );
  }
}), J = (e) => {
  if (!L.has(e)) {
    L.set(
      e,
      D(e)
    );
    const t = () => {
      L.has(e) && L.delete(e);
    };
    process.on("exit", t), process.on("disconnect", t), process.on("SIGINT", t), process.on("uncaughtException", t);
  }
  g.set(
    "proxy",
    L.get(e)
  );
};
function z(e) {
  const { nodeProcess: t, messageChannel: n } = e, r = /* @__PURE__ */ new WeakMap(), a = n || x;
  return J(t), {
    postMessage: (s, o) => {
      t.send && t.send({ message: s, __channel__: a });
    },
    addEventListener: (s, o) => {
      const i = (c) => {
        if (!c || !c.__channel__ || !c.message || c.__channel__ !== a)
          return;
        const { message: E } = c;
        "handleEvent" in o ? o.handleEvent({ data: E }) : o({ data: E });
      };
      t.on("message", i), r.set(o, i);
    },
    removeEventListener: (s, o) => {
      const i = r.get(o);
      i && (t.off("message", i), r.delete(o));
    },
    start: () => {
    }
  };
}
export {
  x as MESSAGE_CHANNEL_NAME,
  f as MESSAGE_EVENT_ERROR,
  l as MESSAGE_EVENT_NAME,
  h as MESSAGE_PORT_MARKER,
  p as PROXY_MESSAGE_CHANNEL_MARKER,
  Q as chromeRuntimeMessageEndpoint,
  q as chromeRuntimePortEndpoint,
  X as electronMainEndpoint,
  A as electronMessagePortMainEndpoint,
  V as electronRendererEndpoint,
  F as figmaCoreEndpoint,
  Y as figmaUIEndpoint,
  z as nodeProcessEndpoint,
  O as socketIoEndpoint,
  b as webSocketEndpoint
};