@utoo/web 1.2.0-rc.1 → 1.2.0-rc.11

package/esm/loaderWorker.js.LICENSE.txt

@@ -16,27 +16,6 @@
  * @license  MIT
  */
 
-/*!
- * fill-range <https://github.com/jonschlinkert/fill-range>
- *
- * Copyright (c) 2014-present, Jon Schlinkert.
- * Licensed under the MIT License.
- */
-
-/*!
- * is-number <https://github.com/jonschlinkert/is-number>
- *
- * Copyright (c) 2014-present, Jon Schlinkert.
- * Released under the MIT License.
- */
-
-/*!
- * to-regex-range <https://github.com/micromatch/to-regex-range>
- *
- * Copyright (c) 2015-present, Jon Schlinkert.
- * Released under the MIT License.
- */
-
 /*! https://mths.be/punycode v1.4.1 by @mathias */
 
 /*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */

package/esm/{forkedProject.d.ts → project/ForkedProject.d.ts}

@@ -1,15 +1,16 @@
-import { PackFile, ProjectEndpoint } from "./type";
+import { DepsOptions, PackFile, ProjectEndpoint, Stats } from "../types";
 export declare class ForkedProject implements ProjectEndpoint {
     private endpoint;
     constructor(port: MessagePort);
+    deps(options?: DepsOptions): Promise<string>;
     install(packageLock: string, maxConcurrentDownloads?: number): Promise<void>;
-    build(): Promise<import("./type").BuildOutput>;
+    build(): Promise<import("..").BuildOutput>;
     readFile(path: string, encoding?: "utf8"): Promise<any>;
     writeFile(path: string, content: string | Uint8Array, encoding?: "utf8"): Promise<void>;
     copyFile(src: string, dst: string): Promise<void>;
     readdir(path: string, options?: {
         recursive?: boolean;
-    }): Promise<import("./type").Dirent[]>;
+    }): Promise<import("..").Dirent[]>;
     mkdir(path: string, options?: {
         recursive?: boolean;
     }): Promise<void>;
@@ -19,6 +20,7 @@ export declare class ForkedProject implements ProjectEndpoint {
     rmdir(path: string, options?: {
         recursive?: boolean;
     }): Promise<void>;
+    stat(path: string): Promise<Stats>;
     gzip(files: PackFile[]): Promise<Uint8Array>;
     sigMd5(content: Uint8Array): Promise<string>;
 }

package/esm/{forkedProject.js → project/ForkedProject.js}

@@ -1,9 +1,13 @@
 import * as comlink from "comlink";
