547 lines
26 KiB
JavaScript
547 lines
26 KiB
JavaScript
/* Barre d'apps commune dracodev — comportement (v0.1.0, ACC-0.2 ;
|
|
* v0.1.3 : menu des applications ouvert par la marque ✦ ;
|
|
* v0.1.5 : noms publics par configuration — aucun nom public d'un
|
|
* environnement particulier n'est codé en dur, voir « URL » ci-dessous ;
|
|
* v0.1.6 (prochaine publication — VERSION non bumpée dans cette PR,
|
|
* la publication est séparée) : dérivation -dev par l'hôte courant,
|
|
* menu trois points par défaut et menu compte fonctionnels, voir ci-dessous ;
|
|
* correctif fusion #70 (SANS bump de version, publication séparée) :
|
|
* bouton trois points et son menu par défaut SUPPRIMÉS, « Console Spark »
|
|
* ajoutée au menu de la marque, fermeture/focus corrigés (voir
|
|
* « Menu des applications », « Focus » et « Écouteurs globaux »).
|
|
*
|
|
* Aucun gestionnaire inline : un seul écouteur délégué sur le document
|
|
* (patron validé par le prototype — les onclick du HTML généré sont
|
|
* proscrits dans tout le programme).
|
|
*
|
|
* Configuration attendue avant le chargement :
|
|
* window.DRACO_BAR_CONFIG = {
|
|
* current: "tiktak", // app courante
|
|
* domain: "pro", // domaine actif
|
|
* counts: { tiktak: 3, kanbante: 3, alertes: 3, spark: 0 },
|
|
* user: "Bruno", // nom affiché (v0.1.6) ;
|
|
* // ou { display_name: "Bruno", username: "bruno" }
|
|
* urls: { // bases des applications
|
|
* obsigate: "https://og.dracodev.net/",
|
|
* flowdeck: "https://flowdeck.dracodev.net/",
|
|
* tiktak: "https://tiktak.dracodev.net/",
|
|
* kanbante: "https://kanbante.dracodev.net/",
|
|
* agent: "https://agent.dracodev.net/",
|
|
* spark: "https://spark.dracodev.net/"
|
|
* },
|
|
* onAction: function (act, el) { … } // l'app relaie les actions
|
|
* } // qu'elle ne connaît pas
|
|
*
|
|
* URL des applications (contrat dev/prod, v0.1.5 puis v0.1.6) —
|
|
* résolution, dans l'ordre STRICT, pour chaque app :
|
|
* 1. DRACO_BAR_CONFIG.urls.<app>, injectée par l'app hôte (rendu
|
|
* serveur ou client) depuis SA configuration d'environnement —
|
|
* explicite, donc prioritaire, même sur un hôte -dev ;
|
|
* 2. (v0.1.6) SI l'hôte courant est un hôte -dev dracodev.net
|
|
* (première étiquette se terminant par -dev : tiktak-dev,
|
|
* kanbante-dev, og-dev, flowdeck-dev, agent-dev…), l'URL sœur
|
|
* dérivée avec -dev (voir DEV_URLS). C'est le correctif du bug
|
|
* constaté sur tiktak-dev / kanbante-dev, où les liens suivaient
|
|
* les noms SANS -dev faute de configuration explicite ;
|
|
* 3. le href déjà rendu dans le fragment HTML, c.-à-d. le jeton
|
|
* {{URL_<APP>}} remplacé côté serveur par l'app hôte ;
|
|
* 4. le défaut officiel ci-dessous (production, noms SANS suffixe).
|
|
* Un jeton {{URL_…}} non remplacé n'est jamais une URL : il est ignoré
|
|
* partout (config injectée comme href rendu) et ne peut pas être exposé.
|
|
* Cas spark (v0.1.6) : AUCUNE dérivation inventée — aucun hôte
|
|
* spark-dev connu ; sur un hôte -dev, spark retombe sur l'étape 3
|
|
* (href rendu) puis 4 (défaut prod), sauf config explicite (étape 1).
|
|
* La clé spark ne correspond à aucun onglet de la barre : elle est
|
|
* résolue et exposée via DRACO_BAR.urls pour le panneau Spark
|
|
* (panneau-agent), qui suit le même contrat d'injection. La clé agent,
|
|
* elle, a un onglet depuis le chantier 5 (ordre : ObsiGate, Flowdeck,
|
|
* TikTak, Kanbante, Console Spark) : elle suit donc l'étape « href
|
|
* rendu » comme les autres onglets, en plus d'alimenter le menu de
|
|
* la marque et DRACO_BAR.urls.
|
|
* Actions émises (data-act) : rail, palette, domaine (data-dom),
|
|
* alertes, spark, rappel-entete. L'app intégratrice décide de chacune
|
|
* (ouvrir la palette, le panneau Spark, changer de domaine…).
|
|
* Actions INTERNES (jamais relayées comme avant) : apps — la marque ✦
|
|
* ouvre le menu des applications, construit depuis les onglets, plus
|
|
* (depuis le correctif #70) une entrée « Console Spark » vers la
|
|
* console de l'agent commun (URL agent résolue, voir ci-dessous) ;
|
|
* c'est le moyen de changer d'app en mobile, où les onglets sont
|
|
* repliés (v0.1.2). Menu compte : voir ci-dessous.
|
|
* L'action « menu » n'est PLUS émise nulle part : le bouton trois points
|
|
* a été supprimé (#70) ; les branches onAction("menu") des hôtes
|
|
* (TikTak/Kanbante/Flowdeck : retour false pour le menu par défaut ;
|
|
* ObsiGate : clic #header-menu-btn) sont donc mortes et ont été
|
|
* retirées des gabarits hôtes — le menu natif d'ObsiGate
|
|
* (#header-menu-btn) lui-même n'est pas touché.
|
|
*
|
|
* Retrait du bouton trois points (correctif fusion #70) — le bouton et
|
|
* son menu par défaut (console agent + applications) sont supprimés
|
|
* du fragment, du JS et du CSS. La console agent reste joignable par
|
|
* l'entrée « Console Spark » du menu de la marque (ci-dessous) et
|
|
* par le bouton Spark (panneau), donc aucun accès n'est perdu.
|
|
* Menu des applications (v0.1.3, étendu #70) — construit depuis les
|
|
* onglets présents dans la barre, puis une entrée « Console Spark »
|
|
* (logo ✦, rôle « Agent commun ») APRÈS Kanbante, vers l'URL agent
|
|
* résolue : 1) config explicite DRACO_BAR_CONFIG.urls.agent,
|
|
* 2) dérivation -dev agent-dev sur hôte -dev, 3) href rendu de
|
|
* l'onglet « Console Spark » (chantier 5, data-app="agent"),
|
|
* 4) défaut officiel prod https://agent.dracodev.net/.
|
|
* AUCUN hôte spark-dev n'est inventé :
|
|
* la clé spark, elle, suit toujours son propre contrat (explicite >
|
|
* href rendu > défaut prod) et ne sert qu'au panneau Spark.
|
|
* Focus (correctif #70) — ouverture au clavier : Entrée sur la marque
|
|
* (clic natif du lien) ; Espace sur la marque (keydown dédié, car un
|
|
* lien ne s'active pas à l'Espace) : ouvre le menu et met le focus
|
|
* sur son premier item. Fermeture : Échap (focus rendu au déclencheur
|
|
* qui avait ouvert le menu : la marque pour le menu apps, l'avatar
|
|
* pour le menu compte), nouvel appui sur le déclencheur (le focus y
|
|
* est déjà), choix d'un item, ou clic extérieur — ce dernier cas ne
|
|
* déplace VOLONTAIREMENT pas le focus (l'utilisateur vient de cliquer
|
|
* ailleurs : recherche, tâche… ; lui voler le focus casserait son
|
|
* geste). aria-expanded est tenu à jour sur chaque déclencheur.
|
|
* Écouteurs globaux (correctif #70, bug tiktak-dev) — les écouteurs
|
|
* clic/Échap de la barre sont posés via EventTarget.prototype (voir
|
|
* addGlobalListener), PAS via document.addEventListener. Cause
|
|
* prouvée sur TikTak (app/static/js/app.js, navigation #89) : app.js
|
|
* remplace document/window.addEventListener par un registre
|
|
* (__tcDocWin) et chaque navigation douce appelle tcInit() puis
|
|
* __tcTeardown(), qui SUPPRIME tous les écouteurs du registre — y
|
|
* compris ceux de draco-barre.js (script defer, enregistré après le
|
|
* tcInit() initial). La barre survit à la navigation (hors .layout
|
|
* remplacé) mais ses gestionnaires sont morts : un menu ouvert avant
|
|
* la navigation reste ouvert (Échap et clic extérieur sans effet) et
|
|
* la marque, lien href="/", est interceptée par l'intercepteur SPA
|
|
* brut de TikTak (__tcDocAdd, hors registre, donc survivant) comme
|
|
* une navigation interne au lieu de basculer le menu. Les écouteurs
|
|
* posés sur le prototype ne figurent pas dans le registre et ne sont
|
|
* donc jamais supprimés par le teardown ; en complément, le gabarit
|
|
* TikTak exclut désormais .draco-bar de l'intercepteur SPA, pour que
|
|
* la marque ne déclenche plus de navigation douce. Les autres hôtes
|
|
* (SSR, rechargement complet) ne sont pas concernés par le teardown
|
|
* mais bénéficient du même code ; repli : si EventTarget.prototype
|
|
* est indisponible (mini-DOM de tests), document.addEventListener
|
|
* classique est utilisé.
|
|
* Menu compte (v0.1.6) — l'avatar, auparavant un <span> mort affichant
|
|
* un « B » codé en dur dans le fragment, est un vrai <button>
|
|
* (data-act="compte"). Son initiale vient de cfg.user ou, à défaut, de
|
|
* la première lettre du title {{UTILISATEUR}} remplacé ; sans nom connu,
|
|
* le neutre ✦ est conservé (jamais de lettre codée en dur). Le clic
|
|
* ouvre un petit menu affichant le nom de l'utilisateur ; les items
|
|
* Profil / Déconnexion sont relayés à l'hôte via onAction ou, à défaut,
|
|
* via l'événement draco:bar (détail { act: "profil" | "deconnexion" }),
|
|
* mais le menu affiche l'identité même sans gestionnaire hôte.
|
|
* Accessibilité : vrais <button>, aria-haspopup / aria-expanded,
|
|
* role="menu" / "menuitem", fermeture par Échap et clic extérieur.
|
|
*/
|
|
(function () {
|
|
"use strict";
|
|
var cfg = window.DRACO_BAR_CONFIG || {};
|
|
|
|
/* Défauts OFFICIELS (production) — les seuls noms publics présents
|
|
* dans ce fichier, documentés comme défauts (contrat dev/prod). */
|
|
var DEFAULT_URLS = {
|
|
obsigate: "https://og.dracodev.net/",
|
|
flowdeck: "https://flowdeck.dracodev.net/",
|
|
tiktak: "https://tiktak.dracodev.net/",
|
|
kanbante: "https://kanbante.dracodev.net/",
|
|
agent: "https://agent.dracodev.net/",
|
|
spark: "https://spark.dracodev.net/"
|
|
};
|
|
|
|
/* Dérivation -dev (v0.1.6) — appliquée UNIQUEMENT quand l'hôte courant
|
|
* est lui-même un hôte -dev dracodev.net (voir isDevHost). spark est
|
|
* volontairement absent : aucun hôte spark-dev connu, aucune URL
|
|
* inventée ; spark retombe sur href rendu puis défaut prod. */
|
|
var DEV_URLS = {
|
|
obsigate: "https://og-dev.dracodev.net/",
|
|
flowdeck: "https://flowdeck-dev.dracodev.net/",
|
|
tiktak: "https://tiktak-dev.dracodev.net/",
|
|
kanbante: "https://kanbante-dev.dracodev.net/",
|
|
agent: "https://agent-dev.dracodev.net/"
|
|
};
|
|
|
|
var APP_LABELS = {
|
|
obsigate: "ObsiGate", flowdeck: "Flowdeck",
|
|
tiktak: "TikTak", kanbante: "Kanbante"
|
|
};
|
|
|
|
/* Vrai si hostname est un hôte -dev dracodev.net : première étiquette
|
|
* se terminant par -dev ET domaine dracodev.net (un suffixe -dev sur
|
|
* un autre domaine, ou un hôte piège du type x-dev.dracodev.net.evil,
|
|
* ne déclenche rien). Insensible à la casse. */
|
|
function isDevHost(hostname) {
|
|
if (!hostname) return false;
|
|
var h = String(hostname).toLowerCase();
|
|
if (h.slice(-13) !== ".dracodev.net") return false;
|
|
var first = h.split(".")[0];
|
|
return first.length > 4 && first.slice(-4) === "-dev";
|
|
}
|
|
|
|
/* Un jeton {{…}} non remplacé n'est pas une URL : l'ignorer. */
|
|
function cleanUrl(u) {
|
|
if (!u || typeof u !== "string") return null;
|
|
if (u.indexOf("{{") !== -1) return null;
|
|
if (!u.replace(/\s/g, "")) return null;
|
|
return u;
|
|
}
|
|
|
|
function withSlash(u) {
|
|
return u.charAt(u.length - 1) !== "/" ? u + "/" : u;
|
|
}
|
|
|
|
function resolveUrls() {
|
|
var host = "";
|
|
try { host = (window.location && window.location.hostname) || ""; } catch (e) { host = ""; }
|
|
var dev = isDevHost(host);
|
|
var urls = {};
|
|
Object.keys(DEFAULT_URLS).forEach(function (app) {
|
|
/* 1. Config explicite de l'hôte — prioritaire, même sur -dev. */
|
|
var u = cleanUrl(cfg.urls && cfg.urls[app]);
|
|
/* 2. Dérivation -dev par l'hôte courant (spark : pas de dérivée). */
|
|
if (!u && dev) u = DEV_URLS[app] || null;
|
|
/* 3. href rendu dans le fragment (jeton remplacé côté serveur). */
|
|
if (!u) {
|
|
var tab = document.querySelector('.draco-apptab[data-app="' + app + '"]');
|
|
var href = tab ? tab.getAttribute("href") : null;
|
|
u = cleanUrl(href);
|
|
}
|
|
/* 4. Défaut officiel (production). */
|
|
if (!u) u = DEFAULT_URLS[app];
|
|
urls[app] = withSlash(u);
|
|
});
|
|
return urls;
|
|
}
|
|
function applyUrls(urls) {
|
|
document.querySelectorAll(".draco-apptab, .draco-apps-item").forEach(function (t) {
|
|
if (t.dataset.app && urls[t.dataset.app]) t.setAttribute("href", urls[t.dataset.app]);
|
|
});
|
|
}
|
|
var resolvedUrls = resolveUrls();
|
|
|
|
function setCounts(counts) {
|
|
Object.keys(counts || {}).forEach(function (k) {
|
|
/* Toutes les occurrences : l'onglet ET sa ligne dans le menu. */
|
|
document.querySelectorAll('.draco-badge[data-badge="' + k + '"]').forEach(function (b) {
|
|
b.textContent = counts[k];
|
|
b.hidden = !(counts[k] > 0);
|
|
});
|
|
});
|
|
}
|
|
function setCurrent(app) {
|
|
document.querySelectorAll(".draco-apptab, .draco-apps-item").forEach(function (t) {
|
|
if (t.dataset.app) t.dataset.active = t.dataset.app === app ? "true" : "false";
|
|
});
|
|
}
|
|
function setDomain(dom) {
|
|
document.querySelectorAll('.draco-domaines [data-dom]').forEach(function (b) {
|
|
b.dataset.on = b.dataset.dom === dom ? "true" : "false";
|
|
});
|
|
}
|
|
|
|
/* ── Identité / avatar (v0.1.6) ───────────────────────────────────
|
|
* Nom : cfg.user (chaîne, ou objet display_name / name / username),
|
|
* sinon le title de l'avatar quand le jeton {{UTILISATEUR}} a bien été
|
|
* remplacé côté serveur. L'initiale en découle ; sans nom, le neutre
|
|
* ✦ du fragment est conservé — jamais de lettre codée en dur. */
|
|
function userName() {
|
|
var u = cfg.user;
|
|
if (typeof u === "string" && u.replace(/\s/g, "")) return u.trim();
|
|
if (u && typeof u === "object") {
|
|
var n = u.display_name || u.name || u.username;
|
|
if (n && String(n).replace(/\s/g, "")) return String(n).trim();
|
|
}
|
|
return null;
|
|
}
|
|
function titleName() {
|
|
var av = document.querySelector(".draco-avatar");
|
|
var t = av ? av.getAttribute("title") : null;
|
|
if (t && t.indexOf("{{") === -1 && t.replace(/\s/g, "")) return t.trim();
|
|
return null;
|
|
}
|
|
function displayName() { return userName() || titleName(); }
|
|
function syncAvatar() {
|
|
var av = document.querySelector(".draco-avatar");
|
|
if (!av) return;
|
|
/* Compatibilité avec un fragment vendangé antérieur (avatar <span>
|
|
* sans data-act) : le rendre déclencheur du menu compte. */
|
|
if (!av.getAttribute("data-act")) av.setAttribute("data-act", "compte");
|
|
if (!av.getAttribute("aria-haspopup")) av.setAttribute("aria-haspopup", "menu");
|
|
var name = displayName();
|
|
if (name) {
|
|
av.textContent = name.charAt(0).toUpperCase();
|
|
av.setAttribute("title", name);
|
|
av.setAttribute("aria-label", "Compte : " + name);
|
|
}
|
|
}
|
|
|
|
/* ── Menus déroulants (apps, compte) ───────────────────────────────
|
|
* Un seul menu ouvert à la fois ; fermeture par clic extérieur,
|
|
* Échap, ou choix d'un item. aria-expanded tenu à jour sur chaque
|
|
* déclencheur. Les href des menus sont (re)synchronisés avec
|
|
* resolvedUrls à chaque ouverture, pour que setUrls et la dérivation
|
|
* -dev s'y reflètent même si le menu a été construit avant. */
|
|
var bar = document.querySelector(".draco-bar");
|
|
var brand = bar ? bar.querySelector(".draco-brand") : null;
|
|
var avatarBtn = document.querySelector(".draco-avatar");
|
|
var appsMenu = null, compteMenu = null;
|
|
/* Déclencheur du menu ouvert en dernier (marque ou avatar) : Échap
|
|
* lui rend le focus à la fermeture (correctif #70). */
|
|
var lastOpener = null;
|
|
|
|
function setExpanded(btn, open) {
|
|
if (btn) btn.setAttribute("aria-expanded", open ? "true" : "false");
|
|
}
|
|
function refreshMenuHrefs(menu) {
|
|
if (!menu) return;
|
|
menu.querySelectorAll(".draco-apps-item").forEach(function (a) {
|
|
if (a.dataset.app && resolvedUrls[a.dataset.app]) a.setAttribute("href", resolvedUrls[a.dataset.app]);
|
|
});
|
|
}
|
|
function togglePopup(menu, btn, force) {
|
|
if (!menu) return;
|
|
var open = typeof force === "boolean" ? force : menu.hidden;
|
|
menu.hidden = !open;
|
|
setExpanded(btn, open);
|
|
}
|
|
function closeAllPopups(returnFocus) {
|
|
var anyOpen = (appsMenu && !appsMenu.hidden) || (compteMenu && !compteMenu.hidden);
|
|
if (appsMenu) togglePopup(appsMenu, brand, false);
|
|
if (compteMenu) togglePopup(compteMenu, avatarBtn, false);
|
|
/* Échap seulement : le clic extérieur ne déplace pas le focus
|
|
* (voir l'en-tête, « Focus »). */
|
|
if (returnFocus && anyOpen && lastOpener && typeof lastOpener.focus === "function") lastOpener.focus();
|
|
}
|
|
function tabLabel(app) {
|
|
var tab = document.querySelector('.draco-apptab[data-app="' + app + '"]');
|
|
var fort = tab ? tab.querySelector(".draco-apptab-txt strong") : null;
|
|
return fort ? fort.textContent : (APP_LABELS[app] || app);
|
|
}
|
|
function tabRole(app) {
|
|
var tab = document.querySelector('.draco-apptab[data-app="' + app + '"]');
|
|
var petit = tab ? tab.querySelector(".draco-apptab-txt small") : null;
|
|
return petit ? petit.textContent : "";
|
|
}
|
|
/* Menu des applications (v0.1.3) — construit depuis les onglets
|
|
* présents dans la barre : mêmes liens, mêmes icônes, mêmes badges.
|
|
* Ouvert par la marque ✦ (data-act="apps"), fermé par un clic
|
|
* extérieur, Échap, ou le choix d'une application (la navigation
|
|
* suit son cours). */
|
|
function buildAppsMenu() {
|
|
if (!bar || !brand || appsMenu) return;
|
|
appsMenu = document.createElement("div");
|
|
appsMenu.className = "draco-apps-menu";
|
|
appsMenu.hidden = true;
|
|
appsMenu.setAttribute("role", "menu");
|
|
appsMenu.setAttribute("aria-label", "Applications");
|
|
document.querySelectorAll(".draco-apptab").forEach(function (t) {
|
|
/* Chantier 5 : l'onglet agent (« Console Spark ») n'est PAS
|
|
* repris ici — l'entrée dédiée ci-dessous le représente déjà
|
|
* (après Kanbante, avec séparateur) ; sans ce saut, le menu
|
|
* listerait « Console Spark » deux fois. */
|
|
if (t.dataset.app === "agent") return;
|
|
var a = document.createElement("a");
|
|
a.className = "draco-apps-item";
|
|
a.href = resolvedUrls[t.dataset.app] || t.getAttribute("href");
|
|
a.dataset.app = t.dataset.app;
|
|
a.setAttribute("role", "menuitem");
|
|
var ico = t.querySelector(".draco-apptab-ico");
|
|
if (ico) a.appendChild(ico.cloneNode(true));
|
|
var txt = document.createElement("span");
|
|
txt.className = "draco-apps-item-txt";
|
|
var fort = t.querySelector(".draco-apptab-txt strong");
|
|
var petit = t.querySelector(".draco-apptab-txt small");
|
|
var nom = document.createElement("span");
|
|
nom.className = "draco-apps-item-nom";
|
|
nom.textContent = fort ? fort.textContent : t.dataset.app;
|
|
txt.appendChild(nom);
|
|
if (petit) {
|
|
var role = document.createElement("span");
|
|
role.className = "draco-apps-item-role";
|
|
role.textContent = petit.textContent;
|
|
txt.appendChild(role);
|
|
}
|
|
a.appendChild(txt);
|
|
var badge = t.querySelector(".draco-badge");
|
|
if (badge) a.appendChild(badge.cloneNode(true));
|
|
appsMenu.appendChild(a);
|
|
});
|
|
/* Entrée « Console Spark » (#70) : après Kanbante, vers la console
|
|
* de l'agent commun (URL agent résolue — explicite > -dev >
|
|
* défaut prod ; aucun hôte spark-dev inventé). data-app="agent"
|
|
* l'intègre à refreshMenuHrefs/applyUrls/setCurrent comme les
|
|
* autres items ; l'icône ✦ reprend la couleur agent du CSS. */
|
|
var sep = document.createElement("div");
|
|
sep.className = "draco-menu-sep";
|
|
sep.setAttribute("aria-hidden", "true");
|
|
appsMenu.appendChild(sep);
|
|
var sparkItem = document.createElement("a");
|
|
sparkItem.className = "draco-apps-item";
|
|
sparkItem.href = resolvedUrls.agent || "#";
|
|
sparkItem.dataset.app = "agent";
|
|
sparkItem.setAttribute("role", "menuitem");
|
|
var sparkIco = document.createElement("span");
|
|
sparkIco.className = "draco-apptab-ico";
|
|
sparkIco.setAttribute("style", "--app:#c2437e");
|
|
sparkIco.textContent = "✦";
|
|
sparkItem.appendChild(sparkIco);
|
|
var sparkTxt = document.createElement("span");
|
|
sparkTxt.className = "draco-apps-item-txt";
|
|
var sparkNom = document.createElement("span");
|
|
sparkNom.className = "draco-apps-item-nom";
|
|
sparkNom.textContent = "Console Spark";
|
|
sparkTxt.appendChild(sparkNom);
|
|
var sparkRole = document.createElement("span");
|
|
sparkRole.className = "draco-apps-item-role";
|
|
sparkRole.textContent = "Agent commun";
|
|
sparkTxt.appendChild(sparkRole);
|
|
sparkItem.appendChild(sparkTxt);
|
|
appsMenu.appendChild(sparkItem);
|
|
bar.appendChild(appsMenu);
|
|
}
|
|
function toggleAppsMenu(force) {
|
|
buildAppsMenu();
|
|
if (!appsMenu) return;
|
|
if (force !== false) refreshMenuHrefs(appsMenu);
|
|
togglePopup(appsMenu, brand, force);
|
|
if (!appsMenu.hidden) lastOpener = brand;
|
|
}
|
|
|
|
/* Menu compte (v0.1.6) — en-tête d'identité + Profil / Déconnexion
|
|
* relayés à l'hôte. L'en-tête est rafraîchi à chaque ouverture, pour
|
|
* refléter un title posé après coup par l'hôte (ex. ObsiGate, qui
|
|
* remplit l'avatar depuis /api/auth/me après chargement). */
|
|
function buildCompteMenu() {
|
|
if (!bar || !avatarBtn || compteMenu) return;
|
|
compteMenu = document.createElement("div");
|
|
compteMenu.className = "draco-compte-menu";
|
|
compteMenu.hidden = true;
|
|
compteMenu.setAttribute("role", "menu");
|
|
compteMenu.setAttribute("aria-label", "Compte");
|
|
var head = document.createElement("div");
|
|
head.className = "draco-compte-nom";
|
|
compteMenu.appendChild(head);
|
|
[["profil", "Profil"], ["deconnexion", "Déconnexion"]].forEach(function (pair) {
|
|
var b = document.createElement("button");
|
|
b.type = "button";
|
|
b.className = "draco-menu-item";
|
|
b.setAttribute("data-compte-act", pair[0]);
|
|
b.setAttribute("role", "menuitem");
|
|
b.textContent = pair[1];
|
|
compteMenu.appendChild(b);
|
|
});
|
|
bar.appendChild(compteMenu);
|
|
}
|
|
function refreshCompteMenu() {
|
|
if (!compteMenu) return;
|
|
var head = compteMenu.querySelector(".draco-compte-nom");
|
|
var name = displayName();
|
|
if (head) head.textContent = name || "Compte";
|
|
}
|
|
function toggleCompteMenu(force) {
|
|
buildCompteMenu();
|
|
if (!compteMenu) return;
|
|
if (force !== false) { syncAvatar(); refreshCompteMenu(); }
|
|
togglePopup(compteMenu, avatarBtn, force);
|
|
if (!compteMenu.hidden) lastOpener = avatarBtn;
|
|
}
|
|
|
|
/* Relais d'une action vers l'hôte : onAction si présent, sinon
|
|
* événement draco:bar (contrat historique des actions relayées). */
|
|
function relay(act, el, ev) {
|
|
if (typeof cfg.onAction === "function") cfg.onAction(act, el, ev);
|
|
else document.dispatchEvent(new CustomEvent("draco:bar", { detail: { act: act, el: el } }));
|
|
}
|
|
|
|
/* Écouteurs globaux posés sur le prototype EventTarget quand il
|
|
* existe, pour survivre au registre/teardown d'un hôte SPA (TikTak,
|
|
* voir l'en-tête) ; sinon document.addEventListener classique. */
|
|
function addGlobalListener(type, fn) {
|
|
try {
|
|
if (typeof EventTarget !== "undefined" && EventTarget.prototype &&
|
|
EventTarget.prototype.addEventListener) {
|
|
EventTarget.prototype.addEventListener.call(document, type, fn, false);
|
|
return;
|
|
}
|
|
} catch (e) { /* repli ci-dessous */ }
|
|
document.addEventListener(type, fn);
|
|
}
|
|
|
|
addGlobalListener("click", function (ev) {
|
|
/* Items du menu compte : relais + fermeture, jamais de navigation. */
|
|
var compteItem = ev.target.closest ? ev.target.closest("[data-compte-act]") : null;
|
|
if (compteItem) {
|
|
relay(compteItem.getAttribute("data-compte-act"), compteItem, ev);
|
|
toggleCompteMenu(false);
|
|
return;
|
|
}
|
|
var el = ev.target.closest ? ev.target.closest("[data-act]") : null;
|
|
if (el && el.dataset.act === "apps") {
|
|
ev.preventDefault();
|
|
if (compteMenu) toggleCompteMenu(false);
|
|
toggleAppsMenu();
|
|
return;
|
|
}
|
|
if (el && el.dataset.act === "compte") {
|
|
if (appsMenu) toggleAppsMenu(false);
|
|
toggleCompteMenu();
|
|
return;
|
|
}
|
|
/* Clic extérieur : ferme tout menu ouvert (clic dans un menu ou
|
|
* sur son déclencheur déjà traité ci-dessus). */
|
|
var inPopup = ev.target.closest ? (ev.target.closest(".draco-apps-menu") ||
|
|
ev.target.closest(".draco-compte-menu")) : null;
|
|
if (!inPopup && ((appsMenu && !appsMenu.hidden) || (compteMenu && !compteMenu.hidden))) {
|
|
closeAllPopups(false);
|
|
}
|
|
if (!el) return;
|
|
var act = el.dataset.act;
|
|
if (act === "domaine") setDomain(el.dataset.dom);
|
|
relay(act, el, ev);
|
|
});
|
|
|
|
addGlobalListener("keydown", function (ev) {
|
|
if (ev.key === "Escape") { closeAllPopups(true); return; }
|
|
/* Espace sur la marque : un lien ne s'active pas à l'Espace, donc
|
|
* ouverture explicite + focus sur le premier item du menu (#70).
|
|
* Entrée : clic natif du lien, déjà géré par le gestionnaire clic
|
|
* ci-dessus (pas de double bascule ici). */
|
|
if ((ev.key === " " || ev.key === "Spacebar") && ev.target && ev.target.closest) {
|
|
var brandEl = ev.target.closest('[data-act="apps"]');
|
|
if (brandEl) {
|
|
if (ev.preventDefault) ev.preventDefault();
|
|
toggleAppsMenu();
|
|
if (appsMenu && !appsMenu.hidden) {
|
|
var first = appsMenu.querySelector(".draco-apps-item");
|
|
if (first && typeof first.focus === "function") first.focus();
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
/* API publique : l'app met les compteurs à jour sans recharger.
|
|
* setUrls(urls) fusionne de nouvelles bases (même contrat que
|
|
* DRACO_BAR_CONFIG.urls — donc prioritaires sur la dérivation -dev)
|
|
* et les ré-applique aux onglets et aux menus ; DRACO_BAR.urls expose
|
|
* les bases résolues (défauts inclus), pour le panneau Spark et tout
|
|
* autre consommateur de l'hôte. */
|
|
window.DRACO_BAR = {
|
|
setCounts: setCounts, setCurrent: setCurrent, setDomain: setDomain,
|
|
urls: resolvedUrls,
|
|
setUrls: function (urls) {
|
|
cfg.urls = Object.assign({}, cfg.urls, urls || {});
|
|
resolvedUrls = resolveUrls();
|
|
window.DRACO_BAR.urls = resolvedUrls;
|
|
applyUrls(resolvedUrls);
|
|
}
|
|
};
|
|
|
|
applyUrls(resolvedUrls);
|
|
buildAppsMenu();
|
|
buildCompteMenu();
|
|
syncAvatar();
|
|
refreshCompteMenu();
|
|
if (cfg.current) setCurrent(cfg.current);
|
|
if (cfg.domain) setDomain(cfg.domain);
|
|
if (cfg.counts) setCounts(cfg.counts);
|
|
})();
|