Excalidraw y Fugu: Mejoras en los recorridos del usuario principales

Cualquier tecnología lo suficientemente avanzada es indistinguible de la magia. A menos que lo entiendas. Mi nombre es Thomas Steiner, trabajo en Relaciones con Desarrolladores en Google y, en este resumen de mi charla de Google I/O, analizaré algunas de las nuevas APIs de Fugu y cómo mejoran los recorridos del usuario principales en la AWP de Excalidraw, para que puedas inspirarte en estas ideas y aplicarlas a tus propias apps.

Cómo llegué a Excalidraw

Quiero comenzar con una historia. El 1 de enero de 2020, Christopher Chedeau, ingeniero de software de Facebook, tuiteó sobre una pequeña app de dibujo en la que había empezado a trabajar. Con esta herramienta, puedes dibujar cuadros y flechas que parezcan caricaturescos y dibujados a mano. Al día siguiente, también podías dibujar elipses y texto, así como seleccionar objetos y moverlos. El 3 de enero, la app obtuvo su nombre, Excalidraw, y, como con todo buen proyecto paralelo, comprar el nombre de dominio fue uno de los primeros actos de Christopher. Por ahora, puedes usar colores y exportar todo el dibujo como un PNG.

Captura de pantalla de la aplicación de prototipo de Excalidraw que muestra que admite rectángulos, flechas, elipses y texto.

El 15 de enero, Christopher publicó una entrada de blog que llamó mucho la atención en Twitter, incluida la mía. La publicación comenzó con algunas estadísticas impresionantes:

  • 12,000 usuarios activos únicos
  • 1,500 estrellas en GitHub
  • 26 colaboradores

Para un proyecto que comenzó hace solo dos semanas, no está nada mal. Pero lo que realmente despertó mi interés estaba más abajo en la publicación. Christopher escribió que esta vez probó algo nuevo: dar acceso de confirmación incondicional a todos los que enviaron una solicitud de extracción. El mismo día que leí la entrada de blog, envié una solicitud de extracción que agregaba compatibilidad con la API de acceso al sistema de archivos a Excalidraw, lo que solucionaba una solicitud de función que alguien había enviado.

Captura de pantalla de la publicación en X en la que anuncio mi RP

Mi solicitud de extracción se fusionó un día después y, a partir de ese momento, tuve acceso completo para confirmar cambios. No hace falta decir que no abusé de mi poder. Y tampoco lo hizo ninguno de los otros 149 colaboradores hasta el momento.

Hoy en día, Excalidraw es una app web progresiva instalable completa con asistencia sin conexión, un modo oscuro increíble y, sí, la capacidad de abrir y guardar archivos gracias a la API de acceso al sistema de archivos.

Captura de pantalla de la AWP de Excalidraw en su estado actual.

Lipis explica por qué dedica tanto tiempo a Excalidraw

Este es el final de mi historia sobre "cómo llegué a Excalidraw", pero antes de profundizar en algunas de las increíbles funciones de Excalidraw, tengo el placer de presentar a Panayiotis. Panayiotis Lipiridis, conocido en Internet simplemente como lipis, es el colaborador más prolífico de Excalidraw. Le pregunté a lipis qué lo motiva a dedicar tanto tiempo a Excalidraw:

Al igual que todos los demás, me enteré de este proyecto por el tweet de Christopher. Mi primera contribución fue agregar la biblioteca de Open Color, los colores que aún forman parte de Excalidraw hoy en día. A medida que el proyecto crecía y teníamos muchas solicitudes, mi siguiente gran contribución fue crear un backend para almacenar dibujos y que los usuarios pudieran compartirlos. Pero lo que realmente me impulsa a contribuir es que quienquiera que haya probado Excalidraw busca excusas para volver a usarlo.

Estoy totalmente de acuerdo con lipis. Quien haya probado Excalidraw buscará excusas para volver a usarlo.

Excalidraw en acción

Ahora quiero mostrarte cómo puedes usar Excalidraw en la práctica. No soy un gran artista, pero el logotipo de Google I/O es bastante simple, así que déjame intentarlo. Una caja es la "i", una línea puede ser la barra, y la "o" es un círculo. Mantengo presionada la tecla Mayúsculas para obtener un círculo perfecto. Moveré un poco la barra para que se vea mejor. Ahora, un poco de color para la "i" y la "o". El azul es bueno. ¿Quizás un estilo de relleno diferente? ¿Todo sólido o con sombreado cruzado? No, el sombreado se ve genial. No es perfecto, pero esa es la idea de Excalidraw, así que lo guardaré.

Hago clic en el ícono de guardar y, en el cuadro de diálogo para guardar el archivo, ingreso un nombre. En Chrome, un navegador que admite la API de File System Access, no se trata de una descarga, sino de una operación de guardado real, en la que puedo elegir la ubicación y el nombre del archivo y, si realizo ediciones, puedo guardarlas en el mismo archivo.

