remoteclient

dist/RemoteClient.d.ts

@@ -0,0 +1,13 @@
+/// <reference lib="webworker" />
+import { BareHeaders, BareTransport, TransferrableResponse } from './BareTypes';
+export declare function registerRemoteListener(channel: ServiceWorker): void;
+export default class RemoteTransport implements BareTransport {
+    canstart: boolean;
+    ready: boolean;
+    promises: Map<string, (data: any) => void>;
+    constructor();
+    init(): Promise<void>;
+    meta(): Promise<void>;
+    request(remote: URL, method: string, body: BodyInit | null, headers: BareHeaders, signal: AbortSignal | undefined): Promise<TransferrableResponse>;
+    connect(url: URL, origin: string, protocols: string[], requestHeaders: BareHeaders, onopen: (protocol: string) => void, onmessage: (data: Blob | ArrayBuffer | string) => void, onclose: (code: number, reason: string) => void, onerror: (error: string) => void): (data: Blob | ArrayBuffer | string) => void;
+}

dist/bare.cjs

@@ -1,8 +1,8 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('uuid')) :
-  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  typeof define === 'function' && define.amd ? define(['exports', 'uuid'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.BareMux = {}));
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.BareMux = {}, global.uuid));
-})(this, (function (exports) { 'use strict';
+})(this, (function (exports, uuid) { 'use strict';
 
   const maxRedirects = 20;
 
@@ -22,7 +22,162 @@
       OPEN: WebSocket.OPEN,
   };
 
-  self.BCC_VERSION = "3.0.2";
+  /// <reference lib="WebWorker" />
+  function registerRemoteListener(channel) {
+      navigator.serviceWorker.addEventListener("message", async ({ data }) => {
+          if (data.type === "request") {
+              const { remote, method, body, headers } = data;
+              let response = await findSwitcher().active?.request(new URL(remote), method, body, headers, undefined);
+              let transferred = [];
+              if (response.body instanceof ArrayBuffer || response.body instanceof Blob || response.body instanceof ReadableStream) {
+                  transferred.push(response.body);
+              }
+              response.id = data.id;
+              response.type = "response";
+              channel.postMessage(response, transferred);
+          }
+      });
+  }
+  let remote;
+  if ("ServiceWorkerGlobalScope" in self) {
+      addEventListener("message", async ({ data }) => {
+          if (data.type === "response") {
+              let resolve = remote.promises.get(data.id);
+              if (resolve) {
+                  resolve(data);
+                  remote.promises.delete(data.id);
+              }
+          }
+      });
+  }
+  class RemoteTransport {
+      canstart = true;
+      ready = false;
+      promises = new Map();
+      constructor() {
+          if (!("ServiceWorkerGlobalScope" in self)) {
+              throw new TypeError("Attempt to construct RemoteClient from outside a service worker");
+          }
+      }
+      async init() {
+          remote = this;
+          this.ready = true;
+      }
+      async meta() { }
+      async request(remote, method, body, headers, signal) {
+          let id = uuid.v4();
+          const clients = await self.clients.matchAll();
+          if (clients.length < 1)
+              throw new Error("no available clients");
+          for (const client of clients) {
+              client.postMessage({
+                  type: "request",
+                  id,
+                  remote: remote.toString(),
+                  method,
+                  body,
+                  headers
+              });
+          }
+          return await new Promise((resolve, reject) => {
+              this.promises.set(id, resolve);
+          });
+      }
+      connect(url, origin, protocols, requestHeaders, onopen, onmessage, onclose, onerror) {
+          throw "why are you calling connect from remoteclient";
+      }
+  }
+  //
+  // declare const self: ServiceWorkerGlobalScope;
+  // export default class RemoteClient extends Client {
+  //   static singleton: RemoteClient;
+  //   private callbacks: Record<string, (message: Record<string, any>) => void> = {};
+  //
+  //   private uid = uuid();
+  //   constructor() {
+  //     if (RemoteClient.singleton) return RemoteClient.singleton;
+  //     super();
+  //     // this should be fine
+  //     // if (!("ServiceWorkerGlobalScope" in self)) {
+  //     //   throw new TypeError("Attempt to construct RemoteClient from outside a service worker")
+  //     // }
+  //
+  //     addEventListener("message", (event) => {
+  //       if (event.data.__remote_target === this.uid) {
+  //         const callback = this.callbacks[event.data.__remote_id];
+  //         callback(event.data.__remote_value);
+  //       }
+  //     });
+  //
+  //     RemoteClient.singleton = this;
+  //   }
+  //
+  //   async send(message: Record<string, any>, id?: string) {
+  //     const clients = await self.clients.matchAll();
+  //     if (clients.length < 1)
+  //       throw new Error("no available clients");
+  //
+  //     for (const client of clients) {
+  //       client.postMessage({
+  //         __remote_target: this.uid,
+  //         __remote_id: id,
+  //         __remote_value: message
+  //       })
+  //     }
+  //
+  //   }
+  //
+  //   async sendWithResponse(message: Record<string, any>): Promise<any> {
+  //     const id = uuid();
+  //     return new Promise((resolve) => {
+  //       this.callbacks[id] = resolve;
+  //       this.send(message, id);
+  //     });
+  //   }
+  //
+  //   connect(
+  //     ...args: any
+  //   ) {
+  //     throw "why are you calling connect from remoteclient"
+  //   }
+  //   async request(
+  //     method: BareMethod,
+  //     requestHeaders: BareHeaders,
+  //     body: BodyInit | null,
+  //     remote: URL,
+  //     cache: BareCache | undefined,
+  //     duplex: string | undefined,
+  //     signal: AbortSignal | undefined
+  //   ): Promise<BareResponse> {
+  //
+  //     const response = await this.sendWithResponse({
+  //       type: "request",
+  //       options: {
+  //         method,
+  //         requestHeaders,
+  //         body,
+  //         remote: remote.toString(),
+  //       },
+  //     });
+  //     // const readResponse = await this.readBareResponse(response);
+  //
+  //     const result: Response & Partial<BareResponse> = new Response(
+  //       statusEmpty.includes(response.status!) ? undefined : response.body,
+  //       {
+  //         status: response.status,
+  //         statusText: response.statusText ?? undefined,
+  //         headers: new Headers(response.headers as HeadersInit),
+  //       }
+  //     );
+  //
+  //     result.rawHeaders = response.rawHeaders;
+  //     result.rawResponse = response;
+  //
+  //     return result as BareResponse;
+  //   }
+  // }
+
+  self.BCC_VERSION = "3.0.4";
   console.warn("BCC_VERSION: " + self.BCC_VERSION);
   class Switcher {
       active = null;
@@ -32,7 +187,7 @@
               console.log(type, data, "ServiceWorker" in globalThis);
               switch (type) {
                   case "setremote":
-                      // this.active = new RemoteClient
+                      this.active = new RemoteTransport;
                       break;
                   case "set":
                       const { name, config } = data;
@@ -181,7 +336,6 @@
                   if (socket.binaryType === "arraybuffer") {
                       payload = await payload.arrayBuffer();
                       Object.setPrototypeOf(payload, arrayBufferImpl);
-                      console.log(payload);
                   }
                   socket.dispatchEvent(new MessageEvent("message", { data: payload }));
               }
@@ -339,6 +493,7 @@
   exports.default = BareClient;
   exports.findSwitcher = findSwitcher;
   exports.maxRedirects = maxRedirects;
+  exports.registerRemoteListener = registerRemoteListener;
 
   Object.defineProperty(exports, '__esModule', { value: true });
 

dist/index.d.ts

@@ -1,5 +1,6 @@
 export * from './BareTypes';
 export * from './BareClient';
 export * from './Switcher';
+export * from './RemoteClient';
 export { BareClient as default } from './BareClient';
 export { WebSocketFields } from "./snapshot";

dist/index.js

@@ -1,3 +1,5 @@
+import { v4 } from 'uuid';
+
 const maxRedirects = 20;
 
 // The user likely has overwritten all networking functions after importing bare-client
@@ -16,7 +18,162 @@ const WebSocketFields = {
     OPEN: WebSocket.OPEN,
 };
 
-self.BCC_VERSION = "3.0.2";
+/// <reference lib="WebWorker" />
+function registerRemoteListener(channel) {
+    navigator.serviceWorker.addEventListener("message", async ({ data }) => {
+        if (data.type === "request") {
+            const { remote, method, body, headers } = data;
+            let response = await findSwitcher().active?.request(new URL(remote), method, body, headers, undefined);
+            let transferred = [];
+            if (response.body instanceof ArrayBuffer || response.body instanceof Blob || response.body instanceof ReadableStream) {
+                transferred.push(response.body);
+            }
+            response.id = data.id;
+            response.type = "response";
+            channel.postMessage(response, transferred);
+        }
+    });
+}
+let remote;
+if ("ServiceWorkerGlobalScope" in self) {
+    addEventListener("message", async ({ data }) => {
+        if (data.type === "response") {
+            let resolve = remote.promises.get(data.id);
+            if (resolve) {
+                resolve(data);
+                remote.promises.delete(data.id);
+            }
+        }
+    });
+}
+class RemoteTransport {
+    canstart = true;
+    ready = false;
+    promises = new Map();
+    constructor() {
+        if (!("ServiceWorkerGlobalScope" in self)) {
+            throw new TypeError("Attempt to construct RemoteClient from outside a service worker");
+        }
+    }
+    async init() {
+        remote = this;
+        this.ready = true;
+    }
+    async meta() { }
+    async request(remote, method, body, headers, signal) {
+        let id = v4();
+        const clients = await self.clients.matchAll();
+        if (clients.length < 1)
+            throw new Error("no available clients");
+        for (const client of clients) {
+            client.postMessage({
+                type: "request",
+                id,
+                remote: remote.toString(),
+                method,
+                body,
+                headers
+            });
+        }
+        return await new Promise((resolve, reject) => {
+            this.promises.set(id, resolve);
+        });
+    }
+    connect(url, origin, protocols, requestHeaders, onopen, onmessage, onclose, onerror) {
+        throw "why are you calling connect from remoteclient";
+    }
+}
+//
+// declare const self: ServiceWorkerGlobalScope;
+// export default class RemoteClient extends Client {
+//   static singleton: RemoteClient;
+//   private callbacks: Record<string, (message: Record<string, any>) => void> = {};
+//
+//   private uid = uuid();
+//   constructor() {
+//     if (RemoteClient.singleton) return RemoteClient.singleton;
+//     super();
+//     // this should be fine
+//     // if (!("ServiceWorkerGlobalScope" in self)) {
+//     //   throw new TypeError("Attempt to construct RemoteClient from outside a service worker")
+//     // }
+//
+//     addEventListener("message", (event) => {
+//       if (event.data.__remote_target === this.uid) {
+//         const callback = this.callbacks[event.data.__remote_id];
+//         callback(event.data.__remote_value);
+//       }
+//     });
+//
+//     RemoteClient.singleton = this;
+//   }
+//
+//   async send(message: Record<string, any>, id?: string) {
+//     const clients = await self.clients.matchAll();
+//     if (clients.length < 1)
+//       throw new Error("no available clients");
+//
+//     for (const client of clients) {
+//       client.postMessage({
+//         __remote_target: this.uid,
+//         __remote_id: id,
+//         __remote_value: message
+//       })
+//     }
+//
+//   }
+//
+//   async sendWithResponse(message: Record<string, any>): Promise<any> {
+//     const id = uuid();
+//     return new Promise((resolve) => {
+//       this.callbacks[id] = resolve;
+//       this.send(message, id);
+//     });
+//   }
+//
+//   connect(
+//     ...args: any
+//   ) {
+//     throw "why are you calling connect from remoteclient"
+//   }
+//   async request(
+//     method: BareMethod,
+//     requestHeaders: BareHeaders,
+//     body: BodyInit | null,
+//     remote: URL,
+//     cache: BareCache | undefined,
+//     duplex: string | undefined,
+//     signal: AbortSignal | undefined
+//   ): Promise<BareResponse> {
+//
+//     const response = await this.sendWithResponse({
+//       type: "request",
+//       options: {
+//         method,
+//         requestHeaders,
+//         body,
+//         remote: remote.toString(),
+//       },
+//     });
+//     // const readResponse = await this.readBareResponse(response);
+//
+//     const result: Response & Partial<BareResponse> = new Response(
+//       statusEmpty.includes(response.status!) ? undefined : response.body,
+//       {
+//         status: response.status,
+//         statusText: response.statusText ?? undefined,
+//         headers: new Headers(response.headers as HeadersInit),
+//       }
+//     );
+//
+//     result.rawHeaders = response.rawHeaders;
+//     result.rawResponse = response;
+//
+//     return result as BareResponse;
+//   }
+// }
+
+self.BCC_VERSION = "3.0.4";
 console.warn("BCC_VERSION: " + self.BCC_VERSION);
 class Switcher {
     active = null;
@@ -26,7 +183,7 @@ class Switcher {
             console.log(type, data, "ServiceWorker" in globalThis);
             switch (type) {
                 case "setremote":
-                    // this.active = new RemoteClient
+                    this.active = new RemoteTransport;
                     break;
                 case "set":
                     const { name, config } = data;
@@ -175,7 +332,6 @@ class BareClient {
                 if (socket.binaryType === "arraybuffer") {
                     payload = await payload.arrayBuffer();
                     Object.setPrototypeOf(payload, arrayBufferImpl);
-                    console.log(payload);
                 }
                 socket.dispatchEvent(new MessageEvent("message", { data: payload }));
             }
@@ -326,5 +482,5 @@ class BareClient {
     }
 }
 
-export { BareClient, SetSingletonTransport, SetTransport, WebSocketFields, BareClient as default, findSwitcher, maxRedirects };
+export { BareClient, SetSingletonTransport, SetTransport, WebSocketFields, BareClient as default, findSwitcher, maxRedirects, registerRemoteListener };
 //# sourceMappingURL=index.js.map

src/RemoteClient.ts

@@ -1,5 +1,97 @@
-// /// <reference lib="WebWorker" />
+/// <reference lib="WebWorker" />
-// import { v4 as uuid } from 'uuid';
+import { v4 as uuid } from 'uuid';
+import { BareHeaders, BareTransport, TransferrableResponse } from './BareTypes';
+import { findSwitcher } from './Switcher';
+
+export function registerRemoteListener(channel: ServiceWorker) {
+  (navigator as any).serviceWorker.addEventListener("message", async ({ data }) => {
+    if (data.type === "request") {
+      const { remote, method, body, headers } = data;
+
+      let response: any = await findSwitcher().active?.request(new URL(remote), method, body, headers, undefined)!;
+      let transferred: any = [];
+      if (response.body instanceof ArrayBuffer || response.body instanceof Blob || response.body instanceof ReadableStream) {
+        transferred.push(response.body);
+      }
+      response.id = data.id;
+      response.type = "response";
+      channel.postMessage(response, transferred);
+    }
+  });
+}
+
+declare var self: ServiceWorkerGlobalScope;
+let remote: RemoteTransport;
+if ("ServiceWorkerGlobalScope" in self) {
+  addEventListener("message", async ({ data }) => {
+    if (data.type === "response") {
+      let resolve = remote.promises.get(data.id);
+      if (resolve) {
+        resolve(data);
+        remote.promises.delete(data.id);
+      }
+    }
+  });
+}
+
+export default class RemoteTransport implements BareTransport {
+  canstart = true;
+  ready = false;
+  promises = new Map<string, (data: any) => void>();
+  constructor() {
+    if (!("ServiceWorkerGlobalScope" in self)) {
+      throw new TypeError("Attempt to construct RemoteClient from outside a service worker")
+    }
+  }
+
+  async init() {
+    remote = this;
+    this.ready = true;
+  }
+
+  async meta() { }
+  async request(
+    remote: URL,
+    method: string,
+    body: BodyInit | null,
+    headers: BareHeaders,
+    signal: AbortSignal | undefined
+  ): Promise<TransferrableResponse> {
+    let id = uuid();
+    const clients = await self.clients.matchAll();
+    if (clients.length < 1)
+      throw new Error("no available clients");
+
+    for (const client of clients) {
+      client.postMessage({
+        type: "request",
+        id,
+        remote: remote.toString(),
+        method,
+        body,
+        headers
+      });
+    }
+
+
+    return await new Promise((resolve, reject) => {
+      this.promises.set(id, resolve);
+    });
+  }
+
+  connect(
+    url: URL,
+    origin: string,
+    protocols: string[],
+    requestHeaders: BareHeaders,
+    onopen: (protocol: string) => void,
+    onmessage: (data: Blob | ArrayBuffer | string) => void,
+    onclose: (code: number, reason: string) => void,
+    onerror: (error: string) => void
+  ): (data: Blob | ArrayBuffer | string) => void {
+    throw "why are you calling connect from remoteclient"
+  }
+}
 //
 // declare const self: ServiceWorkerGlobalScope;
 // export default class RemoteClient extends Client {

src/Switcher.ts

@@ -1,6 +1,7 @@
 import { BareTransport } from "./BareTypes";
+import RemoteTransport from "./RemoteClient";
 
-self.BCC_VERSION = "3.0.2";
+self.BCC_VERSION = "3.0.4";
 console.warn("BCC_VERSION: " + self.BCC_VERSION);
 
 declare global {
@@ -31,7 +32,7 @@ class Switcher {
       console.log(type, data, "ServiceWorker" in globalThis);
       switch (type) {
         case "setremote":
-          // this.active = new RemoteClient
+          this.active = new RemoteTransport
           break;
         case "set":
           const { name, config } = data;

src/index.ts

@@ -1,5 +1,6 @@
 export * from './BareTypes';
 export * from './BareClient';
 export * from './Switcher';
+export * from './RemoteClient';
 export { BareClient as default } from './BareClient';
 export { WebSocketFields } from "./snapshot";