@utoo/web 0.0.1-alpha.2 → 0.0.1-alpha.8

package/esm/index.d.ts

@@ -1,17 +1,20 @@
-import { ProjectEndpoint, DirEntry } from "./type";
+import { Dirent, ProjectEndpoint } from "./type";
 export declare class Project implements ProjectEndpoint {
     #private;
     private cwd;
     private remote;
-    constructor(cwd: string);
+    constructor(cwd: string, worker?: Worker);
     install(packageLock: string): Promise<void>;
     build(): Promise<void>;
-    readFile(path: string): Promise<string>;
-    writeFile(path: string, content: string): 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): Promise<DirEntry[]>;
-    createDir(path: string): Promise<void>;
-    createDirAll(path: string): Promise<void>;
-    static fork(port1: MessagePort, port2: MessagePort): ProjectEndpoint;
+    readdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<Dirent[]>;
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    static fork(channel: MessageChannel): ProjectEndpoint;
 }
 export * from "./type";

package/esm/index.js

@@ -12,17 +12,19 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
 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(cwd) {
+    constructor(cwd, worker) {
         var _a, _b;
         _Project_tunnel.set(this, void 0);
         this.cwd = cwd;
         const { port1, port2 } = new MessageChannel();
         (_a = this.remote) !== null && _a !== void 0 ? _a : (this.remote = comlink.wrap(port1));
         if (!ProjectWorker) {
-            ProjectWorker = new Worker(new URL("./worker", import.meta.url));
+            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)) {
@@ -41,34 +43,33 @@ export class Project {
         await __classPrivateFieldGet(this, _Project_tunnel, "f");
         return await this.remote.build();
     }
-    async readFile(path) {
+    async readFile(path, encoding) {
         await __classPrivateFieldGet(this, _Project_tunnel, "f");
-        return await this.remote.readFile(path);
+        return (await this.remote.readFile(path, encoding));
     }
-    async writeFile(path, content) {
+    async writeFile(path, content, encoding) {
         await __classPrivateFieldGet(this, _Project_tunnel, "f");
-        return await this.remote.writeFile(path, content);
+        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) {
+    async readdir(path, options) {
         await __classPrivateFieldGet(this, _Project_tunnel, "f");
-        return await this.remote.readDir(path);
+        const dirEntry = (await this.remote.readdir(path, options));
+        return dirEntry.map((e) => new Dirent(e));
     }
-    async createDir(path) {
+    async mkdir(path, options) {
         await __classPrivateFieldGet(this, _Project_tunnel, "f");
-        return await this.remote.createDir(path);
+        return await this.remote.mkdir(path, options);
     }
-    async createDirAll(path) {
-        await __classPrivateFieldGet(this, _Project_tunnel, "f");
-        return await this.remote.createDirAll(path);
-    }
-    // This should be called from different worker
-    static fork(port1, port2) {
-        self.postMessage(Fork, [port2]);
-        return new ForkedProject(port1);
+    static fork(channel) {
+        self.postMessage(Fork, {
+            targetOrigin: "*",
+            transfer: [channel.port2],
+        });
+        return new ForkedProject(channel.port1);
     }
 }
 _Project_tunnel = new WeakMap();
@@ -83,23 +84,20 @@ class ForkedProject {
     async build() {
         return await this.endpoint.build();
     }
-    async readFile(path) {
-        return await this.endpoint.readFile(path);
+    async readFile(path, encoding) {
+        return (await this.endpoint.readFile(path, encoding));
     }
-    async writeFile(path, content) {
-        return await this.endpoint.writeFile(path, content);
+    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) {
-        return await this.endpoint.readDir(path);
-    }
-    async createDir(path) {
-        return await this.endpoint.createDir(path);
+    async readdir(path, options) {
+        return await this.endpoint.readdir(path, options);
     }
-    async createDirAll(path) {
-        return await this.endpoint.createDirAll(path);
+    async mkdir(path, options) {
+        return await this.endpoint.mkdir(path, options);
     }
 }
 export * from "./type";

package/esm/type.d.ts

@@ -1,15 +1,28 @@
-import type { DirEntryType } from "./utoo";
-export interface DirEntry {
+import { DirEntryType } from "./utoo";
+export interface RawDirent {
     name: string;
     type: DirEntryType;
 }
+export declare class Dirent {
+    private rawDirent;
+    name: string;
+    constructor(rawDirent: RawDirent);
+    isDirectory(): boolean;
+    isFile(): boolean;
+}
 export interface ProjectEndpoint {
     install: (packageLock: string) => Promise<void>;
     build: () => Promise<void>;
-    readFile(path: string): Promise<string>;
-    writeFile(path: string, content: string): Promise<void>;
-    readDir(path: string): Promise<DirEntry[]>;
-    createDir(path: string): Promise<void>;
-    createDirAll(path: string): Promise<void>;
+    readFile(path: string): Promise<Uint8Array>;
+    readFile(path: string, encoding?: "utf8"): Promise<string>;
+    writeFile(path: string, content: string | Uint8Array, encoding?: "utf8"): Promise<void>;
+    readdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<Dirent[]>;
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
     copyFile(src: string, dst: string): Promise<void>;
 }
+export interface ProjectEndpoint {
+}

package/esm/type.js

@@ -1 +1,12 @@
-export {};
+export class Dirent {
+    constructor(rawDirent) {
+        this.rawDirent = rawDirent;
+        this.name = this.rawDirent.name;
+    }
+    isDirectory() {
+        return this.rawDirent.type === "directory";
+    }
+    isFile() {
+        return this.rawDirent.type === "file";
+    }
+}

package/esm/utoo/index.d.ts

@@ -1,3 +1,4 @@
+export function init_pack(): void;
 export class CreateSyncAccessHandleOptions {
     static __wrap(ptr: any): any;
     __destroy_into_raw(): number | undefined;
@@ -55,17 +56,28 @@ export class Project {
      * @returns {Promise<void>}
      */
     build(): Promise<void>;
+    /**
+     * @param {string} path
+     * @returns {Promise<Uint8Array>}
+     */
+    read(path: string): Promise<Uint8Array>;
     /**
      * @param {string} path
      * @returns {Promise<string>}
      */
-    readFile(path: string): Promise<string>;
+    readToString(path: string): Promise<string>;
+    /**
+     * @param {string} path
+     * @param {Uint8Array} content
+     * @returns {Promise<void>}
+     */
+    write(path: string, content: Uint8Array): Promise<void>;
     /**
      * @param {string} path
      * @param {string} content
      * @returns {Promise<void>}
      */
-    writeFile(path: string, content: string): Promise<void>;
+    writeString(path: string, content: string): Promise<void>;
     /**
      * @param {string} path
      * @returns {Promise<DirEntry[]>}

package/esm/utoo/index.js

@@ -46,6 +46,10 @@ function takeObject(idx) {
     dropObject(idx);
     return ret;
 }
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
 let WASM_VECTOR_LEN = 0;
 const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available'); } });
 const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
@@ -98,17 +102,13 @@ function getDataViewMemory0() {
     }
     return cachedDataViewMemory0;
 }
-function getArrayU8FromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
-}
 function isLikeNone(x) {
     return x === undefined || x === null;
 }
 const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => { }, unregister: () => { } }
     : new FinalizationRegistry(state => {
-        wasm.__wbindgen_export_3.get(state.dtor)(state.a, state.b);
+        wasm.__wbindgen_export_4.get(state.dtor)(state.a, state.b);
     });
 function makeMutClosure(arg0, arg1, dtor, f) {
     const state = { a: arg0, b: arg1, cnt: 1, dtor };
@@ -124,7 +124,7 @@ function makeMutClosure(arg0, arg1, dtor, f) {
         }
         finally {
             if (--state.cnt === 0) {
-                wasm.__wbindgen_export_3.get(state.dtor)(a, state.b);
+                wasm.__wbindgen_export_4.get(state.dtor)(a, state.b);
                 CLOSURE_DTORS.unregister(state);
             }
             else {
@@ -204,14 +204,26 @@ function debugString(val) {
     // TODO we could test for more things here, like `Set`s and `Map`s.
     return className;
 }
-function __wbg_adapter_28(arg0, arg1) {
+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();
+}
+function __wbg_adapter_30(arg0, arg1) {
     wasm.__wbindgen_export_5(arg0, arg1);
 }
-function __wbg_adapter_31(arg0, arg1, arg2) {
+function __wbg_adapter_33(arg0, arg1, arg2) {
     wasm.__wbindgen_export_6(arg0, arg1, addHeapObject(arg2));
 }
-function __wbg_adapter_66(arg0, arg1, arg2, arg3) {
-    wasm.__wbindgen_export_7(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wbg_adapter_36(arg0, arg1) {
+    wasm.__wbindgen_export_7(arg0, arg1);
+}
+function __wbg_adapter_71(arg0, arg1, arg2, arg3) {
+    wasm.__wbindgen_export_8(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 const __wbindgen_enum_DirEntryType = ["file", "directory"];
 const __wbindgen_enum_FileSystemHandleKind = ["file", "directory"];
@@ -289,14 +301,14 @@ export class DirEntry {
         }
         finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
+            wasm.__wbindgen_export_1(deferred1_0, deferred1_1, 1);
         }
     }
     /**
      * @param {string} arg0
      */
     set name(arg0) {
-        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_export_2, wasm.__wbindgen_export_3);
         const len0 = WASM_VECTOR_LEN;
         wasm.__wbg_set_direntry_name(this.__wbg_ptr, ptr0, len0);
     }
@@ -332,7 +344,7 @@ export class Project {
      * @param {string} cwd
      */
     constructor(cwd) {
-        const ptr0 = passStringToWasm0(cwd, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+        const ptr0 = passStringToWasm0(cwd, wasm.__wbindgen_export_2, wasm.__wbindgen_export_3);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.project_new(ptr0, len0);
         this.__wbg_ptr = ret >>> 0;
@@ -356,7 +368,7 @@ export class Project {
         }
         finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
+            wasm.__wbindgen_export_1(deferred1_0, deferred1_1, 1);
         }
     }
     /**
@@ -364,7 +376,7 @@ export class Project {
      * @returns {Promise<void>}
      */
     install(package_lock) {
-        const ptr0 = passStringToWasm0(package_lock, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+        const ptr0 = passStringToWasm0(package_lock, wasm.__wbindgen_export_2, wasm.__wbindgen_export_3);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.project_install(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
@@ -376,14 +388,37 @@ export class Project {
         const ret = wasm.project_build(this.__wbg_ptr);
         return takeObject(ret);
     }
+    /**
+     * @param {string} path
+     * @returns {Promise<Uint8Array>}
+     */
+    read(path) {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_export_2, wasm.__wbindgen_export_3);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.project_read(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
     /**
      * @param {string} path
      * @returns {Promise<string>}
      */
-    readFile(path) {
-        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+    readToString(path) {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_export_2, wasm.__wbindgen_export_3);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.project_readToString(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @param {string} path
+     * @param {Uint8Array} content
+     * @returns {Promise<void>}
+     */
+    write(path, content) {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_export_2, wasm.__wbindgen_export_3);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.project_readFile(this.__wbg_ptr, ptr0, len0);
+        const ptr1 = passArray8ToWasm0(content, wasm.__wbindgen_export_2);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.project_write(this.__wbg_ptr, ptr0, len0, ptr1, len1);
         return takeObject(ret);
     }
     /**
@@ -391,12 +426,12 @@ export class Project {
      * @param {string} content
      * @returns {Promise<void>}
      */
-    writeFile(path, content) {
-        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+    writeString(path, content) {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_export_2, wasm.__wbindgen_export_3);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(content, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+        const ptr1 = passStringToWasm0(content, wasm.__wbindgen_export_2, wasm.__wbindgen_export_3);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.project_writeFile(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        const ret = wasm.project_writeString(this.__wbg_ptr, ptr0, len0, ptr1, len1);
         return takeObject(ret);
     }
     /**
@@ -404,7 +439,7 @@ export class Project {
      * @returns {Promise<DirEntry[]>}
      */
     readDir(path) {
-        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_export_2, wasm.__wbindgen_export_3);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.project_readDir(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
@@ -414,7 +449,7 @@ export class Project {
      * @returns {Promise<void>}
      */
     createDir(path) {
-        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_export_2, wasm.__wbindgen_export_3);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.project_createDir(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
@@ -424,7 +459,7 @@ export class Project {
      * @returns {Promise<void>}
      */
     createDirAll(path) {
-        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_export_2, wasm.__wbindgen_export_3);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.project_createDirAll(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
@@ -435,9 +470,9 @@ export class Project {
      * @returns {Promise<void>}
      */
     copyFile(src, dst) {
-        const ptr0 = passStringToWasm0(src, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+        const ptr0 = passStringToWasm0(src, wasm.__wbindgen_export_2, wasm.__wbindgen_export_3);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(dst, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+        const ptr1 = passStringToWasm0(dst, wasm.__wbindgen_export_2, wasm.__wbindgen_export_3);
         const len1 = WASM_VECTOR_LEN;
         const ret = wasm.project_copyFile(this.__wbg_ptr, ptr0, len0, ptr1, len1);
         return takeObject(ret);
@@ -518,6 +553,12 @@ function __wbg_get_imports() {
         const ret = CreateSyncAccessHandleOptions.__wrap(arg0);
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_debug_3cb59063b29f58c1 = function (arg0) {
+        console.debug(getObject(arg0));
+    };
+    imports.wbg.__wbg_debug_e17b51583ca6a632 = function (arg0, arg1, arg2, arg3) {
+        console.debug(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
+    };
     imports.wbg.__wbg_direntry_new = function (arg0) {
         const ret = DirEntry.__wrap(arg0);
         return addHeapObject(ret);
@@ -530,6 +571,24 @@ function __wbg_get_imports() {
         const ret = getObject(arg0).entries();
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_error_524f506f44df1645 = function (arg0) {
+        console.error(getObject(arg0));
+    };
+    imports.wbg.__wbg_error_7534b8e9a36f1ab4 = function (arg0, arg1) {
+        let deferred0_0;
+        let deferred0_1;
+        try {
+            deferred0_0 = arg0;
+            deferred0_1 = arg1;
+            console.error(getStringFromWasm0(arg0, arg1));
+        }
+        finally {
+            wasm.__wbindgen_export_1(deferred0_0, deferred0_1, 1);
+        }
+    };
+    imports.wbg.__wbg_error_80de38b3f7cc3c3c = function (arg0, arg1, arg2, arg3) {
+        console.error(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
+    };
     imports.wbg.__wbg_fetch_11bff8299d0ecd2b = function (arg0) {
         const ret = fetch(getObject(arg0));
         return addHeapObject(ret);
@@ -554,6 +613,11 @@ function __wbg_get_imports() {
         const ret = getObject(arg0).getFileHandle(getStringFromWasm0(arg1, arg2), getObject(arg3));
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_getRandomValues_21a0191e74d0e1d3 = function () {
+        return handleError(function (arg0, arg1) {
+            globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
+        }, arguments);
+    };
     imports.wbg.__wbg_getSize_e7dbd5ffa0b43df1 = function () {
         return handleError(function (arg0) {
             const ret = getObject(arg0).getSize();
@@ -580,6 +644,12 @@ function __wbg_get_imports() {
         const ret = getObject(arg0).headers;
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_info_033d8b8a0838f1d3 = function (arg0, arg1, arg2, arg3) {
+        console.info(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
+    };
+    imports.wbg.__wbg_info_3daf2e093e091b66 = function (arg0) {
+        console.info(getObject(arg0));
+    };
     imports.wbg.__wbg_instanceof_DomException_ed1ccb7aaf39034c = function (arg0) {
         let result;
         try {
@@ -627,7 +697,7 @@ function __wbg_get_imports() {
     };
     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);
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export_2, wasm.__wbindgen_export_3);
         const len1 = WASM_VECTOR_LEN;
         getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
         getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
@@ -649,7 +719,7 @@ function __wbg_get_imports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wbg_adapter_66(a, state0.b, arg0, arg1);
+                    return __wbg_adapter_71(a, state0.b, arg0, arg1);
                 }
                 finally {
                     state0.a = a;
@@ -666,6 +736,10 @@ function __wbg_get_imports() {
         const ret = new Object();
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_new_8a6f238a6ece86ea = function () {
+        const ret = new Error();
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_new_a12002a7f91c75be = function (arg0) {
         const ret = new Uint8Array(getObject(arg0));
         return addHeapObject(ret);
@@ -706,6 +780,14 @@ function __wbg_get_imports() {
             return addHeapObject(ret);
         }, arguments);
     };
+    imports.wbg.__wbg_now_e1163c67115ff874 = function (arg0) {
+        const ret = getObject(arg0).now();
+        return ret;
+    };
+    imports.wbg.__wbg_performance_7fe0928f3ab059e5 = function (arg0) {
+        const ret = getObject(arg0).performance;
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_queueMicrotask_97d92b4fcc8a61c5 = function (arg0) {
         queueMicrotask(getObject(arg0));
     };
@@ -719,10 +801,20 @@ function __wbg_get_imports() {
             return ret;
         }, arguments);
     };
+    imports.wbg.__wbg_removeEntry_a424e90dff229b19 = function (arg0, arg1, arg2, arg3) {
+        const ret = getObject(arg0).removeEntry(getStringFromWasm0(arg1, arg2), getObject(arg3));
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_resolve_4851785c9c5f573d = function (arg0) {
         const ret = Promise.resolve(getObject(arg0));
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_setTimeout_42370cb3051b8c2c = function () {
+        return handleError(function (arg0, arg1, arg2) {
+            const ret = getObject(arg0).setTimeout(getObject(arg1), arg2);
+            return addHeapObject(ret);
+        }, arguments);
+    };
     imports.wbg.__wbg_setTimeout_73ce8df12de4f2f2 = function (arg0, arg1) {
         const ret = setTimeout(getObject(arg0), arg1);
         return addHeapObject(ret);
@@ -754,6 +846,9 @@ function __wbg_get_imports() {
     imports.wbg.__wbg_setmode_5dc300b865044b65 = function (arg0, arg1) {
         getObject(arg0).mode = __wbindgen_enum_RequestMode[arg1];
     };
+    imports.wbg.__wbg_setrecursive_536113a081d6177a = function (arg0, arg1) {
+        getObject(arg0).recursive = arg1 !== 0;
+    };
     imports.wbg.__wbg_setsignal_75b21ef3a81de905 = function (arg0, arg1) {
         getObject(arg0).signal = getObject(arg1);
     };
@@ -761,6 +856,13 @@ function __wbg_get_imports() {
         const ret = getObject(arg0).signal;
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_stack_0ed75d68575b0f3c = function (arg0, arg1) {
+        const ret = getObject(arg1).stack;
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export_2, wasm.__wbindgen_export_3);
+        const len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
     imports.wbg.__wbg_static_accessor_GLOBAL_88a902d13a557d07 = function () {
         const ret = typeof global === 'undefined' ? null : global;
         return isLikeNone(ret) ? 0 : addHeapObject(ret);
@@ -810,7 +912,7 @@ function __wbg_get_imports() {
     };
     imports.wbg.__wbg_url_ae10c34ca209681d = function (arg0, arg1) {
         const ret = getObject(arg1).url;
-        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export_2, wasm.__wbindgen_export_3);
         const len1 = WASM_VECTOR_LEN;
         getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
         getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
@@ -819,6 +921,12 @@ function __wbg_get_imports() {
         const ret = getObject(arg0).value;
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_warn_4ca3906c248c47c4 = function (arg0) {
+        console.warn(getObject(arg0));
+    };
+    imports.wbg.__wbg_warn_aaf1f4664a035bd6 = function (arg0, arg1, arg2, arg3) {
+        console.warn(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
+    };
     imports.wbg.__wbg_write_530d3c84df874f53 = function () {
         return handleError(function (arg0, arg1, arg2, arg3) {
             const ret = getObject(arg0).write(getArrayU8FromWasm0(arg1, arg2), getObject(arg3));
@@ -841,17 +949,21 @@ function __wbg_get_imports() {
         const ret = false;
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper1053 = function (arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 172, __wbg_adapter_28);
+    imports.wbg.__wbindgen_closure_wrapper220138 = function (arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 148252, __wbg_adapter_33);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper1670 = function (arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 443, __wbg_adapter_31);
+    imports.wbg.__wbindgen_closure_wrapper220295 = function (arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 148274, __wbg_adapter_36);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_closure_wrapper33472 = function (arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 19113, __wbg_adapter_30);
         return addHeapObject(ret);
     };
     imports.wbg.__wbindgen_debug_string = function (arg0, arg1) {
         const ret = debugString(getObject(arg1));
-        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export_2, wasm.__wbindgen_export_3);
         const len1 = WASM_VECTOR_LEN;
         getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
         getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
@@ -883,7 +995,7 @@ function __wbg_get_imports() {
     imports.wbg.__wbindgen_string_get = function (arg0, arg1) {
         const obj = getObject(arg1);
         const ret = typeof (obj) === 'string' ? obj : undefined;
-        var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+        var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export_2, wasm.__wbindgen_export_3);
         var len1 = WASM_VECTOR_LEN;
         getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
         getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
@@ -895,6 +1007,12 @@ function __wbg_get_imports() {
     imports.wbg.__wbindgen_throw = function (arg0, arg1) {
         throw new Error(getStringFromWasm0(arg0, arg1));
     };
+    imports.wbg.__wbindgen_uint8_array_new = function (arg0, arg1) {
+        var v0 = getArrayU8FromWasm0(arg0, arg1).slice();
+        wasm.__wbindgen_export_1(arg0, arg1 * 1, 1);
+        const ret = v0;
+        return addHeapObject(ret);
+    };
     return imports;
 }
 function __wbg_init_memory(imports, memory) {
@@ -904,6 +1022,7 @@ function __wbg_finalize_init(instance, module) {
     __wbg_init.__wbindgen_wasm_module = module;
     cachedDataViewMemory0 = null;
     cachedUint8ArrayMemory0 = null;
+    wasm.__wbindgen_start();
     return wasm;
 }
 function initSync(module) {

package/esm/worker.js

@@ -1,35 +1,71 @@
 import * as comlink from "comlink";
 import { HandShake } from "./message";
 import initWasm, { Project as ProjectInternal } from "./utoo";
+const WasmInit = initWasm();
 const projectEndpoint = {
     projectInternal: undefined,
     async mount(cwd) {
-        await initWasm();
+        await WasmInit;
         this.projectInternal = new ProjectInternal(cwd);
+        return;
     },
     async install(packageLock) {
+        await WasmInit;
         await this.projectInternal.install(packageLock);
+        return;
     },
     async build() {
-        await this.projectInternal.build();
+        await WasmInit;
+        return await this.projectInternal.build();
     },
-    async readFile(path) {
-        return await this.projectInternal.readFile(path);
+    async readFile(path, encoding) {
+        await WasmInit;
+        let ret;
+        if (encoding === "utf8") {
+            ret = await this.projectInternal.readToString(path);
+        }
+        else {
+            ret = await this.projectInternal.read(path);
+        }
+        return ret;
     },
-    async writeFile(path, content) {
-        return await this.projectInternal.writeFile(path, content);
+    async writeFile(path, content, _encoding) {
+        await WasmInit;
+        if (typeof content === "string") {
+            return await this.projectInternal.writeString(path, content);
+        }
+        else {
+            return await this.projectInternal.write(path, content);
+        }
     },
     async copyFile(src, dst) {
+        await WasmInit;
         return await this.projectInternal.copyFile(src, dst);
     },
-    async readDir(path) {
-        return (await this.projectInternal.readDir(path)).map((e) => e.toJSON());
+    async readdir(path, options) {
+        await WasmInit;
+        const dirEntries = (options === null || options === void 0 ? void 0 : options.recursive)
+            ? await this.projectInternal.readDir(path)
+            : // TODO: support recursive readDirAll
+                await this.projectInternal.readDir(path);
+        const rawDirents = dirEntries.map((e) => {
+            const dir = e.toJSON();
+            return {
+                name: dir.name,
+                type: dir.type,
+            };
+        });
+        // WARN: This is a hack, functions can not be structurally cloned
+        return rawDirents;
     },
-    async createDir(path) {
-        return await this.projectInternal.createDir(path);
-    },
-    async createDirAll(path) {
-        return await this.projectInternal.createDirAll(path);
+    async mkdir(path, options) {
+        await WasmInit;
+        if (options === null || options === void 0 ? void 0 : options.recursive) {
+            return await this.projectInternal.createDirAll(path);
+        }
+        else {
+            return await this.projectInternal.createDir(path);
+        }
     },
 };
 const ConnectedPorts = new Set();

package/package.json

@@ -1,16 +1,21 @@
 {
   "name": "@utoo/web",
-  "version": "0.0.1-alpha.2",
+  "version": "0.0.1-alpha.8",
   "module": "esm/index.js",
   "types": "esm/index.d.ts",
   "files": [
     "esm/*"
   ],
   "scripts": {
-    "wasmpack": "wasm-pack build ../../crates/utoo-wasm --out-dir ../../packages/utoo-web/src/utoo --out-name index --no-pack --target web",
+    "install-toolchain": "cargo install wasm-bindgen-cli && brew install binaryen",
+    "build-wasm": "cargo build -p utoo-wasm --target wasm32-unknown-unknown",
+    "build-wasm:pm": "cargo build -p utoo-wasm --target wasm32-unknown-unknown --no-default-features",
+    "bindgen-dev": "wasm-bindgen ../../target/wasm32-unknown-unknown/wasm-dev/utoo_wasm.wasm --out-dir src/utoo --out-name index --target web --debug --keep-debug --no-demangle",
+    "bindgen-build": "wasm-bindgen ../../target/wasm32-unknown-unknown/wasm-release/utoo_wasm.wasm --out-dir src/utoo --out-name index --target web",
     "tsx": "rm -rf esm && tsc -p ./tsconfig.json",
-    "dev": "npm run wasmpack -- --dev && npm run tsx && cp ./src/utoo/*.wasm ./esm/utoo",
-    "build": "npm run wasmpack -- --release && npm run tsx && cp ./src/utoo/*.wasm ./esm/utoo",
+    "dev": "npm run build-wasm -- --profile wasm-dev && npm run bindgen-dev && npm run tsx && cp src/utoo/index_bg.wasm esm/utoo",
+    "dev:pm": "npm run build-wasm:pm -- --profile wasm-dev && npm run bindgen-dev && npm run tsx && cp src/utoo/index_bg.wasm esm/utoo",
+    "build": "npm run build-wasm -- --profile wasm-release && npm run bindgen-build && npm run tsx && wasm-opt src/utoo/index_bg.wasm -o esm/utoo/index_bg.wasm -O4 --enable-bulk-memory --enable-nontrapping-float-to-int",
     "prepublishOnly": "npm run build"
   },
   "dependencies": {