vite-plugin-taro 0.6.1 → 0.6.2

package/dist/node/plugins/h5/transform-app.js

@@ -1,4 +1,4 @@
-import { types } from '@babel/core';
+import * as types from '@babel/types';
 import { createPageComponentImportPath } from '../../utils/modules.js';
 import { createAppConfig } from '../../utils/project-config.js';
 import { replaceWithAst } from '../../utils/transform.js';

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

@@ -2,7 +2,7 @@ import { normalizePath, 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 { appCapsulePath, pageCapsulePath, rolldownRuntimeId, taroRuntimePath } from '../module/module.js';
 import { createWxDevHost } from './dev-host.js';
 import { developmentAppWxssFileName } from './hmr-files.js';
 import { createWxReactRefreshTransforms } from './react-refresh.js';

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

@@ -3,7 +3,7 @@ import { build } from 'rolldown';
 import { viteReporterPlugin } from 'rolldown/experimental';
 import { once } from '../../../utils/once.js';
 import { resolvePackageFile } from '../../../utils/packages.js';
-import { appShellFileName } from '../module.js';
+import { appShellFileName } from '../module/module.js';
 /**
  * Installs physical WX output and runtime conventions over Vite's browser-oriented bundled-development options.
  * Build completion deliberately remains outside this options adapter: DevEngine onOutput is the single lifecycle authority.

package/dist/node/plugins/wx/{module.js → module/module.js}

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import { normalizePath } from 'vite';
-import { normalizeModuleId } from '../../utils/modules.js';
-import { packageRequire, resolvePackageFile } from '../../utils/packages.js';
+import { normalizeModuleId } from '../../../utils/modules.js';
+import { packageRequire, resolvePackageFile } from '../../../utils/packages.js';
 /** Identifies Rolldown's generated helper module independently of its unstable output filename. */
 export const rolldownRuntimeId = '\0rolldown/runtime.js';
 /** Resolves the direct React Reconciler dependency without assuming pnpm's layout. */

package/dist/node/plugins/wx/placer/placement.d.ts

@@ -1,4 +1,5 @@
 import type { Rolldown } from 'vite';
+export declare const subpackagePlanningBudget = 1900000;
 /** Identifies one generated code-only subpackage by its physical output root. */
 export type SubpackageLocation = {
     /** Discriminates generated subpackages from main. */

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

@@ -1,6 +1,6 @@
 import { createHash } from 'node:crypto';
 // Leave headroom below WeChat's 2M subpackage limit for rendered wrappers and native assets.
-const subpackagePlanningBudget = 1_900_000;
+export const subpackagePlanningBudget = 1_900_000;
 const generatedSubpackageRootPrefix = 'sub/p_';
 /** Shared main-package value used for every synchronously reachable chunk. */
 const mainPackage = { kind: 'main' };

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

@@ -1,6 +1,8 @@
-import type { Plugin, Rolldown } from 'vite';
+import { type Plugin, type Rolldown } from 'vite';
 import { type GeneratedSubpackage, type PackageLocation } from './placement.ts';
 export type { GeneratedSubpackage, Placement } from './placement.ts';
+/** Selects the explicit React/Taro roots whose complete dependency closure forms the framework vendor chunk. */
+export declare function isWxFrameworkVendorModule(moduleId: string): boolean;
 /** Placement services consumed by the later `vpt:wx` rendering and output hooks. */
 export type WxPlacementPlugin = Plugin & Readonly<{
     getPackageLocation(chunk: Rolldown.RenderedChunk | Rolldown.OutputChunk): PackageLocation;
@@ -18,6 +20,20 @@ export declare const placementRolldownOptions: {
      * participation only; LTHP mutates the resulting OutputChunk filenames later without replacing the chunks.
      */
     output: {
+        /**
+         * React and Taro form one stable framework boundary shared by the App and every Page capsule. Keeping their complete
+         * dependency closure together prevents application edits from invalidating framework chunk identity and makes later
+         * development generations eligible to reuse the unchanged vendor. All remaining modules use Rolldown's automatic
+         * chunking; physical WX package placement operates on those final chunks without imposing another split strategy.
+         */
+        codeSplitting: {
+            groups: {
+                name: string;
+                test: typeof isWxFrameworkVendorModule;
+                priority: number;
+                includeDependenciesRecursively: boolean;
+            }[];
+        };
         /**
          * Native App/Page/Component shells are files addressed directly by WeChat and must retain the exact names configured
          * in `input`, such as `app.js` and `pages/home/index.js`. Transport is excluded even though it is CommonJS:

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

@@ -1,6 +1,14 @@
-import { getWxExecutionKind, isTransportModule } from '../module.js';
+import { normalizePath } from 'vite';
+import { getWxExecutionKind, isTransportModule } from '../module/module.js';
 import { getNativeComponentAssetBytes } from '../native/native-component-assets.js';
 import { createPlacement } from './placement.js';
+const pnpmFrameworkPackagePattern = /\/node_modules\/\.pnpm\/(?:@tarojs\+|react(?:-dom|-reconciler)?@|scheduler@)/;
+const workspaceFrameworkPackagePattern = /\/packages\/(?:taro-react|taro-plugin-framework-react)\//;
+/** Selects the explicit React/Taro roots whose complete dependency closure forms the framework vendor chunk. */
+export function isWxFrameworkVendorModule(moduleId) {
+    const normalizedId = normalizePath(moduleId);
+    return pnpmFrameworkPackagePattern.test(normalizedId) || workspaceFrameworkPackagePattern.test(normalizedId);
+}
 /**
  * Rolldown options owned by WX placement. Every field enforces a distinct output invariant. The plugin returns this object
  * from its config hook, while direct Rolldown integration tests reuse the same value to exercise the identical lifecycle.
@@ -11,6 +19,22 @@ export const placementRolldownOptions = {
      * participation only; LTHP mutates the resulting OutputChunk filenames later without replacing the chunks.
      */
     output: {
+        /**
+         * React and Taro form one stable framework boundary shared by the App and every Page capsule. Keeping their complete
+         * dependency closure together prevents application edits from invalidating framework chunk identity and makes later
+         * development generations eligible to reuse the unchanged vendor. All remaining modules use Rolldown's automatic
+         * chunking; physical WX package placement operates on those final chunks without imposing another split strategy.
+         */
+        codeSplitting: {
+            groups: [
+                {
+                    name: 'vendor',
+                    test: isWxFrameworkVendorModule,
+                    priority: 100,
+                    includeDependenciesRecursively: true
+                }
+            ]
+        },
         /**
          * Native App/Page/Component shells are files addressed directly by WeChat and must retain the exact names configured
          * in `input`, such as `app.js` and `pages/home/index.js`. Transport is excluded even though it is CommonJS:

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

@@ -2,7 +2,7 @@ import { esTarget } from '../../utils/constant.js';
 import { packageRequire } from '../../utils/packages.js';
 import { clientTaroNativeId } from '../client/constant.js';
 import { createWxDevelopmentPlugin } from './dev/plugins.js';
-import { getWxExecutionKind, isTransportModule } from './module.js';
+import { getWxExecutionKind, isTransportModule } from './module/module.js';
 import { compileNativeComponentInterface } from './native/compile-native-component-interface.js';
 import { createOutputFiles } from './output/files.js';
 import { createWxPlacementPlugin } from './placer/placer.js';

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

@@ -1,4 +1,36 @@
 import type { Rolldown } from 'vite';
-import { type AstTransformResult } from '../../../utils/transform.ts';
-/** Renders one ESM chunk as an inert SystemJS capsule. */
-export declare function renderCapsule(code: string, chunk: Rolldown.RenderedChunk, sourcemap?: boolean): AstTransformResult;
+import type { AstTransformResult } from '../../../utils/transform.ts';
+/**
+ * Converts one final Rolldown ESM chunk into the inert registration consumed by the WX module runtime.
+ *
+ * Why this boundary exists:
+ *
+ * - Rolldown produces an ESM chunk graph, but a Mini Program loads emitted JavaScript through native `require` and
+ *   `require.async`; it does not provide the browser ESM loader that normally links Vite chunks.
+ * - Native App, Page, and Component shells must start through WeChat's synchronous lifecycle APIs, while their application
+ *   graph still needs ESM linking semantics such as cycles, live exports, dynamic imports, `import.meta`, and top-level await.
+ * - The plugin therefore keeps native lifecycle shells as CommonJS and executes application "capsules" through the bundled
+ *   SystemJS runtime. Native shells enter that graph with `global.System.importSync`, and genuine asynchronous boundaries use
+ *   the same runtime through `System.import`.
+ *
+ * What this renderer emits:
+ *
+ * The result is CommonJS source whose `module.exports` is a SystemJS registration tuple:
+ * `[logicalDependencyIds, declaration]`. Requiring a capsule only returns this inert tuple; it does not execute application
+ * code or call a global `System.register`. The generated transport can consequently load the physical file from either the
+ * main package or a subpackage, then hand its registration to the loader. The loader owns linking, setter invocation,
+ * execution order, cycle handling, and export publication.
+ *
+ * Why references are rewritten:
+ *
+ * Rolldown imports name physical output files whose relative paths include placement directories and content hashes. The
+ * SystemJS registry instead uses package-neutral logical chunk IDs. Canonicalizing both static and literal dynamic references
+ * here lets transport independently map a stable module identity to the physical `require` path selected by WX placement.
+ * Runtime-computed dynamic IDs cannot be canonicalized and are intentionally preserved.
+ *
+ * This function runs on final Rolldown output rather than arbitrary source modules. `transformSystemJs` accepts only the
+ * normalized final-chunk grammar required by this pipeline and fails the build on unsupported forms instead of risking a
+ * partial or semantically incorrect capsule. Source maps remain optional because WX development output deliberately disables
+ * them on this startup-critical path.
+ */
+export declare function renderCapsule(code: string, chunk: Rolldown.RenderedChunk, sourcemap: boolean): AstTransformResult;

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

@@ -1,13 +1,54 @@
-import transformDynamicImport from '@babel/plugin-transform-dynamic-import';
-import transformModulesSystemjs from '@babel/plugin-transform-modules-systemjs';
-import { transformWithBabel } from '../../../utils/transform.js';
-import { wrapCapsulePlugin } from './capsule-wrapper.js';
-/** Renders one ESM chunk as an inert SystemJS capsule. */
-export function renderCapsule(code, chunk, sourcemap = true) {
-    return transformWithBabel(code, chunk.fileName, [
-        transformDynamicImport,
-        // Erase Babel's internal plugin pass type.
-        transformModulesSystemjs,
-        wrapCapsulePlugin(chunk.fileName)
-    ], sourcemap);
+import { resolveLogicalChunkReference } from '../module/chunk-path.js';
+import { transformSystemJs } from './system-js/system-js.js';
+/**
+ * Converts one final Rolldown ESM chunk into the inert registration consumed by the WX module runtime.
+ *
+ * Why this boundary exists:
+ *
+ * - Rolldown produces an ESM chunk graph, but a Mini Program loads emitted JavaScript through native `require` and
+ *   `require.async`; it does not provide the browser ESM loader that normally links Vite chunks.
+ * - Native App, Page, and Component shells must start through WeChat's synchronous lifecycle APIs, while their application
+ *   graph still needs ESM linking semantics such as cycles, live exports, dynamic imports, `import.meta`, and top-level await.
+ * - The plugin therefore keeps native lifecycle shells as CommonJS and executes application "capsules" through the bundled
+ *   SystemJS runtime. Native shells enter that graph with `global.System.importSync`, and genuine asynchronous boundaries use
+ *   the same runtime through `System.import`.
+ *
+ * What this renderer emits:
+ *
+ * The result is CommonJS source whose `module.exports` is a SystemJS registration tuple:
+ * `[logicalDependencyIds, declaration]`. Requiring a capsule only returns this inert tuple; it does not execute application
+ * code or call a global `System.register`. The generated transport can consequently load the physical file from either the
+ * main package or a subpackage, then hand its registration to the loader. The loader owns linking, setter invocation,
+ * execution order, cycle handling, and export publication.
+ *
+ * Why references are rewritten:
+ *
+ * Rolldown imports name physical output files whose relative paths include placement directories and content hashes. The
+ * SystemJS registry instead uses package-neutral logical chunk IDs. Canonicalizing both static and literal dynamic references
+ * here lets transport independently map a stable module identity to the physical `require` path selected by WX placement.
+ * Runtime-computed dynamic IDs cannot be canonicalized and are intentionally preserved.
+ *
+ * This function runs on final Rolldown output rather than arbitrary source modules. `transformSystemJs` accepts only the
+ * normalized final-chunk grammar required by this pipeline and fails the build on unsupported forms instead of risking a
+ * partial or semantically incorrect capsule. Source maps remain optional because WX development output deliberately disables
+ * them on this startup-critical path.
+ */
+export function renderCapsule(code, chunk, sourcemap) {
+    return transformSystemJs({
+        code,
+        filename: chunk.fileName,
+        // Native require must return registration data without executing or globally registering the capsule.
+        format: 'commonjs-registration',
+        sourcemap,
+        // Bind every compile-time chunk edge to the same logical identity understood by transport and SystemJS.
+        resolveReference(reference, kind) {
+            return resolveCapsuleReference(chunk.fileName, reference, kind);
+        }
+    });
+}
+/** Canonicalizes physical chunk paths while preserving runtime-computed and package-like dynamic IDs. */
+function resolveCapsuleReference(fileName, reference, kind) {
+    if (kind === 'dynamic' && !reference.startsWith('./') && !reference.startsWith('../'))
+        return reference;
+    return resolveLogicalChunkReference(fileName, reference);
 }

package/dist/node/plugins/wx/render/native.d.ts

@@ -1,6 +1,24 @@
 import type { Rolldown } from 'vite';
-import { type AstTransformResult } from '../../../utils/transform.ts';
-/** Renders a native module while activating its statically imported capsules through SystemJS. */
+import type { AstTransformResult } from '../../../utils/transform.ts';
+/**
+ * Materializes one final native/amphibious Rolldown chunk as executable WX CommonJS.
+ *
+ * The transform performs four semantic operations:
+ *
+ * 1. Static ESM imports are hoisted into source-order `require` calls. Named imports remain property reads from the required
+ *    namespace so they observe current values. Default and namespace imports receive Babel-compatible CommonJS interop.
+ * 2. An import whose target owns a capsule entry is not passed to native `require`. It becomes
+ *    `global.System.importSync(logicalChunkId)`, synchronously linking the capsule before the native lifecycle call.
+ * 3. Local exports are published at declaration and mutation points. Imported re-exports use getters, while assignments and
+ *    updates notify every alias without changing expression completion values or accidentally matching shadowed bindings.
+ * 4. ESM top-level `this` becomes `undefined`. Direct imported calls and tags are explicitly unbound so converting an import
+ *    into a namespace property does not introduce a false CommonJS receiver.
+ *
+ * Static dependency loading is emitted before the untouched module body because ESM evaluates dependencies before body
+ * statements regardless of where import declarations appear textually. Generated helper names are allocated against every
+ * source identifier. Source maps use the same range edits when requested; WX development disables them and keeps this path
+ * focused on startup latency.
+ */
 export declare function renderNative({ code, chunk, chunks, sourcemap }: {
     code: string;
     chunk: Rolldown.RenderedChunk;