vite-plugin-taro 0.6.3 → 0.6.6

package/src/node/plugins/wx/dev/dev-host.ts

@@ -1,4 +1,3 @@
-import { readFile } from 'node:fs/promises'
 import type { ServerResponse } from 'node:http'
 import path from 'node:path'
 import colors from 'picocolors'
@@ -6,10 +5,11 @@ import { type DevEngine, type DevOptions, dev } from 'rolldown/experimental'
 import { asyncScheduler } from 'rxjs'
 import type { Connect, ViteDevServer } from 'vite'
 import type { VptOptions } from '../../../../options.ts'
+import type { WxStylePlugin } from '../styles/plugins.ts'
 import { createHmrResultsStream } from './create-hmr-results-stream.ts'
-import { createStyleCapture, type StyleCaptureAction } from './create-style-capture.ts'
 import {
     developmentAppWxssFileName,
+    globalWxssFileName,
     type HmrInfo,
     hmrControlPath,
     hmrInfoFileName,
@@ -36,7 +36,6 @@ type DevOutputResult = Parameters<NonNullable<DevOptions['onOutput']>>[0]
 type OutputAction = Readonly<{ kind: 'output'; result: DevOutputResult }>
 
 type HostAction =
-    | StyleCaptureAction
     | Readonly<{ kind: 'publish'; result: HmrUpdates }>
     | Readonly<{ kind: 'error'; error: Error }>
     | Readonly<{ kind: 'reports'; reports: readonly RuntimeReport[] }>
@@ -52,17 +51,17 @@ const hmrSettleMilliseconds = 16
  * engine writes directly to the Mini Program output directory instead of serving browser
  * HMR over HTTP.
  *
- * `applicationEntryIds` is the resolver's immutable cascade policy, not a second graph: it selects the App capsule followed
- * by configured Page capsules from Rolldown's larger entry set. Rolldown remains the authority for every live import edge.
+ * The shared style plugin carries the resolver's immutable App/Page cascade policy while Rolldown remains authoritative for
+ * every live import edge.
  */
 export async function createWxDevHost({
     server,
     options,
-    applicationEntryIds
+    styles
 }: {
     server: ViteDevServer
     options: VptOptions
-    applicationEntryIds: readonly string[]
+    styles: WxStylePlugin
 }): Promise<WxDevHost> {
     const bundledDev = getBundledDev(server)
 
@@ -71,23 +70,12 @@ export async function createWxDevHost({
         logWxError(server.config.logger, `wx HMR ${action.kind} failed`, error)
     )
 
-    const styleCapture = createStyleCapture({
-        applicationEntryIds: applicationEntryIds,
-        outDir: server.config.build.outDir,
-        // Capture hooks run only after engine.run, when the host action subscription and all reducer dependencies are ready.
-        emit: (action) => hostActions.next(action),
-        transformTailwindRoot: async (rootId, requestId) => {
-            // The capture contains generated CSS, while the sidecar must re-run from raw Tailwind directives. Vite exposes no
-            // raw source in its live module graph, so this read is the authoritative source generation rather than a read-back.
-            return server.environments.client.pluginContainer.transform(await readFile(rootId, 'utf8'), requestId)
-        }
-    })
     const publisher = new PatchPublisher((content) =>
         writeHmrFile(server.config.build.outDir, hmrPatchesFileName, content)
     )
 
     // Option installation now configures only Rolldown. Build lifecycle results enter through the engine's output action below.
-    installWxDevOptions({ bundledDev, server, options, hostPlugins: [styleCapture.plugin] })
+    installWxDevOptions({ bundledDev, server, options })
     const engine: DevEngine = await createEngine()
 
     const hmrResults = createHmrResultsStream(
@@ -158,12 +146,17 @@ export async function createWxDevHost({
             hmrResults.complete()
             runtimeReports.complete()
             await hostActions.waitForIdle()
-            // Keep the action edge open until the final generation has admitted all capture and output callbacks.
+            // Keep the action edge open until the final generation has admitted every output callback.
             await engine.ensureCurrentBuildFinish()
             await hostActions.complete()
         }
     }
 
+    /** Atomically materializes the style plugin's prepared global artifact. */
+    async function writeGlobalStyle(wxss: string): Promise<void> {
+        await writeHmrFile(server.config.build.outDir, globalWxssFileName, wxss)
+    }
+
     /** Rotates the build identity and materializes the App metadata for it. */
     async function rotateBuildSession(): Promise<void> {
         const port = boundPort(server)
@@ -207,14 +200,6 @@ export async function createWxDevHost({
     /** Reduces one merged source action through the existing authoritative host state. */
     function applyHostAction(action: HostAction): void | Promise<void> {
         switch (action.kind) {
-            case 'capture-graph':
-                // The buildStart reader is a live capability; replacing it only here makes the reducer own build rebinding.
-                styleCapture.captureGraph(action.getModuleInfo)
-                return
-            case 'capture-style':
-                // A failed upstream transform emits no action, intentionally retaining the last valid processed CSS generation.
-                styleCapture.captureStyle(action.id, action.style)
-                return
             case 'publish':
                 return publishUpdates(action.result)
             case 'error':
@@ -228,21 +213,15 @@ export async function createWxDevHost({
                     logWxError(server.config.logger, 'wx dev build failed', action.result)
                     return
                 }
-                return reconcileCompleteOutput(action.result.output)
+                return publishCompleteStyles()
             case 'listening':
                 return rotateBuildSession()
         }
     }
 
-    /**
-     * Reconciles graph-complete styles before rotating the App-visible build identity.
-     *
-     * DevEngine has already written its compiler asset when onOutput fires, but bundled development may have omitted CSS Modules
-     * from that asset. Awaiting reconciliation inside the serialized reducer guarantees the subsequent app.wxss rotation—the
-     * event that refreshes DevTools—can only expose a generation whose global WXSS already represents the complete App/Page graph.
-     */
-    async function reconcileCompleteOutput(output: Exclude<DevOutputResult, Error>['output']): Promise<void> {
-        await styleCapture.reconcileComplete(output)
+    /** Publishes graph-complete styles before rotating the App-visible build identity. */
+    async function publishCompleteStyles(): Promise<void> {
+        await styles.finalizeUpdate([], writeGlobalStyle)
         await rotateBuildSession()
     }
 
@@ -329,18 +308,17 @@ export async function createWxDevHost({
             return
         }
 
-        // `onHmrUpdates` is the transaction boundary after every affected transform has updated graph and candidate state.
-        // Every non-CSS edit may alter imports or Tailwind classes; rendering broadly and comparing finalized bytes avoids
-        // source scanning while preventing unrelated JavaScript edits from notifying DevTools through an identical rename.
-        await styleCapture.publishChanged(patches.flatMap((patch) => patch.changedIds))
+        // `onHmrUpdates` runs after every affected transform has updated captured CSS and the live import graph. The style
+        // boundary finalizes every factory before atomically publishing their matching WXSS.
+        const finalizedPatches = await styles.finalizeUpdate(patches, writeGlobalStyle)
 
         // Publish global.wxss before the matching JavaScript patch so DevTools observes a coherent HMR transaction.
         // The physical file must exist before Rolldown advances: once committed, later patches may be generated relative to
         // this batch even if DevTools has not observed its file event yet. PatchPublisher keeps the unapplied range cumulative,
         // so any later file generation still carries every factory needed to bridge the runtime's older application frontier.
-        await publisher.produce(patches)
+        await publisher.produce(finalizedPatches)
 
-        await commitPublishedBatch(patches)
+        await commitPublishedBatch(finalizedPatches)
     }
 
     /**

package/src/node/plugins/wx/dev/plugins.ts

@@ -4,6 +4,7 @@ import { esTarget } from '../../../utils/constant.ts'
 import { memoize } from '../../../utils/memoize.ts'
 import { normalizeModuleId } from '../../../utils/modules.ts'
 import { pageShellPath, rolldownRuntimeId } from '../module/module.ts'
+import type { WxStylePlugin } from '../styles/plugins.ts'
 import { createWxDevHost, type WxDevHost } from './dev-host.ts'
 import { developmentAppWxssFileName } from './hmr-files.ts'
 import { createWxReactRefreshTransforms } from './react-refresh.ts'
@@ -17,10 +18,10 @@ export function isWxClientEnvironment(environment: Readonly<{ name: string }>):
  * Adds the serve-only bundled-development plugin set for the wx target: the dev adapter,
  * Page HMR activation, and React Refresh adaptation transforms.
  *
- * The ordered application entries cross this configuration boundary unchanged so the host can compose global CSS without
- * reconstructing the resolver's App/Page ownership policy from unrelated Rolldown shell and transport entries.
+ * The shared style pipeline already owns the resolver's ordered App/Page cascade policy, so the host does not reconstruct it
+ * from unrelated Rolldown shell and transport entries.
  */
-export function createWxDevelopmentPlugin(options: VptOptions, applicationEntryIds: readonly string[]): PluginOption[] {
+export function createWxDevelopmentPlugin(options: VptOptions, styles: WxStylePlugin): PluginOption[] {
     /*
      * Vite creates this plugin descriptor before a server or DevEngine exists, then invokes configureServer and closeBundle on
      * different lifecycle stacks. This mutable handle transfers the one client-owned host between those hooks: configureServer
@@ -71,7 +72,7 @@ export function createWxDevelopmentPlugin(options: VptOptions, applicationEntryI
                     host = await createWxDevHost({
                         server: server,
                         options: options,
-                        applicationEntryIds: applicationEntryIds
+                        styles: styles
                     })
                 }
             },

package/src/node/plugins/wx/dev/wx-dev-options.ts

@@ -1,5 +1,5 @@
 import path from 'node:path'
-import type { InputOptions, OutputOptions, Plugin } from 'rolldown'
+import type { InputOptions, OutputOptions } from 'rolldown'
 import { build } from 'rolldown'
 import { type DevEngine, viteReporterPlugin } from 'rolldown/experimental'
 import type { ViteDevServer } from 'vite'
@@ -30,13 +30,11 @@ export type BundledDev = {
 export function installWxDevOptions({
     bundledDev,
     server,
-    options,
-    hostPlugins
+    options
 }: {
     bundledDev: BundledDev
     server: ViteDevServer
     options: VptOptions
-    hostPlugins: Plugin[]
 }): void {
     /*
      * Vite owns this mutable adapter method and calls it later when constructing DevEngine. Replacing that one seam preserves
@@ -113,10 +111,10 @@ export function installWxDevOptions({
 
         /*
          * The plugin list is mutable configuration consumed once by this engine generation. Replace the top-level reference with
-         * an ordered composite rather than pushing into Vite's potentially shared nested array: existing transforms run first,
-         * host capture observes their final values, and the reporter observes final output without mutating either input list.
+         * an ordered composite rather than pushing into Vite's potentially shared nested array; the reporter observes final output
+         * without mutating Vite's retained input list.
          */
-        rolldownOptions.plugins = [rolldownOptions.plugins, hostPlugins, createViteReporter(server)]
+        rolldownOptions.plugins = [rolldownOptions.plugins, createViteReporter(server)]
         disableViteOxcSourcemap(rolldownOptions.plugins)
 
         return rolldownOptions

package/src/node/plugins/wx/plugins.ts

@@ -12,7 +12,7 @@ import { renderCapsule } from './render/capsule.ts'
 import { renderNative } from './render/native.ts'
 import { materializeTransport } from './render/transport.ts'
 import { createResolver } from './resolve/resolver.ts'
-import { createWxStylePlugins } from './styles/plugins.ts'
+import { createWxStylePlugin } from './styles/plugins.ts'
 
 type WxResolver = ReturnType<typeof createResolver>
 
@@ -23,13 +23,9 @@ export function createWxTargetPlugins(options: VptOptions): PluginOption[] {
     // Reuse the resolver instance's ordered application subset. Rolldown's complete input also contains bootstrap, transport,
     // shell, and component entries; entry membership alone cannot recover which roots define the App/Page CSS cascade.
     const placement = createWxPlacementPlugin()
+    const styles = createWxStylePlugin(resolver.applicationEntryIds)
 
-    return [
-        placement,
-        createWxStylePlugins(),
-        createWxPlugin(options, resolver, placement),
-        createWxDevelopmentPlugin(options, resolver.applicationEntryIds)
-    ]
+    return [placement, styles, createWxPlugin(options, resolver, placement), createWxDevelopmentPlugin(options, styles)]
 }
 
 /** Configures the complete wx target build pipeline. */
@@ -133,10 +129,8 @@ function createWxPlugin(options: VptOptions, resolver: WxResolver, placement: Wx
 
         generateBundle: {
             /*
-             * This hook is registered after createWxStylePlugins() and shares hook-level `order: 'post'` with the adapted
-             * upstream hooks and VPT style finalizer. Registration order therefore guarantees that the imported global
-             * stylesheet is complete before native Page/component companions are emitted. Without this order, the finalizer
-             * could consume incomplete Tailwind output or mistake native WXSS companions for additional compiler styles.
+             * Registration after the style pipeline makes the compiler stylesheet final before native Page and component
+             * companions are emitted. The style finalizer therefore cannot mistake native WXSS for application CSS.
              */
             order: 'post',
             async handler(_, bundle) {