vite-plugin-taro 0.5.16 → 0.6.1

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

@@ -1,46 +0,0 @@
-import type { Rolldown } from 'vite';
-/** Identifies one generated code-only subpackage by its physical output root. */
-export type SubpackageLocation = {
-    /** Discriminates generated subpackages from main. */
-    kind: 'subpackage';
-    /** Native subpackage root relative to the Mini Program output directory. */
-    root: string;
-};
-/** Physical package ownership for one transformed module. */
-export type PackageLocation = {
-    kind: 'main';
-} | SubpackageLocation;
-/** Immutable module-to-package ownership produced before Rolldown creates chunks. */
-export type PlacementPlan = ReadonlyMap<string, PackageLocation>;
-/** Minimal Rolldown graph interface consumed by the subpackage planner. */
-export type ModuleGraph = {
-    /** Every transformed module known after graph construction. */
-    moduleIds: Iterable<string>;
-    /** Reads static edges, dynamic edges, transformed code, and entry ownership. */
-    getModuleInfo(moduleId: string): Rolldown.ModuleInfo | null;
-    /** Adds non-JavaScript output owned by a transformed module to its package weight. */
-    getAdditionalModuleBytes?: (info: Rolldown.ModuleInfo) => number;
-};
-/** Shared main-package value used for every eager or output-generated module. */
-export declare const mainPackage: {
-    readonly kind: 'main';
-};
-/**
- * Creates one deterministic subpackage placement plan:
- *
- * 1. Snapshot Rolldown's transformed module graph.
- * 2. Reserve every explicit shell and capsule entry together with its static closure in main.
- * 3. Treat dynamic imports as asynchronous roots, then annotate their modules with affinity.
- * 4. Pack those lazy modules independently under the planning budget.
- * 5. Return only module ownership; chunks and native manifests are reconciled later.
- *
- * Static cycles are deliberately not atomic only after a genuine nested dynamic boundary. System.import() may obtain their
- * registrations from several packages and await top-level execution while preserving the original static ESM graph.
- */
-export declare function createPlacementPlan({ moduleIds, getModuleInfo, getAdditionalModuleBytes, planningBudgetBytes }: ModuleGraph & {
-    planningBudgetBytes?: number;
-}): PlacementPlan;
-/** Uses the generated root directory itself as the native subpackage alias. */
-export declare function getSubpackageName(root: string): string;
-/** Tests the plugin-owned output prefix that physically identifies every generated subpackage. */
-export declare function isGeneratedSubpackageFile(fileName: string): boolean;

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

