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

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

@@ -1,288 +0,0 @@
-import {
-  isMainThread,
-  parentPort
-} from "./chunk-KLXXOLDF.js";
-import {
-  collectAssets,
-  getAppId,
-  getComponent,
-  getContentByPath,
-  getStyleExts,
-  getTargetPath,
-  getWorkPath,
-  resetStoreInfo,
-  tagWhiteList,
-  transformRpx
-} from "./chunk-7F3E2G42.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, compiledPaths = /* @__PURE__ */ new Set()) {
-  let result = "";
-  const pendingModules = [module];
-  while (pendingModules.length > 0) {
-    const currentModule = pendingModules.pop();
-    const currentPath = currentModule.path || currentModule.absolutePath;
-    if (compiledPaths.has(currentPath)) {
-      continue;
-    }
-    compiledPaths.add(currentPath);
-    result += await enhanceCSS(currentModule) || "";
-    const componentPaths = Object.values(currentModule.usingComponents || {});
-    for (let index = componentPaths.length - 1; index >= 0; index--) {
-      const componentModule = getComponent(componentPaths[index]);
-      if (componentModule) {
-        pendingModules.push(componentModule);
-      }
-    }
-  }
-  return result;
-}
-function boostExternalClassSelectors(cssCode, moduleId) {
-  if (!moduleId || !cssCode) {
-    return cssCode;
-  }
-  const scopeAttribute = `data-v-${moduleId}`;
-  const externalScopeAttribute = "data-dd-external-class-scope";
-  const ast = postcss.parse(cssCode);
-  ast.walkRules((rule) => {
-    if (!rule.selector.includes(`[${scopeAttribute}]`)) {
-      return;
-    }
-    rule.selector = selectorParser((selectors) => {
-      for (const selector of [...selectors.nodes]) {
-        const boostedSelector = selector.clone();
-        const scopeNodes = [];
-        boostedSelector.walkAttributes((attribute) => {
-          if (attribute.attribute === scopeAttribute) {
-            scopeNodes.push(attribute);
-          }
-        });
-        const targetScope = scopeNodes.at(-1);
-        if (!targetScope) {
-          continue;
-        }
-        targetScope.parent.insertAfter(targetScope, selectorParser.attribute({
-          attribute: externalScopeAttribute,
-          operator: "~=",
-          quoteMark: '"',
-          value: scopeAttribute
-        }));
-        selectors.append(boostedSelector);
-      }
-    }).processSync(rule.selector);
-  });
-  return ast.toResult().css;
-}
-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 externalClassCode = boostExternalClassSelectors(scopedCode, moduleId);
-  const res = await postcss([
-    autoprefixer({ overrideBrowserslist: ["cover 99.5%"] }),
-    cssnano()
-  ]).process(externalClassCode, { 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}`;
-  });
-}
-function ensureImportSemicolons(css) {
-  return css.replace(/@import[^;\n]*$/gm, (match) => {
-    return match.endsWith(";") ? match : `${match};`;
-  });
-}
-function processHostSelector(selector, moduleId) {
-  const hostSelector = `[data-dd-style-host~="${moduleId}"]`;
-  return selector.replace(/:host\(([^)]+)\)/g, `${hostSelector}$1`).replace(/:host(?![\w-])/g, hostSelector);
-}
-function __resetStyleState() {
-  compileRes.clear();
-}
-export {
-  __resetStyleState,
-  boostExternalClassSelectors,
-  compileSS,
-  ensureImportSemicolons,
-  normalizeCssUrlValue,
-  normalizeRootStyleImports,
-  processHostSelector,
-  resolveStyleImportPath
-};