vite-plugin-taro 0.3.2 → 0.4.0

package/dist/runtime/wx/update-client-state.d.ts

@@ -1,68 +0,0 @@
-/**
- * Pure App-side stop-and-wait protocol state machine.
- *
- * It knows build versions and sequencing only; wx.request, literal code execution, and page lifecycle effects live in
- * update-client.ts and page-update.ts.
- */
-type WxUpdateClientPhase = 'stopped' | 'registering' | 'polling' | 'applying' | 'refreshing' | 'relaunching';
-type WxUpdateClientState = {
-    buildId: string;
-    version: number;
-    phase: WxUpdateClientPhase;
-    targetVersion?: number;
-    pendingBatch?: {
-        fromVersion: number;
-        targetVersion: number;
-    };
-};
-export type WxUpdateClientEvent = {
-    type: 'started';
-} | {
-    type: 'registration-completed';
-} | {
-    type: 'poll-completed';
-} | {
-    type: 'batch-observed';
-    buildId: string;
-    fromVersion: number;
-    targetVersion: number;
-} | {
-    type: 'batch-executed';
-    targetVersion: number;
-} | {
-    type: 'batch-failed';
-} | {
-    type: 'refresh-completed';
-    stale: boolean;
-} | {
-    type: 'route-ready';
-} | {
-    type: 'transport-failed';
-};
-export type WxUpdateClientCommand = {
-    type: 'register';
-    version: number;
-} | {
-    type: 'poll';
-    version: number;
-} | {
-    type: 'apply-batch';
-    fromVersion: number;
-    targetVersion: number;
-} | {
-    type: 'report-version';
-    version: number;
-    reason: 'applied' | 'batch-mismatch';
-} | {
-    type: 'request-full-build';
-    reason: 'batch-execution-failed';
-} | {
-    type: 'retry-transport';
-};
-type WxUpdateClientTransition = {
-    state: WxUpdateClientState;
-    commands: WxUpdateClientCommand[];
-};
-export declare function createWxUpdateClientState(buildId: string): WxUpdateClientState;
-export declare function transitionWxUpdateClient(state: WxUpdateClientState, event: WxUpdateClientEvent): WxUpdateClientTransition;
-export {};

package/dist/runtime/wx/update-client-state.js

@@ -1,84 +0,0 @@
-export function createWxUpdateClientState(buildId) {
-    return { buildId, version: 0, phase: 'stopped' };
-}
-export function transitionWxUpdateClient(state, event) {
-    switch (event.type) {
-        case 'started':
-            if (state.phase !== 'stopped')
-                return transition(state);
-            return command({ ...state, phase: 'registering' }, { type: 'register', version: state.version });
-        case 'registration-completed': {
-            if (state.phase !== 'registering')
-                return transition(state);
-            const pending = state.pendingBatch;
-            if (!pending)
-                return command({ ...state, phase: 'polling' }, { type: 'poll', version: state.version });
-            return command({ ...state, phase: 'applying', targetVersion: pending.targetVersion, pendingBatch: undefined }, { type: 'apply-batch', ...pending });
-        }
-        case 'poll-completed':
-            if (state.phase !== 'polling')
-                return transition(state);
-            return command(state, { type: 'poll', version: state.version });
-        case 'batch-observed':
-            return observeBatch(state, event);
-        case 'batch-executed':
-            if (state.phase !== 'applying' || state.targetVersion !== event.targetVersion) {
-                return command(state, { type: 'report-version', version: state.version, reason: 'batch-mismatch' });
-            }
-            return transition({ ...state, phase: 'refreshing', version: event.targetVersion });
-        case 'batch-failed':
-            return command({ ...state, phase: 'polling', targetVersion: undefined }, { type: 'request-full-build', reason: 'batch-execution-failed' });
-        case 'refresh-completed':
-            if (state.phase !== 'refreshing')
-                return transition(state);
-            if (event.stale)
-                return transition({ ...state, phase: 'relaunching' });
-            return applied(state);
-        case 'route-ready':
-            if (state.phase !== 'relaunching')
-                return transition(state);
-            return applied(state);
-        case 'transport-failed':
-            return command(state, { type: 'retry-transport' });
-    }
-}
-function observeBatch(state, batch) {
-    const valid = batch.buildId === state.buildId &&
-        Number.isInteger(batch.fromVersion) &&
-        Number.isInteger(batch.targetVersion) &&
-        batch.fromVersion >= 0 &&
-        batch.targetVersion > batch.fromVersion;
-    if (state.phase === 'registering') {
-        if (!valid || batch.fromVersion !== state.version || batch.targetVersion <= state.version) {
-            return transition(state);
-        }
-        return transition({
-            ...state,
-            pendingBatch: { fromVersion: batch.fromVersion, targetVersion: batch.targetVersion }
-        });
-    }
-    if (!valid) {
-        return command(state, { type: 'report-version', version: state.version, reason: 'batch-mismatch' });
-    }
-    if (batch.targetVersion <= state.version) {
-        return command(state, { type: 'report-version', version: state.version, reason: 'applied' });
-    }
-    if (state.phase !== 'polling' || batch.fromVersion !== state.version) {
-        return command(state, { type: 'report-version', version: state.version, reason: 'batch-mismatch' });
-    }
-    return command({ ...state, phase: 'applying', targetVersion: batch.targetVersion }, {
-        type: 'apply-batch',
-        fromVersion: batch.fromVersion,
-        targetVersion: batch.targetVersion
-    });
-}
-function applied(state) {
-    const appliedState = { ...state, phase: 'polling', targetVersion: undefined };
-    return command(appliedState, { type: 'report-version', version: state.version, reason: 'applied' });
-}
-function transition(state) {
-    return { state, commands: [] };
-}
-function command(state, value) {
-    return { state, commands: [value] };
-}

