@kookapp/web-bridge 0.0.1

package/README.md

@@ -0,0 +1,144 @@
+# WebBridge
+
+A PostMessage-based bridge for iframe communication, providing symmetric callHandler and registerHandler APIs similar to jsbridge but for web environments.
+
+## Features
+
+- **Symmetric API**: Both parent and iframe can call handlers and register responders
+- **PostMessage-based**: Uses native Web APIs for cross-origin communication
+- **Origin Validation**: Strict domain whitelist verification
+- **Type-Safe**: Full TypeScript support with comprehensive type definitions
+- **Promise & Callback**: Supports both async/await and callback patterns
+- **Error Handling**: Comprehensive error codes and timeout management
+
+## Installation
+
+```bash
+npm install @kookapp/web-bridge
+```
+
+## Usage
+
+### Parent Side (iframe外部)
+
+```typescript
+import { ParentBridge } from '@kookapp/web-bridge'
+
+// Initialize the bridge
+const bridge = new ParentBridge({
+  allowedOrigins: ['https://iframe.example.com']
+})
+
+// Register a handler that can be called from iframe
+bridge.registerHandler('getUserInfo', (data, callback) => {
+  const userInfo = { id: 1, name: 'John' }
+  callback(userInfo)
+})
+
+// Create a communication channel with an iframe
+const iframeElement = document.getElementById('myIframe') as HTMLIFrameElement
+const channel = bridge.createChannel(iframeElement)
+
+// Call a handler inside iframe
+channel.callHandler('getIframeData', { type: 'user' })
+  .then(result => console.log('Result:', result))
+  .catch(error => console.error('Error:', error))
+
+// Clean up
+// bridge.destroy()
+```
+
+### Child Side (iframe内部)
+
+```typescript
+import { ChildBridge } from '@kookapp/web-bridge'
+
+// Initialize the bridge
+const bridge = new ChildBridge({
+  allowedOrigins: ['https://parent.example.com']
+})
+
+// Register a handler that can be called from parent
+bridge.registerHandler('getIframeData', (data, callback) => {
+  const response = { data: 'from iframe', type: data.type }
+  callback(response)
+})
+
+// Call a handler on parent
+bridge.callHandler('getUserInfo', {})
+  .then(userInfo => console.log('User:', userInfo))
+  .catch(error => console.error('Error:', error))
+```
+
+## API Reference
+
+### ParentBridge
+
+```typescript
+class ParentBridge {
+  constructor(config: BridgeConfig)
+  registerHandler(handlerName: string, handler: Handler): void
+  createChannel(iframe: HTMLIFrameElement, options?: { origin: string }): IframeChannel
+  unregisterHandler(handlerName: string): void
+  destroy(): void
+}
+```
+
+### IframeChannel
+
+```typescript
+interface IframeChannel {
+  callHandler(handlerName: string, data?: any, callback?: (result: any) => void): Promise<any>
+  getIframe(): HTMLIFrameElement
+  isConnected(): boolean
+  destroy(): void
+}
+```
+
+### ChildBridge
+
+```typescript
+class ChildBridge {
+  constructor(config: BridgeConfig)
+  callHandler(handlerName: string, data?: any, callback?: (result: any) => void): Promise<any>
+  registerHandler(handlerName: string, handler: Handler): void
+  unregisterHandler(handlerName: string): void
+  destroy(): void
+  isConnected(): boolean
+}
+```
+
+### BridgeConfig
+
+```typescript
+interface BridgeConfig {
+  allowedOrigins: string[]    // Domain whitelist (supports exact match, regex, and wildcard)
+  timeout?: number            // Message timeout in ms (default: 5000)
+  debug?: boolean             // Enable debug logging
+  maxRetries?: number         // Maximum retry attempts (default: 0)
+}
+```
+
+## Error Handling
+
+The bridge throws `BridgeError` with specific error codes:
+
+- `HANDLER_NOT_FOUND`: Handler not found on the other side
+- `ORIGIN_NOT_ALLOWED`: Message origin not in whitelist
+- `TIMEOUT`: Request exceeded timeout
+- `INVALID_MESSAGE`: Malformed message received
+- `CONNECTION_LOST`: Connection to other side lost
+
+## Security
+
+### Origin Validation
+
+- Exact match: `'https://example.com'`
+- Regex pattern: `'^https://.*\\.example\\.com$'`
+- Wildcard (dev only): `'*'`
+
+Origins are validated for both incoming and outgoing messages.
+
+## License
+
+MIT

