nodebb-plugin-ezoic-infinite 1.0.5 → 1.0.7

package/library.js

@@ -2,58 +2,99 @@
 
 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 ({ router, middleware }) {
-  router.get('/admin/plugins/ezoic-infinite', middleware.admin.buildHeader, renderAdmin);
-  router.get('/api/admin/plugins/ezoic-infinite', renderAdmin);
-};
+function normalizeExcludedGroups(value) {
+  if (!value) return [];
+  if (Array.isArray(value)) return value;
+  return String(value).split(',').map(s => s.trim()).filter(Boolean);
+}
 
-async function renderAdmin(req, res) {
-  const settings = await meta.settings.get('ezoic-infinite');
+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';
+}
 
-  let groupNames = [];
-  const candidates = ['groups:createtime', 'groups:visible:createtime', 'groups:alphabetical', 'groups:visible:alphabetical'];
-  for (const set of candidates) {
-    try {
-      groupNames = await groups.getGroupsFromSet(set, 0, -1);
-      if (Array.isArray(groupNames) && groupNames.length) break;
-    } catch (e) {}
+async function getAllGroups() {
+  let names = await db.getSortedSetRange('groups:createtime', 0, -1);
+  if (!names || !names.length) {
+    names = await db.getSortedSetRange('groups:visible: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;
 };
 
-Plugin.addConfig = async function (config) {
-  const settings = await meta.settings.get('ezoic-infinite');
-  config.ezoicInfinite = settings || {};
-  return config;
+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": "1.0.5",
-  "description": "Ezoic ads injection for NodeBB 4.x (ACP stable like 0.9.5 + injection logic like 0.9.7).",
+  "version": "1.0.7",
+  "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 (topics list + topic posts) with pool recycling for infinite scroll.",
+  "name": "NodeBB Ezoic Infinite Ads",
+  "description": "Ezoic ads with infinite scroll using a pool of placeholder IDs",
   "library": "./library.js",
   "hooks": [
     {
@@ -11,10 +11,6 @@
     {
       "hook": "filter:admin.header.build",
       "method": "addAdminNavigation"
-    },
-    {
-      "hook": "filter:config.get",
-      "method": "addConfig"
     }
   ],
   "staticDirs": {
@@ -26,8 +22,8 @@
   "scripts": [
     "public/client.js"
   ],
+  "templates": "public/templates",
   "css": [
     "public/style.css"
-  ],
-  "templates": "public/templates"
+  ]
 }

package/public/admin.js

@@ -1,59 +1,29 @@
-/* global $, app, socket */
+/* globals ajaxify */
 'use strict';
 
 (function () {
-  if (window.ezoicInfiniteAdminLoaded) return;
-  window.ezoicInfiniteAdminLoaded = true;
-
-  $(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()));
+  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é');
+          }
         });
       });
-    }
-
-    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('Paramètres enregistrés');
-      });
-    }
+    });
+  }
 
-    $(document).on('click', '.ezoic-infinite-save', save);
-    load();
-  });
+  $(document).ready(init);
+  $(window).on('action:ajaxify.end', init);
 })();

package/public/client.js

@@ -1,45 +1,26 @@
-/* global $, ajaxify, app */
 'use strict';
 
