@statewalker/webrun-files 0.3.0 → 0.4.0

package/src/NodeFilesApi.js

@@ -1,222 +0,0 @@
-import FilesApi from "./FilesApi.js";
-import getMimeType from "./getMimeType.js";
-
-export default 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("/");
-  }
-}
-
-export function pathDirname(path) {
-  const segments = path.split("/");
-  segments.pop();
-  return segments.join("/");
-}
-
-export 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("/");
-}
-
-export 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;
-}
-
-export 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;
-  }
-}
-
-export 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;
-  }
-}

package/src/addFilesApiLogger.js

@@ -1,25 +0,0 @@
-export default 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,
-  );
-}

package/src/getMimeType.js

@@ -1,19 +0,0 @@
-// import mimeDb from 'mime-db';
-// import mimeTypes from 'mime-types';
-import { extensionToMimeType } from "./mimeTypes.js";
-
-export default 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;
-}

package/src/index.js

@@ -1,10 +0,0 @@
-export { default as FilesApi } from "./FilesApi.js";
-export { default as MemFilesApi } from "./MemFilesApi.js";
-export { default as NodeFilesApi } from "./NodeFilesApi.js";
-export { default as BrowserFilesApi } from "./BrowserFilesApi.js";
-export { default as normalizePath } from "./normalizePath.js";
-export { default as addFilesApiLogger } from "./addFilesApiLogger.js";
-
-export { default as getMimeType } from "./getMimeType.js";
-export * from "./mimeTypes.js";
-export * from "./openBrowserFilesApi.js";

package/src/mimeTypes.js

@@ -1,96 +0,0 @@
-// https://docs.w3cub.com/http/basics_of_http/mime_types/complete_list_of_mime_types
-export 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" },
-
-]
-
-export const mimeTypesDescriptions = mimeTypes.reduce((index, t) => {
-  index[t.mime] = t.description;
-  return index;
-}, {});
-
-export const extensionToMimeType = mimeTypes.reduce((index, t) => {
-  for (const ext of t.extensions) {
-    index[ext] = t.mime;
-  }
-  return index;
-}, {});
-
-export const mimeTypeToExtensions = mimeTypes.reduce((index, t) => {
-  index[t.mime] = t.extensions;
-  return index;
-}, {});

package/src/normalizePath.js

@@ -1,8 +0,0 @@
-export default function normalizePath(filePath) {
-  const segments = filePath.split("/").filter((s) => !!s && s !== ".");
-  if (segments.length === 0) {
-    segments.push("");
-  }
-  segments.unshift("");
-  return segments.join("/");
-}

package/src/notImplemented.js

@@ -1,3 +0,0 @@
-export default function notImplemented(){
-  throw new Error('Not implemented.');
-}

package/src/openBrowserFilesApi.js

@@ -1,67 +0,0 @@
-import BrowserFilesApi from "./BrowserFilesApi.js";
-
-export 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 });
-}
-
-export 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;
-}
-
-export 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;
-}