nodebb-plugin-ezoic-infinite 1.6.18 → 1.6.20

package/package.json

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

package/public/client.js

@@ -1511,172 +1511,147 @@ function buildOrdinalMap(items) {
 
 
 
-// ===== V14.1 Hook any between-wrap and tether to nearest topic LI =====
+// ===== V14.3 reconcile by data-ezoic-after (upscroll only, no DOM scanning on downscroll) =====
 (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 WRAP_SEL = 'div.nodebb-ezoic-wrap.ezoic-ad-between';
+  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 getY() {
+    return window.pageYOffset || document.documentElement.scrollTop || 0;
   }
 
-  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 getTopicList() {
     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;
-      }
-      // Find list container
-      var ul = cur.parentElement;
-      while (ul && !(ul.tagName === 'UL' || ul.tagName === 'OL')) ul = ul.parentElement;
-      if (!ul) return null;
-
-      // Start from current element position within ul
-      var prev = cur.previousElementSibling;
-      while (prev) {
-        if (prev.tagName === 'LI' && !(prev.classList && prev.classList.contains(HOST_CLASS))) return prev;
-        prev = prev.previousElementSibling;
-      }
-    } catch (e) {}
-    return null;
+      var topicLi = document.querySelector(TOPIC_LI_SEL);
+      if (!topicLi) return null;
+      var ul = topicLi.closest ? topicLi.closest('ul,ol') : null;
+      return ul;
+    } catch (e) { return null; }
   }
 
-  function ensureHostForWrap(wrap) {
+  function ensureValidHostForBetween(wrap) {
+    // Ensure ul/ol does not directly contain div wraps: wrap them in LI host.
     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;
+      if (!wrap || wrap.nodeType !== 1) return null;
+      if (!(wrap.matches && wrap.matches(WRAP_SEL))) return null;
       var ul = wrap.parentElement;
       while (ul && !(ul.tagName === 'UL' || ul.tagName === 'OL')) ul = ul.parentElement;
-      if (!ul) return;
+      if (!ul) return null;
 
-      // Ensure wrap is inside UL only via LI host (never direct ul>div)
-      if (!host) {
+      // If already inside host, return host
+      var host = wrap.closest ? wrap.closest('li.' + HOST_CLASS) : null;
+      if (host) return host;
+
+      // If direct child of UL/OL, create host and move wrap into it
+      if (wrap.parentElement === ul) {
         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);
-      }
-
-      // 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
-        host.setAttribute('data-ezoic-orphan', '1');
+        try { wrap.style.width = '100%'; } catch (e) {}
+        return host;
       }
     } catch (e) {}
+    return null;
   }
 
-  function sweepAll() {
-    var now = Date.now();
-    if (now - lastSweep < COOLDOWN) return;
-    lastSweep = now;
+  function desiredAnchorByAfter(ul, afterNum) {
+    // afterNum is like 6/12/18 etc. It means "after nth topic".
+    // We'll locate the nth topic LI currently in DOM (1-indexed), then anchor after it.
+    try {
+      if (!ul || !afterNum) return null;
+      var n = parseInt(afterNum, 10);
+      if (!n || n < 1) return null;
+      var topics = ul.querySelectorAll(TOPIC_LI_SEL);
+      if (!topics || !topics.length) return null;
+      // clamp to range
+      if (n > topics.length) n = topics.length;
+      return topics[n - 1];
+    } catch (e) { return null; }
+  }
 
+  function reconcileHostsUpScroll() {
+    var ul = getTopicList();
+    if (!ul) return;
+
+    // 1) Repair invalid wraps (cheap)
     try {
-      // 1) repair direct ul>div wraps
-      var bad = document.querySelectorAll('ul > ' + BETWEEN_SEL + ', ol > ' + BETWEEN_SEL);
-      bad.forEach(ensureHostForWrap);
+      ul.querySelectorAll(':scope > ' + WRAP_SEL).forEach(function(w){ ensureValidHostForBetween(w); });
+    } catch (e) {}
 
-      // 2) ensure any between wrap anywhere is hosted+tethered
-      var wraps = document.querySelectorAll(BETWEEN_SEL);
-      wraps.forEach(ensureHostForWrap);
+    // 2) Only on upscroll: move hosts back to their after-index positions if they drifted.
+    var y = getY();
+    var dy = y - lastY;
+    lastY = y;
+    if (dy >= -10) return;
 
-      // 3) reconcile/drop hosts that lost their anchor (virtualized)
-      var hosts = document.querySelectorAll('li.' + HOST_CLASS + '[' + TOKEN_ATTR + ']');
+    try {
+      var hosts = ul.querySelectorAll('li.' + HOST_CLASS);
       hosts.forEach(function(host){
         try {
-          var ul = host.parentElement;
-          if (!ul) { host.remove(); return; }
-          var t = host.getAttribute(TOKEN_ATTR);
-          if (!t) { host.remove(); return; }
-          var anchor = ul.querySelector('li[' + TOKEN_ATTR + '="' + t + '"]');
+          var wrap = host.querySelector && host.querySelector(WRAP_SEL);
+          if (!wrap) { host.remove(); return; }
+
+          var afterNum = wrap.getAttribute('data-ezoic-after') || host.getAttribute('data-ezoic-after') || '';
+          if (!afterNum) return;
+
+          var anchor = desiredAnchorByAfter(ul, afterNum);
           if (!anchor) {
+            // if we can't anchor, remove to prevent piling
             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;
+  // Throttled scheduler (scroll)
+  var pending = false;
+  var lastRun = 0;
+  var COOLDOWN = 160;
+
+  function schedule() {
+    var now = Date.now();
+    if (now - lastRun < COOLDOWN) return;
+    if (pending) return;
+    pending = true;
     requestAnimationFrame(function(){
-      pendingSweep = false;
-      sweepAll();
+      pending = false;
+      lastRun = Date.now();
+      reconcileHostsUpScroll();
     });
   }
 
-  function installObservers() {
-    // Observe the document for any between-wrap insertion/moves
+  function init() {
+    // initial repair only
     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; }
-          }
-        });
-        mo.observe(document.documentElement || document.body, { childList: true, subtree: true });
-      }
+      var ul = getTopicList();
+      if (ul) ul.querySelectorAll(':scope > ' + WRAP_SEL).forEach(function(w){ ensureValidHostForBetween(w); });
     } catch (e) {}
-  }
 
-  function init() {
-    scheduleSweep();
-    window.addEventListener('scroll', scheduleSweep, { passive: true });
-    window.addEventListener('resize', scheduleSweep, { 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(scheduleSweep, 0);
-        setTimeout(scheduleSweep, 250);
-        setTimeout(scheduleSweep, 900);
+        setTimeout(schedule, 0);
+        setTimeout(schedule, 300);
       });
     }
-    installObservers();
   }
 
   if (document.readyState === 'loading') document.addEventListener('DOMContentLoaded', init);
   else init();
 })();
-// ===== /V14.1 =====
+// ===== /V14.3 =====
 

package/public/style.css

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