package/dist/child/ChildBridge.d.ts

@@ -0,0 +1,40 @@
+/**
+ * ChildBridge for communication from inside an iframe
+ */
+import { ChildBridgeConfig, BridgeMessage } from '@/types';
+import { MessageHandler } from '@/shared/MessageHandler';
+export declare class ChildBridge extends MessageHandler {
+    private parentWindow;
+    private parentOrigin;
+    private connected;
+    constructor(config: ChildBridgeConfig);
+    /**
+     * Get parent origin
+     */
+    private getParentOrigin;
+    /**
+     * Notify parent that child is ready
+     */
+    private notifyReady;
+    /**
+     * Call a handler on parent
+     */
+    callHandler(handlerName: string, data?: any, callback?: (result: any) => void): Promise<any>;
+    /**
+     * Send message to parent
+     */
+    protected sendMessage(targetOrigin: string, message: BridgeMessage): void;
+    /**
+     * Get target origin
+     */
+    protected getTargetOrigin(): string;
+    /**
+     * Check if connected to parent
+     */
+    isConnected(): boolean;
+    /**
+     * Destroy the bridge
+     */
+    destroy(): void;
+}
+//# sourceMappingURL=ChildBridge.d.ts.map

package/dist/child/ChildBridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChildBridge.d.ts","sourceRoot":"","sources":["../../src/child/ChildBridge.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAA;AAGxD,qBAAa,WAAY,SAAQ,cAAc;IAC7C,OAAO,CAAC,YAAY,CAAQ;IAC5B,OAAO,CAAC,YAAY,CAAQ;IAC5B,OAAO,CAAC,SAAS,CAAiB;gBAEtB,MAAM,EAAE,iBAAiB;IA+BrC;;OAEG;IACH,OAAO,CAAC,eAAe;IAyBvB;;OAEG;IACH,OAAO,CAAC,WAAW;IAgBnB;;OAEG;IACG,WAAW,CACf,WAAW,EAAE,MAAM,EACnB,IAAI,CAAC,EAAE,GAAG,EACV,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,IAAI,GAC/B,OAAO,CAAC,GAAG,CAAC;IAUf;;OAEG;IACH,SAAS,CAAC,WAAW,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,GAAG,IAAI;IAezE;;OAEG;IACH,SAAS,CAAC,eAAe,IAAI,MAAM;IAInC;;OAEG;IACH,WAAW,IAAI,OAAO;IAItB;;OAEG;IACH,OAAO,IAAI,IAAI;CAQhB"}

package/dist/child/ChildBridge.js

