@dimina/compiler 1.0.12 → 1.0.14-beta.0

package/dist/core/logic-compiler.cjs

@@ -1,371 +1,361 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const fs = require("node:fs");
-const path = require("node:path");
-const node_worker_threads = require("node:worker_threads");
-const oxcParser = require("oxc-parser");
-const oxcWalker = require("oxc-walker");
-const oxcTransform = require("oxc-transform");
-const MagicString = require("magic-string");
-const esbuild = require("esbuild");
-const ts = require("typescript");
-const env = require("../env-Cmen1qwy.cjs");
-const processedModules = /* @__PURE__ */ new Set();
-if (!node_worker_threads.isMainThread) {
-  node_worker_threads.parentPort.on("message", async ({ pages, storeInfo }) => {
-    try {
-      env.resetStoreInfo(storeInfo);
-      const progress = {
-        _completedTasks: 0,
-        get completedTasks() {
-          return this._completedTasks;
-        },
-        set completedTasks(value) {
-          this._completedTasks = value;
-          node_worker_threads.parentPort.postMessage({ completedTasks: this.completedTasks });
-        }
-      };
-      const mainCompileRes = await compileJS(pages.mainPages, null, null, progress);
-      for (const [root, subPages] of Object.entries(pages.subPages)) {
-        try {
-          const subCompileRes = await compileJS(
-            subPages.info,
-            root,
-            subPages.independent ? [] : mainCompileRes,
-            progress
-          );
-          await writeCompileRes(subCompileRes, root);
-        } catch (error) {
-          throw new Error(`Error processing subpackage ${root}: ${error.message}
-${error.stack}`);
-        }
-      }
-      await writeCompileRes(mainCompileRes, null);
-      processedModules.clear();
-      node_worker_threads.parentPort.postMessage({ success: true });
-    } catch (error) {
-      processedModules.clear();
-      node_worker_threads.parentPort.postMessage({
-        success: false,
-        error: {
-          message: error.message,
-          stack: error.stack,
-          name: error.name
-        }
-      });
-    }
-  });
-}
+const require_env = require("../env-M-7lpbHL.cjs");
+let node_path = require("node:path");
+let node_worker_threads = require("node:worker_threads");
+let node_fs = require("node:fs");
+node_fs = require_env.__toESM(node_fs, 1);
+let esbuild = require("esbuild");
+let oxc_parser = require("oxc-parser");
+let oxc_walker = require("oxc-walker");
+let oxc_transform = require("oxc-transform");
+let magic_string = require("magic-string");
+magic_string = require_env.__toESM(magic_string, 1);
+let typescript = require("typescript");
+typescript = require_env.__toESM(typescript, 1);
+//#region src/core/logic-compiler.js
+var processedModules = /* @__PURE__ */ new Set();
+if (!node_worker_threads.isMainThread) node_worker_threads.parentPort.on("message", async ({ pages, storeInfo }) => {
+	try {
+		require_env.resetStoreInfo(storeInfo);
+		const progress = {
+			_completedTasks: 0,
+			get completedTasks() {
+				return this._completedTasks;
+			},
+			set completedTasks(value) {
+				this._completedTasks = value;
+				node_worker_threads.parentPort.postMessage({ completedTasks: this.completedTasks });
+			}
+		};
+		const mainCompileRes = await compileJS(pages.mainPages, null, null, progress);
+		for (const [root, subPages] of Object.entries(pages.subPages)) try {
+			await writeCompileRes(await compileJS(subPages.info, root, subPages.independent ? [] : mainCompileRes, progress), root);
+		} catch (error) {
+			throw new Error(`Error processing subpackage ${root}: ${error.message}\n${error.stack}`);
+		}
+		await writeCompileRes(mainCompileRes, null);
+		processedModules.clear();
+		node_worker_threads.parentPort.postMessage({ success: true });
+	} catch (error) {
+		processedModules.clear();
+		node_worker_threads.parentPort.postMessage({
+			success: false,
+			error: {
+				message: error.message,
+				stack: error.stack,
+				name: error.name
+			}
+		});
+	}
+});
 async function writeCompileRes(compileRes, root) {
-  let mergeCode = "";
-  for (const module2 of compileRes) {
-    const amdFormat = `modDefine('${module2.path}', function(require, module, exports) {
-${module2.code}
-});`;
-    const { code: minifiedCode } = await esbuild.transform(amdFormat, {
-      minify: true,
-      target: ["es2023"],
-      // quickjs 支持版本
-      platform: "neutral"
-    });
-    mergeCode += minifiedCode;
-  }
-  if (root) {
-    const subDir = `${env.getTargetPath()}/${root}`;
-    if (!fs.existsSync(subDir)) {
-      fs.mkdirSync(subDir, { recursive: true });
-    }
-    fs.writeFileSync(`${subDir}/logic.js`, mergeCode);
-  } else {
-    const mainDir = `${env.getTargetPath()}/main`;
-    if (!fs.existsSync(mainDir)) {
-      fs.mkdirSync(mainDir, { recursive: true });
-    }
-    fs.writeFileSync(`${mainDir}/logic.js`, mergeCode);
-  }
+	let mergeCode = "";
+	for (const module of compileRes) {
+		const { code: minifiedCode } = await (0, esbuild.transform)(`modDefine('${module.path}', function(require, module, exports) {
+${module.code}
+});`, {
+			minify: true,
+			target: ["es2023"],
+			platform: "neutral"
+		});
+		mergeCode += minifiedCode;
+	}
+	if (root) {
+		const subDir = `${require_env.getTargetPath()}/${root}`;
+		if (!node_fs.default.existsSync(subDir)) node_fs.default.mkdirSync(subDir, { recursive: true });
+		node_fs.default.writeFileSync(`${subDir}/logic.js`, mergeCode);
+	} else {
+		const mainDir = `${require_env.getTargetPath()}/main`;
+		if (!node_fs.default.existsSync(mainDir)) node_fs.default.mkdirSync(mainDir, { recursive: true });
+		node_fs.default.writeFileSync(`${mainDir}/logic.js`, mergeCode);
+	}
 }
