vite-plugin-taro 0.6.20 → 0.7.0

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

@@ -1,51 +0,0 @@
-import { type Rolldown } from 'vite';
-/** Identifies Rolldown's generated helper module independently of its unstable output filename. */
-export declare const rolldownRuntimeId = "\0rolldown/runtime.js";
-/** Resolves the direct React Reconciler dependency without assuming pnpm's layout. */
-export declare const reactReconcilerRoot: string;
-/** Identifies the amphibious bootstrap that initializes SystemJS and serves every native shell. */
-export declare const bootstrapPath: string;
-/** Identifies the native transport source materialized before Rolldown finalizes content hashes. */
-export declare const transportPath: string;
-/** Redirects Vite's injected browser preload helper to the bootstrap identity loader. */
-export declare const vitePreloadId = "\0vite/preload-helper.js";
-/** Forces the native App shell entry to emit at WeChat's required root path. */
-export declare const appShellFileName = "app.js";
-/** Identifies the synchronous native App shell source. */
-export declare const appShellPath: string;
-/** Identifies the App capsule kept behind the native shell boundary. */
-export declare const appCapsulePath: string;
-/** Forces Taro's recursive native Component entry to emit at its configured root path. */
-export declare const componentShellFileName = "comp.js";
-/** Identifies the synchronous recursive Component shell source. */
-export declare const componentShellPath: string;
-/** Identifies the recursive Component capsule shared by generated Taro component shells. */
-export declare const componentCapsulePath: string;
-/** Forces Taro's CustomWrapper native shell to emit at its configured root path. */
-export declare const customWrapperShellFileName = "custom-wrapper.js";
-/** Identifies the synchronous CustomWrapper shell source. */
-export declare const customWrapperShellPath: string;
-/** Resolves the configured Page component from its route-qualified capsule importer. */
-export declare const pageComponentId = "\0vpt:page-component";
-/** Gives every Page shell one private capsule target that can be resolved using its route. */
-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 generated 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;
-/** Build-graph role of an explicit native lifecycle entry. */
-export type WxEntryRole = 'shell' | 'capsule';
-/** Runtime domain in which one final wx JavaScript chunk executes. */
-export type WxExecutionKind = 'native' | 'capsule' | 'amphibious';
-/** Returns the one explicit lifecycle role owned by a chunk. */
-export declare function getWxEntryRole(chunk: WxChunk): WxEntryRole | undefined;
-/** Tests whether a chunk contains the physical transport implementation. */
-export declare function isTransportModule(chunk: WxChunk): boolean;
-/**
- * Classifies one final output chunk by execution domain. Entry role is deliberately independent: explicit capsule entries
- * normally fall through to capsule rendering, but a capsule containing an amphibious runtime executes in both domains.
- */
-export declare function getWxExecutionKind(chunk: WxChunk): WxExecutionKind;

package/dist/node/plugins/wx/output/relative-root.d.ts

@@ -1,2 +0,0 @@
-/** Creates a Page-relative path to a file emitted at the wx output root. */
-export declare function toRootRelativePath(pagePath: string, rootFileName: string): string;

package/dist/node/plugins/wx/output/templates.d.ts

