rainbowindex 0.6.0 → 0.7.0

package/dist/editor.mjs

@@ -1,20 +1,29 @@
 import {
+  analyzeMerge,
+  createEditorSession,
+  renderStylesheet,
+  sortClasses
+} from "./chunk-PZDVDEZJ.mjs";
+import {
+  CANONICAL_COLOR_STOPS,
   CSS_ENTRY_CANDIDATES,
   UTILITY_VALUE_SPACES,
-  enumerateClassNames
-} from "./chunk-ZR7XJMUN.mjs";
+  createClassInspector,
+  cssColorToHex,
+  enumerateClassNames,
+  listThemeTokens,
+  oklchToHex,
+  outermostCandidates,
+  resolveColorSwatch
+} from "./chunk-WBESS2ZD.mjs";
 import {
   isSourceFile
-} from "./chunk-3HRMFZGE.mjs";
+} from "./chunk-X66Z2YHT.mjs";
 import {
   CLASS_HELPER_NAMES,
   RI_IMPORT_SPECIFIERS,
-  STATIC_UTILITIES,
   VARIANT_HELPER_NAMES,
   analyzeProjectCSS,
-  buildBreakpointWeights,
-  compileUtility,
-  createEmptyCompilationResult,
   createThemeSnapshot,
   describeLoadedWeights,
   diagnosticFromWarning,
@@ -24,375 +33,26 @@ import {
   extractClassesFromSource,
   findClosest,
   hasRIActivation,
+  inlineDirectiveImports,
   isSuppressible,
   listVariants,
   parseUtility,
   severityForCode,
+  stripRIDirectives,
   warningCode,
   weightIsLoaded
-} from "./chunk-KSNYSR3C.mjs";
+} from "./chunk-FJOZJIKB.mjs";
 import {
-  computeDarkStop,
-  defaultTheme,
-  formatOklch,
-  generateStop,
-  linearToSrgb,
-  mergeUncached,
-  oklabToLinearSrgb,
-  oklchToOklab,
-  resolverFor
-} from "./chunk-6U4IOFOS.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) {
-      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 === "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/merge/analyze.ts
-function analyzeMerge(classes, snapshot) {
-  const resolve = resolverFor(snapshot);
-  const trace = { claimers: /* @__PURE__ */ new Map(), dropped: [] };
-  const output = mergeUncached(classes, resolve, trace);
-  trace.dropped.sort((a, b) => a.index - b.index);
-  const droppedIndexes = new Set(trace.dropped.map((d) => d.index));
-  const kept = [];
-  for (let i = 0; i < classes.length; i++) {
-    if (!droppedIndexes.has(i)) kept.push(i);
-  }
-  return {
-    output,
-    kept,
-    dropped: trace.dropped.map((d) => ({
-      index: d.index,
-      className: classes[d.index],
-      overriddenBy: d.overriddenBy
-    }))
-  };
-}
-
-// 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/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);
-    }
-  };
-}
+  defaultTheme
+} from "./chunk-L56IRO7A.mjs";
+import {
+  hydrateSnapshot,
+  publishSnapshot,
+  serializeSnapshot
+} from "./chunk-XQGSG2HK.mjs";
 
 // src/entries/editor.ts
-var version = true ? "0.6.0" : "0.0.0-dev";
+var version = true ? "0.7.0" : "0.0.0-dev";
 var EDITOR_API_VERSION = 1;
 var editorCapabilities = Object.freeze([
   "class-candidates",
@@ -419,7 +79,22 @@ var editorCapabilities = Object.freeze([
   "named-radii-and-fluid-ranges",
   // `weightIsLoaded` / `describeLoadedWeights` — the RI-1504 coverage check,
   // so an editor can answer "does any loaded font have this weight?".
-  "font-weight-coverage"
+  "font-weight-coverage",
+  // `inlineDirectiveImports`, and `createEditorSession({ resolveImport })` —
+  // directives living in an `@import`ed file are read, given a host resolver.
+  "import-inlining",
+  // `serializeSnapshot` / `hydrateSnapshot` / `publishSnapshot` — a snapshot
+  // that survives JSON, so a theme can be shipped to a client bundle.
+  "serializable-snapshot",
+  // `renderStylesheet`, and `EditorSession.render` — the whole stylesheet,
+  // not just an answer about one class, from a graph with no `node:` in it.
+  "stylesheet-rendering",
+  // `sortClasses` — the emission order of a class list, so an editor command,
+  // a formatter and a codemod cannot disagree about what sorted means.
+  "class-sorting",
+  // `outermostCandidates` — one candidate per class the author wrote, for
+  // anything that maps a candidate back to a place in the source.
+  "candidate-spans-deduped"
 ]);
 export {
   CANONICAL_COLOR_STOPS,
@@ -446,14 +121,22 @@ export {
   extractClassesFromSource,
   findClosest,
   hasRIActivation,
+  hydrateSnapshot,
+  inlineDirectiveImports,
   isSourceFile,
   isSuppressible,
   listThemeTokens,
   listVariants,
   oklchToHex,
+  outermostCandidates,
   parseUtility,
+  publishSnapshot,
+  renderStylesheet,
   resolveColorSwatch,
+  serializeSnapshot,
   severityForCode,
+  sortClasses,
+  stripRIDirectives,
   version,
   warningCode,
   weightIsLoaded

package/dist/eslint.d.ts

@@ -0,0 +1,16 @@
+import { L as LintRule } from './theme-CIZiGlce.js';
+export { a as LintContext, b as LintFix, c as LintFixer, d as LintLoc, e as LintReport, f as LintSourceCode, g as LintSuggestion, h as LintVisitor, T as ThemeLintOptions, i as clearSessionCache, j as findCSSEntry, k as getSession, n as noConflictingClassesRule, l as noUnknownClassRule, r as rules } from './theme-CIZiGlce.js';
+import './session-CMaskdB7.js';
+import './imports-C9esHd5Q.js';
+import './index-Czx-EUwh.js';
+import './context-DcBtnnan.js';
+
+/** The flat-config plugin object. `plugins: { rainbowindex }`. */
+declare const plugin: {
+    meta: {
+        name: string;
+    };
+    rules: Readonly<Record<string, LintRule>>;
+};
+
+export { LintRule, plugin as default, plugin };

package/dist/eslint.mjs

@@ -0,0 +1,32 @@
+import {
+  clearSessionCache,
+  findCSSEntry,
+  getSession,
+  noConflictingClassesRule,
+  noUnknownClassRule,
+  rules
+} from "./chunk-TQJYVQPE.mjs";
+import "./chunk-PZDVDEZJ.mjs";
+import "./chunk-WBESS2ZD.mjs";
+import "./chunk-W756NVYI.mjs";
+import "./chunk-X66Z2YHT.mjs";
+import "./chunk-FJOZJIKB.mjs";
+import "./chunk-L56IRO7A.mjs";
+import "./chunk-XQGSG2HK.mjs";
+
+// src/integrations/lint/index.ts
+var plugin = {
+  meta: { name: "rainbowindex" },
+  rules
+};
+var lint_default = plugin;
+export {
+  clearSessionCache,
+  lint_default as default,
+  findCSSEntry,
+  getSession,
+  noConflictingClassesRule,
+  noUnknownClassRule,
+  plugin,
+  rules
+};