@dimina/compiler 1.0.12-beta.9 → 1.0.13

package/dist/core/logic-compiler.cjs

@@ -1,276 +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 babel = require("@babel/core");
-const _traverse = require("@babel/traverse");
-const types = require("@babel/types");
-const esbuild = require("esbuild");
-const ts = require("typescript");
-const transformModulesCommonjs = require("@babel/plugin-transform-modules-commonjs");
-const env = require("../env-Cmen1qwy.cjs");
-const traverse = _traverse.default ? _traverse.default : _traverse;
-const BABEL_TRANSFORM_CONFIG = {
-  comments: false,
-  configFile: false,
-  babelrc: false,
-  plugins: [
-    // 将 ES6 import/export 转换为 CommonJS
-    transformModulesCommonjs
-  ]
-};
-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-lm96AacS.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);
+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);
+let typescript = require("typescript");
+typescript = require_env.__toESM(typescript);
+//#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) {
-    buildJSByPath(root, { path: "app" }, compileRes, mainCompileRes, false);
-  }
-  pages.forEach((page) => {
-    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;
 }
-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.CommonJS,
-          strict: false,
-          esModuleInterop: true,
-          skipLibCheck: true
-        }
-      });
-      jsCode = result.outputText;
-    } catch (error) {
-      console.error(`[logic] TypeScript 编译失败 ${modulePath}:`, error.message);
-      jsCode = sourceCode;
-    }
-  }
-  const ast = babel.parseSync(jsCode);
-  const addedArgs = types.objectExpression([
-    types.objectProperty(types.identifier("path"), types.stringLiteral(module2.path))
-  ]);
-  if (module2.component) {
-    const component = types.objectProperty(types.identifier("component"), types.booleanLiteral(true));
-    addedArgs.properties.push(component);
-  }
-  if (module2.usingComponents) {
-    const components = types.objectProperty(types.identifier("usingComponents"), types.objectExpression([]));
-    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;
-      }
-      buildJSByPath(packageName, componentModule, compileRes, mainCompileRes, true, depthChain, toMainSubPackage);
-      const props = types.objectProperty(types.identifier(`'${name}'`), types.stringLiteral(path2));
-      components.value.properties.push(props);
-    }
-    addedArgs.properties.push(components);
-  }
-  if (addExtra) {
-    ast.program.body.splice(0, 0, getExtraInfoStatement("this", addedArgs));
-  }
-  if (putMain) {
-    mainCompileRes.push(compileInfo);
-  } else {
-    compileRes.push(compileInfo);
-  }
-  traverse(ast, {
-    CallExpression(ap) {
-      if (ap.node.callee.name === "require" || ap.node.callee.object?.name === "require") {
-        const requirePath = ap.node.arguments[0].value;
-        if (requirePath) {
-          const requireFullPath = path.resolve(modulePath, `../${requirePath}`);
-          let id = requireFullPath.split(`${env.getWorkPath()}${path.sep}`)[1];
-          id = id.replace(/\.(js|ts)$/, "").replace(/\\/g, "/");
-          if (!id.startsWith("/")) {
-            id = "/" + id;
-          }
-          ap.node.arguments[0] = types.stringLiteral(id);
-          if (!processedModules.has(packageName + id)) {
-            buildJSByPath(packageName, { path: id }, compileRes, mainCompileRes, false, depthChain);
-          }
-        }
-      }
-    },
-    ImportDeclaration(ap) {
-      const importPath = ap.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) {
-          ap.node.source = types.stringLiteral(id);
-          if (!processedModules.has(packageName + id)) {
-            buildJSByPath(packageName, { path: id }, compileRes, mainCompileRes, false, depthChain);
-          }
-        }
-      }
-    }
-  });
-  const { code } = babel.transformFromAstSync(ast, "", BABEL_TRANSFORM_CONFIG);
-  compileInfo.code = code;
-  processedModules.add(packageName + currentPath);
+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);
 }
-function getExtraInfoStatement(type, addedArgs) {
-  const propertyAssignment = types.objectProperty(types.identifier("__extraInfo"), addedArgs);
-  const assignmentExpression = types.assignmentExpression(
-    "=",
-    types.memberExpression(types.identifier("globalThis"), propertyAssignment.key),
-    propertyAssignment.value
-  );
-  return types.expressionStatement(assignmentExpression);
+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;