@utoo/web 1.2.0-rc.1 → 1.2.0-rc.10

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

@@ -10,8 +10,9 @@ const searchPathsCache = {};
 const statSync = (p) => {
     if (p.includes("node_modules") &&
         Object.prototype.hasOwnProperty.call(statCache, p)) {
-        if (statCache[p] === false)
+        if (statCache[p] === false) {
             throw new Error("ENOENT");
+        }
         return statCache[p];
     }
     try {
@@ -31,7 +32,7 @@ const existsSync = (p) => {
         statSync(p);
         return true;
     }
-    catch (_a) {
+    catch (e) {
         return false;
     }
 };
@@ -51,13 +52,16 @@ const executeModule = (moduleCode, moduleId, id, importMaps, entrypoint) => {
     if (moduleId === entrypoint) {
         moduleCode = "self.Buffer = require('buffer').Buffer;" + moduleCode;
     }
+    if (!moduleId.endsWith(".json")) {
+        moduleCode = `// [Debug] Resolved: ${moduleId}\n` + moduleCode;
+    }
     try {
         if (moduleId.endsWith(".json")) {
             finalExports = JSON.parse(moduleCode);
             module.exports = finalExports;
         }
         else {
-            new Function("require", "exports", "module", "__filename", "__dirname", moduleCode)(moduleRequire, module.exports, module, moduleId, context);
+            new Function("require", "exports", "module", "__filename", "__dirname", "process", moduleCode)(moduleRequire, module.exports, module, moduleId, context, nodePolyFills.process);
             finalExports = module.exports;
         }
     }
@@ -86,7 +90,6 @@ const executeModule = (moduleCode, moduleId, id, importMaps, entrypoint) => {
     return finalExports;
 };
 const loadModule = (id, context, importMaps, entrypoint) => {
-    var _a, _b, _c, _d, _e, _f;
     const cacheKey = `${context}:${id}`;
     if (resolutionCache[cacheKey]) {
         const cachedId = resolutionCache[cacheKey];
@@ -133,13 +136,6 @@ const loadModule = (id, context, importMaps, entrypoint) => {
         let searchPaths = searchPathsCache[context];
         if (!searchPaths) {
             searchPaths = [];
-            // @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) || "/";
-            const isInsideNodeModules = context.includes("/node_modules/") ||
-                context.includes("\\node_modules\\");
-            if (isInsideNodeModules) {
-                searchPaths.push(path.join(cwd, "node_modules"));
-            }
             let currentDir = context;
             while (true) {
                 if (path.basename(currentDir) !== "node_modules") {
@@ -153,22 +149,29 @@ const loadModule = (id, context, importMaps, entrypoint) => {
                     break;
                 currentDir = parent;
             }
+            // Ensure cwd/node_modules is always included
+            const cwd = nodePolyFills.process.cwd();
+            const cwdNodeModules = path.join(cwd, "node_modules");
+            if (!searchPaths.includes(cwdNodeModules)) {
+                searchPaths.push(cwdNodeModules);
+            }
             searchPathsCache[context] = searchPaths;
         }
         for (const nodeModulesDir of searchPaths) {
             const nodeModulesPath = path.join(nodeModulesDir, id);
             // Check package.json first
             const pkgJsonPath = path.join(nodeModulesPath, "package.json");
-            if (existsSync(pkgJsonPath)) {
+            let pkg;
+            try {
+                const content = fs.readFileSync(pkgJsonPath, "utf8");
+                pkg = JSON.parse(content);
+                pkgJsonCache[pkgJsonPath] = pkg;
+            }
+            catch (e) {
+                // ignore
+            }
+            if (pkg) {
                 try {
-                    let pkg;
-                    if (pkgJsonCache[pkgJsonPath]) {
-                        pkg = pkgJsonCache[pkgJsonPath];
-                    }
-                    else {
-                        pkg = JSON.parse(fs.readFileSync(pkgJsonPath, "utf8"));
-                        pkgJsonCache[pkgJsonPath] = pkg;
-                    }
                     const mainField = pkg.main;
                     if (mainField) {
                         const candidates = [
@@ -178,65 +181,77 @@ const loadModule = (id, context, importMaps, entrypoint) => {
                             path.resolve(nodeModulesPath, mainField, "index.js"),
                         ];
                         for (const candidate of candidates) {
-                            if (existsSync(candidate) && !statSync(candidate).isDirectory()) {
-                                resolvedId = candidate;
+                            try {
+                                // Try reading directly to bypass potential statSync issues
                                 moduleCode = fs.readFileSync(candidate, "utf8");
+                                resolvedId = candidate;
                                 moduleId = candidate;
                                 break;
                             }
+                            catch (e) {
+                                // ignore
+                            }
                         }
                     }
                 }
-                catch (_g) { }
+                catch (e) {
+                    // ignore
+                }
             }
             if (!moduleCode) {
                 const extensions = ["", ".js", ".json", "/index.js"];
                 for (const ext of extensions) {
                     const p = nodeModulesPath + ext;
-                    if (existsSync(p) && !statSync(p).isDirectory()) {
-                        resolvedId = p;
+                    try {
+                        // Try reading directly
                         moduleCode = fs.readFileSync(p, "utf8");
+                        resolvedId = p;
                         moduleId = p;
                         break;
                     }
+                    catch (e) {
+                        // ignore
+                    }
                 }
             }
             if (moduleCode)
                 break;
         }
     }
-    // Fallback: Try resolving absolute path (handling CWD stripping)
+    // Fallback: Try resolving absolute path
     if (!moduleCode && id.startsWith("/")) {
-        // @ts-ignore
-        const cwd = ((_e = (_d = self.process) === null || _d === void 0 ? void 0 : _d.cwd) === null || _e === void 0 ? void 0 : _e.call(_d)) || ((_f = self.workerData) === null || _f === void 0 ? void 0 : _f.cwd) || "/";
-        let relativeId = id;
-        if (id.startsWith(cwd)) {
-            relativeId = id.slice(cwd.length);
-            if (relativeId.startsWith("/"))
-                relativeId = relativeId.slice(1);
-        }
         const extensions = ["", ".js", ".json", "/index.js"];
         for (const ext of extensions) {
-            const p = relativeId + ext;
-            if (existsSync(p) && !statSync(p).isDirectory()) {
-                resolvedId = p; // Use relative path for FS ops
+            if (ext === "/index.js" && id.endsWith(".js"))
+                continue;
+            const p = id + ext;
+            try {
                 moduleCode = fs.readFileSync(p, "utf8");
-                moduleId = id; // Keep original absolute path as module ID
+                resolvedId = p;
+                moduleId = id;
                 break;
             }
+            catch (e) {
+                // ignore
+            }
         }
     }
     if (!moduleCode) {
         // Try extensions
         const extensions = ["", ".js", ".json", "/index.js"];
         for (const ext of extensions) {
+            if (ext === "/index.js" && id.endsWith(".js"))
+                continue;
             const p = resolvedId + ext;
-            if (existsSync(p) && !statSync(p).isDirectory()) {
-                resolvedId = p;
+            try {
                 moduleCode = fs.readFileSync(p, "utf8");
+                resolvedId = p;
                 moduleId = p;
                 break;
             }
+            catch (e) {
+                // ignore
+            }
         }
     }
     if (moduleCode) {
@@ -244,10 +259,19 @@ const loadModule = (id, context, importMaps, entrypoint) => {
         resolutionCache[cacheKey] = moduleId;
         return executeModule(moduleCode, moduleId, id, importMaps, entrypoint);
     }
-    console.error(`Worker: Dependency ${id} (resolved: ${resolvedId}) not found.`);
+    console.error(`Worker: Dependency ${id} (resolved: ${resolvedId}) not found. Context: ${context}`);
     return {};
 };
 export async function cjs(entrypoint, importMaps) {
+    // Clear caches to avoid stale data across runs
+    for (const key in statCache)
+        delete statCache[key];
+    for (const key in pkgJsonCache)
+        delete pkgJsonCache[key];
+    for (const key in resolutionCache)
+        delete resolutionCache[key];
+    for (const key in searchPathsCache)
+        delete searchPathsCache[key];
     await Promise.all(Object.entries(importMaps).map(async ([k, v]) => {
         if (v.startsWith("https://")) {
             try {

package/esm/webpackLoaders/loaderWorkerPool.d.ts

@@ -0,0 +1,2 @@
+import { Binding } from "../types";
+export declare const runLoaderWorkerPool: (binding: Binding, projectCwd: string, loaderWorkerUrl: string, loadersImportMap?: Record<string, string>) => Promise<void>;

package/esm/webpackLoaders/loaderWorkerPool.js

@@ -0,0 +1,90 @@
+import * as sabcom from "../utils/sabcom";
+import initWasm, { Project as ProjectInternal, registerWorkerScheduler, workerCreated, } from "../utoo";
+let nextWorkerId = 0;
+const loaderWorkers = {};
+export const runLoaderWorkerPool = async (binding, projectCwd, loaderWorkerUrl, loadersImportMap) => {
+    registerWorkerScheduler(async (creation) => {
+        const { options: { filename, cwd }, } = creation;
+        nextWorkerId += 1;
+        const workerId = nextWorkerId;
+        const sab = new SharedArrayBuffer(1024 * 1024 * 10); // 10MB
+        const sabHost = new sabcom.SabComHost(sab);
+        const worker = new Worker(loaderWorkerUrl, { name: filename });
+        worker.onmessage = async (event) => {
+            if (event.data === "sab_request") {
+                await sabcom.handleSabRequest(sabHost, {
+                    read: (path) => ProjectInternal.read(path),
+                    readDir: (path) => ProjectInternal.readDir(path),
+                    writeString: (path, content) => ProjectInternal.writeString(path, content),
+                    createDirAll: (path) => ProjectInternal.createDirAll(path),
+                    createDir: (path) => ProjectInternal.createDir(path),
+                    metadata: (path) => ProjectInternal.metadata(path),
+                    removeFile: (path) => ProjectInternal.removeFile(path),
+                    removeDir: (path, recursive) => ProjectInternal.removeDir(path, recursive),
+                    copyFile: (src, dst) => ProjectInternal.copyFile(src, dst),
+                });
+            }
+        };
+        let finalCwd = cwd;
+        let finalFilename = filename;
+        if (projectCwd) {
+            const sep = "/";
+            let pCwd = projectCwd.endsWith(sep)
+                ? projectCwd.slice(0, -1)
+                : projectCwd;
+            if (!pCwd.startsWith(sep)) {
+                pCwd = sep + pCwd;
+            }
+            if (cwd.startsWith(sep)) {
+                finalCwd = cwd;
+            }
+            else {
+                let cCwd = cwd;
+                if (cCwd === "." || cCwd === "./") {
+                    cCwd = "";
+                }
+                finalCwd = cCwd ? `${pCwd}${sep}${cCwd}` : pCwd;
+            }
+            if (filename.startsWith(sep)) {
+                finalFilename = filename;
+            }
+            else {
+                let fName = filename;
+                if (fName.startsWith("./"))
+                    fName = fName.slice(2);
+                finalFilename = `${pCwd}${sep}${fName}`;
+            }
+        }
+        worker.postMessage([
+            // @ts-ignore
+            initWasm.__wbindgen_wasm_module,
+            binding.memory,
+            {
+                workerData: {
+                    cwd: finalCwd,
+                    projectRoot: projectCwd,
+                    workerId: workerId,
+                },
+                loaderAssets: {
+                    importMaps: { ...loadersImportMap },
+                    entrypoint: finalFilename,
+                },
+                sab,
+            },
+        ]);
+        const workers = loaderWorkers[filename] || (loaderWorkers[filename] = new Map());
+        workers.set(workerId, worker);
+        workerCreated(workerId);
+    }, (termination) => {
+        const { workerId, options } = termination;
+        const entrypoint = options.filename;
+        const workers = loaderWorkers[entrypoint];
+        if (workers) {
+            const worker = workers.get(workerId);
+            if (worker) {
+                worker.terminate();
+                workers.delete(workerId);
+            }
+        }
+    });
+};

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

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