@dimina-kit/compiler 0.0.1-dev.20260702173719

package/dist/pool.browser.js

@@ -0,0 +1,99 @@
+globalThis.global ||= globalThis;
+globalThis.process ||= { env: {}, cwd: () => "/" };
+globalThis.process.cwd ||= () => "/";
+
+// src/pool.js
+var DEFAULT_STAGES = ["logic", "view", "style"];
+function createCompilerPool(options = {}) {
+  const {
+    createWorker,
+    toolchainSetupURL,
+    stages = DEFAULT_STAGES,
+    workPath: defaultWorkPath = "/work",
+    onLog
+  } = options;
+  if (typeof createWorker !== "function") {
+    throw new Error("[compiler] createCompilerPool: options.createWorker (() => Worker) is required");
+  }
+  if (!toolchainSetupURL) {
+    throw new Error("[compiler] createCompilerPool: options.toolchainSetupURL is required");
+  }
+  const workers = stages.map((stage) => {
+    const w = createWorker();
+    const q = [];
+    w.onmessage = (e) => {
+      const d = e.data;
+      if (d && d.type === "log") {
+        if (onLog) {
+          try {
+            onLog({ level: d.level, message: d.message, stage });
+          } catch {
+          }
+        }
+        return;
+      }
+      const r = q.shift();
+      if (r) r(d);
+    };
+    w.onerror = (ev) => {
+      const msg = ev && (ev.message || ev.error && ev.error.message) || "worker failed to load or threw (no message \u2014 often a module-load / static-asset / cross-origin failure)";
+      const where = ev && ev.filename ? ` (${ev.filename}:${ev.lineno || 0})` : "";
+      const r = q.shift();
+      if (r) r({ type: "error", error: `[compiler] stage '${stage}' worker error: ${msg}${where}` });
+    };
+    return { stage, w, send: (m) => new Promise((res) => {
+      q.push(res);
+      w.postMessage(m);
+    }) };
+  });
+  let warmed = null;
+  async function warmup() {
+    if (!warmed) {
+      warmed = Promise.all(workers.map((x) => x.send({ type: "warmup", toolchainSetupURL }))).then((rs) => rs.forEach((r, i) => {
+        if (r && r.type === "error") throw new Error(r.error || `[compiler] stage '${workers[i].stage}' warmup failed`);
+      })).catch((err) => {
+        warmed = null;
+        throw err;
+      });
+    }
+    return warmed;
+  }
+  let chain = Promise.resolve();
+  function compile(input = {}) {
+    const run = chain.then(async () => {
+      await warmup();
+      const files = input.files || input;
+      if (!files || typeof files !== "object" || !Object.keys(files).length) {
+        throw new Error("[compiler] pool.compile expects { files: { relPath: content }, workPath? } (or a non-empty files map)");
+      }
+      const workPath = input.workPath || defaultWorkPath;
+      const parts = await Promise.all(workers.map((x) => x.send({ type: "compile-subset", files, workPath, stages: [x.stage] })));
+      const merged = {};
+      let appId, name;
+      for (let i = 0; i < parts.length; i++) {
+        const pr = parts[i];
+        if (!pr || pr.type === "error") throw new Error(pr && pr.error ? pr.error : `[compiler] stage '${workers[i].stage}' worker error`);
+        appId = pr.result.appId;
+        name = pr.result.name;
+        Object.assign(merged, pr.result.files);
+      }
+      return { appId, name, files: merged };
+    });
+    chain = run.then(() => {
+    }, () => {
+    });
+    return run;
+  }
+  function dispose() {
+    for (const x of workers) {
+      try {
+        x.w.terminate();
+      } catch {
+      }
+    }
+  }
+  return { warmup, compile, dispose, stages: [...stages] };
+}
+export {
+  createCompilerPool
+};