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

package/esm/webpackLoaders/worker/cjs.js

@@ -51,13 +51,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 +89,7 @@ const executeModule = (moduleCode, moduleId, id, importMaps, entrypoint) => {
     return finalExports;
 };
 const loadModule = (id, context, importMaps, entrypoint) => {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c;
     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") {
@@ -179,25 +175,35 @@ const loadModule = (id, context, importMaps, entrypoint) => {
                         ];
                         for (const candidate of candidates) {
                             if (existsSync(candidate) && !statSync(candidate).isDirectory()) {
-                                resolvedId = candidate;
-                                moduleCode = fs.readFileSync(candidate, "utf8");
-                                moduleId = candidate;
-                                break;
+                                try {
+                                    resolvedId = candidate;
+                                    moduleCode = fs.readFileSync(candidate, "utf8");
+                                    moduleId = candidate;
+                                    break;
+                                }
+                                catch (e) {
+                                    // ignore
+                                }
                             }
                         }
                     }
                 }
-                catch (_g) { }
+                catch (_d) { }
             }
             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;
-                        moduleCode = fs.readFileSync(p, "utf8");
-                        moduleId = p;
-                        break;
+                        try {
+                            resolvedId = p;
+                            moduleCode = fs.readFileSync(p, "utf8");
+                            moduleId = p;
+                            break;
+                        }
+                        catch (e) {
+                            // ignore
+                        }
                     }
                 }
             }
@@ -208,7 +214,7 @@ const loadModule = (id, context, importMaps, entrypoint) => {
     // Fallback: Try resolving absolute path (handling CWD stripping)
     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) || "/";
