@dimina/compiler 1.0.14-beta.0 → 1.0.15

package/dist/core/logic-compiler.js

@@ -1,18 +1,103 @@
-import { a as getContentByPath, d as resetStoreInfo, f as resolveAppAlias, g as hasCompileInfo, i as getComponent, l as getTargetPath, m as collectAssets, n as getAppId, o as getNpmResolver, t as getAppConfigInfo, u as getWorkPath } from "../env-DgCLbrQb.js";
+import { a as getContentByPath, d as resetStoreInfo, f as resolveAppAlias, g as hasCompileInfo, i as getComponent, l as getTargetPath, m as collectAssets, n as getAppId, o as getNpmResolver, t as getAppConfigInfo, u as getWorkPath } from "../env-p9Az8lv5.js";
+import { n as getWxMemberName, r as warnUnsupportedWxApi } from "../compatibility-C_zWVjYl.js";
 import { resolve, sep } from "node:path";
 import { isMainThread, parentPort } from "node:worker_threads";
 import fs from "node:fs";
-import { transform } from "esbuild";
 import { parseSync } from "oxc-parser";
 import { walk } from "oxc-walker";
-import { transformSync } from "oxc-transform";
 import MagicString from "magic-string";
-import ts from "typescript";
+import { transform } from "esbuild";
+import { SourceMapConsumer, SourceMapGenerator } from "source-map-js";
+//#region src/core/sourcemap.js
+function wrapModDefine(module) {
+	const code = module.code.endsWith("\n") ? module.code : module.code + "\n";
+	const extraLine = module.extraInfoCode || "";
+	return {
+		header: `modDefine('${module.path}', function(require, module, exports) {\n${extraLine}`,
+		code,
+		footer: "});\n"
+	};
+}
+function mergeSourcemap(compileRes) {
+	const smg = new SourceMapGenerator({ file: "logic.js" });
+	let bundleCode = "";
+	let lineOffset = 0;
+	for (const module of compileRes) {
+		const { header, code, footer } = wrapModDefine(module);
+		bundleCode += header;
+		const headerLineCount = header.split("\n").length - 1;
+		lineOffset += headerLineCount;
+		if (module.map) {
+			const moduleMap = JSON.parse(module.map);
+			new SourceMapConsumer(moduleMap).eachMapping((mapping) => {
+				if (mapping.source == null) return;
+				smg.addMapping({
+					generated: {
+						line: mapping.generatedLine + lineOffset,
+						column: mapping.generatedColumn
+					},
+					original: {
+						line: mapping.originalLine,
+						column: mapping.originalColumn
+					},
+					source: mapping.source,
+					name: mapping.name
+				});
+			});
+			if (moduleMap.sourcesContent) moduleMap.sources.forEach((src, i) => {
+				smg.setSourceContent(src, moduleMap.sourcesContent[i]);
+			});
+		}
+		bundleCode += code;
+		lineOffset += code.split("\n").length - 1;
+		bundleCode += footer;
+		lineOffset += footer.split("\n").length - 1;
+	}
+	return {
+		bundleCode,
+		sourcemap: smg.toString()
+	};
+}
+function remapSourcemap(nextMap, prevMap) {
+	if (!nextMap) return prevMap;
+	if (!prevMap) return nextMap;
+	const nextMapObj = typeof nextMap === "string" ? JSON.parse(nextMap) : nextMap;
+	const prevMapObj = typeof prevMap === "string" ? JSON.parse(prevMap) : prevMap;
+	const smg = new SourceMapGenerator({ file: nextMapObj.file || prevMapObj.file || "" });
+	const prevSmc = new SourceMapConsumer(prevMapObj);
+	new SourceMapConsumer(nextMapObj).eachMapping((mapping) => {
+		if (mapping.source == null || mapping.originalLine == null || mapping.originalColumn == null) return;
+		const original = prevSmc.originalPositionFor({
+			line: mapping.originalLine,
+			column: mapping.originalColumn
+		});
+		if (original.source == null || original.line == null || original.column == null) return;
+		smg.addMapping({
+			generated: {
+				line: mapping.generatedLine,
+				column: mapping.generatedColumn
+			},
+			original: {
+				line: original.line,
+				column: original.column
+			},
+			source: original.source,
+			name: original.name || mapping.name
+		});
+	});
+	if (prevMapObj.sourcesContent) prevMapObj.sources.forEach((src, i) => {
+		smg.setSourceContent(src, prevMapObj.sourcesContent[i]);
+	});
+	return smg.toString();
+}
+//#endregion
 //#region src/core/logic-compiler.js
 var processedModules = /* @__PURE__ */ new Set();
