Toutes les ressources
Reactnov. 2026

Carte profil d'équipe

Un composant React gratuit pour présenter une équipe : le portrait redessiné en trame de Bayer qui scintille doucement, puis, au survol, toute la carte se dissout pixel par pixel en coordonnées, phrase et réseaux sociaux. Personnalisez-le ici, puis copiez les instructions pour votre agent IA.

martinjude.fr/freebies/team-profile-card
Démo en direct
TeamProfileCard.tsxTélécharger
"use client";

/**
 * TeamProfileCard — a team member card drawn in ordered dither.
 *
 * The front is the portrait redrawn as a two-tone Bayer dither that shimmers slowly; hover, focus
 * or a tap dissolves the whole card, pixel by pixel, into its back: a phrase, contact details and
 * social links. React + Tailwind (v3 or v4) only, no other dependency.
 *
 * Free to use, by Martin Jude — https://martinjude.fr/freebies/team-profile-card
 */

import {
  useCallback,
  useEffect,
  useRef,
  useState,
  useSyncExternalStore,
  type CSSProperties,
  type FocusEvent,
  type KeyboardEvent,
  type MouseEvent,
  type PointerEvent,
  type ReactNode,
} from "react";

export type SocialNetwork =
  | "linkedin"
  | "github"
  | "x"
  | "instagram"
  | "dribbble"
  | "behance"
  | "youtube"
  | "website";

export interface TeamProfileSocial {
  /** Accessible name of the link, e.g. "LinkedIn". */
  label: string;
  href: string;
  /** Which glyph to draw. Guessed from `href` when left out. */
  network?: SocialNetwork;
  /** Your own icon, drawn instead of the built-in glyph. */
  icon?: ReactNode;
}

export type DitherPattern = "bayer2" | "bayer4" | "bayer8";

/** How a dither layer laid over the photo mixes with it. */
export type OverlayBlend = "normal" | "multiply" | "overlay";

export interface TeamProfileCardProps {
  name: string;
  role: string;
  /** Portrait URL. A cross-origin image needs CORS headers, or the abstract field is drawn instead. */
  image?: string;
  /** Spoken name of the portrait. Defaults to `name`. */
  imageAlt?: string;
  /** Where the crop is anchored, as fractions `[x, y]` (like `object-position`). Defaults to `[0.5, 0.35]`. */
  imageFocus?: [number, number];
  /** A sentence of their own, shown on the back. */
  phrase?: string;
  email?: string;
  phone?: string;
  location?: string;
  socials?: TeamProfileSocial[];

  /** Text and icons. Any CSS colour. */
  ink?: string;
  /** The dither's dots: the portrait, the back's grain and the transition's ink. Defaults to `ink`. */
  dotColor?: string;
  /** Light tone: the paper. Any CSS colour. */
  paper?: string;
  /** The dissolve's leading edge, the focus ring and link hovers. */
  accent?: string;
  /** Size of one dither cell, in CSS pixels (1–8). */
  pixelSize?: number;
  pattern?: DitherPattern;
  /** Portrait contrast, 1 = as is. */
  contrast?: number;
  /** Portrait brightness, from -0.5 to 0.5. */
  brightness?: number;
  /** Strength of the idle animation, from 0 (still) to 1. */
  shimmer?: number;
  /** Speed of the idle animation, 1 = default. */
  speed?: number;
  /**
   * `overlay` (the default) keeps the photo in colour and lays the dots over its shadows; `dither`
   * redraws the portrait in two tones. Without an image, both draw the abstract field.
   */
  effect?: "dither" | "overlay";
  /** Overlay only: opacity of the dots, from 0 to 1. */
  overlayOpacity?: number;
  /** Overlay only: how the dots mix with the photo. */
  overlayBlend?: OverlayBlend;

  /** `hover` flips on hover and keyboard focus; `click` on click, Enter or Space. A tap always toggles. */
  trigger?: "hover" | "click";
  /** Duration of the full dissolve, in milliseconds. */
  transitionMs?: number;
  /**
   * `2`: an ink wave spreads over the card, then lifts behind a ring that reveals the back.
   * `1`: a single dithered ring sweeps out from the pointer, the back already behind it.
   */
  transitionSteps?: 1 | 2;
  /** How much ink the wave carries, from 0 to 1: the cover's density in 2 steps, the ring's width in 1. */
  transitionAmount?: number;
  /** The card fills its parent's width at a 3:4 ratio; size it here (`w-72`) or with its parent. */
  className?: string;
}

/** Every optional prop's default value. */
export const TEAM_PROFILE_CARD_DEFAULTS = {
  ink: "#111014",
  paper: "#efede6",
  accent: "#ff5a36",
  pixelSize: 2,
  pattern: "bayer4" as DitherPattern,
  contrast: 1.15,
  brightness: 0,
  shimmer: 0.4,
  speed: 1,
  effect: "overlay" as "dither" | "overlay",
  overlayOpacity: 0.6,
  overlayBlend: "overlay" as OverlayBlend,
  trigger: "hover" as "hover" | "click",
  transitionMs: 900,
  transitionSteps: 2 as 1 | 2,
  transitionAmount: 1,
} as const;

/* ------------------------------------------------------------------ dither maths */

const BAYER_SIZE: Record<DitherPattern, number> = { bayer2: 2, bayer4: 4, bayer8: 8 };
const bayerCache = new Map<number, Float32Array>();

