@utoo/web 1.1.0 → 1.2.0-rc.10

package/esm/webpackLoaders/cjs.js

@@ -0,0 +1,299 @@
+import "systemjs/dist/system.js";
+import nodePolyFills from "./polyfills/nodePolyFills";
+const fs = nodePolyFills.fs;
+const path = nodePolyFills.path;
+const installedModules = {};
+const statCache = {};
+const pkgJsonCache = {};
+const resolutionCache = {};
+const searchPathsCache = {};
+const statSync = (p) => {
+    if (p.includes("node_modules") &&
+        Object.prototype.hasOwnProperty.call(statCache, p)) {
+        if (statCache[p] === false) {
+            throw new Error("ENOENT");
+        }
+        return statCache[p];
+    }
+    try {
+        const res = fs.statSync(p);
+        if (p.includes("node_modules"))
+            statCache[p] = res;
+        return res;
+    }
+    catch (e) {
+        if (p.includes("node_modules"))
+            statCache[p] = false;
+        throw e;
+    }
+};
+const existsSync = (p) => {
+    try {
+        statSync(p);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+};
+const executeModule = (moduleCode, moduleId, id, importMaps, entrypoint) => {
+    if (installedModules[moduleId]) {
+        return installedModules[moduleId].exports;
+    }
+    const context = path.dirname(moduleId);
+    let finalExports = {};
+    const moduleRequire = (childId) => loadModule(childId, context, importMaps, entrypoint);
+    moduleRequire.resolve = (request) => request;
+    const module = { exports: finalExports, require: moduleRequire };
+    if (moduleId.includes("node_modules")) {
+        installedModules[moduleId] = module;
+    }
+    // Hack for 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", "process", moduleCode)(moduleRequire, module.exports, module, moduleId, context, nodePolyFills.process);
+            finalExports = module.exports;
+        }
+    }
+    catch (e) {
+        console.error(`Worker: Error executing module ${moduleId}:`, e);
+        throw new Error(`Failed to load dependency ${moduleId}: ${e.message}`);
+    }
+    const originalWarn = console.warn;
+    console.warn = (...args) => {
+        var _a;
+        const msg = ((_a = args[0]) === null || _a === void 0 ? void 0 : _a.toString()) || "";
+        if (msg.includes("(SystemJS Error#W3")) {
+            return;
+        }
+        originalWarn.apply(console, args);
+    };
+    try {
+        System.set(moduleId, { default: finalExports });
+    }
+    catch (e) {
+        // ignore
+    }
+    finally {
+        console.warn = originalWarn;
+    }
+    return finalExports;
+};
+const loadModule = (id, context, importMaps, entrypoint) => {
+    const cacheKey = `${context}:${id}`;
+    if (resolutionCache[cacheKey]) {
+        const cachedId = resolutionCache[cacheKey];
+        if (installedModules[cachedId]) {
+            return installedModules[cachedId].exports;
+        }
+        // Fast path: if we know the resolved path, try to load it directly
+        try {
+            const moduleCode = fs.readFileSync(cachedId, "utf8");
+            return executeModule(moduleCode, cachedId, id, importMaps, entrypoint);
+        }
+        catch (e) {
+            // If read fails, fall back to full resolution
+        }
+    }
+    // 1. Resolve
+    let resolvedId = id;
+    if (id.startsWith(".")) {
+        resolvedId = path.resolve(context, id);
+    }
+    // 2. Check Cache (SystemJS)
+    let dependency = System.get(resolvedId);
+    if (dependency)
+        return dependency.default;
+    if (id !== resolvedId) {
+        dependency = System.get(id);
+        if (dependency)
+            return dependency.default;
+    }
+    // 3. Check Node Polyfills
+    if (id in nodePolyFills) {
+        // @ts-ignore
+        return nodePolyFills[id];
+    }
+    if (resolvedId in nodePolyFills) {
+        // @ts-ignore
+        return nodePolyFills[resolvedId];
+    }
+    // 4. Check importMaps & FS
+    let moduleCode = importMaps[resolvedId] || importMaps[id];
+    let moduleId = importMaps[resolvedId] ? resolvedId : id;
+    // Fallback: Try resolving from node_modules
+    if (!moduleCode && !id.startsWith(".") && !id.startsWith("/")) {
+        let searchPaths = searchPathsCache[context];
+        if (!searchPaths) {
+            searchPaths = [];
+            let currentDir = context;
+            while (true) {
+                if (path.basename(currentDir) !== "node_modules") {
+                    const nodeModulesPath = path.join(currentDir, "node_modules");
+                    if (!searchPaths.includes(nodeModulesPath)) {
+                        searchPaths.push(nodeModulesPath);
+                    }
+                }
+                const parent = path.dirname(currentDir);
+                if (parent === currentDir)
+                    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");
+            let pkg;
+            try {
+                const content = fs.readFileSync(pkgJsonPath, "utf8");
+                pkg = JSON.parse(content);
+                pkgJsonCache[pkgJsonPath] = pkg;
+            }
+            catch (e) {
+                // ignore
+            }
+            if (pkg) {
+                try {
+                    const mainField = pkg.main;
+                    if (mainField) {
+                        const candidates = [
+                            path.resolve(nodeModulesPath, mainField),
+                            path.resolve(nodeModulesPath, mainField) + ".js",
+                            path.resolve(nodeModulesPath, mainField) + ".json",
+                            path.resolve(nodeModulesPath, mainField, "index.js"),
+                        ];
+                        for (const candidate of candidates) {
+                            try {
+                                // Try reading directly to bypass potential statSync issues
+                                moduleCode = fs.readFileSync(candidate, "utf8");
+                                resolvedId = candidate;
+                                moduleId = candidate;
+                                break;
+                            }
+                            catch (e) {
+                                // ignore
+                            }
+                        }
+                    }
+                }
+                catch (e) {
+                    // ignore
+                }
+            }
+            if (!moduleCode) {
+                const extensions = ["", ".js", ".json", "/index.js"];
+                for (const ext of extensions) {
+                    const p = nodeModulesPath + ext;
+                    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
+    if (!moduleCode && id.startsWith("/")) {
+        const extensions = ["", ".js", ".json", "/index.js"];
+        for (const ext of extensions) {
+            if (ext === "/index.js" && id.endsWith(".js"))
+                continue;
+            const p = id + ext;
+            try {
+                moduleCode = fs.readFileSync(p, "utf8");
+                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;
+            try {
+                moduleCode = fs.readFileSync(p, "utf8");
+                resolvedId = p;
+                moduleId = p;
+                break;
+            }
+            catch (e) {
+                // ignore
+            }
+        }
+    }
+    if (moduleCode) {
+        const cacheKey = `${context}:${id}`;
+        resolutionCache[cacheKey] = moduleId;
+        return executeModule(moduleCode, moduleId, id, importMaps, entrypoint);
+    }
+    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 {
+                const response = await fetch(v);
+                if (response.ok) {
+                    importMaps[k] = await response.text();
+                }
+                else {
+                    console.error(`Failed to fetch loader '${k}' from ${v}: ${response.status} ${response.statusText}`);
+                    delete importMaps[k];
+                }
+            }
+            catch (error) {
+                console.error(`Error fetching loader '${k}' from ${v}:`, error);
+                delete importMaps[k];
+            }
+        }
+    }));
+    // @ts-ignore
+    // a hack for loader-runner resolving
+    self.__systemjs_require__ = (id) => loadModule(id, path.dirname(entrypoint), importMaps, entrypoint);
+    // @ts-ignore
+    self.__systemjs_require__.resolve = (request) => request;
+    loadModule(entrypoint, path.dirname(entrypoint), importMaps, entrypoint);
+}

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 };