rainbowindex 0.6.0 → 0.7.0

package/dist/chunk-WBESS2ZD.mjs

@@ -0,0 +1,598 @@
+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,
+  buildBreakpointWeights,
+  codepointCompare,
+  compileUtility,
+  createEmptyCompilationResult,
+  escapeSelector,
+  findClosest,
+  listVariants,
+  parseUtility,
+  resolveUtilityDeclarations
+} from "./chunk-FJOZJIKB.mjs";
+import {
+  computeDarkStop,
+  formatOklch,
+  generateStop,
+  linearToSrgb,
+  oklabToLinearSrgb,
+  oklchToOklab
+} from "./chunk-L56IRO7A.mjs";
+import {
+  SPECIAL_COLORS
+} from "./chunk-XQGSG2HK.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/theme/swatch.ts
+var CANONICAL_COLOR_STOPS = Object.freeze([
+  50,
+  100,
+  150,
+  200,
+  250,
+  300,
+  350,
+  400,
+  450,
+  500,
+  550,
+  600,
+  650,
+  700,
+  750,
+  800,
+  850,
+  900,
+  950
+]);
+function channelHex(value) {
+  return Math.round(Math.min(1, Math.max(0, value)) * 255).toString(16).padStart(2, "0");
+}
+function oklchToHex(l, c, h) {
+  const [labL, labA, labB] = oklchToOklab(l, c, h);
+  const [r, g, b] = oklabToLinearSrgb(labL, labA, labB);
+  return `#${channelHex(linearToSrgb(r))}${channelHex(linearToSrgb(g))}${channelHex(linearToSrgb(b))}`;
+}
+var OKLCH_TEXT_RE = /^oklch\(\s*([\d.]+%?)\s+([\d.]+)\s+([\d.-]+)\s*(?:\/\s*[\d.]+%?\s*)?\)$/i;
+var HEX_TEXT_RE = /^#(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i;
+function cssColorToHex(css) {
+  const text = css.trim();
+  if (HEX_TEXT_RE.test(text)) {
+    if (text.length === 4 || text.length === 5) {
+      return `#${text[1]}${text[1]}${text[2]}${text[2]}${text[3]}${text[3]}`.toLowerCase();
+    }
+    return text.slice(0, 7).toLowerCase();
+  }
+  const match = OKLCH_TEXT_RE.exec(text);
+  if (match) {
+    const rawL = match[1];
+    const l = rawL.endsWith("%") ? Number.parseFloat(rawL) / 100 : Number.parseFloat(rawL);
+    const c = Number.parseFloat(match[2]);
+    const h = Number.parseFloat(match[3]);
+    if (Number.isFinite(l) && Number.isFinite(c) && Number.isFinite(h)) {
+      return oklchToHex(l, c, h);
+    }
+  }
+  return null;
+}
+var MAX_ALIAS_HOPS = 8;
+var SEMANTIC_SWATCHES = Object.freeze({
+  paper: {
+    light: { css: "oklch(1 0 0)", hex: "#ffffff" },
+    dark: { css: "oklch(0 0 0)", hex: "#000000" }
+  },
+  ink: {
+    light: { css: "oklch(0 0 0)", hex: "#000000" },
+    dark: { css: "oklch(1 0 0)", hex: "#ffffff" }
+  },
+  white: {
+    light: { css: "oklch(1 0 0)", hex: "#ffffff" },
+    dark: null
+  },
+  black: {
+    light: { css: "oklch(0 0 0)", hex: "#000000" },
+    dark: null
+  }
+});
+function swatchFromCss(css) {
+  return { css, hex: cssColorToHex(css) };
+}
+function resolveColorSwatch(theme, name, stop = 500) {
+  let def = theme.colors[name];
+  for (let hop = 0; def && def.type === "alias" && hop < MAX_ALIAS_HOPS; hop++) {
+    def = theme.colors[def.source];
+  }
+  if (!def || def.type === "alias") {
+    return SEMANTIC_SWATCHES[name] ?? null;
+  }
+  switch (def.type) {
+    case "generative": {
+      const light = generateStop(def, stop);
+      const lightSwatch = {
+        css: formatOklch(light.l, light.c, light.h),
+        hex: oklchToHex(light.l, light.c, light.h)
+      };
+      if (theme.darkConfig.mode === "off" || def.dark?.strategy === "fixed") {
+        return { light: lightSwatch, dark: null };
+      }
+      const dark = computeDarkStop(def, stop, theme.darkConfig, def.dark);
+      return {
+        light: lightSwatch,
+        dark: {
+          css: formatOklch(dark.l, dark.c, dark.h),
+          hex: oklchToHex(dark.l, dark.c, dark.h)
+        }
+      };
+    }
+    case "explicit":
+      return { light: swatchFromCss(def.value), dark: null };
+    case "pair":
+      return {
+        light: swatchFromCss(def.light),
+        dark: theme.darkConfig.mode === "off" ? null : swatchFromCss(def.dark)
+      };
+    case "keyword":
+      return null;
+  }
+}
+function listThemeTokens(theme) {
+  return {
+    colors: Object.entries(theme.colors).map(([name, def]) => ({ name, kind: def.type })),
+    colorStops: CANONICAL_COLOR_STOPS,
+    spacingBase: theme.spacing.base,
+    textSizes: Object.entries(theme.text).map(([name, def]) => ({
+      name,
+      fontSize: def.fontSize,
+      lineHeight: def.lineHeight
+    })),
+    breakpoints: { ...theme.breakpoints },
+    shadows: { ...theme.shadows },
+    weights: { ...theme.weights },
+    easing: { ...theme.easing },
+    blur: { ...theme.blur },
+    z: { ...theme.z },
+    leading: { ...theme.leading },
+    tracking: { ...theme.tracking },
+    opacity: { ...theme.opacity },
+    duration: { ...theme.duration },
+    radii: { ...theme.radii },
+    fluidRanges: Object.fromEntries(
+      Object.entries(theme.fluidRanges).map(([name, range]) => [
+        name,
+        { min: range.min, max: range.max }
+      ])
+    ),
+    fonts: theme.fonts.map((slot) => ({ slot: slot.slot, family: slot.family })),
+    animations: Object.keys(theme.animations)
+  };
+}
+
+// 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 INT_RE = /^\d+$/;
+var WEIGHT_STEPS = Object.freeze(["100", "200", "300", "400", "500", "600", "700", "800", "900"]);
+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
+]);
+var RADIUS_SAMPLES = Object.freeze([...SPACING_SAMPLES, "none", "full"]);
+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 "fluid-range":
+      return Object.keys(theme.fluidRanges);
+    case "font-slot":
+      return [.../* @__PURE__ */ new Set([...BUILTIN_FONT_SLOTS, ...theme.fonts.map((slot) => slot.slot)])];
+    case "weight":
+      return [...Object.keys(theme.weights), ...WEIGHT_STEPS];
+    // Named @rounded radii plus the spacing multiples, the way @weight pairs
+    // its tokens with the numeric steps. Without the names, `rounded-roof`
+    // compiles but is offered by neither completions nor generated types.
+    case "rounded":
+      return [...Object.keys(theme.radii), ...RADIUS_SAMPLES];
+    case "rounded-side": {
+      const out = [];
+      const sizes = [...Object.keys(theme.radii), ...RADIUS_SAMPLES];
+      for (const side of ROUNDED_SIDES) {
+        for (const size of sizes) out.push(`${side}-${size}`);
+      }
+      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" || kind === "weight" && INT_RE.test(value)) 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 };
+}
+
+// src/engine/inspector.ts
+var RESOLUTION_CACHE_CAP = 1e4;
+var OK = Object.freeze({ ok: true });
+function createClassInspector(theme) {
+  const customVariantMap = new Map(theme.customVariants.map((cv) => [cv.name, cv]));
+  const breakpointWeights = buildBreakpointWeights(theme.breakpoints);
+  const variantMemo = /* @__PURE__ */ new Map();
+  const scratch = createEmptyCompilationResult();
+  const warnSeen = /* @__PURE__ */ new Set();
+  const detail = { reason: null, variant: null, declarations: null };
+  const cache = /* @__PURE__ */ new Map();
+  let variantList = null;
+  let variantNames = null;
+  let utilityCorpus = null;
+  function variants() {
+    if (!variantList) variantList = Object.freeze(listVariants(theme));
+    return variantList;
+  }
+  function variantSuggestionCorpus() {
+    if (!variantNames) {
+      const names = [];
+      for (const v of variants()) {
+        if (v.kind !== "pattern") names.push(v.name);
+      }
+      variantNames = names;
+    }
+    return variantNames;
+  }
+  function utilitySuggestionCorpus() {
+    if (!utilityCorpus) {
+      const names = new Set(STATIC_UTILITIES);
+      for (const custom of theme.customUtilities) {
+        if (!custom.functional) names.add(custom.name);
+      }
+      for (const entry of enumerateClassNames(theme).classes) names.add(entry.name);
+      utilityCorpus = [...names];
+    }
+    return utilityCorpus;
+  }
+  function baseName(raw, parsed) {
+    let base = raw;
+    if (parsed.variants.length > 0) {
+      const prefix = `${parsed.variants.join(":")}:`;
+      if (base.startsWith(prefix)) base = base.slice(prefix.length);
+    }
+    if (parsed.important && base.endsWith("!")) base = base.slice(0, -1);
+    return base;
+  }
+  function resolve(className) {
+    const cached = cache.get(className);
+    if (cached) return cached;
+    if (cache.size >= RESOLUTION_CACHE_CAP) {
+      cache.clear();
+      variantMemo.clear();
+    }
+    scratch.warnings.length = 0;
+    warnSeen.clear();
+    const parsed = parseUtility(className);
+    const rule = compileUtility(
+      parsed,
+      theme,
+      scratch,
+      customVariantMap,
+      warnSeen,
+      breakpointWeights,
+      variantMemo,
+      detail
+    );
+    let entry;
+    if (rule) {
+      entry = {
+        validation: OK,
+        explanation: {
+          parsed,
+          declarations: detail.declarations ? [...detail.declarations] : [],
+          selector: rule.selector,
+          css: rule.css,
+          sortKey: rule.sortKey
+        }
+      };
+    } else if (detail.reason === "marker") {
+      entry = {
+        validation: OK,
+        explanation: {
+          parsed,
+          declarations: [],
+          selector: `.${escapeSelector(parsed.utility)}`,
+          css: "",
+          sortKey: 0,
+          marker: true
+        }
+      };
+    } else if (detail.reason === "unknown-variant" && detail.variant !== null) {
+      const suggestion = findClosest(detail.variant, variantSuggestionCorpus());
+      entry = {
+        validation: {
+          ok: false,
+          reason: "unknown-variant",
+          offender: detail.variant,
+          ...suggestion ? { suggestion } : {}
+        },
+        explanation: null
+      };
+    } else {
+      const base = baseName(className, parsed);
+      if (parsed.arbitrary || parsed.arbitraryProperty !== null) {
+        entry = {
+          validation: { ok: false, reason: "invalid-arbitrary", offender: base },
+          explanation: null
+        };
+      } else {
+        const suggestion = findClosest(base, utilitySuggestionCorpus());
+        entry = {
+          validation: {
+            ok: false,
+            reason: "unknown-utility",
+            offender: base,
+            ...suggestion ? { suggestion } : {}
+          },
+          explanation: null
+        };
+      }
+    }
+    cache.set(className, entry);
+    return entry;
+  }
+  return {
+    theme,
+    validate: (className) => resolve(className).validation,
+    explain: (className) => resolve(className).explanation,
+    variants
+  };
+}
+
+// src/editor/candidates.ts
+function lastIndexWithStart(starts, value, inclusive) {
+  let low = 0;
+  let high = starts.length - 1;
+  let found = -1;
+  while (low <= high) {
+    const mid = low + high >> 1;
+    if (inclusive ? starts[mid] <= value : starts[mid] < value) {
+      found = mid;
+      low = mid + 1;
+    } else {
+      high = mid - 1;
+    }
+  }
+  return found;
+}
+function outermostCandidates(candidates) {
+  if (candidates.length < 2) return [...candidates];
+  const spans = [];
+  for (const candidate of candidates) {
+    spans.push({ start: candidate.start, end: candidate.end });
+    if (candidate.groupPrefix) spans.push(candidate.groupPrefix);
+  }
+  spans.sort((a, b) => a.start - b.start || a.end - b.end);
+  const starts = spans.map((span) => span.start);
+  const prefixMaxEnd = new Array(spans.length);
+  let running = Number.NEGATIVE_INFINITY;
+  for (let i = 0; i < spans.length; i++) {
+    running = Math.max(running, spans[i].end);
+    prefixMaxEnd[i] = running;
+  }
+  const seenSpans = /* @__PURE__ */ new Set();
+  const kept = [];
+  for (const candidate of candidates) {
+    const atOrBefore = lastIndexWithStart(starts, candidate.start, true);
+    const before = lastIndexWithStart(starts, candidate.start, false);
+    const reachAtOrBefore = atOrBefore === -1 ? Number.NEGATIVE_INFINITY : prefixMaxEnd[atOrBefore];
+    const reachBefore = before === -1 ? Number.NEGATIVE_INFINITY : prefixMaxEnd[before];
+    if (reachAtOrBefore > candidate.end || reachBefore >= candidate.end) continue;
+    const key = `${candidate.start}:${candidate.end}`;
+    if (seenSpans.has(key)) continue;
+    seenSpans.add(key);
+    kept.push(candidate);
+  }
+  kept.sort((a, b) => a.start - b.start);
+  return kept;
+}
+
+export {
+  CSS_ENTRY_CANDIDATES,
+  CANONICAL_COLOR_STOPS,
+  oklchToHex,
+  cssColorToHex,
+  resolveColorSwatch,
+  listThemeTokens,
+  UTILITY_VALUE_SPACES,
+  enumerateClassNames,
+  createClassInspector,
+  outermostCandidates
+};

package/dist/{chunk-3HRMFZGE.mjs → chunk-X66Z2YHT.mjs}

@@ -8,7 +8,8 @@ var SOURCE_FILE_EXTENSIONS = Object.freeze([
   "md",
   "mdx",
   "vue",
-  "svelte"
+  "svelte",
+  "astro"
 ]);
 function isSourceFile(file) {
   return SOURCE_FILE_EXTENSIONS.some((ext) => file.endsWith(`.${ext}`));