@utoo/web 1.2.6 → 1.2.8

package/esm/message.d.ts

@@ -0,0 +1,19 @@
+export declare enum WorkerMessageType {
+    InitConnection = 1464664064,// "WM" in hex
+    RequestFork = 1464664065
+}
+/** @deprecated use WorkerMessageType.InitConnection */
+export declare const HandShake = WorkerMessageType.InitConnection;
+/** @deprecated use WorkerMessageType.RequestFork */
+export declare const Fork = WorkerMessageType.RequestFork;
+export declare enum SWMessageType {
+    HandShake = 1398210560,// "SW" in hex
+    HeartbeatPing = 1398210561,
+    HeartbeatPong = 1398210562
+}
+/** @deprecated use SWMessageType */
+export declare const ServiceWorkerHandShake = SWMessageType.HandShake;
+/** @deprecated use SWMessageType */
+export declare const ServiceWorkerHeartbeatPing = SWMessageType.HeartbeatPing;
+/** @deprecated use SWMessageType */
+export declare const ServiceWorkerHeartbeatPong = SWMessageType.HeartbeatPong;

package/esm/message.js

@@ -0,0 +1,21 @@
+export var WorkerMessageType;
+(function (WorkerMessageType) {
+    WorkerMessageType[WorkerMessageType["InitConnection"] = 1464664064] = "InitConnection";
+    WorkerMessageType[WorkerMessageType["RequestFork"] = 1464664065] = "RequestFork";
+})(WorkerMessageType || (WorkerMessageType = {}));
+/** @deprecated use WorkerMessageType.InitConnection */
+export const HandShake = WorkerMessageType.InitConnection;
+/** @deprecated use WorkerMessageType.RequestFork */
+export const Fork = WorkerMessageType.RequestFork;
+export var SWMessageType;
+(function (SWMessageType) {
+    SWMessageType[SWMessageType["HandShake"] = 1398210560] = "HandShake";
+    SWMessageType[SWMessageType["HeartbeatPing"] = 1398210561] = "HeartbeatPing";
+    SWMessageType[SWMessageType["HeartbeatPong"] = 1398210562] = "HeartbeatPong";
+})(SWMessageType || (SWMessageType = {}));
+/** @deprecated use SWMessageType */
+export const ServiceWorkerHandShake = SWMessageType.HandShake;
+/** @deprecated use SWMessageType */
+export const ServiceWorkerHeartbeatPing = SWMessageType.HeartbeatPing;
+/** @deprecated use SWMessageType */
+export const ServiceWorkerHeartbeatPong = SWMessageType.HeartbeatPong;

package/esm/project/InternalProject.js

