vite-plugin-taro 0.6.3 → 0.6.6

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/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);

package/dist/node/plugins/wx/styles/utils.d.ts

@@ -1,39 +0,0 @@
-/**
- * Creates an auxiliary style request without replacing the physical Rolldown graph module.
- *
- * `weapp-vite-sidecar` is an upstream protocol marker, not a cache-busting nonce. `weapp-tailwindcss` detects the query
- * key, strips the complete query when resolving the physical CSS pipeline file, and excludes this synthetic request from
- * transformed-source candidate collection. That lets the request use the latest candidate state without feeding generated
- * CSS back into Tailwind's source memory. The descriptive `style` value is stable; upstream treats the presence of the key
- * as the protocol contract.
- */
-export declare function createTailwindSidecarId(rootId: string): string;
-/** Selects imported style modules whose Vite development output owns a runtime CSS payload. */
-export declare function isGlobalStyleRequest(id: string): boolean;
-/**
- * Creates the ordered style plan for one completed HMR transaction.
- *
- * `entryIds` carries semantic cascade ownership from the WX resolver: the App capsule first, followed by Page capsules in
- * configured route order. Each entry is traversed depth-first. Static imports retain source order and precede dynamic imports;
- * dynamic branches are included because WX cannot inject lazy CSS at browser runtime. A style follows its dependencies,
- * matching evaluation order.
- *
- * Graph IDs may contain queries while `hasStyle` reads physical IDs. Normalization lets aliases share one captured style.
- * JavaScript and non-runtime CSS requests remain traversal nodes but do not enter the plan. All mutable traversal state is
- * transaction-local, so import additions and removals need no invalidation bookkeeping. Complexity is O(modules + edges),
- * with O(modules + styles) temporary memory.
- */
-export declare function createGraphStylePlan(entryIds: readonly string[], getModuleInfo: (moduleId: string) => Readonly<{
-    importedIds: readonly string[];
-    dynamicallyImportedIds: readonly string[];
-}> | null, hasStyle: (styleId: string) => boolean): readonly string[];
-/** Renders one immutable graph plan after any Tailwind roots in that same plan have been refreshed. */
-export declare function composeGraphStyleCss(styleIds: readonly string[], getStyleCss: (styleId: string) => string): string;
-/**
- * Extracts Vite's final CSS payload from the development module without evaluating its browser HMR code.
- *
- * Remove this parser when either Vite exposes a supported plugin-container API that returns final CSS directly, or
- * `weapp-tailwindcss` exposes generated root CSS after candidate updates. Until then the sidecar receives Vite's JavaScript
- * style module, so this function isolates the version-specific `__vite__css` serialization contract.
- */
-export declare function extractViteCss(moduleCode: string, rootId: string): string;

package/dist/node/plugins/wx/styles/utils.js

