@dimina-kit/compiler 0.0.2-dev.20260728080958 → 0.0.2

package/dist/pool.node-chunks/style-compiler-TUNDVSR5.js

@@ -0,0 +1,277 @@
+import {
+  isMainThread,
+  parentPort
+} from "./chunk-KLXXOLDF.js";
+import {
+  collectAssets,
+  getAppId,
+  getComponent,
+  getContentByPath,
+  getStyleExts,
+  getTargetPath,
+  getWorkPath,
+  resetStoreInfo,
+  tagWhiteList,
+  transformRpx
+} from "./chunk-7FGOYOXU.js";
+
+// ../../dimina/fe/packages/compiler/src/core/style-compiler.js
+import fs from "node:fs";
+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.existsSync(subDir)) {
+        fs.mkdirSync(subDir, { recursive: true });
+      }
+      fs.writeFileSync(`${subDir}/${filename}.css`, code);
+    } else {
+      const mainDir = `${getTargetPath()}/main`;
+      if (!fs.existsSync(mainDir)) {
+        fs.mkdirSync(mainDir, { recursive: true });
+      }
+      fs.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.existsSync(ssFullPath)) {
+      return ssFullPath;
+    }
+    const indexSsFullPath = `${workPath}${src}/index${ssType}`;
+    if (fs.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
+};