Pourquoi Pointer Events mérite votre attention

Pendant longtemps, gérer les interactions utilisateur dans le navigateur signifiait jongler entre plusieurs familles d’événements : mousedown, mousemove, mouseup pour la souris, puis touchstart, touchmove, touchend pour les écrans tactiles. Cette séparation produit vite du code redondant, des comportements incohérents et des bugs difficiles à diagnostiquer, notamment sur les appareils hybrides.

Pointer Events propose une approche plus simple : représenter la souris, le doigt et le stylet avec une même famille d’événements. Au lieu d’écrire une logique parallèle pour chaque périphérique, on travaille avec pointerdown, pointermove, pointerup, pointercancel et quelques propriétés normalisées.

Cette API est particulièrement utile pour les interfaces de dessin, les sliders personnalisés, les cartes interactives, les jeux web, les zones de drag and drop ou les composants tactiles avancés. Elle complète très bien des sujets comme l’event delegation en JavaScript, les Web Animations API ou encore les interfaces accessibles.

Le problème des anciens événements souris et tactile

Prenons un exemple classique : un composant que l’utilisateur peut déplacer horizontalement. Avec les événements souris, on peut écrire quelque chose comme :

const handle = document.querySelector<HTMLButtonElement>(".slider-handle");

handle?.addEventListener("mousedown", () => {
  window.addEventListener("mousemove", onMove);
  window.addEventListener("mouseup", onEnd);
});

function onMove(event: MouseEvent) {
  console.log(event.clientX);
}

function onEnd() {
  window.removeEventListener("mousemove", onMove);
  window.removeEventListener("mouseup", onEnd);
}

Ce code ne fonctionne pas correctement au toucher. Il faut donc ajouter une seconde logique avec TouchEvent, lire event.touches[0], gérer les gestes annulés par le navigateur, puis maintenir deux chemins de code.

Pointer Events évite cette duplication. Le même événement contient les coordonnées, l’identifiant du pointeur, son type et parfois des informations supplémentaires comme la pression.

Comprendre pointerdown, pointermove et pointerup

Voici une version minimale d’un suivi de pointeur :

const box = document.querySelector<HTMLDivElement>(".drag-box");

let isDragging = false;

box?.addEventListener("pointerdown", (event) => {
  isDragging = true;
  box.setPointerCapture(event.pointerId);
});

box?.addEventListener("pointermove", (event) => {
  if (!isDragging) return;

  box.style.transform = `translate(${event.clientX}px, ${event.clientY}px)`;
});

box?.addEventListener("pointerup", (event) => {
  isDragging = false;
  box.releasePointerCapture(event.pointerId);
});

box?.addEventListener("pointercancel", () => {
  isDragging = false;
});

La propriété pointerId identifie un pointeur donné. C’est essentiel sur écran tactile, car plusieurs doigts peuvent interagir avec la page en même temps. La méthode setPointerCapture() indique au navigateur que l’élément doit continuer à recevoir les événements de ce pointeur, même si celui-ci sort visuellement de l’élément pendant le déplacement.

Sans capture, un drag peut se couper brutalement quand le curseur ou le doigt quitte la zone active. C’est l’un des détails qui différencient une démonstration rapide d’un composant réellement fiable.

Identifier souris, tactile et stylet

Un événement de pointeur expose la propriété pointerType. Elle vaut généralement "mouse", "touch" ou "pen".

function describePointer(event: PointerEvent) {
  switch (event.pointerType) {
    case "mouse":
      return "Interaction à la souris";
    case "touch":
      return "Interaction tactile";
    case "pen":
      return "Interaction au stylet";
    default:
      return "Pointeur inconnu";
  }
}

Il faut toutefois éviter de réserver une fonctionnalité complète à un seul type de pointeur. Un utilisateur peut avoir un ordinateur tactile, une tablette avec clavier, une souris Bluetooth ou un stylet. Le type de pointeur doit aider à affiner l’expérience, pas à exclure.

