@statewalker/webrun-files 0.2.0 → 0.3.0

package/src/BrowserFilesApi.js

@@ -1,30 +1,165 @@
 import FilesApi from "./FilesApi.js";
 import getMimeType from "./getMimeType.js";
 
+/**
+ * Stateless adapter for the "File and Directory Entries API".
+ * See https://developer.mozilla.org/en-US/docs/Web/API/File_and_Directory_Entries_API
+ *
+ * ## File and Directory Entries API
+ * The File and Directory Entries API simulates a local file system
+ * this web apps can navigate within and access files in. You can
+ * develop apps which read, write, and create files and/or directories
+ * in a virtual, sandboxed file system.
+ */
+class AdapterForFilesAndDirectoryEntriesApi {
+  static canApply(handle) {
+    return ((handle?.isDirectory || handle?.isFile) &&
+      (typeof handle?.name === "string"));
+  }
+
+  async *listDirectoryChildren(handle) {
+    let dirReader = handle.createReader();
+    while (true) {
+      const list = await new Promise((resolve, reject) =>
+        dirReader.readEntries(resolve, reject)
+      );
+      if (!list.length) break;
+      yield* list;
+    }
+  }
+
+  isDirectoryHandle(handle) {
+    return handle?.isDirectory;
+  }
+  isFileHandle(handle) {
+    return handle?.isFile;
+  }
+
+  async getSubdirectoryHandle(dirHandle, directoryName, create) {
+    return new Promise((resolve, reject) =>
+      dirHandle.getDirectory(
+        directoryName,
+        { create },
+        resolve,
+        reject,
+      )
+    );
+  }
+
+  async getFileHandle(dirHandle, fileName, create = true) {
+    return new Promise((resolve, reject) =>
+      dirHandle.getFile(
+        fileName,
+        { create },
+        resolve,
+        reject,
+      )
+    );
+  }
+
+  async removeDirectoryEntry(dirHandle, handle) {
+    return new Promise((resolve, reject) => handle.remove(resolve, reject));
+  }
+
+  async getFile(handle) {
+    const file = await new Promise((resolve, reject) =>
+      handle.file(resolve, reject)
+    );
+    return file;
+  }
+
+  async getFileWriteStream(handle) {
+    throw new Error("Not implemented");
+  }
+}
+
+/**
+ * Stateless adapter for the "File System API" and "File System Access API".
+ * See:
+ * - https://developer.mozilla.org/en-US/docs/Web/API/File_System_API
+ * - https://wicg.github.io/file-system-access/
+ */
+class AdapterForFileSystemApi {
+  static canApply(handle) {
+    return (handle?.kind === "file" || handle?.kind === "directory");
+  }
+
+  async *listDirectoryChildren(handle) {
+    yield* handle.values();
+  }
+
+  isDirectoryHandle(handle) {
+    return handle?.kind === "directory";
+  }
+  isFileHandle(handle) {
+    return handle?.kind === "file";
+  }
+
+  async getSubdirectoryHandle(dirHandle, directoryName, create) {
+    return await dirHandle.getDirectoryHandle(directoryName, { create });
+  }
+
+  async getFileHandle(dirHandle, fileName, create = true) {
+    return await dirHandle.getFileHandle(fileName, { create });
+  }
+
+  async removeDirectoryEntry(dirHandle, handle) {
+    return await dirHandle.removeEntry(handle.name, { recursive: true });
+  }
+
+  async getFile(handle) {
+    return await handle.getFile();
+  }
+
+  async getFileWriteStream(handle) {
+    return await handle.createWritable(); // Write the contents of the file to the stream.
+  }
+}
+
 export default class BrowserFilesApi extends FilesApi {
   constructor(options) {
     super(options);
-    if (!this.rootHandler) {
-      throw new Error("Root directory handler is not defined");
+    if (!this.rootHandle) {
+      throw new Error("Root directory handle is not defined");
+    }
+    if (!this.adapter) {
+      throw new Error(
+        "Can not define a browser adapter for the specified root handle",
+      );
     }
   }
 
-  get rootHandler() {
-    return this.options.rootHandler;
+  get rootHandle() {
+    return this.options.rootHandle || this.options.rootHandler;
+  }
+
+  get adapter() {
+    if (!this._adapter) {
+      const handle = this.rootHandle;
+      let adapter = AdapterForFilesAndDirectoryEntriesApi.canApply(handle)
+        ? new AdapterForFilesAndDirectoryEntriesApi()
+        : AdapterForFileSystemApi.canApply(handle)
+        ? new AdapterForFileSystemApi()
+        : null;
+      this._adapter = adapter;
+    }
+    return this._adapter;
   }
 
   async *list(file, { recursive = false } = {}) {
     const segments = this._getPathSegments(file);
-    const handle = await this._getHandler(segments, false);
+    const handle = await this._getHandle(segments);
+    if (!handle) return;
     const that = this;
-    if (handle.kind === "directory") {
+    if (this.adapter.isDirectoryHandle(handle)) {
+      // yield await this._getFileInfo(segments, handle);
       yield* listChildren(segments, handle, recursive);
     }
 
     async function* listChildren(segments, dirHandle, recursive) {
-      for await (const handle of dirHandle.values()) {
+      for await (const handle of that._listDirectoryContent(dirHandle)) {
         yield await that._getFileInfo([...segments, handle.name], handle);
-        if (recursive && handle.kind == "directory") {
+        if (recursive && that.adapter.isDirectoryHandle(handle)) {
           yield* listChildren(
             [...segments, handle.name],
             handle,
@@ -37,32 +172,45 @@ export default class BrowserFilesApi extends FilesApi {
 
   async stats(file) {
     const segments = this._getPathSegments(file);
-    const handle = await this._getHandler(segments, false);
+    const handle = await this._getHandle(segments);
     return handle ? await this._getFileInfo(segments, handle) : null;
   }
 
   async remove(file) {
-    let segments = this._getPathSegments(file);
-    const name = segments.pop();
-    const parentHandle = await this._getHandler(segments, false);
-    const toRemove = [];
-    if (name) {
-      toRemove.push(name);
-    } else {
-      for await (const childHandle of parentHandle.values()) {
-        toRemove.push(childHandle.name);
+    const doRemove = async (dirHandle, handle) => {
+      let result = true;
+      if (this.adapter.isDirectoryHandle(handle)) {
+        const children = [];
+        for await (let child of this.adapter.listDirectoryChildren(handle)) {
+          children.push(child);
+        }
+        for (let child of children) {
+          result = result && await doRemove(handle, child);
+        }
       }
-    }
-    for (const name of toRemove) {
-      await parentHandle.removeEntry(name, { recursive: true });
-    }
-    return true;
+      if (dirHandle) {
+        result &= await this.adapter.removeDirectoryEntry(dirHandle, handle);
+      }
+      return result;
+    };
+
+    const segments = this._getPathSegments(file);
+    const handle = await this._getHandle(segments);
+    segments.pop();
+    const dirHandle = await this._getHandle(segments);
+    return doRemove(dirHandle !== handle ? dirHandle : null, handle);
   }
 
   async write(file, content) {
     const segments = this._getPathSegments(file);
-    const fileHandle = await this._getFileHandler(segments);
-    const writable = await fileHandle.createWritable(); // Write the contents of the file to the stream.
+    const fileName = segments.pop();
+    const dirHandle = await this._getDirectoryHandle(segments, true);
+    const fileHandle = await this.adapter.getFileHandle(
+      dirHandle,
+      fileName,
+      true,
+    );
+    const writable = await this.adapter.getFileWriteStream(fileHandle);
     try {
       if (typeof content === "function") content = content();
       for await (let block of content) {
@@ -75,18 +223,26 @@ export default class BrowserFilesApi extends FilesApi {
 
   async *read(file /* { start = 0, bufferSize = 1024 * 8 } = {} */) {
     const segments = this._getPathSegments(file);
-    const fileHandle = await this._getFileHandler(segments, false);
+
+    const fileName = segments.pop();
+    const dirHandle = await this._getDirectoryHandle(segments, false);
+    const fileHandle = await this.adapter.getFileHandle(
+      dirHandle,
+      fileName,
+      false,
+    );
     if (!fileHandle) return;
-    const fileData = await fileHandle.getFile();
+    const fileData = await this.adapter.getFile(fileHandle);
     const stream = fileData.stream();
     const reader = stream.getReader();
     try {
       let chunk;
-      while ((chunk = await reader.read()) && !chunk.done) {
-        yield chunk.value;
+      while (chunk = await reader.read()) {
+        if (chunk.done) break;
+        yield await chunk.value;
       }
     } finally {
-      reader.cancel && reader.cancel();
+      await reader.cancel && reader.cancel();
       // stream.cancel && stream.cancel();
     }
   }
@@ -97,41 +253,8 @@ export default class BrowserFilesApi extends FilesApi {
   // TODO:
   // async move(fromPath, toPath, options = {}) { ... }
 
-  async _getHandler(segments, create = false) {
-    let handle;
-    try {
-      handle = await this._getFileHandler(segments, create);
-    } catch (e) {
-      try {
-        handle = await this._getDirectoryHandler(segments, create);
-      } catch (e) {
-        // Just ignore it
-      }
-    }
-    return handle;
-  }
-
-  async _getDirectoryHandler(segments, create = true) {
-    segments = [...segments];
-    let dirHandle = this.rootHandler;
-    for (let directoryName of segments) {
-      dirHandle = await dirHandle.getDirectoryHandle(directoryName, { create });
-    }
-    return dirHandle;
-  }
-
-  async _getFileHandler(segments, create = true) {
-    segments = [...segments];
-    const filename = segments.pop();
-    let dirHandle = this.rootHandler;
-    for (let directoryName of segments) {
-      dirHandle = await dirHandle.getDirectoryHandle(directoryName, {
-        create: true,
-      });
-    }
-    const fileHandler = await dirHandle.getFileHandle(filename, { create });
-    return fileHandler;
-  }
+  // ---------------------------------------------------------
+  // Private methods
 
   async _getFileInfo(segments, handle) {
     segments = [...segments];
@@ -143,11 +266,12 @@ export default class BrowserFilesApi extends FilesApi {
       path,
       name,
     };
-    if (handle.kind === "directory") {
+    if (this.adapter.isDirectoryHandle(handle)) {
       info.kind = "directory";
     } else {
       info.kind = "file";
-      const file = await handle.getFile();
+
+      const file = await this.adapter.getFile(handle);
       info.size = file.size;
       info.type = getMimeType(path);
       info.lastModified = file.lastModified;
@@ -161,4 +285,51 @@ export default class BrowserFilesApi extends FilesApi {
     const segments = filePath.split("/").filter((s) => !!s);
     return segments;
   }
+
+  async _getHandle(segments) {
+    const parentDirSegments = [...segments];
+    const name = parentDirSegments.pop();
+    const create = false;
+    try {
+      const dirHandle = await this._getDirectoryHandle(
+        parentDirSegments,
+        create,
+      );
+      try {
+        if (!name) return dirHandle;
+        return await this.adapter.getSubdirectoryHandle(
+          dirHandle,
+          name,
+          create,
+        );
+      } catch (error) {
+        return await this.adapter.getFileHandle(dirHandle, name, create);
+      }
+    } catch (error) {
+      return undefined;
+    }
+  }
+
+  async _getDirectoryHandle(segments, create = true) {
+    segments = [...segments];
+    let dirHandle = this.rootHandle;
+    for (let directoryName of segments) {
+      dirHandle = await this.adapter.getSubdirectoryHandle(
+        dirHandle,
+        directoryName,
+        create,
+      );
+      if (!dirHandle) break;
+    }
+    return dirHandle;
+  }
+
+  async *_listDirectoryContent(handle) {
+    let entries = [];
+    for await (const entry of this.adapter.listDirectoryChildren(handle)) {
+      entries.push(entry);
+    }
+    entries = entries.sort((a, b) => b.name > a.name ? 1 : -1);
+    yield* entries;
+  }
 }