@glimt/record 0.0.70 → 0.0.72

package/dist/record.cjs

@@ -10281,52 +10281,6 @@ const debugLog = (...args) => {
   if (!isDebug()) return;
   console.log("[recapt:rrweb]", ...args);
 };
-const _StormSnapshotManager = class _StormSnapshotManager2 {
-  constructor() {
-    __publicField(this, "lastFullSnapshot", -1);
-    __publicField(this, "intervalBetweenSnapshots", 150);
-    __publicField(this, "debounceTimeout", null);
-    __publicField(this, "debounceTime", 10);
-    if (_StormSnapshotManager2.instance) {
-      return _StormSnapshotManager2.instance;
-    }
-    _StormSnapshotManager2.instance = this;
-  }
-  //we're debouncing here because of how mutation buffers work.
-  //multiple observers create their own mutation buffer, and
-  //each buffer will handle mutations storms, so multiple buffers
-  //will probably request a full snapshot at (basically) the same time.
-  //we want to ensure all buffers have requested a full snapshot
-  //(so we can be sure that all mutations have been made)
-  //before we actually take a full snapshot.
-  //also, we want a low debounceTime, bc if theres multiple, distinctive mutation storms,
-  //in a somewhat quick succession, we want to record activity between them
-  //not just one full snapshot after all the storms:
-  //[mutation storm] [full snapshot] [mutation storm] [full snapshot]
-  //NOT
-  //[mutation storm] [timeout] [mutation storm] [full snapshot] (in this case, we probably miss all events which fired during the timeout)
-  requestFullSnapshot() {
-    if (this.debounceTimeout) {
-      clearTimeout(this.debounceTimeout);
-    }
-    this.debounceTimeout = setTimeout(() => {
-      this.debounceTimeout = null;
-      this.takeSnapshot();
-    }, this.debounceTime);
-  }
-  takeSnapshot() {
-    if (Date.now() - this.lastFullSnapshot < this.intervalBetweenSnapshots) {
-      debugLog("StormSnapshotManager, takeSnapshot: too soon");
-      return;
-    }
-    debugLog("StormSnapshotManager, takeSnapshot: taking full snapshot");
-    takeFullSnapshot();
-    this.lastFullSnapshot = Date.now();
-  }
-};
-__publicField(_StormSnapshotManager, "instance");
-let StormSnapshotManager = _StormSnapshotManager;
-const stormSnapshotManager = new StormSnapshotManager();
 const _MutationRateLimiter = class _MutationRateLimiter2 {
   constructor() {
     __publicField(this, "mutTracker");
@@ -10337,6 +10291,9 @@ const _MutationRateLimiter = class _MutationRateLimiter2 {
     __publicField(this, "inGlobalStorm", false);
     __publicField(this, "currentStormStartedAt", -1);
     __publicField(this, "stormTimeLimit", 5e3);
+    __publicField(this, "debounceTimeout", null);
+    __publicField(this, "debounceTimeoutMs", 250);
+    __publicField(this, "handleStormFinishMethods", {});
     if (_MutationRateLimiter2.instance) {
       return _MutationRateLimiter2.instance;
     }
@@ -10361,11 +10318,19 @@ const _MutationRateLimiter = class _MutationRateLimiter2 {
     this.resetExitTracker();
     this.currentStormStartedAt = -1;
   }
-  stormStopped() {
+  stormStopped(stoppedByBuffer) {
+    if (this.debounceTimeout) clearTimeout(this.debounceTimeout);
     this.inGlobalStorm = false;
     this.reset();
+    for (const [bufId, method] of Object.entries(
+      this.handleStormFinishMethods
+    )) {
+      if (bufId === stoppedByBuffer) continue;
+      method();
+    }
+    this.handleStormFinishMethods = {};
   }
-  handleStormExit(muts) {
+  handleStormExit(muts, bufId) {
     const now = Date.now();
     if (this.exitMutTracker.requested === -1) {
       this.exitMutTracker = {
@@ -10392,26 +10357,40 @@ const _MutationRateLimiter = class _MutationRateLimiter2 {
             mutTracker: this.mutTracker,
             exitMutTracker: this.exitMutTracker
           });
-          this.stormStopped();
+          this.stormStopped(bufId);
           return false;
         }
       }
     }
     return true;
   }
-  isStorming(muts) {
+  isInGlobalStorm() {
+    return this.inGlobalStorm;
+  }
+  doDebounce() {
+    if (this.debounceTimeout) clearTimeout(this.debounceTimeout);
+    if (!this.inGlobalStorm) return;
+    this.debounceTimeout = setTimeout(() => {
+      this.debounceTimeout = null;
+      this.stormStopped();
+    }, this.debounceTimeoutMs);
+  }
+  isStorming(muts, buffer) {
+    if (!(buffer.bufId in this.handleStormFinishMethods)) {
+      this.handleStormFinishMethods[buffer.bufId] = buffer.handleStormFinish.bind(buffer);
+    }
     const now = Date.now();
     if (this.inGlobalStorm) {
+      this.doDebounce();
       if (now - this.currentStormStartedAt > this.stormTimeLimit) {
         debugLog(
           `MutationRateLimiter, storm time limit reached, stopping storm`
         );
-        this.stormStopped();
+        this.stormStopped(buffer.bufId);
         return false;
       }
-      if (now - this.mutTracker.ts > this.interval) {
-        return this.handleStormExit(muts);
-      }
+      if (now - this.mutTracker.ts > this.interval)
+        return this.handleStormExit(muts, buffer.bufId);
       this.mutTracker.muts += muts;
       this.mutTracker.ts = now;
       return true;
@@ -10425,6 +10404,7 @@ const _MutationRateLimiter = class _MutationRateLimiter2 {
           this.inGlobalStorm = true;
           debugLog(`MutationRateLimiter, detected global rolling storm`);
           this.currentStormStartedAt = now;
+          this.doDebounce();
           return true;
         }
       }
@@ -10436,6 +10416,52 @@ const _MutationRateLimiter = class _MutationRateLimiter2 {
 __publicField(_MutationRateLimiter, "instance");
 let MutationRateLimiter = _MutationRateLimiter;
 const mutationRateLimiter = new MutationRateLimiter();
+const _StormSnapshotManager = class _StormSnapshotManager2 {
+  constructor() {
+    __publicField(this, "lastFullSnapshot", -1);
+    __publicField(this, "intervalBetweenSnapshots", 150);
+    __publicField(this, "debounceTimeout", null);
+    __publicField(this, "debounceTime", 10);
+    if (_StormSnapshotManager2.instance) {
+      return _StormSnapshotManager2.instance;
+    }
+    _StormSnapshotManager2.instance = this;
+  }
+  //we're debouncing here because of how mutation buffers work.
+  //multiple observers create their own mutation buffer, and
+  //each buffer will handle mutations storms, so multiple buffers
+  //will probably request a full snapshot at (basically) the same time.
+  //we want to ensure all buffers have requested a full snapshot
+  //(so we can be sure that all mutations have been made)
+  //before we actually take a full snapshot.
+  //also, we want a low debounceTime, bc if theres multiple, distinctive mutation storms,
+  //in a somewhat quick succession, we want to record activity between them
+  //not just one full snapshot after all the storms:
+  //[mutation storm] [full snapshot] [mutation storm] [full snapshot]
+  //NOT
+  //[mutation storm] [timeout] [mutation storm] [full snapshot] (in this case, we probably miss all events which fired during the timeout)
+  requestFullSnapshot() {
+    if (this.debounceTimeout) {
+      clearTimeout(this.debounceTimeout);
+    }
+    this.debounceTimeout = setTimeout(() => {
+      this.debounceTimeout = null;
+      this.takeSnapshot();
+    }, this.debounceTime);
+  }
+  takeSnapshot() {
+    if (Date.now() - this.lastFullSnapshot < this.intervalBetweenSnapshots) {
+      debugLog("StormSnapshotManager, takeSnapshot: too soon");
+      return;
+    }
+    debugLog("StormSnapshotManager, takeSnapshot: taking full snapshot");
+    takeFullSnapshot();
+    this.lastFullSnapshot = Date.now();
+  }
+};
+__publicField(_StormSnapshotManager, "instance");
+let StormSnapshotManager = _StormSnapshotManager;
+const stormSnapshotManager = new StormSnapshotManager();
 function isNodeInLinkedList(n2) {
   return "__ln" in n2;
 }
@@ -10561,17 +10587,25 @@ class MutationBuffer {
     __publicField(this, "canvasManager");
     __publicField(this, "processedNodeManager");
     __publicField(this, "unattachedDoc");
-    __publicField(this, "bufId", isDebug() ? makeid() : "");
+    __publicField(this, "bufId", makeid());
     __publicField(this, "stormBatches", []);
     __publicField(this, "stormInfo", null);
     __publicField(this, "stormSettings", {
       batchSize: 50,
       //was 300
-      timeout: 30,
+      timeout: 50,
       //was 50
       mutationLimit: 800
       //was 1500
     });
+    __publicField(this, "debounceStormFinish", () => {
+      if (!this.stormInfo) return;
+      if (mutationRateLimiter.isInGlobalStorm()) return;
+      this.stormInfo.timeout = setTimeout(
+        this.handleStormFinish,
+        this.stormSettings.timeout
+      );
+    });
     __publicField(this, "handleStormMutations", (muts, canFinishStorm = true) => {
       const time = Date.now();
       if (this.stormInfo == null) {
@@ -10583,9 +10617,9 @@ class MutationBuffer {
         this.stormInfo = {
           startedAt: time,
           totalMutations: 0,
-          timeout: setTimeout(this.handleStormFinish, this.stormSettings.timeout),
           stormExceededLimit: false
         };
+        if (canFinishStorm) this.debounceStormFinish();
       }
       this.stormInfo.totalMutations += muts.length;
       if (this.stormInfo.totalMutations >= this.stormSettings.mutationLimit) {
@@ -10601,10 +10635,7 @@ class MutationBuffer {
       if (canFinishStorm && muts.length < this.stormSettings.batchSize) {
         this.handleStormFinish();
       } else {
-        this.stormInfo.timeout = setTimeout(
-          this.handleStormFinish,
-          this.stormSettings.timeout
-        );
+        this.debounceStormFinish();
       }
     });
     __publicField(this, "handleStormFinish", () => {
@@ -10638,7 +10669,7 @@ class MutationBuffer {
     });
     __publicField(this, "processInternalMutations", (muts, overrideStorm = false) => {
       if (!overrideStorm) {
-        const isStorming = mutationRateLimiter.isStorming(muts.length);
+        const isStorming = mutationRateLimiter.isStorming(muts.length, this);
         if (isStorming) {
           this.handleStormMutations(muts, false);
           return;