package/dist/runtime/wx/update-client.d.ts

@@ -1 +0,0 @@
-export declare function startWxUpdateClient(): void;

package/dist/runtime/wx/update-client.js

@@ -1,171 +0,0 @@
-/**
- * App-owned adapter for the WX update protocol.
- *
- * It transports metadata with wx.request and executes literal batches delivered through update.js. React/Taro page
- * preservation is delegated to page-update.ts so the App never depends on the mutable update file.
- */
-import { createWxUpdateClientState, transitionWxUpdateClient } from './update-client-state.js';
-const wxClientGlobal = globalThis;
-const transportRetryDelay = 500;
-const rebuildPollDelay = 1_000;
-const updateFileWatchdogDelay = 2_000;
-export function startWxUpdateClient() {
-    if (wxClientGlobal.__VITE_PLUGIN_TARO_WX_UPDATE_CLIENT__)
-        return;
-    const control = wxClientGlobal.__VITE_PLUGIN_TARO_WX_CONTROL__;
-    if (!control)
-        throw new Error('vite-plugin-taro could not find its WX update control configuration.');
-    let state = createWxUpdateClientState(control.buildId);
-    const sessionId = createSessionId();
-    let requestGeneration = 0;
-    let activeRequest;
-    let scheduledRequest;
-    let pendingBatchApply;
-    const dispatch = (event, apply) => {
-        const transition = transitionWxUpdateClient(state, event);
-        state = transition.state;
-        for (const command of transition.commands)
-            execute(command, apply);
-    };
-    const send = (action, version) => {
-        if (scheduledRequest)
-            clearTimeout(scheduledRequest);
-        scheduledRequest = undefined;
-        activeRequest?.abort();
-        const generation = ++requestGeneration;
-        activeRequest = wxClientGlobal.wx.request({
-            url: control.url,
-            method: 'POST',
-            data: {
-                token: control.token,
-                action,
-                buildId: state.buildId,
-                sessionId,
-                version
-            },
-            timeout: 30_000,
-            success(result) {
-                if (generation !== requestGeneration)
-                    return;
-                activeRequest = undefined;
-                const response = parseResponse(result.data);
-                if (action === 'register' && response.type === 'registered') {
-                    dispatch({ type: 'registration-completed' });
-                    return;
-                }
-                if (action === 'poll' && (response.type === 'idle' || response.type === 'changed')) {
-                    dispatch({ type: 'poll-completed' });
-                    return;
-                }
-                if (response.type === 'batch-published') {
-                    // If DevTools misses the update.js event, report the unchanged version and republish with a new nonce.
-                    scheduleRequest(updateFileWatchdogDelay);
-                    return;
-                }
-                if (response.type === 'rebuilding') {
-                    scheduleRequest(rebuildPollDelay);
-                    return;
-                }
-                dispatch({ type: 'transport-failed' });
-            },
-            fail() {
-                if (generation !== requestGeneration)
-                    return;
-                activeRequest = undefined;
-                dispatch({ type: 'transport-failed' });
-            }
-        });
-    };
-    /** Keeps exactly one delayed metadata request and discards it when protocol state advances. */
-    const scheduleRequest = (delay) => {
-        if (scheduledRequest)
-            clearTimeout(scheduledRequest);
-        const expectedPhase = state.phase;
-        const expectedVersion = state.version;
-        scheduledRequest = setTimeout(() => {
-            scheduledRequest = undefined;
-            if (state.phase !== expectedPhase || state.version !== expectedVersion)
-                return;
-            send(state.phase === 'registering' ? 'register' : 'poll', state.version);
-        }, delay);
-    };
-    const execute = (command, apply) => {
-        switch (command.type) {
-            case 'register':
-                send('register', command.version);
-                return;
-            case 'poll':
-            case 'report-version':
-                send('poll', command.version);
-                return;
-            case 'apply-batch': {
-                const batchApply = apply ?? pendingBatchApply;
-                pendingBatchApply = undefined;
-                if (!batchApply) {
-                    dispatch({ type: 'batch-failed' });
-                    return;
-                }
-                const applyUpdate = () => {
-                    const bridge = wxClientGlobal.__VITE_PLUGIN_TARO_WX_PAGE_UPDATE__;
-                    if (!bridge) {
-                        dispatch({ type: 'batch-failed' });
-                        return;
-                    }
-                    bridge.beginUpdate?.();
-                    try {
-                        batchApply();
-                        dispatch({ type: 'batch-executed', targetVersion: command.targetVersion });
-                    }
-                    catch (error) {
-                        console.error('[vite-plugin-taro] WX update execution failed', error);
-                        dispatch({ type: 'batch-failed' });
-                    }
-                    finally {
-                        bridge.endUpdate?.();
-                    }
-                };
-                const bridge = wxClientGlobal.__VITE_PLUGIN_TARO_WX_PAGE_UPDATE__;
-                if (bridge?.ready)
-                    applyUpdate();
-                else if (bridge)
-                    bridge.pendingUpdate = applyUpdate;
-                else
-                    dispatch({ type: 'batch-failed' });
-                return;
-            }
-            case 'request-full-build':
-                send('rebuild', state.version);
-                return;
-            case 'retry-transport':
-                scheduleRequest(transportRetryDelay);
-        }
-    };
-    wxClientGlobal.__VITE_PLUGIN_TARO_WX_UPDATE_CLIENT__ = {
-        receiveBatch(metadata, apply) {
-            dispatch({ type: 'batch-observed', ...metadata }, apply);
-            if (state.pendingBatch?.fromVersion === metadata.fromVersion &&
-                state.pendingBatch.targetVersion === metadata.targetVersion) {
-                pendingBatchApply = apply;
-            }
-            else if (!state.pendingBatch && state.phase !== 'applying') {
-                pendingBatchApply = undefined;
-            }
-        },
-        refreshCompleted(stale) {
-            dispatch({ type: 'refresh-completed', stale });
-        },
-        routeReady() {
-            dispatch({ type: 'route-ready' });
-        }
-    };
-    dispatch({ type: 'started' });
-}
-function createSessionId() {
-    return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
-}
-function parseResponse(value) {
-    if (typeof value !== 'object' || value === null || !('type' in value) || typeof value.type !== 'string') {
-        return { type: 'invalid' };
-    }
-    return { type: value.type };
-}

