@glimt/record 0.0.26 → 0.0.28

package/dist/record.cjs

@@ -367,8 +367,6 @@ const COPY_CANVAS_ON_VOLUME_GREATER_THAN = 25e4;
 function getReadableCanvasContext(canvas, cachedContext) {
   if (canvas.width * canvas.height < COPY_CANVAS_ON_VOLUME_GREATER_THAN)
     return cachedContext ?? canvas.getContext("2d");
-  console.log("cloning canvas for is2DCanvasBlank");
-  const start = performance.now();
   const offscreen = document.createElement("canvas");
   offscreen.width = canvas.width;
   offscreen.height = canvas.height;
@@ -376,11 +374,6 @@ function getReadableCanvasContext(canvas, cachedContext) {
   if (ctx) {
     ctx.drawImage(canvas, 0, 0);
   }
-  console.log(
-    "cloned canvas for is2DCanvasBlank took",
-    performance.now() - start,
-    "ms"
-  );
   return offscreen.getContext("2d", { willReadFrequently: true });
 }
 function is2DCanvasBlank(canvas, cachedContext) {
@@ -905,6 +898,13 @@ function getRootId(doc, mirror2) {
   const docId = mirror2.getId(doc);
   return docId === 1 ? void 0 : docId;
 }
+const runIdleCallback = (cb) => {
+  if ("requestIdleCallback" in window) {
+    window.requestIdleCallback(cb);
+  } else {
+    setTimeout(cb, 100);
+  }
+};
 function serializeTextNode(n2, options) {
   const { needsMask, maskTextFn, rootId, cssCaptured } = options;
   const parent = index$1.parentNode(n2);
@@ -1026,7 +1026,7 @@ function serializeElementNode(n2, options) {
         dataURLOptions.quality
       );
       attributes.rr_dataURL = canvasDataURL;
-      requestIdleCallback(() => {
+      runIdleCallback(() => {
         try {
           const blankCanvas = doc.createElement("canvas");
           blankCanvas.width = n2.width;
@@ -1036,13 +1036,9 @@ function serializeElementNode(n2, options) {
             dataURLOptions.quality
           );
           if (canvasDataURL === blankCanvasDataURL) {
-            console.log(
-              "deleting dataURL because it's the same as blank canvas"
-            );
             delete attributes.rr_dataURL;
           }
         } catch (e2) {
-          console.log("did get context canvas error", e2);
         }
       });
     }
@@ -9427,38 +9423,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;
@@ -9851,25 +9895,30 @@ class MutationBuffer {
           for (let i2 = 0; i2 < m.addedNodes.length; i2++) {
             this.genAdds(m.addedNodes[i2], m.target);
           }
+          const parentId = isShadowRoot(m.target) ? this.mirror.getId(index.host(m.target)) : this.mirror.getId(m.target);
+          if (isBlocked(m.target, this.blockClass, this.blockSelector, false))
+            return;
+          const addedSetHas = this.addedSet.has(m.target);
+          const ancestorRemoved = isAncestorRemoved(m.target, this.mirror);
+          const isShadow = isShadowRoot(m.target) && isNativeShadowDom(m.target) ? true : void 0;
           for (let i2 = 0; i2 < m.removedNodes.length; i2++) {
             const n2 = m.removedNodes[i2];
             const nodeId = this.mirror.getId(n2);
-            const parentId = isShadowRoot(m.target) ? this.mirror.getId(index.host(m.target)) : this.mirror.getId(m.target);
-            if (isBlocked(m.target, this.blockClass, this.blockSelector, false) || isIgnored(n2, this.mirror, this.slimDOMOptions) || !isSerialized(n2, this.mirror)) {
+            if (isIgnored(n2, this.mirror, this.slimDOMOptions) || !isSerialized(n2, this.mirror)) {
               return;
             }
             if (this.addedSet.has(n2)) {
               deepDelete(this.addedSet, n2);
               this.droppedSet.add(n2);
-            } else if (this.addedSet.has(m.target) && nodeId === -1) ;
-            else if (isAncestorRemoved(m.target, this.mirror)) ;
+            } else if (addedSetHas && nodeId === -1) ;
+            else if (ancestorRemoved) ;
             else if (this.movedSet.has(n2) && this.movedMap[moveKey(nodeId, parentId)]) {
               deepDelete(this.movedSet, n2);
             } else {
               this.removes.push({
                 parentId,
                 id: nodeId,
-                isShadow: isShadowRoot(m.target) && isNativeShadowDom(m.target) ? true : void 0
+                isShadow
               });
               processRemoves(n2, this.removesSubTreeCache);
             }