@kookapp/web-bridge 0.0.1

package/dist/parent/IframeChannel.js

@@ -0,0 +1,96 @@
+/**
+ * IframeChannel for managing communication with a specific iframe
+ */
+import { MessageHandler } from '@/shared/MessageHandler';
+export class IframeChannel extends MessageHandler {
+    constructor(iframe, allowedOrigins, timeout = 5000, debug = false) {
+        super(allowedOrigins, timeout, debug);
+        this.connected = false;
+        this.iframe = iframe;
+        this.iframeOrigin = this.extractOrigin(iframe.src);
+        // Setup message listener for this channel
+        this.setupMessageListener((event) => {
+            // Only accept messages from the specific iframe
+            if (event.source === this.iframe.contentWindow) {
+                this.handleMessage(event.data, event.origin);
+                if (!this.connected) {
+                    this.connected = true;
+                    this.eventEmitter.emit('ready');
+                }
+            }
+        });
+    }
+    /**
+     * Extract origin from URL
+     */
+    extractOrigin(url) {
+        try {
+            return new URL(url).origin;
+        }
+        catch {
+            // If iframe.src is not a valid URL, return current location origin
+            return window.location.origin;
+        }
+    }
+    /**
+     * Call a handler in the iframe
+     */
+    async callHandler(handlerName, data, callback) {
+        if (!this.iframe.contentWindow) {
+            throw new Error('iframe contentWindow is not available');
+        }
+        const promise = this.callHandlerWithTimeout(this.iframeOrigin, handlerName, data);
+        if (callback) {
+            promise.then(callback).catch(error => console.error(error));
+        }
+        return promise;
+    }
+    /**
+     * Send message to iframe
+     */
+    sendMessage(targetOrigin, message) {
+        if (!this.iframe.contentWindow) {
+            if (this.debug) {
+                console.warn('[WebBridge] iframe contentWindow is not available');
+            }
+            return;
+        }
+        // Add version info
+        message._version = '1.0.0';
+        this.iframe.contentWindow.postMessage(message, targetOrigin);
+        if (this.debug) {
+            console.log(`[WebBridge] Sent message to iframe:`, message);
+        }
+    }
+    /**
+     * Get target origin (for this channel, it's the iframe origin)
+     */
+    getTargetOrigin() {
+        return this.iframeOrigin;
+    }
+    /**
+     * Get the iframe element
+     */
+    getIframe() {
+        return this.iframe;
+    }
+    /**
+     * Check if connected
+     */
+    isConnected() {
+        return this.connected && !!this.iframe.contentWindow;
+    }
+    /**
+     * Set connected status
+     */
+    setConnected(connected) {
+        this.connected = connected;
+    }
+    /**
+     * Destroy the channel
+     */
+    destroy() {
+        super.destroy();
+        this.connected = false;
+    }
+}

package/dist/parent/ParentBridge.d.ts

@@ -0,0 +1,41 @@
+/**
+ * ParentBridge for managing iframe communication from parent
+ */
+import { ParentBridgeConfig, BridgeMessage } from '@/types';
+import { MessageHandler } from '@/shared/MessageHandler';
+import { IframeChannel } from '@/parent/IframeChannel';
+export declare class ParentBridge extends MessageHandler {
+    private channels;
+    constructor(config: ParentBridgeConfig);
+    /**
+     * Create a channel for an iframe
+     */
+    createChannel(iframe: HTMLIFrameElement, options?: {
+        origin?: string;
+    }): IframeChannel;
+    /**
+     * Get channel for an iframe
+     */
+    getChannel(iframe: HTMLIFrameElement): IframeChannel | undefined;
+    /**
+     * Remove channel for an iframe
+     */
+    removeChannel(iframe: HTMLIFrameElement): void;
+    /**
+     * Send message (overrides parent method)
+     */
+    protected sendMessage(targetOrigin: string, message: BridgeMessage): void;
+    /**
+     * Get target origin
+     */
+    protected getTargetOrigin(): string;
+    /**
+     * Check if any channel is connected
+     */
+    isConnected(): boolean;
+    /**
+     * Destroy the bridge and all channels
+     */
+    destroy(): void;
+}
+//# sourceMappingURL=ParentBridge.d.ts.map

