@signaltree/events 7.3.6 → 7.4.0

package/dist/angular/handlers.cjs

@@ -0,0 +1,38 @@
+'use strict';
+
+/**
+ * Create a simple event handler
+ *
+ * @example
+ * ```typescript
+ * const handler = createEventHandler<TradeProposalCreated>(event => {
+ *   store.$.trades.entities.upsertOne(event.data);
+ * });
+ * ```
+ */
+function createEventHandler(handler) {
+  return handler;
+}
+/**
+ * Create a typed event handler with metadata
+ *
+ * @example
+ * ```typescript
+ * const handler = createTypedHandler('TradeProposalCreated', {
+ *   handle: (event) => {
+ *     store.$.trades.entities.upsertOne(event.data);
+ *   },
+ *   priority: 1,
+ * });
+ * ```
+ */
+function createTypedHandler(eventType, options) {
+  return {
+    eventType,
+    handle: options.handle,
+    priority: options.priority ?? 10
+  };
+}
+
+exports.createEventHandler = createEventHandler;
+exports.createTypedHandler = createTypedHandler;

package/dist/angular/handlers.js

@@ -0,0 +1,35 @@
+/**
+ * Create a simple event handler
+ *
+ * @example
+ * ```typescript
+ * const handler = createEventHandler<TradeProposalCreated>(event => {
+ *   store.$.trades.entities.upsertOne(event.data);
+ * });
+ * ```
+ */
+function createEventHandler(handler) {
+  return handler;
+}
+/**
+ * Create a typed event handler with metadata
+ *
+ * @example
+ * ```typescript
+ * const handler = createTypedHandler('TradeProposalCreated', {
+ *   handle: (event) => {
+ *     store.$.trades.entities.upsertOne(event.data);
+ *   },
+ *   priority: 1,
+ * });
+ * ```
+ */
+function createTypedHandler(eventType, options) {
+  return {
+    eventType,
+    handle: options.handle,
+    priority: options.priority ?? 10
+  };
+}
+
+export { createEventHandler, createTypedHandler };

package/dist/angular/index.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var websocket_service = require('./websocket.service.cjs');
+var optimisticUpdates = require('./optimistic-updates.cjs');
+var handlers = require('./handlers.cjs');
+
+
+
+Object.defineProperty(exports, "WebSocketService", {
+	enumerable: true,
+	get: function () { return websocket_service.WebSocketService; }
+});
+exports.OptimisticUpdateManager = optimisticUpdates.OptimisticUpdateManager;
+exports.createEventHandler = handlers.createEventHandler;
+exports.createTypedHandler = handlers.createTypedHandler;

package/dist/angular/index.js

@@ -0,0 +1,3 @@
+export { WebSocketService } from './websocket.service.js';
+export { OptimisticUpdateManager } from './optimistic-updates.js';
+export { createEventHandler, createTypedHandler } from './handlers.js';

package/dist/angular/optimistic-updates.cjs

