@utoo/web 1.3.0 → 1.3.1

package/esm/webpackLoaders/polyfills/{fsPromisesPolyfill.d.ts → fsPolyfill/promises.d.ts}

@@ -1,4 +1,4 @@
-import { Stats } from "../../types";
+import { Stats } from "../../../types";
 export declare const promises: {
     readFile: (p: string, options?: any) => Promise<any>;
     writeFile: (p: string, data: string | Uint8Array, options?: any) => Promise<void>;

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

@@ -0,0 +1,159 @@
+import { Buffer } from "buffer";
+import { Stats } from "../../../types";
+import { getFs, resolvePath, translateError } from "./utils";
+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 resolvedPath = resolvePath(p);
+        try {
+            const data = await (encoding
+                ? fs.readToString(resolvedPath)
+                : fs.read(resolvedPath));
+            return encoding ? data : Buffer.from(data);
+        }
+        catch (e) {
+            throw translateError(e, p, "open");
+        }
+    },
+    writeFile: async (p, data, options) => {
+        const fs = getFs();
+        const resolvedPath = resolvePath(p);
+        try {
+            if (typeof data === "string") {
+                await fs.writeString(resolvedPath, data);
+            }
+            else {
+                await fs.write(resolvedPath, data);
+            }
+        }
+        catch (e) {
+            throw translateError(e, p, "open");
+        }
+    },
+    readdir: async (p, options) => {
+        const resolvedPath = resolvePath(p);
+        try {
+            const entries = await getFs().readDir(resolvedPath);
+            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;
+            });
+        }
+        catch (e) {
+            throw translateError(e, p, "scandir");
+        }
+    },
+    mkdir: async (p, options) => {
+        const fs = getFs();
+        const resolvedPath = resolvePath(p);
+        try {
+            if (options === null || options === void 0 ? void 0 : options.recursive) {
+                await fs.createDirAll(resolvedPath);
+            }
+            else {
+                await fs.createDir(resolvedPath);
+            }
+        }
+        catch (e) {
+            throw translateError(e, p, "mkdir");
+        }
+    },
+    rm: async (p, options) => {
+        const fs = getFs();
+        const resolvedPath = resolvePath(p);
+        try {
+            const metadata = await fs.metadata(resolvedPath);
+            const type = metadata.toJSON().type;
+            if (type === "file") {
+                await fs.removeFile(resolvedPath);
+            }
+            else {
+                await fs.removeDir(resolvedPath, !!(options === null || options === void 0 ? void 0 : options.recursive));
+            }
+        }
+        catch (e) {
+            throw translateError(e, p, "rm");
+        }
+    },
+    rmdir: async (p, options) => {
+        const resolvedPath = resolvePath(p);
+        try {
+            return await getFs().removeDir(resolvedPath, !!(options === null || options === void 0 ? void 0 : options.recursive));
+        }
+        catch (e) {
+            throw translateError(e, p, "rmdir");
+        }
+    },
+    copyFile: async (src, dst) => {
+        try {
+            return await getFs().copyFile(resolvePath(src), resolvePath(dst));
+        }
+        catch (e) {
+            throw translateError(e, src, "copyfile");
+        }
+    },
+    stat: async (p) => {
+        const resolvedPath = resolvePath(p);
+        try {
+            const metadata = await getFs().metadata(resolvedPath);
+            const json = metadata.toJSON();
+            return new Stats({
+                type: json.type,
+                size: Number(json.file_size || 0),
+            });
+        }
+        catch (e) {
+            throw translateError(e, p, "stat");
+        }
+    },
+    lstat: async (p) => {
+        const resolvedPath = resolvePath(p);
+        try {
+            const metadata = await getFs().metadata(resolvedPath);
+            const json = metadata.toJSON();
+            return new Stats({
+                type: json.type,
+                size: Number(json.file_size || 0),
+            });
+        }
+        catch (e) {
+            throw translateError(e, p, "lstat");
+        }
+    },
+    realpath: async (p) => p,
+    access: async (p, mode) => {
+        const resolvedPath = resolvePath(p);
+        try {
+            await getFs().metadata(resolvedPath);
+        }
+        catch (e) {
+            throw translateError(e, p, "access");
+        }
+    },
+};
+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/polyfills/{fsPolyfill.d.ts → fsPolyfill/sync.d.ts}

