@utoo/web 1.2.0-rc.4 → 1.2.0-rc.6

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 {
@@ -104,6 +104,11 @@ 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);

package/esm/sabcom.d.ts

@@ -10,10 +10,13 @@ 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 class SabComHost {
     private sab;
     private int32;
     private uint8;
+    statStruct: any;
     constructor(sab: SharedArrayBuffer);
     readRequest(): {
         op: number;
@@ -21,14 +24,17 @@ export declare class SabComHost {
     };
     writeResponse(data: Uint8Array | string): void;
     writeError(message: string): void;
+    writeStatResponse(): void;
 }
 export declare class SabComClient {
     private sab;
     private notifyHost;
     private int32;
     private uint8;
+    statStruct: any;
     constructor(sab: SharedArrayBuffer, notifyHost: () => void);
     call(op: number, data: string): Uint8Array<ArrayBuffer>;
+    callStat(path: string): any;
 }
 export interface SabFileSystem {
     read(path: string): Promise<Uint8Array>;

package/esm/sabcom.js

@@ -1,3 +1,4 @@
+import { BigUint64, BufferBackedObject, Float64, Uint8, } from "buffer-backed-object";
 export const SAB_STATE_IDLE = 0;
 export const SAB_STATE_REQUEST = 1;
 export const SAB_STATE_RESPONSE = 2;
@@ -10,6 +11,16 @@ 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;
+const StatDescriptor = {
+    type: Uint8(),
+    size: BigUint64(),
+    atimeMs: Float64(),
+    mtimeMs: Float64(),
+    ctimeMs: Float64(),
+    birthtimeMs: Float64(),
+};
 // Layout:
 // 0: State (Int32)
 // 1: Op (Int32)
@@ -20,6 +31,9 @@ export class SabComHost {
         this.sab = sab;
         this.int32 = new Int32Array(sab);
         this.uint8 = new Uint8Array(sab);
+        this.statStruct = BufferBackedObject(sab, StatDescriptor, {
+            byteOffset: 12,
+        });
     }
     readRequest() {
         const op = this.int32[1];
@@ -44,6 +58,10 @@ export class SabComHost {
         Atomics.store(this.int32, 0, SAB_STATE_ERROR);
         Atomics.notify(this.int32, 0);
     }
+    writeStatResponse() {
+        Atomics.store(this.int32, 0, SAB_STATE_RESPONSE);
+        Atomics.notify(this.int32, 0);
+    }
 }
 export class SabComClient {
     constructor(sab, notifyHost) {
@@ -51,6 +69,9 @@ export class SabComClient {
         this.notifyHost = notifyHost;
         this.int32 = new Int32Array(sab);
         this.uint8 = new Uint8Array(sab);
+        this.statStruct = BufferBackedObject(sab, StatDescriptor, {
+            byteOffset: 12,
+        });
     }
     call(op, data) {
         const encoded = new TextEncoder().encode(data);
@@ -69,6 +90,22 @@ export class SabComClient {
         const len = this.int32[2];
         return this.uint8.slice(12, 12 + len);
     }
+    callStat(path) {
+        const encoded = new TextEncoder().encode(path);
+        this.int32[1] = SAB_OP_STAT;
+        this.int32[2] = encoded.length;
+        this.uint8.set(encoded, 12);
+        Atomics.store(this.int32, 0, SAB_STATE_REQUEST);
+        this.notifyHost();
+        Atomics.wait(this.int32, 0, SAB_STATE_REQUEST);
+        const state = Atomics.load(this.int32, 0);
+        if (state === SAB_STATE_ERROR) {
+            const len = this.int32[2];
+            const msg = new TextDecoder().decode(this.uint8.slice(12, 12 + len));
+            throw new Error(msg);
+        }
+        return this.statStruct;
+    }
 }
 export const handleSabRequest = async (sabHost, fs) => {
     const { op, data: path } = sabHost.readRequest();
@@ -82,9 +119,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 +138,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 +162,17 @@ 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;
+            sabHost.statStruct.type =
+                json.type === "directory" ? STAT_TYPE_DIR : STAT_TYPE_FILE;
+            sabHost.statStruct.size = BigInt(json.file_size || 0);
+            sabHost.statStruct.atimeMs = Number(json.atimeMs || 0);
+            sabHost.statStruct.mtimeMs = Number(json.mtimeMs || 0);
+            sabHost.statStruct.ctimeMs = Number(json.ctimeMs || 0);
+            sabHost.statStruct.birthtimeMs = Number(json.birthtimeMs || 0);
+            sabHost.writeStatResponse();
         }
         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;