rainbowindex 0.2.2 → 0.4.0

package/dist/{chunk-CUUW2K35.mjs → chunk-TLR6RP5L.mjs}

@@ -1,18 +1,14 @@
 import {
-  collectProjectClasses,
-  finalizeProjectCompilation,
-  resolveGoogleFonts,
-  validateGlobPattern
-} from "./chunk-FHATRQMN.mjs";
+  compileScannedProject
+} from "./chunk-4SVFFDS2.mjs";
 import {
   APPLY_ALIASES,
-  DEFAULT_PROPERTY_GROUP,
   DIRECTIVE_NAMES_SET,
   MAX_DIRECTIVE_INPUT_SIZE,
-  PROPERTY_GROUPS,
   RI_IMPORT_SPECIFIER_ALTERNATION,
-  analyzeProjectCSS,
+  applyVariantWrappers,
   compileCSSFunctions,
+  computeSortKey,
   expandVariantGroups,
   forEachApplyClass,
   getCustomUtility,
@@ -22,17 +18,18 @@ import {
   parseUtility,
   pushWarningsDeduped,
   resolveUtilityDeclarations,
-  resolveVariant
-} from "./chunk-W6XIBM4M.mjs";
+  resolveVariant,
+  splitSelectorList
+} from "./chunk-6DAHUFNU.mjs";
 
 // src/integrations/postcss/index.ts
-import postcss from "postcss";
+import postcss2 from "postcss";
 import { isAbsolute } from "path";
 
 // src/integrations/postcss/apply.ts