@@ -0,0 +1,124 @@
+/**
+ * ChildBridge for communication from inside an iframe
+ */
+import { MessageHandler } from '@/shared/MessageHandler';
+import { DEFAULT_TIMEOUT } from '@/constants';
+export class ChildBridge extends MessageHandler {
+    constructor(config) {
+        const timeout = config.timeout || DEFAULT_TIMEOUT;
+        super(config.allowedOrigins, timeout, config.debug);
+        this.connected = false;
+        // Get parent window and origin
+        this.parentWindow = window.parent;
+        this.parentOrigin = this.getParentOrigin(config.allowedOrigins);
+        // Setup message listener
+        this.setupMessageListener((event) => {
+            // Only accept messages from parent
+            if (event.source === this.parentWindow) {
+                this.handleMessage(event.data, event.origin);
+                if (!this.connected) {
+                    this.connected = true;
+                    this.eventEmitter.emit('ready');
+                }
+            }
+        });
+        // Notify parent that we're ready
+        this.notifyReady();
+        if (this.debug) {
+            console.log('[WebBridge] ChildBridge initialized', {
+                parentOrigin: this.parentOrigin,
+                allowedOrigins: config.allowedOrigins
+            });
+        }
+    }
+    /**
+     * Get parent origin
+     */
+    getParentOrigin(allowedOrigins) {
+        // If wildcard is allowed, use it
+        if (allowedOrigins.includes('*')) {
+            return '*';
+        }
+        // Try to get document.referrer as parent origin
+        if (document.referrer) {
+            try {
+                return new URL(document.referrer).origin;
+            }
+            catch {
+                // If referrer is not a valid URL, fall back to *
+            }
+        }
+        // Fall back to the first allowed origin if it's specific
+        const specificOrigins = allowedOrigins.filter(o => o !== '*');
+        if (specificOrigins.length > 0) {
+            return specificOrigins[0];
+        }
+        // Last resort: use wildcard
+        return '*';
+    }
+    /**
+     * Notify parent that child is ready
+     */
+    notifyReady() {
+        try {
+            this.parentWindow.postMessage({
+                type: 'ready',
+                _version: '1.0.0'
+            }, this.parentOrigin);
+        }
+        catch (error) {
+            if (this.debug) {
+                console.warn('[WebBridge] Failed to notify parent:', error);
+            }
+        }
+    }
+    /**
+     * Call a handler on parent
+     */
+    async callHandler(handlerName, data, callback) {
+        const promise = this.callHandlerWithTimeout(this.parentOrigin, handlerName, data);
+        if (callback) {
+            promise.then(callback).catch(error => console.error(error));
+        }
+        return promise;
+    }
+    /**
+     * Send message to parent
+     */
+    sendMessage(targetOrigin, message) {
+        try {
+            message._version = '1.0.0';
+            this.parentWindow.postMessage(message, targetOrigin);
+            if (this.debug) {
+                console.log('[WebBridge] Sent message to parent:', message);
+            }
+        }
+        catch (error) {
+            if (this.debug) {
+                console.error('[WebBridge] Failed to send message to parent:', error);
+            }
+        }
+    }
+    /**
+     * Get target origin
+     */
+    getTargetOrigin() {
+        return this.parentOrigin;
+    }
+    /**
+     * Check if connected to parent
+     */
+    isConnected() {
+        return this.connected;
+    }
+    /**
+     * Destroy the bridge
+     */
+    destroy() {
+        this.connected = false;
+        super.destroy();
+        if (this.debug) {
+            console.log('[WebBridge] ChildBridge destroyed');
+        }
+    }
+}

package/dist/child/index.d.ts

@@ -0,0 +1,4 @@
+export { ChildBridge } from '@/child/ChildBridge';
+export type { ChildBridgeConfig } from '@/types';
+export * from '@/child/utils';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/child/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AACjD,YAAY,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAChD,cAAc,eAAe,CAAA"}

package/dist/child/index.js

@@ -0,0 +1,2 @@
+export { ChildBridge } from '@/child/ChildBridge';
+export * from '@/child/utils';

package/dist/child/utils.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Utility functions for child bridge
+ */
+export declare function isInIframe(): boolean;
+export declare function getParentWindow(): Window;
+export declare function getTopWindow(): Window;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/child/utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,wBAAgB,UAAU,IAAI,OAAO,CAMpC;AAED,wBAAgB,eAAe,IAAI,MAAM,CAExC;AAED,wBAAgB,YAAY,IAAI,MAAM,CAMrC"}

package/dist/child/utils.js

@@ -0,0 +1,22 @@
+/**
+ * Utility functions for child bridge
+ */
+export function isInIframe() {
+    try {
+        return window.self !== window.top;
+    }
+    catch {
+        return true;
+    }
+}
+export function getParentWindow() {
+    return window.parent;
+}
+export function getTopWindow() {
+    try {
+        return window.top || window;
+    }
+    catch {
+        return window;
+    }
+}

package/dist/constants.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Constants for WebBridge
+ */
+export declare const BRIDGE_VERSION = "1.0.0";
+export declare const DEFAULT_TIMEOUT = 5000;
+export declare const DEFAULT_MAX_RETRIES = 0;
+export declare const MESSAGE_TYPE: {
+    CALL: "call";
+    RESPONSE: "response";
+    REGISTER: "register";
+    READY: "ready";
+};
+export declare const ERROR_CODE: {
+    readonly HANDLER_NOT_FOUND: "HANDLER_NOT_FOUND";
+    readonly ORIGIN_NOT_ALLOWED: "ORIGIN_NOT_ALLOWED";
+    readonly TIMEOUT: "TIMEOUT";
+    readonly INVALID_MESSAGE: "INVALID_MESSAGE";
+    readonly CONNECTION_LOST: "CONNECTION_LOST";
+    readonly INVALID_CONFIG: "INVALID_CONFIG";
+};
+export declare const ERROR_MESSAGE: {
+    readonly HANDLER_NOT_FOUND: "Handler not found";
+    readonly ORIGIN_NOT_ALLOWED: "Origin not allowed";
+    readonly TIMEOUT: "Request timeout";
+    readonly INVALID_MESSAGE: "Invalid message format";
+    readonly CONNECTION_LOST: "Connection lost";
+    readonly INVALID_CONFIG: "Invalid configuration";
+};
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,eAAO,MAAM,cAAc,UAAU,CAAA;AAErC,eAAO,MAAM,eAAe,OAAO,CAAA;AAEnC,eAAO,MAAM,mBAAmB,IAAI,CAAA;AAEpC,eAAO,MAAM,YAAY;;;;;CAKxB,CAAA;AAED,eAAO,MAAM,UAAU;;;;;;;CAOb,CAAA;AAEV,eAAO,MAAM,aAAa;;;;;;;CAOhB,CAAA"}

