nodebb-plugin-ezoic-infinite 1.6.19 → 1.6.21

package/package.json

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

package/public/client.js

@@ -1511,86 +1511,95 @@ function buildOrdinalMap(items) {
 
 
 
-// ===== V14.2 targeted hook (topic list only) + upscroll reconcile =====
+// ===== V14.1.1 Hook between-wrap (safe): host repair always, reconcile ONLY on upscroll, never append host to bottom =====
 (function () {
   var BETWEEN_SEL = 'div.nodebb-ezoic-wrap.ezoic-ad-between';
   var HOST_CLASS = 'nodebb-ezoic-host';
   var TOKEN_ATTR = 'data-ezoic-anchor-token';
-  var TOPIC_LI_SEL = 'li[component="category/topic"]';
 
   var lastY = window.pageYOffset || document.documentElement.scrollTop || 0;
+  var pending = false;
+  var lastRun = 0;
+  var COOLDOWN = 140;
 
-  function token() {
-    try { return String(Date.now()) + '-' + Math.random().toString(16).slice(2); } catch (e) { return String(Date.now()); }
-  }
-
-  function getScrollY() {
+  function getY() {
     return window.pageYOffset || document.documentElement.scrollTop || 0;
   }
 
-  function isTopicList(ul) {
-    try { return !!(ul && ul.querySelector && ul.querySelector(TOPIC_LI_SEL)); } catch (e) { return false; }
+  function token() {
+    try { return String(Date.now()) + '-' + Math.random().toString(16).slice(2); } catch (e) { return String(Date.now()); }
   }
 
-  function closestTopicList(node) {
+  function getListContainer(node) {
     try {
       var ul = node && node.closest ? node.closest('ul,ol') : null;
-      if (ul && isTopicList(ul)) return ul;
-      // sometimes wrap is outside: search up
+      if (ul && (ul.tagName === 'UL' || ul.tagName === 'OL')) return ul;
       var p = node && node.parentElement;
       while (p) {
-        if ((p.tagName === 'UL' || p.tagName === 'OL') && isTopicList(p)) return p;
+        if (p.tagName === 'UL' || p.tagName === 'OL') return p;
         p = p.parentElement;
       }
     } catch (e) {}
     return null;
   }
 
-  function closestAnchorTopicLi(hostOrWrap, ul) {
+  function closestNonHostLi(node) {
     try {
-      var cur = hostOrWrap;
+      var cur = node;
       if (!cur) return null;
-      // if wrap inside host li, start from host
       if (cur.closest) {
-        var h = cur.closest('li.' + HOST_CLASS);
-        if (h) cur = h;
+        var host = cur.closest('li.' + HOST_CLASS);
+        if (host) cur = host;
       }
       var prev = cur.previousElementSibling;
       while (prev) {
-        if (prev.matches && prev.matches(TOPIC_LI_SEL)) return prev;
+        if (prev.tagName === 'LI' && !(prev.classList && prev.classList.contains(HOST_CLASS))) return prev;
         prev = prev.previousElementSibling;
       }
     } catch (e) {}
     return null;
   }
 
-  function ensureHostAndTokenForWrap(wrap) {
+  function ensureHost(wrap) {
+    // Always ensure UL/OL doesn't directly contain DIV wraps.
     try {
-      if (!wrap || wrap.nodeType !== 1) return;
-      if (!(wrap.matches && wrap.matches(BETWEEN_SEL))) return;
+      if (!wrap || wrap.nodeType !== 1) return null;
+      if (!(wrap.matches && wrap.matches(BETWEEN_SEL))) return null;
 
-      var ul = closestTopicList(wrap);
-      if (!ul) return;
+      var ul = getListContainer(wrap);
+      if (!ul) return null;
 
-      // Ensure wrap is not direct child of UL/OL
       var host = wrap.closest ? wrap.closest('li.' + HOST_CLASS) : null;
-      if (!host) {
-        if (wrap.parentElement === ul) {
-          host = document.createElement('li');
-          host.className = HOST_CLASS;
-          host.setAttribute('role', 'listitem');
-          host.style.listStyle = 'none';
-          host.style.width = '100%';
-          ul.insertBefore(host, wrap);
-          host.appendChild(wrap);
-        }
+      if (host) return host;
+
+      // If direct child of UL/OL, create host in-place (does not affect infinite scroll measurements much)
+      if (wrap.parentElement === ul) {
+        host = document.createElement('li');
+        host.className = HOST_CLASS;
+        host.setAttribute('role', 'listitem');
+        host.style.listStyle = 'none';
+        host.style.width = '100%';
+
+        ul.insertBefore(host, wrap);
+        host.appendChild(wrap);
+        try { wrap.style.width = '100%'; } catch (e) {}
+        return host;
       }
+    } catch (e) {}
+    return null;
+  }
 
+  function tetherHostToAnchor(host, ul) {
+    // Only called on upscroll to avoid breaking load logic.
+    try {
       if (!host) return;
+      var wrap = host.querySelector && host.querySelector(BETWEEN_SEL);
+      if (!wrap) { host.remove(); return; }
 
-      // Anchor = previous topic LI only
-      var anchorLi = closestAnchorTopicLi(host, ul);
+      // Determine anchor = nearest previous non-host li
+      var anchorLi = closestNonHostLi(host);
       if (!anchorLi) {
+        // No anchor in DOM -> mark orphan (handled on upscroll only)
         host.setAttribute('data-ezoic-orphan', '1');
         return;
       }
@@ -1602,114 +1611,96 @@ function buildOrdinalMap(items) {
       }
       host.setAttribute(TOKEN_ATTR, t);
       host.removeAttribute('data-ezoic-orphan');
+
+      // If host drifted, put it back right after anchor
+      if (host.previousElementSibling !== anchorLi) {
+        anchorLi.insertAdjacentElement('afterend', host);
+      }
     } catch (e) {}
   }
 
-  function repairInvalidUlChildren(ul) {
+  function reconcileUpScroll() {
+    var y = getY();
+    var dy = y - lastY;
+    lastY = y;
+
+    // ALWAYS: repair invalid ul>div occurrences (cheap) but don't reorder
     try {
-      if (!ul) return;
-      // Fix ul>div wraps
-      var bad = ul.querySelectorAll(':scope > ' + BETWEEN_SEL);
-      bad.forEach(function(wrap){ ensureHostAndTokenForWrap(wrap); });
+      var bad = document.querySelectorAll('ul > ' + BETWEEN_SEL + ', ol > ' + BETWEEN_SEL);
+      bad.forEach(function(w){ ensureHost(w); });
     } catch (e) {}
-  }
 
-  function cleanupEmptyHosts(ul) {
+    // If NOT upscroll, do nothing else (prevents "ads accumulate at bottom" and avoids scroll blocking)
+    if (dy > -8) return;
+
+    // Up-scroll: tether/reconcile and drop orphan hosts (they cause pile-ups)
     try {
-      if (!ul) return;
-      var hosts = ul.querySelectorAll('li.' + HOST_CLASS);
-      hosts.forEach(function(host){
-        try {
-          var hasWrap = host.querySelector && host.querySelector(BETWEEN_SEL);
-          if (!hasWrap) host.remove();
-        } catch (e) {}
+      var wraps = document.querySelectorAll(BETWEEN_SEL);
+      wraps.forEach(function(w){
+        var host = ensureHost(w);
+        if (!host) host = w.closest ? w.closest('li.' + HOST_CLASS) : null;
+        var ul = getListContainer(host || w);
+        if (host && ul) tetherHostToAnchor(host, ul);
       });
-    } catch (e) {}
-  }
 
-  function reconcileUpScroll(ul) {
-    // Only reconcile (move/drop) on upscroll to avoid breaking infinite scroll load calculations.
-    try {
-      if (!ul) return;
-      var y = getScrollY();
-      var dy = y - lastY;
-      lastY = y;
-      if (dy >= -10) return; // not an upscroll
-
-      // Reconcile / drop
-      var hosts = ul.querySelectorAll('li.' + HOST_CLASS + '[' + TOKEN_ATTR + '], li.' + HOST_CLASS + '[data-ezoic-orphan="1"]');
-      hosts.forEach(function(host){
-        try {
-          if (host.getAttribute('data-ezoic-orphan') === '1') { host.remove(); return; }
-          var t = host.getAttribute(TOKEN_ATTR);
-          if (!t) { host.remove(); return; }
-          var anchor = ul.querySelector(TOPIC_LI_SEL + '[' + TOKEN_ATTR + '="' + t + '"]');
-          if (!anchor) { host.remove(); return; }
-          if (host.previousElementSibling !== anchor) anchor.insertAdjacentElement('afterend', host);
-        } catch (e) {}
+      // Drop orphans only on upscroll
+      var orphans = document.querySelectorAll('li.' + HOST_CLASS + '[data-ezoic-orphan="1"]');
+      orphans.forEach(function(h){ try { h.remove(); } catch(e) {} });
+
+      // Drop empty hosts
+      var empties = document.querySelectorAll('li.' + HOST_CLASS);
+      empties.forEach(function(h){
+        try { if (!(h.querySelector && h.querySelector(BETWEEN_SEL))) h.remove(); } catch(e) {}
       });
     } catch (e) {}
   }
 
-  function sweepAll(reasonNode) {
-    try {
-      var ul = closestTopicList(reasonNode || document.querySelector(TOPIC_LI_SEL));
-      if (!ul) return;
-      repairInvalidUlChildren(ul);
-
-      // Tokenize any new wraps within this list
-      ul.querySelectorAll(BETWEEN_SEL).forEach(function(wrap){ ensureHostAndTokenForWrap(wrap); });
-
-      // Don't move on downscroll; only clean empties
-      cleanupEmptyHosts(ul);
-      reconcileUpScroll(ul);
-    } catch (e) {}
+  function schedule() {
+    var now = Date.now();
+    if (now - lastRun < COOLDOWN) return;
+    if (pending) return;
+    pending = true;
+    requestAnimationFrame(function(){
+      pending = false;
+      lastRun = Date.now();
+      reconcileUpScroll();
+    });
   }
 
-  // Process mutations incrementally (no full-document scan)
-  function installMO() {
+  function init() {
+    // Initial repair only
     try {
-      if (typeof MutationObserver === 'undefined') return;
-      var mo = new MutationObserver(function(muts){
-        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++){
-              var n = m.addedNodes[j];
-              if (!n || n.nodeType !== 1) continue;
-              if (n.matches && n.matches(BETWEEN_SEL)) {
-                ensureHostAndTokenForWrap(n);
-              } else if (n.querySelector && n.querySelector(BETWEEN_SEL)) {
-                n.querySelectorAll(BETWEEN_SEL).forEach(function(w){ ensureHostAndTokenForWrap(w); });
-              }
-            }
-            // light sweep on the container only
-            sweepAll(m.target);
-            break;
-          }
-        }
-      });
-      mo.observe(document.documentElement || document.body, { childList: true, subtree: true });
+      var bad = document.querySelectorAll('ul > ' + BETWEEN_SEL + ', ol > ' + BETWEEN_SEL);
+      bad.forEach(function(w){ ensureHost(w); });
     } catch (e) {}
-  }
 
-  function init() {
-    // initial tokenizing/repair
-    sweepAll(document);
-    window.addEventListener('scroll', function(){ sweepAll(document); }, { passive: true });
-    window.addEventListener('resize', function(){ sweepAll(document); }, { passive: true });
+    window.addEventListener('scroll', schedule, { passive: true });
+    window.addEventListener('resize', schedule, { passive: true });
 
     if (window.jQuery) {
       window.jQuery(window).on('action:ajaxify.end action:infiniteScroll.loaded', function(){
-        setTimeout(function(){ sweepAll(document); }, 0);
-        setTimeout(function(){ sweepAll(document); }, 250);
+        setTimeout(schedule, 0);
+        setTimeout(schedule, 250);
+        setTimeout(schedule, 900);
       });
     }
-    installMO();
+
+    // MutationObserver: only schedule (no immediate heavy work)
+    try {
+      if (typeof MutationObserver !== 'undefined') {
+        var mo = new MutationObserver(function(muts){
+          for (var i=0;i<muts.length;i++){
+            var m=muts[i];
+            if ((m.addedNodes && m.addedNodes.length) || (m.removedNodes && m.removedNodes.length)) { schedule(); break; }
+          }
+        });
+        mo.observe(document.documentElement || document.body, { childList:true, subtree:true });
+      }
+    } catch (e) {}
   }
 
   if (document.readyState === 'loading') document.addEventListener('DOMContentLoaded', init);
   else init();
 })();
-// ===== /V14.2 =====
+// ===== /V14.1.1 =====
 

package/public/style.css

@@ -81,7 +81,7 @@
 }
 
 
-/* ===== V14.2 host ===== */
+/* ===== V14.1.1 host ===== */
 li.nodebb-ezoic-host { list-style: none; width: 100%; }
-/* ===== /V14.2 ===== */
+/* ===== /V14.1.1 ===== */