@aspectly/transports 0.1.0

package/LICENSE

@@ -0,0 +1,20 @@
+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.

package/README.md

@@ -0,0 +1,368 @@
+# @aspectly/transports
+
+Transport layer for cross-platform communication between WebViews, iframes, and web applications.
+
+## Installation
+
+```bash
+# npm
+npm install @aspectly/transports
+
+# pnpm
+pnpm add @aspectly/transports
+
+# yarn
+yarn add @aspectly/transports
+```
+
+## Overview
+
+`@aspectly/transports` provides a flexible abstraction layer for platform detection and message passing across different execution contexts. It automatically detects the current environment (CefSharp, React Native WebView, iframe, or browser) and provides a unified API for bidirectional communication.
+
+### Built-in Transports
+
+| Transport | Detection | Priority | Use Case |
+|-----------|-----------|----------|----------|
+| **CefSharpTransport** | `window.CefSharp.PostMessage` | 100 | Desktop apps with CefSharp (Chromium Embedded Framework for .NET) |
+| **ReactNativeTransport** | `window.ReactNativeWebView.postMessage` | 90 | React Native WebView |
+| **IframeTransport** | `window.parent !== window` | 80 | Web content inside iframes |
+| **NullTransport** | Always available | - | Fallback for SSR/testing (no-op) |
+
+### Auto-Detection
+
+The `TransportRegistry` automatically selects the appropriate transport based on priority order. Higher priority transports are checked first, ensuring the most specific transport is used.
+
+## Quick Start
+
+### Auto-Detection (Recommended)
+
+```typescript
+import { detectTransport } from '@aspectly/transports';
+
+// Automatically detect the current environment
+const transport = detectTransport();
+console.log(`Using transport: ${transport.name}`); // 'cefsharp', 'react-native', 'iframe', or 'null'
+
+// Send a message
+transport.send(JSON.stringify({ type: 'hello', data: 'world' }));
+
+// Subscribe to incoming messages
+const unsubscribe = transport.subscribe((message) => {
+  const data = JSON.parse(message);
+  console.log('Received:', data);
+});
+
+// Cleanup when done
+unsubscribe();
+```
+
+### Direct Transport Usage
+
+```typescript
+import { CefSharpTransport } from '@aspectly/transports';
+
+const transport = new CefSharpTransport();
+
+if (transport.isAvailable()) {
+  transport.send(JSON.stringify({ method: 'getData' }));
+}
+```
+
+### Custom Transport Registration
+
+```typescript
+import { registerTransport, detectTransport } from '@aspectly/transports';
+
+// Register a custom transport with high priority
+registerTransport({
+  name: 'electron',
+  priority: 150, // Higher than CefSharp (100)
+  detect: () => {
+    return typeof window !== 'undefined' &&
+           window.electron?.send !== undefined;
+  },
+  createTransport: () => new ElectronTransport(),
+});
+
+// Now auto-detection will check your custom transport first
+const transport = detectTransport();
+```
+
+## API Reference
+
+### Transport Interface
+
+The core interface implemented by all transports:
+
+```typescript
+interface Transport {
+  readonly name: string;
+  isAvailable(): boolean;
+  send(message: string): void;
+  subscribe(listener: TransportListener): TransportUnsubscribe;
+}
+```
+
+**Properties:**
+- `name` - Unique identifier for the transport (e.g., 'cefsharp', 'react-native')
+
+**Methods:**
+- `isAvailable()` - Check if the transport is available in the current environment
+- `send(message: string)` - Send a message to the parent/host context
+- `subscribe(listener)` - Subscribe to incoming messages, returns cleanup function
+
+### Types
+
+```typescript
+// Message listener callback
+type TransportListener = (message: string) => void;
+
+// Cleanup function returned by subscribe
+type TransportUnsubscribe = () => void;
+
+// Factory function for creating transports
+type TransportFactory = () => Transport;
+```
+
+### TransportDetector Interface
+
+Used for registering custom transports:
+
+```typescript
+interface TransportDetector {
+  readonly name: string;
+  readonly priority: number;
+  detect(): boolean;
+  createTransport(): Transport;
+}
+```
+
+**Properties:**
+- `name` - Transport identifier
+- `priority` - Detection priority (higher values checked first)
+
+**Methods:**
+- `detect()` - Return `true` if this transport is available
+- `createTransport()` - Create and return a transport instance
+
+### BaseTransport Class
+
+Abstract base class providing common functionality:
+
+```typescript
+abstract class BaseTransport implements Transport {
+  abstract readonly name: string;
+  abstract isAvailable(): boolean;
+  abstract send(message: string): void;
+  abstract subscribe(listener: TransportListener): TransportUnsubscribe;
+
+  protected hasWindow(): boolean;
+  protected getWindow(): Window | null;
+}
+```
+
+**Protected Helpers:**
+- `hasWindow()` - Check if `window` is defined (SSR-safe)
+- `getWindow()` - Safely get the `window` object or `null`
+
+### TransportRegistry
+
+Global registry for managing transport detectors:
+
+```typescript
+class TransportRegistry {
+  register(detector: TransportDetector): void;
+  unregister(name: string): void;
+  getDetectors(): readonly TransportDetector[];
+  detect(forceRedetect?: boolean): Transport;
+  clearCache(): void;
+  reset(): void;
+}
+```
+
+**Methods:**
+- `register(detector)` - Register a custom transport detector
+- `unregister(name)` - Remove a detector by name
+- `getDetectors()` - Get all registered detectors
+- `detect(forceRedetect?)` - Detect and return the appropriate transport (cached)
+- `clearCache()` - Clear the cached transport
+- `reset()` - Reset to default state (built-in detectors only)
+
+### Convenience Functions
+
+```typescript
+// Detect the current transport
+function detectTransport(forceRedetect?: boolean): Transport;
+
+// Register a custom detector
+function registerTransport(detector: TransportDetector): void;
+```
+
+## Built-in Transports
+
+### CefSharpTransport
+
+For desktop applications using [CefSharp](https://cefsharp.github.io/) (Chromium Embedded Framework for .NET).
+
+**Detection:** Checks for `window.CefSharp.PostMessage`
+**Priority:** 100 (highest)
+
+```typescript
+import { CefSharpTransport } from '@aspectly/transports';
+
+const transport = new CefSharpTransport();
+transport.send(JSON.stringify({ action: 'openFile' }));
+
+const unsubscribe = transport.subscribe((message) => {
+  console.log('From C#:', message);
+});
+```
+
+**Messaging:**
+- Sends messages via `window.CefSharp.PostMessage(message)`
+- Receives messages via `window.postMessage` events
+
+### ReactNativeTransport
+
+For web content running inside [React Native WebView](https://github.com/react-native-webview/react-native-webview).
+
+**Detection:** Checks for `window.ReactNativeWebView.postMessage`
+**Priority:** 90
+
+```typescript
+import { ReactNativeTransport } from '@aspectly/transports';
+
+const transport = new ReactNativeTransport();
+transport.send(JSON.stringify({ action: 'navigate' }));
+```
+
+**Messaging:**
+- Sends messages via `window.ReactNativeWebView.postMessage(message)`
+- Messages are wrapped in quotes for iOS compatibility: `'${message}'`
+- Receives messages via `window.postMessage` events
+
+### IframeTransport
+
+For web content running inside an iframe.
+
+**Detection:** Checks if `window.parent !== window`
+**Priority:** 80
+
+```typescript
+import { IframeTransport } from '@aspectly/transports';
+
+// Default: sends to any origin ('*')
+const transport = new IframeTransport();
+
+// Specify target origin for security
+const secureTransport = new IframeTransport('https://parent-domain.com');
+
+transport.send(JSON.stringify({ type: 'ready' }));
+```
+
+**Constructor:**
+- `new IframeTransport(targetOrigin?: string)` - Default: `'*'`
+
+**Messaging:**
+- Sends messages via `window.parent.postMessage(message, targetOrigin)`
+- Receives messages via `window.postMessage` events
+
+### NullTransport
+
+Fallback transport that performs no operations. Used when no other transport is available (e.g., SSR, testing).
+
+**Priority:** Always available (fallback)
+
+```typescript
+import { NullTransport } from '@aspectly/transports';
+
+const transport = new NullTransport();
+transport.isAvailable(); // true
+transport.send('message'); // No-op (logs warning in development)
+transport.subscribe(() => {}); // Returns no-op cleanup function
+```
+
+**Behavior:**
+- `isAvailable()` always returns `true`
+- `send()` is a no-op (logs warning in development mode)
+- `subscribe()` returns a no-op cleanup function
+
+## Creating Custom Transports
+
+### Example: Electron Transport
+
+```typescript
+import { BaseTransport, registerTransport } from '@aspectly/transports';
+import type { TransportListener, TransportUnsubscribe } from '@aspectly/transports';
+
+// Extend BaseTransport for helper methods
+class ElectronTransport extends BaseTransport {
+  readonly name = 'electron';
+
+  isAvailable(): boolean {
+    const win = this.getWindow();
+    return typeof win?.electron?.send === 'function';
+  }
+
+  send(message: string): void {
+    const win = this.getWindow();
+    if (!win?.electron?.send) {
+      console.warn('[ElectronTransport] electron.send not available');
+      return;
+    }
+    win.electron.send('message', message);
+  }
+
+  subscribe(listener: TransportListener): TransportUnsubscribe {
+    const win = this.getWindow();
+    if (!win?.electron?.on) {
+      return () => {};
+    }
+
+    const handler = (_event: any, message: string) => {
+      listener(message);
+    };
+
+    win.electron.on('message', handler);
+    return () => {
+      win.electron?.removeListener('message', handler);
+    };
+  }
+}
+
+// Register with high priority
+registerTransport({
+  name: 'electron',
+  priority: 150,
+  detect: () => {
+    return typeof window !== 'undefined' &&
+           window.electron?.send !== undefined;
+  },
+  createTransport: () => new ElectronTransport(),
+});
+```
+
+### Implementation Checklist
+
+When creating a custom transport:
+
+1. ✓ Extend `BaseTransport` or implement `Transport` interface
+2. ✓ Provide unique `name` property
+3. ✓ Implement `isAvailable()` to check environment
+4. ✓ Implement `send()` to send messages
+5. ✓ Implement `subscribe()` to receive messages
+6. ✓ Return cleanup function from `subscribe()`
+7. ✓ Handle SSR/missing globals safely
+8. ✓ Create a `TransportDetector` for registration
+9. ✓ Set appropriate `priority` (higher = checked first)
+
+## Related Packages
+
+- [`@aspectly/core`](../core) - Core bridge protocol and message handling
+- [`@aspectly/web`](../web) - Web/iframe integration with React hooks
+- [`@aspectly/react-native`](../react-native) - React Native WebView integration
+- [`@aspectly/react-native-web`](../react-native-web) - Universal React Native Web support
+
+## License
+
+MIT

package/dist/BaseTransport-CxzIr1Ds.d.mts

@@ -0,0 +1,80 @@
+/**
+ * Message listener callback type
+ */
+type TransportListener = (message: string) => void;
+/**
+ * Cleanup function returned by subscribe
+ */
+type TransportUnsubscribe = () => void;
+/**
+ * Transport interface - defines how messages are sent and received
+ * between different environments (CefSharp, React Native, iframe, etc.)
+ */
+interface Transport {
+    /**
+     * Unique name of the transport (e.g., 'cefsharp', 'react-native', 'iframe')
+     */
+    readonly name: string;
+    /**
+     * Check if this transport is available in the current environment
+     */
+    isAvailable(): boolean;
+    /**
+     * Send a message to the parent/host context
+     * @param message Serialized message string (usually JSON)
+     */
+    send(message: string): void;
+    /**
+     * Subscribe to incoming messages from the parent/host context
+     * @param listener Callback function for incoming messages
+     * @returns Cleanup function to unsubscribe
+     */
+    subscribe(listener: TransportListener): TransportUnsubscribe;
+}
+/**
+ * Transport factory function type
+ */
+type TransportFactory = () => Transport;
+/**
+ * Transport detector - used for auto-detection
+ */
+interface TransportDetector {
+    /**
+     * Name of the transport this detector is for
+     */
+    readonly name: string;
+    /**
+     * Priority for detection order (higher = checked first)
+     * Default priorities: CefSharp=100, ReactNative=90, Iframe=80
+     */
+    readonly priority: number;
+    /**
+     * Check if this transport is available
+     */
+    detect(): boolean;
+    /**
+     * Create the transport instance
+     */
+    createTransport(): Transport;
+}
+
+/**
+ * Abstract base class for transports
+ * Provides common functionality for message handling
+ */
+declare abstract class BaseTransport implements Transport {
+    abstract readonly name: string;
+    abstract isAvailable(): boolean;
+    abstract send(message: string): void;
+    abstract subscribe(listener: TransportListener): TransportUnsubscribe;
+    /**
+     * Helper to check if window is defined (for SSR safety)
+     */
+    protected hasWindow(): boolean;
+    /**
+     * Helper to safely get window object
+     */
+    protected getWindow(): Window | null;
+}
+
+export { BaseTransport as B, type TransportListener as T, type TransportUnsubscribe as a, type TransportDetector as b, type Transport as c, type TransportFactory as d };

package/dist/BaseTransport-CxzIr1Ds.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Message listener callback type
+ */
+type TransportListener = (message: string) => void;
+/**
+ * Cleanup function returned by subscribe
+ */
+type TransportUnsubscribe = () => void;
+/**
+ * Transport interface - defines how messages are sent and received
+ * between different environments (CefSharp, React Native, iframe, etc.)
+ */
+interface Transport {
+    /**
+     * Unique name of the transport (e.g., 'cefsharp', 'react-native', 'iframe')
+     */
+    readonly name: string;
+    /**
+     * Check if this transport is available in the current environment
+     */
+    isAvailable(): boolean;
+    /**
+     * Send a message to the parent/host context
+     * @param message Serialized message string (usually JSON)
+     */
+    send(message: string): void;
+    /**
+     * Subscribe to incoming messages from the parent/host context
+     * @param listener Callback function for incoming messages
+     * @returns Cleanup function to unsubscribe
+     */
+    subscribe(listener: TransportListener): TransportUnsubscribe;
+}
+/**
+ * Transport factory function type
+ */
+type TransportFactory = () => Transport;
+/**
+ * Transport detector - used for auto-detection
+ */
+interface TransportDetector {
+    /**
+     * Name of the transport this detector is for
+     */
+    readonly name: string;
+    /**
+     * Priority for detection order (higher = checked first)
+     * Default priorities: CefSharp=100, ReactNative=90, Iframe=80
+     */
+    readonly priority: number;
+    /**
+     * Check if this transport is available
+     */
+    detect(): boolean;
+    /**
+     * Create the transport instance
+     */
+    createTransport(): Transport;
+}
+
+/**
+ * Abstract base class for transports
+ * Provides common functionality for message handling
+ */
+declare abstract class BaseTransport implements Transport {
+    abstract readonly name: string;
+    abstract isAvailable(): boolean;
+    abstract send(message: string): void;
+    abstract subscribe(listener: TransportListener): TransportUnsubscribe;
+    /**
+     * Helper to check if window is defined (for SSR safety)
+     */
+    protected hasWindow(): boolean;
+    /**
+     * Helper to safely get window object
+     */
+    protected getWindow(): Window | null;
+}
+
+export { BaseTransport as B, type TransportListener as T, type TransportUnsubscribe as a, type TransportDetector as b, type Transport as c, type TransportFactory as d };

package/dist/cefsharp.d.mts

@@ -0,0 +1,37 @@
+import { B as BaseTransport, T as TransportListener, a as TransportUnsubscribe, b as TransportDetector } from './BaseTransport-CxzIr1Ds.mjs';
+export { c as Transport } from './BaseTransport-CxzIr1Ds.mjs';
+
+declare global {
+    interface Window {
+        CefSharp?: {
+            PostMessage: (message: string) => void;
+            BindObjectAsync: (...args: unknown[]) => Promise<void>;
+        };
+    }
+}
+/**
+ * Transport for CefSharp (Chromium Embedded Framework for .NET)
+ * Used in desktop applications with embedded Chromium browsers
+ *
+ * @example
+ * ```typescript
+ * import { CefSharpTransport } from '@aspectly/transports/cefsharp';
+ *
+ * const transport = new CefSharpTransport();
+ * if (transport.isAvailable()) {
+ *   transport.send(JSON.stringify({ type: 'hello' }));
+ * }
+ * ```
+ */
+declare class CefSharpTransport extends BaseTransport {
+    readonly name = "cefsharp";
+    isAvailable(): boolean;
+    send(message: string): void;
+    subscribe(listener: TransportListener): TransportUnsubscribe;
+}
+/**
+ * Detector for auto-detection registry
+ */
+declare const cefSharpDetector: TransportDetector;
+
+export { CefSharpTransport, TransportListener, TransportUnsubscribe, cefSharpDetector };

package/dist/cefsharp.d.ts

@@ -0,0 +1,37 @@
+import { B as BaseTransport, T as TransportListener, a as TransportUnsubscribe, b as TransportDetector } from './BaseTransport-CxzIr1Ds.js';
+export { c as Transport } from './BaseTransport-CxzIr1Ds.js';
+
+declare global {
+    interface Window {
+        CefSharp?: {
+            PostMessage: (message: string) => void;
+            BindObjectAsync: (...args: unknown[]) => Promise<void>;
+        };
+    }
+}
+/**
+ * Transport for CefSharp (Chromium Embedded Framework for .NET)
+ * Used in desktop applications with embedded Chromium browsers
+ *
+ * @example
+ * ```typescript
+ * import { CefSharpTransport } from '@aspectly/transports/cefsharp';
+ *
+ * const transport = new CefSharpTransport();
+ * if (transport.isAvailable()) {
+ *   transport.send(JSON.stringify({ type: 'hello' }));
+ * }
+ * ```
+ */
+declare class CefSharpTransport extends BaseTransport {
+    readonly name = "cefsharp";
+    isAvailable(): boolean;
+    send(message: string): void;
+    subscribe(listener: TransportListener): TransportUnsubscribe;
+}
+/**
+ * Detector for auto-detection registry
+ */
+declare const cefSharpDetector: TransportDetector;
+
+export { CefSharpTransport, TransportListener, TransportUnsubscribe, cefSharpDetector };

package/dist/cefsharp.js

@@ -0,0 +1,65 @@
+'use strict';
+
+// src/BaseTransport.ts
+var BaseTransport = class {
+  /**
+   * Helper to check if window is defined (for SSR safety)
+   */
+  hasWindow() {
+    return typeof window !== "undefined";
+  }
+  /**
+   * Helper to safely get window object
+   */
+  getWindow() {
+    return this.hasWindow() ? window : null;
+  }
+};
+
+// src/transports/CefSharpTransport.ts
+var CefSharpTransport = class extends BaseTransport {
+  constructor() {
+    super(...arguments);
+    this.name = "cefsharp";
+  }
+  isAvailable() {
+    const win = this.getWindow();
+    return typeof win?.CefSharp?.PostMessage === "function";
+  }
+  send(message) {
+    const win = this.getWindow();
+    if (!win?.CefSharp?.PostMessage) {
+      console.warn("[CefSharpTransport] CefSharp.PostMessage is not available");
+      return;
+    }
+    win.CefSharp.PostMessage(message);
+  }
+  subscribe(listener) {
+    const win = this.getWindow();
+    if (!win) {
+      return () => {
+      };
+    }
+    const handler = (event) => {
+      if (typeof event.data === "string") {
+        listener(event.data);
+      }
+    };
+    win.addEventListener("message", handler);
+    return () => win.removeEventListener("message", handler);
+  }
+};
+var cefSharpDetector = {
+  name: "cefsharp",
+  priority: 100,
+  // Highest priority - check first
+  detect: () => {
+    return typeof window !== "undefined" && typeof window.CefSharp?.PostMessage === "function";
+  },
+  createTransport: () => new CefSharpTransport()
+};
+
+exports.CefSharpTransport = CefSharpTransport;
+exports.cefSharpDetector = cefSharpDetector;
+//# sourceMappingURL=cefsharp.js.map
+//# sourceMappingURL=cefsharp.js.map

package/dist/cefsharp.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/BaseTransport.ts","../src/transports/CefSharpTransport.ts"],"names":[],"mappings":";;;AAMO,IAAe,gBAAf,MAAkD;AAAA;AAAA;AAAA;AAAA,EAU7C,SAAA,GAAqB;AAC7B,IAAA,OAAO,OAAO,MAAA,KAAW,WAAA;AAAA,EAC3B;AAAA;AAAA;AAAA;AAAA,EAKU,SAAA,GAA2B;AACnC,IAAA,OAAO,IAAA,CAAK,SAAA,EAAU,GAAI,MAAA,GAAS,IAAA;AAAA,EACrC;AACF,CAAA;;;ACAO,IAAM,iBAAA,GAAN,cAAgC,aAAA,CAAc;AAAA,EAA9C,WAAA,GAAA;AAAA,IAAA,KAAA,CAAA,GAAA,SAAA,CAAA;AACL,IAAA,IAAA,CAAS,IAAA,GAAO,UAAA;AAAA,EAAA;AAAA,EAEhB,WAAA,GAAuB;AACrB,IAAA,MAAM,GAAA,GAAM,KAAK,SAAA,EAAU;AAC3B,IAAA,OAAO,OAAO,GAAA,EAAK,QAAA,EAAU,WAAA,KAAgB,UAAA;AAAA,EAC/C;AAAA,EAEA,KAAK,OAAA,EAAuB;AAC1B,IAAA,MAAM,GAAA,GAAM,KAAK,SAAA,EAAU;AAC3B,IAAA,IAAI,CAAC,GAAA,EAAK,QAAA,EAAU,WAAA,EAAa;AAC/B,MAAA,OAAA,CAAQ,KAAK,2DAA2D,CAAA;AACxE,MAAA;AAAA,IACF;AACA,IAAA,GAAA,CAAI,QAAA,CAAS,YAAY,OAAO,CAAA;AAAA,EAClC;AAAA,EAEA,UAAU,QAAA,EAAmD;AAC3D,IAAA,MAAM,GAAA,GAAM,KAAK,SAAA,EAAU;AAC3B,IAAA,IAAI,CAAC,GAAA,EAAK;AACR,MAAA,OAAO,MAAM;AAAA,MAAC,CAAA;AAAA,IAChB;AAGA,IAAA,MAAM,OAAA,GAAU,CAAC,KAAA,KAA8B;AAC7C,MAAA,IAAI,OAAO,KAAA,CAAM,IAAA,KAAS,QAAA,EAAU;AAClC,QAAA,QAAA,CAAS,MAAM,IAAI,CAAA;AAAA,MACrB;AAAA,IACF,CAAA;AAEA,IAAA,GAAA,CAAI,gBAAA,CAAiB,WAAW,OAAO,CAAA;AACvC,IAAA,OAAO,MAAM,GAAA,CAAI,mBAAA,CAAoB,SAAA,EAAW,OAAO,CAAA;AAAA,EACzD;AACF;AAKO,IAAM,gBAAA,GAAsC;AAAA,EACjD,IAAA,EAAM,UAAA;AAAA,EACN,QAAA,EAAU,GAAA;AAAA;AAAA,EACV,QAAQ,MAAM;AACZ,IAAA,OAAO,OAAO,MAAA,KAAW,WAAA,IAClB,OAAO,MAAA,CAAO,UAAU,WAAA,KAAgB,UAAA;AAAA,EACjD,CAAA;AAAA,EACA,eAAA,EAAiB,MAAM,IAAI,iBAAA;AAC7B","file":"cefsharp.js","sourcesContent":["import type { Transport, TransportListener, TransportUnsubscribe } from './types';\r\n\r\n/**\r\n * Abstract base class for transports\r\n * Provides common functionality for message handling\r\n */\r\nexport abstract class BaseTransport implements Transport {\r\n  abstract readonly name: string;\r\n\r\n  abstract isAvailable(): boolean;\r\n  abstract send(message: string): void;\r\n  abstract subscribe(listener: TransportListener): TransportUnsubscribe;\r\n\r\n  /**\r\n   * Helper to check if window is defined (for SSR safety)\r\n   */\r\n  protected hasWindow(): boolean {\r\n    return typeof window !== 'undefined';\r\n  }\r\n\r\n  /**\r\n   * Helper to safely get window object\r\n   */\r\n  protected getWindow(): Window | null {\r\n    return this.hasWindow() ? window : null;\r\n  }\r\n}\r\n","import { BaseTransport } from '../BaseTransport';\r\nimport type { TransportListener, TransportUnsubscribe, TransportDetector } from '../types';\r\n\r\ndeclare global {\r\n  interface Window {\r\n    CefSharp?: {\r\n      PostMessage: (message: string) => void;\r\n      BindObjectAsync: (...args: unknown[]) => Promise<void>;\r\n    };\r\n  }\r\n}\r\n\r\n/**\r\n * Transport for CefSharp (Chromium Embedded Framework for .NET)\r\n * Used in desktop applications with embedded Chromium browsers\r\n *\r\n * @example\r\n * ```typescript\r\n * import { CefSharpTransport } from '@aspectly/transports/cefsharp';\r\n *\r\n * const transport = new CefSharpTransport();\r\n * if (transport.isAvailable()) {\r\n *   transport.send(JSON.stringify({ type: 'hello' }));\r\n * }\r\n * ```\r\n */\r\nexport class CefSharpTransport extends BaseTransport {\r\n  readonly name = 'cefsharp';\r\n\r\n  isAvailable(): boolean {\r\n    const win = this.getWindow();\r\n    return typeof win?.CefSharp?.PostMessage === 'function';\r\n  }\r\n\r\n  send(message: string): void {\r\n    const win = this.getWindow();\r\n    if (!win?.CefSharp?.PostMessage) {\r\n      console.warn('[CefSharpTransport] CefSharp.PostMessage is not available');\r\n      return;\r\n    }\r\n    win.CefSharp.PostMessage(message);\r\n  }\r\n\r\n  subscribe(listener: TransportListener): TransportUnsubscribe {\r\n    const win = this.getWindow();\r\n    if (!win) {\r\n      return () => {};\r\n    }\r\n\r\n    // CefSharp sends messages via window.postMessage\r\n    const handler = (event: MessageEvent): void => {\r\n      if (typeof event.data === 'string') {\r\n        listener(event.data);\r\n      }\r\n    };\r\n\r\n    win.addEventListener('message', handler);\r\n    return () => win.removeEventListener('message', handler);\r\n  }\r\n}\r\n\r\n/**\r\n * Detector for auto-detection registry\r\n */\r\nexport const cefSharpDetector: TransportDetector = {\r\n  name: 'cefsharp',\r\n  priority: 100, // Highest priority - check first\r\n  detect: () => {\r\n    return typeof window !== 'undefined' &&\r\n           typeof window.CefSharp?.PostMessage === 'function';\r\n  },\r\n  createTransport: () => new CefSharpTransport(),\r\n};\r\n"]}