nodebb-plugin-ezoic-infinite 1.4.68 → 1.4.69

package/package.json

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

package/public/client.js

@@ -1,828 +1,450 @@
 (function () {
   'use strict';
-  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"]',
-  }, WRAP_CLASS = 'ezoic-ad';
-  const PLACEHOLDER_PREFIX = 'ezoic-pub-ad-placeholder-', MAX_INSERTS_PER_RUN = 3;
-
-  const sessionDefinedIds = new Set();
-
-  const insertingIds = new Set(), state = {
-  pageKey: null,
-  cfg: null,
-  cfgPromise: null,
 
-  poolTopics: [],
-  poolPosts: [],
-  poolCategories: [],
+  /**
+   * NodeBB + Ezoic infinite ad injector
+   * Production-ready refactor:
+   * - No blank space: wrappers hidden until filled, removed on timeout
+   * - Bounded work per tick + throttled MutationObserver
+   * - Clean ajaxify navigation handling
+   */
 
-  usedTopics: new Set(),
-  usedPosts: new Set(),
-  usedCategories: new Set(),
+  const SELECTORS = {
+    topicItem: 'li[component="category/topic"]',
+    categoryItem: 'li[component="categories/category"]',
+    postItem: '[component="post"][data-pid]',
+    postContent: '[component="post/content"]',
+  };
 
-  lastShowById: new Map(),
-  pendingById: new Set(),
-  definedIds: new Set(),
+  const CLASS_WRAP = 'ezoic-ad';
+  const PH_PREFIX = 'ezoic-pub-ad-placeholder-';
 
-  scheduled: false,
-  timer: null,
+  const MAX_INSERTS_PER_TICK = 3;
+  const FILL_TIMEOUT_MS = 3500;
+  const RECYCLE_MARGIN_PX = 600;
+  const SHOW_DEBOUNCE_MS = 500;
 
-  obs: null,
-  activeTimeouts: new Set(),
-  lastScrollRun: 0, };
+  const state = {
+    pageKey: null,
+    cfg: null,
+    cfgPromise: null,
 
-  function normalizeBool(v) {
-  return v === true || v === 'true' || v === 1 || v === '1' || v === 'on';
-  }
+    pools: { topics: [], categories: [], messages: [] },
+    live: { topics: [], categories: [], messages: [] },
 
-  function uniqInts(lines) {
-  const out = [], seen = new Set();
-  for (const v of lines) {
-  const n = parseInt(v, 10);
-  if (Number.isFinite(n) && n > 0 && !seen.has(n)) {
-  seen.add(n);
-  out.push(n);
-  }
-  }
-  return out;
-  }
+    scheduled: false,
+    lastRunAt: 0,
+    timeouts: new Set(),
+    observer: null,
+    lastShowById: new Map(),
+  };
 
-  function parsePool(raw) {
-  if (!raw) return [];
-  const lines = String(raw).split(/\r?\n/).map(s => s.trim()).filter(Boolean);
-  return uniqInts(lines);
-  }
+  function now() { return Date.now(); }
 
   function getPageKey() {
-  try {
-  const ax = window.ajaxify;
-  if (ax && ax.data) {
-  if (ax.data.tid) return `topic:${ax.data.tid}`;
-  if (ax.data.cid) return `cid:${ax.data.cid}:${window.location.pathname}`;
-  }
-  } catch (e) {}
-  return window.location.pathname;
+    try {
+      const ax = window.ajaxify;
+      if (ax && ax.data) {
+        if (ax.data.tid) return `topic:${ax.data.tid}`;
+        if (ax.data.cid) return `cid:${ax.data.cid}:${window.location.pathname}`;
+      }
+    } catch (e) {}
+    return window.location.pathname || '';
   }
 
   function getKind() {
-  const p = window.location.pathname || '';
-  if (/^\/topic\//.test(p)) return 'topic';
-  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) => {
-  if (!el || !el.isConnected) return false;
-  if (!el.querySelector('[component="post/content"]')) return false;
-  const parentPost = el.parentElement && el.parentElement.closest('[component="post"][data-pid]');
-  if (parentPost && parentPost !== el) return false;
-  if (el.getAttribute('component') === 'post/parent') return false;
-  return true;
-  });
-  }
-
-  function safeRect(el) {
-  try { return el.getBoundingClientRect(); } catch (e) { return null; }
-  }
-
-  function destroyPlaceholderIds(ids) {
-  if (!ids || !ids.length) return;
-  const filtered = ids.filter((id) => {
-  try { return sessionDefinedIds.has(id); } catch (e) { return true; }
-  });
-  if (!filtered.length) return;
-
-  const call = () => {
-  try {
-  if (window.ezstandalone && typeof window.ezstandalone.destroyPlaceholders === 'function') {
-  window.ezstandalone.destroyPlaceholders(filtered);
-  }
-  } catch (e) {}
-
-  // Recyclage: libérer IDs après 100ms
-  setTimeout(() => {
-  filtered.forEach(id => sessionDefinedIds.delete(id));
-  }, 100);
-  };
-  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) {}
-
-  // Recyclage: libérer IDs après 100ms
-  setTimeout(() => {
-  filtered.forEach(id => sessionDefinedIds.delete(id));
-  }, 100);
-  }
-
-  // Nettoyer éléments Ezoic invisibles qui créent espace vertical
-  function cleanupInvisibleEzoicElements() {
-  try {
-  document.querySelectorAll('.ezoic-ad').forEach(wrapper => {
-  const ph = wrapper.querySelector('[id^="ezoic-pub-ad-placeholder-"]');
-  if (!ph) return;
-  
-  // Supprimer TOUS les éléments après le placeholder rempli
-  // qui créent de l'espace vertical
-  let found = false;
-  Array.from(wrapper.children).forEach(child => {
-  if (child === ph || child.contains(ph)) {
-  found = true;
-  return;
-  }
-  
-  // Si élément APRÈS le placeholder
-  if (found) {
-  const rect = child.getBoundingClientRect();
-  const computed = window.getComputedStyle(child);
-  
-  // Supprimer si:
-  // 1. Height > 0 mais pas de texte/image visible
-  // 2. Ou opacity: 0
-  // 3. Ou visibility: hidden
-  const hasContent = child.textContent.trim().length > 0 || 
-                    child.querySelector('img, iframe, video');
-  
-  if (!hasContent || computed.opacity === '0' || computed.visibility === 'hidden') {
-  child.remove();
-  }
-  }
-  });
-  });
-  } catch (e) {}
-  }
-
-  function cleanupEmptyWrappers() {
-  try {
-  document.querySelectorAll('.ezoic-ad').forEach(wrapper => {
-  const ph = wrapper.querySelector('[id^="ezoic-pub-ad-placeholder-"]');
-  if (ph && ph.children.length === 0) {
-  // Placeholder vide après 3s = pub non chargée
-  setTimeout(() => {
-  if (ph.children.length === 0) {
-  wrapper.remove();
-  }
-  }, 1500);
-  }
-  });
-  } catch (e) {}
-  }
-
-  function getRecyclable(liveArr) {
-  const margin = 600;
-  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 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 };
+    const p = window.location.pathname || '';
+    if (/^\/topic\//.test(p)) return 'topic';
+    if (/^\/category\//.test(p)) return 'categoryTopics';
+    if (p === '/' || /^\/categories/.test(p)) return 'categories';
+
+    if (document.querySelector(SELECTORS.categoryItem)) return 'categories';
+    if (document.querySelector(SELECTORS.postItem)) return 'topic';
+    if (document.querySelector(SELECTORS.topicItem)) return 'categoryTopics';
+    return 'other';
+  }
+
+  function parseIdPool(raw) {
+    if (!raw) return [];
+    const tokens = String(raw)
+      .split(/[\s,;]+/)
+      .map(s => s.trim())
+      .filter(Boolean);
+
+    const out = [];
+    const seen = new Set();
+    for (const t of tokens) {
+      const n = parseInt(t, 10);
+      if (Number.isFinite(n) && n > 0 && !seen.has(n)) {
+        seen.add(n);
+        out.push(n);
+      }
+    }
+    return out;
   }
 
-  function resetPlaceholderInWrap(wrap, id) {
-  try {
-  if (!wrap) return;
-  try { wrap.removeAttribute('data-ezoic-filled'); } catch (e) {}
-  if (wrap.__ezoicFillObs) { wrap.__ezoicFillObs.disconnect(); wrap.__ezoicFillObs = null; }
-  const old = wrap.querySelector && wrap.querySelector(`#${PLACEHOLDER_PREFIX}${id}`);
-  if (old) old.remove();
-  // Remove any leftover markup inside wrapper
-  wrap.querySelectorAll && wrap.querySelectorAll('iframe, ins').forEach(n => n.remove());
-  const ph = document.createElement('div');
-  ph.id = `${PLACEHOLDER_PREFIX}${id}`;
-  wrap.appendChild(ph);
-  } catch (e) {}
-  }
-
-  function isAdjacentAd(target) {
-  if (!target || !target.nextElementSibling) return false;
-  const next = target.nextElementSibling;
-  if (next && next.classList && next.classList.contains(WRAP_CLASS)) return true;
-  return false;
-  }
-
-  function isPrevAd(target) {
-  if (!target || !target.previousElementSibling) return false;
-  const prev = target.previousElementSibling;
-  if (prev && prev.classList && prev.classList.contains(WRAP_CLASS)) return true;
-  return false;
-  }
-
-  function buildWrap(id, kindClass, afterPos) {
-  const wrap = document.createElement('div');
-  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 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;
-  if (findWrap(kindClass, afterPos)) return null;
-
-  // CRITICAL: Double-lock pour éviter race conditions sur les doublons
-  if (insertingIds.has(id)) return null;
-
-  const existingPh = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
-  if (existingPh && existingPh.isConnected) return null;
-
-  // Acquérir le lock
-  insertingIds.add(id);
-
-  try {
-  const wrap = buildWrap(id, kindClass, afterPos);
-  target.insertAdjacentElement('afterend', wrap);
-  attachFillObserver(wrap, id);
-  return wrap;
-  } finally {
-  setTimeout(() => insertingIds.delete(id), 50);
-  }
-  }
-
-  function destroyUsedPlaceholders() {
-  const ids = [...state.usedTopics, ...state.usedPosts, ...state.usedCategories];
-  if (ids.length) destroyPlaceholderIds(ids);
-  }
-
-  function patchShowAds() {
-  const applyPatch = () => {
-  try {
-  window.ezstandalone = window.ezstandalone || {}, ez = window.ezstandalone;
-  if (window.__nodebbEzoicPatched) return;
-  if (typeof ez.showAds !== 'function') return;
-
-  window.__nodebbEzoicPatched = true;
-  const orig = ez.showAds;
-
-  ez.showAds = function (arg) {
-  if (Array.isArray(arg)) {
-  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;
-  }
-  return orig.apply(ez, arguments);
-  };
-  } catch (e) {}
-  };
-
-  applyPatch();
-  if (!window.__nodebbEzoicPatched) {
-  try {
-  window.ezstandalone = window.ezstandalone || {};
-  window.ezstandalone.cmd = window.ezstandalone.cmd || [];
-  window.ezstandalone.cmd.push(applyPatch);
-  } catch (e) {}
-  }
+  async function fetchConfig() {
+    if (state.cfg) return state.cfg;
+    if (state.cfgPromise) return state.cfgPromise;
+
+    state.cfgPromise = fetch('/api/plugins/ezoic-infinite/config', {
+      credentials: 'same-origin',
+      headers: { 'Accept': 'application/json' },
+    })
+      .then(r => (r && r.ok ? r.json() : null))
+      .catch(() => null)
+      .then((cfg) => {
+        state.cfg = cfg || { excluded: true };
+        state.pools.topics = parseIdPool(state.cfg.placeholderIds);
+        state.pools.categories = parseIdPool(state.cfg.categoryPlaceholderIds);
+        state.pools.messages = parseIdPool(state.cfg.messagePlaceholderIds);
+        return state.cfg;
+      })
+      .finally(() => { state.cfgPromise = null; });
+
+    return state.cfgPromise;
+  }
+
+  function rect(el) {
+    try { return el.getBoundingClientRect(); } catch (e) { return null; }
+  }
+
+  function takeRecyclable(kind) {
+    const arr = state.live[kind];
+    for (let i = 0; i < arr.length; i++) {
+      const entry = arr[i];
+      if (!entry || !entry.wrap || !entry.wrap.isConnected) {
+        arr.splice(i, 1); i--; continue;
+      }
+      const r = rect(entry.wrap);
+      if (r && r.bottom < -RECYCLE_MARGIN_PX) {
+        arr.splice(i, 1);
+        return entry;
+      }
+    }
+    return null;
+  }
+
+  function pickId(kind) {
+    const pool = state.pools[kind];
+    if (pool && pool.length) return { id: pool.shift(), recycled: null };
+    const recycled = takeRecyclable(kind);
+    if (recycled) return { id: recycled.id, recycled };
+    return { id: null, recycled: null };
+  }
+
+  function buildWrap(kind, afterIndex, id) {
+    const wrap = document.createElement('div');
+    wrap.className = `${CLASS_WRAP} ${CLASS_WRAP}--${kind}`;
+    wrap.dataset.ezoicKind = kind;
+    wrap.dataset.ezoicAfter = String(afterIndex);
+    wrap.dataset.ezoicId = String(id);
+
+    const ph = document.createElement('div');
+    ph.id = `${PH_PREFIX}${id}`;
+    wrap.appendChild(ph);
+
+    return wrap;
+  }
+
+  function findWrap(kind, afterIndex) {
+    return document.querySelector(`.${CLASS_WRAP}[data-ezoic-kind="${kind}"][data-ezoic-after="${afterIndex}"]`);
+  }
+
+  function resetWrapPlaceholder(wrap, id) {
+    if (!wrap) return;
+    if (wrap.__ezoicObs) {
+      try { wrap.__ezoicObs.disconnect(); } catch (e) {}
+      wrap.__ezoicObs = null;
+    }
+    wrap.removeAttribute('data-ezoic-filled');
+    wrap.dataset.ezoicId = String(id);
+
+    while (wrap.firstChild) wrap.removeChild(wrap.firstChild);
+    const ph = document.createElement('div');
+    ph.id = `${PH_PREFIX}${id}`;
+    wrap.appendChild(ph);
+  }
+
+  function forcePlaceholderAutoHeight(wrap, id) {
+    const ph = wrap && wrap.querySelector ? wrap.querySelector(`#${PH_PREFIX}${id}`) : null;
+    if (!ph) return;
+    ph.style.setProperty('height', 'auto', 'important');
+    ph.style.setProperty('min-height', '0px', 'important');
+    requestAnimationFrame(() => {
+      ph.style.setProperty('height', 'auto', 'important');
+      ph.style.setProperty('min-height', '0px', 'important');
+    });
   }
 
   function markFilled(wrap) {
-  try {
-  if (!wrap) return;
-  if (wrap.__ezoicFillObs) { wrap.__ezoicFillObs.disconnect(); wrap.__ezoicFillObs = null; }
-  wrap.setAttribute('data-ezoic-filled', '1');
-  } catch (e) {}
-  }
-
-  function isWrapMarkedFilled(wrap) {
-  try { return wrap && wrap.getAttribute && wrap.getAttribute('data-ezoic-filled') === '1'; } catch (e) { return false; }
-  }
+    if (!wrap || !wrap.isConnected) return;
+    if (wrap.getAttribute('data-ezoic-filled') === '1') return;
+    wrap.setAttribute('data-ezoic-filled', '1');
+
+    const id = parseInt(wrap.dataset.ezoicId, 10);
+    if (Number.isFinite(id) && id > 0) forcePlaceholderAutoHeight(wrap, id);
+  }
+
+  function removeWrap(wrap) {
+    if (!wrap) return;
+    if (wrap.__ezoicObs) {
+      try { wrap.__ezoicObs.disconnect(); } catch (e) {}
+      wrap.__ezoicObs = null;
+    }
+    try { wrap.remove(); } catch (e) {}
+  }
+
+  function showEzoicAd(id) {
+    if (!id || id <= 0) return;
+
+    const last = state.lastShowById.get(id) || 0;
+    if (now() - last < SHOW_DEBOUNCE_MS) return;
+    state.lastShowById.set(id, now());
+
+    const call = () => {
+      try {
+        if (window.ezstandalone && typeof window.ezstandalone.showAds === 'function') {
+          window.ezstandalone.showAds(id);
+        }
+      } catch (e) {}
+    };
+
+    try {
+      window.ezstandalone = window.ezstandalone || {};
+      window.ezstandalone.cmd = window.ezstandalone.cmd || [];
+      if (typeof window.ezstandalone.showAds === 'function') call();
+      else window.ezstandalone.cmd.push(call);
+    } catch (e) {}
+  }
+
+  function observeFill(wrap, id) {
+    const ph = wrap.querySelector(`#${PH_PREFIX}${id}`);
+    if (!ph) return;
+
+    // immediate
+    if (ph.querySelector('iframe, ins, img') || ph.childElementCount > 0) {
+      markFilled(wrap);
+      return;
+    }
 
-  function attachFillObserver(wrap, id) {
-  try {
-  const ph = wrap && wrap.querySelector && wrap.querySelector(`#${PLACEHOLDER_PREFIX}${id}`);
-  if (!ph) return;
-  // Already filled?
-  if (ph.childNodes && ph.childNodes.length > 0) {
-  markFilled(wrap); // Afficher wrapper
-  sessionDefinedIds.add(id);
-  return;
-  }
-  const obs = new MutationObserver(() => {
-  if (ph.childNodes && ph.childNodes.length > 0) {
-  markFilled(wrap); // CRITIQUE: Afficher wrapper maintenant
-  try { sessionDefinedIds.add(id); } catch (e) {}
-  try { obs.disconnect(); } catch (e) {}
-  }
-  });
-  obs.observe(ph, { childList: true, subtree: true });
-  wrap.__ezoicFillObs = obs;
-  } catch (e) {}
-  }
+    const obs = new MutationObserver(() => {
+      if (!wrap.isConnected) return;
+      const hasCreative = !!ph.querySelector('iframe, ins, img');
+      const r = rect(ph);
+      if (hasCreative || (r && r.height > 20)) {
+        markFilled(wrap);
+        try { obs.disconnect(); } catch (e) {}
+        wrap.__ezoicObs = null;
+      }
+    });
 
-  function isPlaceholderFilled(id) {
-  const ph = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
-  if (!ph || !ph.isConnected) return false;
+    wrap.__ezoicObs = obs;
+    try { obs.observe(ph, { childList: true, subtree: true, attributes: true }); } catch (e) {}
+  }
 
-  const wrap = ph.parentElement;
-  if (wrap && isWrapMarkedFilled(wrap)) return true;
-
-  const filled = !!(ph.childNodes && ph.childNodes.length > 0);
-  if (filled) {
-  try { state.definedIds && state.definedIds.add(id); sessionDefinedIds.add(id); } catch (e) {}
-  try { markFilled(wrap); } catch (e) {}
+  function scheduleRemovalIfUnfilled(wrap, kind, id) {
+    const t = setTimeout(() => {
+      state.timeouts.delete(t);
+      if (!wrap || !wrap.isConnected) return;
+      if (wrap.getAttribute('data-ezoic-filled') === '1') return;
+      removeWrap(wrap);
+      if (state.pools[kind] && typeof id === 'number' && id > 0) state.pools[kind].push(id);
+    }, FILL_TIMEOUT_MS);
+    state.timeouts.add(t);
   }
-  return filled;
+
+  function insertAfter(target, wrap) {
+    if (!target || !wrap) return false;
+    const next = target.nextElementSibling;
+    if (next && next.classList && next.classList.contains(CLASS_WRAP)) return false;
+    try {
+      target.insertAdjacentElement('afterend', wrap);
+      return true;
+    } catch (e) {
+      return false;
+    }
   }
-
-  let batchShowAdsTimer = null;
-  const pendingShowAdsIds = new Set();
-
-  function scheduleShowAdsBatch(id) {
-  if (!id) return;
-
-  if (sessionDefinedIds.has(id)) {
-  try {
-  destroyPlaceholderIds([id]);
-  sessionDefinedIds.delete(id);
-  } catch (e) {}
+
+  function computeAfterIndexes(count, interval, showFirst) {
+    const out = [];
+    const step = Math.max(1, parseInt(interval, 10) || 1);
+    const start = showFirst ? 1 : step;
+    for (let i = start; i < count; i += step) out.push(i);
+    return out;
   }
 
-  // Throttle: ne pas rappeler le même ID trop vite
-  const now = Date.now(), last = state.lastShowById.get(id) || 0;
-  if (now - last < 3500) return;
-
-  // Ajouter à la batch
-  pendingShowAdsIds.add(id);
-
-  clearTimeout(batchShowAdsTimer);
-  batchShowAdsTimer = setTimeout(() => {
-  if (pendingShowAdsIds.size === 0) return;
-
-  const idsArray = Array.from(pendingShowAdsIds);
-  pendingShowAdsIds.clear();
-
-  // Appeler showAds avec TOUS les IDs en une fois
-  try {
-  window.ezstandalone = window.ezstandalone || {};
-  window.ezstandalone.cmd = window.ezstandalone.cmd || [];
-  window.ezstandalone.cmd.push(function() {
-  if (typeof window.ezstandalone.showAds === 'function') {
-  // Appel batch: showAds(id1, id2, id3...)
-  window.ezstandalone.showAds(...idsArray);
-  // Tracker tous les IDs
-  idsArray.forEach(id => {
-  state.lastShowById.set(id, Date.now());
-  sessionDefinedIds.add(id);
-  });
-  }
-  });
-  } catch (e) {}
-  
-  // CRITIQUE: Nettoyer éléments invisibles APRÈS que pubs soient chargées
-  setTimeout(() => {
-  cleanupInvisibleEzoicElements();
-  }, 800); // 1.5s pour laisser Ezoic charger
-  }, 100);
-  }
+  function runCategoryTopics(cfg) {
+    if (!cfg.enableBetweenAds) return;
 
-  function callShowAdsWhenReady(id) {
-  if (!id) return;
+    const items = Array.from(document.querySelectorAll(SELECTORS.topicItem));
+    if (!items.length) return;
 
-  const now = Date.now(), last = state.lastShowById.get(id) || 0;
-  if (now - last < 3500) return;
+    const after = computeAfterIndexes(items.length, cfg.intervalPosts || 6, !!cfg.showFirstTopicAd);
+    let inserts = 0;
 
-  const phId = `${PLACEHOLDER_PREFIX}${id}`, doCall = () => {
-  try {
-  window.ezstandalone = window.ezstandalone || {};
-  if (typeof window.ezstandalone.showAds === 'function') {
+    for (const afterIndex of after) {
+      if (inserts >= MAX_INSERTS_PER_TICK) break;
+      const anchor = items[afterIndex - 1];
+      if (!anchor) continue;
+      if (findWrap('topics', afterIndex)) continue;
 
-  state.lastShowById.set(id, Date.now());
-  window.ezstandalone.showAds(id);
-  sessionDefinedIds.add(id);
-  return true;
-  }
-  } catch (e) {}
-  return false;
-  };
-
-  const startPageKey = state.pageKey;
-  let attempts = 0;
-  (function waitForPh() {
-  if (state.pageKey !== startPageKey) return;
-  if (state.pendingById.has(id)) return;
-
-  attempts += 1;
-  const el = document.getElementById(phId);
-  if (el && el.isConnected) {
-
-  // Si on arrive ici, soit visible, soit timeout
-
-  if (doCall()) {
-  state.pendingById.delete(id);
-  return;
-  }
-
-  }
-
-  if (attempts < 100) {
-  const timeoutId = setTimeout(waitForPh, 50);
-  state.activeTimeouts.add(timeoutId);
-  }
-  })();
-  }
-
-  async function fetchConfig() {
-  if (state.cfg) return state.cfg;
-  if (state.cfgPromise) return state.cfgPromise;
-
-  state.cfgPromise = (async () => {
-  const MAX_TRIES = 3;
-  let delay = 800;
-  for (let attempt = 1; attempt <= MAX_TRIES; attempt++) {
-  try {
-  const res = await fetch('/api/plugins/ezoic-infinite/config', { credentials: 'same-origin' });
-  if (res.ok) {
-  state.cfg = await res.json();
-  return state.cfg;
-  }
-  } catch (e) {}
-  if (attempt < MAX_TRIES) await new Promise(r => setTimeout(r, delay));
-  delay *= 2;
-  }
-  return null;
-  })();
+      const { id, recycled } = pickId('topics');
+      if (!id) break;
 
-  try { return await state.cfgPromise; } finally { state.cfgPromise = null; }
-  }
+      const wrap = recycled ? recycled.wrap : buildWrap('topics', afterIndex, id);
+      if (recycled) resetWrapPlaceholder(wrap, id);
 
-  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);
-  }
+      if (!insertAfter(anchor, wrap)) { state.pools.topics.push(id); continue; }
 
-  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 Array.from(new Set(out)).sort((a, b) => a - b);
+      state.live.topics.push({ id, wrap });
+      observeFill(wrap, id);
+      scheduleRemovalIfUnfilled(wrap, 'topics', id);
+      if (wrap.querySelector(`#${PH_PREFIX}${id}`)) showEzoicAd(id);
+      inserts++;
+    }
   }
 
-  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 el = items[afterPos - 1];
-  if (!el || !el.isConnected) continue;
+  function runCategories(cfg) {
+    if (!cfg.enableCategoryAds) return;
 
-  if (isAdjacentAd(el) || isPrevAd(el)) {
-  continue;
-  }
+    const items = Array.from(document.querySelectorAll(SELECTORS.categoryItem));
+    if (!items.length) return;
 
-  // Prevent back-to-back at load
-  const prevWrap = findWrap(kindClass, afterPos - 1);
-  if (prevWrap) continue;
+    const after = computeAfterIndexes(items.length, cfg.intervalCategories || 4, !!cfg.showFirstCategoryAd);
+    let inserts = 0;
 
-  if (findWrap(kindClass, afterPos)) continue;
+    for (const afterIndex of after) {
+      if (inserts >= MAX_INSERTS_PER_TICK) break;
+      const anchor = items[afterIndex - 1];
+      if (!anchor) continue;
+      if (findWrap('categories', afterIndex)) continue;
 
-  const pick = pickId(kindPool, []);
-  const id = pick.id;
-  if (!id) break;
+      const { id, recycled } = pickId('categories');
+      if (!id) break;
 
-  let wrap = null;
-  if (pick.recycled && pick.recycled.wrap) {
-  if (sessionDefinedIds.has(id)) {
-  destroyPlaceholderIds([id]);
-  }
-  const oldWrap = pick.recycled.wrap;
-  try { if (oldWrap && oldWrap.__ezoicFillObs) { oldWrap.__ezoicFillObs.disconnect(); } } catch (e) {}
-  try { oldWrap && oldWrap.remove(); } catch (e) {}
-  wrap = insertAfter(el, id, kindClass, afterPos);
-  if (!wrap) continue;
-  setTimeout(() => {
-  callShowAdsWhenReady(id);
-  }, 50);
-  } else {
-  usedSet.add(id);
-  wrap = insertAfter(el, id, kindClass, afterPos);
-  if (!wrap) continue;
-  // Micro-délai pour laisser le DOM se synchroniser
-  // Appel immédiat au lieu de 10ms delay
-  callShowAdsWhenReady(id);
-  }
+      const wrap = recycled ? recycled.wrap : buildWrap('categories', afterIndex, id);
+      if (recycled) resetWrapPlaceholder(wrap, id);
 
-  liveArr.push({ id, wrap });
-  if (wrap && (
-  (wrap.previousElementSibling && wrap.previousElementSibling.classList && wrap.previousElementSibling.classList.contains(WRAP_CLASS)) || (wrap.nextElementSibling && wrap.nextElementSibling.classList && wrap.nextElementSibling.classList.contains(WRAP_CLASS))
-  )) {
-  try { wrap.remove(); } catch (e) {}
-  if (!(pick.recycled && pick.recycled.wrap)) {
-  try { kindPool.unshift(id); } catch (e) {}
-  usedSet.delete(id);
-  }
-  continue;
-  }
-  inserted += 1;
-  }
-  return inserted;
-  }
+      if (!insertAfter(anchor, wrap)) { state.pools.categories.push(id); continue; }
 
-  function enforceNoAdjacentAds() {
-  const ads = Array.from(document.querySelectorAll(`.${WRAP_CLASS}`));
-  for (let i = 0; i < ads.length; i++) {
-  const ad = ads[i], prev = ad.previousElementSibling;
-  if (prev && prev.classList && prev.classList.contains(WRAP_CLASS)) {
-  try {
-  const ph = ad.querySelector && ad.querySelector(`[id^="${PLACEHOLDER_PREFIX}"]`);
-  if (ph) {
-  const id = parseInt(ph.id.replace(PLACEHOLDER_PREFIX, ''), 10);
-  if (Number.isFinite(id) && id > 0) {
-  // Détruire le placeholder si Ezoic l'a déjà défini
-  if (sessionDefinedIds.has(id)) {
-  destroyPlaceholderIds([id]);
-  }
-  }
+      state.live.categories.push({ id, wrap });
+      observeFill(wrap, id);
+      scheduleRemovalIfUnfilled(wrap, 'categories', id);
+      if (wrap.querySelector(`#${PH_PREFIX}${id}`)) showEzoicAd(id);
+      inserts++;
+    }
   }
-  ad.remove();
-  } catch (e) {}
-  }
-  }
-  }
-
-  function cleanup() {
-  destroyUsedPlaceholders();
-
-  document.querySelectorAll('.ezoic-ad').forEach(el => {
-  try { el.remove(); } catch (e) {}
-  });
 
-  state.pageKey = getPageKey();
-  state.cfg = null;
-  state.cfgPromise = null;
+  function runMessageAds(cfg) {
+    if (!cfg.enableMessageAds) return;
 
-  state.poolTopics = [];
-  state.poolPosts = [];
-  state.poolCategories = [];
-  state.usedTopics.clear();
-  state.usedPosts.clear();
-  state.usedCategories.clear();
-  state.lastShowById.clear();
-  state.pendingById.clear();
-  state.definedIds.clear();
+    const posts = Array.from(document.querySelectorAll(SELECTORS.postItem))
+      .filter(p => p && p.isConnected && p.querySelector(SELECTORS.postContent));
+    if (!posts.length) return;
 
-  state.activeTimeouts.forEach(id => {
-  try { clearTimeout(id); } catch (e) {}
-  });
-  state.activeTimeouts.clear();
+    const after = computeAfterIndexes(posts.length, cfg.messageIntervalPosts || 3, !!cfg.showFirstMessageAd);
+    let inserts = 0;
 
-  state.pendingById.clear();
+    for (const afterIndex of after) {
+      if (inserts >= MAX_INSERTS_PER_TICK) break;
+      const anchor = posts[afterIndex - 1];
+      if (!anchor) continue;
+      if (findWrap('messages', afterIndex)) continue;
 
-  if (state.obs) { state.obs.disconnect(); state.obs = null; }
+      const { id, recycled } = pickId('messages');
+      if (!id) break;
 
-  state.scheduled = false;
-  clearTimeout(state.timer);
-  state.timer = null;
-  }
+      const wrap = recycled ? recycled.wrap : buildWrap('messages', afterIndex, id);
+      wrap.classList.add('ezoic-ad--message');
+      if (recycled) resetWrapPlaceholder(wrap, id);
 
-  function ensureObserver() {
-  if (state.obs) return;
-  state.obs = new MutationObserver(() => scheduleRun('mutation'));
-  try { state.obs.observe(document.body, { childList: true, subtree: true }); } catch (e) {}
-  }
+      if (!insertAfter(anchor, wrap)) { state.pools.messages.push(id); continue; }
 
-  async function runCore() {
-  if (!state.canShowAds) {
-  return;
+      state.live.messages.push({ id, wrap });
+      observeFill(wrap, id);
+      scheduleRemovalIfUnfilled(wrap, 'messages', id);
+      if (wrap.querySelector(`#${PH_PREFIX}${id}`)) showEzoicAd(id);
+      inserts++;
+    }
   }
 
-  patchShowAds();
-
-  const cfg = await fetchConfig();
-  if (!cfg || cfg.excluded) return;
+  function cleanupForNavigation() {
+    for (const t of state.timeouts) clearTimeout(t);
+    state.timeouts.clear();
 
-  initPools(cfg);
+    if (state.observer) {
+      try { state.observer.disconnect(); } catch (e) {}
+      state.observer = null;
+    }
 
-  const kind = getKind();
-  let inserted = 0;
-
-  if (kind === 'topic') {
-  if (normalizeBool(cfg.enableMessageAds)) {
-  inserted = injectBetween('ezoic-ad-message', getPostContainers(),
-  Math.max(1, parseInt(cfg.messageIntervalPosts, 10) || 3),
-  normalizeBool(cfg.showFirstMessageAd),
-  state.poolPosts,
-  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),
-  state.poolTopics,
-  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),
-  state.poolCategories,
-  state.usedCategories);
-  }
-  }
-
-  enforceNoAdjacentAds();
-
-  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 && 0 < 25) {
-  setTimeout(arguments[0], 50);
-  return;
-  }
-
-  if (inserted >= MAX_INSERTS_PER_RUN) {
-  setTimeout(arguments[0], 50);
-  } else if (inserted === 0 && count > 0) {
-  // Pool épuisé ou recyclage pas encore disponible.
-  if (state.poolWaitAttempts < 8) {
-  state.poolWaitAttempts += 1;
-  setTimeout(arguments[0], 50);
-  } else {
-  }
-  } else if (inserted > 0) {
-  }
+    state.live.topics = [];
+    state.live.categories = [];
+    state.live.messages = [];
+    state.lastShowById.clear();
   }
 
   function scheduleRun() {
-  if (state.scheduled) return;
-  state.scheduled = true;
-
-  clearTimeout(state.timer);
-  state.timer = setTimeout(() => {
-  state.scheduled = false;
-  const pk = getPageKey();
-  if (state.pageKey && pk !== state.pageKey) return;
-  runCore().catch(() => {});
-  }, 50);
-  }
-
-  function bind() {
-  if (!$) return;
-
-  $(window).off('.ezoicInfinite');
-
-  $(window).on('action:ajaxify.start.ezoicInfinite', () => cleanup());
-
-  $(window).on('action:ajaxify.end.ezoicInfinite', () => {
-  state.pageKey = getPageKey();
-  ensureObserver();
-
-  state.canShowAds = true;
-  });
-
-  $(window).on('action:category.loaded.ezoicInfinite', () => {
-  ensureObserver();
-  waitForContentThenRun();
-  });
-  $(window).on('action:topics.loaded.ezoicInfinite', () => {
-  ensureObserver();
-  waitForContentThenRun();
-  });
-
-  $(window).on('action:topic.loaded.ezoicInfinite', () => {
-  ensureObserver();
-  waitForContentThenRun();
-  });
-
-  $(window).on('action:posts.loaded.ezoicInfinite', () => {
-  ensureObserver();
-  // posts.loaded = infinite scroll
-  waitForContentThenRun();
-  });
-  }
-
-  function bindScroll() {
-  if (state.lastScrollRun > 0) return;
-  state.lastScrollRun = Date.now();
-  let ticking = false;
-  window.addEventListener('scroll', () => {
-  if (ticking) return;
-  ticking = true;
-  window.requestAnimationFrame(() => {
-  ticking = false;
-  enforceNoAdjacentAds();
-  const now = Date.now();
-  if (!state.lastScrollRun || now - state.lastScrollRun > 2000) {
-  state.lastScrollRun = now;
-  scheduleRun();
-  }
-  });
-  }, { passive: true });
-  }
-
-  function waitForContentThenRun() {
-  const MIN_WORDS = 250;
-  let attempts = 0;
-  const maxAttempts = 20; // 20 × 200ms = 4s max
-
-  (function check() {
-  attempts++;
-
-  // Compter les mots sur la page
-  const text = document.body.innerText || '';
-  const wordCount = text.split(/\s+/).filter(Boolean).length;
-
-  if (wordCount >= MIN_WORDS) {
-  // Assez de contenu → lancer l'insertion
-  scheduleRun();
-  return;
-  }
-
-  // Pas assez de contenu
-  if (attempts >= maxAttempts) {
-  // Timeout après 4s → tenter quand même
-  scheduleRun();
-  return;
-  }
-
-  // Réessayer dans 200ms
-  setTimeout(check, 50);
-  })();
-  }
-
-  function waitForEzoicThenRun() {
-  let attempts = 0;
-  const maxAttempts = 50; // 50 × 200ms = 10s max
-
-  (function check() {
-  attempts++;
-  // Vérifier si Ezoic est chargé
-  if (window.ezstandalone && typeof window.ezstandalone.showAds === 'function') {
-  // Ezoic est prêt → lancer l'insertion
-  scheduleRun();
-  waitForContentThenRun();
-  return;
-  }
-  // Ezoic pas encore prêt
-  if (attempts >= maxAttempts) {
-  // Tenter quand même
-  scheduleRun();
-  return;
-  }
-  // Réessayer dans 200ms
-  setTimeout(check, 50);
-  })();
+    if (state.scheduled) return;
+    state.scheduled = true;
+    requestAnimationFrame(() => {
+      state.scheduled = false;
+      run().catch(() => {});
+    });
+  }
+
+  async function run() {
+    const pk = getPageKey();
+    if (pk !== state.pageKey) {
+      state.pageKey = pk;
+      cleanupForNavigation();
+      state.cfg = null;
+      state.cfgPromise = null;
+    }
+
+    const cfg = await fetchConfig();
+    if (!cfg || cfg.excluded) return;
+
+    const kind = getKind();
+    if (kind === 'categoryTopics') runCategoryTopics(cfg);
+    if (kind === 'categories') runCategories(cfg);
+    if (kind === 'topic') runMessageAds(cfg);
+
+    // remove obvious empty spacer nodes injected by networks
+    try {
+      document.querySelectorAll(`.${CLASS_WRAP} > div:empty`).forEach(n => n.remove());
+    } catch (e) {}
+  }
+
+  function start() {
+    scheduleRun();
+
+    state.observer = new MutationObserver(() => {
+      const t = now();
+      if (t - state.lastRunAt < 200) return;
+      state.lastRunAt = t;
+      scheduleRun();
+    });
+
+    try { state.observer.observe(document.body, { childList: true, subtree: true }); } catch (e) {}
+
+    // NodeBB ajaxify hook
+    if (window.jQuery && window.jQuery(window).on) {
+      window.jQuery(window).on('action:ajaxify.end', () => {
+        state.pageKey = null;
+        scheduleRun();
+      });
+    } else {
+      window.addEventListener('popstate', () => {
+        state.pageKey = null;
+        scheduleRun();
+      });
+    }
+  }
+
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', start);
+  } else {
+    start();
   }