package/dist/constants.js

@@ -0,0 +1,28 @@
+/**
+ * Constants for WebBridge
+ */
+export const BRIDGE_VERSION = '1.0.0';
+export const DEFAULT_TIMEOUT = 5000; // 5 seconds
+export const DEFAULT_MAX_RETRIES = 0;
+export const MESSAGE_TYPE = {
+    CALL: 'call',
+    RESPONSE: 'response',
+    REGISTER: 'register',
+    READY: 'ready'
+};
+export const ERROR_CODE = {
+    HANDLER_NOT_FOUND: 'HANDLER_NOT_FOUND',
+    ORIGIN_NOT_ALLOWED: 'ORIGIN_NOT_ALLOWED',
+    TIMEOUT: 'TIMEOUT',
+    INVALID_MESSAGE: 'INVALID_MESSAGE',
+    CONNECTION_LOST: 'CONNECTION_LOST',
+    INVALID_CONFIG: 'INVALID_CONFIG'
+};
+export const ERROR_MESSAGE = {
+    [ERROR_CODE.HANDLER_NOT_FOUND]: 'Handler not found',
+    [ERROR_CODE.ORIGIN_NOT_ALLOWED]: 'Origin not allowed',
+    [ERROR_CODE.TIMEOUT]: 'Request timeout',
+    [ERROR_CODE.INVALID_MESSAGE]: 'Invalid message format',
+    [ERROR_CODE.CONNECTION_LOST]: 'Connection lost',
+    [ERROR_CODE.INVALID_CONFIG]: 'Invalid configuration'
+};

package/dist/errors/BridgeError.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Custom error class for WebBridge
+ */
+import { ERROR_CODE } from '@/constants';
+export type BridgeErrorCode = keyof typeof ERROR_CODE;
+export declare class BridgeError extends Error {
+    code: BridgeErrorCode;
+    originalError?: Error;
+    constructor(code: BridgeErrorCode, message?: string, originalError?: Error);
+    static create(code: BridgeErrorCode, message?: string, originalError?: Error): BridgeError;
+    static isHandlerNotFound(error: any): boolean;
+    static isOriginNotAllowed(error: any): boolean;
+    static isTimeout(error: any): boolean;
+    toJSON(): {
+        name: string;
+        code: "HANDLER_NOT_FOUND" | "ORIGIN_NOT_ALLOWED" | "TIMEOUT" | "INVALID_MESSAGE" | "CONNECTION_LOST" | "INVALID_CONFIG";
+        message: string;
+        originalError: string;
+    };
+}
+//# sourceMappingURL=BridgeError.d.ts.map

package/dist/errors/BridgeError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BridgeError.d.ts","sourceRoot":"","sources":["../../src/errors/BridgeError.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,UAAU,EAAiB,MAAM,aAAa,CAAA;AAEvD,MAAM,MAAM,eAAe,GAAG,MAAM,OAAO,UAAU,CAAA;AAErD,qBAAa,WAAY,SAAQ,KAAK;IACpC,IAAI,EAAE,eAAe,CAAA;IACrB,aAAa,CAAC,EAAE,KAAK,CAAA;gBAET,IAAI,EAAE,eAAe,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,KAAK;IAW1E,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,eAAe,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,KAAK,GAAG,WAAW;IAI1F,MAAM,CAAC,iBAAiB,CAAC,KAAK,EAAE,GAAG,GAAG,OAAO;IAI7C,MAAM,CAAC,kBAAkB,CAAC,KAAK,EAAE,GAAG,GAAG,OAAO;IAI9C,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,GAAG,GAAG,OAAO;IAIrC,MAAM;;;;;;CAQP"}