package/dist/parent/ParentBridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParentBridge.d.ts","sourceRoot":"","sources":["../../src/parent/ParentBridge.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAC3D,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAA;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAA;AAGtD,qBAAa,YAAa,SAAQ,cAAc;IAC9C,OAAO,CAAC,QAAQ,CAAmD;gBAEvD,MAAM,EAAE,kBAAkB;IAqBtC;;OAEG;IACH,aAAa,CACX,MAAM,EAAE,iBAAiB,EACzB,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,GAC5B,aAAa;IAuBhB;;OAEG;IACH,UAAU,CAAC,MAAM,EAAE,iBAAiB,GAAG,aAAa,GAAG,SAAS;IAIhE;;OAEG;IACH,aAAa,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI;IAY9C;;OAEG;IACH,SAAS,CAAC,WAAW,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,GAAG,IAAI;IAezE;;OAEG;IACH,SAAS,CAAC,eAAe,IAAI,MAAM;IAKnC;;OAEG;IACH,WAAW,IAAI,OAAO;IAItB;;OAEG;IACH,OAAO,IAAI,IAAI;CAWhB"}

package/dist/parent/ParentBridge.js

@@ -0,0 +1,101 @@
+/**
+ * ParentBridge for managing iframe communication from parent
+ */
+import { MessageHandler } from '@/shared/MessageHandler';
+import { IframeChannel } from '@/parent/IframeChannel';
+import { DEFAULT_TIMEOUT } from '@/constants';
+export class ParentBridge extends MessageHandler {
+    constructor(config) {
+        const timeout = config.timeout || DEFAULT_TIMEOUT;
+        super(config.allowedOrigins, timeout, config.debug);
+        this.channels = new Map();
+        // Setup global message listener for parent
+        this.setupMessageListener((event) => {
+            // Only handle messages from iframes that are registered
+            const channel = Array.from(this.channels.values()).find(ch => ch.getIframe().contentWindow === event.source);
+            if (channel) {
+                this.handleMessage(event.data, event.origin);
+            }
+        });
+        if (this.debug) {
+            console.log('[WebBridge] ParentBridge initialized');
+        }
+    }
+    /**
+     * Create a channel for an iframe
+     */
+    createChannel(iframe, options) {
+        // If channel already exists, return it
+        if (this.channels.has(iframe)) {
+            return this.channels.get(iframe);
+        }
+        // Create new channel
+        const channel = new IframeChannel(iframe, this.originValidator.getAllowedOrigins(), this.timeout, this.debug);
+        this.channels.set(iframe, channel);
+        if (this.debug) {
+            console.log(`[WebBridge] Channel created for iframe`);
+        }
+        return channel;
+    }
+    /**
+     * Get channel for an iframe
+     */
+    getChannel(iframe) {
+        return this.channels.get(iframe);
+    }
+    /**
+     * Remove channel for an iframe
+     */
+    removeChannel(iframe) {
+        const channel = this.channels.get(iframe);
+        if (channel) {
+            channel.destroy();
+            this.channels.delete(iframe);
+            if (this.debug) {
+                console.log('[WebBridge] Channel removed');
+            }
+        }
+    }
+    /**
+     * Send message (overrides parent method)
+     */
+    sendMessage(targetOrigin, message) {
+        // Find the channel with matching origin
+        for (const channel of this.channels.values()) {
+            if (channel.getIframe().contentWindow) {
+                // Add version info
+                message._version = '1.0.0';
+                channel.getIframe().contentWindow.postMessage(message, targetOrigin);
+                if (this.debug) {
+                    console.log('[WebBridge] Sent message from parent:', message);
+                }
+            }
+        }
+    }
+    /**
+     * Get target origin
+     */
+    getTargetOrigin() {
+        // For parent bridge, return current window origin
+        return window.location.origin;
+    }
+    /**
+     * Check if any channel is connected
+     */
+    isConnected() {
+        return Array.from(this.channels.values()).some(ch => ch.isConnected());
+    }
+    /**
+     * Destroy the bridge and all channels
+     */
+    destroy() {
+        for (const channel of this.channels.values()) {
+            channel.destroy();
+        }
+        this.channels.clear();
+        super.destroy();
+        if (this.debug) {
+            console.log('[WebBridge] ParentBridge destroyed');
+        }
+    }
+}

