nodebb-plugin-ezoic-infinite 1.6.68 → 1.6.70

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodebb-plugin-ezoic-infinite",
-  "version": "1.6.68",
+  "version": "1.6.70",
   "description": "Production-ready Ezoic infinite ads integration for NodeBB 4.x",
   "main": "library.js",
   "license": "MIT",

package/public/client.js

@@ -119,6 +119,10 @@
     burstDeadline:0,
     burstCount:   0,
     lastBurstTs:  0,
+
+    // Detached wraps cache (to survive NodeBB virtual/infinite scroll recycling)
+    // kindClass -> Map(afterPos -> wrapNode)
+    detached: new Map(),
   };
 
   let blockedUntil = 0;
@@ -228,7 +232,22 @@
     try {
       if (!wrap) return;
       const iframes = wrap.querySelectorAll('iframe');
-      if (!iframes.length) return;
+
+      // If no iframe yet (or no-fill), Ezoic can still reserve a large gap via
+      // inline `min-height:400px !important` on `.ezoic-ad` elements.
+      // Inline !important beats our CSS, so we proactively shrink it.
+      if (!iframes.length) {
+        const bad = wrap.querySelectorAll('.ezoic-ad[style*="min-height"], .ezoic-ad-adaptive[style*="min-height"], span.ezoic-ad[style*="min-height"]');
+        bad.forEach(n => {
+          const s = (n.getAttribute('style') || '').toLowerCase();
+          if (s.includes('min-height:400') || s.includes('min-height: 400')) {
+            try { n.style.setProperty('min-height', '1px', 'important'); } catch (e) { n.style.minHeight = '1px'; }
+            try { n.style.setProperty('height', 'auto', 'important'); } catch (e) {}
+            try { n.style.setProperty('line-height', '0', 'important'); } catch (e) {}
+          }
+        });
+        return;
+      }
 
       // Find the nearest ezoic-ad ancestor with the 400px inline min-height.
       let ref = null;
@@ -394,6 +413,54 @@
     try { wrap.remove(); } catch (e) {}
   }
 
+  function getDetachedMap(kindClass) {
+    let m = st.detached.get(kindClass);
+    if (!m) { m = new Map(); st.detached.set(kindClass, m); }
+    return m;
+  }
+
+  function detachWrap(kindClass, wrap) {
+    // Keep a wrap node in memory so we can re-attach it later without
+    // re-requesting the same placement (avoids GPT "format already created" and
+    // prevents ads from vanishing permanently when NodeBB recycles DOM nodes).
+    try {
+      const afterPos = parseInt(wrap.getAttribute('data-ezoic-after') || '0', 10);
+      if (!afterPos) return dropWrap(wrap);
+
+      // Unobserve placeholder while detached
+      try {
+        const ph = wrap.querySelector('[id^="' + PLACEHOLDER_PREFIX + '"]');
+        if (ph) try { st.io && st.io.unobserve(ph); } catch (e) {}
+      } catch (e) {}
+
+      const m = getDetachedMap(kindClass);
+      // If a cached wrap for that position already exists, prefer the newest
+      // and fully drop the old one.
+      if (m.has(afterPos)) {
+        try { dropWrap(m.get(afterPos)); } catch (e) {}
+      }
+      m.set(afterPos, wrap);
+
+      // Hard cap cache size per kind to avoid unbounded memory growth.
+      if (m.size > 80) {
+        const oldest = [...m.entries()].sort((a, b) => {
+          const ta = parseInt((a[1] && a[1].getAttribute('data-created')) || '0', 10);
+          const tb = parseInt((b[1] && b[1].getAttribute('data-created')) || '0', 10);
+          return ta - tb;
+        }).slice(0, m.size - 80);
+        oldest.forEach(([pos, node]) => {
+          m.delete(pos);
+          try { dropWrap(node); } catch (e) {}
+        });
+      }
+
+      // Actually detach from DOM
+      try { wrap.remove(); } catch (e) {}
+    } catch (e) {
+      try { dropWrap(wrap); } catch (x) {}
+    }
+  }
+
   function pickId(poolKey, cursorKey) {
     const pool = st.pools[poolKey];
     if (!pool.length) return null;
@@ -477,11 +544,44 @@
         const w = ph.closest('.' + WRAP_CLASS);
         if (!w) return;
         if (isFilled(ph)) { w.classList.remove('is-empty'); tightenMinHeight(w); }
-        else { w.classList.add('is-empty'); watchFill(w); }
+        else {
+          w.classList.add('is-empty');
+          // Kill any large reserved gap even when there is no iframe.
+          tightenMinHeight(w);
+          watchFill(w);
+          scheduleHardPruneEmpty(id);
+        }
       } catch (e) {}
     }, 15_000);
   }
 
