rainbowindex 0.2.0 → 0.2.2

package/dist/editor.mjs

@@ -0,0 +1,402 @@
+import {
+  CSS_ENTRY_CANDIDATES,
+  UTILITY_VALUE_SPACES,
+  enumerateClassNames
+} from "./chunk-KYDEHYIE.mjs";
+import {
+  CLASS_HELPER_NAMES,
+  RI_IMPORT_SPECIFIERS,
+  STATIC_UTILITIES,
+  VARIANT_HELPER_NAMES,
+  analyzeProjectCSS,
+  buildBreakpointWeights,
+  compileUtility,
+  createEmptyCompilationResult,
+  createThemeSnapshot,
+  diagnosticFromWarning,
+  expandVariantGroups,
+  extractClassCandidates,
+  extractClasses,
+  extractClassesFromSource,
+  findClosest,
+  hasRIActivation,
+  isSourceFile,
+  listVariants,
+  parseUtility,
+  severityForCode,
+  warningCode
+} from "./chunk-W6XIBM4M.mjs";
+import {
+  analyzeMerge,
+  computeDarkStop,
+  defaultTheme,
+  formatOklch,
+  generateStop,
+  linearToSrgb,
+  oklabToLinearSrgb,
+  oklchToOklab
+} from "./chunk-SOMDX7V6.mjs";
+
+// 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) {
+      variantNames = variants().filter((v) => v.kind !== "pattern").map((v) => v.name);
+    }
+    return variantNames;
+  }
+  function utilitySuggestionCorpus() {
+    if (!utilityCorpus) {
+      utilityCorpus = [
+        ...STATIC_UTILITIES,
+        ...theme.customUtilities.filter((u) => !u.functional).map((u) => u.name)
+      ];
+    }
+    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 === "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/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 },
+    rounded: { ...theme.rounded },
+    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 },
+    fonts: theme.fonts.map((slot) => ({ slot: slot.slot, family: slot.family })),
+    animations: Object.keys(theme.animations)
+  };
+}
+
+// src/editor/session.ts
+function createEditorSession(options = {}) {
+  let css = options.css ?? "";
+  let analysis = null;
+  let inspector = null;
+  let enumeration = null;
+  let tokens = null;
+  let snapshot = null;
+  const ensureAnalysis = () => {
+    analysis ??= analyzeProjectCSS(css);
+    return analysis;
+  };
+  const ensureSnapshot = () => {
+    snapshot ??= createThemeSnapshot(ensureAnalysis().theme);
+    return snapshot;
+  };
+  return {
+    get css() {
+      return css;
+    },
+    setCss(next) {
+      if (next === css) return;
+      css = next;
+      analysis = null;
+      inspector = null;
+      enumeration = null;
+      tokens = null;
+      snapshot = null;
+    },
+    get theme() {
+      return ensureAnalysis().theme;
+    },
+    get diagnostics() {
+      return ensureAnalysis().diagnostics;
+    },
+    get inspector() {
+      inspector ??= createClassInspector(ensureAnalysis().theme);
+      return inspector;
+    },
+    enumerate() {
+      enumeration ??= enumerateClassNames(ensureAnalysis().theme);
+      return enumeration;
+    },
+    tokens() {
+      tokens ??= listThemeTokens(ensureAnalysis().theme);
+      return tokens;
+    },
+    snapshot: ensureSnapshot,
+    analyzeMerge(classes) {
+      return analyzeMerge(classes, ensureSnapshot());
+    },
+    extractCandidates(content, path) {
+      return extractClassCandidates({ content, path });
+    },
+    swatch(name, stop) {
+      return resolveColorSwatch(ensureAnalysis().theme, name, stop);
+    }
+  };
+}
+
+// src/entries/editor.ts
+var version = true ? "0.2.2" : "0.0.0-dev";
+var EDITOR_API_VERSION = 1;
+var editorCapabilities = Object.freeze([
+  "class-candidates",
+  "css-entry-detection",
+  "theme-analysis",
+  "class-inspection",
+  "variant-list",
+  "class-enumeration",
+  "merge-analysis",
+  "structured-diagnostics",
+  "color-swatches",
+  "editor-session"
+]);
+export {
+  CANONICAL_COLOR_STOPS,
+  CLASS_HELPER_NAMES,
+  CSS_ENTRY_CANDIDATES,
+  EDITOR_API_VERSION,
+  RI_IMPORT_SPECIFIERS,
+  UTILITY_VALUE_SPACES,
+  VARIANT_HELPER_NAMES,
+  analyzeMerge,
+  analyzeProjectCSS,
+  createClassInspector,
+  createEditorSession,
+  createThemeSnapshot,
+  cssColorToHex,
+  defaultTheme,
+  diagnosticFromWarning,
+  editorCapabilities,
+  enumerateClassNames,
+  expandVariantGroups,
+  extractClassCandidates,
+  extractClasses,
+  extractClassesFromSource,
+  findClosest,
+  hasRIActivation,
+  isSourceFile,
+  listThemeTokens,
+  listVariants,
+  oklchToHex,
+  parseUtility,
+  resolveColorSwatch,
+  severityForCode,
+  version,
+  warningCode
+};