/** The n×n Bayer threshold matrix, normalised to (0, 1). */
function bayerMatrix(n: number): Float32Array {
  const cached = bayerCache.get(n);
  if (cached) return cached;
  let m = [[0]];
  while (m.length < n) {
    const s = m.length;
    const next = Array.from({ length: s * 2 }, () => new Array<number>(s * 2).fill(0));
    for (let y = 0; y < s; y++) {
      for (let x = 0; x < s; x++) {
        const v = m[y][x] * 4;
        next[y][x] = v;
        next[y][x + s] = v + 2;
        next[y + s][x] = v + 3;
        next[y + s][x + s] = v + 1;
      }
    }
    m = next;
  }
  const flat = new Float32Array(n * n);
  for (let y = 0; y < n; y++) for (let x = 0; x < n; x++) flat[y * n + x] = (m[y][x] + 0.5) / (n * n);
  bayerCache.set(n, flat);
  return flat;
}

type Rgb = [number, number, number];

/** Any CSS colour to RGB, by letting a canvas parse it. */
function toRgb(color: string): Rgb {
  const canvas = document.createElement("canvas");
  canvas.width = canvas.height = 1;
  const ctx = canvas.getContext("2d", { willReadFrequently: true });
  if (!ctx) return [0, 0, 0];
  ctx.fillStyle = "#000";
  ctx.fillStyle = color;
  ctx.fillRect(0, 0, 1, 1);
  const [r, g, b] = ctx.getImageData(0, 0, 1, 1).data;
  return [r, g, b];
}

function mix(a: Rgb, b: Rgb, t: number): Rgb {
  return [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t, a[2] + (b[2] - a[2]) * t];
}

/** One RGBA pixel as a little-endian 32-bit word, for an `ImageData` viewed as `Uint32Array`. */
function pack([r, g, b]: Rgb, a = 255): number {
  return ((a << 24) | (Math.round(b) << 16) | (Math.round(g) << 8) | Math.round(r)) >>> 0;
}

/** Luminance (0 = black, 1 = white) of the image covering a cols × rows grid, or null if unreadable. */
function sampleImage(
  img: HTMLImageElement,
  cols: number,
  rows: number,
  contrast: number,
  brightness: number,
  [fx, fy]: [number, number],
): Float32Array | null {
  const canvas = document.createElement("canvas");
  canvas.width = cols;
  canvas.height = rows;
  const ctx = canvas.getContext("2d", { willReadFrequently: true });
  if (!ctx || !img.naturalWidth) return null;
  // object-fit: cover, at the same anchor as the photo's `object-position`.
  const scale = Math.max(cols / img.naturalWidth, rows / img.naturalHeight);
  const w = img.naturalWidth * scale;
  const h = img.naturalHeight * scale;
  ctx.imageSmoothingQuality = "high";
  ctx.drawImage(img, (cols - w) * fx, (rows - h) * fy, w, h);
  let data: Uint8ClampedArray;
  try {
    data = ctx.getImageData(0, 0, cols, rows).data;
  } catch {
    return null; // A cross-origin image without CORS taints the canvas.
  }
  const lum = new Float32Array(cols * rows);
  for (let i = 0; i < lum.length; i++) {
    const l = (0.2126 * data[i * 4] + 0.7152 * data[i * 4 + 1] + 0.0722 * data[i * 4 + 2]) / 255;
    lum[i] = (l - 0.5) * contrast + 0.5 + brightness;
  }
  return lum;
}

function smoothstep(t: number) {
  return t * t * (3 - 2 * t);
}

/* ------------------------------------------------------------------ hooks */

function subscribeReducedMotion(onChange: () => void) {
  const query = window.matchMedia("(prefers-reduced-motion: reduce)");
  query.addEventListener("change", onChange);
  return () => query.removeEventListener("change", onChange);
}

function useReducedMotion() {
  return useSyncExternalStore(
    subscribeReducedMotion,
    () => window.matchMedia("(prefers-reduced-motion: reduce)").matches,
    () => false,
  );
}

/** The portrait, once decoded; null while loading, without an image or when it fails. */
function useImage(src: string | undefined) {
  const [loaded, setLoaded] = useState<{ src: string; img: HTMLImageElement } | null>(null);
  useEffect(() => {
    if (!src) return;
    let cancelled = false;
    const img = new Image();
    img.crossOrigin = "anonymous";
    img.decoding = "async";
    img.onload = () => !cancelled && setLoaded({ src, img });
    img.onerror = () => !cancelled && setLoaded(null);
    img.src = src;
    return () => {
      cancelled = true;
    };
  }, [src]);
  return loaded && loaded.src === src ? loaded.img : null;
}

/* ------------------------------------------------------------------ icons */

const SOCIAL_HOSTS: [RegExp, SocialNetwork][] = [
  [/linkedin\./, "linkedin"],
  [/github\./, "github"],
  [/(^|\.)(x|twitter)\.com$/, "x"],
  [/instagram\./, "instagram"],
  [/dribbble\./, "dribbble"],
  [/behance\./, "behance"],
  [/(youtube\.|youtu\.be)/, "youtube"],
];

/** Which built-in glyph a link gets, from its host. */
export function guessNetwork(href: string): SocialNetwork {
  try {
    const host = new URL(href).hostname.replace(/^www\./, "");
    return SOCIAL_HOSTS.find(([pattern]) => pattern.test(host))?.[1] ?? "website";
  } catch {
    return "website";
  }
}