@@ -0,0 +1,161 @@
+'use strict';
+
+var core = require('@angular/core');
+
+/**
+ * Optimistic Update Manager
+ *
+ * Tracks optimistic updates and handles confirmation/rollback.
+ *
+ * @example
+ * ```typescript
+ * const manager = new OptimisticUpdateManager();
+ *
+ * // Apply optimistic update
+ * manager.apply({
+ *   id: 'update-1',
+ *   correlationId: 'corr-123',
+ *   type: 'UpdateTradeStatus',
+ *   data: { status: 'accepted' },
+ *   previousData: { status: 'pending' },
+ *   timeoutMs: 5000,
+ *   rollback: () => store.$.trade.status.set('pending'),
+ * });
+ *
+ * // When server confirms
+ * manager.confirm('corr-123');
+ *
+ * // Or when server rejects
+ * manager.rollback('corr-123', new Error('Server rejected'));
+ * ```
+ */
+class OptimisticUpdateManager {
+  _updates = core.signal(new Map());
+  timeouts = new Map();
+  /**
+   * Number of pending updates
+   */
+  pendingCount = core.computed(() => this._updates().size);
+  /**
+   * Whether there are any pending updates
+   */
+  hasPending = core.computed(() => this._updates().size > 0);
+  /**
+   * Get all pending updates
+   */
+  pending = core.computed(() => Array.from(this._updates().values()));
+  /**
+   * Apply an optimistic update
+   */
+  apply(update) {
+    // Store the update
+    this._updates.update(map => {
+      const newMap = new Map(map);
+      newMap.set(update.correlationId, update);
+      return newMap;
+    });
+    // Set timeout for automatic rollback
+    const timeout = setTimeout(() => {
+      this.rollback(update.correlationId, new Error(`Optimistic update timeout after ${update.timeoutMs}ms`));
+    }, update.timeoutMs);
+    this.timeouts.set(update.correlationId, timeout);
+  }
+  /**
+   * Confirm an optimistic update (server accepted)
+   */
+  confirm(correlationId) {
+    const update = this._updates().get(correlationId);
+    if (!update) {
+      return false;
+    }
+    // Clear timeout
+    const timeout = this.timeouts.get(correlationId);
+    if (timeout) {
+      clearTimeout(timeout);
+      this.timeouts.delete(correlationId);
+    }
+    // Remove from pending
+    this._updates.update(map => {
+      const newMap = new Map(map);
+      newMap.delete(correlationId);
+      return newMap;
+    });
+    return true;
+  }
+  /**
+   * Rollback an optimistic update (server rejected or timeout)
+   */
+  rollback(correlationId, error) {
+    const update = this._updates().get(correlationId);
+    if (!update) {
+      return false;
+    }
+    // Clear timeout
+    const timeout = this.timeouts.get(correlationId);
+    if (timeout) {
+      clearTimeout(timeout);
+      this.timeouts.delete(correlationId);
+    }
+    // Execute rollback
+    try {
+      update.rollback();
+    } catch (rollbackError) {
+      console.error('Rollback failed:', rollbackError);
+    }
+    // Remove from pending
+    this._updates.update(map => {
+      const newMap = new Map(map);
+      newMap.delete(correlationId);
+      return newMap;
+    });
+    if (error) {
+      console.warn(`Optimistic update rolled back: ${error.message}`);
+    }
+    return true;
+  }
+  /**
+   * Rollback all pending updates
+   */
+  rollbackAll(error) {
+    const updates = Array.from(this._updates().keys());
+    let count = 0;
+    for (const correlationId of updates) {
+      if (this.rollback(correlationId, error)) {
+        count++;
+      }
+    }
+    return count;
+  }
+  /**
+   * Get update by correlation ID
+   */
+  get(correlationId) {
+    return this._updates().get(correlationId);
+  }
+  /**
+   * Check if an update is pending
+   */
+  isPending(correlationId) {
+    return this._updates().has(correlationId);
+  }
+  /**
+   * Clear all updates without rollback (use with caution)
+   */
+  clear() {
+    // Clear all timeouts
+    for (const timeout of this.timeouts.values()) {
+      clearTimeout(timeout);
+    }
+    this.timeouts.clear();
+    // Clear updates
+    this._updates.set(new Map());
+  }
+  /**
+   * Dispose the manager
+   */
+  dispose() {
+    this.clear();
+  }
+}
+
+exports.OptimisticUpdateManager = OptimisticUpdateManager;

package/dist/angular/optimistic-updates.js