+import postcss from "postcss";
 function makeDeclGroup(r) {
-  const firstProp = r.declarations[0]?.property ?? "";
-  const sortKey = PROPERTY_GROUPS[firstProp] ?? DEFAULT_PROPERTY_GROUP;
+  const sortKey = computeSortKey(r.declarations[0]?.property ?? "");
   return {
     sortKey,
     decls: r.declarations.map((d) => ({ decl: d, important: r.important }))
@@ -46,11 +43,8 @@ function flattenGroups(groups) {
 }
 var MAX_APPLY_DEPTH = 5;
 var MAX_APPLY_CLASSES = 500;
-function applySource(node, source) {
-  if (source && typeof source === "object" && "source" in source) {
-    const sourceNode = source;
-    if (sourceNode.source) node.source = sourceNode.source;
-  }
+function applySource(node, from) {
+  if (from.source) node.source = from.source;
   return node;
 }
 var GROUP_VARIANT_RE = /^\.group(.+) &$/;
@@ -70,22 +64,6 @@ function findGroupAncestor(startRule, groupRoots) {
   }
   return null;
 }
-function splitSelectorList(selector) {
-  const results = [];
-  let depth = 0;
-  let start = 0;
-  for (let i = 0; i < selector.length; i++) {
-    const ch = selector[i];
-    if (ch === "(" || ch === "[") depth++;
-    else if (ch === ")" || ch === "]") depth--;
-    else if (ch === "," && depth === 0) {
-      results.push(selector.slice(start, i).trim());
-      start = i + 1;
-    }
-  }
-  results.push(selector.slice(start).trim());
-  return results.filter(Boolean);
-}
 function composeNestedSelectors(parts) {
   if (parts.length === 0) return "";
   let branches = splitSelectorList(parts[0]);
@@ -116,18 +94,7 @@ function resolveFullNestingSelector(rule) {
   }
   return composeNestedSelectors(parts);
 }
-function findDocRoot(node) {
-  let current = node;
-  while (current.parent) {
-    current = current.parent;
-  }
-  return current;
-}
-function processApply(root, theme, warnings, postcss2) {
-  if (!postcss2) {
-    warnings.push("[RI-1006] @apply requires postcss but it was not provided.");
-    return;
-  }
+function processApply(root, theme, warnings) {
   for (const alias of APPLY_ALIASES) {
     root.walkAtRules(alias, (atRule) => {
       atRule.name = "apply";
@@ -159,7 +126,6 @@ function processApply(root, theme, warnings, postcss2) {
         theme,
         warnings,
         customVariantMap,
-        postcss2,
         groupRoots,
         checkedApplyRoots
       );
@@ -178,7 +144,7 @@ function processApply(root, theme, warnings, postcss2) {
     }
   }
 }
-function expandApply(atRule, classNames, theme, warnings, customVariantMap, postcss2, groupRoots, checkedApplyRoots) {
+function expandApply(atRule, classNames, theme, warnings, customVariantMap, groupRoots, checkedApplyRoots) {
   const parentRule = atRule.parent;
   if (parentRule?.type !== "rule") {
     warnings.push("[RI-1006] @apply must be used inside a CSS rule, not at the top level.");
@@ -245,7 +211,7 @@ function expandApply(atRule, classNames, theme, warnings, customVariantMap, post
   }
   for (const { decl, important } of flattenGroups(baseGroups)) {
     const node = applySource(
-      postcss2.decl({
+      postcss.decl({
         prop: decl.property,
         value: decl.value,
         important
@@ -255,15 +221,15 @@ function expandApply(atRule, classNames, theme, warnings, customVariantMap, post
     atRule.before(node);
   }
   for (const { block, important } of baseNestedBlocks) {
-    atRule.before(buildNestedBlockNode(block, postcss2, atRule, important));
+    atRule.before(buildNestedBlockNode(block, atRule, important));
   }
   let insertAfter = parentRule;
   for (const [nestedSel, groups] of nestedGroups) {
     const sel = nestedSel.replaceAll("&", baseSelector);
-    const rule = applySource(postcss2.rule({ selector: sel }), parentRule);
+    const rule = applySource(postcss.rule({ selector: sel }), parentRule);
     for (const { decl, important } of flattenGroups(groups)) {
       rule.append(
-        applySource(postcss2.decl({ prop: decl.property, value: decl.value, important }), atRule)
+        applySource(postcss.decl({ prop: decl.property, value: decl.value, important }), atRule)
       );
     }
     parentContainer.insertAfter(insertAfter, rule);
@@ -284,7 +250,7 @@ function expandApply(atRule, classNames, theme, warnings, customVariantMap, post
   };
   let docRootMemo = null;
   const docRoot = () => {
-    if (docRootMemo === null) docRootMemo = findDocRoot(parentContainer);
+    if (docRootMemo === null) docRootMemo = parentContainer.root();
     return docRootMemo;
   };
   for (const [key, bucket] of variantBuckets) {
@@ -313,7 +279,6 @@ function expandApply(atRule, classNames, theme, warnings, customVariantMap, post
         effectiveBase,
         groupVariantInfo.rewrittenWrappers,
         bucketDecls,
-        postcss2,
         atRule,
         bucket.nestedSelector,
         bucket.nestedBlocks
@@ -326,7 +291,6 @@ function expandApply(atRule, classNames, theme, warnings, customVariantMap, post
         fullNestingSelector(),
         bucket.wrappers,
         bucketDecls,
-        postcss2,
         atRule,
         bucket.nestedSelector,
         bucket.nestedBlocks
@@ -339,7 +303,6 @@ function expandApply(atRule, classNames, theme, warnings, customVariantMap, post
         baseSelector,
         bucket.wrappers,
         bucketDecls,
-        postcss2,
         atRule,
         bucket.nestedSelector,
         bucket.nestedBlocks
@@ -451,60 +414,41 @@ function variantKey(wrappers, nestedSelector) {
   if (nestedSelector) key += `\0N${nestedSelector}`;
   return key;
 }
-function buildNestedBlockNode(block, postcss2, sourceNode, important) {
+function buildNestedBlockNode(block, sourceNode, important) {
   let node;
   if (block.selector.charCodeAt(0) === 64) {
     const spaceIdx = block.selector.indexOf(" ");
     const name = spaceIdx === -1 ? block.selector.slice(1) : block.selector.slice(1, spaceIdx);
     const params = spaceIdx === -1 ? "" : block.selector.slice(spaceIdx + 1);
-    node = applySource(postcss2.atRule({ name, params }), sourceNode);
+    node = applySource(postcss.atRule({ name, params }), sourceNode);
   } else {
-    node = applySource(postcss2.rule({ selector: block.selector }), sourceNode);
+    node = applySource(postcss.rule({ selector: block.selector }), sourceNode);
   }
   for (const d of block.declarations) {
     node.append(
-      applySource(postcss2.decl({ prop: d.property, value: d.value, important }), sourceNode)
+      applySource(postcss.decl({ prop: d.property, value: d.value, important }), sourceNode)
     );
   }
   for (const child of block.nested) {
-    node.append(buildNestedBlockNode(child, postcss2, sourceNode, important));
+    node.append(buildNestedBlockNode(child, sourceNode, important));
   }
   return node;
 }
-function buildVariantNode(baseSelector, wrappers, decls, postcss2, sourceNode, nestedSelector, nestedBlocks) {
+function buildVariantNode(baseSelector, wrappers, decls, sourceNode, nestedSelector, nestedBlocks) {
   if (decls.length === 0 && nestedBlocks.length === 0) return null;
-  let selector = baseSelector;
-  const atRules = [];
-  let startingStyle = false;
-  for (const w of wrappers) {
-    if (w.selectorSuffix) {
-      const branches = splitSelectorList(selector);
-      const suffix = w.selectorSuffix;
-      if (w.replaceAmpersand) {
-        selector = branches.map((b) => suffix.replace(/&/g, b)).join(", ");
-      } else {
-        selector = branches.map((b) => b + suffix).join(", ");
-      }
-    }
-    if (w.atRule) {
-      atRules.push(w.atRule);
-    }
-    if (w.startingStyle) {
-      startingStyle = true;
-    }
-  }
-  const rule = applySource(postcss2.rule({ selector }), sourceNode);
+  const { selector, atRules, startingStyle } = applyVariantWrappers(baseSelector, wrappers);
+  const rule = applySource(postcss.rule({ selector }), sourceNode);
   let declTarget = rule;
   if (nestedSelector) {
-    declTarget = applySource(postcss2.rule({ selector: nestedSelector }), sourceNode);
+    declTarget = applySource(postcss.rule({ selector: nestedSelector }), sourceNode);
     rule.append(declTarget);
   }
   if (startingStyle) {
-    const startingAtRule = applySource(postcss2.atRule({ name: "starting-style" }), sourceNode);
+    const startingAtRule = applySource(postcss.atRule({ name: "starting-style" }), sourceNode);
     for (const { decl, important } of decls) {
       startingAtRule.append(
         applySource(
-          postcss2.decl({ prop: decl.property, value: decl.value, important }),
+          postcss.decl({ prop: decl.property, value: decl.value, important }),
           sourceNode
         )
       );
@@ -514,14 +458,14 @@ function buildVariantNode(baseSelector, wrappers, decls, postcss2, sourceNode, n
     for (const { decl, important } of decls) {
       declTarget.append(
         applySource(
-          postcss2.decl({ prop: decl.property, value: decl.value, important }),
+          postcss.decl({ prop: decl.property, value: decl.value, important }),
           sourceNode
         )
       );
     }
   }
   for (const { block, important } of nestedBlocks) {
-    declTarget.append(buildNestedBlockNode(block, postcss2, sourceNode, important));
+    declTarget.append(buildNestedBlockNode(block, sourceNode, important));
   }
   if (atRules.length === 0) return rule;
   let node = rule;
@@ -530,7 +474,7 @@ function buildVariantNode(baseSelector, wrappers, decls, postcss2, sourceNode, n
     const spaceIdx = atRuleStr.indexOf(" ");
     const name = spaceIdx === -1 ? atRuleStr.slice(1) : atRuleStr.slice(1, spaceIdx);
     const params = spaceIdx === -1 ? "" : atRuleStr.slice(spaceIdx + 1);
-    const wrapper = applySource(postcss2.atRule({ name, params }), sourceNode);
+    const wrapper = applySource(postcss.atRule({ name, params }), sourceNode);
     wrapper.append(node);
     node = wrapper;
   }
@@ -603,47 +547,24 @@ var rainbowindex = (options = {}) => {
         if (!hasActivation) {
           return;
         }
-        const analysis = analyzeProjectCSS(rawCSS);
-        const compilationWarnings = analysis.warnings;
-        const warningSeen = analysis.warningSeen;
-        const theme = analysis.theme;
-        const sourceOverrides = [];
-        if (options.sources) {
-          for (const s of options.sources) {
-            const err = validateGlobPattern(s);
-            if (err) {
-              pushWarningsDeduped(compilationWarnings, [`[RI-1015] ${err}`], warningSeen);
-              continue;
-            }
-            sourceOverrides.push({ pattern: s, negated: false, inline: false });
-          }
-        }
-        const scannedClasses = await collectProjectClasses(
-          theme.sources,
-          sourceOverrides,
-          cwd,
-          compilationWarnings,
-          warningSeen
-        );
-        const from = root.source?.input?.file ?? root.source?.input?.id ?? root.source?.input?.from ?? "<rainbowindex>";
-        const compiled = await finalizeProjectCompilation({
+        const { compiled, warningSeen } = await compileScannedProject({
           css: rawCSS,
-          classNames: scannedClasses,
-          analysis,
-          // Shared resolver: same fetch-timeout + RI-1213 policy as the CLI and
-          // compileProject, so all surfaces emit identical bytes on slow networks.
-          resolveFonts: resolveGoogleFonts
+          cwd,
+          surfacePatterns: options.sources,
+          onInvalidPattern: (err) => `[RI-1015] ${err}`
         });
+        const compilationWarnings = compiled.warnings;
+        const from = root.source?.input?.file ?? root.source?.input?.id ?? root.source?.input?.from ?? "<rainbowindex>";
         stripRIDirectiveNodes(root);
         if (compiled.sections.length > 0) {
-          const generatedRoot = postcss.parse(compiled.sections.join("\n\n"), { from });
+          const generatedRoot = postcss2.parse(compiled.sections.join("\n\n"), { from });
           root.prepend(generatedRoot.nodes);
         }
         const slotWarnings = [];
         warnStandaloneSlots(root, slotWarnings);
         pushWarningsDeduped(compilationWarnings, slotWarnings, warningSeen);
         const applyWarnings = [];
-        processApply(root, compiled.theme, applyWarnings, postcss);
+        processApply(root, compiled.theme, applyWarnings);
         pushWarningsDeduped(compilationWarnings, applyWarnings, warningSeen);
         const cssFnWarnings = [];
         processCSSFunctions(root, compiled.theme, cssFnWarnings);

package/dist/chunk-YLB6FGIG.mjs

@@ -0,0 +1,244 @@
+import {
+  ANIMATION_STATIC_NAMES,
+  BACKGROUND_STATIC_NAMES,
+  BORDER_STATIC_NAMES,
+  EFFECTS_STATIC_NAMES,
+  LAYOUT_STATIC_NAMES,
+  PREFIX_DISPATCH,
+  ROOT_GROUPS,
+  ROUNDED_CORNER_NAMES,
+  ROUNDED_SIDE_NAMES,
+  SPACING_SAMPLES,
+  STATIC_UTILITIES,
+  SVG_STATIC_NAMES,
+  TYPOGRAPHY_STATIC_NAMES,
+  codepointCompare,
+  parseUtility,
+  resolveUtilityDeclarations
+} from "./chunk-6DAHUFNU.mjs";
+import {
+  SPECIAL_COLORS
+} from "./chunk-5Y7EXXLS.mjs";
+
+// src/project/css-entry.ts
+var CSS_ENTRY_CANDIDATES = Object.freeze([
+  "src/index.css",
+  "src/style.css",
+  "src/styles.css",
+  "src/app.css",
+  "src/global.css",
+  "index.css",
+  "style.css",
+  "styles.css",
+  "app.css",
+  "global.css"
+]);
+
+// src/utilities/enumerate.ts
+var COLOR_STOPS = Object.freeze([
+  "50",
+  "100",
+  "150",
+  "200",
+  "250",
+  "300",
+  "350",
+  "400",
+  "450",
+  "500",
+  "550",
+  "600",
+  "650",
+  "700",
+  "750",
+  "800",
+  "850",
+  "900",
+  "950"
+]);
+var FRACTION_SAMPLES = Object.freeze([
+  "1/2",
+  "1/3",
+  "2/3",
+  "1/4",
+  "3/4",
+  "1/5",
+  "2/5",
+  "3/5",
+  "4/5",
+  "1/6",
+  "5/6"
+]);
+var INT_SAMPLES = Object.freeze(["0", "1", "2", "3", "4", "6", "8", "10", "12"]);
+var PERCENT_SAMPLES = Object.freeze([
+  "0",
+  "5",
+  "10",
+  "15",
+  "20",
+  "25",
+  "30",
+  "40",
+  "50",
+  "60",
+  "70",
+  "75",
+  "80",
+  "90",
+  "95",
+  "100"
+]);
+var BUILTIN_FONT_SLOTS = Object.freeze(["sans", "serif", "mono"]);
+var DURATION_SAMPLES = Object.freeze(["75", "100", "150", "200", "300", "500", "700", "1000"]);
+var ROUNDED_SIDES = Object.freeze([
+  ...ROUNDED_SIDE_NAMES,
+  ...ROUNDED_CORNER_NAMES
+]);
+function buildValueSpaces() {
+  const table = /* @__PURE__ */ new Map();
+  for (const { roots, spec } of ROOT_GROUPS) {
+    for (const root of roots) {
+      let entry = table.get(root);
+      if (!entry) {
+        entry = { kinds: /* @__PURE__ */ new Set(), keywords: /* @__PURE__ */ new Set() };
+        table.set(root, entry);
+      }
+      for (const kind of spec.kinds) entry.kinds.add(kind);
+      for (const kw of spec.keywords ?? []) entry.keywords.add(kw);
+    }
+  }
+  const out = /* @__PURE__ */ new Map();
+  for (const [root, entry] of table) {
+    out.set(root, {
+      kinds: Object.freeze([...entry.kinds]),
+      keywords: entry.keywords.size > 0 ? Object.freeze([...entry.keywords]) : void 0
+    });
+  }
+  return out;
+}
+var UTILITY_VALUE_SPACES = buildValueSpaces();
+function candidateValues(kind, theme) {
+  switch (kind) {
+    case "color": {
+      const out = [];
+      for (const name of Object.keys(theme.colors)) {
+        for (const stop of COLOR_STOPS) out.push(`${name}-${stop}`);
+      }
+      return out;
+    }
+    case "special-color":
+      return Object.keys(SPECIAL_COLORS);
+    case "spacing":
+      return [...SPACING_SAMPLES];
+    case "fraction":
+      return [...FRACTION_SAMPLES];
+    case "text-size":
+      return Object.keys(theme.text);
+    case "fluid-text-size":
+      return Object.keys(theme.text).map((size) => `fluid-${size}`);
+    case "font-slot":
+      return [.../* @__PURE__ */ new Set([...BUILTIN_FONT_SLOTS, ...theme.fonts.map((slot) => slot.slot)])];
+    case "weight":
+      return Object.keys(theme.weights);
+    case "rounded":
+      return Object.keys(theme.rounded);
+    case "rounded-side": {
+      const tokens = Object.keys(theme.rounded);
+      const out = [];
+      for (const side of ROUNDED_SIDES) {
+        out.push(side);
+        for (const token of tokens) out.push(`${side}-${token}`);
+      }
+      return out;
+    }
+    case "shadow":
+      return Object.keys(theme.shadows);
+    case "z":
+      return Object.keys(theme.z);
+    case "ease":
+      return Object.keys(theme.easing);
+    case "blur":
+      return Object.keys(theme.blur);
+    case "animation":
+      return Object.keys(theme.animations);
+    case "leading":
+      return Object.keys(theme.leading);
+    case "tracking":
+      return Object.keys(theme.tracking);
+    case "opacity":
+      return Object.keys(theme.opacity);
+    case "duration":
+      return [.../* @__PURE__ */ new Set([...Object.keys(theme.duration), ...DURATION_SAMPLES])];
+    case "breakpoint":
+      return Object.keys(theme.breakpoints);
+    case "int":
+      return [...INT_SAMPLES];
+    case "percent":
+      return [...PERCENT_SAMPLES];
+    case "keywords":
+      return [];
+  }
+}
+function enumerateClassNames(theme) {
+  const seen = /* @__PURE__ */ new Set();
+  const classes = [];
+  const templates = [];
+  const probeWarnings = [];
+  const resolves = (name) => resolveUtilityDeclarations(parseUtility(name), theme, probeWarnings) !== null;
+  const emit = (name, kind, root) => {
+    if (seen.has(name)) return;
+    if (!resolves(name)) return;
+    seen.add(name);
+    classes.push({ name, kind, root });
+  };
+  for (const name of STATIC_UTILITIES) emit(name, "static", null);
+  for (const names of [
+    ANIMATION_STATIC_NAMES,
+    BORDER_STATIC_NAMES,
+    BACKGROUND_STATIC_NAMES,
+    EFFECTS_STATIC_NAMES,
+    LAYOUT_STATIC_NAMES,
+    SVG_STATIC_NAMES,
+    TYPOGRAPHY_STATIC_NAMES
+  ]) {
+    for (const name of names) emit(name, "static", null);
+  }
+  for (const custom of theme.customUtilities) {
+    if (custom.functional) {
+      templates.push({ root: custom.name, kind: "custom", example: `${custom.name}-value` });
+    } else {
+      emit(custom.name, "custom", null);
+    }
+  }
+  for (const root of PREFIX_DISPATCH.keys()) {
+    const spec = UTILITY_VALUE_SPACES.get(root);
+    if (!spec) continue;
+    let spacingHit = false;
+    let intHit = false;
+    for (const kind of spec.kinds) {
+      for (const value of candidateValues(kind, theme)) {
+        const name = `${root}-${value}`;
+        if (seen.has(name)) continue;
+        if (!resolves(name)) continue;
+        seen.add(name);
+        classes.push({ name, kind, root });
+        if (kind === "spacing") spacingHit = true;
+        if (kind === "int") intHit = true;
+      }
+    }
+    for (const keyword of spec.keywords ?? []) {
+      emit(`${root}-${keyword}`, "keywords", root);
+    }
+    if (spacingHit) templates.push({ root, kind: "spacing", example: `${root}-4` });
+    else if (intHit) templates.push({ root, kind: "number", example: `${root}-2` });
+  }
+  classes.sort((a, b) => codepointCompare(a.name, b.name));
+  templates.sort((a, b) => codepointCompare(a.root, b.root));
+  return { classes, templates };
+}
+
+export {
+  CSS_ENTRY_CANDIDATES,
+  UTILITY_VALUE_SPACES,
+  enumerateClassNames
+};