@derivation/rpc 0.1.6 → 0.1.8

package/dist/shared-worker-client.d.ts

@@ -0,0 +1,22 @@
+import { Graph } from "derivation";
+import { Client } from "./client.js";
+import { StreamSinks, RPCDefinition } from "./stream-types.js";
+/**
+ * Create a client connected to a SharedWorker.
+ *
+ * @example
+ * ```typescript
+ * // main.ts
+ * const graph = new Graph();
+ * const worker = new SharedWorker('/worker.js');
+ *
+ * const client = createSharedWorkerClient(worker.port, {
+ *   streams: {
+ *     todos: setSink(graph, todoIso),
+ *   },
+ * }, graph);
+ *
+ * const todos = await client.run('todos', { filter: 'active' });
+ * ```
+ */
+export declare function createSharedWorkerClient<Defs extends RPCDefinition>(port: MessagePort, sinks: StreamSinks<Defs["streams"]>, graph: Graph): Client<Defs>;

package/dist/shared-worker-client.js

@@ -0,0 +1,25 @@
+import { Client } from "./client.js";
+import { MessagePortTransport } from "./messageport-transport.js";
+/**
+ * Create a client connected to a SharedWorker.
+ *
+ * @example
+ * ```typescript
+ * // main.ts
+ * const graph = new Graph();
+ * const worker = new SharedWorker('/worker.js');
+ *
+ * const client = createSharedWorkerClient(worker.port, {
+ *   streams: {
+ *     todos: setSink(graph, todoIso),
+ *   },
+ * }, graph);
+ *
+ * const todos = await client.run('todos', { filter: 'active' });
+ * ```
+ */
+export function createSharedWorkerClient(port, sinks, graph) {
+    const transport = new MessagePortTransport(port);
+    port.start();
+    return new Client(transport, sinks, graph);
+}

package/dist/shared-worker-server.d.ts

@@ -0,0 +1,28 @@
+import { Graph } from "derivation";
+import { StreamEndpoints, MutationEndpoints, RPCDefinition } from "./stream-types.js";
+import { PresenceHandler } from "./presence-manager.js";
+export type SharedWorkerServerOptions<Defs extends RPCDefinition, Ctx = void> = {
+    streams: StreamEndpoints<Defs["streams"], Ctx>;
+    mutations: MutationEndpoints<Defs["mutations"], Ctx>;
+    createContext: (port: MessagePort) => Ctx | Promise<Ctx>;
+    presenceHandler?: PresenceHandler;
+};
+/**
+ * Set up a SharedWorker server for RPC communication.
+ * This creates a shared Graph that all connected tabs can interact with.
+ *
+ * @example
+ * ```typescript
+ * // worker.ts
+ * const { graph } = setupSharedWorker({
+ *   streams: {
+ *     todos: async (args, ctx) => new ReactiveSetSourceAdapter(source),
+ *   },
+ *   mutations: {
+ *     addTodo: async (args, ctx) => ({ success: true, value: newTodo }),
+ *   },
+ *   createContext: (port) => ({ portId: crypto.randomUUID() }),
+ * });
+ * ```
+ */
+export declare function setupSharedWorker<Defs extends RPCDefinition, Ctx = void>(options: SharedWorkerServerOptions<Defs, Ctx>, graph: Graph): void;

package/dist/shared-worker-server.js

@@ -0,0 +1,62 @@
+import { SharedWorkerClientHandler } from "./shared-worker-client-handler.js";
+import WeakList from "./weak-list.js";
+import { MessagePortTransport } from "./messageport-transport.js";
+/**
+ * Set up a SharedWorker server for RPC communication.
+ * This creates a shared Graph that all connected tabs can interact with.
+ *
+ * @example
+ * ```typescript
+ * // worker.ts
+ * const { graph } = setupSharedWorker({
+ *   streams: {
+ *     todos: async (args, ctx) => new ReactiveSetSourceAdapter(source),
+ *   },
+ *   mutations: {
+ *     addTodo: async (args, ctx) => ({ success: true, value: newTodo }),
+ *   },
+ *   createContext: (port) => ({ portId: crypto.randomUUID() }),
+ * });
+ * ```
+ */
+export function setupSharedWorker(options, graph) {
+    const { streams, mutations, createContext, presenceHandler } = options;
+    const clients = new WeakList();
+    // After each graph step, broadcast deltas to all connected clients
+    graph.afterStep(() => {
+        for (const client of clients) {
+            client.handleStep();
+        }
+    });
+    // Handle SharedWorker connections
+    const globalScope = self;
+    globalScope.onconnect = (event) => {
+        const port = event.ports[0];
+        const messageBuffer = [];
+        let client = null;
+        // Set up temporary message handler to buffer messages
+        const tempMessageHandler = (e) => {
+            messageBuffer.push(e.data);
+        };
+        port.onmessage = tempMessageHandler;
+        // Create context (handle both sync and async)
+        Promise.resolve(createContext(port))
+            .then((context) => {
+            // Create transport and client handler
+            const transport = new MessagePortTransport(port);
+            client = new SharedWorkerClientHandler(transport, context, streams, mutations, presenceHandler);
+            clients.add(client);
+            // Process buffered messages
+            for (const msg of messageBuffer) {
+                client.handleMessage(msg);
+            }
+            messageBuffer.length = 0;
+            // Start the port
+            port.start();
+        })
+            .catch((err) => {
+            console.error("Error creating context:", err);
+            port.close();
+        });
+    };
+}

