@utoo/web 1.1.0 → 1.2.0-rc.2

package/esm/internalProject.d.ts

@@ -4,6 +4,7 @@ declare class InternalEndpoint implements ProjectEndpoint {
     projectInternal?: ProjectInternal;
     wasmInit?: ReturnType<typeof initWasm>;
     options?: Omit<ProjectOptions, "workerUrl" | "serviceWorker">;
+    loaderWorkerPoolInitialized: boolean;
     mount(opt: Omit<ProjectOptions, "workerUrl" | "serviceWorker">): Promise<void>;
     install(packageLock: string, maxConcurrentDownloads?: number): Promise<void>;
     build(): Promise<any>;

package/esm/internalProject.js

@@ -1,86 +1,9 @@
-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 concurrency = Math.max(maxConcurrency, navigator.hardwareConcurrency);
-            const workers = loaderWorkers[entrypoint] || (loaderWorkers[entrypoint] = []);
-            if (workers.length < concurrency) {
-                for (let i = workers.length; i < concurrency; 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 > concurrency) {
-                const workersToStop = workers.splice(0, workers.length - concurrency);
-                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;
-        }
-    }
-};
+import { runLoaderWorkerPool } from "./loaderWorkerPool";
+import initWasm, { init_log_filter, Project as ProjectInternal, } from "./utoo";
 class InternalEndpoint {
+    constructor() {
+        this.loaderWorkerPoolInitialized = false;
+    }
     // This should be called only once
     async mount(opt) {
         var _a;
@@ -100,10 +23,12 @@ class InternalEndpoint {
         return;
     }
     async build() {
-        var _a;
+        var _a, _b;
         const binding = await this.wasmInit;
-        createOrScalePool(binding, (_a = this.options) === null || _a === void 0 ? void 0 : _a.loadersImportMap);
-        waitingForWorkerTermination();
+        if (((_a = this.options) === null || _a === void 0 ? void 0 : _a.loaderWorkerUrl) && !this.loaderWorkerPoolInitialized) {
+            runLoaderWorkerPool(binding, this.options.cwd, this.projectInternal, this.options.loaderWorkerUrl, (_b = this.options) === null || _b === void 0 ? void 0 : _b.loadersImportMap);
+            this.loaderWorkerPoolInitialized = true;
+        }
         return await this.projectInternal.build();
     }
     async readFile(path, encoding) {