Vai al contenuto

Selettori

Per impostazione predefinita, Glaze cerca gli elementi con l'attributo data-animate e crea l'animazione in base al valore di quell'attributo. Questa pagina tratta le tre opzioni che modificano gli elementi letti da Glaze: dataAttribute, className e element, oltre ai selettori tra parentesi quadre che indirizzano un'animazione ad altri elementi. Le utilità all'interno della stringa sono descritte in Sintassi.

Come vengono trovati gli elementi

Quando viene eseguito glaze(), e di nuovo a ogni ricostruzione di refresh() o della modalità di osservazione, l'algoritmo scorre ogni elemento all'interno della radice e mantiene quelli che hanno l'attributo configurato o, in modalità classi, una classe con il prefisso configurato. Anche l'elemento radice viene conteggiato se ne ha uno. Gli elementi vengono letti nell'ordine del documento.

Ogni elemento trovato in questo modo ottiene una propria timeline, a meno che non si trovi all'interno di un elemento tl o non sia collegato a uno con tl:<id>. In tal caso viene aggiunto a quella timeline. Vedi Timeline per sapere come funziona il raggruppamento.

Attributo personalizzato

Usate un attributo data diverso:

JavaScript
glaze({
  lib: { gsap: { core: gsap } },
  dataAttribute: "data-move",
})

Ora Glaze cercherà data-move invece di data-animate:

HTML
<div data-move="from:opacity-0"></div>

L’opzione sostituisce l’attributo invece di aggiungerne uno. Con l’impostazione sopra, un elemento che contiene ancora data-animate viene ignorato. Usatela quando un altro script nella pagina legge già data-animate o quando volete che il markup indichi l’attributo con il nome del vostro progetto.

In modalità watch, Glaze osserva l’attributo configurato, quindi modificare il valore di data-move su un elemento pianifica una ricompilazione.

Sintassi basata sulle classi

Preferite le classi agli attributi data? Attivate la modalità classi:

JavaScript
glaze({
  lib: { gsap: { core: gsap } },
  className: "animate",
})

Ora potete scrivere le animazioni come classi:

HTML
<div class="animate-from:opacity-0|duration-1"></div>

Funziona bene se usate già CSS con approccio utility-first e volete che le animazioni abbiano un aspetto simile. La modalità classi è utile anche quando un sistema di template consente di aggiungere classi a un elemento, ma non attributi arbitrari.

Glaze legge ogni classe che inizia con il prefisso seguito da un trattino (qui animate-) e rimuove quella parte. Le classi senza prefisso restano invariate, così le classi di animazione possono affiancare quelle di stile sullo stesso elemento. Potete suddividere un’animazione tra più classi:

HTML
<div class="card animate-from:opacity-0 animate-from:y-24"></div>

Le classi responsive accettano il breakpoint prima o dopo il prefisso. Entrambe queste opzioni vengono eseguite solo quando corrisponde il lg breakpoint:

HTML
<div class="animate-@lg:from:opacity-0"></div>
<div class="@lg:animate-from:opacity-0"></div>

I preset funzionano allo stesso modo nelle classi, ad esempio animate-preset-fadeIn.

La modalità classi non disattiva l’attributo data. Se un elemento contiene entrambi, Glaze li unisce in un’unica stringa: prima il valore dell’attributo, poi le classi con prefisso nell’ordine in cui compaiono nell’attributo class.

HTML
<div
  class="animate-from:opacity-0 animate-@lg:from:y-50"
  data-animate="from:duration-1"
></div>

Questo elemento si anima da opacity: 0 nell’arco di un secondo a ogni dimensione e anche da y: 50 quando corrisponde lg. Poiché le stringhe vengono unite, vale la stessa regola applicata a una singola stringa: se due parti impostano la stessa proprietà, prevale quella successiva. Qui il valore della classe sovrascrive quello dell’attributo per x:

HTML
<div class="animate-to:x-100" data-animate="to:x-50|y-20"></div>

L’elemento si anima verso x: 100 e y: 20.

Con watch attivato in modalità classi, anche Glaze rileva le modifiche a class. Aggiungere una classe animate- a un elemento o modificare le classi di un elemento che Glaze sta già leggendo o animando pianifica una ricostruzione. Anche le modifiche alle classi dei discendenti di un elemento con un selettore relativo la pianificano, perché possono cambiare gli elementi corrispondenti al selettore. Le modifiche alle classi degli altri elementi non la pianificano; questo vale anche per gli antenati degli elementi animati, quindi attivare una classe per la modalità scura su <html> o una classe per bloccare lo scorrimento su <body> non interrompe le animazioni in corso. Non vengono rilevate nemmeno le modifiche alle classi che fanno sì che un elemento corrisponda per la prima volta a un selettore globale: in tal caso, chiamate refresh().