+/**
+* 编译 js 文件
+*/
 async function compileJS(pages, root, mainCompileRes, progress) {
-  const compileRes = [];
-  if (!root) {
-    await buildJSByPath(root, { path: "app" }, compileRes, mainCompileRes, false);
-  }
-  for (const page of pages) {
-    await buildJSByPath(root, page, compileRes, mainCompileRes, true);
-    progress.completedTasks++;
-  }
-  return compileRes;
+	const compileRes = [];
+	if (!root) await buildJSByPath(root, { path: "app" }, compileRes, mainCompileRes, false);
+	for (const page of pages) {
+		await buildJSByPath(root, page, compileRes, mainCompileRes, true);
+		progress.completedTasks++;
+	}
+	return compileRes;
+}
+async function buildJSByPath(packageName, module, compileRes, mainCompileRes, addExtra, depthChain = [], putMain = false) {
+	const currentPath = module.path;
+	if (depthChain.includes(currentPath)) {
+		console.warn("[logic]", `检测到循环依赖: ${[...depthChain, currentPath].join(" -> ")}`);
+		return;
+	}
+	if (depthChain.length > 20) {
+		console.warn("[logic]", `检测到深度依赖: ${[...depthChain, currentPath].join(" -> ")}`);
+		return;
+	}
+	depthChain = [...depthChain, currentPath];
+	if (!module.path) return;
+	if (require_env.hasCompileInfo(module.path, compileRes, mainCompileRes)) return;
+	const compileInfo = {
+		path: module.path,
+		code: ""
+	};
+	const src = module.path.startsWith("/") ? module.path : `/${module.path}`;
+	const modulePath = getJSAbsolutePath(src);
+	if (!modulePath) {
+		console.warn("[logic]", `找不到模块文件: ${src}`);
+		return;
+	}
+	const sourceCode = require_env.getContentByPath(modulePath);
+	if (!sourceCode) {
+		console.warn("[logic]", `无法读取模块文件: ${modulePath}`);
+		return;
+	}
+	let jsCode = sourceCode;
+	if (modulePath.endsWith(".ts")) try {
+		jsCode = typescript.default.transpileModule(sourceCode, { compilerOptions: {
+			target: typescript.default.ScriptTarget.ES2020,
+			module: typescript.default.ModuleKind.ESNext,
+			strict: false,
+			esModuleInterop: true,
+			skipLibCheck: true
+		} }).outputText;
+	} catch (error) {
+		console.error(`[logic] TypeScript 编译失败 ${modulePath}:`, error.message);
+		jsCode = sourceCode;
+	}
+	const ast = (0, oxc_parser.parseSync)(modulePath, jsCode, {
+		sourceType: "module",
+		lang: modulePath.endsWith(".ts") ? "ts" : "js"
+	}).program;
+	const s = new magic_string.default(jsCode);
+	const extraInfo = { path: module.path };
+	if (module.component) extraInfo.component = true;
+	if (module.usingComponents) {
+		const componentsObj = {};
+		const allSubPackages = require_env.getAppConfigInfo().subPackages;
+		for (const [name, path] of Object.entries(module.usingComponents)) {
+			let toMainSubPackage = true;
+			if (packageName) {
+				const normalizedPath = path.startsWith("/") ? path.substring(1) : path;
+				for (const subPackage of allSubPackages) if (normalizedPath.startsWith(`${subPackage.root}/`)) {
+					toMainSubPackage = false;
+					break;
+				}
+			} else toMainSubPackage = false;
+			const componentModule = require_env.getComponent(path);
+			if (!componentModule) continue;
+			await buildJSByPath(packageName, componentModule, compileRes, mainCompileRes, true, depthChain, putMain || toMainSubPackage);
+			componentsObj[name] = path;
+		}
+		extraInfo.usingComponents = componentsObj;
+	}
+	if (addExtra) {
+		const extraInfoCode = `globalThis.__extraInfo = ${JSON.stringify(extraInfo)};\n`;
+		s.prepend(extraInfoCode);
+	}
+	if (putMain) mainCompileRes.push(compileInfo);
+	else compileRes.push(compileInfo);
+	const pathReplacements = [];
+	const dependenciesToProcess = [];
+	(0, oxc_walker.walk)(ast, { enter(node, parent) {
+		if ((node.type === "StringLiteral" || node.type === "Literal") && isLocalAssetString(node.value)) pathReplacements.push({
+			start: node.start,
+			end: node.end,
+			newValue: require_env.collectAssets(require_env.getWorkPath(), modulePath, node.value, require_env.getTargetPath(), require_env.getAppId())
+		});
+		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) {
+					const { id, shouldProcess } = resolveDependencyId(requirePath, modulePath, false);
+					if (shouldProcess) {
+						pathReplacements.push({
+							start: arg.start,
+							end: arg.end,
+							newValue: id
+						});
+						if (!processedModules.has(packageName + id)) dependenciesToProcess.push(id);
+					}
+				}
+			}
+		}
+		if (node.type === "ImportDeclaration") {
+			const importPath = node.source.value;
+			if (importPath) {
+				const { id, shouldProcess } = resolveDependencyId(importPath, modulePath, true);
+				if (shouldProcess) {
+					pathReplacements.push({
+						start: node.source.start,
+						end: node.source.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) {
+				const { id, shouldProcess } = resolveDependencyId(exportPath, modulePath, true);
+				if (shouldProcess) {
+					pathReplacements.push({
+						start: node.source.start,
+						end: node.source.end,
+						newValue: id
+					});
+					if (!processedModules.has(packageName + id)) dependenciesToProcess.push(id);
+				}
+			}
+		}
+	} });
+	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 = (0, oxc_transform.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;
+	}
+	try {
+		const esbuildCode = (await (0, esbuild.transform)(transformedCode, {
+			format: "cjs",
+			target: "es2020",
+			platform: "neutral",
+			loader: "js"
+		})).code;
+		const esbuildAst = (0, oxc_parser.parseSync)(modulePath, esbuildCode, {
+			sourceType: "module",
+			lang: "js"
+		});
+		const postEsbuildReplacements = [];
+		(0, oxc_walker.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 magic_string.default(esbuildCode);
+			for (const replacement of postEsbuildReplacements.reverse()) finalMagicString.overwrite(replacement.start, replacement.end, `"${replacement.newValue}"`);
+			compileInfo.code = finalMagicString.toString();
+		} else compileInfo.code = esbuildCode;
+	} catch (error) {
+		console.error(`[logic] esbuild 转换失败 ${modulePath}:`, error.message);
+		compileInfo.code = transformedCode;
+	}
+	processedModules.add(packageName + currentPath);
 }
