nodebb-plugin-ezoic-infinite 1.2.6 → 1.4.0

package/library.js

@@ -34,13 +34,21 @@ async function getAllGroups() {
 async function getSettings() {
   const s = await meta.settings.get(SETTINGS_KEY);
   return {
-    // Between-post ads (simple blocks)
+    // Between-post ads (simple blocks) in category topic list
     enableBetweenAds: parseBool(s.enableBetweenAds, true),
+    showFirstTopicAd: parseBool(s.showFirstTopicAd, false),
     placeholderIds: (s.placeholderIds || '').trim(),
     intervalPosts: Math.max(1, parseInt(s.intervalPosts, 10) || 6),
 
+    // Home/categories list ads (between categories on / or /categories)
+    enableCategoryAds: parseBool(s.enableCategoryAds, false),
+    showFirstCategoryAd: parseBool(s.showFirstCategoryAd, false),
+    categoryPlaceholderIds: (s.categoryPlaceholderIds || '').trim(),
+    intervalCategories: Math.max(1, parseInt(s.intervalCategories, 10) || 4),
+
     // "Ad message" between replies (looks like a post)
     enableMessageAds: parseBool(s.enableMessageAds, false),
+    showFirstMessageAd: parseBool(s.showFirstMessageAd, false),
     messagePlaceholderIds: (s.messagePlaceholderIds || '').trim(),
     messageIntervalPosts: Math.max(1, parseInt(s.messageIntervalPosts, 10) || 3),
 
@@ -88,9 +96,15 @@ plugin.init = async ({ router, middleware }) => {
     res.json({
       excluded,
       enableBetweenAds: settings.enableBetweenAds,
+      showFirstTopicAd: settings.showFirstTopicAd,
       placeholderIds: settings.placeholderIds,
       intervalPosts: settings.intervalPosts,
+      enableCategoryAds: settings.enableCategoryAds,
+      showFirstCategoryAd: settings.showFirstCategoryAd,
+      categoryPlaceholderIds: settings.categoryPlaceholderIds,
+      intervalCategories: settings.intervalCategories,
       enableMessageAds: settings.enableMessageAds,
+      showFirstMessageAd: settings.showFirstMessageAd,
       messagePlaceholderIds: settings.messagePlaceholderIds,
       messageIntervalPosts: settings.messageIntervalPosts,
     });

package/package.json

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

package/public/client.js

@@ -1,21 +1,17 @@
-/* eslint-disable no-console */
 (function () {
   'use strict';
 
-  // Optional debug switch
-  const DEBUG = !!window.__ezoicInfiniteDebug;
-
   const $ = (typeof window.jQuery === 'function') ? window.jQuery : null;
 
   const SELECTORS = {
     topicItem: 'li[component="category/topic"]',
     postItem: '[component="post"][data-pid]',
+    categoryItem: 'li[component="categories/category"]',
   };
 
   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,24 @@
     cfg: null,
     cfgPromise: null,
 
-    // Per-page pools (refilled by recycling)
     poolTopics: [],
     poolPosts: [],
+    poolCategories: [],
 
-    // Track inserted ads per page
     usedTopics: new Set(),
     usedPosts: new Set(),
+    usedCategories: 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';
   }
@@ -87,89 +74,87 @@
   function getKind() {
     const p = window.location.pathname || '';
     if (/^\/topic\//.test(p)) return 'topic';
-    if (/^\/category\//.test(p)) return 'category';
-    // fallback
+    if (/^\/category\//.test(p)) return 'categoryTopics';
+    if (p === '/' || /^\/categories/.test(p)) return 'categories';
+    // fallback by DOM
+    if (document.querySelector(SELECTORS.categoryItem)) return 'categories';
     if (document.querySelector(SELECTORS.postItem)) return 'topic';
-    return 'category';
+    if (document.querySelector(SELECTORS.topicItem)) return 'categoryTopics';
+    return 'other';
   }
 
-
   function getTopicItems() {
     return Array.from(document.querySelectorAll(SELECTORS.topicItem));
   }
 
+  function getCategoryItems() {
+    return Array.from(document.querySelectorAll(SELECTORS.categoryItem));
+  }
+
   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) {
+  function buildWrap(id, kindClass, afterPos) {
     const wrap = document.createElement('div');
-    wrap.className = `${WRAP_CLASS} ${kind}`;
+    wrap.className = `${WRAP_CLASS} ${kindClass}`;
     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));
+      state.usedCategories.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 +164,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 +223,6 @@
           } catch (e) {}
         });
 
-        // short retries
         let tries = 0;
         (function tick() {
           tries += 1;
@@ -249,17 +235,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;
+    const pool = (kind === 'between') ? state.poolTopics : (kind === 'message') ? state.poolPosts : state.poolCategories;
     if (pool.length) return pool.shift();
-    return null; // stop injecting when pool is empty
+    return null;
   }
 
   async function fetchConfig() {
@@ -283,139 +266,80 @@
   }
 
   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);
+    if (state.poolCategories.length === 0) state.poolCategories = parsePool(cfg.categoryPlaceholderIds);
   }
 
-  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 items = getTopicItems();
-    if (!items.length) return 0;
-
-    let inserted = 0;
-    for (let i = 0; i < items.length; i++) {
-      const li = items[i];
-      if (!li || !li.isConnected) continue;
-
-      // Avoid re-processing anchors already evaluated
-      if (state.seenTopicAnchors.has(li)) continue;
-
-      const pos = i + 1;
-      const ok = (first && pos === 1) || (pos % interval === 0);
-      state.seenTopicAnchors.add(li);
-      if (!ok) continue;
-
-      if (hasAdImmediatelyAfter(li)) continue;
-
-      const id = nextId('between');
-      if (!id) break;
-
-      state.usedTopics.add(id);
-      const wrap = insertAfter(li, id, 'ezoic-ad-between', pos);
-      if (!wrap) continue;
-
-      inserted += 1;
-
-      callShowAdsWhenReady(id);
-
-      if (inserted >= MAX_INSERTS_PER_RUN) break;
+  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);
     }
-    return inserted;
+    return Array.from(new Set(out)).sort((a, b) => a - b);
   }
 
-  function injectPosts(cfg) {
-    if (!normalizeBool(cfg.enableMessageAds)) return 0;
-
-    const interval = Math.max(1, parseInt(cfg.messageIntervalPosts, 10) || 3);
-    const first = normalizeBool(cfg.showFirstMessageAd);
-
-    const posts = getPostContainers();
-    if (!posts.length) return 0;
+  function injectBetween(kindClass, items, interval, showFirst, kindPool, usedSet) {
+    if (!items.length) return 0;
+    const targets = computeTargets(items.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 el = items[afterPos - 1];
+      if (!el || !el.isConnected) continue;
 
-      const no = i + 1;
-      const ok = (first && no === 1) || (no % interval === 0);
-      state.seenPostAnchors.add(post);
-      if (!ok) continue;
+      // Prevent back-to-back at load
+      const prevWrap = findWrap(kindClass, afterPos - 1);
+      if (prevWrap) continue;
 
-      if (hasAdImmediatelyAfter(post)) continue;
+      if (findWrap(kindClass, afterPos)) continue;
 
-      const id = nextId('message');
+      const id = nextId(kindPool);
       if (!id) break;
 
-      state.usedPosts.add(id);
-      const wrap = insertAfter(post, id, 'ezoic-ad-message', no);
+      usedSet.add(id);
+      const wrap = insertAfter(el, id, kindClass, afterPos);
       if (!wrap) continue;
 
-      inserted += 1;
-
       callShowAdsWhenReady(id);
-
-      if (inserted >= MAX_INSERTS_PER_RUN) break;
+      inserted += 1;
     }
     return inserted;
   }
 
-
-  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 {
-        // queue for when ezstandalone becomes ready
-        window.ezstandalone.cmd.push(call);
-      }
-    } catch (e) {}
+  function enforceNoAdjacentAds() {
+    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() {
-    // Destroy slots for IDs we used on the previous view before we reuse the same IDs on the next page
     destroyUsedPlaceholders();
+
     state.pageKey = getPageKey();
     state.cfg = null;
     state.cfgPromise = null;
 
     state.poolTopics = [];
     state.poolPosts = [];
+    state.poolCategories = [];
     state.usedTopics.clear();
     state.usedPosts.clear();
-
-    state.seenTopicAnchors = new WeakSet();
-    state.seenPostAnchors = new WeakSet();
+    state.usedCategories.clear();
 
     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; }
@@ -426,14 +350,13 @@
 
   function ensureObserver() {
     if (state.obs) return;
-    state.obs = new MutationObserver(() => scheduleRun('dom-mutation'));
+    state.obs = new MutationObserver(() => scheduleRun('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() {
     patchShowAds();
-    patchShowAds();
 
     const cfg = await fetchConfig();
     if (!cfg || cfg.excluded) return;
@@ -443,77 +366,106 @@
     const kind = getKind();
     let inserted = 0;
 
-    if (kind === 'topic') inserted = injectPosts(cfg);
-    else inserted = injectTopics(cfg);
+    if (kind === 'topic') {
+      if (normalizeBool(cfg.enableMessageAds)) {
+        inserted = injectBetween('ezoic-ad-message', getPostContainers(),
+          Math.max(1, parseInt(cfg.messageIntervalPosts, 10) || 3),
+          normalizeBool(cfg.showFirstMessageAd),
+          'message',
+          state.usedPosts);
+      }
+    } else if (kind === 'categoryTopics') {
+      if (normalizeBool(cfg.enableBetweenAds)) {
+        inserted = injectBetween('ezoic-ad-between', getTopicItems(),
+          Math.max(1, parseInt(cfg.intervalPosts, 10) || 6),
+          normalizeBool(cfg.showFirstTopicAd),
+          'between',
+          state.usedTopics);
+      }
+    } else if (kind === 'categories') {
+      if (normalizeBool(cfg.enableCategoryAds)) {
+        inserted = injectBetween('ezoic-ad-categories', getCategoryItems(),
+          Math.max(1, parseInt(cfg.intervalCategories, 10) || 4),
+          normalizeBool(cfg.showFirstCategoryAd),
+          'categories',
+          state.usedCategories);
+      }
+    }
 
     enforceNoAdjacentAds();
 
-    // If we inserted max per run, schedule another pass to gradually fill (avoids “burst”)
-    if (inserted >= MAX_INSERTS_PER_RUN) {
-      setTimeout(() => scheduleRun('continue-fill'), 120);
+    // If nothing inserted and list isn't in DOM yet (first click), retry a bit
+    let count = 0;
+    if (kind === 'topic') count = getPostContainers().length;
+    else if (kind === 'categoryTopics') count = getTopicItems().length;
+    else if (kind === 'categories') count = getCategoryItems().length;
+
+    if (count === 0 && state.attempts < 25) {
+      state.attempts += 1;
+      setTimeout(() => scheduleRun('await-items'), 120);
+      return;
     }
+
+    if (inserted >= MAX_INSERTS_PER_RUN) setTimeout(() => scheduleRun('continue'), 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);
     });
   }
 
-  // Boot
   cleanup();
   bind();
   ensureObserver();
   state.pageKey = getPageKey();
-  scheduleRun('boot');
-  setTimeout(() => scheduleRun('boot+250'), 250);
-})();
+  scheduleRun();
+  setTimeout(scheduleRun, 250);
+})();

