Cours Vibe coding avec Claude Code · Module 8: Clone de Slack

La cloche du pont : mentions, notifications et hook Notification

9 min de lecture
Dans cette leçon9

Dans le canal #general, il se passe beaucoup de choses, et toi, tu veux seulement savoir quand quelqu'un a besoin de toi. Slack résout cela avec les mentions : tu tapes @ et un nom, et cette personne reçoit une notification. C'est la cloche qui appelle sur le pont un marin précis, et non toute la flotte.

Problème : quatre sortes d'appels

Dans Ship's Comms, une mention a quatre formes : @redbeard appelle une personne, @channel tous les membres du canal, @here seulement ceux qui sont en ligne en ce moment, et @everyone est traité comme @channel. Il faut retrouver la mention dans le texte, la mettre en évidence à l'écran et la transformer en notification pour les bonnes personnes. Chacune de ces étapes peut être ratée de façon que l'écran paraisse correct pendant que la cloche sonne chez quelqu'un d'autre. Tu commences donc par les tests.

Demande pour Claude Code :

Ajoute les mentions. D'abord les tests de parseMentions(text, members)
dans lib/mentions.test.ts : @RedBeard trouve le membre quelle que
soit la casse, @Étienne avec une lettre accentuée aussi, @channel et
@here ont une vraie position dans le texte, deux mentions côte à côte,
un prénom inconnu et une adresse e-mail sont ignorés. Lance les
tests, montre l'échec, puis l'implémentation. Ne modifie pas les
tests pour les faire passer.

Ce qu'a montré le premier passage

Claude a écrit les tests, puis une première version de la fonction : l'expression /@(\w+)/g pour les membres de l'équipage et text.includes("@channel") pour les mentions spéciales. Quatre tests sur cinq ont échoué. Le passage essentiel du résultat :

FAIL  lib/mentions.test.ts > parseMentions > enregistre la vraie position de @channel
- Expected
+ Received

  [
    {
-     "end": 16,
+     "end": 0,
      "kind": "channel",
-     "start": 8,
+     "start": 0,
    },
  ]

Le test a fourni le texte « Debout, @channel » et attendait la position de 8 à 16, c'est-à-dire exactement là où se trouve l'inscription. includes dit seulement que @channel est quelque part, donc la fonction a écrit la position 0-0. À l'écran, cela donnerait une mise en évidence vide au début du message, et la vraie inscription @channel resterait du texte ordinaire : l'œil le manque facilement, le test l'attrape tout de suite. La même position 0-0 a cassé le test avec @here à côté de @anne. De plus, \w ne connaît pas les lettres accentuées : @Étienne a disparu, et dans l'adresse capitaine@anne.fr la fonction a trouvé une mention d'Anne.

Ce que Claude a écrit : une expression pour tous

Ouvre lib/mentions.ts. La deuxième version cherche toutes les mentions avec une seule expression régulière :

const MENTION = /(?<![\p{L}\p{N}_])@([\p{L}\p{N}_]+)/gu;
const SPECIAL = ["channel", "here", "everyone"] as const;

\p{L} désigne n'importe quelle lettre, accentuée comprise, et \p{N} un chiffre ; les deux écritures ne fonctionnent qu'avec le drapeau u. Le début (?<!...) est la condition « avant @ ne se tient ni lettre ni chiffre », donc une adresse e-mail est écartée. La boucle de parseMentions parcourt les résultats de text.matchAll(MENTION), met le nom en minuscules avec toLocaleLowerCase("fr") et prend la position dans match.index et la longueur du résultat. Un nom de la liste SPECIAL donne une mention spéciale, un autre est cherché parmi les membres par handle, et un nom inconnu est perdu. Les cinq tests ont passé, et pas une seule ligne de leur contenu n'a changé.

Mise en évidence à l'écran

La fonction splitByMentions du même fichier découpe le texte, d'après les positions, en morceaux ordinaires et en mentions. Le composant components/MessageText.tsx dessine les mentions dans une balise <mark> : celles des autres en bleu, la tienne en jaune. Le contenu du message ne change pas, seul l'aspect à l'écran diffère. Si les positions étaient fausses, c'est ici que tu verrais une mise en évidence vide.

Suggestions après la frappe de @

L'ancienne liste de suggestions avait un état query que personne ne définissait, donc le filtre ne fonctionnait jamais et montrait toujours les cinq mêmes membres. Claude a déduit la requête du texte avant le curseur, sans état supplémentaire :

