@tarojs/webpack5-runner 4.1.12-beta.32 → 4.1.12-beta.33

package/dist/plugins/SubPackageIndiePlugin.js

@@ -0,0 +1,863 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUBPACKAGE_STANDALONE_CHILD_TAG = exports.recursiveComponentName = 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");
+const TaroSingleEntryPlugin_1 = __importDefault(require("./TaroSingleEntryPlugin"));
+exports.subPackageIndieCustomWrapperRootsKey = '__taroSubPackageIndieCustomWrapperRoots';
+exports.recursiveComponentName = 'recursive-component';
+exports.SUBPACKAGE_STANDALONE_CHILD_TAG = 'sub_package_indie_standalone_child';
+const PLUGIN_NAME = 'TaroSubPackageIndiePlugin';
+class SubPackageIndiePlugin {
+    constructor(miniPlugin) {
+        this.moduleRequestMap = new Map();
+        this.miniPlugin = miniPlugin;
+        this.options = miniPlugin.options;
+    }
+    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.compileExtraEntries.tap(PLUGIN_NAME, (compiler, compilation, promises) => {
+            this.compileSubPackageIndieStandaloneEntries(compiler, compilation, promises);
+        });
+        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);
+            }
+        });
+        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();
+            const isUsingCustomWrapper = component_1.componentConfig.thirdPartyComponents.has(MiniPlugin_1.customWrapperName);
+            const shouldKeepRecursiveComponent = !this.options.template.isSupportRecursive || isUsingCustomWrapper;
+            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}`];
+                    delete compilation.assets[`${root}/${exports.recursiveComponentName}.js`];
+                    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 (!shouldKeepRecursiveComponent) {
+                this.getAllIndieRoots().forEach(root => {
+                    delete compilation.assets[`${root}/${exports.recursiveComponentName}.js`];
+                });
+            }
+            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`];
+            }
+        });
+        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) {
+        if (typeof rootConfig === 'string') {
+            return { path: this.normalizeIndieRoot(rootConfig), disableRecursiveComponent: false };
+        }
+        return {
+            path: this.normalizeIndieRoot(rootConfig.path),
+            disableRecursiveComponent: !!rootConfig.disableRecursiveComponent,
+        };
+    }
+    getSubPackageIndieConfigs() {
+        var _a;
+        const subPackageIndie = (_a = this.miniPlugin.appConfig) === null || _a === void 0 ? void 0 : _a.subPackageIndie;
+        if (!Array.isArray(subPackageIndie))
+            return [];
+        return subPackageIndie.map(({ mainPackageRoot, subPackageRoots = [] }) => {
+            const mainParsed = this.parseIndieRootConfig(mainPackageRoot);
+            const subParsedList = subPackageRoots.map(root => this.parseIndieRootConfig(root));
+            const disableRecursiveComponentRoots = new Set();
+            if (mainParsed.disableRecursiveComponent) {
+                disableRecursiveComponentRoots.add(mainParsed.path);
+            }
+            subParsedList.forEach(sub => {
+                if (sub.disableRecursiveComponent) {
+                    disableRecursiveComponentRoots.add(sub.path);
+                }
+            });
+            return {
+                mainPackageRoot: mainParsed.path,
+                subPackageRoots: Array.from(new Set(subParsedList.map(sub => sub.path))),
+                disableRecursiveComponentRoots,
+            };
+        });
+    }
+    getAllIndieRoots() {
+        return Array.from(new Set(this.getSubPackageIndieConfigs().flatMap(({ mainPackageRoot, subPackageRoots }) => [mainPackageRoot, ...subPackageRoots])));
+    }
+    getAllMainPackageRoots() {
+        return Array.from(new Set(this.getSubPackageIndieConfigs().map(item => item.mainPackageRoot)));
+    }
+    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;
+        const configs = this.getSubPackageIndieConfigs();
+        for (const config of configs) {
+            if (pageName.startsWith(config.mainPackageRoot + '/') || pageName === config.mainPackageRoot) {
+                return {
+                    config,
+                    root: config.mainPackageRoot,
+                    isMainPackageRoot: true,
+                };
+            }
+            for (const root of config.subPackageRoots) {
+                if (pageName.startsWith(root + '/') || pageName === root) {
+                    return {
+                        config,
+                        root,
+                        isMainPackageRoot: false,
+                    };
+                }
+            }
+        }
+        return null;
+    }
+    isInSubPackageIndieRoot(pageName) {
+        var _a;
+        return ((_a = this.getSubPackageIndieMatch(pageName)) === null || _a === void 0 ? void 0 : _a.root) || null;
+    }
+    compileSubPackageIndieStandaloneEntries(compiler, compilation, promises) {
+        const indieRoots = this.getAllIndieRoots();
+        if (!this.options.newBlended || !indieRoots.length)
+            return;
+        const JsonpTemplatePlugin = require('webpack/lib/web/JsonpTemplatePlugin');
+        const NaturalChunkIdsPlugin = require('webpack/lib/ids/NaturalChunkIdsPlugin');
+        indieRoots.forEach(root => {
+            if (this.isRecursiveComponentDisabledForRoot(root))
+                return;
+            const childCompiler = compilation.createChildCompiler(PLUGIN_NAME, {
+                path: compiler.options.output.path,
+                filename: '[name].js',
+                chunkFilename: '[name].js',
+                chunkLoadingGlobal: `subpackage_indie_${root.replace(/[\\/]/g, '_')}`,
+            });
+            childCompiler.inputFileSystem = compiler.inputFileSystem;
+            childCompiler.outputFileSystem = compiler.outputFileSystem;
+            childCompiler.context = compiler.context;
+            new JsonpTemplatePlugin().apply(childCompiler);
+            new NaturalChunkIdsPlugin().apply(childCompiler);
+            new compiler.webpack.DefinePlugin(this.options.constantsReplaceList).apply(childCompiler);
+            childCompiler.hooks.compilation.tap(PLUGIN_NAME, (childCompilation) => {
+                childCompilation.__tag = exports.SUBPACKAGE_STANDALONE_CHILD_TAG;
+                childCompilation.__name = root;
+            });
+            childCompiler.options.optimization = Object.assign(Object.assign({}, childCompiler.options.optimization), { splitChunks: false, runtimeChunk: false });
+            const outputOptions = childCompiler.options.output || {};
+            const libraryOptions = typeof outputOptions.library === 'object' && outputOptions.library !== null
+                ? outputOptions.library
+                : {};
+            childCompiler.options.output = Object.assign(Object.assign({}, outputOptions), { library: Object.assign(Object.assign({}, libraryOptions), { type: 'commonjs2' }) });
+            new TaroSingleEntryPlugin_1.default(compiler.context, node_path_1.default.resolve(__dirname, '..', 'template/recursive-component'), `${root}/${exports.recursiveComponentName}`, helper_1.META_TYPE.EXPORTS).apply(childCompiler);
+            promises.push(new Promise((resolve, reject) => {
+                childCompiler.runAsChild(err => err ? reject(err) : resolve(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;
+        }
+        if (this.isSubPackageIndieRootUsingCustomWrapperByModules(compilation, root)) {
+            return true;
+        }
+        return false;
+    }
+    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) {
+        const entries = new Map();
+        [...this.miniPlugin.pages, ...this.miniPlugin.components].forEach(item => {
+            if (this.isInSubPackageIndieRoot(item.name) === root) {
+                entries.set(item.name, item);
+            }
+        });
+        return Array.from(entries.values());
+    }
+    getComponentByName(componentName) {
+        return [...this.miniPlugin.pages, ...this.miniPlugin.components].find(item => item.name === componentName);
+    }
+    getScopedSubPackageIndieComponentConfig(compilation, root) {
+        var _a;
+        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);
+                }
+            }
+        }
+        return {
+            includes: this.collectScopedInnerComponents(compilation, root),
+            exclude: new Set(component_1.componentConfig.exclude),
+            thirdPartyComponents,
+            includeAll: false,
+            skipRecursiveComponent: false,
+        };
+    }
+    generateSubPackageIndieScriptFile(compilation, compiler, filePath, content) {
+        const { RawSource } = compiler.webpack.sources;
+        compilation.assets[this.miniPlugin.getTargetFilePath(filePath, '.js')] = new RawSource(content);
+    }
+    createRecursiveComponentWrapperSource(componentName) {
+        const args = componentName ? JSON.stringify(componentName) : '';
+        return `const registerRecursiveComponent = globalThis.__taroRegisterRecursiveComponent
+
+if (typeof registerRecursiveComponent !== 'function') {
+  throw new Error('globalThis.__taroRegisterRecursiveComponent is not a function')
+}
+
+registerRecursiveComponent(${args})
+`;
+    }
+    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 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());
+                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));
+                this.miniPlugin.generateTemplateFile(compilation, compiler, `${root}/${MiniPlugin_1.customWrapperName}`, template.buildCustomComponentTemplate, this.options.fileType.templ);
+                this.miniPlugin.generateConfigFile(compilation, compiler, `${root}/${MiniPlugin_1.customWrapperName}`, {
+                    component: true,
+                    styleIsolation: MiniPlugin_1.STYLE_ISOLATION_APPLY_SHARED,
+                    usingComponents: {
+                        [MiniPlugin_1.baseCompName]: `./${MiniPlugin_1.baseCompName}`,
+                        [MiniPlugin_1.customWrapperName]: `./${MiniPlugin_1.customWrapperName}`,
+                    },
+                });
+            }
+        });
+        return customWrapperRoots;
+    }
+    generateMainPackageRuntimeFiles(compilation, _compiler) {
+        const { commonChunks, fileType } = this.options;
+        const mainPackageRoots = this.getAllMainPackageRoots();
+        if (!mainPackageRoots.length)
+            return;
+        const styleExt = fileType.style;
+        const runtimeChunks = ['app', ...commonChunks];
+        mainPackageRoots.forEach(mainPackageRoot => {
+            runtimeChunks.forEach(chunkName => {
+                var _a, _b, _c, _d;
+                const jsFile = `${chunkName}.js`;
+                if (compilation.assets[jsFile]) {
+                    let jsContent = compilation.assets[jsFile];
+                    if (chunkName === 'app') {
+                        const { RawSource } = ((_b = (_a = compilation.compiler) === null || _a === void 0 ? void 0 : _a.webpack) === null || _b === void 0 ? void 0 : _b.sources) || require('webpack').sources;
+                        const originalSource = String(((_d = (_c = jsContent).source) === null || _d === void 0 ? void 0 : _d.call(_c)) || String(jsContent));
+                        const registrarExpr = `(typeof globalThis.__taroRegisterRecursiveComponent==="function"||(globalThis.__taroRegisterRecursiveComponent=function(componentName){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));}))`;
+                        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=`);
+                        }
+                        jsContent = new RawSource(patchedSource);
+                    }
+                    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];
+            }
+        });
+    }
+}
+exports.default = SubPackageIndiePlugin;
+//# sourceMappingURL=SubPackageIndiePlugin.js.map