nodebb-plugin-ezoic-infinite 0.9.0 → 0.9.1

package/library.js

@@ -2,96 +2,36 @@
 
 const meta = require.main.require('./src/meta');
 const groups = require.main.require('./src/groups');
-const db = require.main.require('./src/database');
 
-const SETTINGS_KEY = 'ezoic-infinite';
-const plugin = {};
+const Plugin = {};
 
-function normalizeExcludedGroups(value) {
-  if (!value) return [];
-  if (Array.isArray(value)) return value;
-  return String(value).split(',').map(s => s.trim()).filter(Boolean);
-}
-
-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 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),
-
-    // "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),
+Plugin.init = async function (params) {
+  const { router, middleware } = params;
 
-    excludedGroups: normalizeExcludedGroups(s.excludedGroups),
-  };
-}
+  router.get('/admin/plugins/ezoic-infinite', middleware.admin.buildHeader, renderAdmin);
+  router.get('/api/admin/plugins/ezoic-infinite', renderAdmin);
+};
 
-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));
+async function renderAdmin(req, res) {
+  const settings = await meta.settings.get('ezoic-infinite');
+  // groups list for exclusions
+  const groupList = await groups.getGroups('groups:visible:createtime', 0, -1);
+  groupList.sort((a, b) => (a.name || '').localeCompare(b.name || '', undefined, { sensitivity: 'base' }));
+  res.render('admin/plugins/ezoic-infinite', {
+    title: 'Ezoic Infinite',
+    settings,
+    groups: groupList,
+  });
 }
 
