Hands-on with Portals: Seamless navigation on the web

Scopri come l'API Portals proposta può migliorare la UX di navigazione.

Yusuke Utsunomiya
Yusuke Utsunomiya

Assicurarti che le pagine vengano caricate rapidamente è fondamentale per offrire un'esperienza utente ottimale. Tuttavia, un'area che spesso trascuriamo sono le transizioni di pagina, ovvero ciò che gli utenti vedono quando si spostano tra le pagine.

Una nuova proposta di API della piattaforma web chiamata Portals mira a risolvere questo problema semplificando l'esperienza di navigazione degli utenti all'interno del tuo sito.

Guarda i portali in azione:

Incorporamenti e navigazione senza interruzioni con Portals. Creato da Adam Argyle.

Cosa consentono i portali

Le applicazioni a pagina singola (SPA) offrono transizioni piacevoli, ma sono più complesse da creare. Le applicazioni multipagina (MPA) sono molto più facili da creare, ma si ottengono schermate vuote tra le pagine.

I portali offrono il meglio di entrambi i mondi: la bassa complessità di un'MPA con le transizioni fluide di un'SPA. Sono simili a un <iframe> in quanto consentono l'incorporamento, ma a differenza di un <iframe>, offrono anche funzionalità per navigare verso i contenuti.

Vedere per credere: dai un'occhiata a ciò che abbiamo presentato al Chrome Dev Summit 2018:

Con le navigazioni classiche, gli utenti devono attendere con una schermata vuota finché il browser non termina il rendering della destinazione. Con Portals, gli utenti possono visualizzare un'animazione, mentre <portal> esegue il prerendering dei contenuti e crea un'esperienza di navigazione fluida.

Prima di Portals, avremmo potuto eseguire il rendering di un'altra pagina utilizzando un <iframe>. Avremmo anche potuto aggiungere animazioni per spostare il frame nella pagina. Tuttavia, un <iframe> non ti consente di navigare nei suoi contenuti. I portali colmano questa lacuna, consentendo casi d'uso interessanti.

Prova Portali

Attivazione tramite about://flags

Prova Portals in Chrome 85 e versioni successive attivando un flag sperimentale:

  • Attiva il flag about://flags/#enable-portals per le navigazioni della stessa origine.
  • Per testare le navigazioni multiorigine, attiva anche il flag about://flags/#enable-portals-cross-origin.

Durante questa fase iniziale dell'esperimento sui portali, ti consigliamo anche di utilizzare una directory dei dati utente completamente separata per i test impostando il flag della riga di comando --user-data-dir. Una volta attivati i portali, verifica in DevTools di avere il nuovo HTMLPortalElement.

Uno screenshot della console DevTools che mostra l'elemento HTMLPortalElement

Implementa i portali

Vediamo un esempio di implementazione di base.

// Create a portal with the wikipedia page, and embed it
// (like an iframe). You can also use the <portal> tag instead.
portal = document.createElement('portal');
portal.src = 'https://en.wikipedia.org/wiki/World_Wide_Web';
portal.style = '...';
document.body.appendChild(portal);

// When the user touches the preview (embedded portal):
// do fancy animation, e.g. expand …
// and finish by doing the actual transition.
// For the sake of simplicity, this snippet will navigate
// on the `onload` event of the Portals element.
portal.addEventListener('load', (evt) => {
   portal.activate();
});

Niente di più semplice. Prova questo codice nella console DevTools. Dovrebbe aprirsi la pagina di Wikipedia.

Una GIF della demo dello stile del portale di anteprima

Se vuoi creare qualcosa di simile a quello che abbiamo mostrato al Chrome Dev Summit, che funziona esattamente come la demo precedente, lo snippet seguente ti interesserà.

// Adding some styles with transitions
const style = document.createElement('style');
style.innerHTML = `
  portal {
    position:fixed;
    width: 100%;
    height: 100%;
    opacity: 0;
    box-shadow: 0 0 20px 10px #999;
    transform: scale(0.4);
    transform-origin: bottom left;
    bottom: 20px;
    left: 20px;
    animation-name: fade-in;
    animation-duration: 1s;
    animation-delay: 2s;
    animation-fill-mode: forwards;
  }
  .portal-transition {
    transition: transform 0.4s;
  }
  @media (prefers-reduced-motion: reduce) {
    .portal-transition {
      transition: transform 0.001s;
    }
  }
  .portal-reveal {
    transform: scale(1.0) translateX(-20px) translateY(20px);
  }
  @keyframes fade-in {
    0%   { opacity: 0; }
    100% { opacity: 1; }
  }
`;
const portal = document.createElement('portal');
// Let's navigate into the WICG Portals spec page
portal.src = 'https://wicg.github.io/portals/';
// Add a class that defines the transition. Consider using
// `prefers-reduced-motion` media query to control the animation.
// https://developers.google.com/web/updates/2019/03/prefers-reduced-motion
portal.classList.add('portal-transition');
portal.addEventListener('click', (evt) => {
  // Animate the portal once user interacts
  portal.classList.add('portal-reveal');
});
portal.addEventListener('transitionend', (evt) => {
  if (evt.propertyName == 'transform') {
    // Activate the portal once the transition has completed
    portal.activate();
  }
});
document.body.append(style, portal);

