@fragments-sdk/cli 0.7.2 → 0.7.3

package/dist/{chunk-7KUSBMI4.js → chunk-QPY4DUFB.js}

@@ -1,4 +1,17 @@
 import { createRequire as __banner_createRequire } from 'module'; const require = __banner_createRequire(import.meta.url);
+import {
+  generateContextMd,
+  generateRegistry,
+  loadFragmentFile,
+  parseFragmentFile
+} from "./chunk-R6IZZSE7.js";
+import {
+  discoverBlockFiles,
+  discoverComponentFiles,
+  discoverFragmentFiles,
+  discoverTokenFiles,
+  extractComponentName
+} from "./chunk-D34Q6A7S.js";
 import {
   BrowserPool,
   CaptureEngine,
@@ -8,27 +21,18 @@ import {
   formatMs,
   generateHtmlReport,
   getGrade
-} from "./chunk-GKX2HPZ6.js";
-import {
-  discoverBlockFiles,
-  discoverComponentFiles,
-  discoverFragmentFiles,
-  discoverTokenFiles,
-  extractComponentName,
-  generateContextMd,
-  generateRegistry,
-  loadFragmentFile,
-  parseFragmentFile
-} from "./chunk-3T6QL7IY.js";
+} from "./chunk-YMPGYEWK.js";
 import {
   compileBlock,
   parseTokenFile
-} from "./chunk-OOGTG5FM.js";
+} from "./chunk-UXLGIGSX.js";
 import {
-  BRAND,
-  DEFAULTS,
   fragmentDefinitionSchema
-} from "./chunk-GHYYFAQN.js";
+} from "./chunk-P33AKQJW.js";
+import {
+  BRAND,
+  DEFAULTS
+} from "./chunk-EKLMXTWU.js";
 
 // src/validators.ts
 async function validateSchema(config, configDir) {
@@ -120,18 +124,110 @@ async function validateAll(config, configDir) {
 
 // src/build.ts
 import { readFile, writeFile, mkdir } from "fs/promises";
-import { resolve as resolve3, join as join3 } from "path";
-import { existsSync as existsSync3 } from "fs";
+import { resolve as resolve4, join as join3 } from "path";
+import { existsSync as existsSync4 } from "fs";
+
+// src/core/token-resolver.ts
+import { resolve, dirname, basename } from "path";
+import { existsSync, readdirSync } from "fs";
+function roundRgbValues(value) {
+  return value.replace(
+    /rgb\(([^)]+)\)/g,
+    (_full, inner) => {
+      const parts = inner.split(",").map((p) => p.trim());
+      const rounded = parts.map((p) => {
+        const num = parseFloat(p);
+        return isNaN(num) ? p : String(Math.round(num));
+      });
+      return `rgb(${rounded.join(", ")})`;
+    }
+  ).replace(
+    /rgba\(([^)]+)\)/g,
+    (_full, inner) => {
+      const parts = inner.split(",").map((p) => p.trim());
+      const rounded = parts.map((p, i) => {
+        if (i >= 3) return p;
+        const num = parseFloat(p);
+        return isNaN(num) ? p : String(Math.round(num));
+      });
+      return `rgba(${rounded.join(", ")})`;
+    }
+  );
+}
+async function resolveTokensWithSass(unresolvedTokens, tokensDir) {
+  const resolvedMap = /* @__PURE__ */ new Map();
+  const needsResolution = unresolvedTokens.filter(
+    (t) => t.value.includes("#{") || t.value.includes("$")
+  );
+  if (needsResolution.length === 0) {
+    return resolvedMap;
+  }
+  try {
+    const sass = await import("./sass.node-4XJK6YBF.js");
+    const variablesPath = findVariablesFile(tokensDir);
+    if (!variablesPath) {
+      return resolvedMap;
+    }
+    const fileName = basename(variablesPath);
+    const moduleName = fileName.replace(/^_/, "").replace(/\.scss$/, "");
+    const scssSource = `
+@use '${moduleName}' as vars;
+:root { @include vars.fui-css-variables; }
+`;
+    const compiled = sass.compileString(scssSource, {
+      loadPaths: [tokensDir, dirname(tokensDir)],
+      style: "expanded",
+      // Suppress sass deprecation warnings during build
+      logger: { warn() {
+      }, debug() {
+      } }
+    });
+    const cssVarRegex = /(--[\w-]+)\s*:\s*([^;]+)/g;
+    let match;
+    const allResolved = /* @__PURE__ */ new Map();
+    while ((match = cssVarRegex.exec(compiled.css)) !== null) {
+      allResolved.set(match[1], roundRgbValues(match[2].trim()));
+    }
+    for (const token of needsResolution) {
+      const value = allResolved.get(token.name);
+      if (value !== void 0) {
+        resolvedMap.set(token.name, value);
+      }
+    }
+  } catch {
+  }
+  return resolvedMap;
+}
+function findVariablesFile(tokensDir) {
+  const candidates = ["_variables.scss", "variables.scss"];
+  for (const name of candidates) {
+    const path = resolve(tokensDir, name);
+    if (existsSync(path)) {
+      return path;
+    }
+  }
+  try {
+    const files = readdirSync(tokensDir).filter((f) => f.endsWith(".scss"));
+    for (const file of files) {
+      const path = resolve(tokensDir, file);
+      if (file.includes("variables") || file.includes("tokens")) {
+        return path;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
 
 // src/core/auto-props.ts
-import { existsSync, statSync } from "fs";
-import { dirname, extname, join, resolve } from "path";
+import { existsSync as existsSync2, statSync } from "fs";
+import { dirname as dirname2, extname, join, resolve as resolve2 } from "path";
 import ts from "typescript";
 function toPosixPath(filePath) {
   return filePath.replace(/\\/g, "/");
 }
 function isFile(filePath) {
-  if (!existsSync(filePath)) return false;
+  if (!existsSync2(filePath)) return false;
   try {
     return statSync(filePath).isFile();
   } catch {
@@ -157,7 +253,7 @@ function resolveModulePath(basePath) {
   }
   for (const candidate of candidates) {
     if (isFile(candidate)) {
-      return resolve(candidate);
+      return resolve2(candidate);
     }
   }
   return null;
@@ -165,8 +261,8 @@ function resolveModulePath(basePath) {
 function resolveComponentSourcePath(fragmentFileAbsolutePath, componentImportPath) {
   if (!componentImportPath) return null;
   if (!componentImportPath.startsWith(".")) return null;
-  const fragmentDir = dirname(fragmentFileAbsolutePath);
-  const basePath = resolve(fragmentDir, componentImportPath);
+  const fragmentDir = dirname2(fragmentFileAbsolutePath);
+  const basePath = resolve2(fragmentDir, componentImportPath);
   return resolveModulePath(basePath);
 }
 function collectTopLevelDeclarations(sourceFile) {
@@ -354,8 +450,8 @@ function resolveComponentSignature(exportName, declarations, sourceFile) {
 }
 function extractCustomPropsFromComponentFile(componentFilePath, exportName) {
   const warnings = [];
-  const resolvedPath = resolve(componentFilePath);
-  if (!existsSync(resolvedPath)) {
+  const resolvedPath = resolve2(componentFilePath);
+  if (!existsSync2(resolvedPath)) {
     return {
       props: {},
       warnings: [`Component file not found: ${resolvedPath}`],
@@ -431,9 +527,9 @@ function extractCustomPropsFromComponentFile(componentFilePath, exportName) {
 
 // src/core/graph-extractor.ts
 import ts2 from "typescript";
-import { readFileSync, existsSync as existsSync2 } from "fs";
+import { readFileSync, existsSync as existsSync3 } from "fs";
 import { join as join2 } from "path";
-import { readdirSync } from "fs";
+import { readdirSync as readdirSync2 } from "fs";
 import { EDGE_TYPE_WEIGHTS, computeHealthFromData } from "@fragments-sdk/context/graph";
 async function buildComponentGraph(fragments, blocks, componentDir, options) {
   const knownComponents = new Set(Object.keys(fragments));
@@ -790,12 +886,12 @@ function findComponentIndex(componentDir, componentName) {
     join2(componentDir, componentName, `${componentName}.ts`)
   ];
   for (const candidate of candidates) {
-    if (existsSync2(candidate)) {
+    if (existsSync3(candidate)) {
       return candidate;
     }
   }
   try {
-    const entries = readdirSync(componentDir, { withFileTypes: true });
+    const entries = readdirSync2(componentDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory() && entry.name === componentName) {
         const subCandidates = [
@@ -803,7 +899,7 @@ function findComponentIndex(componentDir, componentName) {
           join2(componentDir, entry.name, "index.ts")
         ];
         for (const sc of subCandidates) {
-          if (existsSync2(sc)) return sc;
+          if (existsSync3(sc)) return sc;
         }
       }
     }
@@ -988,38 +1084,71 @@ async function buildFragments(config, configDir) {
       const mergedCategories = {};
       let prefix = "--";
       let total = 0;
+      const fileContents = [];
       for (const file of tokenFiles) {
         const content = await readFile(file.absolutePath, "utf-8");
-        const parsed = parseTokenFile(content, file.relativePath);
-        prefix = parsed.prefix;
-        total += parsed.total;
-        for (const [cat, catTokens] of Object.entries(parsed.categories)) {
+        fileContents.push({ content, path: file.relativePath });
+      }
+      const allContent = fileContents.map((f) => f.content).join("\n");
+      for (const { content, path } of fileContents) {
+        const parsed = parseTokenFile(allContent, path);
+        const fileParsed = parseTokenFile(content, path);
+        prefix = fileParsed.prefix;
+        total += fileParsed.total;
+        for (const [cat, catTokens] of Object.entries(fileParsed.categories)) {
           if (!mergedCategories[cat]) {
             mergedCategories[cat] = [];
           }
           for (const t of catTokens) {
             if (!mergedCategories[cat].some((e) => e.name === t.name)) {
-              mergedCategories[cat].push({ name: t.name, ...t.value && { value: t.value }, description: t.description });
+              const combinedToken = Object.values(parsed.categories).flat().find((ct) => ct.name === t.name);
+              const resolvedValue = combinedToken?.resolvedValue ?? t.resolvedValue;
+              mergedCategories[cat].push({
+                name: t.name,
+                ...resolvedValue ? { value: resolvedValue } : t.value ? { value: t.value } : {},
+                description: t.description
+              });
             }
           }
         }
       }
       if (total > 0) {
+        const allTokens = Object.values(mergedCategories).flat();
+        const unresolved = allTokens.filter(
+          (t) => t.value && (t.value.includes("#{") || t.value.includes("$"))
+        );
+        if (unresolved.length > 0 && tokenFiles.length > 0) {
+          const tokensDir = resolve4(configDir, tokenFiles[0].relativePath, "..");
+          const sassResolved = await resolveTokensWithSass(
+            unresolved,
+            tokensDir
+          );
+          if (sassResolved.size > 0) {
+            for (const catTokens of Object.values(mergedCategories)) {
+              for (const token of catTokens) {
+                const resolved = sassResolved.get(token.name);
+                if (resolved && token.value && (token.value.includes("#{") || token.value.includes("$"))) {
+                  token.value = resolved;
+                }
+              }
+            }
+          }
+        }
         tokens = { prefix, total, categories: mergedCategories };
       }
     }
   } catch {
   }
   let packageName;
-  const pkgJsonPath = resolve3(configDir, "package.json");
-  if (existsSync3(pkgJsonPath)) {
+  const pkgJsonPath = resolve4(configDir, "package.json");
+  if (existsSync4(pkgJsonPath)) {
     try {
       const pkg = JSON.parse(await readFile(pkgJsonPath, "utf-8"));
       if (pkg.name) packageName = pkg.name;
     } catch {
     }
   }
-  const componentDir = resolve3(configDir, "src", "components");
+  const componentDir = resolve4(configDir, "src", "components");
   let graphData;
   try {
     const graphResult = await buildComponentGraph(fragments, blocks, componentDir);
@@ -1059,7 +1188,7 @@ async function buildFragments(config, configDir) {
     ...tokens && { tokens },
     ...graphData && { graph: graphData }
   };
-  const outputPath = resolve3(configDir, config.outFile ?? BRAND.outFile);
+  const outputPath = resolve4(configDir, config.outFile ?? BRAND.outFile);
   await writeFile(outputPath, JSON.stringify(output));
   return {
     success: errors.length === 0,
@@ -1450,9 +1579,9 @@ ${BRAND.name} Diff
 }
 
 // src/analyze.ts
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { join as join4, dirname as dirname2 } from "path";
+import { join as join4, dirname as dirname3 } from "path";
 import pc3 from "picocolors";
 async function runAnalyzeCommand(config, configDir, options = {}) {
   const format = options.format ?? "html";
@@ -1461,7 +1590,7 @@ async function runAnalyzeCommand(config, configDir, options = {}) {
 ${BRAND.name} Analyzer
 `));
   const fragmentsPath = join4(configDir, config.outFile ?? "fragments.json");
-  if (!existsSync4(fragmentsPath)) {
+  if (!existsSync5(fragmentsPath)) {
     console.log(pc3.red(`\u2717 No fragments.json found. Run \`${BRAND.cliCommand} build\` first.
 `));
     return {
@@ -1477,7 +1606,7 @@ ${BRAND.name} Analyzer
   let outputPath;
   if (format === "html" || format === "json") {
     outputPath = options.output ?? getDefaultOutputPath(format, configDir);
-    await mkdir2(dirname2(outputPath), { recursive: true });
+    await mkdir2(dirname3(outputPath), { recursive: true });
     if (format === "html") {
       const html = generateHtmlReport(analytics);
       await writeFile2(outputPath, html);
@@ -1624,4 +1753,4 @@ export {
   runDiffCommand,
   runAnalyzeCommand
 };
-//# sourceMappingURL=chunk-7KUSBMI4.js.map
+//# sourceMappingURL=chunk-QPY4DUFB.js.map