nodebb-plugin-ezoic-infinite 1.3.0 → 1.4.2

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.3.0",
+  "version": "1.4.2",
   "description": "Production-ready Ezoic infinite ads integration for NodeBB 4.x",
   "main": "library.js",
   "license": "MIT",

package/public/client.js

@@ -1,4 +1,3 @@
-/* eslint-disable no-console */
 (function () {
   'use strict';
 
@@ -7,6 +6,7 @@
   const SELECTORS = {
     topicItem: 'li[component="category/topic"]',
     postItem: '[component="post"][data-pid]',
+    categoryItem: 'li[component="categories/category"]',
   };
 
   const WRAP_CLASS = 'ezoic-ad';
@@ -21,9 +21,17 @@
 
     poolTopics: [],
     poolPosts: [],
+    poolCategories: [],
 
     usedTopics: new Set(),
     usedPosts: new Set(),
+    usedCategories: new Set(),
+
+    // wrappers currently on page (FIFO for recycling)
+    liveBetween: [],
+    liveMessage: [],
+    liveCategory: [],
+    usedCategories: new Set(),
 
     lastShowById: new Map(),
     pendingById: new Set(),
@@ -72,15 +80,23 @@
   function getKind() {
     const p = window.location.pathname || '';
     if (/^\/topic\//.test(p)) return 'topic';
-    if (/^\/category\//.test(p)) return 'category';
-    if (document.querySelector('[component="topic"]') || document.querySelector('[component="post"][data-pid]')) return 'topic';
-    return 'category';
+    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';
+    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() {
     const nodes = Array.from(document.querySelectorAll(SELECTORS.postItem));
     return nodes.filter((el) => {
@@ -93,9 +109,63 @@
     });
   }
 
-  function buildWrap(id, kind, afterPos) {
+
+  function safeRect(el) {
+    try { return el.getBoundingClientRect(); } catch (e) { return null; }
+  }
+
+  function destroyPlaceholderIds(ids) {
+    if (!ids || !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) {}
+  }
+
+  function getRecyclable(liveArr) {
+    const margin = 1800;
+    for (let i = 0; i < liveArr.length; i++) {
+      const entry = liveArr[i];
+      if (!entry || !entry.wrap || !entry.wrap.isConnected) { liveArr.splice(i, 1); i--; continue; }
+      const r = safeRect(entry.wrap);
+      if (r && r.bottom < -margin) {
+        liveArr.splice(i, 1);
+        return entry;
+      }
+    }
+    return null;
+  }
+
+  function moveWrapAfter(wrap, target, kindClass, afterPos) {
+    try {
+      wrap.className = `${WRAP_CLASS} ${kindClass}`;
+      wrap.setAttribute('data-ezoic-after', String(afterPos));
+      target.insertAdjacentElement('afterend', wrap);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+
+  function pickId(pool, liveArr) {
+    if (pool.length) return { id: pool.shift(), recycled: null };
+    const recycled = getRecyclable(liveArr);
+    if (recycled) return { id: recycled.id, recycled };
+    return { id: null, recycled: null };
+  }
+
+  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%';
 
@@ -122,15 +192,10 @@
     try {
       state.usedTopics.forEach((id) => ids.push(id));
       state.usedPosts.forEach((id) => ids.push(id));
+      state.usedCategories && 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);
-        }
+    destroyPlaceholderIds(ids);
+  }
       } catch (e) {}
     };
 
@@ -228,9 +293,9 @@
     })();
   }
 
-  function nextId(kind) {
-    const pool = (kind === 'between') ? state.poolTopics : state.poolPosts;
-    if (pool.length) return pool.shift();
+  function nextId(pool) {
+    // backward compatible: the injector passes the pool array
+    if (Array.isArray(pool) && pool.length) return pool.shift();
     return null;
   }
 
@@ -257,6 +322,7 @@
   function initPools(cfg) {
     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 computeTargets(count, interval, showFirst) {
@@ -266,77 +332,46 @@
     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 showFirst = normalizeBool(cfg.showFirstTopicAd);
-
-    const items = getTopicItems();
+  function injectBetween(kindClass, items, interval, showFirst, kindPool, usedSet) {
     if (!items.length) return 0;
-
     const targets = computeTargets(items.length, interval, showFirst);
 
     let inserted = 0;
     for (const afterPos of targets) {
       if (inserted >= MAX_INSERTS_PER_RUN) break;
 
-      const li = items[afterPos - 1];
-      if (!li || !li.isConnected) continue;
+      const el = items[afterPos - 1];
+      if (!el || !el.isConnected) 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);
+      // Prevent back-to-back at load
+      const prevWrap = findWrap(kindClass, afterPos - 1);
       if (prevWrap) 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', afterPos);
-      if (!wrap) continue;
-
-      callShowAdsWhenReady(id);
-      inserted += 1;
-    }
-    return inserted;
-  }
-
-  function injectPosts(cfg) {
-    if (!normalizeBool(cfg.enableMessageAds)) return 0;
-
-    const interval = Math.max(1, parseInt(cfg.messageIntervalPosts, 10) || 3);
-    const showFirst = normalizeBool(cfg.showFirstMessageAd);
-
-    const posts = getPostContainers();
-    if (!posts.length) return 0;
-
-    const targets = computeTargets(posts.length, interval, showFirst);
-
-    let inserted = 0;
-    for (const afterPos of targets) {
-      if (inserted >= MAX_INSERTS_PER_RUN) break;
-
-      const post = posts[afterPos - 1];
-      if (!post || !post.isConnected) continue;
+      if (findWrap(kindClass, afterPos)) continue;
 
-      const prevWrap = findWrap('ezoic-ad-message', afterPos - 1);
-      if (prevWrap) continue;
-
-      if (findWrap('ezoic-ad-message', afterPos)) continue;
+      const liveArr = (kindClass === 'ezoic-ad-between') ? state.liveBetween
+        : (kindClass === 'ezoic-ad-message') ? state.liveMessage
+        : state.liveCategory;
 
-      const id = nextId('message');
+      const pick = pickId(kindPool, liveArr);
+      const id = pick.id;
       if (!id) break;
 
-      state.usedPosts.add(id);
-      const wrap = insertAfter(post, id, 'ezoic-ad-message', afterPos);
-      if (!wrap) continue;
+      let wrap = null;
+      if (pick.recycled && pick.recycled.wrap) {
+        destroyPlaceholderIds([id]);
+        wrap = pick.recycled.wrap;
+        if (!moveWrapAfter(wrap, el, kindClass, afterPos)) continue;
+      } else {
+        usedSet.add(id);
+        wrap = insertAfter(el, id, kindClass, afterPos);
+        if (!wrap) continue;
+      }
 
+      liveArr.push({ id, wrap });
       callShowAdsWhenReady(id);
       inserted += 1;
     }
@@ -344,7 +379,6 @@
   }
 
   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];
@@ -363,8 +397,15 @@
 
     state.poolTopics = [];
     state.poolPosts = [];
+    state.poolCategories = [];
+    state.poolCategories = [];
     state.usedTopics.clear();
     state.usedPosts.clear();
+    state.usedCategories && state.usedCategories.clear();
+    state.liveBetween = [];
+    state.liveMessage = [];
+    state.liveCategory = [];
+    state.usedCategories.clear();
 
     state.lastShowById = new Map();
     state.pendingById = new Set();
@@ -381,7 +422,7 @@
 
   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; } }, 15000);
   }
@@ -397,22 +438,47 @@
     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 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) {
+    // 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-fill'), 140);
-    }
+    if (inserted >= MAX_INSERTS_PER_RUN) setTimeout(() => scheduleRun('continue'), 140);
   }
 
   function scheduleRun() {
@@ -468,11 +534,10 @@
     });
   }
 
-  // Boot
   cleanup();
   bind();
   ensureObserver();
   state.pageKey = getPageKey();
   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>