package/dist/{safelist-DRk1XXxi.d.ts → index-CfDtWufj.d.ts}

@@ -165,6 +165,34 @@ declare function ri(...inputs: ClassInput[]): string;
  * ri('p-2 bg-red-500', 'p-4') // → 'bg-red-500 p-4'
  */
 declare function createRi(snapshot?: CompilationSnapshot): (...inputs: ClassInput[]) => string;
+interface MergeDrop {
+    index: number;
+    className: string;
+    /** Ascending indices of the surviving classes that together claimed every
+     *  CSS property this class sets (px-4 + py-4 jointly dominate p-2). */
+    overriddenBy: number[];
+}
+interface MergeAnalysis {
+    /** The merged output — identical to ri()'s result for this token list. */
+    output: string;
+    /** Indices of surviving classes, ascending. */
+    kept: number[];
+    /** Dropped classes with attribution, ascending by index. */
+    dropped: MergeDrop[];
+}
+/**
+ * Explain ri()'s conflict resolution for a list of class tokens — which
+ * classes the right-most-wins scan drops, and which survivors claimed their
+ * properties. Powers "this class is overridden" editor diagnostics.
+ *
+ * Unlike ri(), the input is pre-tokenized: one class per element, no falsy
+ * filtering, no whitespace splitting — exactly the token list an editor
+ * extracts from one class attribute. `snapshot` binds custom utilities, text
+ * sizes, and color names the same way createRi(snapshot) does (editors build
+ * one with createThemeSnapshot()); without it, the module-level state of the
+ * most recent compile applies. Uncached — call sites own their memoization.
+ */
+declare function analyzeMerge(classes: readonly string[], snapshot?: CompilationSnapshot): MergeAnalysis;
 /**
  * Create a fresh compilation context.
  * Called at the start of each compile() pass.
@@ -194,46 +222,4 @@ declare function registerCustomFontFamilies(ctx: CompilationContext, families: s
 declare function registerColorNames(ctx: CompilationContext, names: string[]): void;
 declare function finalizeCompilationContext(ctx: CompilationContext): CompilationSnapshot;
 
-/**
- * `safelist()` — declare utility classes that must be emitted regardless of
- * whether the consumer's source files reference them directly.
- *
- * At runtime this is a plain identity-join: pass any number of strings (and
- * falsy values, which are filtered) and receive a single space-joined string
- * suitable for `className`. The function performs no global registration, has
- * no side effects, and is tree-shake-safe.
- *
- * The build-time meaning comes from the scanner: when the source-file
- * extractor encounters a `safelist(...)` call, it extracts every literal
- * string argument as a class declaration — so the classes get emitted in the
- * final CSS even though the consumer's source never names them literally.
- *
- * Primary use case is component libraries that ship classNames inside their
- * bundled code (e.g. a curated icon set whose strokes are described by
- * utility classes). The library wraps its declarations in `safelist(...)`,
- * the consumer's setup points the scanner at the library's `dist/`, and the
- * classes flow through unchanged. The Vite plugin auto-discovers libraries
- * that opt in via a `rainbowindex.safelistSources` field in their
- * `package.json`, so consumers typically don't have to add `@source` lines
- * by hand.
- *
- *   const ICON_BASE = safelist("stroke-cap-round", "stroke-join-round");
- *   const SidebarLeft = defineIcon({
- *     primitives: SIDEBAR,
- *     className: safelist(ICON_BASE, "-scale-x-100"),
- *   });
- *
- * Scanner contract:
- * - Only STATIC string literals at the call site are extracted. Values
- *   passed through variables (`safelist(ICON_BASE, ...)`) won't be re-read
- *   at the outer call site, but the original `safelist("stroke-cap-round",
- *   ...)` that produced `ICON_BASE` is itself extracted, so the classes are
- *   still covered.
- * - Template literals with no `${…}` interpolation are extracted; templates
- *   with interpolation are skipped.
- * - Falsy arguments are dropped at runtime so conditional fragments compose
- *   naturally: `safelist("flex", side === "left" && "flex-row-reverse")`.
- */
-declare function safelist(...parts: ReadonlyArray<string | false | null | undefined>): string;
-
-export { type AnimationDefinition as A, type ColorDefinition as C, DEFAULT_TEXT_SIZES as D, type FluidConfig as F, type TextSize as T, type CompilationContext as a, type CompilationSnapshot as b, type Theme as c, createCompilationContext as d, createRi as e, defaultTheme as f, finalizeCompilationContext as g, registerCustomFontFamilies as h, registerCustomTextSizes as i, registerCustomUtility as j, ri as k, type DarkModeConfig as l, type CornerShape as m, registerColorNames as r, safelist as s };
+export { type AnimationDefinition as A, type ColorDefinition as C, DEFAULT_TEXT_SIZES as D, type FluidConfig as F, type MergeAnalysis as M, type TextSize as T, type CompilationContext as a, type CompilationSnapshot as b, type Theme as c, createCompilationContext as d, createRi as e, defaultTheme as f, finalizeCompilationContext as g, registerCustomFontFamilies as h, registerCustomTextSizes as i, registerCustomUtility as j, ri as k, type DarkModeConfig as l, type CornerShape as m, type MergeDrop as n, analyzeMerge as o, registerColorNames as r };