@@ -1,124 +0,0 @@
-import type { Rolldown } from 'vite';
-import type { VptOptions } from '../../../../options.ts';
-import { type GeneratedSubpackage } from '../placer/placement.ts';
-type NativeComponentRegistration = {
-    name: string;
-    componentPath: string;
-    fields: readonly string[];
-};
-/** Creates every JSON, WXML, WXS, and Page WXSS asset owned by Taro's native rendering boundary. */
-export declare function createTemplateAssets({ bundle, options, subpackages, nativeComponents, isProduction }: {
-    bundle: Rolldown.OutputBundle;
-    options: VptOptions;
-    subpackages: readonly GeneratedSubpackage[];
-    nativeComponents: readonly NativeComponentRegistration[];
-    isProduction: boolean;
-}): Rolldown.EmittedAsset[];
-/**
- * Adapts Taro's stock template builder to the WXML half of WX App wrapping without changing its recursive renderer.
- *
- * End-to-end contract
- * -------------------
- * React and Taro retain one in-memory ownership tree:
- *
- * App React root
- *   -> App host records
- *      -> vpt_page_outlet host at App {children}
- *         -> independently scheduled Taro Page roots
- *
- * The patched WX document makes the singleton App host a TaroRootElement. App host mutations therefore batch under app.*
- * and fan out to every mounted native Page. Each Page root remains its own TaroRootElement and emits only page.*. The React
- * host renderer marks the outlet and its App ancestors with an ordinary compact `vo` prop after each commit, while patched
- * hydrate() stops at vpt_page_outlet. Page roots remain attached for React Context, lifecycle, events, removal, refs, effects,
- * and HMR without entering app data.
- *
- * Build-time output
- * -----------------
- * createTemplateAssets asks one builder for shared base.wxml, utils.wxs, comp.wxml, custom-wrapper.wxml, and each Page WXML.
- * This adapter specializes the products that own the native join:
- *
- * - shared base.wxml receives branch-local slot forwarding at comp boundaries plus vpt_fragment and vpt_page_outlet
- *   template definitions;
- * - each Page WXML replaces Taro's root:root entry with one generic comp bound to app and one caller-owned taro_tmpl bound
- *   to page as that component's default slot.
- *
- * utils.wxs remains Taro's normal compact-node dispatcher. comp.wxml and custom-wrapper.wxml retain Taro's generic compact
- * rendering contracts; their JSON companions register recursive boundaries and native components, while runtime configs
- * retain standard event dispatch. CustomWrapper keeps Taro's Page-local ownership model and is not made slot-transparent
- * for App wrapping.
- * There is one shared template namespace, no Page-specific base file, no App/Page mode property, and no Page object threaded
- * through App template data.
- *
- * First native Page
- * -----------------
- * createPageConfig starts the native Page with:
- *
- *     app  = { nn: 'vpt_fragment', cn: [] }
- *     page = { cn: [] }
- *
- * nn lets unchanged comp dispatch one input object even though App JSX may produce one or many root hosts. The record
- * is WXML-only rather than a Taro host, so it needs no sid. After React commits the Page root below the outlet, the framework
- * queues a lazy hydrate(AppRoot).cn value beside the Page root's already-pending page.* payloads. Taro drains both through the
- * native Page's existing first setData, making App wrapping and Page content appear atomically.
- *
- * Native WXML execution
- * ---------------------
- * Data/slot ownership and named-template ownership intentionally travel through different scopes:
- *
- * Page WXML (owns app, page, Page eh, and Page-content light DOM)
- *   -> <comp i="{{app}}"> (crosses into a virtual custom-component scope)
- *      -> comp.wxml (owns App eh, imports unchanged utils.wxs and shared base.wxml)
- *         -> tmpl_0_vpt_fragment (iterates the real App compact roots in app.cn)
- *            -> stock Taro templates (render App hosts and recurse through their cn arrays)
- *               -> native recursion boundary <comp ...>
- *                    -> forwards <slot /> only when this compact subtree root has i.vo
- *               -> tmpl_0_vpt_page_outlet at React's exact {children} position
- *                  -> <slot />
- *                     -> caller-owned <template is="taro_tmpl" data="{{root:page}}" />
- *                        -> stock Taro templates render this native Page's page.cn records
- *
- * The virtual comp and both private templates add no native layout node. `vo` is part of the existing compact node i, not a
- * component property or template context. App events execute through comp.eh; slotted Page events retain the native Page's
- * eh. Both resolve the original Taro sid through the same event source.
- *
- * Named-template scope
- * --------------------
- * Slots transfer caller-owned light DOM only. They do not transfer the caller's named-template table or WXS modules. App
- * dispatch runs inside comp.wxml, so vpt_fragment and vpt_page_outlet must live in base.wxml imported by that component.
- * Putting those definitions in buildPageTemplate produces Page WXML that compiles, but component runtime dispatch fails with
- * `Template tmpl_0_vpt_fragment not found`. Shared base.wxml makes the names visible in the root and every recursive
- * component scope and emits them once rather than once per Page.
- *
- * Projection-spine ownership
- * --------------------------
- * React's host renderer runs after the final commit tree exists and caches the outlet-to-root Taro host ancestor array. It
- * skips the unchanged root-side suffix, gives old leaf-side nodes the ordinary host prop vo=false, and gives new ones vo=true.
- * Taro's existing lazy structural hydration runs later and therefore serializes those props without projection-specific
- * scheduler or hydrate behavior. If React replaces the outlet host while moving it, the renderer finds the unique new marker
- * once and caches its new ancestor array. At each depth-reset comp boundary, i.vo makes forwarding an O(1) local decision;
- * WXML never searches descendants, and Page trees instantiate no unnamed slot.
- *
- * Steady-state updates and navigation
- * -----------------------------------
- * A page.* setData updates only the caller-owned Page template inside the slot. app is not passed through that template and
- * comp.i does not change, so Page updates cannot invalidate App recursion. Ordinary app.* payloads and outlet-spine marker
- * changes remain in Taro's granular batch before it fans out to every retained native Page. Adding or removing a React Page
- * root mutates the outlet only in memory, and the runtime suppresses that marker's native child update. A newly pushed Page
- * receives the latest complete App snapshot in its initial batch, while existing and hidden Pages require no navigation
- * synchronization.
- *
- * Method responsibilities
- * -----------------------
- * 1. buildBaseTemplate preserves stock host templates, makes each depth-reset comp boundary slot-transparent through i.vo,
- *    and adds the two private definitions to the shared namespace.
- * 2. buildPageTemplate owns only the Page boundary: app binding, page binding, and the single Page-content slot.
- * 3. buildXScript delegates unchanged because routing metadata already travels inside compact node i.
- * 4. buildBaseComponentTemplate delegates unchanged so recursive comp remains generic and feature-independent.
- * 5. buildCustomComponentTemplate delegates unchanged so CustomWrapper renders compact children in its own native scope.
- *
- * H5 never calls this WX output builder. Its App continues to receive ordinary Fragment children and none of these native
- * data roots, templates, custom-component boundaries, or slot rules enter the browser build.
- */
-/** Replaces one pinned Taro fragment and rejects absent or duplicated upstream contracts. */
-export declare function replaceExactlyOnce(source: string, current: string, replacement: string, description: string): string;
-export {};

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

