vite-plugin-taro 0.6.2 → 0.6.5

package/src/node/utils/vite.ts

@@ -1,67 +1,22 @@
-import type { HookHandler, Plugin, PluginOption } from 'vite'
+import type { HookHandler, Plugin } from 'vite'
 
 type TransformHook = HookHandler<NonNullable<Plugin['transform']>>
-export type TransformHookResult = Awaited<ReturnType<TransformHook>>
-export type AsyncTransformHook = (
+
+type AsyncTransformHook = (
     this: ThisParameterType<TransformHook>,
     ...args: Parameters<TransformHook>
-) => Promise<TransformHookResult>
-export type TransformHookWrapper = (transform: AsyncTransformHook) => AsyncTransformHook
-
-export type PluginMapper = (plugin: Plugin) => Plugin
-
-/** Transforms every concrete plugin while preserving nested arrays, falsy options, and promised options. */
-export function transformVitePlugin(pluginOptions: PluginOption[], mapPlugin: PluginMapper): PluginOption[] {
-    return pluginOptions.map((option) => transformPluginOption(option, mapPlugin))
-}
-
-function transformPluginOption(option: PluginOption, mapPlugin: PluginMapper): PluginOption {
-    if (option instanceof Promise) {
-        return option.then((resolvedOption) => transformPluginOption(resolvedOption, mapPlugin))
-    }
+) => Promise<Awaited<ReturnType<TransformHook>>>
 
-    if (Array.isArray(option)) {
-        return transformVitePlugin(option, mapPlugin)
-    }
-
-    return isPlugin(option) ? mapPlugin(option) : option
-}
-
-function isPlugin(option: PluginOption): option is Plugin {
-    return (
-        option !== null &&
-        option !== false &&
-        option !== undefined &&
-        typeof option === 'object' &&
-        !Array.isArray(option) &&
-        'name' in option
-    )
-}
-
-/**
- * Clones a Vite transform hook with middleware that controls execution of the original handler.
- *
- * Function and object hook forms retain their original plugin context. Object metadata such as `order` and `filter` is copied
- * unchanged, and the input descriptor is never mutated. The wrapper receives the normalized asynchronous transform with its
- * complete plugin context, code, ID, and metadata signature, and returns the handler that continues Vite's plugin pipeline.
- */
-export function wrapPluginTransform(plugin: Plugin, wrapper: TransformHookWrapper): Plugin {
-    const { transform } = plugin
-
-    if (!transform) {
-        throw new Error(`${plugin.name} must expose a transform hook`)
-    }
-
-    const isTransformFunction = typeof transform === 'function'
-
-    const handler = isTransformFunction ? transform : transform.handler
+export type TransformHookWrapper = (transform: AsyncTransformHook) => AsyncTransformHook
 
-    const wrappedHandler = wrapper(async function (code, id, meta) {
-        return handler.call(this, code, id, meta)
+/** Mutates one concrete plugin to interpose on its transform while preserving hook metadata and plugin context. */
+export function wrapPluginTransform(plugin: Plugin, wrapper: TransformHookWrapper): void {
+    const transform = plugin.transform!
+    const handler = typeof transform === 'function' ? transform : transform.handler
+    const wrapped = wrapper(async function (code, id, options) {
+        return handler.call(this, code, id, options)
     })
 
-    return {
-        ...plugin,
-        transform: isTransformFunction ? wrappedHandler : { ...transform, handler: wrappedHandler }
-    }
+    // Installation-time mutation keeps Vite's existing plugin identity and resolved hook registration.
+    plugin.transform = typeof transform === 'function' ? wrapped : { ...transform, handler: wrapped }
 }

package/src/runtime/wx/amphibious/bootstrap.ts

@@ -2,11 +2,6 @@
 import '../systemjs/system-core.js'
 import { transport } from './transport.ts'
 
-declare const __VPT_APP_CONFIG__: Record<string, unknown>
-
-/** Shares one App configuration object between the specialized bootstrap and App capsule. */
-export const appConfig = __VPT_APP_CONFIG__
-
 // WX has no modulepreload transport. Genuine application import() boundaries retain System.import() and may load
 // asynchronous subpackage or top-level-await graphs through this identity wrapper.
 export const __vitePreload = <Value>(load: () => Value): Value => load()

package/src/runtime/wx/capsule/app.ts

@@ -1,9 +1,12 @@
 // biome-ignore assist/source/organizeImports: Taro must initialize before the App component.
 import { createReactApp, ReactDOM } from './taro-runtime.ts'
 import React from 'react'
-import { appConfig } from '../amphibious/bootstrap.ts'
 
 // @ts-expect-error: The wx build resolves this private App component.
 import AppComponent from '\0vpt:app-component'
 
-export default createReactApp(AppComponent, React, ReactDOM, appConfig)
+declare const __VPT_APP_CONFIG__: Record<string, unknown>
+
+const config = createReactApp(AppComponent, React, ReactDOM, __VPT_APP_CONFIG__)
+
+export default config

package/src/runtime/wx/dev/dev-runtime.ts

@@ -5,7 +5,7 @@
 // The `DevRuntime` base class is injected into the chunk by Rolldown's dev-mode
 // transform, so the WX host only extends it.
 //
-// Every Page explicitly passes the inert hmr/patches.js export here before importing its capsule. The runtime applies that
+// Every Page explicitly passes the inert hmr/patches.js export here before native Page registration. The runtime applies that
 // cumulative suffix synchronously, reports its successful application frontier, and ignores sequences replayed by other Pages.
 
 import type { DevRuntime as RolldownDevRuntime } from 'rolldown/experimental/runtime-types'
@@ -54,54 +54,30 @@ type HmrUpdate = Readonly<{
 
 type AcceptCallback = (moduleExports: unknown) => void
 
-type PageSnapshot = Readonly<{
-    $taroPath: string
-    $taroParams: Record<string, unknown>
-    data: Record<string, unknown>
-}>
-
 type NativePage = {
-    $taroPath: string
-    $taroParams: Record<string, unknown>
     data: Record<string, unknown>
-    setData(data: Record<string, unknown>): void
+}
+
+const pageHmrStateKey: unique symbol = Symbol('vpt.pageHmrState')
+
+type PageHmrState = {
+    /** True only across the unload/load/show sequence triggered by one native re-registration. */
+    isReregistering: boolean
+    /** The Page bound to `this` by ordinary onLoad, retained until ordinary onUnload. */
+    mountedPage: NativePage | undefined
 }
 
 type HmrPageConfig = {
+    data: Record<string, unknown>
     onUnload?: unknown
     onLoad?: unknown
     onShow?: unknown
+    [pageHmrStateKey]?: PageHmrState
 }
 
-type TaroRoot = {
-    ctx: unknown
-}
-
-/** Immutable bridge references plus replacement transactions owned by one Taro singleton. */
-type TaroState = {
-    /** Taro's existing current-page source of truth; replacement onLoad switches its receiver. */
-    readonly current: { page: NativePage | null }
-    /** Taro's virtual document, used to find the retained root by its preserved unique path. */
-    readonly document: { getElementById(path: string): unknown }
-    /** Replaces Taro's native lifecycle receiver without remounting the retained React subtree. */
-    readonly injectPageInstance: (instance: unknown, path: string) => void
-    /**
-     * Short-lived route transactions. Absence means ordinary lifecycle; null means armed
-     * before onUnload or snapshot-consumed before onShow; a snapshot exists only between
-     * replacement onUnload and onLoad. The large data reference is therefore released in
-     * onLoad, while the null marker remains just long enough to suppress synthetic onShow.
-     */
-    readonly pageReplacements: Map<string, PageSnapshot | null>
-}
-
-/** Forwards a native lifecycle with its original Page receiver. */
-function forward(handler: unknown, receiver: unknown, args: unknown[]): void {
-    if (typeof handler === 'function') handler.apply(receiver, args)
-}
-
-/** Narrows the untyped element returned across the Taro connection boundary. */
-function isTaroRoot(value: unknown): value is TaroRoot {
-    return typeof value === 'object' && value !== null && 'ctx' in value
+/** Calls a native lifecycle with the same Page bound to `this` and the same arguments. */
+function forward(handler: unknown, page: unknown, args: unknown[]): void {
+    if (typeof handler === 'function') handler.apply(page, args)
 }
 
 /** Shared no-op CSS contract because physical rebuilds replace styles wholesale. */
@@ -285,109 +261,90 @@ class WxDevRuntime extends DevRuntime {
         this.session = { ...info, appliedSeq: 0 }
     }
 
-    /**
-     * One-shot bridge to the application's Taro singleton. It cannot be imported into this
-     * separately bundled global runtime without creating a second Taro identity. Undefined
-     * only before the serve-only facade connection; route transactions share its lifetime.
-     */
-    private taro: TaroState | undefined
-
-    /** Connects HMR to the same Taro singleton used by the application module graph. */
-    connectTaro(
-        current: TaroState['current'],
-        document: TaroState['document'],
-        injectPageInstance: TaroState['injectPageInstance']
-    ): void {
-        if (this.taro) {
-            return
-        }
+    /** Tracks the mounted native Page and prepares its static config for HMR re-registration. */
+    injectPageHmr(config: HmrPageConfig): HmrPageConfig {
+        const existingState = config[pageHmrStateKey]
+
+        if (existingState) {
+            const mountedPage = existingState.mountedPage
+            /*
+             * The static config can outlive a native Page instance. Before its first ordinary onLoad, or after a real onUnload,
+             * there is no mounted Page or current view-model to carry into another registration. Leave the lifecycle gate
+             * unarmed and preserve the config's existing initial data so a future real onLoad still enters Taro normally.
+             */
+            if (!mountedPage) {
+                return config
+            }
 
-        this.taro = {
-            current,
-            document,
-            injectPageInstance,
-            pageReplacements: new Map()
+            /*
+             * Arm the lifecycle wrappers on this exact static config before it is passed back to `Page(config)`. DevTools then
+             * triggers an unload/load/show sequence for that native re-registration: unload and load observe `true` and return
+             * before entering Taro, preserving the mounted React tree and its original Page connection; show consumes the
+             * one-shot gate by restoring `false`. Ordinary navigation never enters this branch, and every Page config owns an
+             * independent state object, so no route map, global phase, or Page identity comparison participates in the decision.
+             */
+            existingState.isReregistering = true
+            /*
+             * `Page(config)` reads `config.data` as the initial native view-model for this registration. Supplying the mounted
+             * Page's latest data before that call prevents the temporary Page used for re-registration callbacks from starting
+             * empty. This is an O(1) reference assignment in vpt: it does not clone the recursive data tree, call `setData`, move
+             * React state, or rebind Taro. The ordinary Taro lifecycle remains suppressed until re-registration onShow, so its
+             * React tree and output connection stay attached to `mountedPage`; every later registration reads its latest data.
+             */
+            config.data = mountedPage.data
+
+            return config
         }
-    }
 
-    /** Injects snapshot-preserving behavior into one route-specific Taro Page configuration. */
-    injectPageHmr(config: HmrPageConfig, route: string): void {
         const originalOnUnload = config.onUnload
         const originalOnLoad = config.onLoad
         const originalOnShow = config.onShow
-        const runtime = this
+
+        const state: PageHmrState = {
+            isReregistering: false,
+            mountedPage: undefined
+        }
+
+        /*
+         * Attach the one mutable HMR state object to this exact static config. The lifecycle wrappers below close over the same
+         * object, while a later `injectPageHmr(config)` call finds it through the symbol and knows wrapping is already complete.
+         * A symbol cannot collide with WeChat or Taro's string-named Page options, and config-local ownership avoids route maps,
+         * a runtime-wide WeakMap, or state shared by two Page configs. The state becomes unreachable together with the config.
+         */
+        config[pageHmrStateKey] = state
 
         config.onUnload = function (this: NativePage, ...args: unknown[]) {
-            const taro = runtime.requireTaro()
-            if (taro.pageReplacements.has(route)) {
-                taro.pageReplacements.set(route, {
-                    $taroPath: this.$taroPath,
-                    $taroParams: this.$taroParams,
-                    // WeChat owns this serializable view-model. Keeping its reference is O(1),
-                    // unlike cloning the complete recursive projection before every edit.
-                    data: this.data
-                })
+            if (state.isReregistering) {
                 return
             }
+
             forward(originalOnUnload, this, args)
+            state.mountedPage = undefined
         }
 
         config.onLoad = function (this: NativePage, ...args: unknown[]) {
-            const taro = runtime.requireTaro()
-            const snapshot = taro.pageReplacements.get(route)
-            if (snapshot) {
-                // Replace the transaction before native work so exceptions cannot retain the
-                // large data snapshot while the route waits for its synthetic onShow.
-                taro.pageReplacements.set(route, null)
-
-                // Snapshot paint is the first bridge operation and removes the empty-page gap.
-                this.setData(snapshot.data)
-                this.$taroPath = snapshot.$taroPath
-                this.$taroParams = snapshot.$taroParams
-                runtime.bindPage(this, snapshot.$taroPath)
+            if (state.isReregistering) {
                 return
             }
+
             forward(originalOnLoad, this, args)
+            state.mountedPage = this
         }
 
         config.onShow = function (this: NativePage, ...args: unknown[]) {
-            if (runtime.requireTaro().pageReplacements.delete(route)) {
-                // Synthetic shows must not repeat requests or reset application state.
+            if (state.isReregistering) {
+                state.isReregistering = false
                 return
             }
 
             forward(originalOnShow, this, args)
         }
-    }
-
-    /** Returns the Taro connection or fails at the first incorrectly ordered use. */
-    private requireTaro(): TaroState {
-        if (!this.taro) throw new Error('[vpt] WX HMR used before the Taro runtime was connected')
-        return this.taro
-    }
-
-    /** Returns a retained Taro root after normal Page mount has created it. */
-    private findRoot(path: string): TaroRoot | undefined {
-        const root = this.requireTaro().document.getElementById(path)
-        return isTaroRoot(root) ? root : undefined
-    }
-
-    /** Rebinds a retained Taro tree to one replacement native Page without repainting. */
-    private bindPage(instance: NativePage, path: string): void {
-        const taro = this.requireTaro()
-        taro.injectPageInstance(instance, path)
-        taro.current.page = instance
-
-        const pageElement = this.findRoot(path)
-        if (!pageElement) {
-            throw new Error(`[vpt] retained Taro page not found: ${path}`)
-        }
 
-        pageElement.ctx = instance
+        return config
     }
 
-    /** Applies one Page-delivered payload and arms its route for native replacement. */
-    applyPatches(payload: PatchPayload | undefined, route?: string): void {
+    /** Applies one Page-delivered payload before its native shell registers the static route configuration. */
+    applyPatches(payload: PatchPayload | undefined): void {
         // The initial physical dependency exports undefined until the host has a patch range.
         if (!payload) return
 
@@ -397,12 +354,6 @@ class WxDevRuntime extends DevRuntime {
             return
         }
 
-        // A replayed payload still causes DevTools to replace this physical Page. Arm the
-        // route independently of whether this App heap already applied its patch sequence.
-        if (route) {
-            this.requireTaro().pageReplacements.set(route, null)
-        }
-
         // Apply synchronously: the page's imports below the require resolve against the
         // freshly registered modules, so the re-executed Page evaluates with the new code.
         if (this.applyPatchBatch(session, payload.patches)) {

package/src/runtime/wx/wechat.d.ts

@@ -8,8 +8,7 @@ type WeChatGlobal = object
 /** The App-global Rolldown dev runtime; present only in wx development builds. */
 declare const __rolldown_runtime__:
     | {
-          connectTaro(current: object, document: object, injectPageInstance: (...args: unknown[]) => unknown): void
-          injectPageHmr(config: object, route: string): void
+          injectPageHmr(config: object): object
       }
     | undefined
 

package/dist/node/plugins/wx/dev/create-style-capture.d.ts

@@ -1,54 +0,0 @@
-import type { GetModuleInfo, Plugin } from 'rolldown';
-/** Final CSS extracted from Vite's transformed style module, before the shared WX compatibility pass. */
-type ProcessedStyle = Readonly<{
-    css: string;
-    /** Marks roots whose generated utilities must be refreshed when JavaScript changes Tailwind candidates. */
-    isTailwindRoot: boolean;
-}>;
-/** Minimal structural view of DevEngine output; style reconciliation does not own chunks or other asset metadata. */
-type CompleteOutputFile = Readonly<{
-    type: 'asset';
-    fileName: string;
-    source: string | Uint8Array;
-}> | Readonly<{
-    type: 'chunk';
-    fileName: string;
-}>;
-export type StyleCaptureAction = Readonly<{
-    kind: 'capture-graph';
-    getModuleInfo: GetModuleInfo;
-}> | Readonly<{
-    kind: 'capture-style';
-    id: string;
-    style: ProcessedStyle;
-}>;
-/**
- * Captures final Vite CSS and composes the graph projection with its durable WXSS publisher.
- *
- * Rolldown remains authoritative for topology. Plugin hooks emit typed actions so the host serializes capture mutations with
- * output and HMR publication; the projection and publisher below each own only one mutable concern.
- *
- * Complete-build path:
- *   final transform captures → DevEngine output write → graph reconciliation → App build rotation
- *
- * Incremental path:
- *   final transform captures → optional Tailwind root refresh → graph rendering → WXSS write → JavaScript patch publication
- *
- * Both paths render the same ordered App/Page graph projection. This prevents complete builds and HMR from implementing two
- * subtly different CSS ownership policies, while keeping physical byte equality and atomic writes out of graph state.
- */
-export declare function createStyleCapture({ applicationEntryIds, outDir, emit, transformTailwindRoot }: {
-    applicationEntryIds: readonly string[];
-    outDir: string;
-    emit: (action: StyleCaptureAction) => void;
-    transformTailwindRoot: (rootId: string, requestId: string) => Promise<Readonly<{
-        code: string;
-    }> | null>;
-}): Readonly<{
-    captureGraph: (reader: GetModuleInfo) => void;
-    captureStyle: (id: string, style: ProcessedStyle) => void;
-    plugin: Plugin;
-    publishChanged: (changedIds: readonly string[]) => Promise<void>;
-    reconcileComplete: (output: readonly CompleteOutputFile[]) => Promise<void>;
-}>;
-export {};

package/dist/node/plugins/wx/dev/create-style-capture.js

@@ -1,173 +0,0 @@
-import { isCSSRequest } from 'vite';
-import { normalizeModuleId } from '../../../utils/modules.js';
-import { transformWxStyle } from '../styles/transform-wx-style.js';
-import { composeGraphStyleCss, createGraphStylePlan, createTailwindSidecarId, extractViteCss, isGlobalStyleRequest } from '../styles/utils.js';
-import { globalWxssFileName, writeHmrFile } from './hmr-files.js';
-/**
- * Captures final Vite CSS and composes the graph projection with its durable WXSS publisher.
- *
- * Rolldown remains authoritative for topology. Plugin hooks emit typed actions so the host serializes capture mutations with
- * output and HMR publication; the projection and publisher below each own only one mutable concern.
- *
- * Complete-build path:
- *   final transform captures → DevEngine output write → graph reconciliation → App build rotation
- *
- * Incremental path:
- *   final transform captures → optional Tailwind root refresh → graph rendering → WXSS write → JavaScript patch publication
- *
- * Both paths render the same ordered App/Page graph projection. This prevents complete builds and HMR from implementing two
- * subtly different CSS ownership policies, while keeping physical byte equality and atomic writes out of graph state.
- */
-export function createStyleCapture({ applicationEntryIds, outDir, emit, transformTailwindRoot }) {
-    const projection = createStyleProjection({
-        applicationEntryIds: applicationEntryIds,
-        transformTailwindRoot: transformTailwindRoot
-    });
-    const publication = createStylePublication(outDir);
-    const plugin = {
-        name: 'vpt:wx-dev-style-capture',
-        buildStart() {
-            // Capture a live reader rather than a graph snapshot. Rolldown updates the capability as imports change, and a later
-            // complete generation replaces it through the host action queue before that generation can publish output.
-            emit({ kind: 'capture-graph', getModuleInfo: (moduleId) => this.getModuleInfo(moduleId) });
-        },
-        transform(code, id) {
-            if (!isGlobalStyleRequest(id)) {
-                return;
-            }
-            // This host plugin runs after Vite's CSS transform, so `code` is the JavaScript wrapper containing final PostCSS and
-            // CSS-Module output. Capturing source CSS instead would lose generated class names and framework transformations.
-            const css = extractViteCss(code, id);
-            emit({
-                kind: 'capture-style',
-                id: normalizeModuleId(id),
-                style: {
-                    css: css,
-                    isTailwindRoot: css.includes('weapp-tailwindcss vite-generated-css:')
-                }
-            });
-        }
-    };
-    return {
-        captureGraph: projection.captureGraph,
-        captureStyle: projection.captureStyle,
-        plugin: plugin,
-        async publishChanged(changedIds) {
-            // A CSS edit already carries updated processed bytes. Any non-CSS edit can alter both imports and Tailwind class
-            // candidates, so it requires a fresh graph plan and Tailwind-root generation even when no .css ID changed directly.
-            const styleChanged = changedIds.some(isGlobalStyleRequest);
-            const candidatesChanged = changedIds.some((id) => !isCSSRequest(id));
-            if (!styleChanged && !candidatesChanged) {
-                return;
-            }
-            await publication.publish(await projection.render(candidatesChanged));
-        },
-        async reconcileComplete(output) {
-            // Bundled development can omit CSS Modules from the compiler asset even with cssCodeSplit disabled. Observe the
-            // physical output first, then reconcile the same graph projection used by incremental HMR before App rotation.
-            publication.observeOutput(output);
-            await publication.publish(await projection.render(false));
-        }
-    };
-}
-/**
- * Owns the live graph capability and final transformed bytes for every observed style module.
- *
- * Rendering is O(V + E + C): graph planning visits each reachable module and edge once, then composition and WX conversion
- * process C CSS bytes once. The only persistent memory is one processed byte string per style identity observed by the server.
- */
-function createStyleProjection({ applicationEntryIds, transformTailwindRoot }) {
-    /*
-     * This mutable capability is rebound by buildStart for each complete generation. Rolldown keeps the function live across
-     * incremental graph edits, so rendering uses authoritative topology without maintaining a shadow graph.
-     */
-    let getModuleInfo;
-    /*
-     * This mutable projection stores final CSS bytes that Rolldown does not retain. Successful transforms replace one entry;
-     * unreachable entries can remain because every render filters them through the current graph plan. Its size is bounded by
-     * style module identities observed during this server lifecycle.
-     */
-    const processedStyles = new Map();
-    return {
-        captureGraph(reader) {
-            getModuleInfo = reader;
-        },
-        captureStyle(id, style) {
-            processedStyles.set(id, style);
-        },
-        async render(refreshTailwind) {
-            if (!getModuleInfo) {
-                throw new Error('WX style graph is unavailable before publication');
-            }
-            // App first and configured Pages afterward define one deterministic global cascade. The plan also removes stale map
-            // entries implicitly: styles no longer reachable from these roots never enter composition.
-            const styleIds = createGraphStylePlan(applicationEntryIds, getModuleInfo, (styleId) => processedStyles.has(styleId));
-            if (refreshTailwind) {
-                await refreshTailwindStyles(styleIds, processedStyles, transformTailwindRoot);
-            }
-            // Compose browser-facing transformed CSS first, then run one whole-file WX pass. Transforming modules independently
-            // would change cross-module cascade behavior and duplicate compatibility work.
-            const css = composeGraphStyleCss(styleIds, (styleId) => requireProcessedStyle(processedStyles, styleId).css);
-            return (await transformWxStyle(css)).css;
-        }
-    };
-}
-/**
- * Owns the physical WXSS frontier independently from graph capture and rendering.
- *
- * DevEngine writes complete output itself; incremental HMR does not. Observing complete output before publishing the projection
- * gives both writers one byte frontier, so equality avoids redundant filesystem notifications without pretending the host owns
- * the compiler's write transaction.
- */
-function createStylePublication(outDir) {
-    /*
-     * This mutable value mirrors bytes durable on disk. Complete output adopts the compiler's external write before graph
-     * reconciliation; host publication advances it only after an atomic write succeeds or byte equality proves none is needed.
-     */
-    let publishedWxss;
-    return {
-        observeOutput(output) {
-            // Missing WXSS means DevEngine intentionally reused the existing physical asset. Do not reset the frontier: doing so
-            // would force an identical rewrite and a spurious DevTools style event on every omitted complete generation.
-            const style = output.find((file) => file.type === 'asset' && file.fileName === globalWxssFileName);
-            if (style) {
-                publishedWxss = typeof style.source === 'string' ? style.source : new TextDecoder().decode(style.source);
-            }
-        },
-        async publish(wxss) {
-            if (wxss !== publishedWxss) {
-                // writeHmrFile uses atomic replacement; advance the frontier only after durability so a failed write leaves the
-                // last known physical generation available for the next reconciliation attempt.
-                await writeHmrFile(outDir, globalWxssFileName, wxss);
-            }
-            publishedWxss = wxss;
-        }
-    };
-}
-/**
- * Regenerates all reachable Tailwind roots and commits the cache only when every transform succeeds.
- *
- * Roots run concurrently because they are independent derivations of the same candidate generation. Results remain local until
- * Promise.all fulfills; one failed root therefore preserves every prior root together instead of publishing a mixed generation.
- */
-async function refreshTailwindStyles(styleIds, processedStyles, transformRoot) {
-    const roots = styleIds.filter((styleId) => requireProcessedStyle(processedStyles, styleId).isTailwindRoot);
-    const refreshedStyles = await Promise.all(roots.map(async (rootId) => {
-        const requestId = createTailwindSidecarId(rootId);
-        const result = await transformRoot(rootId, requestId);
-        if (!result) {
-            throw new Error(`Tailwind sidecar transform produced no result: ${requestId}`);
-        }
-        return [rootId, { css: extractViteCss(result.code, requestId), isTailwindRoot: true }];
-    }));
-    refreshedStyles.forEach(([rootId, style]) => {
-        processedStyles.set(rootId, style);
-    });
-}
-function requireProcessedStyle(processedStyles, styleId) {
-    const style = processedStyles.get(styleId);
-    if (!style) {
-        throw new Error(`WX style plan references uncaptured CSS: ${styleId}`);
-    }
-    return style;
-}

package/dist/node/plugins/wx/styles/transform-wx-style.d.ts

@@ -1,8 +0,0 @@
-export declare const wxStyleOptions: {
-    readonly cssCalc: false;
-    readonly autoprefixer: false;
-    readonly rem2rpx: true;
-    readonly px2rpx: true;
-};
-/** Shared finalization policy for complete builds and host-owned style HMR. */
-export declare const transformWxStyle: import("@weapp-tailwindcss/postcss").StyleHandler;

package/dist/node/plugins/wx/styles/transform-wx-style.js

@@ -1,9 +0,0 @@
-import { createStyleHandler } from '@weapp-tailwindcss/postcss';
-export const wxStyleOptions = {
-    cssCalc: false,
-    autoprefixer: false,
-    rem2rpx: true,
-    px2rpx: true
-};
-/** Shared finalization policy for complete builds and host-owned style HMR. */
-export const transformWxStyle = createStyleHandler(wxStyleOptions);