@glimt/record 0.0.74 → 0.0.76

package/dist/record.cjs

@@ -10291,45 +10291,143 @@ 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 WeakMap());
+    __publicField(this, "mutationOptions");
+    __publicField(this, "emitter", null);
     if (_ObserveManager2.instance) {
       return _ObserveManager2.instance;
     }
     _ObserveManager2.instance = this;
   }
-  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);
+  setEmitter(emitter) {
+    this.emitter = emitter;
+  }
+  setMutationOptions(options) {
+    this.mutationOptions = options;
+  }
+  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, {
+      ...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;
+    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;
+    debugLog(
+      "onShadowRootObserver: shadowRoot already observed, emitting full snapshot for shadowRoot",
+      shadowRoot2
+    );
+    this.serializeAndEmitShadowRoot(shadowRoot2);
+    return false;
   }
-  // attachObserverToDoc(doc: Document, observerMethod: (doc: Document)) {}
   // canObserveDoc(doc: Document) {
-  //   if (this.docsObservers.has(doc)) return false;
-  //   this.docsObservers.set(doc);
-  //   return true;
+  //   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);
   // }
-  // canObserveShadow(shadowRoot: ShadowRoot) {
-  //   if (this.shadowRootsObserved.has(shadowRoot)) return false;
-  //   this.shadowRootsObserved.add(shadowRoot);
-  //   return true;
+  // 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 WeakMap();
   }
 };
 __publicField(_ObserveManager, "instance");
@@ -12886,10 +12984,10 @@ class ShadowDomManager {
   }
   addShadowRoot(shadowRoot2, doc) {
     if (!isNativeShadowDom(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(
       {
         ...this.bypassOptions,
@@ -12900,8 +12998,8 @@ class ShadowDomManager {
       },
       shadowRoot2
     );
-    this.mappedRestoreHandlers[observeId] = [
-      () => observer.disconnect(),
+    this.restoreHandlers.push(() => observer.disconnect());
+    this.restoreHandlers.push(
       initScrollObserver({
         ...this.bypassOptions,
         scrollCb: this.scrollCb,
@@ -12910,14 +13008,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,
@@ -12927,18 +13025,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.
@@ -13290,6 +13376,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;
@@ -13491,13 +13600,8 @@ function record(options = {}) {
     };
     iframeManager.addLoadListener((iframeEl) => {
       try {
-        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");