@utoo/web 0.0.1 → 1.0.1

package/esm/forkedProject.d.ts

@@ -0,0 +1,24 @@
+import { PackFile, ProjectEndpoint } from "./type";
+export declare class ForkedProject implements ProjectEndpoint {
+    private endpoint;
+    constructor(port: MessagePort);
+    install(packageLock: string, maxConcurrentDownloads?: number): 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>;
+    gzip(files: PackFile[]): Promise<Uint8Array>;
+    sigMd5(content: Uint8Array): Promise<string>;
+}

package/esm/forkedProject.js

@@ -0,0 +1,40 @@
+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, maxConcurrentDownloads) {
+        return await this.endpoint.install(packageLock, maxConcurrentDownloads);
+    }
+    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);
+    }
+    async gzip(files) {
+        return await this.endpoint.gzip(files);
+    }
+    async sigMd5(content) {
+        return await this.endpoint.sigMd5(content);
+    }
+}

package/esm/index.d.ts

@@ -1,18 +1,2 @@
-import { ProjectEndpoint } from "./type";
-import type { DirEntry } from "./utoo";
-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/internalProject.d.ts

@@ -0,0 +1,29 @@
+import { PackFile, ProjectEndpoint, ProjectOptions } from "./type";
+import initWasm, { Project as ProjectInternal } from "./utoo";
+declare class InternalEndpoint implements ProjectEndpoint {
+    projectInternal?: ProjectInternal;
+    wasmInit?: ReturnType<typeof initWasm>;
+    options?: Omit<ProjectOptions, "workerUrl" | "serviceWorker">;
+    mount(opt: Omit<ProjectOptions, "workerUrl" | "serviceWorker">): Promise<void>;
+    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>;
+    readdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<any>;
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    rm(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    rmdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    gzip(files: PackFile[]): Promise<Uint8Array<ArrayBufferLike>>;
+    sigMd5(content: Uint8Array): Promise<string>;
+}
+declare const internalEndpoint: InternalEndpoint;
+export { internalEndpoint };

package/esm/internalProject.js

@@ -0,0 +1,184 @@
+import initWasm, { init_log_filter, Project as ProjectInternal, recvPoolRequest, recvWorkerTermination, } from "./utoo";
+// @ts-ignore
+import webpackLoadersCode from "./webpackLoaders/workerContent";
+let nextWorkerId = 0;
+const loaderWorkers = {};
+async function getTurbopackLoaderAssets() {
+    const turbopackLoaderAssets = {};
+    const dirEntries = await internalEndpoint.projectInternal.readDir(".turbopack");
+    await Promise.all(dirEntries.map(async (entry) => {
+        // only collect .js files
+        if (entry.type === "file" && entry.name.endsWith(".js")) {
+            turbopackLoaderAssets[`./${entry.name}`] =
+                await internalEndpoint.projectInternal.readToString(`.turbopack/${entry.name}`);
+        }
+    }));
+    return turbopackLoaderAssets;
+}
+const createOrScalePool = async (binding, loadersImportMap) => {
+    while (true) {
+        try {
+            let poolOptions = await recvPoolRequest();
+            const { filename: entrypoint, maxConcurrency } = poolOptions;
+            const workers = loaderWorkers[entrypoint] || (loaderWorkers[entrypoint] = []);
+            if (workers.length < maxConcurrency) {
+                for (let i = workers.length; i < maxConcurrency; i++) {
+                    nextWorkerId += 1;
+                    const turbopackLoaderAssets = await getTurbopackLoaderAssets();
+                    const blob = new Blob([webpackLoadersCode], {
+                        type: "text/javascript",
+                    });
+                    const workerUrl = URL.createObjectURL(blob);
+                    const worker = new Worker(workerUrl);
+                    worker.postMessage([
+                        // @ts-ignore
+                        initWasm.__wbindgen_wasm_module,
+                        binding.memory,
+                        {
+                            workerData: {
+                                poolId: entrypoint,
+                                workerId: nextWorkerId,
+                            },
+                            loaderAssets: {
+                                importMaps: { ...turbopackLoaderAssets, ...loadersImportMap },
+                                entrypoint: entrypoint.replace(".turbopack/", ""),
+                            },
+                        },
+                    ]);
+                    // @ts-ignore
+                    worker.workerId = nextWorkerId;
+                    // @ts-ignore
+                    workers.push(worker);
+                }
+            }
+            else if (workers.length > maxConcurrency) {
+                const workersToStop = workers.splice(0, workers.length - maxConcurrency);
+                workersToStop.forEach((worker) => worker.terminate());
+            }
+        }
+        catch (_e) {
+            // rust channel closed. do nothing
+            return;
+        }
+    }
+};
+const waitingForWorkerTermination = async () => {
+    while (true) {
+        try {
+            const { filename, workerId } = await recvWorkerTermination();
+            const workers = loaderWorkers[filename];
+            const workerIdx = workers.findIndex((worker) => worker.workerId === workerId);
+            if (workerIdx > -1) {
+                const worker = workers.splice(workerIdx, 1);
+                worker[0].terminate();
+            }
+        }
+        catch (_e) {
+            // rust channel closed. do nothing
+            return;
+        }
+    }
+};
+class InternalEndpoint {
+    // 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";
+        init_log_filter(filter);
+        this.projectInternal = new ProjectInternal(cwd, threadWorkerUrl);
+        return;
+    }
+    async install(packageLock, maxConcurrentDownloads) {
+        await this.wasmInit;
+        await this.projectInternal.install(packageLock, maxConcurrentDownloads);
+        return;
+    }
+    async build() {
+        var _a;
+        const binding = await this.wasmInit;
+        createOrScalePool(binding, (_a = this.options) === null || _a === void 0 ? void 0 : _a.loadersImportMap);
+        waitingForWorkerTermination();
+        return await this.projectInternal.build();
+    }
+    async readFile(path, encoding) {
+        await this.wasmInit;
+        let ret;
+        if (encoding === "utf8") {
+            ret = await this.projectInternal.readToString(path);
+        }
+        else {
+            ret = await this.projectInternal.read(path);
+        }
+        return ret;
+    }
+    async writeFile(path, content, _encoding) {
+        await this.wasmInit;
+        if (typeof content === "string") {
+            return await this.projectInternal.writeString(path, content);
+        }
+        else {
+            return await this.projectInternal.write(path, content);
+        }
+    }
+    async copyFile(src, dst) {
+        await this.wasmInit;
+        return await this.projectInternal.copyFile(src, dst);
+    }
+    async readdir(path, options) {
+        await this.wasmInit;
+        const dirEntries = (options === null || options === void 0 ? void 0 : options.recursive)
+            ? await this.projectInternal.readDir(path)
+            : // TODO: support recursive readDirAll
+                await this.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 this.projectInternal.createDirAll(path);
+        }
+        else {
+            return await this.projectInternal.createDir(path);
+        }
+    }
+    async rm(path, options) {
+        await this.wasmInit;
+        let metadata = (await this.projectInternal.metadata(path)).toJSON();
+        switch (metadata.type) {
+            case "file":
+                return await this.projectInternal.removeFile(path);
+            case "directory":
+                return await this.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 this.projectInternal.removeDir(path, !!(options === null || options === void 0 ? void 0 : options.recursive));
+    }
+    async gzip(files) {
+        await this.wasmInit;
+        return await this.projectInternal.gzip(files);
+    }
+    async sigMd5(content) {
+        await this.wasmInit;
+        return await this.projectInternal.sigMd5(content);
+    }
+}
+const internalEndpoint = new InternalEndpoint();
+export { internalEndpoint };

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,31 @@
+import { BuildOutput, Dirent, PackFile, ProjectEndpoint, ProjectOptions, ServiceWorkerOptions } from "./type";
+export declare class Project implements ProjectEndpoint {
+    #private;
+    readonly cwd: string;
+    readonly serviceWorkerOptions?: ServiceWorkerOptions;
+    private remote;
+    constructor(options: ProjectOptions);
+    private connectWorker;
+    installServiceWorker(): Promise<void>;
+    mount(): Promise<void>;
+    install(packageLock: string, maxConcurrentDownloads?: number): 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>;
+    gzip(files: PackFile[]): Promise<Uint8Array>;
+    sigMd5(content: Uint8Array): Promise<string>;
+    static fork(channel: MessageChannel, eventSource?: Client | DedicatedWorkerGlobalScope): ProjectEndpoint;
+}

