@dimina-kit/compiler 0.0.2-dev.20260728065133 → 0.0.2-dev.20260728095034

package/dist/compile-core.node-chunks/{logic-compiler-AEZPY2MO.js → logic-compiler-2SQFOFEO.js}

@@ -1,14 +1,11 @@
 import {
   getWxMemberName,
-  takeCompatibilityWarnings,
   warnUnsupportedWxApi
-} from "./chunk-QYHGF3MS.js";
+} from "./chunk-LUD2P6RM.js";
 import {
   isMainThread,
-  mergeSourcemap,
-  parentPort,
-  remapSourcemap
-} from "./chunk-23PCGQQU.js";
+  parentPort
+} from "./chunk-2VRS523Z.js";
 import {
   collectAssets,
   fs_default,
@@ -16,15 +13,13 @@ import {
   getAppId,
   getComponent,
   getContentByPath,
-  getDependencyGraph,
   getNpmResolver,
   getTargetPath,
   getWorkPath,
   hasCompileInfo,
   resetStoreInfo,
-  resolveAppAlias,
-  resolveAssetSourcePath
-} from "./chunk-M62ZDT7T.js";
+  resolveAppAlias
+} from "./chunk-QJ34C5KK.js";
 
 // ../../dimina/fe/packages/compiler/src/core/logic-compiler.js
 import { resolve, sep } from "node:path";
@@ -32,6 +27,102 @@ import { parseSync } from "oxc-parser";
 import { walk } from "oxc-walker";
 import MagicString from "magic-string";
 import { transform } from "esbuild";
