vite-plugin-taro 0.7.3 → 0.7.4

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

@@ -1,7 +1,10 @@
-import type { Rolldown } from 'vite';
+import { type Rolldown } from 'vite';
 import type { RuntimeModulesContract } from '../mini-contract.ts';
+export declare const miniRuntimeId: string;
 /** Identifies Rolldown's generated helper module independently of its unstable output filename. */
 export declare const rolldownRuntimeId = "\0rolldown/runtime.js";
+/** Generates the selected core-js imports as one independently executable output entry. */
+export declare const miniPolyfillsId = "\0vpt:mini-polyfills";
 /** Resolves the shared Taro facade's target initialization side effect. */
 export declare const taroTargetRuntimeId = "\0vpt:taro-target-runtime";
 /** Redirects Vite's injected browser preload helper to the bootstrap identity loader. */
@@ -27,12 +30,15 @@ export type MiniChunkClassification = Readonly<{
     executionKind: MiniExecutionKind;
     isTransport: boolean;
 }>;
-/** Classifies final chunks against one immutable shared-runtime module table. */
+/** Classifies chunks by runtime roles and framework vendor membership. */
 export type MiniModuleClassifier = (chunk: MiniChunk) => MiniChunkClassification;
+/** Groups the generated entry and core-js into common/polyfills.js. */
+export declare function isMiniPolyfillModule(moduleId: string): boolean;
+/** Uses the same resolved roots for vendor grouping and amphibious execution; Rolldown includes their dependencies. */
+export declare function isMiniFrameworkVendorModule(moduleId: string): boolean;
 /**
- * Creates a classifier whose fixed identity sets are shared by every chunk in one plugin instance.
- *
- * Construction is O(1). Each classification normalizes every module ID exactly once and runs in O(M), where M is the number
- * of modules in the chunk. This replaces separate shell, capsule, amphibious, and transport scans.
+ * Classifies runtime entries and framework vendor chunks in one module-ID scan.
+ * Amphibious chunks share bootstrap's bridge so native and SystemJS callers reuse the same exports.
+ * Construction is O(1); each lookup is O(M), where M is the number of modules in the chunk.
  */
 export declare function createMiniModuleClassifier(modules: RuntimeModulesContract): MiniModuleClassifier;

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

@@ -1,10 +1,8 @@
-import { type Plugin, type Rolldown } from 'vite';
+import type { Plugin, Rolldown } from 'vite';
 import type { RuntimeModulesContract } from '../mini-contract.ts';