@@ -0,0 +1,159 @@
+import { signal, computed } from '@angular/core';
+
+/**
+ * Optimistic Update Manager
+ *
+ * Tracks optimistic updates and handles confirmation/rollback.
+ *
+ * @example
+ * ```typescript
+ * const manager = new OptimisticUpdateManager();
+ *
+ * // Apply optimistic update
+ * manager.apply({
+ *   id: 'update-1',
+ *   correlationId: 'corr-123',
+ *   type: 'UpdateTradeStatus',
+ *   data: { status: 'accepted' },
+ *   previousData: { status: 'pending' },
+ *   timeoutMs: 5000,
+ *   rollback: () => store.$.trade.status.set('pending'),
+ * });
+ *
+ * // When server confirms
+ * manager.confirm('corr-123');
+ *
+ * // Or when server rejects
+ * manager.rollback('corr-123', new Error('Server rejected'));
+ * ```
+ */
+class OptimisticUpdateManager {
+  _updates = signal(new Map());
+  timeouts = new Map();
+  /**
+   * Number of pending updates
+   */
+  pendingCount = computed(() => this._updates().size);
+  /**
+   * Whether there are any pending updates
+   */
+  hasPending = computed(() => this._updates().size > 0);
+  /**
+   * Get all pending updates
+   */
+  pending = computed(() => Array.from(this._updates().values()));
+  /**
+   * Apply an optimistic update
+   */
+  apply(update) {
+    // Store the update
+    this._updates.update(map => {
+      const newMap = new Map(map);
+      newMap.set(update.correlationId, update);
+      return newMap;
+    });
+    // Set timeout for automatic rollback
+    const timeout = setTimeout(() => {
+      this.rollback(update.correlationId, new Error(`Optimistic update timeout after ${update.timeoutMs}ms`));
+    }, update.timeoutMs);
+    this.timeouts.set(update.correlationId, timeout);
+  }
+  /**
+   * Confirm an optimistic update (server accepted)
+   */
+  confirm(correlationId) {
+    const update = this._updates().get(correlationId);
+    if (!update) {
+      return false;
+    }
+    // Clear timeout
+    const timeout = this.timeouts.get(correlationId);
+    if (timeout) {
+      clearTimeout(timeout);
+      this.timeouts.delete(correlationId);
+    }
+    // Remove from pending
+    this._updates.update(map => {
+      const newMap = new Map(map);
+      newMap.delete(correlationId);
+      return newMap;
+    });
+    return true;
+  }
+  /**
+   * Rollback an optimistic update (server rejected or timeout)
+   */
+  rollback(correlationId, error) {
+    const update = this._updates().get(correlationId);
+    if (!update) {
+      return false;
+    }
+    // Clear timeout
+    const timeout = this.timeouts.get(correlationId);
+    if (timeout) {
+      clearTimeout(timeout);
+      this.timeouts.delete(correlationId);
+    }
+    // Execute rollback
+    try {
+      update.rollback();
+    } catch (rollbackError) {
+      console.error('Rollback failed:', rollbackError);
+    }
+    // Remove from pending
+    this._updates.update(map => {
+      const newMap = new Map(map);
+      newMap.delete(correlationId);
+      return newMap;
+    });
+    if (error) {
+      console.warn(`Optimistic update rolled back: ${error.message}`);
+    }
+    return true;
+  }
+  /**
+   * Rollback all pending updates
+   */
+  rollbackAll(error) {
+    const updates = Array.from(this._updates().keys());
+    let count = 0;
+    for (const correlationId of updates) {
+      if (this.rollback(correlationId, error)) {
+        count++;
+      }
+    }
+    return count;
+  }
+  /**
+   * Get update by correlation ID
+   */
+  get(correlationId) {
+    return this._updates().get(correlationId);
+  }
+  /**
+   * Check if an update is pending
+   */
+  isPending(correlationId) {
+    return this._updates().has(correlationId);
+  }
+  /**
+   * Clear all updates without rollback (use with caution)
+   */
+  clear() {
+    // Clear all timeouts
+    for (const timeout of this.timeouts.values()) {
+      clearTimeout(timeout);
+    }
+    this.timeouts.clear();
+    // Clear updates
+    this._updates.set(new Map());
+  }
+  /**
+   * Dispose the manager
+   */
+  dispose() {
+    this.clear();
+  }
+}
+
+export { OptimisticUpdateManager };

package/{angular.cjs.js → dist/angular/websocket.service.cjs}

@@ -355,197 +355,3 @@ exports.WebSocketService = class WebSocketService {
   }
 };
 exports.WebSocketService = tslib.__decorate([core.Injectable(), tslib.__metadata("design:paramtypes", [Object])], exports.WebSocketService);