package/dist/parent/index.d.ts

@@ -0,0 +1,6 @@
+export { ParentBridge } from '@/parent/ParentBridge';
+export { IframeChannel } from '@/parent/IframeChannel';
+export type { IframeChannelInterface } from '@/types';
+export type { ParentBridgeConfig } from '@/types';
+export * from '@/parent/utils';
+//# sourceMappingURL=index.d.ts.map

package/dist/parent/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/parent/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAA;AACtD,YAAY,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAA;AACrD,YAAY,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AACjD,cAAc,gBAAgB,CAAA"}

package/dist/parent/index.js

@@ -0,0 +1,3 @@
+export { ParentBridge } from '@/parent/ParentBridge';
+export { IframeChannel } from '@/parent/IframeChannel';
+export * from '@/parent/utils';

package/dist/parent/utils.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Utility functions for parent bridge
+ */
+export declare function validateIframe(iframe: HTMLIFrameElement): boolean;
+export declare function getIframeOrigin(iframe: HTMLIFrameElement): string;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/parent/utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,wBAAgB,cAAc,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAKjE;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,iBAAiB,GAAG,MAAM,CASjE"}

package/dist/parent/utils.js

@@ -0,0 +1,23 @@
+/**
+ * Utility functions for parent bridge
+ */
+export function validateIframe(iframe) {
+    if (!iframe)
+        return false;
+    if (!(iframe instanceof HTMLIFrameElement))
+        return false;
+    if (!iframe.contentWindow)
+        return false;
+    return true;
+}
+export function getIframeOrigin(iframe) {
+    try {
+        if (!iframe.src) {
+            return window.location.origin;
+        }
+        return new URL(iframe.src).origin;
+    }
+    catch {
+        return window.location.origin;
+    }
+}

package/dist/shared/EventEmitter.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Simple EventEmitter for bridge events
+ */
+import { BridgeEventType } from '@/types';
+export declare class EventEmitter {
+    private listeners;
+    on(type: BridgeEventType, callback: (data?: any) => void): void;
+    off(type: BridgeEventType, callback: (data?: any) => void): void;
+    emit(type: BridgeEventType, data?: any): void;
+    removeAllListeners(type?: BridgeEventType): void;
+    hasListener(type: BridgeEventType): boolean;
+}
+//# sourceMappingURL=EventEmitter.d.ts.map

package/dist/shared/EventEmitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventEmitter.d.ts","sourceRoot":"","sources":["../../src/shared/EventEmitter.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAEzC,qBAAa,YAAY;IACvB,OAAO,CAAC,SAAS,CAA+D;IAEhF,EAAE,CAAC,IAAI,EAAE,eAAe,EAAE,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,GAAG,KAAK,IAAI,GAAG,IAAI;IAO/D,GAAG,CAAC,IAAI,EAAE,eAAe,EAAE,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,GAAG,KAAK,IAAI,GAAG,IAAI;IAUhE,IAAI,CAAC,IAAI,EAAE,eAAe,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI;IAa7C,kBAAkB,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,IAAI;IAQhD,WAAW,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO;CAG5C"}

package/dist/shared/EventEmitter.js

@@ -0,0 +1,47 @@
+/**
+ * Simple EventEmitter for bridge events
+ */
+export class EventEmitter {
+    constructor() {
+        this.listeners = new Map();
+    }
+    on(type, callback) {
+        if (!this.listeners.has(type)) {
+            this.listeners.set(type, []);
+        }
+        this.listeners.get(type).push(callback);
+    }
+    off(type, callback) {
+        if (!this.listeners.has(type))
+            return;
+        const callbacks = this.listeners.get(type);
+        const index = callbacks.indexOf(callback);
+        if (index >= 0) {
+            callbacks.splice(index, 1);
+        }
+    }
+    emit(type, data) {
+        if (!this.listeners.has(type))
+            return;
+        const callbacks = this.listeners.get(type) || [];
+        callbacks.forEach(callback => {
+            try {
+                callback(data);
+            }
+            catch (error) {
+                console.error(`EventEmitter error in ${type} listener:`, error);
+            }
+        });
+    }
+    removeAllListeners(type) {
+        if (type) {
+            this.listeners.delete(type);
+        }
+        else {
+            this.listeners.clear();
+        }
+    }
+    hasListener(type) {
+        return this.listeners.has(type) && (this.listeners.get(type)?.length ?? 0) > 0;
+    }
+}

