nodebb-plugin-ezoic-infinite 1.6.21 → 1.6.22

package/package.json

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

package/public/client.js

@@ -1511,24 +1511,11 @@ function buildOrdinalMap(items) {
 
 
 
-// ===== V14.1.1 Hook between-wrap (safe): host repair always, reconcile ONLY on upscroll, never append host to bottom =====
+// ===== V14.1.2 IO reconcile (visible only) – minimal impact on infinite scroll =====
 (function () {
-  var BETWEEN_SEL = 'div.nodebb-ezoic-wrap.ezoic-ad-between';
+  var WRAP_SEL = 'div.nodebb-ezoic-wrap.ezoic-ad-between';
   var HOST_CLASS = 'nodebb-ezoic-host';
-  var TOKEN_ATTR = 'data-ezoic-anchor-token';
-
-  var lastY = window.pageYOffset || document.documentElement.scrollTop || 0;
-  var pending = false;
-  var lastRun = 0;
-  var COOLDOWN = 140;
-
-  function getY() {
-    return 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()); }
-  }
+  var io = null;
 
   function getListContainer(node) {
     try {
@@ -1547,6 +1534,7 @@ function buildOrdinalMap(items) {
     try {
       var cur = node;
       if (!cur) return null;
+      // If inside host, start from host
       if (cur.closest) {
         var host = cur.closest('li.' + HOST_CLASS);
         if (host) cur = host;
@@ -1560,26 +1548,24 @@ function buildOrdinalMap(items) {
     return null;
   }
 
-  function ensureHost(wrap) {
-    // Always ensure UL/OL doesn't directly contain DIV wraps.
+  function ensureHostForWrap(wrap) {
+    // Only repairs invalid UL>DIV. Does NOT move around the list except wrapping in-place.
     try {
       if (!wrap || wrap.nodeType !== 1) return null;
-      if (!(wrap.matches && wrap.matches(BETWEEN_SEL))) return null;
-
-      var ul = getListContainer(wrap);
-      if (!ul) return null;
+      if (!(wrap.matches && wrap.matches(WRAP_SEL))) return null;
 
       var host = wrap.closest ? wrap.closest('li.' + HOST_CLASS) : null;
       if (host) return host;
 
-      // If direct child of UL/OL, create host in-place (does not affect infinite scroll measurements much)
+      var ul = getListContainer(wrap);
+      if (!ul) return null;
+
       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) {}
@@ -1589,118 +1575,105 @@ function buildOrdinalMap(items) {
     return null;
   }
 
-  function tetherHostToAnchor(host, ul) {
-    // Only called on upscroll to avoid breaking load logic.
+  function reconcileHostPosition(host) {
+    // Moves ONLY the one host we are currently handling (visible or just inserted).
     try {
-      if (!host) return;
-      var wrap = host.querySelector && host.querySelector(BETWEEN_SEL);
-      if (!wrap) { host.remove(); return; }
+      if (!host || host.nodeType !== 1) return;
+      var ul = getListContainer(host);
+      if (!ul) return;
 
-      // 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;
-      }
-
-      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');
+      if (!anchorLi) return;
 
-      // If host drifted, put it back right after anchor
       if (host.previousElementSibling !== anchorLi) {
         anchorLi.insertAdjacentElement('afterend', host);
       }
     } catch (e) {}
   }
 
-  function reconcileUpScroll() {
-    var y = getY();
-    var dy = y - lastY;
-    lastY = y;
-
-    // ALWAYS: repair invalid ul>div occurrences (cheap) but don't reorder
+  function observeHost(host) {
     try {
-      var bad = document.querySelectorAll('ul > ' + BETWEEN_SEL + ', ol > ' + BETWEEN_SEL);
-      bad.forEach(function(w){ ensureHost(w); });
+      if (!host) return;
+      if (!io) return;
+      io.observe(host);
     } catch (e) {}
+  }
 
-    // If NOT upscroll, do nothing else (prevents "ads accumulate at bottom" and avoids scroll blocking)
-    if (dy > -8) return;
+  function initIO() {
+    if (io || typeof IntersectionObserver === 'undefined') return;
+    io = new IntersectionObserver(function (entries) {
+      try {
+        entries.forEach(function (e) {
+          if (!e || !e.isIntersecting || !e.target) return;
+          // When host is near viewport, reconcile once.
+          reconcileHostPosition(e.target);
+        });
+      } catch (e) {}
+    }, { root: null, rootMargin: '800px 0px 800px 0px', threshold: 0.01 });
+  }
 
-    // Up-scroll: tether/reconcile and drop orphan hosts (they cause pile-ups)
+  function processWrap(wrap) {
     try {
-      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);
-      });
-
-      // 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) {}
-      });
+      var host = ensureHostForWrap(wrap) || (wrap.closest ? wrap.closest('li.' + HOST_CLASS) : null);
+      if (host) {
+        // reconcile immediately only for the newly processed node (cheap)
+        reconcileHostPosition(host);
+        observeHost(host);
+      }
     } 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();
-    });
+  function scanInitial() {
+    try {
+      document.querySelectorAll(WRAP_SEL).forEach(processWrap);
+    } catch (e) {}
   }
 
-  function init() {
-    // Initial repair only
+  function installMO() {
     try {
-      var bad = document.querySelectorAll('ul > ' + BETWEEN_SEL + ', ol > ' + BETWEEN_SEL);
-      bad.forEach(function(w){ ensureHost(w); });
+      if (typeof MutationObserver === 'undefined') return;
+      var mo = new MutationObserver(function (muts) {
+        try {
+          for (var i = 0; i < muts.length; i++) {
+            var m = muts[i];
+            if (!m.addedNodes || !m.addedNodes.length) continue;
+
+            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(WRAP_SEL)) {
+                processWrap(n);
+              } else if (n.querySelectorAll) {
+                var inner = n.querySelectorAll(WRAP_SEL);
+                if (inner && inner.length) inner.forEach(processWrap);
+              }
+            }
+          }
+        } catch (e) {}
+      });
+      mo.observe(document.documentElement || document.body, { childList: true, subtree: true });
     } catch (e) {}
+  }
 
-    window.addEventListener('scroll', schedule, { passive: true });
-    window.addEventListener('resize', schedule, { passive: true });
+  function init() {
+    initIO();
+    scanInitial();
+    installMO();
 
     if (window.jQuery) {
-      window.jQuery(window).on('action:ajaxify.end action:infiniteScroll.loaded', function(){
-        setTimeout(schedule, 0);
-        setTimeout(schedule, 250);
-        setTimeout(schedule, 900);
-      });
-    }
-
-    // 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; }
-          }
+      try {
+        window.jQuery(window).on('action:ajaxify.end action:infiniteScroll.loaded', function () {
+          // do a light rescan (no scroll listeners)
+          setTimeout(scanInitial, 0);
+          setTimeout(scanInitial, 250);
         });
-        mo.observe(document.documentElement || document.body, { childList:true, subtree:true });
-      }
-    } catch (e) {}
+      } catch (e) {}
+    }
   }
 
   if (document.readyState === 'loading') document.addEventListener('DOMContentLoaded', init);
   else init();
 })();
-// ===== /V14.1.1 =====
+// ===== /V14.1.2 =====
 

package/public/style.css

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