Oltre le espressioni regolari: miglioramento dell'analisi del valore CSS in Chrome DevTools

Philip Pfaffe
Ergün Erdogmus
Ergün Erdogmus

Hai notato che di recente le proprietà CSS nella scheda Stili di Chrome DevTools hanno un aspetto un po' più rifinito? Questi aggiornamenti, implementati tra Chrome 121 e 128, sono il risultato di un miglioramento significativo del modo in cui analizziamo e presentiamo i valori CSS. In questo articolo, ti illustreremo i dettagli tecnici di questa trasformazione, ovvero il passaggio da un sistema di corrispondenza delle espressioni regolari a un parser più efficace.

Confrontiamo gli attuali DevTools con la versione precedente:

In alto: l'ultima versione di Chrome, in basso: Chrome 121.

Una differenza sostanziale, non trovi? Ecco una panoramica dei miglioramenti principali:

  • color-mix: un'anteprima utile che rappresenta visivamente i due argomenti di colore all'interno della funzione color-mix.
  • pink. Un'anteprima colore cliccabile per il colore denominato pink. Fai clic per aprire un selettore colori per apportare facilmente modifiche.
  • var(--undefined, [fallback value]). Gestione migliorata delle variabili non definite, con la variabile non definita disattivata e il valore di riserva attivo (in questo caso, un colore HSL) visualizzato con un'anteprima del colore selezionabile.
  • hsl(…): un'altra anteprima del colore cliccabile per la funzione colore hsl, che fornisce un accesso rapido al selettore colori.
  • 177deg: un orologio angolare cliccabile che ti consente di trascinare e modificare in modo interattivo il valore dell'angolo.
  • var(--saturation, …): un link cliccabile alla definizione della proprietà personalizzata, che consente di passare facilmente alla dichiarazione pertinente.

La differenza è sorprendente. Per raggiungere questo obiettivo, abbiamo dovuto insegnare a DevTools a comprendere i valori delle proprietà CSS molto meglio di prima.

Queste anteprime non erano già disponibili?

Anche se queste icone di anteprima possono sembrare familiari, non sono sempre state visualizzate in modo coerente, soprattutto nella sintassi CSS complessa come nell'esempio precedente. Anche nei casi in cui funzionavano, spesso era necessario un notevole sforzo per farli funzionare correttamente.

Il motivo è che il sistema per l'analisi dei valori è cresciuto in modo organico sin dai primi giorni di DevTools. Tuttavia, non è stato in grado di stare al passo con le recenti e straordinarie nuove funzionalità che stiamo ottenendo da CSS e con il corrispondente aumento della complessità del linguaggio. Il sistema richiedeva una riprogettazione completa per stare al passo con l'evoluzione ed è esattamente ciò che abbiamo fatto.

Come vengono elaborati i valori delle proprietà CSS

In DevTools, il processo di rendering e decorazione delle dichiarazioni delle proprietà nella scheda Stili è suddiviso in due fasi distinte:

  1. Analisi strutturale. Questa fase iniziale analizza la dichiarazione della proprietà per identificare i componenti sottostanti e le loro relazioni. Ad esempio, nella dichiarazione border: 1px solid red, riconoscerà 1px come lunghezza, solid come stringa e red come colore.
  2. Rendering. Sulla base dell'analisi strutturale, la fase di rendering trasforma questi componenti in una rappresentazione HTML. In questo modo, il testo della proprietà visualizzato viene arricchito con elementi interattivi e indicatori visivi. Ad esempio, il valore del colore red viene visualizzato con un'icona del colore cliccabile che, se selezionata, mostra un selettore colori per una facile modifica.

Espressioni regolari

In precedenza, ci affidavamo alle espressioni regolari (regex) per analizzare i valori delle proprietà per l'analisi strutturale. Abbiamo mantenuto un elenco di espressioni regolari per trovare i bit dei valori delle proprietà che abbiamo preso in considerazione per la decorazione. Ad esempio, erano presenti espressioni che corrispondevano a colori, lunghezze e angoli CSS, sottoespressioni più complicate come le chiamate di funzione var e così via. Abbiamo scansionato il testo da sinistra a destra per eseguire l'analisi dei valori, cercando continuamente la prima espressione dell'elenco che corrisponde alla parte successiva del testo.

Sebbene questo metodo funzionasse bene nella maggior parte dei casi, il numero di casi in cui non funzionava continuava a crescere. Nel corso degli anni abbiamo ricevuto un buon numero di segnalazioni di bug in cui la corrispondenza non era del tutto corretta. Mentre li correggevamo, con correzioni semplici o piuttosto elaborate, abbiamo dovuto ripensare il nostro approccio per tenere sotto controllo il nostro debito tecnico. Diamo un'occhiata ad alcuni dei problemi.

