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

package/esm/webpackLoaders/polyfills/fsPromisesPolyfill.js

@@ -0,0 +1,112 @@
+import { Buffer } from "buffer";
+import path from "path";
+import { Stats } from "../../type";
+function resolvePath(p) {
+    var _a, _b, _c;
+    // @ts-ignore
+    const cwd = ((_b = (_a = self.process) === null || _a === void 0 ? void 0 : _a.cwd) === null || _b === void 0 ? void 0 : _b.call(_a)) || ((_c = self.workerData) === null || _c === void 0 ? void 0 : _c.cwd) || "/";
+    return path.resolve(cwd, p);
+}
+function getFs() {
+    // @ts-ignore
+    const fs = self.workerData.fs;
+    if (!fs) {
+        throw new Error("FS not initialized");
+    }
+    return fs;
+}
+export const promises = {
+    readFile: async (p, options) => {
+        const encoding = options === "utf8" ||
+            options === "utf-8" ||
+            (options === null || options === void 0 ? void 0 : options.encoding) === "utf8" ||
+            (options === null || options === void 0 ? void 0 : options.encoding) === "utf-8"
+            ? "utf8"
+            : undefined;
+        const fs = getFs();
+        const path = resolvePath(p);
+        const data = await (encoding ? fs.readToString(path) : fs.read(path));
+        return encoding ? data : Buffer.from(data);
+    },
+    writeFile: async (p, data, options) => {
+        const fs = getFs();
+        const path = resolvePath(p);
+        if (typeof data === "string") {
+            await fs.writeString(path, data);
+        }
+        else {
+            await fs.write(path, data);
+        }
+    },
+    readdir: async (p, options) => {
+        const entries = await getFs().readDir(resolvePath(p));
+        return entries.map((e) => {
+            const json = e.toJSON();
+            if (options === null || options === void 0 ? void 0 : options.withFileTypes) {
+                return {
+                    name: json.name,
+                    isFile: () => json.type === "file",
+                    isDirectory: () => json.type === "directory",
+                    isSymbolicLink: () => false,
+                };
+            }
+            return json.name;
+        });
+    },
+    mkdir: async (p, options) => {
+        const fs = getFs();
+        const path = resolvePath(p);
+        if (options === null || options === void 0 ? void 0 : options.recursive) {
+            await fs.createDirAll(path);
+        }
+        else {
+            await fs.createDir(path);
+        }
+    },
+    rm: async (p, options) => {
+        const fs = getFs();
+        const path = resolvePath(p);
+        const metadata = await fs.metadata(path);
+        const type = metadata.toJSON().type;
+        if (type === "file") {
+            await fs.removeFile(path);
+        }
+        else {
+            await fs.removeDir(path, !!(options === null || options === void 0 ? void 0 : options.recursive));
+        }
+    },
+    rmdir: async (p, options) => getFs().removeDir(resolvePath(p), !!(options === null || options === void 0 ? void 0 : options.recursive)),
+    copyFile: async (src, dst) => getFs().copyFile(resolvePath(src), resolvePath(dst)),
+    stat: async (p) => {
+        const metadata = await getFs().metadata(resolvePath(p));
+        const json = metadata.toJSON();
+        return new Stats({
+            type: json.type,
+            size: Number(json.file_size || 0),
+        });
+    },
+    lstat: async (p) => {
+        const metadata = await getFs().metadata(resolvePath(p));
+        const json = metadata.toJSON();
+        return new Stats({
+            type: json.type,
+            size: Number(json.file_size || 0),
+        });
+    },
+    realpath: async (p) => p,
+    access: async (p, mode) => {
+        await getFs().metadata(resolvePath(p));
+    },
+};
+export const readFile = promises.readFile;
+export const writeFile = promises.writeFile;
+export const readdir = promises.readdir;
+export const mkdir = promises.mkdir;
+export const rm = promises.rm;
+export const rmdir = promises.rmdir;
+export const copyFile = promises.copyFile;
+export const stat = promises.stat;
+export const lstat = promises.lstat;
+export const realpath = promises.realpath;
+export const access = promises.access;
+export default promises;

package/esm/webpackLoaders/{worker/type.d.ts → type.d.ts}

