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

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,54 @@ 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, serviceWorkerOptions } = options;
+        this.serviceWorkerOptions = serviceWorkerOptions;
         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 { serviceWorkerUrl, proxiedResourcePath } = this.serviceWorkerOptions;
+            await navigator.serviceWorker.register(serviceWorkerUrl);
+            (_a = navigator.serviceWorker.controller) === null || _a === void 0 ? void 0 : _a.postMessage({
+                [ServiceWorkerHandShake]: true,
+                proxiedResourcePath,
+            });
+        }
     }
     async install(packageLock) {
         await __classPrivateFieldGet(this, _Project_tunnel, "f");
@@ -65,9 +89,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,57 @@
+import { Project } from ".";
+import { ServiceWorkerHandShake } from "./message";
+let __resolve__;
+let _promise__ = new Promise((resolve) => {
+    __resolve__ = resolve;
+});
+let projectEndpoint;
+let proxiedResourcePath;
+self.addEventListener("message", (event) => {
+    if (event.data && event.data[ServiceWorkerHandShake] === true) {
+        proxiedResourcePath = event.data.proxiedResourcePath;
+        projectEndpoint = Project.fork(new MessageChannel(), event.source);
+        __resolve__();
+    }
+});
+self.addEventListener("fetch", async (event) => {
+    const { url, referrer } = event.request;
+    if (new URL(url).pathname.startsWith(`/${proxiedResourcePath}`) ||
+        (referrer &&
+            new URL(referrer).pathname.startsWith(`/${proxiedResourcePath}`))) {
+        await _promise__;
+        const projectPath = "." + new URL(url).pathname.replace(`/${proxiedResourcePath}`, "");
+        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/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;
+    serviceWorkerOptions?: ServiceWorkerOptions;
+}
+export interface ServiceWorkerOptions {
+    serviceWorkerUrl: string;
+    proxiedResourcePath: string;
 }

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.14",
   "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": {