swarpc 0.2.0 → 0.2.1

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,272 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Server = Server;
+exports.Client = Client;
+var arktype_1 = require("arktype");
+function Server(procedures, _a) {
+    var _this = this;
+    var _b = _a === void 0 ? {} : _a, worker = _b.worker;
+    var instance = {
+        procedures: procedures,
+        implementations: {},
+        start: function () { },
+    };
+    var _loop_1 = function (functionName) {
+        instance[functionName] = (function (implementation) {
+            if (!instance.procedures[functionName]) {
+                throw new Error("No procedure found for function name: ".concat(functionName));
+            }
+            instance.implementations[functionName] = implementation;
+        });
+    };
+    for (var functionName in procedures) {
+        _loop_1(functionName);
+    }
+    var PayloadSchema = arktype_1.type.or.apply(arktype_1.type, Object.entries(procedures).map(function (_a) {
+        var functionName = _a[0], input = _a[1].input;
+        return ({
+            functionName: (0, arktype_1.type)("\"".concat(functionName, "\"")),
+            requestId: (0, arktype_1.type)("string >= 1"),
+            input: input,
+        });
+    }));
+    instance.start = function (self) {
+        var postMessage = function (data) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!worker) return [3 /*break*/, 1];
+                        self.postMessage(data);
+                        return [3 /*break*/, 3];
+                    case 1: return [4 /*yield*/, self.clients.matchAll().then(function (clients) {
+                            clients.forEach(function (client) { return client.postMessage(data); });
+                        })];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        }); };
+        self.addEventListener("message", function (event) { return __awaiter(_this, void 0, void 0, function () {
+            var _a, functionName, requestId, input, postError, implementation;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = PayloadSchema.assert(event.data), functionName = _a.functionName, requestId = _a.requestId, input = _a.input;
+                        postError = function (error) { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                return [2 /*return*/, postMessage({
+                                        functionName: functionName,
+                                        requestId: requestId,
+                                        error: {
+                                            message: "message" in error ? error.message : String(error),
+                                        },
+                                    })];
+                            });
+                        }); };
+                        implementation = instance.implementations[functionName];
+                        if (!!implementation) return [3 /*break*/, 2];
+                        return [4 /*yield*/, postError("No implementation found")];
+                    case 1:
+                        _b.sent();
+                        return [2 /*return*/];
+                    case 2: return [4 /*yield*/, implementation(input, function (progress) { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, postMessage({ functionName: functionName, requestId: requestId, progress: progress })];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); })
+                            .catch(function (error) { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, postError(error)];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); })
+                            .then(function (result) { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, postMessage({ functionName: functionName, requestId: requestId, result: result })];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); })];
+                    case 3:
+                        _b.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    };
+    return instance;
+}
+function generateRequestId() {
+    return Math.random().toString(36).substring(2, 15);
+}
+var pendingRequests = new Map();
+var _clientListenerStarted = false;
+function startClientListener(worker) {
+    return __awaiter(this, void 0, void 0, function () {
+        var sw, w;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (_clientListenerStarted)
+                        return [2 /*return*/];
+                    if (!!worker) return [3 /*break*/, 2];
+                    return [4 /*yield*/, navigator.serviceWorker.ready];
+                case 1:
+                    sw = _a.sent();
+                    if (!(sw === null || sw === void 0 ? void 0 : 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");
+                    }
+                    _a.label = 2;
+                case 2:
+                    w = worker !== null && worker !== void 0 ? worker : navigator.serviceWorker;
+                    w.addEventListener("message", function (event) {
+                        var _a = event.data || {}, functionName = _a.functionName, requestId = _a.requestId, data = __rest(_a, ["functionName", "requestId"]);
+                        if (!requestId) {
+                            throw new Error("[SWARPC Client] Message received without requestId");
+                        }
+                        var handlers = pendingRequests.get(requestId);
+                        if (!handlers) {
+                            throw new Error("[SWARPC Client] ".concat(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;
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+function Client(procedures, _a) {
+    var _this = this;
+    var _b = _a === void 0 ? {} : _a, worker = _b.worker;
+    var instance = { procedures: procedures };
+    var _loop_2 = function (functionName) {
+        instance[functionName] = (function (input_1) {
+            var args_1 = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                args_1[_i - 1] = arguments[_i];
+            }
+            return __awaiter(_this, __spreadArray([input_1], args_1, true), void 0, function (input, onProgress) {
+                var w, _a;
+                if (onProgress === void 0) { onProgress = function () { }; }
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            procedures[functionName].input.assert(input);
+                            return [4 /*yield*/, startClientListener(worker)];
+                        case 1:
+                            _b.sent();
+                            if (!(worker !== null && worker !== void 0)) return [3 /*break*/, 2];
+                            _a = worker;
+                            return [3 /*break*/, 4];
+                        case 2: return [4 /*yield*/, navigator.serviceWorker.ready.then(function (r) { return r.active; })];
+                        case 3:
+                            _a = (_b.sent());
+                            _b.label = 4;
+                        case 4:
+                            w = _a;
+                            if (!w) {
+                                throw new Error("[SWARPC Client] No active service worker found");
+                            }
+                            return [2 /*return*/, new Promise(function (resolve, reject) {
+                                    if (!worker && !navigator.serviceWorker.controller)
+                                        console.warn("[SWARPC Client] Service Worker is not controlling the page");
+                                    var requestId = generateRequestId();
+                                    pendingRequests.set(requestId, { resolve: resolve, onProgress: onProgress, reject: reject });
+                                    w.postMessage({ functionName: functionName, input: input, requestId: requestId });
+                                })];
+                    }
+                });
+            });
+        });
+    };
+    for (var _i = 0, _c = Object.keys(procedures); _i < _c.length; _i++) {
+        var functionName = _c[_i];
+        _loop_2(functionName);
+    }
+    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,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swarpc",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "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,177 @@
+import { type } from "arktype"
+import type {
+  ProceduresMap,
+  SwarpcClient,
+  SwarpcServer,
+  ProcedureImplementation,
+} from "./types"
+
+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: MessageEvent) => {
+    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 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, 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 {}