vite-plugin-taro 0.3.2 → 0.4.1

package/src/runtime/wx/page-update.ts

@@ -1,230 +0,0 @@
-/**
- * Coordinates page-side update execution after the Rolldown and Taro runtimes exist.
- *
- * This module is intentionally page-only: it suppresses DevTools' synthetic lifecycles, preserves the Taro root,
- * commits React Refresh, and relaunches stale component families. HTTP transport remains in update-client.ts.
- */
-import { document } from '@tarojs/runtime'
-import { validateRefreshBoundaryAndEnqueueUpdate } from '/@react-refresh'
-
-type WxPage = {
-    $taroPath?: string
-    $taroParams?: Record<string, unknown>
-}
-
-type WxPageConfig = Record<string, unknown>
-type PageLifecycle = (this: WxPage, ...args: unknown[]) => unknown
-
-type TaroRoot = {
-    ctx: WxPage | null
-    updateChildNodes(): void
-    performUpdate(initRender?: boolean): void
-}
-
-type ReactRefreshResult = {
-    staleFamilies?: Set<unknown>
-}
-
-type WxRolldownRuntime = {
-    beginPatch?(): void
-    endPatch?(): void
-}
-
-type WxPageUpdateCoordinator = {
-    ready: boolean
-    pendingUpdate?: () => void
-    blockRefreshRegistration?: boolean
-    enqueueRefresh?: () => void
-    beginUpdate?: () => void
-    endUpdate?: () => void
-    afterRefresh?: (update?: ReactRefreshResult) => void
-}
-
-type WxUpdateClient = {
-    refreshCompleted(stale: boolean): void
-    routeReady(): void
-}
-
-type WxRuntimeGlobal = typeof globalThis & {
-    __rolldown_runtime__?: WxRolldownRuntime
-    __VITE_PLUGIN_TARO_WX_PAGE_UPDATE__?: WxPageUpdateCoordinator
-    __VITE_PLUGIN_TARO_WX_UPDATE_CLIENT__?: WxUpdateClient
-    getCurrentPages(): Array<{ route?: string }>
-    wx: {
-        reLaunch(options: { url: string }): void
-    }
-}
-
-const wxRuntimeGlobal = globalThis as WxRuntimeGlobal
-wxRuntimeGlobal.__VITE_PLUGIN_TARO_WX_PAGE_UPDATE__ ??= { ready: false }
-const bridge = wxRuntimeGlobal.__VITE_PLUGIN_TARO_WX_PAGE_UPDATE__
-const refreshBoundary = { default: function WxRefreshBoundary() {} }
-const registeredRoutes = new Set<string>()
-const ignoredPages = new WeakSet<WxPage>()
-
-type PageRuntimeState = Readonly<{
-    activePage?: WxPage
-    pendingUpdate?: { page?: WxPage; root?: TaroRoot }
-    suppressLifecycles: boolean
-}>
-
-type PageRuntimeEvent =
-    | { type: 'page-activated'; page: WxPage }
-    | { type: 'page-unloaded'; page: WxPage }
-    | { type: 'update-started'; root?: TaroRoot }
-    | { type: 'suppression-ended' }
-    | { type: 'refresh-finished' }
-
-let pageRuntimeState: PageRuntimeState = { suppressLifecycles: false }
-
-/** Registers a native route once per App Service runtime generation. */
-export function registerWxPage(route: string, register: () => void): void {
-    if (registeredRoutes.has(route)) return
-    register()
-    registeredRoutes.add(route)
-}
-
-/** Retains Taro's live root while filtering DevTools' synthetic update lifecycles. */
-export function decorateWxPageConfig(config: WxPageConfig): WxPageConfig {
-    const onLoad = getLifecycle(config, 'onLoad')
-    config.onLoad = function (this: WxPage, ...args: unknown[]) {
-        if (pageRuntimeState.suppressLifecycles) {
-            ignoredPages.add(this)
-            this.$taroPath = pageRuntimeState.activePage?.$taroPath
-            this.$taroParams = pageRuntimeState.activePage?.$taroParams
-            dispatchPageRuntime({ type: 'page-activated', page: this })
-            return
-        }
-        const result = onLoad?.apply(this, args)
-        dispatchPageRuntime({ type: 'page-activated', page: this })
-        return result
-    }
-    wrapLifecycle(config, 'onReady', applyPendingPageUpdate)
-    wrapLifecycle(config, 'onShow', function () {
-        dispatchPageRuntime({ type: 'page-activated', page: this })
-    })
-    wrapLifecycle(config, 'onHide')
-    wrapLifecycle(config, 'onUnload', function () {
-        dispatchPageRuntime({ type: 'page-unloaded', page: this })
-    })
-    return config
-}
-
-function wrapLifecycle(config: WxPageConfig, name: string, after?: PageLifecycle): void {
-    const original = getLifecycle(config, name)
-    config[name] = function (this: WxPage, ...args: unknown[]) {
-        if (pageRuntimeState.suppressLifecycles) return
-        if (ignoredPages.has(this)) {
-            if (name === 'onUnload') ignoredPages.delete(this)
-            return
-        }
-        const result = original?.apply(this, args)
-        after?.apply(this, args)
-        return result
-    }
-}
-
-function getLifecycle(config: WxPageConfig, name: string): PageLifecycle | undefined {
-    return typeof config[name] === 'function' ? (config[name] as PageLifecycle) : undefined
-}
-
-function applyPendingPageUpdate(): void {
-    bridge.ready = true
-    const pendingUpdate = bridge.pendingUpdate
-    if (pendingUpdate) {
-        delete bridge.pendingUpdate
-        pendingUpdate()
-    }
-    wxRuntimeGlobal.__VITE_PLUGIN_TARO_WX_UPDATE_CLIENT__?.routeReady()
-}
-
-function getActiveTaroRoot(): TaroRoot | undefined {
-    const page = pageRuntimeState.activePage
-    if (!page?.$taroPath) return
-    return (document.getElementById(page.$taroPath) as TaroRoot | null) ?? undefined
-}
-
-bridge.enqueueRefresh = () => {
-    validateRefreshBoundaryAndEnqueueUpdate('vite-plugin-taro-wx', refreshBoundary, refreshBoundary)
-}
-
-bridge.beginUpdate = () => {
-    bridge.blockRefreshRegistration = false
-    wxRuntimeGlobal.__rolldown_runtime__?.beginPatch?.()
-    dispatchPageRuntime({ type: 'update-started', root: getActiveTaroRoot() })
-    refreshTaroRoot(pageRuntimeState.pendingUpdate?.root, pageRuntimeState.pendingUpdate?.page)
-    runInNextNativeTask(() => dispatchPageRuntime({ type: 'suppression-ended' }))
-}
-
-bridge.endUpdate = () => {
-    wxRuntimeGlobal.__rolldown_runtime__?.endPatch?.()
-    bridge.blockRefreshRegistration = true
-    bridge.enqueueRefresh?.()
-}
-
-bridge.afterRefresh = (update) => {
-    bridge.blockRefreshRegistration = false
-    const pendingUpdate = pageRuntimeState.pendingUpdate
-    dispatchPageRuntime({ type: 'refresh-finished' })
-    const page = pendingUpdate?.page
-    const root = pendingUpdate?.root
-
-    const stale = Boolean(update?.staleFamilies?.size)
-    if (stale) {
-        wxRuntimeGlobal.__VITE_PLUGIN_TARO_WX_UPDATE_CLIENT__?.refreshCompleted(true)
-        relaunchActiveRoute(page)
-        return
-    }
-    runInNextNativeTask(() => {
-        refreshTaroRoot(root, pageRuntimeState.activePage ?? page)
-        wxRuntimeGlobal.__VITE_PLUGIN_TARO_WX_UPDATE_CLIENT__?.refreshCompleted(false)
-    })
-}
-
-function dispatchPageRuntime(event: PageRuntimeEvent): void {
-    pageRuntimeState = transitionPageRuntime(pageRuntimeState, event)
-}
-
-function transitionPageRuntime(state: PageRuntimeState, event: PageRuntimeEvent): PageRuntimeState {
-    switch (event.type) {
-        case 'page-activated':
-            return { ...state, activePage: event.page }
-        case 'page-unloaded':
-            return state.activePage === event.page ? { ...state, activePage: undefined } : state
-        case 'update-started':
-            return {
-                ...state,
-                pendingUpdate: { page: state.activePage, root: event.root },
-                suppressLifecycles: true
-            }
-        case 'suppression-ended':
-            return { ...state, suppressLifecycles: false }
-        case 'refresh-finished':
-            return { ...state, pendingUpdate: undefined }
-    }
-}
-
-function refreshTaroRoot(root: TaroRoot | undefined, page: WxPage | undefined): void {
-    if (!root) return
-    root.ctx = page ?? null
-    root.updateChildNodes()
-    root.performUpdate(true)
-}
-
-function relaunchActiveRoute(page: WxPage | undefined): void {
-    const route = wxRuntimeGlobal.getCurrentPages().at(-1)?.route
-    if (!route) return
-    const query = Object.entries(page?.$taroParams ?? {})
-        .filter(([key, value]) => key !== '$taroTimestamp' && value !== undefined)
-        .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`)
-        .join('&')
-    runInNextNativeTask(() => wxRuntimeGlobal.wx.reLaunch({ url: `/${route}${query ? `?${query}` : ''}` }))
-}
-
-/**
- * DevTools dispatches synthetic page lifecycles after the changed module returns. A macrotask—not a microtask—runs
- * after that native turn and also avoids navigation or Taro root mutation from inside React Refresh's callback.
- */
-function runInNextNativeTask(task: () => void): void {
-    setTimeout(task)
-}

package/src/runtime/wx/react-refresh.d.ts

@@ -1,20 +0,0 @@
-/** Vite's development-only React Refresh virtual module used by the WX runtime. */
-declare module '*/@react-refresh' {
-    export type RefreshResult = {
-        updatedFamilies: Set<unknown>
-        staleFamilies: Set<unknown>
-    }
-
-    export function register(type: unknown, id: string): void
-    export function registerExportsForReactRefresh(filename: string, moduleExports: Record<string, unknown>): void
-    export function validateRefreshBoundaryAndEnqueueUpdate(
-        id: string,
-        previousExports: Record<string, unknown>,
-        nextExports: Record<string, unknown>
-    ): string | undefined
-
-    const runtime: {
-        injectIntoGlobalHook(globalObject: typeof globalThis): void
-    }
-    export default runtime
-}

package/src/runtime/wx/taro-runtime.ts

@@ -1,7 +0,0 @@
-/** Runtime exports consumed by generated WX App, page, and recursive-component entries. */
-import '@tarojs/plugin-platform-weapp/dist/runtime.js'
-
-// @ts-expect-error Taro exposes createReactApp from this runtime-only deep entry without types.
-export { createReactApp } from '@tarojs/plugin-framework-react/dist/runtime'
-export { default as ReactDOM } from '@tarojs/react'
-export { createPageConfig, createRecursiveComponentConfig } from '@tarojs/runtime'

package/src/runtime/wx/update-client-state.ts

@@ -1,138 +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 function createWxUpdateClientState(buildId: string): WxUpdateClientState {
-    return { buildId, version: 0, phase: 'stopped' }
-}
-
-export function transitionWxUpdateClient(
-    state: WxUpdateClientState,
-    event: WxUpdateClientEvent
-): WxUpdateClientTransition {
-    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: WxUpdateClientState,
-    batch: { buildId: string; fromVersion: number; targetVersion: number }
-): WxUpdateClientTransition {
-    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: WxUpdateClientState): WxUpdateClientTransition {
-    const appliedState = { ...state, phase: 'polling' as const, targetVersion: undefined }
-    return command(appliedState, { type: 'report-version', version: state.version, reason: 'applied' })
-}
-
-function transition(state: WxUpdateClientState): WxUpdateClientTransition {
-    return { state, commands: [] }
-}
-
-function command(state: WxUpdateClientState, value: WxUpdateClientCommand): WxUpdateClientTransition {
-    return { state, commands: [value] }
-}

package/src/runtime/wx/update-client.ts

@@ -1,223 +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,
-    type WxUpdateClientCommand,
-    type WxUpdateClientEvent
-} from './update-client-state.ts'
-
-type WxUpdateControl = {
-    url: string
-    token: string
-    buildId: string
-}
-
-type WxUpdateBatchMetadata = {
-    buildId: string
-    fromVersion: number
-    targetVersion: number
-}
-
-type WxRequestTask = {
-    abort(): void
-}
-
-type WxRequestResult = {
-    data?: unknown
-}
-
-type WxPageUpdateCoordinator = {
-    ready: boolean
-    pendingUpdate?: () => void
-    beginUpdate?: () => void
-    endUpdate?: () => void
-}
-
-type WxUpdateClient = {
-    receiveBatch(metadata: WxUpdateBatchMetadata, apply: () => void): void
-    refreshCompleted(stale: boolean): void
-    routeReady(): void
-}
-
-type WxClientGlobal = typeof globalThis & {
-    __VITE_PLUGIN_TARO_WX_CONTROL__?: WxUpdateControl
-    __VITE_PLUGIN_TARO_WX_UPDATE_CLIENT__?: WxUpdateClient
-    __VITE_PLUGIN_TARO_WX_PAGE_UPDATE__?: WxPageUpdateCoordinator
-    wx: {
-        request(options: {
-            url: string
-            method: 'POST'
-            data: unknown
-            timeout: number
-            success(result: WxRequestResult): void
-            fail(error: { errMsg?: string }): void
-        }): WxRequestTask
-    }
-}
-
-const wxClientGlobal = globalThis as WxClientGlobal
-const transportRetryDelay = 500
-const rebuildPollDelay = 1_000
-const updateFileWatchdogDelay = 2_000
-
-export function startWxUpdateClient(): void {
-    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: WxRequestTask | undefined
-    let scheduledRequest: ReturnType<typeof setTimeout> | undefined
-    let pendingBatchApply: (() => void) | undefined
-
-    const dispatch = (event: WxUpdateClientEvent, apply?: () => void): void => {
-        const transition = transitionWxUpdateClient(state, event)
-        state = transition.state
-        for (const command of transition.commands) execute(command, apply)
-    }
-
-    const send = (action: 'register' | 'poll' | 'rebuild', version: number): void => {
-        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: number): void => {
-        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: WxUpdateClientCommand, apply?: () => void): void => {
-        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(): string {
-    return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`
-}
-
-function parseResponse(value: unknown): { type: string } {
-    if (typeof value !== 'object' || value === null || !('type' in value) || typeof value.type !== 'string') {
-        return { type: 'invalid' }
-    }
-    return { type: value.type }
-}