Corrispondente a color-mix()

L'espressione regolare che abbiamo utilizzato per la funzione color-mix() era la seguente:

/color-mix\(.*,\s*(?<firstColor>.+)\s*,\s*(?<secondColor>.+)\s*\)/g

La sintassi è la seguente:

color-mix(<color-interpolation-method>, [<color> && <percentage [0,100]>?]#{2})

Prova a eseguire l'esempio seguente per visualizzare le corrispondenze.

const re = /color-mix\(.*,\s*(?<firstColor>.+)\s*,\s*(?<secondColor>.+)\s*\)/g;

// it works - simpler example
const simpler = re.exec('color-mix(in srgb, pink, hsl(127deg 100% 50%))');
console.table(simpler.groups);

re.exec('');

// it doesn't work - complex example
const complex = re.exec('color-mix(in srgb, pink, var(--undefined, hsl(127deg var(--saturation, 100%) 50%)))');
console.table(complex.groups);

Risultato corrispondente per la funzione color-mix.

L'esempio più semplice funziona correttamente. Tuttavia, nell'esempio più complesso, la corrispondenza di <firstColor> è hsl(177deg var(--saturation e quella di <secondColor> è 100%) 50%)), il che è del tutto privo di significato.

Sapevamo che questo era un problema. Dopotutto, il CSS come linguaggio formale non è regolare, quindi abbiamo già incluso una gestione speciale per gestire argomenti di funzioni più complicati, come le funzioni var. Tuttavia, come puoi vedere nel primo screenshot, questo non funzionava ancora in tutti i casi.

Corrispondente a tan()

Uno dei bug più divertenti segnalati riguardava la funzione trigonometrica tan(). L'espressione regolare che utilizzavamo per trovare i colori corrispondenti includeva una sottoespressione \b[a-zA-Z]+\b(?!-) per trovare i colori con nome corrispondenti, ad esempio la parola chiave red. Poi abbiamo controllato se la parte corrispondente è effettivamente un colore con nome e, indovina un po', anche tan è un colore con nome. Pertanto, abbiamo interpretato erroneamente tan() espressioni come colori.

Corrispondente a var()

Diamo un'occhiata a un altro esempio, le funzioni var() con un valore di riserva contenente altri riferimenti var(): var(--non-existent, var(--margin-vertical)).