package/dist/errors/BridgeError.js

@@ -0,0 +1,35 @@
+/**
+ * Custom error class for WebBridge
+ */
+import { ERROR_MESSAGE } from '@/constants';
+export class BridgeError extends Error {
+    constructor(code, message, originalError) {
+        const errorMessage = message || ERROR_MESSAGE[code] || 'Unknown error';
+        super(errorMessage);
+        this.name = 'BridgeError';
+        this.code = code;
+        this.originalError = originalError;
+        // Maintain proper prototype chain for instanceof checks
+        Object.setPrototypeOf(this, BridgeError.prototype);
+    }
+    static create(code, message, originalError) {
+        return new BridgeError(code, message, originalError);
+    }
+    static isHandlerNotFound(error) {
+        return error instanceof BridgeError && error.code === 'HANDLER_NOT_FOUND';
+    }
+    static isOriginNotAllowed(error) {
+        return error instanceof BridgeError && error.code === 'ORIGIN_NOT_ALLOWED';
+    }
+    static isTimeout(error) {
+        return error instanceof BridgeError && error.code === 'TIMEOUT';
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            code: this.code,
+            message: this.message,
+            originalError: this.originalError?.message
+        };
+    }
+}

package/dist/errors/errorFactory.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Error factory functions
+ */
+import { BridgeError, BridgeErrorCode } from '@/errors/BridgeError';
+export declare const errorFactory: {
+    handlerNotFound: (handlerName: string) => BridgeError;
+    originNotAllowed: (origin: string) => BridgeError;
+    timeout: (timeout: number) => BridgeError;
+    invalidMessage: (message: string) => BridgeError;
+    connectionLost: () => BridgeError;
+    invalidConfig: (message: string) => BridgeError;
+    wrap: (code: BridgeErrorCode, originalError: Error, message?: string) => BridgeError;
+};
+//# sourceMappingURL=errorFactory.d.ts.map

package/dist/errors/errorFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errorFactory.d.ts","sourceRoot":"","sources":["../../src/errors/errorFactory.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAEnE,eAAO,MAAM,YAAY;mCACQ,MAAM;+BAGV,MAAM;uBAGd,MAAM;8BAGC,MAAM;;6BAMP,MAAM;iBAGlB,eAAe,iBAAiB,KAAK,YAAY,MAAM;CAErE,CAAA"}

package/dist/errors/errorFactory.js

@@ -0,0 +1,13 @@
+/**
+ * Error factory functions
+ */
+import { BridgeError } from '@/errors/BridgeError';
+export const errorFactory = {
+    handlerNotFound: (handlerName) => BridgeError.create('HANDLER_NOT_FOUND', `Handler "${handlerName}" not found`),
+    originNotAllowed: (origin) => BridgeError.create('ORIGIN_NOT_ALLOWED', `Origin "${origin}" not allowed`),
+    timeout: (timeout) => BridgeError.create('TIMEOUT', `Request timeout after ${timeout}ms`),
+    invalidMessage: (message) => BridgeError.create('INVALID_MESSAGE', `Invalid message: ${message}`),
+    connectionLost: () => BridgeError.create('CONNECTION_LOST', 'Connection to the other side was lost'),
+    invalidConfig: (message) => BridgeError.create('INVALID_CONFIG', `Invalid configuration: ${message}`),
+    wrap: (code, originalError, message) => BridgeError.create(code, message || originalError.message, originalError)
+};

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Main entry point for WebBridge
+ */
+export { ParentBridge } from '@/parent/index';
+export type { ParentBridgeConfig, IframeChannelInterface } from '@/parent/index';
+export { IframeChannel } from '@/parent/IframeChannel';
+export { ChildBridge } from '@/child/index';
+export type { ChildBridgeConfig } from '@/child/index';
+export type { BridgeConfig, BridgeMessage, Handler, HandlerRegistry, MessageType } from '@/types';
+export { BridgeError } from '@/errors/BridgeError';
+export type { BridgeErrorCode } from '@/errors/BridgeError';
+export { errorFactory } from '@/errors/errorFactory';
+export { BRIDGE_VERSION, DEFAULT_TIMEOUT, ERROR_CODE, MESSAGE_TYPE } from '@/constants';
+export { EventEmitter } from '@/shared/EventEmitter';
+export { OriginValidator } from '@/shared/OriginValidator';
+export { IdGenerator } from '@/shared/IdGenerator';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAC7C,YAAY,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAA;AAChF,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAA;AAGtD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAC3C,YAAY,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAA;AAGtD,YAAY,EACV,YAAY,EACZ,aAAa,EACb,OAAO,EACP,eAAe,EACf,WAAW,EACZ,MAAM,SAAS,CAAA;AAGhB,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAClD,YAAY,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAC3D,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAGpD,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAGvF,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AACpD,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAC1D,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA"}

