@tstdl/base 0.90.19 → 0.90.20

package/api/server/gateway.js

@@ -111,7 +111,7 @@ let ApiGateway = class ApiGateway {
                     };
                     this.apis.set(resource, resourceApis);
                 }
-                const endpointImplementation = implementation[name]?.bind(implementation) ?? deferThrow(new NotImplementedError(`Endpoint ${name} for resource ${resource} not implemented.`));
+                const endpointImplementation = implementation[name]?.bind(implementation) ?? deferThrow(() => new NotImplementedError(`Endpoint ${name} for resource ${resource} not implemented.`));
                 for (const method of methods) {
                     resourceApis.endpoints.set(method, { definition: endpointDefinition, implementation: endpointImplementation });
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.90.19",
+  "version": "0.90.20",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -126,7 +126,7 @@
     "esbuild": "0.19",
     "eslint": "8.52",
     "eslint-import-resolver-typescript": "3.6",
-    "eslint-plugin-import": "2.28",
+    "eslint-plugin-import": "2.29",
     "tsc-alias": "1.8",
     "typedoc": "0.25",
     "typedoc-plugin-missing-exports": "2.1",

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

@@ -7,6 +7,7 @@ type BrowserSource = Worker | MessagePort | Window | SharedWorker;
 type NodeSource = NodeWorkerThreads.MessagePort | NodeWorkerThreads.Worker;
 export type MessagePortRpcEndpointSource = BrowserSource | NodeSource;
 export declare class MessagePortRpcEndpoint extends RpcEndpoint {
+    #private;
     private readonly source;
     private readonly _postMessage;
     readonly supportsTransfers: boolean;

package/rpc/endpoints/message-port.rpc-endpoint.js

@@ -1,7 +1,8 @@
-import { fromEvent, map } from 'rxjs';
+import { Subject, fromEvent, map, takeUntil } from 'rxjs';
 import { isBrowser } from '../../environment.js';
 import { RpcEndpoint } from '../rpc-endpoint.js';
 export class MessagePortRpcEndpoint extends RpcEndpoint {
+    #closeSubject = new Subject();
     source;
     _postMessage;
     supportsTransfers = true;
@@ -11,7 +12,7 @@ export class MessagePortRpcEndpoint extends RpcEndpoint {
         this.source = (isBrowser && ((typeof SharedWorker == 'function') && (source instanceof SharedWorker)))
             ? source.port
             : source;
-        this.message$ = fromEvent(this.source, 'message').pipe(map((message) => ((message instanceof MessageEvent) ? { ...message.data, metadata: { source: message } } : message)));
+        this.message$ = fromEvent(this.source, 'message').pipe(takeUntil(this.#closeSubject), map((message) => ((message instanceof MessageEvent) ? { ...message.data, metadata: { source: message } } : message)));
         this._postMessage = isBrowser
             ? (data, transfer) => this.source.postMessage(data, { transfer })
             : (data, transfer) => this.source.postMessage(data, transfer);
@@ -25,6 +26,7 @@ export class MessagePortRpcEndpoint extends RpcEndpoint {
         if (this.source instanceof MessagePort) {
             this.source.close();
         }
+        this.#closeSubject.next();
     }
     postMessage(data, transfer) {
         this._postMessage(data, transfer);

package/rpc/rpc-endpoint.js

@@ -1,8 +1,7 @@
-import { filter, firstValueFrom } from 'rxjs';
+import { filter } from 'rxjs';
 export class RpcEndpoint {
     async request(message, transfer) {
-        const response$ = this.message$.pipe(filter((incomingMessage) => (incomingMessage.type == 'response') && (incomingMessage.id == message.id)));
-        const $response = firstValueFrom(response$);
+        const $response = getResponsePromise(this.message$, message.id);
         await this.postMessage(message, transfer);
         const response = await $response;
         return response.value;
@@ -16,3 +15,17 @@ export class RpcEndpoint {
         await this.postMessage(message, transfer);
     }
 }
+async function getResponsePromise(message$, messageId) {
+    const response$ = message$.pipe(filter((incomingMessage) => (incomingMessage.type == 'response') && (incomingMessage.id == messageId)));
+    return new Promise((resolve, reject) => {
+        const subscription = response$.subscribe({
+            next(value) {
+                resolve(value);
+                subscription.unsubscribe();
+            },
+            complete() {
+                reject(new Error('RpcEndpoint was closed while waiting for response.'));
+            }
+        });
+    });
+}

package/rpc/rpc.js

@@ -6,7 +6,7 @@ import { deserialize, registerSerializer, serialize } from '../serializer/index.
 import { hasOwnProperty } from '../utils/object/object.js';
 import { reflectMethods } from '../utils/proxy.js';
 import { getRandomString } from '../utils/random.js';
-import { _throw } from '../utils/throw.js';
+import { _throw, deferThrow } from '../utils/throw.js';
 import { assert, isDefined } from '../utils/type-guards.js';
 import { MessagePortRpcEndpoint } from './endpoints/message-port.rpc-endpoint.js';
 import { createRpcMessage } from './model.js';
@@ -15,10 +15,16 @@ import { RpcError, RpcRemoteError } from './rpc-error.js';
 const markedTransfers = new WeakMap();
 const serializationTargets = new WeakMap();
 const proxyTargets = new WeakSet();
+const responsibleEndpoints = new WeakSet();
 const proxyFinalizationRegistry = new FinalizationRegistry(async (data) => {
     const message = createRpcMessage('release-proxy', { proxyId: data.id });
     await data.endpoint.postMessage(message);
+    if (responsibleEndpoints.has(data.endpoint)) {
+        data.endpoint.close();
+    }
 });
+class RpcProxy {
+}
 // eslint-disable-next-line @typescript-eslint/no-redeclare, @typescript-eslint/naming-convention
 export const Rpc = {
     async connect(endpointOrSource, name = 'default') {
@@ -60,8 +66,6 @@ export const Rpc = {
     }
 };
 function createProxy(endpoint, id, path = []) {
-    class RpcProxy {
-    }
     // eslint-disable-next-line prefer-const
     let proxy;
     const handlers = {
@@ -97,13 +101,13 @@ function createProxy(endpoint, id, path = []) {
     };
     for (const method of reflectMethods) {
         if (!hasOwnProperty(handlers, method)) {
-            handlers[method] = () => {
-                throw new Error(`${method} not supported on rpc proxies.`);
-            };
+            handlers[method] = deferThrow(() => new Error(`${method} not supported on rpc proxies.`));
         }
     }
     proxy = new Proxy(RpcProxy, handlers);
-    proxyFinalizationRegistry.register(proxy, { id, endpoint });
+    if (path.length == 0) {
+        proxyFinalizationRegistry.register(proxy, { id, endpoint });
+    }
     return proxy;
 }
 function exposeConnectable(object, endpoint, name) {
@@ -120,9 +124,9 @@ function exposeConnectable(object, endpoint, name) {
     });
 }
 function exposeObject(object, endpoint, proxyId) {
-    const abortSubject = new Subject();
+    const releaseSubject = new Subject();
     endpoint.message$
-        .pipe(takeUntil(abortSubject), filter((message) => (message.proxyId == proxyId)))
+        .pipe(takeUntil(releaseSubject), filter((message) => (message.proxyId == proxyId)))
         .subscribe(async (message) => {
         try {
             switch (message.type) {
@@ -154,7 +158,10 @@ function exposeObject(object, endpoint, proxyId) {
                     break;
                 }
                 case 'release-proxy': {
-                    abortSubject.next();
+                    releaseSubject.next();
+                    if (responsibleEndpoints.has(endpoint)) {
+                        endpoint.close();
+                    }
                     break;
                 }
                 case 'response':
@@ -200,6 +207,7 @@ function createProxyValue(value, endpoint) {
     if (endpoint.supportsTransfers) {
         const { port1, port2 } = new MessageChannel();
         const newEndpoint = new MessagePortRpcEndpoint(port1);
+        responsibleEndpoints.add(newEndpoint);
         newEndpoint.start();
         exposeObject(value, newEndpoint, id);
         return [{ type: 'proxy', id, port: port2 }, [port2]];
@@ -224,6 +232,9 @@ function parseRpcMessageValue(value, endpoint) {
         }
         case 'proxy': {
             const proxyEndpoint = (isDefined(value.port)) ? new MessagePortRpcEndpoint(value.port) : endpoint;
+            if (isDefined(value.port)) {
+                responsibleEndpoints.add(proxyEndpoint);
+            }
             proxyEndpoint.start();
             return createProxy(proxyEndpoint, value.id);
         }
@@ -243,8 +254,6 @@ function deref(object, path, skipLast = false) {
     }
     return { parent, value };
 }
-class RpcProxy {
-}
 registerSerializer(RpcProxy, 'RpcProxy', () => _throw(new Error('Not supported.')), (data, _, { rpcEndpoint }) => parseRpcMessageValue({ type: 'proxy', ...data }, rpcEndpoint));
 function getRpcProxySerializationReplacer(endpoint, transfer) {
     function rpcProxySerializationReplacer(value) {

package/threading/thread-pool.d.ts

@@ -1,8 +1,9 @@
 /// <reference types="node" resolution-mode="require"/>
+import type * as NodeWorkerThreads from 'node:worker_threads';
+import type { LiteralUnion } from 'type-fest';
 import type { AsyncDisposable } from '../disposable/index.js';
 import { disposeAsync } from '../disposable/index.js';
 import type { Logger } from '../logger/index.js';
-import type * as NodeWorkerThreads from 'node:worker_threads';
 import type { ThreadWorker } from './thread-worker.js';
 export type ThreadOptions = (WorkerOptions | NodeWorkerThreads.WorkerOptions) & {
     threadCount?: number;
@@ -15,6 +16,6 @@ export declare class ThreadPool implements AsyncDisposable {
     dispose(): Promise<void>;
     [disposeAsync](): Promise<void>;
     getProcessor<T extends ThreadWorker>(name?: string): (...args: Parameters<T>) => Promise<ReturnType<T>>;
-    process<T extends ThreadWorker>(name: string, ...args: Parameters<T>): Promise<ReturnType<T>>;
+    process<T extends ThreadWorker>(name: LiteralUnion<'default', string>, ...args: Parameters<T>): Promise<ReturnType<T>>;
     private spawn;
 }

package/utils/throw.d.ts

@@ -1,2 +1,2 @@
 export declare function _throw(value: any): never;
-export declare function deferThrow(value: any): () => never;
+export declare function deferThrow(valueProvider: () => any): () => never;

package/utils/throw.js

@@ -1,9 +1,8 @@
 export function _throw(value) {
     throw value;
 }
-export function deferThrow(value) {
-    // eslint-disable-next-line @typescript-eslint/no-shadow
+export function deferThrow(valueProvider) {
     return function deferThrow() {
-        throw value;
+        throw valueProvider();
     };
 }