-async function buildJSByPath(packageName, module2, compileRes, mainCompileRes, addExtra, depthChain = [], putMain = false) {
-  const currentPath = module2.path;
-  if (depthChain.includes(currentPath)) {
-    console.warn("[logic]", `检测到循环依赖: ${[...depthChain, currentPath].join(" -> ")}`);
-    return;
-  }
-  if (depthChain.length > 20) {
-    console.warn("[logic]", `检测到深度依赖: ${[...depthChain, currentPath].join(" -> ")}`);
-    return;
-  }
-  depthChain = [...depthChain, currentPath];
-  if (!module2.path) {
-    return;
-  }
-  if (env.hasCompileInfo(module2.path, compileRes, mainCompileRes)) {
-    return;
-  }
-  const compileInfo = {
-    path: module2.path,
-    code: ""
-  };
-  const src = module2.path.startsWith("/") ? module2.path : `/${module2.path}`;
-  const modulePath = getJSAbsolutePath(src);
-  if (!modulePath) {
-    console.warn("[logic]", `找不到模块文件: ${src}`);
-    return;
-  }
-  const sourceCode = env.getContentByPath(modulePath);
-  if (!sourceCode) {
-    console.warn("[logic]", `无法读取模块文件: ${modulePath}`);
-    return;
-  }
-  let jsCode = sourceCode;
-  if (modulePath.endsWith(".ts")) {
-    try {
-      const result = ts.transpileModule(sourceCode, {
-        compilerOptions: {
-          target: ts.ScriptTarget.ES2020,
-          module: ts.ModuleKind.ESNext,
-          // 保持 ES6 模块语法，让 oxc-transform 后续处理
-          strict: false,
-          esModuleInterop: true,
-          skipLibCheck: true
-        }
-      });
-      jsCode = result.outputText;
-    } catch (error) {
-      console.error(`[logic] TypeScript 编译失败 ${modulePath}:`, error.message);
-      jsCode = sourceCode;
-    }
-  }
-  const parseResult = oxcParser.parseSync(modulePath, jsCode, {
-    sourceType: "module",
-    lang: modulePath.endsWith(".ts") ? "ts" : "js"
-  });
-  const ast = parseResult.program;
-  const s = new MagicString(jsCode);
-  const extraInfo = {
-    path: module2.path
-  };
-  if (module2.component) {
-    extraInfo.component = true;
-  }
-  if (module2.usingComponents) {
-    const componentsObj = {};
-    const allSubPackages = env.getAppConfigInfo().subPackages;
-    for (const [name, path2] of Object.entries(module2.usingComponents)) {
-      let toMainSubPackage = true;
-      if (packageName) {
-        const normalizedPath = path2.startsWith("/") ? path2.substring(1) : path2;
-        for (const subPackage of allSubPackages) {
-          if (normalizedPath.startsWith(`${subPackage.root}/`)) {
-            toMainSubPackage = false;
-            break;
-          }
-        }
-      } else {
-        toMainSubPackage = false;
-      }
-      const componentModule = env.getComponent(path2);
-      if (!componentModule) {
-        continue;
-      }
-      await buildJSByPath(packageName, componentModule, compileRes, mainCompileRes, true, depthChain, toMainSubPackage);
-      componentsObj[name] = path2;
-    }
-    extraInfo.usingComponents = componentsObj;
-  }
-  if (addExtra) {
-    const extraInfoCode = `globalThis.__extraInfo = ${JSON.stringify(extraInfo)};
-`;
-    s.prepend(extraInfoCode);
-  }
-  if (putMain) {
-    mainCompileRes.push(compileInfo);
-  } else {
-    compileRes.push(compileInfo);
-  }
-  const pathReplacements = [];
-  const dependenciesToProcess = [];
-  oxcWalker.walk(ast, {
-    enter(node, parent) {
-      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) {
-            let id;
-            if (requirePath.startsWith("@") || requirePath.startsWith("miniprogram_npm/")) {
-              if (requirePath.startsWith("@")) {
-                id = `/miniprogram_npm/${requirePath}`;
-              } else {
-                id = requirePath.startsWith("/") ? requirePath : `/${requirePath}`;
-              }
-            } else {
-              const requireFullPath = path.resolve(modulePath, `../${requirePath}`);
-              id = requireFullPath.split(`${env.getWorkPath()}${path.sep}`)[1];
-              id = id.replace(/\.(js|ts)$/, "").replace(/\\/g, "/");
-              if (!id.startsWith("/")) {
-                id = "/" + id;
-              }
-            }
-            {
-              pathReplacements.push({
-                start: arg.start,
-                end: arg.end,
-                newValue: id
-              });
-              if (!processedModules.has(packageName + id)) {
-                dependenciesToProcess.push(id);
-              }
-            }
-          }
-        }
-      }
-      if (node.type === "ImportDeclaration") {
-        const importPath = node.source.value;
-        if (importPath) {
-          let id;
-          let shouldProcess = false;
-          if (importPath.startsWith("@") || importPath.startsWith("miniprogram_npm/")) {
-            if (importPath.startsWith("@")) {
-              id = `/miniprogram_npm/${importPath}`;
-            } else {
-              id = importPath.startsWith("/") ? importPath : `/${importPath}`;
-            }
-            shouldProcess = true;
-          } else if (importPath.startsWith("./") || importPath.startsWith("../") || !importPath.startsWith("/")) {
-            const importFullPath = path.resolve(modulePath, `../${importPath}`);
-            id = importFullPath.split(`${env.getWorkPath()}${path.sep}`)[1];
-            id = id.replace(/\.(js|ts)$/, "").replace(/\\/g, "/");
-            if (!id.startsWith("/")) {
-              id = "/" + id;
-            }
-            shouldProcess = true;
-          } else {
-            id = importPath;
-            shouldProcess = true;
-          }
-          if (shouldProcess) {
-            pathReplacements.push({
-              start: node.source.start,
-              end: node.source.end,
-              newValue: id
-            });
-            if (!processedModules.has(packageName + id)) {
-              dependenciesToProcess.push(id);
-            }
-          }
-        }
-      }
-    }
-  });
-  for (const depId of dependenciesToProcess) {
-    await buildJSByPath(packageName, { path: depId }, compileRes, mainCompileRes, false, depthChain);
-  }
-  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 {
-      const result = oxcTransform.transformSync(modulePath, modifiedCode, {
-        sourceType: "module",
-        lang: modulePath.endsWith(".tsx") ? "tsx" : "ts",
-        target: "es2020",
-        typescript: {
-          onlyRemoveTypeImports: true
-        }
-      });
-      transformedCode = result.code;
-    } catch (error) {
-      console.error(`[logic] oxc-transform 转换失败 ${modulePath}:`, error.message);
-      transformedCode = modifiedCode;
-    }
-  }
-  try {
-    const esbuildResult = await esbuild.transform(transformedCode, {
-      format: "cjs",
-      target: "es2020",
-      platform: "neutral",
-      loader: "js"
-    });
-    const esbuildCode = esbuildResult.code;
-    const esbuildAst = oxcParser.parseSync(modulePath, esbuildCode, {
-      sourceType: "module",
-      lang: "js"
-    });
-    const postEsbuildReplacements = [];
-    oxcWalker.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("../"))) {
-              let id;
-              if (requirePath.startsWith("@") || requirePath.startsWith("miniprogram_npm/")) {
-                if (requirePath.startsWith("@")) {
-                  id = `/miniprogram_npm/${requirePath}`;
-                } else {
-                  id = requirePath.startsWith("/") ? requirePath : `/${requirePath}`;
-                }
-              } else {
-                const requireFullPath = path.resolve(modulePath, `../${requirePath}`);
-                id = requireFullPath.split(`${env.getWorkPath()}${path.sep}`)[1];
-                id = id.replace(/\.(js|ts)$/, "").replace(/\\/g, "/");
-                if (!id.startsWith("/")) {
-                  id = "/" + id;
-                }
-              }
-              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;
-    }
-  } catch (error) {
-    console.error(`[logic] esbuild 转换失败 ${modulePath}:`, error.message);
-    compileInfo.code = transformedCode;
-  }
-  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);
 }
