@utoo/web 0.0.1-alpha.13 → 0.0.1-alpha.15

package/esm/index.d.ts

@@ -1,10 +1,11 @@
-import { Dirent, MountOpt, ProjectEndpoint } from "./type";
+import { Dirent, ProjectEndpoint, ProjectOptions } from "./type";
 export declare class Project implements ProjectEndpoint {
     #private;
+    private serviceWorkerOptions?;
     private remote;
-    constructor(opt: MountOpt & {
-        entryUrl?: string;
-    });
+    constructor(options: ProjectOptions);
+    private connectWorker;
+    installServiceWorker(): Promise<void>;
     install(packageLock: string): Promise<void>;
     build(): Promise<void>;
     readFile(path: string, encoding?: "utf8"): Promise<any>;
@@ -16,6 +17,6 @@ export declare class Project implements ProjectEndpoint {
     mkdir(path: string, options?: {
         recursive?: boolean;
     }): Promise<void>;
-    static fork(channel: MessageChannel): ProjectEndpoint;
+    static fork(channel: MessageChannel, eventSource: Client | DedicatedWorkerGlobalScope): ProjectEndpoint;
 }
 export * from "./type";

package/esm/index.js

@@ -11,30 +11,55 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
 };
 var _Project_tunnel;
 import * as comlink from "comlink";
