vite-plugin-taro 0.6.2 → 0.6.5

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;
-}

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

@@ -1,248 +0,0 @@
-import type { GetModuleInfo, Plugin } from 'rolldown'
-import { isCSSRequest } from 'vite'
-import { normalizeModuleId } from '../../../utils/modules.ts'
-import { transformWxStyle } from '../styles/transform-wx-style.ts'
-import {
-    composeGraphStyleCss,
-    createGraphStylePlan,
-    createTailwindSidecarId,
-    extractViteCss,
-    isGlobalStyleRequest
-} from '../styles/utils.ts'
-import { globalWxssFileName, writeHmrFile } from './hmr-files.ts'
-
-/** 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 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>
-}> {
-    const projection = createStyleProjection({
-        applicationEntryIds: applicationEntryIds,
-        transformTailwindRoot: transformTailwindRoot
-    })
-    const publication = createStylePublication(outDir)
-
-    const plugin: 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
-}: {
-    applicationEntryIds: readonly string[]
-    transformTailwindRoot: (rootId: string, requestId: string) => Promise<Readonly<{ code: string }> | null>
-}): Readonly<{
-    captureGraph: (reader: GetModuleInfo) => void
-    captureStyle: (id: string, style: ProcessedStyle) => void
-    render: (refreshTailwind: boolean) => Promise<string>
-}> {
-    /*
-     * 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: GetModuleInfo | undefined
-    /*
-     * 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<string, ProcessedStyle>()
-
-    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: string): Readonly<{
-    observeOutput: (output: readonly CompleteOutputFile[]) => void
-    publish: (wxss: string) => Promise<void>
-}> {
-    /*
-     * 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: string | undefined
-
-    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 is Extract<CompleteOutputFile, { type: 'asset' }> =>
-                    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: readonly string[],
-    processedStyles: Map<string, ProcessedStyle>,
-    transformRoot: (rootId: string, requestId: string) => Promise<Readonly<{ code: string }> | null>
-): Promise<void> {
-    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 }] as const
-        })
-    )
-    refreshedStyles.forEach(([rootId, style]) => {
-        processedStyles.set(rootId, style)
-    })
-}
-
-function requireProcessedStyle(processedStyles: ReadonlyMap<string, ProcessedStyle>, styleId: string): ProcessedStyle {
-    const style = processedStyles.get(styleId)
-    if (!style) {
-        throw new Error(`WX style plan references uncaptured CSS: ${styleId}`)
-    }
-    return style
-}

package/src/node/plugins/wx/styles/transform-wx-style.ts

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

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

@@ -1,119 +0,0 @@
-import { isCSSRequest } from 'vite'
-import { normalizeModuleId } from '../../../utils/modules.ts'
-
-const nonRuntimeStyleQueries = ['direct', 'inline', 'inline-css', 'raw', 'style-attr', 'transform-only', 'url'] as const
-
-/**
- * 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: string): string {
-    return `${rootId}?weapp-vite-sidecar=style`
-}
-
-/** Selects imported style modules whose Vite development output owns a runtime CSS payload. */
-export function isGlobalStyleRequest(id: string): boolean {
-    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: readonly string[],
-    getModuleInfo: (
-        moduleId: string
-    ) => Readonly<{ importedIds: readonly string[]; dynamicallyImportedIds: readonly string[] }> | null,
-    hasStyle: (styleId: string) => boolean
-): readonly string[] {
-    // These local collections collapse cycles, shared modules, and aliases without retaining derived topology between batches.
-    const visitedModuleIds = new Set<string>()
-    const visitedStyleIds = new Set<string>()
-    const styleIds: string[] = []
-
-    const visit = (moduleId: string): void => {
-        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: readonly string[], getStyleCss: (styleId: string) => string): string {
-    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: string, rootId: string): string {
-    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: unknown = JSON.parse(serializedCss)
-    if (typeof css !== 'string') {
-        throw new Error(`Vite CSS transform for ${rootId} exposed a non-string __vite__css value`)
-    }
-
-    return css
-}