@sygnl/talon 1.0.2 → 1.0.4

package/dist/index.d.cts

@@ -1,242 +1,122 @@
-/**
- * Message sent TO the edge
- */
-interface OutboundMessage {
-    /** Message type/event name */
-    type: string;
-    /** Message payload */
-    data: Record<string, unknown>;
-    /** Optional message ID for tracking */
-    id?: string;
-    /** Timestamp */
-    timestamp?: number;
-}
-/**
- * Message received FROM the edge
- */
-interface InboundMessage {
-    /** Message type/event name */
-    type: string;
-    /** Message payload */
-    data: Record<string, unknown>;
-    /** Optional message ID */
-    id?: string;
-    /** Timestamp */
-    timestamp?: number;
-}
-/**
- * Transport connection state
- */
-type TransportState = 'disconnected' | 'connecting' | 'connected' | 'reconnecting' | 'error';
-/**
- * Transport interface - all transports must implement this
- */
-interface TalonTransport {
-    /**
-     * Current connection state
-     */
-    readonly state: TransportState;
-    /**
-     * Connect to the transport
-     */
-    connect(): Promise<void>;
-    /**
-     * Disconnect from the transport
-     */
-    disconnect(): void;
-    /**
-     * Send a message to the edge
-     * @param message - Message to send
-     */
-    send(message: OutboundMessage): Promise<void>;
-    /**
-     * Subscribe to messages from the edge
-     * @param handler - Function to call when message received
-     * @returns Unsubscribe function
-     */
-    onMessage(handler: (message: InboundMessage) => void): () => void;
-    /**
-     * Subscribe to connection state changes
-     * @param handler - Function to call when state changes
-     * @returns Unsubscribe function
-     */
-    onStateChange(handler: (state: TransportState) => void): () => void;
-    /**
-     * Subscribe to errors
-     * @param handler - Function to call when error occurs
-     * @returns Unsubscribe function
-     */
-    onError(handler: (error: Error) => void): () => void;
-}
+import { T as TalonClientOptions, E as EventHandler, a as TransportState } from './types-DsDnVD2W.cjs';
+export { I as InboundMessage, O as OutboundMessage, b as TalonTransport } from './types-DsDnVD2W.cjs';
 
 /**
- * WebSocket transport options
- */
-interface WebSocketTransportOptions {
-    /** WebSocket URL */
-    url: string;
-    /** Auto-reconnect on disconnect */
-    autoReconnect?: boolean;
-    /** Reconnect delay in ms */
-    reconnectDelay?: number;
-    /** Max reconnect attempts (0 = infinite) */
-    maxReconnectAttempts?: number;
-    /** Connection timeout in ms */
-    connectionTimeout?: number;
-    /** Debug mode */
-    debug?: boolean;
-}
-/**
- * WebSocket transport for bidirectional communication
+ * TalonClient - Bidirectional event delivery client
  *
  * Features:
- * - Real-time bidirectional communication
- * - Auto-reconnect with exponential backoff
- * - Connection state management
- * - Message queuing during disconnection
+ * - Send events TO the edge
+ * - Receive updates FROM the edge
+ * - Transport-agnostic (WebSocket, Webhook, etc.)
+ * - Event emitter pattern for edge responses
  *
  * @example
  * ```typescript
- * const transport = new WebSocketTransport({
- *   url: 'wss://edge.sygnl.io',
- *   autoReconnect: true
+ * import { TalonClient } from '@sygnl/talon';
+ * import { WebSocketTransport } from '@sygnl/talon/transports';
+ *
+ * const talon = new TalonClient({
+ *   transport: new WebSocketTransport('wss://edge.sygnl.io')
+ * });
+ *
+ * // Send event TO edge
+ * await talon.send({ event: 'add_to_cart', product_id: 'abc' });
+ *
+ * // Receive updates FROM edge
+ * talon.on('attribution_updated', (data) => {
+ *   console.log('Attribution:', data);
  * });
  * ```
  */
