vite-plugin-taro 0.6.2 → 0.6.5

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

@@ -3,11 +3,11 @@ import { normalizeModuleId, resolveAppComponentPath, resolvePageComponentPath }
 import { createAppConfig } from '../../../utils/project-config.js';
 import { appComponentId } from '../../client/constant.js';
 import { appCapsulePath, appShellFileName, appShellPath, bootstrapPath, componentCapsulePath, componentShellFileName, componentShellPath, pageCapsuleId, pageCapsulePath, pageComponentId, pageShellPath, transportPath, vitePreloadId } from '../module/module.js';
-import { specializeBootstrap } from './specialize-bootstrap.js';
+import { specializeAppCapsule } from './specialize-app-capsule.js';
 import { specializePageCapsule } from './specialize-page-capsule.js';
 /** Creates the resolver and source specializer for the wx module graph. */
 export function createResolver(options) {
-    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.
     const entryGraph = createEntryGraph(options.pages);
@@ -42,8 +42,8 @@ export function createResolver(options) {
         },
         specialize(code, id, 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) {
                 return specializePageCapsule({

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

@@ -1,7 +1,7 @@
 import type { VptJsonObject } from '../../../../options.ts';
 import { type AstTransformResult } from '../../../utils/transform.ts';
-/** Specializes the amphibious bootstrap with the shared App configuration. */
-export declare function specializeBootstrap({ code, id, appConfig, sourcemap }: {
+/** Specializes the App capsule with its normalized native configuration. */
+export declare function specializeAppCapsule({ code, id, appConfig, sourcemap }: {
     code: string;
     id: string;
     appConfig: VptJsonObject;

package/dist/node/plugins/wx/resolve/{specialize-bootstrap.js → specialize-app-capsule.js}

@@ -1,8 +1,8 @@
 import * as types from '@babel/types';
 import { replaceWithAst } from '../../../utils/transform.js';
 const appConfigPlaceholder = '__VPT_APP_CONFIG__';
-/** Specializes the amphibious bootstrap with the shared App configuration. */
-export function specializeBootstrap({ code, id, appConfig, sourcemap = true }) {
+/** Specializes the App capsule with its normalized native configuration. */
+export function specializeAppCapsule({ code, id, appConfig, sourcemap = true }) {
     return replaceWithAst(code, id, {
         [appConfigPlaceholder]: types.valueToNode(appConfig)
     }, sourcemap);

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

@@ -1,3 +1,141 @@
-import type { PluginOption } from 'vite';
-/** Creates the complete WX Tailwind and global-style pipeline. */
-export declare function createWxStylePlugins(): PluginOption[];
+import { type Plugin } from 'vite';
+import { createContext } from 'weapp-tailwindcss/core';
+/** JavaScript code plus the physical filename required by the Weapp JavaScript transformer. */
+type JavaScriptArtifact = Readonly<{
+    code: string;
+    filename: string;
+}>;
+/** Vite plugin with the development-host operation that finalizes one coherent WX style/JavaScript transaction. */
+export type WxStylePlugin = Plugin & Readonly<{
+    /** Converts patch factories and publishes their matching global WXSS through the host's atomic writer. */
+    finalizeUpdate: <Artifact extends JavaScriptArtifact>(artifacts: readonly Artifact[], writeWxss: (wxss: string) => Promise<void>) => Promise<readonly Artifact[]>;
+}>;
+/**
+ * Creates the single owner of global WX style compilation, graph projection, JavaScript class rewriting, and publication.
+ *
+ * ## Architectural invariant
+ *
+ * A WX transaction must expose JavaScript and WXSS produced from one class-identity snapshot. Tailwind utility names can be
+ * rewritten for WeChat—for example, `py-5.5` becomes `py-5_d5`—so publishing either side independently can leave running code
+ * referring to selectors that do not yet exist. This plugin therefore treats reachable CSS, Tailwind candidates, converted
+ * WXSS, and converted JavaScript as one output. Complete builds and HMR updates both call `finalizeOutput()`; they differ only
+ * in how the returned bytes are materialized.
+ *
+ * ## Ownership boundaries
+ *
+ * The pipeline deliberately gives each subsystem one responsibility:
+ *
+ * 1. Rolldown owns module reachability and invalidation. VPT reads `getModuleInfo()` and registers watch files, but does not
+ *    maintain a second import graph or decide independently which root should rerun.
+ * 2. The persistent Tailwind generator owns candidate discovery and incremental candidate removal. VPT invokes it only from
+ *    the owning CSS root's Rolldown transform and never rescans the project during output publication.
+ * 3. Vite owns preprocessors, PostCSS, CSS Modules, and final module CSS semantics. VPT observes the input to the resolved
+ *    `vite:css-post` hook only after the original hook succeeds; it never rereads source files or repeats CSS preprocessing.
+ * 4. The Weapp transformation context owns WX selector conversion and JavaScript class-string conversion. One retained context
+ *    and one projected candidate set drive both operations.
+ * 5. VPT owns physical global WXSS and patch publication. Vite's browser CSS asset is only an intermediate carrier and is
+ *    removed before VPT emits `assets/global.wxss`.
+ *
+ * Native Page and component WXSS are outside this global pipeline. The WX output plugin is registered after this style plugin
+ * and emits those opaque companions later. The WX configuration also enforces `cssCodeSplit: false`, so Vite contributes at
+ * most one browser compiler stylesheet for this plugin to replace.
+ *
+ * ## Compilation phases
+ *
+ * ### 1. Tailwind pre-transform
+ *
+ * The pre-transform checks physical application CSS for Tailwind imports or directives. Ordinary styles pass through. A
+ * Tailwind root compiles to browser CSS before Vite's normal CSS pipeline runs. Successful generation records the generator,
+ * scanner, current class set, compiler dependencies, and exact root source under the normalized physical module ID.
+ *
+ * Candidate files and compiler dependencies intentionally have different invalidation behavior:
+ *
+ * - Candidate-file changes rerun the root with the existing generator and scanner. `incrementalCache: true` updates additions
+ *   and removals without discarding the generator's authoritative cache.
+ * - Compiler-dependency changes mark the root invalid. Its next Rolldown transform resolves a new Tailwind source and creates a
+ *   new generator and scanner. Replacement is delayed until that transform has current source and plugin context.
+ * - If a stylesheet stops being a Tailwind root, its generator is disposed and its Tailwind state is removed. The later Vite
+ *   CSS hook replaces the retained CSS after normal processing succeeds.
+ *
+ * ### 2. Vite-final CSS capture
+ *
+ * `configResolved` wraps the concrete `vite:css-post` transform while preserving its hook metadata, filter, ordering, and
+ * plugin context. The original Vite hook executes first, which preserves CSS Module exports and Vite's internal extraction
+ * state. Only a successful transform updates `styleByModuleId`; syntax errors therefore leave the last successful CSS available
+ * to the currently running application. Query modes such as `?raw`, `?url`, and `?inline` are excluded because they represent
+ * values rather than graph-owned stylesheets.
+ *
+ * ### 3. Live-graph projection
+ *
+ * Output finalization starts from resolved App/Page entry IDs and traverses Rolldown's current static and dynamic import edges
+ * in dependency-first post-order. Transaction-local visited sets terminate cycles and deduplicate shared modules and physical
+ * stylesheets. A retained stylesheet contributes only when its module is still reachable, so removing an import prunes its CSS
+ * and Tailwind candidates without a separate prune protocol or persistent topology cache. Candidate sets are unioned only from
+ * the Tailwind roots whose captured CSS survives that exact traversal, preserving the CSS/class identity invariant.
+ *
+ * ### 4. Shared WX finalization
+ *
+ * `finalizeOutput()` first converts the concatenated reachable CSS to WXSS, then transforms every supplied 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.
+ *
+ * ### 5a. Complete-build commit
+ *
+ * The post-order `generateBundle` hook gathers all JavaScript chunks, finalizes them as one operation, and only then mutates the
+ * bundle. It assigns converted code, clears invalid source maps, removes Vite's intermediate browser stylesheet, and always
+ * emits `assets/global.wxss`. Emitting an empty global file is required because `app.wxss` imports it even when the application
+ * currently has no styles. Native output hooks run afterward and emit Page/component companion files independently.
+ *
+ * ### 5b. Development commit
+ *
+ * The development host calls `finalizeUpdate()` after Rolldown produces patch factories or a complete-output notification.
+ * Finalization uses the `PluginContext` captured by `buildStart`, so it observes the same current graph as the compiler. After
+ * all conversion succeeds, the host's atomic writer publishes changed WXSS before `finalizeUpdate()` returns converted patch
+ * factories. The patch publisher therefore cannot expose newer JavaScript class identities before matching selectors exist.
+ * `publishedWxss` advances only after a successful write and suppresses byte-identical writes that would otherwise trigger
+ * unnecessary WeChat DevTools reload events.
+ *
+ * ## Retained state and lifecycle
+ *
+ * The factory retains four explicit mutable state owners plus one library-owned transformation context:
+ *
+ * - `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;
+ * - `publishedWxss`: the last durably published development stylesheet used for unchanged-write suppression;
+ * - `weappContext`: Weapp's internal conversion state, retained so selector and JavaScript rewriting share one context.
+ *
+ * The state owners remain scoped to one plugin instance; `entryIds` is atomically replaced after each complete resolution.
+ * Build-command bundles dispose Tailwind generators after bundle generation. A development watcher otherwise keeps them alive
+ * across updates and disposes them when it closes. Captured CSS survives compiler cleanup because output notifications can
+ * arrive after that cleanup, and is cleared only when the watcher terminates.
+ *
+ * ## Cost model
+ *
+ * Projection is `O(V + E + B + C)` for reachable modules, import edges, concatenated CSS bytes, and candidate insertions.
+ * JavaScript conversion is linear in the total supplied chunk or patch-factory bytes, subject to the Weapp parser's own cost.
+ * Retained memory is `O(B + C + D + F)` for latest CSS, candidate sets, compiler dependencies, and scanner file identities; no
+ * second application graph is retained. Tailwind's generator and Oxide scanner caches are intentionally persistent because
+ * recreating them on every candidate edit would repeat source normalization and scanning work.
+ */
+export declare function createWxStylePlugin(applicationEntryIds: readonly string[]): WxStylePlugin;
+/**
+ * Produces WXSS 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 WXSS conversion before JavaScript conversion and returns bytes without publishing or mutating caller artifacts.
+ */
+export declare function finalizeOutput(entryIds: readonly string[], styleByModuleId: ReadonlyMap<string, Readonly<{
+    css: string | undefined;
+    tailwind: Readonly<{
+        classSet: ReadonlySet<string>;
+    }> | undefined;
+}>>, getModuleInfo: (moduleId: string) => Readonly<{
+    importedIds: readonly string[];
+    dynamicallyImportedIds: readonly string[];
+}> | null | undefined, weappContext: Pick<ReturnType<typeof createContext>, 'transformJs' | 'transformWxss'>, javaScript: readonly JavaScriptArtifact[]): Promise<{
+    javaScript: string[];
+    wxss: string;
+}>;
+export {};