swarpc 0.6.0 → 0.7.0

package/dist/src/types.d.ts

@@ -0,0 +1,260 @@
+import { type Type } from "arktype";
+/**
+ * A procedure declaration
+ */
+export type Procedure<I extends Type, P extends Type, S extends Type> = {
+    /**
+     * ArkType type for the input (first argument) of the procedure, when calling it from the client.
+     */
+    input: I;
+    /**
+     * ArkType type for the data as the first argument given to the `onProgress` callback
+     * when calling the procedure from the client.
+     */
+    progress: P;
+    /**
+     * ArkType type for the output (return value) of the procedure, when calling it from the client.
+     */
+    success: S;
+    /**
+     * When should the procedure automatically add ArrayBuffers and other transferable objects
+     * to the [transfer list](https://developer.mozilla.org/en-US/docs/Web/API/DedicatedWorkerGlobalScope/postMessage#transfer)
+     * when sending messages, both from the client to the server and vice versa.
+     *
+     * Transferring objects can improve performance by avoiding copies of large objects,
+     * but _moves_ them to the other context, meaning that they cannot be used in the original context after being sent.
+     *
+     * 'output-only' by default: only transferables sent from the server to the client will be transferred.
+     */
+    autotransfer?: "always" | "never" | "output-only";
+};
+/**
+ * A promise that you can cancel by calling `.cancel(reason)` on it:
+ *
+ * ```js
+ * const { request, cancel } = client.runProcedure.cancelable(input, onProgress)
+ * setTimeout(() => cancel("Cancelled by user"), 1000)
+ * const result = await request
+ * ```
+ */
+export type CancelablePromise<T> = {
+    request: Promise<T>;
+    /**
+     * Abort the request.
+     * @param reason The reason for cancelling the request.
+     */
+    cancel: (reason: string) => Promise<void>;
+};
+/**
+ * An implementation of a procedure
+ */
+export type ProcedureImplementation<I extends Type, P extends Type, S extends Type> = (input: I["inferOut"], onProgress: (progress: P["inferIn"]) => void, abortSignal?: AbortSignal) => Promise<S["inferIn"]>;
+/**
+ * Declarations of procedures by name.
+ */
+export type ProceduresMap = Record<string, Procedure<Type, Type, Type>>;
+/**
+ * Implementations of procedures by name
+ */
+export type ImplementationsMap<Procedures extends ProceduresMap> = {
+    [F in keyof Procedures]: ProcedureImplementation<Procedures[F]["input"], Procedures[F]["progress"], Procedures[F]["success"]>;
+};
+/**
+ * Declaration of hooks to run on messages received from the server
+ */
+export type Hooks<Procedures extends ProceduresMap> = {
+    /**
+     * Called when a procedure call has been successful.
+     */
+    success?: <Procedure extends keyof ProceduresMap>(procedure: Procedure, data: Procedures[Procedure]["success"]["inferOut"]) => void;
+    /**
+     * Called when a procedure call has failed.
+     */
+    error?: <Procedure extends keyof ProceduresMap>(procedure: Procedure, error: Error) => void;
+    /**
+     * Called when a procedure call sends progress updates.
+     */
+    progress?: <Procedure extends keyof ProceduresMap>(procedure: Procedure, data: Procedures[Procedure]["progress"]["inferOut"]) => void;
+};
+export declare const PayloadHeaderSchema: import("arktype").Generic<[["Name", string]], {
+    readonly by: "\"sw&rpc\"";
+    readonly functionName: "Name";
+    readonly requestId: "string >= 1";
+}, {}, {}>;
+export type PayloadHeader<PM extends ProceduresMap, Name extends keyof PM = keyof PM> = {
+    by: "sw&rpc";
+    functionName: Name & string;
+    requestId: string;
+};
+export declare const PayloadCoreSchema: import("arktype").Generic<[["I", unknown], ["P", unknown], ["S", unknown]], {
+    readonly "input?": "I";
+    readonly "progress?": "P";
+    readonly "result?": "S";
+    readonly "abort?": {
+        readonly reason: "string";
+    };
+    readonly "error?": {
+        readonly message: "string";
+    };
+}, {}, {}>;
+export type PayloadCore<PM extends ProceduresMap, Name extends keyof PM = keyof PM> = {
+    input: PM[Name]["input"]["inferOut"];
+} | {
+    progress: PM[Name]["progress"]["inferOut"];
+} | {
+    result: PM[Name]["success"]["inferOut"];
+} | {
+    abort: {
+        reason: string;
+    };
+} | {
+    error: {
+        message: string;
+    };
+};
+export declare const PayloadSchema: import("arktype").Generic<[["Name", string], ["I", unknown], ["P", unknown], ["S", unknown]], readonly ["PayloadHeaderSchema<Name>", "&", "PayloadCoreSchema<I, P, S>"], {
+    PayloadCoreSchema: import("arktype/internal/scope.ts").bindGenericToScope<import("@ark/schema").GenericAst<[["I", unknown], ["P", unknown], ["S", unknown]], {
+        readonly "input?": "I";
+        readonly "progress?": "P";
+        readonly "result?": "S";
+        readonly "abort?": {
+            readonly reason: "string";
+        };
+        readonly "error?": {
+            readonly message: "string";
+        };
+    }, {}, {}>, {
+        PayloadCoreSchema: import("@ark/schema").GenericAst<[["I", unknown], ["P", unknown], ["S", unknown]], {
+            readonly "input?": "I";
+            readonly "progress?": "P";
+            readonly "result?": "S";
+            readonly "abort?": {
+                readonly reason: "string";
+            };
+            readonly "error?": {
+                readonly message: "string";
+            };
+        }, {}, {}>;
+        PayloadHeaderSchema: import("@ark/schema").GenericAst<[["Name", string]], {
+            readonly by: "\"sw&rpc\"";
+            readonly functionName: "Name";
+            readonly requestId: "string >= 1";
+        }, {}, {}>;
+    } & {}>;
+    PayloadHeaderSchema: import("arktype/internal/scope.ts").bindGenericToScope<import("@ark/schema").GenericAst<[["Name", string]], {
+        readonly by: "\"sw&rpc\"";
+        readonly functionName: "Name";
+        readonly requestId: "string >= 1";
+    }, {}, {}>, {
+        PayloadCoreSchema: import("@ark/schema").GenericAst<[["I", unknown], ["P", unknown], ["S", unknown]], {
+            readonly "input?": "I";
+            readonly "progress?": "P";
+            readonly "result?": "S";
+            readonly "abort?": {
+                readonly reason: "string";
+            };
+            readonly "error?": {
+                readonly message: "string";
+            };
+        }, {}, {}>;
+        PayloadHeaderSchema: import("@ark/schema").GenericAst<[["Name", string]], {
+            readonly by: "\"sw&rpc\"";
+            readonly functionName: "Name";
+            readonly requestId: "string >= 1";
+        }, {}, {}>;
+    } & {}>;
+}, {
+    PayloadCoreSchema: import("arktype/internal/scope.ts").bindGenericToScope<import("@ark/schema").GenericAst<[["I", unknown], ["P", unknown], ["S", unknown]], {
+        readonly "input?": "I";
+        readonly "progress?": "P";
+        readonly "result?": "S";
+        readonly "abort?": {
+            readonly reason: "string";
+        };
+        readonly "error?": {
+            readonly message: "string";
+        };
+    }, {}, {}>, {
+        PayloadCoreSchema: import("@ark/schema").GenericAst<[["I", unknown], ["P", unknown], ["S", unknown]], {
+            readonly "input?": "I";
+            readonly "progress?": "P";
+            readonly "result?": "S";
+            readonly "abort?": {
+                readonly reason: "string";
+            };
+            readonly "error?": {
+                readonly message: "string";
+            };
+        }, {}, {}>;
+        PayloadHeaderSchema: import("@ark/schema").GenericAst<[["Name", string]], {
+            readonly by: "\"sw&rpc\"";
+            readonly functionName: "Name";
+            readonly requestId: "string >= 1";
+        }, {}, {}>;
+    } & {}>;
+    PayloadHeaderSchema: import("arktype/internal/scope.ts").bindGenericToScope<import("@ark/schema").GenericAst<[["Name", string]], {
+        readonly by: "\"sw&rpc\"";
+        readonly functionName: "Name";
+        readonly requestId: "string >= 1";
+    }, {}, {}>, {
+        PayloadCoreSchema: import("@ark/schema").GenericAst<[["I", unknown], ["P", unknown], ["S", unknown]], {
+            readonly "input?": "I";
+            readonly "progress?": "P";
+            readonly "result?": "S";
+            readonly "abort?": {
+                readonly reason: "string";
+            };
+            readonly "error?": {
+                readonly message: "string";
+            };
+        }, {}, {}>;
+        PayloadHeaderSchema: import("@ark/schema").GenericAst<[["Name", string]], {
+            readonly by: "\"sw&rpc\"";
+            readonly functionName: "Name";
+            readonly requestId: "string >= 1";
+        }, {}, {}>;
+    } & {}>;
+}>;
+/**
+ * The effective payload as sent by the server to the client
+ */
+export type Payload<PM extends ProceduresMap, Name extends keyof PM = keyof PM> = PayloadHeader<PM, Name> & PayloadCore<PM, Name>;
+/**
+ * A procedure's corresponding method on the client instance -- used to call the procedure. If you want to be able to cancel the request, you can use the `cancelable` method instead of running the procedure directly.
+ */
+export type ClientMethod<P extends Procedure<Type, Type, Type>> = ((input: P["input"]["inferIn"], onProgress?: (progress: P["progress"]["inferOut"]) => void) => Promise<P["success"]["inferOut"]>) & {
+    /**
+     * A method that returns a `CancelablePromise`. Cancel it by calling `.cancel(reason)` on it, and wait for the request to resolve by awaiting the `request` property on the returned object.
+     */
+    cancelable: (input: P["input"]["inferIn"], onProgress?: (progress: P["progress"]["inferOut"]) => void, requestId?: string) => CancelablePromise<P["success"]["inferOut"]>;
+};
+/**
+ * Symbol used as the key for the procedures map on the server instance
+ */
+export declare const zImplementations: unique symbol;
+/**
+ * Symbol used as the key for the procedures map on instances
+ */
+export declare const zProcedures: unique symbol;
+/**
+ * The sw&rpc client instance, which provides methods to call procedures.
+ * Each property of the procedures map will be a method, that accepts an input, an optional onProgress callback and an optional request ID.
+ * If you want to be able to cancel the request, you can set the request's ID yourself, and call `.abort(requestId, reason)` on the client instance to cancel it.
+ */
+export type SwarpcClient<Procedures extends ProceduresMap> = {
+    [zProcedures]: Procedures;
+} & {
+    [F in keyof Procedures]: ClientMethod<Procedures[F]>;
+};
+/**
+ * The sw&rpc server instance, which provides methods to register procedure implementations,
+ * and listens for incoming messages that call those procedures
+ */
+export type SwarpcServer<Procedures extends ProceduresMap> = {
+    [zProcedures]: Procedures;
+    [zImplementations]: ImplementationsMap<Procedures>;
+    start(self: Window | Worker): void;
+} & {
+    [F in keyof Procedures]: (impl: ProcedureImplementation<Procedures[F]["input"], Procedures[F]["progress"], Procedures[F]["success"]>) => void;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"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"}