Par exemple, une application de dessin peut utiliser la pression du stylet quand elle est disponible, mais elle doit rester utilisable à la souris :

canvas.addEventListener("pointermove", (event) => {
  if (event.buttons !== 1) return;

  const pressure = event.pressure || 0.5;
  const radius = 2 + pressure * 8;

  drawCircle(event.clientX, event.clientY, radius);
});

La propriété pressure est comprise entre 0 et 1. Avec une souris, elle est souvent moins expressive qu’avec un stylet, mais le code reste commun.

Contrôler le comportement tactile avec touch-action

L’un des pièges les plus fréquents vient du CSS. Sur écran tactile, le navigateur réserve certains gestes au scroll, au zoom ou à la navigation. Si vous créez une zone de dessin ou un slider horizontal, vous devez indiquer explicitement ce que le navigateur peut faire.

.canvas-area {
  touch-action: none;
}

.horizontal-slider {
  touch-action: pan-y;
}

touch-action: none désactive les gestes tactiles natifs sur la zone concernée. C’est utile pour une surface de dessin, mais trop agressif pour une page entière. touch-action: pan-y autorise le défilement vertical tout en laissant votre composant gérer le geste horizontal.

Ce réglage CSS est souvent plus propre que d’appeler preventDefault() dans tous les gestionnaires d’événements. Il clarifie l’intention, améliore la performance et réduit les conflits avec le navigateur.

Exemple : un curseur personnalisé en TypeScript

Voici un exemple simplifié de slider horizontal. L’objectif n’est pas de remplacer systématiquement l’élément natif input type="range", souvent préférable pour l’accessibilité, mais de montrer comment structurer un composant interactif.

type SliderOptions = {
  root: HTMLElement;
  onChange: (value: number) => void;
};

export function createPointerSlider({ root, onChange }: SliderOptions) {
  const track = root.querySelector<HTMLElement>(".slider-track");
  const thumb = root.querySelector<HTMLElement>(".slider-thumb");

  if (!track || !thumb) {
    throw new Error("Structure de slider invalide");
  }

  function updateFromPointer(event: PointerEvent) {
    const rect = track.getBoundingClientRect();
    const raw = (event.clientX - rect.left) / rect.width;
    const value = Math.min(1, Math.max(0, raw));

    thumb.style.left = `${value * 100}%`;
    root.setAttribute("aria-valuenow", String(Math.round(value * 100)));
    onChange(value);
  }

  thumb.addEventListener("pointerdown", (event) => {
    thumb.setPointerCapture(event.pointerId);
    updateFromPointer(event);
  });

  thumb.addEventListener("pointermove", (event) => {
    if (!thumb.hasPointerCapture(event.pointerId)) return;
    updateFromPointer(event);
  });

  thumb.addEventListener("pointerup", (event) => {
    if (thumb.hasPointerCapture(event.pointerId)) {
      thumb.releasePointerCapture(event.pointerId);
    }
  });
}

Le code limite la valeur entre 0 et 1, met à jour la position visuelle et synchronise aria-valuenow. Pour un composant de production, il faudrait aussi gérer le clavier avec les flèches, Home, End, et exposer correctement role="slider", aria-valuemin et aria-valuemax.

Intégration dans un composant Vue

Pointer Events s’intègre naturellement avec Vue. L’important est de garder la logique de calcul claire et de nettoyer les états temporaires.

<script setup lang="ts">
import { ref } from "vue";

const value = ref(0);
const draggingPointerId = ref<number | null>(null);
const track = ref<HTMLElement | null>(null);

function update(event: PointerEvent) {
  if (!track.value) return;

  const rect = track.value.getBoundingClientRect();
  const ratio = (event.clientX - rect.left) / rect.width;
  value.value = Math.min(100, Math.max(0, Math.round(ratio * 100)));
}