package/public/templates/admin/plugins/ezoic-infinite.tpl

@@ -26,6 +26,32 @@
 
     <hr/>
 
+
+    <hr/>
+
+    <h4 class="mt-3">Pubs entre les catégories (page d’accueil)</h4>
+    <p class="form-text">Insère des pubs entre les catégories sur la page d’accueil (liste des catégories).</p>
+
+    <div class="form-check mb-3">
+      <input class="form-check-input" type="checkbox" id="enableCategoryAds" name="enableCategoryAds">
+      <label class="form-check-label" for="enableCategoryAds">Activer les pubs entre les catégories</label>
+      <div class="form-check mt-2">
+        <input class="form-check-input" type="checkbox" name="showFirstCategoryAd" />
+        <label class="form-check-label">Afficher une pub après la 1ère catégorie</label>
+      </div>
+    </div>
+
+    <div class="mb-3">
+      <label class="form-label" for="categoryPlaceholderIds">Pool d’IDs Ezoic (catégories)</label>
+      <textarea id="categoryPlaceholderIds" name="categoryPlaceholderIds" class="form-control" rows="4">{categoryPlaceholderIds}</textarea>
+      <p class="form-text">IDs numériques, un par ligne. Utilise un pool dédié (différent des pools topics/messages).</p>
+    </div>
+
+    <div class="mb-3">
+      <label class="form-label" for="intervalCategories">Afficher une pub toutes les N catégories</label>
+      <input type="number" id="intervalCategories" name="intervalCategories" class="form-control" value="{intervalCategories}" min="1">
+    </div>
+
     <h4 class="mt-3">Pubs “message” entre les réponses</h4>
     <p class="form-text">Insère un bloc qui ressemble à un post, toutes les N réponses (dans une page topic).</p>