Cambiaré el logotipo y haré que la "i" sea roja. Si ahora vuelvo a hacer clic en Guardar, mi modificación se guardará en el mismo archivo que antes. Como prueba, déjame borrar el lienzo y volver a abrir el archivo. Como puedes ver, el logotipo modificado en rojo y azul vuelve a aparecer.

Trabaja con archivos

En los navegadores que actualmente no admiten la API de acceso al sistema de archivos, cada operación de guardado es una descarga, por lo que, cuando realizo cambios, termino con varios archivos con un número incremental en el nombre de archivo que llenan mi carpeta de Descargas. Pero, a pesar de esta desventaja, puedo guardar el archivo.

Cómo abrir archivos

¿Cuál es el secreto? ¿Cómo puede funcionar la apertura y el guardado en diferentes navegadores que pueden o no admitir la API de acceso al sistema de archivos? La apertura de un archivo en Excalidraw se produce en una función llamada loadFromJSON)(), que, a su vez, llama a una función llamada 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 función fileOpen() que proviene de una pequeña biblioteca que escribí llamada browser-fs-access que usamos en Excalidraw. Esta biblioteca proporciona acceso al sistema de archivos a través de la API de File System Access con un resguardo heredado, por lo que se puede usar en cualquier navegador.

Primero, te mostraré la implementación para cuando se admite la API. Después de negociar los tipos de MIME y las extensiones de archivo aceptados, la parte central es llamar a la función showOpenFilePicker() de la API de File System Access. Esta función devuelve un array de archivos o un solo archivo, según si se seleccionan varios archivos. Todo lo que queda por hacer es colocar el identificador de archivo en el objeto de archivo, para que se pueda recuperar de nuevo.

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;
  };
};

La implementación de resguardo se basa en un elemento input de tipo "file". Después de la negociación de los tipos de MIME y las extensiones que se aceptarán, el siguiente paso es hacer clic de manera programática en el elemento de entrada para que se muestre el diálogo de apertura de archivos. Cuando se produce un cambio, es decir, cuando el usuario selecciona uno o varios archivos, se resuelve la promesa.

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();
  });
};

Guardando archivos

Ahora, hablemos de los ahorros. En Excalidraw, el guardado se produce en una función llamada saveAsJSON(). Primero, serializa el array de elementos de Excalidraw en JSON, convierte el JSON en un BLOB y, luego, llama a una función llamada fileSave(). La biblioteca browser-fs-access también proporciona esta función.

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 };
};

Primero, veamos la implementación para navegadores con compatibilidad con la API de acceso al sistema de archivos. Las primeras líneas parecen un poco complejas, pero lo único que hacen es negociar los tipos de MIME y las extensiones de archivo. Cuando ya guardé un archivo y tengo un identificador de archivo, no es necesario que se muestre ningún diálogo para guardar. Sin embargo, si es la primera vez que se guarda, se muestra un diálogo de archivo y la app obtiene un controlador de archivos para usarlo en el futuro. El resto es solo escribir en el archivo, lo que sucede a través de una transmisión de escritura.

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 función "Guardar como"

Si decido ignorar un controlador de archivos existente, puedo implementar una función "guardar como" para crear un archivo nuevo basado en uno existente. Para mostrar esto, abriré un archivo existente, haré algunas modificaciones y, luego, no reemplazaré el archivo existente, sino que crearé uno nuevo con la función Guardar como. Esto deja intacto el archivo original.

La implementación para los navegadores que no admiten la API de sistema de archivos es breve, ya que todo lo que hace es crear un elemento de anclaje con un atributo download cuyo valor es el nombre de archivo deseado y una URL de BLOB como su valor de atributo 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();
};

Luego, se hace clic en el elemento de anclaje de manera programática. Para evitar fugas de memoria, se debe revocar la URL del BLOB después de usarla. Como se trata de una descarga, no se muestra ningún diálogo para guardar el archivo, y todos los archivos se guardan en la carpeta predeterminada Downloads.

Arrastrar y soltar

Una de mis integraciones de sistema favoritas en computadoras de escritorio es arrastrar y soltar. En Excalidraw, cuando suelto un archivo .excalidraw en la aplicación, se abre de inmediato y puedo comenzar a editarlo. En los navegadores que admiten la API de acceso al sistema de archivos, incluso puedo guardar mis cambios de inmediato. No es necesario pasar por un diálogo para guardar el archivo, ya que el controlador de archivos requerido se obtuvo de la operación de arrastrar y soltar.

