Toute technologie suffisamment avancée est indiscernable de la magie. Sauf si vous le comprenez. Je m'appelle Thomas Steiner et je travaille dans l'équipe Developer Relations chez Google. Dans ce compte-rendu de ma présentation lors de la conférence Google I/O, je vais examiner certaines des nouvelles API Fugu et la façon dont elles améliorent les principaux parcours utilisateur dans la PWA Excalidraw. Vous pourrez ainsi vous inspirer de ces idées et les appliquer à vos propres applications.
Comment j'ai découvert Excalidraw
Je voudrais commencer par une histoire. Le 1er janvier 2020, Christopher Chedeau, ingénieur logiciel chez Facebook, a tweeté à propos d'une petite application de dessin sur laquelle il avait commencé à travailler. Avec cet outil, vous pouvez dessiner des cadres et des flèches qui ressemblent à des dessins animés et à des dessins faits à la main. Le lendemain, vous pouviez également dessiner des ellipses et du texte, ainsi que sélectionner des objets et les déplacer. Le 3 janvier, l'application a été baptisée Excalidraw et, comme pour tout bon projet secondaire, l'achat du nom de domaine a été l'une des premières actions de Christopher. Vous pouvez maintenant utiliser des couleurs et exporter l'intégralité du dessin au format PNG.

Le 15 janvier, Christopher a publié un article de blog qui a attiré l'attention de nombreuses personnes sur Twitter, dont la mienne. Le post commençait par des statistiques impressionnantes :
- 12 000 utilisateurs actifs uniques
- 1 500 étoiles sur GitHub
- 26 contributeurs
Pour un projet qui a débuté il y a à peine deux semaines, ce n'est pas mal du tout. Mais ce qui a vraiment piqué ma curiosité se trouvait plus bas dans le post. Christopher a écrit qu'il avait essayé quelque chose de nouveau cette fois-ci : accorder un accès inconditionnel aux commits à tous ceux qui ont envoyé une demande d'extraction. Le jour même où j'ai lu l'article de blog, j'ai envoyé une demande d'extraction qui ajoutait la compatibilité avec l'API File System Access à Excalidraw, répondant ainsi à une demande de fonctionnalité qu'un utilisateur avait déposée.

Ma demande d'extraction a été fusionnée un jour plus tard et, à partir de ce moment-là, j'ai eu un accès complet aux commits. Inutile de dire que je n'ai pas abusé de mon pouvoir. Et aucun des 149 contributeurs n'a pu le faire jusqu'à présent.
Aujourd'hui, Excalidraw est une progressive web app installable à part entière, compatible avec le mode hors connexion, un mode sombre exceptionnel et, oui, la possibilité d'ouvrir et d'enregistrer des fichiers grâce à l'API File System Access.