const QUERY = /(?<![\p{L}\p{N}_])@([\p{L}\p{N}_]*)$/u;

export function mentionQuery(text: string, caret: number): string | null {
  const match = QUERY.exec(text.slice(0, caret));
  return match ? match[1].toLocaleLowerCase("fr") : null;
}

Pour le texte « Ohé @An » avec le curseur à la fin, la fonction renvoie "an", et après une espace null, c'est-à-dire « n'affiche pas la liste ». Dans MessageInput, le champ est maintenant contrôlé : le texte et la position du curseur (selectionStart) sont dans l'état, et la liste vient de suggestMembers(query, members), au plus cinq personnes qui peuvent voir le canal. Tout se calcule pendant le rendu, donc il n'y a pas d'effet que npm run lint rejetterait avec la règle react-hooks/set-state-in-effect. Les flèches changent la personne en surbrillance, Entrée ou Tab insère @handle, et Échap ferme la liste. MentionAutocomplete ne fait que dessiner la liste avec role="listbox".

Le centre de notifications

La notification naît sur le serveur, dans l'action sendMessage, juste après l'enregistrement du message. Le type s'appelle AppNotification, car le navigateur a déjà son propre type Notification pour les notifications système. Qui reçoit la cloche, c'est une fonction pure, recipientsFor de lib/notify.ts, vérifiée par quatre tests. Voici sa fin :

ids.delete(authorId);
return members
  .filter((m) => ids.has(m.id) && canSeeChannel(channel, m))
  .map((m) => m.id);

Avant cela, la fonction rassemble les identifiants dans un ensemble Set, donc quelqu'un appelé deux fois reçoit une seule notification. Puis elle retire l'auteur, car personne n'a besoin d'une cloche pour son propre message, et ne garde que les personnes qui peuvent voir le canal : une mention @jack dans un canal privé n'enverra pas à Jack l'aperçu d'une conversation secrète. Une réponse dans un fil produit en plus une notification reply pour l'auteur du message parent.

Après l'enregistrement du message et des notifications, l'action appelle revalidatePath("/", "layout"). D'après la documentation de Next.js, un tel appel rafraîchit toutes les pages sous le layout principal : l'auteur voit tout de suite son message, et la barre latérale, présente sur chaque page, recalcule les pastilles. Le destinataire verra la sienne à sa prochaine entrée sur n'importe quelle page, car les pages sont rendues à chaque requête. La cloche en direct, sans rechargement, n'existe pas encore dans cette leçon.

La page /activity montre tes notifications, le nombre de non lues et le bouton « Tout marquer comme lu ». Une notification lue a une date dans le champ readAt, donc les non lues sont celles qui n'en ont pas. Un clic sur une notification appelle une action qui vérifie qu'elle est bien à toi, la marque comme lue et ouvre le fil. Dans la barre latérale, à côté du lien « Activité », se trouve UnreadBadge : à zéro il disparaît, au-delà de 99 il affiche « 99+ », car son texte vient de formatBadge avec la ligne return count > 99 ? "99+" : String(count);.

La revue du capitaine

  1. Deux personnes. Dans lib/session.ts, mets anne comme membre connecté, écris « @redbeard, les tonneaux sont prêts », puis reviens à redbeard. Chez nous, la pastille a affiché 1, et le clic a ouvert le fil avec la mention surlignée en jaune.
  2. Les tests comme contrat. Vérifie dans le diff que, entre l'échec et la réussite, lib/mentions.test.ts n'a pas changé. Erreur typique d'un agent : « corriger » le test en y écrivant la position 0-0.
  3. La fuite hors de la cabine. Le test « ne fuit pas d'un canal privé vers une personne extérieure » est le cas le plus important de cette leçon. S'il manque, demande-le.
  4. La preuve. Tests, lint, types, build et npx prettier --check ..

Ta propre cloche : le hook Notification

Quand Claude travaille longtemps, tu passes au navigateur, et lui, pendant ce temps, attend ton accord. L'événement Notification se produit justement quand Claude Code t'attend. Ici le matcher filtre le type de notification : permission_prompt est une demande d'autorisation à laquelle tu ne réponds pas depuis environ six secondes, et idle_prompt est le moment où Claude a fini de répondre il y a environ une minute et où tu n'as rien écrit.

Demande pour Claude Code :

Ajoute un hook Notification qui affiche une notification système
quand j'attends ton autorisation ou quand tu attends ma réponse.
J'utilise macOS. Enregistre-le dans mes réglages utilisateur, pas
dans le projet. Avant de l'enregistrer, lance la commande à la main.

