vite-plugin-taro 0.5.13 → 0.5.16

package/dist/node/plugins/client/client-taro.d.ts

@@ -1,4 +1,4 @@
-import type { Plugin } from 'vite';
+import { type Plugin } from 'vite';
 import type { VitePluginTaroTarget } from '../../../options.ts';
 /** Public facade used by transformed application API imports. */
 export declare const clientTaroApiId = "virtual:taro/api";

package/dist/node/plugins/client/client-taro.js

@@ -1,3 +1,4 @@
+import { normalizePath } from 'vite';
 import { normalizeModuleId } from '../../utils/modules.js';
 import { resolvePackageFile } from '../../utils/packages.js';
 import { clientTaroNativeId } from './constant.js';
@@ -17,7 +18,7 @@ import { injectTaroFrameworkApis } from './inject-taro-framework-apis.js';
 /** Public facade used by transformed application API imports. */
 export const clientTaroApiId = 'virtual:taro/api';
 const clientTaroApiPath = resolvePackageFile('dist/runtime/client/taro/api.js');
-const normalizedClientTaroApiPath = normalizeModuleId(clientTaroApiPath);
+const normalizedClientTaroApiPath = normalizePath(clientTaroApiPath);
 const clientTaroComponentId = 'virtual:taro/components';
 const clientTaroModules = new Map([
     [clientTaroApiId, clientTaroApiPath],

package/dist/node/plugins/h5/create-stencil-client-adapter.d.ts

@@ -1,4 +1,4 @@
-import type { Plugin } from 'vite';
+import { type Plugin } from 'vite';
 /**
  * Creates the compiler-owned adaptation of Stencil's client style insertion.
  *

package/dist/node/plugins/h5/create-stencil-client-adapter.js

@@ -1,10 +1,11 @@
+import { normalizePath } from 'vite';
 import { normalizeModuleId } from '../../utils/modules.js';
 import { transformWithOxcWalker } from '../../utils/oxc-transform.js';
 import { packageRequire } from '../../utils/packages.js';
 const stencilClientPath = packageRequire.resolve('@stencil/core/internal/client', {
     paths: [packageRequire.resolve('@tarojs/components/package.json')]
 });
-const normalizedStencilClientPath = normalizeModuleId(stencilClientPath);
+const normalizedStencilClientPath = normalizePath(stencilClientPath);
 /**
  * Creates the compiler-owned adaptation of Stencil's client style insertion.
  *

package/dist/node/plugins/h5/resolver/module-resolver.js

@@ -1,3 +1,4 @@
+import { normalizePath } from 'vite';
 import { normalizeModuleId, resolveAppComponentPath } from '../../../utils/modules.js';
 import { appComponentId } from '../../client/constant.js';
 import { h5AppPath } from '../constant.js';
@@ -11,7 +12,7 @@ export function createModuleResolver(options) {
             }
         },
         transform({ code, id, projectRoot, sourcemap = true }) {
-            if (normalizeModuleId(id) === normalizeModuleId(h5AppPath)) {
+            if (normalizeModuleId(id) === normalizePath(h5AppPath)) {
                 return transformH5App({ code, id, options, projectRoot, sourcemap });
             }
         }

package/dist/node/plugins/wx/dev/create-hmr-results-stream.d.ts

@@ -0,0 +1,23 @@
+import type { DevOptions } from 'rolldown/experimental';
+import { type SchedulerLike, Subject } from 'rxjs';
+type HmrUpdatesResult = Parameters<NonNullable<DevOptions['onHmrUpdates']>>[0];
+type HmrUpdates = Exclude<HmrUpdatesResult, Error>;
+/**
+ * Adapts Rolldown's non-awaited HMR callback into lossless quiet-window publications.
+ *
+ * Debouncing the result stream itself would retain only the final callback and lose incremental patch factories that later
+ * patches provably do not reproduce. Instead, the debounced view is only a closing notifier for `buffer`: every callback is
+ * retained in arrival order, and one configured quiet period emits the complete window to the host's existing serialized
+ * writer. This first stream migration deliberately does not own physical state; `publish` and `reportError` remain synchronous
+ * admission callbacks so the dev host can enqueue both through its single writer.
+ *
+ * DevEngine failures are values, not Observable errors. They represent transient editor generations and carry no executable
+ * patch, so the stream reports the final error but otherwise removes them. Successful callbacks on either side remain ordered
+ * and lossless; Rolldown generated each against its unpublished client frontier, and the host delivers every retained payload.
+ * Completing the returned Subject flushes its current buffer synchronously, allowing host shutdown to await the resulting
+ * serialized task rather than silently dropping an admitted patch.
+ *
+ * Complexity is O(updates + changed files) per emitted window, with one retained reference per callback until the quiet edge.
+ */
+export declare function createHmrResultsStream(settleMilliseconds: number, scheduler: SchedulerLike, publish: (result: HmrUpdates) => void, reportError: (error: Error) => void): Subject<HmrUpdatesResult>;
+export {};

package/dist/node/plugins/wx/dev/create-hmr-results-stream.js

@@ -0,0 +1,57 @@
+import { buffer, debounceTime, filter, Subject } from 'rxjs';
+/**
+ * Adapts Rolldown's non-awaited HMR callback into lossless quiet-window publications.
+ *
+ * Debouncing the result stream itself would retain only the final callback and lose incremental patch factories that later
+ * patches provably do not reproduce. Instead, the debounced view is only a closing notifier for `buffer`: every callback is
+ * retained in arrival order, and one configured quiet period emits the complete window to the host's existing serialized
+ * writer. This first stream migration deliberately does not own physical state; `publish` and `reportError` remain synchronous
+ * admission callbacks so the dev host can enqueue both through its single writer.
+ *
+ * DevEngine failures are values, not Observable errors. They represent transient editor generations and carry no executable
+ * patch, so the stream reports the final error but otherwise removes them. Successful callbacks on either side remain ordered
+ * and lossless; Rolldown generated each against its unpublished client frontier, and the host delivers every retained payload.
+ * Completing the returned Subject flushes its current buffer synchronously, allowing host shutdown to await the resulting
+ * serialized task rather than silently dropping an admitted patch.
+ *
+ * Complexity is O(updates + changed files) per emitted window, with one retained reference per callback until the quiet edge.
+ */
+export function createHmrResultsStream(settleMilliseconds, scheduler, publish, reportError) {
+    /*
+     * This hot Subject is the sole mutable boundary between Rolldown's non-awaited callback and RxJS. Each next preserves one
+     * compiler generation by reference and in arrival order. buffer owns the temporary lossless window; debounceTime observes the
+     * same Subject only to decide when that window closes. Replacing this with a debounced scalar would discard patch factories,
+     * while letting callback Promises mutate host state directly would overlap publications. Completion flushes the final window
+     * before shutdown, after which the Subject is never reused.
+     */
+    const results = new Subject();
+    results
+        .pipe(buffer(results.pipe(debounceTime(settleMilliseconds, scheduler))), filter((window) => window.length > 0))
+        .subscribe((window) => {
+        /*
+         * An Error is one source generation that produced no executable delta; it does not invalidate successful Rolldown
+         * callbacks already admitted on either side of it. Dropping the whole quiet window would therefore discard real
+         * patch factories, while starting a complete build would compile the same known-invalid editor contents. Keep the
+         * old runtime running, report only the latest diagnostic from a repeated parser burst, and continue below with the
+         * successful callback values exactly as if the temporary invalid save had never produced an HMR payload.
+         */
+        const lastFailure = window.findLast((result) => result instanceof Error);
+        if (lastFailure) {
+            reportError(lastFailure);
+        }
+        const successfulWindow = window.filter((result) => !(result instanceof Error));
+        if (successfulWindow.length > 0) {
+            /*
+             * flatMap preserves callback arrival order and each callback's internal Rolldown order. Updates must not be
+             * deduplicated: later undelivered patches are deltas and do not reproduce factories from earlier sequences.
+             * changedFiles is opaque DevEngine metadata and has no identity semantics in the host, so preserving its raw
+             * concatenation is both cheaper and more faithful than maintaining a second Set-based interpretation here.
+             */
+            publish({
+                updates: successfulWindow.flatMap((result) => result.updates),
+                changedFiles: successfulWindow.flatMap((result) => result.changedFiles)
+            });
+        }
+    });
+    return results;
+}

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

@@ -0,0 +1,54 @@
+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

@@ -0,0 +1,173 @@
+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/dev/dev-host.d.ts

@@ -1,4 +1,4 @@
-import { type ViteDevServer } from 'vite';
+import type { ViteDevServer } from 'vite';
 import type { VitePluginTaroOptions } from '../../../../options.ts';
 export type WxDevHost = Readonly<{
     close: () => Promise<void>;