nodebb-plugin-ezoic-infinite 1.6.35 → 1.6.37

package/package.json

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

package/public/client.js

@@ -1514,15 +1514,18 @@ function buildOrdinalMap(items) {
 
 
 
-// ===== V18: Always host between DIVs in <li> + anchor by topic tid (MutationObserver, no scroll hooks to injection) =====
+// ===== V17.8: No pile-up by design — keep "future" between slots pending/collapsed until their anchor topic exists =====
 (function () {
   var TOPIC_LI_SEL = 'li[component="category/topic"]';
   var BETWEEN_WRAP_SEL = 'div.nodebb-ezoic-wrap.ezoic-ad-between';
   var HOST_CLASS = 'nodebb-ezoic-host';
-  var ANCHOR_ATTR = 'data-ezoic-anchor-tid';
+  var PENDING_CLASS = 'nodebb-ezoic-pending';
 
-  var pending = false;
-  var queue = new Set();
+  var ul = null;
+  var mo = null;
+  var scheduled = false;
+  var lastRun = 0;
+  var COOLDOWN = 80;
 
   function getTopicList() {
     try {
@@ -1532,69 +1535,41 @@ function buildOrdinalMap(items) {
     } catch (e) { return null; }
   }
 
-  function extractTidFromTopicLi(li) {
-    // Parse tid from a topic link (/topic/{tid}/...)
-    try {
-      if (!li || !li.querySelector) return null;
-      var a = li.querySelector('a[href^="/topic/"], a[href*="/topic/"]');
-      if (!a) return null;
-      var href = a.getAttribute('href') || '';
-      var m = href.match(/\/topic\/(\d+)\b/);
-      return m ? m[1] : null;
-    } catch (e) { return null; }
-  }
+  function ensureUL() { ul = ul || getTopicList(); return ul; }
 
-  function buildTidMap(ul) {
-    var map = Object.create(null);
-    try {
-      var topics = ul.querySelectorAll(TOPIC_LI_SEL);
-      for (var i = 0; i < topics.length; i++) {
-        var tid = extractTidFromTopicLi(topics[i]);
-        if (tid && !map[tid]) map[tid] = topics[i];
-      }
-    } catch (e) {}
-    return map;
+  function isHost(el) {
+    return !!(el && el.nodeType === 1 && el.tagName === 'LI' && el.classList && el.classList.contains(HOST_CLASS));
   }
 
-  function previousTopicLi(node) {
-    try {
-      var prev = node.previousElementSibling;
-      while (prev) {
-        if (prev.matches && prev.matches(TOPIC_LI_SEL)) return prev;
-        prev = prev.previousElementSibling;
-      }
-    } catch (e) {}
-    return null;
+  function isBetweenWrap(el) {
+    try { return !!(el && el.nodeType === 1 && el.matches && el.matches(BETWEEN_WRAP_SEL)); } catch(e){ return false; }
   }
 
-  function ensureHostForWrap(wrap, ul) {
-    // Always ensure UL children are LI, to avoid NodeBB reparenting DIVs (root cause of pile-up).
+  function ensureHostForWrap(wrap, ulEl) {
+    // If Ezoic inserts ul > div..., wrap it into a LI to keep a valid list structure (less NodeBB churn).
     try {
-      if (!wrap || wrap.nodeType !== 1) return null;
-      if (!(wrap.matches && wrap.matches(BETWEEN_WRAP_SEL))) return null;
-
+      if (!wrap || !isBetweenWrap(wrap)) return null;
       var host = wrap.closest ? wrap.closest('li.' + HOST_CLASS) : null;
       if (host) return host;
 
-      ul = ul || (wrap.closest ? wrap.closest('ul,ol') : null);
-      if (!ul || !(ul.tagName === 'UL' || ul.tagName === 'OL')) return null;
+      ulEl = ulEl || (wrap.closest ? wrap.closest('ul,ol') : null);
+      if (!ulEl || !(ulEl.tagName === 'UL' || ulEl.tagName === 'OL')) return null;
 
-      // Only wrap if it's a direct child of the list
-      if (wrap.parentElement === ul) {
+      if (wrap.parentElement === ulEl) {
         host = document.createElement('li');
         host.className = HOST_CLASS;
         host.setAttribute('role', 'listitem');
         host.style.listStyle = 'none';
         host.style.width = '100%';
 
-        // anchor tid from previous topic
-        var anchor = previousTopicLi(wrap) || wrap.previousElementSibling;
-        if (anchor && anchor.matches && anchor.matches(TOPIC_LI_SEL)) {
-          var tid = extractTidFromTopicLi(anchor);
-          if (tid) host.setAttribute(ANCHOR_ATTR, tid);
-        }
+        try {
+          var after = wrap.getAttribute('data-ezoic-after');
+          if (after) host.setAttribute('data-ezoic-after', after);
+          var pin = wrap.getAttribute('data-ezoic-pin');
+          if (pin) host.setAttribute('data-ezoic-pin', pin);
+        } catch (e) {}
 
-        ul.insertBefore(host, wrap);
+        ulEl.insertBefore(host, wrap);
         host.appendChild(wrap);
         try { wrap.style.width = '100%'; } catch (e) {}
         return host;
@@ -1603,133 +1578,145 @@ function buildOrdinalMap(items) {
     return null;
   }
 
-  function ensureAnchorTid(host) {
+  function getAfter(el) {
     try {
-      if (!host || host.nodeType !== 1) return;
-      if (host.getAttribute(ANCHOR_ATTR)) return;
-      var anchor = previousTopicLi(host);
-      if (!anchor) return;
-      var tid = extractTidFromTopicLi(anchor);
-      if (tid) host.setAttribute(ANCHOR_ATTR, tid);
-    } catch (e) {}
+      var v = null;
+      if (el && el.getAttribute) v = el.getAttribute('data-ezoic-after');
+      if (!v && el && el.querySelector) {
+        var w = el.querySelector(BETWEEN_WRAP_SEL);
+        if (w) v = w.getAttribute('data-ezoic-after');
+      }
+      var n = parseInt(v, 10);
+      return isNaN(n) ? null : n;
+    } catch (e) { return null; }
   }
 
-  function reconcileHost(host, ul, tidMap) {
-    try {
-      if (!host || host.nodeType !== 1 || !host.isConnected) return;
-      ul = ul || host.parentElement;
-      if (!ul) return;
-
-      // if host got detached from list, skip
-      if (!(ul.tagName === 'UL' || ul.tagName === 'OL')) return;
+  function getTopics(ulEl) {
+    try { return ulEl ? ulEl.querySelectorAll(TOPIC_LI_SEL) : []; } catch(e){ return []; }
+  }
 
-      ensureAnchorTid(host);
+  function lastTopic(ulEl, topics) {
+    try {
+      topics = topics || getTopics(ulEl);
+      return topics && topics.length ? topics[topics.length - 1] : null;
+    } catch (e) { return null; }
+  }
 
-      var tid = host.getAttribute(ANCHOR_ATTR);
-      if (!tid) return;
+  function moveAfter(node, anchor) {
+    try {
+      if (!node || !anchor || !anchor.insertAdjacentElement) return;
+      if (node.previousElementSibling === anchor) return;
+      anchor.insertAdjacentElement('afterend', node);
+    } catch (e) {}
+  }
 
-      var anchorLi = tidMap[tid];
-      if (!anchorLi || !anchorLi.isConnected) return;
+  function placeOrPend(host, ulEl, topics) {
+    try {
+      if (!host) return;
+      ulEl = ulEl || ensureUL();
+      if (!ulEl) return;
+
+      topics = topics || getTopics(ulEl);
+
+      var after = getAfter(host);
+      if (!after) {
+        var lt = lastTopic(ulEl, topics);
+        if (lt) moveAfter(host, lt);
+        host.classList && host.classList.remove(PENDING_CLASS);
+        return;
+      }
 
-      if (host.previousElementSibling !== anchorLi) {
-        anchorLi.insertAdjacentElement('afterend', host);
+      if (after > topics.length) {
+        var lt2 = lastTopic(ulEl, topics);
+        if (lt2) moveAfter(host, lt2);
+        host.classList && host.classList.add(PENDING_CLASS);
+        return;
       }
+
+      var anchor = topics[after - 1];
+      if (anchor) moveAfter(host, anchor);
+      host.classList && host.classList.remove(PENDING_CLASS);
     } catch (e) {}
   }
 
-  function drain() {
-    pending = false;
-    var ul = getTopicList();
-    if (!ul) return;
+  function reconcile() {
+    var ulEl = ensureUL();
+    if (!ulEl) return;
+
+    var topics = getTopics(ulEl);
 
-    // First, host any direct-child between DIVs currently in list (cheap, keeps DOM valid).
     try {
-      ul.querySelectorAll(':scope > ' + BETWEEN_WRAP_SEL).forEach(function (w) {
-        var h = ensureHostForWrap(w, ul);
-        if (h) queue.add(h);
+      ulEl.querySelectorAll(':scope > ' + BETWEEN_WRAP_SEL).forEach(function (w) {
+        var h = ensureHostForWrap(w, ulEl);
+        if (h) placeOrPend(h, ulEl, topics);
       });
-    } catch (e) {}
 
-    var tidMap = buildTidMap(ul);
+      ulEl.querySelectorAll('li.' + HOST_CLASS).forEach(function (h) {
+        placeOrPend(h, ulEl, topics);
+      });
 
-    // Process a limited batch per frame
-    var processed = 0;
-    for (var host of Array.from(queue)) {
-      queue.delete(host);
-      reconcileHost(host, ul, tidMap);
-      processed++;
-      if (processed >= 12) break;
-    }
-    if (queue.size) schedule();
+      ulEl.querySelectorAll(BETWEEN_WRAP_SEL).forEach(function (w) {
+        var h = ensureHostForWrap(w, ulEl) || (w.closest ? w.closest('li.' + HOST_CLASS) : null);
+        if (h) placeOrPend(h, ulEl, topics);
+      });
+    } catch (e) {}
   }
 
-  function schedule() {
-    if (pending) return;
-    pending = true;
-    requestAnimationFrame(drain);
+  function scheduleReconcile() {
+    var now = Date.now();
+    if (scheduled) return;
+    if (now - lastRun < COOLDOWN) return;
+    scheduled = true;
+    lastRun = now;
+    requestAnimationFrame(function () {
+      scheduled = false;
+      reconcile();
+    });
   }
 
-  function enqueueNode(node, ul) {
-    try {
-      if (!node || node.nodeType !== 1) return;
-      if (node.matches && node.matches(BETWEEN_WRAP_SEL)) {
-        var h = ensureHostForWrap(node, ul);
-        if (h) queue.add(h);
-      } else if (node.tagName === 'LI' && node.classList && node.classList.contains(HOST_CLASS)) {
-        queue.add(node);
-      } else if (node.querySelectorAll) {
-        // only check within added subtree, not whole doc
-        node.querySelectorAll(':scope ' + BETWEEN_WRAP_SEL).forEach(function (w) {
-          var h2 = ensureHostForWrap(w, ul);
-          if (h2) queue.add(h2);
-        });
-        node.querySelectorAll(':scope li.' + HOST_CLASS).forEach(function (h3) { queue.add(h3); });
-      }
-    } catch (e) {}
-  }
+  function initObserver() {
+    var ulEl = ensureUL();
+    if (!ulEl || mo) return;
 
-  function init() {
-    var ul = getTopicList();
-    if (!ul) return;
+    mo = new MutationObserver(function () {
+      scheduleReconcile();
+    });
 
-    // Initial pass: host all between DIVs and reconcile once.
-    schedule();
+    mo.observe(ulEl, { childList: true, subtree: true });
+  }
 
-    // Observe only the topic list
-    if (typeof MutationObserver !== 'undefined') {
-      var mo = new MutationObserver(function (muts) {
-        try {
-          var u = getTopicList();
-          if (!u) return;
-
-          for (var i = 0; i < muts.length; i++) {
-            var m = muts[i];
-            if (m.addedNodes && m.addedNodes.length) {
-              for (var j = 0; j < m.addedNodes.length; j++) {
-                enqueueNode(m.addedNodes[j], u);
-              }
-            }
-          }
-          if (queue.size) schedule();
-        } catch (e) {}
-      });
-      try { mo.observe(ul, { childList: true, subtree: true }); } catch (e) {}
-    }
+  function init() {
+    initObserver();
+    scheduleReconcile();
 
-    // NodeBB events: run a settle pass after batches
     if (window.jQuery) {
       try {
         window.jQuery(window).on('action:ajaxify.end action:infiniteScroll.loaded', function () {
-          // Let NodeBB append topics, then reconcile hosts by anchor tid.
-          setTimeout(function(){ schedule(); }, 120);
-          setTimeout(function(){ schedule(); }, 520);
+          ul = null;
+          try { if (mo) mo.disconnect(); } catch (e) {}
+          mo = null;
+          initObserver();
+          scheduleReconcile();
+          setTimeout(scheduleReconcile, 120);
+          setTimeout(scheduleReconcile, 500);
         });
       } catch (e) {}
     }
+
+    var tries = 0;
+    var t = setInterval(function () {
+      tries++;
+      if (ensureUL()) {
+        clearInterval(t);
+        initObserver();
+        scheduleReconcile();
+      }
+      if (tries > 30) clearInterval(t);
+    }, 200);
   }
 
   if (document.readyState === 'loading') document.addEventListener('DOMContentLoaded', init);
   else init();
 })();
-// ===== /V18 =====
+// ===== /V17.8 =====
 

package/public/style.css

@@ -88,8 +88,18 @@ li.nodebb-ezoic-host > .nodebb-ezoic-wrap.ezoic-ad-between { width: 100%; displa
 
 
 
-/* ===== V18 hosts ===== */
-li.nodebb-ezoic-host{ list-style:none; width:100%; display:block; }
-li.nodebb-ezoic-host > .nodebb-ezoic-wrap.ezoic-ad-between{ width:100%; display:block; }
-/* ===== /V18 ===== */
+/* ===== V17.8 pending slots (prevents pile-up top/bottom) ===== */
+li.nodebb-ezoic-host { list-style:none; width:100%; display:block; }
+li.nodebb-ezoic-host > .nodebb-ezoic-wrap.ezoic-ad-between { width:100%; display:block; }
+
+/* slots whose anchor topic isn't loaded yet */
+li.nodebb-ezoic-host.nodebb-ezoic-pending{
+  max-height: 0 !important;
+  margin: 0 !important;
+  padding: 0 !important;
+  overflow: hidden !important;
+  opacity: 0 !important;
+  pointer-events: none !important;
+}
+/* ===== /V17.8 ===== */