const GLYPHS: Record<SocialNetwork, ReactNode> = {
  linkedin: (
    <path d="M4.5 9.5h3v10h-3zM6 4.5a1.75 1.75 0 1 1 0 3.5 1.75 1.75 0 0 1 0-3.5zM10 9.5h2.9v1.4c.4-.8 1.5-1.6 3-1.6 3.1 0 3.6 2 3.6 4.6v5.6h-3v-5c0-1.2 0-2.7-1.6-2.7s-1.9 1.3-1.9 2.6v5.1h-3z" fill="currentColor" stroke="none" />
  ),
  github: (
    <path d="M12 3.5a8.5 8.5 0 0 0-2.7 16.6c.4.1.6-.2.6-.4v-1.5c-2.4.5-2.9-1-2.9-1-.4-1-1-1.3-1-1.3-.8-.5 0-.5 0-.5.9.1 1.4.9 1.4.9.8 1.3 2 1 2.5.7.1-.6.3-1 .6-1.2-1.9-.2-3.9-1-3.9-4.2 0-.9.3-1.7.9-2.3-.1-.2-.4-1.1.1-2.3 0 0 .7-.2 2.3.9a8 8 0 0 1 4.2 0c1.6-1.1 2.3-.9 2.3-.9.5 1.2.2 2.1.1 2.3.5.6.9 1.4.9 2.3 0 3.3-2 4-3.9 4.2.3.3.6.8.6 1.6v2.4c0 .2.2.5.6.4A8.5 8.5 0 0 0 12 3.5z" fill="currentColor" stroke="none" />
  ),
  x: <path d="M5 4.5h4l10 15h-4zM18.5 4.5 13.6 10M5.5 19.5l5-5.6" />,
  instagram: (
    <>
      <rect x="4.5" y="4.5" width="15" height="15" rx="4.5" />
      <circle cx="12" cy="12" r="3.5" />
      <circle cx="16.6" cy="7.4" r=".6" fill="currentColor" />
    </>
  ),
  dribbble: (
    <>
      <circle cx="12" cy="12" r="7.5" />
      <path d="M8.2 5.5c3 3.6 5.6 8.6 6.6 13.3M4.6 10.6c4.8.4 9.6-.6 12.6-3.6M6.7 17.3c2.6-3.4 6.6-4.8 12.7-3.4" />
    </>
  ),
  behance: (
    <path d="M4 7h5a2.5 2.5 0 0 1 0 5H4zm0 5h5.5a2.75 2.75 0 0 1 0 5.5H4zM14 8.5h5M13.5 14h6.5a3.25 3.25 0 1 0-1 2.5" />
  ),
  youtube: (
    <>
      <rect x="3.5" y="6" width="17" height="12" rx="3.5" />
      <path d="m10.5 9.5 4 2.5-4 2.5z" fill="currentColor" />
    </>
  ),
  website: (
    <>
      <circle cx="12" cy="12" r="7.5" />
      <path d="M4.5 12h15M12 4.5c2.2 2.1 3.2 4.6 3.2 7.5s-1 5.4-3.2 7.5c-2.2-2.1-3.2-4.6-3.2-7.5s1-5.4 3.2-7.5z" />
    </>
  ),
};

function Glyph({ children, size = 18 }: { children: ReactNode; size?: number }) {
  return (
    <svg
      viewBox="0 0 24 24"
      width={size}
      height={size}
      fill="none"
      stroke="currentColor"
      strokeWidth={1.6}
      strokeLinecap="round"
      strokeLinejoin="round"
      aria-hidden="true"
      className="shrink-0"
    >
      {children}
    </svg>
  );
}

const MAIL_GLYPH = <path d="M4.5 6.5h15v11h-15zM4.5 7l7.5 6 7.5-6" />;
const PHONE_GLYPH = (
  <path d="M8 4.5H5.5a1 1 0 0 0-1 1C4.5 13.3 10.7 19.5 18.5 19.5a1 1 0 0 0 1-1V16l-3.5-1.5-1.8 1.8a10 10 0 0 1-5.5-5.5L10.5 9z" />
);
const PIN_GLYPH = (
  <>
    <path d="M12 20s-6-5.4-6-10a6 6 0 1 1 12 0c0 4.6-6 10-6 10z" />
    <circle cx="12" cy="10" r="2" />
  </>
);

function initialsOf(name: string) {
  return name
    .split(/\s+/)
    .filter(Boolean)
    .slice(0, 2)
    .map((word) => word[0]!.toUpperCase())
    .join("");
}

/* ------------------------------------------------------------------ the card */

interface Engine {
  /** Dissolve progress: 0 = front, 1 = back. */
  p: number;
  target: boolean;
  /** Where the dissolve starts, as fractions of the card. */
  origin: { x: number; y: number };
  last: number;
}

