@dimina/compiler 1.0.13 → 1.0.14

package/dist/{env-COaZNCzL.js → env-DgCLbrQb.js}

@@ -2,6 +2,33 @@ import path from "node:path";
 import process from "node:process";
 import fs from "node:fs";
 import os from "node:os";
+//#region src/common/path-utils.js
+var WINDOWS_FS_PATH_RE = /^(?:[a-zA-Z]:[\\/]|\\\\)/;
+function isWindowsFsPath(targetPath) {
+	return typeof targetPath === "string" && (WINDOWS_FS_PATH_RE.test(targetPath) || targetPath.includes("\\"));
+}
+function getFsPathApi(targetPath) {
+	return isWindowsFsPath(targetPath) ? path.win32 : path.posix;
+}
+function normalizeToPosixPath(targetPath) {
+	return targetPath.replace(/\\/g, "/");
+}
+function resolveMiniProgramPath(workPath, importerPath, sourcePath) {
+	const pathApi = getFsPathApi(importerPath || workPath);
+	return sourcePath.startsWith("/") ? pathApi.join(workPath, sourcePath) : pathApi.resolve(pathApi.dirname(importerPath), sourcePath);
+}
+function toMiniProgramModuleId(resolvedPath, workPath) {
+	const normalizedResolvedPath = normalizeToPosixPath(resolvedPath);
+	const normalizedWorkPath = normalizeToPosixPath(workPath);
+	let moduleId = normalizedResolvedPath.startsWith(normalizedWorkPath) ? normalizedResolvedPath.slice(normalizedWorkPath.length) : normalizedResolvedPath;
+	moduleId = moduleId.replace(/\/+/g, "/");
+	if (!moduleId.startsWith("/")) moduleId = `/${moduleId}`;
+	return moduleId;
+}
+function getRelativePosixPath(targetPath, rootPath) {
+	return normalizeToPosixPath(targetPath).replace(normalizeToPosixPath(rootPath), "").replace(/^\//, "");
+}
+//#endregion
 //#region src/common/art.js
 var artCode = `
 ██████╗ ██╗███╗   ███╗██╗███╗   ██╗ █████╗
@@ -150,9 +177,7 @@ var NpmResolver = class {
 	* @returns {string} 解析后的路径
 	*/
 	resolveRelativePath(componentPath, pageFilePath) {
-		const lastIndex = pageFilePath.lastIndexOf("/");
-		const newPath = pageFilePath.slice(0, lastIndex);
-		return path.resolve(newPath, componentPath).replace(this.workPath, "");
+		return toMiniProgramModuleId(resolveMiniProgramPath(this.workPath, pageFilePath, componentPath), this.workPath);
 	}
 	/**
 	* 解析 npm 组件
@@ -190,7 +215,7 @@ var NpmResolver = class {
 	* @returns {string[]} 搜索路径数组
 	*/
 	generateSearchPaths(pageFilePath) {
-		const pathParts = pageFilePath.replace(this.workPath, "").replace(/^\//, "").split("/").slice(0, -1);
+		const pathParts = getRelativePosixPath(pageFilePath, this.workPath).split("/").slice(0, -1);
 		const searchPaths = [];
 		for (let i = pathParts.length; i >= 0; i--) {
 			const currentPath = pathParts.slice(0, i).join("/");
@@ -444,10 +469,8 @@ function getModuleId(src, pageFilePath) {
 	const resolvedAlias = resolveAppAlias(src);
 	if (resolvedAlias) return resolvedAlias;
 	if (!npmResolver) {
-		const lastIndex = pageFilePath.lastIndexOf("/");
-		const newPath = pageFilePath.slice(0, lastIndex);
 		const workPath = getWorkPath();
-		return path.resolve(newPath, src).replace(workPath, "");
+		return toMiniProgramModuleId(resolveMiniProgramPath(workPath, pageFilePath, src), workPath);
 	}
 	return npmResolver.resolveComponentPath(src, pageFilePath);
 }

package/dist/{env-lm96AacS.cjs → env-M-7lpbHL.cjs}

@@ -5,7 +5,6 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __copyProps = (to, from, except, desc) => {
 	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
 		key = keys[i];
@@ -22,13 +21,40 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 //#endregion
 let node_path = require("node:path");
-node_path = __toESM(node_path);
+node_path = __toESM(node_path, 1);
 let node_process = require("node:process");
-node_process = __toESM(node_process);
+node_process = __toESM(node_process, 1);
 let node_fs = require("node:fs");
-node_fs = __toESM(node_fs);
+node_fs = __toESM(node_fs, 1);
 let node_os = require("node:os");
-node_os = __toESM(node_os);
+node_os = __toESM(node_os, 1);
+//#region src/common/path-utils.js
+var WINDOWS_FS_PATH_RE = /^(?:[a-zA-Z]:[\\/]|\\\\)/;
+function isWindowsFsPath(targetPath) {
+	return typeof targetPath === "string" && (WINDOWS_FS_PATH_RE.test(targetPath) || targetPath.includes("\\"));
+}
+function getFsPathApi(targetPath) {
+	return isWindowsFsPath(targetPath) ? node_path.default.win32 : node_path.default.posix;
+}
+function normalizeToPosixPath(targetPath) {
+	return targetPath.replace(/\\/g, "/");
+}
+function resolveMiniProgramPath(workPath, importerPath, sourcePath) {
+	const pathApi = getFsPathApi(importerPath || workPath);
+	return sourcePath.startsWith("/") ? pathApi.join(workPath, sourcePath) : pathApi.resolve(pathApi.dirname(importerPath), sourcePath);
+}
+function toMiniProgramModuleId(resolvedPath, workPath) {
+	const normalizedResolvedPath = normalizeToPosixPath(resolvedPath);
+	const normalizedWorkPath = normalizeToPosixPath(workPath);
+	let moduleId = normalizedResolvedPath.startsWith(normalizedWorkPath) ? normalizedResolvedPath.slice(normalizedWorkPath.length) : normalizedResolvedPath;
+	moduleId = moduleId.replace(/\/+/g, "/");
+	if (!moduleId.startsWith("/")) moduleId = `/${moduleId}`;
+	return moduleId;
+}
+function getRelativePosixPath(targetPath, rootPath) {
+	return normalizeToPosixPath(targetPath).replace(normalizeToPosixPath(rootPath), "").replace(/^\//, "");
+}
+//#endregion
 //#region src/common/art.js
 var artCode = `
 ██████╗ ██╗███╗   ███╗██╗███╗   ██╗ █████╗
@@ -177,9 +203,7 @@ var NpmResolver = class {
 	* @returns {string} 解析后的路径
 	*/
 	resolveRelativePath(componentPath, pageFilePath) {
-		const lastIndex = pageFilePath.lastIndexOf("/");
-		const newPath = pageFilePath.slice(0, lastIndex);
-		return node_path.default.resolve(newPath, componentPath).replace(this.workPath, "");
+		return toMiniProgramModuleId(resolveMiniProgramPath(this.workPath, pageFilePath, componentPath), this.workPath);
 	}
 	/**
 	* 解析 npm 组件
@@ -217,7 +241,7 @@ var NpmResolver = class {
 	* @returns {string[]} 搜索路径数组
 	*/
 	generateSearchPaths(pageFilePath) {
-		const pathParts = pageFilePath.replace(this.workPath, "").replace(/^\//, "").split("/").slice(0, -1);
+		const pathParts = getRelativePosixPath(pageFilePath, this.workPath).split("/").slice(0, -1);
 		const searchPaths = [];
 		for (let i = pathParts.length; i >= 0; i--) {
 			const currentPath = pathParts.slice(0, i).join("/");
@@ -471,10 +495,8 @@ function getModuleId(src, pageFilePath) {
 	const resolvedAlias = resolveAppAlias(src);
 	if (resolvedAlias) return resolvedAlias;
 	if (!npmResolver) {
-		const lastIndex = pageFilePath.lastIndexOf("/");
-		const newPath = pageFilePath.slice(0, lastIndex);
 		const workPath = getWorkPath();
-		return node_path.default.resolve(newPath, src).replace(workPath, "");
+		return toMiniProgramModuleId(resolveMiniProgramPath(workPath, pageFilePath, src), workPath);
 	}
 	return npmResolver.resolveComponentPath(src, pageFilePath);
 }
@@ -561,12 +583,6 @@ function getPages() {
 	};
 }
 //#endregion
-Object.defineProperty(exports, "__commonJSMin", {
-	enumerable: true,
-	get: function() {
-		return __commonJSMin;
-	}
-});
 Object.defineProperty(exports, "__toESM", {
 	enumerable: true,
 	get: function() {

package/dist/index.cjs

@@ -1,2 +1,458 @@
-const require_src = require("./src-DycLk1BL.cjs");
-module.exports = require_src.build;
+const require_env = require("./env-M-7lpbHL.cjs");
+let node_path = require("node:path");
+node_path = require_env.__toESM(node_path, 1);
+let node_url = require("node:url");
+let node_worker_threads = require("node:worker_threads");
+let listr2 = require("listr2");
+let node_process = require("node:process");
+node_process = require_env.__toESM(node_process, 1);
+let node_fs = require("node:fs");
+node_fs = require_env.__toESM(node_fs, 1);
+let node_os = require("node:os");
+node_os = require_env.__toESM(node_os, 1);
+//#region src/common/publish.js
+function createDist() {
+	const distPath = require_env.getTargetPath();
+	if (node_fs.default.existsSync(distPath)) node_fs.default.rmSync(distPath, {
+		recursive: true,
+		force: true
+	});
+	node_fs.default.mkdirSync(distPath, { recursive: true });
+}
+/**
+* 发布到指定目录
+* @param {string} dist 目标路径
+* @param {boolean} useAppIdDir 是否在路径中包含appId
+*/
+function publishToDist(dist, useAppIdDir = true) {
+	const distPath = require_env.getTargetPath();
+	const appId = require_env.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) {
+		this.workPath = workPath;
+		this.targetPath = targetPath;
+		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)) node_fs.default.copyFileSync(sourceItemPath, targetItemPath);
+		}
+	}
+	/**
+	* 检查是否为小程序相关文件
+	* @param {string} filename 文件名
+	* @returns {boolean} 是否为小程序文件
+	*/
+	isMiniprogramFile(filename) {
+		const miniprogramExts = [
+			".js",
+			".json",
+			".wxml",
+			".wxss",
+			".wxs",
+			".ts",
+			".less",
+			".scss",
+			".styl"
+		];
+		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_env.getWorkPath();
+	const targetPath = require_env.getTargetPath();
+	const appId = require_env.getAppId();
+	for (const item of list) {
+		if (item.iconPath) item.iconPath = require_env.collectAssets(workPath, "", item.iconPath, targetPath, appId);
+		if (item.selectedIconPath) item.selectedIconPath = require_env.collectAssets(workPath, "", item.selectedIconPath, targetPath, appId);
+	}
+}
+/**
+*
+* 编译项目配置文件 app-config.json
+*/
+function compileConfig() {
+	const app = require_env.getAppConfigInfo();
+	processTabBarIcons(app);
+	const compileResInfo = {
+		app,
+		modules: require_env.getPageConfigInfo(),
+		projectName: require_env.getAppName()
+	};
+	const json = JSON.stringify(compileResInfo, null, 4);
+	const mainDir = `${require_env.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 isPrinted = false;
+/**
+* 构建命令入口
+* @param {string} targetPath 编译产物目标路径
+* @param {string} workPath 编译工作目录
+* @param {boolean} useAppIdDir 产物根目录是否包含appId
+*/
+async function build(targetPath, workPath, useAppIdDir = true, options = {}) {
+	const { sourcemap = false } = options;
+	if (!isPrinted) {
+		require_env.art_default();
+		isPrinted = true;
+	}
+	const tasks = new listr2.Listr([
+		{
+			title: "准备项目编译环境",
+			task: (_, task) => task.newListr([
+				{
+					title: "收集配置信息",
+					task: (ctx) => {
+						ctx.storeInfo = require_env.storeInfo(workPath);
+					}
+				},
+				{
+					title: "准备产物目录",
+					task: () => {
+						createDist();
+					}
+				},
+				{
+					title: "编译配置信息",
+					task: () => {
+						compileConfig();
+					}
+				},
+				{
+					title: "构建 npm 包",
+					task: async () => {
+						await new NpmBuilder(require_env.getWorkPath(), require_env.getTargetPath()).buildNpmPackages();
+					}
+				}
+			], { concurrent: false })
+		},
+		{
+			title: `开始编译:${workPath.split("/").pop()}`,
+			task: (ctx, task) => {
+				const pages = require_env.getPages();
+				ctx.pages = pages;
+				return task.newListr([
+					{
+						title: "编译页面文件",
+						task: async (ctx, task) => {
+							return runCompileInWorker("view", ctx, task, { sourcemap });
+						}
+					},
+					{
+						title: "编译页面逻辑",
+						task: async (ctx, task) => {
+							return runCompileInWorker("logic", ctx, task, { sourcemap });
+						}
+					},
+					{
+						title: "编译样式文件",
+						task: async (ctx, task) => {
+							pages.mainPages.unshift({
+								path: "app",
+								id: ""
+							});
+							return runCompileInWorker("style", ctx, task, { sourcemap });
+						}
+					}
+				], { concurrent: true });
+			}
+		},
+		{
+			title: "输出编译产物",
+			task: () => {
+				publishToDist(targetPath, useAppIdDir);
+			}
+		}
+	], { concurrent: false });
+	try {
+		const context = await tasks.run();
+		return {
+			appId: require_env.getAppId(),
+			name: require_env.getAppName(),
+			path: require_env.getAppConfigInfo().entryPagePath || context.pages.mainPages[1].path
+		};
+	} catch (e) {
+		console.error(`${workPath} 编译出错: ${e.message}\n${e.stack}`);
+	}
+}
+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 totalTasks = Object.keys(ctx.pages.mainPages).length + Object.values(ctx.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: ctx.pages,
+			storeInfo: ctx.storeInfo,
+			sourcemap: !!options.sourcemap
+		});
+		worker.on("message", (message) => {
+			try {
+				if (message.completedTasks) {
+					const progress = message.completedTasks / totalTasks;
+					const percentage = progress * 100;
+					const barLength = 30;
+					const filledLength = Math.ceil(barLength * progress);
+					task.output = `[${"█".repeat(filledLength) + "░".repeat(barLength - filledLength)}] ${percentage.toFixed(2)}%`;
+				}
+				if (message.success) {
+					if (isResolved) return;
+					isResolved = true;
+					worker.terminate();
+					resolve();
+				} else if (message.error) {
+					const error = new Error(message.error.message || message.error);
+					if (message.error.stack) error.stack = message.error.stack;
+					if (message.error.file) error.file = message.error.file;
+					if (message.error.line) error.line = message.error.line;
+					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) handleError(workerError || /* @__PURE__ */ new Error(code === 1 ? "Worker terminated due to reaching memory limit: JS heap out of memory" : `Worker stopped with exit code ${code}`));
+		});
+	}));
+}
+//#endregion
+module.exports = build;