@@ -1,210 +0,0 @@
-import { createHash } from 'node:crypto';
-// Leave headroom below WeChat's 2M subpackage limit for capsule wrappers and bundler-generated code.
-const subpackagePlanningBudget = 1_900_000;
-const generatedSubpackageRootPrefix = 'sub/p_';
-/** Shared main-package value used for every eager or output-generated module. */
-export const mainPackage = { kind: 'main' };
-/**
- * Creates one deterministic subpackage placement plan:
- *
- * 1. Snapshot Rolldown's transformed module graph.
- * 2. Reserve every explicit shell and capsule entry together with its static closure in main.
- * 3. Treat dynamic imports as asynchronous roots, then annotate their modules with affinity.
- * 4. Pack those lazy modules independently under the planning budget.
- * 5. Return only module ownership; chunks and native manifests are reconciled later.
- *
- * Static cycles are deliberately not atomic only after a genuine nested dynamic boundary. System.import() may obtain their
- * registrations from several packages and await top-level execution while preserving the original static ESM graph.
- */
-export function createPlacementPlan({ moduleIds, getModuleInfo, getAdditionalModuleBytes, planningBudgetBytes = subpackagePlanningBudget }) {
-    // Materialize the iterable once because every later phase needs stable random access by module ID.
-    const infos = new Map();
-    for (const moduleId of moduleIds) {
-        const info = getModuleInfo(moduleId);
-        if (info) {
-            infos.set(moduleId, info);
-        }
-    }
-    // Eager ownership is a hard constraint; consumer and neighbor sets below are soft packing preferences only.
-    const eagerModules = findEagerModules(infos);
-    const consumersByModule = findLazyConsumers({ infos, eagerModules });
-    const neighborsByModule = findLazyNeighbors({ infos, eagerModules });
-    const placeableModules = [...infos.entries()]
-        .filter(([moduleId]) => !eagerModules.has(moduleId))
-        .map(([moduleId, info]) => ({
-        moduleId,
-        estimatedBytes: Buffer.byteLength(info.code ?? '', 'utf8') + (getAdditionalModuleBytes?.(info) ?? 0),
-        consumers: consumersByModule.get(moduleId) ?? new Set([moduleId]),
-        neighbors: neighborsByModule.get(moduleId) ?? new Set()
-    }));
-    // Packing operates at module granularity, so a large lazy closure or cycle may span several subpackages.
-    const subpackages = packSubpackages({ modules: placeableModules, planningBudgetBytes }).map(createPackedSubpackage);
-    const locationByModule = new Map();
-    for (const moduleId of eagerModules) {
-        locationByModule.set(moduleId, mainPackage);
-    }
-    for (const subpackage of subpackages) {
-        for (const moduleId of subpackage.moduleIds) {
-            locationByModule.set(moduleId, subpackage);
-        }
-    }
-    return locationByModule;
-}
-/**
- * Finds modules that must remain in main. Native shells and capsules are explicit entries, and static traversal keeps their
- * complete eager closures synchronous. Every dynamic import is therefore a genuine lazy boundary whose graph may use
- * subpackages and top-level await.
- */
-function findEagerModules(infos) {
-    const eagerModules = new Set();
-    const pending = [...infos.values()].filter((info) => info.isEntry).map((info) => info.id);
-    while (pending.length > 0) {
-        const moduleId = pending.pop();
-        if (!moduleId || eagerModules.has(moduleId)) {
-            continue;
-        }
-        const info = infos.get(moduleId);
-        if (!info) {
-            continue;
-        }
-        eagerModules.add(moduleId);
-        pending.push(...info.importedIds);
-    }
-    return eagerModules;
-}
-/**
- * Records demand after the eager importSync closure has been removed. Every remaining dynamic target starts one lazy root
- * traversal; that traversal follows static edges only and stops before another dynamic boundary. A shared module records
- * every root that can request it. These consumer sets improve co-location but never prevent subpackage splitting.
- */
-function findLazyConsumers({ infos, eagerModules }) {
-    const dynamicRoots = new Set();
-    for (const info of infos.values()) {
-        for (const importedId of info.dynamicallyImportedIds) {
-            if (infos.has(importedId) && !eagerModules.has(importedId)) {
-                dynamicRoots.add(importedId);
-            }
-        }
-    }
-    const consumersByModule = new Map();
-    for (const dynamicRoot of [...dynamicRoots].sort()) {
-        const visited = new Set();
-        const pending = [dynamicRoot];
-        while (pending.length > 0) {
-            const moduleId = pending.pop();
-            if (!moduleId || visited.has(moduleId) || eagerModules.has(moduleId)) {
-                continue;
-            }
-            const info = infos.get(moduleId);
-            if (!info) {
-                continue;
-            }
-            visited.add(moduleId);
-            const consumers = consumersByModule.get(moduleId) ?? new Set();
-            consumers.add(dynamicRoot);
-            consumersByModule.set(moduleId, consumers);
-            pending.push(...info.importedIds);
-        }
-    }
-    return consumersByModule;
-}
-/**
- * Converts each lazy static edge into an undirected affinity. Direction is irrelevant for co-location scoring, while the
- * original directed dependency remains in Rolldown and later in SystemJS. Cycles are therefore preferences, not atoms.
- */
-function findLazyNeighbors({ infos, eagerModules }) {
-    const neighborsByModule = new Map();
-    for (const [moduleId, info] of infos) {
-        if (eagerModules.has(moduleId)) {
-            continue;
-        }
-        for (const importedId of info.importedIds) {
-            if (!infos.has(importedId) || eagerModules.has(importedId)) {
-                continue;
-            }
-            addNeighbor(neighborsByModule, moduleId, importedId);
-            addNeighbor(neighborsByModule, importedId, moduleId);
-        }
-    }
-    return neighborsByModule;
-}
-/** Adds one side of an undirected lazy-module affinity edge. */
-function addNeighbor(neighborsByModule, moduleId, neighborId) {
-    const neighbors = neighborsByModule.get(moduleId) ?? new Set();
-    neighbors.add(neighborId);
-    neighborsByModule.set(moduleId, neighbors);
-}
-/**
- * Packs lazy modules with deterministic best-fit decreasing:
- *
- * 1. Visit larger transformed modules first, with module ID as the stable tie-breaker.
- * 2. Consider only existing bins that stay within the planning budget.
- * 3. Prefer the bin with the least remaining space, minimizing subpackage count in the usual best-fit heuristic.
- * 4. When remaining space ties, prefer shared dynamic consumers and then static neighbors.
- * 5. Create a new bin when no existing bin fits; an individually oversized module receives its own bin.
- */
-function packSubpackages({ modules, planningBudgetBytes }) {
-    const bins = [];
-    const sortedModules = [...modules].sort((left, right) => {
-        return right.estimatedBytes - left.estimatedBytes || left.moduleId.localeCompare(right.moduleId);
-    });
-    for (const module of sortedModules) {
-        const candidate = bins
-            .filter((bin) => bin.estimatedBytes + module.estimatedBytes <= planningBudgetBytes)
-            .map((bin) => ({
-            bin,
-            remainingBytes: planningBudgetBytes - bin.estimatedBytes - module.estimatedBytes,
-            affinity: getAffinity(bin, module)
-        }))
-            .sort((left, right) => {
-            return left.remainingBytes - right.remainingBytes || right.affinity - left.affinity;
-        })[0]?.bin;
-        const bin = candidate ?? {
-            moduleIds: [],
-            estimatedBytes: 0,
-            consumers: new Set()
-        };
-        if (!candidate) {
-            bins.push(bin);
-        }
-        bin.moduleIds.push(module.moduleId);
-        bin.estimatedBytes += module.estimatedBytes;
-        for (const consumer of module.consumers) {
-            bin.consumers.add(consumer);
-        }
-    }
-    return bins;
-}
-/** Scores dynamic-root overlap above direct static adjacency when equally full bins compete. */
-function getAffinity(bin, module) {
-    let affinity = 0;
-    for (const consumer of module.consumers) {
-        if (bin.consumers.has(consumer)) {
-            affinity += 2;
-        }
-    }
-    for (const neighbor of module.neighbors) {
-        if (bin.moduleIds.includes(neighbor)) {
-            affinity += 1;
-        }
-    }
-    return affinity;
-}
-/** Freezes bin membership and derives a stable subpackage root from sorted module IDs. */
-function createPackedSubpackage(bin) {
-    const moduleIds = [...bin.moduleIds].sort();
-    const hash = createHash('sha256').update(moduleIds.join('\0')).digest('hex').slice(0, 8);
-    return {
-        kind: 'subpackage',
-        root: `${generatedSubpackageRootPrefix}${hash}`,
-        moduleIds
-    };
-}
-/** Uses the generated root directory itself as the native subpackage alias. */
-export function getSubpackageName(root) {
-    return root.slice(root.lastIndexOf('/') + 1);
-}
-/** Tests the plugin-owned output prefix that physically identifies every generated subpackage. */
-export function isGeneratedSubpackageFile(fileName) {
-    return fileName.startsWith(generatedSubpackageRootPrefix);
-}