El secreto para que esto suceda es llamar a getAsFileSystemHandle() en el elemento de transferencia de datos cuando se admite la API de acceso al sistema de archivos. Luego, paso este controlador de archivos a loadFromBlob(), que tal vez recuerdes de un par de párrafos anteriores. Hay muchas cosas que puedes hacer con los archivos: abrirlos, guardarlos, guardarlos encima de otros, arrastrarlos y soltarlos. Mi colega Pete y yo documentamos todos estos trucos y más en nuestro artículo para que puedas ponerte al día en caso de que todo esto haya sido un poco rápido.

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 });
  });
}

Cómo compartir archivos

Otra integración del sistema que actualmente se encuentra en Android, ChromeOS y Windows es a través de la API de Web Share Target. Aquí estoy en la app de Archivos, en mi carpeta Downloads. Puedo ver dos archivos, uno de ellos con el nombre no descriptivo untitled y una marca de tiempo. Para verificar qué contiene, hago clic en los tres puntos, luego en Compartir y una de las opciones que aparece es Excalidraw. Cuando presiono el ícono, puedo ver que el archivo solo contiene el logotipo de I/O de nuevo.

Lipis sobre la versión obsoleta de Electron

Una de las cosas que puedes hacer con los archivos y de la que aún no hemos hablado es hacer doble clic en ellos. Por lo general, cuando haces doble clic en un archivo, se abre la app asociada con el tipo de MIME del archivo. Por ejemplo, para .docx, sería Microsoft Word.

Excalidraw solía tener una versión de Electron de la app que admitía esas asociaciones de tipos de archivos, por lo que, cuando hacías doble clic en un archivo .excalidraw, se abría la app de Electron de Excalidraw. Lipis, a quien ya conociste, fue el creador y el responsable de la baja de Excalidraw Electron. Le pregunté por qué creía que era posible dar de baja la versión de Electron:

Las personas han estado pidiendo una app de Electron desde el principio, principalmente porque querían abrir archivos haciendo doble clic. También queríamos publicar la app en tiendas de aplicaciones. En paralelo, alguien sugirió crear una PWA, así que hicimos ambas cosas. Por suerte, conocimos las APIs de Project Fugu, como el acceso al sistema de archivos, el acceso al portapapeles, el manejo de archivos y mucho más. Con un solo clic, puedes instalar la app en tu computadora o dispositivo móvil, sin el peso adicional de Electron. Fue una decisión fácil dejar de estar disponible la versión de Electron, concentrarse solo en la app web y convertirla en la mejor PWA posible. Además, ahora podemos publicar las AWP en Play Store y Microsoft Store. ¡Eso es enorme!

Se podría decir que Excalidraw para Electron no se dio de baja porque Electron sea malo, para nada, sino porque la Web se volvió lo suficientemente buena. ¡Me gusta!

Manejo de archivos

Cuando digo que "la Web se volvió lo suficientemente buena", es por funciones como el próximo manejo de archivos.

Esta es una instalación normal de macOS Big Sur. Ahora, veamos qué sucede cuando hago clic con el botón derecho en un archivo de Excalidraw. Puedo elegir abrirlo con Excalidraw, la PWA instalada. Por supuesto, hacer doble clic también funcionaría, pero es menos dramático para demostrarlo en una grabación de pantalla.

¿Cómo funciona? El primer paso es hacer que el sistema operativo conozca los tipos de archivos que mi aplicación puede controlar. Para ello, uso un campo nuevo llamado file_handlers en el manifiesto de la app web. Su valor es un array de objetos con una acción y una propiedad accept. La acción determina la ruta de URL en la que el sistema operativo inicia tu app, y el objeto accept son pares clave-valor de tipos de MIME y las extensiones de archivo asociadas.

{
  "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"]
      }
    }
  ]
}

El siguiente paso es controlar el archivo cuando se inicia la aplicación. Esto sucede en la interfaz launchQueue, en la que debo establecer un consumidor llamando a setConsumer(). El parámetro de esta función es una función asíncrona que recibe el launchParams. Este objeto launchParams tiene un campo llamado files que me proporciona un array de manejo de archivos con los que trabajar. Solo me interesa el primero y, a partir de este controlador de archivos, obtengo un BLOB que luego paso a nuestro viejo amigo 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 });
      });
    });
}

Nuevamente, si esto fue demasiado rápido, puedes leer más sobre la API de manejo de archivos en mi artículo. Para habilitar el manejo de archivos, configura la marca de funciones experimentales de la plataforma web. Está previsto que llegue a Chrome más adelante este año.

Integración del portapapeles

Otra función genial de Excalidraw es la integración con el portapapeles. Puedo copiar todo mi dibujo o solo partes de él en el portapapeles, tal vez agregar una marca de agua si quiero y, luego, pegarlo en otra app. Por cierto, esta es una versión web de la app Paint de Windows 95.