@@ -1,6 +1,6 @@
 import { Buffer } from "buffer";
-import { Stats } from "../../types";
-import { promises } from "./fsPromisesPolyfill";
+import { Stats } from "../../../types";
+import { promises } from "./promises";
 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;
@@ -11,7 +11,7 @@ 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 accessSync(p: 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;

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

@@ -0,0 +1,384 @@
+import { Buffer } from "buffer";
+import { Stats } from "../../../types";
+import { promises } from "./promises";
+import { getFs, resolvePath, translateError } from "./utils";
+// --- Synchronous API (via WASM Project Sync APIs) ---
+const textDecoder = new TextDecoder();
+export function readFileSync(path, options) {
+    const fs = getFs();
+    const resolvedPath = resolvePath(path);
+    try {
+        const result = fs.readSync(resolvedPath);
+        if (options === "utf8" ||
+            options === "utf-8" ||
+            (options && (options.encoding === "utf8" || options.encoding === "utf-8"))) {
+            return textDecoder.decode(result);
+        }
+        return Buffer.from(result);
+    }
+    catch (e) {
+        throw translateError(e, path, "open");
+    }
+}
+export function readdirSync(path, options) {
+    const fs = getFs();
+    const resolvedPath = resolvePath(path);
+    try {
+        const entries = fs.readDirSync(resolvedPath);
+        if (options === null || options === void 0 ? void 0 : options.withFileTypes) {
+            return entries.map((e) => ({
+                name: e.name,
+                isFile: () => e.type === "file",
+                isDirectory: () => e.type === "directory",
+                isSymbolicLink: () => false,
+            }));
+        }
+        return entries.map((e) => e.name);
+    }
+    catch (e) {
+        throw translateError(e, path, "scandir");
+    }
+}
+export function writeFileSync(path, data, options) {
+    const fs = getFs();
+    const resolvedPath = resolvePath(path);
+    try {
+        let content;
+        if (typeof data === "string") {
+            content = new TextEncoder().encode(data);
+        }
+        else {
+            content = data;
+        }
+        fs.writeSync(resolvedPath, content);
+    }
+    catch (e) {
+        throw translateError(e, path, "open");
+    }
+}
+export function mkdirSync(path, options) {
+    const fs = getFs();
+    const resolvedPath = resolvePath(path);
+    try {
+        const recursive = (options === null || options === void 0 ? void 0 : options.recursive) || false;
+        if (recursive) {
+            fs.createDirAllSync(resolvedPath);
+        }
+        else {
+            fs.createDirSync(resolvedPath);
+        }
+    }
+    catch (e) {
+        throw translateError(e, path, "mkdir");
+    }
+}
+export function rmSync(path, options) {
+    const fs = getFs();
+    const resolvedPath = resolvePath(path);
+    try {
+        const recursive = (options === null || options === void 0 ? void 0 : options.recursive) || false;
+        if (recursive) {
+            fs.removeDirSync(resolvedPath, true);
+        }
+        else {
+            fs.removeFileSync(resolvedPath);
+        }
+    }
+    catch (e) {
+        throw translateError(e, path, "rm");
+    }
+}
+export function rmdirSync(path, options) {
+    const fs = getFs();
+    const resolvedPath = resolvePath(path);
+    try {
+        const recursive = (options === null || options === void 0 ? void 0 : options.recursive) || false;
+        fs.removeDirSync(resolvedPath, recursive);
+    }
+    catch (e) {
+        throw translateError(e, path, "rmdir");
+    }
+}
+export function copyFileSync(src, dst) {
+    const fs = getFs();
+    try {
+        fs.copyFileSync(resolvePath(src), resolvePath(dst));
+    }
+    catch (e) {
+        throw translateError(e, src, "copyfile");
+    }
+}
+export function statSync(p) {
+    const fs = getFs();
+    const resolvedPath = resolvePath(p);
+    try {
+        const metadata = fs.metadataSync(resolvedPath);
+        let type, size;
+        // @ts-ignore
+        if (typeof metadata.toJSON === "function") {
+            // @ts-ignore
+            const json = metadata.toJSON();
+            type = json.type;
+            size = json.file_size;
+        }
+        else {
+            // @ts-ignore
+            type = metadata.type;
+            // @ts-ignore
+            size = metadata.file_size;
+        }
+        return new Stats({
+            type: type === "directory" ? "directory" : "file",
+            size: Number(size || 0),
+            atimeMs: Date.now(),
+            mtimeMs: Date.now(),
+            ctimeMs: Date.now(),
+            birthtimeMs: Date.now(),
+        });
+    }
+    catch (e) {
+        throw translateError(e, p, "stat");
+    }
+}
+export function lstatSync(p) {
+    const fs = getFs();
+    const resolvedPath = resolvePath(p);
+    try {
+        const metadata = fs.metadataSync(resolvedPath);
+        let type, size;
+        // @ts-ignore
+        if (typeof metadata.toJSON === "function") {
+            // @ts-ignore
+            const json = metadata.toJSON();
+            type = json.type;
+            size = json.file_size;
+        }
+        else {
+            // @ts-ignore
+            type = metadata.type;
+            // @ts-ignore
+            size = metadata.file_size;
+        }
+        return new Stats({
+            type: type === "directory" ? "directory" : "file",
+            size: Number(size || 0),
+            atimeMs: Date.now(),
+            mtimeMs: Date.now(),
+            ctimeMs: Date.now(),
+            birthtimeMs: Date.now(),
+        });
+    }
+    catch (e) {
+        throw translateError(e, p, "lstat");
+    }
+}
+export function realpathSync(p) {
+    return p;
+}
+export function accessSync(p, mode) {
+    const fs = getFs();
+    const resolvedPath = resolvePath(p);
+    try {
+        fs.metadataSync(resolvedPath);
+    }
+    catch (e) {
+        throw translateError(e, p, "access");
+    }
+}
+export function existsSync(path) {
+    try {
+        statSync(path);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+// --- Asynchronous API (via WASM Project) ---
+export function readFile(path, options, cb) {
+    if (typeof options === "function") {
+        cb = options;
+        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 resolvedPath = resolvePath(path);
+    const fs = getFs();
+    const promise = encoding
+        ? fs.readToString(resolvedPath)
+        : fs.read(resolvedPath);
+    promise
+        .then((data) => {
+        cb(null, encoding ? data : Buffer.from(data));
+    })
+        .catch((e) => cb(translateError(e, path, "open")));
+}
+export function readdir(path, options, cb) {
+    if (typeof options === "function") {
+        cb = options;
+        options = {};
+    }
+    getFs()
+        .readDir(resolvePath(path))
+        .then((entries) => {
+        const result = 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;
+        });
+        cb(null, result);
+    })
+        .catch((e) => cb(translateError(e, path, "scandir")));
+}
+export function writeFile(path, data, options, cb) {
+    if (typeof options === "function") {
+        cb = options;
+        options = {};
+    }
+    const resolvedPath = resolvePath(path);
+    const fs = getFs();
+    const promise = typeof data === "string"
+        ? fs.writeString(resolvedPath, data)
+        : fs.write(resolvedPath, data);
+    promise
+        .then(() => cb(null))
+        .catch((e) => cb(translateError(e, path, "open")));
+}
+export function mkdir(path, options, cb) {
+    if (typeof options === "function") {
+        cb = options;
+        options = {};
+    }
+    const resolvedPath = resolvePath(path);
+    const fs = getFs();
+    const promise = (options === null || options === void 0 ? void 0 : options.recursive)
+        ? fs.createDirAll(resolvedPath)
+        : fs.createDir(resolvedPath);
+    promise
+        .then(() => cb(null))
+        .catch((e) => cb(translateError(e, path, "mkdir")));
+}
+export function rm(path, options, cb) {
+    if (typeof options === "function") {
+        cb = options;
+        options = {};
+    }
+    const resolvedPath = resolvePath(path);
+    const fs = getFs();
+    fs.metadata(resolvedPath)
+        .then((metadata) => {
+        const type = metadata.toJSON().type;
+        if (type === "file") {
+            return fs.removeFile(resolvedPath);
+        }
+        else {
+            return fs.removeDir(resolvedPath, !!(options === null || options === void 0 ? void 0 : options.recursive));
+        }
+    })
+        .then(() => cb(null))
+        .catch((e) => cb(translateError(e, path, "rm")));
+}
+export function rmdir(path, options, cb) {
+    if (typeof options === "function") {
+        cb = options;
+        options = {};
+    }
+    getFs()
+        .removeDir(resolvePath(path), !!(options === null || options === void 0 ? void 0 : options.recursive))
+        .then(() => cb(null))
+        .catch((e) => cb(translateError(e, path, "rmdir")));
+}
+export function copyFile(src, dst, cb) {
+    getFs()
+        .copyFile(resolvePath(src), resolvePath(dst))
+        .then(() => cb(null))
+        .catch((e) => cb(translateError(e, src, "copyfile")));
+}
+export function stat(p, cb) {
+    getFs()
+        .metadata(resolvePath(p))
+        .then((metadata) => {
+        const json = metadata.toJSON();
+        cb(null, new Stats({
+            type: json.type,
+            size: Number(json.file_size || 0),
+        }));
+    })
+        .catch((e) => cb(translateError(e, p, "stat")));
+}
+export function lstat(p, cb) {
+    getFs()
+        .metadata(resolvePath(p))
+        .then((metadata) => {
+        const json = metadata.toJSON();
+        cb(null, new Stats({
+            type: json.type,
+            size: Number(json.file_size || 0),
+        }));
+    })
+        .catch((e) => cb(translateError(e, p, "lstat")));
+}
+export function realpath(p, cb) {
+    cb(null, p);
+}
+export function access(p, mode, cb) {
+    if (typeof mode === "function") {
+        cb = mode;
+        mode = 0;
+    }
+    getFs()
+        .metadata(resolvePath(p))
+        .then(() => {
+        if (cb)
+            cb(null);
+    })
+        .catch((e) => {
+        if (cb)
+            cb(translateError(e, p, "access"));
+    });
+}
+export const constants = {
+    F_OK: 0,
+    R_OK: 4,
+    W_OK: 2,
+    X_OK: 1,
+};
+export default {
+    readFile,
+    readFileSync,
+    readdir,
+    readdirSync,
+    writeFile,
+    writeFileSync,
+    mkdir,
+    mkdirSync,
+    rm,
+    rmSync,
+    rmdir,
+    rmdirSync,
+    copyFile,
+    copyFileSync,
+    stat,
+    statSync,
+    lstat,
+    lstatSync,
+    realpath,
+    realpathSync,
+    access,
+    accessSync,
+    existsSync,
+    promises,
+    constants,
+};
+export { promises };

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

@@ -0,0 +1,3 @@
+export declare function resolvePath(p: string): string;
+export declare function getFs(): any;
+export declare function translateError(error: any, path: string, syscall: string): any;

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

@@ -0,0 +1,28 @@
+import path from "path";
+import { workerData } from "../workerThreadsPolyfill";
+export function resolvePath(p) {
+    var _a, _b;
+    // @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)) || (workerData === null || workerData === void 0 ? void 0 : workerData.cwd) || "/";
+    return path.resolve(cwd, p);
+}
+export function getFs() {
+    // @ts-ignore
+    const fs = workerData.fs;
+    if (!fs) {
+        throw new Error("FS not initialized");
+    }
+    return fs;
+}
+export function translateError(error, path, syscall) {
+    const message = error.message || String(error);
+    if (message.includes("NotFound")) {
+        const e = new Error(`ENOENT: no such file or directory, ${syscall} '${path}'`);
+        e.errno = -2;
+        e.code = "ENOENT";
+        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";
+import * as fs from "./fsPolyfill/sync";
 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";
+import * as fs from "./fsPolyfill/sync";
 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.0",
+  "version": "1.3.1",
   "module": "esm/index.js",
   "types": "esm/index.d.ts",
   "files": [