package/dist/shared/IdGenerator.d.ts

@@ -0,0 +1,11 @@
+/**
+ * ID generator for unique message IDs
+ */
+export declare class IdGenerator {
+    private counter;
+    private prefix;
+    constructor(prefix?: string);
+    generate(): string;
+    reset(): void;
+}
+//# sourceMappingURL=IdGenerator.d.ts.map

package/dist/shared/IdGenerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IdGenerator.d.ts","sourceRoot":"","sources":["../../src/shared/IdGenerator.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,qBAAa,WAAW;IACtB,OAAO,CAAC,OAAO,CAAY;IAC3B,OAAO,CAAC,MAAM,CAAQ;gBAEV,MAAM,GAAE,MAAc;IAIlC,QAAQ,IAAI,MAAM;IAKlB,KAAK,IAAI,IAAI;CAGd"}

package/dist/shared/IdGenerator.js

@@ -0,0 +1,16 @@
+/**
+ * ID generator for unique message IDs
+ */
+export class IdGenerator {
+    constructor(prefix = 'msg') {
+        this.counter = 0;
+        this.prefix = prefix;
+    }
+    generate() {
+        this.counter++;
+        return `${this.prefix}_${Date.now()}_${this.counter}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+    reset() {
+        this.counter = 0;
+    }
+}

package/dist/shared/MessageHandler.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Base class for handling postMessage communication
+ */
+import { BridgeMessage, HandlerRegistry, PendingRequest } from '@/types';
+import { EventEmitter } from '@/shared/EventEmitter';
+import { OriginValidator } from '@/shared/OriginValidator';
+import { IdGenerator } from '@/shared/IdGenerator';
+export declare abstract class MessageHandler {
+    protected handlers: HandlerRegistry;
+    protected pendingRequests: Map<string, PendingRequest>;
+    protected eventEmitter: EventEmitter;
+    protected originValidator: OriginValidator;
+    protected idGenerator: IdGenerator;
+    protected timeout: number;
+    protected debug: boolean;
+    protected messageListener: ((event: MessageEvent) => void) | null;
+    constructor(allowedOrigins: string[], timeout?: number, debug?: boolean);
+    /**
+     * Register a handler
+     */
+    registerHandler(handlerName: string, handler: (data?: any, callback?: Function) => void): void;
+    /**
+     * Unregister a handler
+     */
+    unregisterHandler(handlerName: string): void;
+    /**
+     * Call a handler on the other side with timeout
+     */
+    protected callHandlerWithTimeout(targetOrigin: string, handlerName: string, data?: any): Promise<any>;
+    /**
+     * Send a message to the other side (must be implemented by subclass)
+     */
+    protected abstract sendMessage(targetOrigin: string, message: BridgeMessage): void;
+    /**
+     * Get the target origin for sending messages (must be implemented by subclass)
+     */
+    protected abstract getTargetOrigin(): string;
+    /**
+     * Handle incoming message
+     */
+    protected handleMessage(message: BridgeMessage, origin: string): void;
+    /**
+     * Handle incoming call message
+     */
+    private handleCall;
+    /**
+     * Handle incoming response message
+     */
+    private handleResponse;
+    /**
+     * Setup message listener
+     */
+    protected setupMessageListener(handler: (event: MessageEvent) => void): void;
+    /**
+     * Remove message listener
+     */
+    protected removeMessageListener(): void;
+    /**
+     * Check if connected
+     */
+    abstract isConnected(): boolean;
+    /**
+     * Add event listener
+     */
+    on(type: 'ready' | 'disconnect' | 'error', callback: (data?: any) => void): void;
+    /**
+     * Remove event listener
+     */
+    off(type: 'ready' | 'disconnect' | 'error', callback: (data?: any) => void): void;
+    /**
+     * Clean up
+     */
+    destroy(): void;
+}
+//# sourceMappingURL=MessageHandler.d.ts.map

package/dist/shared/MessageHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessageHandler.d.ts","sourceRoot":"","sources":["../../src/shared/MessageHandler.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AACxE,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AACpD,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAC1D,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAIlD,8BAAsB,cAAc;IAClC,SAAS,CAAC,QAAQ,EAAE,eAAe,CAAY;IAC/C,SAAS,CAAC,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAY;IAClE,SAAS,CAAC,YAAY,EAAE,YAAY,CAAqB;IACzD,SAAS,CAAC,eAAe,EAAE,eAAe,CAAA;IAC1C,SAAS,CAAC,WAAW,EAAE,WAAW,CAAoB;IACtD,SAAS,CAAC,OAAO,EAAE,MAAM,CAAA;IACzB,SAAS,CAAC,KAAK,EAAE,OAAO,CAAA;IACxB,SAAS,CAAC,eAAe,EAAE,CAAC,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAC,GAAG,IAAI,CAAO;gBAE5D,cAAc,EAAE,MAAM,EAAE,EAAE,OAAO,GAAE,MAAwB,EAAE,KAAK,GAAE,OAAe;IAM/F;;OAEG;IACH,eAAe,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,QAAQ,CAAC,EAAE,QAAQ,KAAK,IAAI,GAAG,IAAI;IAO9F;;OAEG;IACH,iBAAiB,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAO5C;;OAEG;IACH,SAAS,CAAC,sBAAsB,CAC9B,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,MAAM,EACnB,IAAI,CAAC,EAAE,GAAG,GACT,OAAO,CAAC,GAAG,CAAC;IA2Bf;;OAEG;IACH,SAAS,CAAC,QAAQ,CAAC,WAAW,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,GAAG,IAAI;IAElF;;OAEG;IACH,SAAS,CAAC,QAAQ,CAAC,eAAe,IAAI,MAAM;IAE5C;;OAEG;IACH,SAAS,CAAC,aAAa,CAAC,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAgCrE;;OAEG;YACW,UAAU;IAyCxB;;OAEG;IACH,OAAO,CAAC,cAAc;IAqBtB;;OAEG;IACH,SAAS,CAAC,oBAAoB,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,GAAG,IAAI;IAK5E;;OAEG;IACH,SAAS,CAAC,qBAAqB,IAAI,IAAI;IAOvC;;OAEG;IACH,QAAQ,CAAC,WAAW,IAAI,OAAO;IAE/B;;OAEG;IACH,EAAE,CAAC,IAAI,EAAE,OAAO,GAAG,YAAY,GAAG,OAAO,EAAE,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,GAAG,KAAK,IAAI,GAAG,IAAI;IAIhF;;OAEG;IACH,GAAG,CAAC,IAAI,EAAE,OAAO,GAAG,YAAY,GAAG,OAAO,EAAE,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,GAAG,KAAK,IAAI,GAAG,IAAI;IAIjF;;OAEG;IACH,OAAO,IAAI,IAAI;CAOhB"}

package/dist/shared/MessageHandler.js

@@ -0,0 +1,197 @@
+/**
+ * Base class for handling postMessage communication
+ */
+import { EventEmitter } from '@/shared/EventEmitter';
+import { OriginValidator } from '@/shared/OriginValidator';
+import { IdGenerator } from '@/shared/IdGenerator';
+import { errorFactory } from '@/errors/errorFactory';
+import { DEFAULT_TIMEOUT } from '@/constants';
+export class MessageHandler {
+    constructor(allowedOrigins, timeout = DEFAULT_TIMEOUT, debug = false) {
+        this.handlers = new Map();
+        this.pendingRequests = new Map();
+        this.eventEmitter = new EventEmitter();
+        this.idGenerator = new IdGenerator();
+        this.messageListener = null;
+        this.originValidator = new OriginValidator(allowedOrigins, debug);
+        this.timeout = timeout;
+        this.debug = debug;
+    }
+    /**
+     * Register a handler
+     */
+    registerHandler(handlerName, handler) {
+        this.handlers.set(handlerName, handler);
+        if (this.debug) {
+            console.log(`[WebBridge] Handler registered: ${handlerName}`);
+        }
+    }
+    /**
+     * Unregister a handler
+     */
+    unregisterHandler(handlerName) {
+        this.handlers.delete(handlerName);
+        if (this.debug) {
+            console.log(`[WebBridge] Handler unregistered: ${handlerName}`);
+        }
+    }
+    /**
+     * Call a handler on the other side with timeout
+     */
+    callHandlerWithTimeout(targetOrigin, handlerName, data) {
+        return new Promise((resolve, reject) => {
+            const messageId = this.idGenerator.generate();
+            const timeoutHandle = setTimeout(() => {
+                this.pendingRequests.delete(messageId);
+                reject(errorFactory.timeout(this.timeout));
+            }, this.timeout);
+            this.pendingRequests.set(messageId, {
+                id: messageId,
+                timeout: timeoutHandle,
+                resolve,
+                reject
+            });
+            const message = {
+                type: 'call',
+                id: messageId,
+                handlerName,
+                data
+            };
+            this.sendMessage(targetOrigin, message);
+        });
+    }
+    /**
+     * Handle incoming message
+     */
+    handleMessage(message, origin) {
+        // Validate origin
+        if (!this.originValidator.isOriginAllowed(origin)) {
+            if (this.debug) {
+                console.warn(`[WebBridge] Message from disallowed origin: ${origin}`);
+            }
+            return;
+        }
+        try {
+            switch (message.type) {
+                case 'call':
+                    this.handleCall(message, origin);
+                    break;
+                case 'response':
+                    this.handleResponse(message);
+                    break;
+                case 'ready':
+                    this.eventEmitter.emit('ready');
+                    break;
+                default:
+                    if (this.debug) {
+                        console.warn(`[WebBridge] Unknown message type: ${message.type}`);
+                    }
+            }
+        }
+        catch (error) {
+            if (this.debug) {
+                console.error('[WebBridge] Error handling message:', error);
+            }
+        }
+    }
+    /**
+     * Handle incoming call message
+     */
+    async handleCall(message, origin) {
+        const { id, handlerName, data } = message;
+        const handler = this.handlers.get(handlerName);
+        if (!handler) {
+            this.sendMessage(origin, {
+                type: 'response',
+                id,
+                error: `Handler "${handlerName}" not found`
+            });
+            return;
+        }
+        try {
+            // Execute handler
+            const result = await Promise.resolve(handler(data, (response) => {
+                this.sendMessage(origin, {
+                    type: 'response',
+                    id,
+                    data: response
+                });
+            }));
+            // If handler returns a value directly (not using callback)
+            if (result !== undefined) {
+                this.sendMessage(origin, {
+                    type: 'response',
+                    id,
+                    data: result
+                });
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.sendMessage(origin, {
+                type: 'response',
+                id,
+                error: errorMessage
+            });
+        }
+    }
+    /**
+     * Handle incoming response message
+     */
+    handleResponse(message) {
+        const { id, data, error } = message;
+        const pending = this.pendingRequests.get(id);
+        if (!pending) {
+            if (this.debug) {
+                console.warn(`[WebBridge] Received response for unknown request: ${id}`);
+            }
+            return;
+        }
+        clearTimeout(pending.timeout);
+        this.pendingRequests.delete(id);
+        if (error) {
+            pending.reject(new Error(error));
+        }
+        else {
+            pending.resolve(data);
+        }
+    }
+    /**
+     * Setup message listener
+     */
+    setupMessageListener(handler) {
+        window.addEventListener('message', handler);
+        this.messageListener = handler;
+    }
+    /**
+     * Remove message listener
+     */
+    removeMessageListener() {
+        if (this.messageListener) {
+            window.removeEventListener('message', this.messageListener);
+            this.messageListener = null;
+        }
+    }
+    /**
+     * Add event listener
+     */
+    on(type, callback) {
+        this.eventEmitter.on(type, callback);
+    }
+    /**
+     * Remove event listener
+     */
+    off(type, callback) {
+        this.eventEmitter.off(type, callback);
+    }
+    /**
+     * Clean up
+     */
+    destroy() {
+        this.handlers.clear();
+        this.pendingRequests.forEach(({ timeout }) => clearTimeout(timeout));
+        this.pendingRequests.clear();
+        this.eventEmitter.removeAllListeners();
+        this.removeMessageListener();
+    }
+}