La API de File System Access permite que las apps web lean o guarden cambios directamente en archivos y carpetas del dispositivo del usuario.
¿Qué es la API de File System Access?
La API de File System Access (antes conocida como la API de Native File System y antes de que se llamara API de Writeable Files) permite a los desarrolladores compilar apps web potentes que interactúan con los archivos del dispositivo local del usuario, como IDE, editores de fotos y videos, editores de texto y mucho más. Después de que un usuario otorga acceso a una app web, esta API le permite leer o guardar cambios directamente en archivos y carpetas del dispositivo del usuario. Además de leer y escribir archivos, la API de File System Access permite abrir un directorio y enumerar su contenido.
Si ya trabajaste con la lectura y escritura de archivos, mucho de lo que voy a compartir te resultará familiar. Te recomiendo que lo leas de todos modos, porque no todos los sistemas son iguales.
Actualmente, la API de File System Access es compatible con la mayoría de los navegadores Chromium en Windows, macOS, ChromeOS y Linux. Una excepción notable es el de Brave, ya que por el momento solo está disponible detrás de una marca. Android admite la parte del sistema de archivos privados de origen de la API a partir de Chromium 109. Por el momento, no hay planes para los métodos del selector, pero puedes destacar crbug.com/1011535 para realizar un seguimiento del progreso potencial.
Cómo usar la API de File System Access
Para mostrar la potencia y utilidad de la API de File System Access, escribí un solo editor de texto de archivos. Te permite abrir un archivo de texto, editarlo, guardar los cambios de nuevo en el disco o iniciar un archivo nuevo y guardar los cambios en el disco. No es nada sofisticado, pero proporciona suficiente para ayudarte a comprender los conceptos.
Navegadores compatibles
Probar
Observa la API de File System Access en acción en la demostración del editor de texto.
Lee un archivo desde el sistema de archivos local
El primer caso de uso que quiero abordar es pedirle al usuario que elija un archivo y, luego, lo abra y lo lea desde el disco.
Pídele al usuario que elija un archivo para leer
El punto de entrada a la API de File System Access es window.showOpenFilePicker(). Cuando se llama, muestra un cuadro de diálogo de selector de archivos y le pide al usuario que seleccione un archivo. Después de seleccionar un archivo, la API muestra un arreglo de controladores de archivos. Un parámetro options opcional te permite influir en el comportamiento del selector de archivos, por ejemplo, permitiendo que el usuario seleccione varios archivos, directorios o diferentes tipos de archivos.
Sin ninguna opción especificada, el selector de archivos permite que el usuario seleccione un solo archivo. Esto es perfecto para un editor de texto.
Al igual que muchas otras APIs potentes, la llamada a showOpenFilePicker() debe realizarse en un contexto seguro y debe llamarse desde un gesto del usuario.
let fileHandle;
butOpenFile.addEventListener('click', async () => {
// Destructure the one-element array.
[fileHandle] = await window.showOpenFilePicker();
// Do something with the file handle.
});
Una vez que el usuario selecciona un archivo, showOpenFilePicker() muestra un array de controladores, en este caso, un array de un elemento con un FileSystemFileHandle que contiene las propiedades y los métodos necesarios para interactuar con el archivo.
Es útil mantener una referencia al identificador del archivo para que pueda usarse más adelante. Será necesario para guardar los cambios en el archivo o realizar cualquier otra operación con el archivo.
Cómo leer un archivo desde el sistema de archivos
Ahora que tienes un controlador para un archivo, puedes obtener las propiedades del archivo o acceder a él.
Por ahora, solo leeré su contenido. Si llamas a handle.getFile(), se muestra un objeto File, que contiene un BLOB. Para obtener los datos del BLOB, llama a uno de sus métodos (slice(), stream(), text() o arrayBuffer()).
const file = await fileHandle.getFile();
const contents = await file.text();
El objeto File que muestra FileSystemFileHandle.getFile() solo se puede leer si el archivo subyacente en el disco no ha cambiado. Si se modifica el archivo en el disco, el objeto File se vuelve ilegible y deberás volver a llamar a getFile() para obtener un objeto File nuevo que lea los datos modificados.
Revisión general
Cuando los usuarios hacen clic en el botón Abrir, el navegador muestra un selector de archivos. Una vez que selecciona un archivo, la app lee el contenido y lo coloca en un <textarea>.
let fileHandle;
butOpenFile.addEventListener('click', async () => {
[fileHandle] = await window.showOpenFilePicker();
const file = await fileHandle.getFile();
const contents = await file.text();
textArea.value = contents;
});
Escribe el archivo en el sistema de archivos local
En el editor de texto, hay dos maneras de guardar un archivo: Guardar y Guardar como. Save simplemente vuelve a escribir los cambios en el archivo original con el controlador de archivos que recuperaste antes. Sin embargo, Guardar como crea un archivo nuevo y, por lo tanto, requiere un controlador de archivo nuevo.
Crea un archivo nuevo
Para guardar un archivo, llama a showSaveFilePicker(), que muestra el selector de archivos en modo de "guardar", lo que le permite al usuario elegir un archivo nuevo que quiera usar para guardar. En el caso del editor de texto, también quería que agregara automáticamente una extensión .txt, por lo que proporcioné algunos parámetros adicionales.
async function getNewFileHandle() {
const options = {
types: [
{
description: 'Text Files',
accept: {
'text/plain': ['.txt'],
},
},
],
};
const handle = await window.showSaveFilePicker(options);
return handle;
}
Guardar cambios en el disco
Puedes encontrar todo el código para guardar cambios en un archivo en mi demostración del editor de texto en GitHub. Las interacciones principales del sistema de archivos se encuentran en fs-helpers.js. En su sencillez, el proceso es similar al siguiente código.
Voy a explicar cada paso y los explicaré.
// fileHandle is an instance of FileSystemFileHandle..
async function writeFile(fileHandle, contents) {
// Create a FileSystemWritableFileStream to write to.
const writable = await fileHandle.createWritable();
// Write the contents of the file to the stream.
await writable.write(contents);
// Close the file and write the contents to disk.
await writable.close();
}
Cuando escribes datos en el disco, se usa un objeto FileSystemWritableFileStream, una subclase de WritableStream. Para crear la transmisión, llama a createWritable() en el objeto del controlador de archivos. Cuando se llama a createWritable(), el navegador primero comprueba si el usuario otorgó permiso de escritura al archivo. Si no se otorgó permiso para escribir, el navegador le solicita permiso al usuario. Si no se otorga el permiso, createWritable() arroja una DOMException y la app no podrá escribir en el archivo. En el editor de texto, los objetos DOMException se controlan en el método saveFile().
El método write() toma una cadena, que es lo que se necesita para un editor de texto. Sin embargo, también puede tomar una BufferSource o una Blob. Por ejemplo, puedes canalizar una transmisión directamente a ella:
async function writeURLToFile(fileHandle, url) {
// Create a FileSystemWritableFileStream to write to.
const writable = await fileHandle.createWritable();
// Make an HTTP request for the contents.
const response = await fetch(url);
// Stream the response into the file.
await response.body.pipeTo(writable);
// pipeTo() closes the destination pipe by default, no need to close it.
}
También puedes seek() o truncate() dentro de la transmisión para actualizar el archivo en una posición específica o cambiar el tamaño.
Cómo especificar un nombre de archivo sugerido y un directorio de inicio
En muchos casos, es posible que quieras que tu app sugiera una ubicación o un nombre de archivo predeterminados. Por ejemplo, un editor de texto podría sugerir un nombre de archivo predeterminado Untitled Text.txt en lugar de Untitled. Para lograrlo, pasa una propiedad suggestedName como parte de las opciones showSaveFilePicker.
const fileHandle = await self.showSaveFilePicker({
suggestedName: 'Untitled Text.txt',
types: [{
description: 'Text documents',
accept: {
'text/plain': ['.txt'],
},
}],
});
Lo mismo ocurre con el directorio start predeterminado. Si estás compilando un editor de texto, es posible que desees que se inicie el diálogo para guardar o abrir archivos en la carpeta predeterminada documents, mientras que, en el caso de un editor de imágenes, se recomienda que comience en la carpeta predeterminada pictures. Puedes sugerir un directorio de inicio predeterminado pasando una propiedad startIn a los métodos showSaveFilePicker, showDirectoryPicker() o showOpenFilePicker.
const fileHandle = await self.showOpenFilePicker({
startIn: 'pictures'
});
Esta es la lista de los directorios del sistema conocidos:
desktop: Es el directorio de escritorio del usuario, si tal cosa existe.documents: Directorio en el que, por lo general, se almacenan los documentos que crea el usuario.downloads: Es el directorio en el que se suelen almacenar los archivos descargados.music: Es el directorio en el que se suelen almacenar los archivos de audio.pictures: Directorio en el que se suelen almacenar las fotos y otras imágenes estáticas.videos: Es el directorio en el que se suelen almacenar los videos y las películas.
Además de los directorios del sistema conocidos, también puedes pasar un archivo existente o un controlador de directorio como un valor para startIn. El diálogo se abrirá en el mismo directorio.
// Assume `directoryHandle` is a handle to a previously opened directory.
const fileHandle = await self.showOpenFilePicker({
startIn: directoryHandle
});
Cómo especificar el propósito de diferentes selectores de archivos
A veces, las aplicaciones tienen diferentes selectores para diferentes propósitos. Por ejemplo, un editor de texto enriquecido puede permitir al usuario abrir archivos de texto, pero también importar imágenes. De forma predeterminada, cada selector de archivos se abrirá en la última ubicación recordada. Puedes evitar esto si almacenas valores id para cada tipo de selector. Si se especifica un id, la implementación del selector de archivos recordará un directorio independiente utilizado por última vez para ese id.
const fileHandle1 = await self.showSaveFilePicker({
id: 'openText',
});
const fileHandle2 = await self.showSaveFilePicker({
id: 'importImage',
});
Almacenar los controladores de archivos o de directorios en IndexedDB
Los controladores de archivos y directorios se pueden serializar, lo que significa que puedes guardar un archivo o un controlador de directorio en IndexedDB, o llamar a postMessage() para enviarlos entre el mismo origen de nivel superior.
Guardar los controladores de archivos o directorios en IndexedDB significa que puedes almacenar el estado o recordar en qué archivos o directorios estaba trabajando un usuario. Esto permite mantener una lista de los archivos abiertos o editados recientemente, ofrecer volver a abrir el último archivo cuando se abre la app, restablecer el directorio de trabajo anterior y mucho más. En el editor de texto, almaceno una lista de los cinco archivos más recientes que el usuario abrió, lo que facilita el acceso a esos archivos nuevamente.
En el siguiente ejemplo de código, se muestra cómo almacenar y recuperar un controlador de archivo y un controlador de directorio. Puedes ver esto en acción en Glitch. (Uso la biblioteca idb-keyval para abreviar).
import { get, set } from 'https://unpkg.com/idb-keyval@5.0.2/dist/esm/index.js';
const pre1 = document.querySelector('pre.file');
const pre2 = document.querySelector('pre.directory');
const button1 = document.querySelector('button.file');
const button2 = document.querySelector('button.directory');
// File handle
button1.addEventListener('click', async () => {
try {
const fileHandleOrUndefined = await get('file');
if (fileHandleOrUndefined) {
pre1.textContent = `Retrieved file handle "${fileHandleOrUndefined.name}" from IndexedDB.`;
return;
}
const [fileHandle] = await window.showOpenFilePicker();
await set('file', fileHandle);
pre1.textContent = `Stored file handle for "${fileHandle.name}" in IndexedDB.`;
} catch (error) {
alert(error.name, error.message);
}
});
// Directory handle
button2.addEventListener('click', async () => {
try {
const directoryHandleOrUndefined = await get('directory');
if (directoryHandleOrUndefined) {
pre2.textContent = `Retrieved directroy handle "${directoryHandleOrUndefined.name}" from IndexedDB.`;
return;
}
const directoryHandle = await window.showDirectoryPicker();
await set('directory', directoryHandle);
pre2.textContent = `Stored directory handle for "${directoryHandle.name}" in IndexedDB.`;
} catch (error) {
alert(error.name, error.message);
}
});
Identificadores y permisos de archivos o directorios almacenados
Dado que los permisos actualmente no se mantienen entre sesiones, debes verificar si el usuario otorgó permiso al archivo o directorio mediante queryPermission(). Si no es así, llama a requestPermission() para volver a solicitarlo. Esto funciona de la misma manera para los controladores de archivos y directorios. Debes ejecutar fileOrDirectoryHandle.requestPermission(descriptor) o fileOrDirectoryHandle.queryPermission(descriptor), respectivamente.
En el editor de texto, creé un método verifyPermission() que verifica si el usuario ya otorgó permiso y, si es necesario, realiza la solicitud.
async function verifyPermission(fileHandle, readWrite) {
const options = {};
if (readWrite) {
options.mode = 'readwrite';
}
// Check if permission was already granted. If so, return true.
if ((await fileHandle.queryPermission(options)) === 'granted') {
return true;
}
// Request permission. If the user grants permission, return true.
if ((await fileHandle.requestPermission(options)) === 'granted') {
return true;
}
// The user didn't grant permission, so return false.
return false;
}
Al solicitar permiso de escritura con la solicitud de lectura, reduje la cantidad de solicitudes de permisos; el usuario ve un mensaje cuando abre el archivo y otorga permiso para leer y escribir en él.
Cómo abrir un directorio y enumerar su contenido
Para enumerar todos los archivos de un directorio, llama a showDirectoryPicker(). El usuario elige un directorio en un selector, después de lo cual se muestra un FileSystemDirectoryHandle, que te permite enumerar los archivos del directorio y acceder a ellos. De forma predeterminada, tendrás acceso de lectura a los archivos del directorio, pero si necesitas acceso de escritura, puedes pasar { mode: 'readwrite' } al método.
const butDir = document.getElementById('butDirectory');
butDir.addEventListener('click', async () => {
const dirHandle = await window.showDirectoryPicker();
for await (const entry of dirHandle.values()) {
console.log(entry.kind, entry.name);
}
});
Además, si necesitas acceder a cada archivo con getFile() para, por ejemplo, obtener los tamaños de archivos individuales, no uses await en cada resultado de manera secuencial, sino que proceses todos los archivos en paralelo, por ejemplo, a través de Promise.all().
const butDir = document.getElementById('butDirectory');
butDir.addEventListener('click', async () => {
const dirHandle = await window.showDirectoryPicker();
const promises = [];
for await (const entry of dirHandle.values()) {
if (entry.kind !== 'file') {
continue;
}
promises.push(entry.getFile().then((file) => `${file.name} (${file.size})`));
}
console.log(await Promise.all(promises));
});
Crear archivos y carpetas de un directorio, o acceder a ellos
Desde un directorio, puedes crear archivos y carpetas, o acceder a ellos, con getFileHandle() o, respectivamente, el método getDirectoryHandle(). Cuando pasas un objeto options opcional con una clave de create y un valor booleano de true o false, puedes determinar si se debe crear un archivo o una carpeta nuevos en caso de que no existan.
// In an existing directory, create a new directory named "My Documents".
const newDirectoryHandle = await existingDirectoryHandle.getDirectoryHandle('My Documents', {
create: true,
});
// In this new directory, create a file named "My Notes.txt".
const newFileHandle = await newDirectoryHandle.getFileHandle('My Notes.txt', { create: true });
Resuelve la ruta de acceso de un elemento en un directorio
Cuando trabajas con archivos o carpetas en un directorio, puede ser útil resolver la ruta de acceso del elemento en cuestión. Esto se puede hacer con el método resolve() que tiene un nombre adecuado. Para resolverlo, el elemento puede ser un elemento secundario directo o indirecto del directorio.
// Resolve the path of the previously created file called "My Notes.txt".
const path = await newDirectoryHandle.resolve(newFileHandle);
// `path` is now ["My Documents", "My Notes.txt"]
Borra archivos y carpetas de un directorio
Si obtuviste acceso a un directorio, puedes borrar los archivos y carpetas contenidos con el método removeEntry(). En el caso de las carpetas, la eliminación puede ser recursiva y, además, incluir todas las subcarpetas y los archivos contenidos en ellas.
// Delete a file.
await directoryHandle.removeEntry('Abandoned Projects.txt');
// Recursively delete a folder.
await directoryHandle.removeEntry('Old Stuff', { recursive: true });
Cómo borrar un archivo o una carpeta directamente
Si tienes acceso a un controlador de archivo o directorio, llama a remove() en un FileSystemFileHandle o FileSystemDirectoryHandle para quitarlo.
// Delete a file.
await fileHandle.remove();
// Delete a directory.
await directoryHandle.remove();
Cambiar el nombre de archivos y carpetas y moverlos
Puedes cambiar el nombre de los archivos y las carpetas o moverlos a una nueva ubicación llamando a move() en la interfaz FileSystemHandle. FileSystemHandle tiene las interfaces secundarias FileSystemFileHandle y FileSystemDirectoryHandle. El método move() toma uno o dos parámetros. El primero puede ser una string con el nombre nuevo o una FileSystemDirectoryHandle para la carpeta de destino. En el último caso, el segundo parámetro opcional es una string con el nuevo nombre, por lo que el movimiento y el cambio de nombre pueden ocurrir en un solo paso.
// Rename the file.
await file.move('new_name');
// Move the file to a new directory.
await file.move(directory);
// Move the file to a new directory and rename it.
await file.move(directory, 'newer_name');
Integración de arrastrar y soltar
Las interfaces de arrastrar y soltar HTML permiten que las aplicaciones web acepten archivos arrastrados y soltados en una página web. Durante una operación de arrastrar y soltar, los elementos del archivo y del directorio arrastrados se asocian con entradas de archivos y de directorio, respectivamente. El método DataTransferItem.getAsFileSystemHandle() muestra una promesa con un objeto FileSystemFileHandle si el elemento arrastrado es un archivo y una promesa con un objeto FileSystemDirectoryHandle si el elemento arrastrado es un directorio. En la siguiente lista, se muestra esto en acción. Ten en cuenta que el elemento DataTransferItem.kind de la interfaz de arrastrar y soltar es "file" para los archivos y directorios, mientras que el FileSystemHandle.kind de la API de File System Access es "file" para los archivos y "directory" para los directorios.
elem.addEventListener('dragover', (e) => {
// Prevent navigation.
e.preventDefault();
});
elem.addEventListener('drop', async (e) => {
e.preventDefault();
const fileHandlesPromises = [...e.dataTransfer.items]
.filter((item) => item.kind === 'file')
.map((item) => item.getAsFileSystemHandle());
for await (const handle of fileHandlesPromises) {
if (handle.kind === 'directory') {
console.log(`Directory: ${handle.name}`);
} else {
console.log(`File: ${handle.name}`);
}
}
});
Accede al sistema de archivos privados de origen
El sistema de archivos privados de origen es un extremo de almacenamiento que, como su nombre lo indica, es privado para el origen de la página. Si bien los navegadores suelen implementar esto mediante la persistencia del contenido de este sistema de archivos privados de origen en un disco, no se pretende que el contenido sea de fácil acceso para el usuario. Del mismo modo, no se espera que existan archivos o directorios cuyos nombres coincidan con los nombres de los elementos secundarios del sistema de archivos privados de origen. Si bien el navegador puede hacer parecer que hay archivos, internamente (ya que se trata de un sistema de archivos privados de origen), el navegador puede almacenar estos “archivos” en una base de datos o en cualquier otra estructura de datos. En esencia, si usas esta API, no esperas que los archivos creados coincidan uno a uno en algún lugar del disco duro. Puedes operar como de costumbre en el sistema de archivos privados de origen una vez que tengas acceso a la raíz FileSystemDirectoryHandle.
const root = await navigator.storage.getDirectory();
// Create a new file handle.
const fileHandle = await root.getFileHandle('Untitled.txt', { create: true });
// Create a new directory handle.
const dirHandle = await root.getDirectoryHandle('New Folder', { create: true });
// Recursively remove a directory.
await root.removeEntry('Old Stuff', { recursive: true });
Acceso a archivos optimizados para el rendimiento desde el sistema de archivos privados de origen
El sistema de archivos privados de origen proporciona acceso opcional a un tipo especial de archivo que está altamente optimizado para el rendimiento, por ejemplo, cuando ofrece acceso de escritura exclusivo y local al contenido de un archivo. En Chromium 102 y versiones posteriores, existe un método adicional en el sistema de archivos privados de origen para simplificar el acceso a los archivos: createSyncAccessHandle() (para operaciones de lectura y escritura síncronas).
Está expuesto en FileSystemFileHandle, pero exclusivamente en Web Workers.
// (Read and write operations are synchronous,
// but obtaining the handle is asynchronous.)
// Synchronous access exclusively in Worker contexts.
const accessHandle = await fileHandle.createSyncAccessHandle();
const writtenBytes = accessHandle.write(buffer);
const readBytes = accessHandle.read(buffer, { at: 1 });
Polirelleno
No es posible aplicar polyfills de todos los métodos de la API de File System Access.
- Se puede aproximar el método
showOpenFilePicker()con un elemento<input type="file">. - Se puede simular el método
showSaveFilePicker()con un elemento<a download="file_name">, aunque esto activa una descarga programática y no permite reemplazar archivos existentes. - El método
showDirectoryPicker()se puede emular de alguna forma con el elemento<input type="file" webkitdirectory>no estándar.
Desarrollamos una biblioteca llamada browser-fs-access que utiliza la API de File System Access siempre que sea posible y que recurre a las siguientes mejores opciones en todos los demás casos.
Seguridad y permisos
El equipo de Chrome diseñó e implementó la API de File System Access según los principios fundamentales definidos en Cómo controlar el acceso a funciones potentes de la plataforma web, incluidos el control y la transparencia del usuario, y la ergonomía del usuario.
Abrir un archivo o guardar uno nuevo
Al abrir un archivo, el usuario otorga permiso para leer un archivo o directorio a través del selector de archivos.
El selector de archivos abierto solo se puede mostrar con un gesto del usuario cuando se entrega desde un contexto seguro. Si los usuarios cambian de opinión, pueden cancelar la selección en el selector de archivos y el sitio no tendrá acceso a nada. Este es el mismo comportamiento que el del elemento <input type="file">.
Del mismo modo, cuando una app web quiere guardar un archivo nuevo, el navegador muestra el selector para guardar archivos, que permite al usuario especificar el nombre y la ubicación del archivo nuevo. Dado que están guardando un archivo nuevo en el dispositivo (en lugar de reemplazar uno existente), el selector de archivos le otorga permiso a la app para escribir en el archivo.
Carpetas restringidas
Para ayudar a proteger a los usuarios y sus datos, el navegador puede limitar la capacidad del usuario de guardar en ciertas carpetas, por ejemplo, las carpetas principales del sistema operativo, como Windows, las carpetas de la biblioteca de macOS, etc. Cuando esto sucede, el navegador muestra un mensaje y le pide al usuario que elija una carpeta diferente.
Modifica un archivo o directorio existente
Una aplicación web no puede modificar un archivo en un disco sin obtener el permiso explícito del usuario.
Mensaje de permiso
Si una persona quiere guardar cambios en un archivo al que le otorgó acceso de lectura anteriormente, el navegador mostrará un mensaje de permiso y solicitará permiso para que el sitio escriba cambios en el disco. La solicitud de permiso solo se puede activar con un gesto del usuario, por ejemplo, haciendo clic en un botón Guardar.
Como alternativa, una app web que edita varios archivos, como un IDE, también puede solicitar permiso para guardar cambios en el momento de abrirse.
Si el usuario elige Cancelar y no otorga acceso de escritura, la aplicación web no podrá guardar los cambios en el archivo local. Debe ofrecer un método alternativo para que el usuario guarde sus datos, por ejemplo, proporcionando una forma de "descargar" el archivo, guardar datos en la nube, etcétera.
Transparencia
Una vez que un usuario otorga permiso a una app web para guardar un archivo local, el navegador muestra un ícono en la barra de URL. Si haces clic en el ícono, se abrirá una ventana emergente que muestra la lista de archivos a los que el usuario otorgó acceso. El usuario puede revocar fácilmente ese acceso si así lo desea.
Persistencia de permisos
La app web puede seguir guardando cambios en el archivo sin solicitarlo hasta que se cierren todas las pestañas de su origen. Una vez que se cierra una pestaña, el sitio pierde todo el acceso. La próxima vez que el usuario utilice la aplicación web, se le solicitará que acceda a los archivos.
Comentarios
Queremos conocer tu experiencia con la API de File System Access.
Cuéntanos sobre el diseño de la API
¿Hay algo acerca de la API que no funciona como esperabas? ¿O faltan métodos o propiedades que necesitas para implementar tu idea? ¿Tienes alguna pregunta o comentario sobre el modelo de seguridad?
- Informa un problema de especificaciones en el repositorio de GitHub de acceso al sistema de archivos de WICG o agrega tus ideas sobre un problema existente.
¿Tienes problemas con la implementación?
¿Encontraste un error en la implementación de Chrome? ¿O la implementación es diferente de la especificación?
- Informa un error en https://new.crbug.com. Asegúrate de incluir tantos detalles como puedas, instrucciones simples para la reproducción y establece los Componentes como
Blink>Storage>FileSystem. Glitch funciona muy bien para compartir repros rápidos y fáciles.
¿Piensas usar la API?
¿Planeas usar la API de File System Access en tu sitio? Tu apoyo público nos ayuda a priorizar funciones y muestra a otros proveedores de navegadores lo fundamental que es admitirlas.
- Comparte cómo planeas usarlo en la conversación del discurso de WICG.
- Envía un tweet a @ChromiumDev con el hashtag
#FileSystemAccessy cuéntanos dónde y cómo lo usas.
Vínculos útiles
- Explicación pública
- Especificación de Acceso al sistema de archivos y Especificación de archivos
- Error de seguimiento
- Entrada de ChromeStatus.com
- Definiciones de TypeScript
- API de Acceso al sistema de archivos: Modelo de seguridad de Chromium
- Componente de Blink:
Blink>Storage>FileSystem
Agradecimientos
Marijn Kruisselbrink escribió la especificación de la API de File System Access.