@statewalker/webrun-files 0.1.0

package/dist/index-umd.js

@@ -0,0 +1,881 @@
+// @statewalker/webrun-files v0.1.0 https://github.com/statewalker/webrun-files Copyright 2023 Mikhail Kotelnikov
+(function (global, factory) {
+typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+typeof define === 'function' && define.amd ? define(['exports'], factory) :
+(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.statewalker = global.statewalker || {}, global.statewalker["webrun-files"] = global.statewalker["webrun-files"] || {})));
+})(this, (function (exports) { 'use strict';
+
+function normalizePath(filePath) {
+  const segments = filePath.split("/").filter((s) => !!s && s !== ".");
+  if (segments.length === 0) {
+    segments.push("");
+  }
+  segments.unshift("");
+  return segments.join("/");
+}
+
+function notImplemented(){
+  throw new Error('Not implemented.');
+}
+
+/*
+ * FileInfo
+ * - `kind` - (`file`|`directory`) kind of the returned entity
+ * - `name` - the local name of this file entry (the last segment of the path)
+ * - `path` - path to the file from the root of the "file system"
+ * - `type` - an optional mime type of the file content; it is not defined for directories
+ * - `size` - size of the file (only for files)
+ * - `lastModified` - modification time as a long integer
+ */
+
+/**
+ * This is a common interface providing access to methods dealing with files.
+ */
+class FilesApi {
+  constructor(options) {
+    this.options = options || {};
+  }
+
+  /**
+   * Returns an async generator providing information about files (FileInfo[]).
+   * Paths corresponding to directories has the "/" trailing symbol.
+   * @param {Object|String} file path to the folder or an object returned by the `list` or `info` methods
+   * @param {Object} options optional parameters
+   * @param {Boolean} options.recursive this flag defines if the returned generator
+   * should give access to all child directories and files or just direct children
+   * @return {AsyncGenerator<FileInfo>} generator returning information about
+   * individual file entries
+   */
+  async *list(file, options = {}) {
+    yield notImplemented();
+  }
+
+  /**
+   * Returns information about an individual file.
+   * @param {Object|String} file path to the file or an object returned by
+   * the `list` or `info` methods
+   * @return {FileInfo} information about the file corresponding to the specified
+   * path or null if there is no such a file
+   */
+  async stats(file) {
+    return notImplemented();
+  }
+
+  /**
+   * Removes file or folder corresponding to the specified path.
+   * All children of this entry will be removed as well.
+   * @param {Object|String} file path to the file to remove or an object
+   * returned by the `list` or `info` methods
+   * @return {Boolean} return true if the file was removed
+   */
+  async remove(file) {
+    return notImplemented();
+  }
+
+  /**
+   * Creates and returns a write stream for the file with the specified path.
+   * @param {Object|String} file path to the file or an object returned by
+   * the `list` or `info` methods
+   * @param {AsyncGenerator|AsyncIterator} content async generator function providing the binary
+   * file content to store
+   * @return {any} result of the action execution
+   */
+  async write(file, content) {
+    return notImplemented();
+  }
+
+  /**
+   * Creates an returns an AsyncIterator returning byte blocks with the file content.
+   * @param {Object|String} file path to the file or an object returned by
+   * the `list` or `info` methods
+   * @param {object} options read parameters
+   * @param {number} options.start starting read position; default value is 0
+   * @param {number} options.bufferSize the optional size of returned chunks buffers
+   */
+  async *read(file, options) {
+    yield notImplemented();
+  }
+
+  /**
+   * Copies a file from one path to another.
+   * @param {String} fromPath path to the source file
+   * @param {String} toPath path to the target file
+   * @param {Object} options additional options
+   * @param {Store} options.recursive if this flag is true then subfolders are also copied
+   * @param {Store} options.target optional target store where data should be copied
+   * @return {Boolean} if the file was successfully copied
+   */
+  async copy(source, target, options = {}) {
+    const doCopy = async (sourcePath, targetPath, sourceFile) => {
+      const suffix = sourceFile.path.substring(sourcePath.length);
+      targetPath = `${targetPath}${suffix}`;
+      const content = this.read(sourceFile);
+      return await this.write(targetPath, content);
+    };
+    const recursive = options.recursive === undefined || !!options.recursive;
+    const sourceFile = await this.stats(source);
+    if (sourceFile.kind === "directory") {
+      for await (const file of this.list(source, { ...options, recursive })) {
+        if (file.kind === "directory") continue;
+        await doCopy(source, target, file);
+      }
+    } else {
+      await doCopy(source, target, sourceFile);
+    }
+    return true;
+  }
+
+  /**
+   * Moves files from the initial position to the target path.
+   * The default implementation creates a new file copy in the new location
+   * and removes the old file.
+   *
+   * @param {String} fromPath path to the source file
+   * @param {String} toPath path to the target file
+   * @param {Object} options additional options
+   * @param {Store} options.target optional target store where data should be moved
+   * @return {Boolean} if the file was successfully moved
+   */
+  async move(fromPath, toPath, options = {}) {
+    if (!await this.copy(fromPath, toPath, options)) return false;
+    await this.remove(fromPath);
+    return true;
+  }
+
+  normalizePath(file) {
+    let filePath = typeof file === "object" ? file.path : file + "";
+    return normalizePath(filePath);
+  }
+}
+
+// https://docs.w3cub.com/http/basics_of_http/mime_types/complete_list_of_mime_types
+const mimeTypes = [
+  { "extensions": ["aac"], "mime": "audio/aac", "description": "AAC audio" },
+  { "extensions": ["abw"], "mime": "application/x-abiword", "description": "AbiWord document" },
+  { "extensions": ["arc"], "mime": "application/x-freearc", "description": "Archive document (multiple files embedded)" },
+  { "extensions": ["avi"], "mime": "video/x-msvideo", "description": "AVI: Audio Video Interleave" },
+  { "extensions": ["azw"], "mime": "application/vnd.amazon.ebook", "description": "Amazon Kindle eBook format" },
+  { "extensions": ["bin"], "mime": "application/octet-stream", "description": "Any kind of binary data" },
+  { "extensions": ["bmp"], "mime": "image/bmp", "description": "Windows OS/2 Bitmap Graphics" },
+  { "extensions": ["bz"], "mime": "application/x-bzip", "description": "BZip archive" },
+  { "extensions": ["bz2"], "mime": "application/x-bzip2", "description": "BZip2 archive" },
+  { "extensions": ["csh"], "mime": "application/x-csh", "description": "C-Shell script" },
+  { "extensions": ["css"], "mime": "text/css", "description": "Cascading Style Sheets (CSS)" },
+  { "extensions": ["csv"], "mime": "text/csv", "description": "Comma-separated values (CSV)" },
+  { "extensions": ["doc"], "mime": "application/msword", "description": "Microsoft Word" },
+  { "extensions": ["docx"], "mime": "application/vnd.openxmlformats-officedocument.wordprocessingml.document", "description": "Microsoft Word (OpenXML)" },
+  { "extensions": ["eot"], "mime": "application/vnd.ms-fontobject", "description": "MS Embedded OpenType fonts" },
+  { "extensions": ["epub"], "mime": "application/epub+zip", "description": "Electronic publication (EPUB)" },
+  { "extensions": ["gz"], "mime": "application/gzip", "description": "GZip Compressed Archive" },
+  { "extensions": ["gif"], "mime": "image/gif", "description": "Graphics Interchange Format (GIF)" },
+  { "extensions": ["htm", "html"], "mime": "text/html", "description": "HyperText Markup Language (HTML)" },
+  { "extensions": ["ico"], "mime": "image/vnd.microsoft.icon", "description": "Icon format" },
+  { "extensions": ["ics"], "mime": "text/calendar", "description": "iCalendar format" },
+  { "extensions": ["jar"], "mime": "application/java-archive", "description": "Java Archive (JAR)" },
+  { "extensions": ["jpg", "jpeg"], "mime": "image/jpeg", "description": "JPEG images" },
+  { "extensions": ["js"], "mime": "text/javascript", "description": "JavaScript per the following specifications: https://html.spec.whatwg.org/multipage/#scriptingLanguages, https://html.spec.whatwg.org/multipage/#dependencies:willful-violation, https://datatracker.ietf.org/doc/draft-ietf-dispatch-javascript-mjs/" },
+  { "extensions": ["json"], "mime": "application/json", "description": "JSON format" },
+  { "extensions": ["jsonld"], "mime": "application/ld+json", "description": "JSON-LD format" },
+  { "extensions": ["mid", "midi"], "mime": "application/ld+json", "description": "Musical Instrument Digital Interface (MIDI)	audio/midi audio/x-midi" },
+  { "extensions": ["mjs"], "mime": "text/javascript", "description": "JavaScript module" },
+  { "extensions": ["mp3"], "mime": "audio/mpeg", "description": "MP3 audio" },
+  { "extensions": ["md"], "mime": "text/markdown", "description": "Markdown" },
+  { "extensions": ["mpeg"], "mime": "video/mpeg", "description": "MPEG Video" },
+  { "extensions": ["mpkg"], "mime": "application/vnd.apple.installer+xml", "description": "Apple Installer Package" },
+  { "extensions": ["odp"], "mime": "application/vnd.oasis.opendocument.presentation", "description": "OpenDocument presentation document" },
+  { "extensions": ["ods"], "mime": "application/vnd.oasis.opendocument.spreadsheet", "description": "OpenDocument spreadsheet document" },
+  { "extensions": ["odt"], "mime": "application/vnd.oasis.opendocument.text", "description": "OpenDocument text document" },
+  { "extensions": ["oga"], "mime": "audio/ogg", "description": "OGG audio" },
+  { "extensions": ["ogv"], "mime": "video/ogg", "description": "OGG video" },
+  { "extensions": ["ogx"], "mime": "application/ogg", "description": "OGG" },
+  { "extensions": ["opus"], "mime": "audio/opus", "description": "Opus audio" },
+  { "extensions": ["otf"], "mime": "font/otf", "description": "OpenType font" },
+  { "extensions": ["png"], "mime": "image/png", "description": "Portable Network Graphics" },
+  { "extensions": ["pdf"], "mime": "application/pdf", "description": "Adobe Portable Document Format (PDF)" },
+  { "extensions": ["php"], "mime": "application/x-httpd-php", "description": "Hypertext Preprocessor (Personal Home Page)" },
+  { "extensions": ["ppt"], "mime": "application/vnd.ms-powerpoint", "description": "Microsoft PowerPoint" },
+  { "extensions": ["pptx"], "mime": "application/vnd.openxmlformats-officedocument.presentationml.presentation", "description": "Microsoft PowerPoint (OpenXML)" },
+  { "extensions": ["rar"], "mime": "application/vnd.rar", "description": "RAR archive" },
+  { "extensions": ["rtf"], "mime": "application/rtf", "description": "Rich Text Format (RTF)" },
+  { "extensions": ["sh"], "mime": "application/x-sh", "description": "Bourne shell script" },
+  { "extensions": ["svg"], "mime": "image/svg+xml", "description": "Scalable Vector Graphics (SVG)" },
+  { "extensions": ["swf"], "mime": "application/x-shockwave-flash", "description": "Small web format (SWF) or Adobe Flash document" },
+  { "extensions": ["tar"], "mime": "application/x-tar", "description": "Tape Archive (TAR)" },
+  { "extensions": ["tif", "tiff"], "mime": "image/tiff", "description": "Tagged Image File Format (TIFF)" },
+  // { "extensions": ["ts"], "mime": "video/mp2t", "description": "MPEG transport stream" },
+  { "extensions": ["ttf"], "mime": "font/ttf", "description": "TrueType Font" },
+  { "extensions": ["txt"], "mime": "text/plain", "description": "Text, (generally ASCII or ISO 8859-n)" },
+  { "extensions": ["vsd"], "mime": "application/vnd.visio", "description": "Microsoft Visio" },
+  { "extensions": ["wav"], "mime": "audio/wav", "description": "Waveform Audio Format" },
+  { "extensions": ["weba"], "mime": "audio/webm", "description": "WEBM audio" },
+  { "extensions": ["webm"], "mime": "video/webm", "description": "WEBM video" },
+  { "extensions": ["webp"], "mime": "image/webp", "description": "WEBP image" },
+  { "extensions": ["woff"], "mime": "font/woff", "description": "Web Open Font Format (WOFF)" },
+  { "extensions": ["woff2"], "mime": "font/woff2", "description": "Web Open Font Format (WOFF)" },
+  { "extensions": ["xhtml"], "mime": "application/xhtml+xml", "description": "XHTML" },
+  { "extensions": ["xls"], "mime": "application/vnd.ms-excel", "description": "Microsoft Excel" },
+  { "extensions": ["xlsx"], "mime": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "description": "Microsoft Excel (OpenXML)" },
+  { "extensions": ["xml"], "mime": "application/xml", "description": "XML; application/xml - if not readable from casual users (RFC 3023, section 3); text/xml - if readable from casual users (RFC 3023, section 3)" },
+  { "extensions": ["xul"], "mime": "application/vnd.mozilla.xul+xml", "description": "XUL" },
+  { "extensions": ["zip"], "mime": "application/zip", "description": "ZIP archive" },
+  { "extensions": ["3gp"], "mime": "video/3gpp", "description": "3GPP audio/video container" },
+  { "extensions": ["3g2"], "mime": "video/3gpp2", "description": "3GPP2 audio/video container; audio/3gpp if it doesn't contain video; audio/3gpp2 if it doesn't contain video" },
+  { "extensions": ["7z"], "mime": "application/x-7z-compressed", "description": "7-zip archive" },
+
+  { "extensions": ["jsx"], "mime": "text/jsx", "description": "JavaScript Syntax Extension / JavaScript XML format" },
+  { "extensions": ["ts"], "mime": "text/ts", "description": "TypeScript format" },
+  { "extensions": ["tsx"], "mime": "text/tsx", "description": "TypeScript Syntax Extension / TypeScript XML format" },
+
+];
+
+const mimeTypesDescriptions = mimeTypes.reduce((index, t) => {
+  index[t.mime] = t.description;
+  return index;
+}, {});
+
+const extensionToMimeType = mimeTypes.reduce((index, t) => {
+  for (const ext of t.extensions) {
+    index[ext] = t.mime;
+  }
+  return index;
+}, {});
+
+const mimeTypeToExtensions = mimeTypes.reduce((index, t) => {
+  index[t.mime] = t.extensions;
+  return index;
+}, {});
+
+// import mimeDb from 'mime-db';
+// import mimeTypes from 'mime-types';
+
+function getMimeType(url) {
+  url = url || '';
+  const originalUrl = url;
+  url = url.split('?').shift(); // Remove queries (if any)
+  url = url.split('/').pop(); // Keep only the last segment of the path  
+  const extension = url.split('.').pop(); // Get extension
+  let mimeType = extensionToMimeType[extension];
+  if (!mimeType) {
+    mimeType =
+      originalUrl.match(/api\.observablehq\.com/) || originalUrl.match(/\.ojs$/)
+        ? 'application/javascript-observable'
+        : 'application/binary';
+  }
+  return mimeType;
+}
+
+class MemFilesApi extends FilesApi {
+  constructor(options) {
+    super(options);
+    this.index = {
+      "/" : {
+        "kind": "directory",
+        "path": "/",
+        "name": ""
+      }
+    };
+  }
+
+  async *list(file, { recursive = false } = {}) {
+    await this._init();
+    const filePath = this.normalizePath(file);
+    const paths = this._getPaths();
+    for (const path of paths) {
+      if (path.indexOf(filePath) !== 0 || path === filePath) continue;
+      const suffix = path.substring(filePath.length + 1);
+      const segments = suffix.split("/");
+      if (recursive || segments.length === 1) {
+        yield this._getFileInfo(path);
+      }
+    }
+  }
+
+  async stats(file) {
+    await this._init();
+    const filePath = this.normalizePath(file);
+    return this._getFileInfo(filePath);
+  }
+
+  async remove(file) {
+    await this._init();
+    const fileInfo = await this.stats(file);
+    if (!fileInfo) return false;
+    for await (const { path } of this.list(fileInfo, { recursive: true })) {
+      if (path !== "/") delete this.index[path];
+    }
+    delete this.index[fileInfo.path];
+  }
+
+  async write(file, content) {
+    await this._init();
+    await this._doWrite(file, content);
+  }
+
+  async *read(file /* { start = 0, bufferSize = 1024 * 8 } = {} */) {
+    await this._init();
+    const filePath = this.normalizePath(file);
+    const fileInfo = this.index[filePath];
+    if (!fileInfo || fileInfo.kind !== "file") return ; // throw new Error("Not a file");
+    const content = fileInfo.content;
+    yield* content;
+  }
+
+  // TODO:
+  // async copy(fromPath, toPath, options = {}) { ... }
+
+  // TODO:
+  // async move(fromPath, toPath, options = {}) { ... }
+
+  async _init() {
+    return this._initPromise = this._initPromise ||
+      Promise.resolve().then(() => this._addEntries(this.options.files));
+  }
+
+  async _doWrite(file, content) {
+    const filePath = this.normalizePath(file);
+    const segments = filePath.split("/").filter((s) => !!s);
+    const pathSegments = [""];
+    let info;
+    for (let i = 0; i < segments.length; i++) {
+      const name = segments[i];
+      pathSegments.push(name);
+      const path = pathSegments.join("/");
+      info = this.index[path] = this.index[path] || {
+        path,
+        name,
+        kind: "directory",
+      };
+    }
+    info.kind = "file";
+    info.content = [];
+    info.type = getMimeType(info.path);
+    info.size = 0;
+    info.lastModified = Date.now();
+    if (typeof content === "function") content = content();
+    for await (let chunk of content) {
+      chunk = new Uint8Array(chunk);
+      info.content.push(chunk);
+      info.size += chunk.length;
+    }
+  }
+
+  async _addEntries(index = {}) {
+    for (let [path, content] of Object.entries(index)) {
+      if (typeof content === "string") {
+        content = [new TextEncoder().encode(content)];
+      } else if (content instanceof Uint8Array) {
+        content = [content];
+      }
+      await this._doWrite(path, content);
+    }
+  }
+
+  _getPaths() {
+    return this._getIndexPaths(this.index);
+  }
+
+  _getIndexPaths(index) {
+    return Object.keys(index).sort(compare);
+    function compare(a, b) {
+      return a > b ? 1 : a < b ? -1 : 0;
+    }
+  }
+
+  _getFileInfo(path) {
+    const fileInfo = this.index[path];
+    if (!fileInfo) return null;
+    const info = { ...fileInfo };
+    delete info.content;
+    return info;
+  }
+
+}
+
+class NodeFilesApi extends FilesApi {
+  constructor(options) {
+    super(options);
+    if (!this.fs) throw new Error("File System is not defined.");
+    if (!this.rootDir) throw new Error("Root directory is not defined.");
+  }
+
+  get rootDirSegments() {
+    if (!this._rootDirSegments) {
+      this._rootDirSegments = this._toPathSegments(
+        this.options.rootDir || "./",
+      );
+    }
+    return this._rootDirSegments;
+  }
+
+  get rootDir() {
+    if (!this._rootDir) {
+      this._rootDir = this.rootDirSegments.join("/");
+    }
+    return this._rootDir;
+  }
+
+  get fs() {
+    return this.options.fs;
+  }
+
+  async _init() {
+    return this._initialized = this._initialized ||
+      (async () => {
+        const dirPath = this.rootDir;
+        return await mkdir(this.fs, dirPath);
+      })();
+  }
+
+  async *list(file, { recursive = false } = {}) {
+    await this._init();
+    const filePath = this._expandPath(file);
+    const fileInfo = await this._stats(filePath);
+    if (!fileInfo || fileInfo.kind !== "directory") return;
+    for await (let f of list(this.fs, filePath, recursive)) {
+      yield this._getFileInfo(f.path, f.stat);
+    }
+  }
+
+  async stats(file) {
+    await this._init();
+    const filePath = this._expandPath(file);
+    return this._stats(filePath);
+  }
+
+  async remove(file) {
+    await this._init();
+    const filePath = this._expandPath(file);
+    return await remove(this.fs, filePath);
+  }
+
+  async write(file, content) {
+    await this._init();
+    const filePath = this._expandPath(file);
+    const dir = pathDirname(filePath);
+    await this.fs.mkdir(dir, { recursive: true });
+    let handle;
+    try {
+      handle = await this.fs.open(filePath, "w");
+      if (typeof content === "function") content = content();
+      await handle.writeFile(content);
+    } finally {
+      handle && await handle.close();
+    }
+  }
+
+  async *read(file, { start = 0, bufferSize = 1024 * 8 } = {}) {
+    await this._init();
+    const filePath = this._expandPath(file);
+    let handle;
+    try {
+      handle = await this.fs.open(filePath, "r");
+      const offset = 0;
+      for (let position = start, bytesRead = 0; true; position += bytesRead) {
+        const buffer = new Uint8ClampedArray(bufferSize);
+        const result = await handle.read(
+          buffer,
+          offset,
+          bufferSize,
+          position,
+        );
+        bytesRead = result.bytesRead;
+        if (bytesRead === 0) break;
+        yield bytesRead < bufferSize
+          ? result.buffer.slice(0, bytesRead)
+          : result.buffer;
+      }
+    } finally {
+      handle && await handle.close();
+    }
+  }
+
+  // TODO:
+  // async copy(fromPath, toPath, options = {}) { ... }
+
+  // TODO:
+  // async move(fromPath, toPath, options = {}) { ... }
+
+  async _stats(filePath) {
+    try {
+      const stat = await this.fs.stat(filePath);
+      return this._getFileInfo(filePath, stat);
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+      return null;
+    }
+  }
+
+  _getFileInfo(path, stat) {
+    const segments = this._toPathSegments(path).slice(
+      this.rootDirSegments.length,
+    );
+    segments.unshift("");
+    const name = segments[segments.length - 1];
+    path = segments.join("/");
+    // const name = path.split("/").filter((s) => !!s).pop() || "";
+    let info = {
+      path,
+      name,
+      kind: "",
+    };
+    if (!stat.isFile()) {
+      info.kind = "directory";
+    } else {
+      info.size = stat.size || 0;
+      info.type = getMimeType(path);
+      info.kind = "file";
+      info.lastModified = new Date(stat.mtime).getTime();
+    }
+    return info;
+  }
+
+  _toPathSegments(filePath) {
+    filePath = this.normalizePath(filePath);
+    const segments = filePath.split("/"); // .filter((s) => !!s);
+    // if (segments.length === 0) segments.push("");
+    // segments.unshift("");
+    return segments;
+  }
+
+  _expandPath(file) {
+    const filePath = typeof file === "object" ? file.path : file + "";
+    const segments = this._toPathSegments(filePath).filter((s) => !!s);
+    // segments.shift(); // The first segment is always empty
+    segments.unshift(...this.rootDirSegments);
+    return segments.join("/");
+  }
+}
+
+function pathDirname(path) {
+  const segments = path.split("/");
+  segments.pop();
+  return segments.join("/");
+}
+
+function pathJoin(...paths) {
+  let segments = paths
+    .map((path) => path.split("/"))
+    .reduce((result, segments) => (result.push(...segments), result), []);
+  const firstSegment = segments.shift();
+  segments = segments.filter((s) => !!s && s !== ".");
+  segments.unshift(firstSegment);
+  return segments.join("/");
+}
+
+async function mkdir(fs, dir) {
+  try {
+    const stat = await fs.stat(dir);
+    if (stat && stat.isDirectory()) return true;
+  } catch (error) {
+    // Just ignore
+  }
+  const parent = pathDirname(dir);
+  if (dir === parent) return false;
+  await mkdir(fs, parent);
+  await fs.mkdir(dir, { recursive: true });
+  return true;
+}
+
+async function remove(fs, path) {
+  try {
+    let stat = await fs.stat(path);
+    if (stat.isDirectory()) {
+      for await (let file of list(fs, path, false)) {
+        await remove(fs, file.path);
+      }
+      await fs.rmdir(path);
+    } else {
+      await fs.unlink(path);
+    }
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+}
+
+async function* list(fs, filePath, recursive) {
+  try {
+    const stat = await fs.stat(filePath);
+    if (stat.isDirectory()) {
+      const array = await fs.readdir(filePath);
+      for (const name of array.sort()) {
+        const f = pathJoin(filePath, name);
+        let stat = await fs.stat(f);
+        yield { path: f, stat };
+        if (recursive && stat.isDirectory()) {
+          yield* list(fs, f, true);
+        }
+      }
+    }
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+}
+
+class BrowserFilesApi extends FilesApi {
+  constructor(options) {
+    super(options);
+    if (!this.rootHandler) {
+      throw new Error("Root directory handler is not defined");
+    }
+  }
+
+  get rootHandler() {
+    return this.options.rootHandler;
+  }
+
+  async *list(file, { recursive = false } = {}) {
+    const segments = this._getPathSegments(file);
+    const handle = await this._getHandler(segments, false);
+    const that = this;
+    if (handle.kind === "directory") {
+      yield* listChildren(segments, handle, recursive);
+    }
+
+    async function* listChildren(segments, dirHandle, recursive) {
+      for await (const handle of dirHandle.values()) {
+        yield await that._getFileInfo([...segments, handle.name], handle);
+        if (recursive && handle.kind == "directory") {
+          yield* listChildren(
+            [...segments, handle.name],
+            handle,
+            recursive,
+          );
+        }
+      }
+    }
+  }
+
+  async stats(file) {
+    const segments = this._getPathSegments(file);
+    const handle = await this._getHandler(segments, false);
+    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);
+      }
+    }
+    for (const name of toRemove) {
+      await parentHandle.removeEntry(name, { recursive: true });
+    }
+    return true;
+  }
+
+  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.
+    try {
+      if (typeof content === "function") content = content();
+      for await (let block of content) {
+        await writable.write(block.buffer ? block.buffer : block); // Close the file and write the contents to disk.
+      }
+    } finally {
+      await writable.close();
+    }
+  }
+
+  async *read(file /* { start = 0, bufferSize = 1024 * 8 } = {} */) {
+    const segments = this._getPathSegments(file);
+    const fileHandle = await this._getFileHandler(segments, false);
+    if (!fileHandle) return;
+    const fileData = await fileHandle.getFile();
+    const stream = fileData.stream();
+    const reader = stream.getReader();
+    try {
+      let chunk;
+      while ((chunk = await reader.read()) && !chunk.done) {
+        yield chunk.value;
+      }
+    } finally {
+      reader.cancel && reader.cancel();
+      // stream.cancel && stream.cancel();
+    }
+  }
+
+  // TODO:
+  // async copy(fromPath, toPath, options = {}) { ... }
+
+  // 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;
+  }
+
+  async _getFileInfo(segments, handle) {
+    segments = [...segments];
+    const name = segments[segments.length - 1];
+    segments.unshift("");
+    const path = segments.join("/");
+    const info = {
+      kind: "",
+      path,
+      name,
+    };
+    if (handle.kind === "directory") {
+      info.kind = "directory";
+    } else {
+      info.kind = "file";
+      const file = await handle.getFile();
+      info.size = file.size;
+      info.type = getMimeType(path);
+      info.lastModified = file.lastModified;
+    }
+    return info;
+  }
+
+  _getPathSegments(file) {
+    let filePath = typeof file === "object" ? file.path : file + "";
+    // filePath = this.normalizePath(filePath);
+    const segments = filePath.split("/").filter((s) => !!s);
+    return segments;
+  }
+}
+
+function addFilesApiLogger({
+  filesApi,
+  log = console.log,
+  wrapper = {},
+}) {
+  return ["list", "stats", "remove", "write", "read", "copy", "move"].reduce(
+    (wrapper, methodName) => {
+      const method = filesApi[methodName].bind(filesApi);
+      wrapper[methodName] = (...args) => {
+        let message = { method: methodName, stage : "enter", args };
+        try {
+          log(message);
+          return message.result = method.call(filesApi, ...args);
+        } catch (e) {
+          message.error = e;
+        } finally {
+          message.stage = "exit";
+          log(message);
+        }
+      };
+      return wrapper;
+    },
+    wrapper,
+  );
+}
+
+async function openBrowserFilesApi({
+  handlerKey = "root-dir",
+  readwrite = true,
+  // Methods below could be replaced by persistent implementation
+  // using the "idb-keyval" package (methods "get", "set", "del").
+  index = {},
+  get = async (key) => index[key],
+  set = async (key, handler) => index[key] = handler,
+  del = async (key) => delete index[key],
+} = {}) {
+  let rootHandler = await get(handlerKey);
+  if (!rootHandler) {
+    rootHandler = await window.showDirectoryPicker();
+    await set(handlerKey, rootHandler);
+  }
+  if (!(await verifyPermission(rootHandler, readwrite))) {
+    throw new Error("Access was not granted");
+  }
+  if (!(await isHandlerAccessible(rootHandler))) {
+    // await set(handlerKey, null);
+    await del(handlerKey);
+    throw new Error("Can not access to the folder. Please try again.");
+  }
+  return new BrowserFilesApi({ rootHandler });
+
+  async function isHandlerAccessible(fileHandle) {
+    // We need to perform a real read operation with the handler
+    // to check if the file/directory still exists.
+    let exists = false;
+    try {
+      if (fileHandle.kind === "file") {
+        await fileHandle.getFile();
+      } else {
+        for await (let item of fileHandle.values()) {
+          break;
+        }
+      }
+      exists = true;
+    } catch (error) {
+      console.log(error, fileHandle);
+      exists = false;
+    }
+    return exists;
+  }
+
+  async function verifyPermission(fileHandle, readWrite) {
+    const options = {};
+    if (readWrite) {
+      options.mode = "readwrite";
+    }
+    let granted = false;
+    // Check if permission was already granted. If so, return true.
+    if ((await fileHandle.queryPermission(options)) === "granted") {
+      granted = true;
+    }
+    // Request permission. If the user grants permission, return true.
+    if (
+      !granted && (await fileHandle.requestPermission(options)) === "granted"
+    ) {
+      granted = true;
+    }
+    // The user didn't grant permission, so return false.
+    return granted;
+  }
+}
+
+exports.BrowserFilesApi = BrowserFilesApi;
+exports.FilesApi = FilesApi;
+exports.MemFilesApi = MemFilesApi;
+exports.NodeFilesApi = NodeFilesApi;
+exports.addFilesApiLogger = addFilesApiLogger;
+exports.extensionToMimeType = extensionToMimeType;
+exports.getMimeType = getMimeType;
+exports.mimeTypeToExtensions = mimeTypeToExtensions;
+exports.mimeTypes = mimeTypes;
+exports.mimeTypesDescriptions = mimeTypesDescriptions;
+exports.normalizePath = normalizePath;
+exports.openBrowserFilesApi = openBrowserFilesApi;
+
+}));