@tarojs/webpack5-runner 4.2.1-beta.0 → 4.2.1-beta.2

package/dist/plugins/SubPackageIndiePlugin.js

@@ -0,0 +1,1022 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subPackageIndieCustomWrapperRootsKey = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const helper_1 = require("@tarojs/helper");
+const loader_utils_1 = require("loader-utils");
+const component_1 = require("../utils/component");
+const webpack_1 = require("../utils/webpack");
+const MiniPlugin_1 = require("./MiniPlugin");
+exports.subPackageIndieCustomWrapperRootsKey = '__taroSubPackageIndieCustomWrapperRoots';
+const PLUGIN_NAME = 'TaroSubPackageIndiePlugin';
+class SubPackageIndiePlugin {
+    constructor(miniPlugin) {
+        this.moduleRequestMap = new Map();
+        this.subPackageIndieConfigsCache = null;
+        this.allIndieRootsCache = null;
+        this.allMainPackageRootsCache = null;
+        this.subPackageIndieMatchCache = new Map();
+        this.entriesByRootCache = null;
+        this.componentByNameCache = null;
+        this.rootConfigContentCache = new Map();
+        this.forceCustomWrapperByRootCache = new Map();
+        this.scopedComponentConfigByCompilation = new WeakMap();
+        this.rootUsingCustomWrapperByCompilation = new WeakMap();
+        this.miniPlugin = miniPlugin;
+        this.options = miniPlugin.options;
+    }
+    invalidateRunCache() {
+        this.subPackageIndieConfigsCache = null;
+        this.allIndieRootsCache = null;
+        this.allMainPackageRootsCache = null;
+        this.subPackageIndieMatchCache.clear();
+        this.entriesByRootCache = null;
+        this.componentByNameCache = null;
+        this.rootConfigContentCache.clear();
+        this.forceCustomWrapperByRootCache.clear();
+    }
+    apply() {
+        this.miniPlugin.hooks.modifyEntries.tap(PLUGIN_NAME, entries => {
+            const shouldSkipRootEntries = this.hasSubPackageIndieMainPackageRoot() && this.options.newBlended;
+            if (!shouldSkipRootEntries)
+                return entries;
+            return Object.assign(Object.assign({}, entries), { skipRootComp: true, skipRootWrapper: true });
+        });
+        this.miniPlugin.hooks.afterResolveModule.tap(PLUGIN_NAME, (resolveData) => {
+            var _a, _b;
+            if (!this.options.newBlended)
+                return;
+            const issuer = (_a = resolveData.contextInfo) === null || _a === void 0 ? void 0 : _a.issuer;
+            const request = resolveData.request;
+            const resource = ((_b = resolveData.createData) === null || _b === void 0 ? void 0 : _b.resource) || resolveData.resource;
+            if (issuer && request && resource) {
+                this.setResolvedRequestResource(issuer, request, resource);
+            }
+            if (resolveData.request !== helper_1.taroJsComponents)
+                return;
+            if (!issuer || !issuer.startsWith(this.options.sourceDir))
+                return;
+            const componentName = this.miniPlugin.getComponentName(issuer);
+            const root = this.isInSubPackageIndieRoot(componentName);
+            if (!root)
+                return;
+            resolveData.dependencies.forEach((dependency) => {
+                var _a;
+                if (((_a = dependency.ids) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+                    dependency.ids.forEach((id) => {
+                        const dashedName = this.toDashedComponentName(id);
+                        if (!component_1.componentConfig.scopedIncludes.has(root)) {
+                            component_1.componentConfig.scopedIncludes.set(root, new Set());
+                        }
+                        component_1.componentConfig.scopedIncludes.get(root).add(dashedName);
+                    });
+                }
+            });
+        });
+        this.miniPlugin.hooks.modifyChunkRequire.tap(PLUGIN_NAME, (result, chunkId, miniType) => {
+            if (!this.options.newBlended)
+                return result;
+            if (this.miniPlugin.nativeComponents.has(chunkId) || miniType === helper_1.META_TYPE.STATIC) {
+                const isSubPackageIndie = this.isInSubPackageIndieRoot(chunkId);
+                if (isSubPackageIndie) {
+                    return {
+                        source: result.source,
+                        handled: true,
+                    };
+                }
+            }
+            else if (miniType === helper_1.META_TYPE.PAGE) {
+                const subPackageIndieRoot = this.isInSubPackageIndieRoot(chunkId);
+                if (subPackageIndieRoot) {
+                    return {
+                        source: (0, webpack_1.addRequireToSource)(chunkId, result.source, [{ name: `${subPackageIndieRoot}/app` }]),
+                        handled: true,
+                    };
+                }
+            }
+            return result;
+        });
+        this.miniPlugin.hooks.modifySkipRootTemplates.tap(PLUGIN_NAME, skip => {
+            return skip || (this.hasSubPackageIndieMainPackageRoot() && this.options.newBlended);
+        });
+        this.miniPlugin.hooks.generateExtraFiles.tap(PLUGIN_NAME, (customWrapperRoots, compilation, compiler) => {
+            if (!this.options.newBlended)
+                return customWrapperRoots;
+            if (!this.getSubPackageIndieConfigs().length)
+                return customWrapperRoots;
+            const roots = this.generateSubPackageIndieFiles(compilation, compiler, this.options.template, 'base');
+            compilation[exports.subPackageIndieCustomWrapperRootsKey] = roots;
+            return roots;
+        });
+        this.miniPlugin.hooks.modifyComponentConfig.tap(PLUGIN_NAME, ({ config, component }, customWrapperRoots) => {
+            const indieMatch = this.getSubPackageIndieMatch(component.name);
+            if (!indieMatch || component.isNative)
+                return;
+            const importBaseCompPath = this.getRootRelativePath(component.path, indieMatch.root, this.miniPlugin.getTargetFilePath(MiniPlugin_1.baseCompName, ''));
+            const importCustomWrapperPath = this.getRootRelativePath(component.path, indieMatch.root, this.miniPlugin.getTargetFilePath(MiniPlugin_1.customWrapperName, ''));
+            config.content.usingComponents = Object.assign({}, config.content.usingComponents);
+            const isRootUsingCustomWrapper = customWrapperRoots.has(indieMatch.root);
+            const isRootRecursiveDisabled = this.isRecursiveComponentDisabledForRoot(indieMatch.root);
+            if (isRootUsingCustomWrapper && !isRootRecursiveDisabled && !config.content.usingComponents[MiniPlugin_1.customWrapperName]) {
+                config.content.usingComponents[MiniPlugin_1.customWrapperName] = importCustomWrapperPath;
+            }
+            if (!this.options.template.isSupportRecursive && !isRootRecursiveDisabled && !config.content.usingComponents[MiniPlugin_1.baseCompName]) {
+                config.content.usingComponents[MiniPlugin_1.baseCompName] = importBaseCompPath;
+            }
+        });
+        this.miniPlugin.hooks.modifyPageConfig.tap(PLUGIN_NAME, (context, page, customWrapperRoots) => {
+            const subPackageIndieRoot = this.isInSubPackageIndieRoot(page.name);
+            if (!subPackageIndieRoot)
+                return context;
+            const isPageRecursiveDisabled = this.isRecursiveComponentDisabledForRoot(subPackageIndieRoot);
+            const shouldUseCustomWrapper = customWrapperRoots.has(subPackageIndieRoot) && !isPageRecursiveDisabled;
+            return Object.assign(Object.assign({}, context), { importBaseTemplatePath: this.getRootRelativePath(page.path, subPackageIndieRoot, this.miniPlugin.getTemplatePath('base')), importBaseCompPath: this.getRootRelativePath(page.path, subPackageIndieRoot, this.miniPlugin.getTargetFilePath(MiniPlugin_1.baseCompName, '')), importCustomWrapperPath: this.getRootRelativePath(page.path, subPackageIndieRoot, this.miniPlugin.getTargetFilePath(MiniPlugin_1.customWrapperName, '')), shouldUseCustomWrapper,
+                isPageRecursiveDisabled });
+        });
+        this.miniPlugin.hooks.afterGenerateFiles.tap(PLUGIN_NAME, (compilation, compiler) => {
+            if (this.hasSubPackageIndieMainPackageRoot() && this.options.newBlended) {
+                this.generateMainPackageRuntimeFiles(compilation, compiler);
+            }
+            if (this.getSubPackageIndieConfigs().length) {
+                this.cleanSubPackageIndieAppConfig(compilation, compiler);
+            }
+        });
+        this.miniPlugin.hooks.optimizeAssets.tap(PLUGIN_NAME, compilation => {
+            if (!this.options.newBlended)
+                return;
+            const hasSubPackageIndieCustomWrapperRoots = compilation[exports.subPackageIndieCustomWrapperRootsKey] instanceof Set;
+            const subPackageIndieCustomWrapperRoots = hasSubPackageIndieCustomWrapperRoots
+                ? compilation[exports.subPackageIndieCustomWrapperRootsKey]
+                : new Set();
+            this.getAllIndieRoots().forEach(root => {
+                if (this.isRecursiveComponentDisabledForRoot(root)) {
+                    delete compilation.assets[`${root}/${MiniPlugin_1.baseCompName}.js`];
+                    delete compilation.assets[`${root}/${MiniPlugin_1.baseCompName}${this.options.fileType.config}`];
+                    delete compilation.assets[`${root}/${MiniPlugin_1.baseCompName}${this.options.fileType.templ}`];
+                    delete compilation.assets[`${root}/${MiniPlugin_1.customWrapperName}.js`];
+                    delete compilation.assets[`${root}/${MiniPlugin_1.customWrapperName}${this.options.fileType.config}`];
+                    delete compilation.assets[`${root}/${MiniPlugin_1.customWrapperName}${this.options.fileType.templ}`];
+                    return;
+                }
+                const isRootUsingCustomWrapper = hasSubPackageIndieCustomWrapperRoots
+                    ? subPackageIndieCustomWrapperRoots.has(root)
+                    : this.isSubPackageIndieRootUsingCustomWrapper(compilation, root, this.getScopedSubPackageIndieComponentConfig(compilation, root).thirdPartyComponents);
+                if (isRootUsingCustomWrapper)
+                    return;
+                delete compilation.assets[`${root}/${MiniPlugin_1.customWrapperName}.js`];
+                delete compilation.assets[`${root}/${MiniPlugin_1.customWrapperName}${this.options.fileType.config}`];
+                delete compilation.assets[`${root}/${MiniPlugin_1.customWrapperName}${this.options.fileType.templ}`];
+            });
+            if (this.hasSubPackageIndieMainPackageRoot()) {
+                const styleExt = this.options.fileType.style;
+                const runtimeChunks = ['app', ...this.options.commonChunks];
+                runtimeChunks.forEach(chunkName => {
+                    delete compilation.assets[`${chunkName}.js`];
+                    delete compilation.assets[`${chunkName}${styleExt}`];
+                });
+                delete compilation.assets[`app-origin${styleExt}`];
+                delete compilation.assets[`${MiniPlugin_1.baseCompName}.js`];
+                delete compilation.assets[`${MiniPlugin_1.customWrapperName}.js`];
+                delete compilation.assets[`common-templates${this.options.fileType.templ}`];
+            }
+        });
+        this.miniPlugin.hooks.modifyConfig.tap(PLUGIN_NAME, (config, componentName) => {
+            const subPackageIndieRoot = this.isInSubPackageIndieRoot(componentName);
+            if (subPackageIndieRoot && this.miniPlugin.nativeComponents.has(componentName)) {
+                const styleIsolation = this.options.template.isSupportRecursive
+                    ? MiniPlugin_1.STYLE_ISOLATION_APPLY_SHARED
+                    : MiniPlugin_1.STYLE_ISOLATION_SHARED;
+                config.styleIsolation = config.styleIsolation || styleIsolation;
+                config.isNewBlended = true;
+            }
+            return config;
+        });
+        this.miniPlugin.hooks.modifyShouldProcessStyles.tap(PLUGIN_NAME, shouldProcess => {
+            const hasMainPackageRoot = this.hasSubPackageIndieMainPackageRoot() && this.options.newBlended;
+            return shouldProcess || hasMainPackageRoot;
+        });
+        this.miniPlugin.hooks.modifyStyleImport.tap(PLUGIN_NAME, (context, page) => {
+            if (!this.options.newBlended)
+                return context;
+            const indieMatch = this.getSubPackageIndieMatch(page.name);
+            if (!indieMatch)
+                return context;
+            if (this.miniPlugin.nativeComponents.has(page.name)) {
+                if (indieMatch.isMainPackageRoot) {
+                    return Object.assign(Object.assign({}, context), { importStatement: `@import ${JSON.stringify((0, loader_utils_1.urlToRequest)('./app' + this.options.fileType.style))};\n`, shouldSkip: false, isMainPackageRoot: true });
+                }
+                return Object.assign(Object.assign({}, context), { importStatement: '', shouldSkip: true, isMainPackageRoot: false });
+            }
+            if (indieMatch.isMainPackageRoot) {
+                return Object.assign(Object.assign({}, context), { importStatement: `@import ${JSON.stringify((0, loader_utils_1.urlToRequest)('./app' + this.options.fileType.style))};\n`, shouldSkip: false, isMainPackageRoot: true });
+            }
+            return context;
+        });
+    }
+    getRootRelativePath(fromPath, root, targetPath) {
+        return (0, helper_1.promoteRelativePath)(node_path_1.default.relative(fromPath, node_path_1.default.join(this.options.sourceDir, root, targetPath)));
+    }
+    normalizeIndieRoot(root) {
+        if (root.endsWith('/index')) {
+            return node_path_1.default.dirname(root);
+        }
+        return root;
+    }
+    parseIndieRootConfig(rootConfig) {
+        var _a;
+        if (typeof rootConfig === 'string') {
+            return { path: this.normalizeIndieRoot(rootConfig), originalPath: rootConfig, disableRecursiveComponent: false };
+        }
+        return {
+            path: this.normalizeIndieRoot(rootConfig.path),
+            originalPath: rootConfig.path,
+            disableRecursiveComponent: !!rootConfig.disableRecursiveComponent,
+            asyncRoot: (_a = rootConfig.asyncSubPackage) === null || _a === void 0 ? void 0 : _a.asyncRoot,
+        };
+    }
+    getSubPackageIndieConfigs() {
+        if (this.subPackageIndieConfigsCache)
+            return this.subPackageIndieConfigsCache;
+        const appConfig = this.miniPlugin.appConfig;
+        const subPackageIndie = appConfig === null || appConfig === void 0 ? void 0 : appConfig.subPackageIndie;
+        if (!Array.isArray(subPackageIndie)) {
+            this.subPackageIndieConfigsCache = [];
+            return this.subPackageIndieConfigsCache;
+        }
+        const appPages = new Set((appConfig === null || appConfig === void 0 ? void 0 : appConfig.pages) || []);
+        this.subPackageIndieConfigsCache = subPackageIndie.map(({ mainPackageRoot, subPackageRoots = [] }) => {
+            var _a;
+            const mainParsed = this.parseIndieRootConfig(mainPackageRoot);
+            if (!appPages.has(mainParsed.originalPath) && ((_a = this.options.logger) === null || _a === void 0 ? void 0 : _a.quiet) === false) {
+                (0, helper_1.printLog)("warning" /* processTypeEnum.WARNING */, 'subPackageIndie', `mainPackageRoot.path "${mainParsed.originalPath}" 未配置在 app.config 的 pages 中，请补充 pages: [..., "${mainParsed.originalPath}"]，否则主包入口页面文件不会生成。`);
+            }
+            const subParsedList = subPackageRoots.map(root => this.parseIndieRootConfig(root));
+            const disableRecursiveComponentRoots = new Set();
+            const asyncSubPackageRootMap = new Map();
+            if (mainParsed.disableRecursiveComponent) {
+                disableRecursiveComponentRoots.add(mainParsed.path);
+            }
+            if (mainParsed.asyncRoot) {
+                asyncSubPackageRootMap.set(mainParsed.path, mainParsed.asyncRoot);
+            }
+            subParsedList.forEach(sub => {
+                if (sub.disableRecursiveComponent) {
+                    disableRecursiveComponentRoots.add(sub.path);
+                }
+                if (sub.asyncRoot) {
+                    asyncSubPackageRootMap.set(sub.path, sub.asyncRoot);
+                }
+            });
+            return {
+                mainPackageRoot: mainParsed.path,
+                subPackageRoots: Array.from(new Set(subParsedList.map(sub => sub.path))),
+                disableRecursiveComponentRoots,
+                asyncSubPackageRootMap,
+            };
+        });
+        return this.subPackageIndieConfigsCache;
+    }
+    getAllIndieRoots() {
+        if (!this.allIndieRootsCache) {
+            this.allIndieRootsCache = Array.from(new Set(this.getSubPackageIndieConfigs().flatMap(({ mainPackageRoot, subPackageRoots }) => [mainPackageRoot, ...subPackageRoots])));
+        }
+        return this.allIndieRootsCache;
+    }
+    /**
+     * 获取所有配置了 asyncSubPackage 的 root -> asyncRoot 映射
+     * key: source root 路径, value: asyncRoot 路径
+     */
+    getAsyncSubPackageRootMap() {
+        const result = new Map();
+        for (const config of this.getSubPackageIndieConfigs()) {
+            for (const [sourceRoot, asyncRoot] of config.asyncSubPackageRootMap) {
+                result.set(sourceRoot, asyncRoot);
+            }
+        }
+        return result;
+    }
+    /**
+     * 获取 asyncSubPackage 运行时路径解析锚点。
+     * blended 场景下动态组件实际渲染在 mainPackageRoot 页面上下文中，
+     * require.async 也应始终基于当前 mainRoot route 计算到 asyncRoot/index 的相对路径。
+     * sourceRoot -> asyncRoot 映射仍用于 chunk/style/template 归属；运行时只需要 mainPackageRoot -> asyncRoot。
+     */
+    getAsyncSubPackageRuntimeRoots() {
+        const result = [];
+        const seen = new Set();
+        const push = (sourceRoot, asyncRoot) => {
+            const key = `${sourceRoot}${asyncRoot}`;
+            if (seen.has(key))
+                return;
+            seen.add(key);
+            result.push({ sourceRoot, asyncRoot });
+        };
+        for (const config of this.getSubPackageIndieConfigs()) {
+            const asyncRoots = new Set(config.asyncSubPackageRootMap.values());
+            for (const asyncRoot of asyncRoots) {
+                push(config.mainPackageRoot, asyncRoot);
+            }
+        }
+        return result;
+    }
+    getAllMainPackageRoots() {
+        if (!this.allMainPackageRootsCache) {
+            this.allMainPackageRootsCache = Array.from(new Set(this.getSubPackageIndieConfigs().map(item => item.mainPackageRoot)));
+        }
+        return this.allMainPackageRootsCache;
+    }
+    hasSubPackageIndieMainPackageRoot() {
+        return this.getAllMainPackageRoots().length > 0;
+    }
+    isRecursiveComponentDisabledForRoot(root) {
+        return this.getSubPackageIndieConfigs().some(config => config.disableRecursiveComponentRoots.has(root));
+    }
+    getSubPackageIndieMatch(pageName) {
+        if (!this.options.newBlended)
+            return null;
+        if (this.subPackageIndieMatchCache.has(pageName)) {
+            return this.subPackageIndieMatchCache.get(pageName) || null;
+        }
+        const configs = this.getSubPackageIndieConfigs();
+        for (const config of configs) {
+            if (pageName.startsWith(config.mainPackageRoot + '/') || pageName === config.mainPackageRoot) {
+                const match = {
+                    config,
+                    root: config.mainPackageRoot,
+                    isMainPackageRoot: true,
+                };
+                this.subPackageIndieMatchCache.set(pageName, match);
+                return match;
+            }
+            for (const root of config.subPackageRoots) {
+                if (pageName.startsWith(root + '/') || pageName === root) {
+                    const match = {
+                        config,
+                        root,
+                        isMainPackageRoot: false,
+                    };
+                    this.subPackageIndieMatchCache.set(pageName, match);
+                    return match;
+                }
+            }
+        }
+        this.subPackageIndieMatchCache.set(pageName, null);
+        return null;
+    }
+    isInSubPackageIndieRoot(pageName) {
+        var _a;
+        return ((_a = this.getSubPackageIndieMatch(pageName)) === null || _a === void 0 ? void 0 : _a.root) || null;
+    }
+    getModuleSourceContent(module) {
+        var _a;
+        try {
+            const source = (_a = module === null || module === void 0 ? void 0 : module.originalSource) === null || _a === void 0 ? void 0 : _a.call(module);
+            if (!source || typeof source.source !== 'function')
+                return '';
+            return String(source.source() || '');
+        }
+        catch (_err) {
+            return '';
+        }
+    }
+    getModuleResource(module) {
+        var _a;
+        const resource = (module === null || module === void 0 ? void 0 : module.resource) || ((_a = module === null || module === void 0 ? void 0 : module.rootModule) === null || _a === void 0 ? void 0 : _a.resource);
+        return typeof resource === 'string' ? resource : undefined;
+    }
+    collectFlattenedModules(module, collected, visited = new Set()) {
+        if (!module || visited.has(module))
+            return;
+        visited.add(module);
+        collected.add(module);
+        const nestedModuleCollections = [module.rootModule, module.modules, module._modules];
+        nestedModuleCollections.forEach(item => {
+            if (!item)
+                return;
+            if (item && typeof item[Symbol.iterator] === 'function') {
+                for (const nested of item) {
+                    this.collectFlattenedModules(nested, collected, visited);
+                }
+            }
+            else {
+                this.collectFlattenedModules(item, collected, visited);
+            }
+        });
+    }
+    getCompilationModuleResourceMap(compilation) {
+        const moduleMap = new Map();
+        for (const module of compilation.modules) {
+            const flattenedModules = new Set();
+            this.collectFlattenedModules(module, flattenedModules);
+            flattenedModules.forEach(flattenedModule => {
+                const resource = this.getModuleResource(flattenedModule);
+                if (resource) {
+                    moduleMap.set(resource, flattenedModule);
+                }
+            });
+        }
+        return moduleMap;
+    }
+    getChunksBySubPackageIndieRoot(compilation, root) {
+        const chunks = new Set();
+        this.getSubPackageIndieEntriesByRoot(root).forEach(({ name }) => {
+            const entryChunk = Array.from(compilation.chunks).find(chunk => chunk.name === name);
+            if (!entryChunk)
+                return;
+            chunks.add(entryChunk);
+            entryChunk.groupsIterable.forEach(group => {
+                group.chunks.forEach(chunk => chunks.add(chunk));
+            });
+        });
+        return chunks;
+    }
+    getSubPackageIndieModules(compilation, root) {
+        const modules = new Set();
+        this.getChunksBySubPackageIndieRoot(compilation, root).forEach(chunk => {
+            for (const module of compilation.chunkGraph.getChunkModulesIterable(chunk)) {
+                this.collectFlattenedModules(module, modules);
+            }
+        });
+        return modules;
+    }
+    normalizeModuleRequestMapKey(resource) {
+        if (!resource || typeof resource !== 'string')
+            return null;
+        const resourceWithoutLoader = resource.split('!').pop();
+        if (!resourceWithoutLoader)
+            return null;
+        const resourcePath = resourceWithoutLoader.split('?')[0];
+        if (!resourcePath)
+            return null;
+        return node_path_1.default.normalize(resourcePath);
+    }
+    getModuleRequestMapKeys(resource) {
+        const keys = new Set();
+        if (resource && typeof resource === 'string') {
+            keys.add(resource);
+        }
+        const normalizedResource = this.normalizeModuleRequestMapKey(resource);
+        if (normalizedResource) {
+            keys.add(normalizedResource);
+        }
+        return Array.from(keys);
+    }
+    setResolvedRequestResource(issuer, request, resource) {
+        this.getModuleRequestMapKeys(issuer).forEach(key => {
+            if (!this.moduleRequestMap.has(key)) {
+                this.moduleRequestMap.set(key, new Map());
+            }
+            this.moduleRequestMap.get(key).set(request, resource);
+        });
+    }
+    getResolvedRequestResource(issuerResource, request) {
+        var _a;
+        for (const key of this.getModuleRequestMapKeys(issuerResource)) {
+            const resolvedResource = (_a = this.moduleRequestMap.get(key)) === null || _a === void 0 ? void 0 : _a.get(request);
+            if (resolvedResource)
+                return resolvedResource;
+        }
+    }
+    getResolvedModuleByResource(moduleResourceMap, resource) {
+        const exactModule = moduleResourceMap.get(resource);
+        if (exactModule)
+            return exactModule;
+        const normalizedResource = this.normalizeModuleRequestMapKey(resource);
+        if (!normalizedResource)
+            return null;
+        const normalizedModule = moduleResourceMap.get(normalizedResource);
+        if (normalizedModule)
+            return normalizedModule;
+        for (const [moduleResource, module] of moduleResourceMap.entries()) {
+            if (this.normalizeModuleRequestMapKey(moduleResource) === normalizedResource) {
+                return module;
+            }
+        }
+        return null;
+    }
+    resolveRequestedModule(moduleResourceMap, issuerModule, request) {
+        const issuerResource = this.getModuleResource(issuerModule);
+        const resolvedResource = this.getResolvedRequestResource(issuerResource, request);
+        if (resolvedResource) {
+            const resolvedModule = this.getResolvedModuleByResource(moduleResourceMap, resolvedResource);
+            if (resolvedModule)
+                return resolvedModule;
+        }
+        if (issuerResource && /^[.\\/]/.test(request)) {
+            const requestPath = node_path_1.default.resolve(node_path_1.default.dirname(issuerResource), request);
+            const resolvedPath = (0, helper_1.resolveMainFilePath)(requestPath);
+            const requestModule = this.getResolvedModuleByResource(moduleResourceMap, resolvedPath);
+            if (requestModule)
+                return requestModule;
+        }
+        for (const module of moduleResourceMap.values()) {
+            if (!module)
+                continue;
+            if (module.rawRequest === request || module.userRequest === request || module.request === request) {
+                return module;
+            }
+        }
+        return null;
+    }
+    resolveImportBindingToTaroComponentName(moduleResourceMap, issuerModule, binding, propertyName, visited = new Set()) {
+        if (!(binding === null || binding === void 0 ? void 0 : binding.source))
+            return null;
+        if (binding.kind === 'namespace') {
+            if (!propertyName)
+                return null;
+            if (binding.source === helper_1.taroJsComponents) {
+                return propertyName;
+            }
+            const targetModule = this.resolveRequestedModule(moduleResourceMap, issuerModule, binding.source);
+            if (!targetModule) {
+                if (!/^[.\\/]/.test(binding.source)) {
+                    return propertyName;
+                }
+                return null;
+            }
+            return this.resolveModuleExportToTaroComponentName(moduleResourceMap, targetModule, propertyName, visited);
+        }
+        const importedName = binding.imported || propertyName;
+        if (!importedName || importedName === 'default')
+            return null;
+        if (binding.source === helper_1.taroJsComponents) {
+            return importedName;
+        }
+        const targetModule = this.resolveRequestedModule(moduleResourceMap, issuerModule, binding.source);
+        if (!targetModule) {
+            if (!/^[.\\/]/.test(binding.source)) {
+                return importedName;
+            }
+            return null;
+        }
+        return this.resolveModuleExportToTaroComponentName(moduleResourceMap, targetModule, importedName, visited);
+    }
+    resolveModuleExportToTaroComponentName(moduleResourceMap, module, exportName, visited = new Set()) {
+        var _a, _b;
+        const moduleResource = this.getModuleResource(module);
+        if (!moduleResource)
+            return null;
+        const visitKey = `${moduleResource}::${exportName}`;
+        if (visited.has(visitKey))
+            return null;
+        visited.add(visitKey);
+        const exportBinding = (_a = module === null || module === void 0 ? void 0 : module.exportBindings) === null || _a === void 0 ? void 0 : _a[exportName];
+        if (exportBinding) {
+            if (exportBinding.kind === 'reexport' && exportBinding.source) {
+                if (exportBinding.source === helper_1.taroJsComponents) {
+                    return exportBinding.imported || exportName;
+                }
+                const targetModule = this.resolveRequestedModule(moduleResourceMap, module, exportBinding.source);
+                if (targetModule) {
+                    const resolvedName = this.resolveModuleExportToTaroComponentName(moduleResourceMap, targetModule, exportBinding.imported || exportName, visited);
+                    if (resolvedName)
+                        return resolvedName;
+                }
+            }
+            if (exportBinding.kind === 'local' && exportBinding.local) {
+                const importedBinding = (_b = module === null || module === void 0 ? void 0 : module.importedBindings) === null || _b === void 0 ? void 0 : _b[exportBinding.local];
+                if (importedBinding) {
+                    const resolvedName = this.resolveImportBindingToTaroComponentName(moduleResourceMap, module, importedBinding, undefined, visited);
+                    if (resolvedName)
+                        return resolvedName;
+                }
+            }
+        }
+        for (const source of (module === null || module === void 0 ? void 0 : module.exportAllSources) || []) {
+            if (source === helper_1.taroJsComponents) {
+                return exportName;
+            }
+            const targetModule = this.resolveRequestedModule(moduleResourceMap, module, source);
+            if (!targetModule)
+                continue;
+            const resolvedName = this.resolveModuleExportToTaroComponentName(moduleResourceMap, targetModule, exportName, visited);
+            if (resolvedName)
+                return resolvedName;
+        }
+        return null;
+    }
+    resolveUsedComponentRefToTaroComponentName(moduleResourceMap, module, componentRef) {
+        var _a, _b;
+        if (!componentRef)
+            return null;
+        if (componentRef.kind === 'identifier') {
+            const binding = (_a = module === null || module === void 0 ? void 0 : module.importedBindings) === null || _a === void 0 ? void 0 : _a[componentRef.name];
+            if (!binding) {
+                return componentRef.name;
+            }
+            const resolvedName = this.resolveImportBindingToTaroComponentName(moduleResourceMap, module, binding);
+            return resolvedName || componentRef.name;
+        }
+        if (componentRef.kind === 'member') {
+            const binding = (_b = module === null || module === void 0 ? void 0 : module.importedBindings) === null || _b === void 0 ? void 0 : _b[componentRef.object];
+            if (!binding) {
+                return componentRef.property || null;
+            }
+            const resolvedName = this.resolveImportBindingToTaroComponentName(moduleResourceMap, module, binding, componentRef.property);
+            return resolvedName || componentRef.property || null;
+        }
+        return null;
+    }
+    shouldSkipSubPackageIndieModule(module, root) {
+        const resource = this.getModuleResource(module);
+        if (typeof resource !== 'string' || !resource.startsWith(this.options.sourceDir)) {
+            return false;
+        }
+        const componentName = this.miniPlugin.getComponentName(resource);
+        const targetRoot = this.isInSubPackageIndieRoot(componentName);
+        return !!targetRoot && targetRoot !== root;
+    }
+    collectModuleResolvedComponentIncludes(compilation, root) {
+        const includes = new Set();
+        const moduleResourceMap = this.getCompilationModuleResourceMap(compilation);
+        for (const module of this.getSubPackageIndieModules(compilation, root)) {
+            if (this.shouldSkipSubPackageIndieModule(module, root))
+                continue;
+            for (const elementName of (module === null || module === void 0 ? void 0 : module.elementNameSet) || []) {
+                if (!component_1.componentConfig.thirdPartyComponents.has(elementName)) {
+                    includes.add(elementName);
+                }
+            }
+            for (const binding of Object.values((module === null || module === void 0 ? void 0 : module.importedBindings) || {})) {
+                const resolvedComponentName = this.resolveImportBindingToTaroComponentName(moduleResourceMap, module, binding);
+                if (!resolvedComponentName)
+                    continue;
+                const dashedName = this.toDashedComponentName(resolvedComponentName);
+                if (!component_1.componentConfig.thirdPartyComponents.has(dashedName)) {
+                    includes.add(dashedName);
+                }
+            }
+            for (const componentRef of (module === null || module === void 0 ? void 0 : module.usedComponentRefs) || []) {
+                const resolvedComponentName = this.resolveUsedComponentRefToTaroComponentName(moduleResourceMap, module, componentRef);
+                if (!resolvedComponentName)
+                    continue;
+                const dashedName = this.toDashedComponentName(resolvedComponentName);
+                if (!component_1.componentConfig.thirdPartyComponents.has(dashedName)) {
+                    includes.add(dashedName);
+                }
+            }
+        }
+        return includes;
+    }
+    expandScopedIncludes(includes) {
+        const scopedIncludes = new Set(includes);
+        if (scopedIncludes.has('view')) {
+            scopedIncludes.add('catch-view');
+            scopedIncludes.add('static-view');
+            scopedIncludes.add('pure-view');
+            scopedIncludes.add('click-view');
+        }
+        if (scopedIncludes.has('image')) {
+            scopedIncludes.add('static-image');
+        }
+        if (scopedIncludes.has('text')) {
+            scopedIncludes.add('static-text');
+        }
+        return scopedIncludes;
+    }
+    toDashedComponentName(componentName) {
+        return componentName.replace(/[A-Z]/g, (match, offset) => `${offset === 0 ? '' : '-'}${match.toLowerCase()}`);
+    }
+    collectScopedInnerComponents(compilation, root) {
+        const includes = new Set();
+        const scopedIncludes = component_1.componentConfig.scopedIncludes.get(root);
+        if (scopedIncludes && scopedIncludes.size > 0) {
+            scopedIncludes.forEach(name => includes.add(name));
+        }
+        this.collectModuleResolvedComponentIncludes(compilation, root).forEach(name => includes.add(name));
+        const finalIncludes = includes.size > 0
+            ? includes
+            : new Set(component_1.componentConfig.includes);
+        return this.expandScopedIncludes(finalIncludes);
+    }
+    isSubPackageIndieRootUsingCustomWrapperByModules(compilation, root) {
+        const moduleResourceMap = this.getCompilationModuleResourceMap(compilation);
+        for (const module of this.getSubPackageIndieModules(compilation, root)) {
+            if (this.shouldSkipSubPackageIndieModule(module, root))
+                continue;
+            for (const componentRef of (module === null || module === void 0 ? void 0 : module.usedComponentRefs) || []) {
+                const resolvedComponentName = this.resolveUsedComponentRefToTaroComponentName(moduleResourceMap, module, componentRef);
+                if (resolvedComponentName === 'CustomWrapper') {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    isSubPackageIndieRootUsingCustomWrapper(compilation, root, scopedThirdPartyComponents) {
+        if (scopedThirdPartyComponents === null || scopedThirdPartyComponents === void 0 ? void 0 : scopedThirdPartyComponents.has(MiniPlugin_1.customWrapperName)) {
+            return true;
+        }
+        let cache = this.rootUsingCustomWrapperByCompilation.get(compilation);
+        if (!cache) {
+            cache = new Map();
+            this.rootUsingCustomWrapperByCompilation.set(compilation, cache);
+        }
+        if (cache.has(root)) {
+            return cache.get(root) || false;
+        }
+        const usingCustomWrapper = this.isSubPackageIndieRootUsingCustomWrapperByModules(compilation, root);
+        cache.set(root, usingCustomWrapper);
+        return usingCustomWrapper;
+    }
+    resolveUsingComponentTarget(filePath, componentPath) {
+        if (componentPath.startsWith('plugin://'))
+            return null;
+        let sourcePath = componentPath;
+        if (node_path_1.default.isAbsolute(componentPath)) {
+            sourcePath = helper_1.fs.existsSync(componentPath)
+                ? componentPath
+                : node_path_1.default.resolve(this.options.sourceDir, `.${componentPath}`);
+        }
+        else {
+            const isRelativePath = /^[.\\/]/;
+            if (!isRelativePath.test(componentPath))
+                return null;
+            sourcePath = node_path_1.default.resolve(node_path_1.default.dirname(filePath), componentPath);
+        }
+        const targetPath = (0, helper_1.resolveMainFilePath)(sourcePath);
+        const targetName = this.miniPlugin.getComponentName(targetPath);
+        return {
+            path: targetPath,
+            name: targetName,
+            root: this.isInSubPackageIndieRoot(targetName),
+        };
+    }
+    cloneThirdPartyComponent(thirdPartyComponents, componentName) {
+        const attrs = component_1.componentConfig.thirdPartyComponents.get(componentName);
+        if (!attrs || thirdPartyComponents.has(componentName))
+            return;
+        thirdPartyComponents.set(componentName, new Set(attrs));
+    }
+    getSubPackageIndieEntriesByRoot(root) {
+        if (!this.entriesByRootCache) {
+            const entriesByRoot = new Map();
+            [...this.miniPlugin.pages, ...this.miniPlugin.components].forEach(item => {
+                const indieRoot = this.isInSubPackageIndieRoot(item.name);
+                if (!indieRoot)
+                    return;
+                if (!entriesByRoot.has(indieRoot)) {
+                    entriesByRoot.set(indieRoot, new Map());
+                }
+                entriesByRoot.get(indieRoot).set(item.name, item);
+            });
+            this.entriesByRootCache = new Map();
+            entriesByRoot.forEach((entries, indieRoot) => {
+                this.entriesByRootCache.set(indieRoot, Array.from(entries.values()));
+            });
+        }
+        return this.entriesByRootCache.get(root) || [];
+    }
+    getSubPackageIndieRootEntry(root) {
+        const entries = this.getSubPackageIndieEntriesByRoot(root);
+        return entries.find(entry => entry.name === `${root}/index`) || entries.find(entry => entry.name === root) || entries[0];
+    }
+    getSubPackageIndieRootConfigContent(root) {
+        var _a;
+        if (this.rootConfigContentCache.has(root)) {
+            return this.rootConfigContentCache.get(root);
+        }
+        const entry = this.getSubPackageIndieRootEntry(root);
+        const content = entry
+            ? (_a = this.miniPlugin.filesConfig[this.miniPlugin.getConfigFilePath(entry.name)]) === null || _a === void 0 ? void 0 : _a.content
+            : undefined;
+        this.rootConfigContentCache.set(root, content);
+        return content;
+    }
+    getSubPackageIndieRootUsingComponents(root) {
+        const content = this.getSubPackageIndieRootConfigContent(root);
+        return Object.assign({}, content === null || content === void 0 ? void 0 : content.usingComponents);
+    }
+    getSubPackageIndieRootComponentPlaceholder(root) {
+        const content = this.getSubPackageIndieRootConfigContent(root);
+        const componentPlaceholder = content === null || content === void 0 ? void 0 : content.componentPlaceholder;
+        if (!componentPlaceholder || Object.keys(componentPlaceholder).length === 0)
+            return undefined;
+        return Object.assign({}, componentPlaceholder);
+    }
+    isForceCustomWrapperEnabledForRoot(root) {
+        var _a;
+        if (this.options.template.isSupportRecursive)
+            return false;
+        if (this.forceCustomWrapperByRootCache.has(root)) {
+            return this.forceCustomWrapperByRootCache.get(root) || false;
+        }
+        const entries = this.getSubPackageIndieEntriesByRoot(root);
+        for (const entry of entries) {
+            if (entry === null || entry === void 0 ? void 0 : entry.isNative)
+                continue;
+            const content = (_a = this.miniPlugin.filesConfig[this.miniPlugin.getConfigFilePath(entry.name)]) === null || _a === void 0 ? void 0 : _a.content;
+            if (content === null || content === void 0 ? void 0 : content.forceCustomWrapper) {
+                this.forceCustomWrapperByRootCache.set(root, true);
+                return true;
+            }
+        }
+        this.forceCustomWrapperByRootCache.set(root, false);
+        return false;
+    }
+    getComponentByName(componentName) {
+        if (!this.componentByNameCache) {
+            this.componentByNameCache = new Map();
+            [...this.miniPlugin.pages, ...this.miniPlugin.components].forEach(item => {
+                this.componentByNameCache.set(item.name, item);
+            });
+        }
+        return this.componentByNameCache.get(componentName);
+    }
+    getScopedSubPackageIndieComponentConfig(compilation, root) {
+        var _a;
+        let cache = this.scopedComponentConfigByCompilation.get(compilation);
+        if (!cache) {
+            cache = new Map();
+            this.scopedComponentConfigByCompilation.set(compilation, cache);
+        }
+        if (cache.has(root)) {
+            return cache.get(root);
+        }
+        const thirdPartyComponents = new Map();
+        const queue = [...this.getSubPackageIndieEntriesByRoot(root)];
+        const visited = new Set();
+        while (queue.length) {
+            const current = queue.shift();
+            if (!current || visited.has(current.name))
+                continue;
+            visited.add(current.name);
+            const fileConfig = (_a = this.miniPlugin.filesConfig[this.miniPlugin.getConfigFilePath(current.name)]) === null || _a === void 0 ? void 0 : _a.content;
+            const usingComponents = fileConfig === null || fileConfig === void 0 ? void 0 : fileConfig.usingComponents;
+            if (!usingComponents)
+                continue;
+            for (const [componentName, componentValue] of Object.entries(usingComponents)) {
+                if (componentName === MiniPlugin_1.customWrapperName) {
+                    this.cloneThirdPartyComponent(thirdPartyComponents, componentName);
+                    continue;
+                }
+                if (!component_1.componentConfig.thirdPartyComponents.has(componentName))
+                    continue;
+                const componentPath = componentValue instanceof Array ? componentValue[0] : componentValue;
+                const target = this.resolveUsingComponentTarget(current.path, componentPath);
+                this.cloneThirdPartyComponent(thirdPartyComponents, componentName);
+                if (!target)
+                    continue;
+                const targetComponent = this.getComponentByName(target.name);
+                if (targetComponent && (!target.root || target.root === root) && !visited.has(targetComponent.name)) {
+                    queue.push(targetComponent);
+                }
+            }
+        }
+        const scopedComponentConfig = {
+            includes: this.collectScopedInnerComponents(compilation, root),
+            exclude: new Set(component_1.componentConfig.exclude),
+            thirdPartyComponents,
+            includeAll: false,
+            skipRecursiveComponent: false,
+        };
+        cache.set(root, scopedComponentConfig);
+        return scopedComponentConfig;
+    }
+    generateSubPackageIndieScriptFile(compilation, compiler, filePath, content) {
+        const { RawSource } = compiler.webpack.sources;
+        compilation.assets[this.miniPlugin.getTargetFilePath(filePath, '.js')] = new RawSource(content);
+    }
+    createRecursiveComponentWrapperSource(componentName, forceCustomWrapper = false) {
+        const args = [];
+        if (componentName) {
+            args.push(JSON.stringify(componentName));
+        }
+        else if (forceCustomWrapper) {
+            args.push('undefined');
+        }
+        if (forceCustomWrapper) {
+            args.push('true');
+        }
+        return `const registerRecursiveComponent = globalThis.__taroRegisterRecursiveComponent
+
+if (typeof registerRecursiveComponent !== 'function') {
+  throw new Error('globalThis.__taroRegisterRecursiveComponent is not a function')
+}
+
+registerRecursiveComponent(${args.join(', ')})
+`;
+    }
+    generateSubPackageIndieFiles(compilation, compiler, template, baseTemplateName) {
+        const customWrapperRoots = new Set();
+        if (!this.getSubPackageIndieConfigs().length)
+            return customWrapperRoots;
+        const allIndieRoots = this.getAllIndieRoots();
+        allIndieRoots.forEach(root => {
+            const scopedComponentConfig = this.getScopedSubPackageIndieComponentConfig(compilation, root);
+            const isRecursiveDisabled = this.isRecursiveComponentDisabledForRoot(root);
+            if (isRecursiveDisabled) {
+                scopedComponentConfig.skipRecursiveComponent = true;
+            }
+            const forceCustomWrapperForRoot = isRecursiveDisabled
+                ? false
+                : this.isForceCustomWrapperEnabledForRoot(root);
+            const isRootUsingCustomWrapper = isRecursiveDisabled
+                ? false
+                : this.isSubPackageIndieRootUsingCustomWrapper(compilation, root, scopedComponentConfig.thirdPartyComponents);
+            if (isRootUsingCustomWrapper) {
+                customWrapperRoots.add(root);
+                if (!scopedComponentConfig.thirdPartyComponents.has(MiniPlugin_1.customWrapperName)) {
+                    const attrs = component_1.componentConfig.thirdPartyComponents.get(MiniPlugin_1.customWrapperName);
+                    scopedComponentConfig.thirdPartyComponents.set(MiniPlugin_1.customWrapperName, new Set(attrs || []));
+                }
+            }
+            this.miniPlugin.generateTemplateFile(compilation, compiler, `${root}/${baseTemplateName}`, template.buildTemplate, scopedComponentConfig);
+            this.miniPlugin.generateXSFile(compilation, compiler, `${root}/utils`);
+            if (!template.isSupportRecursive && !isRecursiveDisabled) {
+                this.generateSubPackageIndieScriptFile(compilation, compiler, `${root}/${MiniPlugin_1.baseCompName}`, this.createRecursiveComponentWrapperSource(undefined, forceCustomWrapperForRoot));
+                this.miniPlugin.generateTemplateFile(compilation, compiler, `${root}/${MiniPlugin_1.baseCompName}`, template.buildBaseComponentTemplate, this.options.fileType.templ);
+                const compConfig = {
+                    component: true,
+                    styleIsolation: MiniPlugin_1.STYLE_ISOLATION_APPLY_SHARED,
+                    usingComponents: {
+                        [MiniPlugin_1.baseCompName]: `./${MiniPlugin_1.baseCompName}`,
+                    },
+                };
+                if (isRootUsingCustomWrapper) {
+                    compConfig.usingComponents[MiniPlugin_1.customWrapperName] = `./${MiniPlugin_1.customWrapperName}`;
+                }
+                this.miniPlugin.generateConfigFile(compilation, compiler, `${root}/${MiniPlugin_1.baseCompName}`, compConfig);
+            }
+            if (isRootUsingCustomWrapper) {
+                this.generateSubPackageIndieScriptFile(compilation, compiler, `${root}/${MiniPlugin_1.customWrapperName}`, this.createRecursiveComponentWrapperSource(MiniPlugin_1.customWrapperName, forceCustomWrapperForRoot));
+                this.miniPlugin.generateTemplateFile(compilation, compiler, `${root}/${MiniPlugin_1.customWrapperName}`, template.buildCustomComponentTemplate, this.options.fileType.templ);
+                const customWrapperConfig = {
+                    component: true,
+                    styleIsolation: MiniPlugin_1.STYLE_ISOLATION_APPLY_SHARED,
+                    usingComponents: Object.assign(Object.assign({}, this.getSubPackageIndieRootUsingComponents(root)), { [MiniPlugin_1.baseCompName]: `./${MiniPlugin_1.baseCompName}`, [MiniPlugin_1.customWrapperName]: `./${MiniPlugin_1.customWrapperName}` }),
+                };
+                const componentPlaceholder = this.getSubPackageIndieRootComponentPlaceholder(root);
+                if (componentPlaceholder) {
+                    customWrapperConfig.componentPlaceholder = componentPlaceholder;
+                }
+                this.miniPlugin.generateConfigFile(compilation, compiler, `${root}/${MiniPlugin_1.customWrapperName}`, customWrapperConfig);
+            }
+        });
+        return customWrapperRoots;
+    }
+    cleanSubPackageIndieAppConfig(compilation, compiler) {
+        var _a;
+        const { RawSource } = compiler.webpack.sources;
+        const appCfgPath = this.miniPlugin.getConfigFilePath(this.miniPlugin.appEntry);
+        const appCfgName = node_path_1.default.basename(appCfgPath).replace(node_path_1.default.extname(appCfgPath), '');
+        const fc = (_a = this.miniPlugin.filesConfig) === null || _a === void 0 ? void 0 : _a[appCfgName];
+        if (!(fc === null || fc === void 0 ? void 0 : fc.content))
+            return;
+        delete fc.content.subPackageIndie;
+        compilation.assets[this.miniPlugin.getConfigPath(appCfgName)] = new RawSource(JSON.stringify(fc.content, null, 2));
+    }
+    generateMainPackageRuntimeFiles(compilation, compiler) {
+        var _a, _b;
+        const { commonChunks, fileType } = this.options;
+        const mainPackageRoots = this.getAllMainPackageRoots();
+        if (!mainPackageRoots.length)
+            return;
+        const styleExt = fileType.style;
+        const templateExt = fileType.templ;
+        const runtimeChunks = ['app', ...commonChunks];
+        const commonTemplates = `common-templates${templateExt}`;
+        const appJsContent = compilation.assets['app.js'];
+        let patchedAppJsContent = appJsContent;
+        if (appJsContent) {
+            const { RawSource } = compiler.webpack.sources;
+            const originalSource = String(((_b = (_a = appJsContent).source) === null || _b === void 0 ? void 0 : _b.call(_a)) || String(appJsContent));
+            const registrarExpr = `(typeof globalThis.__taroRegisterRecursiveComponent==="function"||(globalThis.__taroRegisterRecursiveComponent=function(componentName,forceCustomWrapper){const cache=__webpack_require__.c||{};let createRecursiveComponentConfig;for(const key in cache){const exports=cache[key]&&cache[key].exports;if(exports&&typeof exports.createRecursiveComponentConfig==="function"){createRecursiveComponentConfig=exports.createRecursiveComponentConfig;break;}}if(typeof createRecursiveComponentConfig!=="function"){const modules=__webpack_require__.m||{};for(const moduleId in modules){const moduleFactory=modules[moduleId];if(!moduleFactory||typeof moduleFactory!=="function")continue;const source=String(moduleFactory);if(source.indexOf("createRecursiveComponentConfig")===-1)continue;const exports=__webpack_require__(moduleId);if(exports&&typeof exports.createRecursiveComponentConfig==="function"){createRecursiveComponentConfig=exports.createRecursiveComponentConfig;break;}}}if(typeof createRecursiveComponentConfig!=="function"){throw new Error("Cannot find createRecursiveComponentConfig in webpack modules");}Component(createRecursiveComponentConfig(componentName,forceCustomWrapper));}))`;
+            let patchedSource = originalSource;
+            if (/,\s*exports\.taroApp\s*=/.test(patchedSource)) {
+                patchedSource = patchedSource.replace(/,\s*exports\.taroApp\s*=/, `,${registrarExpr},exports.taroApp=`);
+            }
+            else {
+                patchedSource = patchedSource.replace(/exports\.taroApp\s*=/, `;${registrarExpr};exports.taroApp=`);
+            }
+            patchedAppJsContent = new RawSource(patchedSource);
+        }
+        mainPackageRoots.forEach(mainPackageRoot => {
+            runtimeChunks.forEach(chunkName => {
+                const jsFile = `${chunkName}.js`;
+                if (compilation.assets[jsFile]) {
+                    const jsContent = chunkName === 'app'
+                        ? patchedAppJsContent
+                        : compilation.assets[jsFile];
+                    compilation.assets[`${mainPackageRoot}/${jsFile}`] = jsContent;
+                }
+                const cssFile = `${chunkName}${styleExt}`;
+                if (compilation.assets[cssFile]) {
+                    compilation.assets[`${mainPackageRoot}/${cssFile}`] = compilation.assets[cssFile];
+                }
+            });
+            const appOriginCss = `app-origin${styleExt}`;
+            if (compilation.assets[appOriginCss]) {
+                compilation.assets[`${mainPackageRoot}/${appOriginCss}`] = compilation.assets[appOriginCss];
+            }
+            if (compilation.assets[commonTemplates]) {
+                compilation.assets[`${mainPackageRoot}/${commonTemplates}`] = compilation.assets[commonTemplates];
+            }
+        });
+    }
+}
+exports.default = SubPackageIndiePlugin;
+//# sourceMappingURL=SubPackageIndiePlugin.js.map