@gala-chain/launchpad-sdk 5.0.3 → 5.0.4-beta.1

package/dist/src/utils/websocket-patterns.d.ts

@@ -0,0 +1,681 @@
+/**
+ * WebSocket Patterns & Utilities
+ *
+ * Consolidates recurring WebSocket subscription, event handling, and lifecycle patterns
+ * used across multiple streaming services. Eliminates code duplication and provides
+ * reusable patterns for real-time features.
+ *
+ * Patterns consolidated:
+ * 1. RoomSubscriptionManager - Room-based subscription tracking with auto-cleanup
+ * 2. PayloadWalkerWithDeduplication - Recursive payload traversal with deduplication
+ * 3. PendingSubscriptionTracker - Pending subscriptions with timeout guards
+ * 4. GlobalAndRoomCallbackDispatcher - Dual-level callback dispatching
+ * 5. SelectiveEventForwarding - Event filtering before forwarding
+ * 6. ListenerCleanupManager - Multi-stage listener cleanup with error isolation
+ * 7. EventBufferWithAutoCleanup - Event buffering with TTL and max size
+ * 8. TypingIndicatorDebouncer - Typing indicator debouncing
+ *
+ * @category Utilities
+ * @since 6.6.0
+ */
+import type { Logger } from './Logger';
+/**
+ * Room Subscription Manager
+ *
+ * Unified room-based subscription tracking with automatic cleanup and duplicate prevention.
+ * Used by StreamWebSocketService, PoolStateManager, and MultiPoolStateManager to track
+ * which rooms (token subscriptions, pools, etc.) are currently active.
+ *
+ * Features:
+ * - Duplicate prevention (can't add same room twice)
+ * - O(1) subscription checks
+ * - Bulk retrieval of subscribed rooms
+ * - Automatic cleanup on unsubscribe
+ *
+ * @example
+ * ```typescript
+ * // Test case: Room tracking with subscription metadata
+ * const manager = new RoomSubscriptionManager();
+ *
+ * // Add room
+ * manager.addRoom('token:anime');
+ * console.assert(manager.isSubscribedTo('token:anime') === true);
+ *
+ * // Prevent duplicates (no-op if already added)
+ * manager.addRoom('token:anime'); // Silent duplicate prevention
+ *
+ * // Get all subscribed rooms
+ * const rooms = manager.getRooms();
+ * console.assert(rooms.includes('token:anime'));
+ *
+ * // Remove room
+ * manager.removeRoom('token:anime');
+ * console.assert(manager.isSubscribedTo('token:anime') === false);
+ *
+ * // Clear all
+ * manager.addRoom('room1');
+ * manager.addRoom('room2');
+ * manager.clear();
+ * console.assert(manager.getRooms().length === 0);
+ * ```
+ *
+ * @since 6.6.0
+ */
+export declare class RoomSubscriptionManager {
+    private rooms;
+    /**
+     * Add a room to subscriptions
+     *
+     * No-op if room already exists (duplicate prevention).
+     *
+     * @param roomId - Room identifier (e.g., 'token:anime', 'pool:GALA-USDC')
+     */
+    addRoom(roomId: string): void;
+    /**
+     * Remove a room from subscriptions
+     *
+     * No-op if room doesn't exist.
+     *
+     * @param roomId - Room identifier to remove
+     */
+    removeRoom(roomId: string): void;
+    /**
+     * Get all subscribed rooms
+     *
+     * @returns Array of room identifiers currently subscribed to
+     */
+    getRooms(): string[];
+    /**
+     * Check if subscribed to a room
+     *
+     * @param roomId - Room identifier to check
+     * @returns True if currently subscribed to this room
+     */
+    isSubscribedTo(roomId: string): boolean;
+    /**
+     * Clear all room subscriptions
+     *
+     * Typically called during disconnect or cleanup.
+     */
+    clear(): void;
+    /**
+     * Get count of subscribed rooms
+     *
+     * @returns Number of currently subscribed rooms
+     */
+    get size(): number;
+}
+/**
+ * Payload Walker with Deduplication
+ *
+ * Recursively walks through object payloads to extract events while deduplicating
+ * by a key (e.g., transactionId, eventId). Prevents duplicate processing of the
+ * same event across multiple payload traversals.
+ *
+ * Used in LiquidityEventExtractor, SwapEventExtractor, and MultiPoolStateManager
+ * to find events nested at various depths in WebSocket payloads.
+ *
+ * Features:
+ * - Recursive depth limiting (prevents DoS from circular structures)
+ * - WeakSet tracking to prevent infinite loops on circular references
+ * - Configurable deduplication key
+ * - Callback-based event processing
+ *
+ * @example
+ * ```typescript
+ * // Test case: Recursive payload walking with deduplication
+ * const walker = new PayloadWalkerWithDeduplication<{ id: string; value: number }>(
+ *   (obj) => {
+ *     // Extraction predicate: return event if found
+ *     return obj.id && obj.value ? { id: obj.id, value: obj.value } : null;
+ *   },
+ *   (event) => event.id // Deduplication key
+ * );
+ *
+ * // First walk - extracts new events
+ * const events1 = walker.walk({
+ *   Data: { id: 'e1', value: 100 },
+ *   nested: { id: 'e2', value: 200 }
+ * });
+ * console.assert(events1.length === 2);
+ *
+ * // Second walk - skips already seen events
+ * const events2 = walker.walk({
+ *   Data: { id: 'e1', value: 999 }, // Already seen, skipped
+ *   other: { id: 'e3', value: 300 }  // New, included
+ * });
+ * console.assert(events2.length === 1);
+ * console.assert(events2[0].id === 'e3');
+ *
+ * // Reset deduplication to reprocess all events
+ * walker.reset();
+ * const events3 = walker.walk({ Data: { id: 'e1', value: 100 } });
+ * console.assert(events3.length === 1); // e1 is processed again
+ * ```
+ *
+ * @typeParam T - Event type being extracted
+ * @since 6.6.0
+ */
+export declare class PayloadWalkerWithDeduplication<T> {
+    private seen;
+    private readonly maxDepth;
+    private readonly extractor;
+    private readonly dedupeKeyFn;
+    constructor(extractor: (obj: unknown) => T | null, dedupeKeyFn: (event: T) => string, maxDepth?: number);
+    /**
+     * Walk through a payload and extract events
+     *
+     * @param payload - Root object to traverse
+     * @returns Array of extracted events not previously seen
+     */
+    walk(payload: unknown): T[];
+    /**
+     * Reset deduplication state to reprocess all events
+     */
+    reset(): void;
+    /**
+     * Get count of deduplicated events
+     *
+     * @returns Number of unique events seen so far
+     */
+    getSeenCount(): number;
+}
+/**
+ * Pending Subscription Tracker
+ *
+ * Tracks pending subscriptions with timeout guards. Prevents memory leaks from
+ * subscriptions that never complete. Used when subscribing to streams where
+ * confirmation is required from the server.
+ *
+ * Features:
+ * - Automatic timeout handling
+ * - Memory leak prevention (clears expired pending)
+ * - Tracks pending duration
+ * - Fast O(1) checks
+ *
+ * @example
+ * ```typescript
+ * // Test case: Pending subscription tracking with timeouts
+ * const tracker = new PendingSubscriptionTracker();
+ *
+ * // Add pending subscription with 1 second timeout
+ * tracker.addPending('sub-123', 1000);
+ * console.assert(tracker.isPending('sub-123') === true);
+ * console.assert(tracker.getPendingCount() === 1);
+ *
+ * // Mark as completed (timeout won't fire)
+ * tracker.removePending('sub-123');
+ * console.assert(tracker.isPending('sub-123') === false);
+ *
+ * // Check if subscription timed out
+ * tracker.addPending('sub-456', 100);
+ * await new Promise(r => setTimeout(r, 200)); // Wait for timeout
+ * tracker.clearExpired(); // Manual cleanup
+ * console.assert(tracker.isPending('sub-456') === false);
+ *
+ * // Multiple pending subscriptions
+ * tracker.addPending('sub-a', 1000);
+ * tracker.addPending('sub-b', 1000);
+ * tracker.addPending('sub-c', 1000);
+ * console.assert(tracker.getPendingCount() === 3);
+ * ```
+ *
+ * @since 6.6.0
+ */
+export declare class PendingSubscriptionTracker {
+    private pending;
+    /**
+     * Add a pending subscription with timeout
+     *
+     * @param id - Subscription identifier (e.g., token name)
+     * @param timeoutMs - Timeout duration in milliseconds
+     */
+    addPending(id: string, timeoutMs: number): void;
+    /**
+     * Remove a pending subscription (e.g., when it completes or is cancelled)
+     *
+     * @param id - Subscription identifier to remove
+     */
+    removePending(id: string): void;
+    /**
+     * Check if a subscription is pending
+     *
+     * @param id - Subscription identifier to check
+     * @returns True if subscription is still pending
+     */
+    isPending(id: string): boolean;
+    /**
+     * Get count of pending subscriptions
+     *
+     * @returns Number of subscriptions currently pending
+     */
+    getPendingCount(): number;
+    /**
+     * Manually clear expired pending subscriptions
+     *
+     * Normally called automatically by the timeout, but can be called
+     * explicitly for cleanup.
+     */
+    clearExpired(): void;
+    /**
+     * Clear all pending subscriptions
+     */
+    clear(): void;
+}
+/**
+ * Global and Room Callback Dispatcher
+ *
+ * Dispatches callbacks to both global and room-specific listeners in the correct order.
+ * Global callbacks execute first, then room-specific callbacks.
+ *
+ * Used in StreamWebSocketService to ensure consistent callback ordering across
+ * different event types.
+ *
+ * Features:
+ * - Global-first execution order
+ * - Isolated error handling per listener
+ * - Type-safe callback dispatch
+ * - Logging for debugging
+ *
+ * @example
+ * ```typescript
+ * // Test case: Global and room-specific callbacks
+ * interface MyEvent { tokenName: string; value: number }
+ * type MyCallback = (event: MyEvent) => void;
+ *
+ * const dispatcher = new GlobalAndRoomCallbackDispatcher<MyEvent, MyCallback>();
+ *
+ * const calls: string[] = [];
+ *
+ * // Register global callback
+ * dispatcher.registerGlobalCallback((event) => {
+ *   calls.push(`global:${event.tokenName}`);
+ * });
+ *
+ * // Register room-specific callbacks
+ * dispatcher.registerRoomCallback('token:anime', (event) => {
+ *   calls.push(`room:anime:${event.value}`);
+ * });
+ * dispatcher.registerRoomCallback('token:gala', (event) => {
+ *   calls.push(`room:gala:${event.value}`);
+ * });
+ *
+ * // Dispatch event
+ * const event: MyEvent = { tokenName: 'anime', value: 42 };
+ * dispatcher.dispatch('token:anime', event);
+ *
+ * // Global callback should execute first
+ * console.assert(calls[0] === 'global:anime');
+ * console.assert(calls[1] === 'room:anime:42');
+ *
+ * // Unrelated room callback not called
+ * console.assert(!calls.some(c => c.startsWith('room:gala')));
+ * ```
+ *
+ * @typeParam TEvent - Event type being dispatched
+ * @typeParam TCallback - Callback function type
+ * @since 6.6.0
+ */
+export declare class GlobalAndRoomCallbackDispatcher<TEvent, TCallback extends (event: TEvent) => void> {
+    private globalCallbacks;
+    private roomCallbacks;
+    private logger;
+    constructor(logger?: Logger);
+    /**
+     * Register a global callback
+     *
+     * @param callback - Function to call for all events
+     */
+    registerGlobalCallback(callback: TCallback): void;
+    /**
+     * Register a room-specific callback
+     *
+     * @param roomId - Room identifier (e.g., 'token:anime')
+     * @param callback - Function to call for events in this room
+     */
+    registerRoomCallback(roomId: string, callback: TCallback): void;
+    /**
+     * Dispatch an event to global and room-specific callbacks
+     *
+     * Calls global callbacks first, then room-specific callbacks.
+     * Errors in one callback don't prevent others from executing.
+     *
+     * @param roomId - Room identifier for this event
+     * @param event - Event data to dispatch
+     */
+    dispatch(roomId: string, event: TEvent): void;
+    /**
+     * Clear all callbacks
+     */
+    clear(): void;
+    /**
+     * Remove all callbacks for a specific room
+     *
+     * @param roomId - Room identifier
+     */
+    clearRoom(roomId: string): void;
+}
+/**
+ * Selective Event Forwarding
+ *
+ * Filters events based on multiple predicates before forwarding. Reduces message
+ * volume by eliminating noisy or unwanted events.
+ *
+ * Features:
+ * - Multiple filter predicates (AND logic)
+ * - Short-circuit evaluation (stops at first failing filter)
+ * - Chainable filter registration
+ *
+ * @example
+ * ```typescript
+ * // Test case: Event filtering pipeline
+ * interface SwapEvent { token0: string; token1: string; amount: string; user: string }
+ *
+ * const forwarder = new SelectiveEventForwarding<SwapEvent>();
+ *
+ * // Add filters
+ * forwarder.addFilter((event) => event.amount !== '0'); // Skip zero amounts
+ * forwarder.addFilter((event) => event.token0 === 'GALA'); // Only GALA swaps
+ * forwarder.addFilter((event) => !event.user.includes('bot')); // Skip bot swaps
+ *
+ * // Test filtering
+ * const allowed = { token0: 'GALA', token1: 'USDC', amount: '100', user: 'alice' };
+ * console.assert(forwarder.forward(allowed) === true);
+ *
+ * const zeroAmount = { token0: 'GALA', token1: 'USDC', amount: '0', user: 'alice' };
+ * console.assert(forwarder.forward(zeroAmount) === false);
+ *
+ * const nonGala = { token0: 'USDC', token1: 'USDT', amount: '100', user: 'alice' };
+ * console.assert(forwarder.forward(nonGala) === false);
+ *
+ * const botSwap = { token0: 'GALA', token1: 'USDC', amount: '100', user: 'bot123' };
+ * console.assert(forwarder.forward(botSwap) === false);
+ * ```
+ *
+ * @typeParam TEvent - Event type being filtered
+ * @since 6.6.0
+ */
+export declare class SelectiveEventForwarding<TEvent> {
+    private filters;
+    /**
+     * Add a filter predicate
+     *
+     * Event must pass ALL filters to be forwarded. Filters are evaluated
+     * in the order they were added (short-circuit evaluation).
+     *
+     * @param predicate - Function returning true to allow event, false to block
+     * @returns This instance for chaining
+     */
+    addFilter(predicate: (event: TEvent) => boolean): this;
+    /**
+     * Forward an event if it passes all filters
+     *
+     * @param event - Event to evaluate
+     * @returns True if event passed all filters, false otherwise
+     */
+    forward(event: TEvent): boolean;
+    /**
+     * Clear all filters
+     */
+    clearFilters(): void;
+    /**
+     * Get count of active filters
+     *
+     * @returns Number of filter predicates
+     */
+    get filterCount(): number;
+}
+/**
+ * Listener Cleanup Manager
+ *
+ * Multi-stage cleanup with error isolation per listener. Ensures cleanup
+ * of one listener doesn't block cleanup of others.
+ *
+ * Features:
+ * - Error isolation (one failure doesn't block others)
+ * - Async cleanup support (waitPromises)
+ * - Ordering (LIFO - last registered, first cleaned up)
+ * - Detailed error logging
+ *
+ * @example
+ * ```typescript
+ * // Test case: Multi-stage listener cleanup
+ * const manager = new ListenerCleanupManager();
+ * const cleaned: string[] = [];
+ *
+ * // Register listeners with cleanup functions
+ * manager.register('listener1', () => {
+ *   cleaned.push('1');
+ * });
+ * manager.register('listener2', () => {
+ *   cleaned.push('2');
+ * });
+ * manager.register('listener3', () => {
+ *   throw new Error('Cleanup failed for 3');
+ * });
+ * manager.register('listener4', () => {
+ *   cleaned.push('4');
+ * });
+ *
+ * // Cleanup all (error in listener3 doesn't block listener4)
+ * await manager.cleanup();
+ *
+ * // All listeners cleaned up despite error in listener3
+ * console.assert(cleaned.includes('1'));
+ * console.assert(cleaned.includes('2'));
+ * console.assert(cleaned.includes('4'));
+ * // Order is LIFO: 4, 3 (error), 2, 1
+ * ```
+ *
+ * @since 6.6.0
+ */
+export declare class ListenerCleanupManager {
+    private listeners;
+    private logger;
+    constructor(logger?: Logger);
+    /**
+     * Register a listener with cleanup function
+     *
+     * Cleanup functions are called in LIFO order (last registered, first cleaned up).
+     *
+     * @param id - Unique identifier for this listener
+     * @param cleanup - Sync or async cleanup function
+     */
+    register(id: string, cleanup: () => void | Promise<void>): void;
+    /**
+     * Cleanup all listeners
+     *
+     * Errors in one listener don't prevent cleanup of others.
+     * Returns array of errors encountered during cleanup.
+     *
+     * @returns Promise that resolves when all cleanup complete
+     */
+    cleanup(): Promise<Error[]>;
+    /**
+     * Clear all registered listeners without calling cleanup
+     */
+    clear(): void;
+    /**
+     * Get count of registered listeners
+     *
+     * @returns Number of listeners awaiting cleanup
+     */
+    get size(): number;
+}
+/**
+ * Event Buffer with Auto-Cleanup
+ *
+ * Buffers events with TTL (time-to-live) and max size limits. Old events are
+ * automatically expired and removed.
+ *
+ * Features:
+ * - Configurable TTL per event
+ * - Max size enforcement (FIFO eviction when full)
+ * - Automatic expiration cleanup
+ * - Memory-efficient
+ *
+ * @example
+ * ```typescript
+ * // Test case: Event buffering with TTL and size limits
+ * interface LogEvent { id: string; message: string }
+ *
+ * const buffer = new EventBufferWithAutoCleanup<LogEvent>({
+ *   maxSize: 5,
+ *   defaultTtlMs: 2000
+ * });
+ *
+ * // Add events
+ * buffer.push({ id: 'e1', message: 'Event 1' });
+ * buffer.push({ id: 'e2', message: 'Event 2' });
+ * console.assert(buffer.getAll().length === 2);
+ *
+ * // Wait for TTL expiration
+ * await new Promise(r => setTimeout(r, 2100));
+ * // Manual cleanup (normally automatic)
+ * buffer.clear(); // Or events auto-expire
+ *
+ * // Max size enforcement
+ * const buffer2 = new EventBufferWithAutoCleanup<LogEvent>({
+ *   maxSize: 3,
+ *   defaultTtlMs: 10000
+ * });
+ * buffer2.push({ id: 'a', message: 'A' });
+ * buffer2.push({ id: 'b', message: 'B' });
+ * buffer2.push({ id: 'c', message: 'C' });
+ * buffer2.push({ id: 'd', message: 'D' }); // Oldest (a) is evicted
+ * console.assert(buffer2.getAll().length === 3);
+ * console.assert(!buffer2.getAll().some(e => e.id === 'a'));
+ * ```
+ *
+ * @typeParam TEvent - Event type being buffered
+ * @since 6.6.0
+ */
+export interface EventBufferConfig {
+    maxSize?: number;
+    defaultTtlMs?: number;
+}
+export declare class EventBufferWithAutoCleanup<TEvent> {
+    private events;
+    private timeouts;
+    private readonly maxSize;
+    private readonly defaultTtlMs;
+    private readonly logger;
+    constructor(config?: EventBufferConfig, logger?: Logger);
+    /**
+     * Add an event to the buffer
+     *
+     * If buffer is full, removes oldest event (FIFO).
+     * Event will auto-expire after TTL.
+     *
+     * @param event - Event to buffer
+     */
+    push(event: TEvent): void;
+    /**
+     * Get all currently buffered events
+     *
+     * @returns Array of buffered events
+     */
+    getAll(): TEvent[];
+    /**
+     * Clear all buffered events
+     */
+    clear(): void;
+    /**
+     * Get count of buffered events
+     *
+     * @returns Number of events currently buffered
+     */
+    get size(): number;
+}
+/**
+ * Typing Indicator Debouncer
+ *
+ * Debounces typing indicator events to reduce message volume. Multiple
+ * typing events from the same user within the debounce window are collapsed
+ * into a single indicator.
+ *
+ * Features:
+ * - Per-user debouncing (independent timers for each user)
+ * - Automatic cleanup of pending indicators
+ * - Configurable debounce delay
+ * - Prevents spam of typing events
+ *
+ * @example
+ * ```typescript
+ * // Test case: Typing indicator debouncing
+ * const debouncer = new TypingIndicatorDebouncer({
+ *   delayMs: 100,
+ *   onTyping: (userId, roomId) => {
+ *     console.log(`User ${userId} is typing in ${roomId}`);
+ *   },
+ *   onStopTyping: (userId, roomId) => {
+ *     console.log(`User ${userId} stopped typing in ${roomId}`);
+ *   }
+ * });
+ *
+ * const events: string[] = [];
+ * debouncer.onTyping = (userId, roomId) => {
+ *   events.push(`typing:${userId}:${roomId}`);
+ * };
+ * debouncer.onStopTyping = (userId, roomId) => {
+ *   events.push(`stop:${userId}:${roomId}`);
+ * };
+ *
+ * // Rapid typing events from same user
+ * debouncer.indicate('user123', 'room1');
+ * debouncer.indicate('user123', 'room1');
+ * debouncer.indicate('user123', 'room1');
+ *
+ * // Only one typing event sent (debounced)
+ * console.assert(events.filter(e => e.startsWith('typing')).length === 1);
+ *
+ * // Different users send independent indicators
+ * debouncer.indicate('user456', 'room1');
+ * debouncer.indicate('user789', 'room1');
+ * console.assert(events.filter(e => e.startsWith('typing')).length === 3);
+ * ```
+ *
+ * @since 6.6.0
+ */
+export interface TypingIndicatorConfig {
+    delayMs?: number;
+    onTyping?: (userId: string, roomId: string) => void | Promise<void>;
+    onStopTyping?: (userId: string, roomId: string) => void | Promise<void>;
+}
+export declare class TypingIndicatorDebouncer {
+    private pendingIndicators;
+    private activeIndicators;
+    private readonly delayMs;
+    private readonly onTyping;
+    private readonly onStopTyping;
+    private readonly logger;
+    constructor(config?: TypingIndicatorConfig, logger?: Logger);
+    /**
+     * Indicate that a user is typing
+     *
+     * If user is already typing, the debounce window is reset.
+     * Stop indicator is sent after delayMs of inactivity.
+     *
+     * @param userId - User identifier
+     * @param roomId - Room identifier (e.g., 'token:anime')
+     */
+    indicate(userId: string, roomId: string): void;
+    /**
+     * Explicitly stop typing indicator for a user
+     *
+     * @param userId - User identifier
+     * @param roomId - Room identifier
+     */
+    stopTyping(userId: string, roomId: string): void;
+    /**
+     * Clear all pending typing indicators
+     */
+    clear(): void;
+    /**
+     * Get count of active typing indicators
+     *
+     * @returns Number of users currently typing
+     */
+    get activeCount(): number;
+}
+//# sourceMappingURL=websocket-patterns.d.ts.map

