roboto-js 1.6.18 → 1.7.1

package/dist/esm/rbt_object.js

@@ -15,15 +15,27 @@ export default class RbtObject {
     } else {
       this._data = record.dataJson ? this._deepUnpackJson(record.dataJson) : {};
     }
-    if (options.websocketClient && this.id) {
+    if (options.websocketClient && this.id && options.enableRealtime) {
       this._realtime = true;
       this._ws = options.websocketClient;
       this._subscribeToRealtime(this._ws);
+    } else if (options.websocketClient && this.id) {
+      // Store websocket client for potential later use, but don't auto-subscribe
+      this._ws = options.websocketClient;
+    }
+
+    // If enableRealtime is requested but no websocketClient provided, try to initialize lazily
+    if (options.enableRealtime && this.id && !this._realtime) {
+      this._initRealtime();
     }
     this._eventHandlers = {
       change: [],
       save: []
     };
+
+    // Debounce properties for WebSocket broadcasting
+    this._broadcastDebounceTimer = null;
+    this._pendingBroadcasts = new Map(); // path -> value
   }
   get(path) {
     return _.get(this._data, path);
@@ -80,16 +92,34 @@ export default class RbtObject {
       if (!_.isEqual(currentValue, mergedValue)) {
         _.set(this._data, path, mergedValue); // Set the merged value at the deep path
         this._addChange(path);
+        // Trigger local change events for any registered handlers
+        this._trigger('change', {
+          path,
+          value: mergedValue,
+          options
+        });
       }
     } else {
       // If value is undefined and not merging, delete the key
       if (value === undefined) {
         _.unset(this._data, path);
         this._addChange(path);
+        // Trigger local change events for any registered handlers
+        this._trigger('change', {
+          path,
+          value: undefined,
+          options
+        });
       } else if (!_.isEqual(currentValue, value)) {
         _.set(this._data, path, value); // Set the value directly at the deep path
         this._addChange(path);
         this._broadcastChange(path, value);
+        // Trigger local change events for any registered handlers
+        this._trigger('change', {
+          path,
+          value,
+          options
+        });
       }
     }
   }
@@ -116,6 +146,12 @@ export default class RbtObject {
         if (!_.isEqual(currentValue, mergedValue)) {
           _.set(this._data, path, mergedValue);
           this._addChange(path);
+          // Trigger change event for this path
+          this._trigger('change', {
+            path,
+            value: mergedValue,
+            options
+          });
         }
       } else if (!_.isEqual(currentValue, newValue)) {
         _.setWith(this._data, path, newValue, (nsValue, key, nsObject, nsPath) => {
@@ -125,6 +161,12 @@ export default class RbtObject {
           return nsValue;
         });
         this._addChange(path);
+        // Trigger change event for this path
+        this._trigger('change', {
+          path,
+          value: newValue,
+          options
+        });
       }
     });
   }