package/src/node/build-context.ts

@@ -1,62 +0,0 @@
-import path from 'node:path'
-import type { ConfigEnv, ResolvedConfig } from 'vite'
-import type { JsonObject, VitePluginTaroOptions, VitePluginTaroPageOption, VitePluginTaroTarget } from '../options.ts'
-import { CssPipeline } from './css/css-pipeline.ts'
-
-type ProjectContext = Readonly<{
-    target: VitePluginTaroTarget
-    appComponentFile: string
-    pages: readonly VitePluginTaroPageOption[]
-    appConfig: JsonObject
-    projectConfigJson: JsonObject
-    projectPrivateConfigJson?: JsonObject
-    sitemapJson: JsonObject
-}>
-
-/** Owns the shared project, Vite lifecycle state, and cross-target services for one build. */
-export class BuildContext {
-    readonly project: ProjectContext
-    readonly css: CssPipeline
-    private developmentMode: boolean | undefined
-    private resolvedViteConfig: ResolvedConfig | undefined
-
-    constructor(options: VitePluginTaroOptions) {
-        this.css = new CssPipeline(options.target)
-        this.project = {
-            target: options.target,
-            appComponentFile: path.resolve(options.app),
-            pages: options.pages,
-            appConfig: {
-                ...options.appJson,
-                pages: options.pages.map((page) => page.path)
-            },
-            projectConfigJson: options.projectConfigJson,
-            projectPrivateConfigJson: options.projectPrivateConfigJson,
-            sitemapJson: options.sitemapJson
-        }
-    }
-
-    configure(environment: ConfigEnv): void {
-        if (this.developmentMode !== undefined)
-            throw new Error('vite-plugin-taro build context was already configured.')
-        this.developmentMode = environment.command === 'serve'
-    }
-
-    resolve(config: ResolvedConfig): void {
-        if (this.developmentMode === undefined) {
-            throw new Error('vite-plugin-taro build context resolved before it was configured.')
-        }
-        if (this.resolvedViteConfig) throw new Error('vite-plugin-taro build context was already resolved.')
-        this.resolvedViteConfig = config
-    }
-
-    get development(): boolean {
-        if (this.developmentMode === undefined) throw new Error('vite-plugin-taro build context is not configured.')
-        return this.developmentMode
-    }
-
-    get vite(): ResolvedConfig {
-        if (!this.resolvedViteConfig) throw new Error('vite-plugin-taro build context is not resolved.')
-        return this.resolvedViteConfig
-    }
-}

