@utoo/web 1.3.1 → 1.3.2

package/esm/webpackLoaders/cjs.js

@@ -7,6 +7,34 @@ const statCache = {};
 const pkgJsonCache = {};
 const resolutionCache = {};
 const searchPathsCache = {};
+const RESOLUTION_EXTENSIONS = [
+    "",
+    ".js",
+    ".cjs",
+    ".json",
+    "/index.js",
+    "/index.cjs",
+    "/index.json",
+];
+const tryReadFile = (p) => {
+    try {
+        return fs.readFileSync(p, "utf8");
+    }
+    catch (_a) {
+        return null;
+    }
+};
+const resolveWithExtensions = (p, skipIndexJsIfJs = false) => {
+    for (const ext of RESOLUTION_EXTENSIONS) {
+        if (skipIndexJsIfJs && ext === "/index.js" && p.endsWith(".js"))
+            continue;
+        const candidate = p + ext;
+        const code = tryReadFile(candidate);
+        if (code !== null)
+            return { code, id: candidate };
+    }
+    return null;
+};
 const executeModule = (moduleCode, moduleId, id, importMaps, entrypoint) => {
     if (installedModules[moduleId]) {
         return installedModules[moduleId].exports;
@@ -19,7 +47,6 @@ const executeModule = (moduleCode, moduleId, id, importMaps, entrypoint) => {
     if (moduleId.includes("node_modules")) {
         installedModules[moduleId] = module;
     }
-    // Hack for entrypoint
     if (moduleId === entrypoint) {
         moduleCode = "self.Buffer = require('buffer').Buffer;" + moduleCode;
     }
@@ -44,15 +71,14 @@ const executeModule = (moduleCode, moduleId, id, importMaps, entrypoint) => {
     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;
+        if (!msg.includes("(SystemJS Error#W3")) {
+            originalWarn.apply(console, args);
         }
-        originalWarn.apply(console, args);
     };
     try {
         System.set(moduleId, { default: finalExports });
     }
-    catch (e) {
+    catch (_a) {
         // ignore
     }
     finally {
@@ -61,47 +87,52 @@ const executeModule = (moduleCode, moduleId, id, importMaps, entrypoint) => {
     return finalExports;
 };
 const loadModule = (id, context, importMaps, entrypoint) => {
+    var _a;
     const cacheKey = `${context}:${id}`;
     if (resolutionCache[cacheKey]) {
         const cachedId = resolutionCache[cacheKey];
-        if (installedModules[cachedId]) {
+        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
+        const code = tryReadFile(cachedId);
+        if (code !== null) {
+            return executeModule(code, cachedId, id, importMaps, entrypoint);
         }
     }
     // 1. Resolve
-    let resolvedId = id;
-    if (id.startsWith(".")) {
-        resolvedId = path.join(context, id);
-    }
+    let resolvedId = id.startsWith(".") ? path.join(context, id) : 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;
-    }
+    const sysDef = System.get(resolvedId) || (id !== resolvedId && System.get(id));
+    if (sysDef)
+        return sysDef.default;
     // 3. Check Node Polyfills
-    if (id in nodePolyFills) {
-        // @ts-ignore
+    if (id in nodePolyFills)
         return nodePolyFills[id];
-    }
-    if (resolvedId in nodePolyFills) {
-        // @ts-ignore
+    if (resolvedId in nodePolyFills)
         return nodePolyFills[resolvedId];
-    }
     // 4. Check importMaps & FS
     let moduleCode = importMaps[resolvedId] || importMaps[id];
     let moduleId = importMaps[resolvedId] ? resolvedId : id;
+    if (!moduleCode) {
+        let longestMatch = null;
+        for (const key in importMaps) {
+            const sanitized = key.replace(/^\.?\//, "");
+            if (!sanitized)
+                continue;
+            const isMatch = [id, resolvedId].some((p) => p.startsWith("/") &&
+                p.endsWith(sanitized) &&
+                p[p.length - sanitized.length - 1] === "/");
+            if (isMatch && (!longestMatch || key.length > longestMatch.key.length)) {
+                longestMatch = { key, sanitized };
+            }
+        }
+        if (longestMatch) {
+            moduleCode = importMaps[longestMatch.key];
+            moduleId =
+                id.startsWith("/") && id.endsWith(longestMatch.sanitized)
+                    ? id
+                    : resolvedId;
+        }
+    }
     // Fallback: Try resolving from node_modules
     if (!moduleCode && !id.startsWith(".") && !id.startsWith("/")) {
         let searchPaths = searchPathsCache[context];
@@ -110,140 +141,76 @@ const loadModule = (id, context, importMaps, entrypoint) => {
             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 nmPath = path.join(currentDir, "node_modules");
+                    if (!searchPaths.includes(nmPath))
+                        searchPaths.push(nmPath);
                 }
                 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);
-            }
+            const cwdNm = path.join(nodePolyFills.process.cwd(), "node_modules");
+            if (!searchPaths.includes(cwdNm))
+                searchPaths.push(cwdNm);
             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
-                            }
-                        }
+            const pkgPath = path.join(nodeModulesPath, "package.json");
+            // Check package.json main
+            let pkgMain;
+            if (!pkgJsonCache[pkgPath]) {
+                const json = tryReadFile(pkgPath);
+                if (json) {
+                    try {
+                        pkgJsonCache[pkgPath] = JSON.parse(json);
                     }
-                }
-                catch (e) {
-                    // ignore
+                    catch (_b) { }
                 }
             }
-            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 ((_a = pkgJsonCache[pkgPath]) === null || _a === void 0 ? void 0 : _a.main) {
+                pkgMain = path.resolve(nodeModulesPath, pkgJsonCache[pkgPath].main);
+                const res = resolveWithExtensions(pkgMain);
+                if (res) {
+                    moduleCode = res.code;
+                    moduleId = resolvedId = res.id;
+                    break;
                 }
             }
-            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;
+            // Check direct file/directory
+            const res = resolveWithExtensions(nodeModulesPath);
+            if (res) {
+                moduleCode = res.code;
+                moduleId = resolvedId = res.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
-            }
+    // Fallback: Try resolving absolute or relative path
+    if (!moduleCode && (id.startsWith("/") || id.startsWith("."))) {
+        const res = resolveWithExtensions(resolvedId, id.endsWith(".js"));
+        if (res) {
+            moduleCode = res.code;
+            moduleId = resolvedId = res.id;
         }
     }
     if (moduleCode) {
-        const cacheKey = `${context}:${id}`;
-        resolutionCache[cacheKey] = moduleId;
+        resolutionCache[`${context}:${id}`] = moduleId;
         return executeModule(moduleCode, moduleId, id, importMaps, entrypoint);
     }
-    const error = new Error(`Worker: Dependency ${id} (resolved: ${resolvedId}) not found. Context: ${context}`);
+    const error = new Error(`Worker: Dependency ${id} (resolved: ${resolvedId}) not found. Context: ${context}. ` +
+        `ImportMaps count: ${Object.keys(importMaps).length}. ` +
+        `CWD: ${nodePolyFills.process.cwd()}. ` +
+        `Sample ImportMaps keys: ${Object.keys(importMaps).slice(0, 5).join(", ")}`);
     console.error(error);
     throw error;
 };
 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];
+    [statCache, pkgJsonCache, resolutionCache, searchPathsCache].forEach((c) => {
+        for (const key in c)
+            delete c[key];
+    });
     await Promise.all(Object.entries(importMaps).map(async ([k, v]) => {
         if (v.startsWith("https://")) {
             try {
@@ -252,18 +219,17 @@ export async function cjs(entrypoint, importMaps) {
                     importMaps[k] = await response.text();
                 }
                 else {
-                    console.error(`Failed to fetch loader '${k}' from ${v}: ${response.status} ${response.statusText}`);
+                    console.error(`Failed to fetch loader '${k}': ${response.status}`);
                     delete importMaps[k];
                 }
             }
             catch (error) {
-                console.error(`Error fetching loader '${k}' from ${v}:`, error);
+                console.error(`Error fetching loader '${k}':`, 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;

package/esm/webpackLoaders/polyfills/fsPolyfill/utils.js

@@ -1,4 +1,5 @@
 import path from "path";
+import { ERR_ABORT, ERR_INVALID_STATE, ERR_NO_MODIFICATION_ALLOWED, ERR_NOT_ALLOWED, ERR_NOT_FOUND, ERR_QUOTA_EXCEEDED, ERR_TYPE_MISMATCH, } from "../../../utoo";
 import { workerData } from "../workerThreadsPolyfill";
 export function resolvePath(p) {
     var _a, _b;
@@ -16,7 +17,9 @@ export function getFs() {
 }
 export function translateError(error, path, syscall) {
     const message = error.message || String(error);
-    if (message.includes("NotFound")) {
+    // 1. NotFound (ENOENT)
+    // Mapping "NotFoundError" from tokio-fs-ext
+    if (message.includes(ERR_NOT_FOUND())) {
         const e = new Error(`ENOENT: no such file or directory, ${syscall} '${path}'`);
         e.errno = -2;
         e.code = "ENOENT";
@@ -24,5 +27,65 @@ export function translateError(error, path, syscall) {
         e.path = path;
         return e;
     }
+    // 2. Directory error (Mapped to EISDIR)
+    // Mapping "TypeMismatchError" or "type mismatch" from tokio-fs-ext
+    if (message.includes(ERR_TYPE_MISMATCH())) {
+        const e = new Error(`EISDIR: illegal operation on a directory, ${syscall} '${path}'`);
+        e.errno = -21;
+        e.code = "EISDIR";
+        e.syscall = syscall;
+        e.path = path;
+        return e;
+    }
+    // 3. Locking/Concurrency (Mapped to EAGAIN/EBUSY)
+    // Mapping "NoModificationAllowedError" from tokio-fs-ext
+    if (message.includes(ERR_NO_MODIFICATION_ALLOWED())) {
+        const e = new Error(`EAGAIN: resource temporarily unavailable, ${syscall} '${path}'`);
+        e.errno = -11;
+        e.code = "EAGAIN";
+        e.syscall = syscall;
+        e.path = path;
+        return e;
+    }
+    // 4. Permission Denied (EACCES)
+    // Mapping "NotAllowedError" from tokio-fs-ext
+    if (message.includes(ERR_NOT_ALLOWED())) {
+        const e = new Error(`EACCES: permission denied, ${syscall} '${path}'`);
+        e.errno = -13;
+        e.code = "EACCES";
+        e.syscall = syscall;
+        e.path = path;
+        return e;
+    }
+    // 5. Storage Full (ENOSPC)
+    // Mapping "QuotaExceededError" from tokio-fs-ext
+    if (message.includes(ERR_QUOTA_EXCEEDED())) {
+        const e = new Error(`ENOSPC: no space left on device, ${syscall} '${path}'`);
+        e.errno = -28;
+        e.code = "ENOSPC";
+        e.syscall = syscall;
+        e.path = path;
+        return e;
+    }
+    // 6. Invalid Argument (EINVAL)
+    // Mapping "InvalidStateError" from tokio-fs-ext
+    if (message.includes(ERR_INVALID_STATE())) {
+        const e = new Error(`EINVAL: invalid argument, ${syscall} '${path}'`);
+        e.errno = -22;
+        e.code = "EINVAL";
+        e.syscall = syscall;
+        e.path = path;
+        return e;
+    }
+    // 7. Interrupted (EINTR)
+    // Mapping "AbortError" from tokio-fs-ext
+    if (message.includes(ERR_ABORT())) {
+        const e = new Error(`EINTR: interrupted system call, ${syscall} '${path}'`);
+        e.errno = -4;
+        e.code = "EINTR";
+        e.syscall = syscall;
+        e.path = path;
+        return e;
+    }
     return error;
 }

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

@@ -1,4 +1,4 @@
-import * as fs from "./fsPolyfill/sync";
+import * as fs from "./fsPolyfill";
 declare const _default: {
     readonly assert: any;
     readonly "node:assert": any;

package/esm/webpackLoaders/polyfills/nodePolyFills.js

@@ -1,4 +1,4 @@
-import * as fs from "./fsPolyfill/sync";
+import * as fs from "./fsPolyfill";
 import * as workerThreads from "./workerThreadsPolyfill";
 const buffer = require("buffer");
 self.Buffer = buffer.Buffer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@utoo/web",
-  "version": "1.3.1",
+  "version": "1.3.2",
   "module": "esm/index.js",
   "types": "esm/index.d.ts",
   "files": [