chrome-in-iframe 1.0.0 → 2.0.0

package/dist/channel/types.d.ts

@@ -40,12 +40,20 @@ export interface Messages {
         data?: MessageValue;
         error?: SerializedError;
     };
+    releaseCallbacks: {
+        ids: string[];
+    };
+    destroyEndpoint: {
+        instanceId: string;
+    };
 }
 export type MessageType = keyof Messages;
 export type MessageBody<K extends MessageType = MessageType> = {
     type: K;
     key: string;
     data: Messages[K];
+    senderInstanceId: string;
+    targetInstanceId?: string;
 };
 export interface MessagePoster {
     postMessage(message: string): void;
@@ -60,32 +68,42 @@ export interface PromiseCallbacks {
 export interface ClientContext {
     getDelegateTarget(): MessageValue;
     getMessageChannel(): MessageChannel;
-    getFunctionCache(): LRUCache<string, Callable>;
-    getPersistentFunctionCache(): Map<string, Callable>;
-    registerFunction(fn: Callable, options?: CallbackCacheOptions): string;
-    getRemoteCallback(id: string, invoke: (args: MessageValue[]) => MessageValue, options?: CallbackCacheOptions): Callable;
+    getInstanceId(): string;
+    getFunctionCache(): LRUCache<string, CallbackEntry>;
+    getPersistentFunctionCache(): Map<string, CallbackEntry>;
+    registerFunction(fn: Callable, thisArg: MessageValue, options?: CallbackCacheOptions): string;
+    getRemoteCallback(id: string, invoke: (args: MessageValue[]) => MessageValue, options: CallbackCacheOptions | undefined, remoteInstanceId: string): Callable;
     getAndRemovePendingPromise(id: RequestId): PromiseCallbacks | undefined;
     invoke(path: PathKey[], args: MessageValue[]): Promise<MessageValue>;
     accessProperty(path: PathKey[]): Promise<MessageValue>;
     invokeFunctionById(id: string, args: MessageValue[], options?: CallbackCacheOptions): Promise<MessageValue>;
     registerPendingPromise(id: RequestId, callbacks: PromiseCallbacks): void;
-    destroy(): void;
+    handleRemoteDestroy(instanceId: string): void;
+    destroy(notifyRemote?: boolean): void;
 }
 export interface CallbackCacheOptions {
     persistent?: boolean;
 }
+export interface CallbackEntry {
+    fn: Callable;
+    thisArg: MessageValue;
+}
 export interface MessageChannel {
     getSender(): MessageSender;
     getContext(): ClientContext;
     getPoster(): MessagePoster;
     getKey(): string;
+    getInstanceId(): string;
     destroy(): void;
 }
 export interface MessageSender {
-    sendMessage<K extends MessageType>(type: K, data: Messages[K]): void;
+    sendMessage<K extends MessageType>(type: K, data: Messages[K], targetInstanceId?: string): void;
 }
 export interface RequestHandler<K extends MessageType = MessageType> {
-    (data: Messages[K], ctx: ClientContext): void;
+    (data: Messages[K], ctx: ClientContext, meta: MessageMeta): void;
+}
+export interface MessageMeta {
+    senderInstanceId: string;
 }
 export type ProxyNode = {
     parent?: ProxyNode;

package/dist/client/context.d.ts

@@ -2,5 +2,9 @@ import type { ClientContext, MessageChannel, MessageValue } from '../channel/typ
 export interface ClientContextOptions {
     delegateTarget?: MessageValue;
     timeout?: number;
+    functionCacheMax?: number;
+    functionCacheTtl?: number;
+    remoteCallbackCacheMax?: number;
+    remoteCallbackCacheTtl?: number;
 }
-export declare function createClientContext(getMessageChannel: () => MessageChannel, options?: ClientContextOptions): ClientContext;
+export declare function createClientContext(getMessageChannel: () => MessageChannel, instanceId: string, options?: ClientContextOptions): ClientContext;

package/dist/client/endpoint.d.ts

@@ -1,4 +1,4 @@
-import type { MessagePoster } from '../channel/types';
+import type { ClientContext, MessagePoster } from '../channel/types';
 import { type ClientContextOptions } from './context';
 export interface EndpointOptions {
     poster: MessagePoster;
@@ -8,5 +8,7 @@ export interface EndpointOptions {
 export interface Endpoint<TProxy = unknown> {
     proxy: TProxy;
     destroy: () => void;
+    /** @internal Exposed for tests; do not use in application code. */
+    getContext: () => ClientContext;
 }
 export declare function createEndpoint<TProxy = unknown>(options: EndpointOptions): Endpoint<TProxy>;