Claude a enregistré le hook dans ~/.claude/settings.json :

{
  "hooks": {
    "Notification": [
      {
        "matcher": "permission_prompt|idle_prompt",
        "hooks": [
          {
            "type": "command",
            "command": "osascript -e 'display notification \"Claude Code t’attend\" with title \"Claude Code\"'"
          }
        ]
      }
    ]
  }
}

osascript est la commande système de macOS, et display notification affiche une bulle dans le coin de l'écran. Sous Linux, la documentation indique notify-send, et sous Windows PowerShell. C'est justement pour cela que le hook est allé dans les réglages utilisateur : il fonctionne dans tous tes projets et n'entre pas dans le dépôt, donc quelqu'un de l'équipage sous Linux ne recevra pas une commande que son système ne connaît pas. Dans /hooks, tu le verras avec une autre source que le hook Prettier.

Le test à la main s'est terminé avec le code 0. Si la bulle ne s'est pas affichée, c'est un piège connu de la documentation : osascript envoie les notifications par l'application Script Editor, et sans son autorisation il reste muet. Ouvre les Réglages Système, la section Notifications, trouve Script Editor et active les notifications. Puis l'essai en direct : passe la session en Manual avec Maj+Tab, demande quelque chose qui exige une autorisation et va dans une autre fenêtre.

Ce hook ne bloque rien, car pour l'événement Notification le code de sortie est ignoré. C'est un pur signal, et plus sûr que la phrase « préviens-moi quand tu as fini » dans CLAUDE.md, que le modèle peut ne pas suivre.

Étape suivante

Demande un commit, par exemple « Mentions et notifications ». Le hook Notification n'entre pas dans le commit, car il se trouve hors du projet. Ensuite un petit pas :

Ajoute des tests : @channel à la fin d'une phrase avec un point, et
une mention juste après un saut de ligne. Montre le résultat. Si
tu casses quelque chose, on revient en arrière avec /rewind.

Dans l'éditeur ci-dessous t'attend un champ avec des suggestions : tape @ et un début de prénom, choisis une personne avec les flèches, envoie le message et regarde qui a entendu la cloche.

Retiens : la cloche appelle un marin précis, le test veille à ce qu'elle appelle le bon, et le hook veille à ce que toi, tu l'entendes quand Claude attend sur le pont.

Code de cette leçon : App.jsx
// Mentions et cloche en miniature : parseMentions, suggestions après @ et destinataires des notifications.
// Dans le projet, les fonctions vivent dans lib/mentions.ts et lib/notify.ts (avec des tests),
// et c’est l’action sendMessage, côté serveur, qui enregistre les notifications.
import { useState } from 'react';

const members = [
  { id: 'u1', handle: 'redbeard', name: 'Capitaine Barbe-Rousse', role: 'owner', presence: 'online' },
  { id: 'u2', handle: 'anne', name: 'Anne Bonny', role: 'admin', presence: 'online' },
  { id: 'u3', handle: 'étienne', name: 'Étienne Sternik', role: 'member', presence: 'away' },
  { id: 'u4', handle: 'jack', name: 'Jack Rackham', role: 'member', presence: 'offline' },
];

const channels = [
  { id: 'c1', name: 'general', isPrivate: false, memberIds: ['u1', 'u2', 'u3', 'u4'] },
  { id: 'c5', name: 'secrets-du-capitaine', isPrivate: true, memberIds: ['u1', 'u2'] },
];

function canSeeChannel(channel, member) {
  if (channel.isPrivate || member.role === 'guest') return channel.memberIds.includes(member.id);
  return true;
}

const MENTION = /(?<![\p{L}\p{N}_])@([\p{L}\p{N}_]+)/gu;
const QUERY = /(?<![\p{L}\p{N}_])@([\p{L}\p{N}_]*)$/u;
const SPECIAL = ['channel', 'here', 'everyone'];

function parseMentions(text) {
  const mentions = [];
  for (const match of text.matchAll(MENTION)) {
    const name = match[1].toLocaleLowerCase('fr');
    const start = match.index;
    const end = start + match[0].length;
    if (SPECIAL.includes(name)) {
      mentions.push({ kind: name, start, end });
      continue;
    }
    const member = members.find((m) => m.handle === name);
    if (member) mentions.push({ kind: 'member', memberId: member.id, start, end });
  }
  return mentions;
}