+  // If a placement stays empty for a long time, remove it entirely so the user
+  // doesn't get persistent blank blocks. This also frees the placeholder ID so
+  // a future injection can try a different one.
+  function scheduleHardPruneEmpty(id) {
+    setTimeout(() => {
+      try {
+        const ph = document.getElementById(PLACEHOLDER_PREFIX + id);
+        if (!ph || !ph.isConnected) return;
+        const w = ph.closest('.' + WRAP_CLASS);
+        if (!w) return;
+        // If still not filled after 45s, drop it.
+        if (!isFilled(w)) {
+          // Also ensure it isn't cached as detached.
+          try {
+            const kind = Array.from(w.classList).find(c => c.startsWith('ezoic-ad-'));
+            if (kind) {
+              const afterPos = parseInt(w.getAttribute('data-ezoic-after') || '0', 10);
+              const m = st.detached.get(kind);
+              if (m && afterPos && m.get(afterPos) === w) m.delete(afterPos);
+            }
+          } catch (e) {}
+          withInternal(() => dropWrap(w));
+        }
+      } catch (e) {}
+    }, 45_000);
+  }
+
   function startShow(id) {
     if (!id || isBlocked()) return;
     st.inflight++;
@@ -573,16 +673,38 @@
           if (itemSet.has(el)) { found = true; break; }
       }
 
-      if (!found) withInternal(() => dropWrap(wrap));
+      if (!found) {
+        // Detach instead of destroy so ads can survive DOM recycling.
+        withInternal(() => detachWrap(kindClass, wrap));
+      }
     });
   }
 
+  function reapDetached(kindClass) {
+    // Soft-prune very old detached nodes.
+    try {
+      const m = st.detached.get(kindClass);
+      if (!m || !m.size) return;
+      for (const [pos, wrap] of m.entries()) {
+        if (!wrap) { m.delete(pos); continue; }
+        if (wrap.isConnected) { m.delete(pos); continue; }
+        const created = parseInt(wrap.getAttribute('data-created') || '0', 10);
+        if (created && (now() - created) > 15 * 60 * 1000) {
+          m.delete(pos);
+          try { dropWrap(wrap); } catch (e) {}
+        }
+      }
+    } catch (e) {}
+  }
+
   function injectWraps(kindClass, items, interval, showFirst, poolKey, cursorKey) {
     if (!items.length) return 0;
     const { map, targets } = computeTargets(items, interval, showFirst);
     const max = MAX_INSERTS_PER_RUN + (isBoosted() ? 1 : 0);
     let n = 0;
 
+    const detachedMap = st.detached.get(kindClass);
+
     for (const pos of targets) {
       if (n >= max) break;
       const el = map.get(pos);
@@ -597,6 +719,27 @@
       if (isAdjacentWrap(el))          continue;
       if (findWrapAt(kindClass, pos))  continue;
 
+      // If we previously had a wrap at this exact position but NodeBB recycled
+      // the DOM, re-attach the cached wrap instead of creating a new one.
+      if (detachedMap && detachedMap.has(pos)) {
+        const cached = detachedMap.get(pos);
+        detachedMap.delete(pos);
+        if (cached) {
+          withInternal(() => el.insertAdjacentElement('afterend', cached));
+          // Re-observe placeholder and trigger show only if the cached wrap is empty.
+          try {
+            const ph = cached.querySelector('[id^="' + PLACEHOLDER_PREFIX + '"]');
+            const id = ph ? parseInt(ph.getAttribute('data-ezoic-id') || (ph.id || '').split('-').pop(), 10) : 0;
+            if (id > 0) {
+              observePh(id);
+              if (!isFilled(cached)) enqueueShow(id);
+            }
+          } catch (e) {}
+          n++;
+          continue;
+        }
+      }
+
       const id = pickId(poolKey, cursorKey);
       if (!id) break;
 
@@ -684,6 +827,7 @@
       const items = getItems('topic');
       const set   = new Set(items);
       removeOrphanWraps('ezoic-ad-message', set);
+      reapDetached('ezoic-ad-message');
       inserted += injectWraps('ezoic-ad-message', items,
         Math.max(1, parseInt(cfg.messageIntervalPosts, 10) || 3),
         normBool(cfg.showFirstMessageAd), 'post', 'post');
@@ -692,6 +836,7 @@
       const items = getItems('categoryTopics');
       const set   = new Set(items);
       removeOrphanWraps('ezoic-ad-between', set);
+      reapDetached('ezoic-ad-between');
       inserted += injectWraps('ezoic-ad-between', items,
         Math.max(1, parseInt(cfg.intervalPosts, 10) || 6),
         normBool(cfg.showFirstTopicAd), 'topic', 'topic');
@@ -701,6 +846,7 @@
       const items = getItems('categories');
       const set   = new Set(items);
       removeOrphanWraps('ezoic-ad-categories', set);
+      reapDetached('ezoic-ad-categories');
       inserted += injectWraps('ezoic-ad-categories', items,
         Math.max(1, parseInt(cfg.intervalCategories, 10) || 4),
         normBool(cfg.showFirstCategoryAd), 'category', 'category');
@@ -792,6 +938,13 @@
   function cleanup() {
     blockedUntil = now() + 1200;
     try { document.querySelectorAll('.' + WRAP_CLASS).forEach(dropWrap); } catch (e) {}
+    try {
+      for (const m of st.detached.values()) {
+        for (const w of m.values()) try { dropWrap(w); } catch (e) {}
+        m.clear();
+      }
+      st.detached.clear();
+    } catch (e) {}
     st.cfg       = null;
     st.pools     = { topic: [], post: [], category: [] };
     st.cursors   = { topic: 0,  post: 0,  category: 0 };