@utoo/web 0.0.1-alpha.3 → 0.0.1-alpha.31

package/esm/forkedProject.d.ts

@@ -0,0 +1,22 @@
+import { ProjectEndpoint } from "./type";
+export declare class ForkedProject implements ProjectEndpoint {
+    private endpoint;
+    constructor(port: MessagePort);
+    install(packageLock: string): Promise<void>;
+    build(): Promise<import("./type").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[]>;
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    rm(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    rmdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+}

package/esm/forkedProject.js

@@ -0,0 +1,34 @@
+import * as comlink from "comlink";
+export class ForkedProject {
+    constructor(port) {
+        var _a;
+        (_a = this.endpoint) !== null && _a !== void 0 ? _a : (this.endpoint = comlink.wrap(port));
+    }
+    async install(packageLock) {
+        return await this.endpoint.install(packageLock);
+    }
+    async build() {
+        return await this.endpoint.build();
+    }
+    async readFile(path, encoding) {
+        return (await this.endpoint.readFile(path, encoding));
+    }
+    async writeFile(path, content, encoding) {
+        return await this.endpoint.writeFile(path, content, encoding);
+    }
+    async copyFile(src, dst) {
+        return await this.endpoint.copyFile(src, dst);
+    }
+    async readdir(path, options) {
+        return await this.endpoint.readdir(path, options);
+    }
+    async mkdir(path, options) {
+        return await this.endpoint.mkdir(path, options);
+    }
+    async rm(path, options) {
+        return await this.endpoint.rm(path, options);
+    }
+    async rmdir(path, options) {
+        return await this.endpoint.rmdir(path, options);
+    }
+}

package/esm/index.d.ts

@@ -1,17 +1,2 @@
-import { ProjectEndpoint, DirEntry } from "./type";
-export declare class Project implements ProjectEndpoint {
-    #private;
-    private cwd;
-    private remote;
-    constructor(cwd: string);
-    install(packageLock: string): Promise<void>;
-    build(): Promise<void>;
-    readFile(path: string): Promise<string>;
-    writeFile(path: string, content: string): Promise<void>;
-    copyFile(src: string, dst: string): Promise<void>;
-    readDir(path: string): Promise<DirEntry[]>;
-    createDir(path: string): Promise<void>;
-    createDirAll(path: string): Promise<void>;
-    static fork(port1: MessagePort, port2: MessagePort): ProjectEndpoint;
-}
+export { Project } from "./project";
 export * from "./type";

package/esm/index.js

@@ -1,105 +1,2 @@
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var _Project_tunnel;
-import * as comlink from "comlink";
-import { Fork, HandShake } from "./message";
-let ProjectWorker;
-const ConnectedPorts = new Set();
-export class Project {
-    constructor(cwd) {
-        var _a, _b;
-        _Project_tunnel.set(this, void 0);
-        this.cwd = cwd;
-        const { port1, port2 } = new MessageChannel();
-        (_a = this.remote) !== null && _a !== void 0 ? _a : (this.remote = comlink.wrap(port1));
-        if (!ProjectWorker) {
-            ProjectWorker = new Worker(new URL("./worker", import.meta.url));
-            self.addEventListener("message", (e) => {
-                const port = e.ports[0];
-                if (e.data === Fork && !ConnectedPorts.has(port)) {
-                    ProjectWorker.postMessage(HandShake, [port]);
-                }
-            });
-        }
-        ProjectWorker.postMessage(HandShake, [port2]);
-        __classPrivateFieldSet(this, _Project_tunnel, (_b = __classPrivateFieldGet(this, _Project_tunnel, "f")) !== null && _b !== void 0 ? _b : this.remote.mount(this.cwd), "f");
-    }
-    async install(packageLock) {
-        await __classPrivateFieldGet(this, _Project_tunnel, "f");
-        return await this.remote.install(packageLock);
-    }
-    async build() {
-        await __classPrivateFieldGet(this, _Project_tunnel, "f");
-        return await this.remote.build();
-    }
-    async readFile(path) {
-        await __classPrivateFieldGet(this, _Project_tunnel, "f");
-        return await this.remote.readFile(path);
-    }
-    async writeFile(path, content) {
-        await __classPrivateFieldGet(this, _Project_tunnel, "f");
-        return await this.remote.writeFile(path, content);
-    }
-    async copyFile(src, dst) {
-        await __classPrivateFieldGet(this, _Project_tunnel, "f");
-        return await this.remote.copyFile(src, dst);
-    }
-    async readDir(path) {
-        await __classPrivateFieldGet(this, _Project_tunnel, "f");
-        return await this.remote.readDir(path);
-    }
-    async createDir(path) {
-        await __classPrivateFieldGet(this, _Project_tunnel, "f");
-        return await this.remote.createDir(path);
-    }
-    async createDirAll(path) {
-        await __classPrivateFieldGet(this, _Project_tunnel, "f");
-        return await this.remote.createDirAll(path);
-    }
-    // This should be called from different worker
-    static fork(port1, port2) {
-        self.postMessage(Fork, [port2]);
-        return new ForkedProject(port1);
-    }
-}
-_Project_tunnel = new WeakMap();
-class ForkedProject {
-    constructor(port) {
-        var _a;
-        (_a = this.endpoint) !== null && _a !== void 0 ? _a : (this.endpoint = comlink.wrap(port));
-    }
-    async install(packageLock) {
-        return await this.endpoint.install(packageLock);
-    }
-    async build() {
-        return await this.endpoint.build();
-    }
-    async readFile(path) {
-        return await this.endpoint.readFile(path);
-    }
-    async writeFile(path, content) {
-        return await this.endpoint.writeFile(path, content);
-    }
-    async copyFile(src, dst) {
-        return await this.endpoint.copyFile(src, dst);
-    }
-    async readDir(path) {
-        return await this.endpoint.readDir(path);
-    }
-    async createDir(path) {
-        return await this.endpoint.createDir(path);
-    }
-    async createDirAll(path) {
-        return await this.endpoint.createDirAll(path);
-    }
-}
+export { Project } from "./project";
 export * from "./type";

package/esm/installServiceWorker.d.ts

@@ -0,0 +1 @@
+export declare function installServiceWorker(url: string, scope: string): Promise<void>;

package/esm/installServiceWorker.js

@@ -0,0 +1,36 @@
+import { ServiceWorkerHandShake } from "./message";
+export async function installServiceWorker(url, scope) {
+    const registration = await navigator.serviceWorker.register(url, {
+        scope: "/",
+    });
+    return new Promise((resolve) => {
+        function sendMessage(sw) {
+            sw.postMessage({
+                [ServiceWorkerHandShake]: true,
+                scope,
+            });
+            resolve();
+        }
+        function listenForActivation(sw) {
+            sw.addEventListener("statechange", () => {
+                if (sw.state === "activated") {
+                    sendMessage(sw);
+                }
+            });
+        }
+        function checkSWState(registration) {
+            if (registration.active) {
+                sendMessage(registration.active);
+            }
+            else if (registration.installing) {
+                listenForActivation(registration.installing);
+            }
+            registration.addEventListener("updatefound", () => {
+                if (registration.installing) {
+                    listenForActivation(registration.installing);
+                }
+            });
+        }
+        checkSWState(registration);
+    });
+}

package/esm/message.d.ts

@@ -1,2 +1,3 @@
 export declare const HandShake = "__handshake__";
+export declare const ServiceWorkerHandShake = "__service_worker_handshake__";
 export declare const Fork = "__fork__";

package/esm/message.js

@@ -1,2 +1,3 @@
 export const HandShake = "__handshake__";
+export const ServiceWorkerHandShake = "__service_worker_handshake__";
 export const Fork = "__fork__";

package/esm/project.d.ts

@@ -0,0 +1,28 @@
+import { BuildOutput, Dirent, ProjectEndpoint, ProjectOptions } from "./type";
+export declare class Project implements ProjectEndpoint {
+    #private;
+    private serviceWorkerOptions?;
+    private remote;
+    constructor(options: ProjectOptions);
+    private connectWorker;
+    installServiceWorker(): Promise<void>;
+    mount(): Promise<void>;
+    install(packageLock: string): Promise<void>;
+    build(): Promise<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<Dirent[]>;
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    rm(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    rmdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    static fork(channel: MessageChannel, eventSource?: Client | DedicatedWorkerGlobalScope): ProjectEndpoint;
+}

package/esm/project.js

@@ -0,0 +1,111 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+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";
+let ProjectWorker;
+const ConnectedPorts = new Set();
+export class Project {
+    constructor(options) {
+        var _a, _b;
+        _Project_mount.set(this, void 0);
+        const { cwd, workerUrl, wasmUrl, threadWorkerUrl, serviceWorker } = options;
+        this.serviceWorkerOptions = serviceWorker;
+        const { port1, port2 } = new MessageChannel();
+        (_a = this.remote) !== null && _a !== void 0 ? _a : (this.remote = comlink.wrap(port1));
+        if (!ProjectWorker) {
+            ProjectWorker = workerUrl
+                ? new Worker(workerUrl)
+                : new Worker(new URL("./worker", import.meta.url));
+            window.addEventListener("message", (e) => {
+                this.connectWorker(e);
+            });
+            if (this.serviceWorkerOptions) {
+                navigator.serviceWorker.addEventListener("message", (e) => {
+                    this.connectWorker(e);
+                });
+            }
+        }
+        ProjectWorker.postMessage(HandShake, [port2]);
+        __classPrivateFieldSet(this, _Project_mount, (_b = __classPrivateFieldGet(this, _Project_mount, "f")) !== null && _b !== void 0 ? _b : this.remote.mount({
+            cwd,
+            wasmUrl,
+            threadWorkerUrl,
+        }), "f");
+    }
+    connectWorker(e) {
+        const port = e.ports[0];
+        if (e.data === Fork && !ConnectedPorts.has(port)) {
+            ProjectWorker.postMessage(HandShake, [port]);
+        }
+    }
+    async installServiceWorker() {
+        if (this.serviceWorkerOptions) {
+            const { url, scope } = this.serviceWorkerOptions;
+            // Should add "Service-Worker-Allowed": "/" in page root response headers,
+            return await installServiceWorker(url, scope);
+        }
+    }
+    async mount() {
+        return await __classPrivateFieldGet(this, _Project_mount, "f");
+    }
+    async install(packageLock) {
+        await __classPrivateFieldGet(this, _Project_mount, "f");
+        return await this.remote.install(packageLock);
+    }
+    async build() {
+        await __classPrivateFieldGet(this, _Project_mount, "f");
+        const res = await this.remote.build();
+        handleIssues(res.issues, false, false);
+        return res;
+    }
+    async readFile(path, encoding) {
+        await __classPrivateFieldGet(this, _Project_mount, "f");
+        return (await this.remote.readFile(path, encoding));
+    }
+    async writeFile(path, content, encoding) {
+        await __classPrivateFieldGet(this, _Project_mount, "f");
+        return await this.remote.writeFile(path, content, encoding);
+    }
+    async copyFile(src, dst) {
+        await __classPrivateFieldGet(this, _Project_mount, "f");
+        return await this.remote.copyFile(src, dst);
+    }
+    async readdir(path, options) {
+        await __classPrivateFieldGet(this, _Project_mount, "f");
+        const dirEntry = (await this.remote.readdir(path, options));
+        return dirEntry.map((e) => new Dirent(e));
+    }
+    async mkdir(path, options) {
+        await __classPrivateFieldGet(this, _Project_mount, "f");
+        return await this.remote.mkdir(path, options);
+    }
+    async rm(path, options) {
+        await __classPrivateFieldGet(this, _Project_mount, "f");
+        return await this.remote.rm(path, options);
+    }
+    async rmdir(path, options) {
+        await __classPrivateFieldGet(this, _Project_mount, "f");
+        return await this.remote.rmdir(path, options);
+    }
+    static fork(channel, eventSource) {
+        (eventSource || self).postMessage(Fork, {
+            transfer: [channel.port2],
+        });
+        return new ForkedProject(channel.port1);
+    }
+}
+_Project_mount = new WeakMap();

package/esm/serviceWorker.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/serviceWorker.js

@@ -0,0 +1,56 @@
+import { Project } from ".";
+import { ServiceWorkerHandShake } from "./message";
+let _resolve;
+let _promise = new Promise((resolve) => {
+    _resolve = resolve;
+});
+let _projectEndpoint;
+let _serviceWorkerScope;
+self.addEventListener("message", (event) => {
+    if (event.data && event.data[ServiceWorkerHandShake] === true) {
+        _serviceWorkerScope = event.data.scope;
+        _projectEndpoint = Project.fork(new MessageChannel(), event.source);
+        _resolve();
+    }
+});
+self.addEventListener("fetch", async (event) => {
+    await _promise;
+    const { url, referrer } = event.request;
+    if (new URL(url).pathname.startsWith(_serviceWorkerScope) ||
+        (referrer && new URL(referrer).pathname.startsWith(_serviceWorkerScope))) {
+        const projectPath = "." + new URL(url).pathname.replace(_serviceWorkerScope, "");
+        event.respondWith(readFileFromProject(projectPath));
+    }
+    else {
+        event.respondWith(fetch(event.request));
+    }
+});
+async function readFileFromProject(projectPath) {
+    try {
+        const content = await _projectEndpoint.readFile(projectPath);
+        let mimeType = "application/octet-stream";
+        if (projectPath.endsWith(".js")) {
+            mimeType = "application/javascript";
+        }
+        else if (projectPath.endsWith(".css")) {
+            mimeType = "text/css";
+        }
+        else if (projectPath.endsWith(".html")) {
+            mimeType = "text/html";
+        }
+        else if (projectPath.endsWith(".json")) {
+            mimeType = "application/json";
+        }
+        return new Response(content, {
+            headers: {
+                "Content-Type": mimeType,
+                ...(mimeType === "text/html"
+                    ? { "Cross-Origin-Embedder-Policy": "require-corp" }
+                    : {}),
+            },
+        });
+    }
+    catch (e) {
+        return new Response("Not Found", { status: 404 });
+    }
+}

package/esm/threadWorker.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/threadWorker.js

@@ -0,0 +1,4 @@
+import initWasm from "./utoo";
+// this is for wasm_thread to spawn new worker thread.
+// see: https://github.com/utooland/wasm_thread/blob/94438ff771ee0a6a55d79e49a655707970acb615/src/wasm32/js/web_worker.js#L10
+self.wasm_bindgen = initWasm;

package/esm/type.d.ts

@@ -1,15 +1,47 @@
-import type { DirEntryType } from "./utoo";
-export interface DirEntry {
+import { Issue } from "@utoo/pack-shared";
+import { DirEntryType } from "./utoo";
+export interface RawDirent {
     name: string;
     type: DirEntryType;
 }
+export declare class Dirent {
+    private rawDirent;
+    name: string;
+    constructor(rawDirent: RawDirent);
+    isDirectory(): boolean;
+    isFile(): boolean;
+}
+export interface BuildOutput {
+    issues: Issue[];
+}
 export interface ProjectEndpoint {
     install: (packageLock: string) => Promise<void>;
-    build: () => Promise<void>;
-    readFile(path: string): Promise<string>;
-    writeFile(path: string, content: string): Promise<void>;
-    readDir(path: string): Promise<DirEntry[]>;
-    createDir(path: string): Promise<void>;
-    createDirAll(path: string): Promise<void>;
+    build: () => Promise<BuildOutput>;
+    readFile(path: string): Promise<Uint8Array>;
+    readFile(path: string, encoding?: "utf8"): Promise<string>;
+    writeFile(path: string, content: string | Uint8Array, encoding?: "utf8"): Promise<void>;
+    readdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<Dirent[]>;
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    rm(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    rmdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
     copyFile(src: string, dst: string): Promise<void>;
 }
+export interface ProjectOptions {
+    cwd: string;
+    workerUrl?: string;
+    threadWorkerUrl: string;
+    wasmUrl?: string;
+    serviceWorker?: ServiceWorkerOptions;
+}
+export interface ServiceWorkerOptions {
+    url: string;
+    scope: string;
+}

package/esm/type.js

@@ -1 +1,12 @@
-export {};
+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/utoo/index.d.ts

@@ -1,18 +1,15 @@
+export function init_pack(): void;
 /**
- * @param {PartialProjectOptions} partial_options
- * @returns {Promise<void>}
+ * Entry point for web workers
+ * @param {number} ptr
  */
-export function build(partial_options: PartialProjectOptions): Promise<void>;
-export function init_pack(): void;
+export function wasm_thread_entry_point(ptr: number): void;
 export class CreateSyncAccessHandleOptions {
     static __wrap(ptr: any): any;
     __destroy_into_raw(): number | undefined;
     __wbg_ptr: number | undefined;
     free(): void;
 }
-/**
- * Directory entry with name and type information
- */
 export class DirEntry {
     static __wrap(ptr: any): any;
     toJSON(): {
@@ -40,74 +37,89 @@ export class DirEntry {
      */
     get type(): DirEntryType;
 }
-export class PartialProjectOptions {
+export class Metadata {
+    static __wrap(ptr: any): any;
+    toJSON(): {};
+    toString(): string;
     __destroy_into_raw(): number | undefined;
     __wbg_ptr: number | undefined;
     free(): void;
-    /**
-     * @param {string} arg0
-     */
-    set project_path(arg0: string);
-    /**
-     * @returns {string}
-     */
-    get project_path(): string;
-    /**
-     * @param {string | null} [arg0]
-     */
-    set config(arg0: string | null);
-    /**
-     * @returns {string | undefined}
-     */
-    get config(): string | undefined;
 }
 export class Project {
     /**
      * @param {string} cwd
+     * @param {string} thread_url
      */
-    constructor(cwd: string);
+    constructor(cwd: string, thread_url: string);
     __destroy_into_raw(): number;
     __wbg_ptr: number;
     free(): void;
     /**
-     * @returns {string}
+     * @param {string} path
+     * @returns {Promise<void>}
      */
-    get cwd(): string;
+    createDir(path: string): Promise<void>;
     /**
-     * @param {string} package_lock
+     * @param {string} path
+     * @param {boolean} recursive
      * @returns {Promise<void>}
      */
-    install(package_lock: string): Promise<void>;
+    removeDir(path: string, recursive: boolean): Promise<void>;
     /**
+     * @param {string} path
      * @returns {Promise<void>}
      */
-    build(): Promise<void>;
+    removeFile(path: string): Promise<void>;
     /**
      * @param {string} path
-     * @returns {Promise<string>}
+     * @param {string} content
+     * @returns {Promise<void>}
      */
-    readFile(path: string): Promise<string>;
+    writeString(path: string, content: string): Promise<void>;
     /**
      * @param {string} path
-     * @param {string} content
      * @returns {Promise<void>}
      */
-    writeFile(path: string, content: string): Promise<void>;
+    createDirAll(path: string): Promise<void>;
     /**
      * @param {string} path
-     * @returns {Promise<DirEntry[]>}
+     * @returns {Promise<string>}
      */
-    readDir(path: string): Promise<DirEntry[]>;
+    readToString(path: string): Promise<string>;
+    /**
+     * @returns {string}
+     */
+    get cwd(): string;
     /**
      * @param {string} path
-     * @returns {Promise<void>}
+     * @returns {Promise<Uint8Array>}
      */
-    createDir(path: string): Promise<void>;
+    read(path: string): Promise<Uint8Array>;
+    /**
+     * @returns {Promise<any>}
+     */
+    build(): Promise<any>;
     /**
      * @param {string} path
+     * @param {Uint8Array} content
      * @returns {Promise<void>}
      */
-    createDirAll(path: string): Promise<void>;
+    write(path: string, content: Uint8Array): Promise<void>;
+    /**
+     * @param {string} package_lock
+     * @returns {Promise<void>}
+     */
+    install(package_lock: string): Promise<void>;
+    /**
+     * @param {string} path
+     * @returns {Promise<Metadata>}
+     */
+    metadata(path: string): Promise<Metadata>;
+    /**
+     * @param {string} path
+     * @returns {Promise<DirEntry[]>}
+     */
+    readDir(path: string): Promise<DirEntry[]>;
     /**
      * @param {string} src
      * @param {string} dst
@@ -116,5 +128,5 @@ export class Project {
     copyFile(src: string, dst: string): Promise<void>;
 }
 export default __wbg_init;
-export function initSync(module: any): any;
-declare function __wbg_init(module_or_path: any): Promise<any>;
+export function initSync(module: any, memory: any): any;
+declare function __wbg_init(module_or_path: any, memory: any): Promise<any>;