nodebb-plugin-ezoic-infinite 1.6.18 → 1.6.19

package/package.json

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

package/public/client.js

@@ -1511,172 +1511,205 @@ function buildOrdinalMap(items) {
 
 
 
-// ===== V14.1 Hook any between-wrap and tether to nearest topic LI =====
+// ===== V14.2 targeted hook (topic list only) + upscroll reconcile =====
 (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 pendingSweep = false;
-  var lastSweep = 0;
-  var COOLDOWN = 120;
+  var TOPIC_LI_SEL = 'li[component="category/topic"]';
+
+  var lastY = window.pageYOffset || document.documentElement.scrollTop || 0;
 
   function token() {
     try { return String(Date.now()) + '-' + Math.random().toString(16).slice(2); } catch (e) { return String(Date.now()); }
   }
 
-  function closestTopicLi(node) {
-    // Find the topic <li> that this wrap should be associated with:
-    // prefer previous sibling <li> that is NOT a host, else climb to nearest previous in the list.
+  function getScrollY() {
+    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 closestTopicList(node) {
     try {
-      if (!node) return null;
-      var cur = node;
-      // If wrap is inside a host li, start from host
-      if (cur.closest) {
-        var host = cur.closest('li.' + HOST_CLASS);
-        if (host) cur = host;
+      var ul = node && node.closest ? node.closest('ul,ol') : null;
+      if (ul && isTopicList(ul)) return ul;
+      // sometimes wrap is outside: search up
+      var p = node && node.parentElement;
+      while (p) {
+        if ((p.tagName === 'UL' || p.tagName === 'OL') && isTopicList(p)) return p;
+        p = p.parentElement;
       }
-      // Find list container
-      var ul = cur.parentElement;
-      while (ul && !(ul.tagName === 'UL' || ul.tagName === 'OL')) ul = ul.parentElement;
-      if (!ul) return null;
+    } catch (e) {}
+    return null;
+  }
 
-      // Start from current element position within ul
+  function closestAnchorTopicLi(hostOrWrap, ul) {
+    try {
+      var cur = hostOrWrap;
+      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 prev = cur.previousElementSibling;
       while (prev) {
-        if (prev.tagName === 'LI' && !(prev.classList && prev.classList.contains(HOST_CLASS))) return prev;
+        if (prev.matches && prev.matches(TOPIC_LI_SEL)) return prev;
         prev = prev.previousElementSibling;
       }
     } catch (e) {}
     return null;
   }
 
-  function ensureHostForWrap(wrap) {
+  function ensureHostAndTokenForWrap(wrap) {
     try {
       if (!wrap || wrap.nodeType !== 1) return;
       if (!(wrap.matches && wrap.matches(BETWEEN_SEL))) return;
 
-      // Already in a host?
-      var host = wrap.closest ? wrap.closest('li.' + HOST_CLASS) : null;
-      var ul = wrap.parentElement;
-      while (ul && !(ul.tagName === 'UL' || ul.tagName === 'OL')) ul = ul.parentElement;
+      var ul = closestTopicList(wrap);
       if (!ul) return;
 
-      // Ensure wrap is inside UL only via LI host (never direct ul>div)
+      // Ensure wrap is not direct child of UL/OL
+      var host = wrap.closest ? wrap.closest('li.' + HOST_CLASS) : null;
       if (!host) {
-        host = document.createElement('li');
-        host.className = HOST_CLASS;
-        host.setAttribute('role', 'listitem');
-        host.style.listStyle = 'none';
-        host.style.width = '100%';
-        // Insert host at wrap position
-        ul.insertBefore(host, wrap);
-        host.appendChild(wrap);
-      } else if (host.parentElement !== ul) {
-        // move host into correct list container if needed
-        ul.appendChild(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);
+        }
       }
 
-      // Tether to nearest topic li and tag both with same token
-      var anchorLi = closestTopicLi(host) || closestTopicLi(wrap);
-      if (anchorLi) {
-        var t = anchorLi.getAttribute(TOKEN_ATTR);
-        if (!t) {
-          t = token();
-          anchorLi.setAttribute(TOKEN_ATTR, t);
-        }
-        host.setAttribute(TOKEN_ATTR, t);
-        // keep host just after anchor
-        if (host.previousElementSibling !== anchorLi) {
-          anchorLi.insertAdjacentElement('afterend', host);
-        }
-      } else {
-        // No anchor -> it's dangerous; mark host so we can drop it later
+      if (!host) return;
+
+      // Anchor = previous topic LI only
+      var anchorLi = closestAnchorTopicLi(host, ul);
+      if (!anchorLi) {
         host.setAttribute('data-ezoic-orphan', '1');
+        return;
+      }
+
+      var t = anchorLi.getAttribute(TOKEN_ATTR);
+      if (!t) {
+        t = token();
+        anchorLi.setAttribute(TOKEN_ATTR, t);
       }
+      host.setAttribute(TOKEN_ATTR, t);
+      host.removeAttribute('data-ezoic-orphan');
     } catch (e) {}
   }
 
-  function sweepAll() {
-    var now = Date.now();
-    if (now - lastSweep < COOLDOWN) return;
-    lastSweep = now;
+  function repairInvalidUlChildren(ul) {
+    try {
+      if (!ul) return;
+      // Fix ul>div wraps
+      var bad = ul.querySelectorAll(':scope > ' + BETWEEN_SEL);
+      bad.forEach(function(wrap){ ensureHostAndTokenForWrap(wrap); });
+    } catch (e) {}
+  }
 
+  function cleanupEmptyHosts(ul) {
     try {
-      // 1) repair direct ul>div wraps
-      var bad = document.querySelectorAll('ul > ' + BETWEEN_SEL + ', ol > ' + BETWEEN_SEL);
-      bad.forEach(ensureHostForWrap);
+      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) {}
+      });
+    } catch (e) {}
+  }
 
-      // 2) ensure any between wrap anywhere is hosted+tethered
-      var wraps = document.querySelectorAll(BETWEEN_SEL);
-      wraps.forEach(ensureHostForWrap);
+  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
 
-      // 3) reconcile/drop hosts that lost their anchor (virtualized)
-      var hosts = document.querySelectorAll('li.' + HOST_CLASS + '[' + TOKEN_ATTR + ']');
+      // Reconcile / drop
+      var hosts = ul.querySelectorAll('li.' + HOST_CLASS + '[' + TOKEN_ATTR + '], li.' + HOST_CLASS + '[data-ezoic-orphan="1"]');
       hosts.forEach(function(host){
         try {
-          var ul = host.parentElement;
-          if (!ul) { host.remove(); return; }
+          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('li[' + TOKEN_ATTR + '="' + t + '"]');
-          if (!anchor) {
-            host.remove();
-            return;
-          }
-          if (host.previousElementSibling !== anchor) {
-            anchor.insertAdjacentElement('afterend', host);
-          }
+          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) {}
       });
-
-      // 4) drop explicit orphans
-      var orphans = document.querySelectorAll('li.' + HOST_CLASS + '[data-ezoic-orphan="1"]');
-      orphans.forEach(function(h){ try { h.remove(); } catch(e) {} });
     } catch (e) {}
   }
 
-  function scheduleSweep() {
-    if (pendingSweep) return;
-    pendingSweep = true;
-    requestAnimationFrame(function(){
-      pendingSweep = false;
-      sweepAll();
-    });
+  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 installObservers() {
-    // Observe the document for any between-wrap insertion/moves
+  // Process mutations incrementally (no full-document scan)
+  function installMO() {
     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) { scheduleSweep(); break; }
-            if (m.removedNodes && m.removedNodes.length) { scheduleSweep(); break; }
+      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 });
-      }
+        }
+      });
+      mo.observe(document.documentElement || document.body, { childList: true, subtree: true });
     } catch (e) {}
   }
 
   function init() {
-    scheduleSweep();
-    window.addEventListener('scroll', scheduleSweep, { passive: true });
-    window.addEventListener('resize', scheduleSweep, { passive: true });
+    // initial tokenizing/repair
+    sweepAll(document);
+    window.addEventListener('scroll', function(){ sweepAll(document); }, { passive: true });
+    window.addEventListener('resize', function(){ sweepAll(document); }, { passive: true });
 
     if (window.jQuery) {
       window.jQuery(window).on('action:ajaxify.end action:infiniteScroll.loaded', function(){
-        setTimeout(scheduleSweep, 0);
-        setTimeout(scheduleSweep, 250);
-        setTimeout(scheduleSweep, 900);
+        setTimeout(function(){ sweepAll(document); }, 0);
+        setTimeout(function(){ sweepAll(document); }, 250);
       });
     }
-    installObservers();
+    installMO();
   }
 
   if (document.readyState === 'loading') document.addEventListener('DOMContentLoaded', init);
   else init();
 })();
-// ===== /V14.1 =====
+// ===== /V14.2 =====
 

package/public/style.css

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