Glaze cerca per impostazione predefinita nell’intero document. Passate element per animare solo gli elementi all’interno di un contenitore:

JavaScript
glaze({
  lib: { gsap: { core: gsap } },
  element: document.querySelector("#app"),
})

element accetta un Element o un Document. Limita tre aspetti:

  • Solo la radice e i suoi discendenti vengono analizzati alla ricerca di utility di animazione. Gli elementi altrove nella pagina vengono ignorati, anche se contengono data-animate.
  • La modalità watch osserva solo le modifiche all’interno della radice.
  • destroy() rimuove solo ciò che ha creato questa istanza, così le animazioni delle altre parti della pagina restano intatte.

Questo rende element l’opzione ideale per i framework a componenti. Create un’istanza per ogni componente montato, usando l’elemento radice del componente, e chiamate destroy() quando viene smontato, come mostrato in Aggiornamento e pulizia. Assegnate alle istanze radici separate che non si sovrappongono: un elemento all’interno di due radici viene animato da entrambe le istanze.

Selezionare altri elementi

Le opzioni precedenti determinano quali elementi legge Glaze. Un selettore tra parentesi quadre all’inizio di un segmento determina a quali elementi viene applicata l’animazione. In sua assenza, l’animazione ha come destinazione l’elemento che contiene le utility.

Selettori relativi

Un selettore che inizia con & viene risolto a partire dall’elemento stesso, rappresentato da &. Viene interrogato con querySelectorAll, quindi può corrispondere a più elementi:

HTML
<ul data-animate="[&>li]:from:opacity-0|y-20|stagger-0.1">
  <li>One</li>
  <li>Two</li>
  <li>Three</li>
</ul>

[&>li] corrisponde agli elementi li figli diretti. Il valore stagger distanzia gli orari di inizio di 0.1 secondi. Usatelo quando un elemento deve controllare l’animazione di un elenco, una griglia o un gruppo di elementi figli senza aggiungere un attributo a ciascuno di essi.

Scrivete gli spazi come trattini bassi. [&_p] diventa & p e corrisponde a ogni p all’interno dell’elemento, a qualsiasi profondità:

HTML
<article data-animate="[&_p]:from:opacity-0|stagger-0.2">
  <p>First paragraph</p>
  <div><p>Nested paragraph</p></div>
</article>

Ogni trattino basso in un selettore viene convertito in uno spazio, quindi non è possibile trovare in questo modo un nome di classe che contiene un trattino basso.

[&] da solo si risolve nell’elemento stesso. Si usa soprattutto come valore, ad esempio scrollTrigger.trigger-[&] in ScrollTrigger e nelle impostazioni predefinite della timeline.

Selettori globali

Un selettore senza & viene passato come stringa al motore di animazione. GSAP e Motion lo risolvono sull’intero documento, non sull’elemento o sulla radice element:

HTML
<h2 data-animate="[.badge]:from:opacity-0|scale-0.5|duration-0.3">Inbox</h2>
<span class="badge">3</span>

Questo anima ogni .badge nella pagina, ovunque si trovi. Nei componenti riutilizzabili, preferite i selettori relativi, perché un selettore globale corrisponde anche alle copie del componente presenti altrove nella pagina.

Limiti

Ogni elemento ha una sola destinazione. Quando più segmenti contengono un selettore, l’ultimo si applica a tutti gli stati dell’elemento. Qui sia from sia to vengono applicati a p, non a h1:

HTML
<div data-animate="[&>h1]:from:opacity-0 [&>p]:to:x-20">
  <h1>Title</h1>
  <p>Text</p>
</div>

Per animare due gruppi in modo diverso, applicate le utility direttamente agli elementi figli oppure raggruppateli in una timeline.

Un selettore termina alla prima ], quindi i selettori che contengono parentesi quadre, come i selettori di attributo [&>[data-item]], non sono supportati. Usate invece un selettore di classe o di elemento.

I selettori si combinano con i breakpoint nell’ordine descritto in Sintassi, ad esempio @lg:[&>div]:from:opacity-0.