+        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) || "/";
         let relativeId = id;
         if (id.startsWith(cwd)) {
             relativeId = id.slice(cwd.length);
@@ -219,10 +225,15 @@ const loadModule = (id, context, importMaps, entrypoint) => {
         for (const ext of extensions) {
             const p = relativeId + ext;
             if (existsSync(p) && !statSync(p).isDirectory()) {
-                resolvedId = p; // Use relative path for FS ops
-                moduleCode = fs.readFileSync(p, "utf8");
-                moduleId = id; // Keep original absolute path as module ID
-                break;
+                try {
+                    resolvedId = p; // Use relative path for FS ops
+                    moduleCode = fs.readFileSync(p, "utf8");
+                    moduleId = id; // Keep original absolute path as module ID
+                    break;
+                }
+                catch (e) {
+                    // ignore
+                }
             }
         }
     }
@@ -232,10 +243,16 @@ const loadModule = (id, context, importMaps, entrypoint) => {
         for (const ext of extensions) {
             const p = resolvedId + ext;
             if (existsSync(p) && !statSync(p).isDirectory()) {
-                resolvedId = p;
-                moduleCode = fs.readFileSync(p, "utf8");
-                moduleId = p;
-                break;
+                try {
+                    resolvedId = p;
+                    moduleCode = fs.readFileSync(p, "utf8");
+                    moduleId = p;
+                    break;
+                }
+                catch (e) {
+                    console.error(`[Debug] Failed to read file ${p}:`, e);
+                    // ignore
+                }
             }
         }
     }
@@ -244,7 +261,7 @@ 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) {

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

@@ -14,18 +14,58 @@ 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;
-    size: number;
-    mtime: Date;
+    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;
-    size: number;
-    mtime: Date;
+    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;
@@ -43,18 +83,58 @@ export declare const promises: {
     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;
-        size: number;
-        mtime: Date;
+        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;
-        size: number;
-        mtime: Date;
+        isBlockDevice: () => boolean;
+        isCharacterDevice: () => boolean;
+        isFIFO: () => boolean;
+        isSocket: () => boolean;
     }>;
     realpath: (p: string) => Promise<string>;
     access: (path: string, mode?: number) => Promise<void>;
@@ -98,18 +178,58 @@ declare const _default: {
         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;
-            size: number;
-            mtime: Date;
+            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;
-            size: number;
-            mtime: Date;
+            isBlockDevice: () => boolean;
+            isCharacterDevice: () => boolean;
+            isFIFO: () => boolean;
+            isSocket: () => boolean;
         }>;
         realpath: (p: string) => Promise<string>;
         access: (path: string, mode?: number) => Promise<void>;

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

@@ -1,6 +1,6 @@
 import { Buffer } from "buffer";
 import path from "path";
-import { SAB_OP_COPY_FILE, SAB_OP_MKDIR, SAB_OP_READ_DIR, SAB_OP_READ_FILE, SAB_OP_RM, SAB_OP_RMDIR, SAB_OP_WRITE_FILE, } from "../../../sabcom";
+import * as sabcom from "../../../sabcom";
 function resolvePath(p) {
     var _a, _b, _c;
     // @ts-ignore
@@ -48,7 +48,7 @@ export function readFile(path, options, cb) {
 }
 export function readFileSync(path, options) {
     const client = getSabClient();
-    const result = client.call(SAB_OP_READ_FILE, resolvePath(path));
+    const result = client.call(sabcom.SAB_OP_READ_FILE, resolvePath(path));
     if (options === "utf8" ||
         options === "utf-8" ||
         (options && (options.encoding === "utf8" || options.encoding === "utf-8"))) {
@@ -58,7 +58,7 @@ export function readFileSync(path, options) {
 }
 export function readdirSync(path, options) {
     const client = getSabClient();
-    const result = client.call(SAB_OP_READ_DIR, resolvePath(path));
+    const result = client.call(sabcom.SAB_OP_READ_DIR, resolvePath(path));
     const json = new TextDecoder().decode(result);
     const entries = JSON.parse(json);
     if (options === null || options === void 0 ? void 0 : options.withFileTypes) {
@@ -89,7 +89,7 @@ export function writeFileSync(path, data, options) {
     // TODO: handle binary data properly
     const content = typeof data === "string" ? data : new TextDecoder().decode(data);
     const payload = JSON.stringify({ path: resolvePath(path), data: content });
-    client.call(SAB_OP_WRITE_FILE, payload);
+    client.call(sabcom.SAB_OP_WRITE_FILE, payload);
 }
 export function writeFile(path, data, options, cb) {
     if (typeof options === "function") {
@@ -108,7 +108,7 @@ export function mkdirSync(path, options) {
     const client = getSabClient();
     const recursive = (options === null || options === void 0 ? void 0 : options.recursive) || false;
     const payload = JSON.stringify({ path: resolvePath(path), recursive });
-    client.call(SAB_OP_MKDIR, payload);
+    client.call(sabcom.SAB_OP_MKDIR, payload);
 }
 export function mkdir(path, options, cb) {
     if (typeof options === "function") {
@@ -127,7 +127,7 @@ export function rmSync(path, options) {
     const client = getSabClient();
     const recursive = (options === null || options === void 0 ? void 0 : options.recursive) || false;
     const payload = JSON.stringify({ path: resolvePath(path), recursive });
-    client.call(SAB_OP_RM, payload);
+    client.call(sabcom.SAB_OP_RM, payload);
 }
 export function rm(path, options, cb) {
     if (typeof options === "function") {
@@ -146,7 +146,7 @@ export function rmdirSync(path, options) {
     const client = getSabClient();
     const recursive = (options === null || options === void 0 ? void 0 : options.recursive) || false;
     const payload = JSON.stringify({ path: resolvePath(path), recursive });
-    client.call(SAB_OP_RMDIR, payload);
+    client.call(sabcom.SAB_OP_RMDIR, payload);
 }
 export function rmdir(path, options, cb) {
     if (typeof options === "function") {
@@ -167,7 +167,7 @@ export function copyFileSync(src, dst) {
         src: resolvePath(src),
         dst: resolvePath(dst),
     });
-    client.call(SAB_OP_COPY_FILE, payload);
+    client.call(sabcom.SAB_OP_COPY_FILE, payload);
 }
 export function copyFile(src, dst, cb) {
     try {
@@ -183,26 +183,79 @@ export function statSync(p) {
     const name = path.basename(p);
     // Root check
     if (p === "/" || p === ".") {
+        const now = new Date();
+        const nowMs = now.getTime();
         return {
+            dev: 0,
+            ino: 0,
+            mode: 16877,
+            nlink: 1,
+            uid: 0,
+            gid: 0,
+            rdev: 0,
+            size: 0,
+            blksize: 4096,
+            blocks: 0,
+            atimeMs: nowMs,
+            mtimeMs: nowMs,
+            ctimeMs: nowMs,
+            birthtimeMs: nowMs,
+            atime: now,
+            mtime: now,
+            ctime: now,
+            birthtime: now,
             isDirectory: () => true,
             isFile: () => false,
             isSymbolicLink: () => false,
-            size: 0,
-            mtime: new Date(),
+            isBlockDevice: () => false,
+            isCharacterDevice: () => false,
+            isFIFO: () => false,
+            isSocket: () => false,
         };
     }
     try {
         const entries = readdirSync(parent, { withFileTypes: true });
         const entry = entries.find((e) => e.name === name);
         if (!entry) {
-            throw new Error(`ENOENT: no such file or directory, stat '${p}'`);
+            const error = new Error(`ENOENT: no such file or directory, stat '${p}'`);
+            // @ts-ignore
+            error.code = "ENOENT";
+            // @ts-ignore
+            error.errno = -2;
+            // @ts-ignore
+            error.syscall = "stat";
+            // @ts-ignore
+            error.path = p;
+            throw error;
         }
+        const now = new Date();
+        const nowMs = now.getTime();
         return {
+            dev: 0,
+            ino: 0,
+            mode: entry.isDirectory() ? 16877 : 33188,
+            nlink: 1,
+            uid: 0,
+            gid: 0,
+            rdev: 0,
+            size: 0,
+            blksize: 4096,
+            blocks: 0,
+            atimeMs: nowMs,
+            mtimeMs: nowMs,
+            ctimeMs: nowMs,
+            birthtimeMs: nowMs,
+            atime: now,
+            mtime: now,
+            ctime: now,
+            birthtime: now,
             isDirectory: () => entry.isDirectory(),
             isFile: () => entry.isFile(),
             isSymbolicLink: () => entry.isSymbolicLink(),
-            size: 0,
-            mtime: new Date(),
+            isBlockDevice: () => false,
+            isCharacterDevice: () => false,
+            isFIFO: () => false,
+            isSocket: () => false,
         };
     }
     catch (e) {

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

@@ -22,7 +22,6 @@ declare const _default: {
     readonly "node:domain": any;
     readonly events: any;
     readonly "node:events": any;
-    "fast-glob": any;
     readonly http: any;
     readonly "node:http": any;
     readonly http2: any;
@@ -61,7 +60,6 @@ declare const _default: {
     readonly "node:zlib": any;
     fs: typeof fs;
     "node:fs": typeof fs;
-    "graceful-fs": typeof fs;
     path: any;
     "node:path": any;
     process: any;

package/esm/webpackLoaders/worker/polyfills/nodePolyFills.js

@@ -7,6 +7,10 @@ process.cwd = () => {
     // @ts-ignore
     return ((_a = self.workerData) === null || _a === void 0 ? void 0 : _a.cwd) || (originalCwd === null || originalCwd === void 0 ? void 0 : originalCwd()) || "/";
 };
+if (!process.versions)
+    process.versions = {};
+if (!process.versions.node)
+    process.versions.node = "24.0.0";
 self.process = process;
 self.global = self;
 const path = require("path");
@@ -17,7 +21,6 @@ path.resolve = (...args) => {
     const cwd = ((_a = self.workerData) === null || _a === void 0 ? void 0 : _a.cwd) || "/";
     return originalResolve(cwd, ...args);
 };
-import fastGlob from "./fastGlobPolyfill";
 import * as fs from "./fsPolyfill";
 import * as workerThreads from "./workerThreadsPolyfill";
 const workerThreadsWithLiveWorkerData = {
@@ -96,7 +99,6 @@ export default {
     get "node:events"() {
         return require("events");
     },
-    "fast-glob": fastGlob,
     get http() {
         return require("http");
     },
@@ -207,7 +209,6 @@ export default {
     },
     fs,
     "node:fs": fs,
-    "graceful-fs": fs,
     path,
     "node:path": path,
     process,

package/package.json

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

package/esm/webpackLoaders/loaders/less-loader/index.d.ts

@@ -1,3 +0,0 @@
-export const __esModule: boolean;
-export default lessLoader;
-declare function lessLoader(source: any): Promise<void>;

package/esm/webpackLoaders/loaders/less-loader/index.js

@@ -1,103 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-exports.default = void 0;
-var _path = _interopRequireDefault(require("path"));
-var _options = _interopRequireDefault(require("./options.json"));
-var _utils = require("./utils");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-async function lessLoader(source) {
-    const options = this.getOptions(_options.default);
-    const callback = this.async();
-    let implementation;
-    try {
-        implementation = (0, _utils.getLessImplementation)(this, options.implementation);
-    }
-    catch (error) {
-        callback(error);
-        return;
-    }
-    if (!implementation) {
-        callback(new Error(`The Less implementation "${options.implementation}" not found`));
-        return;
-    }
-    const lessOptions = (0, _utils.getLessOptions)(this, options, implementation);
-    const useSourceMap = typeof options.sourceMap === "boolean" ? options.sourceMap : this.sourceMap;
-    if (useSourceMap) {
-        lessOptions.sourceMap = {
-            outputSourceFiles: true
-        };
-    }
-    let data = source;
-    if (typeof options.additionalData !== "undefined") {
-        data = typeof options.additionalData === "function" ? `${await options.additionalData(data, this)}` : `${options.additionalData}\n${data}`;
-    }
-    const logger = this.getLogger("less-loader");
-    const loaderContext = this;
-    const loggerListener = {
-        error(message) {
-            // TODO enable by default in the next major release
-            if (options.lessLogAsWarnOrErr) {
-                loaderContext.emitError(new Error(message));
-            }
-            else {
-                logger.error(message);
-            }
-        },
-        warn(message) {
-            // TODO enable by default in the next major release
-            if (options.lessLogAsWarnOrErr) {
-                loaderContext.emitWarning(new Error(message));
-            }
-            else {
-                logger.warn(message);
-            }
-        },
-        info(message) {
-            logger.log(message);
-        },
-        debug(message) {
-            logger.debug(message);
-        }
-    };
-    implementation.logger.addListener(loggerListener);
-    let result;
-    try {
-        result = await implementation.render(data, lessOptions);
-    }
-    catch (error) {
-        if (error.filename) {
-            // `less` returns forward slashes on windows when `webpack` resolver return an absolute windows path in `WebpackFileManager`
-            // Ref: https://github.com/webpack-contrib/less-loader/issues/357
-            this.addDependency(_path.default.normalize(error.filename));
-        }
-        callback((0, _utils.errorFactory)(error));
-        return;
-    }
-    finally {
-        // Fix memory leaks in `less`
-        implementation.logger.removeListener(loggerListener);
-        delete lessOptions.pluginManager.webpackLoaderContext;
-        delete lessOptions.pluginManager;
-    }
-    const { css, imports } = result;
-    imports.forEach(item => {
-        if ((0, _utils.isUnsupportedUrl)(item)) {
-            return;
-        }
-        // `less` return forward slashes on windows when `webpack` resolver return an absolute windows path in `WebpackFileManager`
-        // Ref: https://github.com/webpack-contrib/less-loader/issues/357
-        const normalizedItem = _path.default.normalize(item);
-        // Custom `importer` can return only `contents` so item will be relative
-        if (_path.default.isAbsolute(normalizedItem)) {
-            this.addDependency(normalizedItem);
-        }
-    });
-    let map = typeof result.map === "string" ? JSON.parse(result.map) : result.map;
-    if (map && useSourceMap) {
-        map = (0, _utils.normalizeSourceMap)(map, this.rootContext);
-    }
-    callback(null, css, map);
-}
-var _default = exports.default = lessLoader;