-plugin.addAdminNavigation = async (header) => {
+Plugin.addAdminNavigation = async function (header) {
   header.plugins = header.plugins || [];
   header.plugins.push({
     route: '/plugins/ezoic-infinite',
-    icon: 'fa-ad',
-    name: 'Ezoic Infinite Ads'
+    icon: 'fa-bullhorn',
+    name: 'Ezoic Infinite',
   });
   return header;
 };
 
-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;
+module.exports = Plugin;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nodebb-plugin-ezoic-infinite",
-  "version": "0.9.0",
-  "description": "Ezoic ads with infinite scroll using a pool of placeholder IDs",
+  "version": "0.9.1",
+  "description": "Ezoic ads injection for NodeBB infinite scroll (topics list + topic posts) using a pool of placeholder IDs.",
   "main": "library.js",
   "license": "MIT",
   "keywords": [
@@ -11,9 +11,6 @@
     "ads",
     "infinite-scroll"
   ],
-  "engines": {
-    "node": ">=18"
-  },
   "nbbpm": {
     "compatibility": "^4.0.0"
   }

package/public/admin.js

@@ -1,29 +1,51 @@
-/* globals ajaxify */
+/* global $, app, socket */
 'use strict';
 
-(function () {
-  function init() {
-    const $form = $('.ezoic-infinite-settings');
-    if (!$form.length) return;
-
-    require(['settings', 'alerts'], function (Settings, alerts) {
-      Settings.load('ezoic-infinite', $form);
-
-      $('#save').off('click.ezoicInfinite').on('click.ezoicInfinite', function (e) {
-        e.preventDefault();
-
-        Settings.save('ezoic-infinite', $form, function () {
-          // Toast vert (NodeBB core)
-          if (alerts && typeof alerts.success === 'function') {
-            alerts.success('Enregistré');
-          } else if (window.app && typeof window.app.alertSuccess === 'function') {
-            window.app.alertSuccess('Enregistré');
-          }
-        });
+$(document).ready(function () {
+  const namespace = 'ezoic-infinite';
+
+  function load() {
+    socket.emit('admin.settings.get', { hash: namespace }, function (err, data) {
+      if (err) return;
+      data = data || {};
+
+      const form = $('.ezoic-infinite-settings');
+      form.find('[name="enableBetweenAds"]').prop('checked', data.enableBetweenAds === true || data.enableBetweenAds === 'on');
+      form.find('[name="intervalTopics"]').val(parseInt(data.intervalTopics, 10) || 6);
+      form.find('[name="placeholderIds"]').val(data.placeholderIds || '');
+
+      form.find('[name="enableMessageAds"]').prop('checked', data.enableMessageAds === true || data.enableMessageAds === 'on');
+      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()));
       });
     });
   }
 
-  $(document).ready(init);
-  $(window).on('action:ajaxify.end', init);
-})();
+  function save() {
+    const form = $('.ezoic-infinite-settings');
+    const payload = {
+      enableBetweenAds: form.find('[name="enableBetweenAds"]').is(':checked'),
+      intervalTopics: parseInt(form.find('[name="intervalTopics"]').val(), 10) || 6,
+      placeholderIds: form.find('[name="placeholderIds"]').val() || '',
+      enableMessageAds: form.find('[name="enableMessageAds"]').is(':checked'),
+      messageIntervalPosts: parseInt(form.find('[name="messageIntervalPosts"]').val(), 10) || 3,
+      messagePlaceholderIds: form.find('[name="messagePlaceholderIds"]').val() || '',
+      excludedGroups: (form.find('[name="excludedGroups"]').val() || []).join(','),
+    };
+
+    socket.emit('admin.settings.set', { hash: namespace, values: payload }, function (err) {
+      if (err) {
+        app.alertError(err.message || err);
+        return;
+      }
+      app.alertSuccess('Settings saved');
+    });
+  }
+
+  $('.ezoic-infinite-save').on('click', save);
+  load();
+});

package/public/client.js

@@ -1,443 +1,331 @@
+/* global $, ajaxify, app */
 'use strict';
-/* globals ajaxify */
-
-window.ezoicInfiniteLoaded = true;
-
-let cachedConfig = null;
-let lastFetch = 0;
-let inFlight = false;
-let rerunRequested = false;
-let debounceTimer = null;
-
-let pageKey = null;
-
-// Separate state per "mode" so category and topic don't leak ids
-let usedBetween = new Set();
-let usedMessages = new Set();
-
-let seenBetweenAfter = new Set();   // category: after absolute topic position
-let fifoBetween = [];              // [{afterPos, id}]
-let seenMsgAfter = new Set();      // topic: after absolute post number
-let fifoMsg = [];                  // [{afterPostNo, id}]
-
-// Destroy spam guard
-window.__ezoicLastDestroy = window.__ezoicLastDestroy || {};
-window.__ezoicRecycling = false;
-
-// ---------- Config ----------
-async function fetchConfig() {
-  const now = Date.now();
-  if (cachedConfig && (now - lastFetch) < 5000) return cachedConfig;
-  lastFetch = now;
-
-  try {
-    const res = await fetch('/api/admin/settings/ezoic-infinite', { credentials: 'same-origin' });
-    const data = await res.json();
-    cachedConfig = {
-      excluded: !!data.excluded,
-      enableBetweenAds: data.enableBetweenAds !== false,
-      placeholderIds: String(data.placeholderIds || '').trim(),
-      intervalPosts: parseInt(data.intervalPosts, 10) || 6,
-
-      enableMessageAds: data.enableMessageAds !== false,
-      messagePlaceholderIds: String(data.messagePlaceholderIds || '').trim(),
-      messageIntervalPosts: parseInt(data.messageIntervalPosts, 10) || 3,
-    };
-    return cachedConfig;
-  } catch (e) {
-    return cachedConfig || {
-      excluded: false,
-      enableBetweenAds: true,
-      placeholderIds: '',
-      intervalPosts: 6,
-      enableMessageAds: true,
-      messagePlaceholderIds: '',
-      messageIntervalPosts: 3,
-    };
+
+(function () {
+  if (window.ezoicInfiniteLoaded) return;
+  window.ezoicInfiniteLoaded = true;
+
+  const SETTINGS_NS = 'ezoic-infinite';
+
+  let settings = null;
+  let pageKey = null;
+
+  // Separate pools for category/topic
+  let usedTopic = new Set();
+  let usedCat = new Set();
+  let fifoTopic = []; // [{id, afterNo}]
+  let fifoCat = [];   // [{id, afterPos}]
+
+  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 loadSettings(cb) {
+    socket.emit('admin.settings.get', { hash: SETTINGS_NS }, function (err, data) {
+      settings = data || {};
+      cb && cb();
+    });
   }
-}
-
-function parsePool(text) {
-  return String(text || '')
-    .split(/\r?\n|,|;/g)
-    .map(s => s.trim())
-    .filter(Boolean)
-    .map(s => parseInt(s, 10))
-    .filter(n => Number.isFinite(n) && n > 0);
-}
-
-// ---------- Page detection ----------
-function isTopicPage() {
-  try {
-    if (ajaxify && ajaxify.data && ajaxify.data.tid) return true;
-  } catch (e) {}
-  return /^\/topic\//.test(window.location.pathname);
-}
-
-function isCategoryTopicListPage() {
-  return document.querySelectorAll('li[component="category/topic"]').length > 0;
-}
-
-function getPageKey() {
-  try {
-    if (ajaxify && ajaxify.data) {
-      if (ajaxify.data.tid) return `topic:${ajaxify.data.tid}`;
-      if (ajaxify.data.cid) return `category:${ajaxify.data.cid}`;
+
+  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;
     }
-  } catch (e) {}
-  return `path:${window.location.pathname}`;
-}
-
-function resetState() {
-  usedBetween = new Set();
-  usedMessages = new Set();
-  seenBetweenAfter = new Set();
-  seenMsgAfter = new Set();
-  fifoBetween = [];
-  fifoMsg = [];
-  window.__ezoicLastShowKey = null;
-  window.__ezoicLastShowAt = 0;
-}
-
-function cleanupOnNav() {
-  document.querySelectorAll('.ezoic-ad-post, .ezoic-ad-topic, .ezoic-ad').forEach(el => el.remove());
-}
-
-// ---------- Ezoic helpers ----------
-function destroyEzoicId(id) {
-  const now = Date.now();
-  if (window.__ezoicLastDestroy[id] && (now - window.__ezoicLastDestroy[id]) < 2000) return;
-  window.__ezoicLastDestroy[id] = now;
-
-  try {
-    window.ezstandalone = window.ezstandalone || {};
-    if (typeof window.ezstandalone.destroyPlaceholders === 'function') {
-      window.ezstandalone.destroyPlaceholders(id);
-      return;
+  }
+
+  function getPageKey() {
+    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;
+      }
+    } 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;
     }
-    window.ezstandalone.cmd = window.ezstandalone.cmd || [];
-    window.ezstandalone.cmd.push(function () {
-      try {
-        if (typeof window.ezstandalone.destroyPlaceholders === 'function') {
-          window.ezstandalone.destroyPlaceholders(id);
-        }
-      } catch (e) {}
-    });
-  } catch (e) {}
-}
-
-// Auto-height: hide until filled
-function setupAdAutoHeight() {
-  if (window.__ezoicAutoHeightAttached) return;
-  window.__ezoicAutoHeightAttached = true;
-
-  const attach = function () {
-    document.querySelectorAll('.ezoic-ad').forEach(function (wrap) {
-      if (!wrap.classList.contains('ezoic-filled')) {
-        wrap.style.display = 'none';
+    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) {}
+  }
+
+  function callEzoic(ids) {
+    if (!ids || !ids.length) return;
+    try {
+      window.ezstandalone = window.ezstandalone || {};
+      window.ezstandalone.cmd = window.ezstandalone.cmd || [];
+      const run = function () {
+        try {
+          if (typeof window.ezstandalone.showAds === 'function') {
+            window.ezstandalone.showAds.apply(window.ezstandalone, ids);
+            return true;
+          }
+        } catch (e) {}
+        return false;
+      };
+      window.ezstandalone.cmd.push(function () { run(); });
+      // retries in case ez loads late
+      let tries = 0;
+      const tick = function () {
+        tries++;
+        if (run() || tries >= 10) return;
+        setTimeout(tick, 800);
+      };
+      setTimeout(tick, 800);
+    } catch (e) {}
+  }
+
+  // Auto height: show wrapper only when placeholder gets children
+  function setupAutoHeight() {
+    if (window.__ezoicAutoHeight) return;
+    window.__ezoicAutoHeight = true;
+
+    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');
-        wrap.style.display = '';
       }
-    });
-  };
-
-  attach();
-  setTimeout(attach, 500);
-  setTimeout(attach, 1500);
-  setTimeout(attach, 3000);
-  setInterval(attach, 1000);
-}
-
-function callEzoic(ids) {
-  window.ezstandalone = window.ezstandalone || {};
-  window.ezstandalone.cmd = window.ezstandalone.cmd || [];
-
-  const uniq = Array.from(new Set(ids || []));
-  if (!uniq.length) return;
-
-  // De-dupe rapid duplicates
-  const key = uniq.join(',');
-  const now = Date.now();
-  if (window.__ezoicLastShowKey === key && (now - (window.__ezoicLastShowAt || 0)) < 1200) return;
-  window.__ezoicLastShowKey = key;
-  window.__ezoicLastShowAt = now;
-
-  const run = function () {
+    };
+
+    const scan = function () {
+      document.querySelectorAll('.ezoic-ad').forEach(mark);
+    };
+
+    scan();
+    setInterval(scan, 1000);
+
     try {
-      if (typeof window.ezstandalone.showAds === 'function') {
-        window.ezstandalone.showAds.apply(window.ezstandalone, uniq);
-        return true;
-      }
+      const mo = new MutationObserver(scan);
+      mo.observe(document.body, { childList: true, subtree: true });
     } catch (e) {}
-    return false;
-  };
+  }
 
-  setupAdAutoHeight();
-  window.ezstandalone.cmd.push(function () { run(); });
+  function insertAfter($target, id, kind, afterVal) {
+    const wrap = $(
+      '<div class="ezoic-ad ezoic-ad-' + kind + '" 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;
+  }
 
-  // Retry only if showAds isn't available yet
-  try {
-    if (typeof window.ezstandalone.showAds !== 'function') {
-      let tries = 0;
-      const retry = function () {
-        tries++;
-        if (run()) return;
-        if (tries < 6) setTimeout(retry, 800);
-      };
-      setTimeout(retry, 800);
-    }
-  } catch (e) {}
-}
+  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;
 
-// ---------- Pool logic ----------
-function pickNextId(pool, usedSet) {
-  for (const id of pool) {
-    if (!usedSet.has(id)) return id;
-  }
-  return null;
-}
-
-function recycleOldest(fifo, usedSet, selector, avoidAfterNode) {
-  if (window.__ezoicRecycling) return null;
-  window.__ezoicRecycling = true;
-  try {
-    fifo.sort((a, b) => (a.after - b.after));
-    while (fifo.length) {
-      const old = fifo.shift();
-      const el = document.querySelector(selector(old));
-      if (!el) continue;
-
-      // Don't recycle if it is right after the last real item (protect sentinel)
+      // don't recycle if this is right before the sentinel (after last post)
       try {
-        if (avoidAfterNode && el.previousElementSibling === avoidAfterNode) {
-          fifo.push(old);
+        const $last = $posts.last();
+        if ($last.length && $el.prev().is($last)) {
+          fifoTopic.push(old);
           return null;
         }
       } catch (e) {}
 
-      el.remove();
-      usedSet.delete(old.id);
-      destroyEzoicId(old.id);
+      $el.remove();
+      usedTopic.delete(old.id);
+      destroyPlaceholder(old.id);
       return old.id;
     }
     return null;
-  } finally {
-    window.__ezoicRecycling = false;
   }
-}
-
-// ---------- Injection ----------
-function injectBetweenAds(config) {
-  if (!config.enableBetweenAds) return;
-  const pool = parsePool(config.placeholderIds);
-  if (!pool.length) return;
-
-  const interval = Math.max(1, config.intervalPosts);
-  const items = Array.from(document.querySelectorAll('li[component="category/topic"]'));
-  if (!items.length) return;
-
-  const newIds = [];
-  const lastItem = items[items.length - 1];
-
-  for (let i = 0; i < items.length; i++) {
-    const pos = i + 1; // absolute position in loaded list
-    if (pos % interval !== 0) continue;
-    if (seenBetweenAfter.has(pos)) continue;
-
-    let id = pickNextId(pool, usedBetween);
-    if (!id) {
-      // recycle oldest
-      id = recycleOldest(
-        fifoBetween,
-        usedBetween,
-        (o) => `.ezoic-ad-topic[data-ezoic-after="${o.after}"][data-ezoic-id="${o.id}"]`,
-        lastItem
-      );
-      if (!id) break;
-    }
 
-    const anchor = items[i];
-    const wrap = document.createElement('li');
-    wrap.className = 'ezoic-ad ezoic-ad-topic';
-    wrap.setAttribute('data-ezoic-after', String(pos));
-    wrap.setAttribute('data-ezoic-id', String(id));
-    wrap.innerHTML = `<div id="ezoic-pub-ad-placeholder-${id}"></div>`;
+  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;
 
-    anchor.insertAdjacentElement('afterend', wrap);
+      try {
+        const $last = $items.last();
+        if ($last.length && $el.prev().is($last)) {
+          fifoCat.push(old);
+          return null;
+        }
+      } catch (e) {}
 
-    seenBetweenAfter.add(pos);
-    usedBetween.add(id);
-    fifoBetween.push({ after: pos, id });
-    newIds.push(id);
+      $el.remove();
+      usedCat.delete(old.id);
+      destroyPlaceholder(old.id);
+      return old.id;
+    }
+    return null;
   }
 
-  if (newIds.length) callEzoic(newIds);
-}
+  function injectInTopic() {
+    if (!(settings && (settings.enableMessageAds === true || settings.enableMessageAds === 'on'))) return;
+    const interval = parseInt(settings.messageIntervalPosts, 10) || 3;
+    const pool = parsePool(settings.messagePlaceholderIds);
+    if (!pool.length) return;
 
-function getPostNumberFromPost(postEl) {
-  // Prefer post-index text (#72)
-  try {
-    const idx = postEl.querySelector('a.post-index');
-    if (idx) {
-      const n = parseInt(String(idx.textContent || '').replace('#', '').trim(), 10);
-      if (Number.isFinite(n)) return n;
-    }
-  } catch (e) {}
-
-  // Fallback: pid-based ordering not reliable, but DOM order is ok for interval within loaded window.
-  return null;
-}
-
-function injectMessageAds(config) {
-  if (!config.enableMessageAds) return;
-  const pool = parsePool(config.messagePlaceholderIds);
-  if (!pool.length) return;
-
-  const interval = Math.max(1, config.messageIntervalPosts);
-  const posts = Array.from(document.querySelectorAll('[component="post"][data-pid]'));
-  if (!posts.length) return;
-
-  const newIds = [];
-  const lastPost = posts[posts.length - 1];
-
-  // Determine absolute post numbers if available; else use DOM position
-  let numbers = posts.map((p, i) => ({ el: p, no: getPostNumberFromPost(p) || (i + 1) }));
-  // Ensure strictly increasing by DOM
-  numbers = numbers.map((x, i) => ({ el: x.el, no: x.no || (i + 1) }));
-
-  for (const entry of numbers) {
-    const afterNo = entry.no;
-    if (afterNo % interval !== 0) continue;
-    if (seenMsgAfter.has(afterNo)) continue;
-
-    let id = pickNextId(pool, usedMessages);
-    if (!id) {
-      id = recycleOldest(
-        fifoMsg,
-        usedMessages,
-        (o) => `.ezoic-ad-post[data-ezoic-after="${o.after}"][data-ezoic-id="${o.id}"]`,
-        lastPost
-      );
-      if (!id) break;
-    }
+    const $posts = $('[component="post"][data-pid]');
+    if (!$posts.length) return;
+
+    const newIds = [];
+    $posts.each(function (idx) {
+      const postNo = idx + 1; // 1-based within loaded set
+      if (postNo % interval !== 0) return;
+
+      // Do not insert after the last post in DOM (to keep infinite scroll sentinel stable)
+      if (idx === $posts.length - 1) return;
 
-    const wrap = document.createElement('div');
-    wrap.className = 'ezoic-ad ezoic-ad-post';
-    wrap.setAttribute('data-ezoic-after', String(afterNo));
-    wrap.setAttribute('data-ezoic-id', String(id));
-    wrap.innerHTML = `<div class="ezoic-ad-message-inner"><div id="ezoic-pub-ad-placeholder-${id}"></div></div>`;
+      const $post = $(this);
+      const existing = $post.next('.ezoic-ad-topic');
+      if (existing.length) return;
 
-    entry.el.insertAdjacentElement('afterend', wrap);
+      let id = pickNextId(pool, usedTopic);
+      if (!id) {
+        id = recycleTopic($posts);
+        if (!id) return;
+      }
+      usedTopic.add(id);
+      fifoTopic.push({ id, afterNo: postNo });
+
+      insertAfter($post, id, 'topic', postNo).addClass('ezoic-ad-topic');
+      newIds.push(id);
+    });
 
-    seenMsgAfter.add(afterNo);
-    usedMessages.add(id);
-    fifoMsg.push({ after: afterNo, id });
-    newIds.push(id);
+    if (newIds.length) callEzoic(newIds);
   }
 
-  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;
+
+    const newIds = [];
+    $items.each(function (idx) {
+      const pos = idx + 1;
+      if (pos % interval !== 0) return;
+
+      if (idx === $items.length - 1) return;
 
-// ---------- Main refresh ----------
-async function refreshAds() {
-  if (inFlight) {
-    rerunRequested = true;
-    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).addClass('ezoic-ad-between');
+      newIds.push(id);
+    });
+
+    if (newIds.length) callEzoic(newIds);
   }
-  inFlight = true;
-  rerunRequested = false;
 
-  try {
-    const cfg = await fetchConfig();
-    if (cfg.excluded) return;
+  function refresh() {
+    if (!settings) return;
+    if (userExcluded()) return;
 
     const key = getPageKey();
-    if (key !== pageKey) {
+    if (pageKey !== key) {
       pageKey = key;
-      resetState();
-      cleanupOnNav();
+      cleanupForNewPage();
     }
 
-    const onTopic = isTopicPage();
-    const onCategory = isCategoryTopicListPage() && !onTopic;
+    setupAutoHeight();
+
+    if (isTopicPage()) {
+      injectInTopic();
+    } else if (isCategoryTopicList()) {
+      injectInCategory();
+    }
+  }
 
-    if (onCategory) injectBetweenAds(cfg);
-    if (onTopic) injectMessageAds(cfg);
-  } finally {
-    inFlight = false;
-    if (rerunRequested) setTimeout(refreshAds, 50);
+  // triggers: hard load + ajaxify + infinite scroll events
+  function boot() {
+    loadSettings(function () {
+      refresh();
+      // extra delayed refresh for late ez init
+      setTimeout(refresh, 1500);
+      setTimeout(refresh, 5000);
+      setTimeout(refresh, 10000);
+    });
   }
-}
 
-function debounceRefresh() {
-  if (debounceTimer) clearTimeout(debounceTimer);
-  debounceTimer = setTimeout(refreshAds, 250);
-}
+  // Hard load
+  $(document).ready(boot);
+  // Ajaxify nav end
+  $(window).on('action:ajaxify.end', boot);
+  // Infinite scroll loads (varies by view)
+  $(window).on('action:posts.loaded action:topic.loaded action:topics.loaded action:category.loaded', function () {
+    refresh();
+    setTimeout(refresh, 800);
+  });
 
-// ---------- Observers / Events ----------
-(function setupTriggers() {
-  // Ajaxify navigation: only cleanup when URL changes
+  // Clean only on real navigation start (not infinite loads)
   $(window).on('action:ajaxify.start', function (ev, data) {
     try {
-      const targetUrl = (data && (data.url || data.href)) ? String(data.url || data.href) : '';
-      if (targetUrl) {
-        const a = document.createElement('a');
-        a.href = targetUrl;
-        const targetPath = a.pathname || targetUrl;
-        if (targetPath === window.location.pathname) return;
-      }
+      const url = data && (data.url || data.href);
+      if (!url) return;
+      const a = document.createElement('a');
+      a.href = url;
+      if (a.pathname && a.pathname === window.location.pathname) return;
     } catch (e) {}
     pageKey = null;
-    resetState();
-    cleanupOnNav();
+    cleanupForNewPage();
   });
 
-  $(window).on('action:ajaxify.end action:posts.loaded action:topics.loaded action:topic.loaded action:category.loaded', debounceRefresh);
-
-  // MutationObserver (new posts/topics appended)
-  try {
-    const obs = new MutationObserver(function (mutations) {
-      for (const m of mutations) {
-        if (!m.addedNodes) continue;
-        for (const n of m.addedNodes) {
-          if (!n || n.nodeType !== 1) continue;
-          if (n.matches && (n.matches('[component="post"][data-pid]') || n.matches('li[component="category/topic"]'))) {
-            debounceRefresh();
-            return;
-          }
-          if (n.querySelector && (n.querySelector('[component="post"][data-pid]') || n.querySelector('li[component="category/topic"]'))) {
-            debounceRefresh();
-            return;
-          }
-        }
-      }
-    });
-    obs.observe(document.body, { childList: true, subtree: true });
-    window.__ezoicInfiniteObserver = obs;
-  } catch (e) {}
-
-  // Poller fallback (count changes)
-  let lastPosts = 0;
-  let lastTopics = 0;
-  setInterval(function () {
-    const p = document.querySelectorAll('[component="post"][data-pid]').length;
-    const t = document.querySelectorAll('li[component="category/topic"]').length;
-    if (p !== lastPosts || t !== lastTopics) {
-      lastPosts = p; lastTopics = t;
-      debounceRefresh();
-    }
-  }, 1500);
-
-  // First run(s) - important for hard load
-  document.addEventListener('DOMContentLoaded', function () {
-    debounceRefresh();
-    setTimeout(debounceRefresh, 1500);
-    setTimeout(debounceRefresh, 5000);
-    setTimeout(debounceRefresh, 10000);
-  });
-  // In case this script loads after DOMContentLoaded
-  setTimeout(debounceRefresh, 800);
 })();

package/public/style.css

@@ -1,4 +1,4 @@
 .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-message-inner{padding:0;margin:0;}
-.ezoic-ad-message-inner > div{margin:0;padding:0;}
+.ezoic-ad .ezoic-ad-inner{padding:0;margin:0;}
+.ezoic-ad .ezoic-ad-inner > div{margin:0;padding:0;}

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

@@ -1,59 +1,59 @@
 <div class="acp-page-container">
-  <h2>Ezoic Infinite Ads</h2>
+  <h1 class="mb-3">Ezoic Infinite</h1>
 
-  <form class="ezoic-infinite-settings" role="form">
-    <h4 class="mt-3">Pubs entre les posts (bloc simple)</h4>
-
-    <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="alert alert-info">
+    Placeholders format: <code>&lt;div id="ezoic-pub-ad-placeholder-XXX"&gt;&lt;/div&gt;</code>
+  </div>
 
+  <form role="form" class="ezoic-infinite-settings">
     <div class="mb-3">
-      <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" for="intervalPosts">Afficher une pub tous les N posts</label>
-      <input type="number" id="intervalPosts" name="intervalPosts" class="form-control" value="{intervalPosts}" min="1">
+      <label class="form-label">Exclude groups (ads disabled for members of these groups)</label>
+      <select multiple class="form-select" name="excludedGroups">
+        <!-- BEGIN groups -->
+        <option value="{groups.name}">{groups.name}</option>
+        <!-- END groups -->
+      </select>
+      <div class="form-text">Hold Ctrl/Cmd to select multiple. Groups are sorted alphabetically.</div>
     </div>
 
     <hr/>
 
-    <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>
+    <h3>Between topics in category (topic list)</h3>
 
-    <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 class="form-check form-switch mb-2">
+      <input class="form-check-input" type="checkbox" name="enableBetweenAds">
+      <label class="form-check-label">Enable between-topic ads</label>
     </div>
 
     <div class="mb-3">
-      <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>
+      <label class="form-label">Interval (insert after every N topics)</label>
+      <input type="number" class="form-control" name="intervalTopics" min="1" step="1">
     </div>
 
     <div class="mb-3">
-      <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">
+      <label class="form-label">Placeholder ID pool (one per line)</label>
+      <textarea class="form-control" name="placeholderIds" rows="6"></textarea>
     </div>
 
     <hr/>
 
-    <h4 class="mt-3">Exclusions</h4>
+    <h3>Inside topics (between posts)</h3>
+
+    <div class="form-check form-switch mb-2">
+      <input class="form-check-input" type="checkbox" name="enableMessageAds">
+      <label class="form-check-label">Enable between-post ads</label>
+    </div>
+
     <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>
+      <label class="form-label">Interval (insert after every N posts)</label>
+      <input type="number" class="form-control" name="messageIntervalPosts" min="1" step="1">
+    </div>
+
+    <div class="mb-3">
+      <label class="form-label">Message placeholder ID pool (one per line)</label>
+      <textarea class="form-control" name="messagePlaceholderIds" rows="6"></textarea>
     </div>
 
-    <button id="save" class="btn btn-primary">Enregistrer</button>
+    <button type="button" class="btn btn-primary ezoic-infinite-save">Save</button>
   </form>
 </div>