@utoo/web 0.0.1-alpha.9 → 1.0.0

package/esm/forkedProject.d.ts

@@ -0,0 +1,24 @@
+import { PackFile, ProjectEndpoint } from "./type";
+export declare class ForkedProject implements ProjectEndpoint {
+    private endpoint;
+    constructor(port: MessagePort);
+    install(packageLock: string, maxConcurrentDownloads?: number): Promise<void>;
+    build(): Promise<import("./type").BuildOutput>;
+    readFile(path: string, encoding?: "utf8"): Promise<any>;
+    writeFile(path: string, content: string | Uint8Array, encoding?: "utf8"): Promise<void>;
+    copyFile(src: string, dst: string): Promise<void>;
+    readdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<import("./type").Dirent[]>;
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    rm(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    rmdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    gzip(files: PackFile[]): Promise<Uint8Array>;
+    sigMd5(content: Uint8Array): Promise<string>;
+}

package/esm/forkedProject.js

@@ -0,0 +1,40 @@
+import * as comlink from "comlink";
+export class ForkedProject {
+    constructor(port) {
+        var _a;
+        (_a = this.endpoint) !== null && _a !== void 0 ? _a : (this.endpoint = comlink.wrap(port));
+    }
+    async install(packageLock, maxConcurrentDownloads) {
+        return await this.endpoint.install(packageLock, maxConcurrentDownloads);
+    }
+    async build() {
+        return await this.endpoint.build();
+    }
+    async readFile(path, encoding) {
+        return (await this.endpoint.readFile(path, encoding));
+    }
+    async writeFile(path, content, encoding) {
+        return await this.endpoint.writeFile(path, content, encoding);
+    }
+    async copyFile(src, dst) {
+        return await this.endpoint.copyFile(src, dst);
+    }
+    async readdir(path, options) {
+        return await this.endpoint.readdir(path, options);
+    }
+    async mkdir(path, options) {
+        return await this.endpoint.mkdir(path, options);
+    }
+    async rm(path, options) {
+        return await this.endpoint.rm(path, options);
+    }
+    async rmdir(path, options) {
+        return await this.endpoint.rmdir(path, options);
+    }
+    async gzip(files) {
+        return await this.endpoint.gzip(files);
+    }
+    async sigMd5(content) {
+        return await this.endpoint.sigMd5(content);
+    }
+}

package/esm/index.d.ts

@@ -1,22 +1,2 @@
-import { Dirent, ProjectEndpoint } from "./type";
-import { MountOpt } from "./worker";
-export declare class Project implements ProjectEndpoint {
-    #private;
-    private remote;
-    constructor(opt: MountOpt & {
-        worker?: Worker;
-    });
-    install(packageLock: string): Promise<void>;
-    build(): Promise<void>;
-    readFile(path: string, encoding?: "utf8"): Promise<any>;
-    writeFile(path: string, content: string | Uint8Array, encoding?: "utf8"): Promise<void>;
-    copyFile(src: string, dst: string): Promise<void>;
-    readdir(path: string, options?: {
-        recursive?: boolean;
-    }): Promise<Dirent[]>;
-    mkdir(path: string, options?: {
-        recursive?: boolean;
-    }): Promise<void>;
-    static fork(channel: MessageChannel): ProjectEndpoint;
-}
+export { Project } from "./project";
 export * from "./type";

package/esm/index.js

@@ -1,103 +1,2 @@
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var _Project_tunnel;
-import * as comlink from "comlink";
-import { Fork, HandShake } from "./message";
-import { Dirent } from "./type";
-let ProjectWorker;
-const ConnectedPorts = new Set();
-export class Project {
-    constructor(opt) {
-        var _a, _b;
-        _Project_tunnel.set(this, void 0);
-        const { cwd, worker, wasmUrl } = opt;
-        const { port1, port2 } = new MessageChannel();
-        (_a = this.remote) !== null && _a !== void 0 ? _a : (this.remote = comlink.wrap(port1));
-        if (!ProjectWorker) {
-            ProjectWorker =
-                worker || new Worker(new URL("./worker", import.meta.url));
-            self.addEventListener("message", (e) => {
-                const port = e.ports[0];
-                if (e.data === Fork && !ConnectedPorts.has(port)) {
-                    ProjectWorker.postMessage(HandShake, [port]);
-                }
-            });
-        }
-        ProjectWorker.postMessage(HandShake, [port2]);
-        __classPrivateFieldSet(this, _Project_tunnel, (_b = __classPrivateFieldGet(this, _Project_tunnel, "f")) !== null && _b !== void 0 ? _b : this.remote.mount({ cwd, wasmUrl }), "f");
-    }
-    async install(packageLock) {
-        await __classPrivateFieldGet(this, _Project_tunnel, "f");
-        return await this.remote.install(packageLock);
-    }
-    async build() {
-        await __classPrivateFieldGet(this, _Project_tunnel, "f");
-        return await this.remote.build();
-    }
-    async readFile(path, encoding) {
-        await __classPrivateFieldGet(this, _Project_tunnel, "f");
-        return (await this.remote.readFile(path, encoding));
-    }
-    async writeFile(path, content, encoding) {
-        await __classPrivateFieldGet(this, _Project_tunnel, "f");
-        return await this.remote.writeFile(path, content, encoding);
-    }
-    async copyFile(src, dst) {
-        await __classPrivateFieldGet(this, _Project_tunnel, "f");
-        return await this.remote.copyFile(src, dst);
-    }
-    async readdir(path, options) {
-        await __classPrivateFieldGet(this, _Project_tunnel, "f");
-        const dirEntry = (await this.remote.readdir(path, options));
-        return dirEntry.map((e) => new Dirent(e));
-    }
-    async mkdir(path, options) {
-        await __classPrivateFieldGet(this, _Project_tunnel, "f");
-        return await this.remote.mkdir(path, options);
-    }
-    static fork(channel) {
-        self.postMessage(Fork, {
-            targetOrigin: "*",
-            transfer: [channel.port2],
-        });
-        return new ForkedProject(channel.port1);
-    }
-}
-_Project_tunnel = new WeakMap();
-class ForkedProject {
-    constructor(port) {
-        var _a;
-        (_a = this.endpoint) !== null && _a !== void 0 ? _a : (this.endpoint = comlink.wrap(port));
-    }
-    async install(packageLock) {
-        return await this.endpoint.install(packageLock);
-    }
-    async build() {
-        return await this.endpoint.build();
-    }
-    async readFile(path, encoding) {
-        return (await this.endpoint.readFile(path, encoding));
-    }
-    async writeFile(path, content, encoding) {
-        return await this.endpoint.writeFile(path, content, encoding);
-    }
-    async copyFile(src, dst) {
-        return await this.endpoint.copyFile(src, dst);
-    }
-    async readdir(path, options) {
-        return await this.endpoint.readdir(path, options);
-    }
-    async mkdir(path, options) {
-        return await this.endpoint.mkdir(path, options);
-    }
-}
+export { Project } from "./project";
 export * from "./type";

package/esm/installServiceWorker.d.ts

@@ -0,0 +1 @@
+export declare function installServiceWorker(url: string, scope: string): Promise<void>;

package/esm/installServiceWorker.js

@@ -0,0 +1,36 @@
+import { ServiceWorkerHandShake } from "./message";
+export async function installServiceWorker(url, scope) {
+    const registration = await navigator.serviceWorker.register(url, {
+        scope: "/",
+    });
+    return new Promise((resolve) => {
+        function sendMessage(sw) {
+            sw.postMessage({
+                [ServiceWorkerHandShake]: true,
+                scope,
+            });
+            resolve();
+        }
+        function listenForActivation(sw) {
+            sw.addEventListener("statechange", () => {
+                if (sw.state === "activated") {
+                    sendMessage(sw);
+                }
+            });
+        }
+        function checkSWState(registration) {
+            if (registration.active) {
+                sendMessage(registration.active);
+            }
+            else if (registration.installing) {
+                listenForActivation(registration.installing);
+            }
+            registration.addEventListener("updatefound", () => {
+                if (registration.installing) {
+                    listenForActivation(registration.installing);
+                }
+            });
+        }
+        checkSWState(registration);
+    });
+}

package/esm/message.d.ts

@@ -1,2 +1,3 @@
 export declare const HandShake = "__handshake__";
+export declare const ServiceWorkerHandShake = "__service_worker_handshake__";
 export declare const Fork = "__fork__";

package/esm/message.js

@@ -1,2 +1,3 @@
 export const HandShake = "__handshake__";
+export const ServiceWorkerHandShake = "__service_worker_handshake__";
 export const Fork = "__fork__";

package/esm/project.d.ts

@@ -0,0 +1,30 @@
+import { BuildOutput, Dirent, PackFile, ProjectEndpoint, ProjectOptions } from "./type";
+export declare class Project implements ProjectEndpoint {
+    #private;
+    private serviceWorkerOptions?;
+    private remote;
+    constructor(options: ProjectOptions);
+    private connectWorker;
+    installServiceWorker(): Promise<void>;
+    mount(): Promise<void>;
+    install(packageLock: string, maxConcurrentDownloads?: number): Promise<void>;
+    build(): Promise<BuildOutput>;
+    readFile(path: string, encoding?: "utf8"): Promise<any>;
+    writeFile(path: string, content: string | Uint8Array, encoding?: "utf8"): Promise<void>;
+    copyFile(src: string, dst: string): Promise<void>;
+    readdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<Dirent[]>;
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    rm(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    rmdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    gzip(files: PackFile[]): Promise<Uint8Array>;
+    sigMd5(content: Uint8Array): Promise<string>;
+    static fork(channel: MessageChannel, eventSource?: Client | DedicatedWorkerGlobalScope): ProjectEndpoint;
+}

package/esm/project.js

@@ -0,0 +1,120 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _Project_mount;
+import { handleIssues } from "@utoo/pack-shared";
+import * as comlink from "comlink";
+import { ForkedProject } from "./forkedProject";
+import { installServiceWorker } from "./installServiceWorker";
+import { Fork, HandShake } from "./message";
+import { Dirent, } from "./type";
+let ProjectWorker;
+const ConnectedPorts = new Set();
+export class Project {
+    constructor(options) {
+        var _a, _b;
+        _Project_mount.set(this, void 0);
+        const { cwd, workerUrl, wasmUrl, threadWorkerUrl, serviceWorker, logFilter, } = options;
+        this.serviceWorkerOptions = serviceWorker;
+        const { port1, port2 } = new MessageChannel();
+        (_a = this.remote) !== null && _a !== void 0 ? _a : (this.remote = comlink.wrap(port1));
+        if (!ProjectWorker) {
+            ProjectWorker = workerUrl
+                ? new Worker(workerUrl)
+                : new Worker(new URL("./worker", import.meta.url));
+            window.addEventListener("message", (e) => {
+                this.connectWorker(e);
+            });
+            if (this.serviceWorkerOptions) {
+                navigator.serviceWorker.addEventListener("message", (e) => {
+                    this.connectWorker(e);
+                });
+            }
+        }
+        ProjectWorker.postMessage(HandShake, [port2]);
+        __classPrivateFieldSet(this, _Project_mount, (_b = __classPrivateFieldGet(this, _Project_mount, "f")) !== null && _b !== void 0 ? _b : this.remote.mount({
+            cwd,
+            wasmUrl,
+            threadWorkerUrl,
+            logFilter,
+        }), "f");
+    }
+    connectWorker(e) {
+        const port = e.ports[0];
+        if (e.data === Fork && !ConnectedPorts.has(port)) {
+            ProjectWorker.postMessage(HandShake, [port]);
+        }
+    }
+    async installServiceWorker() {
+        if (this.serviceWorkerOptions) {
+            const { url, scope } = this.serviceWorkerOptions;
+            // Should add "Service-Worker-Allowed": "/" in page root response headers,
+            return await installServiceWorker(url, scope);
+        }
+    }
+    async mount() {
+        return await __classPrivateFieldGet(this, _Project_mount, "f");
+    }
+    async install(packageLock, maxConcurrentDownloads) {
+        await __classPrivateFieldGet(this, _Project_mount, "f");
+        return await this.remote.install(packageLock, maxConcurrentDownloads);
+    }
+    async build() {
+        await __classPrivateFieldGet(this, _Project_mount, "f");
+        const res = await this.remote.build();
+        handleIssues(res.issues, false, false);
+        return res;
+    }
+    async readFile(path, encoding) {
+        await __classPrivateFieldGet(this, _Project_mount, "f");
+        return (await this.remote.readFile(path, encoding));
+    }
+    async writeFile(path, content, encoding) {
+        await __classPrivateFieldGet(this, _Project_mount, "f");
+        return await this.remote.writeFile(path, content, encoding);
+    }
+    async copyFile(src, dst) {
+        await __classPrivateFieldGet(this, _Project_mount, "f");
+        return await this.remote.copyFile(src, dst);
+    }
+    async readdir(path, options) {
+        await __classPrivateFieldGet(this, _Project_mount, "f");
+        const dirEntry = (await this.remote.readdir(path, options));
+        return dirEntry.map((e) => new Dirent(e));
+    }
+    async mkdir(path, options) {
+        await __classPrivateFieldGet(this, _Project_mount, "f");
+        return await this.remote.mkdir(path, options);
+    }
+    async rm(path, options) {
+        await __classPrivateFieldGet(this, _Project_mount, "f");
+        return await this.remote.rm(path, options);
+    }
+    async rmdir(path, options) {
+        await __classPrivateFieldGet(this, _Project_mount, "f");
+        return await this.remote.rmdir(path, options);
+    }
+    async gzip(files) {
+        await __classPrivateFieldGet(this, _Project_mount, "f");
+        return await this.remote.gzip(files);
+    }
+    async sigMd5(content) {
+        await __classPrivateFieldGet(this, _Project_mount, "f");
+        return await this.remote.sigMd5(content);
+    }
+    static fork(channel, eventSource) {
+        (eventSource || self).postMessage(Fork, {
+            transfer: [channel.port2],
+        });
+        return new ForkedProject(channel.port1);
+    }
+}
+_Project_mount = new WeakMap();

package/esm/serviceWorker.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/serviceWorker.js

@@ -0,0 +1,62 @@
+import { Project } from ".";
+import { ServiceWorkerHandShake } from "./message";
+let _resolve;
+let _promise = new Promise((resolve) => {
+    _resolve = resolve;
+});
+let _projectEndpoint;
+let _serviceWorkerScope;
+self.addEventListener("install", (event) => {
+    event.waitUntil(self.skipWaiting());
+});
+self.addEventListener("activate", (event) => {
+    event.waitUntil(self.clients.claim());
+});
+self.addEventListener("message", (event) => {
+    if (event.data && event.data[ServiceWorkerHandShake] === true) {
+        _serviceWorkerScope = event.data.scope;
+        _projectEndpoint = Project.fork(new MessageChannel(), event.source);
+        _resolve();
+    }
+});
+self.addEventListener("fetch", async (event) => {
+    await _promise;
+    const { url, referrer } = event.request;
+    if (new URL(url).pathname.startsWith(_serviceWorkerScope) ||
+        (referrer && new URL(referrer).pathname.startsWith(_serviceWorkerScope))) {
+        const projectPath = "." + new URL(url).pathname.replace(_serviceWorkerScope, "");
+        event.respondWith(readFileFromProject(projectPath));
+    }
+    else {
+        return;
+    }
+});
+async function readFileFromProject(projectPath) {
+    try {
+        const content = await _projectEndpoint.readFile(projectPath);
+        let mimeType = "application/octet-stream";
+        if (projectPath.endsWith(".js")) {
+            mimeType = "application/javascript";
+        }
+        else if (projectPath.endsWith(".css")) {
+            mimeType = "text/css";
+        }
+        else if (projectPath.endsWith(".html")) {
+            mimeType = "text/html";
+        }
+        else if (projectPath.endsWith(".json")) {
+            mimeType = "application/json";
+        }
+        return new Response(content, {
+            headers: {
+                "Content-Type": mimeType,
+                ...(mimeType === "text/html"
+                    ? { "Cross-Origin-Embedder-Policy": "require-corp" }
+                    : {}),
+            },
+        });
+    }
+    catch (e) {
+        return new Response("Not Found", { status: 404 });
+    }
+}

package/esm/threadWorker.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/threadWorker.js

@@ -0,0 +1,10 @@
+import initWasm from "./utoo";
+// Read logFilter from URL query string and set to globalThis
+const urlParams = new URLSearchParams(self.location.search);
+const logFilter = urlParams.get("logFilter");
+if (logFilter) {
+    globalThis.__UTOO_LOG_FILTER__ = logFilter;
+}
+// this is for wasm_thread to spawn new worker thread.
+// see: https://github.com/utooland/wasm_thread/blob/94438ff771ee0a6a55d79e49a655707970acb615/src/wasm32/js/web_worker.js#L10
+self.wasm_bindgen = initWasm;

package/esm/type.d.ts

@@ -1,3 +1,4 @@
+import { Issue } from "@utoo/pack-shared";
 import { DirEntryType } from "./utoo";
 export interface RawDirent {
     name: string;
@@ -10,9 +11,16 @@ export declare class Dirent {
     isDirectory(): boolean;
     isFile(): boolean;
 }
+export interface BuildOutput {
+    issues: Issue[];
+}
+export interface PackFile {
+    path: string;
+    content: Uint8Array;
+}
 export interface ProjectEndpoint {
-    install: (packageLock: string) => Promise<void>;
-    build: () => Promise<void>;
+    install: (packageLock: string, maxConcurrentDownloads?: number) => Promise<void>;
+    build: () => Promise<BuildOutput>;
     readFile(path: string): Promise<Uint8Array>;
     readFile(path: string, encoding?: "utf8"): Promise<string>;
     writeFile(path: string, content: string | Uint8Array, encoding?: "utf8"): Promise<void>;
@@ -22,7 +30,25 @@ export interface ProjectEndpoint {
     mkdir(path: string, options?: {
         recursive?: boolean;
     }): Promise<void>;
+    rm(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    rmdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
     copyFile(src: string, dst: string): Promise<void>;
+    gzip: (files: PackFile[]) => Promise<Uint8Array>;
+    sigMd5: (content: Uint8Array) => Promise<string>;
 }
-export interface ProjectEndpoint {
+export interface ProjectOptions {
+    cwd: string;
+    workerUrl?: string;
+    threadWorkerUrl: string;
+    wasmUrl?: string;
+    serviceWorker?: ServiceWorkerOptions;
+    logFilter?: string;
+}
+export interface ServiceWorkerOptions {
+    url: string;
+    scope: string;
 }

package/esm/utoo/index.d.ts

@@ -37,37 +37,75 @@ export class DirEntry {
      */
     get type(): DirEntryType;
 }
+export class Metadata {
+    static __wrap(ptr: any): any;
+    toJSON(): {};
+    toString(): string;
+    __destroy_into_raw(): number | undefined;
+    __wbg_ptr: number | undefined;
+    free(): void;
+}
 export class Project {
     /**
      * @param {string} cwd
+     * @param {string} thread_url
      */
-    constructor(cwd: string);
+    constructor(cwd: string, thread_url: string);
     __destroy_into_raw(): number;
     __wbg_ptr: number;
     free(): void;
     /**
-     * @returns {string}
+     * @param {string} path
+     * @returns {Promise<void>}
      */
-    get cwd(): string;
+    createDir(path: string): Promise<void>;
     /**
-     * @param {string} package_lock
+     * @param {string} path
+     * @param {boolean} recursive
      * @returns {Promise<void>}
      */
-    install(package_lock: string): Promise<void>;
+    removeDir(path: string, recursive: boolean): Promise<void>;
     /**
-     * @returns {Promise<any>}
+     * @param {string} path
+     * @returns {Promise<void>}
      */
-    build(): Promise<any>;
+    removeFile(path: string): Promise<void>;
     /**
      * @param {string} path
-     * @returns {Promise<Uint8Array>}
+     * @param {string} content
+     * @returns {Promise<void>}
      */
-    read(path: string): Promise<Uint8Array>;
+    writeString(path: string, content: string): Promise<void>;
+    /**
+     * @param {string} path
+     * @returns {Promise<void>}
+     */
+    createDirAll(path: string): Promise<void>;
     /**
      * @param {string} path
      * @returns {Promise<string>}
      */
     readToString(path: string): Promise<string>;
+    /**
+     * @returns {string}
+     */
+    get cwd(): string;
+    /**
+     * Create a tar.gz archive and return bytes (no file I/O)
+     * This is useful for main thread execution without OPFS access
+     * @param {any} files
+     * @returns {Uint8Array}
+     */
+    gzip(files: any): Uint8Array;
+    /**
+     * @param {string} path
+     * @returns {Promise<Uint8Array>}
+     */
+    read(path: string): Promise<Uint8Array>;
+    /**
+     * @returns {Promise<any>}
+     */
+    build(): Promise<any>;
     /**
      * @param {string} path
      * @param {Uint8Array} content
@@ -75,26 +113,27 @@ export class Project {
      */
     write(path: string, content: Uint8Array): Promise<void>;
     /**
-     * @param {string} path
-     * @param {string} content
+     * @param {string} package_lock
+     * @param {number | null} [max_concurrent_downloads]
      * @returns {Promise<void>}
      */
-    writeString(path: string, content: string): Promise<void>;
+    install(package_lock: string, max_concurrent_downloads?: number | null): Promise<void>;
     /**
-     * @param {string} path
-     * @returns {Promise<DirEntry[]>}
+     * Calculate MD5 hash of byte content
+     * @param {Uint8Array} content
+     * @returns {string}
      */
-    readDir(path: string): Promise<DirEntry[]>;
+    sigMd5(content: Uint8Array): string;
     /**
      * @param {string} path
-     * @returns {Promise<void>}
+     * @returns {Promise<Metadata>}
      */
-    createDir(path: string): Promise<void>;
+    metadata(path: string): Promise<Metadata>;
     /**
      * @param {string} path
-     * @returns {Promise<void>}
+     * @returns {Promise<DirEntry[]>}
      */
-    createDirAll(path: string): Promise<void>;
+    readDir(path: string): Promise<DirEntry[]>;
     /**
      * @param {string} src
      * @param {string} dst