package/dist/src/types.js

@@ -0,0 +1,28 @@
+import { type } from "arktype";
+export const PayloadHeaderSchema = type("<Name extends string>", {
+    by: '"sw&rpc"',
+    functionName: "Name",
+    requestId: "string >= 1",
+});
+export const PayloadCoreSchema = type("<I, P, S>", {
+    "input?": "I",
+    "progress?": "P",
+    "result?": "S",
+    "abort?": { reason: "string" },
+    "error?": { message: "string" },
+});
+export const PayloadSchema = type
+    .scope({ PayloadCoreSchema, PayloadHeaderSchema })
+    .type("<Name extends string, I, P, S>", [
+    "PayloadHeaderSchema<Name>",
+    "&",
+    "PayloadCoreSchema<I, P, S>",
+]);
+/**
+ * Symbol used as the key for the procedures map on the server instance
+ */
+export const zImplementations = Symbol("SWARPC implementations");
+/**
+ * Symbol used as the key for the procedures map on instances
+ */
+export const zProcedures = Symbol("SWARPC procedures");

package/dist/src/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAWA,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,GAAG,GAAG,YAAY,EAAE,CAsB5D"}

package/dist/{utils.js → src/utils.js}

@@ -1,15 +1,9 @@
 // TODO: keep it in sync with web standards, how?
 const transferableClasses = [
-    OffscreenCanvas,
-    ImageBitmap,
     MessagePort,
-    MediaSourceHandle,
     ReadableStream,
     WritableStream,
     TransformStream,
-    AudioData,
-    VideoFrame,
-    RTCDataChannel,
     ArrayBuffer,
 ];
 export function findTransferables(value) {

package/dist/tests/core.procedures.d.ts

@@ -0,0 +1,45 @@
+export declare const procedures: {
+    readonly hello: {
+        readonly input: import("arktype/internal/methods/string.ts").StringType<string, {}>;
+        readonly progress: import("arktype").BaseType<undefined, {}>;
+        readonly success: import("arktype/internal/methods/string.ts").StringType<string, {}>;
+    };
+    readonly helloWithProgress: {
+        readonly input: import("arktype/internal/methods/string.ts").StringType<string, {}>;
+        readonly progress: import("arktype/internal/methods/object.ts").ObjectType<{
+            current: number;
+            total: number;
+        }, {}>;
+        readonly success: import("arktype/internal/methods/string.ts").StringType<string, {}>;
+    };
+    readonly cancellable: {
+        readonly input: import("arktype/internal/methods/string.ts").StringType<string, {}>;
+        readonly progress: import("arktype/internal/methods/object.ts").ObjectType<{
+            current: number;
+            total: number;
+        }, {}>;
+        readonly success: import("arktype/internal/methods/string.ts").StringType<string, {}>;
+    };
+    readonly complexData: {
+        readonly input: import("arktype/internal/methods/object.ts").ObjectType<{
+            name: string;
+            age: number;
+            custom: (In: string) => import("arktype/internal/attributes.ts").To<import("@ark/util").Json>;
+            hobbies: import("arktype/internal/attributes.ts").Default<string[], never[]>;
+            address: (In: {
+                street: string;
+                city: string;
+                zip: string;
+                houseno?: number | undefined;
+            }) => import("arktype").Out<string>;
+        }, {}>;
+        readonly progress: import("arktype/internal/methods/object.ts").ObjectType<{
+            message: string;
+            percent: number;
+        }, {}>;
+        readonly success: import("arktype/internal/methods/object.ts").ObjectType<{
+            message: string;
+        }, {}>;
+    };
+};
+//# sourceMappingURL=core.procedures.d.ts.map

package/dist/tests/core.procedures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.procedures.d.ts","sourceRoot":"","sources":["../../tests/core.procedures.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgDW,CAAA"}

package/dist/tests/core.procedures.js

@@ -0,0 +1,49 @@
+import { type } from "arktype";
+export const procedures = {
+    hello: {
+        input: type("string"),
+        progress: type("undefined"),
+        success: type("string"),
+    },
+    helloWithProgress: {
+        input: type("string"),
+        progress: type({
+            current: "number",
+            total: "number",
+        }),
+        success: type("string"),
+    },
+    cancellable: {
+        input: type("string"),
+        progress: type({
+            current: "number",
+            total: "number",
+        }),
+        success: type("string"),
+    },
+    complexData: {
+        input: type({
+            name: "string",
+            age: "number",
+            custom: "string.json.parse",
+            hobbies: type("string[]").default(() => []),
+            address: type([
+                {
+                    "houseno?": "number",
+                    street: "string",
+                    city: "string",
+                    zip: "string",
+                },
+                "=>",
+                (address) => `${address.houseno ? address.houseno + " " : ""}${address.street}, ${address.city} ${address.zip}`,
+            ]),
+        }),
+        progress: type({
+            message: "string",
+            percent: "number",
+        }),
+        success: type({
+            message: "string",
+        }),
+    },
+};

package/dist/tests/core.test.d.ts

@@ -0,0 +1,2 @@
+import "@vitest/web-worker";
+//# sourceMappingURL=core.test.d.ts.map

package/dist/tests/core.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.test.d.ts","sourceRoot":"","sources":["../../tests/core.test.ts"],"names":[],"mappings":"AAAA,OAAO,oBAAoB,CAAA"}

package/dist/tests/core.test.js

@@ -0,0 +1,100 @@
+import "@vitest/web-worker";
+import { beforeEach, describe, expect, test, vi } from "vitest";
+import { Client } from "../src/index.js";
+import { procedures } from "./core.procedures.js";
+// @ts-ignore
+import Worker from "./core.worker.js?worker";
+const client = Client(procedures, { worker: new Worker(), loglevel: "warn" });
+test("Simple exchange", async () => {
+    const answer = await client.hello("world");
+    expect(answer).toBe("Hello world");
+});
+test("Progress info", async () => {
+    const callback = vi.fn();
+    const answer = await client.helloWithProgress("world", callback);
+    expect(answer).toBe("Hello with progress world");
+    expect(callback.mock.calls).toStrictEqual([
+        [{ current: 0, total: 10 }],
+        [{ current: 1, total: 10 }],
+        [{ current: 2, total: 10 }],
+        [{ current: 3, total: 10 }],
+        [{ current: 4, total: 10 }],
+        [{ current: 5, total: 10 }],
+        [{ current: 6, total: 10 }],
+        [{ current: 7, total: 10 }],
+        [{ current: 8, total: 10 }],
+        [{ current: 9, total: 10 }],
+    ]);
+});
+describe("Cancellable procedure", () => {
+    const progress = vi.fn();
+    beforeEach(() => {
+        progress.mockReset();
+    });
+    test("Can be cancelled", async () => {
+        const { cancel } = client.cancellable.cancelable("test", progress);
+        await new Promise((resolve) => setTimeout(resolve, 2));
+        await cancel("test cancellation");
+        expect(progress.mock.calls.length).toBeLessThan(10);
+    });
+    test("Can be completed", async () => {
+        const { request } = client.cancellable.cancelable("test", progress);
+        const answer = await request;
+        expect(answer).toBe("Cancellable hello test");
+        expect(progress.mock.calls.length).toBe(10);
+    });
+    test("Can be run normally", async () => {
+        const answer = await client.cancellable("test", progress);
+        expect(answer).toBe("Cancellable hello test");
+        expect(progress.mock.calls.length).toBe(10);
+    });
+});
+describe("Complex data", () => {
+    test("Processes complex data", async () => {
+        const response = await client.complexData({
+            name: "test",
+            custom: '{"key": "value"}',
+            address: {
+                street: "Main St",
+                city: "Testville",
+                zip: "12345",
+                houseno: 42,
+            },
+            age: 30,
+        });
+        expect(response).toEqual({
+            message: "Processed data for test",
+            addr: "42 Main St, Testville 12345",
+        });
+    });
+    test("Handles missing optional fields", async () => {
+        const response = await client.complexData({
+            name: "test",
+            custom: '{"key": "value"}',
+            address: {
+                street: "Main St",
+                city: "Testville",
+                zip: "12345",
+            },
+            age: 30,
+        });
+        expect(response).toEqual({
+            message: "Processed data for test",
+            addr: "Main St, Testville 12345",
+        });
+    });
+    test("Errors on invalid data", async () => {
+        await expect(client.complexData({
+            name: "test",
+            custom: '{"key": "value"}',
+            address: {
+                street: "Main St",
+                city: "Testville",
+                zip: "12345",
+                // @ts-expect-error
+                houseno: "not-a-number", // Invalid type
+            },
+            age: 30,
+        })).rejects.toThrowErrorMatchingInlineSnapshot(`[TraversalError: address.houseno must be a number (was a string)]`);
+    });
+});

package/dist/tests/core.worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=core.worker.d.ts.map

package/dist/tests/core.worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.worker.d.ts","sourceRoot":"","sources":["../../tests/core.worker.ts"],"names":[],"mappings":""}

package/dist/tests/core.worker.js

@@ -0,0 +1,30 @@
+import { Server } from "../src/index.js";
+import { procedures } from "./core.procedures.js";
+const server = Server(procedures, { worker: self, loglevel: "warn" });
+server.hello(async (input) => {
+    return `Hello ${input}`;
+});
+server.helloWithProgress(async (input, onProgress) => {
+    for (let i = 0; i < 10; i++) {
+        onProgress({ current: i, total: 10 });
+    }
+    return `Hello with progress ${input}`;
+});
+server.cancellable(async (input, onProgress, abortSignal) => {
+    let aborted = false;
+    abortSignal?.addEventListener("abort", () => {
+        aborted = true;
+    });
+    for (let i = 0; i < 10; i++) {
+        if (aborted)
+            return "cancelled";
+        onProgress({ current: i, total: 10 });
+        await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+    return `Cancellable hello ${input}`;
+});
+server.complexData(async (input, onProgress) => {
+    onProgress({ message: "Processing data", percent: 50 });
+    return { message: `Processed data for ${input.name}`, addr: input.address };
+});
+server.start(self);

package/dist/vite.config.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("vite").UserConfig;
+export default _default;
+//# sourceMappingURL=vite.config.d.ts.map

package/dist/vite.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite.config.d.ts","sourceRoot":"","sources":["../vite.config.ts"],"names":[],"mappings":";AAEA,wBAKE"}

package/dist/vite.config.js

@@ -0,0 +1,7 @@
+import { defineConfig } from "vite";
+export default defineConfig({
+    test: {
+        include: ["tests/**/*.test.ts"],
+        setupFiles: ["@vitest/web-worker"],
+    },
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swarpc",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Full type-safe RPC library for service worker -- move things off of the UI thread with ease!",
   "keywords": [
     "service-workers",
@@ -24,22 +24,26 @@
     "dist",
     "src"
   ],
-  "main": "dist/swarpc.js",
-  "types": "dist/swarpc.d.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc",
     "dev": "tsc --watch",
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "typedoc": "typedoc src/swarpc.ts src/types.ts --readme README.md",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest",
+    "typedoc": "typedoc src/index.ts src/types.ts --readme README.md",
     "version": "kacl release && prettier -w CHANGELOG.md && git add CHANGELOG.md"
   },
   "dependencies": {
     "arktype": "^2.1.20"
   },
   "devDependencies": {
+    "@vitest/web-worker": "^3.2.4",
     "kacl": "^1.1.1",
     "prettier": "^3.6.2",
     "typedoc": "^0.28.7",
-    "typescript": "^5.8.3"
+    "typescript": "^5.8.3",
+    "vite": "^7.0.6",
+    "vitest": "^3.2.4"
   }
 }