+/* globals ajaxify */
 (function () {
   if (window.ezoicInfiniteLoaded) return;
   window.ezoicInfiniteLoaded = true;
 
-  function getSettings() {
-    return (window.config && window.config.ezoicInfinite) ? window.config.ezoicInfinite : {};
-  }
+  let cachedConfig;
+  let lastFetch = 0;
+  let debounceTimer;
+
+  let inFlight = false;
+  let rerunRequested = false;
 
-  let settings = getSettings();
+  // per page state
   let pageKey = null;
 
-  let usedBetween = new Set();
-  let usedMessage = new Set();
+  // separate pools/state
+  let usedBetween = new Set();  // between topics list
+  let usedMessage = new Set();  // between replies
   let fifoBetween = [];
   let fifoMessage = [];
 
-  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; }
-  }
-
   function getPageKey() {
     try {
       if (ajaxify && ajaxify.data) {
@@ -56,11 +37,31 @@
   }
 
   function isCategoryTopicList() {
-    return $('li[component="category/topic"]').length > 0 && !isTopicPage();
+    return document.querySelectorAll('li[component="category/topic"]').length > 0 && !isTopicPage();
+  }
+
+  function parsePool(raw) {
+    if (!raw) return [];
+    // accept newline, comma, space, semicolon
+    const arr = String(raw).split(/[\n,;\s]+/)
+      .map(x => parseInt(x, 10))
+      .filter(n => Number.isFinite(n) && n > 0);
+    // unique while preserving order
+    return Array.from(new Set(arr));
+  }
+
+  async function fetchConfig() {
+    if (cachedConfig && Date.now() - lastFetch < 10000) return cachedConfig;
+    const base = (window.config && window.config.relative_path) ? window.config.relative_path : '';
+    const res = await fetch(base + '/api/plugins/ezoic-infinite/config', { credentials: 'same-origin' });
+    const json = await res.json();
+    cachedConfig = json;
+    lastFetch = Date.now();
+    return json;
   }
 
   function cleanupForNewPage() {
-    $('.ezoic-ad').remove();
+    document.querySelectorAll('.ezoic-ad').forEach(el => el.remove());
     usedBetween = new Set();
     usedMessage = new Set();
     fifoBetween = [];
@@ -85,15 +86,12 @@
     const existing = document.getElementById('ezoic-pub-ad-placeholder-' + id);
     if (!existing) return;
     const wrap = existing.closest('.ezoic-ad');
-    if (wrap) {
-      try { $(wrap).remove(); } catch (e) { wrap.remove(); }
-    } else {
-      existing.remove();
-    }
+    if (wrap) wrap.remove();
+    else existing.remove();
     destroyPlaceholder(id);
   }
 
-  function callEzoicSingle(id) {
+  function callShowAdsSingle(id) {
     if (!id) return;
 
     const now = Date.now();
@@ -102,30 +100,27 @@
     if (now - last < 1200) return;
     window.__ezoicLastSingle[id] = now;
 
-    try {
-      window.ezstandalone = window.ezstandalone || {};
-      window.ezstandalone.cmd = window.ezstandalone.cmd || [];
-
-      const run = function () {
-        try {
-          if (typeof window.ezstandalone.showAds === 'function') {
-            window.ezstandalone.showAds(id);
-            return true;
-          }
-        } catch (e) {}
-        return false;
-      };
-
-      window.ezstandalone.cmd.push(function () { run(); });
-
-      let tries = 0;
-      const tick = function () {
-        tries++;
-        if (run() || tries >= 8) return;
-        setTimeout(tick, 800);
-      };
+    window.ezstandalone = window.ezstandalone || {};
+    window.ezstandalone.cmd = window.ezstandalone.cmd || [];
+
+    const run = function () {
+      try {
+        if (typeof window.ezstandalone.showAds === 'function') {
+          window.ezstandalone.showAds(id);
+          return true;
+        }
+      } catch (e) {}
+      return false;
+    };
+
+    window.ezstandalone.cmd.push(function () { run(); });
+
+    let tries = 0;
+    (function tick() {
+      tries++;
+      if (run() || tries >= 8) return;
       setTimeout(tick, 800);
-    } catch (e) {}
+    })();
   }
 
   function pickNextId(pool, usedSet) {
@@ -133,14 +128,13 @@
     return null;
   }
 
-  function recycle(fifo, usedSet, selectorFn) {
+  function recycle(fifo, usedSet, selector) {
     fifo.sort((a, b) => a.after - b.after);
     while (fifo.length) {
       const old = fifo.shift();
-      const $el = selectorFn(old);
-      if (!$el.length) continue;
-
-      $el.remove();
+      const el = document.querySelector(selector(old));
+      if (!el) continue;
+      el.remove();
       usedSet.delete(old.id);
       destroyPlaceholder(old.id);
       return old.id;
@@ -148,93 +142,81 @@
     return null;
   }
 
-  function insertAfter($target, id, cls, afterVal) {
+  function insertAfter(targetEl, id, cls, afterVal) {
     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);
+    const wrap = document.createElement('div');
+    wrap.className = 'ezoic-ad ' + cls;
+    wrap.setAttribute('data-ezoic-id', String(id));
+    wrap.setAttribute('data-ezoic-after', String(afterVal));
+    wrap.innerHTML = '<div class="ezoic-ad-inner"><div id="ezoic-pub-ad-placeholder-' + id + '"></div></div>';
+    targetEl.insertAdjacentElement('afterend', wrap);
   }
 
-  function injectBetweenTopics() {
-    if (!(settings && (settings.enableBetweenAds === true || settings.enableBetweenAds === 'on'))) return;
-
-    const interval = parseInt(settings.intervalTopics, 10) || 6;
-    const pool = parsePool(settings.placeholderIds);
+  function injectBetweenTopics(cfg) {
+    if (!cfg.enableBetweenAds) return;
+    const interval = Math.max(1, parseInt(cfg.intervalPosts, 10) || 6);
+    const pool = parsePool(cfg.placeholderIds);
     if (!pool.length) return;
 
-    const $items = $('li[component="category/topic"]');
-    if (!$items.length) return;
+    const items = Array.from(document.querySelectorAll('li[component="category/topic"]'));
+    if (!items.length) return;
 
-    $items.each(function (idx) {
+    items.forEach((li, idx) => {
       const pos = idx + 1;
       if (pos % interval !== 0) return;
-      if (idx === $items.length - 1) return;
+      if (idx === items.length - 1) return;
 
-      const $li = $(this);
-      if ($li.next('.ezoic-ad-between').length) return;
+      const next = li.nextElementSibling;
+      if (next && next.classList && next.classList.contains('ezoic-ad-between')) return;
 
       let id = pickNextId(pool, usedBetween);
       if (!id) {
-        id = recycle(
-          fifoBetween, usedBetween,
-          (old) => $('.ezoic-ad-between[data-ezoic-id="' + old.id + '"][data-ezoic-after="' + old.after + '"]')
-        );
-        if (!id) return;
+        id = recycle(fifoBetween, usedBetween, (old) => '.ezoic-ad-between[data-ezoic-id="' + old.id + '"][data-ezoic-after="' + old.after + '"]');
+        if (!id) return; // pool empty and nothing recyclable => stop
       }
 
       usedBetween.add(id);
       fifoBetween.push({ id, after: pos });
 
-      insertAfter($li, id, 'ezoic-ad-between', pos);
-      callEzoicSingle(id);
+      insertAfter(li, id, 'ezoic-ad-between', pos);
+      callShowAdsSingle(id);
     });
   }
 
-  function injectBetweenMessages() {
-    if (!(settings && (settings.enableMessageAds === true || settings.enableMessageAds === 'on'))) return;
-
-    const interval = parseInt(settings.messageIntervalPosts, 10) || 3;
-    const pool = parsePool(settings.messagePlaceholderIds);
+  function injectBetweenMessages(cfg) {
+    if (!cfg.enableMessageAds) return;
+    const interval = Math.max(1, parseInt(cfg.messageIntervalPosts, 10) || 3);
+    const pool = parsePool(cfg.messagePlaceholderIds);
     if (!pool.length) return;
 
-    const $posts = $('[component="post"][data-pid]');
-    if (!$posts.length) return;
+    const posts = Array.from(document.querySelectorAll('[component="post"][data-pid]'));
+    if (!posts.length) return;
 
-    $posts.each(function (idx) {
-      const postNo = idx + 1;
-      if (postNo % interval !== 0) return;
-      if (idx === $posts.length - 1) return;
+    posts.forEach((post, idx) => {
+      const no = idx + 1;
+      if (no % interval !== 0) return;
+      if (idx === posts.length - 1) return;
 
-      const $post = $(this);
-      if ($post.next('.ezoic-ad-message').length) return;
+      const next = post.nextElementSibling;
+      if (next && next.classList && next.classList.contains('ezoic-ad-message')) return;
 
       let id = pickNextId(pool, usedMessage);
       if (!id) {
-        id = recycle(
-          fifoMessage, usedMessage,
-          (old) => $('.ezoic-ad-message[data-ezoic-id="' + old.id + '"][data-ezoic-after="' + old.after + '"]')
-        );
+        id = recycle(fifoMessage, usedMessage, (old) => '.ezoic-ad-message[data-ezoic-id="' + old.id + '"][data-ezoic-after="' + old.after + '"]');
         if (!id) return;
       }
 
       usedMessage.add(id);
-      fifoMessage.push({ id, after: postNo });
+      fifoMessage.push({ id, after: no });
 
-      insertAfter($post, id, 'ezoic-ad-message', postNo);
-      callEzoicSingle(id);
+      insertAfter(post, id, 'ezoic-ad-message', no);
+      callShowAdsSingle(id);
     });
   }
 
-  function refresh() {
-    settings = getSettings();
-    if (!settings) return;
-    if (userExcluded()) return;
-
-    if (refreshInFlight) { refreshQueued = true; return; }
-    refreshInFlight = true;
+  async function run() {
+    if (inFlight) { rerunRequested = true; return; }
+    inFlight = true;
 
     try {
       const key = getPageKey();
@@ -243,29 +225,56 @@
         cleanupForNewPage();
       }
 
-      if (isTopicPage()) injectBetweenMessages();
-      else if (isCategoryTopicList()) injectBetweenTopics();
+      const cfg = await fetchConfig();
+      if (!cfg || cfg.excluded) return;
+
+      if (isTopicPage()) injectBetweenMessages(cfg);
+      else if (isCategoryTopicList()) injectBetweenTopics(cfg);
+    } catch (e) {
+      // silent
     } finally {
-      refreshInFlight = false;
-      if (refreshQueued) { refreshQueued = false; setTimeout(refresh, 50); }
+      inFlight = false;
+      if (rerunRequested) {
+        rerunRequested = false;
+        setTimeout(run, 50);
+      }
     }
   }
 
-  function boot() {
-    refresh();
-    setTimeout(refresh, 1200);
+  function scheduleRun() {
+    clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(run, 150);
+  }
+
+function bindNodeBBEvents() {
+    // NodeBB triggers these events through jQuery on window
+    if (window.jQuery) {
+      const $w = window.jQuery(window);
+      $w.off('.ezoicInfinite');
+      $w.on('action:ajaxify.end.ezoicInfinite', scheduleRun);
+      $w.on('action:posts.loaded.ezoicInfinite', scheduleRun);
+      $w.on('action:topic.loaded.ezoicInfinite', scheduleRun);
+      $w.on('action:topics.loaded.ezoicInfinite', scheduleRun);
+      $w.on('action:category.loaded.ezoicInfinite', scheduleRun);
+      $w.on('action:ajaxify.start.ezoicInfinite', function () {
+        pageKey = null;
+        cleanupForNewPage();
+      });
+    }
   }
 
-  $(document).ready(boot);
-  $(window).on('action:ajaxify.end', boot);
+  bindNodeBBEvents();
 
-  $(window).on('action:posts.loaded action:topics.loaded action:topic.loaded action:category.loaded', function () {
-    refresh();
-    setTimeout(refresh, 600);
-  });
+  // Run immediately, so it works on first ajaxify navigation too
+  run();
+  setTimeout(run, 1200);
 
-  $(window).on('action:ajaxify.start', function () {
-    pageKey = null;
-    cleanupForNewPage();
-  });
+  // Also run on hard-refresh initial load
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', function () {
+      bindNodeBBEvents();
+      run();
+      setTimeout(run, 1200);
+    });
+  }
 })();

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

@@ -1,78 +1,59 @@
-<div class="row">
-  <div class="col-lg-9">
-    <div class="card">
-      <div class="card-header">
-        <strong>Ezoic Infinite</strong>
-      </div>
-      <div class="card-body">
-        <form class="ezoic-infinite-settings">
-          <div class="mb-3">
-            <label class="form-label">Groupes exclus</label>
-            <select multiple class="form-control" name="excludedGroups" size="10">
-              <!-- BEGIN groups -->
-              <option value="{groups.name}">{groups.name}</option>
-              <!-- END groups -->
-            </select>
-            <p class="form-text">Aucune publicité ne sera affichée pour ces groupes.</p>
-          </div>
+<div class="acp-page-container">
+  <h2>Ezoic - Publicités Infinite Scroll Ads</h2>
 
-          <hr />
+  <form class="ezoic-infinite-settings" role="form">
+    <h4 class="mt-3">Pubs entre les posts (bloc simple)</h4>
 
-          <h5>Publicités entre les topics (liste des sujets)</h5>
-
-          <div class="form-check mb-3">
-            <input class="form-check-input" type="checkbox" name="enableBetweenAds" id="enableBetweenAds">
-            <label class="form-check-label" for="enableBetweenAds">Activer</label>
-          </div>
-
-          <div class="mb-3">
-            <label class="form-label">Intervalle (après chaque N topics)</label>
-            <input type="number" class="form-control" name="intervalTopics" min="1" step="1">
-          </div>
+    <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">Pool d'IDs placeholder (un par ligne)</label>
-            <textarea class="form-control" name="placeholderIds" rows="6"></textarea>
-          </div>
+    <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>
 
-          <hr />
+    <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">
+    </div>
 
-          <h5>Publicités entre les messages (dans un topic)</h5>
+    <hr/>
 
-          <div class="form-check mb-3">
-            <input class="form-check-input" type="checkbox" name="enableMessageAds" id="enableMessageAds">
-            <label class="form-check-label" for="enableMessageAds">Activer</label>
-          </div>
+    <h4 class="mt-3">Pubs “message” entre les réponses</h4>
+    <p class="form-text">Insère un bloc qui ressemble à un post, toutes les N réponses (dans une page topic).</p>
 
-          <div class="mb-3">
-            <label class="form-label">Intervalle (après chaque N messages)</label>
-            <input type="number" class="form-control" name="messageIntervalPosts" min="1" step="1">
-          </div>
+    <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">Pool d'IDs placeholder messages (un par ligne)</label>
-            <textarea class="form-control" name="messagePlaceholderIds" rows="6"></textarea>
-          </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>
+    </div>
 
-          <button type="button" class="btn btn-primary ezoic-infinite-save">
-            <i class="fa fa-save"></i> Enregistrer
-          </button>
-        </form>
-      </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">
     </div>
-  </div>
 
-  <div class="col-lg-3">
-    <div class="card">
-      <div class="card-header">
-        <strong>Aide</strong>
-      </div>
-      <div class="card-body">
-        <p>Placeholder Ezoic :</p>
-        <pre class="mb-0">&lt;div id="ezoic-pub-ad-placeholder-123"&gt;&lt;/div&gt;</pre>
-        <hr />
-        <p class="mb-0">Les IDs doivent exister côté Ezoic (ad units configurées).</p>
-      </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>
-  </div>
+
+    <button id="save" class="btn btn-primary">Enregistrer</button>
+  </form>
 </div>

package/README.md

@@ -1,5 +0,0 @@
-nodebb-plugin-ezoic-infinite v1.0.5
-
-- ACP kept in the same spirit as v0.9.5 (server-rendered groups + admin.settings.get/set)
-- Injection logic matches v0.9.7: showAds called one placeholder at a time, separate pools, FIFO recycling.
-- Frontend settings are read from window.config.ezoicInfinite (filter:config.get), no admin endpoints used on frontend.