@dimina/compiler 1.0.12-beta.9 → 1.0.12

package/dist/core/logic-compiler.js

@@ -1,23 +1,13 @@
 import fs from "node:fs";
 import { resolve, sep } from "node:path";
 import { isMainThread, parentPort } from "node:worker_threads";
-import babel from "@babel/core";
-import _traverse from "@babel/traverse";
-import types from "@babel/types";
+import { parseSync } from "oxc-parser";
+import { walk } from "oxc-walker";
+import { transformSync } from "oxc-transform";
+import MagicString from "magic-string";
 import { transform } from "esbuild";
 import ts from "typescript";
-import transformModulesCommonjs from "@babel/plugin-transform-modules-commonjs";
-import { r as resetStoreInfo, g as getTargetPath, i as hasCompileInfo, b as getContentByPath, j as getAppConfigInfo, a as getComponent, d as getWorkPath } from "../env-Csj3AHY4.js";
-const traverse = _traverse.default ? _traverse.default : _traverse;
-const BABEL_TRANSFORM_CONFIG = {
-  comments: false,
-  configFile: false,
-  babelrc: false,
-  plugins: [
-    // 将 ES6 import/export 转换为 CommonJS
-    transformModulesCommonjs
-  ]
-};
+import { r as resetStoreInfo, e as getTargetPath, i as hasCompileInfo, a as getContentByPath, j as getAppConfigInfo, g as getComponent, f as getWorkPath } from "../env-QQjdhY-G.js";
 const processedModules = /* @__PURE__ */ new Set();
 if (!isMainThread) {
   parentPort.on("message", async ({ pages, storeInfo }) => {
@@ -95,15 +85,15 @@ ${module.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, module, compileRes, mainCompileRes, addExtra, depthChain = [], putMain = false) {
+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(" -> ")}`);
@@ -141,7 +131,8 @@ function buildJSByPath(packageName, module, compileRes, mainCompileRes, addExtra
       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
@@ -153,16 +144,20 @@ function buildJSByPath(packageName, module, compileRes, mainCompileRes, addExtra
       jsCode = sourceCode;
     }
   }
-  const ast = babel.parseSync(jsCode);
-  const addedArgs = types.objectExpression([
-    types.objectProperty(types.identifier("path"), types.stringLiteral(module.path))
-  ]);
+  const parseResult = parseSync(modulePath, jsCode, {
+    sourceType: "module",
+    lang: modulePath.endsWith(".ts") ? "ts" : "js"
+  });
+  const ast = parseResult.program;
+  const s = new MagicString(jsCode);
+  const extraInfo = {
+    path: module.path
+  };
   if (module.component) {
-    const component = types.objectProperty(types.identifier("component"), types.booleanLiteral(true));
-    addedArgs.properties.push(component);
+    extraInfo.component = true;
   }
   if (module.usingComponents) {
-    const components = types.objectProperty(types.identifier("usingComponents"), types.objectExpression([]));
+    const componentsObj = {};
     const allSubPackages = getAppConfigInfo().subPackages;
     for (const [name, path] of Object.entries(module.usingComponents)) {
       let toMainSubPackage = true;
@@ -181,84 +176,184 @@ function buildJSByPath(packageName, module, compileRes, mainCompileRes, addExtra
       if (!componentModule) {
         continue;
       }
-      buildJSByPath(packageName, componentModule, compileRes, mainCompileRes, true, depthChain, toMainSubPackage);
-      const props = types.objectProperty(types.identifier(`'${name}'`), types.stringLiteral(path));
-      components.value.properties.push(props);
+      await buildJSByPath(packageName, componentModule, compileRes, mainCompileRes, true, depthChain, toMainSubPackage);
+      componentsObj[name] = path;
     }
-    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 = resolve(modulePath, `../${requirePath}`);
-          let id = requireFullPath.split(`${getWorkPath()}${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);
+  const pathReplacements = [];
+  const dependenciesToProcess = [];
+  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 = resolve(modulePath, `../${requirePath}`);
+              id = requireFullPath.split(`${getWorkPath()}${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);
+              }
+            }
           }
         }
       }
-    },
-    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 = resolve(modulePath, `../${importPath}`);
+            id = importFullPath.split(`${getWorkPath()}${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 = resolve(modulePath, `../${importPath}`);
-          id = importFullPath.split(`${getWorkPath()}${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);
-          if (!processedModules.has(packageName + id)) {
-            buildJSByPath(packageName, { path: id }, compileRes, mainCompileRes, false, depthChain);
+      }
+    }
+  });
+  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 = 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 transform(transformedCode, {
+      format: "cjs",
+      target: "es2020",
+      platform: "neutral",
+      loader: "js"
+    });
+    const esbuildCode = esbuildResult.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("../"))) {
+              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 = resolve(modulePath, `../${requirePath}`);
+                id = requireFullPath.split(`${getWorkPath()}${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;
     }
-  });
-  const { code } = babel.transformFromAstSync(ast, "", BABEL_TRANSFORM_CONFIG);
-  compileInfo.code = code;
+  } 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 getJSAbsolutePath(modulePath) {
   const workPath = getWorkPath();
   const fileTypes = [".js", ".ts"];

package/dist/core/style-compiler.cjs

@@ -186,17 +186,18 @@ async function enhanceCSS(module2) {
   });
   const cssCode = ast.toResult().css;
   const moduleId = module2.id;
-  const code = compilerSfc.compileStyle({
+  const scopedCode = compilerSfc.compileStyle({
     source: cssCode,
     id: moduleId,
     scoped: !!moduleId
   }).code;
-  const res = await postcss([autoprefixer({ overrideBrowserslist: ["cover 99.5%"] }), cssnano()]).process(code, {
-    from: void 0
-    // 未指定输入源文件路径
-  });
+  const cleanedCode = await removeBaseComponentScope(scopedCode, moduleId);
+  const res = await postcss([
+    autoprefixer({ overrideBrowserslist: ["cover 99.5%"] }),
+    cssnano()
+  ]).process(cleanedCode, { from: void 0 });
   const importCss = (await Promise.all(promises)).filter(Boolean).join("");
-  const result = importCss ? importCss + res.css : res.css;
+  const result = importCss + res.css;
   compileRes.set(module2.path, result);
   return result;
 }
@@ -210,6 +211,26 @@ function getAbsolutePath(modulePath) {
     }
   }
 }
+async function removeBaseComponentScope(css, moduleId) {
+  if (!moduleId) return css;
+  const ast = postcss.parse(css);
+  const scopeAttrName = `data-v-${moduleId}`;
+  ast.walkRules((rule) => {
+    const hasBaseComponent = env.tagWhiteList.some(
+      (tag) => rule.selector.includes(`.dd-${tag}`)
+    );
+    if (hasBaseComponent && rule.selector.includes(scopeAttrName)) {
+      rule.selector = selectorParser((selectors) => {
+        selectors.walkAttributes((attr) => {
+          if (attr.attribute === scopeAttrName) {
+            attr.remove();
+          }
+        });
+      }).processSync(rule.selector);
+    }
+  });
+  return ast.toResult().css;
+}
 function ensureImportSemicolons(css) {
   return css.replace(/@import[^;\n]*$/gm, (match) => {
     return match.endsWith(";") ? match : `${match};`;
@@ -221,3 +242,4 @@ function processHostSelector(selector, moduleId) {
 exports.compileSS = compileSS;
 exports.ensureImportSemicolons = ensureImportSemicolons;
 exports.processHostSelector = processHostSelector;
+exports.removeBaseComponentScope = removeBaseComponentScope;

package/dist/core/style-compiler.js

@@ -8,7 +8,7 @@ import less from "less";
 import postcss from "postcss";
 import selectorParser from "postcss-selector-parser";
 import * as sass from "sass";
-import { r as resetStoreInfo, g as getTargetPath, a as getComponent, b as getContentByPath, h as tagWhiteList, e as collectAssets, f as getAppId, d as getWorkPath, t as transformRpx } from "../env-Csj3AHY4.js";
+import { r as resetStoreInfo, e as getTargetPath, g as getComponent, a as getContentByPath, h as tagWhiteList, c as collectAssets, d as getAppId, f as getWorkPath, t as transformRpx } from "../env-QQjdhY-G.js";
 const fileType = [".wxss", ".ddss", ".less", ".scss", ".sass"];
 const compileRes = /* @__PURE__ */ new Map();
 if (!isMainThread) {
@@ -167,17 +167,18 @@ async function enhanceCSS(module) {
   });
   const cssCode = ast.toResult().css;
   const moduleId = module.id;
-  const code = compileStyle({
+  const scopedCode = compileStyle({
     source: cssCode,
     id: moduleId,
     scoped: !!moduleId
   }).code;
-  const res = await postcss([autoprefixer({ overrideBrowserslist: ["cover 99.5%"] }), cssnano()]).process(code, {
-    from: void 0
-    // 未指定输入源文件路径
-  });
+  const cleanedCode = await removeBaseComponentScope(scopedCode, moduleId);
+  const res = await postcss([
+    autoprefixer({ overrideBrowserslist: ["cover 99.5%"] }),
+    cssnano()
+  ]).process(cleanedCode, { from: void 0 });
   const importCss = (await Promise.all(promises)).filter(Boolean).join("");
-  const result = importCss ? importCss + res.css : res.css;
+  const result = importCss + res.css;
   compileRes.set(module.path, result);
   return result;
 }
@@ -191,6 +192,26 @@ function getAbsolutePath(modulePath) {
     }
   }
 }
+async function removeBaseComponentScope(css, moduleId) {
+  if (!moduleId) return css;
+  const ast = postcss.parse(css);
+  const scopeAttrName = `data-v-${moduleId}`;
+  ast.walkRules((rule) => {
+    const hasBaseComponent = tagWhiteList.some(
+      (tag) => rule.selector.includes(`.dd-${tag}`)
+    );
+    if (hasBaseComponent && rule.selector.includes(scopeAttrName)) {
+      rule.selector = selectorParser((selectors) => {
+        selectors.walkAttributes((attr) => {
+          if (attr.attribute === scopeAttrName) {
+            attr.remove();
+          }
+        });
+      }).processSync(rule.selector);
+    }
+  });
+  return ast.toResult().css;
+}
 function ensureImportSemicolons(css) {
   return css.replace(/@import[^;\n]*$/gm, (match) => {
     return match.endsWith(";") ? match : `${match};`;
@@ -202,5 +223,6 @@ function processHostSelector(selector, moduleId) {
 export {
   compileSS,
   ensureImportSemicolons,
-  processHostSelector
+  processHostSelector,
+  removeBaseComponentScope
 };