@@ -1,95 +0,0 @@
-import { isCSSRequest } from 'vite';
-import { normalizeModuleId } from '../../../utils/modules.js';
-const nonRuntimeStyleQueries = ['direct', 'inline', 'inline-css', 'raw', 'style-attr', 'transform-only', 'url'];
-/**
- * Creates an auxiliary style request without replacing the physical Rolldown graph module.
- *
- * `weapp-vite-sidecar` is an upstream protocol marker, not a cache-busting nonce. `weapp-tailwindcss` detects the query
- * key, strips the complete query when resolving the physical CSS pipeline file, and excludes this synthetic request from
- * transformed-source candidate collection. That lets the request use the latest candidate state without feeding generated
- * CSS back into Tailwind's source memory. The descriptive `style` value is stable; upstream treats the presence of the key
- * as the protocol contract.
- */
-export function createTailwindSidecarId(rootId) {
-    return `${rootId}?weapp-vite-sidecar=style`;
-}
-/** Selects imported style modules whose Vite development output owns a runtime CSS payload. */
-export function isGlobalStyleRequest(id) {
-    if (!isCSSRequest(id)) {
-        return false;
-    }
-    const queryStart = id.indexOf('?');
-    if (queryStart < 0) {
-        return true;
-    }
-    const fragmentStart = id.indexOf('#', queryStart);
-    const query = id.slice(queryStart + 1, fragmentStart < 0 ? undefined : fragmentStart);
-    const parameters = new URLSearchParams(query);
-    return (!parameters.has('weapp-vite-sidecar') && nonRuntimeStyleQueries.every((parameter) => !parameters.has(parameter)));
-}
-/**
- * Creates the ordered style plan for one completed HMR transaction.
- *
- * `entryIds` carries semantic cascade ownership from the WX resolver: the App capsule first, followed by Page capsules in
- * configured route order. Each entry is traversed depth-first. Static imports retain source order and precede dynamic imports;
- * dynamic branches are included because WX cannot inject lazy CSS at browser runtime. A style follows its dependencies,
- * matching evaluation order.
- *
- * Graph IDs may contain queries while `hasStyle` reads physical IDs. Normalization lets aliases share one captured style.
- * JavaScript and non-runtime CSS requests remain traversal nodes but do not enter the plan. All mutable traversal state is
- * transaction-local, so import additions and removals need no invalidation bookkeeping. Complexity is O(modules + edges),
- * with O(modules + styles) temporary memory.
- */
-export function createGraphStylePlan(entryIds, getModuleInfo, hasStyle) {
-    // These local collections collapse cycles, shared modules, and aliases without retaining derived topology between batches.
-    const visitedModuleIds = new Set();
-    const visitedStyleIds = new Set();
-    const styleIds = [];
-    const visit = (moduleId) => {
-        if (visitedModuleIds.has(moduleId)) {
-            return;
-        }
-        visitedModuleIds.add(moduleId);
-        const moduleInfo = getModuleInfo(moduleId);
-        if (!moduleInfo) {
-            return;
-        }
-        moduleInfo.importedIds.forEach(visit);
-        moduleInfo.dynamicallyImportedIds.forEach(visit);
-        const styleId = normalizeModuleId(moduleId);
-        if (hasStyle(styleId) && !visitedStyleIds.has(styleId)) {
-            visitedStyleIds.add(styleId);
-            styleIds.push(styleId);
-        }
-    };
-    entryIds.forEach(visit);
-    return styleIds;
-}
-/** Renders one immutable graph plan after any Tailwind roots in that same plan have been refreshed. */
-export function composeGraphStyleCss(styleIds, getStyleCss) {
-    return styleIds.map(getStyleCss).join('\n');
-}
-/**
- * Extracts Vite's final CSS payload from the development module without evaluating its browser HMR code.
- *
- * Remove this parser when either Vite exposes a supported plugin-container API that returns final CSS directly, or
- * `weapp-tailwindcss` exposes generated root CSS after candidate updates. Until then the sidecar receives Vite's JavaScript
- * style module, so this function isolates the version-specific `__vite__css` serialization contract.
- */
-export function extractViteCss(moduleCode, rootId) {
-    const assignmentPrefix = 'const __vite__css = ';
-    const assignmentStart = moduleCode.indexOf(assignmentPrefix);
-    if (assignmentStart < 0) {
-        throw new Error(`Vite CSS transform for ${rootId} did not expose __vite__css`);
-    }
-    // Vite serializes the payload with JSON.stringify on one assignment line. Parse that literal so quotes, escapes, and
-    // embedded CSS newlines are decoded by JSON rather than by a second, subtly different unescaping implementation.
-    const valueStart = assignmentStart + assignmentPrefix.length;
-    const lineEnd = moduleCode.indexOf('\n', valueStart);
-    const serializedCss = moduleCode.slice(valueStart, lineEnd < 0 ? moduleCode.length : lineEnd);
-    const css = JSON.parse(serializedCss);
-    if (typeof css !== 'string') {
-        throw new Error(`Vite CSS transform for ${rootId} exposed a non-string __vite__css value`);
-    }
-    return css;
-}