function splitByMentions(text, mentions) {
  const segments = [];
  let last = 0;
  for (const mention of mentions) {
    if (mention.start > last) segments.push({ text: text.slice(last, mention.start) });
    segments.push({ text: text.slice(mention.start, mention.end), mention });
    last = mention.end;
  }
  if (last < text.length) segments.push({ text: text.slice(last) });
  return segments;
}

function mentionQuery(text, caret) {
  const match = QUERY.exec(text.slice(0, caret));
  return match ? match[1].toLocaleLowerCase('fr') : null;
}

function suggestMembers(query, list) {
  return list
    .filter((m) => m.handle.startsWith(query) || m.name.toLocaleLowerCase('fr').startsWith(query))
    .slice(0, 5);
}

function recipientsFor(mentions, channel, authorId) {
  const ids = new Set();
  for (const mention of mentions) {
    if (mention.kind === 'member') ids.add(mention.memberId);
    else if (mention.kind === 'here') {
      members.filter((m) => m.presence === 'online' && channel.memberIds.includes(m.id)).forEach((m) => ids.add(m.id));
    } else channel.memberIds.forEach((id) => ids.add(id));
  }
  ids.delete(authorId);
  return members.filter((m) => ids.has(m.id) && canSeeChannel(channel, m)).map((m) => m.id);
}

function formatBadge(count) {
  return count > 99 ? '99+' : String(count);
}

function MessageText({ text, meId }) {
  return (
    <p className="whitespace-pre-wrap text-sm">
      {splitByMentions(text, parseMentions(text)).map((segment, index) => {
        if (!segment.mention) return <span key={index}>{segment.text}</span>;
        const isMe = segment.mention.kind === 'member' && segment.mention.memberId === meId;
        return (
          <mark key={index} className={'rounded-sm px-0.5 font-semibold ' + (isMe ? 'bg-yellow-200 text-yellow-900' : 'bg-blue-100 text-blue-800')}>
            {segment.text}
          </mark>
        );
      })}
    </p>
  );
}

