@aspectly/core 0.1.0 → 2.0.8

package/src/BridgeCore.test.ts

@@ -1,9 +1,11 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { BridgeCore } from './BridgeCore';
+import type { Transport } from '@aspectly/transports';
 
 describe('BridgeCore', () => {
   beforeEach(() => {
     vi.clearAllMocks();
+    BridgeCore.resetTransport();
   });
 
   describe('wrapBridgeEvent', () => {
@@ -103,152 +105,89 @@ describe('BridgeCore', () => {
     });
   });
 
-  describe('browserListener', () => {
-    it('should extract data from MessageEvent', () => {
-      const listener = vi.fn();
-      const browserListener = BridgeCore.browserListener(listener);
-      const event = { method: 'test' };
-      const messageEvent = {
-        data: JSON.stringify({ type: 'BridgeEvent', event }),
-      } as MessageEvent;
-
-      browserListener(messageEvent);
-
-      expect(listener).toHaveBeenCalledWith(event);
-    });
-
-    it('should ignore events without data', () => {
-      const listener = vi.fn();
-      const browserListener = BridgeCore.browserListener(listener);
-
-      browserListener({ data: undefined } as MessageEvent);
-      browserListener({} as MessageEvent);
-
-      expect(listener).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('webViewListener', () => {
-    it('should extract data from WebView nativeEvent', () => {
-      const listener = vi.fn();
-      const webViewListener = BridgeCore.webViewListener(listener);
-      const event = { method: 'test' };
-      const webViewMessage = {
-        nativeEvent: {
-          data: JSON.stringify({ type: 'BridgeEvent', event }),
-        },
-      };
-
-      webViewListener(webViewMessage);
-
-      expect(listener).toHaveBeenCalledWith(event);
-    });
-
-    it('should ignore messages without nativeEvent', () => {
-      const listener = vi.fn();
-      const webViewListener = BridgeCore.webViewListener(listener);
-
-      webViewListener({});
-      webViewListener({ nativeEvent: {} });
-      webViewListener({ nativeEvent: { data: undefined } });
-
-      expect(listener).not.toHaveBeenCalled();
-    });
-  });
-
   describe('sendEvent', () => {
-    let originalParent: Window;
-    let originalRNW: typeof window.ReactNativeWebView;
-
-    beforeEach(() => {
-      originalParent = window.parent;
-      originalRNW = window.ReactNativeWebView;
-    });
-
-    afterEach(() => {
-      Object.defineProperty(window, 'parent', {
-        value: originalParent,
-        writable: true,
-        configurable: true,
-      });
-      (window as any).ReactNativeWebView = originalRNW;
-    });
-
-    it('should send to iframe parent when available', () => {
-      (window as any).ReactNativeWebView = undefined;
-      const mockParent = {
-        postMessage: vi.fn(),
+    it('should send via the configured transport', () => {
+      const mockTransport: Transport = {
+        name: 'mock',
+        isAvailable: () => true,
+        send: vi.fn(),
+        subscribe: vi.fn(),
       };
-      Object.defineProperty(window, 'parent', {
-        value: mockParent,
-        writable: true,
-        configurable: true,
-      });
+      BridgeCore.setTransport(mockTransport);
 
       const event = { method: 'test' };
       BridgeCore.sendEvent(event);
 
-      expect(mockParent.postMessage).toHaveBeenCalledWith(
-        expect.any(String),
-        '*'
-      );
+      expect(mockTransport.send).toHaveBeenCalledWith(expect.any(String));
     });
 
-    it('should send to ReactNativeWebView when available', () => {
-      const mockRNW = {
-        postMessage: vi.fn(),
-      };
-      (window as any).ReactNativeWebView = mockRNW;
-
+    it('should not throw with null transport (fallback)', () => {
       const event = { method: 'test' };
-      BridgeCore.sendEvent(event);
-
-      expect(mockRNW.postMessage).toHaveBeenCalledWith(expect.any(String));
-    });
-
-    it('should not send when window.parent === window (top level)', () => {
-      (window as any).ReactNativeWebView = undefined;
-      Object.defineProperty(window, 'parent', {
-        value: window,
-        writable: true,
-        configurable: true,
-      });
-
-      const event = { method: 'test' };
-      // This should not throw
       expect(() => BridgeCore.sendEvent(event)).not.toThrow();
     });
   });
 
   describe('subscribe', () => {
-    it('should subscribe to message events', () => {
-      const listener = vi.fn();
-      const addEventListenerSpy = vi.spyOn(window, 'addEventListener');
+    it('should subscribe via the configured transport', () => {
+      const mockUnsubscribe = vi.fn();
+      const mockTransport: Transport = {
+        name: 'mock',
+        isAvailable: () => true,
+        send: vi.fn(),
+        subscribe: vi.fn().mockReturnValue(mockUnsubscribe),
+      };
+      BridgeCore.setTransport(mockTransport);
 
+      const listener = vi.fn();
       const unsubscribe = BridgeCore.subscribe(listener);
 
-      expect(addEventListenerSpy).toHaveBeenCalledWith(
-        'message',
-        expect.any(Function)
-      );
+      expect(mockTransport.subscribe).toHaveBeenCalledWith(expect.any(Function));
       expect(typeof unsubscribe).toBe('function');
-
-      addEventListenerSpy.mockRestore();
     });
 
-    it('should return cleanup function that removes listener', () => {
-      const listener = vi.fn();
-      const removeEventListenerSpy = vi.spyOn(window, 'removeEventListener');
+    it('should return cleanup function from transport', () => {
+      const mockUnsubscribe = vi.fn();
+      const mockTransport: Transport = {
+        name: 'mock',
+        isAvailable: () => true,
+        send: vi.fn(),
+        subscribe: vi.fn().mockReturnValue(mockUnsubscribe),
+      };
+      BridgeCore.setTransport(mockTransport);
 
+      const listener = vi.fn();
       const unsubscribe = BridgeCore.subscribe(listener);
       unsubscribe();
 
-      expect(removeEventListenerSpy).toHaveBeenCalledWith(
-        'message',
-        expect.any(Function)
-      );
+      expect(mockUnsubscribe).toHaveBeenCalled();
+    });
+  });
+
+  describe('transport management', () => {
+    it('should allow setting a custom transport', () => {
+      const mockTransport: Transport = {
+        name: 'custom',
+        isAvailable: () => true,
+        send: vi.fn(),
+        subscribe: vi.fn(),
+      };
+      BridgeCore.setTransport(mockTransport);
+
+      expect(BridgeCore.getTransportName()).toBe('custom');
+    });
+
+    it('should reset transport to auto-detect', () => {
+      const mockTransport: Transport = {
+        name: 'custom',
+        isAvailable: () => true,
+        send: vi.fn(),
+        subscribe: vi.fn(),
+      };
+      BridgeCore.setTransport(mockTransport);
+      BridgeCore.resetTransport();
 
-      removeEventListenerSpy.mockRestore();
+      // After reset, auto-detection will pick a default transport
+      expect(BridgeCore.getTransportName()).not.toBe('custom');
     });
   });
 });

package/src/BridgeCore.ts

@@ -1,7 +1,10 @@
 /**
  * Low-level bridge core handling platform-specific message passing
+ * Now delegates to @aspectly/transports for platform detection
  */
 
+import { detectTransport, type Transport } from '@aspectly/transports';
+
 export type Event = unknown;
 
 interface BridgeCoreEvent {
@@ -9,33 +12,57 @@ interface BridgeCoreEvent {
   event: Event;
 }
 
-interface WebViewMessage {
-  nativeEvent?: {
-    data?: string;
-  };
-}
-
 export type BridgeCoreListener = (event: Event) => void;
 
-declare global {
-  interface Window {
-    ReactNativeWebView?: {
-      postMessage: (message: string) => void;
-    };
-  }
-}
-
 /**
  * BridgeCore handles the low-level platform detection and message serialization.
  * It provides static methods for wrapping events, creating listeners, and sending messages.
+ *
+ * Platform detection is now handled by @aspectly/transports which supports:
+ * - CefSharp (Chromium Embedded Framework for .NET)
+ * - React Native WebView
+ * - Iframe (window.parent.postMessage)
+ * - Custom transports via TransportRegistry
  */
 export class BridgeCore {
   private static BRIDGE_EVENT_TYPE = 'BridgeEvent';
+  private static transport: Transport | null = null;
 
   private static isJSONObject = (str: string): boolean => {
     return str.startsWith('{') && str.endsWith('}');
   };
 
+  /**
+   * Get the current transport (lazy initialization)
+   */
+  private static getTransport(): Transport {
+    if (!BridgeCore.transport) {
+      BridgeCore.transport = detectTransport();
+    }
+    return BridgeCore.transport;
+  }
+
+  /**
+   * Set a custom transport (useful for testing or manual configuration)
+   */
+  public static setTransport(transport: Transport): void {
+    BridgeCore.transport = transport;
+  }
+
+  /**
+   * Reset transport to auto-detect on next use
+   */
+  public static resetTransport(): void {
+    BridgeCore.transport = null;
+  }
+
+  /**
+   * Get the name of the current transport
+   */
+  public static getTransportName(): string {
+    return BridgeCore.getTransport().name;
+  }
+
   /**
    * Wraps an event in the bridge protocol format
    */
@@ -78,61 +105,21 @@ export class BridgeCore {
     };
 
   /**
-   * Creates a browser-specific message event listener
-   */
-  static browserListener = (listener: BridgeCoreListener) => {
-    const triggerEvent = BridgeCore.wrapListener(listener);
-    return (originalEvent: MessageEvent): void => {
-      if (!originalEvent?.data) {
-        return;
-      }
-      triggerEvent(originalEvent.data);
-    };
-  };
-
-  /**
-   * Creates a React Native WebView message listener
-   */
-  static webViewListener = (listener: BridgeCoreListener) => {
-    const triggerEvent = BridgeCore.wrapListener(listener);
-    return (originalEvent: WebViewMessage): void => {
-      if (!originalEvent?.nativeEvent?.data) {
-        return;
-      }
-      triggerEvent(originalEvent.nativeEvent.data);
-    };
-  };
-
-  /**
-   * Sends an event to the parent context (WebView or iframe parent)
+   * Sends an event to the parent context using the detected transport
    */
   static sendEvent = (event: Event): void => {
     const bridgeEvent = BridgeCore.wrapBridgeEvent(event);
-    if (typeof window === 'undefined') {
-      console.warn('Window is undefined');
-      return;
-    }
-    const RNW = window.ReactNativeWebView;
-    if (typeof RNW?.postMessage === 'function') {
-      RNW.postMessage(`'${bridgeEvent}'`);
-      return;
-    }
-    if (window.parent === window) {
-      return;
-    }
-    window.parent.postMessage(bridgeEvent, '*');
+    const transport = BridgeCore.getTransport();
+    transport.send(bridgeEvent);
   };
 
   /**
-   * Subscribes to window message events
+   * Subscribes to incoming messages via the detected transport
    * @returns Cleanup function to unsubscribe
    */
   static subscribe = (listener: BridgeCoreListener): VoidFunction => {
-    const browserListener = BridgeCore.browserListener(listener);
-    if (typeof window === 'undefined' || !window.addEventListener) {
-      return () => {};
-    }
-    window.addEventListener('message', browserListener);
-    return () => window.removeEventListener('message', browserListener);
+    const transport = BridgeCore.getTransport();
+    const wrappedListener = BridgeCore.wrapListener(listener);
+    return transport.subscribe(wrappedListener);
   };
 }

package/src/BridgeInternal.test.ts

@@ -318,6 +318,69 @@ describe('BridgeInternal', () => {
     });
   });
 
+  describe('registerHandler/unregisterHandler', () => {
+    it('should register a handler that can be called via Request', async () => {
+      const handler = vi.fn().mockResolvedValue({ ok: true });
+      bridge.registerHandler('myMethod', handler);
+
+      bridge.handleCoreEvent({
+        type: BridgeEventType.Request,
+        data: { method: 'myMethod', params: { x: 1 }, request_id: '1' },
+      });
+
+      await new Promise((resolve) => setTimeout(resolve, 50));
+
+      expect(handler).toHaveBeenCalledWith({ x: 1 });
+      expect(sendEvent).toHaveBeenCalledWith({
+        type: BridgeEventType.Result,
+        data: {
+          type: BridgeResultType.Success,
+          data: { ok: true },
+          method: 'myMethod',
+          request_id: '1',
+        },
+      });
+    });
+
+    it('should unregister a handler', async () => {
+      bridge.registerHandler('myMethod', vi.fn().mockResolvedValue({}));
+      bridge.unregisterHandler('myMethod');
+
+      bridge.handleCoreEvent({
+        type: BridgeEventType.Request,
+        data: { method: 'myMethod', params: {}, request_id: '1' },
+      });
+
+      await new Promise((resolve) => setTimeout(resolve, 50));
+
+      expect(sendEvent).toHaveBeenCalledWith({
+        type: BridgeEventType.Result,
+        data: expect.objectContaining({
+          type: BridgeResultType.Error,
+          data: expect.objectContaining({
+            error_type: BridgeErrorType.UNSUPPORTED_METHOD,
+          }),
+        }),
+      });
+    });
+
+    it('should include registerHandler methods in init', () => {
+      bridge.registerHandler('pre1', vi.fn().mockResolvedValue({}));
+      bridge.registerHandler('pre2', vi.fn().mockResolvedValue({}));
+
+      bridge.init({
+        pre1: vi.fn().mockResolvedValue({}),
+        pre2: vi.fn().mockResolvedValue({}),
+        extra: vi.fn().mockResolvedValue({}),
+      });
+
+      expect(sendEvent).toHaveBeenCalledWith({
+        type: BridgeEventType.Init,
+        data: { methods: ['pre1', 'pre2', 'extra'] },
+      });
+    });
+  });
+
   describe('supports', () => {
     it('should return false before initialization', () => {
       expect(bridge.supports('test')).toBe(false);

package/src/BridgeInternal.ts

@@ -1,6 +1,7 @@
 import type {
   BridgeData,
   BridgeEvent,
+  BridgeHandler,
   BridgeHandlers,
   BridgeInitEvent,
   BridgeInitResultEvent,
@@ -67,6 +68,32 @@ export class BridgeInternal {
     this.timeout = options?.timeout ?? DEFAULT_TIMEOUT;
   }
 
+  /**
+   * Reset bridge state for a new connection context.
+   * Call this when the remote side has changed (e.g., new popup window).
+   */
+  public reset = (): void => {
+    this.handlers = {};
+    this.available = false;
+    this.supportedMethods = [];
+    this.initPromise = undefined;
+  };
+
+  /**
+   * Register a single handler for a method.
+   * Can be called before or after init().
+   */
+  public registerHandler = (method: string, handler: BridgeHandler): void => {
+    this.handlers[method] = handler;
+  };
+
+  /**
+   * Remove a previously registered handler.
+   */
+  public unregisterHandler = (method: string): void => {
+    delete this.handlers[method];
+  };
+
   /**
    * Subscribe to all result events
    */

package/src/index.ts

@@ -4,6 +4,24 @@ export { BridgeBase } from './BridgeBase';
 export { BridgeInternal } from './BridgeInternal';
 export { BridgeCore } from './BridgeCore';
 
+// Re-export transports for convenience
+export {
+  detectTransport,
+  registerTransport,
+  TransportRegistry,
+  CefSharpTransport,
+  ReactNativeTransport,
+  IframeTransport,
+  NullTransport,
+} from '@aspectly/transports';
+
+export type {
+  Transport,
+  TransportDetector,
+  TransportListener,
+  TransportUnsubscribe,
+} from '@aspectly/transports';
+
 // Type exports
 export type {
   BridgeEvent,

package/LICENSE

@@ -1,20 +0,0 @@
-MIT License
-
-Copyright (c) 2022 Zhan Isaakian
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.