-
-  cleanup();
-  bind();
-  bindScroll();
-  ensureObserver();
-  state.pageKey = getPageKey();
-
-  // Attendre que Ezoic soit chargé avant d'insérer
-  waitForEzoicThenRun();
-})();
+})();

package/public/style.css

@@ -1,10 +1,41 @@
+/*
+  Ezoic Infinite Ads
+  - Wrappers are hidden until ad is detected as filled (data-ezoic-filled="1").
+  - Prevent reserved heights/margins creating blank space under creatives.
+*/
+
 .ezoic-ad {
-  height: auto !important;
-  padding: 0 !important;
-  margin: 0 !important;
+  display: none;
+  width: 100%;
+  clear: both;
+  margin: 0;
+  padding: 0;
 }
 
-.ezoic-ad * {
+.ezoic-ad[data-ezoic-filled="1"] {
+  display: block;
+}
+
+/* Do not let the placeholder reserve fixed height */
+.ezoic-ad > [id^="ezoic-pub-ad-placeholder-"] {
+  height: auto !important;
+  min-height: 0 !important;
   margin: 0 !important;
   padding: 0 !important;
-}
+}
+
+/* Avoid baseline gaps under iframes/ins */
+.ezoic-ad iframe,
+.ezoic-ad ins {
+  display: block !important;
+}
+
+/* Remove empty spacer divs that can appear after injection */
+.ezoic-ad > div:empty {
+  display: none !important;
+}
+
+/* Optional: message-style ad spacing (looks nicer between posts) */
+.ezoic-ad--message[data-ezoic-filled="1"] {
+  margin: 0.75rem 0;
+}