nodebb-plugin-ezoic-infinite 0.9.8 → 0.9.10

package/library.js

@@ -1,57 +1,96 @@
 'use strict';
 
 const meta = require.main.require('./src/meta');
-const groups = require.main.require('./src/groups');
+const db = require.main.require('./src/database');
 
-const Plugin = {};
+const SETTINGS_KEY = 'ezoic-infinite';
+const plugin = {};
 
-Plugin.init = async function (params) {
-  const { router, middleware } = params;
+function normalizeExcludedGroups(value) {
+  if (!value) return [];
+  if (Array.isArray(value)) return value;
+  return String(value).split(',').map(s => s.trim()).filter(Boolean);
+}
 
-  router.get('/admin/plugins/ezoic-infinite', middleware.admin.buildHeader, renderAdmin);
-  router.get('/api/admin/plugins/ezoic-infinite', renderAdmin);
-};
+function parseBool(v, def = false) {
+  if (v === undefined || v === null || v === '') return def;
+  if (typeof v === 'boolean') return v;
+  const s = String(v).toLowerCase();
+  return s === '1' || s === 'true' || s === 'on' || s === 'yes';
+}
 
-async function renderAdmin(req, res) {
-  const settings = await meta.settings.get('ezoic-infinite');
-
-  let groupNames = [];
-  try {
-    groupNames = await groups.getGroupsFromSet('groups:createtime', 0, -1);
-  } catch (e) {
-    try {
-      groupNames = await groups.getGroupsFromSet('groups:visible:createtime', 0, -1);
-    } catch (e2) {
-      groupNames = [];
-    }
-  }
+async function getAllGroups() {
+  const names = await db.getSortedSetRange('groups:createtime', 0, -1);
+  const filtered = names.filter(name => !groups.isPrivilegeGroup(name));
+  const data = await groups.getGroupsData(filtered);
+  // Sort alphabetically for ACP usability
+  data.sort((a, b) => String(a.name).localeCompare(String(b.name), 'fr', { sensitivity: 'base' }));
+  return data;
+}
+async function getSettings() {
+  const s = await meta.settings.get(SETTINGS_KEY);
+  return {
+    // Between-post ads (simple blocks)
+    enableBetweenAds: parseBool(s.enableBetweenAds, true),
+    placeholderIds: (s.placeholderIds || '').trim(),
+    intervalPosts: Math.max(1, parseInt(s.intervalPosts, 10) || 6),
 
-  let groupList = [];
-  try {
-    groupList = await groups.getGroupsData(groupNames);
-  } catch (e) {
-    groupList = groupNames.map((name) => ({ name }));
-  }
+    // "Ad message" between replies (looks like a post)
+    enableMessageAds: parseBool(s.enableMessageAds, false),
+    messagePlaceholderIds: (s.messagePlaceholderIds || '').trim(),
+    messageIntervalPosts: Math.max(1, parseInt(s.messageIntervalPosts, 10) || 3),
 
-  groupList = (groupList || [])
-    .filter(g => g && g.name)
-    .sort((a, b) => (a.name || '').localeCompare(b.name || '', 'fr', { sensitivity: 'base' }));
+    excludedGroups: normalizeExcludedGroups(s.excludedGroups),
+  };
+}
 
-  res.render('admin/plugins/ezoic-infinite', {
-    title: 'Ezoic - Publicités Infinite Scroll',
-    settings,
-    groups: groupList,
-  });
+async function isUserExcluded(uid, excludedGroups) {
+  if (!uid || !excludedGroups.length) return false;
+  const userGroups = await groups.getUserGroups([uid]);
+  return (userGroups[0] || []).some(g => excludedGroups.includes(g.name));
 }
 
-Plugin.addAdminNavigation = async function (header) {
+plugin.addAdminNavigation = async (header) => {
   header.plugins = header.plugins || [];
   header.plugins.push({
     route: '/plugins/ezoic-infinite',
-    icon: 'fa-bullhorn',
-    name: 'Ezoic Infinite',
+    icon: 'fa-ad',
+    name: 'Ezoic Infinite Ads'
   });
   return header;
 };
 
-module.exports = Plugin;
+plugin.init = async ({ router, middleware }) => {
+  async function render(req, res) {
+    const settings = await getSettings();
+    const allGroups = await getAllGroups();
+
+    res.render('admin/plugins/ezoic-infinite', {
+      title: 'Ezoic Infinite Ads',
+      ...settings,
+      enableBetweenAds_checked: settings.enableBetweenAds ? 'checked' : '',
+      enableMessageAds_checked: settings.enableMessageAds ? 'checked' : '',
+      allGroups,
+    });
+  }
+
+  router.get('/admin/plugins/ezoic-infinite', middleware.admin.buildHeader, render);
+  router.get('/api/admin/plugins/ezoic-infinite', render);
+
+  router.get('/api/plugins/ezoic-infinite/config', middleware.buildHeader, async (req, res) => {
+    const settings = await getSettings();
+    const excluded = await isUserExcluded(req.uid, settings.excludedGroups);
+
+    res.json({
+      excluded,
+      enableBetweenAds: settings.enableBetweenAds,
+      placeholderIds: settings.placeholderIds,
+      intervalPosts: settings.intervalPosts,
+      enableMessageAds: settings.enableMessageAds,
+      messagePlaceholderIds: settings.messagePlaceholderIds,
+      messageIntervalPosts: settings.messageIntervalPosts,
+    });
+  });
+};
+
+module.exports = plugin;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nodebb-plugin-ezoic-infinite",
-  "version": "0.9.8",
-  "description": "Injection de publicités Ezoic entre les topics et entre les messages avec infinite scroll (NodeBB 4.x).",
+  "version": "0.9.10",
+  "description": "Ezoic ads with infinite scroll using a pool of placeholder IDs",
   "main": "library.js",
   "license": "MIT",
   "keywords": [
@@ -11,6 +11,9 @@
     "ads",
     "infinite-scroll"
   ],
+  "engines": {
+    "node": ">=18"
+  },
   "nbbpm": {
     "compatibility": "^4.0.0"
   }

package/plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "nodebb-plugin-ezoic-infinite",
-  "name": "Ezoic Infinite",
-  "description": "Ezoic ads injection with infinite scroll (topics list + topic posts)",
+  "name": "NodeBB Ezoic Infinite Ads",
+  "description": "Ezoic ads with infinite scroll using a pool of placeholder IDs",
   "library": "./library.js",
   "hooks": [
     {
@@ -22,8 +22,5 @@
   "scripts": [
     "public/client.js"
   ],
-  "css": [
-    "public/style.css"
-  ],
   "templates": "public/templates"
 }

package/public/admin.js

@@ -19,9 +19,25 @@ $(document).ready(function () {
       form.find('[name="messageIntervalPosts"]').val(parseInt(data.messageIntervalPosts, 10) || 3);
       form.find('[name="messagePlaceholderIds"]').val(data.messagePlaceholderIds || '');
 
-      const selected = (data.excludedGroups || '').split(',').map(s => s.trim()).filter(Boolean);
-      form.find('[name="excludedGroups"] option').each(function () {
-        $(this).prop('selected', selected.includes($(this).val()));
+      // NodeBB 4.x: charger les groupes via socket côté ACP
+      socket.emit('groups.getGroups', {}, function (err2, groups) {
+        const $select = form.find('[name="excludedGroups"]');
+        $select.empty();
+
+        if (!err2 && Array.isArray(groups)) {
+          groups
+            .map(g => g && g.name)
+            .filter(Boolean)
+            .sort((a, b) => a.localeCompare(b, 'fr', { sensitivity: 'base' }))
+            .forEach((name) => {
+              $select.append($('<option>').val(name).text(name));
+            });
+        }
+
+        const selected = (data.excludedGroups || '').split(',').map(s => s.trim()).filter(Boolean);
+        $select.find('option').each(function () {
+          $(this).prop('selected', selected.includes($(this).val()));
+        });
       });
     });
   }
@@ -49,6 +65,11 @@ $(document).ready(function () {
     });
   }
 
-  $('.ezoic-infinite-save').on('click', save);
+  $(document).off('click.ezoicInfiniteSave', '.ezoic-infinite-save')
+    .on('click.ezoicInfiniteSave', '.ezoic-infinite-save', function (e) {
+      e.preventDefault();
+      save();
+    });
+
   load();
 });

package/public/client.js

@@ -1,360 +1,248 @@
-/* global $, ajaxify, app, socket */
 'use strict';
 
-(function () {
-  if (window.ezoicInfiniteLoaded) return;
-  window.ezoicInfiniteLoaded = true;
-
-  const SETTINGS_NS = 'ezoic-infinite';
-
-  let settings = null;
-  let pageKey = null;
-
-  // State per page
-  let usedTopic = new Set(); // ids currently in DOM (topic)
-  let usedCat = new Set();   // ids currently in DOM (category)
-  let fifoTopic = [];        // [{id, afterNo}]
-  let fifoCat = [];          // [{id, afterPos}]
-
-  // Refresh single-flight
-  let refreshInFlight = false;
-  let refreshQueued = false;
-
-  function parsePool(text) {
-    return String(text || '')
-      .split(/\r?\n/)
-      .map(s => s.trim())
-      .filter(Boolean)
-      .map(s => parseInt(s, 10))
-      .filter(n => Number.isFinite(n) && n > 0);
-  }
-
-  function userExcluded() {
-    try {
-      const raw = (settings && settings.excludedGroups) ? String(settings.excludedGroups) : '';
-      if (!raw) return false;
-      const excluded = raw.split(',').map(s => s.trim()).filter(Boolean);
-      if (!excluded.length) return false;
-      const myGroups = (app.user && app.user.groups) ? app.user.groups : [];
-      return excluded.some(g => myGroups.includes(g));
-    } catch (e) {
-      return false;
+/* globals ajaxify */
+window.ezoicInfiniteLoaded = true;
+
+let cachedConfig;
+let lastFetch = 0;
+let debounceTimer;
+
+let inFlight = false;
+let rerunRequested = false;
+
+// Incremental state (prevents ads "jumping to the top")
+let pageKey = null;
+let injectedSlots = new Set(); // slotNumber per page
+let usedIds = new Set();       // ids currently injected per page
+
+function resetPageState() {
+  injectedSlots = new Set();
+  usedIds = new Set();
+}
+
+function currentPageKey() {
+  // Stable key per ajaxified page
+  try {
+    if (ajaxify && ajaxify.data) {
+      if (ajaxify.data.tid) return 'topic:' + ajaxify.data.tid;
+      if (ajaxify.data.cid) return 'category:' + ajaxify.data.cid;
+      if (ajaxify.data.template) return 'tpl:' + ajaxify.data.template + ':' + (ajaxify.data.url || window.location.pathname);
     }
-  }
-
-  function getPageKey() {
+  } catch (e) {}
+  return window.location.pathname;
+}
+
+function parsePool(raw) {
+  if (!raw) return [];
+  return Array.from(new Set(
+    String(raw).split(/[\n,;\s]+/)
+      .map(x => parseInt(x, 10))
+      .filter(n => Number.isFinite(n) && n > 0)
+  ));
+}
+
+async function fetchConfig() {
+  if (cachedConfig && Date.now() - lastFetch < 10000) return cachedConfig;
+  const res = await fetch('/api/plugins/ezoic-infinite/config', { credentials: 'same-origin' });
+  cachedConfig = await res.json();
+  lastFetch = Date.now();
+  return cachedConfig;
+}
+
+function isTopicPage() {
+  return $('[component="post/content"]').length > 0 || $('[component="post"][data-pid]').length > 0;
+}
+
+function isCategoryTopicListPage() {
+  return $('li[component="category/topic"]').length > 0;
+}
+
+function getTopicPosts() {
+  const $primary = $('[component="post"][data-pid]');
+  if ($primary.length) return $primary.not('.ezoic-ad-post');
+
+  return $('[data-pid]').filter(function () {
+    const $el = $(this);
+    const hasContent = $el.find('[component="post/content"]').length > 0;
+    const nested = $el.parents('[data-pid]').length > 0;
+    return hasContent && !nested;
+  }).not('.ezoic-ad-post');
+}
+
+function getCategoryTopicItems() {
+  return $('li[component="category/topic"]').not('.ezoic-ad-topic');
+}
+
+function tagName($el) {
+  return ($el && $el.length ? (($el.prop('tagName') || '').toUpperCase()) : '');
+}
+
+function makeWrapperLike($target, classes, innerHtml, attrs) {
+  const t = tagName($target);
+  const attrStr = attrs ? ' ' + attrs : '';
+  if (t === 'LI') {
+    return '<li class="' + classes + ' list-unstyled"' + attrStr + '>' + innerHtml + '</li>';
+  }
+  return '<div class="' + classes + '"' + attrStr + '>' + innerHtml + '</div>';
+}
+
+function pickNextId(pool) {
+  for (const id of pool) {
+    if (!usedIds.has(id)) return id;
+  }
+  return null;
+}
+
+function callEzoic(ids) {
+  if (!ids || !ids.length) return;
+
+  window.ezstandalone = window.ezstandalone || {};
+  window.ezstandalone.cmd = window.ezstandalone.cmd || [];
+
+  const run = function () {
     try {
-      if (ajaxify && ajaxify.data) {
-        if (ajaxify.data.tid) return 'topic:' + ajaxify.data.tid;
-        if (ajaxify.data.cid) return 'cid:' + ajaxify.data.cid + ':' + window.location.pathname;
+      if (typeof window.ezstandalone.showAds === 'function') {
+        window.ezstandalone.showAds.apply(window.ezstandalone, ids);
+        return true;
       }
     } catch (e) {}
-    return window.location.pathname;
-  }
-
-  function isTopicPage() {
-    try { if (ajaxify && ajaxify.data && ajaxify.data.tid) return true; } catch (e) {}
-    return /^\/topic\//.test(window.location.pathname);
-  }
-
-  function isCategoryTopicList() {
-    return $('li[component="category/topic"]').length > 0 && !isTopicPage();
-  }
-
-  function cleanupForNewPage() {
-    $('.ezoic-ad').remove();
-    usedTopic = new Set();
-    usedCat = new Set();
-    fifoTopic = [];
-    fifoCat = [];
-  }
-
-  function pickNextId(pool, usedSet) {
-    for (const id of pool) {
-      if (!usedSet.has(id)) return id;
+    return false;
+  };
+
+  window.ezstandalone.cmd.push(function () { run(); });
+
+  // retry a few times (Ezoic can load late)
+  let tries = 0;
+  const maxTries = 6;
+  const timer = setInterval(function () {
+    tries++;
+    if (run() || tries >= maxTries) clearInterval(timer);
+  }, 800);
+}
+
+function injectBetweenIncremental($items, pool, interval, wrapperClass) {
+  const total = $items.length;
+  const maxSlot = Math.floor(total / interval);
+  if (maxSlot <= 0) return [];
+
+  for (let slot = 1; slot <= maxSlot; slot++) {
+    if (injectedSlots.has(slot)) continue;
+
+    const index = slot * interval - 1;
+    const $target = $items.eq(index);
+    if (!$target.length) continue;
+
+    const id = pickNextId(pool);
+    if (!id) {
+      // pool exhausted: stop injecting further to avoid reusing ids and "jumping"
+      break;
     }
-    return null;
-  }
 
-  function destroyPlaceholder(id) {
-    try {
-      window.ezstandalone = window.ezstandalone || {};
-      window.ezstandalone.cmd = window.ezstandalone.cmd || [];
-      if (typeof window.ezstandalone.destroyPlaceholders === 'function') {
-        window.ezstandalone.destroyPlaceholders(id);
-        return;
-      }
-      window.ezstandalone.cmd.push(function () {
-        try { window.ezstandalone.destroyPlaceholders(id); } catch (e) {}
-      });
-    } catch (e) {}
-  }
+    const placeholder = '<div id="ezoic-pub-ad-placeholder-' + id + '"></div>';
+    const html = makeWrapperLike($target, wrapperClass, placeholder, 'data-ezoic-slot="' + slot + '" data-ezoic-id="' + id + '"');
 
-  function ensureUniquePlaceholder(id) {
-    const existing = document.getElementById('ezoic-pub-ad-placeholder-' + id);
-    if (!existing) return;
+    $target.after(html);
 
-    const wrap = existing.closest('.ezoic-ad');
-    if (wrap) {
-      try { $(wrap).remove(); } catch (e) { wrap.remove(); }
-    } else {
-      existing.remove();
-    }
-    // On détruit le slot correspondant pour éviter les comportements imprévisibles
-    destroyPlaceholder(id);
+    injectedSlots.add(slot);
+    usedIds.add(id);
+    newIds.push(id);
   }
 
-  // IMPORTANT: showAds is called ONLY with newly injected ids (never the entire pool)
-  function callEzoic(ids) {
-    if (!ids || !ids.length) return;
+  return newIds;
+}
 
-    // Anti double-call: same ids within 1.2s
-    const key = ids.slice().sort((a, b) => a - b).join(',');
-    const now = Date.now();
-    if (window.__ezoicLastShowKey === key && now - (window.__ezoicLastShowAt || 0) < 1200) return;
-    window.__ezoicLastShowKey = key;
-    window.__ezoicLastShowAt = now;
+function injectMessageIncremental($posts, pool, interval) {
+  const total = $posts.length;
+  const maxSlot = Math.floor(total / interval);
+  if (maxSlot <= 0) return [];
 
-    try {
-      window.ezstandalone = window.ezstandalone || {};
-      window.ezstandalone.cmd = window.ezstandalone.cmd || [];
-
-      const run = function () {
-        try {
-          if (typeof window.ezstandalone.showAds === 'function') {
-            // Ezoic accepte plusieurs args: showAds(1,2,3)
-            window.ezstandalone.showAds.apply(window.ezstandalone, ids);
-            return true;
-          }
-        } catch (e) {}
-        return false;
-      };
-
-      window.ezstandalone.cmd.push(function () { run(); });
-
-      // Retry a few times if ez loads late
-      let tries = 0;
-      const tick = function () {
-        tries++;
-        if (run() || tries >= 8) return;
-        setTimeout(tick, 800);
-      };
-      setTimeout(tick, 800);
-    } catch (e) {}
-  }
-
-  // Auto height: wrapper visible only when placeholder gets children
-  function setupAutoHeightOnce() {
-    if (window.__ezoicAutoHeight) return;
-    window.__ezoicAutoHeight = true;
+  for (let slot = 1; slot <= maxSlot; slot++) {
+    if (injectedSlots.has(slot)) continue;
 
-    const mark = function (wrap) {
-      if (!wrap) return;
-      const ph = wrap.querySelector('[id^="ezoic-pub-ad-placeholder-"]');
-      if (ph && ph.children && ph.children.length) {
-        wrap.classList.add('ezoic-filled');
-      }
-    };
+    const index = slot * interval - 1;
+    const $target = $posts.eq(index);
+    if (!$target.length) continue;
 
-    const scan = function () {
-      document.querySelectorAll('.ezoic-ad').forEach(mark);
-    };
+    const id = pickNextId(pool);
+    if (!id) break;
 
-    scan();
-    setInterval(scan, 1000);
+    const inner = '<div class="content"><div id="ezoic-pub-ad-placeholder-' + id + '"></div></div>';
+    const html = makeWrapperLike($target, 'post ezoic-ad-post', inner, 'data-ezoic-slot="' + slot + '" data-ezoic-id="' + id + '"');
 
-    try {
-      const mo = new MutationObserver(scan);
-      mo.observe(document.body, { childList: true, subtree: true });
-    } catch (e) {}
-  }
+    $target.after(html);
 
-  function insertAfter($target, id, kind, afterVal, cls) {
-    ensureUniquePlaceholder(id);
-    const wrap = $(
-      '<div class="ezoic-ad ' + cls + '" data-ezoic-id="' + id + '" data-ezoic-after="' + afterVal + '">' +
-        '<div class="ezoic-ad-inner"><div id="ezoic-pub-ad-placeholder-' + id + '"></div></div>' +
-      '</div>'
-    );
-    $target.after(wrap);
-    return wrap;
+    injectedSlots.add(slot);
+    usedIds.add(id);
+    newIds.push(id);
   }
 
-  function recycleTopic($posts) {
-    fifoTopic.sort((a, b) => a.afterNo - b.afterNo);
-    while (fifoTopic.length) {
-      const old = fifoTopic.shift();
-      const sel = '.ezoic-ad-topic[data-ezoic-id="' + old.id + '"][data-ezoic-after="' + old.afterNo + '"]';
-      const $el = $(sel);
-      if (!$el.length) continue;
-
-      // Ne pas recycler si collé juste avant le dernier post (sentinel / scroll)
-      try {
-        const $last = $posts.last();
-        if ($last.length && $el.prev().is($last)) {
-          fifoTopic.push(old);
-          return null;
-        }
-      } catch (e) {}
-
-      $el.remove();
-      usedTopic.delete(old.id);
-      destroyPlaceholder(old.id);
-      return old.id;
-    }
-    return null;
-  }
+  return newIds;
+}
 
-  function recycleCat($items) {
-    fifoCat.sort((a, b) => a.afterPos - b.afterPos);
-    while (fifoCat.length) {
-      const old = fifoCat.shift();
-      const sel = '.ezoic-ad-between[data-ezoic-id="' + old.id + '"][data-ezoic-after="' + old.afterPos + '"]';
-      const $el = $(sel);
-      if (!$el.length) continue;
-
-      try {
-        const $last = $items.last();
-        if ($last.length && $el.prev().is($last)) {
-          fifoCat.push(old);
-          return null;
-        }
-      } catch (e) {}
-
-      $el.remove();
-      usedCat.delete(old.id);
-      destroyPlaceholder(old.id);
-      return old.id;
-    }
-    return null;
+async function refreshAds() {
+  // reset state when navigating (ajaxify)
+  const key = currentPageKey();
+  if (pageKey !== key) {
+    pageKey = key;
+    resetPageState();
+    // also cleanup any injected wrappers that may have been left by browser bfcache
+    $('.ezoic-ad-post, .ezoic-ad-between, .ezoic-ad-topic').remove();
   }
 
-  function injectInTopic() {
-    if (!(settings && (settings.enableMessageAds === true || settings.enableMessageAds === 'on'))) return;
+  if (inFlight) { rerunRequested = true; return; }
+  inFlight = true;
 
-    const interval = parseInt(settings.messageIntervalPosts, 10) || 3;
-    const pool = parsePool(settings.messagePlaceholderIds);
-    if (!pool.length) return;
+  try {
+    const cfg = await fetchConfig();
+    if (!cfg || cfg.excluded) return;
 
-    const $posts = $('[component="post"][data-pid]');
-    if (!$posts.length) return;
+    const betweenPool = parsePool(cfg.placeholderIds);
+    const betweenInterval = Math.max(1, parseInt(cfg.intervalPosts, 10) || 6);
 
-    const newIds = [];
-    $posts.each(function (idx) {
-      const postNo = idx + 1;
-      if (postNo % interval !== 0) return;
-      if (idx === $posts.length - 1) return; // pas après le dernier
-
-      const $post = $(this);
-      const existing = $post.next('.ezoic-ad-topic');
-      if (existing.length) return;
-
-      let id = pickNextId(pool, usedTopic);
-      if (!id) {
-        id = recycleTopic($posts);
-        if (!id) return;
-      }
+    const messagePool = parsePool(cfg.messagePlaceholderIds);
+    const messageInterval = Math.max(1, parseInt(cfg.messageIntervalPosts, 10) || 3);
 
-      usedTopic.add(id);
-      fifoTopic.push({ id, afterNo: postNo });
+    const onTopic = isTopicPage();
+    const onCategory = !onTopic && isCategoryTopicListPage();
 
-      insertAfter($post, id, 'topic', postNo, 'ezoic-ad-topic');
-      newIds.push(id);
-    });
+    const $posts = onTopic ? getTopicPosts() : $();
+    const $topicItems = onCategory ? getCategoryTopicItems() : $();
 
-    if (newIds.length) callEzoic(newIds);
-  }
-
-  function injectInCategory() {
-    if (!(settings && (settings.enableBetweenAds === true || settings.enableBetweenAds === 'on'))) return;
-
-    const interval = parseInt(settings.intervalTopics, 10) || 6;
-    const pool = parsePool(settings.placeholderIds);
-    if (!pool.length) return;
-
-    const $items = $('li[component="category/topic"]');
-    if (!$items.length) return;
+    if (!$posts.length && !$topicItems.length) return;
 
     const newIds = [];
-    $items.each(function (idx) {
-      const pos = idx + 1;
-      if (pos % interval !== 0) return;
-      if (idx === $items.length - 1) return;
-
-      const $li = $(this);
-      const existing = $li.next('.ezoic-ad-between');
-      if (existing.length) return;
-
-      let id = pickNextId(pool, usedCat);
-      if (!id) {
-        id = recycleCat($items);
-        if (!id) return;
-      }
-
-      usedCat.add(id);
-      fifoCat.push({ id, afterPos: pos });
-
-      insertAfter($li, id, 'between', pos, 'ezoic-ad-between');
-      newIds.push(id);
-    });
 
-    if (newIds.length) callEzoic(newIds);
-  }
-
-  function refresh() {
-    if (!settings) return;
-    if (userExcluded()) return;
-
-    if (refreshInFlight) { refreshQueued = true; return; }
-    refreshInFlight = true;
-    try {
-      const key = getPageKey();
-      if (pageKey !== key) {
-        pageKey = key;
-        cleanupForNewPage();
+    // Your rule:
+    // - Category topic list: BETWEEN only
+    // - Topic page: MESSAGE only
+    if ($topicItems.length) {
+      if (cfg.enableBetweenAds && betweenPool.length) {
+        newIds.push(...injectBetweenIncremental($topicItems, betweenPool, betweenInterval, 'ezoic-ad-topic'));
       }
-
-      setupAutoHeightOnce();
-
-      if (isTopicPage()) injectInTopic();
-      else if (isCategoryTopicList()) injectInCategory();
-    } finally {
-      refreshInFlight = false;
-      if (refreshQueued) { refreshQueued = false; setTimeout(refresh, 50); }
+      callEzoic(newIds);
+      return;
     }
-  }
 
-  function loadSettings(cb) {
-    // We read settings via socket so it works in ACP changes without restart
-    socket.emit('admin.settings.get', { hash: SETTINGS_NS }, function (err, data) {
-      settings = data || {};
-      cb && cb();
-    });
-  }
-
-  // Boot: load settings then refresh. No showAds batch here.
-  function boot() {
-    loadSettings(function () {
-      refresh();
-      // Small delayed refresh (DOM late), harmless: it won't call showAds if no new placeholders were injected
-      setTimeout(refresh, 1200);
-    });
+    if ($posts.length) {
+      if (cfg.enableMessageAds && messagePool.length) {
+        newIds.push(...injectMessageIncremental($posts, messagePool, messageInterval));
+      }
+      callEzoic(newIds);
+    }
+  } finally {
+    inFlight = false;
+    if (rerunRequested) {
+      rerunRequested = false;
+      setTimeout(refreshAds, 120);
+    }
   }
+}
 
-  // Hard load + SPA
-  $(document).ready(boot);
-  $(window).on('action:ajaxify.end', boot);
-
-  // Infinite scroll related events
-  $(window).on('action:posts.loaded action:topic.loaded action:topics.loaded action:category.loaded', function () {
-    refresh();
-    setTimeout(refresh, 600);
-  });
-
-  // Navigation start: cleanup to avoid duplicates
-  $(window).on('action:ajaxify.start', function () {
-    pageKey = null;
-    cleanupForNewPage();
-  });
+function debounceRefresh() {
+  clearTimeout(debounceTimer);
+  debounceTimer = setTimeout(refreshAds, 180);
+}
 
-})();
+$(document).ready(debounceRefresh);
+$(window).on('action:ajaxify.end action:posts.loaded action:topic.loaded', debounceRefresh);
+setTimeout(debounceRefresh, 1800);

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

@@ -1,59 +1,59 @@
 <div class="acp-page-container">
-  <h1 class="mb-3">Ezoic - Publicités Infinite Scroll</h1>
+  <h2>Ezoic - Publicités Infinite Scroll Ads</h2>
 
-  <div class="alert alert-info">
-    Format placeholder&nbsp;: <code>&lt;div id="ezoic-pub-ad-placeholder-XXX"&gt;&lt;/div&gt;</code>
-  </div>
+  <form class="ezoic-infinite-settings" role="form">
+    <h4 class="mt-3">Pubs entre les posts (bloc simple)</h4>
 
-  <form role="form" class="ezoic-infinite-settings">
-    <div class="mb-3">
-      <label class="form-label">Groupes exclus (pas de pubs pour ces groupes)</label>
-      <select multiple class="form-select" name="excludedGroups">
-        <!-- BEGIN groups -->
-        <option value="{groups.name}">{groups.name}</option>
-        <!-- END groups -->
-      </select>
-      <div class="form-text">Maintenez Ctrl/Cmd pour sélectionner plusieurs groupes. Liste triée par ordre alphabétique.</div>
-    </div>
-
-    <hr/>
-
-    <h3>Entre les topics dans une catégorie (liste des sujets)</h3>
-
-    <div class="form-check form-switch mb-2">
-      <input class="form-check-input" type="checkbox" name="enableBetweenAds">
-      <label class="form-check-label">Activer les pubs entre les topics</label>
+    <div class="form-check mb-3">
+      <input class="form-check-input" type="checkbox" id="enableBetweenAds" name="enableBetweenAds" {enableBetweenAds_checked}>
+      <label class="form-check-label" for="enableBetweenAds">Activer les pubs entre les posts</label>
     </div>
 
     <div class="mb-3">
-      <label class="form-label">Intervalle (insérer après chaque N topics)</label>
-      <input type="number" class="form-control" name="intervalTopics" min="1" step="1">
+      <label class="form-label" for="placeholderIds">Pool d’IDs Ezoic (entre posts)</label>
+      <textarea id="placeholderIds" name="placeholderIds" class="form-control" rows="4">{placeholderIds}</textarea>
+      <p class="form-text">Un ID par ligne (ou séparé par virgules/espaces). Le nombre d’IDs = nombre max de pubs simultanées.</p>
     </div>
 
     <div class="mb-3">
-      <label class="form-label">Pool d'IDs de placeholder (un par ligne)</label>
-      <textarea class="form-control" name="placeholderIds" rows="6"></textarea>
+      <label class="form-label" for="intervalPosts">Afficher une pub tous les N posts</label>
+      <input type="number" id="intervalPosts" name="intervalPosts" class="form-control" value="{intervalPosts}" min="1">
     </div>
 
     <hr/>
 
-    <h3>Dans les topics (entre les messages)</h3>
+    <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>
 
-    <div class="form-check form-switch mb-2">
-      <input class="form-check-input" type="checkbox" name="enableMessageAds">
-      <label class="form-check-label">Activer les pubs entre les messages</label>
+    <div class="form-check mb-3">
+      <input class="form-check-input" type="checkbox" id="enableMessageAds" name="enableMessageAds" {enableMessageAds_checked}>
+      <label class="form-check-label" for="enableMessageAds">Activer les pubs “message”</label>
     </div>
 
     <div class="mb-3">
-      <label class="form-label">Intervalle (insérer après chaque N messages)</label>
-      <input type="number" class="form-control" name="messageIntervalPosts" min="1" step="1">
+      <label class="form-label" for="messagePlaceholderIds">Pool d’IDs Ezoic (message)</label>
+      <textarea id="messagePlaceholderIds" name="messagePlaceholderIds" class="form-control" rows="4">{messagePlaceholderIds}</textarea>
+      <p class="form-text">Pool séparé recommandé pour éviter la réutilisation d’IDs. IMPORTANT : ne réutilise pas les mêmes IDs dans les deux pools.</p>
     </div>
 
     <div class="mb-3">
-      <label class="form-label">Pool d'IDs de placeholder pour messages (un par ligne)</label>
-      <textarea class="form-control" name="messagePlaceholderIds" rows="6"></textarea>
+      <label class="form-label" for="messageIntervalPosts">Afficher un “message pub” tous les N messages</label>
+      <input type="number" id="messageIntervalPosts" name="messageIntervalPosts" class="form-control" value="{messageIntervalPosts}" min="1">
+    </div>
+
+    <hr/>
+
+    <h4 class="mt-3">Exclusions</h4>
+    <div class="mb-3">
+      <label class="form-label" for="excludedGroups">Groupes exclus</label>
+      <select id="excludedGroups" name="excludedGroups" class="form-select" multiple>
+        <!-- BEGIN allGroups -->
+        <option value="{allGroups.name}">{allGroups.name}</option>
+        <!-- END allGroups -->
+      </select>
+      <p class="form-text">Si l’utilisateur appartient à un de ces groupes, aucune pub n’est injectée.</p>
     </div>
 
-    <button type="button" class="btn btn-primary ezoic-infinite-save">Enregistrer</button>
+    <button id="save" class="btn btn-primary">Enregistrer</button>
   </form>
 </div>

package/public/style.css

@@ -1,5 +0,0 @@
-/* Le conteneur est caché tant qu'Ezoic n'a pas injecté de contenu */
-.ezoic-ad{min-height:0 !important;height:auto !important;padding:0 !important;margin:0.5rem 0;}
-.ezoic-ad:not(.ezoic-filled){display:none !important;}
-.ezoic-ad .ezoic-ad-inner{padding:0;margin:0;}
-.ezoic-ad .ezoic-ad-inner > div{margin:0;padding:0;}