swarpc 0.2.0 → 0.2.2

package/dist/swarpc.d.ts

@@ -1,23 +1,8 @@
-/**
- * @import { ProceduresMap, SwarpcClient, SwarpcServer } from './typings.js'
- */
-/**
- * @template {ProceduresMap} Procedures
- * @param {Procedures} procedures
- * @returns {SwarpcServer<Procedures>}
- */
-export function Server<Procedures extends ProceduresMap>(procedures: Procedures): SwarpcServer<Procedures>;
-/**
- * @template {ProceduresMap} Procedures
- * @param {Procedures} procedures
- * @param {object} [options]
- * @param {Worker} [options.worker] the worker instance to connect to -- uses the navigator's service worker if not provided
- * @returns {SwarpcClient<Procedures>}
- */
-export function Client<Procedures extends ProceduresMap>(procedures: Procedures, { worker }?: {
+import type { ProceduresMap, SwarpcClient, SwarpcServer } from "./types";
+export declare function Server<Procedures extends ProceduresMap>(procedures: Procedures, { worker }?: {
+    worker?: Worker;
+}): SwarpcServer<Procedures>;
+export declare function Client<Procedures extends ProceduresMap>(procedures: Procedures, { worker }?: {
     worker?: Worker;
 }): SwarpcClient<Procedures>;
-import type { ProceduresMap } from './typings.js';
-import type { SwarpcServer } from './typings.js';
-import type { SwarpcClient } from './typings.js';
 //# sourceMappingURL=swarpc.d.ts.map

package/dist/swarpc.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"swarpc.d.ts","sourceRoot":"","sources":["../src/swarpc.js"],"names":[],"mappings":"AAEA;;GAEG;AAEH;;;;GAIG;AACH,uBAJ6B,UAAU,SAA1B,aAAe,cACjB,UAAU,GACR,aAAa,UAAU,CAAC,CAsGpC;AA0DD;;;;;;GAMG;AACH,uBAN6B,UAAU,SAA1B,aAAe,cACjB,UAAU,eAElB;IAAyB,MAAM,GAAvB,MAAM;CACd,GAAU,aAAa,UAAU,CAAC,CAiCpC;mCA5M6D,cAAc;kCAAd,cAAc;kCAAd,cAAc"}
+{"version":3,"file":"swarpc.d.ts","sourceRoot":"","sources":["../src/swarpc.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,aAAa,EACb,YAAY,EACZ,YAAY,EAEb,MAAM,SAAS,CAAA;AAEhB,wBAAgB,MAAM,CAAC,UAAU,SAAS,aAAa,EACrD,UAAU,EAAE,UAAU,EACtB,EAAE,MAAM,EAAE,GAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAO,GACnC,YAAY,CAAC,UAAU,CAAC,CAyE1B;AAwDD,wBAAgB,MAAM,CAAC,UAAU,SAAS,aAAa,EACrD,UAAU,EAAE,UAAU,EACtB,EAAE,MAAM,EAAE,GAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAO,GACnC,YAAY,CAAC,UAAU,CAAC,CAiC1B"}

package/dist/swarpc.js

@@ -0,0 +1,120 @@
+import { type } from "arktype";
+export function Server(procedures, { worker } = {}) {
+    const instance = {
+        procedures,
+        implementations: {},
+        start: () => { },
+    };
+    for (const functionName in procedures) {
+        instance[functionName] = ((implementation) => {
+            if (!instance.procedures[functionName]) {
+                throw new Error(`No procedure found for function name: ${functionName}`);
+            }
+            instance.implementations[functionName] = implementation;
+        });
+    }
+    const PayloadSchema = type.or(...Object.entries(procedures).map(([functionName, { input }]) => ({
+        functionName: type(`"${functionName}"`),
+        requestId: type("string >= 1"),
+        input,
+    })));
+    instance.start = (self) => {
+        const postMessage = async (data) => {
+            if (worker) {
+                self.postMessage(data);
+            }
+            else {
+                await self.clients.matchAll().then((clients) => {
+                    clients.forEach((client) => client.postMessage(data));
+                });
+            }
+        };
+        self.addEventListener("message", async (event) => {
+            const { functionName, requestId, input } = PayloadSchema.assert(event.data);
+            const postError = async (error) => postMessage({
+                functionName,
+                requestId,
+                error: {
+                    message: "message" in error ? error.message : String(error),
+                },
+            });
+            const implementation = instance.implementations[functionName];
+            if (!implementation) {
+                await postError("No implementation found");
+                return;
+            }
+            await implementation(input, async (progress) => {
+                await postMessage({ functionName, requestId, progress });
+            })
+                .catch(async (error) => {
+                await postError(error);
+            })
+                .then(async (result) => {
+                await postMessage({ functionName, requestId, result });
+            });
+        });
+    };
+    return instance;
+}
+function generateRequestId() {
+    return Math.random().toString(36).substring(2, 15);
+}
+const pendingRequests = new Map();
+let _clientListenerStarted = false;
+async function startClientListener(worker) {
+    if (_clientListenerStarted)
+        return;
+    if (!worker) {
+        const sw = await navigator.serviceWorker.ready;
+        if (!sw?.active) {
+            throw new Error("[SWARPC Client] Service Worker is not active");
+        }
+        if (!navigator.serviceWorker.controller) {
+            console.warn("[SWARPC Client] Service Worker is not controlling the page");
+        }
+    }
+    const w = worker ?? navigator.serviceWorker;
+    w.addEventListener("message", (event) => {
+        const { functionName, requestId, ...data } = event.data || {};
+        if (!requestId) {
+            throw new Error("[SWARPC Client] Message received without requestId");
+        }
+        const handlers = pendingRequests.get(requestId);
+        if (!handlers) {
+            throw new Error(`[SWARPC Client] ${requestId} has no active request handlers`);
+        }
+        if ("error" in data) {
+            handlers.reject(new Error(data.error.message));
+            pendingRequests.delete(requestId);
+        }
+        else if ("progress" in data) {
+            handlers.onProgress(data.progress);
+        }
+        else if ("result" in data) {
+            handlers.resolve(data.result);
+            pendingRequests.delete(requestId);
+        }
+    });
+    _clientListenerStarted = true;
+}
+export function Client(procedures, { worker } = {}) {
+    const instance = { procedures };
+    for (const functionName of Object.keys(procedures)) {
+        instance[functionName] = (async (input, onProgress = () => { }) => {
+            procedures[functionName].input.assert(input);
+            await startClientListener(worker);
+            const w = worker ?? (await navigator.serviceWorker.ready.then((r) => r.active));
+            if (!w) {
+                throw new Error("[SWARPC Client] No active service worker found");
+            }
+            return new Promise((resolve, reject) => {
+                if (!worker && !navigator.serviceWorker.controller)
+                    console.warn("[SWARPC Client] Service Worker is not controlling the page");
+                const requestId = generateRequestId();
+                pendingRequests.set(requestId, { resolve, onProgress, reject });
+                w.postMessage({ functionName, input, requestId });
+            });
+        });
+    }
+    return instance;
+}

package/dist/{typings.d.ts → types.d.ts}

@@ -1,18 +1,24 @@
+import type { Type } from "arktype";
 export type Procedure<I extends Type, P extends Type, S extends Type> = {
     input: I;
     progress: P;
     success: S;
 };
-export type ProcedureImplementation<I extends Type, P extends Type, S extends Type> = (input: I["inferOut"], onProgress: (progress: P["inferOut"]) => void) => Promise<NoInfer<S>["inferOut"] | NoInfer<S>["inferOut"]>;
+export type ProcedureImplementation<I extends Type, P extends Type, S extends Type> = (input: I["inferOut"], onProgress: (progress: P["inferOut"]) => void) => Promise<S["inferOut"]>;
 export type ProceduresMap = Record<string, Procedure<Type, Type, Type>>;
 export type ClientMethod<P extends Procedure<Type, Type, Type>> = (input: P["input"]["inferIn"], onProgress?: (progress: P["progress"]["inferOut"]) => void) => Promise<P["success"]["inferOut"]>;
 export type SwarpcClient<Procedures extends ProceduresMap> = {
     procedures: Procedures;
-} & { [F in keyof Procedures]: ClientMethod<Procedures[F]>; };
+} & {
+    [F in keyof Procedures]: ClientMethod<Procedures[F]>;
+};
 export type SwarpcServer<Procedures extends ProceduresMap> = {
     procedures: Procedures;
-    implementations: { [F in keyof Procedures]: ProcedureImplementation<Procedures[F]["input"], Procedures[F]["progress"], Procedures[F]["success"]>; };
-    start: (self: Window) => void;
-} & { [F in keyof Procedures]: (impl: NoInfer<ProcedureImplementation<Procedures[F]["input"], Procedures[F]["progress"], Procedures[F]["success"]>>) => void; };
-import type { Type } from 'arktype';
-//# sourceMappingURL=typings.d.ts.map
+    implementations: {
+        [F in keyof Procedures]: ProcedureImplementation<Procedures[F]["input"], Procedures[F]["progress"], Procedures[F]["success"]>;
+    };
+    start(self: Window): void;
+} & {
+    [F in keyof Procedures]: (impl: ProcedureImplementation<Procedures[F]["input"], Procedures[F]["progress"], Procedures[F]["success"]>) => void;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAEpC,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,IAAI,EAAE,CAAC,SAAS,IAAI,EAAE,CAAC,SAAS,IAAI,IAAI;IACtE,KAAK,EAAE,CAAC,CAAC;IACT,QAAQ,EAAE,CAAC,CAAC;IACZ,OAAO,EAAE,CAAC,CAAC;CACZ,CAAC;AAEF,MAAM,MAAM,uBAAuB,CACjC,CAAC,SAAS,IAAI,EACd,CAAC,SAAS,IAAI,EACd,CAAC,SAAS,IAAI,IACZ,CACF,KAAK,EAAE,CAAC,CAAC,UAAU,CAAC,EACpB,UAAU,EAAE,CAAC,QAAQ,EAAE,CAAC,CAAC,UAAU,CAAC,KAAK,IAAI,KAC1C,OAAO,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC;AAE5B,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;AAExE,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,CAChE,KAAK,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,SAAS,CAAC,EAC5B,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,CAAC,CAAC,UAAU,CAAC,CAAC,UAAU,CAAC,KAAK,IAAI,KACvD,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC;AAEvC,MAAM,MAAM,YAAY,CAAC,UAAU,SAAS,aAAa,IAAI;IAC3D,UAAU,EAAE,UAAU,CAAC;CACxB,GAAG;KACD,CAAC,IAAI,MAAM,UAAU,GAAG,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;CACrD,CAAC;AAEF,MAAM,MAAM,YAAY,CAAC,UAAU,SAAS,aAAa,IAAI;IAC3D,UAAU,EAAE,UAAU,CAAC;IACvB,eAAe,EAAE;SACd,CAAC,IAAI,MAAM,UAAU,GAAG,uBAAuB,CAC9C,UAAU,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,EACtB,UAAU,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,EACzB,UAAU,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CACzB;KACF,CAAC;IACF,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B,GAAG;KACD,CAAC,IAAI,MAAM,UAAU,GAAG,CACvB,IAAI,EAAE,uBAAuB,CAC3B,UAAU,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,EACtB,UAAU,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,EACzB,UAAU,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CACzB,KACE,IAAI;CACV,CAAC"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swarpc",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Full type-safe RPC library for service worker -- move things off of the UI thread with ease!",
   "keywords": [
     "service-workers",
@@ -24,12 +24,12 @@
     "dist",
     "src"
   ],
-  "main": "src/swarpc.js",
+  "main": "dist/swarpc.js",
   "types": "dist/swarpc.d.ts",
   "scripts": {
     "build": "tsc",
     "test": "echo \"Error: no test specified\" && exit 1",
-    "typedoc": "typedoc src/swarpc.js src/typings.js --readme README.md"
+    "typedoc": "typedoc src/swarpc.ts src/types.ts --readme README.md"
   },
   "dependencies": {
     "arktype": "^2.1.20"

package/src/swarpc.ts

@@ -0,0 +1,175 @@
+import { type } from "arktype"
+import type { ProceduresMap, SwarpcClient, SwarpcServer } from "./types.js"
+
+export function Server<Procedures extends ProceduresMap>(
+  procedures: Procedures,
+  { worker }: { worker?: Worker } = {}
+): SwarpcServer<Procedures> {
+  const instance = {
+    procedures,
+    implementations: {} as SwarpcServer<Procedures>["implementations"],
+    start: () => {},
+  } as SwarpcServer<Procedures>
+
+  for (const functionName in procedures) {
+    instance[functionName] = ((implementation) => {
+      if (!instance.procedures[functionName]) {
+        throw new Error(`No procedure found for function name: ${functionName}`)
+      }
+      instance.implementations[functionName] = implementation as any
+    }) as SwarpcServer<Procedures>[typeof functionName]
+  }
+
+  const PayloadSchema = type.or(
+    ...Object.entries(procedures).map(([functionName, { input }]) => ({
+      functionName: type(`"${functionName}"`),
+      requestId: type("string >= 1"),
+      input,
+    }))
+  )
+
+  instance.start = (self: Window) => {
+    const postMessage = async (
+      data: { functionName: string; requestId: string } & Partial<{
+        result: any
+        error: any
+        progress: any
+      }>
+    ) => {
+      if (worker) {
+        self.postMessage(data)
+      } else {
+        await (self as any).clients.matchAll().then((clients: any[]) => {
+          clients.forEach((client) => client.postMessage(data))
+        })
+      }
+    }
+
+    self.addEventListener("message", async (event: MessageEvent) => {
+      const { functionName, requestId, input } = PayloadSchema.assert(
+        event.data
+      )
+      const postError = async (error: any) =>
+        postMessage({
+          functionName,
+          requestId,
+          error: {
+            message: "message" in error ? error.message : String(error),
+          },
+        })
+
+      const implementation = instance.implementations[functionName]
+      if (!implementation) {
+        await postError("No implementation found")
+        return
+      }
+
+      await implementation(input, async (progress: any) => {
+        await postMessage({ functionName, requestId, progress })
+      })
+        .catch(async (error: any) => {
+          await postError(error)
+        })
+        .then(async (result: any) => {
+          await postMessage({ functionName, requestId, result })
+        })
+    })
+  }
+
+  return instance
+}
+
+function generateRequestId(): string {
+  return Math.random().toString(36).substring(2, 15)
+}
+
+type PendingRequest = {
+  reject: (err: Error) => void
+  onProgress: (progress: any) => void
+  resolve: (result: any) => void
+}
+
+const pendingRequests = new Map<string, PendingRequest>()
+
+let _clientListenerStarted = false
+async function startClientListener(worker?: Worker) {
+  if (_clientListenerStarted) return
+
+  if (!worker) {
+    const sw = await navigator.serviceWorker.ready
+    if (!sw?.active) {
+      throw new Error("[SWARPC Client] Service Worker is not active")
+    }
+
+    if (!navigator.serviceWorker.controller) {
+      console.warn("[SWARPC Client] Service Worker is not controlling the page")
+    }
+  }
+
+  const w = worker ?? navigator.serviceWorker
+  w.addEventListener("message", (event) => {
+    const { functionName, requestId, ...data } =
+      (event as MessageEvent).data || {}
+
+    if (!requestId) {
+      throw new Error("[SWARPC Client] Message received without requestId")
+    }
+
+    const handlers = pendingRequests.get(requestId)
+    if (!handlers) {
+      throw new Error(
+        `[SWARPC Client] ${requestId} has no active request handlers`
+      )
+    }
+
+    if ("error" in data) {
+      handlers.reject(new Error(data.error.message))
+      pendingRequests.delete(requestId)
+    } else if ("progress" in data) {
+      handlers.onProgress(data.progress)
+    } else if ("result" in data) {
+      handlers.resolve(data.result)
+      pendingRequests.delete(requestId)
+    }
+  })
+
+  _clientListenerStarted = true
+}
+
+export function Client<Procedures extends ProceduresMap>(
+  procedures: Procedures,
+  { worker }: { worker?: Worker } = {}
+): SwarpcClient<Procedures> {
+  const instance = { procedures } as Partial<SwarpcClient<Procedures>>
+
+  for (const functionName of Object.keys(procedures) as Array<
+    keyof Procedures
+  >) {
+    instance[functionName] = (async (input: unknown, onProgress = () => {}) => {
+      procedures[functionName].input.assert(input)
+      await startClientListener(worker)
+
+      const w =
+        worker ?? (await navigator.serviceWorker.ready.then((r) => r.active))
+
+      if (!w) {
+        throw new Error("[SWARPC Client] No active service worker found")
+      }
+
+      return new Promise((resolve, reject) => {
+        if (!worker && !navigator.serviceWorker.controller)
+          console.warn(
+            "[SWARPC Client] Service Worker is not controlling the page"
+          )
+
+        const requestId = generateRequestId()
+
+        pendingRequests.set(requestId, { resolve, onProgress, reject })
+
+        w.postMessage({ functionName, input, requestId })
+      })
+    }) as SwarpcClient<Procedures>[typeof functionName]
+  }
+
+  return instance as SwarpcClient<Procedures>
+}

package/src/types.ts

@@ -0,0 +1,49 @@
+import type { Type } from "arktype";
+
+export type Procedure<I extends Type, P extends Type, S extends Type> = {
+  input: I;
+  progress: P;
+  success: S;
+};
+
+export type ProcedureImplementation<
+  I extends Type,
+  P extends Type,
+  S extends Type
+> = (
+  input: I["inferOut"],
+  onProgress: (progress: P["inferOut"]) => void
+) => Promise<S["inferOut"]>;
+
+export type ProceduresMap = Record<string, Procedure<Type, Type, Type>>;
+
+export type ClientMethod<P extends Procedure<Type, Type, Type>> = (
+  input: P["input"]["inferIn"],
+  onProgress?: (progress: P["progress"]["inferOut"]) => void
+) => Promise<P["success"]["inferOut"]>;
+
+export type SwarpcClient<Procedures extends ProceduresMap> = {
+  procedures: Procedures;
+} & {
+  [F in keyof Procedures]: ClientMethod<Procedures[F]>;
+};
+
+export type SwarpcServer<Procedures extends ProceduresMap> = {
+  procedures: Procedures;
+  implementations: {
+    [F in keyof Procedures]: ProcedureImplementation<
+      Procedures[F]["input"],
+      Procedures[F]["progress"],
+      Procedures[F]["success"]
+    >;
+  };
+  start(self: Window): void;
+} & {
+  [F in keyof Procedures]: (
+    impl: ProcedureImplementation<
+      Procedures[F]["input"],
+      Procedures[F]["progress"],
+      Procedures[F]["success"]
+    >
+  ) => void;
+};

package/dist/typings.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"typings.d.ts","sourceRoot":"","sources":["../src/typings.js"],"names":[],"mappings":"sBAKoB,CAAC,SAAR,IAAM,EACC,CAAC,SAAR,IAAM,EACC,CAAC,SAAR,IAAM;WAEL,CAAC;cACD,CAAC;aACD,CAAC;;oCAIK,CAAC,SAAR,IAAM,EACC,CAAC,SAAR,IAAM,EACC,CAAC,SAAR,IAAM,IACN,CAAC,KAAK,EAAE,CAAC,CAAC,UAAU,CAAC,EAAE,UAAU,EAAE,CAAC,QAAQ,EAAE,CAAC,CAAC,UAAU,CAAC,KAAK,IAAI,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC;4BAIjI,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;yBAIb,CAAC,SAA9B,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAE,IAC7B,CAAC,KAAK,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,SAAS,CAAC,EAAE,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,CAAC,CAAC,UAAU,CAAC,CAAC,UAAU,CAAC,KAAK,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,UAAU,CAAC,CAAC;yBAI/G,UAAU,SAAzB,aAAc,IACf;IAAE,UAAU,EAAE,UAAU,CAAA;CAAE,GAAG,GAAG,CAAC,IAAI,MAAM,UAAU,GAAG,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,GAAE;yBAIrE,UAAU,SAAzB,aAAc,IACf;IAAE,UAAU,EAAE,UAAU,CAAC;IAAC,eAAe,EAAE,GAAE,CAAC,IAAI,MAAM,UAAU,GAAG,uBAAuB,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,GAAE,CAAC;IAAC,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;CAAG,GAAG,GAAG,CAAC,IAAI,MAAM,UAAU,GAAG,CAAC,IAAI,EAAE,OAAO,CAAC,uBAAuB,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAE,CAAC,KAAK,IAAI,GAAE;0BApC/V,SAAS"}

package/src/swarpc.js

@@ -1,215 +0,0 @@
-import { type } from "arktype"
-
-/**
- * @import { ProceduresMap, SwarpcClient, SwarpcServer } from './typings.js'
- */
-
-/**
- * @template {ProceduresMap} Procedures
- * @param {Procedures} procedures
- * @param {object} [options]
- * @param {Worker} [options.worker] the worker instance to connect to -- uses the navigator's service worker if not provided
- * @returns {SwarpcServer<Procedures>}
- */
-export function Server(procedures, { worker } = { worker: undefined }) {
-  /** @type {SwarpcServer<Procedures>}  */
-  // @ts-expect-error
-  const instance = {
-    procedures,
-    implementations: {},
-  }
-
-  for (const functionName in procedures) {
-    instance[functionName] = (
-      /**
-       * @type {ProcedureImplementation<ProceduresMap[typeof functionName]['input'], ProceduresMap[typeof functionName]['progress'], ProceduresMap[typeof functionName]['success']>}
-       */
-      implementation
-    ) => {
-      if (!instance.procedures[functionName]) {
-        throw new Error(`No procedure found for function name: ${functionName}`)
-      }
-
-      instance.implementations[functionName] = implementation
-    }
-  }
-
-  const PayloadSchema = type.or(
-    ...Object.entries(procedures).map(([functionName, { input }]) => ({
-      functionName: type(`"${functionName}"`),
-      requestId: type("string >= 1"),
-      input,
-    }))
-  )
-
-  /**
-   * Starts the message event handler. Needs to be called within the Service Worker context.
-   * @param {Window} self
-   */
-  instance.start = (self) => {
-    /**
-     * @param {{functionName: string} & Partial<{ result: any; error: any; progress: any }>} data
-     */
-    const postMessage = async (data) => {
-      if (worker) {
-        self.postMessage(data)
-      } else {
-        await self.clients.matchAll().then((clients) => {
-          console.debug(`[SWARPC Server] Posting message to clients`, clients)
-          clients.forEach((client) => client.postMessage(data))
-        })
-      }
-    }
-
-    console.log("[SWARPC Server] Starting message listener on", self)
-
-    self.addEventListener("message", async (event) => {
-      const { functionName, requestId, input } = PayloadSchema.assert(
-        event.data
-      )
-      console.log(
-        `[SWARPC Server] ${requestId} Running ${functionName} with`,
-        input
-      )
-
-      /**
-       * @param {*} error
-       */
-      const postError = async (error) =>
-        postMessage({
-          functionName,
-          requestId,
-          error: {
-            message: "message" in error ? error.message : String(error),
-          },
-        })
-
-      const implementation = instance.implementations[functionName]
-      if (!implementation) {
-        await postError("No implementation found")
-        return
-      }
-
-      await implementation(input, async (progress) => {
-        console.debug(
-          `[SWARPC Server] ${requestId} Progress for ${functionName}:`,
-          progress
-        )
-        await postMessage({ functionName, requestId, progress })
-      })
-        .catch(async (error) => {
-          console.debug(
-            `[SWARPC Server] ${requestId} Error in ${functionName}:`,
-            error
-          )
-          await postError(error)
-        })
-        .then(async (result) => {
-          console.debug(
-            `[SWARPC Server] ${requestId} Result for ${functionName}:`,
-            result
-          )
-          await postMessage({ functionName, requestId, result })
-        })
-    })
-  }
-
-  return instance
-}
-
-function generateRequestId() {
-  return Math.random().toString(36).substring(2, 15)
-}
-
-/**
- * @type {Map<string, { reject: (err: Error) => void; onProgress: (progress: any) => void; resolve: (result: any) => void }>}
- */
-const pendingRequests = new Map()
-
-let _clientListenerStarted = false
-/**
- * @param {Worker} [worker] the worker instance to connect to -- uses the navigator's service worker if not provided
- */
-async function startClientListener(worker) {
-  if (_clientListenerStarted) return
-
-  if (!worker) {
-    const sw = await navigator.serviceWorker.ready
-    if (!sw?.active) {
-      throw new Error("[SWARPC Client] Service Worker is not active")
-    }
-
-    if (!navigator.serviceWorker.controller) {
-      console.warn("[SWARPC Client] Service Worker is not controlling the page")
-    }
-  }
-
-  const w = worker ?? navigator.serviceWorker
-  console.debug("[SWARPC Client] Registering message listener for client", w)
-
-  w.addEventListener("message", (event) => {
-    const { functionName, requestId, ...data } = event.data || {}
-    if (!requestId) {
-      throw new Error("[SWARPC Client] Message received without requestId")
-    }
-    const handlers = pendingRequests.get(requestId)
-    if (!handlers) {
-      throw new Error(
-        `[SWARPC Client] ${requestId} has no active request handlers`
-      )
-    }
-
-    if ("error" in data) {
-      handlers.reject(new Error(data.error.message))
-      pendingRequests.delete(requestId)
-    } else if ("progress" in data) {
-      handlers.onProgress(data.progress)
-    } else if ("result" in data) {
-      handlers.resolve(data.result)
-      pendingRequests.delete(requestId)
-    }
-  })
-
-  _clientListenerStarted = true
-}
-
-/**
- * @template {ProceduresMap} Procedures
- * @param {Procedures} procedures
- * @param {object} [options]
- * @param {Worker} [options.worker] the worker instance to connect to -- uses the navigator's service worker if not provided
- * @returns {SwarpcClient<Procedures>}
- */
-export function Client(procedures, { worker } = { worker: undefined }) {
-  /** @type {SwarpcClient<Procedures>} */
-  // @ts-expect-error
-  const instance = { procedures }
-
-  for (const functionName of Object.keys(procedures)) {
-    instance[functionName] = async (input, onProgress = () => {}) => {
-      procedures[functionName].input.assert(input)
-      await startClientListener(worker)
-
-      const w =
-        worker ?? (await navigator.serviceWorker.ready.then((r) => r.active))
-      return new Promise((resolve, reject) => {
-        if (!worker && !navigator.serviceWorker.controller)
-          console.warn(
-            "[SWARPC Client] Service Worker is not controlling the page"
-          )
-
-        const requestId = generateRequestId()
-
-        pendingRequests.set(requestId, { resolve, onProgress, reject })
-
-        console.log(
-          `[SWARPC Client] ${requestId} Requesting ${functionName} with`,
-          input
-        )
-        w.postMessage({ functionName, input, requestId })
-      })
-    }
-  }
-
-  return instance
-}

package/src/typings.js

@@ -1,42 +0,0 @@
-/**
- * @import { Type } from 'arktype';
- */
-
-/**
- * @template {Type} I
- * @template {Type} P
- * @template {Type} S
- * @typedef {Object} Procedure
- * @property {I} input
- * @property {P} progress
- * @property {S} success
- */
-
-/**
- * @template {Type} I
- * @template {Type} P
- * @template {Type} S
- * @typedef {(input: I['inferOut'], onProgress: (progress: P['inferOut']) => void) => Promise<NoInfer<S>['inferOut'] | NoInfer<S>['inferOut']>} ProcedureImplementation
- */
-
-/**
- * @typedef {Record<string, Procedure<Type, Type, Type>>} ProceduresMap
- */
-
-/**
- * @template {Procedure<Type, Type, Type>} P
- * @typedef {(input: P['input']['inferIn'], onProgress?: (progress: P['progress']['inferOut']) => void) => Promise<P['success']['inferOut']>} ClientMethod
- */
-
-/**
- * @template {ProceduresMap} Procedures
- * @typedef {{ procedures: Procedures } & { [F in keyof Procedures]: ClientMethod<Procedures[F]> }} SwarpcClient
- */
-
-/**
- * @template {ProceduresMap} Procedures
- * @typedef {{ procedures: Procedures, implementations: {[F in keyof Procedures]: ProcedureImplementation<Procedures[F]['input'], Procedures[F]['progress'], Procedures[F]['success']> }, start: (self: Window) => void  } & { [F in keyof Procedures]: (impl: NoInfer<ProcedureImplementation<Procedures[F]['input'], Procedures[F]['progress'], Procedures[F]['success'] >>) => void }} SwarpcServer
- */
-
-// Required, otherwise nothing can be imported from this file
-export {}