@utoo/web 0.0.1-alpha.15 → 0.0.1-alpha.17

package/esm/forkedProject.d.ts

@@ -0,0 +1,22 @@
+import { ProjectEndpoint } from "./type";
+export declare class ForkedProject implements ProjectEndpoint {
+    private endpoint;
+    constructor(port: MessagePort);
+    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<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>;
+}

package/esm/forkedProject.js

@@ -0,0 +1,34 @@
+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) {
+        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);
+    }
+    async rm(path, options) {
+        return await this.endpoint.rm(path, options);
+    }
+    async rmdir(path, options) {
+        return await this.endpoint.rmdir(path, options);
+    }
+}

package/esm/index.d.ts

@@ -1,22 +1,2 @@
-import { Dirent, ProjectEndpoint, ProjectOptions } from "./type";
-export declare class Project implements ProjectEndpoint {
-    #private;
-    private serviceWorkerOptions?;
-    private remote;
-    constructor(options: ProjectOptions);
-    private connectWorker;
-    installServiceWorker(): Promise<void>;
-    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, eventSource: Client | DedicatedWorkerGlobalScope): ProjectEndpoint;
-}
+export { Project } from "./project";
 export * from "./type";

package/esm/index.js

@@ -1,128 +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, ServiceWorkerHandShake } from "./message";
-import { Dirent, } from "./type";
-let ProjectWorker;
-const ConnectedPorts = new Set();
-export class Project {
-    constructor(options) {
-        var _a, _b;
-        _Project_tunnel.set(this, void 0);
-        const { cwd, workerUrl, wasmUrl, threadWorkerUrl, serviceWorker } = 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_tunnel, (_b = __classPrivateFieldGet(this, _Project_tunnel, "f")) !== null && _b !== void 0 ? _b : this.remote.mount({
-            cwd,
-            wasmUrl,
-            threadWorkerUrl,
-        }), "f");
-    }
-    connectWorker(e) {
-        const port = e.ports[0];
-        if (e.data === Fork && !ConnectedPorts.has(port)) {
-            ProjectWorker.postMessage(HandShake, [port]);
-        }
-    }
-    async installServiceWorker() {
-        var _a;
-        if (this.serviceWorkerOptions) {
-            const { url, scope } = this.serviceWorkerOptions;
-            // Should add "Service-Worker-Allowed": "/" in page root response,
-            await navigator.serviceWorker.register(url, { scope: "/" });
-            (_a = navigator.serviceWorker.controller) === null || _a === void 0 ? void 0 : _a.postMessage({
-                [ServiceWorkerHandShake]: true,
-                scope,
-            });
-        }
-    }
-    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, eventSource) {
-        eventSource.postMessage(Fork, {
-            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/project.d.ts

@@ -0,0 +1,27 @@
+import { Dirent, ProjectEndpoint, ProjectOptions } from "./type";
+export declare class Project implements ProjectEndpoint {
+    #private;
+    private serviceWorkerOptions?;
+    private remote;
+    constructor(options: ProjectOptions);
+    private connectWorker;
+    installServiceWorker(): Promise<void>;
+    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>;
+    rm(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    rmdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    static fork(channel: MessageChannel, eventSource: Client | DedicatedWorkerGlobalScope): ProjectEndpoint;
+}

package/esm/project.js

@@ -0,0 +1,109 @@
+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 { ForkedProject } from "./forkedProject";
+import { Fork, HandShake, ServiceWorkerHandShake } from "./message";
+import { Dirent, } from "./type";
+let ProjectWorker;
+const ConnectedPorts = new Set();
+export class Project {
+    constructor(options) {
+        var _a, _b;
+        _Project_tunnel.set(this, void 0);
+        const { cwd, workerUrl, wasmUrl, threadWorkerUrl, serviceWorker } = 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_tunnel, (_b = __classPrivateFieldGet(this, _Project_tunnel, "f")) !== null && _b !== void 0 ? _b : this.remote.mount({
+            cwd,
+            wasmUrl,
+            threadWorkerUrl,
+        }), "f");
+    }
+    connectWorker(e) {
+        const port = e.ports[0];
+        if (e.data === Fork && !ConnectedPorts.has(port)) {
+            ProjectWorker.postMessage(HandShake, [port]);
+        }
+    }
+    async installServiceWorker() {
+        var _a;
+        if (this.serviceWorkerOptions) {
+            const { url, scope } = this.serviceWorkerOptions;
+            // Should add "Service-Worker-Allowed": "/" in page root response headers,
+            await navigator.serviceWorker.register(url, { scope: "/" });
+            (_a = navigator.serviceWorker.controller) === null || _a === void 0 ? void 0 : _a.postMessage({
+                [ServiceWorkerHandShake]: true,
+                scope,
+            });
+        }
+    }
+    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);
+    }
+    async rm(path, options) {
+        await __classPrivateFieldGet(this, _Project_tunnel, "f");
+        return await this.remote.rm(path, options);
+    }
+    async rmdir(path, options) {
+        await __classPrivateFieldGet(this, _Project_tunnel, "f");
+        return await this.remote.rmdir(path, options);
+    }
+    static fork(channel, eventSource) {
+        eventSource.postMessage(Fork, {
+            transfer: [channel.port2],
+        });
+        return new ForkedProject(channel.port1);
+    }
+}
+_Project_tunnel = new WeakMap();

package/esm/serviceWorker.js

@@ -6,6 +6,12 @@ let _promise = new Promise((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;

package/esm/type.d.ts

@@ -22,6 +22,12 @@ 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>;
 }
 export interface ProjectOptions {

package/esm/utoo/index.d.ts

@@ -37,6 +37,14 @@ 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
@@ -102,6 +110,22 @@ export class Project {
      * @returns {Promise<void>}
      */
     copyFile(src: string, dst: string): Promise<void>;
+    /**
+     * @param {string} path
+     * @returns {Promise<void>}
+     */
+    removeFile(path: string): Promise<void>;
+    /**
+     * @param {string} path
+     * @param {boolean} recursive
+     * @returns {Promise<void>}
+     */
+    removeDir(path: string, recursive: boolean): Promise<void>;
+    /**
+     * @param {string} path
+     * @returns {Promise<Metadata>}
+     */
+    metadata(path: string): Promise<Metadata>;
 }
 export default __wbg_init;
 export function initSync(module: any, memory: any): any;

package/esm/utoo/index.js

@@ -200,15 +200,15 @@ function debugString(val) {
     // TODO we could test for more things here, like `Set`s and `Map`s.
     return className;
 }
-export function init_pack() {
-    wasm.init_pack();
-}
 function passArray8ToWasm0(arg, malloc) {
     const ptr = malloc(arg.length * 1, 1) >>> 0;
     getUint8ArrayMemory0().set(arg, ptr / 1);
     WASM_VECTOR_LEN = arg.length;
     return ptr;
 }
+export function init_pack() {
+    wasm.init_pack();
+}
 /**
  * Entry point for web workers
  * @param {number} ptr
@@ -339,6 +339,34 @@ export class DirEntry {
         wasm.__wbg_set_direntry_type(this.__wbg_ptr, (__wbindgen_enum_DirEntryType.indexOf(arg0) + 1 || 3) - 1);
     }
 }
+const MetadataFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => { }, unregister: () => { } }
+    : new FinalizationRegistry(ptr => wasm.__wbg_metadata_free(ptr >>> 0, 1));
+export class Metadata {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Metadata.prototype);
+        obj.__wbg_ptr = ptr;
+        MetadataFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    toJSON() {
+        return {};
+    }
+    toString() {
+        return JSON.stringify(this);
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MetadataFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_metadata_free(ptr, 0);
+    }
+}
 const ProjectFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => { }, unregister: () => { } }
     : new FinalizationRegistry(ptr => wasm.__wbg_project_free(ptr >>> 0, 1));
@@ -493,6 +521,37 @@ export class Project {
         const ret = wasm.project_copyFile(this.__wbg_ptr, ptr0, len0, ptr1, len1);
         return takeObject(ret);
     }
+    /**
+     * @param {string} path
+     * @returns {Promise<void>}
+     */
+    removeFile(path) {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.project_removeFile(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @param {string} path
+     * @param {boolean} recursive
+     * @returns {Promise<void>}
+     */
+    removeDir(path, recursive) {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.project_removeDir(this.__wbg_ptr, ptr0, len0, recursive);
+        return takeObject(ret);
+    }
+    /**
+     * @param {string} path
+     * @returns {Promise<Metadata>}
+     */
+    metadata(path) {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.project_metadata(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
 }
 async function __wbg_load(module, imports) {
     if (typeof Response === 'function' && module instanceof Response) {
@@ -770,6 +829,10 @@ function __wbg_get_imports() {
         getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
         getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
     };
+    imports.wbg.__wbg_metadata_new = function (arg0) {
+        const ret = Metadata.__wrap(arg0);
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_name_f2d27098bfd843e7 = function (arg0, arg1) {
         const ret = getObject(arg1).name;
         const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
@@ -932,6 +995,12 @@ function __wbg_get_imports() {
         const ret = Math.random();
         return ret;
     };
+    imports.wbg.__wbg_read_b863f640f1437745 = function () {
+        return handleError(function (arg0, arg1, arg2) {
+            const ret = getObject(arg0).read(getArrayU8FromWasm0(arg1, arg2));
+            return ret;
+        }, arguments);
+    };
     imports.wbg.__wbg_read_f8fdd4b410209222 = function () {
         return handleError(function (arg0, arg1, arg2, arg3) {
             const ret = getObject(arg0).read(getArrayU8FromWasm0(arg1, arg2), getObject(arg3));
@@ -1126,6 +1195,12 @@ function __wbg_get_imports() {
             return ret;
         }, arguments);
     };
+    imports.wbg.__wbg_write_978b8e385470e7a9 = function () {
+        return handleError(function (arg0, arg1, arg2) {
+            const ret = getObject(arg0).write(getArrayU8FromWasm0(arg1, arg2));
+            return ret;
+        }, arguments);
+    };
     imports.wbg.__wbindgen_array_new = function () {
         const ret = [];
         return addHeapObject(ret);
@@ -1150,28 +1225,28 @@ function __wbg_get_imports() {
         const ret = false;
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper163109 = function (arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 9521, __wbg_adapter_49);
+    imports.wbg.__wbindgen_closure_wrapper163189 = function (arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 9520, __wbg_adapter_49);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper163111 = function (arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 1976, __wbg_adapter_49);
+    imports.wbg.__wbindgen_closure_wrapper163191 = function (arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 2008, __wbg_adapter_49);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper168917 = function (arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 9521, __wbg_adapter_49);
+    imports.wbg.__wbindgen_closure_wrapper168988 = function (arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 9520, __wbg_adapter_49);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper168971 = function (arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 9524, __wbg_adapter_56);
+    imports.wbg.__wbindgen_closure_wrapper169042 = function (arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 9523, __wbg_adapter_56);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper168994 = function (arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 9528, __wbg_adapter_46);
+    imports.wbg.__wbindgen_closure_wrapper169065 = function (arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 9527, __wbg_adapter_46);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper30059 = function (arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 1976, __wbg_adapter_46);
+    imports.wbg.__wbindgen_closure_wrapper30132 = function (arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 2008, __wbg_adapter_46);
         return addHeapObject(ret);
     };
     imports.wbg.__wbindgen_debug_string = function (arg0, arg1) {

package/esm/worker.js

@@ -71,6 +71,23 @@ const projectEndpoint = {
             return await this.projectInternal.createDir(path);
         }
     },
+    async rm(path, options) {
+        await this.wasmInit;
+        let metadata = (await this.projectInternal.metadata(path)).toJSON();
+        switch (metadata.type) {
+            case "file":
+                return await this.projectInternal.removeFile(path);
+            case "directory":
+                return await this.projectInternal.removeDir(path, !!(options === null || options === void 0 ? void 0 : options.recursive));
+            default:
+                // nothing to remove now
+                break;
+        }
+    },
+    async rmdir(path, options) {
+        await this.wasmInit;
+        return await this.projectInternal.removeDir(path, !!(options === null || options === void 0 ? void 0 : options.recursive));
+    },
 };
 const ConnectedPorts = new Set();
 self.addEventListener("message", (e) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@utoo/web",
-  "version": "0.0.1-alpha.15",
+  "version": "0.0.1-alpha.17",
   "module": "esm/index.js",
   "types": "esm/index.d.ts",
   "files": [