package/dist/src/utils/websocket-patterns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket-patterns.d.ts","sourceRoot":"","sources":["../../../src/utils/websocket-patterns.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,qBAAa,uBAAuB;IAClC,OAAO,CAAC,KAAK,CAA0B;IAEvC;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAI7B;;;;;;OAMG;IACH,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAIhC;;;;OAIG;IACH,QAAQ,IAAI,MAAM,EAAE;IAIpB;;;;;OAKG;IACH,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAIvC;;;;OAIG;IACH,KAAK,IAAI,IAAI;IAIb;;;;OAIG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,qBAAa,8BAA8B,CAAC,CAAC;IAC3C,OAAO,CAAC,IAAI,CAA0B;IACtC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA6B;IACvD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAuB;gBAGjD,SAAS,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,CAAC,GAAG,IAAI,EACrC,WAAW,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,EACjC,QAAQ,GAAE,MAAW;IAOvB;;;;;OAKG;IACH,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,CAAC,EAAE;IA6B3B;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb;;;;OAIG;IACH,YAAY,IAAI,MAAM;CAGvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,qBAAa,0BAA0B;IACrC,OAAO,CAAC,OAAO,CAA0E;IAEzF;;;;;OAKG;IACH,UAAU,CAAC,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI;IAc/C;;;;OAIG;IACH,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAQ/B;;;;;OAKG;IACH,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAI9B;;;;OAIG;IACH,eAAe,IAAI,MAAM;IAIzB;;;;;OAKG;IACH,YAAY,IAAI,IAAI;IAUpB;;OAEG;IACH,KAAK,IAAI,IAAI;CAMd;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,qBAAa,+BAA+B,CAAC,MAAM,EAAE,SAAS,SAAS,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI;IAC5F,OAAO,CAAC,eAAe,CAAmB;IAC1C,OAAO,CAAC,aAAa,CAAuC;IAC5D,OAAO,CAAC,MAAM,CAAqB;gBAEvB,MAAM,CAAC,EAAE,MAAM;IAI3B;;;;OAIG;IACH,sBAAsB,CAAC,QAAQ,EAAE,SAAS,GAAG,IAAI;IAIjD;;;;;OAKG;IACH,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,GAAG,IAAI;IAM/D;;;;;;;;OAQG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAuB7C;;OAEG;IACH,KAAK,IAAI,IAAI;IAKb;;;;OAIG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;CAGhC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,qBAAa,wBAAwB,CAAC,MAAM;IAC1C,OAAO,CAAC,OAAO,CAAyC;IAExD;;;;;;;;OAQG;IACH,SAAS,CAAC,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,GAAG,IAAI;IAKtD;;;;;OAKG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAS/B;;OAEG;IACH,YAAY,IAAI,IAAI;IAIpB;;;;OAIG;IACH,IAAI,WAAW,IAAI,MAAM,CAExB;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,qBAAa,sBAAsB;IACjC,OAAO,CAAC,SAAS,CAGT;IACR,OAAO,CAAC,MAAM,CAAqB;gBAEvB,MAAM,CAAC,EAAE,MAAM;IAI3B;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;IAI/D;;;;;;;OAOG;IACG,OAAO,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC;IAmBjC;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb;;;;OAIG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,MAAM,WAAW,iBAAiB;IAChC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,qBAAa,0BAA0B,CAAC,MAAM;IAC5C,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,QAAQ,CAA0C;IAC1D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IACtC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqB;gBAEhC,MAAM,GAAE,iBAAsB,EAAE,MAAM,CAAC,EAAE,MAAM;IAM3D;;;;;;;OAOG;IACH,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IA4BzB;;;;OAIG;IACH,MAAM,IAAI,MAAM,EAAE;IAIlB;;OAEG;IACH,KAAK,IAAI,IAAI;IAQb;;;;OAIG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,MAAM,WAAW,qBAAqB;IACpC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACpE,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACzE;AAED,qBAAa,wBAAwB;IACnC,OAAO,CAAC,iBAAiB,CAA0C;IACnE,OAAO,CAAC,gBAAgB,CAA0B;IAClD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAyE;IAClG,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAyE;IACtG,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqB;gBAEhC,MAAM,GAAE,qBAA0B,EAAE,MAAM,CAAC,EAAE,MAAM;IAO/D;;;;;;;;OAQG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAyB9C;;;;;OAKG;IACH,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAehD;;OAEG;IACH,KAAK,IAAI,IAAI;IAQb;;;;OAIG;IACH,IAAI,WAAW,IAAI,MAAM,CAExB;CACF"}

package/dist/src/utils/websocket-validators.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"websocket-validators.d.ts","sourceRoot":"","sources":["../../../src/utils/websocket-validators.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EACL,WAAW,EACX,YAAY,EACZ,cAAc,EACf,MAAM,+BAA+B,CAAC;AAGvC;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,WAAW,CAchE;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,YAAY,CAalE;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,cAAc,CActE;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,GAAG,IAAI,CAa1F"}
+{"version":3,"file":"websocket-validators.d.ts","sourceRoot":"","sources":["../../../src/utils/websocket-validators.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EACL,WAAW,EACX,YAAY,EACZ,cAAc,EACf,MAAM,+BAA+B,CAAC;AAIvC;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,WAAW,CAchE;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,YAAY,CAalE;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,cAAc,CActE;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,GAAG,IAAI,CAa1F"}