function onPointerDown(event: PointerEvent) {
  draggingPointerId.value = event.pointerId;
  (event.currentTarget as HTMLElement).setPointerCapture(event.pointerId);
  update(event);
}

function onPointerMove(event: PointerEvent) {
  if (draggingPointerId.value !== event.pointerId) return;
  update(event);
}

function onPointerUp(event: PointerEvent) {
  draggingPointerId.value = null;
  (event.currentTarget as HTMLElement).releasePointerCapture(event.pointerId);
}
</script>

<template>
  <div ref="track" class="slider" @pointerdown="onPointerDown" @pointermove="onPointerMove" @pointerup="onPointerUp">
    <div class="slider-fill" :style="{ width: `${value}%` }" />
  </div>
</template>
.slider {
  position: relative;
  height: 1rem;
  border-radius: 999px;
  background: color-mix(in srgb, CanvasText 15%, Canvas);
  touch-action: pan-y;
}

.slider-fill {
  height: 100%;
  border-radius: inherit;
  background: CanvasText;
}

On pourrait écrire la même logique en React avec onPointerDown, onPointerMove et onPointerUp. Le point important est de ne pas lier cette API à un framework particulier : Pointer Events appartient à la plateforme web.

Accessibilité : ne pas confondre interaction avancée et interaction exclusive

Les interactions au pointeur sont confortables, mais elles ne doivent pas devenir le seul moyen d’utiliser une interface. Un composant déplaçable peut aussi avoir des boutons de déplacement. Un slider personnalisé doit être pilotable au clavier. Une zone de dessin peut proposer des actions alternatives, comme annuler, effacer ou ajuster l’épaisseur via des contrôles standards.

Il faut aussi éviter de bloquer le zoom tactile sur des zones trop larges. Le zoom est un outil d’accessibilité majeur pour de nombreux utilisateurs. Désactiver les gestes natifs sur tout le document avec touch-action: none est rarement acceptable.

Pour les annonces dynamiques, notamment après une interaction de glisser-déposer, les ARIA live regions peuvent aider à rendre l’état de l’interface compréhensible aux technologies d’assistance.

Bonnes pratiques de performance

pointermove peut se déclencher très souvent. Il faut donc éviter les calculs lourds, les écritures DOM multiples et les lectures de layout répétées dans le même cycle.

Une approche robuste consiste à stocker la dernière position puis à appliquer les changements visuels dans requestAnimationFrame :

let latestEvent: PointerEvent | null = null;
let frameId: number | null = null;

function onPointerMove(event: PointerEvent) {
  latestEvent = event;

  if (frameId !== null) return;

  frameId = requestAnimationFrame(() => {
    if (latestEvent) {
      updatePosition(latestEvent.clientX, latestEvent.clientY);
    }

    frameId = null;
  });
}

Cette technique évite de saturer le thread principal avec trop de mises à jour visuelles. Pour des traitements vraiment coûteux, comme l’analyse d’un tracé ou la génération d’une géométrie complexe, il peut être pertinent de déplacer une partie du travail dans un Web Worker.

Quand utiliser Pointer Events

Utilisez Pointer Events dès qu’une interaction doit fonctionner aussi bien à la souris qu’au tactile ou au stylet. C’est le cas des sliders avancés, surfaces de dessin, cartes interactives, interfaces de drag, jeux HTML canvas, timelines manipulables et outils créatifs.

Préférez toutefois les contrôles natifs quand ils répondent au besoin. Un bouton, une case à cocher, un champ de formulaire ou un input type="range" restent souvent plus simples, plus accessibles et plus robustes qu’un composant entièrement personnalisé.

La bonne stratégie consiste à partir du HTML sémantique quand c’est possible, puis à enrichir l’expérience avec Pointer Events lorsque l’interaction l’exige. C’est exactement l’esprit du progressive enhancement : construire une base fiable, puis ajouter des capacités avancées sans fragiliser l’usage principal.