export function TeamProfileCard({
  name,
  role,
  image,
  imageAlt,
  imageFocus,
  phrase,
  email,
  phone,
  location,
  socials = [],
  ink = TEAM_PROFILE_CARD_DEFAULTS.ink,
  paper = TEAM_PROFILE_CARD_DEFAULTS.paper,
  accent = TEAM_PROFILE_CARD_DEFAULTS.accent,
  dotColor,
  pixelSize = TEAM_PROFILE_CARD_DEFAULTS.pixelSize,
  pattern = TEAM_PROFILE_CARD_DEFAULTS.pattern,
  contrast = TEAM_PROFILE_CARD_DEFAULTS.contrast,
  brightness = TEAM_PROFILE_CARD_DEFAULTS.brightness,
  shimmer = TEAM_PROFILE_CARD_DEFAULTS.shimmer,
  speed = TEAM_PROFILE_CARD_DEFAULTS.speed,
  effect = TEAM_PROFILE_CARD_DEFAULTS.effect,
  overlayOpacity = TEAM_PROFILE_CARD_DEFAULTS.overlayOpacity,
  overlayBlend = TEAM_PROFILE_CARD_DEFAULTS.overlayBlend,
  trigger = TEAM_PROFILE_CARD_DEFAULTS.trigger,
  transitionMs = TEAM_PROFILE_CARD_DEFAULTS.transitionMs,
  transitionSteps = TEAM_PROFILE_CARD_DEFAULTS.transitionSteps,
  transitionAmount = TEAM_PROFILE_CARD_DEFAULTS.transitionAmount,
  className,
}: TeamProfileCardProps) {
  const rootRef = useRef<HTMLElement>(null);
  const fieldRef = useRef<HTMLCanvasElement>(null);
  const veilRef = useRef<HTMLCanvasElement>(null);
  const backRef = useRef<HTMLDivElement>(null);
  const grainRef = useRef<HTMLCanvasElement>(null);
  const engine = useRef<Engine>({ p: 0, target: false, origin: { x: 0.5, y: 0.5 }, last: 0 });
  const kick = useRef<() => void>(() => {});

  const reduced = useReducedMotion();
  const img = useImage(image);
  const [size, setSize] = useState({ w: 0, h: 0 });
  const [showBack, setShowBack] = useState(false);

  const [hovered, setHovered] = useState(false);
  const [toggled, setToggled] = useState(false);
  // "root" = the card itself has keyboard focus; "inside" = a link on the back has it.
  const [focus, setFocus] = useState<"root" | "inside" | null>(null);
  const lastPointer = useRef("mouse");

  const flipped =
    toggled || focus === "inside" || (trigger === "hover" && (hovered || focus === "root"));

  // Layout size, untransformed: the card may sit in a scaled or rotated parent.
  useEffect(() => {
    const root = rootRef.current;
    if (!root) return;
    const measure = () => setSize({ w: root.offsetWidth, h: root.offsetHeight });
    measure();
    const observer = new ResizeObserver(measure);
    observer.observe(root);
    return () => observer.disconnect();
  }, []);

  // The photo stays visible under the dots; decided by the prop, not the decoded image, so a photo
  // that can't be sampled (cross-origin without CORS) still shows, under an even screen of dots.
  const overlay = effect === "overlay" && !!image;

  // Anchored a little above centre by default, where faces usually sit.
  const focusX = imageFocus?.[0] ?? 0.5;
  const focusY = imageFocus?.[1] ?? 0.35;

  const cell = Math.max(1, pixelSize);
  const cols = Math.max(1, Math.round(size.w / cell));
  const rows = Math.max(1, Math.round(size.h / cell));

  useEffect(() => {
    const root = rootRef.current;
    const field = fieldRef.current;
    const grain = grainRef.current;
    const veil = veilRef.current;
    const back = backRef.current;
    const fieldCtx = field?.getContext("2d");
    const grainCtx = grain?.getContext("2d");
    const veilCtx = veil?.getContext("2d");
    if (!root || !field || !grain || !veil || !back || !fieldCtx || !grainCtx || !veilCtx || size.w === 0) return;

    field.width = grain.width = veil.width = cols;
    field.height = grain.height = veil.height = rows;
    const fieldData = fieldCtx.createImageData(cols, rows);
    const grainData = grainCtx.createImageData(cols, rows);
    const veilData = veilCtx.createImageData(cols, rows);
    const fieldPx = new Uint32Array(fieldData.data.buffer);
    const grainPx = new Uint32Array(grainData.data.buffer);
    const veilPx = new Uint32Array(veilData.data.buffer);

    const n = BAYER_SIZE[pattern];
    const matrix = bayerMatrix(n);
    const dotRgb = toRgb(dotColor ?? ink);
    const paperRgb = toRgb(paper);
    const accentRgb = toRgb(accent);
    const DOT = pack(dotRgb);
    const PAPER = pack(paperRgb);
    const ACCENT = pack(accentRgb);
    const GRAIN = pack(mix(paperRgb, dotRgb, 0.16));
    const lum = img ? sampleImage(img, cols, rows, contrast, brightness, [focusX, focusY]) : null;

    // Separable waves, refilled once per frame rather than once per cell, shared by both faces.
    const waveX = new Float32Array(cols);
    const waveY = new Float32Array(rows);
    const waveD = new Float32Array(cols + rows);
    const strength = Math.min(1, Math.max(0, shimmer));
    const amp = (lum ? 0.2 : 0.32) * strength;
    const grainAmp = 0.1 * strength;
    const animated = !reduced && strength > 0;
    const amount = Math.min(1, Math.max(0, transitionAmount));
    const oneStep = transitionSteps === 1;

    const fillWaves = (time: number) => {
      for (let x = 0; x < cols; x++) waveX[x] = Math.sin(x * 0.13 + time * 1.7);
      for (let y = 0; y < rows; y++) waveY[y] = Math.sin(y * 0.11 - time * 1.3);
      for (let d = 0; d < cols + rows; d++) waveD[d] = Math.sin((d - rows) * 0.07 + time * 2.3);
    };

    const drawFront = () => {
      for (let y = 0; y < rows; y++) {
        const by = (y % n) * n;
        const fy = y / rows;
        for (let x = 0; x < cols; x++) {
          const i = y * cols + x;
          const wave = waveX[x] * waveY[y] * 0.6 + waveD[x - y + rows] * 0.4;
          let base: number;
          if (lum) base = lum[i];
          else if (overlay) base = 0.62;
          else {
            // No portrait: a soft light falling from the top, darker toward the name.
            const fx = x / cols - 0.5;
            base = 0.95 - 0.9 * Math.sqrt(fx * fx * 1.4 + (fy - 0.3) * (fy - 0.3)) - fy * 0.25;
          }
          // Over the photo, the paper cells are left transparent.
          fieldPx[i] = base + amp * wave < matrix[by + (x % n)] ? DOT : overlay ? 0 : PAPER;
        }
      }
      fieldCtx.putImageData(fieldData, 0, 0);
    };

    // The back's grain: sparse, so its text stays readable, and drifting with the same waves.
    const drawGrain = () => {
      for (let y = 0; y < rows; y++) {
        const by = (y % n) * n;
        for (let x = 0; x < cols; x++) {
          const wave = waveX[x] * waveY[y] * 0.6 + waveD[x - y + rows] * 0.4;
          grainPx[y * cols + x] = matrix[by + (x % n)] + grainAmp * wave > 0.95 ? GRAIN : 0;
        }
      }
      grainCtx.putImageData(grainData, 0, 0);
    };

    // Distance of every cell from the transition's origin (0 there, 1 at the farthest corner),
    // computed once per origin rather than once per cell per frame.
    const dist = new Float32Array(cols * rows);
    let distKey = "";
    let maxCells = 1;
    let maxPx = 1;
    const ensureDist = () => {
      const { x: ox, y: oy } = engine.current.origin;
      const key = `${ox}:${oy}`;
      if (key === distKey) return;
      distKey = key;
      maxCells = Math.hypot(Math.max(ox, 1 - ox) * cols, Math.max(oy, 1 - oy) * rows) || 1;
      maxPx = Math.hypot(Math.max(ox, 1 - ox) * size.w, Math.max(oy, 1 - oy) * size.h) || 1;
      for (let y = 0; y < rows; y++) {
        const dy = y + 0.5 - oy * rows;
        for (let x = 0; x < cols; x++) dist[y * cols + x] = Math.hypot(x + 0.5 - ox * cols, dy) / maxCells;
      }
    };

    /** The revealing ring at progress p: its radius (0–1, the back's clip) and half-width, or null. */
    const ring = (p: number) => {
      // Never under three cells each side, so the clip's hard edge is always under ink.
      const floor = 3 / maxCells;
      if (oneStep) {
        const half = Math.max(0.04 + 0.2 * amount, floor);
        return { r: smoothstep(p) * (1 + 2 * half) - half, half };
      }
      if (p < 0.5) return null;
      const half = Math.max(0.035, floor);
      return { r: smoothstep((p - 0.5) * 2) * (1 + 2 * half) - half, half };
    };

    let clip = "";
    const applyClip = (p: number) => {
      let next: string;
      if (p <= 0) next = "inset(0 0 100% 0)";
      else if (p >= 1) next = "none";
      else {
        ensureDist();
        const current = ring(p);
        const { x: ox, y: oy } = engine.current.origin;
        next =
          current && current.r > 0
            ? `circle(${(current.r * maxPx).toFixed(1)}px at ${(ox * 100).toFixed(2)}% ${(oy * 100).toFixed(2)}%)`
            : "inset(0 0 100% 0)";
      }
      if (next !== clip) {
        clip = next;
        back.style.clipPath = next;
      }
    };

    let veilClear = true;
    const drawVeil = (p: number) => {
      if (p <= 0 || p >= 1) {
        if (!veilClear) veilCtx.clearRect(0, 0, cols, rows);
        veilClear = true;
        return;
      }
      veilClear = false;
      ensureDist();
      const current = ring(p);
      // Two steps, first half: the ink spreads from the origin, `amount` of the cells at most.
      const cover = smoothstep(Math.min(1, p * 2)) * 1.02;
      for (let y = 0; y < rows; y++) {
        const by = (y % n) * n;
        for (let x = 0; x < cols; x++) {
          const i = y * cols + x;
          const th = matrix[by + (x % n)];
          const d = dist[i];
          if (!current) {
            const t = 0.5 * th + 0.5 * d;
            veilPx[i] = th >= amount ? 0 : t < cover - 0.045 ? DOT : t < cover ? ACCENT : 0;
            continue;
          }
          const off = d - current.r;
          if (off < -current.half) {
            veilPx[i] = 0; // Behind the ring: the back.
          } else if (off <= current.half) {
            // The ring: solid at its core (over the clip edge), dithered toward its sides, the
            // accent on its leading side.
            const k = 1 - Math.abs(off) / current.half;
            const inked = Math.abs(off) < current.half * 0.35 || th < k;
            veilPx[i] = !inked ? 0 : off > 0 && k < 0.5 ? ACCENT : DOT;
          } else {
            // Ahead of it: the front, still under the cover in two steps.
            veilPx[i] = !oneStep && th < amount ? DOT : 0;
          }
        }
      }
      veilCtx.putImageData(veilData, 0, 0);
    };

    const state = engine.current;
    let raf = 0;
    let visible = true;
    let lastDraw = -Infinity;
    let shown = state.p >= 0.5;

    const draw = (time: number) => {
      fillWaves(time);
      // Each face is drawn only while some of it can be seen.
      if (state.p < 1) drawFront();
      if (state.p > 0) drawGrain();
      drawVeil(state.p);
      applyClip(state.p);
    };

    const frame = (now: number) => {
      raf = 0;
      const dt = state.last ? now - state.last : 0;
      state.last = now;
      const goal = state.target ? 1 : 0;
      state.p =
        reduced || transitionMs <= 0
          ? goal
          : Math.min(1, Math.max(0, state.p + ((state.target ? 1 : -1) * dt) / transitionMs));
      const moving = state.p !== goal;
      const nextShown = state.p >= 0.5;
      const swapped = nextShown !== shown;
      if (swapped) {
        shown = nextShown;
        setShowBack(nextShown);
      }
      // The idle shimmer is held to ~30 fps; the transition runs at the display's rate.
      if (moving || swapped || now - lastDraw >= 33) {
        draw(animated ? (now / 1000) * speed * 0.35 : 0);
        lastDraw = now;
      }
      if (visible && (moving || animated)) raf = requestAnimationFrame(frame);
      else state.last = 0;
    };

    const start = () => {
      if (!raf && visible) raf = requestAnimationFrame(frame);
    };
    kick.current = start;

    // Nothing runs while the card is off screen or the tab is hidden.
    const observer = new IntersectionObserver(([entry]) => {
      visible = entry.isIntersecting && !document.hidden;
      if (visible) start();
    });
    observer.observe(root);
    const onVisibility = () => {
      visible = !document.hidden;
      if (visible) start();
    };
    document.addEventListener("visibilitychange", onVisibility);

    // First paint straight away, so the card is never blank.
    draw(0);
    start();

    return () => {
      cancelAnimationFrame(raf);
      state.last = 0;
      kick.current = () => {};
      observer.disconnect();
      document.removeEventListener("visibilitychange", onVisibility);
    };
  }, [cols, rows, size.w, size.h, pattern, ink, dotColor, paper, accent, img, focusX, focusY, overlay, contrast, brightness, shimmer, speed, transitionMs, transitionSteps, transitionAmount, reduced]);

  useEffect(() => {
    engine.current.target = flipped;
    kick.current();
  }, [flipped]);

  const setOrigin = useCallback((event: { clientX: number; clientY: number }) => {
    const rect = rootRef.current?.getBoundingClientRect();
    if (!rect || !rect.width) return;
    engine.current.origin = {
      x: Math.min(1, Math.max(0, (event.clientX - rect.left) / rect.width)),
      y: Math.min(1, Math.max(0, (event.clientY - rect.top) / rect.height)),
    };
  }, []);

  const onPointerEnter = (event: PointerEvent) => {
    if (event.pointerType === "touch") return;
    setOrigin(event);
    setHovered(true);
  };
  const onPointerLeave = (event: PointerEvent) => {
    if (event.pointerType === "touch") return;
    setOrigin(event);
    setHovered(false);
  };
  const onClick = (event: MouseEvent) => {
    if ((event.target as Element).closest("a")) return;
    if (trigger === "click" || lastPointer.current === "touch") {
      setOrigin(event);
      setToggled((value) => !value);
    }
  };
  const onKeyDown = (event: KeyboardEvent) => {
    if (event.target !== event.currentTarget) return;
    if (event.key === "Enter" || event.key === " ") {
      event.preventDefault();
      engine.current.origin = { x: 0, y: 0 };
      setToggled((value) => !value);
    } else if (event.key === "Escape") {
      setToggled(false);
    }
  };
  const onFocus = (event: FocusEvent) => {
    if (event.target === event.currentTarget) {
      // A mouse click focuses the card too; only keyboard focus should hold it open.
      setFocus(event.currentTarget.matches(":focus-visible") ? "root" : null);
    } else {
      engine.current.origin = { x: 0, y: 1 };
      setFocus("inside");
    }
  };
  const onBlur = (event: FocusEvent) => {
    if (!event.currentTarget.contains(event.relatedTarget as Node | null)) setFocus(null);
  };

  const vars = {
    "--tpc-ink": ink,
    "--tpc-paper": paper,
    "--tpc-accent": accent,
    // 72 % keeps the secondary text over 4.5:1 wherever the text itself is well over 7:1.
    "--tpc-muted": `color-mix(in srgb, ${ink} 72%, ${paper})`,
    "--tpc-rule": `color-mix(in srgb, ${ink} 18%, ${paper})`,
  } as CSSProperties;

  const contactClass =
    "flex min-w-0 items-center gap-2.5 text-sm transition-colors hover:text-[color:var(--tpc-accent)] focus-visible:text-[color:var(--tpc-accent)] focus-visible:outline-none";

  return (
    <article
      ref={rootRef}
      tabIndex={0}
      aria-label={`${name}, ${role}`}
      data-flipped={showBack || undefined}
      onPointerDown={(event) => {
        lastPointer.current = event.pointerType;
      }}
      onPointerEnter={onPointerEnter}
      onPointerLeave={onPointerLeave}
      onClick={onClick}
      onKeyDown={onKeyDown}
      onFocus={onFocus}
      onBlur={onBlur}
      style={vars}
      className={[
        "relative block aspect-[3/4] cursor-pointer select-none overflow-hidden rounded-[22px] bg-[color:var(--tpc-paper)] text-[color:var(--tpc-ink)] outline-none focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-4 focus-visible:outline-[color:var(--tpc-accent)]",
        className,
      ]
        .filter(Boolean)
        .join(" ")}
    >
      {overlay && (
        // A plain <img>, not next/image: the file has to work in any React project.
        <img
          src={image}
          alt={imageAlt ?? name}
          draggable={false}
          className="absolute inset-0 h-full w-full object-cover"
          // The same anchor as the sampling, so the dots fall on the photo's own shadows.
          style={{ objectPosition: `${focusX * 100}% ${focusY * 100}%` }}
        />
      )}
      <canvas
        ref={fieldRef}
        role={image && !overlay ? "img" : undefined}
        aria-label={image && !overlay ? (imageAlt ?? name) : undefined}
        aria-hidden={image && !overlay ? undefined : true}
        className="absolute inset-0 h-full w-full [image-rendering:pixelated]"
        style={overlay ? { opacity: overlayOpacity, mixBlendMode: overlayBlend } : undefined}
      />

      {/* Front. The back layer covers it, so it never needs hiding. */}
      <div className="absolute inset-0 flex flex-col justify-end p-3">
        {!img && !overlay && (
          <span
            aria-hidden="true"
            className="absolute left-1/2 top-[38%] grid h-24 w-24 -translate-x-1/2 -translate-y-1/2 place-items-center rounded-full bg-[color:var(--tpc-paper)] text-3xl font-semibold tracking-tight"
          >
            {initialsOf(name)}
          </span>
        )}
        <div className="flex items-end justify-between gap-3 rounded-[14px] bg-[color:var(--tpc-paper)] px-4 py-3">
          <div className="min-w-0">
            <p className="truncate text-lg font-semibold leading-tight tracking-tight">{name}</p>
            <p className="truncate text-sm text-[color:var(--tpc-muted)]">{role}</p>
          </div>
          <span aria-hidden="true" className="mb-1.5 h-2 w-2 shrink-0 bg-[color:var(--tpc-accent)]" />
        </div>
      </div>

      {/* Back: opaque paper, revealed by a clip-path the animation loop writes (from a growing circle
          to `none`). Clipped, not hidden, so its links stay focusable: tabbing onto one turns the card. */}
      <div
        ref={backRef}
        className="absolute inset-0 bg-[color:var(--tpc-paper)]"
        style={{ clipPath: "inset(0 0 100% 0)", pointerEvents: showBack ? "auto" : "none" }}
      >
        <canvas
          ref={grainRef}
          aria-hidden="true"
          className="pointer-events-none absolute inset-0 h-full w-full [image-rendering:pixelated]"
        />
        {/* Positioned, so it paints over the grain canvas. */}
        <div className="relative flex h-full flex-col gap-4 p-5">
          <div className="flex items-center gap-2">
            <span aria-hidden="true" className="h-2 w-2 shrink-0 bg-[color:var(--tpc-accent)]" />
            <p className="min-w-0 truncate text-xs font-medium">
              {name} <span className="text-[color:var(--tpc-muted)]">· {role}</span>
            </p>
          </div>
          {phrase && (
            <p className="select-text text-xl font-medium leading-snug tracking-tight">{phrase}</p>
          )}
          <div className="mt-auto flex flex-col gap-2.5">
            {email && (
              <a href={`mailto:${email}`} className={contactClass}>
                <Glyph size={16}>{MAIL_GLYPH}</Glyph>
                <span className="truncate">{email}</span>
              </a>
            )}
            {phone && (
              <a href={`tel:${phone.replace(/[^\d+]/g, "")}`} className={contactClass}>
                <Glyph size={16}>{PHONE_GLYPH}</Glyph>
                <span className="truncate">{phone}</span>
              </a>
            )}
            {location && (
              <p className="flex min-w-0 items-center gap-2.5 text-sm text-[color:var(--tpc-muted)]">
                <Glyph size={16}>{PIN_GLYPH}</Glyph>
                <span className="truncate">{location}</span>
              </p>
            )}
          </div>
          {socials.length > 0 && (
            // Rules are inset shadows, not borders: a global `* { border-color }`
            // in the host app would otherwise repaint them.
            <ul className="flex flex-wrap gap-2 pt-4 shadow-[inset_0_1px_0_var(--tpc-rule)]">
              {socials.map((social) => (
                <li key={social.href}>
                  <a
                    href={social.href}
                    target="_blank"
                    rel="noopener noreferrer"
                    aria-label={social.label}
                    title={social.label}
                    className="grid h-9 w-9 place-items-center rounded-full shadow-[inset_0_0_0_1px_var(--tpc-rule)] transition-colors hover:bg-[color:var(--tpc-ink)] hover:text-[color:var(--tpc-paper)] focus-visible:outline focus-visible:outline-2 focus-visible:outline-[color:var(--tpc-accent)]"
                  >
                    {social.icon ?? <Glyph>{GLYPHS[social.network ?? guessNetwork(social.href)]}</Glyph>}
                  </a>
                </li>
              ))}
            </ul>
          )}
        </div>
      </div>

      <canvas
        ref={veilRef}
        aria-hidden="true"
        className="pointer-events-none absolute inset-0 h-full w-full [image-rendering:pixelated]"
      />
    </article>
  );
}