-if (!isMainThread) parentPort.on("message", async ({ pages, storeInfo }) => {
+var enableSourcemap = false;
+if (!isMainThread) parentPort.on("message", async ({ pages, storeInfo, sourcemap }) => {
 	try {
 		resetStoreInfo(storeInfo);
+		enableSourcemap = !!sourcemap;
 		const progress = {
 			_completedTasks: 0,
 			get completedTasks() {
@@ -45,25 +130,26 @@ if (!isMainThread) parentPort.on("message", async ({ pages, storeInfo }) => {
 	}
 });
 async function writeCompileRes(compileRes, root) {
-	let mergeCode = "";
-	for (const module of compileRes) {
-		const { code: minifiedCode } = await transform(`modDefine('${module.path}', function(require, module, exports) {
+	const outputDir = root ? `${getTargetPath()}/${root}` : `${getTargetPath()}/main`;
+	if (!fs.existsSync(outputDir)) fs.mkdirSync(outputDir, { recursive: true });
+	if (enableSourcemap) {
+		const { bundleCode, sourcemap } = mergeSourcemap(compileRes);
+		const sourcemapFileName = "logic.js.map";
+		fs.writeFileSync(`${outputDir}/logic.js`, `${bundleCode}//# sourceMappingURL=${sourcemapFileName}\n`);
+		fs.writeFileSync(`${outputDir}/${sourcemapFileName}`, sourcemap);
+	} else {
+		let mergeCode = "";
+		for (const module of compileRes) {
+			const { code: minifiedCode } = await transform(`modDefine('${module.path}', function(require, module, exports) {
 ${module.code}
 });`, {
-			minify: true,
-			target: ["es2023"],
-			platform: "neutral"
-		});
-		mergeCode += minifiedCode;
-	}
-	if (root) {
-		const subDir = `${getTargetPath()}/${root}`;
-		if (!fs.existsSync(subDir)) fs.mkdirSync(subDir, { recursive: true });
-		fs.writeFileSync(`${subDir}/logic.js`, mergeCode);
-	} else {
-		const mainDir = `${getTargetPath()}/main`;
-		if (!fs.existsSync(mainDir)) fs.mkdirSync(mainDir, { recursive: true });
-		fs.writeFileSync(`${mainDir}/logic.js`, mergeCode);
+				minify: true,
+				target: ["es2023"],
+				platform: "neutral"
+			});
+			mergeCode += minifiedCode;
+		}
+		fs.writeFileSync(`${outputDir}/logic.js`, mergeCode);
 	}
 }
 /**
@@ -93,7 +179,8 @@ async function buildJSByPath(packageName, module, compileRes, mainCompileRes, ad
 	if (hasCompileInfo(module.path, compileRes, mainCompileRes)) return;
 	const compileInfo = {
 		path: module.path,
-		code: ""
+		code: "",
+		sourceFile: null
 	};
 	const src = module.path.startsWith("/") ? module.path : `/${module.path}`;
 	const modulePath = getJSAbsolutePath(src);
@@ -101,29 +188,22 @@ async function buildJSByPath(packageName, module, compileRes, mainCompileRes, ad
 		console.warn("[logic]", `找不到模块文件: ${src}`);
 		return;
 	}
+	const diagnosticSource = modulePath.startsWith(getWorkPath()) ? modulePath.slice(getWorkPath().length) : src;
 	const sourceCode = getContentByPath(modulePath);
 	if (!sourceCode) {
 		console.warn("[logic]", `无法读取模块文件: ${modulePath}`);
 		return;
 	}
-	let jsCode = sourceCode;
-	if (modulePath.endsWith(".ts")) try {
-		jsCode = ts.transpileModule(sourceCode, { compilerOptions: {
-			target: ts.ScriptTarget.ES2020,
-			module: ts.ModuleKind.ESNext,
-			strict: false,
-			esModuleInterop: true,
-			skipLibCheck: true
-		} }).outputText;
-	} catch (error) {
-		console.error(`[logic] TypeScript 编译失败 ${modulePath}:`, error.message);
-		jsCode = sourceCode;
+	const isTypeScript = modulePath.endsWith(".ts");
+	if (enableSourcemap) {
+		const workPath = getWorkPath();
+		compileInfo.sourceFile = modulePath.startsWith(workPath) ? modulePath.slice(workPath.length) : src;
 	}
-	const ast = parseSync(modulePath, jsCode, {
+	const ast = parseSync(modulePath, sourceCode, {
 		sourceType: "module",
-		lang: modulePath.endsWith(".ts") ? "ts" : "js"
+		lang: isTypeScript ? "ts" : "js"
 	}).program;
-	const s = new MagicString(jsCode);
+	const s = new MagicString(sourceCode);
 	const extraInfo = { path: module.path };
 	if (module.component) extraInfo.component = true;
 	if (module.usingComponents) {
@@ -147,13 +227,16 @@ async function buildJSByPath(packageName, module, compileRes, mainCompileRes, ad
 	}
 	if (addExtra) {
 		const extraInfoCode = `globalThis.__extraInfo = ${JSON.stringify(extraInfo)};\n`;
-		s.prepend(extraInfoCode);
+		if (enableSourcemap) compileInfo.extraInfoCode = extraInfoCode;
+		else s.prepend(extraInfoCode);
 	}
 	if (putMain) mainCompileRes.push(compileInfo);
 	else compileRes.push(compileInfo);
 	const pathReplacements = [];
 	const dependenciesToProcess = [];
 	walk(ast, { enter(node, parent) {
+		const wxMemberName = getWxMemberName(node);
+		if (wxMemberName) warnUnsupportedWxApi(wxMemberName, compileInfo.sourceFile || diagnosticSource, node.loc?.start?.line || getLineByIndex(sourceCode, node.start));
 		if ((node.type === "StringLiteral" || node.type === "Literal") && isLocalAssetString(node.value)) pathReplacements.push({
 			start: node.start,
 			end: node.end,
@@ -192,6 +275,21 @@ async function buildJSByPath(packageName, module, compileRes, mainCompileRes, ad
 				}
 			}
 		}
+		if (node.type === "TSImportEqualsDeclaration" && node.moduleReference?.type === "TSExternalModuleReference") {
+			const importPathNode = node.moduleReference.expression;
+			const importPath = importPathNode?.value;
+			if (importPath) {
+				const { id, shouldProcess } = resolveDependencyId(importPath, modulePath, false);
+				if (shouldProcess) {
+					pathReplacements.push({
+						start: importPathNode.start,
+						end: importPathNode.end,
+						newValue: id
+					});
+					if (!processedModules.has(packageName + id)) dependenciesToProcess.push(id);
+				}
+			}
+		}
 		if ((node.type === "ExportAllDeclaration" || node.type === "ExportNamedDeclaration") && node.source) {
 			const exportPath = node.source.value;
 			if (exportPath) {
@@ -210,62 +308,49 @@ async function buildJSByPath(packageName, module, compileRes, mainCompileRes, ad
 	for (const depId of dependenciesToProcess) await buildJSByPath(packageName, { path: depId }, compileRes, mainCompileRes, false, depthChain, putMain);
 	for (const replacement of pathReplacements.reverse()) s.overwrite(replacement.start, replacement.end, `'${replacement.newValue}'`);
 	const modifiedCode = s.toString();
-	let transformedCode = modifiedCode;
-	if (modulePath.endsWith(".ts") || modulePath.endsWith(".tsx")) try {
-		transformedCode = transformSync(modulePath, modifiedCode, {
-			sourceType: "module",
-			lang: modulePath.endsWith(".tsx") ? "tsx" : "ts",
-			target: "es2020",
-			typescript: { onlyRemoveTypeImports: true }
-		}).code;
-	} catch (error) {
-		console.error(`[logic] oxc-transform 转换失败 ${modulePath}:`, error.message);
-		transformedCode = modifiedCode;
+	let preEsbuildMap = null;
+	if (enableSourcemap && compileInfo.sourceFile) {
+		const generatedMap = JSON.parse(s.generateMap({
+			file: compileInfo.sourceFile,
+			source: compileInfo.sourceFile,
+			includeContent: true,
+			hires: true
+		}).toString());
+		generatedMap.file = compileInfo.sourceFile;
+		generatedMap.sources = [compileInfo.sourceFile];
+		generatedMap.sourcesContent = [sourceCode];
+		preEsbuildMap = JSON.stringify(generatedMap);
 	}
 	try {
-		const esbuildCode = (await transform(transformedCode, {
+		const esbuildOpts = {
 			format: "cjs",
 			target: "es2020",
 			platform: "neutral",
-			loader: "js"
-		})).code;
-		const esbuildAst = parseSync(modulePath, esbuildCode, {
-			sourceType: "module",
-			lang: "js"
-		});
-		const postEsbuildReplacements = [];
-		walk(esbuildAst.program, { enter(node) {
-			if (node.type === "CallExpression") {
-				const isRequire = node.callee.type === "Identifier" && node.callee.name === "require";
-				const isRequireProperty = node.callee.type === "MemberExpression" && node.callee.object?.type === "Identifier" && node.callee.object?.name === "require";
-				if ((isRequire || isRequireProperty) && node.arguments.length > 0 && (node.arguments[0].type === "StringLiteral" || node.arguments[0].type === "Literal")) {
-					const arg = node.arguments[0];
-					const requirePath = arg.value;
-					if (requirePath && (requirePath.startsWith("./") || requirePath.startsWith("../"))) {
-						const { id } = resolveDependencyId(requirePath, modulePath, false);
-						postEsbuildReplacements.push({
-							start: arg.start,
-							end: arg.end,
-							newValue: id
-						});
-					}
-				}
-			}
-		} });
-		if (postEsbuildReplacements.length > 0) {
-			const finalMagicString = new MagicString(esbuildCode);
-			for (const replacement of postEsbuildReplacements.reverse()) finalMagicString.overwrite(replacement.start, replacement.end, `"${replacement.newValue}"`);
-			compileInfo.code = finalMagicString.toString();
-		} else compileInfo.code = esbuildCode;
+			loader: isTypeScript ? "ts" : "js"
+		};
+		if (enableSourcemap && compileInfo.sourceFile) {
+			esbuildOpts.sourcemap = true;
+			esbuildOpts.sourcefile = compileInfo.sourceFile;
+			esbuildOpts.sourcesContent = true;
+		}
+		const esbuildResult = await transform(modifiedCode, esbuildOpts);
+		if (enableSourcemap && esbuildResult.map) compileInfo.map = preEsbuildMap ? remapSourcemap(esbuildResult.map, preEsbuildMap) : esbuildResult.map;
+		compileInfo.code = esbuildResult.code;
 	} catch (error) {
 		console.error(`[logic] esbuild 转换失败 ${modulePath}:`, error.message);
-		compileInfo.code = transformedCode;
+		compileInfo.code = modifiedCode;
 	}
 	processedModules.add(packageName + currentPath);
 }
 function isLocalAssetString(value) {
 	return typeof value === "string" && !value.startsWith("http") && !value.startsWith("//") && (value.startsWith("/") || value.startsWith("./") || value.startsWith("../")) && /\.(?:png|jpe?g|gif|svg)(?:\?.*)?$/.test(value);
 }
+function getLineByIndex(content, index) {
+	if (typeof index !== "number" || index < 0) return null;
+	let line = 1;
+	for (let i = 0; i < index; i++) if (content.charCodeAt(i) === 10) line++;
+	return line;
+}
 /**
 * 获取 JavaScript 或 TypeScript 文件的绝对路径
 * @param {string} modulePath - 模块路径
@@ -308,9 +393,14 @@ function resolveDependencyId(specifier, modulePath, allowAbsolute) {
 	};
 	if (specifier.startsWith("@") || isBareModuleSpecifier(specifier)) {
 		const npmModuleId = resolveNpmModuleId(specifier, modulePath);
+		if (npmModuleId) return {
+			id: npmModuleId,
+			shouldProcess: true
+		};
+		const siblingModuleId = resolveBareSiblingModuleId(specifier, modulePath);
 		return {
-			id: npmModuleId || specifier,
-			shouldProcess: Boolean(npmModuleId)
+			id: siblingModuleId || specifier,
+			shouldProcess: Boolean(siblingModuleId)
 		};
 	}
 	return {
@@ -325,6 +415,9 @@ function resolveRelativeModuleId(specifier, modulePath) {
 	const relativeId = resolve(modulePath, `../${specifier}`).split(`${getWorkPath()}${sep}`)[1];
 	return normalizeModuleId(relativeId);
 }
+function resolveBareSiblingModuleId(specifier, modulePath) {
+	return resolveModuleIdToExistingPath(resolveRelativeModuleId(`./${specifier}`, modulePath));
+}
 function normalizeModuleId(moduleId) {
 	let normalized = moduleId.replace(/\.(js|ts)$/, "").replace(/\\/g, "/");
 	if (!normalized.startsWith("/")) normalized = `/${normalized}`;

package/dist/core/style-compiler.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_env = require("../env-M-7lpbHL.cjs");
+const require_env = require("../env-Dmnqp9bD.cjs");
 let node_path = require("node:path");
 node_path = require_env.__toESM(node_path, 1);
 let node_worker_threads = require("node:worker_threads");
@@ -79,11 +79,11 @@ async function buildCompileCss(module, depthChain = [], compiledPaths = /* @__PU
 	const currentPath = module.path || module.absolutePath;
 	if (depthChain.includes(currentPath)) {
 		console.warn("[style]", `检测到循环依赖: ${[...depthChain, currentPath].join(" -> ")}`);
-		return;
+		return "";
 	}
 	if (depthChain.length > 20) {
 		console.warn("[style]", `检测到深度依赖: ${[...depthChain, currentPath].join(" -> ")}`);
-		return;
+		return "";
 	}
 	if (compiledPaths.has(currentPath)) return "";
 	compiledPaths.add(currentPath);
@@ -92,15 +92,15 @@ async function buildCompileCss(module, depthChain = [], compiledPaths = /* @__PU
 	if (module.usingComponents) for (const componentInfo of Object.values(module.usingComponents)) {
 		const componentModule = require_env.getComponent(componentInfo);
 		if (!componentModule) continue;
-		result += await buildCompileCss(componentModule, depthChain, compiledPaths);
+		result += await buildCompileCss(componentModule, depthChain, compiledPaths) || "";
 	}
 	return result;
 }
 async function enhanceCSS(module) {
 	const absolutePath = module.absolutePath ? module.absolutePath : getAbsolutePath(module.path);
-	if (!absolutePath) return;
+	if (!absolutePath) return "";
 	const inputCSS = require_env.getContentByPath(absolutePath);
-	if (!inputCSS) return;
+	if (!inputCSS) return "";
 	if (compileRes.has(absolutePath)) return compileRes.get(absolutePath);
 	let processedCSS = normalizeRootStyleImports(inputCSS);
 	const ext = node_path.default.extname(absolutePath).toLowerCase();
@@ -158,7 +158,7 @@ async function enhanceCSS(module) {
 	const cleanedCode = await removeBaseComponentScope(scopedCode, moduleId);
 	const res = await (0, postcss.default)([(0, autoprefixer.default)({ overrideBrowserslist: ["cover 99.5%"] }), (0, cssnano.default)()]).process(cleanedCode, { from: void 0 });
 	const result = (await Promise.all(promises)).filter(Boolean).join("") + res.css;
-	compileRes.set(module.path, result);
+	compileRes.set(absolutePath, result);
 	return result;
 }
 function normalizeCssUrlValue(value, absolutePath) {

package/dist/core/style-compiler.js

@@ -1,4 +1,4 @@
-import { _ as tagWhiteList, a as getContentByPath, d as resetStoreInfo, i as getComponent, l as getTargetPath, m as collectAssets, n as getAppId, u as getWorkPath, v as transformRpx } from "../env-DgCLbrQb.js";
+import { _ as tagWhiteList, a as getContentByPath, d as resetStoreInfo, i as getComponent, l as getTargetPath, m as collectAssets, n as getAppId, u as getWorkPath, v as transformRpx } from "../env-p9Az8lv5.js";
 import path from "node:path";
 import { isMainThread, parentPort } from "node:worker_threads";
 import fs from "node:fs";
@@ -70,11 +70,11 @@ async function buildCompileCss(module, depthChain = [], compiledPaths = /* @__PU
 	const currentPath = module.path || module.absolutePath;
 	if (depthChain.includes(currentPath)) {
 		console.warn("[style]", `检测到循环依赖: ${[...depthChain, currentPath].join(" -> ")}`);
-		return;
+		return "";
 	}
 	if (depthChain.length > 20) {
 		console.warn("[style]", `检测到深度依赖: ${[...depthChain, currentPath].join(" -> ")}`);
-		return;
+		return "";
 	}
 	if (compiledPaths.has(currentPath)) return "";
 	compiledPaths.add(currentPath);
@@ -83,15 +83,15 @@ async function buildCompileCss(module, depthChain = [], compiledPaths = /* @__PU
 	if (module.usingComponents) for (const componentInfo of Object.values(module.usingComponents)) {
 		const componentModule = getComponent(componentInfo);
 		if (!componentModule) continue;
-		result += await buildCompileCss(componentModule, depthChain, compiledPaths);
+		result += await buildCompileCss(componentModule, depthChain, compiledPaths) || "";
 	}
 	return result;
 }
 async function enhanceCSS(module) {
 	const absolutePath = module.absolutePath ? module.absolutePath : getAbsolutePath(module.path);
-	if (!absolutePath) return;
+	if (!absolutePath) return "";
 	const inputCSS = getContentByPath(absolutePath);
-	if (!inputCSS) return;
+	if (!inputCSS) return "";
 	if (compileRes.has(absolutePath)) return compileRes.get(absolutePath);
 	let processedCSS = normalizeRootStyleImports(inputCSS);
 	const ext = path.extname(absolutePath).toLowerCase();
@@ -149,7 +149,7 @@ async function enhanceCSS(module) {
 	const cleanedCode = await removeBaseComponentScope(scopedCode, moduleId);
 	const res = await postcss([autoprefixer({ overrideBrowserslist: ["cover 99.5%"] }), cssnano()]).process(cleanedCode, { from: void 0 });
 	const result = (await Promise.all(promises)).filter(Boolean).join("") + res.css;
-	compileRes.set(module.path, result);
+	compileRes.set(absolutePath, result);
 	return result;
 }
 function normalizeCssUrlValue(value, absolutePath) {