@utoo/web 1.2.0-rc.5 → 1.2.0-rc.7

package/esm/project.d.ts

@@ -1,4 +1,4 @@
-import { BuildOutput, Dirent, PackFile, ProjectEndpoint, ProjectOptions, ServiceWorkerOptions } from "./type";
+import { BuildOutput, Dirent, PackFile, ProjectEndpoint, ProjectOptions, ServiceWorkerOptions, Stats } from "./type";
 export declare class Project implements ProjectEndpoint {
     #private;
     private options;
@@ -26,6 +26,7 @@ export declare class Project implements ProjectEndpoint {
     rmdir(path: string, options?: {
         recursive?: boolean;
     }): Promise<void>;
+    stat(path: string): Promise<Stats>;
     gzip(files: PackFile[]): Promise<Uint8Array>;
     sigMd5(content: Uint8Array): Promise<string>;
     static fork(channel: MessageChannel, eventSource?: Client | DedicatedWorkerGlobalScope): ProjectEndpoint;

package/esm/project.js

@@ -15,7 +15,7 @@ import * as comlink from "comlink";
 import { ForkedProject } from "./forkedProject";
 import { installServiceWorker } from "./installServiceWorker";
 import { Fork, HandShake } from "./message";
-import { Dirent, } from "./type";
+import { Dirent, Stats, } from "./type";
 let ProjectWorker;
 const ConnectedPorts = new Set();
 export class Project {
@@ -81,6 +81,9 @@ export class Project {
     }
     async writeFile(path, content, encoding) {
         await __classPrivateFieldGet(this, _Project_mount, "f");
+        if (content instanceof Uint8Array) {
+            return await this.remote.writeFile(path, comlink.transfer(content, [content.buffer]), encoding);
+        }
         return await this.remote.writeFile(path, content, encoding);
     }
     async copyFile(src, dst) {
@@ -104,13 +107,19 @@ export class Project {
         await __classPrivateFieldGet(this, _Project_mount, "f");
         return await this.remote.rmdir(path, options);
     }
+    async stat(path) {
+        await __classPrivateFieldGet(this, _Project_mount, "f");
+        const raw = (await this.remote.stat(path));
+        return new Stats(raw);
+    }
     async gzip(files) {
         await __classPrivateFieldGet(this, _Project_mount, "f");
-        return await this.remote.gzip(files);
+        const buffers = files.map((f) => f.content.buffer);
+        return await this.remote.gzip(comlink.transfer(files, buffers));
     }
     async sigMd5(content) {
         await __classPrivateFieldGet(this, _Project_mount, "f");
-        return await this.remote.sigMd5(content);
+        return await this.remote.sigMd5(comlink.transfer(content, [content.buffer]));
     }
     static fork(channel, eventSource) {
         (eventSource || self).postMessage(Fork, {

package/esm/sabcom.d.ts

@@ -10,10 +10,17 @@ export declare const SAB_OP_RM = 5;
 export declare const SAB_OP_RMDIR = 6;
 export declare const SAB_OP_COPY_FILE = 7;
 export declare const SAB_OP_STAT = 8;
+export declare const STAT_TYPE_FILE = 0;
+export declare const STAT_TYPE_DIR = 1;
+export declare const SAB_INDEX_STATE = 0;
+export declare const SAB_INDEX_OP = 1;
+export declare const SAB_INDEX_DATA_LEN = 2;
+export declare const SAB_DATA_OFFSET = 12;
 export declare class SabComHost {
     private sab;
     private int32;
     private uint8;
+    private dataView;
     constructor(sab: SharedArrayBuffer);
     readRequest(): {
         op: number;
@@ -21,14 +28,24 @@ export declare class SabComHost {
     };
     writeResponse(data: Uint8Array | string): void;
     writeError(message: string): void;
+    writeStat(type: number, size: bigint, atimeMs: number, mtimeMs: number, ctimeMs: number, birthtimeMs: number): void;
 }
 export declare class SabComClient {
     private sab;
     private notifyHost;
     private int32;
     private uint8;
+    private dataView;
     constructor(sab: SharedArrayBuffer, notifyHost: () => void);
     call(op: number, data: string): Uint8Array<ArrayBuffer>;
+    callStat(path: string): {
+        type: number;
+        size: bigint;
+        atimeMs: number;
+        mtimeMs: number;
+        ctimeMs: number;
+        birthtimeMs: number;
+    };
 }
 export interface SabFileSystem {
     read(path: string): Promise<Uint8Array>;

package/esm/sabcom.js

@@ -10,6 +10,26 @@ export const SAB_OP_RM = 5;
 export const SAB_OP_RMDIR = 6;
 export const SAB_OP_COPY_FILE = 7;
 export const SAB_OP_STAT = 8;
+export const STAT_TYPE_FILE = 0;
+export const STAT_TYPE_DIR = 1;
+export const SAB_INDEX_STATE = 0;
+export const SAB_INDEX_OP = 1;
+export const SAB_INDEX_DATA_LEN = 2;
+export const SAB_DATA_OFFSET = 12;
+// Stat struct layout (starts at byte 12)
+// type: Uint8 (1 byte) -> offset 0
+// padding: 7 bytes
+// size: BigUint64 (8 bytes) -> offset 8
+// atimeMs: Float64 (8 bytes) -> offset 16
+// mtimeMs: Float64 (8 bytes) -> offset 24
+// ctimeMs: Float64 (8 bytes) -> offset 32
+// birthtimeMs: Float64 (8 bytes) -> offset 40
+const STAT_OFFSET_TYPE = 0;
+const STAT_OFFSET_SIZE = 8;
+const STAT_OFFSET_ATIME = 16;
+const STAT_OFFSET_MTIME = 24;
+const STAT_OFFSET_CTIME = 32;
+const STAT_OFFSET_BIRTHTIME = 40;
 // Layout:
 // 0: State (Int32)
 // 1: Op (Int32)
@@ -20,11 +40,12 @@ export class SabComHost {
         this.sab = sab;
         this.int32 = new Int32Array(sab);
         this.uint8 = new Uint8Array(sab);
+        this.dataView = new DataView(sab);
     }
     readRequest() {
-        const op = this.int32[1];
-        const len = this.int32[2];
-        const data = new TextDecoder().decode(this.uint8.slice(12, 12 + len));
+        const op = this.int32[SAB_INDEX_OP];
+        const len = this.int32[SAB_INDEX_DATA_LEN];
+        const data = new TextDecoder().decode(this.uint8.slice(SAB_DATA_OFFSET, SAB_DATA_OFFSET + len));
         return { op, data };
     }
     writeResponse(data) {
@@ -32,17 +53,28 @@ export class SabComHost {
             data = new TextEncoder().encode(data);
         }
         // TODO: Check size overflow
-        this.int32[2] = data.length;
-        this.uint8.set(data, 12);
-        Atomics.store(this.int32, 0, SAB_STATE_RESPONSE);
-        Atomics.notify(this.int32, 0);
+        this.int32[SAB_INDEX_DATA_LEN] = data.length;
+        this.uint8.set(data, SAB_DATA_OFFSET);
+        Atomics.store(this.int32, SAB_INDEX_STATE, SAB_STATE_RESPONSE);
+        Atomics.notify(this.int32, SAB_INDEX_STATE);
     }
     writeError(message) {
         const data = new TextEncoder().encode(message);
-        this.int32[2] = data.length;
-        this.uint8.set(data, 12);
-        Atomics.store(this.int32, 0, SAB_STATE_ERROR);
-        Atomics.notify(this.int32, 0);
+        this.int32[SAB_INDEX_DATA_LEN] = data.length;
+        this.uint8.set(data, SAB_DATA_OFFSET);
+        Atomics.store(this.int32, SAB_INDEX_STATE, SAB_STATE_ERROR);
+        Atomics.notify(this.int32, SAB_INDEX_STATE);
+    }
+    writeStat(type, size, atimeMs, mtimeMs, ctimeMs, birthtimeMs) {
+        const base = SAB_DATA_OFFSET;
+        this.dataView.setUint8(base + STAT_OFFSET_TYPE, type);
+        this.dataView.setBigUint64(base + STAT_OFFSET_SIZE, size, true);
+        this.dataView.setFloat64(base + STAT_OFFSET_ATIME, atimeMs, true);
+        this.dataView.setFloat64(base + STAT_OFFSET_MTIME, mtimeMs, true);
+        this.dataView.setFloat64(base + STAT_OFFSET_CTIME, ctimeMs, true);
+        this.dataView.setFloat64(base + STAT_OFFSET_BIRTHTIME, birthtimeMs, true);
+        Atomics.store(this.int32, SAB_INDEX_STATE, SAB_STATE_RESPONSE);
+        Atomics.notify(this.int32, SAB_INDEX_STATE);
     }
 }
 export class SabComClient {
@@ -51,23 +83,48 @@ export class SabComClient {
         this.notifyHost = notifyHost;
         this.int32 = new Int32Array(sab);
         this.uint8 = new Uint8Array(sab);
+        this.dataView = new DataView(sab);
     }
     call(op, data) {
         const encoded = new TextEncoder().encode(data);
-        this.int32[1] = op;
-        this.int32[2] = encoded.length;
-        this.uint8.set(encoded, 12);
-        Atomics.store(this.int32, 0, SAB_STATE_REQUEST);
+        this.int32[SAB_INDEX_OP] = op;
+        this.int32[SAB_INDEX_DATA_LEN] = encoded.length;
+        this.uint8.set(encoded, SAB_DATA_OFFSET);
+        Atomics.store(this.int32, SAB_INDEX_STATE, SAB_STATE_REQUEST);
+        this.notifyHost();
+        Atomics.wait(this.int32, SAB_INDEX_STATE, SAB_STATE_REQUEST);
+        const state = Atomics.load(this.int32, SAB_INDEX_STATE);
+        if (state === SAB_STATE_ERROR) {
+            const len = this.int32[SAB_INDEX_DATA_LEN];
+            const msg = new TextDecoder().decode(this.uint8.slice(SAB_DATA_OFFSET, SAB_DATA_OFFSET + len));
+            throw new Error(msg);
+        }
+        const len = this.int32[SAB_INDEX_DATA_LEN];
+        return this.uint8.slice(SAB_DATA_OFFSET, SAB_DATA_OFFSET + len);
+    }
+    callStat(path) {
+        const encoded = new TextEncoder().encode(path);
+        this.int32[SAB_INDEX_OP] = SAB_OP_STAT;
+        this.int32[SAB_INDEX_DATA_LEN] = encoded.length;
+        this.uint8.set(encoded, SAB_DATA_OFFSET);
+        Atomics.store(this.int32, SAB_INDEX_STATE, SAB_STATE_REQUEST);
         this.notifyHost();
-        Atomics.wait(this.int32, 0, SAB_STATE_REQUEST);
-        const state = Atomics.load(this.int32, 0);
+        Atomics.wait(this.int32, SAB_INDEX_STATE, SAB_STATE_REQUEST);
+        const state = Atomics.load(this.int32, SAB_INDEX_STATE);
         if (state === SAB_STATE_ERROR) {
-            const len = this.int32[2];
-            const msg = new TextDecoder().decode(this.uint8.slice(12, 12 + len));
+            const len = this.int32[SAB_INDEX_DATA_LEN];
+            const msg = new TextDecoder().decode(this.uint8.slice(SAB_DATA_OFFSET, SAB_DATA_OFFSET + len));
             throw new Error(msg);
         }
-        const len = this.int32[2];
-        return this.uint8.slice(12, 12 + len);
+        const base = SAB_DATA_OFFSET;
+        return {
+            type: this.dataView.getUint8(base + STAT_OFFSET_TYPE),
+            size: this.dataView.getBigUint64(base + STAT_OFFSET_SIZE, true),
+            atimeMs: this.dataView.getFloat64(base + STAT_OFFSET_ATIME, true),
+            mtimeMs: this.dataView.getFloat64(base + STAT_OFFSET_MTIME, true),
+            ctimeMs: this.dataView.getFloat64(base + STAT_OFFSET_CTIME, true),
+            birthtimeMs: this.dataView.getFloat64(base + STAT_OFFSET_BIRTHTIME, true),
+        };
     }
 }
 export const handleSabRequest = async (sabHost, fs) => {
@@ -82,9 +139,7 @@ export const handleSabRequest = async (sabHost, fs) => {
             sabHost.writeResponse(JSON.stringify(entries.map((e) => e.toJSON())));
         }
         else if (op === SAB_OP_WRITE_FILE) {
-            const { content, encoding } = JSON.parse(path);
-            const filePath = content.path;
-            const fileContent = content.data;
+            const { path: filePath, data: fileContent } = JSON.parse(path);
             // TODO: handle binary content (base64?)
             await fs.writeString(filePath, fileContent);
             sabHost.writeResponse("ok");
@@ -103,7 +158,10 @@ export const handleSabRequest = async (sabHost, fs) => {
             const { path: rmPath, recursive } = JSON.parse(path);
             // Mimic internalProject.rm logic
             const metadata = await fs.metadata(rmPath);
-            const type = metadata.toJSON().type;
+            const json = metadata.toJSON
+                ? metadata.toJSON()
+                : metadata;
+            const type = json.type;
             if (type === "file") {
                 await fs.removeFile(rmPath);
             }
@@ -124,7 +182,16 @@ export const handleSabRequest = async (sabHost, fs) => {
         }
         else if (op === SAB_OP_STAT) {
             const metadata = await fs.metadata(path);
-            sabHost.writeResponse(JSON.stringify(metadata));
+            const json = metadata.toJSON
+                ? metadata.toJSON()
+                : metadata;
+            const type = json.type === "directory" ? STAT_TYPE_DIR : STAT_TYPE_FILE;
+            const size = BigInt(json.file_size || 0);
+            const atimeMs = Number(json.atimeMs || 0);
+            const mtimeMs = Number(json.mtimeMs || 0);
+            const ctimeMs = Number(json.ctimeMs || 0);
+            const birthtimeMs = Number(json.birthtimeMs || 0);
+            sabHost.writeStat(type, size, atimeMs, mtimeMs, ctimeMs, birthtimeMs);
         }
         else {
             sabHost.writeError("Unknown op");

package/esm/serviceWorker.js

@@ -60,6 +60,7 @@ async function readFileFromProject(projectPath) {
         });
     }
     catch (e) {
+        console.error(`File ${projectPath} not found`);
         return new Response("Not Found", { status: 404 });
     }
 }

package/esm/type.d.ts

@@ -4,6 +4,43 @@ export interface RawDirent {
     name: string;
     type: DirEntryType;
 }
+export interface RawStats {
+    type: DirEntryType;
+    size: number;
+    atimeMs?: number;
+    mtimeMs?: number;
+    ctimeMs?: number;
+    birthtimeMs?: number;
+}
+export declare class Stats {
+    private raw;
+    dev: number;
+    ino: number;
+    mode: number;
+    nlink: number;
+    uid: number;
+    gid: number;
+    rdev: number;
+    size: number;
+    blksize: number;
+    blocks: number;
+    atimeMs: number;
+    mtimeMs: number;
+    ctimeMs: number;
+    birthtimeMs: number;
+    atime: Date;
+    mtime: Date;
+    ctime: Date;
+    birthtime: Date;
+    constructor(raw: RawStats);
+    isDirectory(): boolean;
+    isFile(): boolean;
+    isSymbolicLink(): boolean;
+    isBlockDevice(): boolean;
+    isCharacterDevice(): boolean;
+    isFIFO(): boolean;
+    isSocket(): boolean;
+}
 export declare class Dirent {
     private rawDirent;
     name: string;
@@ -37,6 +74,7 @@ export interface ProjectEndpoint {
         recursive?: boolean;
     }): Promise<void>;
     copyFile(src: string, dst: string): Promise<void>;
+    stat(path: string): Promise<Stats>;
     gzip: (files: PackFile[]) => Promise<Uint8Array>;
     sigMd5: (content: Uint8Array) => Promise<string>;
 }

package/esm/type.js

@@ -1,3 +1,47 @@
+export class Stats {
+    constructor(raw) {
+        this.raw = raw;
+        this.dev = 0;
+        this.ino = 0;
+        this.nlink = 1;
+        this.uid = 0;
+        this.gid = 0;
+        this.rdev = 0;
+        this.blksize = 4096;
+        this.blocks = 0;
+        this.size = raw.size;
+        this.mode = raw.type === "directory" ? 16877 : 33188;
+        this.atimeMs = raw.atimeMs || 0;
+        this.mtimeMs = raw.mtimeMs || 0;
+        this.ctimeMs = raw.ctimeMs || 0;
+        this.birthtimeMs = raw.birthtimeMs || 0;
+        this.atime = new Date(this.atimeMs);
+        this.mtime = new Date(this.mtimeMs);
+        this.ctime = new Date(this.ctimeMs);
+        this.birthtime = new Date(this.birthtimeMs);
+    }
+    isDirectory() {
+        return this.raw.type === "directory";
+    }
+    isFile() {
+        return this.raw.type === "file";
+    }
+    isSymbolicLink() {
+        return false;
+    }
+    isBlockDevice() {
+        return false;
+    }
+    isCharacterDevice() {
+        return false;
+    }
+    isFIFO() {
+        return false;
+    }
+    isSocket() {
+        return false;
+    }
+}
 export class Dirent {
     constructor(rawDirent) {
         this.rawDirent = rawDirent;

package/esm/utoo/index.d.ts

@@ -88,100 +88,103 @@ export class Metadata {
     get file_size(): bigint;
 }
 export class Project {
-    /**
-     * @param {string} cwd
-     * @param {string} thread_url
-     */
-    constructor(cwd: string, thread_url: string);
-    __destroy_into_raw(): number;
-    __wbg_ptr: number;
-    free(): void;
     /**
      * @param {string} path
      * @returns {Promise<void>}
      */
-    createDir(path: string): Promise<void>;
+    static createDir(path: string): Promise<void>;
     /**
      * @param {string} path
      * @param {boolean} recursive
      * @returns {Promise<void>}
      */
-    removeDir(path: string, recursive: boolean): Promise<void>;
+    static removeDir(path: string, recursive: boolean): Promise<void>;
     /**
      * @param {string} path
      * @returns {Promise<void>}
      */
-    removeFile(path: string): Promise<void>;
+    static removeFile(path: string): Promise<void>;
     /**
      * @param {string} path
      * @param {string} content
      * @returns {Promise<void>}
      */
-    writeString(path: string, content: string): Promise<void>;
+    static writeString(path: string, content: string): Promise<void>;
     /**
      * @param {string} path
      * @returns {Promise<void>}
      */
-    createDirAll(path: string): Promise<void>;
+    static createDirAll(path: string): Promise<void>;
     /**
      * @param {string} path
      * @returns {Promise<string>}
      */
-    readToString(path: string): Promise<string>;
+    static readToString(path: string): Promise<string>;
     /**
      * @returns {string}
      */
-    get cwd(): string;
+    static 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;
+    static gzip(files: any): Uint8Array;
+    /**
+     * @param {string} thread_url
+     */
+    static init(thread_url: string): void;
     /**
      * @param {string} path
      * @returns {Promise<Uint8Array>}
      */
-    read(path: string): Promise<Uint8Array>;
+    static read(path: string): Promise<Uint8Array>;
     /**
      * @returns {Promise<any>}
      */
-    build(): Promise<any>;
+    static build(): Promise<any>;
     /**
      * @param {string} path
      * @param {Uint8Array} content
      * @returns {Promise<void>}
      */
-    write(path: string, content: Uint8Array): Promise<void>;
+    static write(path: string, content: Uint8Array): Promise<void>;
     /**
      * @param {string} package_lock
      * @param {number | null} [max_concurrent_downloads]
      * @returns {Promise<void>}
      */
-    install(package_lock: string, max_concurrent_downloads?: number | null): Promise<void>;
+    static install(package_lock: string, max_concurrent_downloads?: number | null): Promise<void>;
+    /**
+     * @param {string} path
+     */
+    static setCwd(path: string): void;
     /**
      * Calculate MD5 hash of byte content
      * @param {Uint8Array} content
      * @returns {string}
      */
-    sigMd5(content: Uint8Array): string;
+    static sigMd5(content: Uint8Array): string;
     /**
      * @param {string} path
      * @returns {Promise<Metadata>}
      */
-    metadata(path: string): Promise<Metadata>;
+    static metadata(path: string): Promise<Metadata>;
     /**
      * @param {string} path
      * @returns {Promise<DirEntry[]>}
      */
-    readDir(path: string): Promise<DirEntry[]>;
+    static readDir(path: string): Promise<DirEntry[]>;
     /**
      * @param {string} src
      * @param {string} dst
      * @returns {Promise<void>}
      */
-    copyFile(src: string, dst: string): Promise<void>;
+    static copyFile(src: string, dst: string): Promise<void>;
+    __destroy_into_raw(): number | undefined;
+    __wbg_ptr: number | undefined;
+    free(): void;
 }
 export class WasmTaskMessage {
     static __wrap(ptr: any): any;