package/dist/stream-adapter.d.ts

@@ -1,6 +1,6 @@
 import { Graph, ReactiveValue, Input } from "derivation";
-import { Source, Sink } from "./stream-types";
-import { Iso } from "./iso";
+import { Source, Sink } from "./stream-types.js";
+import { Iso } from "./iso.js";
 export declare class StreamSourceAdapter<T extends object> implements Source<ReactiveValue<T>> {
     private readonly stream;
     private readonly iso;

package/dist/stream-adapter.js

@@ -1,3 +1,4 @@
+import { inputValue } from "derivation";
 export class StreamSourceAdapter {
     constructor(stream, iso) {
         this.stream = stream;
@@ -23,7 +24,7 @@ export class StreamSinkAdapter {
         input.push(this.iso.from(change));
     }
     build() {
-        const stream = this.graph.inputValue(this.initialValue);
+        const stream = inputValue(this.graph, this.initialValue);
         return { stream, input: stream };
     }
 }

package/dist/stream-types.d.ts

@@ -17,8 +17,8 @@ export type StreamDefinition<Args extends object, ReturnType extends object, Sin
     inputType: InputType;
 };
 export type StreamDefinitions = Record<string, StreamDefinition<object, object, object, object>>;
-export type StreamEndpoints<Definitions extends StreamDefinitions> = {
-    [K in keyof Definitions]: (args: Definitions[K]["args"]) => Source<Definitions[K]["returnType"]>;
+export type StreamEndpoints<Definitions extends StreamDefinitions, Ctx = void> = {
+    [K in keyof Definitions]: (args: Definitions[K]["args"], ctx: Ctx) => Promise<Source<Definitions[K]["returnType"]>>;
 };
 export type StreamSinks<Definitions extends StreamDefinitions> = {
     [K in keyof Definitions]: (snapshot: object) => Sink<Definitions[K]["sinkType"], Definitions[K]["inputType"]>;
@@ -35,8 +35,8 @@ export type MutationDefinition<Args, Result> = {
     result: Result;
 };
 export type MutationDefinitions = Record<string, MutationDefinition<unknown, unknown>>;
-export type MutationEndpoints<Definitions extends MutationDefinitions> = {
-    [K in keyof Definitions]: (args: Definitions[K]["args"]) => Promise<MutationResult<Definitions[K]["result"]>>;
+export type MutationEndpoints<Definitions extends MutationDefinitions, Ctx = void> = {
+    [K in keyof Definitions]: (args: Definitions[K]["args"], ctx: Ctx) => Promise<MutationResult<Definitions[K]["result"]>>;
 };
 export type RPCDefinition = {
     streams: StreamDefinitions;

package/dist/transport.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Transport abstraction for RPC communication.
+ * Allows the same RPC system to work over WebSocket or MessagePort.
+ */
+export interface Transport {
+    /**
+     * Send a string message through the transport.
+     */
+    send(data: string): void;
+    /**
+     * Register a handler for incoming messages.
+     */
+    onMessage(handler: (data: string) => void): void;
+    /**
+     * Register a handler for transport closure/disconnection.
+     */
+    onClose(handler: () => void): void;
+    /**
+     * Close the transport connection.
+     */
+    close(): void;
+    /**
+     * Number of bytes buffered to be sent (optional, used for flow control).
+     * MessagePort doesn't provide this, so it's optional.
+     */
+    readonly bufferedAmount?: number;
+}

package/dist/transport.js

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