@dimina/compiler 1.0.12 → 1.0.14-beta.0

package/dist/index.cjs

@@ -1,476 +1,435 @@
-"use strict";
-const path = require("node:path");
-const node_url = require("node:url");
-const node_worker_threads = require("node:worker_threads");
-const listr2 = require("listr2");
-const process = require("node:process");
-const fs = require("node:fs");
-const env = require("./env-Cmen1qwy.cjs");
-const os = require("node:os");
-var _documentCurrentScript = typeof document !== "undefined" ? document.currentScript : null;
-const artCode$1 = `
-██████╗ ██╗███╗   ███╗██╗███╗   ██╗ █████╗
-██╔══██╗██║████╗ ████║██║████╗  ██║██╔══██╗
-██║  ██║██║██╔████╔██║██║██╔██╗ ██║███████║
-██║  ██║██║██║╚██╔╝██║██║██║╚██╗██║██╔══██║
-██████╔╝██║██║ ╚═╝ ██║██║██║ ╚████║██║  ██║
-╚═════╝ ╚═╝╚═╝     ╚═╝╚═╝╚═╝  ╚═══╝╚═╝  ╚═╝
-`;
-function artCode() {
-  console.log(artCode$1);
-}
+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 = env.getTargetPath();
-  if (fs.existsSync(distPath)) {
-    fs.rmSync(distPath, { recursive: true, force: true });
-  }
-  fs.mkdirSync(distPath, { recursive: true });
+	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 = env.getTargetPath();
-  const appId = env.getAppId();
-  const absolutePath = useAppIdDir ? `${path.resolve(process.cwd(), dist)}${path.sep}${appId}` : `${path.resolve(process.cwd(), dist)}`;
-  if (fs.existsSync(absolutePath)) {
-    fs.rmSync(absolutePath, { recursive: true, force: true });
-  }
-  fs.mkdirSync(absolutePath, { recursive: true });
-  function copyDir(src, dest) {
-    fs.mkdirSync(dest, { recursive: true });
-    const entries = fs.readdirSync(src, { withFileTypes: true });
-    for (const entry of entries) {
-      const srcPath = path.join(src, entry.name);
-      const destPath = path.join(dest, entry.name);
-      if (entry.isDirectory()) {
-        copyDir(srcPath, destPath);
-      } else {
-        fs.copyFileSync(srcPath, destPath);
-      }
-    }
-  }
-  copyDir(distPath, absolutePath);
+	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 (fs.existsSync(quotaPath) && fs.existsSync(periodPath)) {
-      const quota = Number.parseInt(fs.readFileSync(quotaPath, "utf8"));
-      const period = Number.parseInt(fs.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 os.cpus().length;
+	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 (fs.existsSync(memLimitPath)) {
-      const memLimit = Number.parseInt(fs.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 os.totalmem();
-}
-const MAX_WORKERS = Math.max(1, Math.min(4, Math.floor(getCGroupCPUCount() / 4)));
-class WorkerPool {
-  constructor(maxWorkers = MAX_WORKERS) {
-    this.maxWorkers = maxWorkers;
-    this.activeWorkers = 0;
-    this.queue = [];
-    this.memoryLimit = Math.floor(getCGroupMemoryLimit() * 0.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) {
-        const next = this.queue.shift();
-        next();
-      }
-    }
-  }
-  getWorkerOptions() {
-    const memoryMb = Math.floor(this.memoryLimit / (1024 * 1024));
-    return {
-      resourceLimits: {
-        maxOldGenerationSizeMb: Math.max(256, memoryMb),
-        // 最少 256MB
-        maxYoungGenerationSizeMb: Math.max(64, Math.floor(memoryMb / 4)),
-        // 最少 64MB
-        codeRangeSizeMb: 64
-        // 减少代码范围大小从 128MB 到 64MB
-      }
-    };
-  }
-}
-const workerPool = new WorkerPool();
-class NpmBuilder {
-  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 (!fs.existsSync(dir)) {
-        return;
-      }
-      const items = fs.readdirSync(dir, { withFileTypes: true });
-      for (const item of items) {
-        if (item.isDirectory()) {
-          const itemPath = path.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 = path.join(this.workPath, npmDirPath);
-    if (!fs.existsSync(fullNpmPath)) {
-      return;
-    }
-    const packages = fs.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 = path.join(this.workPath, npmDirPath, packageName);
-    const targetPackagePath = path.join(this.targetPath, npmDirPath, packageName);
-    if (!fs.existsSync(path.dirname(targetPackagePath))) {
-      fs.mkdirSync(path.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 (!fs.existsSync(sourcePath)) {
-      return;
-    }
-    if (!fs.existsSync(targetPath)) {
-      fs.mkdirSync(targetPath, { recursive: true });
-    }
-    const items = fs.readdirSync(sourcePath, { withFileTypes: true });
-    for (const item of items) {
-      const sourceItemPath = path.join(sourcePath, item.name);
-      const targetItemPath = path.join(targetPath, item.name);
-      if (item.isDirectory()) {
-        await this.copyPackageFiles(sourceItemPath, targetItemPath);
-      } else {
-        if (this.isMiniprogramFile(item.name)) {
-          fs.copyFileSync(sourceItemPath, targetItemPath);
-        }
-      }
-    }
-  }
-  /**
-   * 检查是否为小程序相关文件
-   * @param {string} filename 文件名
-   * @returns {boolean} 是否为小程序文件
-   */
-  isMiniprogramFile(filename) {
-    const miniprogramExts = [".js", ".json", ".wxml", ".wxss", ".wxs", ".ts", ".less", ".scss", ".styl"];
-    const ext = path.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 = path.join(packagePath, "package.json");
-    if (!fs.existsSync(packageJsonPath)) {
-      return;
-    }
-    try {
-      const packageJson = JSON.parse(fs.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) {
-    const requiredFiles = ["package.json"];
-    for (const file of requiredFiles) {
-      if (!fs.existsSync(path.join(packagePath, file))) {
-        console.warn(`[npm-builder] 包 ${packageName} 缺少必要文件: ${file}`);
-        return false;
-      }
-    }
-    try {
-      const packageJsonPath = path.join(packagePath, "package.json");
-      const packageJson = JSON.parse(fs.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();
-  }
+	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
+/**
+*
+* 编译项目配置文件 app-config.json
+*/
 function compileConfig() {
-  const compileResInfo = {
-    app: env.getAppConfigInfo(),
-    modules: env.getPageConfigInfo(),
-    projectName: env.getAppName()
-  };
-  const json = JSON.stringify(compileResInfo, null, 4);
-  const mainDir = `${env.getTargetPath()}/main`;
-  if (!fs.existsSync(mainDir)) {
-    fs.mkdirSync(mainDir, { recursive: true });
-  }
-  fs.writeFileSync(`${mainDir}/app-config.json`, json);
+	const compileResInfo = {
+		app: require_env.getAppConfigInfo(),
+		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);
 }
-let isPrinted = false;
+//#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) {
-  if (!isPrinted) {
-    artCode();
-    isPrinted = true;
-  }
-  const tasks = new listr2.Listr(
-    [
-      {
-        title: "准备项目编译环境",
-        task: (_, task) => task.newListr(
-          [
-            {
-              title: "收集配置信息",
-              task: (ctx) => {
-                ctx.storeInfo = env.storeInfo(workPath);
-              }
-            },
-            {
-              title: "准备产物目录",
-              task: () => {
-                createDist();
-              }
-            },
-            {
-              title: "编译配置信息",
-              task: () => {
-                compileConfig();
-              }
-            },
-            {
-              title: "构建 npm 包",
-              task: async () => {
-                const npmBuilder = new NpmBuilder(env.getWorkPath(), env.getTargetPath());
-                await npmBuilder.buildNpmPackages();
-              }
-            }
-          ],
-          { concurrent: false }
-        )
-      },
-      {
-        title: `开始编译:${workPath.split("/").pop()}`,
-        task: (ctx, task) => {
-          const pages = env.getPages();
-          ctx.pages = pages;
-          return task.newListr(
-            [
-              {
-                title: "编译页面文件",
-                task: async (ctx2, task2) => {
-                  return runCompileInWorker("view", ctx2, task2);
-                }
-              },
-              {
-                title: "编译页面逻辑",
-                task: async (ctx2, task2) => {
-                  return runCompileInWorker("logic", ctx2, task2);
-                }
-              },
-              {
-                title: "编译样式文件",
-                task: async (ctx2, task2) => {
-                  pages.mainPages.unshift({
-                    path: "app",
-                    id: ""
-                  });
-                  return runCompileInWorker("style", ctx2, task2);
-                }
-              }
-            ],
-            { concurrent: true }
-          );
-        }
-      },
-      {
-        title: "输出编译产物",
-        task: () => {
-          publishToDist(targetPath, useAppIdDir);
-        }
-      }
-    ],
-    { concurrent: false }
-  );
-  try {
-    const context = await tasks.run();
-    return {
-      appId: env.getAppId(),
-      name: env.getAppName(),
-      path: env.getAppConfigInfo().entryPagePath || context.pages.mainPages[1].path
-    };
-  } catch (e) {
-    console.error(`${workPath} 编译出错: ${e.message}
-${e.stack}`);
-  }
+	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);
+						}
+					},
+					{
+						title: "编译页面逻辑",
+						task: async (ctx, task) => {
+							return runCompileInWorker("logic", ctx, task);
+						}
+					},
+					{
+						title: "编译样式文件",
+						task: async (ctx, task) => {
+							pages.mainPages.unshift({
+								path: "app",
+								id: ""
+							});
+							return runCompileInWorker("style", ctx, task);
+						}
+					}
+				], { 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) {
-  return workerPool.runWorker(() => new Promise((resolve, reject) => {
-    const worker = new node_worker_threads.Worker(
-      path.join(path.dirname(node_url.fileURLToPath(typeof document === "undefined" ? require("url").pathToFileURL(__filename).href : _documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === "SCRIPT" && _documentCurrentScript.src || new URL("index.cjs", document.baseURI).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 });
-    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);
-          const bar = "█".repeat(filledLength) + "░".repeat(barLength - filledLength);
-          task.output = `[${bar}] ${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(new Error(`Error processing worker message: ${err.message}
-${err.stack}`));
-      }
-    });
-    worker.on("error", (err) => {
-      workerError = err;
-      handleError(err);
-    });
-    worker.on("exit", (code) => {
-      if (code !== 0 && !isResolved) {
-        const error = workerError || new Error(
-          code === 1 ? "Worker terminated due to reaching memory limit: JS heap out of memory" : `Worker stopped with exit code ${code}`
-        );
-        handleError(error);
-      }
-    });
-  }));
+	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
+		});
+		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;