@tstdl/base 0.93.36 → 0.93.38

package/source/rpc/README.md

@@ -1,234 +0,0 @@
-# RPC Module
-
-Provides a powerful and type-safe mechanism for Remote Procedure Calls (RPC) between different JavaScript environments, such as the main thread, web workers, or different browser windows.
-
-## Table of Contents
-- [Features](#features)
-- [Core Concepts](#core-concepts)
-- [Usage](#usage)
-  - [Basic Worker Communication](#basic-worker-communication)
-  - [Streaming Data with ReadableStream](#streaming-data-with-readablestream)
-  - [Transferring Data Efficiently](#transferring-data-efficiently)
-- [API Summary](#api-summary)
-
-## Features
-
-*   **Type-Safe Proxies:** Interact with remote objects and functions as if they were local, with full TypeScript support.
-*   **Multiple Transports:** Works seamlessly with `Worker`, `SharedWorker`, `MessagePort`, and `Window` objects via `MessagePortRpcEndpoint`.
-*   **Extensible Adapters:** Supports complex, non-serializable types like `ReadableStream` through custom adapters.
-*   **Transferable Objects:** Optimizes performance by transferring objects like `ArrayBuffer` instead of cloning them.
-*   **Advanced Serialization:** Fine-grained control over how objects are transmitted—either by proxy, by value (serialization), or using a custom adapter.
-
-## Core Concepts
-
-This module simplifies communication between different JavaScript contexts by abstracting away the complexities of `postMessage`.
-
--   **Endpoint (`MessagePortRpcEndpoint`):** An endpoint is the communication hub for one side of an RPC connection. It's created from a transport like a `Worker` or `MessagePort`. It manages the creation and lifecycle of communication channels.
-
--   **Channel (`RpcChannel`):** A channel is a dedicated, isolated communication link between two endpoints. When you establish a connection, a main control channel is used to negotiate and open new channels for specific proxies or adapted objects, ensuring messages don't get mixed up.
-
--   **Exposing & Connecting:** The core pattern involves making an object or function available on one side using `Rpc.expose()` and connecting to it from the other side using `Rpc.connect()`.
-
--   **Proxies:** When you `connect` to a remote object, you receive a local *proxy*. Any interaction with this proxy (calling methods, getting/setting properties) is automatically translated into an RPC message, sent to the remote environment, executed on the original object, and the result is sent back. This creates the illusion that the remote object is available locally.
-
--   **Adapters:** Some objects, like `ReadableStream`, cannot be serialized or proxied directly. Adapters solve this by defining a custom communication protocol over an RPC channel. For instance, the `ReadableStreamRpcAdapter` creates a proxy stream that pulls data from the original stream on demand. You can create custom adapters for any object type by implementing the `RpcAdapter` interface.
-
--   **Value Transmission Control:** By default, primitives are sent by copy and objects are sent by creating a remote proxy. You can alter this behavior:
-    -   `Rpc.serialize(obj)`: Forces the object to be serialized and sent by value.
-    -   `Rpc.proxy(obj)`: Explicitly marks an object to be sent as a proxy.
-    -   `Rpc.adapt(obj, adapter)`: Uses a specific adapter to handle the object's transmission.
-    -   `Rpc.transfer(obj, transferables)`: Marks associated data (like `ArrayBuffer`s) to be transferred efficiently instead of copied.
-
-## Usage
-
-### Basic Worker Communication
-
-This example demonstrates how to expose a service class in a web worker and consume it from the main thread.
-
-**`pet.service.ts` (shared code)**
-```typescript
-export type Pet = {
-  name: string;
-  species: 'dog' | 'cat';
-};
-
-export class PetService {
-  private pets: Pet[] = [{ name: 'Fido', species: 'dog' }];
-
-  async getPets(): Promise<Pet[]> {
-    return this.pets;
-  }
-
-  async addPet(pet: Pet): Promise<void> {
-    this.pets.push(pet);
-  }
-}
-```
-
-**`worker.ts` (Web Worker)**
-```typescript
-import { Rpc } from '@tstdl/rpc';
-import { MessagePortRpcEndpoint } from '@tstdl/rpc/endpoints';
-import { PetService } from './pet.service.js';
-
-const endpoint = new MessagePortRpcEndpoint(self as any);
-Rpc.listen(endpoint);
-
-const petService = new PetService();
-Rpc.expose(petService, 'pet-service');
-```
-
-**`main.ts` (Main Thread)**
-```typescript
-import { Rpc } from '@tstdl/rpc';
-import { MessagePortRpcEndpoint } from '@tstdl/rpc/endpoints';
-import type { PetService } from './pet.service.js';
-
-async function main() {
-  const worker = new Worker(new URL('./worker.ts', import.meta.url), { type: 'module' });
-  const endpoint = new MessagePortRpcEndpoint(worker);
-
-  const remotePetService = await Rpc.connect<PetService>(endpoint, 'pet-service');
-
-  const allPets = await remotePetService.getPets();
-  console.log('Initial pets:', allPets); // -> [{ name: 'Fido', species: 'dog' }]
-
-  await remotePetService.addPet({ name: 'Whiskers', species: 'cat' });
-
-  const updatedPets = await remotePetService.getPets();
-  console.log('Updated pets:', updatedPets); // -> [{ name: 'Fido', species: 'dog' }, { name: 'Whiskers', species: 'cat' }]
-}
-
-main();
-```
-
-### Streaming Data with `ReadableStream`
-
-The `ReadableStreamRpcAdapter` allows you to transparently send and receive readable streams.
-
-**`stream.worker.ts` (Web Worker)**
-```typescript
-import { Rpc } from '@tstdl/rpc';
-import { ReadableStreamRpcAdapter } from '@tstdl/rpc/adapters';
-import { MessagePortRpcEndpoint } from '@tstdl/rpc/endpoints';
-import { timeout } from '@tstdl/base/utils';
-
-// Register the adapter on both ends
-Rpc.registerAdapter(new ReadableStreamRpcAdapter());
-
-const endpoint = new MessagePortRpcEndpoint(self as any);
-Rpc.listen(endpoint);
-
-function getLogStream(): ReadableStream<string> {
-  let count = 0;
-  return new ReadableStream({
-    async pull(controller) {
-      if (count++ >= 5) {
-        controller.close();
-        return;
-      }
-      await timeout(500);
-      controller.enqueue(`Log entry #${count}`);
-    },
-  });
-}
-
-// Expose a function that returns an adapted stream
-const getAdaptedLogStream = () => Rpc.adapt(getLogStream(), new ReadableStreamRpcAdapter());
-
-Rpc.expose(getAdaptedLogStream, 'log-service');
-```
-
-**`main.ts` (Main Thread)**
-```typescript
-import { Rpc } from '@tstdl/rpc';
-import { ReadableStreamRpcAdapter } from '@tstdl/rpc/adapters';
-import { MessagePortRpcEndpoint } from '@tstdl/rpc/endpoints';
-
-async function main() {
-  // Register the adapter on both ends
-  Rpc.registerAdapter(new ReadableStreamRpcAdapter());
-
-  const worker = new Worker(new URL('./stream.worker.ts', import.meta.url), { type: 'module' });
-  const endpoint = new MessagePortRpcEndpoint(worker);
-
-  const getRemoteLogStream = await Rpc.connect<() => ReadableStream<string>>(endpoint, 'log-service');
-
-  const stream = await getRemoteLogStream();
-  const reader = stream.getReader();
-
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) {
-      console.log('Stream finished.');
-      break;
-    }
-    console.log('Received:', value);
-  }
-}
-
-main();
-```
-
-### Transferring Data Efficiently
-
-Use `Rpc.transfer` to move large data like an `ArrayBuffer` without the performance overhead of copying.
-
-**`upload.worker.ts` (Web Worker)**
-```typescript
-import { Rpc } from '@tstdl/rpc';
-import { MessagePortRpcEndpoint } from '@tstdl/rpc/endpoints';
-
-const endpoint = new MessagePortRpcEndpoint(self as any);
-Rpc.listen(endpoint);
-
-async function uploadFile(buffer: ArrayBuffer): Promise<number> {
-  console.log(`Worker received a buffer of size: ${buffer.byteLength}`);
-  return buffer.byteLength;
-}
-
-Rpc.expose(uploadFile, 'upload-service');
-```
-
-**`main.ts` (Main Thread)**
-```typescript
-import { Rpc } from '@tstdl/rpc';
-import { MessagePortRpcEndpoint } from '@tstdl/rpc/endpoints';
-
-async function main() {
-  const worker = new Worker(new URL('./upload.worker.ts', import.meta.url), { type: 'module' });
-  const endpoint = new MessagePortRpcEndpoint(worker);
-
-  const remoteUploadFile = await Rpc.connect<(buffer: ArrayBuffer) => Promise<number>>(endpoint, 'upload-service');
-
-  // Create some data
-  const buffer = new Uint8Array(1024 * 1024 * 4).buffer; // 4MB
-  console.log(`Main thread sending buffer of size: ${buffer.byteLength}`);
-
-  // Call the remote function, marking the buffer for transfer
-  const receivedSize = await remoteUploadFile(Rpc.transfer(buffer, [buffer]));
-
-  console.log(`Worker confirmed receiving ${receivedSize} bytes.`);
-  console.log(`Buffer size in main thread after transfer: ${buffer.byteLength}`); // -> 0
-}
-
-main();
-```
-
-## API Summary
-
-| Function/Class | Arguments | Returns | Description |
-| :--- | :--- | :--- | :--- |
-| **Rpc** |
-| `listen` | `endpoint: RpcEndpoint` | `void` | Starts listening for incoming connections on an endpoint. |
-| `connect` | `endpoint: RpcEndpoint`, `name?: string` | `Promise<RpcRemote<T>>` | Connects to a remote object exposed with the given name. |
-| `expose` | `object: RpcRemoteInput`, `name?: string` | `void` | Makes an object or function available for remote connections. |
-| `registerAdapter` | `adapter: RpcAdapter` | `void` | Registers a custom adapter for handling non-serializable types. |
-| `proxy` | `object: T` | `T` | Explicitly marks an object to be transmitted as a remote proxy. |
-| `transfer` | `object: T`, `transfer: any[]` | `T` | Marks an object and its associated transferable data for efficient transfer. |
-| `serialize` | `object: T`, `options?: SerializationOptions` | `T` | Forces an object to be transmitted by value (serialized) instead of by proxy. |
-| `adapt` | `object: T`, `adapter: RpcAdapter` | `T` | Marks an object to be handled by a specific adapter. |
-| **MessagePortRpcEndpoint** |
-| `from` | `transport: MessagePortRpcTransport` | `MessagePortRpcEndpoint` | Creates a new RPC endpoint from a transport (Worker, MessagePort, etc.). |
-| **ReadableStreamRpcAdapter** |
-| `constructor` | `maxChunkSize?: number` | `ReadableStreamRpcAdapter` | Creates an adapter for `ReadableStream`. |

package/source/rpc/adapters/index.ts

@@ -1 +0,0 @@
-export * from './readable-stream.adapter.js';

package/source/rpc/adapters/readable-stream.adapter.ts

@@ -1,97 +0,0 @@
-import { NotSupportedError } from '#/errors/not-supported.error.js';
-import { Timer } from '#/utils/timer.js';
-import type { AdaptSourceResult, RpcAdapter } from '../rpc.adapter.js';
-import type { RpcChannel } from '../rpc.endpoint.js';
-
-type Request =
-  | { type: 'pull' }
-  | { type: 'cancel', reason?: any };
-
-type Response<T> =
-  | { type: 'values', values: T[] }
-  | { type: 'done' }
-  | { type: 'void' };
-
-export class ReadableStreamRpcAdapter<T> implements RpcAdapter<ReadableStream<T>, void, void, Request, Response<T>> {
-  readonly name = 'ReadableStream';
-  readonly maxChunkSize: number;
-
-  constructor(maxChunkSize = 1000) {
-    this.maxChunkSize = maxChunkSize;
-  }
-
-  adaptSource(stream: ReadableStream<T>, channel: RpcChannel<void, Request, Response<T>>): AdaptSourceResult<void> {
-    const reader = stream.getReader();
-
-    channel.request$.subscribe(async ({ id, data }) => { // eslint-disable-line @typescript-eslint/no-misused-promises
-      switch (data.type) {
-        case 'pull': {
-          const values: T[] = [];
-
-          const timer = Timer.startNew();
-          while ((timer.milliseconds < 3) && (values.length < this.maxChunkSize)) {
-            const result = await reader.read();
-
-            if (result.done) {
-              break;
-            }
-
-            values.push(result.value);
-          }
-
-          const response: Response<T> = (values.length > 0)
-            ? { type: 'values', values }
-            : { type: 'done' };
-
-          await channel.respond(id, response);
-
-          break;
-        }
-
-        case 'cancel': {
-          await reader.cancel(data.reason);
-          await channel.respond(id, { type: 'void' });
-          channel.close();
-
-          break;
-        }
-
-        default:
-          throw new NotSupportedError(`Type ${(data as Request).type} is not supported.`);
-      }
-    });
-  }
-
-  adaptTarget(_data: void, channel: RpcChannel<void, Request, Response<T>>): ReadableStream<T> {
-    return new ReadableStream<T>({
-      async pull(controller) {
-        const response = await channel.request({ type: 'pull' });
-
-        switch (response.type) {
-          case 'values': {
-            for (const value of response.values) {
-              controller.enqueue(value);
-            }
-
-            break;
-          }
-
-          case 'done': {
-            controller.close();
-            break;
-          }
-
-          default: {
-            throw new NotSupportedError(`Type ${(response as Response<T>).type} is not supported.`);
-          }
-        }
-      },
-      async cancel(reason) {
-        await channel.request({ type: 'cancel', reason });
-        channel.close();
-      }
-    });
-  }
-}
-
-export const defaultReadableStreamRpcAdapter = new ReadableStreamRpcAdapter();

package/source/rpc/endpoints/index.ts

@@ -1 +0,0 @@
-export * from './message-port.rpc-endpoint.js';

package/source/rpc/endpoints/message-port.rpc-endpoint.ts

@@ -1,185 +0,0 @@
-import type * as NodeWorkerThreads from 'node:worker_threads';
-
-import type { Observable } from 'rxjs';
-import { ReplaySubject, Subject, filter, fromEvent, map, shareReplay, startWith, switchMap, takeUntil } from 'rxjs';
-
-import { isBrowser } from '#/environment.js';
-import { deferThrow } from '#/utils/throw.js';
-import { isDefined, isUndefined } from '#/utils/type-guards.js';
-import type { RpcChannelMessage } from '../rpc.endpoint.js';
-import { RpcChannel, RpcEndpoint } from '../rpc.endpoint.js';
-
-type BrowserTransport = Worker | MessagePort | Window | SharedWorker;
-type NodeTransport = NodeWorkerThreads.MessagePort | NodeWorkerThreads.Worker;
-
-export type MessagePortRpcTransport = BrowserTransport | NodeTransport;
-
-type MessagePortMessageBase<Type extends string> = { seq: number, type: Type };
-type MessagePortOpenChannelMessage = MessagePortMessageBase<'open-channel'> & { id: string, port: MessagePort | NodeWorkerThreads.MessagePort };
-type MessagePortCloseChannelMessage = MessagePortMessageBase<'close-channel'>;
-type MessagePortDataMessage<T> = MessagePortMessageBase<'data'> & { data: T };
-
-type MessagePortMessage<T> = MessagePortOpenChannelMessage | MessagePortCloseChannelMessage | MessagePortDataMessage<T>;
-
-export class MessagePortRpcChannel<Data = any, Req = any, Res = any> extends RpcChannel<Data, Req, Res> {
-  readonly #transportSubject = new ReplaySubject<MessagePortRpcTransport>(1);
-  readonly #closeSubject = new Subject<void>();
-
-  private readonly _postMessage: (message: MessagePortMessage<RpcChannelMessage<Data, Req, Res>>, transfer?: any[]) => void;
-
-  private transport: MessagePortRpcTransport | undefined = { postMessage: deferThrow(() => new Error('Rpc transport not yet initialized.')) } satisfies Pick<MessagePort, 'postMessage'> as unknown as MessagePortRpcTransport;
-  readonly messagePortMessage$: Observable<MessagePortMessage<RpcChannelMessage<Data, Req, Res>>>;
-  override channelMessages$: Observable<RpcChannelMessage<Data, Req, Res>>;
-
-  override readonly supportsTransfers = true;
-  override readonly endpoint: MessagePortRpcEndpoint;
-
-  sequence = 1;
-  lastSequence = 0;
-
-  constructor(id: string, transport: MessagePortRpcTransport | undefined, endpoint: MessagePortRpcEndpoint) {
-    super(id);
-
-    this.endpoint = endpoint;
-
-    if (isDefined(transport)) {
-      this.setTransport(transport);
-    }
-
-    this.messagePortMessage$ = this.#transportSubject.pipe(
-      startWith(transport),
-      filter(isDefined),
-      switchMap((newTransport) => fromEvent<MessagePortMessage<RpcChannelMessage<Data, Req, Res>> | MessageEvent<MessagePortMessage<RpcChannelMessage<Data, Req, Res>>>>((newTransport as MessagePort), 'message')),
-      takeUntil(this.#closeSubject),
-      map((message) => ((message instanceof MessageEvent) ? message.data : message)),
-      shareReplay({ bufferSize: 0, refCount: true })
-    );
-
-    this.channelMessages$ = this.messagePortMessage$.pipe(
-      filter((message): message is MessagePortDataMessage<RpcChannelMessage<Data, Req, Res>> => message.type == 'data'),
-      map((message) => message.data)
-    );
-
-    this._postMessage = isBrowser
-      ? (data, transfer) => (this.transport as MessagePort).postMessage(data, { transfer })
-      : (data, transfer) => (this.transport as NodeTransport).postMessage(data, transfer);
-
-    if (transport instanceof MessagePort) {
-      transport.start();
-    }
-
-    this.messagePortMessage$.subscribe((message) => {
-      if (message.type == 'close-channel') {
-        this.close();
-      }
-    });
-  }
-
-  setTransport(transport: MessagePortRpcTransport): void {
-    this.transport = transport;
-
-    this.#transportSubject.next(transport);
-    this.#transportSubject.complete();
-  }
-
-  postPortMessage(message: MessagePortMessage<RpcChannelMessage<Data, Req, Res>>, transfer?: any[]): void {
-    this._postMessage(message, transfer);
-  }
-
-  override close(): void {
-    this.postPortMessage({ seq: this.sequence++, type: 'close-channel' });
-
-    if (this.transport instanceof MessagePort) {
-      this.transport.close();
-    }
-
-    this.#closeSubject.next();
-    this.endpoint.forgetChannel(this.id);
-  }
-
-  override postMessage(message: RpcChannelMessage<Data, Req, Res>, transfer?: any[] | undefined): void | Promise<void> {
-    this.postPortMessage({ seq: this.sequence++, type: 'data', data: message }, transfer);
-  }
-}
-
-export class MessagePortRpcEndpoint extends RpcEndpoint {
-  readonly #closeSubject = new Subject<void>();
-  readonly #channels = new Map<string, MessagePortRpcChannel>();
-
-  private readonly transport: MessagePortRpcTransport;
-  private readonly mainChannel: MessagePortRpcChannel;
-
-  constructor(source: MessagePortRpcTransport) {
-    super();
-
-    this.transport = (isBrowser && ((typeof SharedWorker == 'function') && (source instanceof SharedWorker)))
-      ? source.port
-      : source;
-
-    this.mainChannel = new MessagePortRpcChannel('main', this.transport, this);
-
-    this.mainChannel.messagePortMessage$.subscribe((message) => {
-      if (message.type == 'open-channel') {
-        this.handleOpenChannelMessage(message);
-      }
-    });
-  }
-
-  static from(transport: MessagePortRpcTransport): MessagePortRpcEndpoint {
-    return new MessagePortRpcEndpoint(transport);
-  }
-
-  override openChannel<Data, Req, Res>(id: string = crypto.randomUUID()): MessagePortRpcChannel<Data, Req, Res> {
-    const { port1, port2 } = new MessageChannel();
-
-    const openChannelMessage: MessagePortOpenChannelMessage = { seq: this.mainChannel.sequence++, type: 'open-channel', id, port: port2 };
-
-    this.mainChannel.postPortMessage(openChannelMessage, [port2]);
-
-    const channel = new MessagePortRpcChannel<Data, Req, Res>(id, port1, this);
-    this.#channels.set(id, channel);
-
-    return channel;
-  }
-
-  override getChannel<Data, Req, Res>(id: string): MessagePortRpcChannel<Data, Req, Res> {
-    const channel = this.#channels.get(id);
-
-    if (isUndefined(channel)) {
-      const newChannel = new MessagePortRpcChannel<Data, Req, Res>(id, undefined, this);
-      this.#channels.set(id, newChannel);
-
-      return newChannel;
-    }
-
-    return channel as MessagePortRpcChannel<Data, Req, Res>;
-  }
-
-  override getOrOpenChannel<Data, Req, Res>(id: string): RpcChannel<Data, Req, Res> {
-    return this.#channels.get(id) ?? this.openChannel(id);
-  }
-
-  close(): void {
-    if (this.transport instanceof MessagePort) {
-      this.transport.close();
-    }
-
-    this.#closeSubject.next();
-  }
-
-  forgetChannel(id: string): void {
-    this.#channels.delete(id);
-  }
-
-  private handleOpenChannelMessage(message: MessagePortOpenChannelMessage): void {
-    const { id, port } = message;
-
-    if (this.#channels.has(id)) {
-      this.#channels.get(id)!.setTransport(port);
-      return;
-    }
-
-    const channel = new MessagePortRpcChannel(id, port, this);
-    this.#channels.set(id, channel);
-  }
-}

package/source/rpc/index.ts

@@ -1,6 +0,0 @@
-export * from './adapters/index.js';
-export * from './model.js';
-export * from './rpc.adapter.js';
-export * from './rpc.endpoint.js';
-export * from './rpc.error.js';
-export * from './rpc.js';

package/source/rpc/model.ts

@@ -1,41 +0,0 @@
-import type { SerializationOptions } from '#/serializer/types.js';
-import type { Constructor, Record } from '#/types/index.js';
-
-export type RpcConstructor<T extends Constructor> = T extends Constructor<any, infer R> ? Constructor<Promise<RpcRemote<InstanceType<T>>>, R> : never;
-export type RpcFunction<T extends (...args: any) => any> = T extends (...args: infer Args) => infer R ? (...args: Args) => Promise<Awaited<R>> : never;
-export type RpcObject<T extends Record> = { [P in keyof T]: T[P] extends (...args: any) => any ? RpcFunction<T[P]> : Promise<Awaited<T[P]>> };
-
-export type RpcRemoteInput = ((...args: any) => any) | Record;
-
-export type RpcRemote<T extends RpcRemoteInput = RpcRemoteInput> =
-  T extends Constructor ? RpcConstructor<T> : T extends (...args: any) => any ? RpcFunction<T> : RpcObject<T>;
-
-export type RpcMessageBase<Type extends string = string> = { type: Type };
-
-export type RpcConnectMessage = RpcMessageBase<'connect'> & { name: string };
-
-export type RpcControlRequestMessage = RpcConnectMessage;
-
-export type RpcProxyApplyMessage = RpcMessageBase<'apply'> & { path: PropertyKey[], args: RpcValue[] };
-export type RpcProxyConstructMessage = RpcMessageBase<'construct'> & { path: PropertyKey[], args: RpcValue[] };
-export type RpcProxyGetMessage = RpcMessageBase<'get'> & { path: PropertyKey[] };
-export type RpcProxySetMessage = RpcMessageBase<'set'> & { path: PropertyKey[], value: RpcValue };
-export type RpcProxyRequestMessage = RpcProxyApplyMessage | RpcProxyConstructMessage | RpcProxyGetMessage | RpcProxySetMessage;
-
-export type RpcMessageRawValue = { type: 'raw', value: any };
-export type RpcMessageSerializedValue = { type: 'serialized', value: any, options?: SerializationOptions };
-export type RpcMessageProxyValue = { type: 'proxy', channel: string };
-export type RpcMessageAdapterValue = { type: 'adapter', adapter: string, channel: string, data: any };
-export type RpcMessageThrowValue = { type: 'throw', error: unknown };
-
-export type RpcValue = RpcMessageRawValue | RpcMessageSerializedValue | RpcMessageProxyValue | RpcMessageAdapterValue | RpcMessageThrowValue;
-
-export type RpcPostMessageArrayData = {
-  value: RpcValue[],
-  transfer?: any[]
-};
-
-export type RpcPostMessageData = {
-  value: RpcValue,
-  transfer?: any[]
-};

package/source/rpc/rpc.adapter.ts

@@ -1,14 +0,0 @@
-import type { NonPrimitive } from '#/serializer/types.js';
-import type { RpcChannel } from './rpc.endpoint.js';
-
-export type AdaptSourceResult<Data> = Data extends void ? (void | { data?: undefined, transfer?: any[] }) : { data: Data, transfer?: any[] };
-
-export type RpcAdapterNonPrimitive = NonPrimitive<string, RpcAdapterNonPrimitiveData>;
-export type RpcAdapterNonPrimitiveData = { channel: string, data: any };
-
-export interface RpcAdapter<T extends object = any, Data = any, ChannelData = any, Req = any, Res = any> {
-  name: string;
-
-  adaptSource(value: T, channel: RpcChannel<ChannelData, Req, Res>): AdaptSourceResult<Data>;
-  adaptTarget(data: Data, channel: RpcChannel<ChannelData, Req, Res>): T;
-}

package/source/rpc/rpc.endpoint.ts

@@ -1,86 +0,0 @@
-import { defer, filter, map, type Observable } from 'rxjs';
-
-export type RpcChannelDataMessage<T> = { type: 'data', data: T };
-export type RpcChannelRequestMessage<T> = { type: 'request', id: string, data: T };
-export type RpcChannelResponseMessage<T> = { type: 'response', id: string, data: T };
-export type RpcChannelMessage<Data, Req, Res> = RpcChannelDataMessage<Data> | RpcChannelRequestMessage<Req> | RpcChannelResponseMessage<Res>;
-
-export type RpcChannelRequest<T> = { id: string, data: T };
-
-export abstract class RpcEndpoint {
-  abstract openChannel<Data, Req, Res>(id?: string): RpcChannel<Data, Req, Res>;
-
-  abstract getChannel<Data, Req, Res>(id: string): RpcChannel<Data, Req, Res>;
-
-  abstract getOrOpenChannel<Data, Req, Res>(id: string): RpcChannel<Data, Req, Res>;
-
-  abstract close(): void;
-}
-
-/**
- * @template Data - type of data-messages
- * @template Req - type of request-messages
- * @template Res - type of response-messages
- */
-export abstract class RpcChannel<Data = unknown, Req = unknown, Res = unknown> {
-  readonly id: string;
-  readonly message$: Observable<Data>;
-  readonly request$: Observable<RpcChannelRequest<Req>>;
-
-  protected abstract readonly channelMessages$: Observable<RpcChannelMessage<Data, Req, Res>>;
-
-  abstract readonly supportsTransfers: boolean;
-  abstract readonly endpoint: RpcEndpoint;
-
-  constructor(id: string) {
-    this.id = id;
-
-    this.message$ = defer(() => this.channelMessages$.pipe(
-      filter((message): message is RpcChannelDataMessage<Data> => message.type == 'data'),
-      map((message) => message.data)
-    ));
-
-    this.request$ = defer(() => this.channelMessages$.pipe(
-      filter((message): message is RpcChannelRequestMessage<Req> => message.type == 'request'),
-      map((message) => message)
-    ));
-  }
-
-  async request<U extends Res>(data: Req, transfer?: any[]): Promise<U> {
-    const id = crypto.randomUUID();
-
-    const $response = getResponsePromise(this.channelMessages$, id);
-    await this.postMessage({ type: 'request', id, data } satisfies RpcChannelRequestMessage<Req>, transfer);
-    const response = await $response;
-
-    return response as U;
-  }
-
-  async respond(id: string, data: Res, transfer?: any[]): Promise<void> {
-    await this.postMessage({ type: 'response', id, data } satisfies RpcChannelResponseMessage<Res>, transfer);
-  }
-
-  async send(data: Data, transfer?: any[]): Promise<void> {
-    await this.postMessage({ type: 'data', data } satisfies RpcChannelDataMessage<Data>, transfer);
-  }
-
-  abstract close(): void;
-
-  protected abstract postMessage(message: RpcChannelMessage<Data, Req, Res>, transfer?: any[]): void | Promise<void>;
-}
-
-async function getResponsePromise<Data, Req, Res>(channelMessage$: Observable<RpcChannelMessage<Data, Req, Res>>, requestId: string): Promise<Res> {
-  return new Promise<Res>((resolve, reject) => {
-    const subscription = channelMessage$.subscribe({
-      next(message) {
-        if ((message.type == 'response') && (message.id == requestId)) {
-          resolve(message.data);
-          subscription.unsubscribe();
-        }
-      },
-      complete() {
-        reject(new Error('RpcEndpoint was closed while waiting for response.'));
-      }
-    });
-  });
-}