nodebb-plugin-ezoic-infinite 1.2.5 → 1.3.0

package/package.json

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

package/public/client.js

@@ -2,9 +2,6 @@
 (function () {
   'use strict';
 
-  // Optional debug switch
-  const DEBUG = !!window.__ezoicInfiniteDebug;
-
   const $ = (typeof window.jQuery === 'function') ? window.jQuery : null;
 
   const SELECTORS = {
@@ -15,7 +12,6 @@
   const WRAP_CLASS = 'ezoic-ad';
   const PLACEHOLDER_PREFIX = 'ezoic-pub-ad-placeholder-';
 
-  // Prevent “burst” injection: at most N inserts per run per kind
   const MAX_INSERTS_PER_RUN = 2;
 
   const state = {
@@ -23,33 +19,22 @@
     cfg: null,
     cfgPromise: null,
 
-    // Per-page pools (refilled by recycling)
     poolTopics: [],
     poolPosts: [],
 
-    // Track inserted ads per page
     usedTopics: new Set(),
     usedPosts: new Set(),
 
-    // Track which anchors we already evaluated to avoid reprocessing everything on each event
-    seenTopicAnchors: new WeakSet(),
-    seenPostAnchors: new WeakSet(),
-
-    // showAds anti-double
     lastShowById: new Map(),
     pendingById: new Set(),
 
-    // debounce
     scheduled: false,
     timer: null,
 
-    // observers
     obs: null,
+    attempts: 0,
   };
 
-  function log(...args) { if (DEBUG) console.log('[ezoic-infinite]', ...args); }
-  function warn(...args) { if (DEBUG) console.warn('[ezoic-infinite]', ...args); }
-
   function normalizeBool(v) {
     return v === true || v === 'true' || v === 1 || v === '1' || v === 'on';
   }
@@ -88,88 +73,77 @@
     const p = window.location.pathname || '';
     if (/^\/topic\//.test(p)) return 'topic';
     if (/^\/category\//.test(p)) return 'category';
-    // fallback
-    if (document.querySelector(SELECTORS.postItem)) return 'topic';
+    if (document.querySelector('[component="topic"]') || document.querySelector('[component="post"][data-pid]')) return 'topic';
     return 'category';
   }
 
-
   function getTopicItems() {
     return Array.from(document.querySelectorAll(SELECTORS.topicItem));
   }
 
   function getPostContainers() {
-    // Harmony can include multiple [component="post"] blocks (e.g. parent previews, nested structures).
-    // We only want top-level post containers that actually contain post content.
     const nodes = Array.from(document.querySelectorAll(SELECTORS.postItem));
     return nodes.filter((el) => {
       if (!el || !el.isConnected) return false;
-
-      // Must contain post content
       if (!el.querySelector('[component="post/content"]')) return false;
-
-      // Must not be nested within another post container
       const parentPost = el.parentElement && el.parentElement.closest('[component="post"][data-pid]');
       if (parentPost && parentPost !== el) return false;
-
-      // Avoid "parent/quote" blocks that use component="post/parent"
       if (el.getAttribute('component') === 'post/parent') return false;
-
       return true;
     });
   }
 
-  function hasAdImmediatelyAfter(el) {
-    const n = el && el.nextElementSibling;
-    return !!(n && n.classList && n.classList.contains(WRAP_CLASS));
-  }
-
-  function enforceNoAdjacentAds() {
-    // NodeBB can virtualize (remove) topics/posts from the DOM while keeping our ad wrappers,
-    // which can temporarily make two ad wrappers adjacent. Hide the later one to avoid back-to-back ads.
-    const ads = Array.from(document.querySelectorAll(`.${WRAP_CLASS}`));
-    for (let i = 0; i < ads.length; i++) {
-      const ad = ads[i];
-      const prev = ad.previousElementSibling;
-      if (prev && prev.classList && prev.classList.contains(WRAP_CLASS)) {
-        ad.style.display = 'none';
-      } else {
-        ad.style.display = '';
-      }
-    }
-  }
-
-
-    const n = el && el.nextElementSibling;
-    return !!(n && n.classList && n.classList.contains(WRAP_CLASS));
-  }
-
   function buildWrap(id, kind, afterPos) {
     const wrap = document.createElement('div');
     wrap.className = `${WRAP_CLASS} ${kind}`;
     wrap.setAttribute('data-ezoic-after', String(afterPos));
     wrap.style.width = '100%';
+
     const ph = document.createElement('div');
     ph.id = `${PLACEHOLDER_PREFIX}${id}`;
     wrap.appendChild(ph);
     return wrap;
   }
 
-  function insertAfter(target, id, kind, afterPos) {
+  function findWrap(kindClass, afterPos) {
+    return document.querySelector(`.${WRAP_CLASS}.${kindClass}[data-ezoic-after="${afterPos}"]`);
+  }
+
+  function insertAfter(target, id, kindClass, afterPos) {
     if (!target || !target.insertAdjacentElement) return null;
-    const wrap = buildWrap(id, kind, afterPos);
+    if (findWrap(kindClass, afterPos)) return null;
+    const wrap = buildWrap(id, kindClass, afterPos);
     target.insertAdjacentElement('afterend', wrap);
     return wrap;
   }
 
-  function safeRect(el) {
-    try { return el.getBoundingClientRect(); } catch (e) { return null; }
-  }
+  function destroyUsedPlaceholders() {
+    const ids = [];
+    try {
+      state.usedTopics.forEach((id) => ids.push(id));
+      state.usedPosts.forEach((id) => ids.push(id));
+    } catch (e) {}
+
+    if (!ids.length) return;
+
+    const call = () => {
+      try {
+        if (window.ezstandalone && typeof window.ezstandalone.destroyPlaceholders === 'function') {
+          window.ezstandalone.destroyPlaceholders(ids);
+        }
+      } catch (e) {}
+    };
+
+    try {
+      window.ezstandalone = window.ezstandalone || {};
+      window.ezstandalone.cmd = window.ezstandalone.cmd || [];
+      if (window.ezstandalone && typeof window.ezstandalone.destroyPlaceholders === 'function') call();
+      else window.ezstandalone.cmd.push(call);
     } catch (e) {}
   }
 
-  // Patch ezstandalone.showAds to split batch calls (we NEVER call batch from this plugin)
   function patchShowAds() {
+    // Minimal safety net: batch showAds can be triggered by other scripts; split into individual calls.
     try {
       window.ezstandalone = window.ezstandalone || {};
       const ez = window.ezstandalone;
@@ -179,11 +153,13 @@
       ez.__nodebbEzoicPatched = true;
       const orig = ez.showAds;
 
-      ez.showAds = function patchedShowAds(arg) {
+      ez.showAds = function (arg) {
         if (Array.isArray(arg)) {
-          try { warn('showAds(batch) detected. Splitting…'); } catch (e) {}
-          const ids = uniqInts(arg);
-          for (const id of ids) {
+          const seen = new Set();
+          for (const v of arg) {
+            const id = parseInt(v, 10);
+            if (!Number.isFinite(id) || id <= 0 || seen.has(id)) continue;
+            seen.add(id);
             try { orig.call(ez, id); } catch (e) {}
           }
           return;
@@ -236,7 +212,6 @@
           } catch (e) {}
         });
 
-        // short retries
         let tries = 0;
         (function tick() {
           tries += 1;
@@ -249,17 +224,14 @@
         return;
       }
 
-      if (attempts < 40) setTimeout(waitForPh, 50);
+      if (attempts < 50) setTimeout(waitForPh, 50);
     })();
   }
-    }
-    return false;
-  }
 
   function nextId(kind) {
     const pool = (kind === 'between') ? state.poolTopics : state.poolPosts;
     if (pool.length) return pool.shift();
-    return null; // stop injecting when pool is empty
+    return null;
   }
 
   async function fetchConfig() {
@@ -283,47 +255,54 @@
   }
 
   function initPools(cfg) {
-    // Re-init pools once per page
     if (state.poolTopics.length === 0) state.poolTopics = parsePool(cfg.placeholderIds);
     if (state.poolPosts.length === 0) state.poolPosts = parsePool(cfg.messagePlaceholderIds);
   }
 
+  function computeTargets(count, interval, showFirst) {
+    const out = [];
+    if (count <= 0) return out;
+    if (showFirst) out.push(1);
+    for (let i = 1; i <= count; i++) {
+      if (i % interval === 0) out.push(i);
+    }
+    // uniq + sort
+    return Array.from(new Set(out)).sort((a, b) => a - b);
+  }
+
   function injectTopics(cfg) {
     if (!normalizeBool(cfg.enableBetweenAds)) return 0;
 
     const interval = Math.max(1, parseInt(cfg.intervalPosts, 10) || 6);
-    const first = normalizeBool(cfg.showFirstTopicAd);
+    const showFirst = normalizeBool(cfg.showFirstTopicAd);
 
     const items = getTopicItems();
     if (!items.length) return 0;
 
+    const targets = computeTargets(items.length, interval, showFirst);
+
     let inserted = 0;
-    for (let i = 0; i < items.length; i++) {
-      const li = items[i];
-      if (!li || !li.isConnected) continue;
+    for (const afterPos of targets) {
+      if (inserted >= MAX_INSERTS_PER_RUN) break;
 
-      // Avoid re-processing anchors already evaluated
-      if (state.seenTopicAnchors.has(li)) continue;
+      const li = items[afterPos - 1];
+      if (!li || !li.isConnected) continue;
 
-      const pos = i + 1;
-      const ok = (first && pos === 1) || (pos % interval === 0);
-      state.seenTopicAnchors.add(li);
-      if (!ok) continue;
+      // Avoid back-to-back ads at load: if afterPos-1 already has an ad wrapper, skip
+      const prevWrap = findWrap('ezoic-ad-between', afterPos - 1);
+      if (prevWrap) continue;
 
-      if (hasAdImmediatelyAfter(li)) continue;
+      if (findWrap('ezoic-ad-between', afterPos)) continue;
 
       const id = nextId('between');
       if (!id) break;
 
       state.usedTopics.add(id);
-      const wrap = insertAfter(li, id, 'ezoic-ad-between', pos);
+      const wrap = insertAfter(li, id, 'ezoic-ad-between', afterPos);
       if (!wrap) continue;
 
-      inserted += 1;
-
       callShowAdsWhenReady(id);
-
-      if (inserted >= MAX_INSERTS_PER_RUN) break;
+      inserted += 1;
     }
     return inserted;
   }
@@ -332,42 +311,52 @@
     if (!normalizeBool(cfg.enableMessageAds)) return 0;
 
     const interval = Math.max(1, parseInt(cfg.messageIntervalPosts, 10) || 3);
-    const first = normalizeBool(cfg.showFirstMessageAd);
+    const showFirst = normalizeBool(cfg.showFirstMessageAd);
 
     const posts = getPostContainers();
     if (!posts.length) return 0;
 
+    const targets = computeTargets(posts.length, interval, showFirst);
+
     let inserted = 0;
-    for (let i = 0; i < posts.length; i++) {
-      const post = posts[i];
-      if (!post || !post.isConnected) continue;
+    for (const afterPos of targets) {
+      if (inserted >= MAX_INSERTS_PER_RUN) break;
 
-      if (state.seenPostAnchors.has(post)) continue;
+      const post = posts[afterPos - 1];
+      if (!post || !post.isConnected) continue;
 
-      const no = i + 1;
-      const ok = (first && no === 1) || (no % interval === 0);
-      state.seenPostAnchors.add(post);
-      if (!ok) continue;
+      const prevWrap = findWrap('ezoic-ad-message', afterPos - 1);
+      if (prevWrap) continue;
 
-      if (hasAdImmediatelyAfter(post)) continue;
+      if (findWrap('ezoic-ad-message', afterPos)) continue;
 
       const id = nextId('message');
       if (!id) break;
 
       state.usedPosts.add(id);
-      const wrap = insertAfter(post, id, 'ezoic-ad-message', no);
+      const wrap = insertAfter(post, id, 'ezoic-ad-message', afterPos);
       if (!wrap) continue;
 
-      inserted += 1;
-
       callShowAdsWhenReady(id);
-
-      if (inserted >= MAX_INSERTS_PER_RUN) break;
+      inserted += 1;
     }
     return inserted;
   }
 
+  function enforceNoAdjacentAds() {
+    // If DOM changes produce adjacent wrappers (rare but possible), hide the later one.
+    const ads = Array.from(document.querySelectorAll(`.${WRAP_CLASS}`));
+    for (let i = 0; i < ads.length; i++) {
+      const ad = ads[i];
+      const prev = ad.previousElementSibling;
+      if (prev && prev.classList && prev.classList.contains(WRAP_CLASS)) ad.style.display = 'none';
+      else ad.style.display = '';
+    }
+  }
+
   function cleanup() {
+    destroyUsedPlaceholders();
+
     state.pageKey = getPageKey();
     state.cfg = null;
     state.cfgPromise = null;
@@ -377,12 +366,11 @@
     state.usedTopics.clear();
     state.usedPosts.clear();
 
-    state.seenTopicAnchors = new WeakSet();
-    state.seenPostAnchors = new WeakSet();
-
     state.lastShowById = new Map();
     state.pendingById = new Set();
 
+    state.attempts = 0;
+
     document.querySelectorAll(`.${WRAP_CLASS}`).forEach(el => el.remove());
 
     if (state.obs) { try { state.obs.disconnect(); } catch (e) {} state.obs = null; }
@@ -395,7 +383,7 @@
     if (state.obs) return;
     state.obs = new MutationObserver(() => scheduleRun('dom-mutation'));
     try { state.obs.observe(document.body, { childList: true, subtree: true }); } catch (e) {}
-    setTimeout(() => { if (state.obs) { try { state.obs.disconnect(); } catch (e) {} state.obs = null; } }, 12000);
+    setTimeout(() => { if (state.obs) { try { state.obs.disconnect(); } catch (e) {} state.obs = null; } }, 15000);
   }
 
   async function runCore() {
@@ -414,64 +402,69 @@
 
     enforceNoAdjacentAds();
 
-    // If we inserted max per run, schedule another pass to gradually fill (avoids “burst”)
+    // If nothing inserted and we have no items yet (first click), retry a few times
+    const itemCount = (kind === 'topic') ? getPostContainers().length : getTopicItems().length;
+    if (itemCount === 0 && state.attempts < 25) {
+      state.attempts += 1;
+      setTimeout(() => scheduleRun('await-items'), 120);
+      return;
+    }
+
     if (inserted >= MAX_INSERTS_PER_RUN) {
-      setTimeout(() => scheduleRun('continue-fill'), 120);
+      setTimeout(() => scheduleRun('continue-fill'), 140);
     }
   }
 
-  function scheduleRun(reason) {
+  function scheduleRun() {
     if (state.scheduled) return;
     state.scheduled = true;
 
     clearTimeout(state.timer);
     state.timer = setTimeout(() => {
       state.scheduled = false;
-      // Ensure we're still on same page
       const pk = getPageKey();
       if (state.pageKey && pk !== state.pageKey) return;
       runCore().catch(() => {});
     }, 80);
+  }
 
   function bind() {
     if (!$) return;
 
     $(window).off('.ezoicInfinite');
 
-    $(window).on('action:ajaxify.start.ezoicInfinite', () => {
-      cleanup();
-    });
+    $(window).on('action:ajaxify.start.ezoicInfinite', () => cleanup());
 
     $(window).on('action:ajaxify.end.ezoicInfinite', () => {
       state.pageKey = getPageKey();
       ensureObserver();
-      scheduleRun('ajaxify.end');
-      setTimeout(() => scheduleRun('ajaxify.end+250'), 250);
-      setTimeout(() => scheduleRun('ajaxify.end+800'), 800);
+      scheduleRun();
+      setTimeout(scheduleRun, 200);
+      setTimeout(scheduleRun, 700);
     });
 
     $(window).on('action:category.loaded.ezoicInfinite', () => {
       ensureObserver();
-      scheduleRun('category.loaded');
-      setTimeout(() => scheduleRun('category.loaded+250'), 250);
+      scheduleRun();
+      setTimeout(scheduleRun, 250);
     });
 
     $(window).on('action:topics.loaded.ezoicInfinite', () => {
       ensureObserver();
-      scheduleRun('topics.loaded');
-      setTimeout(() => scheduleRun('topics.loaded+150'), 150);
+      scheduleRun();
+      setTimeout(scheduleRun, 150);
     });
 
     $(window).on('action:topic.loaded.ezoicInfinite', () => {
       ensureObserver();
-      scheduleRun('topic.loaded');
-      setTimeout(() => scheduleRun('topic.loaded+200'), 200);
+      scheduleRun();
+      setTimeout(scheduleRun, 200);
     });
 
     $(window).on('action:posts.loaded.ezoicInfinite', () => {
       ensureObserver();
-      scheduleRun('posts.loaded');
-      setTimeout(() => scheduleRun('posts.loaded+150'), 150);
+      scheduleRun();
+      setTimeout(scheduleRun, 150);
     });
   }
 
@@ -480,6 +473,6 @@
   bind();
   ensureObserver();
   state.pageKey = getPageKey();
-  scheduleRun('boot');
-  setTimeout(() => scheduleRun('boot+250'), 250);
+  scheduleRun();
+  setTimeout(scheduleRun, 250);
 })();