La forma en que funciona es sorprendentemente sencilla. Solo necesito el lienzo como un BLOB, que luego escribo en el portapapeles pasando un array de un elemento con un ClipboardItem con el BLOB a la función navigator.clipboard.write(). Para obtener más información sobre lo que puedes hacer con la API de Clipboard, consulta el artículo de Jason y mi artículo.

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);
    }
  });
};

Colaborar con otras personas

Cómo compartir la URL de una sesión

¿Sabías que Excalidraw también tiene un modo colaborativo? Diferentes personas pueden trabajar juntas en el mismo documento. Para iniciar una sesión nueva, hago clic en el botón de colaboración en vivo y, luego, en iniciar una sesión. Puedo compartir la URL de la sesión con mis colaboradores fácilmente gracias a la API de Web Share que Excalidraw integró.

Colaboración en vivo

Simulé una sesión de colaboración de forma local trabajando en el logotipo de Google I/O en mi Pixelbook, mi teléfono Pixel 3a y mi iPad Pro. Puedes ver que los cambios que realizo en un dispositivo se reflejan en todos los demás.

Incluso puedo ver cómo se mueven todos los cursores. El cursor de la Pixelbook se mueve de forma constante, ya que se controla con un panel táctil, pero el cursor del teléfono Pixel 3a y el de la tablet iPad Pro saltan, ya que controlo estos dispositivos presionando con el dedo.

Cómo ver los estados de los colaboradores

Para mejorar la experiencia de colaboración en tiempo real, incluso hay un sistema de detección de inactividad en ejecución. El cursor del iPad Pro muestra un punto verde cuando lo uso. El punto se vuelve negro cuando cambio a otra pestaña del navegador o app. Y cuando estoy en la app de Excalidraw, pero no hago nada, el cursor me muestra como inactivo, lo que se simboliza con las tres zZZ.

Los lectores ávidos de nuestras publicaciones podrían pensar que la detección de inactividad se realiza a través de la API de Idle Detection, una propuesta en etapa inicial en la que se trabajó en el contexto del proyecto Fugu. Alerta de spoiler: no lo es. Si bien teníamos una implementación basada en esta API en Excalidraw, al final, decidimos optar por un enfoque más tradicional basado en la medición del movimiento del puntero y la visibilidad de la página.

Captura de pantalla de los comentarios sobre la API de Idle Detection presentados en el repositorio de Idle Detection de WICG.

Enviamos comentarios sobre por qué la API de Idle Detection no resolvía nuestro caso de uso. Todas las APIs de Project Fugu se desarrollan de forma abierta, por lo que todos pueden participar y hacer oír su voz.

Lipis habla sobre los factores que frenan a Excalidraw

Hablando de eso, le hice a lipis una última pregunta sobre lo que cree que falta en la plataforma web que frena a Excalidraw:

La API de File System Access es excelente, pero ¿sabes qué? La mayoría de los archivos que me importan hoy en día están en mi Dropbox o Google Drive, no en mi disco duro. Me gustaría que la API de File System Access incluyera una capa de abstracción para que los proveedores de sistemas de archivos remotos, como Dropbox o Google, se integraran y que los desarrolladores pudieran programar. Luego, los usuarios podrían relajarse y saber que sus archivos están seguros con el proveedor de servicios en la nube en el que confían.

Estoy totalmente de acuerdo con lipis, yo también vivo en la nube. Esperamos que esto se implemente pronto.

Modo de aplicación con pestañas

¡Vaya! Hemos visto muchas integraciones de APIs excelentes en Excalidraw. Sistema de archivos, manejo de archivos, portapapeles, uso compartido web y destino de uso compartido web. Pero hay un detalle más. Hasta ahora, solo podía editar un documento a la vez. Ya no. Disfruta por primera vez de una versión preliminar del modo de aplicación con pestañas en Excalidraw. Así es como se ve.

Tengo un archivo existente abierto en la AWP de Excalidraw instalada que se ejecuta en modo independiente. Ahora, abro una pestaña nueva en la ventana independiente. Esta no es una pestaña normal del navegador, sino una pestaña de PWA. En esta pestaña nueva, puedo abrir un archivo secundario y trabajar en él de forma independiente desde la misma ventana de la app.

El modo de aplicación con pestañas se encuentra en sus etapas iniciales y no todo está definido. Si te interesa, asegúrate de leer sobre el estado actual de esta función en mi artículo.

Closing

Para mantenerte al tanto de esta y otras funciones, asegúrate de mirar nuestro seguimiento de la API de Fugu. Nos entusiasma mucho impulsar la Web y permitirte hacer más en la plataforma. Esperamos que Excalidraw siga mejorando y que puedas crear aplicaciones increíbles. Comienza a crear en excalidraw.com.

No puedo esperar para ver algunas de las APIs que mostré hoy en tus apps. Me llamo Tom, puedes encontrarme como @tomayac en Twitter y en Internet en general. Muchas gracias por mirar el video y disfruta del resto de Google I/O.