@dimina-kit/compiler 0.0.1 → 0.0.2-dev.20260711062001

package/src/pool.js

@@ -159,10 +159,10 @@ export function createCompilerPool(options = {}) {
   // One full compile attempt against the resident realms. Ends quiescent: settleAll
   // guarantees no request is still in flight when it returns/throws, so a retry can
   // start fresh without cross-attempt FIFO pairing.
-  async function runAttempt(files, workPath) {
+  async function runAttempt(files, workPath, options) {
     await settleAll(workers.map(ensureWarm))
 
-    // Phase 1 — one worker runs setup ONCE: it allocates the scope-hash ids
+    // Setup step — one worker runs setup ONCE: it allocates the scope-hash ids
     // (page + component data-v-XXXXX) and builds miniprogram_npm/app-config.json.
     // Broadcasting this single bundle to every stage is REQUIRED for correctness:
     // each stage runs in its own realm, and if each ran its own setup it would roll
@@ -170,10 +170,15 @@ export function createCompilerPool(options = {}) {
     // the render `Module id` and every WXSS rule would target nothing (regression
     // guarded by scripts/test-pool-scopehash.js). This mirrors the Node disk pool,
     // which likewise sets up once and fans the same { pages, storeInfo } out.
-    const s = await requestChecked(workers[0], { type: 'setup', files, workPath, wantHeartbeat: true }, 'setup', sendTimeoutMs)
+    // `options` (e.g. { fileTypes }) only needs to reach THIS setup call: dmcc's
+    // storeInfo() bakes the normalized dialect into the returned storeInfo object
+    // (dimina/fe/packages/compiler/src/env.js:106-120), which rides inside `bundle`
+    // below and is restored per-stage via resetStoreInfo (compile-core.js's
+    // compileStage -> env.js:122-132) — so compile-subset never needs its own copy.
+    const s = await requestChecked(workers[0], { type: 'setup', files, workPath, options, wantHeartbeat: true }, 'setup', sendTimeoutMs)
     const { bundle, scaffold } = s
 
-    // Phase 2 — every stage compiles in parallel against the SHARED bundle. The
+    // Compile step — every stage compiles in parallel against the SHARED bundle. The
     // non-stage scaffold (app-config.json + npm, produced once) seeds the union.
     const parts = await settleAll(workers.map((x) =>
       requestChecked(x, { type: 'compile-subset', files, workPath, stages: [x.stage], bundle, wantHeartbeat: true }, 'compile-subset', sendTimeoutMs)))
@@ -188,9 +193,16 @@ export function createCompilerPool(options = {}) {
   let chain = Promise.resolve()
 
   /**
-   * Single argument, no ambiguity: pass { files, workPath }. A bare { relPath: content }
-   * map is also accepted (uses the default workPath).
-   * @param {{ files: Record<string,string>, workPath?: string } | Record<string,string>} input
+   * Single argument, no ambiguity: pass { files, workPath, options }. A bare
+   * { relPath: content } map is also accepted (uses the default workPath, no options).
+   * @param {{
+   *   files: Record<string,string>,
+   *   workPath?: string,
+   *   options?: { fileTypes?: { template?: string[], style?: string[], viewScript?: string[] } },
+   * } | Record<string,string>} input
+   *   options.fileTypes lets a caller register a custom template/style/view-script
+   *   dialect (e.g. { template: ['qdml'], style: ['qdss'], viewScript: ['qds'] }) —
+   *   forwarded to the setup worker's `setupCompile` (dmcc's storeInfo).
    * @returns {Promise<{ appId: string, name: string, files: Record<string,string> }>}
    */
   function compile(input = {}) {
@@ -200,17 +212,18 @@ export function createCompilerPool(options = {}) {
       }
       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)')
+        throw new Error('[compiler] pool.compile expects { files: { relPath: content }, workPath?, options? } (or a non-empty files map)')
       }
       const workPath = input.workPath || defaultWorkPath
+      const options = input.options || {}
       try {
-        return await runAttempt(files, workPath)
+        return await runAttempt(files, workPath, options)
       } catch (err) {
         // A worker death is often transient (memory pressure, tab freeze, a one-off
         // toolchain stall) — retry the WHOLE attempt once on fresh workers. Real
         // compile errors (bad user source) are deterministic and are never retried.
         if (!retryOnWorkerDeath || !err || !WORKER_DEATH_CODES.has(err.code)) throw err
-        return await runAttempt(files, workPath)
+        return await runAttempt(files, workPath, options)
       }
     })
     // keep the chain alive regardless of this compile's outcome

package/src/stage-worker.js

@@ -65,10 +65,10 @@ function freshFs(files, workPath) {
 // what keeps the CSS `[data-v-X]` selectors and the render `Module id` in agreement:
 // if each stage ran its own setupCompile it would roll its own random uuids and every
 // WXSS rule would target a selector that never renders (see scripts/test-pool-scopehash.js).
-async function runSetup(files, workPath) {
+async function runSetup(files, workPath, options) {
   const fs = freshFs(files, workPath)
   resetCompilerState()
-  const ctx = await setupCompile({ fs, workPath })
+  const ctx = await setupCompile({ fs, workPath, options })
   const map = collectOutputs({ fs, targetPath: ctx.targetPath })
   const scaffold = {}
   for (const k of Object.keys(map)) if (map[k] != null) scaffold[k] = map[k]
@@ -93,7 +93,11 @@ async function runSetup(files, workPath) {
 // cross-stage scope-hash mismatch. Stages read source from `workPath` and write
 // disjoint products; they never read the setup scaffold, so it is not seeded here.
 // Without a bundle the worker stays self-contained (single-worker / legacy callers).
-async function compileSubset(files, workPath, stages, bundle) {
+// `options` (e.g. { fileTypes }) is only used on the no-bundle fallback path: with a
+// bundle, its storeInfo already carries the normalized dialect from the coordinator's
+// setupCompile call (see runSetup below / pool.js's runAttempt), restored via
+// compileStage -> resetStoreInfo, so re-deriving it here would be redundant.
+async function compileSubset(files, workPath, stages, bundle, options) {
   const fs = freshFs(files, workPath)
   resetCompilerState()
   let appId, name, targetPath
@@ -103,7 +107,7 @@ async function compileSubset(files, workPath, stages, bundle) {
     }
     ;({ appId, name, targetPath } = bundle)
   } else {
-    const ctx = await setupCompile({ fs, workPath })
+    const ctx = await setupCompile({ fs, workPath, options })
     for (const stage of stages) {
       await compileStage({ stage, pages: ctx.pages, storeInfo: ctx.storeInfo, fs })
     }
@@ -150,21 +154,21 @@ self.onmessage = async (e) => {
       // Coordinator phase: one worker parses config, allocates the shared scope-hash
       // ids and builds miniprogram_npm once. setupCompile's npm build can invoke the
       // wasm toolchain, so ensure it's loaded regardless of this worker's own stage.
-      const { files, workPath = '/work', toolchainSetupURL } = e.data
+      const { files, workPath = '/work', options, toolchainSetupURL } = e.data
       if (toolchainSetupURL) toolchainURL = toolchainSetupURL
       await ensureToolchain()
       const t = performance.now()
-      const { bundle, scaffold } = await runSetup(files, workPath)
+      const { bundle, scaffold } = await runSetup(files, workPath, options)
       self.postMessage({ type: 'setup-done', bundle, scaffold, ms: Math.round(performance.now() - t) })
       return
     }
     if (type === 'compile-subset') {
-      const { files, workPath = '/work', stages = ['logic', 'view', 'style'], bundle, toolchainSetupURL } = e.data
+      const { files, workPath = '/work', stages = ['logic', 'view', 'style'], bundle, options, toolchainSetupURL } = e.data
       if (toolchainSetupURL) toolchainURL = toolchainSetupURL
       if (needsToolchain(stages)) await ensureToolchain()
       const warm = !!toolchainReady
       const t = performance.now()
-      const result = await compileSubset(files, workPath, stages, bundle)
+      const result = await compileSubset(files, workPath, stages, bundle, options)
       self.postMessage({ type: 'done', result, ms: Math.round(performance.now() - t), warm })
       return
     }