nodebb-plugin-ezoic-infinite 1.5.89 → 1.5.90

package/package.json

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

package/public/client.js

@@ -1,14 +1,32 @@
 (function () {
   'use strict';
 
-function purgeEzoicWrapsInContainer(containerEl) {
+// ===== V5.1 multi-ads stable anchors =====
+function getStableAnchorKey(el, fallbackPos) {
   try {
-    if (!containerEl || !containerEl.querySelectorAll) return;
-    containerEl.querySelectorAll('.nodebb-ezoic-wrap').forEach(function (n) {
-      try { n.remove(); } catch (e) {}
-    });
+    if (!el) return 'pos:' + String(fallbackPos || 0);
+    var pid = el.getAttribute && (el.getAttribute('data-pid') || el.getAttribute('data-id'));
+    if (pid) return 'pid:' + String(pid);
+    var tid = el.getAttribute && (el.getAttribute('data-tid') || el.getAttribute('data-topic-id'));
+    if (tid) return 'tid:' + String(tid);
+    var topic = el.querySelector && el.querySelector('[data-tid],[data-topic-id]');
+    if (topic) {
+      var t = topic.getAttribute('data-tid') || topic.getAttribute('data-topic-id');
+      if (t) return 'tid:' + String(t);
+    }
   } catch (e) {}
+  return 'pos:' + String(fallbackPos || 0);
+}
+
+function findWrapByAnchor(kindClass, anchorKey) {
+  try {
+    var sel = '.nodebb-ezoic-wrap.' + kindClass + '[data-ezoic-anchor="' + anchorKey.replace(/"/g, '') + '"]';
+    return document.querySelector(sel);
+  } catch (e) {
+    return null;
+  }
 }
+// ===== /V5.1 =====
 
 
   // Track scroll direction to avoid aggressive recycling when the user scrolls upward.
@@ -650,6 +668,7 @@ function globalGapFixInit() {
     const wrap = document.createElement('div');
     wrap.className = `${WRAP_CLASS} ${kindClass}`;
     wrap.setAttribute('data-ezoic-after', String(afterPos));
+      try { wrap.setAttribute('data-ezoic-anchor', getStableAnchorKey(el, afterPos)); } catch (e) {}
     wrap.setAttribute('data-ezoic-wrapid', String(id));
     wrap.setAttribute('data-created', String(now()));
     // "Pinned" placements (after the first item) should remain stable.
@@ -714,12 +733,143 @@ function globalGapFixInit() {
   }
 
   function pruneOrphanWraps(kindClass, items) {
+    // Topic pages can be virtualized (posts removed from DOM as you scroll).
+    // When that happens, previously-inserted ad wraps may become "orphan" nodes with no
+    // nearby post containers, which leads to ads clustering together when scrolling back up.
+    // We prune only *true* orphans that are far offscreen to keep the UI stable.
+    if (!items || !items.length) return 0;
+    const itemSet = new Set(items);
+    const wraps = document.querySelectorAll(`.${WRAP_CLASS}.${kindClass}`);
+    let removed = 0;
+
+    const isFilled = (wrap) => {
+      return !!(wrap.querySelector('iframe, ins, img, video, [data-google-container-id]'));
+    };
+
+    const hasNearbyItem = (wrap) => {
+      // NodeBB/skins can inject separators/spacers; be tolerant.
+      let prev = wrap.previousElementSibling;
+      for (let i = 0; i < 14 && prev; i++) {
+        if (itemSet.has(prev)) return true;
+        prev = prev.previousElementSibling;
+      }
+      let next = wrap.nextElementSibling;
+      for (let i = 0; i < 14 && next; i++) {
+        if (itemSet.has(next)) return true;
+        next = next.nextElementSibling;
+      }
+      return false;
+    };
+
+    wraps.forEach((wrap) => {
+      // Never prune pinned placements.
+      try {
+        if (wrap.getAttribute('data-ezoic-pin') === '1') return;
+      } catch (e) {}
+
+      // For message/topic pages we may prune filled or empty orphans if they are far away,
+      // otherwise consecutive "stacks" can appear when posts are virtualized.
+      const isMessage = (kindClass === 'ezoic-ad-message');
+      if (!isMessage && isFilled(wrap)) return; // never prune filled ads for non-message lists
+
+      // Never prune a fresh wrap: it may fill late.
+      try {
+        const created = parseInt(wrap.getAttribute('data-created') || '0', 10);
+        if (created && (now() - created) < keepEmptyWrapMs()) return;
+      } catch (e) {}
+
+if (hasNearbyItem(wrap)) {
+  try { wrap.classList && wrap.classList.remove('ez-orphan-hidden'); wrap.style && (wrap.style.display = ''); } catch (e) {}
   return;
 }
 
-  function decluster(kindClass) {
-  return;
+// If the anchor item is no longer in the DOM (virtualized), hide the wrap so ads never "stack"
+// back-to-back while scrolling. We'll recycle it when its anchor comes back.
+try { wrap.classList && wrap.classList.add('ez-orphan-hidden'); wrap.style && (wrap.style.display = 'none'); } catch (e) {}
+
+// For message ads: only release if far offscreen to avoid perceived "vanishing" during fast scroll.
+if (isMessage) {
+  try {
+    const r = wrap.getBoundingClientRect();
+    const vh = Math.max(1, window.innerHeight || 1);
+    const farAbove = r.bottom < -vh * 2;
+    const farBelow = r.top > vh * 4;
+    if (!farAbove && !farBelow) return;
+  } catch (e) {
+  // keep original behavior in base build
 }
+}
+
+withInternalDomChange(() => releaseWrapNode(wrap));
+removed++;
+    });
+
+    return removed;
+  }
+
+  function decluster(kindClass) {
+    // Remove "near-consecutive" wraps (keep the first). Be tolerant of spacer nodes.
+    const wraps = Array.from(document.querySelectorAll(`.${WRAP_CLASS}.${kindClass}`));
+    if (wraps.length < 2) return 0;
+
+    const isWrap = (el) => !!(el && el.classList && el.classList.contains(WRAP_CLASS));
+
+    const isFilled = (wrap) => {
+      return !!(wrap && wrap.querySelector && wrap.querySelector('iframe, ins, img, video, [data-google-container-id]'));
+    };
+
+    const isFresh = (wrap) => {
+      try {
+        const created = parseInt(wrap.getAttribute('data-created') || '0', 10);
+        return created && (now() - created) < keepEmptyWrapMs();
+      } catch (e) {
+        return false;
+      }
+    };
+
+    let removed = 0;
+    for (const w of wraps) {
+      // Never decluster pinned placements.
+      try {
+        if (w.getAttribute && w.getAttribute('data-ezoic-pin') === '1') continue;
+      } catch (e) {}
+
+      let prev = w.previousElementSibling;
+      for (let i = 0; i < 3 && prev; i++) {
+        if (isWrap(prev)) {
+          // If the previous wrap is pinned, keep this one (spacing is intentional).
+          try {
+            if (prev.getAttribute && prev.getAttribute('data-ezoic-pin') === '1') break;
+          } catch (e) {}
+
+          // Never remove a wrap that is already filled; otherwise it looks like
+          // ads "disappear" while scrolling. Only remove the empty neighbour.
+          const prevFilled = isFilled(prev);
+          const curFilled = isFilled(w);
+
+          if (curFilled) {
+            // If the previous one is empty (and not fresh), drop the previous instead.
+            if (!prevFilled && !isFresh(prev)) {
+              withInternalDomChange(() => releaseWrapNode(prev));
+              removed++;
+            }
+            break;
+          }
+
+          // Current is empty.
+          // Don't decluster two "fresh" empty wraps — it can reduce fill on slow auctions.
+          // Only decluster when previous is filled, or when current is stale.
+          if (prevFilled || !isFresh(w)) {
+            withInternalDomChange(() => releaseWrapNode(w));
+            removed++;
+          }
+          break;
+        }
+        prev = prev.previousElementSibling;
+      }
+    }
+    return removed;
+  }
 
   // ---------------- show (preload / fast fill) ----------------
 
@@ -958,8 +1108,8 @@ function buildOrdinalMap(items) {
   }
 
   function injectBetween(kindClass, items, interval, showFirst, allIds, cursorKey) {
-  // V5: local stateless mode (container only)
-  purgeEzoicWrapsInContainer(containerEl);
+
+  // V5.1: stable anchor dedupe (prevents regrouping while preserving multiple ads)
 
     if (!items.length) return 0;
 
@@ -986,7 +1136,7 @@ function buildOrdinalMap(items) {
       if (!id) {
         // Only recycle while scrolling down. Recycling while scrolling up tends to
         // cause perceived instability (ads bunching/disappearing).
-        recycledWrap = null;
+        recycledWrap = scrollDir > 0 ? pickRecyclableWrap(kindClass) : null;
         if (recycledWrap) {
           id = recycledWrap.getAttribute('data-ezoic-wrapid') || '';
         }
@@ -1013,7 +1163,7 @@ function buildOrdinalMap(items) {
 }
 
   function moveWrapAfter(anchorEl, wrap, kindClass, afterPos) {
-  return;
+  // keep original behavior in base build
 }
 
   async function runCore() {