-import { type MiniChunkClassification, type MiniModuleClassifier } from '../module/module.ts';
+import { isMiniPolyfillModule, type MiniChunkClassification, type MiniModuleClassifier } from '../module/module.ts';
 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 isMiniFrameworkVendorModule(moduleId: string): boolean;
 /** Placement services consumed by the later Mini Program rendering and output hooks. */
 export type MiniPlacementPlugin = Plugin & Readonly<{
     classifyChunk(chunk: Rolldown.PreRenderedChunk | Rolldown.RenderedChunk): MiniChunkClassification;
@@ -24,15 +22,15 @@ export declare function createPlacementRolldownOptions(classifyChunk: MiniModule
      */
     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
+         * React and Taro form one stable framework boundary shared by the App and every Page capsule. Keeping their framework
+         * dependencies together prevents application edits from invalidating framework chunk identity and makes later
          * development generations eligible to reuse the unchanged vendor. Application code and other dependencies
          * use Rolldown's automatic chunking without source-path groups or a blanket external vendor group.
          */
         codeSplitting: {
             groups: {
                 name: string;
-                test: typeof isMiniFrameworkVendorModule;
+                test: typeof isMiniPolyfillModule;
                 priority: number;
                 includeDependenciesRecursively: boolean;
             }[];

package/dist/node/plugins/mini/polyfill/create-mini-polyfill-plugin.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from 'vite';
+import type { MiniContract } from '../mini-contract.ts';
+/** Loads a standalone polyfills entry before bootstrap and retains Taro's renderer bindings. */
+export declare function createMiniPolyfillPlugin(contract: Pick<MiniContract, 'options'>): Plugin;

package/dist/node/plugins/mini/polyfill/mini-browser-bindings.d.ts

@@ -0,0 +1,13 @@
+/** Taro's renderer-owned browser bindings; portable APIs use native globals or explicit polyfills. */
+export declare const miniBrowserBindings: {
+    window: [string, string];
+    document: [string, string];
+    navigator: [string, string];
+    requestAnimationFrame: [string, string];
+    cancelAnimationFrame: [string, string];
+    Element: [string, string];
+    SVGElement: [string, string];
+    MutationObserver: [string, string];
+    history: [string, string];
+    location: [string, string];
+};

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

@@ -4,7 +4,7 @@ import type { MiniModuleClassifier } from '../module/module.ts';
 /**
  * Materializes one final native/amphibious Rolldown chunk as executable Mini Program CommonJS.
  *
- * The transform performs four semantic operations:
+ * The transform performs five 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.
@@ -14,6 +14,8 @@ import type { MiniModuleClassifier } from '../module/module.ts';
  *    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.
+ * 5. Dynamic imports call the shared SystemJS loader. Relative string literals become logical chunk IDs, while computed IDs
+ *    are preserved, matching capsule loading and leaving physical require/require.async selection to transport.
  *
  * 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

package/dist/node/plugins/mini/styles/minify-mini-stylesheet.d.ts

@@ -0,0 +1,6 @@
+import type { BuildOptions } from 'vite';
+/** Minifies only the completed global native stylesheet, without another browser compatibility or preprocessing pass. */
+export declare function minifyMiniStylesheet(css: string, options: Readonly<{
+    filename: string;
+    minify: BuildOptions['cssMinify'];
+}>): Promise<string>;

package/dist/node/plugins/mini/styles/plugins.d.ts

@@ -1,6 +1,7 @@
 import { type Plugin } from 'vite';
 import type { MiniContract } from '../mini-contract.ts';
 import { createMiniTransformer } from './create-mini-transformer.ts';
+import { minifyMiniStylesheet } from './minify-mini-stylesheet.ts';
 /** JavaScript code plus the physical filename required by the Mini Program class-name transformer. */
 type JavaScriptArtifact = Readonly<{
     code: string;
@@ -77,10 +78,12 @@ export type MiniStylePlugin = Plugin & Readonly<{
  *
  * ### 4. Shared native-style finalization
  *
- * `finalizeOutput()` first converts the concatenated reachable CSS to native CSS, then transforms each JavaScript artifact
- * with the same projected class set. It returns data and performs no bundle mutation or filesystem publication. If either
- * transformation fails, the promise rejects before callers expose partial output. JavaScript conversion is skipped when the
- * projection contains no Tailwind candidates, preserving ordinary bundle bytes.
+ * `finalizeOutput()` converts the concatenated reachable CSS to native CSS, optionally minifies that complete global file
+ * (including HTML defaults), then transforms each JavaScript artifact with the same projected class set. Both builds and HMR
+ * follow `build.cssMinify`, defaulting to `build.minify`, using Lightning CSS. Vite's intermediate CSS minification
+ * remains disabled so only final native bytes are optimized. The function returns data without bundle mutation or filesystem
+ * publication. Any conversion or minification failure rejects before callers expose partial output. JavaScript conversion is
+ * skipped when the projection contains no Tailwind candidates, preserving ordinary bundle bytes.
  *
  * ### 5a. Complete-build commit
  *
@@ -100,8 +103,9 @@ export type MiniStylePlugin = Plugin & Readonly<{
  *
  * ## Retained state and lifecycle
  *
- * The factory retains four explicit mutable state owners plus one fixed transformation service:
+ * The factory retains five explicit mutable state owners plus one fixed transformation service:
  *
+ * - `cssMinify`: requested global-style minification captured before disabling Vite's intermediate pass, then resolved once;
  * - `entryIds`: graph-exact App/Page entry identities resolved at the start of each build;
  * - `graphContext`: the active Rolldown graph reader needed by host calls made outside plugin hooks;
  * - `styleByModuleId`: the latest successful Vite CSS plus optional Tailwind state at one normalized module identity;
@@ -118,14 +122,15 @@ export type MiniStylePlugin = Plugin & Readonly<{
  * chunks then parse and walk in `O(J)`; replacing `Kᵢ` candidate tokens in literal `i` costs `O(LᵢKᵢ)` while preserving
  * untouched bytes through Rolldown's native editor. Retained memory is `O(B + C + D + F)` for latest CSS, candidate sets,
  * compiler dependencies, and watched file identities; no second application graph is retained. The Tailwind generator stays
- * alive across candidate edits to avoid repeating source normalization and compiler initialization.
+ * alive across candidate edits to avoid repeating source normalization and compiler initialization. Enabled minification parses
+ * the one final global stylesheet in builds and HMR; no extra source reads or graph traversals are needed.
  */
 export declare function createMiniStylePlugin(contract: Pick<MiniContract, 'styles'>, applicationEntryIds: readonly string[]): MiniStylePlugin;
 /**
  * Produces native CSS and JavaScript from one live-graph projection.
  *
  * The function receives every stateful dependency explicitly so tests and both output modes execute the same algorithm. It
- * completes stylesheet conversion before JavaScript conversion and returns bytes without publishing or mutating caller artifacts.
+ * completes stylesheet conversion and optional minification before JavaScript conversion and returns bytes without publication.
  */
 export declare function finalizeOutput(entryIds: readonly string[], styleByModuleId: ReadonlyMap<string, Readonly<{
     css: string | undefined;
@@ -135,7 +140,7 @@ export declare function finalizeOutput(entryIds: readonly string[], styleByModul
 }>>, getModuleInfo: (moduleId: string) => Readonly<{
     importedIds: readonly string[];
     dynamicallyImportedIds: readonly string[];
-}> | null | undefined, miniTransformer: MiniTransformer, javaScript: readonly JavaScriptArtifact[]): Promise<{
+}> | null | undefined, miniTransformer: MiniTransformer, javaScript: readonly JavaScriptArtifact[], stylesheetOptions: Parameters<typeof minifyMiniStylesheet>[1]): Promise<{
     javaScript: string[];
     stylesheet: string;
 }>;

package/dist/options.d.ts

@@ -92,6 +92,20 @@ export interface VptOptions {
      * The file is emitted only when this value is provided for a `wx` build. It is ignored for ZFB and H5.
      */
     sitemapJson?: VptJsonObject;
+    /**
+     * Add JavaScript and Web APIs that your mini app needs but its host may not provide.
+     *
+     * Use core-js module names without the `core-js/modules/` prefix or `.js` suffix; no separate core-js installation is needed.
+     * For example, `web.url` provides `URL` and `URLSearchParams`, while `es.array.at` provides `Array.prototype.at`.
+     * On WX, use `globalThis.URL` or add `define: { URL: 'globalThis.URL' }` to your Vite config for bare `URL` references.
+     *
+     * Selected polyfills run before your app in development and production, updating global APIs and prototypes when needed.
+     * Omit this option or use `[]` to add no optional polyfills. H5 ignores this option.
+     *
+     * @example
+     * polyfills: ['web.url', 'es.array.at']
+     */
+    polyfills?: readonly string[];
     /**
      * Selects the Mini Program development update mode. Omission uses `devtools`.
      *

package/dist/runtime/mini/amphibious/bootstrap.d.ts

@@ -1,2 +1,3 @@
+import '\0vpt:mini-polyfills';
 import '../systemjs/system-core.js';
 export declare const __vitePreload: <Value>(load: () => Value) => Value;

package/dist/runtime/mini/amphibious/bootstrap.js

@@ -1,3 +1,6 @@
+// Install the selected polyfills before the runtime or application uses them.
+// @ts-expect-error: The Mini build resolves this private polyfills entry.
+import '\0vpt:mini-polyfills';
 // Install the minimal SystemJS loader and its synchronous-import extension before any native entry requests a capsule.
 import '../systemjs/system-core.js';
 import { transport } from './transport.js';

package/dist/runtime/mini/dev/mini-hmr-runtime.js

@@ -79,9 +79,8 @@ export class MiniHmrRuntime extends DevRuntime {
         // The base has no messenger: the engine tracks per-client shipped payloads instead
         // of executed module ids, so the Mini Program host registers the client session itself.
         super('');
-        // Rolldown schedules each generated React Refresh boundary with queueMicrotask. This shared runtime is constructed before
-        // any application factory, so installing the language-global fallback here covers every Mini target and development mode
-        // at the one common execution boundary while leaving production output untouched.
+        // Generated React Refresh boundaries need this host primitive before any application factory runs.
+        // Installing it in the shared development runtime covers every Mini target and mode without production overhead.
         polyfillQueueMicrotask(globalThis);
         this.connectSocket = connectSocket;
     }

package/dist/runtime/mini/dev/modes/interpreter/interpreter-runtime.js

@@ -11,15 +11,10 @@ class InterpreterHmrRuntime extends MiniHmrRuntime {
     installPatch;
     constructor(connectSocket) {
         super(connectSocket);
-        const interpreter = new Sval();
-        interpreter.import('__rolldown_runtime__', this);
-        /*
-         * Sval snapshots its sandbox built-ins while its module evaluates, before this runtime's base constructor can install
-         * Mini polyfills. Import the resulting host function explicitly so interpreted Rolldown Refresh wrappers resolve the
-         * same queue as physical chunks; otherwise their first free `queueMicrotask` lookup aborts the patch before registration.
-         */
-        interpreter.import('queueMicrotask', globalThis.queueMicrotask);
-        this.installPatch = (patch) => interpreter.run(patch.code);
+        // Trusted application patches share live host globals, including APIs installed during app startup, rather than Sval's
+        // module-time sandbox snapshot. A function scope keeps patch-local declarations isolated, as in native HMR factories.
+        const interpreter = new Sval({ sandBox: false });
+        this.installPatch = (patch) => interpreter.run(`(() => {\n${patch.code}\n})();`);
     }
     onSocketEvent(info, event, data) {
         if (event !== interpreterServerEvent) {

package/dist/runtime/mini/dev/polyfill/polyfill-queue-microtask.d.ts

@@ -3,12 +3,10 @@ type QueueMicrotaskGlobal = {
     queueMicrotask?: QueueMicrotask;
 };
 /**
- * Polyfills the microtask primitive required by Rolldown's development React Refresh boundaries.
+ * Provides the microtask primitive required by generated development React Refresh boundaries.
  *
- * Mini Program AppService engines do not share a `queueMicrotask` compatibility baseline, while every supported engine provides
- * Promise jobs. Every target adapter constructs its selected development runtime before any application factory evaluates, so
- * defining the primitive there covers WX and ZFB in every development mode. Reusing one resolved Promise preserves FIFO ordering
- * without rewriting generated modules, delaying registration to a timer task, or adding unused code to production builds.
+ * Supported Mini Program engines provide Promise jobs but do not share a queueMicrotask baseline.
+ * Reusing one resolved Promise preserves FIFO ordering without adding core-js or production code.
  */
 export declare function polyfillQueueMicrotask(runtimeGlobal: QueueMicrotaskGlobal): void;
 export {};

package/dist/runtime/mini/dev/polyfill/polyfill-queue-microtask.js

@@ -1,17 +1,15 @@
 /**
- * Polyfills the microtask primitive required by Rolldown's development React Refresh boundaries.
+ * Provides the microtask primitive required by generated development React Refresh boundaries.
  *
- * Mini Program AppService engines do not share a `queueMicrotask` compatibility baseline, while every supported engine provides
- * Promise jobs. Every target adapter constructs its selected development runtime before any application factory evaluates, so
- * defining the primitive there covers WX and ZFB in every development mode. Reusing one resolved Promise preserves FIFO ordering
- * without rewriting generated modules, delaying registration to a timer task, or adding unused code to production builds.
+ * Supported Mini Program engines provide Promise jobs but do not share a queueMicrotask baseline.
+ * Reusing one resolved Promise preserves FIFO ordering without adding core-js or production code.
  */
 export function polyfillQueueMicrotask(runtimeGlobal) {
-    if (runtimeGlobal.queueMicrotask !== undefined)
+    if (runtimeGlobal.queueMicrotask !== undefined) {
         return;
+    }
     const resolvedPromise = Promise.resolve();
-    // This is the one intentional global mutation: every independently bundled development chunk must resolve the same host
-    // primitive, and assigning the real global is the only scope shared by the injected runtime and later application factories.
+    // This intentional global mutation shares one host queue between native chunks and interpreted HMR patches.
     runtimeGlobal.queueMicrotask = (callback) => {
         void resolvedPromise.then(callback);
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite-plugin-taro",
-  "version": "0.7.3",
+  "version": "0.7.4",
   "author": "sep2",
   "description": "Vite 8 plugin for building one React/Taro codebase for WeChat, Alipay, and H5 targets.",
   "type": "module",
@@ -59,11 +59,13 @@
     "@tailwindcss/vite": "4.3.3",
     "@tarojs/shared": "4.2.1",
     "@vitejs/plugin-react": "^6.1.1",
+    "core-js": "^3.50.0",
+    "lightningcss": "1.33.0",
     "react-reconciler": "0.34.0",
     "rolldown": "1.2.8",
     "sval": "0.6.12",
     "tailwindcss": "^4.3.3",
-    "vite-plugin-taro-runtime": "0.7.3"
+    "vite-plugin-taro-runtime": "0.7.4"
   },
   "peerDependencies": {
     "react": "^19.3.0",