rainbowindex 0.6.0 → 0.7.0

package/dist/oxlint.d.ts

@@ -1,3 +1,10 @@
+import { L as LintRule } from './theme-CIZiGlce.js';
+export { T as ThemeLintOptions, n as noConflictingClassesRule, l as noUnknownClassRule } from './theme-CIZiGlce.js';
+import './session-CMaskdB7.js';
+import './imports-C9esHd5Q.js';
+import './index-Czx-EUwh.js';
+import './context-DcBtnnan.js';
+
 /**
  * Oxlint plugin for Rainbow Index projects.
  *
@@ -9,17 +16,28 @@
  * export default defineConfig({
  * 	lint: {
  * 		jsPlugins: [{ name: "rainbowindex", specifier: "rainbowindex/oxlint" }],
- * 		rules: { "rainbowindex/prefer-ri": "error" },
+ * 		rules: {
+ * 			"rainbowindex/prefer-ri": "error",
+ * 			"rainbowindex/no-unknown-class": "error",
+ * 			"rainbowindex/no-conflicting-classes": "warn",
+ * 		},
  * 	},
  * });
  * ```
  *
+ * `prefer-ri` is local to this file: it reads one import statement and needs
+ * no theme. The other two come from `lint/rules.ts`, shared with the ESLint
+ * entry, because a rule that says what a class *means* has to answer the same
+ * way in both linters — it reads the project's compiled theme through the
+ * editor API, and there is one right answer.
+ *
  * The types below describe only the slice of the Oxlint rule API this plugin
  * touches. They are declared here rather than imported from `@oxlint/plugins`
  * because that package is a transitive dependency of Oxlint that a consumer
  * cannot resolve, and its `definePlugin` / `defineRule` helpers are identity
  * functions with no runtime behavior to reuse.
  */