package/src/node/css/css-pipeline.ts

@@ -1,171 +0,0 @@
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import { extractSourceCandidates } from '@tailwindcss-mangle/engine'
-import type { PluginOption, ResolvedConfig } from 'vite'
-import { createContext } from 'weapp-tailwindcss/core'
-import {
-    createWeappTailwindcssGenerator,
-    resolveTailwindV4Source,
-    type WeappTailwindcssGenerator
-} from 'weapp-tailwindcss/generator'
-import { WeappTailwindcss } from 'weapp-tailwindcss/vite'
-import type { VitePluginTaroTarget } from '../../options.ts'
-import { normalizeModuleId } from '../utils/modules.ts'
-import { resolvePackageFile } from '../utils/packages.ts'
-
-const wxStyleOptions = {
-    cssCalc: false,
-    autoprefixer: false,
-    rem2rpx: true,
-    px2rpx: true
-} as const
-
-type WxContext = ReturnType<typeof createContext>
-type CssEntry = { source: string; generator: WeappTailwindcssGenerator }
-type PatchResult = { code: string } | { requiresFullBuild: true }
-
-/** Owns Tailwind's Vite integration and native WX patch synchronization. */
-export class CssPipeline {
-    readonly plugins: PluginOption[]
-    // Each Tailwind CSS entry can define a different design system, so additions must pass every relevant validator.
-    private readonly entries = new Map<string, CssEntry>()
-    // Vite can report the same source more than once; avoid repeating extraction and validation.
-    private readonly sourceCache = new Map<string, string>()
-    // Upstream owns WX JavaScript escaping; this context is deliberately reused between patches.
-    private wxContext: WxContext | undefined
-    // CSS transforms arrive after configResolved, so the Vite root is retained for source and module resolution.
-    private root: string | undefined
-    // Only classes represented by a completed WX build are safe to publish in a JavaScript-only patch.
-    private builtClassSet = new Set<string>()
-
-    /** Composes the upstream web/WX plugins and adds candidate tracking only for native WX patches. */
-    constructor(target: VitePluginTaroTarget) {
-        const pipeline = this
-
-        const wx = target === 'wx'
-
-        this.plugins = [
-            wx
-                ? {
-                      name: 'vite-plugin-taro:wx-tailwind-pipeline',
-                      enforce: 'pre',
-                      configResolved(config) {
-                          pipeline.resolveWx(config)
-                      },
-                      async transform(code, id) {
-                          if (!isTailwindCssEntry(code, id)) return
-                          await pipeline.registerCssEntry(id, code)
-                      }
-                  }
-                : undefined,
-            ...(WeappTailwindcss({
-                appType: 'taro',
-                // Route split Tailwind imports around Vite's unresolved production CSS package imports.
-                rewriteCssImports: true,
-                generator: { target: wx ? 'weapp' : 'web' },
-                ...(wx ? wxStyleOptions : {}),
-                logLevel: 'silent'
-            }) ?? [])
-        ]
-    }
-
-    /** Records every utility guaranteed to exist after a successful full WX build. */
-    async captureFullBuild(): Promise<void> {
-        this.sourceCache.clear()
-        // Preserve removed development CSS, matching upstream's append-only HMR default.
-        for (const { generator } of this.entries.values()) {
-            const result = await generator.generate({ scanSources: true })
-            for (const candidate of result.classSet) this.builtClassSet.add(candidate)
-        }
-    }
-
-    /** Applies upstream mini-program compatibility transforms to Taro's fully materialized WXSS. */
-    async transformWxss(code: string): Promise<string> {
-        return (await this.getWxContext().transformWxss(code)).css
-    }
-
-    /** Escapes a JavaScript-only WX patch, or rejects it when its utilities require new WXSS. */
-    async transformNativePatch(code: string, filename: string, files: string[]): Promise<PatchResult> {
-        if (await this.hasAddedCandidates(files)) return { requiresFullBuild: true }
-        const result = await this.getWxContext().transformJs(code, {
-            runtimeSet: this.builtClassSet,
-            filename,
-            generateMap: false
-        })
-        return { code: result.code }
-    }
-
-    /** Retains Vite's root for resolving later CSS transforms and changed-file notifications. */
-    private resolveWx(config: ResolvedConfig): void {
-        this.root = config.root
-    }
-
-    /** Creates one validator per Tailwind entry and refreshes the shared upstream WX transformer. */
-    private async registerCssEntry(id: string, source: string): Promise<void> {
-        const file = resolveFile(id, this.getRoot())
-        if (this.entries.get(file)?.source === source) return
-        const base = path.dirname(file)
-        const resolved = await resolveTailwindV4Source({
-            projectRoot: this.getRoot(),
-            cwd: this.getRoot(),
-            base,
-            baseFallbacks: [resolvePackageFile()],
-            css: source,
-            cssSources: [{ file, base, css: source, dependencies: [file] }]
-        })
-        this.entries.set(file, { source, generator: createWeappTailwindcssGenerator(resolved) })
-        this.wxContext = createContext({
-            appType: 'taro',
-            cssEntries: [...this.entries.keys()],
-            tailwindcssBasedir: this.getRoot(),
-            generator: { target: 'weapp' },
-            ...wxStyleOptions,
-            logLevel: 'silent'
-        })
-    }
-
-    /** Incrementally checks changed source files for utilities absent from the completed WX build. */
-    private async hasAddedCandidates(files: string[]): Promise<boolean> {
-        for (const input of files) {
-            const file = resolveFile(input, this.getRoot())
-            if (!/\.[cm]?[jt]sx?$/.test(file)) continue
-            const source = await fs.readFile(file, 'utf8')
-            if (this.sourceCache.get(file) === source) continue
-            this.sourceCache.set(file, source)
-            const extracted = await extractSourceCandidates(source, path.extname(file).slice(1))
-            for (const { generator } of this.entries.values()) {
-                const candidates = await generator.validateCandidates(extracted)
-                // Native WX patches bypass Vite; a new utility therefore requires synchronized WXSS first.
-                for (const candidate of candidates) if (!this.builtClassSet.has(candidate)) return true
-            }
-        }
-        return false
-    }
-
-    /** Returns the initialized WX transformer and detects invalid lifecycle ordering. */
-    private getWxContext(): WxContext {
-        if (!this.wxContext) throw new Error('WX CSS pipeline was used before Vite resolved.')
-        return this.wxContext
-    }
-
-    /** Returns the resolved project root and detects use before Vite configuration. */
-    private getRoot(): string {
-        if (!this.root) throw new Error('WX CSS pipeline was used before Vite resolved.')
-        return this.root
-    }
-}
-
-/** Identifies style modules that establish a Tailwind design system. */
-function isTailwindCssEntry(code: string, id: string): boolean {
-    return (
-        /\.(?:css|scss|sass|less|styl|stylus)(?:$|[?#])/.test(id) &&
-        /@(?:import|reference)\s+(?:url\(\s*)?["']tailwindcss(?:\/[^"']*)?["']/.test(code)
-    )
-}
-
-/** Converts Vite IDs, including /@fs/ IDs and query strings, into normalized absolute paths. */
-function resolveFile(id: string, root: string): string {
-    const normalized = normalizeModuleId(id).replace(/[?#].*$/, '')
-    const file = normalized.startsWith('/@fs/') ? normalized.slice('/@fs'.length) : normalized
-    return normalizeModuleId(path.resolve(root, file))
-}

package/src/node/plugins/taro-runtime.ts

@@ -1,22 +0,0 @@
-import type { Plugin } from 'vite'
-import { resolvePackageFile } from '../utils/packages.ts'
-
-/** Public IDs used by Taro's API transform and generated target modules. */
-export const virtualTaroApiId = 'virtual:taro/api'
-const virtualTaroComponentsId = 'virtual:taro/components'
-
-const runtimeModules = new Map([
-    [virtualTaroApiId, resolvePackageFile('dist/runtime/taro/api.js')],
-    [virtualTaroComponentsId, resolvePackageFile('dist/runtime/taro/components.js')]
-])
-
-/** Resolves target-neutral Taro shims once instead of duplicating this concern in every target plugin. */
-export function createTaroRuntimePlugin(): Plugin {
-    return {
-        name: 'vite-plugin-taro:runtime',
-        enforce: 'pre',
-        resolveId(id) {
-            return runtimeModules.get(id)
-        }
-    }
-}