@@ -1,4 +1,4 @@
-import initWasm, { initLogFilter, Project as ProjectInternal, } from "../utoo";
+import initWasm, { Fs, initLogFilter, Project as ProjectInternal, } from "../utoo";
 import { runLoaderWorkerPool } from "../webpackLoaders/loaderWorkerPool";
 class InternalEndpoint {
     constructor() {
@@ -26,16 +26,15 @@ class InternalEndpoint {
         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, options) {
-        var _a;
         await this.wasmInit;
-        await ProjectInternal.install(packageLock, options === null || options === void 0 ? void 0 : options.maxConcurrentDownloads, (_a = options === null || options === void 0 ? void 0 : options.omit) !== null && _a !== void 0 ? _a : []);
+        await ProjectInternal.install(packageLock, options === null || options === void 0 ? void 0 : options.maxConcurrentDownloads);
         return;
     }
     async build() {
         var _a, _b;
-        const binding = await this.wasmInit;
+        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);
+            runLoaderWorkerPool(this.options.cwd, this.options.loaderWorkerUrl, (_b = this.options) === null || _b === void 0 ? void 0 : _b.loadersImportMap);
             this.loaderWorkerPoolInitialized = true;
         }
         return await ProjectInternal.build();
@@ -44,29 +43,29 @@ class InternalEndpoint {
         await this.wasmInit;
         let ret;
         if (encoding === "utf8") {
-            ret = await ProjectInternal.readToString(path);
+            ret = await Fs.readToString(path);
         }
         else {
-            return await ProjectInternal.read(path);
+            return await Fs.read(path);
         }
         return ret;
     }
     async writeFile(path, content, _encoding) {
         await this.wasmInit;
         if (typeof content === "string") {
-            return await ProjectInternal.writeString(path, content);
+            return await Fs.writeString(path, content);
         }
         else {
-            return await ProjectInternal.write(path, content);
+            return await Fs.write(path, content);
         }
     }
     async copyFile(src, dst) {
         await this.wasmInit;
-        return await ProjectInternal.copyFile(src, dst);
+        return await Fs.copyFile(src, dst);
     }
     async stat(path) {
         await this.wasmInit;
-        const metadata = await ProjectInternal.metadata(path);
+        const metadata = await Fs.metadata(path);
         const json = metadata.toJSON();
         const raw = {
             type: json.type,
@@ -78,9 +77,9 @@ class InternalEndpoint {
     async readdir(path, options) {
         await this.wasmInit;
         const dirEntries = (options === null || options === void 0 ? void 0 : options.recursive)
-            ? await ProjectInternal.readDir(path)
+            ? await Fs.readDir(path)
             : // TODO: support recursive readDirAll
-                await ProjectInternal.readDir(path);
+                await Fs.readDir(path);
         const rawDirents = dirEntries.map((e) => {
             const dir = e.toJSON();
             return {
@@ -94,20 +93,20 @@ class InternalEndpoint {
     async mkdir(path, options) {
         await this.wasmInit;
         if (options === null || options === void 0 ? void 0 : options.recursive) {
-            return await ProjectInternal.createDirAll(path);
+            return await Fs.createDirAll(path);
         }
         else {
-            return await ProjectInternal.createDir(path);
+            return await Fs.createDir(path);
         }
     }
     async rm(path, options) {
         await this.wasmInit;
-        let metadata = (await ProjectInternal.metadata(path)).toJSON();
+        let metadata = (await Fs.metadata(path)).toJSON();
         switch (metadata.type) {
             case "file":
-                return await ProjectInternal.removeFile(path);
+                return await Fs.removeFile(path);
             case "directory":
-                return await ProjectInternal.removeDir(path, !!(options === null || options === void 0 ? void 0 : options.recursive));
+                return await Fs.removeDir(path, !!(options === null || options === void 0 ? void 0 : options.recursive));
             default:
                 // nothing to remove now
                 break;
@@ -115,7 +114,7 @@ class InternalEndpoint {
     }
     async rmdir(path, options) {
         await this.wasmInit;
-        return await ProjectInternal.removeDir(path, !!(options === null || options === void 0 ? void 0 : options.recursive));
+        return await Fs.removeDir(path, !!(options === null || options === void 0 ? void 0 : options.recursive));
     }
     async gzip(files) {
         await this.wasmInit;

package/esm/project/Project.js

@@ -12,9 +12,9 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
 var _Project_mount;
 import { handleIssues } from "@utoo/pack-shared";
 import * as comlink from "comlink";
+import { WorkerMessageType } from "../message";
+import { installServiceWorker } from "../serviceWorker/install";
 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();
@@ -39,7 +39,7 @@ export class Project {
                 });
             }
         }
-        ProjectWorker.postMessage(HandShake, [port2]);
+        ProjectWorker.postMessage(WorkerMessageType.InitConnection, [port2]);
         __classPrivateFieldSet(this, _Project_mount, (_b = __classPrivateFieldGet(this, _Project_mount, "f")) !== null && _b !== void 0 ? _b : this.remote.mount({
             cwd,
             wasmUrl,
@@ -51,8 +51,8 @@ export class Project {
     }
     connectWorker(e) {
         const port = e.ports[0];
-        if (e.data === Fork && !ConnectedPorts.has(port)) {
-            ProjectWorker.postMessage(HandShake, [port]);
+        if (e.data === WorkerMessageType.RequestFork && !ConnectedPorts.has(port)) {
+            ProjectWorker.postMessage(WorkerMessageType.InitConnection, [port]);
         }
     }
     async installServiceWorker() {
@@ -125,7 +125,7 @@ export class Project {
         return await this.remote.sigMd5(content);
     }
     static fork(channel, eventSource) {
-        (eventSource || self).postMessage(Fork, {
+        (eventSource || self).postMessage(WorkerMessageType.RequestFork, {
             transfer: [channel.port2],
         });
         return new ForkedProject(channel.port1);

package/esm/{serviceWorker.js → serviceWorker/index.js}

@@ -1,8 +1,14 @@
-import { Project } from "./project/Project";
-import { ServiceWorkerHandShake } from "./utils/message";
+import { SWMessageType } from "../message";
+import { Project } from "../project/Project";
+const HANDSHAKE_TIMEOUT = 10000; // 10 seconds
+const HANDSHAKE_WARNING_INTERVAL = 3000; // 3 seconds
 let _resolve;
+let _handshakeCompleted = false;
 let _promise = new Promise((resolve) => {
-    _resolve = resolve;
+    _resolve = () => {
+        _handshakeCompleted = true;
+        resolve();
+    };
 });
 let _projectEndpoint;
 const params = new URLSearchParams(self.location.search);
@@ -15,18 +21,56 @@ self.addEventListener("activate", (event) => {
     event.waitUntil(self.clients.claim());
 });
 self.addEventListener("message", (event) => {
-    if (event.data && event.data[ServiceWorkerHandShake] === true) {
+    if (event.data && event.data[SWMessageType.HandShake] === true) {
+        console.log("[ServiceWorker] Handshake message received");
         _projectEndpoint = Project.fork(new MessageChannel(), event.source);
         _resolve();
+        console.log("[ServiceWorker] Handshake completed, ProjectEndpoint ready");
+    }
+    else if (event.data && event.data[SWMessageType.HeartbeatPing] === true) {
+        event.source.postMessage({
+            [SWMessageType.HeartbeatPong]: true,
+        });
     }
 });
+async function waitForHandshake(requestUrl) {
+    if (_handshakeCompleted)
+        return;
+    const startTime = Date.now();
+    const warningTimer = setInterval(() => {
+        const elapsed = Date.now() - startTime;
+        console.warn(`[ServiceWorker] Still waiting for handshake... (${elapsed}ms elapsed, request: ${requestUrl})`);
+    }, HANDSHAKE_WARNING_INTERVAL);
+    const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => {
+            reject(new Error(`[ServiceWorker] Handshake timeout after ${HANDSHAKE_TIMEOUT}ms. ` +
+                `Make sure the main thread calls installServiceWorker() and sends the handshake message. ` +
+                `Request: ${requestUrl}`));
+        }, HANDSHAKE_TIMEOUT);
+    });
+    try {
+        await Promise.race([_promise, timeoutPromise]);
+    }
+    finally {
+        clearInterval(warningTimer);
+    }
+}
 self.addEventListener("fetch", (event) => {
     let { url: urlStr } = event.request;
     let url = new URL(urlStr);
     if (typeof _serviceWorkerScope === "string") {
         if (url.pathname.startsWith(_serviceWorkerScope)) {
             event.respondWith((async () => {
-                await _promise;
+                try {
+                    await waitForHandshake(urlStr);
+                }
+                catch (e) {
+                    console.error(e.message);
+                    return new Response(e.message, {
+                        status: 503,
+                        statusText: "Service Unavailable",
+                    });
+                }
                 const relativePathToCwd = (_targetDirToCwd !== null && _targetDirToCwd !== void 0 ? _targetDirToCwd : ".") +
                     url.pathname.replace(_serviceWorkerScope, "");
                 return readFileFromProject(relativePathToCwd);

package/esm/{utils/installServiceWorker.js → serviceWorker/install.js}

@@ -1,4 +1,21 @@
-import { ServiceWorkerHandShake } from "./message";
+import { SWMessageType } from "../message";
+const HEARTBEAT_INTERVAL = 10000;
+function startHeartbeat(sw) {
+    let lastHeartbeat = Date.now();
+    navigator.serviceWorker.addEventListener("message", (event) => {
+        if (event.data && event.data[SWMessageType.HeartbeatPong] === true) {
+            lastHeartbeat = Date.now();
+        }
+    });
+    setInterval(() => {
+        sw.postMessage({
+            [SWMessageType.HeartbeatPing]: true,
+        });
+        if (Date.now() - lastHeartbeat > HEARTBEAT_INTERVAL * 2) {
+            console.error("Service Worker Heartbeat Timeout");
+        }
+    }, HEARTBEAT_INTERVAL);
+}
 export async function installServiceWorker(url, scope, targetDirToCwd) {
     const swUrl = new URL(url, window.location.href);
     swUrl.searchParams.set("scope", scope);
@@ -11,8 +28,9 @@ export async function installServiceWorker(url, scope, targetDirToCwd) {
     return new Promise((resolve) => {
         function sendMessage(sw) {
             sw.postMessage({
-                [ServiceWorkerHandShake]: true,
+                [SWMessageType.HandShake]: true,
             });
+            startHeartbeat(sw);
             resolve();
         }
         function listenForActivation(sw) {

package/esm/utoo/index.d.ts

@@ -1,3 +1,11 @@
+/**
+ * @returns {any}
+ */
+export function getWasmMemory(): any;
+/**
+ * @returns {any}
+ */
+export function getWasmModule(): any;
 /**
  * @param {string} filter
  */
@@ -60,34 +68,18 @@ export class DirEntry {
      */
     get type(): DirEntryType;
 }
-export class Metadata {
-    static __wrap(ptr: any): any;
-    toJSON(): {
-        type: DirEntryType;
-        file_size: bigint;
-    };
-    toString(): string;
-    __destroy_into_raw(): number | undefined;
-    __wbg_ptr: number | undefined;
-    free(): void;
-    /**
-     * @param {DirEntryType} arg0
-     */
-    set type(arg0: DirEntryType);
+export class Fs {
     /**
-     * @returns {DirEntryType}
-     */
-    get type(): DirEntryType;
-    /**
-     * @param {bigint} arg0
+     * @param {string} src
+     * @param {string} dst
+     * @returns {Promise<void>}
      */
-    set file_size(arg0: bigint);
+    static copyFile(src: string, dst: string): Promise<void>;
     /**
-     * @returns {bigint}
+     * @param {string} src
+     * @param {string} dst
      */
-    get file_size(): bigint;
-}
-export class Project {
+    static copyFileSync(src: string, dst: string): void;
     /**
      * @param {string} path
      * @returns {Promise<void>}
@@ -95,26 +87,22 @@ export class Project {
     static createDir(path: string): Promise<void>;
     /**
      * @param {string} path
-     * @param {boolean} recursive
      * @returns {Promise<void>}
      */
-    static removeDir(path: string, recursive: boolean): Promise<void>;
+    static createDirAll(path: string): Promise<void>;
     /**
      * @param {string} path
-     * @param {Uint8Array} content
      */
-    static writeSync(path: string, content: Uint8Array): void;
+    static createDirAllSync(path: string): void;
     /**
      * @param {string} path
-     * @returns {Promise<void>}
      */
-    static removeFile(path: string): Promise<void>;
+    static createDirSync(path: string): void;
     /**
      * @param {string} path
-     * @param {string} content
-     * @returns {Promise<void>}
+     * @returns {Promise<Metadata>}
      */
-    static writeString(path: string, content: string): Promise<void>;
+    static metadata(path: string): Promise<Metadata>;
     /**
      * @param {string} path
      * @returns {Metadata}
@@ -122,19 +110,24 @@ export class Project {
     static metadataSync(path: string): Metadata;
     /**
      * @param {string} path
-     * @returns {DirEntry[]}
+     * @returns {Promise<Uint8Array>}
      */
-    static readDirSync(path: string): DirEntry[];
+    static read(path: string): Promise<Uint8Array>;
     /**
-     * @param {string} src
-     * @param {string} dst
+     * @param {string} path
+     * @returns {Promise<DirEntry[]>}
      */
-    static copyFileSync(src: string, dst: string): void;
+    static readDir(path: string): Promise<DirEntry[]>;
     /**
      * @param {string} path
-     * @returns {Promise<void>}
+     * @returns {DirEntry[]}
      */
-    static createDirAll(path: string): Promise<void>;
+    static readDirSync(path: string): DirEntry[];
+    /**
+     * @param {string} path
+     * @returns {Uint8Array}
+     */
+    static readSync(path: string): Uint8Array;
     /**
      * @param {string} path
      * @returns {Promise<string>}
@@ -142,21 +135,77 @@ export class Project {
     static readToString(path: string): Promise<string>;
     /**
      * @param {string} path
+     * @param {boolean} recursive
+     * @returns {Promise<void>}
      */
-    static createDirSync(path: string): void;
+    static removeDir(path: string, recursive: boolean): Promise<void>;
     /**
      * @param {string} path
      * @param {boolean} recursive
      */
     static removeDirSync(path: string, recursive: boolean): void;
+    /**
+     * @param {string} path
+     * @returns {Promise<void>}
+     */
+    static removeFile(path: string): Promise<void>;
     /**
      * @param {string} path
      */
     static removeFileSync(path: string): void;
     /**
      * @param {string} path
+     * @param {Uint8Array} content
+     * @returns {Promise<void>}
+     */
+    static write(path: string, content: Uint8Array): Promise<void>;
+    /**
+     * @param {string} path
+     * @param {string} content
+     * @returns {Promise<void>}
      */
-    static createDirAllSync(path: string): void;
+    static writeString(path: string, content: string): Promise<void>;
+    /**
+     * @param {string} path
+     * @param {Uint8Array} content
+     */
+    static writeSync(path: string, content: Uint8Array): void;
+    __destroy_into_raw(): number | undefined;
+    __wbg_ptr: number | undefined;
+    free(): void;
+}
+export class Metadata {
+    static __wrap(ptr: any): any;
+    toJSON(): {
+        file_size: bigint;
+        type: DirEntryType;
+    };
+    toString(): string;
+    __destroy_into_raw(): number | undefined;
+    __wbg_ptr: number | undefined;
+    free(): void;
+    /**
+     * @param {bigint} arg0
+     */
+    set file_size(arg0: bigint);
+    /**
+     * @returns {bigint}
+     */
+    get file_size(): bigint;
+    /**
+     * @param {DirEntryType} arg0
+     */
+    set type(arg0: DirEntryType);
+    /**
+     * @returns {DirEntryType}
+     */
+    get type(): DirEntryType;
+}
+export class Project {
+    /**
+     * @returns {Promise<any>}
+     */
+    static build(): Promise<any>;
     /**
      * @returns {string}
      */
@@ -185,29 +234,13 @@ export class Project {
      * @param {string} thread_url
      */
     static init(thread_url: string): void;
-    /**
-     * @param {string} path
-     * @returns {Promise<Uint8Array>}
-     */
-    static read(path: string): Promise<Uint8Array>;
-    /**
-     * @returns {Promise<any>}
-     */
-    static build(): Promise<any>;
-    /**
-     * @param {string} path
-     * @param {Uint8Array} content
-     * @returns {Promise<void>}
-     */
-    static write(path: string, content: Uint8Array): Promise<void>;
     /**
      * Install dependencies - downloads tgz files only, extracts on-demand when files are read
      * @param {string} package_lock
-     * @param {number | null | undefined} max_concurrent_downloads
-     * @param {string[]} omit
+     * @param {number | null} [max_concurrent_downloads]
      * @returns {Promise<void>}
      */
-    static install(package_lock: string, max_concurrent_downloads: number | null | undefined, omit: string[]): Promise<void>;
+    static install(package_lock: string, max_concurrent_downloads?: number | null): Promise<void>;
     /**
      * @param {string} path
      */
@@ -218,27 +251,6 @@ export class Project {
      * @returns {Promise<string>}
      */
     static sigMd5(content: Uint8Array): Promise<string>;
-    /**
-     * @param {string} path
-     * @returns {Promise<Metadata>}
-     */
-    static metadata(path: string): Promise<Metadata>;
-    /**
-     * @param {string} path
-     * @returns {Promise<DirEntry[]>}
-     */
-    static readDir(path: string): Promise<DirEntry[]>;
-    /**
-     * @param {string} src
-     * @param {string} dst
-     * @returns {Promise<void>}
-     */
-    static copyFile(src: string, dst: string): Promise<void>;
-    /**
-     * @param {string} path
-     * @returns {Uint8Array}
-     */
-    static readSync(path: string): Uint8Array;
     __destroy_into_raw(): number | undefined;
     __wbg_ptr: number | undefined;
     free(): void;
@@ -248,10 +260,6 @@ export class WasmTaskMessage {
     __destroy_into_raw(): number | undefined;
     __wbg_ptr: number | undefined;
     free(): void;
-    /**
-     * @returns {Uint8Array}
-     */
-    get data(): Uint8Array;
     /**
      * @param {number} arg0
      */
@@ -260,6 +268,10 @@ export class WasmTaskMessage {
      * @returns {number}
      */
     get taskId(): number;
+    /**
+     * @returns {Uint8Array}
+     */
+    get data(): Uint8Array;
 }
 export class WebWorkerCreation {
     static __wrap(ptr: any): any;
@@ -283,19 +295,19 @@ export class WebWorkerOptions {
     /**
      * @param {string} arg0
      */
-    set filename(arg0: string);
+    set cwd(arg0: string);
     /**
      * @returns {string}
      */
-    get filename(): string;
+    get cwd(): string;
     /**
      * @param {string} arg0
      */
-    set cwd(arg0: string);
+    set filename(arg0: string);
     /**
      * @returns {string}
      */
-    get cwd(): string;
+    get filename(): string;
 }
 export class WebWorkerTermination {
     static __wrap(ptr: any): any;
@@ -319,6 +331,6 @@ export class WebWorkerTermination {
      */
     get workerId(): number;
 }
-export default __wbg_init;
 export function initSync(module: any, memory: any): any;
 declare function __wbg_init(module_or_path: any, memory: any): Promise<any>;
+export { __wbg_init as default };