-import { Fork, HandShake } from "./message";
-import { Dirent } from "./type";
+import { Fork, HandShake, ServiceWorkerHandShake } from "./message";
+import { Dirent, } from "./type";
 let ProjectWorker;
 const ConnectedPorts = new Set();
 export class Project {
-    constructor(opt) {
+    constructor(options) {
         var _a, _b;
         _Project_tunnel.set(this, void 0);
-        const { cwd, entryUrl, wasmUrl, threadUrl } = opt;
+        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 = entryUrl
-                ? new Worker(entryUrl)
+            ProjectWorker = workerUrl
+                ? new Worker(workerUrl)
                 : 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]);
-                }
+            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_tunnel, (_b = __classPrivateFieldGet(this, _Project_tunnel, "f")) !== null && _b !== void 0 ? _b : this.remote.mount({ cwd, wasmUrl, threadUrl }), "f");
+        __classPrivateFieldSet(this, _Project_tunnel, (_b = __classPrivateFieldGet(this, _Project_tunnel, "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() {
+        var _a;
+        if (this.serviceWorkerOptions) {
+            const { url, scope } = this.serviceWorkerOptions;
+            // Should add "Service-Worker-Allowed": "/" in page root response,
+            await navigator.serviceWorker.register(url, { scope: "/" });
+            (_a = navigator.serviceWorker.controller) === null || _a === void 0 ? void 0 : _a.postMessage({
+                [ServiceWorkerHandShake]: true,
+                scope,
+            });
+        }
     }
     async install(packageLock) {
         await __classPrivateFieldGet(this, _Project_tunnel, "f");
@@ -65,9 +90,8 @@ export class Project {
         await __classPrivateFieldGet(this, _Project_tunnel, "f");
         return await this.remote.mkdir(path, options);
     }
-    static fork(channel) {
-        self.postMessage(Fork, {
-            targetOrigin: "*",
+    static fork(channel, eventSource) {
+        eventSource.postMessage(Fork, {
             transfer: [channel.port2],
         });
         return new ForkedProject(channel.port1);

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/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) => {
+    const { url, referrer } = event.request;
+    if (new URL(url).pathname.startsWith(_serviceWorkerScope) ||
+        (referrer && new URL(referrer).pathname.startsWith(_serviceWorkerScope))) {
+        await _promise;
+        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

@@ -24,8 +24,14 @@ export interface ProjectEndpoint {
     }): Promise<void>;
     copyFile(src: string, dst: string): Promise<void>;
 }
-export interface MountOpt {
+export interface ProjectOptions {
     cwd: string;
-    threadUrl: string;
+    workerUrl?: string;
+    threadWorkerUrl: string;
     wasmUrl?: string;
+    serviceWorker?: ServiceWorkerOptions;
+}
+export interface ServiceWorkerOptions {
+    url: string;
+    scope: string;
 }

package/esm/utoo/index.js

@@ -1150,27 +1150,27 @@ function __wbg_get_imports() {
         const ret = false;
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper163125 = function (arg0, arg1, arg2) {
+    imports.wbg.__wbindgen_closure_wrapper163109 = function (arg0, arg1, arg2) {
         const ret = makeMutClosure(arg0, arg1, 9521, __wbg_adapter_49);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper163127 = function (arg0, arg1, arg2) {
+    imports.wbg.__wbindgen_closure_wrapper163111 = function (arg0, arg1, arg2) {
         const ret = makeMutClosure(arg0, arg1, 1976, __wbg_adapter_49);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper168916 = function (arg0, arg1, arg2) {
+    imports.wbg.__wbindgen_closure_wrapper168917 = function (arg0, arg1, arg2) {
         const ret = makeMutClosure(arg0, arg1, 9521, __wbg_adapter_49);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper168970 = function (arg0, arg1, arg2) {
+    imports.wbg.__wbindgen_closure_wrapper168971 = function (arg0, arg1, arg2) {
         const ret = makeMutClosure(arg0, arg1, 9524, __wbg_adapter_56);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper168993 = function (arg0, arg1, arg2) {
+    imports.wbg.__wbindgen_closure_wrapper168994 = function (arg0, arg1, arg2) {
         const ret = makeMutClosure(arg0, arg1, 9528, __wbg_adapter_46);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper30076 = function (arg0, arg1, arg2) {
+    imports.wbg.__wbindgen_closure_wrapper30059 = function (arg0, arg1, arg2) {
         const ret = makeMutClosure(arg0, arg1, 1976, __wbg_adapter_46);
         return addHeapObject(ret);
     };

package/esm/worker.js

@@ -7,10 +7,10 @@ const projectEndpoint = {
     // This should be called only once
     async mount(opt) {
         var _a;
-        const { cwd, wasmUrl, threadUrl } = opt;
+        const { cwd, wasmUrl, threadWorkerUrl } = opt;
         (_a = this.wasmInit) !== null && _a !== void 0 ? _a : (this.wasmInit = initWasm(wasmUrl));
         await this.wasmInit;
-        this.projectInternal = new ProjectInternal(cwd, threadUrl);
+        this.projectInternal = new ProjectInternal(cwd, threadWorkerUrl);
         return;
     },
     async install(packageLock) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@utoo/web",
-  "version": "0.0.1-alpha.13",
+  "version": "0.0.1-alpha.15",
   "module": "esm/index.js",
   "types": "esm/index.d.ts",
   "files": [
@@ -12,11 +12,11 @@
     "build-wasm:pm": "cargo build -p utoo-wasm --target wasm32-unknown-unknown --no-default-features -Z build-std=panic_abort,std",
     "bindgen-dev": "wasm-bindgen ../../target/wasm32-unknown-unknown/wasm-dev/utoo_wasm.wasm --out-dir src/utoo --out-name index --target web --debug --keep-debug --no-demangle",
     "bindgen-build": "wasm-bindgen ../../target/wasm32-unknown-unknown/release/utoo_wasm.wasm --out-dir src/utoo --out-name index --target web",
-    "tsx": "rm -rf esm && tsc -p ./tsconfig.json",
-    "dev": "npm run build-wasm -- --profile wasm-dev && npm run bindgen-dev && npm run tsx && cp src/utoo/index_bg.wasm esm/utoo",
-    "dev:pm": "npm run build-wasm:pm -- --profile wasm-dev && npm run bindgen-dev && npm run tsx && cp src/utoo/index_bg.wasm esm/utoo",
+    "tsc": "rm -rf esm && tsc -p ./tsconfig.json",
+    "dev": "npm run build-wasm -- --profile wasm-dev && npm run bindgen-dev && npm run tsc && cp src/utoo/index_bg.wasm esm/utoo",
+    "dev:pm": "npm run build-wasm:pm -- --profile wasm-dev && npm run bindgen-dev && npm run tsc && cp src/utoo/index_bg.wasm esm/utoo",
     "wasm-opt": "wasm-opt src/utoo/index_bg.wasm -o esm/utoo/index_bg.wasm --enable-threads --enable-bulk-memory --enable-nontrapping-float-to-int -Oz",
-    "build": "npm run build-wasm -- --release && npm run bindgen-build && npm run tsx && npm run wasm-opt",
+    "build": "npm run build-wasm -- --release && npm run bindgen-build && npm run tsc && npm run wasm-opt",
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
@@ -30,5 +30,5 @@
   },
   "author": "xusd320",
   "license": "MIT",
-  "repository": "git@github.com:umijs/mako.git"
+  "repository": "git@github.com:utooland/utoo.git"
 }

package/esm/thread_worker.js

@@ -1,2 +0,0 @@
-import initWasm from "./utoo";
-self.wasm_bindgen = initWasm;