export default function App() {
  const [meId, setMeId] = useState('u1');
  const [channelId, setChannelId] = useState('c1');
  const [text, setText] = useState('');
  const [caret, setCaret] = useState(0);
  const [active, setActive] = useState(0);
  const [open, setOpen] = useState(true);
  const [messages, setMessages] = useState([]);
  const [notifications, setNotifications] = useState([]);

  const me = members.find((m) => m.id === meId);
  const channel = channels.find((c) => c.id === channelId);
  const visibleMembers = members.filter((m) => canSeeChannel(channel, m));
  const query = open ? mentionQuery(text, caret) : null;
  const suggestions = query === null ? [] : suggestMembers(query, visibleMembers);
  const activeIndex = Math.min(active, suggestions.length - 1);
  const mine = notifications.filter((n) => n.recipientId === meId);
  const unread = mine.filter((n) => !n.read).length;

  function pick(member) {
    const before = text.slice(0, caret).replace(/@[\p{L}\p{N}_]*$/u, '@' + member.handle + ' ');
    setText(before + text.slice(caret));
    setCaret(before.length);
    setActive(0);
  }

  function send() {
    const clean = text.trim();
    if (!clean) return;
    const id = 'm' + Date.now();
    const recipients = recipientsFor(parseMentions(clean), channel, meId);
    setMessages([...messages, { id, channelId, authorId: meId, text: clean, recipients }]);
    setNotifications([
      ...notifications,
      ...recipients.map((recipientId) => ({ id: id + recipientId, recipientId, fromId: meId, channelName: channel.name, preview: clean, read: false })),
    ]);
    setText('');
    setCaret(0);
  }

  function handleKeyDown(e) {
    if (suggestions.length > 0) {
      if (e.key === 'ArrowDown' || e.key === 'ArrowUp') {
        e.preventDefault();
        const step = e.key === 'ArrowDown' ? 1 : -1;
        setActive((activeIndex + step + suggestions.length) % suggestions.length);
        return;
      }
      if (e.key === 'Enter' || e.key === 'Tab') {
        e.preventDefault();
        pick(suggestions[activeIndex]);
        return;
      }
      if (e.key === 'Escape') {
        setOpen(false);
        return;
      }
    }
    if (e.key === 'Enter' && !e.shiftKey && !e.nativeEvent.isComposing) {
      e.preventDefault();
      send();
    }
  }

  function addTestNotifications() {
    const extra = Array.from({ length: 120 }, (_, i) => ({ id: 'test' + i + '-' + notifications.length, recipientId: meId, fromId: 'u2', channelName: 'general', preview: 'Notification de test ' + (i + 1), read: false }));
    setNotifications([...notifications, ...extra]);
  }

  return (
    <div className="min-h-screen bg-gray-100 p-3 text-gray-900">
      <div className="mb-2 flex flex-wrap items-center gap-2 text-sm">
        <label htmlFor="me">Connecté :</label>
        <select
          id="me"
          value={meId}
          onChange={(e) => {
            const next = members.find((m) => m.id === e.target.value);
            setMeId(next.id);
            if (!canSeeChannel(channel, next)) setChannelId('c1');
          }}
          className="rounded-md border border-gray-300 bg-white px-2 py-1"
        >
          {members.map((m) => (
            <option key={m.id} value={m.id}>{m.name}</option>
          ))}
        </select>
        <label htmlFor="channel">Canal :</label>
        <select id="channel" value={channelId} onChange={(e) => setChannelId(e.target.value)} className="rounded-md border border-gray-300 bg-white px-2 py-1">
          {channels.filter((c) => canSeeChannel(c, me)).map((c) => (
            <option key={c.id} value={c.id}>#{c.name}</option>
          ))}
        </select>
      </div>

      <div className="grid gap-3 md:grid-cols-3">
        <section className="flex flex-col rounded-lg border border-gray-200 bg-white md:col-span-2">
          <h1 className="border-b border-gray-200 px-3 py-2 font-bold">#{channel.name}</h1>
          <ol className="flex-1 space-y-2 p-3">
            {messages.filter((m) => m.channelId === channelId).map((m) => (
              <li key={m.id}>
                <p className="text-xs font-bold">{members.find((x) => x.id === m.authorId).name}</p>
                <MessageText text={m.text} meId={meId} />
                <p className="text-xs text-gray-500">
                  La cloche a sonné pour : {m.recipients.length ? m.recipients.map((id) => members.find((x) => x.id === id).name).join(', ') : 'personne'}
                </p>
              </li>
            ))}
          </ol>
          <form onSubmit={(e) => { e.preventDefault(); send(); }} className="relative border-t border-gray-200 p-2">
            {suggestions.length > 0 && (
              <ul role="listbox" aria-label="Suggestions de mentions" className="absolute bottom-full left-2 mb-1 w-60 rounded-md border border-gray-200 bg-white py-1 shadow-lg">
                {suggestions.map((m, index) => (
                  <li
                    key={m.id}
                    role="option"
                    aria-selected={index === activeIndex}
                    onMouseDown={(e) => { e.preventDefault(); pick(m); }}
                    className="cursor-pointer px-3 py-1 text-sm aria-selected:bg-blue-50"
                  >
                    <span className="font-semibold">{m.name}</span> <span className="text-gray-500">@{m.handle}</span>
                  </li>
                ))}
              </ul>
            )}
            <label htmlFor="text" className="sr-only">Message</label>
            <textarea
              id="text"
              rows={2}
              value={text}
              placeholder="Tape @ et le début d’un prénom"
              onChange={(e) => {
                setText(e.target.value);
                setCaret(e.target.selectionStart);
                setActive(0);
                setOpen(true);
              }}
              onSelect={(e) => setCaret(e.currentTarget.selectionStart)}
              onKeyDown={handleKeyDown}
              className="w-full resize-none rounded-md border border-gray-300 p-2 text-sm"
            />
            <div className="flex items-center justify-between text-xs text-gray-500">
              <span>Les flèches choisissent, Entrée ou Tab insère, Échap ferme</span>
              <button className="rounded-md bg-green-700 px-3 py-1 text-sm font-semibold text-white">Envoyer</button>
            </div>
          </form>
        </section>

        <aside className="rounded-lg border border-gray-200 bg-white">
          <div className="flex items-center justify-between border-b border-gray-200 px-3 py-2">
            <h2 className="flex items-center gap-2 font-bold">
              Activité
              {unread > 0 && (
                <span className="rounded-full bg-red-600 px-2 text-xs text-white">
                  {formatBadge(unread)}
                  <span className="sr-only"> non lues</span>
                </span>
              )}
            </h2>
            {unread > 0 && (
              <button
                onClick={() => setNotifications(notifications.map((n) => (n.recipientId === meId ? { ...n, read: true } : n)))}
                className="text-xs font-semibold text-blue-700 hover:underline"
              >
                Tout marquer comme lu
              </button>
            )}
          </div>
          {mine.length === 0 ? (
            <p className="p-3 text-sm text-gray-500">Calme plat sur le pont : personne ne t’a encore appelé.</p>
          ) : (
            <ol className="max-h-72 overflow-y-auto">
              {[...mine].reverse().map((n) => (
                <li key={n.id} className={'border-b border-gray-200 px-3 py-2 text-sm ' + (n.read ? '' : 'bg-blue-50')}>
                  <span className="font-semibold">{members.find((x) => x.id === n.fromId).name}</span> te mentionne sur #{n.channelName}
                  <span className="block truncate text-xs text-gray-600">{n.preview}</span>
                </li>
              ))}
            </ol>
          )}
          <button onClick={addTestNotifications} className="m-3 rounded-md border border-gray-300 px-2 py-1 text-xs">Ajouter 120 notifications de test</button>
        </aside>
      </div>
    </div>
  );
}

