@glimt/record 0.0.75 → 0.0.77

package/dist/record.umd.cjs

@@ -10333,40 +10333,144 @@ class IframeManager {
 }
 const _ObserveManager = class _ObserveManager2 {
   constructor() {
-    __publicField(this, "docsObservers", /* @__PURE__ */ new WeakMap());
-    __publicField(this, "shadowRootsObserved", /* @__PURE__ */ new WeakMap());
+    __publicField(this, "docsObservers", /* @__PURE__ */ new WeakSet());
+    __publicField(this, "shadowRootsObservers", /* @__PURE__ */ new WeakSet());
+    __publicField(this, "mutationOptions");
+    __publicField(this, "emitter", null);
     if (_ObserveManager2.instance) {
       return _ObserveManager2.instance;
     }
     _ObserveManager2.instance = this;
   }
-  canObserveDoc(doc) {
-    return !this.docsObservers.has(doc);
+  setEmitter(emitter) {
+    this.emitter = emitter;
   }
-  canObserveShadowRoot(shadowRoot2) {
-    return !this.shadowRootsObserved.has(shadowRoot2);
+  setMutationOptions(options) {
+    this.mutationOptions = options;
   }
-  observerAttached(doc, onCleanup) {
-    debugLog("[doc] attaching observer to doc", doc);
-    if (this.docsObservers.has(doc)) {
-      debugLog("[doc] detected existing observer, cleaning up old observer");
-      const cleanupFn = this.docsObservers.get(doc);
-      cleanupFn == null ? void 0 : cleanupFn();
-    }
-    this.docsObservers.set(doc, onCleanup);
+  get usable() {
+    const result2 = this.emitter != null;
+    if (!result2) debugLog("observerManager: emitter is null");
+    return result2;
   }
-  observerAttachedToShadow(shadowRoot2, onCleanup) {
-    debugLog("[shadow] attaching observer to shadowRoot", shadowRoot2);
-    if (this.shadowRootsObserved.has(shadowRoot2)) {
-      debugLog("[shadow] detected existing observer, cleaning up old observer");
-      const cleanupFn = this.shadowRootsObserved.get(shadowRoot2);
-      cleanupFn == null ? void 0 : cleanupFn();
+  serializeDoc(doc) {
+    var _a2, _b2, _c;
+    if (!((_a2 = this.mutationOptions) == null ? void 0 : _a2.mirror)) return null;
+    const serialized = serializeNodeWithId(doc, __spreadProps(__spreadValues({}, this.mutationOptions), {
+      doc,
+      skipChild: false,
+      maskTextFn: (_b2 = this.mutationOptions) == null ? void 0 : _b2.maskTextFn,
+      maskInputFn: (_c = this.mutationOptions) == null ? void 0 : _c.maskInputFn
+    }));
+    if (!serialized) {
+      debugLog("snapshotDoc: no serialized node");
+      return null;
     }
-    this.shadowRootsObserved.set(shadowRoot2, onCleanup);
+    return serialized;
+  }
+  emitDoc(serialized) {
+    if (!this.emitter || !serialized) return;
+    this.emitter({
+      type: EventType.FullSnapshot,
+      data: {
+        node: serialized,
+        initialOffset: {
+          left: 0,
+          top: 0
+        }
+      }
+    });
+  }
+  emitShadowRoot(serialized, shadowRoot2) {
+    var _a2;
+    if (!this.emitter || !serialized || !((_a2 = this.mutationOptions) == null ? void 0 : _a2.mirror)) return;
+    const hostId = this.mutationOptions.mirror.getId(shadowRoot2.host);
+    const shadowId = this.mutationOptions.mirror.getId(shadowRoot2);
+    this.emitter({
+      type: EventType.IncrementalSnapshot,
+      data: {
+        source: IncrementalSource.Mutation,
+        adds: [
+          {
+            parentId: hostId,
+            nextId: null,
+            node: serialized
+          }
+        ],
+        removes: [
+          {
+            id: shadowId,
+            parentId: hostId
+          }
+        ],
+        attributes: [],
+        texts: []
+      }
+    });
+  }
+  serializeAndEmitDoc(doc) {
+    const serialized = this.serializeDoc(doc);
+    this.emitDoc(serialized);
+  }
+  serializeAndEmitShadowRoot(shadowRoot2) {
+    const serialized = this.serializeDoc(shadowRoot2.ownerDocument);
+    this.emitShadowRoot(serialized, shadowRoot2);
+  }
+  onDocObserver(doc) {
+    if (!this.usable) return false;
+    if (!this.docsObservers.has(doc)) return true;
+    this.docsObservers.add(doc);
+    debugLog(
+      "onDocObserver: doc already observed, emitting full snapshot for doc",
+      doc
+    );
+    this.serializeAndEmitDoc(doc);
+    return false;
   }
+  onShadowRootObserver(shadowRoot2) {
+    if (!this.usable) return false;
+    if (!this.shadowRootsObservers.has(shadowRoot2)) return true;
+    this.shadowRootsObservers.add(shadowRoot2);
+    debugLog(
+      "onShadowRootObserver: shadowRoot already observed, emitting full snapshot for shadowRoot",
+      shadowRoot2
+    );
+    this.serializeAndEmitShadowRoot(shadowRoot2);
+    return false;
+  }
+  // canObserveDoc(doc: Document) {
+  //   if (!this.usable) return false;
+  //   const hasObserver = this.docsObservers.has(doc);
+  //   if (!hasObserver) return true;
+  //   return false;
+  // }
+  // canObserveShadowRoot(shadowRoot: ShadowRoot) {
+  //   if (!this.usable) return false;
+  //   return !this.shadowRootsObserved.has(shadowRoot);
+  // }
+  // observerAttached(doc: Document, onCleanup: VoidFunction) {
+  //   if (!this.usable) return;
+  //   debugLog('[doc] attaching observer to doc', doc);
+  //   if (this.docsObservers.has(doc)) {
+  //     debugLog('[doc] detected existing observer, cleaning up old observer');
+  //     const cleanupFn = this.docsObservers.get(doc);
+  //     cleanupFn?.();
+  //   }
+  //   this.docsObservers.set(doc, onCleanup);
+  // }
+  // observerAttachedToShadow(shadowRoot: ShadowRoot, onCleanup: VoidFunction) {
+  //   if (!this.usable) return;
+  //   debugLog('[shadow] attaching observer to shadowRoot', shadowRoot);
+  //   if (this.shadowRootsObserved.has(shadowRoot)) {
+  //     debugLog('[shadow] detected existing observer, cleaning up old observer');
+  //     const cleanupFn = this.shadowRootsObserved.get(shadowRoot);
+  //     cleanupFn?.();
+  //   }
+  //   this.shadowRootsObserved.set(shadowRoot, onCleanup);
+  // }
   destroy() {
-    this.docsObservers = /* @__PURE__ */ new WeakMap();
-    this.shadowRootsObserved = /* @__PURE__ */ new WeakMap();
+    this.docsObservers = /* @__PURE__ */ new WeakSet();
+    this.shadowRootsObservers = /* @__PURE__ */ new WeakSet();
   }
 };
 __publicField(_ObserveManager, "instance");
@@ -12921,11 +13025,10 @@ class ShadowDomManager {
   }
   addShadowRoot(shadowRoot2, doc) {
     if (!isNativeShadowDom(shadowRoot2)) return;
-    if (!observeManager.canObserveShadowRoot(shadowRoot2)) return;
+    if (!observeManager.onShadowRootObserver(shadowRoot2)) return;
     if (this.shadowDoms.has(shadowRoot2)) return;
     this.shadowDoms.add(shadowRoot2);
     debugLog(`Adding mutation observer for shadowRoot ${shadowRoot2.host}`);
-    const observeId = makeid();
     const observer = initMutationObserver(
       __spreadProps(__spreadValues({}, this.bypassOptions), {
         doc,
@@ -12935,8 +13038,8 @@ class ShadowDomManager {
       }),
       shadowRoot2
     );
-    this.mappedRestoreHandlers[observeId] = [
-      () => observer.disconnect(),
+    this.restoreHandlers.push(() => observer.disconnect());
+    this.restoreHandlers.push(
       initScrollObserver(__spreadProps(__spreadValues({}, this.bypassOptions), {
         scrollCb: this.scrollCb,
         // https://gist.github.com/praveenpuglia/0832da687ed5a5d7a0907046c9ef1813
@@ -12944,14 +13047,14 @@ class ShadowDomManager {
         doc: shadowRoot2,
         mirror: this.mirror
       }))
-    ];
+    );
     setTimeout(() => {
       if (shadowRoot2.adoptedStyleSheets && shadowRoot2.adoptedStyleSheets.length > 0)
         this.bypassOptions.stylesheetManager.adoptStyleSheets(
           shadowRoot2.adoptedStyleSheets,
           this.mirror.getId(index$1.host(shadowRoot2))
         );
-      this.mappedRestoreHandlers[observeId].push(
+      this.restoreHandlers.push(
         initAdoptedStyleSheetObserver(
           {
             mirror: this.mirror,
@@ -12961,18 +13064,6 @@ class ShadowDomManager {
         )
       );
     }, 0);
-    observeManager.observerAttachedToShadow(shadowRoot2, () => {
-      const handlers = this.mappedRestoreHandlers[observeId];
-      if (handlers) {
-        for (const handler of handlers) {
-          try {
-            handler();
-          } catch (e2) {
-          }
-        }
-      }
-      delete this.mappedRestoreHandlers[observeId];
-    });
   }
   /**
    * Monkey patch 'attachShadow' of an IFrameElement to observe newly added shadow doms.
@@ -13320,6 +13411,29 @@ function record(options = {}) {
     },
     mirror
   });
+  observeManager.setEmitter(wrappedEmit);
+  observeManager.setMutationOptions({
+    blockClass,
+    blockSelector,
+    maskTextClass,
+    maskTextSelector,
+    inlineStylesheet,
+    maskInputOptions,
+    maskTextFn,
+    maskInputFn,
+    slimDOMOptions,
+    dataURLOptions,
+    canvasManager,
+    stylesheetManager,
+    shadowDomManager,
+    recordCanvas,
+    inlineImages,
+    mirror,
+    iframeManager,
+    keepIframeSrcFn,
+    mutationCb: wrappedMutationEmit,
+    processedNodeManager
+  });
   takeFullSnapshot$1 = (isCheckout = false) => {
     if (!recordDOM) {
       return;
@@ -13512,14 +13626,8 @@ function record(options = {}) {
     };
     iframeManager.addLoadListener((iframeEl) => {
       try {
-        if (!observeManager.canObserveDoc(iframeEl.contentDocument)) return;
-        const stopObserve = observe(iframeEl.contentDocument);
-        const id = makeid();
-        registeredHandlers[id] = stopObserve;
-        observeManager.observerAttached(iframeEl.contentDocument, () => {
-          stopObserve();
-          delete registeredHandlers[id];
-        });
+        if (!observeManager.onDocObserver(iframeEl.contentDocument)) return;
+        handlers.push(observe(iframeEl.contentDocument));
       } catch (error) {
         if (isDebug()) {
           console.warn("internal error");