depth-scroll

Créez une page à défilement en profondeur : une séquence de panneaux (dessins, cartes une-idée, étapes) disposés comme des stations sur un axe de profondeur que le défilement parcourt, chaque panneau émergeant de la distance, s'arrêtant net au plan de l'écran et passant le spectateur, avec un flux de cartes volant vers le spectateur derrière eux, après le champ d'atterrissage de WhatTheFad (whatthefad.netlify.app). Déclenché sur « une UI qui défile vers l'utilisateur », « comme whatthefad », « fais-le voler vers moi », « défilement en profondeur », « défilement dans l'écran », « un tunnel de ces trucs », ou toute demande de transformer une page plate de figures en une page que le lecteur traverse.

Qu'est-ce que depth-scroll ?

depth-scroll est une compétence d'agent IA qui génère une page Web interactive unique en son genre : une expérience de défilement en profondeur où le lecteur traverse une série de stations (panneaux, dessins, cartes) qui semblent émerger de l'écran, inspirée de la page d'accueil de WhatTheFad. Cette compétence est utile pour les développeurs qui souhaitent créer des présentations visuelles immersives, des tutoriels pas à pas ou des portfolios avec un effet de profondeur réaliste, sans nécessiter de WebGL. Elle prend en charge la génération de fichiers HTML autonomes à partir d'un fichier de spécifications JSON ou d'un dictionnaire Python, et inclut des outils de capture et de vérification headless. Le fonctionnement repose sur une projection en perspective CSS, un défilement synchronisé avec des snap points, et un flux de cartes animé en arrière-plan. La compétence gère également les modes sans JavaScript et de mouvement réduit, et offre une personnalisation poussée via des constantes réglables.

Compatible avec✓Claude Code~Codex CLI✓Cursor
npx skills add https://github.com/rafaelcarlosabbariao/skills/tree/HEAD/agnostic/depth-scroll

Installed? Explore more Développement et programmation skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Si SKILL.local.md existe dans ce dossier, lisez-le d'abord ; il contient vos chemins, données et règles personnelles.

Défilement en profondeur

Un format de page pour un ensemble de figures que le lecteur traverse, une à la fois. La première construction a transformé un ensemble de dessins explicatifs en un défilement vers le spectateur, modelé sur la page d'accueil de WhatTheFad (whatthefad.netlify.app, source sur github.com/rafaelcarlosabbariao/cultural-archaeology).

La compétence contient quatre fichiers :

FichierQu'est-ce que c'est
template.htmlLa page : chrome des stations, le flux, le rail et le script qui les pilote
build.pyRemplit le modèle à partir d'une spécification, en tant que commande ou module
capture.mjsCaptures headless en temps réel et vérifications de navigation via le protocole DevTools
SKILL.mdCe fichier

Quand l'utiliser

  • Cela convient pour quatre à douze panneaux autonomes lus un par un, chacun adapté à un écran : dessins, cartes une-idée, les étapes d'une séquence.
  • Cela ne convient pas pour les longs textes, les tableaux ou tout ce que le lecteur compare côte à côte ou parcourt dans les deux sens. Créez une page plate pour ces cas.
  • Sortie. La page est un seul fichier .html autonome, sans scripts externes ni WebGL. Le modèle est livré avec une palette crème chaude et encre dans les tokens :root ; vous pouvez les restyler à votre goût.

Comment ça fonctionne

Le champ de WhatTheFad, la source