Tu as repéré une erreur dans cette leçon ?

Teste tes connaissances

Réponds aux questions de cette leçon. Choisis une réponse pour voir tout de suite si elle est correcte.

  1. 1. Quels types de mentions parseMentions reconnaît-il dans Ship's Comms ?

  2. 2. En quoi @channel diffère-t-il de @here ?

Voici 2 des 12 questions de cette leçon. Réponds aux autres dans le jeu.

Tâches pratiques dans le jeu

  • Clique dans l'ordre

    Construis la ligne de mentionQuery qui cherche @ juste avant le curseur : const match = QUERY.exec(text.slice(0, caret));

  • Éditeur de code

    Fenêtre d'autocomplétion des mentions

  • Tri horizontal

    Place sur une seule ligne le filtre de recipientsFor : .filter((m) => ids.has(m.id) && canSeeChannel(channel, m))

  • Tri vertical

    Anne envoie « @redbeard, les tonneaux sont prêts ». Ordonne ce qui se passe :

  • Éditeur de code

    Panneau de notifications

  • Clique dans l'ordre

    Construis la ligne de recipientsFor qui retire l'auteur des destinataires : ids.delete(authorId);

  • Tri vertical

    Ordonne les lignes du hook Notification dans le fichier de réglages, de l'extérieur vers l'intérieur :

  • Clique dans l'ordre

    Construis la dernière ligne de mentionQuery : return match ? match[1].toLocaleLowerCase("fr") : null;

  • Tri horizontal

    Place sur une seule ligne la commande du hook Notification sous macOS :

  • Tri horizontal

    Place sur une seule ligne le début de la fonction : export function mentionQuery(text: string, caret: number): string | null {

  • Clique dans l'ordre

    Construis la ligne qui affiche 99+ pour un nombre supérieur à 99 : return count > 99 ? "99+" : String(count);

  • Tri vertical

    Ordonne le parcours dans Ship's Comms, du choix d'un canal à l'ouverture d'une notification :

  1. QuestionQuiz : les types de mentions
  2. QuestionQuiz : @channel et @here
  3. Clique dans l'ordreTri : la requête avant le curseur
  4. Exercice de codePratique : autocomplétion des mentions
  5. Remets dans l'ordreTri : le filtre des destinataires
  6. QuestionQuiz : les types d'AppNotification
  7. QuestionQuiz : le nom AppNotification
  8. Remets dans l'ordreTri : de la mention à la pastille
  9. Exercice de codePratique : centre de notifications
  10. QuestionQuiz : le nombre de notifications non lues
  11. Clique dans l'ordreTri : l'auteur sans cloche
  12. QuestionQuiz : le clic sur une notification
  13. Remets dans l'ordreTri : le hook Notification dans les réglages
  14. Clique dans l'ordreTri : le résultat de mentionQuery
  15. QuestionQuiz : la mise en évidence d'une mention
  16. Remets dans l'ordreTri : la commande de notification sous macOS
  17. Remets dans l'ordreTri : la signature de mentionQuery
  18. QuestionQuiz : quand la pastille disparaît
  19. Clique dans l'ordreTri : la pastille 99+
  20. QuestionQuiz : le résultat de parseMentions
  21. QuestionQuiz : où se trouve le hook Notification
  22. Remets dans l'ordreTri : du canal à la notification
  23. QuestionQuiz : le code de sortie du hook Notification
  24. QuestionQuiz : Ship's Comms et Kraken's Call

Articles utiles