A partire da Chrome 120, è disponibile una nuova opzione unsanitized nell'API Async Clipboard. Questa opzione può essere utile in situazioni speciali con l'HTML, in cui devi incollare i contenuti degli appunti in modo identico a come erano quando sono stati copiati.
In altre parole, senza alcun passaggio di sanitizzazione intermedio che i browser applicano comunemente, e per buoni motivi. Scopri come utilizzarla in questa guida.
Quando lavorano con l'API Async Clipboard, nella maggior parte dei casi gli sviluppatori non devono preoccuparsi dell'integrità dei contenuti negli appunti e possono presumere che ciò che scrivono negli appunti (copia) sia lo stesso che otterranno quando leggono i dati dagli appunti (incolla).
Questo è sicuramente vero per il testo. Prova a incollare il seguente codice nella console di DevTools e poi attiva di nuovo immediatamente lo stato attivo sulla pagina. (setTimeout() è necessario per avere il tempo sufficiente per attivare la pagina, un requisito dell'API Async Clipboard). Come puoi vedere, l'input è esattamente lo stesso dell'output.
setTimeout(async () => {
const input = 'Hello';
await navigator.clipboard.writeText(input);
const output = await navigator.clipboard.readText();
console.log(input, output, input === output);
// Logs "Hello Hello true".
}, 3000);
Con le immagini, è un po' diverso. Per evitare i cosiddetti attacchi di compression bomb, i browser ricodificano le immagini come i PNG, ma le immagini di input e output sono visivamente esattamente le stesse, pixel per pixel.
setTimeout(async () => {
const dataURL =
'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVQYV2NgYAAAAAMAAWgmWQ0AAAAASUVORK5CYII=';
const input = await fetch(dataURL).then((response) => response.blob());
await navigator.clipboard.write([
new ClipboardItem({
[input.type]: input,
}),
]);
const [clipboardItem] = await navigator.clipboard.read();
const output = await clipboardItem.getType(input.type);
console.log(input.size, output.size, input.type === output.type);
// Logs "68 161 true".
}, 3000);
Cosa succede invece con il testo HTML? Come avrai intuito, con l'HTML la situazione è diversa. In questo caso, il browser esegue la sanificazione del codice HTML per evitare che si verifichino problemi, ad esempio rimuovendo i tag <script> dal codice HTML (e altri come <meta>, <head> e <style>) e incorporando il CSS.
Considera l'esempio seguente e provalo nella console di DevTools. Noterai che l'output è molto diverso dall'input.
setTimeout(async () => {
const input = `<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<meta name="ProgId" content="Excel.Sheet" />
<meta name="Generator" content="Microsoft Excel 15" />
<style>
body {
font-family: HK Grotesk;
background-color: var(--color-bg);
}
</style>
</head>
<body>
<div>hello</div>
</body>
</html>`;
const inputBlob = new Blob([input], { type: 'text/html' });
await navigator.clipboard.write([
new ClipboardItem({
'text/html': inputBlob,
}),
]);
const [clipboardItem] = await navigator.clipboard.read();
const outputBlob = await clipboardItem.getType('text/html');
const output = await outputBlob.text();
console.log(input, output);
}, 3000);
La sanitizzazione HTML è generalmente una buona cosa. Nella maggior parte dei casi, non vuoi esporti a problemi di sicurezza consentendo l'HTML non sanitizzato. Esistono scenari, tuttavia, in cui lo sviluppatore sa esattamente cosa sta facendo e in cui l'integrità dell'HTML di input e output è fondamentale per il corretto funzionamento dell'app. In queste circostanze, hai due opzioni:
- Se controlli sia la copia che l'incolla, ad esempio se copi dall'interno della tua app per poi incollare allo stesso modo all'interno della tua app, devi utilizzare i formati web personalizzati per l'API Async Clipboard. Interrompi la lettura qui e consulta l'articolo collegato.
- Se nella tua app controlli solo l'operazione di incolla, ma non quella di copia,
magari perché l'operazione di copia avviene in un'app nativa che non supporta
i formati web personalizzati, devi utilizzare l'opzione
unsanitized, che viene spiegata nel resto di questo articolo.
La sanitizzazione include la rimozione dei tag script, l'incorporamento degli stili e la verifica che l'HTML sia ben formato. Questo elenco non è esaustivo e in futuro potrebbero essere aggiunti altri passaggi.
Copia e incolla di codice HTML non sanitizzato
Quando write() (copi) il codice HTML negli appunti con l'API Async Clipboard, il browser si assicura che sia ben formato eseguendolo tramite un parser DOM e serializzando la stringa HTML risultante, ma in questo passaggio non viene eseguita alcuna sanitizzazione. Non devi fare nulla. Quando read() l'HTML inserito negli appunti da un'altra applicazione e la tua app web attiva la ricezione dei contenuti con fedeltà completa e deve eseguire la sanitizzazione nel tuo codice, puoi passare un oggetto opzioni al metodo read() con una proprietà unsanitized e un valore ['text/html']. In isolamento, l'aspetto è il seguente:
navigator.clipboard.read({ unsanitized: ['text/html'] }). Il seguente esempio di codice
è quasi identico a quello mostrato in precedenza, ma questa volta con l'opzione
unsanitized. Se provi a farlo nella console DevTools, vedrai che l'input e l'output sono gli stessi.
setTimeout(async () => {
const input = `<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<meta name="ProgId" content="Excel.Sheet" />
<meta name="Generator" content="Microsoft Excel 15" />
<style>
body {
font-family: HK Grotesk;
background-color: var(--color-bg);
}
</style>
</head>
<body>
<div>hello</div>
</body>
</html>`;
const inputBlob = new Blob([input], { type: 'text/html' });
await navigator.clipboard.write([
new ClipboardItem({
'text/html': inputBlob,
}),
]);
const [clipboardItem] = await navigator.clipboard.read({
unsanitized: ['text/html'],
});
const outputBlob = await clipboardItem.getType('text/html');
const output = await outputBlob.text();
console.log(input, output);
}, 3000);
Supporto del browser e rilevamento delle funzionalità
Non esiste un modo diretto per verificare se la funzionalità è supportata, pertanto il rilevamento della funzionalità si basa sull'osservazione del comportamento. Pertanto, l'esempio seguente si basa sul rilevamento del fatto che un tag <style> sopravviva, il che indica il supporto, o venga inserito in linea, il che indica il mancato supporto. Tieni presente che, affinché funzioni, la pagina deve aver già ottenuto l'autorizzazione per gli appunti.
const supportsUnsanitized = async () => {
const input = `<style>p{color:red}</style><p>a`;
const inputBlob = new Blob([input], { type: 'text/html' });
await navigator.clipboard.write([
new ClipboardItem({
'text/html': inputBlob,
}),
]);
const [clipboardItem] = await navigator.clipboard.read({
unsanitized: ['text/html'],
});
const outputBlob = await clipboardItem.getType('text/html');
const output = await outputBlob.text();
return /<style>/.test(output);
};
Demo
Per vedere l'opzione unsanitized in azione, guarda la demo e consulta il relativo codice sorgente.
Conclusioni
Come descritto nell'introduzione, la maggior parte degli sviluppatori non dovrà mai preoccuparsi della sanitizzazione degli appunti e potrà semplicemente utilizzare le scelte di sanitizzazione predefinite effettuate dal browser. Per i rari casi in cui gli sviluppatori devono prestare attenzione, esiste l'opzione unsanitized.
Link utili
Ringraziamenti
Questo articolo è stato rivisto da Anupam Snigdha e Rachel Andrew. L'API è stata specificata e implementata dal team di Microsoft Edge.