@utoo/web 1.1.0 → 1.2.0-rc.2

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

@@ -0,0 +1,316 @@
+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";
+function resolvePath(p) {
+    var _a, _b, _c;
+    // @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) || "/";
+    if (cwd === "/") {
+        if (p.startsWith("/")) {
+            return p.slice(1);
+        }
+        return p;
+    }
+    if (p.startsWith(cwd)) {
+        // Check if it's an exact match or followed by separator
+        if (p.length === cwd.length) {
+            return ".";
+        }
+        if (p[cwd.length] === path.sep || p[cwd.length] === "/") {
+            let relative = p.slice(cwd.length);
+            if (relative.startsWith("/"))
+                relative = relative.slice(1);
+            return relative || ".";
+        }
+    }
+    return p;
+}
+function getSabClient() {
+    // @ts-ignore
+    const client = self.workerData.sabClient;
+    if (!client) {
+        throw new Error("Sync fs not supported (no sabClient)");
+    }
+    return client;
+}
+export function readFile(path, options, cb) {
+    if (typeof options === "function") {
+        cb = options;
+        options = {};
+    }
+    try {
+        const data = readFileSync(path, options);
+        cb(null, data);
+    }
+    catch (e) {
+        cb(e);
+    }
+}
+export function readFileSync(path, options) {
+    const client = getSabClient();
+    const result = client.call(SAB_OP_READ_FILE, resolvePath(path));
+    if (options === "utf8" ||
+        options === "utf-8" ||
+        (options && (options.encoding === "utf8" || options.encoding === "utf-8"))) {
+        return new TextDecoder().decode(result);
+    }
+    return Buffer.from(result);
+}
+export function readdirSync(path, options) {
+    const client = getSabClient();
+    const result = client.call(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) {
+        return entries.map((e) => ({
+            name: e.name,
+            isFile: () => e.type === "file",
+            isDirectory: () => e.type === "directory",
+            isSymbolicLink: () => false,
+        }));
+    }
+    return entries.map((e) => e.name);
+}
+export function readdir(path, options, cb) {
+    if (typeof options === "function") {
+        cb = options;
+        options = {};
+    }
+    try {
+        const files = readdirSync(path, options);
+        cb(null, files);
+    }
+    catch (e) {
+        cb(e);
+    }
+}
+export function writeFileSync(path, data, options) {
+    const client = getSabClient();
+    // 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);
+}
+export function writeFile(path, data, options, cb) {
+    if (typeof options === "function") {
+        cb = options;
+        options = {};
+    }
+    try {
+        writeFileSync(path, data, options);
+        cb(null);
+    }
+    catch (e) {
+        cb(e);
+    }
+}
+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);
+}
+export function mkdir(path, options, cb) {
+    if (typeof options === "function") {
+        cb = options;
+        options = {};
+    }
+    try {
+        mkdirSync(path, options);
+        cb(null);
+    }
+    catch (e) {
+        cb(e);
+    }
+}
+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);
+}
+export function rm(path, options, cb) {
+    if (typeof options === "function") {
+        cb = options;
+        options = {};
+    }
+    try {
+        rmSync(path, options);
+        cb(null);
+    }
+    catch (e) {
+        cb(e);
+    }
+}
+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);
+}
+export function rmdir(path, options, cb) {
+    if (typeof options === "function") {
+        cb = options;
+        options = {};
+    }
+    try {
+        rmdirSync(path, options);
+        cb(null);
+    }
+    catch (e) {
+        cb(e);
+    }
+}
+export function copyFileSync(src, dst) {
+    const client = getSabClient();
+    const payload = JSON.stringify({
+        src: resolvePath(src),
+        dst: resolvePath(dst),
+    });
+    client.call(SAB_OP_COPY_FILE, payload);
+}
+export function copyFile(src, dst, cb) {
+    try {
+        copyFileSync(src, dst);
+        cb(null);
+    }
+    catch (e) {
+        cb(e);
+    }
+}
+export function statSync(p) {
+    const parent = path.dirname(p);
+    const name = path.basename(p);
+    // Root check
+    if (p === "/" || p === ".") {
+        return {
+            isDirectory: () => true,
+            isFile: () => false,
+            isSymbolicLink: () => false,
+            size: 0,
+            mtime: new Date(),
+        };
+    }
+    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}'`);
+        }
+        return {
+            isDirectory: () => entry.isDirectory(),
+            isFile: () => entry.isFile(),
+            isSymbolicLink: () => entry.isSymbolicLink(),
+            size: 0,
+            mtime: new Date(),
+        };
+    }
+    catch (e) {
+        throw e;
+    }
+}
+export function lstatSync(p) {
+    return statSync(p);
+}
+export function stat(path, cb) {
+    try {
+        const stats = statSync(path);
+        cb(null, stats);
+    }
+    catch (e) {
+        cb(e);
+    }
+}
+export function lstat(path, cb) {
+    try {
+        const stats = lstatSync(path);
+        cb(null, stats);
+    }
+    catch (e) {
+        cb(e);
+    }
+}
+export function realpathSync(p) {
+    return p;
+}
+export function realpath(p, cb) {
+    cb(null, p);
+}
+export function accessSync(path, mode) {
+    try {
+        statSync(path);
+    }
+    catch (e) {
+        throw e;
+    }
+}
+export function access(path, mode, cb) {
+    if (typeof mode === "function") {
+        cb = mode;
+        mode = 0;
+    }
+    try {
+        accessSync(path, mode);
+        if (cb)
+            cb(null);
+    }
+    catch (e) {
+        if (cb)
+            cb(e);
+    }
+}
+export function existsSync(path) {
+    try {
+        statSync(path);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+export const promises = {
+    readFile: async (path, options) => readFileSync(path, options),
+    writeFile: async (path, data, options) => writeFileSync(path, data, options),
+    readdir: async (path, options) => readdirSync(path, options),
+    mkdir: async (path, options) => mkdirSync(path, options),
+    rm: async (path, options) => rmSync(path, options),
+    rmdir: async (path, options) => rmdirSync(path, options),
+    copyFile: async (src, dst) => copyFileSync(src, dst),
+    stat: async (p) => statSync(p),
+    lstat: async (p) => lstatSync(p),
+    realpath: async (p) => realpathSync(p),
+    access: async (path, mode) => accessSync(path, mode),
+};
+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,
+};

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

@@ -0,0 +1,9 @@
+import { promises } from "./fsPolyfill";
+export declare const readFile: (path: string, options?: any) => Promise<string | Buffer<any>>;
+export declare const writeFile: (path: string, data: string | Uint8Array, options?: any) => Promise<void>;
+export declare const readdir: (path: string, options?: any) => Promise<any>;
+export declare const mkdir: (path: string, options?: any) => Promise<void>;
+export declare const rm: (path: string, options?: any) => Promise<void>;
+export declare const rmdir: (path: string, options?: any) => Promise<void>;
+export declare const copyFile: (src: string, dst: string) => Promise<void>;
+export default promises;

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

@@ -0,0 +1,9 @@
+import { promises } from "./fsPolyfill";
+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 default promises;

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

@@ -0,0 +1,94 @@
+import * as fs from "./fsPolyfill";
+declare const _default: {
+    readonly assert: any;
+    readonly "node:assert": any;
+    buffer: any;
+    "node:buffer": any;
+    readonly child_process: any;
+    readonly "node:child_process": any;
+    readonly cluster: any;
+    readonly "node:cluster": any;
+    readonly console: any;
+    readonly "node:console": any;
+    readonly constants: any;
+    readonly "node:constants": any;
+    readonly crypto: any;
+    readonly "node:crypto": any;
+    readonly dgram: any;
+    readonly "node:dgram": any;
+    readonly dns: any;
+    readonly "node:dns": any;
+    readonly domain: any;
+    readonly "node:domain": any;
+    readonly events: any;
+    readonly "node:events": any;
+    "fast-glob": any;
+    readonly http: any;
+    readonly "node:http": any;
+    readonly http2: any;
+    readonly "node:http2": any;
+    readonly https: any;
+    readonly "node:https": any;
+    readonly module: any;
+    readonly "node:module": any;
+    readonly net: any;
+    readonly "node:net": any;
+    readonly os: any;
+    readonly "node:os": any;
+    readonly punycode: any;
+    readonly "node:punycode": any;
+    readonly querystring: any;
+    readonly "node:querystring": any;
+    readonly readline: any;
+    readonly "node:readline": any;
+    readonly repl: any;
+    readonly "node:repl": any;
+    readonly stream: any;
+    readonly "node:stream": any;
+    readonly string_decoder: any;
+    readonly "node:string_decoder": any;
+    readonly sys: any;
+    readonly "node:sys": any;
+    readonly timers: any;
+    readonly "node:timers": any;
+    readonly tls: any;
+    readonly "node:tls": any;
+    readonly tty: any;
+    readonly "node:tty": any;
+    readonly vm: any;
+    readonly "node:vm": any;
+    readonly zlib: any;
+    readonly "node:zlib": any;
+    fs: typeof fs;
+    "node:fs": typeof fs;
+    "graceful-fs": typeof fs;
+    path: any;
+    "node:path": any;
+    process: any;
+    "node:process": any;
+    readonly url: any;
+    readonly "node:url": any;
+    readonly util: any;
+    readonly "node:util": any;
+    worker_threads: {
+        workerData: any;
+        threadId: any;
+        isMainThread: false;
+        parentPort: {
+            postMessage: (message: any) => void;
+            on: (event: string, listener: (...args: any[]) => void) => void;
+            off: (event: string, listener: (...args: any[]) => void) => void;
+        };
+    };
+    "node:worker_threads": {
+        workerData: any;
+        threadId: any;
+        isMainThread: false;
+        parentPort: {
+            postMessage: (message: any) => void;
+            on: (event: string, listener: (...args: any[]) => void) => void;
+            off: (event: string, listener: (...args: any[]) => void) => void;
+        };
+    };
+};
+export default _default;

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

@@ -0,0 +1,229 @@
+const buffer = require("buffer");
+self.Buffer = buffer.Buffer;
+const process = require("process");
+const originalCwd = process.cwd;
+process.cwd = () => {
+    var _a;
+    // @ts-ignore
+    return ((_a = self.workerData) === null || _a === void 0 ? void 0 : _a.cwd) || (originalCwd === null || originalCwd === void 0 ? void 0 : originalCwd()) || "/";
+};
+self.process = process;
+self.global = self;
+const path = require("path");
+const originalResolve = path.resolve;
+path.resolve = (...args) => {
+    var _a;
+    // @ts-ignore
+    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 = {
+    ...workerThreads,
+    get workerData() {
+        // @ts-ignore
+        return self.workerData;
+    },
+    get threadId() {
+        var _a;
+        // @ts-ignore
+        return ((_a = self.workerData) === null || _a === void 0 ? void 0 : _a.workerId) || 0;
+    },
+};
+// Used to directly inject polyfill instance into systemjs
+export default {
+    get assert() {
+        return require("assert");
+    },
+    get "node:assert"() {
+        return require("assert");
+    },
+    buffer,
+    "node:buffer": buffer,
+    get child_process() {
+        return require("child_process");
+    },
+    get "node:child_process"() {
+        return require("child_process");
+    },
+    get cluster() {
+        return require("cluster");
+    },
+    get "node:cluster"() {
+        return require("cluster");
+    },
+    get console() {
+        return require("console");
+    },
+    get "node:console"() {
+        return require("console");
+    },
+    get constants() {
+        return require("constants");
+    },
+    get "node:constants"() {
+        return require("constants");
+    },
+    get crypto() {
+        return require("crypto");
+    },
+    get "node:crypto"() {
+        return require("crypto");
+    },
+    get dgram() {
+        return require("dgram");
+    },
+    get "node:dgram"() {
+        return require("dgram");
+    },
+    get dns() {
+        return require("dns");
+    },
+    get "node:dns"() {
+        return require("dns");
+    },
+    get domain() {
+        return require("domain");
+    },
+    get "node:domain"() {
+        return require("domain");
+    },
+    get events() {
+        return require("events");
+    },
+    get "node:events"() {
+        return require("events");
+    },
+    "fast-glob": fastGlob,
+    get http() {
+        return require("http");
+    },
+    get "node:http"() {
+        return require("http");
+    },
+    get http2() {
+        return require("http2");
+    },
+    get "node:http2"() {
+        return require("http2");
+    },
+    get https() {
+        return require("https");
+    },
+    get "node:https"() {
+        return require("https");
+    },
+    get module() {
+        return require("module");
+    },
+    get "node:module"() {
+        return require("module");
+    },
+    get net() {
+        return require("net");
+    },
+    get "node:net"() {
+        return require("net");
+    },
+    get os() {
+        return require("os");
+    },
+    get "node:os"() {
+        return require("os");
+    },
+    get punycode() {
+        return require("punycode");
+    },
+    get "node:punycode"() {
+        return require("punycode");
+    },
+    get querystring() {
+        return require("querystring");
+    },
+    get "node:querystring"() {
+        return require("querystring");
+    },
+    get readline() {
+        return require("readline");
+    },
+    get "node:readline"() {
+        return require("readline");
+    },
+    get repl() {
+        return require("repl");
+    },
+    get "node:repl"() {
+        return require("repl");
+    },
+    get stream() {
+        return require("stream");
+    },
+    get "node:stream"() {
+        return require("stream");
+    },
+    get string_decoder() {
+        return require("string_decoder");
+    },
+    get "node:string_decoder"() {
+        return require("string_decoder");
+    },
+    get sys() {
+        return require("util");
+    },
+    get "node:sys"() {
+        return require("util");
+    },
+    get timers() {
+        return require("timers");
+    },
+    get "node:timers"() {
+        return require("timers");
+    },
+    get tls() {
+        return require("tls");
+    },
+    get "node:tls"() {
+        return require("tls");
+    },
+    get tty() {
+        return require("tty");
+    },
+    get "node:tty"() {
+        return require("tty");
+    },
+    get vm() {
+        return require("vm");
+    },
+    get "node:vm"() {
+        return require("vm");
+    },
+    get zlib() {
+        return require("zlib");
+    },
+    get "node:zlib"() {
+        return require("zlib");
+    },
+    fs,
+    "node:fs": fs,
+    "graceful-fs": fs,
+    path,
+    "node:path": path,
+    process,
+    "node:process": process,
+    get url() {
+        return require("url");
+    },
+    get "node:url"() {
+        return require("url");
+    },
+    get util() {
+        return require("util");
+    },
+    get "node:util"() {
+        return require("util");
+    },
+    worker_threads: workerThreadsWithLiveWorkerData,
+    "node:worker_threads": workerThreadsWithLiveWorkerData,
+};

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

@@ -0,0 +1,7 @@
+export declare const workerData: any;
+export declare const isMainThread = false;
+export declare const parentPort: {
+    postMessage: (message: any) => void;
+    on: (event: string, listener: (...args: any[]) => void) => void;
+    off: (event: string, listener: (...args: any[]) => void) => void;
+};

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

@@ -0,0 +1,16 @@
+// @ts-ignore
+export const workerData = self.workerData;
+export const isMainThread = false;
+export const parentPort = {
+    postMessage: (message) => self.postMessage(message),
+    on: (event, listener) => {
+        if (event === "message") {
+            self.onmessage = (e) => listener(e.data);
+        }
+    },
+    off: (event, listener) => {
+        if (event === "message") {
+            self.onmessage = null;
+        }
+    },
+};

package/esm/webpackLoaders/worker/type.d.ts

@@ -1,6 +1,5 @@
 export interface LoaderRunnerMeta {
     workerData: {
-        poolId: string;
         workerId: number;
         cwd: string;
     };
@@ -8,4 +7,5 @@ export interface LoaderRunnerMeta {
         importMaps: Record<string, string>;
         entrypoint: string;
     };
+    sab?: SharedArrayBuffer;
 }