vite-plugin-taro 0.5.5 → 0.5.7

package/dist/node/plugins/wx/dev/plugins.d.ts

@@ -0,0 +1,22 @@
+import type { PluginOption } from 'vite';
+import type { VitePluginTaroOptions } from '../../../../options.ts';
+/**
+ * Adds the serve-only bundled-development plugin set for the wx target: the dev adapter,
+ * Page HMR activation, and React Refresh adaptation transforms.
+ */
+export declare function createWxDevelopmentPlugin(options: VitePluginTaroOptions): PluginOption[];
+/** Ensures the Refresh hook exists before React's renderer evaluates and injects itself. */
+export declare function injectReactRefreshBootstrap(code: string): {
+    code: string;
+    map: null;
+};
+/** Connects the shared WX dev runtime to the application graph's Taro runtime instance. */
+export declare function injectTaroConnection(code: string): {
+    code: string;
+    map: null;
+};
+/** Activates development-only lifecycle handling for one plugin-owned Page capsule. */
+export declare function injectPageHmr(code: string, route: string): {
+    code: string;
+    map: null;
+};

package/dist/node/plugins/wx/dev/plugins.js

@@ -0,0 +1,158 @@
+import { transformWithOxc } from 'vite';
+import { esTarget } from '../../../utils/constant.js';
+import { memoize } from '../../../utils/memoize.js';
+import { normalizeModuleId } from '../../../utils/modules.js';
+import { appCapsulePath, pageCapsulePath, rolldownRuntimeId, taroRuntimePath } from '../module.js';
+import { createWxDevHost } from './dev-host.js';
+import { createWxReactRefreshTransforms } from './react-refresh.js';
+const taroRuntimeId = '@tarojs/runtime';
+/**
+ * Adds the serve-only bundled-development plugin set for the wx target: the dev adapter,
+ * Page HMR activation, and React Refresh adaptation transforms.
+ */
+export function createWxDevelopmentPlugin(options) {
+    let host = null;
+    // Portable hook filters stay broad; these exact identities exclude similarly named user modules.
+    const normalizedAppCapsulePath = normalizeModuleId(appCapsulePath);
+    const normalizedPageCapsulePath = normalizeModuleId(pageCapsulePath);
+    const normalizedTaroRuntimePath = normalizeModuleId(taroRuntimePath);
+    return [
+        {
+            name: 'vpt:wx-dev',
+            apply: 'serve',
+            config() {
+                return {
+                    build: {
+                        // Disable maps in resolved environment config as well as final output so Oxc and Babel skip producing
+                        // intermediate maps that Rolldown would discard.
+                        sourcemap: false
+                    },
+                    experimental: {
+                        // Ask Vite to resolve its bundled-development graph and expose the private adapter instance. The wx
+                        // configureServer hook replaces only its startup method with the directly writing DevEngine.
+                        bundledDev: true
+                    }
+                };
+            },
+            configureServer: {
+                // Install after Vite and user plugins have finished configuring the environment, but before server.listen()
+                // asks bundledDev to create its hard-coded skip-write DevEngine.
+                order: 'post',
+                async handler(server) {
+                    host = await createWxDevHost({ server, options });
+                }
+            },
+            closeBundle() {
+                return host?.close();
+            }
+        },
+        {
+            name: 'vpt:wx-runtime-lowering',
+            apply: 'serve',
+            transform: {
+                order: 'post',
+                // The dev-mode transform assembles the runtime chunk (Rolldown's base runtime
+                // plus our injected implement) as this module's transform output, which
+                // bypasses the build's es2018 lowering. Real-device engines and WeChat's
+                // upload parser predate class fields and nullish operators, so the assembled
+                // runtime is lowered here — the only module that needs it. The exact id
+                // filter needs no code scan; the id must stay in sync with rolldownRuntimeId
+                // in module.ts (kept as a regex for the Rolldown-side filter).
+                filter: { id: /^\0rolldown\/runtime\.js(?:\?|$)/ },
+                handler(code) {
+                    // The `setPublicClassFields` assumption emits plain `this.x = ...`
+                    // assignments instead of external helpers, whose references the later
+                    // minifier would mangle.
+                    return fixRolldownRuntime(code);
+                }
+            }
+        },
+        {
+            name: 'vpt:wx-react-refresh-bootstrap',
+            apply: 'serve',
+            transform: {
+                order: 'post',
+                filter: { id: /\/runtime\/wx\/capsule\/app\.js(?:\?|$)/ },
+                handler(code, id) {
+                    if (normalizeModuleId(id) !== normalizedAppCapsulePath)
+                        return;
+                    return injectReactRefreshBootstrap(code);
+                }
+            }
+        },
+        {
+            name: 'vpt:wx-page-hmr',
+            apply: 'serve',
+            transform: {
+                order: 'post',
+                filter: { id: /\/runtime\/wx\/capsule\/page\.js(?:\?|$)/ },
+                handler(code, id) {
+                    if (normalizeModuleId(id) !== normalizedPageCapsulePath)
+                        return;
+                    return injectPageHmr(code, getPageRoute(id));
+                }
+            }
+        },
+        {
+            name: 'vpt:wx-taro-hmr',
+            apply: 'serve',
+            transform: {
+                order: 'post',
+                filter: { id: /\/runtime\/wx\/capsule\/taro-runtime\.js(?:\?|$)/ },
+                handler(code, id) {
+                    if (normalizeModuleId(id) !== normalizedTaroRuntimePath)
+                        return;
+                    return injectTaroConnection(code);
+                }
+            }
+        },
+        ...createWxReactRefreshTransforms()
+    ];
+}
+/** Ensures the Refresh hook exists before React's renderer evaluates and injects itself. */
+export function injectReactRefreshBootstrap(code) {
+    return {
+        code: `import ${JSON.stringify('/@react-refresh')};\n${code}`,
+        map: null
+    };
+}
+/** Connects the shared WX dev runtime to the application graph's Taro runtime instance. */
+export function injectTaroConnection(code) {
+    if (!/\bCurrent\b/.test(code) || !/\bdocument\b/.test(code) || !/\binjectPageInstance\b/.test(code)) {
+        throw new Error('WX Taro runtime must expose Current, document, and injectPageInstance for HMR');
+    }
+    const taroImport = `import { Current as __vptCurrent, document as __vptDocument, injectPageInstance as __vptInjectPageInstance } from ${JSON.stringify(taroRuntimeId)};`;
+    return {
+        code: `${code}\n${taroImport}\n__rolldown_runtime__.connectTaro(__vptCurrent, __vptDocument, __vptInjectPageInstance);`,
+        map: null
+    };
+}
+/** Activates development-only lifecycle handling for one plugin-owned Page capsule. */
+export function injectPageHmr(code, route) {
+    if (!/\bconst\s+config\s*=/.test(code) || !/\bexport\s+default\s+config\b/.test(code)) {
+        throw new Error('WX Page capsule must declare and default-export config before HMR injection');
+    }
+    return {
+        code: `${code}\n__rolldown_runtime__.injectPageHmr(config, ${JSON.stringify(route)});`,
+        map: null
+    };
+}
+/** Reads the stable route carried by every specialized Page capsule ID. */
+function getPageRoute(id) {
+    const queryIndex = id.indexOf('?');
+    const route = queryIndex < 0 ? null : new URLSearchParams(id.slice(queryIndex + 1)).get('route');
+    if (!route)
+        throw new Error(`WX Page capsule is missing its route: ${id}`);
+    return route;
+}
+// The assembled runtime chunk is byte-identical on every build (the base runtime and the
+// bundled implement are immutable for the server's lifetime), so the lowering runs once
+// and every build reuses it.
+const fixRolldownRuntime = memoize((code) => {
+    return transformWithOxc(code, rolldownRuntimeId, {
+        lang: 'js',
+        target: esTarget,
+        sourcemap: false,
+        assumptions: { setPublicClassFields: true }
+    });
+});