La nostra espressione regolare per var() corrisponderebbe perfettamente a questo valore. Tuttavia, la corrispondenza si interromperebbe alla prima parentesi di chiusura. Pertanto, il testo precedente viene abbinato come var(--non-existent, var(--margin-vertical). Si tratta di una limitazione classica della corrispondenza delle espressioni regolari. I linguaggi che richiedono la corrispondenza delle parentesi non sono fondamentalmente regolari.

Passaggio a un parser CSS

Quando l'analisi del testo che utilizza espressioni regolari smette di funzionare (perché la lingua analizzata non è regolare), il passaggio successivo canonico è utilizzare un parser per una grammatica di tipo superiore. Per CSS, ciò significa un parser per linguaggi non contestuali. In effetti, un sistema di parser di questo tipo esisteva già nel codebase di DevTools: Lezer di CodeMirror, che è alla base, ad esempio, dell'evidenziazione della sintassi in CodeMirror, l'editor che trovi nel riquadro Origini. Il parser CSS di Lezer ci ha permesso di produrre alberi di sintassi (non astratti) per le regole CSS ed era pronto per l'uso. Vittoria.

Un albero della sintassi per il valore della proprietà &quot;hsl(177deg var(--saturation, 100%) 50%)&quot;. Si tratta di una versione semplificata del risultato prodotto dal parser Lezer, che omette i nodi puramente sintattici per virgole e parentesi.

Tuttavia, abbiamo scoperto che non è possibile eseguire la migrazione diretta dalla corrispondenza basata su espressioni regolari alla corrispondenza basata su parser: i due approcci funzionano in direzioni opposte. Quando si abbinano parti di valori con espressioni regolari, DevTools analizza l'input da sinistra a destra, cercando ripetutamente di trovare la prima corrispondenza da un elenco ordinato di pattern. Con un albero della sintassi, la corrispondenza inizia dal basso verso l'alto, ad esempio analizzando prima gli argomenti di una chiamata, prima di provare a trovare una corrispondenza con la chiamata di funzione. Immagina di valutare un'espressione aritmetica, in cui consideri prima le espressioni tra parentesi, poi gli operatori di moltiplicazione e infine gli operatori di addizione. In questo contesto, la corrispondenza basata su regex equivale alla valutazione dell'espressione aritmetica da sinistra a destra. Non volevamo davvero riscrivere l'intero sistema di corrispondenza da zero: c'erano 15 diverse coppie di matcher e renderer, con migliaia di righe di codice, il che rendeva improbabile che potessimo rilasciarlo in un'unica milestone.

Abbiamo quindi trovato una soluzione che ci ha permesso di apportare modifiche incrementali, che descriveremo di seguito in maggiore dettaglio. In breve, abbiamo mantenuto l'approccio in due fasi, ma nella prima fase cerchiamo di trovare corrispondenze per le sottoespressioni dal basso verso l'alto (interrompendo così il flusso delle espressioni regolari), mentre nella seconda fase eseguiamo il rendering dall'alto verso il basso. In entrambe le fasi, abbiamo potuto utilizzare i matcher e i renderer basati su espressioni regolari esistenti, praticamente invariati, e siamo stati quindi in grado di eseguirne la migrazione uno alla volta.

Fase 1: corrispondenza bottom-up

La prima fase fa più o meno esattamente ed esclusivamente ciò che dice il nome. Attraversiamo l'albero in ordine dal basso verso l'alto e proviamo a trovare corrispondenze per le sottoespressioni in ogni nodo dell'albero della sintassi che visitiamo. Per trovare una corrispondenza con una sottoespressione specifica, un matcher potrebbe utilizzare l'espressione regolare proprio come faceva nel sistema esistente. A partire dalla versione 128, in realtà lo facciamo ancora in alcuni casi, ad esempio per le lunghezze corrispondenti. In alternativa, un matcher può analizzare la struttura del sottoalbero con radice nel nodo corrente. In questo modo, può rilevare errori di sintassi e registrare informazioni strutturali contemporaneamente.

Considera l'esempio di albero di sintassi riportato sopra:

Fase 1: corrispondenza bottom-up nell'albero della sintassi.

Per questo albero, i nostri matcher verrebbero applicati nel seguente ordine:

  1. hsl(177degvar(--saturation, 100%) 50%): per prima cosa, scopriamo il primo argomento della chiamata di funzione hsl, l'angolo della tonalità. Lo abbiniamo a un matcher di angoli, in modo da poter decorare il valore dell'angolo con l'icona dell'angolo.
  2. hsl(177degvar(--saturation, 100%)50%): in secondo luogo, scopriamo la chiamata di funzione var con un matcher var. Per queste chiamate, vogliamo principalmente fare due cose:
    • Cerca la dichiarazione della variabile e calcola il suo valore, quindi aggiungi un link e un popover al nome della variabile per collegarli, rispettivamente.
    • Decorare la chiamata con un'icona colorata se il valore calcolato è un colore. In realtà c'è una terza cosa, ma ne parleremo più avanti.
  3. hsl(177deg var(--saturation, 100%) 50%): infine, abbiniamo l'espressione di chiamata per la funzione hsl, in modo da poterla decorare con l'icona del colore.

Oltre a cercare le sottoespressioni che vogliamo decorare, esiste una seconda funzionalità che eseguiamo nell'ambito del processo di corrispondenza. Tieni presente che nel passaggio 2 abbiamo detto che cerchiamo il valore calcolato per un nome di variabile. In effetti, facciamo un ulteriore passo avanti e propaghiamo i risultati verso l'alto nell'albero. E non solo per la variabile, ma anche per il valore di riserva. È garantito che, quando si visita un nodo della funzione var, i relativi elementi secondari siano stati visitati in precedenza, quindi conosciamo già i risultati di tutte le funzioni var che potrebbero essere visualizzate nel valore di riserva. Pertanto, siamo in grado di sostituire facilmente ed economicamente le funzioni var con i relativi risultati al volo, il che ci consente di rispondere facilmente a domande come "Il risultato di questa chiamata var è un colore?", come abbiamo fatto nel passaggio 2.

Fase 2: rendering dall'alto verso il basso

Per la seconda fase, invertiamo la direzione. Prendendo i risultati della corrispondenza della fase 1, eseguiamo il rendering dell'albero in HTML attraversandolo in ordine dall'alto verso il basso. Per ogni nodo visitato, controlliamo se corrisponde e, in caso affermativo, chiamiamo il renderer corrispondente del matcher. Evitiamo la necessità di una gestione speciale per i nodi che contengono solo testo (come NumberLiteral "50%") includendo un matcher e un renderer predefiniti per i nodi di testo. I renderer generano semplicemente nodi HTML che, una volta messi insieme, producono la rappresentazione del valore della proprietà, incluse le relative decorazioni.

Fase 2: rendering dall'alto verso il basso nell'albero della sintassi.

Per l'albero di esempio, ecco l'ordine in cui viene visualizzato il valore della proprietà:

  1. Visita la chiamata di funzione hsl. La corrispondenza è stata trovata, quindi chiama il renderer della funzione di colore. Con un duplice effetto:
    • Calcola il valore effettivo del colore utilizzando il meccanismo di sostituzione immediata per tutti gli argomenti var, quindi disegna un'icona del colore.
    • Esegue il rendering ricorsivo degli elementi secondari di CallExpression. In questo modo, il nome della funzione, le parentesi e le virgole, che sono solo testo, vengono visualizzati automaticamente.
  2. Visita il primo argomento della chiamata hsl. La corrispondenza è stata trovata, quindi chiama il renderer dell'angolo, che disegna l'icona dell'angolo e il testo dell'angolo.
  3. Visita il secondo argomento, ovvero la chiamata var. La corrispondenza è stata trovata, quindi chiama la variabile renderer, che restituisce il seguente output:
    • Il testo var( all'inizio.
    • Il nome della variabile e lo decora con un link alla definizione della variabile o con un colore del testo grigio per indicare che non è stata definita. Aggiunge anche un popover alla variabile per mostrare informazioni sul suo valore.
    • La virgola e poi esegue il rendering ricorsivo del valore di riserva.
    • Una parentesi chiusa.
  4. Visita l'ultimo argomento della chiamata hsl. Non corrisponde, quindi restituisci semplicemente i contenuti testuali.

Hai notato che in questo algoritmo un render controlla completamente il modo in cui vengono visualizzati i nodi secondari di un nodo corrispondente? Il rendering ricorsivo degli elementi secondari è proattivo. Questo trucco ha consentito una migrazione graduale dal rendering basato su espressioni regolari al rendering basato su albero della sintassi. Per i nodi corrispondenti a un matcher regex precedente, il renderer corrispondente potrebbe essere utilizzato nella sua forma originale. In termini di albero della sintassi, si assumerebbe la responsabilità di eseguire il rendering dell'intero sottoalbero e il suo risultato (un nodo HTML) potrebbe essere inserito in modo pulito nel processo di rendering circostante. In questo modo abbiamo avuto la possibilità di trasferire matcher e renderer in coppia e di scambiarli uno alla volta.

Un'altra caratteristica interessante dei renderer che controllano il rendering dei nodi secondari del nodo corrispondente è che ci consente di ragionare sulle dipendenze tra le icone che stiamo aggiungendo. Nell'esempio precedente, il colore prodotto dalla funzione hsl dipende ovviamente dal valore della tonalità. Ciò significa che il colore mostrato dall'icona del colore dipende dall'angolo mostrato dall'icona dell'angolo. Se l'utente apre l'editor dell'angolo tramite l'icona e modifica l'angolo, ora possiamo aggiornare il colore dell'icona del colore in tempo reale:

Come puoi vedere nell'esempio precedente, utilizziamo questo meccanismo anche per altri accoppiamenti di icone, ad esempio per color-mix() e i suoi due canali di colore o per le funzioni var che restituiscono un colore dal relativo colore di riserva.

Impatto sulle prestazioni

Quando abbiamo affrontato questo problema per migliorare l'affidabilità e risolvere problemi di lunga data, ci aspettavamo una regressione delle prestazioni, considerando che abbiamo iniziato a eseguire un parser completo. Per testare questa funzionalità, abbiamo creato un benchmark che esegue il rendering di circa 3500 dichiarazioni di proprietà e abbiamo profilato le versioni basate su espressioni regolari e su parser con una limitazione di 6x su una macchina M1.

Come previsto, l'approccio basato sull'analisi è risultato più lento del 27% rispetto all'approccio basato su regex in questo caso. L'approccio basato su espressioni regolari ha richiesto 11 secondi per il rendering, mentre l'approccio basato su parser ha richiesto 15 secondi.

Considerando i vantaggi che otteniamo con il nuovo approccio, abbiamo deciso di adottarlo.

Ringraziamenti

La nostra più profonda gratitudine va a Sofia Emelianova e Jecelyn Yeen per il loro prezioso aiuto nella modifica di questo post.

Scarica i canali in anteprima

Valuta la possibilità di utilizzare Chrome Canary, Dev o Beta come browser di sviluppo predefinito. Questi canali di anteprima ti consentono di accedere alle funzionalità più recenti di DevTools, di testare le API della piattaforma web all'avanguardia e di trovare i problemi sul tuo sito prima che lo facciano gli utenti.

Contatta il team di Chrome DevTools

Utilizza le seguenti opzioni per discutere di nuove funzionalità, aggiornamenti o qualsiasi altro argomento relativo a DevTools.