osra 0.0.10 → 0.0.11

package/build/index.d.ts

@@ -2,3 +2,4 @@ import type { ApiMessageData, ApiResolverOptions, Resolvers, StructuredCloneTran
 export type { ApiMessageData, ApiResolverOptions, Resolvers, StructuredCloneTransferableObject, StructuredCloneTransferableType, StructuredCloneObject, StructuredCloneType, Target, TransferableObject };
 export * from './register';
 export * from './call';
+export * from './webextension';

package/build/index.js

@@ -1,89 +1,181 @@
-const m = "osra-message", A = ({
-  target: r,
-  resolvers: s,
-  filter: o,
-  map: t,
-  key: n = m
+const g = "osra-message", l = ({
+  target: e,
+  resolvers: t,
+  filter: r,
+  map: n,
+  key: a = g
 }) => {
-  const a = (e) => {
-    if (!e.data || typeof e.data != "object" || e.data?.source !== n || o && !o(e))
+  const o = (s) => {
+    if (!s.data || typeof s.data != "object" || s.data?.source !== a || r && !r(s))
       return;
-    const { type: c, data: b, port: g } = e.data, i = s[c];
-    if (!i)
+    const { type: c, data: i, port: d } = s.data, m = t[c];
+    if (!m)
       throw new Error(`Osra received a message of type "${String(c)}" but no resolver was found for type.`);
-    t ? i(...t(b, { event: e, type: c, port: g })) : i(b, { event: e, type: c, port: g });
+    n ? m(...n(i, { event: s, type: c, port: d })) : m(i, { event: s, type: c, port: d });
   };
-  return r.addEventListener("message", a), {
-    listener: a,
-    resolvers: s
+  return e.addEventListener("message", o), {
+    listener: o,
+    resolvers: t
   };
-}, y = (r) => !!(globalThis.SharedArrayBuffer && r instanceof globalThis.SharedArrayBuffer), h = (r) => globalThis.ArrayBuffer && r instanceof globalThis.ArrayBuffer || globalThis.MessagePort && r instanceof globalThis.MessagePort || globalThis.ReadableStream && r instanceof globalThis.ReadableStream || globalThis.WritableStream && r instanceof globalThis.WritableStream || globalThis.TransformStream && r instanceof globalThis.TransformStream ? !0 : !!(globalThis.ImageBitmap && r instanceof globalThis.ImageBitmap), p = (r) => {
-  const s = [], o = (t) => y(t) ? void 0 : h(t) ? s.push(t) : Array.isArray(t) ? t.map(o) : t && typeof t == "object" ? Object.values(t).map(o) : void 0;
-  return o(r), s;
-}, l = "__proxyFunctionPort__", O = (r) => {
-  const { port1: s, port2: o } = new MessageChannel();
-  return s.addEventListener("message", async (t) => {
+}, b = (e) => !!(globalThis.SharedArrayBuffer && e instanceof globalThis.SharedArrayBuffer), y = (e) => globalThis.ArrayBuffer && e instanceof globalThis.ArrayBuffer || globalThis.MessagePort && e instanceof globalThis.MessagePort || globalThis.ReadableStream && e instanceof globalThis.ReadableStream || globalThis.WritableStream && e instanceof globalThis.WritableStream || globalThis.TransformStream && e instanceof globalThis.TransformStream ? !0 : !!(globalThis.ImageBitmap && e instanceof globalThis.ImageBitmap), h = (e) => {
+  const t = [], r = (n) => b(n) ? void 0 : y(n) ? t.push(n) : Array.isArray(n) ? n.map(r) : n && typeof n == "object" ? Object.values(n).map(r) : void 0;
+  return r(e), t;
+}, p = "__proxyFunctionPort__", M = "__proxyMessageChannelPort__", j = (e) => {
+  const { port1: t, port2: r } = new MessageChannel();
+  return t.addEventListener("message", async (n) => {
     try {
-      const n = await r(...t.data), a = f(n), e = p(a);
-      s.postMessage({ result: a }, { transfer: e });
-    } catch (n) {
-      s.postMessage({ error: n });
+      const a = await e(...n.data), o = f(a), s = h(o);
+      t.postMessage({ result: o }, { transfer: s });
+    } catch (a) {
+      t.postMessage({ error: a });
     }
-  }), s.start(), o;
-}, f = (r) => y(r) || h(r) ? r : typeof r == "function" ? { [l]: O(r) } : Array.isArray(r) ? r.map(f) : r && typeof r == "object" ? Object.fromEntries(
-  Object.entries(r).map(([s, o]) => [
-    s,
-    f(o)
+  }), t.start(), r;
+}, f = (e) => b(e) || y(e) ? e : typeof e == "function" ? { [p]: j(e) } : Array.isArray(e) ? e.map(f) : e && typeof e == "object" ? Object.fromEntries(
+  Object.entries(e).map(([t, r]) => [
+    t,
+    f(r)
   ])
-) : r, j = (r) => (...s) => new Promise((o, t) => {
-  const n = f(s), a = p(n);
-  r.addEventListener("message", (e) => {
-    e.data.error ? t(e.data.error) : o(d(e.data.result));
-  }), r.start(), r.postMessage(n, { transfer: a });
-}), d = (r) => y(r) || h(r) ? r : r && typeof r == "object" && r[l] ? j(r[l]) : Array.isArray(r) ? r.map(f) : r && typeof r == "object" ? Object.fromEntries(
-  Object.entries(r).map(([s, o]) => [
-    s,
-    d(o)
+) : e, x = (e) => (...t) => new Promise((r, n) => {
+  const a = f(t), o = h(a), s = (c) => {
+    c.data.error ? n(c.data.error) : r(E(c.data.result)), e.removeEventListener("message", s);
+  };
+  e.addEventListener("message", s), e.start(), e.postMessage(a, { transfer: o });
+}), E = (e) => b(e) || y(e) ? e : e && typeof e == "object" && e[p] ? x(e[p]) : Array.isArray(e) ? e.map(f) : e && typeof e == "object" ? Object.fromEntries(
+  Object.entries(e).map(([t, r]) => [
+    t,
+    E(r)
   ])
-) : r, E = (r, { key: s = m } = { key: m }) => (o, t) => new Promise((n, a) => {
-  const { port1: e, port2: c } = new MessageChannel();
-  e.addEventListener(
+) : e, A = (e, { key: t = g } = { key: g }) => (r, n) => new Promise((a, o) => {
+  const { port1: s, port2: c } = new MessageChannel();
+  s.addEventListener(
     "message",
-    ({ data: i }) => {
-      if (i.error)
-        a(i.error);
+    ({ data: m }) => {
+      if (m.error)
+        o(m.error);
       else {
-        const T = d(i.result);
-        n(T);
+        const L = E(m.result);
+        a(L);
       }
-      e.close(), c.close();
+      s.close(), c.close();
     },
     { once: !0 }
-  ), e.start();
-  const b = f(t), g = p(b);
-  r.postMessage(
+  ), s.start();
+  const i = f(n), d = h(i);
+  e.postMessage(
     {
-      source: s,
-      type: o,
-      data: b,
+      source: t,
+      type: r,
+      data: i,
       port: c
     },
     {
       targetOrigin: "*",
-      transfer: [c, ...g ?? []]
+      transfer: [c, ...d ?? []]
     }
   );
-}), S = (r) => async (s, o) => {
-  const { port: t } = o, n = d(s);
+}), _ = (e) => async (t, r) => {
+  const { port: n } = r, a = E(t);
   try {
-    const a = await r(n, o), e = f(a), c = p(e);
-    return t.postMessage({ result: e }, { transfer: c }), t.close(), a;
-  } catch (a) {
-    throw t.postMessage({ error: a }), t.close(), a;
+    const o = await e(a, r), s = f(o), c = h(s);
+    return n.postMessage({ result: s }, { transfer: c }), n.close(), o;
+  } catch (o) {
+    throw n.postMessage({ error: o }), n.close(), o;
   }
+}, w = ({ key: e = g }) => {
+  const t = /* @__PURE__ */ new Map(), r = async (a) => t.get(a) ?? new Promise((o, s) => {
+    let c = !1;
+    setTimeout(() => {
+      c || s(new Error(`Osra getPort for "${a}" timed out`));
+    }, 1e3), chrome.runtime.onConnect.addListener((i) => {
+      i.name === `${e}:${a}` && (t.set(a, i), o(i), c = !0);
+    });
+  }), n = {
+    addPort: (a, o) => t.set(a, o),
+    proxyPort: (a) => {
+      const o = self.crypto.randomUUID(), s = chrome.runtime.connect({ name: `${e}:${o}` });
+      return t.set(o, s), s.onDisconnect.addListener(() => {
+        t.delete(o);
+      }), s.onMessage.addListener((c) => {
+        a.postMessage(c);
+      }), a.addEventListener("message", async (c) => {
+        s.postMessage(c.data);
+      }), a.addEventListener("close", () => {
+        s.disconnect();
+      }), {
+        [M]: o
+      };
+    },
+    proxiedPort: async ({ [M]: a }) => {
+      const { port1: o, port2: s } = new MessageChannel(), c = await r(a);
+      c.onMessage.addListener((d) => {
+        o.postMessage(d);
+      }), c.onDisconnect.addListener(() => {
+        o.close();
+      }), o.addEventListener("close", () => {
+        c.disconnect();
+      }), o.addEventListener("message", async (d) => {
+        c.postMessage(d.data);
+      }), o.start(), s.addEventListener("message", async (d) => {
+        c.postMessage(d.data);
+      }), s.start();
+      const i = O(n, s);
+      return i.uuid = a, i;
+    }
+  };
+  return n;
+}, P = (e, t) => t instanceof MessagePort ? e.proxyPort(t) : b(t) || y(t) ? t : typeof t == "object" && p in t ? { [p]: e.proxyPort(t[p]) } : Array.isArray(t) ? t.map((r) => P(e, r)) : t && typeof t == "object" ? Object.fromEntries(
+  Object.entries(t).map(([r, n]) => [
+    r,
+    P(e, n)
+  ])
+) : t, T = async (e, t) => b(t) || y(t) ? t : typeof t == "object" && M in t ? await e.proxiedPort(t) : typeof t == "object" && p in t ? { [p]: await e.proxiedPort(t[p]) } : Array.isArray(t) ? await Promise.all(t.map((r) => T(e, r))) : t && typeof t == "object" ? Object.fromEntries(
+  await Promise.all(
+    Object.entries(t).map(async ([r, n]) => [
+      r,
+      await T(e, n)
+    ])
+  )
+) : t, O = (e, t) => {
+  const r = t.postMessage;
+  return t.postMessage = (n) => {
+    r.apply(t, [P(e, n)]);
+  }, t;
+}, S = ({
+  target: e,
+  key: t = g
+}) => {
+  const r = w({ key: t });
+  return {
+    ...e,
+    postMessage: (n) => {
+      e.runtime.sendMessage(P(r, n));
+    }
+  };
+}, C = ({
+  target: e,
+  key: t = g
+}) => {
+  const r = w({ key: t });
+  return {
+    ...e,
+    addEventListener: (n, a, o) => {
+      if (n !== "message")
+        return e.addEventListener(n, a, o);
+      chrome.runtime.onMessage.addListener((s, c, i) => {
+        T(r, s).then((d) => a({ data: d }));
+      }), chrome.runtime.onConnect.addListener((s) => {
+        s.name.startsWith(`${t}:`) && r.addPort(s.name.split(":")[1], s);
+      });
+    }
+  };
 };
 export {
-  E as call,
-  S as makeCallListener,
-  A as registerListener
+  A as call,
+  _ as makeCallListener,
+  l as registerListener,
+  T as replaceProxied,
+  P as replaceProxies,
+  S as wrapExtensionTarget,
+  C as wrapListenerExtensionTarget,
+  O as wrapPort
 };

package/build/utils.d.ts

@@ -1,5 +1,9 @@
 import { TransferableObject } from './types';
+export declare const isClonable: (value: any) => boolean;
+export declare const isTransferable: (value: any) => boolean;
 export declare const getTransferableObjects: (value: any) => TransferableObject[];
+export declare const PROXY_FUNCTION_PROPERTY = "__proxyFunctionPort__";
+export declare const PROXY_MESSAGE_CHANNEL_PROPERTY = "__proxyMessageChannelPort__";
 export declare const makeProxyFunction: (func: any) => MessagePort;
 export declare const proxyObjectFunctions: (value: any) => any;
 export declare const makeProxiedFunction: (port: MessagePort) => (...args: any[]) => Promise<unknown>;

package/build/webextension.d.ts

@@ -0,0 +1,137 @@
+import type browser from 'webextension-polyfill';
+import { PROXY_MESSAGE_CHANNEL_PROPERTY } from './utils';
+type PortManager = ReturnType<typeof makePortManager>;
+declare const makePortManager: ({ key }: {
+    key?: string | undefined;
+}) => {
+    addPort: (name: string, port: browser.Runtime.Port) => Map<string, browser.Runtime.Port>;
+    proxyPort: (messagePort: MessagePort) => {
+        __proxyMessageChannelPort__: string;
+    };
+    proxiedPort: ({ [PROXY_MESSAGE_CHANNEL_PROPERTY]: uuid }: {
+        [PROXY_MESSAGE_CHANNEL_PROPERTY]: string;
+    }) => Promise<MessagePort>;
+};
+export declare const replaceProxies: (portManager: PortManager, value: any) => any;
+export declare const replaceProxied: (portManager: PortManager, value: any) => any;
+export declare const wrapPort: (portManager: any, port: MessagePort) => MessagePort;
+export declare const wrapExtensionTarget: ({ target, key }: {
+    target: browser.Browser;
+    key?: string | undefined;
+}) => {
+    postMessage: (message: any) => void;
+    activityLog: browser.ActivityLog.Static;
+    alarms: browser.Alarms.Static;
+    bookmarks: browser.Bookmarks.Static;
+    action: browser.Action.Static;
+    browserAction: browser.BrowserAction.Static;
+    browserSettings: browser.BrowserSettings.Static;
+    browsingData: browser.BrowsingData.Static;
+    captivePortal: browser.CaptivePortal.Static;
+    clipboard: browser.Clipboard.Static;
+    commands: browser.Commands.Static;
+    contentScripts: browser.ContentScripts.Static;
+    contextualIdentities: browser.ContextualIdentities.Static;
+    cookies: browser.Cookies.Static;
+    declarativeNetRequest: browser.DeclarativeNetRequest.Static;
+    devtools: browser.Devtools.Static;
+    dns: browser.Dns.Static;
+    downloads: browser.Downloads.Static;
+    events: browser.Events.Static;
+    experiments: browser.Experiments.Static;
+    extension: browser.Extension.Static;
+    extensionTypes: browser.ExtensionTypes.Static;
+    find: browser.Find.Static;
+    geckoProfiler: browser.GeckoProfiler.Static;
+    history: browser.History.Static;
+    i18n: browser.I18n.Static;
+    identity: browser.Identity.Static;
+    idle: browser.Idle.Static;
+    management: browser.Management.Static;
+    manifest: browser.Manifest.Static;
+    contextMenus: browser.ContextMenus.Static;
+    menus: browser.Menus.Static;
+    networkStatus: browser.NetworkStatus.Static;
+    normandyAddonStudy: browser.NormandyAddonStudy.Static;
+    notifications: browser.Notifications.Static;
+    omnibox: browser.Omnibox.Static;
+    pageAction: browser.PageAction.Static;
+    permissions: browser.Permissions.Static;
+    pkcs11: browser.Pkcs11.Static;
+    privacy: browser.Privacy.Static;
+    proxy: browser.Proxy.Static;
+    runtime: browser.Runtime.Static;
+    scripting: browser.Scripting.Static;
+    search: browser.Search.Static;
+    sessions: browser.Sessions.Static;
+    sidebarAction: browser.SidebarAction.Static;
+    storage: browser.Storage.Static;
+    tabs: browser.Tabs.Static;
+    theme: browser.Theme.Static;
+    topSites: browser.TopSites.Static;
+    types: browser.Types.Static;
+    urlbar: browser.Urlbar.Static;
+    userScripts: browser.UserScripts.Static;
+    webNavigation: browser.WebNavigation.Static;
+    webRequest: browser.WebRequest.Static;
+    windows: browser.Windows.Static;
+};
+export declare const wrapListenerExtensionTarget: ({ target, key }: {
+    target: WindowEventHandlers | ServiceWorkerContainer | Worker | SharedWorker;
+    key?: string | undefined;
+}) => {
+    addEventListener: (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions) => void;
+    onafterprint: ((this: WindowEventHandlers, ev: Event) => any) | null;
+    onbeforeprint: ((this: WindowEventHandlers, ev: Event) => any) | null;
+    onbeforeunload: ((this: WindowEventHandlers, ev: BeforeUnloadEvent) => any) | null;
+    ongamepadconnected: ((this: WindowEventHandlers, ev: GamepadEvent) => any) | null;
+    ongamepaddisconnected: ((this: WindowEventHandlers, ev: GamepadEvent) => any) | null;
+    onhashchange: ((this: WindowEventHandlers, ev: HashChangeEvent) => any) | null;
+    onlanguagechange: ((this: WindowEventHandlers, ev: Event) => any) | null;
+    onmessage: ((this: WindowEventHandlers, ev: MessageEvent<any>) => any) | null;
+    onmessageerror: ((this: WindowEventHandlers, ev: MessageEvent<any>) => any) | null;
+    onoffline: ((this: WindowEventHandlers, ev: Event) => any) | null;
+    ononline: ((this: WindowEventHandlers, ev: Event) => any) | null;
+    onpagehide: ((this: WindowEventHandlers, ev: PageTransitionEvent) => any) | null;
+    onpageshow: ((this: WindowEventHandlers, ev: PageTransitionEvent) => any) | null;
+    onpopstate: ((this: WindowEventHandlers, ev: PopStateEvent) => any) | null;
+    onrejectionhandled: ((this: WindowEventHandlers, ev: PromiseRejectionEvent) => any) | null;
+    onstorage: ((this: WindowEventHandlers, ev: StorageEvent) => any) | null;
+    onunhandledrejection: ((this: WindowEventHandlers, ev: PromiseRejectionEvent) => any) | null;
+    onunload: ((this: WindowEventHandlers, ev: Event) => any) | null;
+    removeEventListener<K extends keyof WindowEventHandlersEventMap>(type: K, listener: (this: WindowEventHandlers, ev: WindowEventHandlersEventMap[K]) => any, options?: boolean | EventListenerOptions | undefined): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+} | {
+    addEventListener: (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions) => void;
+    controller: ServiceWorker | null;
+    oncontrollerchange: ((this: ServiceWorkerContainer, ev: Event) => any) | null;
+    onmessage: ((this: ServiceWorkerContainer, ev: MessageEvent<any>) => any) | null;
+    onmessageerror: ((this: ServiceWorkerContainer, ev: MessageEvent<any>) => any) | null;
+    ready: Promise<ServiceWorkerRegistration>;
+    getRegistration(clientURL?: string | URL | undefined): Promise<ServiceWorkerRegistration | undefined>;
+    getRegistrations(): Promise<readonly ServiceWorkerRegistration[]>;
+    register(scriptURL: string | URL, options?: RegistrationOptions | undefined): Promise<ServiceWorkerRegistration>;
+    startMessages(): void;
+    removeEventListener<K_1 extends keyof ServiceWorkerContainerEventMap>(type: K_1, listener: (this: ServiceWorkerContainer, ev: ServiceWorkerContainerEventMap[K_1]) => any, options?: boolean | EventListenerOptions | undefined): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+    dispatchEvent(event: Event): boolean;
+} | {
+    addEventListener: (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions) => void;
+    port: MessagePort;
+    removeEventListener<K_2 extends "error">(type: K_2, listener: (this: SharedWorker, ev: AbstractWorkerEventMap[K_2]) => any, options?: boolean | EventListenerOptions | undefined): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+    dispatchEvent(event: Event): boolean;
+    onerror: ((this: AbstractWorker, ev: ErrorEvent) => any) | null;
+} | {
+    addEventListener: (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions) => void;
+    onmessage: ((this: Worker, ev: MessageEvent<any>) => any) | null;
+    onmessageerror: ((this: Worker, ev: MessageEvent<any>) => any) | null;
+    postMessage(message: any, transfer: Transferable[]): void;
+    postMessage(message: any, options?: StructuredSerializeOptions | undefined): void;
+    terminate(): void;
+    removeEventListener<K_3 extends keyof WorkerEventMap>(type: K_3, listener: (this: Worker, ev: WorkerEventMap[K_3]) => any, options?: boolean | EventListenerOptions | undefined): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+    dispatchEvent(event: Event): boolean;
+    onerror: ((this: AbstractWorker, ev: ErrorEvent) => any) | null;
+};
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "osra",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "description": "Easy communication between workers",
   "files": [
     "build"
@@ -31,7 +31,9 @@
   "homepage": "https://github.com/Banou26/osra#readme",
   "devDependencies": {
     "@types/chai-as-promised": "^7.1.5",
+    "@types/chrome": "^0.0.237",
     "@types/node": "^18.11.18",
+    "@types/webextension-polyfill": "^0.10.0",
     "chai": "^4.3.6",
     "chai-as-promised": "^7.1.1",
     "concurrently": "^7.0.0",
@@ -39,6 +41,7 @@
     "epk": "^0.16.0",
     "mime": "^3.0.0",
     "typescript": "^4.9.4",
-    "vite": "^4.0.4"
+    "vite": "^4.0.4",
+    "webextension-polyfill": "^0.10.0"
   }
 }