+
 interface ImportDeclarationNode {
     source: {
         value: string;
@@ -47,9 +65,9 @@ interface OxlintPlugin {
     meta: {
         name: string;
     };
-    rules: Record<string, OxlintRule>;
+    rules: Record<string, OxlintRule | LintRule>;
 }
 declare const preferRiRule: OxlintRule;
 declare const plugin: OxlintPlugin;
 
-export { type OxlintPlugin, type OxlintRule, plugin as default, plugin, preferRiRule };
+export { LintRule, type OxlintPlugin, type OxlintRule, plugin as default, plugin, preferRiRule };

package/dist/oxlint.mjs

@@ -1,3 +1,15 @@
+import {
+  noConflictingClassesRule,
+  noUnknownClassRule
+} 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/oxlint.ts
 var REPLACED_PACKAGES = {
   clsx: "composes conditional classes",
@@ -28,11 +40,17 @@ var preferRiRule = {
 };
 var plugin = {
   meta: { name: "rainbowindex" },
-  rules: { "prefer-ri": preferRiRule }
+  rules: {
+    "prefer-ri": preferRiRule,
+    "no-unknown-class": noUnknownClassRule,
+    "no-conflicting-classes": noConflictingClassesRule
+  }
 };
 var oxlint_default = plugin;
 export {
   oxlint_default as default,
+  noConflictingClassesRule,
+  noUnknownClassRule,
   plugin,
   preferRiRule
 };

package/dist/recipe.d.ts

@@ -0,0 +1,111 @@
+import { C as ClassInput } from './index-CNqdL5U0.js';
+import './context-DcBtnnan.js';
+
+/**
+ * `recipe()` — a typed variant layer whose output is ordinary class names.
+ *
+ * A component library needs to say "a button has a size and a tone, and these
+ * are the only valid values" without giving up plain CSS. `cva` and `tv` do
+ * that, and both merge with a table of Tailwind utilities: every utility this
+ * project defines is unknown to them, a `@utility` never resolves, and a theme
+ * change never reaches them. `recipe()` is the same idea over `ri()`, so the
+ * conflict resolution is the one the compiler emitted.
+ *
+ * The result is a string. Nothing is styled at runtime, nothing is injected,
+ * and the classes live in the config where the scanner already reads them —
+ * `recipe` sits beside `cva` and `tv` in the variant-helper list, so a build
+ * finds them with no extra configuration.
+ *
+ * ```ts
+ * const button = recipe({
+ * 	base: "inline-flex items-center rounded-card font-medium",
+ * 	variants: {
+ * 		tone: { solid: "bg-brand-600 text-white", quiet: "text-brand-700" },
+ * 		size: { sm: "h-8 px-3 text-sm", md: "h-10 px-4" },
+ * 		block: { true: "w-full" },
+ * 	},
+ * 	compoundVariants: [{ tone: "solid", size: "sm", class: "shadow-sm" }],
+ * 	defaultVariants: { tone: "solid", size: "md" },
+ * });
+ *
+ * button({ size: "sm" });        // → "inline-flex … bg-brand-600 … h-8 px-3 text-sm shadow-sm"
+ * button({ size: "xl" });        // ✗ Type error: "xl" is not a size
+ * ```
+ */
+
+/** One variant option's classes — anything `ri()` accepts. */
+type RecipeClassValue = ClassInput;
+/** One variant group: option name → the classes that option adds. */
+type VariantGroup = Record<string, RecipeClassValue>;
+/** All of a recipe's variant groups, by name. */
+type VariantShape = Record<string, VariantGroup>;
+type OptionNames<Group> = Extract<keyof Group, string>;
+/**
+ * A group whose only options are `true`/`false` takes a boolean, not the
+ * strings. The tuple brackets keep the check non-distributive, so a group with
+ * both options is still recognized as the boolean one.
+ */
+type IsBooleanGroup<Group> = [OptionNames<Group>] extends ["true" | "false"] ? true : false;
+/** The value a caller may pass for one variant group. */
+type VariantValue<Group> = IsBooleanGroup<Group> extends true ? boolean : OptionNames<Group>;
+/**
+ * The props a recipe accepts, one optional key per variant group.
+ *
+ * `null` is explicit opt-out: it suppresses the group's default rather than
+ * falling back to it, which is the only way to say "no size at all" for a
+ * recipe that defines a default size.
+ */
+type VariantProps<V extends VariantShape> = {
+    [K in keyof V]?: VariantValue<V[K]> | null;
+};
+/** One compound rule: classes that apply when several variants line up. */
+type CompoundVariant<V extends VariantShape> = {
+    [K in keyof V]?: VariantValue<V[K]> | ReadonlyArray<VariantValue<V[K]>>;
+} & {
+    class?: RecipeClassValue;
+    /** Accepted alongside `class`, as `cva` and `tv` do. Both are applied. */
+    className?: RecipeClassValue;
+};
+interface RecipeConfig<V extends VariantShape> {
+    /** Classes every call starts from. */
+    base?: RecipeClassValue;
+    /** The variant groups. Their declaration order is their merge order. */
+    variants?: V;
+    /** Classes that apply only when several variants take given values. */
+    compoundVariants?: ReadonlyArray<CompoundVariant<V>>;
+    /** The value each group takes when the caller passes none. */
+    defaultVariants?: VariantProps<V>;
+}
+/** What a recipe is called with: its variants, plus per-call overrides. */
+type RecipeProps<V extends VariantShape> = VariantProps<V> & {
+    class?: RecipeClassValue;
+    className?: RecipeClassValue;
+};
+interface Recipe<V extends VariantShape> {
+    (props?: RecipeProps<V>): string;
+    /** The config object this recipe was built from, for composing another. */
+    readonly config: RecipeConfig<V>;
+}
+interface RecipeOptions {
+    /**
+     * The merge function. Defaults to the module-level `ri()`.
+     *
+     * Pass `createRi(snapshot)` where the global one cannot be trusted: a
+     * multi-tenant SSR process compiling more than one theme, or a client
+     * bundle that imports the bound `ri` its generated snapshot exports.
+     */
+    merge?: (...inputs: ClassInput[]) => string;
+}
+/** The props type of an existing recipe, for a component's own props. */
+type PropsOf<R> = R extends Recipe<infer V> ? RecipeProps<V> : never;
+/**
+ * Build a recipe: a function from variant props to a merged class string.
+ *
+ * The merge order is base, then each variant group in declaration order, then
+ * the compound rules in array order, then the caller's own `class`/`className`
+ * — so a per-call override always wins, and a compound rule always beats the
+ * plain variants it is refining.
+ */
+declare function recipe<V extends VariantShape>(config: RecipeConfig<V>, options?: RecipeOptions): Recipe<V>;
+
+export { ClassInput, type CompoundVariant, type PropsOf, type Recipe, type RecipeClassValue, type RecipeConfig, type RecipeOptions, type RecipeProps, type VariantGroup, type VariantProps, type VariantShape, type VariantValue, recipe };

package/dist/recipe.mjs

@@ -0,0 +1,71 @@
+import {
+  devWarn,
+  ri
+} from "./chunk-XQGSG2HK.mjs";
+
+// src/recipe.ts
+var COMPOUND_CLASS_KEYS = /* @__PURE__ */ new Set(["class", "className"]);
+function compoundApplies(compound, selection) {
+  for (const key of Object.keys(compound)) {
+    if (COMPOUND_CLASS_KEYS.has(key)) continue;
+    const expected = compound[key];
+    if (expected === void 0) continue;
+    const actual = selection[key];
+    if (actual === void 0) return false;
+    if (Array.isArray(expected)) {
+      if (!expected.some((value) => String(value) === actual)) return false;
+    } else if (String(expected) !== actual) {
+      return false;
+    }
+  }
+  return true;
+}
+function warnUnknownCompoundKeys(config) {
+  const groups = new Set(Object.keys(config.variants ?? {}));
+  const unknown = /* @__PURE__ */ new Set();
+  for (const compound of config.compoundVariants ?? []) {
+    for (const key of Object.keys(compound)) {
+      if (COMPOUND_CLASS_KEYS.has(key)) continue;
+      if (!groups.has(key)) unknown.add(key);
+    }
+  }
+  if (unknown.size === 0) return;
+  const named = [...unknown].map((key) => `"${key}"`).join(", ");
+  const known = [...groups].map((key) => `"${key}"`).join(", ") || "none";
+  devWarn(
+    `[RI-2013] recipe() compoundVariants name ${named}, which ${unknown.size === 1 ? "is not a variant group" : "are not variant groups"} of this recipe (defined: ${known}). Those rules can never apply. Check the spelling, or add the group to \`variants\`.`
+  );
+}
+function recipe(config, options = {}) {
+  const merge = options.merge ?? ri;
+  warnUnknownCompoundKeys(config);
+  const build = (props) => {
+    const parts = [config.base];
+    const selection = {};
+    const variants = config.variants;
+    if (variants) {
+      const supplied = props;
+      const defaults = config.defaultVariants;
+      for (const name of Object.keys(variants)) {
+        const fromProps = supplied?.[name];
+        const chosen = fromProps === void 0 ? defaults?.[name] : fromProps;
+        if (chosen === null || chosen === void 0) continue;
+        const option = String(chosen);
+        selection[name] = option;
+        const group = variants[name];
+        if (Object.hasOwn(group, option)) parts.push(group[option]);
+      }
+    }
+    for (const compound of config.compoundVariants ?? []) {
+      const entry = compound;
+      if (!compoundApplies(entry, selection)) continue;
+      parts.push(entry.class, entry.className);
+    }
+    if (props) parts.push(props.class, props.className);
+    return merge(...parts);
+  };
+  return Object.assign(build, { config });
+}
+export {
+  recipe
+};

package/dist/safelist-CH3_PywB.d.ts

@@ -0,0 +1,43 @@
+/**
+ * `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 { safelist as s };