@@ -2,6 +2,7 @@ export interface LoaderRunnerMeta {
     workerData: {
         workerId: number;
         cwd: string;
+        projectRoot: string;
     };
     loaderAssets: {
         importMaps: Record<string, string>;

package/esm/webpackLoaders/{worker/index.js → worker.js}

@@ -1,5 +1,5 @@
-import { SabComClient } from "../../sabcom";
-import initWasm, { recvTaskMessageInWorker, sendTaskMessage, workerCreated, } from "../../utoo";
+import { SabComClient } from "../sabcom";
+import initWasm, { Project, recvTaskMessageInWorker, sendTaskMessage, workerCreated, } from "../utoo";
 import { cjs } from "./cjs";
 const binding = {
     recvTaskMessageInWorker,
@@ -18,17 +18,22 @@ export function startLoaderWorker() {
                 self.postMessage("sab_request");
             })
             : undefined;
+        // Initialize the thread-local state (tokio runtime).
+        // We don't need to pass threadWorkerUrl here because it's already stored in a global static in Rust.
+        Project.init("");
+        Project.setCwd(meta.workerData.cwd);
         self.workerData = {
             workerId: meta.workerData.workerId,
             cwd: meta.workerData.cwd,
+            projectRoot: meta.workerData.projectRoot,
             binding,
             sabClient,
+            fs: Project,
         };
         self.process = {
             env: {},
             cwd: () => self.workerData.cwd,
         };
-        console.log("Worker CWD:", self.process.cwd());
         cjs(meta.loaderAssets.entrypoint, meta.loaderAssets.importMaps);
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@utoo/web",
-  "version": "1.2.0-rc.5",
+  "version": "1.2.0-rc.6",
   "module": "esm/index.js",
   "types": "esm/index.d.ts",
   "files": [
@@ -20,11 +20,12 @@
     "wasm-opt": "wasm-opt src/utoo/index_bg.wasm -o esm/utoo/index_bg.wasm --enable-threads --enable-bulk-memory --enable-nontrapping-float-to-int -Oz",
     "build": "npm run build-wasm -- --release && npm run bindgen-build && npm run tsc && npm run build-loaderWorker && npm run wasm-opt",
     "build:local": "npm run build-wasm -- --profile release-local && npm run bindgen-build:local && npm run tsc && npm run build-loaderWorker && cp src/utoo/index_bg.wasm esm/utoo",
-    "build-loaderWorker": "node cli/umd.js -e ./src/webpackLoaders/worker/index.ts -o ./esm/loaderWorker.js -t webworker",
+    "build-loaderWorker": "node cli/umd.js -e ./src/webpackLoaders/worker.ts -o ./esm/loaderWorker.js -t webworker",
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
     "@utoo/pack-shared": "^0.0.7",
+    "buffer-backed-object": "^1.0.1",
     "comlink": "^4.4.2",
     "micromatch": "^4.0.8",
     "systemjs": "^6.15.1"

package/esm/loaderWorkerPool.d.ts

@@ -1,3 +0,0 @@
-import { Binding } from "./type";
-import { Project as ProjectInternal } from "./utoo";
-export declare const runLoaderWorkerPool: (binding: Binding, projectCwd: string, projectInternal: ProjectInternal, loaderWorkerUrl: string, loadersImportMap?: Record<string, string>) => Promise<void>;

package/esm/webpackLoaders/worker/polyfills/fsPolyfill.d.ts

@@ -1,244 +0,0 @@
-import { Buffer } from "buffer";
-export declare function readFile(path: string, options: any, cb: Function): void;
-export declare function readFileSync(path: string, options: any): string | Buffer<any>;
-export declare function readdirSync(path: string, options?: any): any;
-export declare function readdir(path: string, options: any, cb: Function): void;
-export declare function writeFileSync(path: string, data: string | Uint8Array, options?: any): void;
-export declare function writeFile(path: string, data: string | Uint8Array, options: any, cb: Function): void;
-export declare function mkdirSync(path: string, options?: any): void;
-export declare function mkdir(path: string, options: any, cb: Function): void;
-export declare function rmSync(path: string, options?: any): void;
-export declare function rm(path: string, options: any, cb: Function): void;
-export declare function rmdirSync(path: string, options?: any): void;
-export declare function rmdir(path: string, options: any, cb: Function): void;
-export declare function copyFileSync(src: string, dst: string): void;
-export declare function copyFile(src: string, dst: string, cb: Function): void;
-export declare function statSync(p: string): {
-    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;
-    isDirectory: () => any;
-    isFile: () => any;
-    isSymbolicLink: () => any;
-    isBlockDevice: () => boolean;
-    isCharacterDevice: () => boolean;
-    isFIFO: () => boolean;
-    isSocket: () => boolean;
-};
-export declare function lstatSync(p: string): {
-    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;
-    isDirectory: () => any;
-    isFile: () => any;
-    isSymbolicLink: () => any;
-    isBlockDevice: () => boolean;
-    isCharacterDevice: () => boolean;
-    isFIFO: () => boolean;
-    isSocket: () => boolean;
-};
-export declare function stat(path: string, cb: Function): void;
-export declare function lstat(path: string, cb: Function): void;
-export declare function realpathSync(p: string): string;
-export declare function realpath(p: string, cb: Function): void;
-export declare function accessSync(path: string, mode?: number): void;
-export declare function access(path: string, mode: number | Function, cb?: Function): void;
-export declare function existsSync(path: string): boolean;
-export declare const promises: {
-    readFile: (path: string, options?: any) => Promise<string | Buffer<any>>;
-    writeFile: (path: string, data: string | Uint8Array, options?: any) => Promise<void>;
-    readdir: (path: string, options?: any) => Promise<any>;
-    mkdir: (path: string, options?: any) => Promise<void>;
-    rm: (path: string, options?: any) => Promise<void>;
-    rmdir: (path: string, options?: any) => Promise<void>;
-    copyFile: (src: string, dst: string) => Promise<void>;
-    stat: (p: string) => Promise<{
-        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;
-        isDirectory: () => any;
-        isFile: () => any;
-        isSymbolicLink: () => any;
-        isBlockDevice: () => boolean;
-        isCharacterDevice: () => boolean;
-        isFIFO: () => boolean;
-        isSocket: () => boolean;
-    }>;
-    lstat: (p: string) => Promise<{
-        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;
-        isDirectory: () => any;
-        isFile: () => any;
-        isSymbolicLink: () => any;
-        isBlockDevice: () => boolean;
-        isCharacterDevice: () => boolean;
-        isFIFO: () => boolean;
-        isSocket: () => boolean;
-    }>;
-    realpath: (p: string) => Promise<string>;
-    access: (path: string, mode?: number) => Promise<void>;
-};
-export declare const constants: {
-    F_OK: number;
-    R_OK: number;
-    W_OK: number;
-    X_OK: number;
-};
-declare const _default: {
-    readFile: typeof readFile;
-    readFileSync: typeof readFileSync;
-    readdir: typeof readdir;
-    readdirSync: typeof readdirSync;
-    writeFile: typeof writeFile;
-    writeFileSync: typeof writeFileSync;
-    mkdir: typeof mkdir;
-    mkdirSync: typeof mkdirSync;
-    rm: typeof rm;
-    rmSync: typeof rmSync;
-    rmdir: typeof rmdir;
-    rmdirSync: typeof rmdirSync;
-    copyFile: typeof copyFile;
-    copyFileSync: typeof copyFileSync;
-    stat: typeof stat;
-    statSync: typeof statSync;
-    lstat: typeof lstat;
-    lstatSync: typeof lstatSync;
-    realpath: typeof realpath;
-    realpathSync: typeof realpathSync;
-    access: typeof access;
-    accessSync: typeof accessSync;
-    existsSync: typeof existsSync;
-    promises: {
-        readFile: (path: string, options?: any) => Promise<string | Buffer<any>>;
-        writeFile: (path: string, data: string | Uint8Array, options?: any) => Promise<void>;
-        readdir: (path: string, options?: any) => Promise<any>;
-        mkdir: (path: string, options?: any) => Promise<void>;
-        rm: (path: string, options?: any) => Promise<void>;
-        rmdir: (path: string, options?: any) => Promise<void>;
-        copyFile: (src: string, dst: string) => Promise<void>;
-        stat: (p: string) => Promise<{
-            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;
-            isDirectory: () => any;
-            isFile: () => any;
-            isSymbolicLink: () => any;
-            isBlockDevice: () => boolean;
-            isCharacterDevice: () => boolean;
-            isFIFO: () => boolean;
-            isSocket: () => boolean;
-        }>;
-        lstat: (p: string) => Promise<{
-            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;
-            isDirectory: () => any;
-            isFile: () => any;
-            isSymbolicLink: () => any;
-            isBlockDevice: () => boolean;
-            isCharacterDevice: () => boolean;
-            isFIFO: () => boolean;
-            isSocket: () => boolean;
-        }>;
-        realpath: (p: string) => Promise<string>;
-        access: (path: string, mode?: number) => Promise<void>;
-    };
-    constants: {
-        F_OK: number;
-        R_OK: number;
-        W_OK: number;
-        X_OK: number;
-    };
-};
-export default _default;