+import { Stats, } from "../types";
 export class ForkedProject {
     constructor(port) {
         var _a;
         (_a = this.endpoint) !== null && _a !== void 0 ? _a : (this.endpoint = comlink.wrap(port));
     }
+    async deps(options) {
+        return await this.endpoint.deps(options);
+    }
     async install(packageLock, maxConcurrentDownloads) {
         return await this.endpoint.install(packageLock, maxConcurrentDownloads);
     }
@@ -31,6 +35,10 @@ export class ForkedProject {
     async rmdir(path, options) {
         return await this.endpoint.rmdir(path, options);
     }
+    async stat(path) {
+        const raw = (await this.endpoint.stat(path));
+        return new Stats(raw);
+    }
     async gzip(files) {
         return await this.endpoint.gzip(files);
     }

package/esm/{internalProject.d.ts → project/InternalProject.d.ts}

@@ -1,16 +1,17 @@
-import { PackFile, ProjectEndpoint, ProjectOptions } from "./type";
-import initWasm, { Project as ProjectInternal } from "./utoo";
+import { DepsOptions, PackFile, ProjectEndpoint, ProjectOptions, Stats } from "../types";
+import initWasm from "../utoo";
 declare class InternalEndpoint implements ProjectEndpoint {
-    projectInternal?: ProjectInternal;
     wasmInit?: ReturnType<typeof initWasm>;
     options?: Omit<ProjectOptions, "workerUrl" | "serviceWorker">;
     loaderWorkerPoolInitialized: boolean;
     mount(opt: Omit<ProjectOptions, "workerUrl" | "serviceWorker">): Promise<void>;
+    deps(options?: DepsOptions): Promise<string>;
     install(packageLock: string, maxConcurrentDownloads?: number): Promise<void>;
     build(): Promise<any>;
     readFile(path: string, encoding?: "utf8"): Promise<any>;
     writeFile(path: string, content: string | Uint8Array, _encoding?: "utf8"): Promise<void>;
     copyFile(src: string, dst: string): Promise<void>;
+    stat(path: string): Promise<Stats>;
     readdir(path: string, options?: {
         recursive?: boolean;
     }): Promise<any>;
@@ -23,7 +24,7 @@ declare class InternalEndpoint implements ProjectEndpoint {
     rmdir(path: string, options?: {
         recursive?: boolean;
     }): Promise<void>;
-    gzip(files: PackFile[]): Promise<Uint8Array<ArrayBufferLike>>;
+    gzip(files: PackFile[]): Promise<Uint8Array<ArrayBuffer>>;
     sigMd5(content: Uint8Array): Promise<string>;
 }
 declare const internalEndpoint: InternalEndpoint;

package/esm/project/InternalProject.js

@@ -0,0 +1,134 @@
+import * as comlink from "comlink";
+import initWasm, { initLogFilter, Project as ProjectInternal, } from "../utoo";
+import { runLoaderWorkerPool } from "../webpackLoaders/loaderWorkerPool";
+class InternalEndpoint {
+    constructor() {
+        this.loaderWorkerPoolInitialized = false;
+    }
+    // This should be called only once
+    async mount(opt) {
+        var _a;
+        this.options = opt;
+        const { cwd, wasmUrl, threadWorkerUrl, logFilter } = opt;
+        (_a = this.wasmInit) !== null && _a !== void 0 ? _a : (this.wasmInit = initWasm(wasmUrl));
+        await this.wasmInit;
+        // Initialize log filter after wasm init
+        const filter = logFilter ||
+            "pack_core=info,pack_api=info,utoo_wasm=info,utoo_ruborist=info";
+        initLogFilter(filter);
+        const absoluteCwd = cwd.startsWith("/") ? cwd : "/" + cwd;
+        ProjectInternal.init(threadWorkerUrl || "");
+        ProjectInternal.setCwd(absoluteCwd);
+        return;
+    }
+    async deps(options) {
+        var _a, _b;
+        await this.wasmInit;
+        return await ProjectInternal.deps((_a = options === null || options === void 0 ? void 0 : options.registry) !== null && _a !== void 0 ? _a : undefined, (_b = options === null || options === void 0 ? void 0 : options.concurrency) !== null && _b !== void 0 ? _b : undefined);
+    }
+    async install(packageLock, maxConcurrentDownloads) {
+        await this.wasmInit;
+        await ProjectInternal.install(packageLock, maxConcurrentDownloads);
+        return;
+    }
+    async build() {
+        var _a, _b;
+        const binding = await this.wasmInit;
+        if (((_a = this.options) === null || _a === void 0 ? void 0 : _a.loaderWorkerUrl) && !this.loaderWorkerPoolInitialized) {
+            runLoaderWorkerPool(binding, this.options.cwd, this.options.loaderWorkerUrl, (_b = this.options) === null || _b === void 0 ? void 0 : _b.loadersImportMap);
+            this.loaderWorkerPoolInitialized = true;
+        }
+        return await ProjectInternal.build();
+    }
+    async readFile(path, encoding) {
+        await this.wasmInit;
+        let ret;
+        if (encoding === "utf8") {
+            ret = await ProjectInternal.readToString(path);
+        }
+        else {
+            ret = await ProjectInternal.read(path);
+            const copied = ret.slice(0);
+            return comlink.transfer(copied, [copied.buffer]);
+        }
+        return ret;
+    }
+    async writeFile(path, content, _encoding) {
+        await this.wasmInit;
+        if (typeof content === "string") {
+            return await ProjectInternal.writeString(path, content);
+        }
+        else {
+            return await ProjectInternal.write(path, content);
+        }
+    }
+    async copyFile(src, dst) {
+        await this.wasmInit;
+        return await ProjectInternal.copyFile(src, dst);
+    }
+    async stat(path) {
+        await this.wasmInit;
+        const metadata = await ProjectInternal.metadata(path);
+        const json = metadata.toJSON();
+        const raw = {
+            type: json.type,
+            size: Number(json.file_size),
+        };
+        // WARN: This is a hack, functions can not be structurally cloned
+        return raw;
+    }
+    async readdir(path, options) {
+        await this.wasmInit;
+        const dirEntries = (options === null || options === void 0 ? void 0 : options.recursive)
+            ? await ProjectInternal.readDir(path)
+            : // TODO: support recursive readDirAll
+                await ProjectInternal.readDir(path);
+        const rawDirents = dirEntries.map((e) => {
+            const dir = e.toJSON();
+            return {
+                name: dir.name,
+                type: dir.type,
+            };
+        });
+        // WARN: This is a hack, functions can not be structurally cloned
+        return rawDirents;
+    }
+    async mkdir(path, options) {
+        await this.wasmInit;
+        if (options === null || options === void 0 ? void 0 : options.recursive) {
+            return await ProjectInternal.createDirAll(path);
+        }
+        else {
+            return await ProjectInternal.createDir(path);
+        }
+    }
+    async rm(path, options) {
+        await this.wasmInit;
+        let metadata = (await ProjectInternal.metadata(path)).toJSON();
+        switch (metadata.type) {
+            case "file":
+                return await ProjectInternal.removeFile(path);
+            case "directory":
+                return await ProjectInternal.removeDir(path, !!(options === null || options === void 0 ? void 0 : options.recursive));
+            default:
+                // nothing to remove now
+                break;
+        }
+    }
+    async rmdir(path, options) {
+        await this.wasmInit;
+        return await ProjectInternal.removeDir(path, !!(options === null || options === void 0 ? void 0 : options.recursive));
+    }
+    async gzip(files) {
+        await this.wasmInit;
+        const ret = await ProjectInternal.gzip(files);
+        const copied = ret.slice(0);
+        return comlink.transfer(copied, [copied.buffer]);
+    }
+    async sigMd5(content) {
+        await this.wasmInit;
+        return await ProjectInternal.sigMd5(content);
+    }
+}
+const internalEndpoint = new InternalEndpoint();
+export { internalEndpoint };

package/esm/{project.d.ts → project/Project.d.ts}

@@ -1,4 +1,4 @@
-import { BuildOutput, Dirent, PackFile, ProjectEndpoint, ProjectOptions, ServiceWorkerOptions } from "./type";
+import { BuildOutput, DepsOptions, Dirent, PackFile, ProjectEndpoint, ProjectOptions, ServiceWorkerOptions, Stats } from "../types";
 export declare class Project implements ProjectEndpoint {
     #private;
     private options;
@@ -9,6 +9,7 @@ export declare class Project implements ProjectEndpoint {
     private connectWorker;
     installServiceWorker(): Promise<void>;
     mount(): Promise<void>;
+    deps(options?: DepsOptions): Promise<string>;
     install(packageLock: string, maxConcurrentDownloads?: number): Promise<void>;
     build(): Promise<BuildOutput>;
     readFile(path: string, encoding?: "utf8"): Promise<any>;
@@ -26,6 +27,7 @@ export declare class Project implements ProjectEndpoint {
     rmdir(path: string, options?: {
         recursive?: boolean;
     }): Promise<void>;
+    stat(path: string): Promise<Stats>;
     gzip(files: PackFile[]): Promise<Uint8Array>;
     sigMd5(content: Uint8Array): Promise<string>;
     static fork(channel: MessageChannel, eventSource?: Client | DedicatedWorkerGlobalScope): ProjectEndpoint;

package/esm/{project.js → project/Project.js}

@@ -12,10 +12,10 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
 var _Project_mount;
 import { handleIssues } from "@utoo/pack-shared";
 import * as comlink from "comlink";
-import { ForkedProject } from "./forkedProject";
-import { installServiceWorker } from "./installServiceWorker";
-import { Fork, HandShake } from "./message";
-import { Dirent, } from "./type";
+import { Dirent, Stats, } from "../types";
+import { installServiceWorker } from "../utils/installServiceWorker";
+import { Fork, HandShake } from "../utils/message";
+import { ForkedProject } from "./ForkedProject";
 let ProjectWorker;
 const ConnectedPorts = new Set();
 export class Project {
@@ -65,6 +65,10 @@ export class Project {
     async mount() {
         return await __classPrivateFieldGet(this, _Project_mount, "f");
     }
+    async deps(options) {
+        await __classPrivateFieldGet(this, _Project_mount, "f");
+        return await this.remote.deps(options);
+    }
     async install(packageLock, maxConcurrentDownloads) {
         await __classPrivateFieldGet(this, _Project_mount, "f");
         return await this.remote.install(packageLock, maxConcurrentDownloads);
@@ -81,6 +85,9 @@ export class Project {
     }
     async writeFile(path, content, encoding) {
         await __classPrivateFieldGet(this, _Project_mount, "f");
+        if (content instanceof Uint8Array) {
+            return await this.remote.writeFile(path, comlink.transfer(content, [content.buffer]), encoding);
+        }
         return await this.remote.writeFile(path, content, encoding);
     }
     async copyFile(src, dst) {
@@ -104,13 +111,19 @@ export class Project {
         await __classPrivateFieldGet(this, _Project_mount, "f");
         return await this.remote.rmdir(path, options);
     }
+    async stat(path) {
+        await __classPrivateFieldGet(this, _Project_mount, "f");
+        const raw = (await this.remote.stat(path));
+        return new Stats(raw);
+    }
     async gzip(files) {
         await __classPrivateFieldGet(this, _Project_mount, "f");
-        return await this.remote.gzip(files);
+        const buffers = files.map((f) => f.content.buffer);
+        return await this.remote.gzip(comlink.transfer(files, buffers));
     }
     async sigMd5(content) {
         await __classPrivateFieldGet(this, _Project_mount, "f");
-        return await this.remote.sigMd5(content);
+        return await this.remote.sigMd5(comlink.transfer(content, [content.buffer]));
     }
     static fork(channel, eventSource) {
         (eventSource || self).postMessage(Fork, {

package/esm/serviceWorker.js

@@ -1,5 +1,5 @@
-import { Project } from ".";
-import { ServiceWorkerHandShake } from "./message";
+import { Project } from "./project/Project";
+import { ServiceWorkerHandShake } from "./utils/message";
 let _resolve;
 let _promise = new Promise((resolve) => {
     _resolve = resolve;
@@ -54,12 +54,13 @@ async function readFileFromProject(projectPath) {
             headers: {
                 "Content-Type": mimeType,
                 ...(mimeType === "text/html"
-                    ? { "Cross-Origin-Embedder-Policy": "require-corp" }
+                    ? { "Cross-Origin-Embedder-Policy": "credentialless" }
                     : {}),
             },
         });
     }
     catch (e) {
+        console.error(`File ${projectPath} not found`);
         return new Response("Not Found", { status: 404 });
     }
 }

package/esm/{type.d.ts → types.d.ts}

@@ -4,6 +4,43 @@ export interface RawDirent {
     name: string;
     type: DirEntryType;
 }
+export interface RawStats {
+    type: DirEntryType;
+    size: number;
+    atimeMs?: number;
+    mtimeMs?: number;
+    ctimeMs?: number;
+    birthtimeMs?: number;
+}
+export declare class Stats {
+    private raw;
+    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;
+    constructor(raw: RawStats);
+    isDirectory(): boolean;
+    isFile(): boolean;
+    isSymbolicLink(): boolean;
+    isBlockDevice(): boolean;
+    isCharacterDevice(): boolean;
+    isFIFO(): boolean;
+    isSocket(): boolean;
+}
 export declare class Dirent {
     private rawDirent;
     name: string;
@@ -18,7 +55,12 @@ export interface PackFile {
     path: string;
     content: Uint8Array;
 }
+export interface DepsOptions {
+    registry?: string | null;
+    concurrency?: number | null;
+}
 export interface ProjectEndpoint {
+    deps: (options?: DepsOptions) => Promise<string>;
     install: (packageLock: string, maxConcurrentDownloads?: number) => Promise<void>;
     build: () => Promise<BuildOutput>;
     readFile(path: string): Promise<Uint8Array>;
@@ -37,6 +79,7 @@ export interface ProjectEndpoint {
         recursive?: boolean;
     }): Promise<void>;
     copyFile(src: string, dst: string): Promise<void>;
+    stat(path: string): Promise<Stats>;
     gzip: (files: PackFile[]) => Promise<Uint8Array>;
     sigMd5: (content: Uint8Array) => Promise<string>;
 }

package/esm/types.js

@@ -0,0 +1,56 @@
+export class Stats {
+    constructor(raw) {
+        this.raw = raw;
+        this.dev = 0;
+        this.ino = 0;
+        this.nlink = 1;
+        this.uid = 0;
+        this.gid = 0;
+        this.rdev = 0;
+        this.blksize = 4096;
+        this.blocks = 0;
+        this.size = raw.size;
+        this.mode = raw.type === "directory" ? 16877 : 33188;
+        this.atimeMs = raw.atimeMs || 0;
+        this.mtimeMs = raw.mtimeMs || 0;
+        this.ctimeMs = raw.ctimeMs || 0;
+        this.birthtimeMs = raw.birthtimeMs || 0;
+        this.atime = new Date(this.atimeMs);
+        this.mtime = new Date(this.mtimeMs);
+        this.ctime = new Date(this.ctimeMs);
+        this.birthtime = new Date(this.birthtimeMs);
+    }
+    isDirectory() {
+        return this.raw.type === "directory";
+    }
+    isFile() {
+        return this.raw.type === "file";
+    }
+    isSymbolicLink() {
+        return false;
+    }
+    isBlockDevice() {
+        return false;
+    }
+    isCharacterDevice() {
+        return false;
+    }
+    isFIFO() {
+        return false;
+    }
+    isSocket() {
+        return false;
+    }
+}
+export class Dirent {
+    constructor(rawDirent) {
+        this.rawDirent = rawDirent;
+        this.name = this.rawDirent.name;
+    }
+    isDirectory() {
+        return this.rawDirent.type === "directory";
+    }
+    isFile() {
+        return this.rawDirent.type === "file";
+    }
+}

package/esm/utils/sabcom.d.ts

@@ -0,0 +1,61 @@
+export declare const SAB_STATE_IDLE = 0;
+export declare const SAB_STATE_REQUEST = 1;
+export declare const SAB_STATE_RESPONSE = 2;
+export declare const SAB_STATE_ERROR = 3;
+export declare const SAB_OP_READ_FILE = 1;
+export declare const SAB_OP_READ_DIR = 2;
+export declare const SAB_OP_WRITE_FILE = 3;
+export declare const SAB_OP_MKDIR = 4;
+export declare const SAB_OP_RM = 5;
+export declare const SAB_OP_RMDIR = 6;
+export declare const SAB_OP_COPY_FILE = 7;
+export declare const SAB_OP_STAT = 8;
+export declare const STAT_TYPE_FILE = 0;
+export declare const STAT_TYPE_DIR = 1;
+export declare const SAB_INDEX_STATE = 0;
+export declare const SAB_INDEX_OP = 1;
+export declare const SAB_INDEX_DATA_LEN = 2;
+export declare const SAB_DATA_OFFSET = 12;
+export declare class SabComHost {
+    private sab;
+    private int32;
+    private uint8;
+    private dataView;
+    constructor(sab: SharedArrayBuffer);
+    readRequest(): {
+        op: number;
+        data: string;
+    };
+    writeResponse(data: Uint8Array | string): void;
+    writeError(message: string): void;
+    writeStat(type: number, size: bigint, atimeMs: number, mtimeMs: number, ctimeMs: number, birthtimeMs: number): void;
+}
+export declare class SabComClient {
+    private sab;
+    private notifyHost;
+    private int32;
+    private uint8;
+    private dataView;
+    constructor(sab: SharedArrayBuffer, notifyHost: () => void);
+    call(op: number, data: string): Uint8Array<ArrayBuffer>;
+    callStat(path: string): {
+        type: number;
+        size: bigint;
+        atimeMs: number;
+        mtimeMs: number;
+        ctimeMs: number;
+        birthtimeMs: number;
+    };
+}
+export interface SabFileSystem {
+    read(path: string): Promise<Uint8Array>;
+    readDir(path: string): Promise<any[]>;
+    writeString(path: string, content: string): Promise<void>;
+    createDirAll(path: string): Promise<void>;
+    createDir(path: string): Promise<void>;
+    metadata(path: string): Promise<any>;
+    removeFile(path: string): Promise<void>;
+    removeDir(path: string, recursive: boolean): Promise<void>;
+    copyFile(src: string, dst: string): Promise<void>;
+}
+export declare const handleSabRequest: (sabHost: SabComHost, fs: SabFileSystem) => Promise<void>;