@dimina/compiler 1.0.12-beta.1 → 1.0.12-beta.11

package/dist/bin/index.cjs

@@ -5,7 +5,7 @@ const process = require("node:process");
 const chokidar = require("chokidar");
 const commander = require("commander");
 const index = require("../index.cjs");
-const version = "1.0.12-beta.0";
+const version = "1.0.12-beta.11";
 const pack = {
   version
 };

package/dist/bin/index.js

@@ -4,7 +4,7 @@ import process from "node:process";
 import chokidar from "chokidar";
 import { program } from "commander";
 import build from "../index.js";
-const version = "1.0.12-beta.0";
+const version = "1.0.12-beta.11";
 const pack = {
   version
 };

package/dist/core/logic-compiler.cjs

@@ -3,14 +3,13 @@ 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 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 transformModulesCommonjs = require("@babel/plugin-transform-modules-commonjs");
 const env = require("../env-Cmen1qwy.cjs");
-const traverse = _traverse.default ? _traverse.default : _traverse;
 const processedModules = /* @__PURE__ */ new Set();
 if (!node_worker_threads.isMainThread) {
   node_worker_threads.parentPort.on("message", async ({ pages, storeInfo }) => {
@@ -42,8 +41,10 @@ ${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: {
@@ -86,26 +87,31 @@ ${module2.code}
 async function compileJS(pages, root, mainCompileRes, progress) {
   const compileRes = [];
   if (!root) {
-    buildJSByPath(root, { path: "app" }, compileRes, mainCompileRes, false);
+    await buildJSByPath(root, { path: "app" }, compileRes, mainCompileRes, false);
   }
-  pages.forEach((page) => {
-    buildJSByPath(root, page, compileRes, mainCompileRes, true);
+  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) {
-  if (!module2.path) {
+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;
   }
-  const moduleKey = packageName + module2.path;
-  if (processedModules.has(moduleKey)) {
+  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;
   }
-  processedModules.add(moduleKey);
   const compileInfo = {
     path: module2.path,
     code: ""
@@ -127,7 +133,8 @@ function buildJSByPath(packageName, module2, compileRes, mainCompileRes, addExtr
       const result = ts.transpileModule(sourceCode, {
         compilerOptions: {
           target: ts.ScriptTarget.ES2020,
-          module: ts.ModuleKind.CommonJS,
+          module: ts.ModuleKind.ESNext,
+          // 保持 ES6 模块语法，让 oxc-transform 后续处理
           strict: false,
           esModuleInterop: true,
           skipLibCheck: true
@@ -139,16 +146,20 @@ function buildJSByPath(packageName, module2, compileRes, mainCompileRes, addExtr
       jsCode = sourceCode;
     }
   }
-  const ast = babel.parseSync(jsCode);
-  const addedArgs = types.objectExpression([
-    types.objectProperty(types.identifier("path"), types.stringLiteral(module2.path))
-  ]);
+  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) {
-    const component = types.objectProperty(types.identifier("component"), types.booleanLiteral(true));
-    addedArgs.properties.push(component);
+    extraInfo.component = true;
   }
   if (module2.usingComponents) {
-    const components = types.objectProperty(types.identifier("usingComponents"), types.objectExpression([]));
+    const componentsObj = {};
     const allSubPackages = env.getAppConfigInfo().subPackages;
     for (const [name, path2] of Object.entries(module2.usingComponents)) {
       let toMainSubPackage = true;
@@ -167,83 +178,183 @@ function buildJSByPath(packageName, module2, compileRes, mainCompileRes, addExtr
       if (!componentModule) {
         continue;
       }
-      buildJSByPath(packageName, componentModule, compileRes, mainCompileRes, true, toMainSubPackage);
-      const props = types.objectProperty(types.identifier(`'${name}'`), types.stringLiteral(path2));
-      components.value.properties.push(props);
+      await buildJSByPath(packageName, componentModule, compileRes, mainCompileRes, true, depthChain, toMainSubPackage);
+      componentsObj[name] = path2;
     }
-    addedArgs.properties.push(components);
+    extraInfo.usingComponents = componentsObj;
   }
   if (addExtra) {
-    ast.program.body.splice(0, 0, getExtraInfoStatement("this", addedArgs));
+    const extraInfoCode = `globalThis.__extraInfo = ${JSON.stringify(extraInfo)};
+`;
+    s.prepend(extraInfoCode);
   }
   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;
+  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);
+              }
+            }
           }
-          ap.node.arguments[0] = types.stringLiteral(id);
-          buildJSByPath(packageName, { path: id }, compileRes, mainCompileRes, false);
         }
       }
-    },
-    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}`;
+      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.startsWith("/") ? importPath : `/${importPath}`;
+            id = importPath;
+            shouldProcess = true;
           }
-          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;
+          if (shouldProcess) {
+            pathReplacements.push({
+              start: node.source.start,
+              end: node.source.end,
+              newValue: id
+            });
+            if (!processedModules.has(packageName + id)) {
+              dependenciesToProcess.push(id);
+            }
           }
-          shouldProcess = true;
-        } else {
-          id = importPath;
-          shouldProcess = true;
-        }
-        if (shouldProcess) {
-          ap.node.source = types.stringLiteral(id);
-          buildJSByPath(packageName, { path: id }, compileRes, mainCompileRes, false);
         }
       }
     }
   });
-  const { code } = babel.transformFromAstSync(ast, "", {
-    comments: false,
-    plugins: [
-      // 将 ES6 import/export 转换为 CommonJS
-      transformModulesCommonjs
-    ]
-  });
-  compileInfo.code = code;
-}
-function getExtraInfoStatement(type, addedArgs) {
-  const assignmentExpression = types.assignmentExpression(
-    "=",
-    types.memberExpression(types.identifier("globalThis"), types.identifier("__extraInfo")),
-    addedArgs
-  );
-  return types.expressionStatement(assignmentExpression);
+  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 getJSAbsolutePath(modulePath) {
   const workPath = env.getWorkPath();