-declare class WebSocketTransport implements TalonTransport {
-    private url;
-    private ws;
-    private _state;
-    private autoReconnect;
-    private reconnectDelay;
-    private maxReconnectAttempts;
-    private reconnectAttempts;
-    private reconnectTimeout;
-    private connectionTimeout;
+declare class TalonClient {
+    private transport;
+    private eventHandlers;
+    private messageUnsubscribe?;
+    private stateUnsubscribe?;
+    private errorUnsubscribe?;
     private debug;
-    private messageHandlers;
-    private stateHandlers;
-    private errorHandlers;
-    private messageQueue;
-    constructor(options: WebSocketTransportOptions);
-    get state(): TransportState;
+    constructor(options: TalonClientOptions);
+    /**
+     * Connect to the edge
+     */
     connect(): Promise<void>;
+    /**
+     * Disconnect from the edge
+     */
     disconnect(): void;
-    send(message: OutboundMessage): Promise<void>;
-    onMessage(handler: (message: InboundMessage) => void): () => void;
-    onStateChange(handler: (state: TransportState) => void): () => void;
-    onError(handler: (error: Error) => void): () => void;
     /**
-     * Handle incoming WebSocket message
+     * Send event TO the edge
+     *
+     * @param event - Event data to send
+     * @returns Promise that resolves when sent
+     *
+     * @example
+     * ```typescript
+     * await talon.send({
+     *   event: 'add_to_cart',
+     *   product_id: 'prod_123',
+     *   price: 99.99
+     * });
+     * ```
+     */
+    send(event: Record<string, unknown>): Promise<void>;
+    /**
+     * Subscribe to events FROM the edge
+     *
+     * @param eventType - Event type to listen for
+     * @param handler - Function to call when event received
+     * @returns Unsubscribe function
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = talon.on('attribution_updated', (data) => {
+     *   console.log('Attribution:', data);
+     * });
+     *
+     * // Later: unsubscribe()
+     * ```
      */
-    private handleMessage;
+    on<T = any>(eventType: string, handler: EventHandler<T>): () => void;
     /**
-     * Handle WebSocket disconnect
+     * Subscribe to event once (auto-unsubscribe after first call)
      */
-    private handleDisconnect;
+    once<T = any>(eventType: string, handler: EventHandler<T>): () => void;
     /**
-     * Schedule reconnection attempt with exponential backoff
+     * Remove all handlers for an event type
      */
-    private scheduleReconnect;
+    off(eventType: string): void;
     /**
-     * Flush queued messages
+     * Get current connection state
      */
-    private flushMessageQueue;
+    get state(): TransportState;
     /**
-     * Set connection state
+     * Check if connected
      */
-    private setState;
+    get connected(): boolean;
     /**
-     * Emit error to handlers
+     * Handle incoming message from transport
      */
-    private emitError;
+    private handleMessage;
     /**
-     * Debug logging
+     * Handle transport state change
      */
-    private log;
-}
-
-/**
- * Webhook transport options
- */
-interface WebhookTransportOptions {
-    /** Webhook URL */
-    url: string;
-    /** HTTP method */
-    method?: 'POST' | 'PUT';
-    /** Custom headers */
-    headers?: Record<string, string>;
-    /** Request timeout in ms */
-    timeout?: number;
-    /** Retry failed requests */
-    retry?: boolean;
-    /** Max retry attempts */
-    maxRetries?: number;
-    /** Retry delay in ms */
-    retryDelay?: number;
-    /** Debug mode */
-    debug?: boolean;
-}
-/**
- * Webhook transport for fire-and-forget HTTP requests
- *
- * Features:
- * - One-way communication (no responses)
- * - HTTP POST/PUT requests
- * - Optional retry logic
- * - Custom headers support
- *
- * Use this for:
- * - Server-side event delivery
- * - Fire-and-forget scenarios
- * - When WebSocket not available/needed
- *
- * @example
- * ```typescript
- * const transport = new WebhookTransport({
- *   url: 'https://edge.sygnl.io/webhook',
- *   method: 'POST',
- *   retry: true
- * });
- * ```
- */
-declare class WebhookTransport implements TalonTransport {
-    private url;
-    private method;
-    private headers;
-    private timeout;
-    private retry;
-    private maxRetries;
-    private retryDelay;
-    private debug;
-    private _state;
-    private messageHandlers;
-    private stateHandlers;
-    private errorHandlers;
-    constructor(options: WebhookTransportOptions);
-    get state(): TransportState;
-    connect(): Promise<void>;
-    disconnect(): void;
-    send(message: OutboundMessage): Promise<void>;
-    onMessage(handler: (message: InboundMessage) => void): () => void;
-    onStateChange(handler: (state: TransportState) => void): () => void;
-    onError(handler: (error: Error) => void): () => void;
+    private handleStateChange;
     /**
-     * Send HTTP request
+     * Handle transport error
      */
-    private sendRequest;
+    private handleError;
     /**
-     * Set connection state
+     * Cleanup subscriptions
      */
-    private setState;
+    private cleanup;
     /**
-     * Emit error to handlers
+     * Generate unique message ID
      */
-    private emitError;
+    private generateId;
     /**
      * Debug logging
      */
     private log;
 }
 
-export { WebSocketTransport, type WebSocketTransportOptions, WebhookTransport, type WebhookTransportOptions };
+export { EventHandler, TalonClient, TalonClientOptions, TransportState };

package/dist/index.d.ts

@@ -1,242 +1,122 @@
-/**
- * Message sent TO the edge
- */
-interface OutboundMessage {
-    /** Message type/event name */
-    type: string;
-    /** Message payload */
-    data: Record<string, unknown>;
-    /** Optional message ID for tracking */
-    id?: string;
-    /** Timestamp */
-    timestamp?: number;
-}
-/**
- * Message received FROM the edge
- */
-interface InboundMessage {
-    /** Message type/event name */
-    type: string;
-    /** Message payload */
-    data: Record<string, unknown>;
-    /** Optional message ID */
-    id?: string;
-    /** Timestamp */
-    timestamp?: number;
-}
-/**
- * Transport connection state
- */
-type TransportState = 'disconnected' | 'connecting' | 'connected' | 'reconnecting' | 'error';
-/**
- * Transport interface - all transports must implement this
- */
-interface TalonTransport {
-    /**
-     * Current connection state
-     */
-    readonly state: TransportState;
-    /**
-     * Connect to the transport
-     */
-    connect(): Promise<void>;
-    /**
-     * Disconnect from the transport
-     */
-    disconnect(): void;
-    /**
-     * Send a message to the edge
-     * @param message - Message to send
-     */
-    send(message: OutboundMessage): Promise<void>;
-    /**
-     * Subscribe to messages from the edge
-     * @param handler - Function to call when message received
-     * @returns Unsubscribe function
-     */
-    onMessage(handler: (message: InboundMessage) => void): () => void;
-    /**
-     * Subscribe to connection state changes
-     * @param handler - Function to call when state changes
-     * @returns Unsubscribe function
-     */
-    onStateChange(handler: (state: TransportState) => void): () => void;
-    /**
-     * Subscribe to errors
-     * @param handler - Function to call when error occurs
-     * @returns Unsubscribe function
-     */
-    onError(handler: (error: Error) => void): () => void;
-}
+import { T as TalonClientOptions, E as EventHandler, a as TransportState } from './types-DsDnVD2W.js';
+export { I as InboundMessage, O as OutboundMessage, b as TalonTransport } from './types-DsDnVD2W.js';
 
 /**
- * WebSocket transport options
- */
-interface WebSocketTransportOptions {
-    /** WebSocket URL */
-    url: string;
-    /** Auto-reconnect on disconnect */
-    autoReconnect?: boolean;
-    /** Reconnect delay in ms */
-    reconnectDelay?: number;
-    /** Max reconnect attempts (0 = infinite) */
-    maxReconnectAttempts?: number;
-    /** Connection timeout in ms */
-    connectionTimeout?: number;
-    /** Debug mode */
-    debug?: boolean;
-}
-/**
- * WebSocket transport for bidirectional communication
+ * TalonClient - Bidirectional event delivery client
  *
  * Features:
- * - Real-time bidirectional communication
- * - Auto-reconnect with exponential backoff
- * - Connection state management
- * - Message queuing during disconnection
+ * - Send events TO the edge
+ * - Receive updates FROM the edge
+ * - Transport-agnostic (WebSocket, Webhook, etc.)
+ * - Event emitter pattern for edge responses
  *
  * @example
  * ```typescript
- * const transport = new WebSocketTransport({
- *   url: 'wss://edge.sygnl.io',
- *   autoReconnect: true
+ * import { TalonClient } from '@sygnl/talon';
+ * import { WebSocketTransport } from '@sygnl/talon/transports';
+ *
+ * const talon = new TalonClient({
+ *   transport: new WebSocketTransport('wss://edge.sygnl.io')
+ * });
+ *
+ * // Send event TO edge
+ * await talon.send({ event: 'add_to_cart', product_id: 'abc' });
+ *
+ * // Receive updates FROM edge
+ * talon.on('attribution_updated', (data) => {
+ *   console.log('Attribution:', data);
  * });
  * ```
  */
-declare class WebSocketTransport implements TalonTransport {
-    private url;
-    private ws;
-    private _state;
-    private autoReconnect;
-    private reconnectDelay;
-    private maxReconnectAttempts;
-    private reconnectAttempts;
-    private reconnectTimeout;
-    private connectionTimeout;
+declare class TalonClient {
+    private transport;
+    private eventHandlers;
+    private messageUnsubscribe?;
+    private stateUnsubscribe?;
+    private errorUnsubscribe?;
     private debug;
-    private messageHandlers;
-    private stateHandlers;
-    private errorHandlers;
-    private messageQueue;
-    constructor(options: WebSocketTransportOptions);
-    get state(): TransportState;
+    constructor(options: TalonClientOptions);
+    /**
+     * Connect to the edge
+     */
     connect(): Promise<void>;
+    /**
+     * Disconnect from the edge
+     */
     disconnect(): void;
-    send(message: OutboundMessage): Promise<void>;
-    onMessage(handler: (message: InboundMessage) => void): () => void;
-    onStateChange(handler: (state: TransportState) => void): () => void;
-    onError(handler: (error: Error) => void): () => void;
     /**
-     * Handle incoming WebSocket message
+     * Send event TO the edge
+     *
+     * @param event - Event data to send
+     * @returns Promise that resolves when sent
+     *
+     * @example
+     * ```typescript
+     * await talon.send({
+     *   event: 'add_to_cart',
+     *   product_id: 'prod_123',
+     *   price: 99.99
+     * });
+     * ```
+     */
+    send(event: Record<string, unknown>): Promise<void>;
+    /**
+     * Subscribe to events FROM the edge
+     *
+     * @param eventType - Event type to listen for
+     * @param handler - Function to call when event received
+     * @returns Unsubscribe function
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = talon.on('attribution_updated', (data) => {
+     *   console.log('Attribution:', data);
+     * });
+     *
+     * // Later: unsubscribe()
+     * ```
      */
-    private handleMessage;
+    on<T = any>(eventType: string, handler: EventHandler<T>): () => void;
     /**
-     * Handle WebSocket disconnect
+     * Subscribe to event once (auto-unsubscribe after first call)
      */
-    private handleDisconnect;
+    once<T = any>(eventType: string, handler: EventHandler<T>): () => void;
     /**
-     * Schedule reconnection attempt with exponential backoff
+     * Remove all handlers for an event type
      */
-    private scheduleReconnect;
+    off(eventType: string): void;
     /**
-     * Flush queued messages
+     * Get current connection state
      */
-    private flushMessageQueue;
+    get state(): TransportState;
     /**
-     * Set connection state
+     * Check if connected
      */
-    private setState;
+    get connected(): boolean;
     /**
-     * Emit error to handlers
+     * Handle incoming message from transport
      */
-    private emitError;
+    private handleMessage;
     /**
-     * Debug logging
+     * Handle transport state change
      */
-    private log;
-}
-
-/**
- * Webhook transport options
- */
-interface WebhookTransportOptions {
-    /** Webhook URL */
-    url: string;
-    /** HTTP method */
-    method?: 'POST' | 'PUT';
-    /** Custom headers */
-    headers?: Record<string, string>;
-    /** Request timeout in ms */
-    timeout?: number;
-    /** Retry failed requests */
-    retry?: boolean;
-    /** Max retry attempts */
-    maxRetries?: number;
-    /** Retry delay in ms */
-    retryDelay?: number;
-    /** Debug mode */
-    debug?: boolean;
-}
-/**
- * Webhook transport for fire-and-forget HTTP requests
- *
- * Features:
- * - One-way communication (no responses)
- * - HTTP POST/PUT requests
- * - Optional retry logic
- * - Custom headers support
- *
- * Use this for:
- * - Server-side event delivery
- * - Fire-and-forget scenarios
- * - When WebSocket not available/needed
- *
- * @example
- * ```typescript
- * const transport = new WebhookTransport({
- *   url: 'https://edge.sygnl.io/webhook',
- *   method: 'POST',
- *   retry: true
- * });
- * ```
- */
-declare class WebhookTransport implements TalonTransport {
-    private url;
-    private method;
-    private headers;
-    private timeout;
-    private retry;
-    private maxRetries;
-    private retryDelay;
-    private debug;
-    private _state;
-    private messageHandlers;
-    private stateHandlers;
-    private errorHandlers;
-    constructor(options: WebhookTransportOptions);
-    get state(): TransportState;
-    connect(): Promise<void>;
-    disconnect(): void;
-    send(message: OutboundMessage): Promise<void>;
-    onMessage(handler: (message: InboundMessage) => void): () => void;
-    onStateChange(handler: (state: TransportState) => void): () => void;
-    onError(handler: (error: Error) => void): () => void;
+    private handleStateChange;
     /**
-     * Send HTTP request
+     * Handle transport error
      */
-    private sendRequest;
+    private handleError;
     /**
-     * Set connection state
+     * Cleanup subscriptions
      */
-    private setState;
+    private cleanup;
     /**
-     * Emit error to handlers
+     * Generate unique message ID
      */
-    private emitError;
+    private generateId;
     /**
      * Debug logging
      */
     private log;
 }
 
-export { WebSocketTransport, type WebSocketTransportOptions, WebhookTransport, type WebhookTransportOptions };
+export { EventHandler, TalonClient, TalonClientOptions, TransportState };