@taro-hmr-compile/plugin-webpack 0.0.1-alpha.6 → 0.0.1-alpha.8

package/src/patch/hmr-patch-plugin.ts

@@ -1,217 +1,90 @@
-import generator from '@babel/generator'
-import {parse} from '@babel/parser'
-import template from '@babel/template'
-import traverse from '@babel/traverse'
-import * as t from '@babel/types'
 import type {Compilation, Compiler} from 'webpack'
 import {RawSource} from 'webpack-sources'
-import {DEFAULT_HMR_PATCH_HISTORY_LIMIT, HMR_PATCH_ASSET} from '../constants'
+import {HMR_PATCH_ASSET} from '../constants'
 import {HmrCompilerPlugin} from '../compile/hmr-compiler-plugin'
-import {HmrPatchManager} from './hmr-patch-manager'
-import type {PatchSource, UpdatePatchSource} from './hmr-patch-manager'
 import {HmrPatchRuntimePlugin} from './hmr-patch-runtime-plugin'
+import {HmrPatchProcessor, HmrPatchProcessorOptions} from "./hmr-patch-processor";
 
 const PLUGIN_NAME = 'HmrPatchPlugin'
 const HOT_UPDATE_MANIFEST_SUFFIX = '.hot-update.json'
 const HOT_UPDATE_SCRIPT_SUFFIX = '.hot-update.js'
-const HOT_UPDATE_HASH_PATTERN = /\.([0-9a-f]+)\.hot-update\.json$/i
 const STYLE_ASSET_PATTERN = /\.(?:css|wxss|acss|ttss|qss|jxss)(?:\.map)?$/i
 const TEMPLATE_RUNTIME_ASSET_PATTERN = /(?:^|\/)(?:base\.wxml|utils\.wxs)$/i
 