+/**
+* 获取 JavaScript 或 TypeScript 文件的绝对路径
+* @param {string} modulePath - 模块路径
+* @returns {string|null} - 文件的绝对路径，如果找不到则返回 null
+*/
 function getJSAbsolutePath(modulePath) {
-  const workPath = env.getWorkPath();
-  const fileTypes = [".js", ".ts"];
-  for (const ext of fileTypes) {
-    const fullPath = `${workPath}${modulePath}${ext}`;
-    if (fs.existsSync(fullPath)) {
-      return fullPath;
-    }
-  }
-  return null;
+	const workPath = require_env.getWorkPath();
+	const resolvedModuleId = resolveModuleIdToExistingPath(modulePath);
+	if (!resolvedModuleId) return null;
+	for (const ext of [".js", ".ts"]) {
+		const fullPath = `${workPath}${resolvedModuleId}${ext}`;
+		if (node_fs.default.existsSync(fullPath)) return fullPath;
+	}
+	return null;
+}
+function resolveDependencyId(specifier, modulePath, allowAbsolute) {
+	if (!specifier) return {
+		id: specifier,
+		shouldProcess: false
+	};
+	if (specifier.startsWith("miniprogram_npm/")) {
+		const npmModuleId = normalizeModuleId(`/${specifier}`);
+		return {
+			id: resolveModuleIdToExistingPath(npmModuleId) || npmModuleId,
+			shouldProcess: true
+		};
+	}
+	if (specifier.startsWith("./") || specifier.startsWith("../")) return {
+		id: resolveRelativeModuleId(specifier, modulePath),
+		shouldProcess: true
+	};
+	if (specifier.startsWith("/")) return {
+		id: allowAbsolute ? normalizeModuleId(specifier) : resolveRelativeModuleId(specifier, modulePath),
+		shouldProcess: true
+	};
+	const aliasResolved = require_env.resolveAppAlias(specifier);
+	if (aliasResolved) return {
+		id: normalizeModuleId(aliasResolved),
+		shouldProcess: true
+	};
+	if (specifier.startsWith("@") || isBareModuleSpecifier(specifier)) {
+		const npmModuleId = resolveNpmModuleId(specifier, modulePath);
+		return {
+			id: npmModuleId || specifier,
+			shouldProcess: Boolean(npmModuleId)
+		};
+	}
+	return {
+		id: specifier,
+		shouldProcess: false
+	};
+}
+function isBareModuleSpecifier(specifier) {
+	return !specifier.startsWith(".") && !specifier.startsWith("/");
+}
+function resolveRelativeModuleId(specifier, modulePath) {
+	const relativeId = (0, node_path.resolve)(modulePath, `../${specifier}`).split(`${require_env.getWorkPath()}${node_path.sep}`)[1];
+	return normalizeModuleId(relativeId);
+}
+function normalizeModuleId(moduleId) {
+	let normalized = moduleId.replace(/\.(js|ts)$/, "").replace(/\\/g, "/");
+	if (!normalized.startsWith("/")) normalized = `/${normalized}`;
+	return normalized;
+}
+function resolveNpmModuleId(specifier, modulePath) {
+	const npmResolver = require_env.getNpmResolver();
+	if (!npmResolver) return null;
+	return npmResolver.resolveScriptModule(specifier, modulePath, resolveModuleIdToExistingPath);
+}
+function resolveModuleIdToExistingPath(moduleId) {
+	const normalizedModuleId = normalizeModuleId(moduleId);
+	const workPath = require_env.getWorkPath();
+	for (const ext of [".js", ".ts"]) if (node_fs.default.existsSync(`${workPath}${normalizedModuleId}${ext}`)) return normalizedModuleId;
+	for (const ext of [".js", ".ts"]) if (node_fs.default.existsSync(`${workPath}${normalizedModuleId}/index${ext}`)) return `${normalizedModuleId}/index`;
+	const packageJsonPath = `${workPath}${normalizedModuleId}/package.json`;
+	if (node_fs.default.existsSync(packageJsonPath)) try {
+		const packageInfo = JSON.parse(node_fs.default.readFileSync(packageJsonPath, "utf-8"));
+		for (const entryField of ["miniprogram", "main"]) if (typeof packageInfo[entryField] === "string" && packageInfo[entryField]) {
+			const resolvedEntry = resolveModuleIdToExistingPath(normalizeModuleId((0, node_path.resolve)(normalizedModuleId, packageInfo[entryField])));
+			if (resolvedEntry) return resolvedEntry;
+		}
+	} catch (error) {
+		console.warn("[logic]", `解析 package.json 失败: ${packageJsonPath}`, error.message);
+	}
+	return null;
 }
+//#endregion
 exports.buildJSByPath = buildJSByPath;
 exports.compileJS = compileJS;