@@ -1,18 +0,0 @@
-// App and Page shells activate independently; make Current.app initialization an explicit prerequisite for Page mount.
-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 { createPageConfig } from './taro-runtime.js';
-/*
- * Generated Page WXML invokes Taro's unchanged recursive comp, whose input contract is one compact node selected by i.nn.
- * App JSX does not have that cardinality: it may return one or many top-level hosts, and the private Page outlet may
- * occur at any depth within them. vpt_fragment is therefore a WXML-only collection adapter. Its fixed nn selects a
- * transparent template that iterates cn while one surrounding comp owns the Page's default slot. Runtime projection markers
- * relay that slot only through the App branch containing the outlet. Without the fragment, Page WXML would need one comp—and
- * one potential copy of the Page slot—for every App root, or comp would need an App-specific collection mode.
- *
- * This record is not a Taro host: it has no Fiber, event source, ref, lifecycle, native element, or keyed parent collection.
- * It consequently needs no sid. Only cn is seeded and updated; nn remains the stable generic-template discriminator.
- */
-const config = createPageConfig(PageComponent, __VPT_PAGE_PATH__, { app: { nn: 'vpt_fragment', cn: [] }, page: { cn: [] } }, __VPT_PAGE_CONFIG__);
-export default config;

package/dist/runtime/wx/dev/modes/interpreter/interpreter-protocol.js

@@ -1 +0,0 @@
-export const interpreterServerEvent = 'vpt:wx-interpreter:source';