package/dist/index.js

@@ -0,0 +1,17 @@
+/**
+ * Main entry point for WebBridge
+ */
+// Export parent bridge
+export { ParentBridge } from '@/parent/index';
+export { IframeChannel } from '@/parent/IframeChannel';
+// Export child bridge
+export { ChildBridge } from '@/child/index';
+// Export error handling
+export { BridgeError } from '@/errors/BridgeError';
+export { errorFactory } from '@/errors/errorFactory';
+// Export constants
+export { BRIDGE_VERSION, DEFAULT_TIMEOUT, ERROR_CODE, MESSAGE_TYPE } from '@/constants';
+// Export utilities
+export { EventEmitter } from '@/shared/EventEmitter';
+export { OriginValidator } from '@/shared/OriginValidator';
+export { IdGenerator } from '@/shared/IdGenerator';

package/dist/parent/IframeChannel.d.ts

@@ -0,0 +1,44 @@
+/**
+ * IframeChannel for managing communication with a specific iframe
+ */
+import { BridgeMessage, IframeChannelInterface } from '@/types';
+import { MessageHandler } from '@/shared/MessageHandler';
+export declare class IframeChannel extends MessageHandler implements IframeChannelInterface {
+    private iframe;
+    private iframeOrigin;
+    private connected;
+    constructor(iframe: HTMLIFrameElement, allowedOrigins: string[], timeout?: number, debug?: boolean);
+    /**
+     * Extract origin from URL
+     */
+    private extractOrigin;
+    /**
+     * Call a handler in the iframe
+     */
+    callHandler(handlerName: string, data?: any, callback?: (result: any) => void): Promise<any>;
+    /**
+     * Send message to iframe
+     */
+    protected sendMessage(targetOrigin: string, message: BridgeMessage): void;
+    /**
+     * Get target origin (for this channel, it's the iframe origin)
+     */
+    protected getTargetOrigin(): string;
+    /**
+     * Get the iframe element
+     */
+    getIframe(): HTMLIFrameElement;
+    /**
+     * Check if connected
+     */
+    isConnected(): boolean;
+    /**
+     * Set connected status
+     */
+    setConnected(connected: boolean): void;
+    /**
+     * Destroy the channel
+     */
+    destroy(): void;
+}
+//# sourceMappingURL=IframeChannel.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"IframeChannel.d.ts","sourceRoot":"","sources":["../../src/parent/IframeChannel.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,aAAa,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAA;AAC/D,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAA;AAExD,qBAAa,aAAc,SAAQ,cAAe,YAAW,sBAAsB;IACjF,OAAO,CAAC,MAAM,CAAmB;IACjC,OAAO,CAAC,YAAY,CAAQ;IAC5B,OAAO,CAAC,SAAS,CAAiB;gBAGhC,MAAM,EAAE,iBAAiB,EACzB,cAAc,EAAE,MAAM,EAAE,EACxB,OAAO,GAAE,MAAa,EACtB,KAAK,GAAE,OAAe;IAmBxB;;OAEG;IACH,OAAO,CAAC,aAAa;IASrB;;OAEG;IACG,WAAW,CACf,WAAW,EAAE,MAAM,EACnB,IAAI,CAAC,EAAE,GAAG,EACV,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,IAAI,GAC/B,OAAO,CAAC,GAAG,CAAC;IAcf;;OAEG;IACH,SAAS,CAAC,WAAW,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,GAAG,IAAI;IAkBzE;;OAEG;IACH,SAAS,CAAC,eAAe,IAAI,MAAM;IAInC;;OAEG;IACH,SAAS,IAAI,iBAAiB;IAI9B;;OAEG;IACH,WAAW,IAAI,OAAO;IAItB;;OAEG;IACH,YAAY,CAAC,SAAS,EAAE,OAAO,GAAG,IAAI;IAItC;;OAEG;IACH,OAAO,IAAI,IAAI;CAIhB"}