-
-/**
- * Optimistic Update Manager
- *
- * Tracks optimistic updates and handles confirmation/rollback.
- *
- * @example
- * ```typescript
- * const manager = new OptimisticUpdateManager();
- *
- * // Apply optimistic update
- * manager.apply({
- *   id: 'update-1',
- *   correlationId: 'corr-123',
- *   type: 'UpdateTradeStatus',
- *   data: { status: 'accepted' },
- *   previousData: { status: 'pending' },
- *   timeoutMs: 5000,
- *   rollback: () => store.$.trade.status.set('pending'),
- * });
- *
- * // When server confirms
- * manager.confirm('corr-123');
- *
- * // Or when server rejects
- * manager.rollback('corr-123', new Error('Server rejected'));
- * ```
- */
-class OptimisticUpdateManager {
-  _updates = core.signal(new Map());
-  timeouts = new Map();
-  /**
-   * Number of pending updates
-   */
-  pendingCount = core.computed(() => this._updates().size);
-  /**
-   * Whether there are any pending updates
-   */
-  hasPending = core.computed(() => this._updates().size > 0);
-  /**
-   * Get all pending updates
-   */
-  pending = core.computed(() => Array.from(this._updates().values()));
-  /**
-   * Apply an optimistic update
-   */
-  apply(update) {
-    // Store the update
-    this._updates.update(map => {
-      const newMap = new Map(map);
-      newMap.set(update.correlationId, update);
-      return newMap;
-    });
-    // Set timeout for automatic rollback
-    const timeout = setTimeout(() => {
-      this.rollback(update.correlationId, new Error(`Optimistic update timeout after ${update.timeoutMs}ms`));
-    }, update.timeoutMs);
-    this.timeouts.set(update.correlationId, timeout);
-  }
-  /**
-   * Confirm an optimistic update (server accepted)
-   */
-  confirm(correlationId) {
-    const update = this._updates().get(correlationId);
-    if (!update) {
-      return false;
-    }
-    // Clear timeout
-    const timeout = this.timeouts.get(correlationId);
-    if (timeout) {
-      clearTimeout(timeout);
-      this.timeouts.delete(correlationId);
-    }
-    // Remove from pending
-    this._updates.update(map => {
-      const newMap = new Map(map);
-      newMap.delete(correlationId);
-      return newMap;
-    });
-    return true;
-  }
-  /**
-   * Rollback an optimistic update (server rejected or timeout)
-   */
-  rollback(correlationId, error) {
-    const update = this._updates().get(correlationId);
-    if (!update) {
-      return false;
-    }
-    // Clear timeout
-    const timeout = this.timeouts.get(correlationId);
-    if (timeout) {
-      clearTimeout(timeout);
-      this.timeouts.delete(correlationId);
-    }
-    // Execute rollback
-    try {
-      update.rollback();
-    } catch (rollbackError) {
-      console.error('Rollback failed:', rollbackError);
-    }
-    // Remove from pending
-    this._updates.update(map => {
-      const newMap = new Map(map);
-      newMap.delete(correlationId);
-      return newMap;
-    });
-    if (error) {
-      console.warn(`Optimistic update rolled back: ${error.message}`);
-    }
-    return true;
-  }
-  /**
-   * Rollback all pending updates
-   */
-  rollbackAll(error) {
-    const updates = Array.from(this._updates().keys());
-    let count = 0;
-    for (const correlationId of updates) {
-      if (this.rollback(correlationId, error)) {
-        count++;
-      }
-    }
-    return count;
-  }
-  /**
-   * Get update by correlation ID
-   */
-  get(correlationId) {
-    return this._updates().get(correlationId);
-  }
-  /**
-   * Check if an update is pending
-   */
-  isPending(correlationId) {
-    return this._updates().has(correlationId);
-  }
-  /**
-   * Clear all updates without rollback (use with caution)
-   */
-  clear() {
-    // Clear all timeouts
-    for (const timeout of this.timeouts.values()) {
-      clearTimeout(timeout);
-    }
-    this.timeouts.clear();
-    // Clear updates
-    this._updates.set(new Map());
-  }
-  /**
-   * Dispose the manager
-   */
-  dispose() {
-    this.clear();
-  }
-}
-
-/**
- * Create a simple event handler
- *
- * @example
- * ```typescript
- * const handler = createEventHandler<TradeProposalCreated>(event => {
- *   store.$.trades.entities.upsertOne(event.data);
- * });
- * ```
- */
-function createEventHandler(handler) {
-  return handler;
-}
-/**
- * Create a typed event handler with metadata
- *
- * @example
- * ```typescript
- * const handler = createTypedHandler('TradeProposalCreated', {
- *   handle: (event) => {
- *     store.$.trades.entities.upsertOne(event.data);
- *   },
- *   priority: 1,
- * });
- * ```
- */
-function createTypedHandler(eventType, options) {
-  return {
-    eventType,
-    handle: options.handle,
-    priority: options.priority ?? 10
-  };
-}
-
-exports.OptimisticUpdateManager = OptimisticUpdateManager;
-exports.createEventHandler = createEventHandler;
-exports.createTypedHandler = createTypedHandler;