vite-plugin-taro 0.5.13 → 0.5.16

package/dist/node/utils/serialized-task-queue.js

@@ -1,25 +0,0 @@
-/** Runs asynchronous tasks in insertion order without letting one failure block later work. */
-export class SerializedTaskQueue {
-    /** Mutable promise tail confines ordering state to this queue. */
-    tail = Promise.resolve();
-    reportError;
-    constructor(reportError) {
-        this.reportError = reportError;
-    }
-    /** Schedules a background task and reports its failure. */
-    enqueue(operation, task) {
-        void this.run(task).catch((error) => {
-            this.reportError(operation, error);
-        });
-    }
-    /** Schedules a task whose result and failure belong to the caller. */
-    run(task) {
-        const result = this.tail.then(task);
-        this.tail = result.then(() => undefined, () => undefined);
-        return result;
-    }
-    /** Waits for every task that was queued when this method was called. */
-    async waitForIdle() {
-        await this.tail;
-    }
-}

package/src/node/plugins/wx/dev/create-wx-dev-mode.ts

@@ -1,14 +0,0 @@
-import type { InputOptions } from 'rolldown'
-
-type DevMode = NonNullable<NonNullable<InputOptions['experimental']>['devMode']>
-type DevModeOptions = Exclude<DevMode, boolean>
-
-/** Installs the custom WX runtime while restoring Rolldown's common runtime base. */
-export function createWxDevMode(devMode: DevMode | undefined, implement: string): DevModeOptions {
-    return {
-        ...(typeof devMode === 'object' ? devMode : {}),
-        implement,
-        lazy: false,
-        skipCommonRuntimeInjection: false
-    }
-}

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

@@ -1,34 +0,0 @@
-import type { GetModuleInfo, Plugin } from 'rolldown'
-import { normalizeModuleId } from '../../../../utils/modules.ts'
-import { extractViteCss, isGlobalStyleRequest } from '../../styles/utils.ts'
-
-export type ProcessedStyle = Readonly<{
-    css: string
-    isTailwindRoot: boolean
-}>
-
-type StyleCaptureOptions = Readonly<{
-    captureGraph: (getModuleInfo: GetModuleInfo) => void
-    captureStyle: (id: string, style: ProcessedStyle) => void
-}>
-
-/** Captures Vite's final development CSS and Rolldown's live graph without running the style pipeline twice. */
-export function createStyleCapturePlugin({ captureGraph, captureStyle }: StyleCaptureOptions): Plugin {
-    return {
-        name: 'vpt:wx-dev-style-capture',
-        buildStart() {
-            captureGraph((moduleId) => this.getModuleInfo(moduleId))
-        },
-        transform(code, id) {
-            if (!isGlobalStyleRequest(id)) {
-                return
-            }
-
-            const css = extractViteCss(code, id)
-            captureStyle(normalizeModuleId(id), {
-                css: css,
-                isTailwindRoot: css.includes('weapp-tailwindcss vite-generated-css:')
-            })
-        }
-    }
-}

package/src/node/plugins/wx/dev/styles/publish-style-hmr.ts

@@ -1,71 +0,0 @@
-import { transformWxStyle } from '../../styles/transform-wx-style.ts'
-import { composeGraphStyleCss, createTailwindSidecarId, extractViteCss } from '../../styles/utils.ts'
-import { writeHmrFile } from '../hmr-files.ts'
-import type { ProcessedStyle } from './create-style-capture-plugin.ts'
-
-export const globalWxssFileName = 'assets/global.wxss'
-
-type StyleHmrOptions = Readonly<{
-    styleIds: readonly string[]
-    outDir: string
-    processedStyles: ReadonlyMap<string, ProcessedStyle>
-    publishedWxss: string | undefined
-}>
-
-/** Regenerates reachable Tailwind roots concurrently from upstream's current candidate state. */
-export 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
-        })
-    )
-    // Commit the cache generation only after every independent root succeeds; a failed sibling cannot leave a mixed snapshot.
-    refreshedStyles.forEach(([rootId, style]) => {
-        processedStyles.set(rootId, style)
-    })
-}
-
-/**
- * Materializes one host-owned style snapshot for a completed HMR transaction.
- *
- * Rolldown owns topology but does not retain Vite's final CSS module payload, while `processedStyles` owns those payloads but
- * deliberately retains no topology. The caller supplies the transaction's one ordered graph plan; both Tailwind refresh and
- * this renderer consume that same snapshot, so sidecar generation cannot cause a second topology traversal.
- *
- * Ordinary CSS is never transformed again here: capture already observed it after Vite/PostCSS. The composed stylesheet alone
- * receives the same final WX conversion as complete builds. Byte equality with the host's physical publication frontier skips
- * an atomic rename that would otherwise notify DevTools despite no style change. The returned bytes advance that frontier only
- * after any required write succeeds. The caller awaits this before exposing the corresponding JavaScript patch.
- * Complexity is O(styles + CSS bytes), after the caller's O(V + E) plan traversal.
- */
-export async function publishStyleHmr({
-    styleIds,
-    outDir,
-    processedStyles,
-    publishedWxss
-}: StyleHmrOptions): Promise<string> {
-    const css = composeGraphStyleCss(styleIds, (styleId) => requireProcessedStyle(processedStyles, styleId).css)
-    const wxss = (await transformWxStyle(css)).css
-    if (wxss !== publishedWxss) {
-        await writeHmrFile(outDir, globalWxssFileName, wxss)
-    }
-    return wxss
-}
-
-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/utils/serialized-task-queue.ts

@@ -1,32 +0,0 @@
-/** Runs asynchronous tasks in insertion order without letting one failure block later work. */
-export class SerializedTaskQueue {
-    /** Mutable promise tail confines ordering state to this queue. */
-    private tail: Promise<void> = Promise.resolve()
-    private readonly reportError: (operation: string, error: unknown) => void
-
-    constructor(reportError: (operation: string, error: unknown) => void) {
-        this.reportError = reportError
-    }
-
-    /** Schedules a background task and reports its failure. */
-    enqueue(operation: string, task: () => void | PromiseLike<void>): void {
-        void this.run(task).catch((error) => {
-            this.reportError(operation, error)
-        })
-    }
-
-    /** Schedules a task whose result and failure belong to the caller. */
-    run<Result>(task: () => Result | PromiseLike<Result>): Promise<Result> {
-        const result = this.tail.then(task)
-        this.tail = result.then(
-            () => undefined,
-            () => undefined
-        )
-        return result
-    }
-
-    /** Waits for every task that was queued when this method was called. */
-    async waitForIdle(): Promise<void> {
-        await this.tail
-    }
-}