nodebb-plugin-ezoic-infinite 1.6.61 → 1.6.63

package/package.json

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

package/public/client.js

@@ -467,17 +467,31 @@
   // ─── Orphan / cluster management ────────────────────────────────────────────
   function pruneOrphanWraps(kindClass, items) {
     if (!items || !items.length) return 0;
-    const itemSet  = new Set(items);
+    const itemSet   = new Set(items);
     const isMessage = kindClass === 'ezoic-ad-message';
+    // Between-ads and category-ads are NEVER fully released — only hidden/shown.
+    // Releasing them frees their placeholder IDs back into the pool. When the
+    // anchor topics return (scroll-up / NodeBB re-render), injectBetween would
+    // re-insert those IDs, but DOM ordinals have shifted → all wraps pile at top.
+    // Keeping the wrap node in DOM at its original position means findWrap() will
+    // always find it and injectBetween() will never create a duplicate.
+    const allowRelease = isMessage;
     let removed = 0;
 
     const hasNearbyItem = (wrap) => {
-      let prev = wrap.previousElementSibling;
+      // If the wrap is inside a li.nodebb-ezoic-host, we must check the HOST's
+      // siblings, not the wrap's own siblings (the wrap has no siblings inside host).
+      const pivot = (wrap.parentElement && wrap.parentElement.classList &&
+                     wrap.parentElement.classList.contains(HOST_CLASS))
+        ? wrap.parentElement
+        : wrap;
+
+      let prev = pivot.previousElementSibling;
       for (let i = 0; i < 14 && prev; i++) {
         if (itemSet.has(prev)) return true;
         prev = prev.previousElementSibling;
       }
-      let next = wrap.nextElementSibling;
+      let next = pivot.nextElementSibling;
       for (let i = 0; i < 14 && next; i++) {
         if (itemSet.has(next)) return true;
         next = next.nextElementSibling;
@@ -494,6 +508,7 @@
       if (created && (now() - created) < keepEmptyWrapMs()) return;
 
       if (hasNearbyItem(wrap)) {
+        // Anchor back in DOM → restore visibility.
         try { wrap.classList.remove('ez-orphan-hidden'); wrap.style.display = ''; } catch (e) {}
         return;
       }
@@ -501,17 +516,15 @@
       // Anchor is gone (virtualized) → hide so ads don't stack visually.
       try { wrap.classList.add('ez-orphan-hidden'); wrap.style.display = 'none'; } catch (e) {}
 
-      // Only fully release when far off-screen (avoids perceived "vanishing").
-      // FIX: between-ads are now also subject to this offscreen check, not
-      // just message-ads. Previously, filled between-ad wraps were NEVER pruned,
-      // causing orphaned filled wraps to drift near the top of the list.
+      // For between/category ads: stop here — never release the node.
+      // The wrap stays in DOM (hidden) at its correct data-ezoic-after position.
+      if (!allowRelease) return;
+
+      // For message-ads only: fully release when far off-screen.
       try {
-        const r   = wrap.getBoundingClientRect();
-        const vh  = Math.max(1, window.innerHeight || 1);
-        const near = isMessage
-          ? (r.bottom > -vh * 2 && r.top < vh * 4)
-          : (r.bottom > -vh * 3 && r.top < vh * 5);
-        if (near) return;
+        const r  = wrap.getBoundingClientRect();
+        const vh = Math.max(1, window.innerHeight || 1);
+        if (r.bottom > -vh * 2 && r.top < vh * 4) return; // still near viewport
       } catch (e) { return; }
 
       withInternalDomChange(() => releaseWrapNode(wrap));
@@ -523,6 +536,13 @@
   function decluster(kindClass) {
     const wraps = Array.from(document.querySelectorAll('.' + WRAP_CLASS + '.' + kindClass));
     if (wraps.length < 2) return 0;
+    // Between/category ads: hide the duplicate rather than releasing it.
+    // Releasing frees IDs into the pool → re-injection at wrong positions on scroll-up.
+    const allowRelease = kindClass === 'ezoic-ad-message';
+    const evict = (n) => {
+      if (allowRelease) { withInternalDomChange(() => releaseWrapNode(n)); }
+      else { try { n.classList.add('ez-orphan-hidden'); n.style.display = 'none'; } catch (e) {} }
+    };
     const isWrap  = (el) => !!(el && el.classList && el.classList.contains(WRAP_CLASS));
     const isFresh = (w)  => {
       const c = parseInt(w.getAttribute('data-created') || '0', 10);
@@ -531,17 +551,19 @@
     let removed = 0;
     for (const w of wraps) {
       if (w.getAttribute && w.getAttribute('data-ezoic-pin') === '1') continue;
+      if (w.classList && w.classList.contains('ez-orphan-hidden')) continue;
       let prev = w.previousElementSibling;
       for (let i = 0; i < 3 && prev; i++) {
         if (isWrap(prev)) {
           if (prev.getAttribute && prev.getAttribute('data-ezoic-pin') === '1') break;
+          if (prev.classList && prev.classList.contains('ez-orphan-hidden')) break;
           const prevFilled = isFilled(prev);
           const curFilled  = isFilled(w);
           if (curFilled) {
-            if (!prevFilled && !isFresh(prev)) { withInternalDomChange(() => releaseWrapNode(prev)); removed++; }
+            if (!prevFilled && !isFresh(prev)) { evict(prev); removed++; }
             break;
           }
-          if (prevFilled || !isFresh(w)) { withInternalDomChange(() => releaseWrapNode(w)); removed++; }
+          if (prevFilled || !isFresh(w)) { evict(w); removed++; }
           break;
         }
         prev = prev.previousElementSibling;
@@ -913,7 +935,8 @@
       if (!id) {
         // Pool exhausted: try to recycle a wrap that is far above the viewport.
         // Recycling is disabled when scrolling up and for message ads.
-        const allowRecycle = kindClass !== 'ezoic-ad-message' && scrollDir > 0;
+        // Recycling is disabled for between/category ads (we never release those wraps).
+        const allowRecycle = kindClass === 'ezoic-ad-message' && scrollDir > 0;
         recycledWrap = allowRecycle ? pickRecyclableWrap(kindClass) : null;
         if (recycledWrap) id = recycledWrap.getAttribute('data-ezoic-wrapid') || '';
       }
@@ -942,30 +965,43 @@
     const kind = getKind();
     let inserted = 0;
 
+    // When the user is scrolling UP, NodeBB loads content above the viewport.
+    // Injecting new ad wraps at that moment targets those freshly-loaded top items
+    // (low ordinals) and makes ads appear right at the top of the list.
+    // While scrolling up we only restore previously-hidden wraps (pruneOrphanWraps
+    // un-hides them as their anchor posts return) — no new injections.
+    const canInject = scrollDir >= 0;
+
     if (kind === 'topic' && normalizeBool(cfg.enableMessageAds)) {
       const items = getPostContainers();
       pruneOrphanWraps('ezoic-ad-message', items);
-      inserted += injectBetween('ezoic-ad-message', items,
-        Math.max(1, parseInt(cfg.messageIntervalPosts, 10) || 3),
-        normalizeBool(cfg.showFirstMessageAd), state.allPosts, 'curPosts');
-      decluster('ezoic-ad-message');
+      if (canInject) {
+        inserted += injectBetween('ezoic-ad-message', items,
+          Math.max(1, parseInt(cfg.messageIntervalPosts, 10) || 3),
+          normalizeBool(cfg.showFirstMessageAd), state.allPosts, 'curPosts');
+        decluster('ezoic-ad-message');
+      }
 
     } else if (kind === 'categoryTopics' && normalizeBool(cfg.enableBetweenAds)) {
       const items = getTopicItems();
       pruneOrphanWraps('ezoic-ad-between', items);
-      inserted += injectBetween('ezoic-ad-between', items,
-        Math.max(1, parseInt(cfg.intervalPosts, 10) || 6),
-        normalizeBool(cfg.showFirstTopicAd), state.allTopics, 'curTopics');
-      decluster('ezoic-ad-between');
-      schedulePileFix();
+      if (canInject) {
+        inserted += injectBetween('ezoic-ad-between', items,
+          Math.max(1, parseInt(cfg.intervalPosts, 10) || 6),
+          normalizeBool(cfg.showFirstTopicAd), state.allTopics, 'curTopics');
+        decluster('ezoic-ad-between');
+        schedulePileFix();
+      }
 
     } else if (kind === 'categories' && normalizeBool(cfg.enableCategoryAds)) {
       const items = getCategoryItems();
       pruneOrphanWraps('ezoic-ad-categories', items);
-      inserted += injectBetween('ezoic-ad-categories', items,
-        Math.max(1, parseInt(cfg.intervalCategories, 10) || 4),
-        normalizeBool(cfg.showFirstCategoryAd), state.allCategories, 'curCategories');
-      decluster('ezoic-ad-categories');
+      if (canInject) {
+        inserted += injectBetween('ezoic-ad-categories', items,
+          Math.max(1, parseInt(cfg.intervalCategories, 10) || 4),
+          normalizeBool(cfg.showFirstCategoryAd), state.allCategories, 'curCategories');
+        decluster('ezoic-ad-categories');
+      }
     }
 
     return inserted;