@@ -301,16 +343,26 @@ export default class RbtObject {
   _initRealtime() {
     if (this._realtime || !this._axios) return;
 
-    // Lazily pull WebSocket from parent API (injected via axios instance)
-    const api = this._axios?.__rbtApiInstance;
-    if (!api || typeof api.getWebSocketClient !== 'function') return;
-    const ws = api.getWebSocketClient();
+    // Use stored websocket client if available
+    let ws = this._ws;
+
+    // Otherwise, lazily pull WebSocket from parent API (injected via axios instance)
+    if (!ws) {
+      const api = this._axios?.__rbtApiInstance;
+      if (!api || typeof api.getWebSocketClient !== 'function') return;
+      ws = api.getWebSocketClient();
+    }
     if (!ws || this._realtime) return;
     this._ws = ws;
     this._realtime = true;
     this._subscribeToRealtime(ws);
   }
   _subscribeToRealtime(ws) {
+    // Track subscription for reconnection
+    const api = this._axios?.__rbtApiInstance;
+    if (api && typeof api._trackSubscription === 'function') {
+      api._trackSubscription(this.id);
+    }
     if (ws.readyState === 1) {
       ws.send(JSON.stringify({
         type: 'subscribe',
@@ -325,31 +377,82 @@ export default class RbtObject {
       });
     }
     ws.addEventListener('message', event => {
-      const msg = JSON.parse(event.data);
-      if (msg.objectId !== this.id) return;
-      if (msg.type === 'update') {
-        _.set(this._data, msg.delta.path, msg.delta.value);
-        this._trigger('change', msg.delta);
-      } else if (msg.type === 'save') {
-        this._trigger('save', msg.revision || {});
+      try {
+        const msg = JSON.parse(event.data);
+        if (msg.objectId !== this.id) return;
+        if (msg.type === 'update') {
+          if (msg.delta && msg.delta.path !== undefined) {
+            _.set(this._data, msg.delta.path, msg.delta.value);
+
+            // Add metadata to indicate if this is state sync vs live update
+            const changeData = {
+              ...msg.delta,
+              isStateSync: msg.isStateSync || false,
+              source: msg.isStateSync ? 'state-sync' : 'realtime',
+              userId: msg.userId || msg.delta.userId || null
+            };
+            this._trigger('change', changeData);
+            if (msg.isStateSync) {
+              console.log('[RbtObject] Applied state sync:', msg.delta.path, '=', msg.delta.value);
+            }
+          } else {
+            console.warn('[RbtObject] Received update message without valid delta:', msg);
+          }
+        } else if (msg.type === 'save') {
+          this._trigger('save', msg.revision || {});
+        }
+      } catch (error) {
+        console.error('[RbtObject] Error processing WebSocket message:', error, event.data);
       }
     });
   }
-  onRealtimeChange(cb) {
+
+  // General change handler for both local and remote changes
+  onChange(cb) {
     this._eventHandlers.change.push(cb);
-    this._initRealtime(); // lazy connect
+    // Auto-initialize realtime if this object has WebSocket capability
+    if (this._ws && !this._realtime) {
+      this._initRealtime();
+    }
   }
-  onRealtimeSave(cb) {
+
+  // General save handler for both local and remote saves
+  onSave(cb) {
     this._eventHandlers.save.push(cb);
-    this._initRealtime(); // lazy connect
+    // Note: Does not initialize realtime connection
   }
   _trigger(type, data) {
+    console.log('[AgentProviderSync] _trigger called:', type, 'handlers:', this._eventHandlers[type]?.length, 'data:', data);
     for (const fn of this._eventHandlers[type] || []) {
       fn(data);
     }
   }
   _broadcastChange(path, value) {
-    if (this._realtime && this._ws && this._ws.readyState === 1) {
+    if (!this._realtime || !this._ws || this._ws.readyState !== 1) {
+      return;
+    }
+
+    // Store the pending broadcast
+    this._pendingBroadcasts.set(path, value);
+
+    // Clear existing timer if any
+    if (this._broadcastDebounceTimer) {
+      clearTimeout(this._broadcastDebounceTimer);
+    }
+
+    // Set new debounced timer
+    this._broadcastDebounceTimer = setTimeout(() => {
+      this._flushPendingBroadcasts();
+    }, 300);
+  }
+  _flushPendingBroadcasts() {
+    if (!this._realtime || !this._ws || this._ws.readyState !== 1) {
+      this._pendingBroadcasts.clear();
+      return;
+    }
+
+    // Send all pending broadcasts
+    for (const [path, value] of this._pendingBroadcasts) {
       this._ws.send(JSON.stringify({
         type: 'update',
         objectId: this.id,
@@ -359,5 +462,18 @@ export default class RbtObject {
         }
       }));
     }
+
+    // Clear pending broadcasts and timer
+    this._pendingBroadcasts.clear();
+    this._broadcastDebounceTimer = null;
+  }
+
+  // Cleanup method to clear any pending debounced broadcasts
+  _cleanup() {
+    if (this._broadcastDebounceTimer) {
+      clearTimeout(this._broadcastDebounceTimer);
+      this._broadcastDebounceTimer = null;
+    }
+    this._pendingBroadcasts.clear();
   }
 }