package/esm/project.js

@@ -0,0 +1,120 @@
+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, logFilter, loadersImportMap, } = options;
+        this.cwd = cwd;
+        this.serviceWorkerOptions = serviceWorker;
+        const { port1, port2 } = new MessageChannel();
+        (_a = this.remote) !== null && _a !== void 0 ? _a : (this.remote = comlink.wrap(port1));
+        if (!ProjectWorker) {
+            ProjectWorker = new Worker(workerUrl);
+            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,
+            loadersImportMap,
+            logFilter,
+        }), "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, maxConcurrentDownloads) {
+        await __classPrivateFieldGet(this, _Project_mount, "f");
+        return await this.remote.install(packageLock, maxConcurrentDownloads);
+    }
+    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);
+    }
+    async gzip(files) {
+        await __classPrivateFieldGet(this, _Project_mount, "f");
+        return await this.remote.gzip(files);
+    }
+    async sigMd5(content) {
+        await __classPrivateFieldGet(this, _Project_mount, "f");
+        return await this.remote.sigMd5(content);
+    }
+    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,62 @@
+import { Project } from ".";
+import { ServiceWorkerHandShake } from "./message";
+let _resolve;
+let _promise = new Promise((resolve) => {
+    _resolve = resolve;
+});
+let _projectEndpoint;
+let _serviceWorkerScope;
+self.addEventListener("install", (event) => {
+    event.waitUntil(self.skipWaiting());
+});
+self.addEventListener("activate", (event) => {
+    event.waitUntil(self.clients.claim());
+});
+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 {
+        return;
+    }
+});
+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 {};