@dimina/compiler 1.0.12-beta.9 → 1.0.13

package/dist/src-DycLk1BL.cjs

@@ -0,0 +1,440 @@
+const require_env = require("./env-lm96AacS.cjs");
+let node_path = require("node:path");
+node_path = require_env.__toESM(node_path);
+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);
+let node_fs = require("node:fs");
+node_fs = require_env.__toESM(node_fs);
+let node_os = require("node:os");
+node_os = require_env.__toESM(node_os);
+//#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
+/**
+*
+* 编译项目配置文件 app-config.json
+*/
+function compileConfig() {
+	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);
+}
+//#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) {
+		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(node_path.default.join(node_path.default.dirname((0, node_url.fileURLToPath)({}.url)), `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
+Object.defineProperty(exports, "build", {
+	enumerable: true,
+	get: function() {
+		return build;
+	}
+});

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@dimina/compiler",
-	"version": "1.0.12-beta.9",
+	"version": "1.0.13",
 	"description": "星河编译工具",
 	"main": "./dist/index.cjs",
 	"module": "./dist/index.js",
@@ -47,25 +47,29 @@
 		"星河"
 	],
 	"dependencies": {
-		"@babel/core": "^7.28.5",
-		"@babel/generator": "^7.28.5",
-		"@babel/plugin-transform-modules-commonjs": "^7.27.1",
-		"@babel/traverse": "^7.28.5",
-		"@babel/types": "^7.28.5",
-		"@vue/compiler-sfc": "^3.5.26",
-		"autoprefixer": "^10.4.23",
-		"cheerio": "^1.1.2",
+		"@babel/core": "^7.29.0",
+		"@babel/generator": "^7.29.1",
+		"@babel/plugin-transform-modules-commonjs": "^7.28.6",
+		"@babel/traverse": "^7.29.0",
+		"@babel/types": "^7.29.0",
+		"@vue/compiler-sfc": "^3.5.32",
+		"autoprefixer": "^10.4.27",
+		"cheerio": "^1.2.0",
 		"chokidar": "^4.0.3",
-		"commander": "^14.0.2",
-		"cssnano": "^7.1.2",
-		"esbuild": "^0.25.12",
-		"htmlparser2": "^10.0.0",
-		"less": "^4.5.1",
-		"listr2": "8.3.3",
-		"postcss": "^8.5.6",
+		"commander": "^14.0.3",
+		"cssnano": "^7.1.4",
+		"esbuild": "^0.27.7",
+		"htmlparser2": "^10.1.0",
+		"less": "^4.6.4",
+		"listr2": "^9.0.5",
+		"magic-string": "^0.30.21",
+		"oxc-parser": "^0.123.0",
+		"oxc-transform": "^0.124.0",
+		"oxc-walker": "^0.7.0",
+		"postcss": "^8.5.9",
 		"postcss-selector-parser": "^7.1.1",
-		"sass": "^1.97.2",
-		"typescript": "^5.9.3"
+		"sass": "^1.99.0",
+		"typescript": "^6.0.2"
 	},
 	"publishConfig": {
 		"registry": "https://registry.npmjs.org/",