@glimt/record 0.0.27 → 0.0.28

package/dist/record.js

@@ -9421,38 +9421,86 @@ class MutationBuffer {
     __publicField(this, "canvasManager");
     __publicField(this, "processedNodeManager");
     __publicField(this, "unattachedDoc");
-    __publicField(this, "tempPerfStore", {});
-    __publicField(this, "processMutations", (mutations) => {
+    __publicField(this, "stormBatches", []);
+    __publicField(this, "stormInfo");
+    __publicField(this, "stormSettings", {
+      batchSize: 300,
+      timeout: 50,
+      mutationLimit: 1500
+    });
+    __publicField(this, "handleStormMutations", (muts) => {
+      const time = Date.now();
+      if (this.stormInfo == null) {
+        console.log("detected probable mutation storm start");
+        this.stormInfo = {
+          startedAt: time,
+          totalMutations: 0,
+          timeout: setTimeout(this.handleStormFinish, this.stormSettings.timeout),
+          stormExceededLimit: false
+        };
+      }
+      this.stormInfo.totalMutations += muts.length;
+      console.log("current storm mutations", this.stormInfo.totalMutations);
+      if (this.stormInfo.totalMutations >= this.stormSettings.mutationLimit) {
+        this.stormInfo.stormExceededLimit = true;
+        this.stormBatches = [];
+      } else {
+        this.stormBatches.push({
+          ts: time,
+          mutations: muts
+        });
+      }
+      if (muts.length < this.stormSettings.batchSize) {
+        clearTimeout(this.stormInfo.timeout);
+        this.handleStormFinish();
+      }
+    });
+    __publicField(this, "handleStormFinish", () => {
+      if (!this.stormInfo) return;
+      const { stormExceededLimit } = this.stormInfo;
+      console.log(
+        "mutation storm finished",
+        "totalMutations:",
+        this.stormInfo.totalMutations,
+        "stormExceededLimit:",
+        stormExceededLimit
+      );
+      clearTimeout(this.stormInfo.timeout);
+      this.stormInfo = null;
+      if (!stormExceededLimit) {
+        let muts = [];
+        for (const batch of this.stormBatches) {
+          muts.push(...batch.mutations);
+        }
+        this.stormBatches = [];
+        this.processInternalMutations(muts, true);
+      } else {
+        this.stormBatches = [];
+        takeFullSnapshot();
+      }
+    });
+    __publicField(this, "processInternalMutations", (muts, overrideStorm = false) => {
+      if (!overrideStorm && (this.stormInfo != null || muts.length >= this.stormSettings.batchSize)) {
+        this.handleStormMutations(muts);
+        return;
+      }
       const start = performance.now();
-      let uniqueTypes = [];
-      for (const mut of mutations) {
-        const mutStart = performance.now();
+      for (const mut of muts) {
         this.processMutation(mut);
-        const took = performance.now() - mutStart;
-        if (!uniqueTypes.includes(mut.type)) uniqueTypes.push(mut.type);
-        if (!(mut.type in this.tempPerfStore)) {
-          this.tempPerfStore[mut.type] = {
-            avg: 0,
-            times: []
-          };
-        }
-        this.tempPerfStore[mut.type].times.push(took);
-        if (this.tempPerfStore[mut.type].times.length > 1e3) {
-          this.tempPerfStore[mut.type].times.shift();
-        }
-        this.tempPerfStore[mut.type].avg = this.tempPerfStore[mut.type].times.reduce((a2, b) => a2 + b, 0) / this.tempPerfStore[mut.type].times.length;
       }
       console.log(
-        mutations.length,
+        muts.length,
         "mutations processed in",
         performance.now() - start,
         "ms",
-        "types:",
-        uniqueTypes
+        "overrideStorm",
+        overrideStorm
       );
-      window.temp_perf_store = this.tempPerfStore;
       this.emit();
     });
+    __publicField(this, "processMutations", (mutations) => {
+      this.processInternalMutations(mutations);
+    });
     __publicField(this, "emit", () => {
       if (this.frozen || this.locked) {
         return;