vite-plugin-taro 0.5.13 → 0.5.14

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,42 @@
+import type { GetModuleInfo, Plugin } from 'rolldown';
+type ProcessedStyle = Readonly<{
+    css: string;
+    isTailwindRoot: boolean;
+}>;
+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;
+}>;
+/**
+ * Owns capture hooks, the host's style projection, and its physical WXSS publication frontier.
+ *
+ * Rolldown remains authoritative for topology through its live graph reader. Plugin hooks emit typed actions so the host can
+ * serialize captures with every other effect; only the matching capture methods mutate this projection.
+ */
+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<{
+    bindOutput: (output: readonly CompleteOutputFile[]) => void;
+    captureGraph: (reader: GetModuleInfo) => void;
+    captureStyle: (id: string, style: ProcessedStyle) => void;
+    plugin: Plugin;
+    publishChanged: (changedIds: readonly string[]) => Promise<void>;
+}>;
+export {};

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

@@ -0,0 +1,125 @@
+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';
+/**
+ * Owns capture hooks, the host's style projection, and its physical WXSS publication frontier.
+ *
+ * Rolldown remains authoritative for topology through its live graph reader. Plugin hooks emit typed actions so the host can
+ * serialize captures with every other effect; only the matching capture methods mutate this projection.
+ */
+export function createStyleCapture({ applicationEntryIds, outDir, emit, transformTailwindRoot }) {
+    /*
+     * This mutable capability is rebound by buildStart for each complete generation. Rolldown keeps the captured function live
+     * across incremental graph edits, so HMR traverses authoritative current topology without maintaining a shadow graph. It is
+     * undefined only before the first buildStart; retaining an older reader across a later complete build would bind transactions
+     * to the wrong engine generation, while snapshotting module data would require O(V + E) mutation on every edit.
+     */
+    let getModuleInfo;
+    /*
+     * This mutable Map is the CSS projection Rolldown does not retain: successful final transform hooks replace one module's
+     * processed bytes, failed transforms intentionally leave its last valid generation, and a successful multi-root Tailwind
+     * refresh commits all replacements only after every sibling resolves. Entries are not deleted when topology changes because
+     * reachability comes from the live graph plan; eager deletion would need a duplicate reverse graph and could remove CSS still
+     * shared by another App/Page root. Its size is bounded by style module identities seen during this server lifecycle.
+     */
+    const processedStyles = new Map();
+    /*
+     * This mutable value mirrors the WXSS bytes currently durable on disk. It has one owner but two real transition sources:
+     *
+     * 1. DevEngine physically writes complete output before onOutput, so bindOutput only observes and adopts that external
+     *    commit. An omitted asset means DevEngine preserved the existing file and this value must remain unchanged.
+     * 2. Incremental HMR is physically written by this host, so publishChanged advances the value only after its atomic write
+     *    succeeds (or after byte equality proves no write was needed).
+     *
+     * Combining these operations behind one generic update event would still require branching between “observe an existing
+     * write” and “perform a new write”, while hiding their different durability boundaries. A genuine single path would require
+     * preventing DevEngine from writing complete WXSS and transferring that entire output responsibility to the host, adding
+     * asset interception and ordering machinery. The two explicit methods are therefore the smallest accurate state model.
+     */
+    let publishedWxss;
+    const plugin = {
+        name: 'vpt:wx-dev-style-capture',
+        buildStart() {
+            emit({ kind: 'capture-graph', getModuleInfo: (moduleId) => this.getModuleInfo(moduleId) });
+        },
+        transform(code, id) {
+            if (!isGlobalStyleRequest(id)) {
+                return;
+            }
+            const css = extractViteCss(code, id);
+            emit({
+                kind: 'capture-style',
+                id: normalizeModuleId(id),
+                style: {
+                    css: css,
+                    isTailwindRoot: css.includes('weapp-tailwindcss vite-generated-css:')
+                }
+            });
+        }
+    };
+    return {
+        bindOutput(output) {
+            /*
+             * Complete output is one of the two real physical writers. Its emitted asset is therefore the authoritative frontier
+             * when present; omission means DevEngine preserved the existing file and this state must remain unchanged.
+             */
+            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);
+            }
+        },
+        captureGraph(reader) {
+            getModuleInfo = reader;
+        },
+        captureStyle(id, style) {
+            processedStyles.set(id, style);
+        },
+        plugin: plugin,
+        async publishChanged(changedIds) {
+            const styleChanged = changedIds.some(isGlobalStyleRequest);
+            const candidatesChanged = changedIds.some((id) => !isCSSRequest(id));
+            if (!styleChanged && !candidatesChanged) {
+                return;
+            }
+            if (!getModuleInfo) {
+                throw new Error('WX style graph is unavailable before HMR publication');
+            }
+            // Traverse topology exactly once; root refresh and final rendering consume this immutable transaction plan.
+            const styleIds = createGraphStylePlan(applicationEntryIds, getModuleInfo, (styleId) => processedStyles.has(styleId));
+            if (candidatesChanged) {
+                await refreshTailwindStyles(styleIds, processedStyles, transformTailwindRoot);
+            }
+            const css = composeGraphStyleCss(styleIds, (styleId) => requireProcessedStyle(processedStyles, styleId).css);
+            const wxss = (await transformWxStyle(css)).css;
+            if (wxss !== publishedWxss) {
+                await writeHmrFile(outDir, globalWxssFileName, wxss);
+            }
+            // HMR is the second physical writer; advance the frontier only after its atomic write succeeds or was unnecessary.
+            publishedWxss = wxss;
+        }
+    };
+}
+/** Regenerates all reachable Tailwind roots and commits the cache only when every transform succeeds. */
+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>;