export default TeamProfileCard;
Notes

Un seul fichier, React et Tailwind (v3 ou v4), aucune autre dépendance.

« Copier les instructions IA » donne à Claude Code, Cursor ou Codex le code complet et votre configuration : collez, il l'installe.

README.md

Carte profil d'équipe

Une carte de profil pour une page « Équipe » : la photo reste en couleur sous une trame de Bayer qui scintille lentement, ou le portrait est entièrement redessiné en deux tons, comme une impression en demi-teinte (effect="dither"). Au survol, au focus clavier ou d'un toucher, la carte entière se dissout pixel par pixel depuis le point d'entrée du curseur et laisse place à son dos : une phrase, l'e-mail, le téléphone, le lieu et les réseaux sociaux.

Un seul fichier, TeamProfileCard.tsx : React 18+ et Tailwind CSS v3 ou v4, rien d'autre. Le tramage est calculé dans un <canvas> 2D, sans WebGL.

Installer

Avec un agent IA : réglez la carte dans la démo ci-dessus, cliquez sur « Copier les instructions IA » et collez le prompt dans Claude Code, Cursor ou Codex. Il contient le code complet, votre configuration et les étapes.

À la main :

  1. Téléchargez TeamProfileCard.tsx et placez-le dans vos composants (src/components/, par exemple).
  2. Vérifiez que Tailwind lit ce fichier (content en v3 ; en v4, la détection automatique suffit tant que le dossier n'est pas exclu).
  3. Utilisez-le :
import { TeamProfileCard } from "@/components/TeamProfileCard";

export function Equipe() {
  return (
    <div className="grid grid-cols-[repeat(auto-fill,minmax(16rem,1fr))] gap-6">
      <TeamProfileCard
        name="Mark S."
        role="Raffinage des macrodonnées"
        image="/team/mark.jpg"
        phrase="Je ne sais pas ce que je fais ici, mais je le fais très bien."
        email="mark.s@lumen.example"
        location="Lumen Industries, Kier"
        dotColor="#2f7a6b"
        socials={[{ label: "Lumen Industries", href: "https://lumen.example" }]}
      />
    </div>
  );
}

Avec le routeur app/ de Next.js, gardez la directive "use client" en tête du fichier : la carte s'importe ensuite depuis un composant serveur.

Props

Prop Type Par défaut Rôle
name, role string requis Nom et fonction, sur la face avant
image string URL du portrait. Sans image : un motif abstrait et les initiales
imageAlt string name Description du portrait pour les lecteurs d'écran
imageFocus [number, number] [0.5, 0.35] Point d'ancrage du cadrage, en fractions [x, y] comme object-position : [0.55, 0.3] recentre un visage placé à droite
phrase string La phrase du dos
email, phone, location string Coordonnées (liens mailto: et tel:)
socials { label, href, network?, icon? }[] [] Réseaux, en icônes. Le réseau est deviné d'après l'URL (LinkedIn, GitHub, X, Instagram, Dribbble, Behance, YouTube, sinon un globe) ; icon accepte la vôtre
ink couleur CSS #111014 Le texte et les icônes
dotColor couleur CSS ink Les points : la trame du portrait, le grain du dos et l'encre de la transition
paper couleur CSS #efede6 Ton clair : le papier
accent couleur CSS #ff5a36 Le front de la dissolution, le focus, les survols
pixelSize number 2 Taille d'une cellule de trame, en pixels CSS (1 à 8)
pattern "bayer2" | "bayer4" | "bayer8" "bayer4" Matrice de Bayer : plus elle est grande, plus les dégradés sont fins
contrast number 1.15 Contraste du portrait, 1 = tel quel
brightness number 0 Luminosité du portrait, de -0.5 à 0.5
shimmer number 0.4 Force du scintillement au repos, de 0 (immobile) à 1
speed number 1 Vitesse du scintillement
effect "overlay" | "dither" "overlay" overlay garde la photo en couleur et pose les points sur ses ombres ; dither redessine le portrait en deux tons
overlayOpacity number 0.6 En superposition : opacité des points, de 0 à 1
overlayBlend "normal" | "multiply" | "overlay" "overlay" En superposition : fusion des points avec la photo
trigger "hover" | "click" "hover" Ce qui retourne la carte. Un toucher la bascule toujours
transitionMs number 900 Durée de la dissolution complète
transitionSteps 1 | 2 2 2 : l'encre couvre la carte, puis se retire derrière un anneau qui révèle le dos. 1 : un seul anneau tramé balaie la carte depuis le curseur
transitionAmount number 1 De 0 à 1 : la densité de l'encre en 2 temps (1 = couverture complète), l'épaisseur de l'anneau en 1 temps
className string La carte prend la largeur de son parent, au format 3/4 : donnez-lui une largeur ici (w-72) ou par la grille qui la contient

TEAM_PROFILE_CARD_DEFAULTS exporte ces valeurs par défaut.

Bon à savoir

  • Transitions : en deux temps, la carte se couvre d'encre (en entier, ou en partie avec un transitionAmount plus bas) avant de se révéler ; en un temps, le dos apparaît directement derrière l'anneau. Les points du dos scintillent comme la face avant.
  • Superposition (le mode par défaut) : la photo reste en couleur sous la trame, et brightness règle jusqu'où les points montent dans les tons clairs. Le dos de la carte reste sur le papier.
  • Images d'un autre domaine : le tramage lit les pixels du portrait, ce que le navigateur n'autorise que si l'image vient du même site ou d'un serveur qui envoie des en-têtes CORS. Sinon, la carte dessine son motif abstrait au lieu de planter.
  • Accessibilité : le nom et la fonction sont du vrai texte. La carte se parcourt au clavier (Tab montre le dos et ses liens, Entrée ou Espace la retourne, Échap la referme), et les icônes ont un nom accessible.
  • Mouvement réduit : avec prefers-reduced-motion, le portrait ne scintille plus et la dissolution devient un changement instantané.
  • Performance : l'animation s'arrête quand la carte sort de l'écran ou que l'onglet est caché, et le scintillement est limité à 30 images par seconde. Une carte de 300 px fait environ 10 000 cellules par image avec des pixels de 3, 120 000 avec des pixels de 1 : ça reste fluide, mais pour une grille de plusieurs dizaines de cartes, gardez 2 ou plus.

Gratuit, pour vos projets personnels comme commerciaux. Un lien vers martinjude.fr fait toujours plaisir.