rainbowindex 0.6.0 → 0.7.0

package/dist/chunk-ZR7XJMUN.mjs

@@ -1,251 +0,0 @@
-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-KSNYSR3C.mjs";
-import {
-  SPECIAL_COLORS
-} from "./chunk-6U4IOFOS.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 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 };
-}
-
-export {
-  CSS_ENTRY_CANDIDATES,
-  UTILITY_VALUE_SPACES,
-  enumerateClassNames
-};

package/dist/safelist-CGCtF-Fr.d.ts

@@ -1,96 +0,0 @@
-import { b as CompilationSnapshot } from './index-DSgpB6bS.js';
-
-/**
- * ri() — class merge function.
- * Replaces both tailwind-merge and clsx.
- *
- * Re-exported from the package's main and browser entries as `ri()`.
- * Right-to-left scan: rightmost class wins when two classes set the same CSS property.
- *
- * This file is the pure merge runtime. Its siblings hold the other merge
- * concepts: props.ts (claim data), resolve.ts (dual-mode claim resolution),
- * context.ts (compilation-context lifecycle + published state), analyze.ts
- * (editor-only merge diagnostics).
- *
- * ## Concurrency
- *
- * The default `ri()` export uses module-level state published by
- * `finalizeCompilationContext()`. This is safe for single-compilation
- * environments (typical browser usage, single Vite build, PostCSS).
- *
- * In multi-tenant / SSR / concurrent-compilation environments, use
- * `createRi(snapshot)` instead — it captures a frozen snapshot of the
- * compilation state and uses its own independent cache:
- *
- *   const snapshot = finalizeCompilationContext(ctx);
- *   const ri = createRi(snapshot);
- */
-type ClassInput = string | false | null | undefined | ClassInput[];
-
-/**
- * Merge class names with conflict resolution (replaces both tailwind-merge and clsx).
- * Rightmost class wins when two classes set the same CSS property.
- * Falsy values are filtered.
- *
- * @example
- * ri('p-2 bg-red-500', 'p-4')           // → 'bg-red-500 p-4'
- * ri('px-2 py-1', 'p-4')                // → 'p-4' (shorthand wins)
- * ri('flex', isActive && 'bg-blue-500') // → 'flex bg-blue-500'
- * ri('text-lg text-red-500')            // → 'text-lg text-red-500' (different properties)
- */
-declare function ri(...inputs: ClassInput[]): string;
-/**
- * Create an isolated ri() instance bound to a specific compilation snapshot.
- * Use this in SSR or multi-compilation environments where the global ri()
- * would be corrupted by concurrent compilations.
- *
- * @example
- * const snapshot = finalizeCompilationContext(ctx);
- * const ri = createRi(snapshot);
- * ri('p-2 bg-red-500', 'p-4') // → 'bg-red-500 p-4'
- */
-declare function createRi(snapshot?: CompilationSnapshot): (...inputs: ClassInput[]) => string;
-
-/**
- * `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 { createRi as c, ri as r, safelist as s };