+
+// ../../dimina/fe/packages/compiler/src/core/sourcemap.js
+import { SourceMapConsumer, SourceMapGenerator } from "source-map-js";
+function wrapModDefine(module) {
+  const code = module.code.endsWith("\n") ? module.code : module.code + "\n";
+  const extraLine = module.extraInfoCode || "";
+  const header = `modDefine('${module.path}', function(require, module, exports) {
+${extraLine}`;
+  const footer = "});\n";
+  return { header, code, footer };
+}
+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);
+      const smc = new SourceMapConsumer(moduleMap);
+      smc.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);
+  const nextSmc = new SourceMapConsumer(nextMapObj);
+  nextSmc.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();
+}
+
+// ../../dimina/fe/packages/compiler/src/core/logic-compiler.js
 var processedModules = /* @__PURE__ */ new Set();
 var enableSourcemap = false;
 if (!isMainThread) {
@@ -66,11 +157,7 @@ ${error.stack}`);
       }
       await writeCompileRes(mainCompileRes, null);
       processedModules.clear();
-      parentPort.postMessage({
-        success: true,
-        compatibilityWarnings: takeCompatibilityWarnings(),
-        dependencyGraph: getDependencyGraph().toJSON()
-      });
+      parentPort.postMessage({ success: true });
     } catch (error) {
       processedModules.clear();
       parentPort.postMessage({
@@ -123,12 +210,18 @@ async function compileJS(pages, root, mainCompileRes, progress) {
   }
   return compileRes;
 }
-async function buildJSByPath(packageName, module, compileRes, mainCompileRes, addExtra, activePaths = /* @__PURE__ */ new Set(), putMain = false) {
+async function buildJSByPath(packageName, module, compileRes, mainCompileRes, addExtra, depthChain = [], putMain = false) {
   const currentPath = module.path;
-  if (!currentPath) {
+  if (depthChain.includes(currentPath)) {
+    console.warn("[logic]", `\u68C0\u6D4B\u5230\u5FAA\u73AF\u4F9D\u8D56: ${[...depthChain, currentPath].join(" -> ")}`);
     return;
   }
-  if (activePaths.has(currentPath)) {
+  if (depthChain.length > 20) {
+    console.warn("[logic]", `\u68C0\u6D4B\u5230\u6DF1\u5EA6\u4F9D\u8D56: ${[...depthChain, currentPath].join(" -> ")}`);
+    return;
+  }
+  depthChain = [...depthChain, currentPath];
+  if (!module.path) {
     return;
   }
   if (hasCompileInfo(module.path, compileRes, mainCompileRes)) {
@@ -145,7 +238,6 @@ async function buildJSByPath(packageName, module, compileRes, mainCompileRes, ad
     console.warn("[logic]", `\u627E\u4E0D\u5230\u6A21\u5757\u6587\u4EF6: ${src}`);
     return;
   }
-  getDependencyGraph().addFile(currentPath, modulePath, "logic");
   const diagnosticSource = modulePath.startsWith(getWorkPath()) ? modulePath.slice(getWorkPath().length) : src;
   const sourceCode = getContentByPath(modulePath);
   if (!sourceCode) {
@@ -166,19 +258,13 @@ async function buildJSByPath(packageName, module, compileRes, mainCompileRes, ad
   const extraInfo = {
     path: module.path
   };
-  activePaths.add(currentPath);
   if (module.component) {
     extraInfo.component = true;
   }
   if (module.usingComponents) {
     const componentsObj = {};
     const allSubPackages = getAppConfigInfo().subPackages;
-    const graphDependencies = getDependencyGraph().getDirectDependencies(module.path, "component");
-    const componentDependencies = graphDependencies.length > 0 ? new Set(graphDependencies) : null;
     for (const [name, path] of Object.entries(module.usingComponents)) {
-      if (componentDependencies && !componentDependencies.has(path)) {
-        continue;
-      }
       let toMainSubPackage = true;
       if (packageName) {
         const normalizedPath = path.startsWith("/") ? path.substring(1) : path;
@@ -195,7 +281,7 @@ async function buildJSByPath(packageName, module, compileRes, mainCompileRes, ad
       if (!componentModule) {
         continue;
       }
-      await buildJSByPath(packageName, componentModule, compileRes, mainCompileRes, true, activePaths, putMain || toMainSubPackage);
+      await buildJSByPath(packageName, componentModule, compileRes, mainCompileRes, true, depthChain, putMain || toMainSubPackage);
       componentsObj[name] = path;
     }
     extraInfo.usingComponents = componentsObj;
@@ -227,11 +313,6 @@ async function buildJSByPath(packageName, module, compileRes, mainCompileRes, ad
         );
       }
       if ((node.type === "StringLiteral" || node.type === "Literal") && isLocalAssetString(node.value)) {
-        getDependencyGraph().addFile(
-          currentPath,
-          resolveAssetSourcePath(getWorkPath(), modulePath, node.value),
-          "logic"
-        );
         pathReplacements.push({
           start: node.start,
           end: node.end,
@@ -247,7 +328,6 @@ async function buildJSByPath(packageName, module, compileRes, mainCompileRes, ad
           if (requirePath) {
             const { id, shouldProcess } = resolveDependencyId(requirePath, modulePath, false);
             if (shouldProcess) {
-              getDependencyGraph().addDependency(currentPath, id, "logic");
               pathReplacements.push({
                 start: arg.start,
                 end: arg.end,
@@ -265,7 +345,6 @@ async function buildJSByPath(packageName, module, compileRes, mainCompileRes, ad
         if (importPath) {
           const { id, shouldProcess } = resolveDependencyId(importPath, modulePath, true);
           if (shouldProcess) {
-            getDependencyGraph().addDependency(currentPath, id, "logic");
             pathReplacements.push({
               start: node.source.start,
               end: node.source.end,
@@ -283,7 +362,6 @@ async function buildJSByPath(packageName, module, compileRes, mainCompileRes, ad
         if (importPath) {
           const { id, shouldProcess } = resolveDependencyId(importPath, modulePath, false);
           if (shouldProcess) {
-            getDependencyGraph().addDependency(currentPath, id, "logic");
             pathReplacements.push({
               start: importPathNode.start,
               end: importPathNode.end,
@@ -300,7 +378,6 @@ async function buildJSByPath(packageName, module, compileRes, mainCompileRes, ad
         if (exportPath) {
           const { id, shouldProcess } = resolveDependencyId(exportPath, modulePath, true);
           if (shouldProcess) {
-            getDependencyGraph().addDependency(currentPath, id, "logic");
             pathReplacements.push({
               start: node.source.start,
               end: node.source.end,
@@ -315,7 +392,7 @@ async function buildJSByPath(packageName, module, compileRes, mainCompileRes, ad
     }
   });
   for (const depId of dependenciesToProcess) {
-    await buildJSByPath(packageName, { path: depId }, compileRes, mainCompileRes, false, activePaths, putMain);
+    await buildJSByPath(packageName, { path: depId }, compileRes, mainCompileRes, false, depthChain, putMain);
   }
   for (const replacement of pathReplacements.reverse()) {
     s.overwrite(replacement.start, replacement.end, `'${replacement.newValue}'`);
@@ -356,7 +433,6 @@ async function buildJSByPath(packageName, module, compileRes, mainCompileRes, ad
     compileInfo.code = modifiedCode;
   }
   processedModules.add(packageName + currentPath);
-  activePaths.delete(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);

package/dist/compile-core.node-chunks/style-compiler-ZEJ3XLTS.js

@@ -0,0 +1,277 @@
+import {
+  isMainThread,
+  parentPort
+} from "./chunk-2VRS523Z.js";
+import {
+  collectAssets,
+  fs_default,
+  getAppId,
+  getComponent,
+  getContentByPath,
+  getStyleExts,
+  getTargetPath,
+  getWorkPath,
+  resetStoreInfo,
+  tagWhiteList,
+  transformRpx
+} from "./chunk-QJ34C5KK.js";
+
+// ../../dimina/fe/packages/compiler/src/core/style-compiler.js
+import path from "node:path";
+import { compileStyle } from "@vue/compiler-sfc";
+import autoprefixer from "autoprefixer";
+import cssnano from "cssnano";
+import less from "less";
+import postcss from "postcss";
+import selectorParser from "postcss-selector-parser";
+import * as sass from "sass";
+var compileRes = /* @__PURE__ */ new Map();
+if (!isMainThread) {
+  parentPort.on("message", async ({ pages, storeInfo }) => {
+    try {
+      resetStoreInfo(storeInfo);
+      const progress = {
+        _completedTasks: 0,
+        get completedTasks() {
+          return this._completedTasks;
+        },
+        set completedTasks(value) {
+          this._completedTasks = value;
+          parentPort.postMessage({ completedTasks: this._completedTasks });
+        }
+      };
+      await compileSS(pages.mainPages, null, progress);
+      for (const [root, subPages] of Object.entries(pages.subPages)) {
+        await compileSS(subPages.info, root, progress);
+      }
+      compileRes.clear();
+      parentPort.postMessage({ success: true });
+    } catch (error) {
+      compileRes.clear();
+      parentPort.postMessage({
+        success: false,
+        error: {
+          message: error.message,
+          stack: error.stack,
+          name: error.name
+        }
+      });
+    }
+  });
+}
+async function compileSS(pages, root, progress) {
+  for (const page of pages) {
+    const code = await buildCompileCss(page, [], /* @__PURE__ */ new Set()) || "";
+    const filename = `${page.path.replace(/\//g, "_")}`;
+    if (root) {
+      const subDir = `${getTargetPath()}/${root}`;
+      if (!fs_default.existsSync(subDir)) {
+        fs_default.mkdirSync(subDir, { recursive: true });
+      }
+      fs_default.writeFileSync(`${subDir}/${filename}.css`, code);
+    } else {
+      const mainDir = `${getTargetPath()}/main`;
+      if (!fs_default.existsSync(mainDir)) {
+        fs_default.mkdirSync(mainDir, { recursive: true });
+      }
+      fs_default.writeFileSync(`${mainDir}/${filename}.css`, code);
+    }
+    progress.completedTasks++;
+  }
+}
+async function buildCompileCss(module, depthChain = [], compiledPaths = /* @__PURE__ */ new Set()) {
+  const currentPath = module.path || module.absolutePath;
+  if (depthChain.includes(currentPath)) {
+    console.warn("[style]", `\u68C0\u6D4B\u5230\u5FAA\u73AF\u4F9D\u8D56: ${[...depthChain, currentPath].join(" -> ")}`);
+    return "";
+  }
+  if (depthChain.length > 20) {
+    console.warn("[style]", `\u68C0\u6D4B\u5230\u6DF1\u5EA6\u4F9D\u8D56: ${[...depthChain, currentPath].join(" -> ")}`);
+    return "";
+  }
+  if (compiledPaths.has(currentPath)) {
+    return "";
+  }
+  compiledPaths.add(currentPath);
+  depthChain = [...depthChain, currentPath];
+  let result = await enhanceCSS(module) || "";
+  if (module.usingComponents) {
+    for (const componentInfo of Object.values(module.usingComponents)) {
+      const componentModule = getComponent(componentInfo);
+      if (!componentModule) {
+        continue;
+      }
+      result += await buildCompileCss(componentModule, depthChain, compiledPaths) || "";
+    }
+  }
+  return result;
+}
+async function enhanceCSS(module) {
+  const absolutePath = module.absolutePath ? module.absolutePath : getAbsolutePath(module.path);
+  if (!absolutePath) {
+    return "";
+  }
+  const cacheKey = `${absolutePath}::${module.id || ""}`;
+  const inputCSS = getContentByPath(absolutePath);
+  if (!inputCSS) {
+    return "";
+  }
+  if (compileRes.has(cacheKey)) {
+    return compileRes.get(cacheKey);
+  }
+  let processedCSS = normalizeRootStyleImports(inputCSS);
+  const ext = path.extname(absolutePath).toLowerCase();
+  try {
+    if (ext === ".less") {
+      const result2 = await less.render(processedCSS, {
+        filename: absolutePath,
+        paths: [path.dirname(absolutePath), getWorkPath()]
+      });
+      processedCSS = result2.css;
+    } else if (ext === ".scss" || ext === ".sass") {
+      const result2 = sass.compileString(processedCSS, {
+        loadPaths: [path.dirname(absolutePath), getWorkPath()],
+        syntax: ext === ".sass" ? "indented" : "scss"
+      });
+      processedCSS = result2.css;
+    }
+  } catch (error) {
+    console.error(`[style] \u9884\u5904\u7406\u5668\u7F16\u8BD1\u5931\u8D25 ${absolutePath}:`, error.message);
+    processedCSS = inputCSS;
+  }
+  const fixedCSS = ensureImportSemicolons(processedCSS);
+  let ast;
+  try {
+    ast = postcss.parse(fixedCSS);
+  } catch (error) {
+    console.error(`[style] PostCSS \u89E3\u6790\u5931\u8D25 ${absolutePath}:`, error.message);
+    return "";
+  }
+  const promises = [];
+  ast.walk(async (node) => {
+    if (node.type === "atrule" && node.name === "import") {
+      const str = node.params.replace(/^['"]|['"]$/g, "");
+      const importFullPath = resolveStyleImportPath(absolutePath, str);
+      node.remove();
+      promises.push(buildCompileCss({ absolutePath: importFullPath, id: module.id }, [], /* @__PURE__ */ new Set()));
+    } else if (node.type === "rule") {
+      if (node.selector.includes("::v-deep")) {
+        node.selector = node.selector.replace(/::v-deep\s+(\S[^{]*)/g, ":deep($1)");
+      }
+      if (node.selector.includes(":host")) {
+        node.selector = processHostSelector(node.selector, module.id);
+      }
+      node.selector = selectorParser((selectors) => {
+        selectors.walkTags((tag) => {
+          if (tagWhiteList.includes(tag.value)) {
+            tag.value = `.dd-${tag.value}`;
+          }
+        });
+      }).processSync(node.selector);
+    } else if (node.type === "comment") {
+      node.remove();
+    }
+  });
+  ast.walkDecls((decl) => {
+    decl.value = normalizeCssUrlValue(decl.value, absolutePath);
+    decl.value = transformRpx(decl.value);
+  });
+  const cssCode = ast.toResult().css;
+  const moduleId = module.id;
+  const scopedCode = compileStyle({
+    source: cssCode,
+    id: moduleId,
+    scoped: !!moduleId
+  }).code;
+  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 + res.css;
+  compileRes.set(cacheKey, result);
+  return result;
+}
+function normalizeCssUrlValue(value, absolutePath) {
+  return value.replace(/url\(([^)]+)\)/g, (fullMatch, rawUrl) => {
+    const cleanedUrl = rawUrl.trim().replace(/^['"]|['"]$/g, "");
+    if (!cleanedUrl || cleanedUrl.startsWith("data:image")) {
+      return fullMatch;
+    }
+    if (cleanedUrl.startsWith("//")) {
+      return `url(https:${cleanedUrl})`;
+    }
+    if (/^(https?:|blob:|data:)/.test(cleanedUrl)) {
+      return fullMatch;
+    }
+    const realSrc = collectAssets(getWorkPath(), absolutePath, cleanedUrl, getTargetPath(), getAppId());
+    return `url(${realSrc})`;
+  });
+}
+function getAbsolutePath(modulePath) {
+  const workPath = getWorkPath();
+  const src = modulePath.startsWith("/") ? modulePath : `/${modulePath}`;
+  for (const ssType of getStyleExts()) {
+    const ssFullPath = `${workPath}${src}${ssType}`;
+    if (fs_default.existsSync(ssFullPath)) {
+      return ssFullPath;
+    }
+    const indexSsFullPath = `${workPath}${src}/index${ssType}`;
+    if (fs_default.existsSync(indexSsFullPath)) {
+      return indexSsFullPath;
+    }
+  }
+}
+function resolveStyleImportPath(absolutePath, importPath, workPath = getWorkPath()) {
+  if (importPath.startsWith("/")) {
+    return path.join(workPath, importPath);
+  }
+  return path.resolve(path.dirname(absolutePath), importPath);
+}
+function normalizeRootStyleImports(source, workPath = getWorkPath()) {
+  return source.replace(/(@import\s+(?:\(.*?\)\s*)?(?:url\()?['"])(\/[^'")]+)(['"]\)?)/g, (_, prefix, importPath, suffix) => {
+    return `${prefix}${path.join(workPath, importPath)}${suffix}`;
+  });
+}
+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};`;
+  });
+}
+function processHostSelector(selector, moduleId) {
+  return selector.replace(/^:host$/, `[data-v-${moduleId}]`).replace(/:host\(([^)]+)\)/g, `[data-v-${moduleId}]$1`).replace(/:host\s+/g, `[data-v-${moduleId}] `).replace(/:host(?=\.|#|:)/g, `[data-v-${moduleId}]`);
+}
+function __resetStyleState() {
+  compileRes.clear();
+}
+export {
+  __resetStyleState,
+  compileSS,
+  ensureImportSemicolons,
+  normalizeCssUrlValue,
+  normalizeRootStyleImports,
+  processHostSelector,
+  removeBaseComponentScope,
+  resolveStyleImportPath
+};