vite-plugin-taro 0.5.16 → 0.6.1

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

@@ -1,306 +0,0 @@
-import { createHash } from 'node:crypto'
-import type { Rolldown } from 'vite'
-
-// Leave headroom below WeChat's 2M subpackage limit for capsule wrappers and bundler-generated code.
-const subpackagePlanningBudget = 1_900_000
-const generatedSubpackageRootPrefix = 'sub/p_'
-
-/** 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
-}
-
-/** One independently placeable lazy module together with size and co-location preferences. */
-type PlaceableModule = {
-    /** Stable module identity and final ownership key. */
-    moduleId: string
-    /** UTF-8 size of transformed source used as the bin-packing estimate. */
-    estimatedBytes: number
-    /** Dynamic roots whose static closures contain this module. */
-    consumers: ReadonlySet<string>
-    /** Lazy modules connected by a direct static import in either direction. */
-    neighbors: ReadonlySet<string>
-}
-
-/** Mutable subpackage candidate used only while best-fit packing is in progress. */
-type SubpackageBin = {
-    /** Modules currently assigned to this candidate. */
-    moduleIds: string[]
-    /** Accumulated transformed-source estimate. */
-    estimatedBytes: number
-    /** Dynamic roots represented by at least one assigned module. */
-    consumers: Set<string>
-}
-
-/** Final membership and stable physical location for one generated subpackage. */
-type PackedSubpackage = SubpackageLocation & {
-    /** Sorted membership used both for stable hashing and ownership assignment. */
-    moduleIds: readonly string[]
-}
-
-/** Shared main-package value used for every eager or output-generated module. */
-export const mainPackage = { kind: 'main' } as const
-
-/**
- * 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
-}: ModuleGraph & { planningBudgetBytes?: number }): PlacementPlan {
-    // Materialize the iterable once because every later phase needs stable random access by module ID.
-    const infos = new Map<string, Rolldown.ModuleInfo>()
-    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<string>()
-        }))
-
-    // 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<string, PackageLocation>()
-    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: ReadonlyMap<string, Rolldown.ModuleInfo>): Set<string> {
-    const eagerModules = new Set<string>()
-    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
-}: {
-    infos: ReadonlyMap<string, Rolldown.ModuleInfo>
-    eagerModules: ReadonlySet<string>
-}): Map<string, Set<string>> {
-    const dynamicRoots = new Set<string>()
-    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<string, Set<string>>()
-    for (const dynamicRoot of [...dynamicRoots].sort()) {
-        const visited = new Set<string>()
-        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<string>()
-            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
-}: {
-    infos: ReadonlyMap<string, Rolldown.ModuleInfo>
-    eagerModules: ReadonlySet<string>
-}): Map<string, Set<string>> {
-    const neighborsByModule = new Map<string, Set<string>>()
-    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: Map<string, Set<string>>, moduleId: string, neighborId: string): void {
-    const neighbors = neighborsByModule.get(moduleId) ?? new Set<string>()
-    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
-}: {
-    modules: readonly PlaceableModule[]
-    planningBudgetBytes: number
-}): SubpackageBin[] {
-    const bins: SubpackageBin[] = []
-    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<string>()
-        }
-        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: SubpackageBin, module: PlaceableModule): number {
-    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: SubpackageBin): PackedSubpackage {
-    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: string): string {
-    return root.slice(root.lastIndexOf('/') + 1)
-}
-
-/** Tests the plugin-owned output prefix that physically identifies every generated subpackage. */
-export function isGeneratedSubpackageFile(fileName: string): boolean {
-    return fileName.startsWith(generatedSubpackageRootPrefix)
-}