vite-plugin-taro 0.6.1 → 0.6.3

package/src/node/plugins/wx/render/transport.ts

@@ -1,9 +1,9 @@
 import path from 'node:path'
-import { types } from '@babel/core'
+import * as types from '@babel/types'
 import type { Rolldown } from 'vite'
 import { type AstTransformResult, replaceWithAst } from '../../../utils/transform.ts'
-import { toLogicalChunkId } from '../chunk-path.ts'
-import { getWxExecutionKind } from '../module.ts'
+import { toLogicalChunkId } from '../module/chunk-path.ts'
+import { getWxExecutionKind } from '../module/module.ts'
 
 const transportPlaceholder = '__VPT_TRANSPORT__'
 const moduleIdParameter = 'moduleId'

package/src/node/plugins/wx/resolve/resolver.ts

@@ -17,8 +17,8 @@ import {
     pageShellPath,
     transportPath,
     vitePreloadId
-} from '../module.ts'
-import { specializeBootstrap } from './specialize-bootstrap.ts'
+} from '../module/module.ts'
+import { specializeAppCapsule } from './specialize-app-capsule.ts'
 import { specializePageCapsule } from './specialize-page-capsule.ts'
 
 /** Resolves one exact plugin-private ID using its importer and configured project root. */
@@ -26,7 +26,7 @@ type PrivateIdResolver = (importer: string | undefined, projectRoot: string) =>
 
 /** Creates the resolver and source specializer for the wx module graph. */
 export function createResolver(options: VptOptions) {
-    const normalizedBootstrapPath = normalizePath(bootstrapPath)
+    const normalizedAppCapsulePath = normalizePath(appCapsulePath)
     const normalizedPageCapsulePath = normalizePath(pageCapsulePath)
 
     // Construct output input and application traversal roots together once so style order cannot drift from route order.
@@ -70,8 +70,8 @@ export function createResolver(options: VptOptions) {
         specialize(code: string, id: string, sourcemap = true) {
             const normalizedId = normalizeModuleId(id)
 
-            if (normalizedId === normalizedBootstrapPath) {
-                return specializeBootstrap({ code, id, appConfig: createAppConfig(options), sourcemap })
+            if (normalizedId === normalizedAppCapsulePath) {
+                return specializeAppCapsule({ code, id, appConfig: createAppConfig(options), sourcemap })
             }
 
             if (normalizedId === normalizedPageCapsulePath) {

package/src/node/plugins/wx/resolve/{specialize-bootstrap.ts → specialize-app-capsule.ts}

@@ -1,11 +1,11 @@
-import { types } from '@babel/core'
+import * as types from '@babel/types'
 import type { VptJsonObject } from '../../../../options.ts'
 import { type AstTransformResult, replaceWithAst } from '../../../utils/transform.ts'
 
 const appConfigPlaceholder = '__VPT_APP_CONFIG__'
 
-/** Specializes the amphibious bootstrap with the shared App configuration. */
-export function specializeBootstrap({
+/** Specializes the App capsule with its normalized native configuration. */
+export function specializeAppCapsule({
     code,
     id,
     appConfig,

package/src/node/plugins/wx/resolve/specialize-page-capsule.ts

@@ -1,4 +1,4 @@
-import { types } from '@babel/core'
+import * as types from '@babel/types'
 import type { VptPageOption } from '../../../../options.ts'
 import { type AstTransformResult, replaceWithAst } from '../../../utils/transform.ts'
 

package/src/node/utils/transform.ts

@@ -1,4 +1,3 @@
-import { type PluginItem, transformSync } from '@babel/core'
 import { generate } from '@babel/generator'
 import { type Rolldown, transformWithOxc } from 'vite'
 import { esTarget } from './constant.ts'
@@ -51,32 +50,3 @@ function requireOnePlaceholder(code: string, placeholder: string): void {
         throw new Error(`Expected one placeholder ${placeholder}, found ${replacementCount}`)
     }
 }
-
-/** Transforms one module with Babel's shared parser and source-map configuration. */
-export function transformWithBabel(
-    code: string,
-    filename: string,
-    plugins: PluginItem[],
-    sourcemap = true
-): AstTransformResult {
-    const transformed = transformSync(code, {
-        babelrc: false,
-        compact: true,
-        minified: true,
-        comments: false,
-        configFile: false,
-        filename,
-        plugins,
-        sourceFileName: filename,
-        sourceMaps: sourcemap,
-        sourceType: 'module'
-    })
-    if (!transformed?.code || (sourcemap && !transformed.map)) {
-        throw new Error(`Failed to transform ${filename} with Babel`)
-    }
-
-    return {
-        code: transformed.code,
-        map: sourcemap ? (transformed.map as Rolldown.ExistingRawSourceMap) : null
-    }
-}

package/src/runtime/wx/amphibious/bootstrap.ts

@@ -2,11 +2,6 @@
 import '../systemjs/system-core.js'
 import { transport } from './transport.ts'
 
-declare const __VPT_APP_CONFIG__: Record<string, unknown>
-
-/** Shares one App configuration object between the specialized bootstrap and App capsule. */
-export const appConfig = __VPT_APP_CONFIG__
-
 // WX has no modulepreload transport. Genuine application import() boundaries retain System.import() and may load
 // asynchronous subpackage or top-level-await graphs through this identity wrapper.
 export const __vitePreload = <Value>(load: () => Value): Value => load()

package/src/runtime/wx/capsule/app.ts

@@ -1,9 +1,12 @@
 // biome-ignore assist/source/organizeImports: Taro must initialize before the App component.
 import { createReactApp, ReactDOM } from './taro-runtime.ts'
 import React from 'react'
-import { appConfig } from '../amphibious/bootstrap.ts'
 
 // @ts-expect-error: The wx build resolves this private App component.
 import AppComponent from '\0vpt:app-component'
 
-export default createReactApp(AppComponent, React, ReactDOM, appConfig)
+declare const __VPT_APP_CONFIG__: Record<string, unknown>
+
+const config = createReactApp(AppComponent, React, ReactDOM, __VPT_APP_CONFIG__)
+
+export default config

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

@@ -5,7 +5,7 @@
 // The `DevRuntime` base class is injected into the chunk by Rolldown's dev-mode
 // transform, so the WX host only extends it.
 //
-// Every Page explicitly passes the inert hmr/patches.js export here before importing its capsule. The runtime applies that
+// Every Page explicitly passes the inert hmr/patches.js export here before native Page registration. The runtime applies that
 // cumulative suffix synchronously, reports its successful application frontier, and ignores sequences replayed by other Pages.
 
 import type { DevRuntime as RolldownDevRuntime } from 'rolldown/experimental/runtime-types'
@@ -54,54 +54,30 @@ type HmrUpdate = Readonly<{
 
 type AcceptCallback = (moduleExports: unknown) => void
 
-type PageSnapshot = Readonly<{
-    $taroPath: string
-    $taroParams: Record<string, unknown>
-    data: Record<string, unknown>
-}>
-
 type NativePage = {
-    $taroPath: string
-    $taroParams: Record<string, unknown>
     data: Record<string, unknown>
-    setData(data: Record<string, unknown>): void
+}
+
+const pageHmrStateKey: unique symbol = Symbol('vpt.pageHmrState')
+
+type PageHmrState = {
+    /** True only across the unload/load/show sequence triggered by one native re-registration. */
+    isReregistering: boolean
+    /** The Page bound to `this` by ordinary onLoad, retained until ordinary onUnload. */
+    mountedPage: NativePage | undefined
 }
 
 type HmrPageConfig = {
+    data: Record<string, unknown>
     onUnload?: unknown
     onLoad?: unknown
     onShow?: unknown
+    [pageHmrStateKey]?: PageHmrState
 }
 
-type TaroRoot = {
-    ctx: unknown
-}
-
-/** Immutable bridge references plus replacement transactions owned by one Taro singleton. */
-type TaroState = {
-    /** Taro's existing current-page source of truth; replacement onLoad switches its receiver. */
-    readonly current: { page: NativePage | null }
-    /** Taro's virtual document, used to find the retained root by its preserved unique path. */
-    readonly document: { getElementById(path: string): unknown }
-    /** Replaces Taro's native lifecycle receiver without remounting the retained React subtree. */
-    readonly injectPageInstance: (instance: unknown, path: string) => void
-    /**
-     * Short-lived route transactions. Absence means ordinary lifecycle; null means armed
-     * before onUnload or snapshot-consumed before onShow; a snapshot exists only between
-     * replacement onUnload and onLoad. The large data reference is therefore released in
-     * onLoad, while the null marker remains just long enough to suppress synthetic onShow.
-     */
-    readonly pageReplacements: Map<string, PageSnapshot | null>
-}
-
-/** Forwards a native lifecycle with its original Page receiver. */
-function forward(handler: unknown, receiver: unknown, args: unknown[]): void {
-    if (typeof handler === 'function') handler.apply(receiver, args)
-}
-
-/** Narrows the untyped element returned across the Taro connection boundary. */
-function isTaroRoot(value: unknown): value is TaroRoot {
-    return typeof value === 'object' && value !== null && 'ctx' in value
+/** Calls a native lifecycle with the same Page bound to `this` and the same arguments. */
+function forward(handler: unknown, page: unknown, args: unknown[]): void {
+    if (typeof handler === 'function') handler.apply(page, args)
 }
 
 /** Shared no-op CSS contract because physical rebuilds replace styles wholesale. */
@@ -285,109 +261,90 @@ class WxDevRuntime extends DevRuntime {
         this.session = { ...info, appliedSeq: 0 }
     }
 
-    /**
-     * One-shot bridge to the application's Taro singleton. It cannot be imported into this
-     * separately bundled global runtime without creating a second Taro identity. Undefined
-     * only before the serve-only facade connection; route transactions share its lifetime.
-     */
-    private taro: TaroState | undefined
-
-    /** Connects HMR to the same Taro singleton used by the application module graph. */
-    connectTaro(
-        current: TaroState['current'],
-        document: TaroState['document'],
-        injectPageInstance: TaroState['injectPageInstance']
-    ): void {
-        if (this.taro) {
-            return
-        }
+    /** Tracks the mounted native Page and prepares its static config for HMR re-registration. */
+    injectPageHmr(config: HmrPageConfig): HmrPageConfig {
+        const existingState = config[pageHmrStateKey]
+
+        if (existingState) {
+            const mountedPage = existingState.mountedPage
+            /*
+             * The static config can outlive a native Page instance. Before its first ordinary onLoad, or after a real onUnload,
+             * there is no mounted Page or current view-model to carry into another registration. Leave the lifecycle gate
+             * unarmed and preserve the config's existing initial data so a future real onLoad still enters Taro normally.
+             */
+            if (!mountedPage) {
+                return config
+            }
 
-        this.taro = {
-            current,
-            document,
-            injectPageInstance,
-            pageReplacements: new Map()
+            /*
+             * Arm the lifecycle wrappers on this exact static config before it is passed back to `Page(config)`. DevTools then
+             * triggers an unload/load/show sequence for that native re-registration: unload and load observe `true` and return
+             * before entering Taro, preserving the mounted React tree and its original Page connection; show consumes the
+             * one-shot gate by restoring `false`. Ordinary navigation never enters this branch, and every Page config owns an
+             * independent state object, so no route map, global phase, or Page identity comparison participates in the decision.
+             */
+            existingState.isReregistering = true
+            /*
+             * `Page(config)` reads `config.data` as the initial native view-model for this registration. Supplying the mounted
+             * Page's latest data before that call prevents the temporary Page used for re-registration callbacks from starting
+             * empty. This is an O(1) reference assignment in vpt: it does not clone the recursive data tree, call `setData`, move
+             * React state, or rebind Taro. The ordinary Taro lifecycle remains suppressed until re-registration onShow, so its
+             * React tree and output connection stay attached to `mountedPage`; every later registration reads its latest data.
+             */
+            config.data = mountedPage.data
+
+            return config
         }
-    }
 
-    /** Injects snapshot-preserving behavior into one route-specific Taro Page configuration. */
-    injectPageHmr(config: HmrPageConfig, route: string): void {
         const originalOnUnload = config.onUnload
         const originalOnLoad = config.onLoad
         const originalOnShow = config.onShow
-        const runtime = this
+
+        const state: PageHmrState = {
+            isReregistering: false,
+            mountedPage: undefined
+        }
+
+        /*
+         * Attach the one mutable HMR state object to this exact static config. The lifecycle wrappers below close over the same
+         * object, while a later `injectPageHmr(config)` call finds it through the symbol and knows wrapping is already complete.
+         * A symbol cannot collide with WeChat or Taro's string-named Page options, and config-local ownership avoids route maps,
+         * a runtime-wide WeakMap, or state shared by two Page configs. The state becomes unreachable together with the config.
+         */
+        config[pageHmrStateKey] = state
 
         config.onUnload = function (this: NativePage, ...args: unknown[]) {
-            const taro = runtime.requireTaro()
-            if (taro.pageReplacements.has(route)) {
-                taro.pageReplacements.set(route, {
-                    $taroPath: this.$taroPath,
-                    $taroParams: this.$taroParams,
-                    // WeChat owns this serializable view-model. Keeping its reference is O(1),
-                    // unlike cloning the complete recursive projection before every edit.
-                    data: this.data
-                })
+            if (state.isReregistering) {
                 return
             }
+
             forward(originalOnUnload, this, args)
+            state.mountedPage = undefined
         }
 
         config.onLoad = function (this: NativePage, ...args: unknown[]) {
-            const taro = runtime.requireTaro()
-            const snapshot = taro.pageReplacements.get(route)
-            if (snapshot) {
-                // Replace the transaction before native work so exceptions cannot retain the
-                // large data snapshot while the route waits for its synthetic onShow.
-                taro.pageReplacements.set(route, null)
-
-                // Snapshot paint is the first bridge operation and removes the empty-page gap.
-                this.setData(snapshot.data)
-                this.$taroPath = snapshot.$taroPath
-                this.$taroParams = snapshot.$taroParams
-                runtime.bindPage(this, snapshot.$taroPath)
+            if (state.isReregistering) {
                 return
             }
+
             forward(originalOnLoad, this, args)
+            state.mountedPage = this
         }
 
         config.onShow = function (this: NativePage, ...args: unknown[]) {
-            if (runtime.requireTaro().pageReplacements.delete(route)) {
-                // Synthetic shows must not repeat requests or reset application state.
+            if (state.isReregistering) {
+                state.isReregistering = false
                 return
             }
 
             forward(originalOnShow, this, args)
         }
-    }
-
-    /** Returns the Taro connection or fails at the first incorrectly ordered use. */
-    private requireTaro(): TaroState {
-        if (!this.taro) throw new Error('[vpt] WX HMR used before the Taro runtime was connected')
-        return this.taro
-    }
-
-    /** Returns a retained Taro root after normal Page mount has created it. */
-    private findRoot(path: string): TaroRoot | undefined {
-        const root = this.requireTaro().document.getElementById(path)
-        return isTaroRoot(root) ? root : undefined
-    }
-
-    /** Rebinds a retained Taro tree to one replacement native Page without repainting. */
-    private bindPage(instance: NativePage, path: string): void {
-        const taro = this.requireTaro()
-        taro.injectPageInstance(instance, path)
-        taro.current.page = instance
-
-        const pageElement = this.findRoot(path)
-        if (!pageElement) {
-            throw new Error(`[vpt] retained Taro page not found: ${path}`)
-        }
 
-        pageElement.ctx = instance
+        return config
     }
 
-    /** Applies one Page-delivered payload and arms its route for native replacement. */
-    applyPatches(payload: PatchPayload | undefined, route?: string): void {
+    /** Applies one Page-delivered payload before its native shell registers the static route configuration. */
+    applyPatches(payload: PatchPayload | undefined): void {
         // The initial physical dependency exports undefined until the host has a patch range.
         if (!payload) return
 
@@ -397,12 +354,6 @@ class WxDevRuntime extends DevRuntime {
             return
         }
 
-        // A replayed payload still causes DevTools to replace this physical Page. Arm the
-        // route independently of whether this App heap already applied its patch sequence.
-        if (route) {
-            this.requireTaro().pageReplacements.set(route, null)
-        }
-
         // Apply synchronously: the page's imports below the require resolve against the
         // freshly registered modules, so the re-executed Page evaluates with the new code.
         if (this.applyPatchBatch(session, payload.patches)) {

package/src/runtime/wx/wechat.d.ts

@@ -8,8 +8,7 @@ type WeChatGlobal = object
 /** The App-global Rolldown dev runtime; present only in wx development builds. */
 declare const __rolldown_runtime__:
     | {
-          connectTaro(current: object, document: object, injectPageInstance: (...args: unknown[]) => unknown): void
-          injectPageHmr(config: object, route: string): void
+          injectPageHmr(config: object): object
       }
     | undefined
 

package/dist/node/plugins/wx/render/capsule-wrapper.d.ts

@@ -1,3 +0,0 @@
-import { type PluginObj } from '@babel/core';
-/** Wraps System.register as an inert CommonJS capsule tuple with canonical final dependency IDs. */
-export declare function wrapCapsulePlugin(fileName: string): PluginObj;

package/dist/node/plugins/wx/render/capsule-wrapper.js

@@ -1,64 +0,0 @@
-import { types } from '@babel/core';
-import { resolveLogicalChunkReference } from '../chunk-path.js';
-/** Wraps System.register as an inert CommonJS capsule tuple with canonical final dependency IDs. */
-export function wrapCapsulePlugin(fileName) {
-    return {
-        name: 'vpt:wrap-capsule',
-        visitor: {},
-        post(file) {
-            const program = file.ast.program;
-            const [statement] = program.body;
-            const registration = statement && types.isExpressionStatement(statement) ? statement.expression : undefined;
-            if (program.body.length !== 1 ||
-                !types.isCallExpression(registration) ||
-                !types.isMemberExpression(registration.callee) ||
-                registration.callee.computed ||
-                !types.isIdentifier(registration.callee.object, { name: 'System' }) ||
-                !types.isIdentifier(registration.callee.property, { name: 'register' })) {
-                throw new Error(`Expected one anonymous System.register call in ${fileName}`);
-            }
-            const [dependencies, declaration] = registration.arguments;
-            if (registration.arguments.length !== 2 ||
-                !types.isArrayExpression(dependencies) ||
-                !types.isFunctionExpression(declaration)) {
-                throw new Error(`Expected System.register(dependencies, declaration) in ${fileName}`);
-            }
-            dependencies.elements.forEach((dependency) => {
-                canonicalizeStaticReference(dependency, fileName);
-            });
-            const context = declaration.params[1];
-            if (types.isIdentifier(context)) {
-                file.path.traverse({
-                    CallExpression(callPath) {
-                        const callee = callPath.node.callee;
-                        if (!types.isMemberExpression(callee) ||
-                            callee.computed ||
-                            !types.isIdentifier(callee.object, { name: context.name }) ||
-                            !types.isIdentifier(callee.property, { name: 'import' })) {
-                            return;
-                        }
-                        const [dependency] = callPath.node.arguments;
-                        canonicalizeDynamicReference(dependency, fileName);
-                    }
-                });
-            }
-            program.directives = [];
-            program.body = [
-                types.expressionStatement(types.assignmentExpression('=', types.memberExpression(types.identifier('module'), types.identifier('exports')), types.arrayExpression([dependencies, declaration])))
-            ];
-        }
-    };
-}
-/** Resolves one generated static reference while the final importing chunk filename is known. */
-function canonicalizeStaticReference(reference, fileName) {
-    if (!types.isStringLiteral(reference)) {
-        throw new Error(`Expected a literal System.register dependency in ${fileName}`);
-    }
-    reference.value = resolveLogicalChunkReference(fileName, reference.value);
-}
-/** Resolves application literals while preserving runtime-computed IDs injected by the development runtime. */
-function canonicalizeDynamicReference(reference, fileName) {
-    if (types.isStringLiteral(reference) && (reference.value.startsWith('./') || reference.value.startsWith('../'))) {
-        reference.value = resolveLogicalChunkReference(fileName, reference.value);
-    }
-}

package/src/node/plugins/wx/render/capsule-wrapper.ts

@@ -1,86 +0,0 @@
-import { type PluginObj, types } from '@babel/core'
-import { resolveLogicalChunkReference } from '../chunk-path.ts'
-
-/** Wraps System.register as an inert CommonJS capsule tuple with canonical final dependency IDs. */
-export function wrapCapsulePlugin(fileName: string): PluginObj {
-    return {
-        name: 'vpt:wrap-capsule',
-        visitor: {},
-
-        post(file) {
-            const program = file.ast.program
-            const [statement] = program.body
-            const registration = statement && types.isExpressionStatement(statement) ? statement.expression : undefined
-
-            if (
-                program.body.length !== 1 ||
-                !types.isCallExpression(registration) ||
-                !types.isMemberExpression(registration.callee) ||
-                registration.callee.computed ||
-                !types.isIdentifier(registration.callee.object, { name: 'System' }) ||
-                !types.isIdentifier(registration.callee.property, { name: 'register' })
-            ) {
-                throw new Error(`Expected one anonymous System.register call in ${fileName}`)
-            }
-
-            const [dependencies, declaration] = registration.arguments
-            if (
-                registration.arguments.length !== 2 ||
-                !types.isArrayExpression(dependencies) ||
-                !types.isFunctionExpression(declaration)
-            ) {
-                throw new Error(`Expected System.register(dependencies, declaration) in ${fileName}`)
-            }
-
-            dependencies.elements.forEach((dependency) => {
-                canonicalizeStaticReference(dependency, fileName)
-            })
-
-            const context = declaration.params[1]
-            if (types.isIdentifier(context)) {
-                file.path.traverse({
-                    CallExpression(callPath) {
-                        const callee = callPath.node.callee
-                        if (
-                            !types.isMemberExpression(callee) ||
-                            callee.computed ||
-                            !types.isIdentifier(callee.object, { name: context.name }) ||
-                            !types.isIdentifier(callee.property, { name: 'import' })
-                        ) {
-                            return
-                        }
-
-                        const [dependency] = callPath.node.arguments
-                        canonicalizeDynamicReference(dependency, fileName)
-                    }
-                })
-            }
-
-            program.directives = []
-            program.body = [
-                types.expressionStatement(
-                    types.assignmentExpression(
-                        '=',
-                        types.memberExpression(types.identifier('module'), types.identifier('exports')),
-                        types.arrayExpression([dependencies, declaration])
-                    )
-                )
-            ]
-        }
-    }
-}
-
-/** Resolves one generated static reference while the final importing chunk filename is known. */
-function canonicalizeStaticReference(reference: types.Node | null | undefined, fileName: string): void {
-    if (!types.isStringLiteral(reference)) {
-        throw new Error(`Expected a literal System.register dependency in ${fileName}`)
-    }
-    reference.value = resolveLogicalChunkReference(fileName, reference.value)
-}
-
-/** Resolves application literals while preserving runtime-computed IDs injected by the development runtime. */
-function canonicalizeDynamicReference(reference: types.Node | null | undefined, fileName: string): void {
-    if (types.isStringLiteral(reference) && (reference.value.startsWith('./') || reference.value.startsWith('../'))) {
-        reference.value = resolveLogicalChunkReference(fileName, reference.value)
-    }
-}