package/dist/node/vite-plugin.d.ts

@@ -1,4 +0,0 @@
-import type { PluginOption } from 'vite';
-import type { VitePluginTaroOptions } from '../options.ts';
-/** Creates the Vite plugins for one Taro target. */
-export default function vitePluginTaro(options: VitePluginTaroOptions): PluginOption[];

package/src/node/plugins/wx/placement/placer.ts

@@ -1,187 +0,0 @@
-import path from 'node:path'
-import type { Rolldown } from 'vite'
-import { getWxExecutionKind, isTransportModule } from '../module.ts'
-import {
-    createPlacementPlan,
-    getSubpackageName,
-    isGeneratedSubpackageFile,
-    type ModuleGraph,
-    mainPackage,
-    type PackageLocation,
-    type PlacementPlan
-} from './plan.ts'
-
-/** Native app.json declaration for one generated code-only subpackage. */
-export type GeneratedSubpackage = {
-    /** Stable native alias derived from the generated root hash. */
-    name: string
-    /** Physical directory containing this subpackage's emitted capsules. */
-    root: string
-    /** Marks this as a code-only subpackage with no native Page routes. */
-    pages: readonly []
-}
-
-/**
- * Creates the stateful adapter between graph planning and Rolldown's output lifecycle:
- *
- * - renderStart analyzes transformed modules before chunking.
- * - codeSplitting prevents modules assigned to different packages from being merged.
- * - filename callbacks materialize planned subpackage roots.
- * - renderChunk derives native loading mode from those physical paths.
- * - generateBundle reconciles the plan with chunks that survived tree shaking.
- */
-export function createPlacer() {
-    // Filename and output callbacks run after analyze and read this immutable plan through their shared closure.
-    let plan: PlacementPlan = new Map()
-
-    /**
-     * Reduces module ownership to one package for filename generation. Unknown Rolldown-generated modules default to
-     * main, empty chunks default to main, and a chunk containing multiple known owners is rejected before paths diverge.
-     */
-    function getChunkLocation(chunk: Rolldown.PreRenderedChunk): PackageLocation {
-        let location: PackageLocation | undefined
-        for (const moduleId of chunk.moduleIds) {
-            const moduleLocation = plan.get(moduleId) ?? mainPackage
-            if (!location) {
-                location = moduleLocation
-                continue
-            }
-            if (!hasSameLocation(location, moduleLocation)) {
-                throw new Error(`wx chunk mixes package owners: ${chunk.moduleIds.join(', ')}`)
-            }
-        }
-        return location ?? mainPackage
-    }
-
-    return {
-        /** Assigns every transformed module to main or one generated, size-bounded subpackage. */
-        analyze(graph: ModuleGraph): void {
-            plan = createPlacementPlan(graph)
-        },
-
-        /**
-         * Complete Rolldown fragment required to preserve package placement and native entry semantics.
-         *
-         * ```text
-         * native App/Page/Component shell entry
-         *   └─ static import / runtime importSync() ─▶ explicit capsule entry + static closure [main, no TLA]
-         *                                                └─ System.import() ─▶ lazy-a [package A, TLA allowed]
-         *                                                                      └─ static import ─▶ lazy-b [package B]
-         *
-         * name()                              assigns lazy-a and lazy-b to their planned package groups
-         * includeDependenciesRecursively      false: does not pull lazy-b back into package A
-         * preserveEntrySignatures             allows cross-chunk bindings without weakening native entry exports
-         *
-         * package A capsule
-         *   └─ SystemJS dependency ─▶ package B capsule
-         *                                ▲
-         *                                └─ main transport obtains registration with require.async()
-         * ```
-         *
-         * Explicit entries preserve the shell/capsule rendering boundary while their static edge executes synchronously
-         * from main. Once a dynamic boundary is crossed, physical fetches may be asynchronous and modules may use
-         * top-level await. SystemJS still links that complete static lazy graph before execution, even across packages.
-         */
-        rolldownOptions: {
-            output: {
-                /**
-                 * Gives every generated subpackage a distinct Rolldown chunk group. Recursive dependency capture must
-                 * stay disabled: lazy static dependencies may belong to other subpackages and SystemJS links them
-                 * asynchronously.
-                 */
-                codeSplitting: {
-                    groups: [
-                        {
-                            name(moduleId: string): string | null {
-                                const location = plan.get(moduleId)
-                                return location?.kind === 'subpackage' ? getSubpackageName(location.root) : null
-                            },
-                            // Do not let Rolldown pull a lazy group's static closure into one chunk. Past the nested dynamic
-                            // boundary, transport may obtain registrations from several packages asynchronously before
-                            // SystemJS links and executes the original graph, including cycles and top-level await.
-                            includeDependenciesRecursively: false
-                        }
-                    ]
-                },
-                // strictExecutionOrder deliberately has no plugin default. When an application enables it through normal
-                // Rolldown output options, the generated helper runtime becomes amphibious: CommonJS evaluates it once and
-                // transport publishes that cached namespace to SystemJS.
-                /** Preserves exact native shell paths while hashing transport and explicit capsule entries. */
-                entryFileNames(chunk: Rolldown.PreRenderedChunk): string {
-                    return getWxExecutionKind(chunk) === 'native' && !isTransportModule(chunk)
-                        ? '[name]'
-                        : 'assets/[name]-[hash].js'
-                },
-                /** Converts the planned owner into its physical main or generated subpackage filename template. */
-                chunkFileNames(chunk: Rolldown.PreRenderedChunk): string {
-                    const location = getChunkLocation(chunk)
-                    if (location.kind === 'main') {
-                        return 'assets/[name]-[hash].js'
-                    }
-                    // The package group replaces Rolldown's [name], so recover the first bundled source file's name from
-                    // the final chunk module list instead of leaking the generated package hash into the filename.
-                    return `${location.root}/assets/${getFirstModuleName(chunk)}-[hash].js`
-                },
-                // Keep generic assets independent of native output identities assigned after bundling.
-                assetFileNames: 'assets/[name]-[hash][extname]'
-            },
-            // Rolldown rejects strict entry signatures when code-splitting groups disable recursive dependency capture.
-            // allow-extension retains required native-entry exports while permitting the extra cross-chunk bindings used
-            // to split lazy static closures across physical packages.
-            preserveEntrySignatures: 'allow-extension' as const
-        },
-
-        /**
-         * Selects loading mode from physical output rather than graph intent. Transport executes in main, so main files
-         * use require() and every generated subpackage file uses require.async().
-         */
-        getLoadMode(chunk: Rolldown.RenderedChunk): 'sync' | 'async' {
-            return isGeneratedSubpackageFile(chunk.fileName) ? 'async' : 'sync'
-        },
-
-        /**
-         * Reconciles planned ownership with final chunks through module IDs. Tree-shaken subpackages disappear naturally,
-         * while roots are deduplicated and sorted before becoming deterministic app.json declarations.
-         */
-        getSubpackages(bundle: Rolldown.OutputBundle): GeneratedSubpackage[] {
-            const emittedSubpackageRoots = new Set<string>()
-            for (const output of Object.values(bundle)) {
-                if (output.type !== 'chunk') {
-                    continue
-                }
-                for (const moduleId of output.moduleIds) {
-                    const location = plan.get(moduleId)
-                    if (location?.kind === 'subpackage') {
-                        emittedSubpackageRoots.add(location.root)
-                    }
-                }
-            }
-
-            return [...emittedSubpackageRoots].sort().map((root) => ({
-                name: getSubpackageName(root),
-                root,
-                pages: []
-            }))
-        }
-    }
-}
-
-/** Uses the first bundled source filename as the readable identity of a generated subpackage chunk. */
-function getFirstModuleName(chunk: Rolldown.PreRenderedChunk): string {
-    const firstModuleId = chunk.moduleIds[0]
-    if (!firstModuleId) {
-        throw new Error('wx subpackage chunk has no source modules')
-    }
-
-    const normalizedId = firstModuleId.replaceAll('\\', '/')
-    const suffixIndex = normalizedId.search(/[?#]/)
-    const cleanId = suffixIndex === -1 ? normalizedId : normalizedId.slice(0, suffixIndex)
-    const fileName = path.posix.basename(cleanId)
-    const extension = path.posix.extname(fileName)
-    return extension ? fileName.slice(0, -extension.length) : fileName
-}
-
-/** Compares main by discriminant and generated subpackages by their unique physical root. */
-function hasSameLocation(left: PackageLocation, right: PackageLocation): boolean {
-    return left.kind === 'main' ? right.kind === 'main' : right.kind === 'subpackage' && left.root === right.root
-}