@neuxnet/neux-cli 0.2.3

package/vendor/dimina-compiler/index.cjs

@@ -0,0 +1,762 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_sourcemap = require("./sourcemap-BgtIgqkC.cjs");
+const require_core_style_compiler = require("./core/style-compiler.cjs");
+const require_core_view_compiler = require("./core/view-compiler.cjs");
+let node_fs = require("node:fs");
+node_fs = require_sourcemap.__toESM(node_fs, 1);
+let node_path = require("node:path");
+node_path = require_sourcemap.__toESM(node_path, 1);
+let node_process = require("node:process");
+node_process = require_sourcemap.__toESM(node_process, 1);
+let node_url = require("node:url");
+let node_worker_threads = require("node:worker_threads");
+let listr2 = require("listr2");
+let node_os = require("node:os");
+node_os = require_sourcemap.__toESM(node_os, 1);
+//#region src/common/compile-progress.js
+var DEFAULT_TERMINAL_COLUMNS = 80;
+var MIN_PROGRESS_WIDTH = 8;
+var MAX_PROGRESS_WIDTH = 28;
+var RENDERER_CHROME_WIDTH = 14;
+var PROGRESS_BRACKETS_WIDTH = 2;
+/**
+* Format worker progress without assuming a fixed terminal width.
+* The completed count remains the source of truth. Whole cells avoid the
+* visible gap that partial block glyphs leave before the unfilled section.
+*/
+function formatCompileProgress(completed, total, options = {}) {
+	const unicode = options.unicode ?? (0, listr2.isUnicodeSupported)();
+	const columns = normalizePositiveInteger(options.columns) || node_process.default.stdout.columns || DEFAULT_TERMINAL_COLUMNS;
+	const safeTotal = normalizePositiveInteger(total);
+	const safeCompleted = Math.min(normalizePositiveInteger(completed), safeTotal);
+	const ratio = safeTotal === 0 ? 0 : safeCompleted / safeTotal;
+	const percentage = Math.round(ratio * 100);
+	const separator = unicode ? "·" : "|";
+	const metadata = `${String(safeCompleted).padStart(String(safeTotal).length)}/${safeTotal} ${separator} ${String(percentage).padStart(3)}%`;
+	const availableWidth = columns - metadata.length - RENDERER_CHROME_WIDTH - PROGRESS_BRACKETS_WIDTH;
+	if (availableWidth < MIN_PROGRESS_WIDTH) return metadata;
+	const width = Math.min(availableWidth, MAX_PROGRESS_WIDTH);
+	return `[${unicode ? createUnicodeBar(ratio, width) : createAsciiBar(ratio, width)}]  ${metadata}`;
+}
+function createUnicodeBar(ratio, width) {
+	const completeWidth = Math.round(ratio * width);
+	const emptyWidth = width - completeWidth;
+	return `${"█".repeat(completeWidth)}${"░".repeat(emptyWidth)}`;
+}
+function createAsciiBar(ratio, width) {
+	const completeWidth = Math.floor(ratio * width);
+	const showHead = ratio > 0 && ratio < 1;
+	const bodyWidth = Math.max(0, completeWidth - (showHead ? 1 : 0));
+	const emptyWidth = width - bodyWidth - (showHead ? 1 : 0);
+	return `${"=".repeat(bodyWidth)}${showHead ? ">" : ""}${"-".repeat(emptyWidth)}`;
+}
+function normalizePositiveInteger(value) {
+	return Number.isFinite(value) ? Math.max(0, Math.trunc(value)) : 0;
+}
+//#endregion
+//#region src/common/publish.js
+function createDist(seedPath) {
+	const distPath = require_sourcemap.getTargetPath();
+	if (node_fs.default.existsSync(distPath)) node_fs.default.rmSync(distPath, {
+		recursive: true,
+		force: true
+	});
+	node_fs.default.mkdirSync(distPath, { recursive: true });
+	if (seedPath && node_fs.default.existsSync(seedPath)) node_fs.default.cpSync(seedPath, distPath, { recursive: true });
+}
+/**
+* 发布到指定目录
+* @param {string} dist 目标路径
+* @param {boolean} useAppIdDir 是否在路径中包含appId
+*/
+function publishToDist(dist, useAppIdDir = true) {
+	const distPath = require_sourcemap.getTargetPath();
+	const appId = require_sourcemap.getAppId();
+	const absolutePath = useAppIdDir ? `${node_path.default.resolve(node_process.default.cwd(), dist)}${node_path.default.sep}${appId}` : `${node_path.default.resolve(node_process.default.cwd(), dist)}`;
+	if (node_fs.default.existsSync(absolutePath)) node_fs.default.rmSync(absolutePath, {
+		recursive: true,
+		force: true
+	});
+	node_fs.default.mkdirSync(absolutePath, { recursive: true });
+	function copyDir(src, dest) {
+		node_fs.default.mkdirSync(dest, { recursive: true });
+		const entries = node_fs.default.readdirSync(src, { withFileTypes: true });
+		for (const entry of entries) {
+			const srcPath = node_path.default.join(src, entry.name);
+			const destPath = node_path.default.join(dest, entry.name);
+			if (entry.isDirectory()) copyDir(srcPath, destPath);
+			else node_fs.default.copyFileSync(srcPath, destPath);
+		}
+	}
+	copyDir(distPath, absolutePath);
+}
+//#endregion
+//#region src/common/worker-pool.js
+function getCGroupCPUCount() {
+	try {
+		const quotaPath = "/sys/fs/cgroup/cpu/cpu.cfs_quota_us";
+		const periodPath = "/sys/fs/cgroup/cpu/cpu.cfs_period_us";
+		if (node_fs.default.existsSync(quotaPath) && node_fs.default.existsSync(periodPath)) {
+			const quota = Number.parseInt(node_fs.default.readFileSync(quotaPath, "utf8"));
+			const period = Number.parseInt(node_fs.default.readFileSync(periodPath, "utf8"));
+			if (quota > 0) return Math.max(1, Math.floor(quota / period));
+		}
+	} catch (e) {
+		console.warn("Failed to read CPU limits from cgroup:", e.message);
+	}
+	return node_os.default.cpus().length;
+}
+function getCGroupMemoryLimit() {
+	try {
+		const memLimitPath = "/sys/fs/cgroup/memory/memory.limit_in_bytes";
+		if (node_fs.default.existsSync(memLimitPath)) {
+			const memLimit = Number.parseInt(node_fs.default.readFileSync(memLimitPath, "utf8"));
+			if (memLimit < Number.Infinity && memLimit > 0) return memLimit;
+		}
+	} catch (e) {
+		console.warn("Failed to read memory limits from cgroup:", e.message);
+	}
+	return node_os.default.totalmem();
+}
+var MAX_WORKERS = Math.max(1, Math.min(4, Math.floor(getCGroupCPUCount() / 4)));
+var WorkerPool = class {
+	constructor(maxWorkers = MAX_WORKERS) {
+		this.maxWorkers = maxWorkers;
+		this.activeWorkers = 0;
+		this.queue = [];
+		this.memoryLimit = Math.floor(getCGroupMemoryLimit() * .6 / maxWorkers);
+	}
+	async runWorker(workerCreator) {
+		if (this.activeWorkers >= this.maxWorkers) await new Promise((resolve) => this.queue.push(resolve));
+		this.activeWorkers++;
+		try {
+			return await workerCreator();
+		} finally {
+			this.activeWorkers--;
+			if (this.queue.length > 0) this.queue.shift()();
+		}
+	}
+	getWorkerOptions() {
+		const memoryMb = Math.floor(this.memoryLimit / (1024 * 1024));
+		return { resourceLimits: {
+			maxOldGenerationSizeMb: Math.max(256, memoryMb),
+			maxYoungGenerationSizeMb: Math.max(64, Math.floor(memoryMb / 4)),
+			codeRangeSizeMb: 64
+		} };
+	}
+};
+var workerPool = new WorkerPool();
+//#endregion
+//#region src/common/npm-builder.js
+/**
+* npm 构建工具
+* 用于处理小程序 npm 包的构建和管理
+*/
+var NpmBuilder = class {
+	constructor(workPath, targetPath, dependencyGraph = null) {
+		this.workPath = workPath;
+		this.targetPath = targetPath;
+		this.dependencyGraph = dependencyGraph;
+		this.builtPackages = /* @__PURE__ */ new Set();
+		this.packageDependencies = /* @__PURE__ */ new Map();
+	}
+	/**
+	* 构建 npm 包
+	* 扫描 miniprogram_npm 目录并构建相关包
+	*/
+	async buildNpmPackages() {
+		const miniprogramNpmPaths = this.findMiniprogramNpmDirs();
+		for (const npmPath of miniprogramNpmPaths) await this.buildNpmDir(npmPath);
+	}
+	/**
+	* 查找所有 miniprogram_npm 目录
+	* @returns {string[]} miniprogram_npm 目录路径数组
+	*/
+	findMiniprogramNpmDirs() {
+		const npmDirs = [];
+		const scanDir = (dir, relativePath = "") => {
+			if (!node_fs.default.existsSync(dir)) return;
+			const items = node_fs.default.readdirSync(dir, { withFileTypes: true });
+			for (const item of items) if (item.isDirectory()) {
+				const itemPath = node_path.default.join(dir, item.name);
+				const itemRelativePath = relativePath ? `${relativePath}/${item.name}` : item.name;
+				if (item.name === "miniprogram_npm") npmDirs.push(itemRelativePath);
+				else scanDir(itemPath, itemRelativePath);
+			}
+		};
+		scanDir(this.workPath);
+		return npmDirs;
+	}
+	/**
+	* 构建指定的 miniprogram_npm 目录
+	* @param {string} npmDirPath miniprogram_npm 目录路径
+	*/
+	async buildNpmDir(npmDirPath) {
+		const fullNpmPath = node_path.default.join(this.workPath, npmDirPath);
+		if (!node_fs.default.existsSync(fullNpmPath)) return;
+		const packages = node_fs.default.readdirSync(fullNpmPath, { withFileTypes: true }).filter((item) => item.isDirectory()).map((item) => item.name);
+		for (const packageName of packages) await this.buildPackage(packageName, npmDirPath);
+	}
+	/**
+	* 构建单个 npm 包
+	* @param {string} packageName 包名
+	* @param {string} npmDirPath miniprogram_npm 目录路径
+	*/
+	async buildPackage(packageName, npmDirPath) {
+		const packageKey = `${npmDirPath}/${packageName}`;
+		if (this.builtPackages.has(packageKey)) return;
+		const packagePath = node_path.default.join(this.workPath, npmDirPath, packageName);
+		const targetPackagePath = node_path.default.join(this.targetPath, npmDirPath, packageName);
+		if (!node_fs.default.existsSync(node_path.default.dirname(targetPackagePath))) node_fs.default.mkdirSync(node_path.default.dirname(targetPackagePath), { recursive: true });
+		await this.copyPackageFiles(packagePath, targetPackagePath);
+		await this.processDependencies(packageName, packagePath, npmDirPath);
+		this.builtPackages.add(packageKey);
+	}
+	/**
+	* 复制包文件
+	* @param {string} sourcePath 源路径
+	* @param {string} targetPath 目标路径
+	*/
+	async copyPackageFiles(sourcePath, targetPath) {
+		if (!node_fs.default.existsSync(sourcePath)) return;
+		if (!node_fs.default.existsSync(targetPath)) node_fs.default.mkdirSync(targetPath, { recursive: true });
+		const items = node_fs.default.readdirSync(sourcePath, { withFileTypes: true });
+		for (const item of items) {
+			const sourceItemPath = node_path.default.join(sourcePath, item.name);
+			const targetItemPath = node_path.default.join(targetPath, item.name);
+			if (item.isDirectory()) await this.copyPackageFiles(sourceItemPath, targetItemPath);
+			else if (this.isMiniprogramFile(item.name)) {
+				this.dependencyGraph?.addFile("app", sourceItemPath, "config");
+				node_fs.default.copyFileSync(sourceItemPath, targetItemPath);
+			}
+		}
+	}
+	/**
+	* 检查是否为小程序相关文件
+	* @param {string} filename 文件名
+	* @returns {boolean} 是否为小程序文件
+	*/
+	isMiniprogramFile(filename) {
+		const miniprogramExts = [
+			".js",
+			".json",
+			".ts",
+			...require_sourcemap.getTemplateExts(),
+			...require_sourcemap.getStyleExts(),
+			...require_sourcemap.getViewScriptExts()
+		];
+		const ext = node_path.default.extname(filename).toLowerCase();
+		return miniprogramExts.includes(ext) || filename === "package.json" || filename === "README.md" || filename.startsWith(".");
+	}
+	/**
+	* 处理包依赖
+	* @param {string} packageName 包名
+	* @param {string} packagePath 包路径
+	* @param {string} npmDirPath npm 目录路径
+	*/
+	async processDependencies(packageName, packagePath, npmDirPath) {
+		const packageJsonPath = node_path.default.join(packagePath, "package.json");
+		if (!node_fs.default.existsSync(packageJsonPath)) return;
+		try {
+			const packageJson = JSON.parse(node_fs.default.readFileSync(packageJsonPath, "utf-8"));
+			const dependencies = {
+				...packageJson.dependencies,
+				...packageJson.peerDependencies
+			};
+			if (dependencies && Object.keys(dependencies).length > 0) {
+				this.packageDependencies.set(packageName, dependencies);
+				for (const depName of Object.keys(dependencies)) await this.buildPackage(depName, npmDirPath);
+			}
+		} catch (e) {
+			console.warn(`[npm-builder] 解析 package.json 失败: ${packageJsonPath}`, e.message);
+		}
+	}
+	/**
+	* 验证 npm 包的完整性
+	* @param {string} packageName 包名
+	* @param {string} packagePath 包路径
+	* @returns {boolean} 是否有效
+	*/
+	validatePackage(packageName, packagePath) {
+		for (const file of ["package.json"]) if (!node_fs.default.existsSync(node_path.default.join(packagePath, file))) {
+			console.warn(`[npm-builder] 包 ${packageName} 缺少必要文件: ${file}`);
+			return false;
+		}
+		try {
+			const packageJsonPath = node_path.default.join(packagePath, "package.json");
+			const packageJson = JSON.parse(node_fs.default.readFileSync(packageJsonPath, "utf-8"));
+			if (!packageJson.name || !packageJson.version) {
+				console.warn(`[npm-builder] 包 ${packageName} 的 package.json 格式不正确`);
+				return false;
+			}
+		} catch (e) {
+			console.warn(`[npm-builder] 包 ${packageName} 的 package.json 解析失败:`, e.message);
+			return false;
+		}
+		return true;
+	}
+	/**
+	* 获取已构建的包列表
+	* @returns {string[]} 已构建的包列表
+	*/
+	getBuiltPackages() {
+		return Array.from(this.builtPackages);
+	}
+	/**
+	* 获取包依赖关系
+	* @returns {Map} 包依赖关系映射
+	*/
+	getPackageDependencies() {
+		return this.packageDependencies;
+	}
+	/**
+	* 清理构建缓存
+	*/
+	clearCache() {
+		this.builtPackages.clear();
+		this.packageDependencies.clear();
+	}
+};
+//#endregion
+//#region src/core/config-compiler.js
+/**
+* 处理 tabBar.list 中的 iconPath / selectedIconPath。
+* 视为相对小程序根目录的资源，复用 collectAssets 拷贝到 main/static/，
+* 并把 list 中的路径改写成产物 URL，避免容器侧再做特殊解析。
+*
+* 注意：会在原 app 配置上原地修改，不影响后续输出（compileConfig 是
+* 整个流水线最后才走到的环节，不会被再次读取）。
+*/
+function processTabBarIcons(app) {
+	const list = app?.tabBar?.list;
+	if (!Array.isArray(list) || list.length === 0) return;
+	const workPath = require_sourcemap.getWorkPath();
+	const targetPath = require_sourcemap.getTargetPath();
+	const appId = require_sourcemap.getAppId();
+	for (const item of list) {
+		if (item.iconPath) item.iconPath = require_sourcemap.collectAssets(workPath, "", item.iconPath, targetPath, appId);
+		if (item.selectedIconPath) item.selectedIconPath = require_sourcemap.collectAssets(workPath, "", item.selectedIconPath, targetPath, appId);
+	}
+}
+/**
+*
+* 编译项目配置文件 app-config.json
+*/
+function compileConfig() {
+	const app = require_sourcemap.getAppConfigInfo();
+	processTabBarIcons(app);
+	const compileResInfo = {
+		app,
+		modules: require_sourcemap.getPageConfigInfo(),
+		projectName: require_sourcemap.getAppName()
+	};
+	const apiNamespaces = require_sourcemap.getProjectConfig().apiNamespaces;
+	if (Array.isArray(apiNamespaces) && apiNamespaces.length > 0) compileResInfo.apiNamespaces = apiNamespaces;
+	const json = JSON.stringify(compileResInfo, null, 4);
+	const mainDir = `${require_sourcemap.getTargetPath()}/main`;
+	if (!node_fs.default.existsSync(mainDir)) node_fs.default.mkdirSync(mainDir, { recursive: true });
+	node_fs.default.writeFileSync(`${mainDir}/app-config.json`, json);
+}
+//#endregion
+//#region src/index.js
+var previousCompatibilityWarnings = /* @__PURE__ */ new Map();
+var COMPILE_STAGE_ORDER = [
+	"view",
+	"logic",
+	"style"
+];
+var BUILD_LABELS = {
+	en: {
+		initialize: "Prepare project build environment",
+		collectConfig: "Collect project configuration",
+		prepareOutput: "Prepare output directory",
+		compileConfig: "Compile project configuration",
+		buildNpm: "Build npm packages",
+		compile: "Compile project",
+		view: "Compile view files",
+		logic: "Compile logic files",
+		style: "Compile style files",
+		writeOutput: "Write build output"
+	},
+	"zh-CN": {
+		initialize: "初始化项目",
+		collectConfig: "收集配置信息",
+		prepareOutput: "准备产物目录",
+		compileConfig: "编译配置信息",
+		buildNpm: "构建 npm 包",
+		compile: "编译项目",
+		view: "编译视图",
+		logic: "编译逻辑",
+		style: "编译样式",
+		writeOutput: "写入编译产物"
+	}
+};
+function resolveBuildLabels(options = {}) {
+	return BUILD_LABELS[String(options.lang || node_process.default.env.NEUX_CLI_LANG || "en").toLowerCase().startsWith("zh") ? "zh-CN" : "en"];
+}
+function getStyleOnlyChangedPathPattern() {
+	return createExtensionPattern([
+		...require_sourcemap.getStyleExts(),
+		".acss",
+		".css"
+	]);
+}
+function getViewOnlyChangedPathPattern() {
+	return createExtensionPattern([...require_sourcemap.getTemplateExts(), ".axml"]);
+}
+/**
+* 构建命令入口
+* @param {string} targetPath 编译产物目标路径
+* @param {string} workPath 编译工作目录
+* @param {boolean} useAppIdDir 产物根目录是否包含 appId
+* @param {object} [options] 构建选项
+* @param {boolean} [options.sourcemap] 是否生成 sourcemap
+* @param {{ template?: string[], style?: string[], viewScript?: string[] }} [options.fileTypes]
+*   自定义文件类型，在内置 wx/dd 类型基础上追加；template 为模板扩展名，style 为样式扩展名，
+*   viewScript 为视图脚本扩展名和内联标签名
+* @param {string[]} [options.affectedEntries] 仅重编这些页面的视图和样式；逻辑仍按包重建
+* @param {string} [options.seedPath] 增量构建前用于保留未受影响产物的已发布目录
+* @param {object} [options.dependencyGraph] 上一次构建的依赖图快照
+* @param {Array<'view'|'logic'|'style'>} [options.stages] 仅运行指定编译阶段
+*/
+async function build(targetPath, workPath, useAppIdDir = true, options = {}) {
+	const { sourcemap = false, fileTypes, affectedEntries, seedPath, dependencyGraph, stages } = options;
+	const labels = resolveBuildLabels(options);
+	if (stages !== void 0 && (!Array.isArray(stages) || stages.some((stage) => !COMPILE_STAGE_ORDER.includes(stage)))) throw new TypeError(`Invalid compiler stages: ${JSON.stringify(stages)}`);
+	const enabledStages = new Set(stages === void 0 ? COMPILE_STAGE_ORDER : COMPILE_STAGE_ORDER.filter((stage) => stages.includes(stage)));
+	require_sourcemap.resetAssetCache();
+	const context = await new listr2.Listr([
+		{
+			title: labels.initialize,
+			task: (_, task) => task.newListr([
+				{
+					title: labels.collectConfig,
+					task: (ctx) => {
+						ctx.storeInfo = require_sourcemap.storeInfo(workPath, {
+							fileTypes,
+							dependencyGraph
+						});
+						ctx.dependencyGraph = new require_sourcemap.DependencyGraph(ctx.storeInfo.dependencyGraph);
+					}
+				},
+				{
+					title: labels.prepareOutput,
+					task: () => {
+						createDist(seedPath);
+					}
+				},
+				{
+					title: labels.compileConfig,
+					task: () => {
+						compileConfig();
+					}
+				},
+				{
+					title: labels.buildNpm,
+					task: async (ctx) => {
+						await new NpmBuilder(require_sourcemap.getWorkPath(), require_sourcemap.getTargetPath(), ctx.dependencyGraph).buildNpmPackages();
+					}
+				}
+			], { concurrent: false })
+		},
+		{
+			title: `${labels.compile} · ${node_path.default.basename(node_path.default.resolve(workPath))}`,
+			task: (ctx, task) => {
+				const allPages = require_sourcemap.getPages();
+				ctx.allPages = allPages;
+				ctx.pages = filterPagesByEntries(allPages, affectedEntries);
+				ctx.compatibilityWarnings = /* @__PURE__ */ new Set();
+				const compileTasks = [];
+				if (enabledStages.has("view")) compileTasks.push({
+					title: labels.view,
+					rendererOptions: {
+						outputBar: true,
+						persistentOutput: false
+					},
+					task: async (ctx, task) => {
+						return runCompileInWorker("view", ctx, task, { sourcemap });
+					}
+				});
+				if (enabledStages.has("logic")) compileTasks.push({
+					title: labels.logic,
+					rendererOptions: {
+						outputBar: true,
+						persistentOutput: false
+					},
+					task: async (ctx, task) => {
+						return runCompileInWorker("logic", ctx, task, {
+							sourcemap,
+							pages: ctx.allPages
+						});
+					}
+				});
+				if (enabledStages.has("style")) compileTasks.push({
+					title: labels.style,
+					rendererOptions: {
+						outputBar: true,
+						persistentOutput: false
+					},
+					task: async (ctx, task) => {
+						const stylePages = {
+							...ctx.pages,
+							mainPages: [{
+								path: "app",
+								id: require_sourcemap.getAppStyleScopeId()
+							}, ...ctx.pages.mainPages]
+						};
+						return runCompileInWorker("style", ctx, task, {
+							sourcemap,
+							pages: stylePages
+						});
+					}
+				});
+				if (compileTasks.length > 0) return task.newListr(compileTasks, { concurrent: true });
+			}
+		},
+		{
+			title: labels.writeOutput,
+			task: () => {
+				publishToDist(targetPath, useAppIdDir);
+			}
+		}
+	], {
+		concurrent: false,
+		rendererOptions: {
+			collapseSubtasks: true,
+			formatOutput: "truncate",
+			timer: listr2.PRESET_TIMER
+		},
+		fallbackRendererOptions: { timer: listr2.PRESET_TIMER }
+	}).run();
+	printCompatibilityWarnings(workPath, context.compatibilityWarnings);
+	return {
+		appId: require_sourcemap.getAppId(),
+		name: require_sourcemap.getAppName(),
+		path: require_sourcemap.getAppConfigInfo().entryPagePath || context.allPages.mainPages[0].path,
+		dependencyGraph: context.dependencyGraph.toJSON()
+	};
+}
+function filterPagesByEntries(pages, affectedEntries) {
+	if (!Array.isArray(affectedEntries)) return pages;
+	const selected = new Set(affectedEntries);
+	return {
+		mainPages: pages.mainPages.filter((page) => selected.has(page.path)),
+		subPages: Object.fromEntries(Object.entries(pages.subPages).map(([root, subPackage]) => [root, {
+			...subPackage,
+			info: subPackage.info.filter((page) => selected.has(page.path))
+		}]).filter(([, subPackage]) => subPackage.info.length > 0))
+	};
+}
+async function buildStyleOnly(targetPath, workPath, useAppIdDir = true, options = {}) {
+	require_sourcemap.storeInfo(workPath, { fileTypes: options.fileTypes });
+	const pages = require_sourcemap.getPages();
+	const affectedPages = getAffectedPages(pages, options.changedPath, getStyleOnlyChangedPathPattern());
+	const progress = { completedTasks: 0 };
+	await require_core_style_compiler.compileSS(affectedPages.mainPages, null, progress);
+	for (const [root, subPages] of Object.entries(affectedPages.subPages)) await require_core_style_compiler.compileSS(subPages.info, root, progress);
+	publishCssToDist(targetPath, useAppIdDir);
+	return {
+		appId: require_sourcemap.getAppId(),
+		name: require_sourcemap.getAppName(),
+		path: require_sourcemap.getAppConfigInfo().entryPagePath || pages.mainPages[0]?.path,
+		styleOnly: true,
+		compiledTasks: progress.completedTasks
+	};
+}
+async function buildViewOnly(targetPath, workPath, useAppIdDir = true, options = {}) {
+	require_core_view_compiler.resetViewCompilerCache();
+	require_sourcemap.storeInfo(workPath, { fileTypes: options.fileTypes });
+	const pages = require_sourcemap.getPages();
+	const affectedPages = getAffectedPages(pages, options.changedPath, getViewOnlyChangedPathPattern());
+	const progress = { completedTasks: 0 };
+	await require_core_view_compiler.compileML(affectedPages.mainPages, null, progress);
+	for (const [root, subPages] of Object.entries(affectedPages.subPages)) await require_core_view_compiler.compileML(subPages.info, root, progress);
+	publishFilesToDist(targetPath, useAppIdDir, ".js");
+	return {
+		appId: require_sourcemap.getAppId(),
+		name: require_sourcemap.getAppName(),
+		path: require_sourcemap.getAppConfigInfo().entryPagePath || pages.mainPages[0].path,
+		viewOnly: true,
+		compiledTasks: progress.completedTasks,
+		updatedPages: collectUpdatedPages(affectedPages)
+	};
+}
+async function buildLogicOnly(targetPath, workPath, useAppIdDir = true, options = {}) {
+	const currentStoreInfo = require_sourcemap.storeInfo(workPath, { fileTypes: options.fileTypes });
+	const pages = require_sourcemap.getPages();
+	await runCompileInWorker("logic", {
+		pages,
+		storeInfo: currentStoreInfo
+	}, {}, { sourcemap: options.sourcemap });
+	publishFilesToDist(targetPath, useAppIdDir, ".js");
+	return {
+		appId: require_sourcemap.getAppId(),
+		name: require_sourcemap.getAppName(),
+		path: require_sourcemap.getAppConfigInfo().entryPagePath || pages.mainPages[0].path,
+		logicOnly: true,
+		compiledTasks: pages.mainPages.length + Object.values(pages.subPages).reduce((sum, item) => sum + item.info.length, 0),
+		updatedPages: collectUpdatedPages(pages)
+	};
+}
+function collectUpdatedPages(pages) {
+	return [...pages.mainPages.map((page) => ({
+		pagePath: page.path,
+		root: "main"
+	})), ...Object.entries(pages.subPages).flatMap(([root, subPackage]) => subPackage.info.map((page) => ({
+		pagePath: page.path,
+		root
+	})))];
+}
+function getAffectedPages(pages, changedPath, extensionPattern) {
+	const appStylePage = {
+		path: "app",
+		id: ""
+	};
+	if (!changedPath) return {
+		mainPages: extensionPattern.test("app.wxss") ? [appStylePage, ...pages.mainPages] : pages.mainPages,
+		subPages: pages.subPages
+	};
+	const modulePath = normalizeChangedModulePath(changedPath, extensionPattern);
+	if (!modulePath) return {
+		mainPages: extensionPattern.test("app.wxss") ? [appStylePage, ...pages.mainPages] : pages.mainPages,
+		subPages: pages.subPages
+	};
+	if (modulePath === "app") return {
+		mainPages: [appStylePage],
+		subPages: {}
+	};
+	const mainPages = pages.mainPages.filter((page) => isStyleModuleAffected(page, modulePath));
+	const subPages = {};
+	for (const [root, subPackage] of Object.entries(pages.subPages)) {
+		const info = subPackage.info.filter((page) => isStyleModuleAffected(page, modulePath));
+		if (info.length) subPages[root] = {
+			...subPackage,
+			info
+		};
+	}
+	if (!mainPages.length && !Object.keys(subPages).length) return {
+		mainPages: extensionPattern.test("app.wxss") ? [appStylePage, ...pages.mainPages] : pages.mainPages,
+		subPages: pages.subPages
+	};
+	return {
+		mainPages,
+		subPages
+	};
+}
+function normalizeChangedModulePath(changedPath, extensionPattern) {
+	const relativePath = node_path.default.relative(require_sourcemap.getWorkPath(), changedPath);
+	if (!relativePath || relativePath.startsWith("..") || node_path.default.isAbsolute(relativePath)) return null;
+	return relativePath.replace(/\\/g, "/").replace(extensionPattern, "");
+}
+function isStyleModuleAffected(page, modulePath, visited = /* @__PURE__ */ new Set()) {
+	if (isSameStyleModulePath(page.path, modulePath)) return true;
+	if (!page.usingComponents || visited.has(page.path)) return false;
+	visited.add(page.path);
+	for (const componentPath of Object.values(page.usingComponents)) {
+		if (isSameStyleModulePath(componentPath, modulePath)) return true;
+		const component = require_sourcemap.getComponent(componentPath);
+		if (component && isStyleModuleAffected(component, modulePath, visited)) return true;
+	}
+	return false;
+}
+function isSameStyleModulePath(left, right) {
+	return String(left || "").replace(/^\/+/, "") === String(right || "").replace(/^\/+/, "");
+}
+function createExtensionPattern(extensions) {
+	const normalizedExts = [...new Set(extensions)].map((ext) => String(ext).trim().toLowerCase()).filter(Boolean).map((ext) => ext.startsWith(".") ? ext.slice(1) : ext).map((ext) => ext.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+	return new RegExp(`\\.(?:${normalizedExts.join("|")})$`, "i");
+}
+function publishCssToDist(dist, useAppIdDir = true) {
+	publishFilesToDist(dist, useAppIdDir, ".css");
+}
+function publishFilesToDist(dist, useAppIdDir = true, extension) {
+	const sourceRoot = require_sourcemap.getTargetPath();
+	const targetRoot = useAppIdDir ? node_path.default.join(node_path.default.resolve(node_process.default.cwd(), dist), require_sourcemap.getAppId()) : node_path.default.resolve(node_process.default.cwd(), dist);
+	function copyFiles(src, dest) {
+		if (!node_fs.default.existsSync(src)) return;
+		node_fs.default.mkdirSync(dest, { recursive: true });
+		for (const entry of node_fs.default.readdirSync(src, { withFileTypes: true })) {
+			const srcPath = node_path.default.join(src, entry.name);
+			const destPath = node_path.default.join(dest, entry.name);
+			if (entry.isDirectory()) copyFiles(srcPath, destPath);
+			else if (entry.isFile() && entry.name.endsWith(extension)) node_fs.default.copyFileSync(srcPath, destPath);
+		}
+	}
+	copyFiles(sourceRoot, targetRoot);
+}
+function runCompileInWorker(script, ctx, task, options = {}) {
+	return workerPool.runWorker(() => new Promise((resolve, reject) => {
+		const worker = new node_worker_threads.Worker(node_path.default.join(node_path.default.dirname((0, node_url.fileURLToPath)(require("url").pathToFileURL(__filename).href)), `core/${script}-compiler.js`), workerPool.getWorkerOptions());
+		const pages = options.pages || ctx.pages;
+		const totalTasks = Object.keys(pages.mainPages).length + Object.values(pages.subPages).reduce((sum, item) => sum + item.info.length, 0);
+		let isResolved = false;
+		let workerError = null;
+		const handleError = (error) => {
+			if (isResolved) return;
+			isResolved = true;
+			worker.terminate();
+			reject(error);
+		};
+		worker.postMessage({
+			pages,
+			storeInfo: ctx.storeInfo,
+			sourcemap: !!options.sourcemap
+		});
+		worker.on("message", (message) => {
+			try {
+				for (const warning of message.compatibilityWarnings || []) ctx.compatibilityWarnings.add(warning);
+				if (node_process.default.stdout.isTTY && message.completedTasks !== void 0) task.output = formatCompileProgress(message.completedTasks, totalTasks);
+				if (message.success) {
+					if (isResolved) return;
+					isResolved = true;
+					if (node_process.default.stdout.isTTY && totalTasks > 0) task.output = formatCompileProgress(totalTasks, totalTasks);
+					ctx.dependencyGraph.merge(message.dependencyGraph);
+					worker.terminate();
+					resolve();
+				} else if (message.error) {
+					const error = new Error(message.error.message || message.error);
+					if (message.error.name) error.name = message.error.name;
+					if (message.error.stack) error.stack = message.error.stack;
+					if (message.error.file) error.file = message.error.file;
+					if (message.error.line != null) error.line = message.error.line;
+					if (message.error.column != null) error.column = message.error.column;
+					if (message.error.stage) error.stage = message.error.stage;
+					handleError(error);
+				}
+			} catch (err) {
+				handleError(/* @__PURE__ */ new Error(`Error processing worker message: ${err.message}\n${err.stack}`));
+			}
+		});
+		worker.on("error", (err) => {
+			workerError = err;
+			handleError(err);
+		});
+		worker.on("exit", (code) => {
+			if (code !== 0 && !isResolved) {
+				const error = workerError || /* @__PURE__ */ new Error(code === 1 ? "Worker terminated due to reaching memory limit: JS heap out of memory" : `Worker stopped with exit code ${code}`);
+				handleError(error);
+			}
+		});
+	}));
+}
+function printCompatibilityWarnings(workPath, warnings = /* @__PURE__ */ new Set()) {
+	const projectPath = node_path.default.resolve(workPath);
+	const hasPreviousResult = previousCompatibilityWarnings.has(projectPath);
+	const previousWarnings = previousCompatibilityWarnings.get(projectPath) || /* @__PURE__ */ new Set();
+	const currentWarnings = new Set(warnings);
+	const newWarnings = [...currentWarnings].filter((warning) => !previousWarnings.has(warning));
+	previousCompatibilityWarnings.set(projectPath, currentWarnings);
+	if (newWarnings.length === 0) return;
+	const qualifier = hasPreviousResult ? " new" : "";
+	const suffix = newWarnings.length === 1 ? "" : "s";
+	console.warn(`\n[compat] ${newWarnings.length}${qualifier} compatibility warning${suffix}`);
+	for (const warning of newWarnings) console.warn(`  - ${warning.replace(/^\[compat\]\s*/, "")}`);
+}
+//#endregion
+exports.buildLogicOnly = buildLogicOnly;
+exports.buildStyleOnly = buildStyleOnly;
+exports.buildViewOnly = buildViewOnly;
+exports.default = build;