package/dist/node/plugins/wx/dev/react-refresh.d.ts

@@ -5,8 +5,7 @@ import type { Plugin } from 'vite';
  * @vitejs/plugin-react's generated refresh code assumes the web HTML preamble and a browser
  * global scope; wx has neither. Each transform adapts one piece of that contract:
  * - the refresh runtime module (id-filtered): the vendored runtime reads and assigns
- *   `window` protocol globals (rewritten to `global`) and must inject itself at evaluation
- *   — the preamble's `injectIntoGlobalHook` call has no HTML home in wx;
+ *   `window` protocol globals (rewritten to `global`) and must inject itself at evaluation;
  * - react-family modules (filtered on free references): the DevTools hook is read as a free
  *   variable, which the WeChat runtime scope never resolves against `global` — every free
  *   reference becomes an explicit member access;

package/dist/node/plugins/wx/dev/react-refresh.js

@@ -20,8 +20,7 @@ const refreshRuntimeWindowGlobals = ['__registerBeforePerformReactRefresh', '__g
  * @vitejs/plugin-react's generated refresh code assumes the web HTML preamble and a browser
  * global scope; wx has neither. Each transform adapts one piece of that contract:
  * - the refresh runtime module (id-filtered): the vendored runtime reads and assigns
- *   `window` protocol globals (rewritten to `global`) and must inject itself at evaluation
- *   — the preamble's `injectIntoGlobalHook` call has no HTML home in wx;
+ *   `window` protocol globals (rewritten to `global`) and must inject itself at evaluation;
  * - react-family modules (filtered on free references): the DevTools hook is read as a free
  *   variable, which the WeChat runtime scope never resolves against `global` — every free
  *   reference becomes an explicit member access;
@@ -87,7 +86,7 @@ export function createWxReactRefreshTransforms() {
  * The protocol name is unique, but only reference identifiers are rewritten. Declaration
  * keys and explicit members such as `global.__REACT_DEVTOOLS_GLOBAL_HOOK__` must remain
  * untouched; rewriting those would either produce invalid syntax or double-prefix the hook.
- * The hook itself is created on `global` by the dev runtime chunk in `dev-runtime.ts`.
+ * The eagerly evaluated refresh runtime creates the hook on `global` before the renderer loads.
  */
 function createReactDevtoolsHookVisitor(editor) {
     return function enter(node, parent) {
@@ -127,18 +126,17 @@ function createRefreshRuntimeVisitor(editor) {
     // unimplemented in wx.
     editor.append('\ninjectIntoGlobalHook(global);');
     return function enter(node) {
-        if (node.type !== 'MemberExpression' ||
-            node.computed ||
-            node.object.type !== 'Identifier' ||
-            node.object.name !== 'window' ||
-            node.property.type !== 'Identifier' ||
-            !refreshRuntimeWindowGlobals.some((globalName) => globalName === node.property.name)) {
-            return;
+        if (node.type === 'MemberExpression' &&
+            !node.computed &&
+            node.object.type === 'Identifier' &&
+            node.object.name === 'window' &&
+            node.property.type === 'Identifier' &&
+            refreshRuntimeWindowGlobals.some((globalName) => globalName === node.property.name)) {
+            // `global` is the shared wx App heap used by the dev runtime and hook injection. Only
+            // replacing the object range preserves the vendored runtime byte-for-byte otherwise
+            // and prevents unrelated `window` expressions from being silently adapted.
+            editor.overwrite(node.object.start, node.object.end, 'global');
         }
-        // `global` is the shared wx App heap used by the dev runtime and hook injection. Only
-        // replacing the object range preserves the vendored runtime byte-for-byte otherwise
-        // and prevents unrelated `window` expressions from being silently adapted.
-        editor.overwrite(node.object.start, node.object.end, 'global');
     };
 }
 /**

package/dist/node/plugins/wx/dev/wx-dev-options.js

@@ -93,7 +93,8 @@ function createEntryBanner(pageFiles) {
         }
         if (pageFiles.has(chunk.name)) {
             const patchesPath = path.posix.relative(path.posix.dirname(chunk.fileName), 'hmr/patches.js');
-            return `__rolldown_runtime__.applyPatches(require('${patchesPath}'));\n`;
+            const route = chunk.name.slice(0, -'.js'.length);
+            return `__rolldown_runtime__.applyPatches(require('${patchesPath}'), ${JSON.stringify(route)});\n`;
         }
         return '';
     };

package/dist/node/plugins/wx/module.d.ts

@@ -27,6 +27,8 @@ export declare const pageComponentId = "\0vpt:page-component";
 export declare const pageCapsuleId = "\0vpt:page-capsule";
 /** Provides the Page capsule source specialized through a stable route query. */
 export declare const pageCapsulePath: string;
+/** Identifies the Taro facade shared by the App, Page, and recursive Component capsules. */
+export declare const taroRuntimePath: string;
 /** Identifies the reusable synchronous native Page shell source. */
 export declare const pageShellPath: string;
 export type WxChunk = Rolldown.PreRenderedChunk | Rolldown.RenderedChunk;

package/dist/node/plugins/wx/module.js

@@ -29,6 +29,8 @@ export const pageComponentId = '\0vpt:page-component';
 export const pageCapsuleId = '\0vpt:page-capsule';
 /** Provides the Page capsule source specialized through a stable route query. */
 export const pageCapsulePath = resolvePackageFile('dist/runtime/wx/capsule/page.js');
+/** Identifies the Taro facade shared by the App, Page, and recursive Component capsules. */
+export const taroRuntimePath = resolvePackageFile('dist/runtime/wx/capsule/taro-runtime.js');
 /** Identifies the reusable synchronous native Page shell source. */
 export const pageShellPath = resolvePackageFile('dist/runtime/wx/native/page.js');
 // These fixed source identities describe entry roles independently from the final execution kind. A capsule entry may,

package/dist/node/plugins/wx/plugins.js

@@ -1,7 +1,7 @@
 import { esTarget } from '../../utils/constant.js';
 import { packageRequire } from '../../utils/packages.js';
 import { clientTaroNativeId } from '../client/constant.js';
-import { createWxDevelopmentPlugin } from './dev/plugin.js';
+import { createWxDevelopmentPlugin } from './dev/plugins.js';
 import { getWxExecutionKind, isTransportModule } from './module.js';
 import { compileNativeComponentInterface } from './native/compile-native-component-interface.js';
 import { getNativeComponentAssetBytes } from './native/native-component-assets.js';

package/dist/runtime/wx/capsule/page.js

@@ -2,67 +2,6 @@
 import './app.js';
 // @ts-expect-error: The wx build replaces this private import with the configured Page component.
 import PageComponent from '\0vpt:page-component';
-import { Current, createPageConfig, document, injectPageInstance } from './taro-runtime.js';
+import { createPageConfig } from './taro-runtime.js';
 const config = createPageConfig(PageComponent, __VITE_PLUGIN_TARO_PAGE_PATH__, { root: { cn: [] } }, __VITE_PLUGIN_TARO_PAGE_CONFIG__);
 export default config;
-/** Forwards a call with the native page instance as `this`, matching Taro's invocation. */
-function forward(handler, receiver, args) {
-    ;
-    handler?.apply(receiver, args);
-}
-// DevTools re-executes the page and replays the replacement lifecycle on every edit. Taro's
-// onUnload unmounts the React tree and onLoad mounts a fresh one, destroying state. While
-// the runtime says a patch was just delivered, the pair is intercepted instead: onUnload
-// captures the surviving page identity, and onLoad restores it onto the replacement native
-// instance and rebinds the retained tree to it (pageElement.ctx + a full re-render). The
-// capsule module is cached across re-executions, so this closure holds the capture.
-// Ordinary navigation (no patch) passes through unchanged. The wrappers are regular
-// functions so the native page instance (`this`) reaches the original handlers.
-if (typeof __rolldown_runtime__ !== 'undefined') {
-    const originalOnUnload = config.onUnload;
-    const originalOnLoad = config.onLoad;
-    const originalOnShow = config.onShow;
-    let captured;
-    config.onUnload = function (...args) {
-        if (__rolldown_runtime__.isHotReloading()) {
-            const instance = this;
-            captured = {
-                $taroPath: instance.$taroPath,
-                $taroParams: instance.$taroParams
-            };
-            return;
-        }
-        forward(originalOnUnload, this, args);
-    };
-    config.onLoad = function (...args) {
-        if (__rolldown_runtime__.isHotReloading() && captured) {
-            // Restore the surviving page identity onto the replacement native instance: the
-            // re-loaded $taroPath embeds a fresh timestamp, so without this the tree and the
-            // native side would disagree on the page key.
-            const instance = this;
-            instance.$taroPath = captured.$taroPath;
-            instance.$taroParams = captured.$taroParams;
-            // Rebind the retained tree to the replacement receiver and resync the native
-            // data: updateChildNodes enqueues the full hydrated node tree (root.cn) — the
-            // surviving tree's mutations were consumed long ago, so without it the payload
-            // queue is empty and the new receiver renders nothing.
-            injectPageInstance(instance, captured.$taroPath);
-            Current.page = instance;
-            const pageElement = document.getElementById(captured.$taroPath);
-            pageElement.ctx = instance;
-            pageElement.updateChildNodes();
-            pageElement.performUpdate(true);
-            return;
-        }
-        forward(originalOnLoad, this, args);
-    };
-    config.onShow = function (...args) {
-        if (__rolldown_runtime__.isHotReloading()) {
-            // The window ends at the first show; the user's onShow must not re-run on a
-            // synthetic re-execution (it could reset state).
-            __rolldown_runtime__.clearHotReloading();
-            return;
-        }
-        forward(originalOnShow, this, args);
-    };
-}