Lipis explique pourquoi il consacre autant de temps à Excalidraw
Voilà qui conclut l'histoire de mon arrivée chez Excalidraw. Avant de vous présenter certaines des fonctionnalités incroyables d'Excalidraw, j'ai le plaisir de vous présenter Panayiotis. Panayiotis Lipiridis, simplement connu sur Internet sous le nom de lipis, est le contributeur le plus prolifique d'Excalidraw. J'ai demandé à lipis ce qui le motivait à consacrer autant de temps à Excalidraw :
Comme tout le monde, j'ai découvert ce projet grâce au tweet de Christopher. Ma première contribution a été d'ajouter la bibliothèque Open Color, les couleurs qui font encore partie d'Excalidraw aujourd'hui. À mesure que le projet s'est développé et que nous avons reçu de nombreuses demandes, ma contribution majeure suivante a été de créer un backend pour stocker les dessins afin que les utilisateurs puissent les partager. Mais ce qui me pousse vraiment à contribuer, c'est que tous ceux qui ont essayé Excalidraw cherchent des excuses pour l'utiliser à nouveau.
Je suis tout à fait d'accord avec lipis. Quiconque a essayé Excalidraw cherche des excuses pour l'utiliser à nouveau.
Excalidraw en action
Je vais maintenant vous montrer comment utiliser Excalidraw en pratique. Je ne suis pas un grand artiste, mais le logo Google I/O est assez simple, alors je vais essayer. Une boîte est le "i", une ligne peut être la barre oblique et le "o" est un cercle. Je maintiens la touche Maj enfoncée pour obtenir un cercle parfait. Je vais déplacer un peu la barre oblique pour que ce soit plus joli. Ajoutons maintenant de la couleur au "i" et au "o". Le bleu, c'est bien. Peut-être un autre style de remplissage ? Tout solide ou hachuré ? Non, les hachures sont très bien. Ce n'est pas parfait, mais c'est le principe d'Excalidraw. Je vais l'enregistrer.
Je clique sur l'icône d'enregistrement et je saisis un nom de fichier dans la boîte de dialogue d'enregistrement. Dans Chrome, un navigateur compatible avec l'API File System Access, il ne s'agit pas d'un téléchargement, mais d'une véritable opération d'enregistrement. Je peux choisir l'emplacement et le nom du fichier, et si j'apporte des modifications, je peux simplement les enregistrer dans le même fichier.
Je vais modifier le logo et mettre le "i" en rouge. Si je clique à nouveau sur "Enregistrer", ma modification est enregistrée dans le même fichier qu'auparavant. Pour vous le prouver, je vais effacer le canevas et rouvrir le fichier. Comme vous pouvez le voir, le logo rouge et bleu modifié est de nouveau présent.
Utiliser des fichiers
Sur les navigateurs qui ne sont pas compatibles avec l'API File System Access, chaque opération d'enregistrement est un téléchargement. Par conséquent, lorsque j'apporte des modifications, je me retrouve avec plusieurs fichiers dont le nom comporte un numéro incrémenté, ce qui remplit mon dossier "Téléchargements". Mais malgré cet inconvénient, je peux toujours enregistrer le fichier.
Ouverture des fichiers…
Quel est le secret ? Comment l'ouverture et l'enregistrement peuvent-ils fonctionner sur différents navigateurs qui peuvent ou non être compatibles avec l'API File System Access ? L'ouverture d'un fichier dans Excalidraw s'effectue dans une fonction appelée loadFromJSON)(, qui appelle à son tour une fonction appelée fileOpen().
export const loadFromJSON = async (localAppState: AppState) => {
const blob = await fileOpen({
description: 'Excalidraw files',
extensions: ['.json', '.excalidraw', '.png', '.svg'],
mimeTypes: ['application/json', 'image/png', 'image/svg+xml'],
});
return loadFromBlob(blob, localAppState);
};
La fonction fileOpen() provient d'une petite bibliothèque que j'ai écrite, appelée browser-fs-access, que nous utilisons dans Excalidraw. Cette bibliothèque permet d'accéder au système de fichiers via l'API File System Access avec une solution de remplacement, ce qui permet de l'utiliser dans n'importe quel navigateur.
Je vais d'abord vous montrer l'implémentation lorsque l'API est compatible. Après avoir négocié les types MIME et les extensions de fichier acceptés, l'élément central appelle la fonction showOpenFilePicker() de l'API File System Access. Cette fonction renvoie un tableau de fichiers ou un seul fichier, selon que plusieurs fichiers sont sélectionnés ou non. Il ne reste plus qu'à placer le handle de fichier sur l'objet de fichier pour qu'il puisse être récupéré à nouveau.
export default async (options = {}) => {
const accept = {};
// Not shown: deal with extensions and MIME types.
const handleOrHandles = await window.showOpenFilePicker({
types: [
{
description: options.description || '',
accept: accept,
},
],
multiple: options.multiple || false,
});
const files = await Promise.all(handleOrHandles.map(getFileWithHandle));
if (options.multiple) return files;
return files[0];
const getFileWithHandle = async (handle) => {
const file = await handle.getFile();
file.handle = handle;
return file;
};
};
L'implémentation de remplacement repose sur un élément input de type "file". Après avoir négocié les types MIME et les extensions à accepter, l'étape suivante consiste à cliquer par programmation sur l'élément d'entrée pour afficher la boîte de dialogue d'ouverture de fichier. En cas de modification, c'est-à-dire lorsque l'utilisateur a sélectionné un ou plusieurs fichiers, la promesse est résolue.
export default async (options = {}) => {
return new Promise((resolve) => {
const input = document.createElement('input');
input.type = 'file';
const accept = [
...(options.mimeTypes ? options.mimeTypes : []),
options.extensions ? options.extensions : [],
].join();
input.multiple = options.multiple || false;
input.accept = accept || '*/*';
input.addEventListener('change', () => {
resolve(input.multiple ? Array.from(input.files) : input.files[0]);
});
input.click();
});
};
Enregistrement des fichiers…
Passons maintenant à l'enregistrement. Dans Excalidraw, l'enregistrement s'effectue dans une fonction appelée saveAsJSON(). Il sérialise d'abord le tableau d'éléments Excalidraw au format JSON, convertit le JSON en blob, puis appelle une fonction nommée fileSave(). Cette fonction est également fournie par la bibliothèque browser-fs-access.
export const saveAsJSON = async (
elements: readonly ExcalidrawElement[],
appState: AppState,
) => {
const serialized = serializeAsJSON(elements, appState);
const blob = new Blob([serialized], {
type: 'application/vnd.excalidraw+json',
});
const fileHandle = await fileSave(
blob,
{
fileName: appState.name,
description: 'Excalidraw file',
extensions: ['.excalidraw'],
},
appState.fileHandle,
);
return { fileHandle };
};
Voyons d'abord l'implémentation pour les navigateurs compatibles avec l'API File System Access. Les premières lignes semblent un peu complexes, mais elles ne font que négocier les types MIME et les extensions de fichier. Si j'ai déjà enregistré un fichier et que je dispose déjà d'un handle de fichier, aucune boîte de dialogue d'enregistrement ne doit s'afficher. S'il s'agit du premier enregistrement, une boîte de dialogue de fichier s'affiche et l'application récupère un handle de fichier pour une utilisation ultérieure. Le reste consiste simplement à écrire dans le fichier, ce qui se fait via un flux accessible en écriture.
export default async (blob, options = {}, handle = null) => {
options.fileName = options.fileName || 'Untitled';
const accept = {};
// Not shown: deal with extensions and MIME types.
handle =
handle ||
(await window.showSaveFilePicker({
suggestedName: options.fileName,
types: [
{
description: options.description || '',
accept: accept,
},
],
}));
const writable = await handle.createWritable();
await writable.write(blob);
await writable.close();
return handle;
};
La fonctionnalité "Enregistrer sous"
Si je décide d'ignorer un handle de fichier existant, je peux implémenter une fonctionnalité "Enregistrer sous" pour créer un fichier basé sur un fichier existant. Pour vous montrer cela, je vais ouvrir un fichier existant, y apporter quelques modifications, puis, au lieu d'écraser le fichier existant, je vais créer un fichier à l'aide de la fonctionnalité "Enregistrer sous". Le fichier d'origine reste intact.
L'implémentation pour les navigateurs qui ne sont pas compatibles avec l'API File System Access est courte, car elle ne fait que créer un élément d'ancrage avec un attribut download dont la valeur est le nom de fichier souhaité et une URL de blob comme valeur d'attribut href.
export default async (blob, options = {}) => {
const a = document.createElement('a');
a.download = options.fileName || 'Untitled';
a.href = URL.createObjectURL(blob);
a.addEventListener('click', () => {
setTimeout(() => URL.revokeObjectURL(a.href), 30 * 1000);
});
a.click();
};
L'élément d'ancrage est ensuite cliqué de manière programmatique. Pour éviter les fuites de mémoire, l'URL du blob doit être révoquée après utilisation. Comme il s'agit d'un simple téléchargement, aucune boîte de dialogue d'enregistrement de fichier ne s'affiche, et tous les fichiers sont placés dans le dossier Downloads par défaut.
Glisser-déposer
L'une de mes intégrations système préférées sur ordinateur est le glisser-déposer. Dans Excalidraw, lorsque je dépose un fichier .excalidraw dans l'application, il s'ouvre immédiatement et je peux commencer à le modifier. Sur les navigateurs compatibles avec l'API File System Access, je peux même enregistrer immédiatement mes modifications. Il n'est pas nécessaire de passer par une boîte de dialogue d'enregistrement de fichier, car le handle de fichier requis a été obtenu à partir de l'opération de glisser-déposer.
Pour ce faire, il suffit d'appeler getAsFileSystemHandle() sur l'élément de transfert de données lorsque l'API File System Access est compatible. Je transmets ensuite ce handle de fichier à loadFromBlob(), que vous avez peut-être vu quelques paragraphes plus haut. Vous pouvez faire tellement de choses avec les fichiers : les ouvrir, les enregistrer, les écraser, les faire glisser, les déposer. Mon collègue Pete et moi avons documenté toutes ces astuces et bien d'autres dans notre article pour que vous puissiez vous rattraper si tout cela est allé un peu trop vite.
const file = event.dataTransfer?.files[0];
if (file?.type === 'application/json' || file?.name.endsWith('.excalidraw')) {
this.setState({ isLoading: true });
// Provided by browser-fs-access.
if (supported) {
try {
const item = event.dataTransfer.items[0];
file as any.handle = await item as any
.getAsFileSystemHandle();
} catch (error) {
console.warn(error.name, error.message);
}
}
loadFromBlob(file, this.state).then(({ elements, appState }) =>
// Load from blob
).catch((error) => {
this.setState({ isLoading: false, errorMessage: error.message });
});
}
Partager des fichiers
Une autre intégration système actuellement disponible sur Android, ChromeOS et Windows est l'API Web Share Target. Je me trouve dans l'application Fichiers, dans mon dossier Downloads. Je vois deux fichiers, dont l'un porte le nom non descriptif untitled et un code temporel. Pour vérifier ce qu'il contient, je clique sur les trois points, puis sur "Partager". L'une des options qui s'affiche est Excalidraw. Lorsque j'appuie sur l'icône, je vois que le fichier ne contient que le logo I/O.
Lipis sur la version obsolète d'Electron
Il y a une chose que vous pouvez faire avec les fichiers et dont je n'ai pas encore parlé : double-cliquer dessus. En général, lorsque vous double-cliquez sur un fichier, l'application associée au type MIME du fichier s'ouvre. Par exemple, pour .docx, il s'agirait de Microsoft Word.
Excalidraw proposait une version Electron de l'application qui prenait en charge ces associations de types de fichiers. Ainsi, lorsque vous double-cliquiez sur un fichier .excalidraw, l'application Excalidraw Electron s'ouvrait. Lipis, que vous avez déjà rencontré, est à la fois le créateur et le dépréciateur d'Excalidraw Electron. Je lui ai demandé pourquoi il pensait qu'il était possible d'abandonner la version Electron :
Les utilisateurs demandent une application Electron depuis le début, principalement parce qu'ils souhaitent ouvrir des fichiers en double-cliquant dessus. Nous avions également l'intention de la publier sur les plates-formes de téléchargement d'applications. En parallèle, quelqu'un a suggéré de créer une PWA à la place. Nous avons donc fait les deux. Heureusement, nous avons découvert les API du projet Fugu, comme l'accès au système de fichiers, l'accès au presse-papiers, la gestion des fichiers, etc. En un seul clic, vous pouvez installer l'application sur votre ordinateur ou votre mobile, sans le poids supplémentaire d'Electron. La décision d'abandonner la version Electron, de se concentrer uniquement sur l'application Web et d'en faire la meilleure PWA possible a été facile à prendre. De plus, nous pouvons désormais publier des PWA sur le Play Store et le Microsoft Store. C'est énorme !
On pourrait dire qu'Excalidraw pour Electron n'a pas été abandonné parce qu'Electron est mauvais, pas du tout, mais parce que le Web est devenu suffisamment bon. J'aime beaucoup !
Gestion de fichiers
Quand je dis que "le Web est devenu suffisamment performant", c'est grâce à des fonctionnalités comme la gestion des fichiers, qui sera bientôt disponible.
Il s'agit d'une installation standard de macOS Big Sur. Voyons maintenant ce qui se passe lorsque je fais un clic droit sur un fichier Excalidraw. Je peux choisir de l'ouvrir avec Excalidraw, la PWA installée. Bien sûr, un double-clic fonctionnerait également, mais c'est moins spectaculaire à montrer dans un enregistrement d'écran.
Voyons le fonctionnement. La première étape consiste à indiquer au système d'exploitation les types de fichiers que mon application peut gérer. Pour ce faire, j'utilise un nouveau champ appelé file_handlers dans le fichier manifeste de l'application Web. Sa valeur est un tableau d'objets avec une action et une propriété accept. L'action détermine le chemin d'URL auquel le système d'exploitation lance votre application, et l'objet d'acceptation correspond à des paires clé/valeur de types MIME et d'extensions de fichier associées.
{
"name": "Excalidraw",
"description": "Excalidraw is a whiteboard tool...",
"start_url": "/",
"display": "standalone",
"theme_color": "#000000",
"background_color": "#ffffff",
"file_handlers": [
{
"action": "/",
"accept": {
"application/vnd.excalidraw+json": [".excalidraw"]
}
}
]
}
L'étape suivante consiste à gérer le fichier au lancement de l'application. Cela se produit dans l'interface launchQueue, où je dois définir un consommateur en appelant setConsumer(). Le paramètre de cette fonction est une fonction asynchrone qui reçoit le launchParams. Cet objet launchParams comporte un champ appelé "files" qui me permet d'obtenir un tableau de gestionnaires de fichiers à utiliser. Seul le premier m'intéresse. À partir de ce descripteur de fichier, j'obtiens un blob que je transmets ensuite à notre vieil ami loadFromBlob().
if ('launchQueue' in window && 'LaunchParams' in window) {
window as any.launchQueue
.setConsumer(async (launchParams: { files: any[] }) => {
if (!launchParams.files.length) return;
const fileHandle = launchParams.files[0];
const blob: Blob = await fileHandle.getFile();
blob.handle = fileHandle;
loadFromBlob(blob, this.state).then(({ elements, appState }) =>
// Initialize app state.
).catch((error) => {
this.setState({ isLoading: false, errorMessage: error.message });
});
});
}
Encore une fois, si cela est allé trop vite, vous pouvez en savoir plus sur l'API de gestion de fichiers dans mon article. Vous pouvez activer la gestion des fichiers en définissant le flag de fonctionnalités expérimentales de la plate-forme Web. Elle devrait être disponible dans Chrome d'ici la fin de l'année.
Intégration du presse-papiers
Une autre fonctionnalité intéressante d'Excalidraw est l'intégration du presse-papiers. Je peux copier l'intégralité de mon dessin ou seulement certaines parties dans le presse-papiers, en ajoutant éventuellement un filigrane si je le souhaite, puis le coller dans une autre application. Il s'agit d'une version Web de l'application Paint de Windows 95.
Le fonctionnement est étonnamment simple. Il me suffit d'obtenir le canevas sous forme de blob, que j'écris ensuite dans le presse-papiers en transmettant un tableau à un élément avec un ClipboardItem contenant le blob à la fonction navigator.clipboard.write(). Pour en savoir plus sur ce que vous pouvez faire avec l'API Clipboard, consultez l'article de Jason et moi.
export const copyCanvasToClipboardAsPng = async (canvas: HTMLCanvasElement) => {
const blob = await canvasToBlob(canvas);
await navigator.clipboard.write([
new window.ClipboardItem({
'image/png': blob,
}),
]);
};
export const canvasToBlob = async (canvas: HTMLCanvasElement): Promise<Blob> => {
return new Promise((resolve, reject) => {
try {
canvas.toBlob((blob) => {
if (!blob) {
return reject(new CanvasError(t('canvasError.canvasTooBig'), 'CANVAS_POSSIBLY_TOO_BIG'));
}
resolve(blob);
});
} catch (error) {
reject(error);
}
});
};
Collaboration avec d'autres personnes
Partager l'URL d'une session
Saviez-vous qu'Excalidraw propose également un mode collaboratif ? Plusieurs personnes peuvent travailler ensemble sur le même document. Pour démarrer une nouvelle session, je clique sur le bouton de collaboration en direct, puis je démarre une session. Je peux facilement partager l'URL de la session avec mes collaborateurs grâce à l'API Web Share intégrée à Excalidraw.
Collaboration en direct
J'ai simulé une session de collaboration en local en travaillant sur le logo Google I/O sur mon Pixelbook, mon téléphone Pixel 3a et mon iPad Pro. Comme vous pouvez le voir, les modifications que j'apporte sur un appareil sont répercutées sur tous les autres.
Je peux même voir tous les curseurs se déplacer. Le curseur du Pixelbook se déplace de manière fluide, car il est contrôlé par un pavé tactile, mais le curseur du téléphone Pixel 3a et celui de la tablette iPad Pro sautent, car je contrôle ces appareils en appuyant avec mon doigt.
Afficher l'état des collaborateurs
Pour améliorer l'expérience de collaboration en temps réel, un système de détection d'inactivité est même en cours d'exécution. Le curseur de l'iPad Pro affiche un point vert lorsque je l'utilise. Le point devient noir lorsque je passe à un autre onglet du navigateur ou à une autre application. Et lorsque je suis dans l'application Excalidraw, mais que je ne fais rien, le curseur m'indique comme inactif, symbolisé par les trois zZZ.
Les lecteurs assidus de nos publications pourraient penser que la détection d'inactivité est réalisée via l'API Idle Detection, une proposition préliminaire sur laquelle nous avons travaillé dans le cadre du projet Fugu. Alerte spoiler : ce n'est pas le cas. Bien que nous ayons implémenté cette API dans Excalidraw, nous avons finalement décidé d'opter pour une approche plus traditionnelle basée sur la mesure du mouvement du pointeur et de la visibilité de la page.

Nous avons envoyé des commentaires expliquant pourquoi l'API Idle Detection ne répondait pas à notre cas d'utilisation. Toutes les API du projet Fugu sont développées de manière ouverte, de sorte que tout le monde peut participer et se faire entendre.
Lipis sur ce qui freine Excalidraw
À ce propos, j'ai posé une dernière question à lipis concernant ce qui, selon lui, manque à la plate-forme Web et freine Excalidraw :
L'API File System Access est formidable, mais vous savez quoi ? La plupart des fichiers qui m'intéressent aujourd'hui se trouvent dans Dropbox ou Google Drive, et non sur mon disque dur. J'aimerais que l'API File System Access inclue une couche d'abstraction pour les fournisseurs de systèmes de fichiers distants comme Dropbox ou Google, et que les développeurs puissent coder en fonction de cette couche. Les utilisateurs pourraient alors se détendre et savoir que leurs fichiers sont en sécurité avec le fournisseur de services cloud en qui ils ont confiance.
Je suis tout à fait d'accord avec lipis, je vis aussi dans le cloud. Espérons que cette fonctionnalité sera bientôt implémentée.
Mode d'application à onglets
Impressionnant ! Nous avons vu de nombreuses intégrations d'API très intéressantes dans Excalidraw. Système de fichiers, gestion des fichiers, presse-papiers, partage Web et cible de partage Web. Mais il y a une dernière chose. Jusqu'à présent, je ne pouvais modifier qu'un seul document à la fois. Plus maintenant. Découvrez pour la première fois une version préliminaire du mode d'application à onglets dans Excalidraw. Voici à quoi cela ressemble.
Un fichier existant est ouvert dans la PWA Excalidraw installée, qui s'exécute en mode autonome. Maintenant, j'ouvre un nouvel onglet dans la fenêtre autonome. Il ne s'agit pas d'un onglet de navigateur standard, mais d'un onglet de PWA. Dans ce nouvel onglet, je peux ouvrir un fichier secondaire et travailler sur les deux fichiers indépendamment l'un de l'autre, depuis la même fenêtre d'application.
Le mode d'application à onglets n'en est qu'à ses débuts, et rien n'est encore figé. Si vous êtes intéressé, n'hésitez pas à consulter l'état actuel de cette fonctionnalité dans mon article.
Closing
Pour rester informé de cette fonctionnalité et d'autres, consultez notre outil de suivi des API Fugu. Nous sommes ravis de faire progresser le Web et de vous permettre d'en faire plus sur la plate-forme. Nous espérons qu'Excalidraw continuera de s'améliorer et que vous créerez de nombreuses applications incroyables. Commencez à créer sur excalidraw.com.
J'ai hâte de voir certaines des API que j'ai présentées aujourd'hui apparaître dans vos applications. Je m'appelle Tom. Vous pouvez me trouver sous le nom @tomayac sur Twitter et sur Internet en général. Merci de votre attention et profitez bien du reste de Google I/O.