È anche facile eseguire il rilevamento delle funzionalità per applicare il potenziamento progressivo a un sito web utilizzando Portals.

if ('HTMLPortalElement' in window) {
  // If this is a platform that have Portals...
  const portal = document.createElement('portal');
  ...
}

La seguente demo mostra l'aspetto di Portals:

  1. Inserisci un URL di cui vuoi visualizzare l'anteprima.
  2. La pagina verrà quindi incorporata come elemento <portal>.
  3. Fai clic sull'anteprima.
  4. L'anteprima verrà attivata dopo un'animazione.

Una GIF che mostra l'utilizzo di una demo di Portals

Consulta la specifica

Stiamo discutendo attivamente della specifica Portals nel Web Incubation Community Group (WICG). Per iniziare rapidamente, dai un'occhiata ad alcuni degli scenari chiave. Ecco le tre funzionalità importanti con cui acquisire familiarità:

  • L'elemento <portal>: l'elemento HTML stesso. L'API è molto semplice. È costituito dall'attributo src, dalla funzione activate e da un'interfaccia per la messaggistica (postMessage). activate accetta un argomento facoltativo per passare i dati a <portal> al momento dell'attivazione.
  • L'interfaccia portalHost: aggiunge un oggetto portalHost all'oggetto window. In questo modo puoi verificare se la pagina è incorporata come elemento <portal>. Fornisce inoltre un'interfaccia per l'invio di messaggi (postMessage) all'host.
  • L'interfaccia PortalActivateEvent: un evento che viene attivato quando viene attivato <portal>. Esiste una funzione molto utile chiamata adoptPredecessor che puoi utilizzare per recuperare la pagina precedente come elemento <portal>. In questo modo, puoi creare navigazioni fluide ed esperienze composte tra due pagine.

Andiamo oltre il pattern di utilizzo di base. Ecco un elenco non esaustivo di ciò che puoi ottenere con Portals, insieme a un codice campione.

Personalizza lo stile quando viene incorporato come elemento <portal>

// Detect whether this page is hosted in a portal
if (window.portalHost) {
  // Customize the UI when being embedded as a portal
}

Messaggistica tra l'elemento <portal> e portalHost

// Send message to the portal element
const portal = document.querySelector('portal');
portal.postMessage({someKey: someValue}, ORIGIN);

// Receive message via window.portalHost
window.portalHost.addEventListener('message', (evt) => {
  const data = evt.data.someKey;
  // handle the event
});

Attivazione dell'elemento <portal> e ricezione dell'evento portalactivate

// You can optionally add data to the argument of the activate function
portal.activate({data: {somekey: 'somevalue'}});

// The portal content will receive the portalactivate event
// when the activate happens
window.addEventListener('portalactivate', (evt) => {
  // Data available as evt.data
  const data = evt.data;
});

Recupero del predecessore

// Listen to the portalactivate event
window.addEventListener('portalactivate', (evt) => {
  // ... and creatively use the predecessor
  const portal = evt.adoptPredecessor();
  document.querySelector('someElm').appendChild(portal);
});

Sapere che la tua pagina è stata adottata come predecessore

// The activate function returns a Promise.
// When the promise resolves, it means that the portal has been activated.
// If this document was adopted by it, then window.portalHost will exist.
portal.activate().then(() => {
  // Check if this document was adopted into a portal element.
  if (window.portalHost) {
    // You can start communicating with the portal element
    // i.e. listen to messages
    window.portalHost.addEventListener('message', (evt) => {
      // handle the event
    });
  }
});

Combinando tutte le funzionalità supportate da Portals, puoi creare esperienze utente davvero sofisticate. Ad esempio, la demo di seguito mostra come Portals può consentire un'esperienza utente fluida tra un sito web e contenuti incorporati di terze parti.

Casi d'uso e piani

Ci auguriamo che questo breve tour di Portals ti sia piaciuto. Non vediamo l'ora di scoprire cosa creerai. Ad esempio, potresti voler iniziare a utilizzare i portali per navigazioni non banali, come il prerendering della pagina del tuo prodotto più venduto da una pagina di elenco delle categorie di prodotti.

Un altro aspetto importante da sapere è che i portali possono essere utilizzati nelle navigazioni multiorigine, proprio come un <iframe>. Quindi, se hai più siti web che fanno riferimento l'uno all'altro, puoi anche utilizzare Portals per creare navigazioni senza interruzioni tra due siti web diversi. Questo caso d'uso multiorigine è molto specifico per Portals e può persino migliorare l'esperienza utente delle SPA.

I feedback sono ben accetti

I portali sono pronti per la sperimentazione in Chrome 85 e versioni successive. Il feedback della community è fondamentale per la progettazione di nuove API, quindi provale e facci sapere cosa ne pensi. Se hai richieste di funzionalità o feedback, visita il repository GitHub del WICG.