Lisez le index.html de WhatTheFad (#landing-trendfield CSS, et la fonction renderTrendField).

  • Projection. Le champ est un conteneur avec perspective: 900px, et chaque jeton est placé avec translate3d(x, y, z). Le navigateur dessine un jeton à l'échelle 900 / (900 − z) : 0,24 à z = −2800, 1 au plan de l'écran et 1,3 à z = 220.
  • Une horloge pilote le mouvement. Une boucle requestAnimationFrame déplace chaque jeton vers le spectateur à 150 px/s fois un facteur par jeton de 0,75 à 1,25. Après z = 220, il réapparaît sur un anneau elliptique à z = −2800.
  • Fondu et ordre de peinture. Un jeton s'estompe sur le premier quart de sa profondeur et disparaît entre z = 60 et 220. Le champ n'utilise jamais preserve-3d, donc le z-index de chaque jeton est défini à partir de sa profondeur pour que le plus proche soit peint par-dessus.
  • Le centre calme. Un mask-image radial cache le milieu, où les jetons lointains se rassemblent au point de fuite.
  • Attraper un jeton. Le navigateur ne revérifie :hover que lorsque le pointeur bouge, donc un jeton dérivant sous un curseur immobile ne s'allume jamais. WhatTheFad teste le pointeur par rapport au rectangle projeté de chaque jeton à chaque frame, et un jeton attrapé ralentit le champ à 8%.

Ce que ce format ajoute

  • Le défilement est la caméra.
    • Une piste haute (main.depth) contient un arrêt par station, espacé d'une hauteur d'étape, avec scroll-snap-type: y proximity.
    • Une étape collante sous l'en-tête épinglé contient la scène.
    • La position de défilement devient un index de station, entier à chaque arrêt. Une caméra se déplace en douceur vers elle (taux de 9 par seconde), et la station i est dessinée à z = (caméra − i) × 1400.
  • Le passage d'une station.
    • La station qui attend derrière est atténuée et se trouve un peu basse, de sorte qu'elle se lève en place en arrivant vers l'avant.
    • Au repos, elle est à z = 0 et échelle 1, sur des pixels entiers, donc son texte est aussi net qu'une page plate.
    • En passant le spectateur, elle s'estompe à z = 300, à 1,5×.
    • Une station plus haute que l'étape est mise à l'échelle pour s'adapter.
  • Le flux. Le champ de WhatTheFad, masque inclus. La vitesse des cartes est une base de 46 plus 0,9 de la vitesse de la caméra, donc le défilement vers l'avant les fait défiler rapidement et le défilement vers l'arrière les renvoie. Une station nomme les groupes de cartes qu'elle éclaire (lit), et ces cartes s'allument lorsqu'elle est devant.
  • Entrée.
    • Molette, trackpad, toucher, les touches fléchées, le rail et le contenu de l'en-tête font tous bouger le défilement natif unique, donc chaque entrée atterrit sur les mêmes arrêts.
    • Le focus entrant dans une station qui n'est pas devant y fait défiler la page.
    • Le flux est décoratif, et seule la station au repos reçoit les événements de pointeur, donc aucun test de hit par frame n'est nécessaire.
  • Fallback. Sans JavaScript, ou avec prefers-reduced-motion: reduce, la page est les stations empilées à plat. La profondeur est activée par une classe deep que le script ajoute. En mode plat, les ancres du contenu se déplacent sur les stations.

En construire une

SK ci-dessous est l'endroit où vous avez installé cette compétence, par exemple ~/.claude/skills/depth-scroll.

  1. Contenu d'abord. Mettez chaque panneau sur une page plate en tant que <figure class="fig"> contenant une .plate (le dessin) et une figcaption. La page plate est aussi la copie de lecture. Une station peut aussi porter du html brut.
  2. Écrivez une spécification (ci-dessous), sous forme de fichier JSON ou de dictionnaire dans le script de construction du projet lui-même lorsque les valeurs sont calculées (par exemple, les noms de cartes lus à partir d'un fichier de données).
  3. Construisez-la.
    python3 -I $SK/build.py spec.json
    
    ou, depuis un script :
    sys.path.insert(0, str(Path.home() / '.claude/skills/depth-scroll'))
    import build
    build.write(spec, base=HERE)
    
  4. En-tête optionnel. Le modèle laisse de la place pour un en-tête épinglé (--pin-h, header.pin, nav.pin-toc). Sans un, l'étape commence en haut de la fenêtre.
  5. Vérifiez-la avec capture.mjs (ci-dessous), puis validez.

La spécification

Les chemins sont relatifs à base : le dossier du fichier de spécification, ou le dossier passé à write. Les chemins d'image sont écrits dans la page tels quels, donnez-les donc relatifs à la page de sortie.

ChampCe qu'il contient
outLa page à écrire
titleLe <title>, nommé par type (<Sujet> <nom de type>)
sourcePage plate optionnelle. Ses blocs figure.fig deviennent fig: n, et ses blocs de style (pas ceux de l'en-tête) sont copiés pour que les dessins gardent leurs classes
kickerLe petit label au-dessus d'une station de section ; le kicker d'une sous-section est le nom de sa section
doorHTML de la première station : un chapeau, une note, un lien vers la page plate
stations[]id ; sec et/ou sub (les lignes de contenu ; sec seul est une section, sub seul une sous-section, les deux ouvrent une section sur cette station) ; title (par défaut sub, puis sec) ; lead (HTML, une ou deux phrases) ; fig ou html ; cards ([{img, label}], une petite rangée d'images) ; lit (groupes de flux à allumer)
cards_labelLe label à la fin de la rangée d'images d'une station
close{title, kicker, html} pour la dernière station, généralement les sources
stream[]{label, img, group} par carte. De quarante à quatre-vingts donne un flux
cssCSS supplémentaire optionnel, ajouté à la fin

Vérification

K=$SK/capture.mjs
node $K file:///path/page.html at-2.png 2                  # une station au repos
node $K file:///path/page.html transit.png 4.4 --wait=900  # entre deux stations, en train de s'arrêter
node $K file:///path/page.html last.png 9                  # le dernier arrêt est accessible
node $K file:///path/page.html light.png 5 --light         # le fond clair
node $K file:///path/page.html phone.png 3 375 700         # largeur téléphone
node $K file:///path/page.html flat.png 0 --reduce         # la page à mouvement réduit
node $K "file:///path/page.html#st-model" hash.png -       # un lien vers un arrêt, au chargement
node $K file:///path/page.html nav.png 0 --nav             # flèches, le dernier lien de contenu, le rail

Chaque exécution affiche les arrêts et, par étape, y, front (la station qui reçoit les événements de pointeur), rail, cardsShown, cardsLit, deep et pageWidth. Une station au repos a front égal à son indice ; pageWidth doit lire la largeur de la fenêtre (pas de défilement latéral de la page). Regardez chaque image, dans les deux fonds et à la largeur téléphone, avant de déclarer la tâche terminée. Pour les pages dont les images se trouvent à l'extérieur du dossier, copiez d'abord la page dans le bloc-notes avec des chemins d'image absolus.

Ne vérifiez pas avec chrome --headless --screenshot. Sous --virtual-time-budget, les images d'animation avancent à peine, donc la caméra atténuée n'arrive jamais, et une capture d'écran d'une fenêtre défilée peut revenir vide. capture.mjs pilote un Chrome headless en temps réel, où les images s'exécutent à leur vitesse réelle.

Réglage

Les constantes se trouvent en tête du script dans template.html.

ConstanteValeurCe qu'elle modifie
PERSP900Doit correspondre au perspective CSS sur .stations et .field
GAP1400Profondeur du monde entre deux stations
AHEAD2,2 × GAPJusqu'où une station est dessinée à l'avance
PASS300Où une station qui passe a disparu (échelle 1,5)
LIFT36Pixels qu'une station en attente est basse par GAP de distance
DEPTH, NEAR2800, 220La profondeur d'apparition du flux et la profondeur où une carte est passée
BASE46La vitesse du flux au repos, px/s
Ease de la caméra9 par secondeÀ quelle vitesse la caméra rattrape le défilement

Ce qui a mal tourné lors de la première construction

Chacun de ces problèmes a été trouvé en regardant, et chacun est corrigé dans le modèle.

  • La marge de défilement de l'en-tête. L'en-tête épinglé donne à chaque [id] un scroll-margin-top, pour que les ancres atterrissent en dessous. Les sauts atterrissaient 126 px trop tôt de chaque arrêt jusqu'à ce que les arrêts soient mis à zéro.
  • La piste était trop courte d'un en-tête. La page se terminait avant que le dernier arrêt ne puisse atteindre le haut. La hauteur de la piste utilise la hauteur de la fenêtre, pas celle de l'étape.
  • Les cartes volaient derrière la colonne de contenu. Cette colonne est fixe et transparente, donc les cartes apparaissaient à travers son texte. Lorsque la colonne est fixe, l'étape commence à sa droite.
  • Les cartes lointaines se rassemblaient au point de fuite. Le masque de WhatTheFad a résolu le problème.
  • La station qui passait s'attardait comme une grande tache floue. La correction a été un PASS plus court et un fondu au carré.
  • La station en attente apparaissait sous les stations courtes. Elle est dessinée atténuée (au carré).
  • Le contenu du mode plat pointait vers des arrêts cachés. Les arrêts se déplacent sur les stations.
  • Un défilement qui atterrissait avant l'événement de chargement frappait une page courte. La piste est disposée dès que le document est analysé, et à nouveau une fois que les polices et les images se stabilisent, donc un défilement restauré et un lien #st-<id> atterrissent tous les deux.
  • Sur un téléphone, les dessins larges se déplacent latéralement à l'intérieur de leur plaque, la rangée d'images est cachée et la station est rétrécie pour que le rail garde le bord droit.

À faire

  • Attraper une carte. Dans WhatTheFad, un jeton attrapé ouvre une excavation. Ici, une carte pourrait ouvrir son enregistrement, ce qui nécessite que la page cible prenne un identifiant dans son URL et le test de hit projeté ci-dessus.
  • Un contrôle de pause. Le flux bouge tant que la page est ouverte. Le mouvement réduit l'arrête, mais il n'y a pas de bouton pause, ce que WCAG 2.2.2 demande pour un mouvement qui dure plus de cinq secondes à côté d'autre contenu.
  • La sensation sur un vrai trackpad et téléphone, et le taux d'images par seconde, n'ont pas été évalués par une personne.

Individual skills in this repo

This repo contains 1 individual skill — each has its own dedicated page.

Skills associés