-interface HotUpdateManifest {
-    m?: Array<string | number>
-}
-
-type CompilationAsset = ReturnType<Compilation['getAssets']>[number]
-
-interface HotUpdateAssets {
-    manifests: CompilationAsset[]
-    scripts: CompilationAsset[]
-}
-
-export interface HmrPatchPluginOptions {
-    patchHistoryLimit?: number
-}
-
-const collectModuleFactories = (source: string, moduleFactories: Map<string, t.Expression>) => {
-    const ast = parse(`(${source})`, {sourceType: 'script'})
-    const statement = ast.program.body[0]
-    if (!t.isExpressionStatement(statement) || !t.isObjectExpression(statement.expression)) {
-        throw new Error('[taro-hmr-compile] Page Chunk 模块段不是对象表达式')
-    }
-
-    statement.expression.properties.forEach(property => {
-        if (!t.isObjectProperty(property) || !t.isExpression(property.value)) {
-            throw new Error('[taro-hmr-compile] Page Chunk 模块对象包含无法识别的属性')
-        }
-
-        const {key} = property
-        let moduleId: string
-        if (t.isStringLiteral(key) || t.isNumericLiteral(key)) moduleId = String(key.value)
-        else if (t.isIdentifier(key) && !property.computed) moduleId = key.name
-        else throw new Error('[taro-hmr-compile] Page Chunk 模块对象包含无法识别的模块 ID')
-
-        moduleFactories.set(moduleId, property.value)
-    })
-}
-
-/** 将本轮 Webpack hot-update 产物转换为内部 update 表示。 */
-const createUpdatePatch = (toHash: string, assets: HotUpdateAssets): UpdatePatchSource => {
-    const manifestAsset = assets.manifests[0]
-    const hashMatch = manifestAsset.name.match(HOT_UPDATE_HASH_PATTERN)
-    if (!hashMatch) throw new Error(`[taro-hmr-compile] 无法从 ${manifestAsset.name} 提取 HMR 基线 hash`)
-
-    const moduleFactories = new Map<string, t.Expression>()
-    assets.scripts.forEach(asset => {
-        const ast = parse(asset.source.source().toString(), {sourceType: 'script'})
-
-        traverse(ast, {
-            CallExpression(nodePath) {
-                const {callee} = nodePath.node
-                if (!t.isMemberExpression(callee) || !t.isIdentifier(callee.object, {name: 'wx'})) return
-                if (!t.isStringLiteral(callee.property) || !callee.property.value.startsWith('webpackHotUpdate')) return
-
-                const modules = nodePath.node.arguments[1]
-                if (!t.isObjectExpression(modules)) return
-
-                modules.properties.forEach(property => {
-                    if (!t.isObjectProperty(property) || !t.isExpression(property.value)) {
-                        throw new Error('[taro-hmr-compile] HMR 模块对象包含无法识别的属性')
-                    }
-
-                    const {key} = property
-                    let moduleId: string
-                    if (t.isStringLiteral(key) || t.isNumericLiteral(key)) moduleId = String(key.value)
-                    else if (t.isIdentifier(key) && !property.computed) moduleId = key.name
-                    else throw new Error('[taro-hmr-compile] HMR 模块对象包含无法识别的模块 ID')
-
-                    moduleFactories.set(moduleId, property.value)
-                })
-            },
-        })
-    })
-
-    const removedModules = new Set<string>()
-    assets.manifests.forEach(asset => {
-        const manifest = JSON.parse(asset.source.source().toString()) as HotUpdateManifest
-        manifest.m?.forEach(moduleId => removedModules.add(String(moduleId)))
-    })
-
-    return {
-        type: 'update',
-        fromHash: hashMatch[1],
-        toHash,
-        moduleFactories,
-        removedModules: Array.from(removedModules),
-    }
-}
-
-/** 将内部 Patch 表示序列化为固定 patch.js。 */
-const createPatchAssetSource = (patches: PatchSource[]): string => {
-    const buildBootstrapPatchNode = template.expression(`({
-        type: 'bootstrap',
-        modules: %%MODULES%%
-    })`)
-    const buildUpdatePatchNode = template.expression(`({
-        type: 'update',
-        fromHash: %%FROM_HASH%%,
-        toHash: %%TO_HASH%%,
-        modules: %%MODULES%%,
-        removedModules: %%REMOVED_MODULES%%
-    })`)
-    const patchNodes = patches.map(patch => {
-        const modules = t.objectExpression(Array.from(
-            patch.moduleFactories,
-            ([moduleId, factory]) => t.objectProperty(t.stringLiteral(moduleId), factory),
-        ))
-        if (patch.type === 'bootstrap') return buildBootstrapPatchNode({MODULES: modules})
-
-        return buildUpdatePatchNode({
-            FROM_HASH: t.stringLiteral(patch.fromHash),
-            TO_HASH: t.stringLiteral(patch.toHash),
-            MODULES: modules,
-            REMOVED_MODULES: t.arrayExpression(patch.removedModules.map(moduleId => t.stringLiteral(moduleId))),
-        })
-    })
-
-    const statements = template.statements('module.exports = %%PATCHES%%;')({PATCHES: t.arrayExpression(patchNodes)})
-    return generator(t.program(statements)).code
-}
+ type HmrPatchPluginOptions = Partial<HmrPatchProcessorOptions>
 
 const isPassthroughAsset = (assetName: string) => {
     return STYLE_ASSET_PATTERN.test(assetName) || TEMPLATE_RUNTIME_ASSET_PATTERN.test(assetName)
 }
 
 export class HmrPatchPlugin {
-    private hasCompletedInitialBuild = false
 
-    private readonly patchManager: HmrPatchManager
+    private previousHash: string = ''
+
+    private initialBuildDone = false
+
+    private readonly patchProcessor: HmrPatchProcessor
 
     private readonly emittedAssetSources = new Map<string, string>()
 
     constructor(options: HmrPatchPluginOptions) {
-        this.patchManager = new HmrPatchManager(options.patchHistoryLimit ?? DEFAULT_HMR_PATCH_HISTORY_LIMIT)
+        this.patchProcessor = new HmrPatchProcessor(options)
     }
 
     apply(compiler: Compiler) {
         new HmrPatchRuntimePlugin().apply(compiler)
 
         compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
-            const initialPageFactories = new Map<string, t.Expression>()
-
-            HmrCompilerPlugin.getCompilationHooks(compilation).pageChunkModules.tap(PLUGIN_NAME, source => {
-                collectModuleFactories(source, initialPageFactories)
+            HmrCompilerPlugin.getCompilationHooks(compilation).chunkModulesRendered.tap(PLUGIN_NAME, (source, isBootstrapChunk) => {
+                this.patchProcessor.processChunkModules({compilation, source, isBootstrapChunk})
             })
 
             // 等 Webpack 生成完整的 hot-update assets 后，再统一转换成固定的 patch.js。
             const stage = compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_REPORT
-            compilation.hooks.processAssets.tap({name: PLUGIN_NAME, stage}, () => {
-                this.processAssets(compilation, initialPageFactories)
-            })
+            compilation.hooks.processAssets.tap({name: PLUGIN_NAME, stage}, () => this.processAssets(compilation))
         })
 
         compiler.hooks.afterEmit.tap(PLUGIN_NAME, compilation => {
             const isSuccessful = compilation.errors.length === 0 && Boolean(compilation.hash)
-            this.hasCompletedInitialBuild = this.hasCompletedInitialBuild || isSuccessful
+            this.initialBuildDone = this.initialBuildDone || isSuccessful
         })
 
         compiler.hooks.watchClose.tap(PLUGIN_NAME, () => this.reset())
     }
 
-    private processAssets(compilation: Compilation, initialPageFactories: Map<string, t.Expression>) {
-        if (!compilation.hash || compilation.errors.length > 0) return
-
-        const originalAssets = compilation.getAssets()
-        if (!this.hasCompletedInitialBuild) {
-            this.patchManager.clear()
-            this.emittedAssetSources.clear()
-            originalAssets.forEach(asset => {
-                if (isPassthroughAsset(asset.name)) {
-                    this.emittedAssetSources.set(asset.name, asset.source.source().toString())
-                }
+    private processAssets(compilation: Compilation) {
+        const {previousHash: fromHash, initialBuildDone} = this
+
+        const {hash: toHash, errors: compilationErrors} = compilation
+
+        if (!toHash || compilationErrors.length > 0) return
+        // 首次编译完成过滤文件输出
+        if (!initialBuildDone) {
+            this.patchProcessor.commitBootstrapFactories(compilation)
+            compilation.getAssets().forEach(asset => {
+                if (!isPassthroughAsset(asset.name)) return
+                this.emittedAssetSources.set(asset.name, asset.source.source().toString())
             })
-            this.patchManager.setBootstrap(initialPageFactories)
-            this.emitPatchAsset(compilation, false)
-            return
+            this.previousHash = toHash
+            return this.emitPatchAsset(compilation, false)
         }
 
-        const hotUpdateAssets: HotUpdateAssets = {
-            manifests: originalAssets.filter(asset => asset.name.endsWith(HOT_UPDATE_MANIFEST_SUFFIX)),
-            scripts: originalAssets.filter(asset => asset.name.endsWith(HOT_UPDATE_SCRIPT_SUFFIX)),
-        }
+        const manifests = compilation.getAssets().filter(asset => asset.name.endsWith(HOT_UPDATE_MANIFEST_SUFFIX))
 
-        if (hotUpdateAssets.manifests.length) {
-            this.patchManager.appendUpdate(createUpdatePatch(compilation.hash, hotUpdateAssets))
-            this.emitPatchAsset(compilation, true)
-        }
+        const scripts = compilation.getAssets().filter(asset => asset.name.endsWith(HOT_UPDATE_SCRIPT_SUFFIX))
+
+        this.patchProcessor.processUpdate({toHash, fromHash, manifests, scripts})
+
+        this.emitPatchAsset(compilation, true)
+
+        this.removeSupersededAssets(compilation)
 
-        // 增量 compilation 仍可能包含普通 chunk 资产，不能让它们覆盖初始 PageShell。
-        this.removeSupersededAssets(compilation, originalAssets)
+        this.previousHash = toHash
     }
 
     /** 热更新转换完成后，保留固定 patch 与发生变化的模板、平台样式资产。 */
-    private removeSupersededAssets(compilation: Compilation, assets: CompilationAsset[]) {
-        assets.forEach(asset => {
+    private removeSupersededAssets(compilation: Compilation) {
+        compilation.getAssets().forEach(asset => {
             if (asset.name === HMR_PATCH_ASSET) return
             if (!isPassthroughAsset(asset.name)) return compilation.deleteAsset(asset.name)
 
@@ -223,15 +96,16 @@ export class HmrPatchPlugin {
     }
 
     private emitPatchAsset(compilation: Compilation, isHotUpdate: boolean) {
-        const source = new RawSource(createPatchAssetSource(this.patchManager.getPatches()))
+        const source = new RawSource(this.patchProcessor.generate())
         const assetInfo = {hotModuleReplacement: isHotUpdate}
         if (compilation.getAsset(HMR_PATCH_ASSET)) compilation.updateAsset(HMR_PATCH_ASSET, source, assetInfo)
         else compilation.emitAsset(HMR_PATCH_ASSET, source, assetInfo)
     }
 
     private reset() {
-        this.hasCompletedInitialBuild = false
+        this.previousHash = ''
+        this.initialBuildDone = false
         this.emittedAssetSources.clear()
-        this.patchManager.clear()
+        this.patchProcessor.reset()
     }
 }

package/src/patch/hmr-patch-processor.ts

@@ -0,0 +1,149 @@
+import {type Compilation,} from "webpack";
+import generator from '@babel/generator'
+import {
+    parseHotUpdateAssets,
+    ParseHotUpdateAssetsOptions,
+    parseChunkAsset, mergeUpdatePatches, generatePatchAssetSource,
+} from "./utils";
+import {createHash} from "crypto";
+import {ModuleFactory, UpdatePatchSource} from "./types";
+import {DEFAULT_HMR_PATCH_HISTORY_LIMIT} from "../constants";
+
+interface ModuleHash {
+    moduleId: string;
+    factoryHash: string;
+}
+
+interface ProcessChunkModulesOptions {
+    source: string
+    compilation: Compilation,
+    isBootstrapChunk: boolean
+}
+
+export interface HmrPatchProcessorOptions {
+    patchHistoryLimit?: number
+}
+
+interface ProcessUpdateOptions extends ParseHotUpdateAssetsOptions {
+    fromHash: string
+    toHash: string
+}
+
+type BootstrapFactories = Map<string, ModuleFactory>
+
+type ModuleHashesByFullHash = Map<string, Map<string, ModuleHash>>
+
+export class HmrPatchProcessor {
+    private readonly bootstrapFactories: BootstrapFactories = new Map()
+
+    private readonly bootstrapFactoriesByCompilation = new WeakMap<Compilation, BootstrapFactories>()
+
+    private readonly moduleHashesByFullHash: ModuleHashesByFullHash = new Map()
+
+    private recentUpdatePatches: UpdatePatchSource[] = []
+
+    private readonly opts: Partial<HmrPatchProcessorOptions>
+
+    constructor(opts: Partial<HmrPatchProcessorOptions>) {
+        this.opts = opts
+    }
+
+    private getChangedModuleIdsByFullHash(fromHash: string, toHash: string): Set<string> | undefined {
+        const fromModuleHashes = this.moduleHashesByFullHash.get(fromHash)
+
+        const toModuleHashes = this.moduleHashesByFullHash.get(toHash)
+
+        // 任一编译缺少 Hash 基线时不做过滤，避免误丢有效的 hot-update 模块。
+        if (!fromModuleHashes || !toModuleHashes) return
+
+        // 同时检查前后两次编译的模块，确保新增、修改和删除都能被识别。
+        const moduleIds = new Set(fromModuleHashes.keys())
+        toModuleHashes.forEach((_, moduleId) => moduleIds.add(moduleId))
+
+        const changedModuleIds = new Set<string>()
+        moduleIds.forEach(moduleId => {
+            const fromFactoryHash = fromModuleHashes.get(moduleId)?.factoryHash
+            const toFactoryHash = toModuleHashes.get(moduleId)?.factoryHash
+            if (fromFactoryHash !== toFactoryHash) changedModuleIds.add(moduleId)
+        })
+
+        return changedModuleIds
+    }
+
+    processUpdate(opt: ProcessUpdateOptions) {
+        const {fromHash, toHash} = opt
+
+        const tempPatchInfo = parseHotUpdateAssets(opt)
+
+        const changedModuleIds = this.getChangedModuleIdsByFullHash(fromHash, toHash)
+
+        const moduleFactories = (() => {
+            if (!changedModuleIds) return Array.from(tempPatchInfo.moduleFactories.values())
+            return Array.from(tempPatchInfo.moduleFactories.values()).filter(item => changedModuleIds.has(item.moduleId))
+        })()
+
+        const removedModules = (() => {
+            if (!changedModuleIds) return Array.from(tempPatchInfo.removedModules.values())
+            return Array.from(tempPatchInfo.removedModules.values()).filter(item => changedModuleIds.has(item))
+        })()
+
+        this.recentUpdatePatches.push({type: 'update', moduleFactories, fromHash, toHash, removedModules})
+
+        const patchHistoryLimit = Math.max(1, this.opts.patchHistoryLimit ?? DEFAULT_HMR_PATCH_HISTORY_LIMIT)
+
+        if (this.recentUpdatePatches.length <= patchHistoryLimit) return
+
+        const [oldestUpdatePatch, secondOldestUpdatePatch, ...rest] = this.recentUpdatePatches
+
+        const mergedUpdatePatch = mergeUpdatePatches(oldestUpdatePatch, secondOldestUpdatePatch)
+
+        this.recentUpdatePatches = [mergedUpdatePatch, ...rest]
+
+        this.moduleHashesByFullHash.delete(oldestUpdatePatch.toHash)
+    }
+
+    processChunkModules(opt: ProcessChunkModulesOptions) {
+        const {hash: fullHash} = opt.compilation
+        const modules = parseChunkAsset(opt.source)
+        modules.forEach(moduleFactory => {
+            const {moduleId, factory} = moduleFactory
+
+            if (opt.isBootstrapChunk) {
+                const compilationFactories = this.bootstrapFactoriesByCompilation.get(opt.compilation) ?? new Map()
+                compilationFactories.set(moduleId, {moduleId, factory})
+                this.bootstrapFactoriesByCompilation.set(opt.compilation, compilationFactories)
+            }
+
+            if (!fullHash) return
+
+            const moduleHashes = (() => {
+                const hasCurFullHashModuleHashMap = this.moduleHashesByFullHash.has(fullHash)
+                if (!hasCurFullHashModuleHashMap) this.moduleHashesByFullHash.set(fullHash, new Map())
+                return this.moduleHashesByFullHash.get(fullHash)!
+            })()
+
+            const {code: source} = generator(factory, {compact: true, comments: false, minified: true,})
+            const factoryHash = createHash('sha256').update(source).digest('hex')
+            moduleHashes.set(moduleId, {moduleId, factoryHash})
+        })
+    }
+
+    commitBootstrapFactories(compilation: Compilation) {
+        this.bootstrapFactories.clear()
+        this.bootstrapFactoriesByCompilation.get(compilation)?.forEach(moduleFactory => {
+            this.bootstrapFactories.set(moduleFactory.moduleId, moduleFactory)
+        })
+        this.bootstrapFactoriesByCompilation.delete(compilation)
+    }
+
+    generate() {
+        const {bootstrapFactories, recentUpdatePatches} = this
+        return generatePatchAssetSource({bootstrapFactories, recentUpdatePatches})
+    }
+
+    reset() {
+        this.bootstrapFactories.clear()
+        this.moduleHashesByFullHash.clear()
+        this.recentUpdatePatches = []
+    }
+}

package/src/patch/types.ts

@@ -0,0 +1,19 @@
+import type {Expression} from "@babel/types";
+
+export interface ModuleFactory {
+    factory: Expression,
+    moduleId: string
+}
+
+export interface HotUpdateManifest {
+    m?: Array<string | number>
+}
+
+export interface UpdatePatchSource {
+    type: 'update'
+    fromHash: string
+    toHash: string
+    moduleFactories: ModuleFactory[]
+    removedModules: string[]
+}
+

package/src/patch/utils.ts

@@ -0,0 +1,174 @@
+import * as t from "@babel/types";
+import {parse} from "@babel/parser";
+import traverse from "@babel/traverse";
+import template from "@babel/template";
+import generator from "@babel/generator";
+import {Asset} from "webpack";
+import {HotUpdateManifest, ModuleFactory} from "./types";
+import type {ObjectExpression} from "@babel/types";
+import {UpdatePatchSource} from "./types";
+
+
+/**
+ * 解析模块 Factory
+ * @param expression
+ */
+const parseModuleFactories = (expression: ObjectExpression) => {
+
+    const moduleFactories = new Map<string, ModuleFactory>()
+
+    if (!t.isObjectExpression(expression)) return moduleFactories.values()
+
+    expression.properties.forEach(property => {
+        if (!t.isObjectProperty(property) || !t.isExpression(property.value)) throw new Error('[taro-hmr-compile] HMR 模块对象包含无法识别的属性')
+
+        const {key, value: factory} = property
+
+        const moduleId = (() => {
+            if (t.isStringLiteral(key) || t.isNumericLiteral(key)) return String(key.value)
+            if (t.isIdentifier(key) && !property.computed) return key.name
+            throw new Error('[taro-hmr-compile] Chunk 模块对象包含无法识别的模块 ID')
+        })()
+
+        moduleFactories.set(moduleId, {factory, moduleId})
+    })
+
+    return moduleFactories.values()
+}
+
+
+export interface ParseHotUpdateAssetsOptions {
+    manifests: Readonly<Asset>[]
+    scripts: Readonly<Asset>[]
+}
+
+/**
+ * 解析热更新产物
+ * @param opt
+ */
+export const parseHotUpdateAssets = (opt: ParseHotUpdateAssetsOptions) => {
+    const {manifests, scripts} = opt
+
+    const moduleFactories = new Map<string, ModuleFactory>()
+
+    scripts.forEach(asset => {
+
+        const ast = parse(asset.source.source().toString(), {sourceType: 'script'})
+
+        traverse(ast, {
+            CallExpression(nodePath) {
+                const {callee} = nodePath.node
+
+                if (!t.isMemberExpression(callee) || !t.isIdentifier(callee.object, {name: 'wx'})) return
+
+                if (!t.isStringLiteral(callee.property) || !callee.property.value.startsWith('webpackHotUpdate')) return
+
+                const [_, modules] = nodePath.node.arguments
+
+                if (!t.isObjectExpression(modules)) return
+
+                parseModuleFactories(modules).forEach(module => moduleFactories.set(module.moduleId, module))
+            },
+        })
+    })
+
+    const removedModules = new Set<string>()
+
+    manifests.forEach((module) => {
+
+        const manifest = JSON.parse(module.source.source().toString()) as HotUpdateManifest
+
+        const {m: tempRemoveModules = []} = manifest
+
+        tempRemoveModules.forEach(removedModule => removedModules.add(String(removedModule)))
+    }, [])
+
+    return {moduleFactories, removedModules}
+}
+
+/**
+ * 解析 chunk 产物
+ * @param source
+ */
+export const parseChunkAsset = (source: string): Map<string, ModuleFactory> => {
+    const ast = parse(`(${source})`, {sourceType: 'script'})
+
+    const [statement] = ast.program.body
+
+    if (!t.isExpressionStatement(statement) || !t.isObjectExpression(statement.expression)) throw new Error('[taro-hmr-compile] Chunk 模块段不是对象表达式')
+
+    const moduleFactories = new Map<string, ModuleFactory>()
+
+    parseModuleFactories(statement.expression).forEach(module => moduleFactories.set(module.moduleId, module))
+
+    return moduleFactories
+}
+
+export const mergeUpdatePatches = (basePatch: UpdatePatchSource, nextPatch: UpdatePatchSource,): UpdatePatchSource => {
+    if (basePatch.toHash !== nextPatch.fromHash) throw new Error(`[taro-hmr-compile] 无法合并不连续的 HMR patch：${basePatch.toHash} !== ${nextPatch.fromHash}`)
+
+    const moduleFactories = new Map(basePatch.moduleFactories.map(moduleFactory => [moduleFactory.moduleId, moduleFactory]))
+
+    const removedModules = new Set(basePatch.removedModules)
+
+    nextPatch.moduleFactories.forEach(moduleFactory => {
+        const {moduleId} = moduleFactory
+        moduleFactories.set(moduleId, moduleFactory)
+        removedModules.delete(moduleId)
+    })
+
+    nextPatch.removedModules.forEach(moduleId => {
+        moduleFactories.delete(moduleId)
+        removedModules.add(moduleId)
+    })
+
+    return {
+        type: 'update',
+        fromHash: basePatch.fromHash,
+        toHash: nextPatch.toHash,
+        moduleFactories: [...moduleFactories.values()],
+        removedModules: [...removedModules],
+    }
+}
+
+export interface generatePatchAssetSourceOpts {
+    bootstrapFactories: Map<string, ModuleFactory>
+    recentUpdatePatches: UpdatePatchSource[]
+}
+
+export const generatePatchAssetSource = (opt: generatePatchAssetSourceOpts): string => {
+    const {bootstrapFactories, recentUpdatePatches} = opt
+    const buildBootstrapPatch = template.expression(`({
+        type: 'bootstrap',
+        modules: MODULES
+    })`)
+    const buildUpdatePatch = template.expression(`({
+        type: 'update',
+        fromHash: "FROM_HASH",
+        toHash: "TO_HASH",
+        modules: MODULES,
+        removedModules: REMOVED_MODULES
+    })`)
+    const buildPatchAsset = template.program('module.exports = PATCHES;')
+    const bootstrapModules = Array.from(bootstrapFactories.values()).map((moduleFactory) => {
+        const {moduleId, factory} = moduleFactory
+        return t.objectProperty(t.stringLiteral(moduleId), factory)
+    })
+    const patchNodes = [
+        buildBootstrapPatch({MODULES: t.objectExpression(bootstrapModules)}),
+        ...recentUpdatePatches.map(patch => {
+            const updateModules = patch.moduleFactories.map((moduleFactory) => {
+                const {moduleId, factory} = moduleFactory
+                return t.objectProperty(t.stringLiteral(moduleId), factory)
+            })
+            return buildUpdatePatch({
+                FROM_HASH: patch.fromHash,
+                TO_HASH: patch.toHash,
+                MODULES: t.objectExpression(updateModules),
+                REMOVED_MODULES: t.arrayExpression(patch.removedModules.map(moduleId => t.stringLiteral(moduleId))),
+            })
+        }),
+    ]
+
+    return generator(buildPatchAsset({PATCHES: t.arrayExpression(patchNodes)})).code
+}

package/dist/patch/hmr-patch-manager.d.ts

@@ -1,30 +0,0 @@
-import type { Expression } from '@babel/types';
-export interface BootstrapPatchSource {
-    type: 'bootstrap';
-    moduleFactories: Map<string, Expression>;
-}
-export interface UpdatePatchSource {
-    type: 'update';
-    fromHash: string;
-    toHash: string;
-    moduleFactories: Map<string, Expression>;
-    removedModules: string[];
-}
-export type PatchSource = BootstrapPatchSource | UpdatePatchSource;
-/** 仅维护 bootstrap/update Patch 状态、连续性和压缩，不依赖 Webpack 编译对象。 */
-export declare class HmrPatchManager {
-    private bootstrapPatch?;
-    private compactedUpdatePatch?;
-    private readonly recentUpdatePatches;
-    private readonly limit;
-    constructor(limit: number);
-    clear(): void;
-    setBootstrap(moduleFactories: Map<string, Expression>): void;
-    /** 追加 update；发现 hash 不连续时丢弃旧 update 链，并在追加后执行容量压缩。 */
-    appendUpdate(patch: UpdatePatchSource): void;
-    /** 按客户端消费顺序返回 bootstrap、压缩 update 与近期 update。 */
-    getPatches(): PatchSource[];
-    private clearUpdateHistory;
-    /** 将超出上限的旧 update 逐步合并到首个 update；bootstrap 永不参与 merge。 */
-    private compactUpdateHistory;
-}