@work-rjkashyap/unified-ui 0.3.4 → 0.3.5

package/dist/utils/contrast.d.ts

@@ -0,0 +1,209 @@
+/** An RGB color represented as a tuple of [red, green, blue] (0–255 each). */
+type RGB = readonly [number, number, number];
+/** Text size category for WCAG contrast thresholds. */
+type TextSize = "normal" | "large";
+/** Full result of a contrast check between two colors. */
+interface ContrastResult {
+    /** The computed contrast ratio (e.g. 4.56). Always ≥ 1. */
+    ratio: number;
+    /** Meets WCAG AA for normal text (≥ 4.5:1). */
+    aa: boolean;
+    /** Meets WCAG AA for large text (≥ 3:1). */
+    aaLarge: boolean;
+    /** Meets WCAG AAA for normal text (≥ 7:1). */
+    aaa: boolean;
+    /** Meets WCAG AAA for large text (≥ 4.5:1). */
+    aaaLarge: boolean;
+    /** Meets WCAG AA for non-text UI components (≥ 3:1). */
+    nonTextAA: boolean;
+}
+/** Minimum contrast ratio for WCAG AA normal text. */
+declare const WCAG_AA_NORMAL = 4.5;
+/** Minimum contrast ratio for WCAG AA large text. */
+declare const WCAG_AA_LARGE = 3;
+/** Minimum contrast ratio for WCAG AAA normal text. */
+declare const WCAG_AAA_NORMAL = 7;
+/** Minimum contrast ratio for WCAG AAA large text. */
+declare const WCAG_AAA_LARGE = 4.5;
+/** Minimum contrast ratio for WCAG AA non-text UI components (SC 1.4.11). */
+declare const WCAG_NON_TEXT_AA = 3;
+/**
+ * Calculate the relative luminance of an sRGB color.
+ *
+ * @param color - RGB tuple [r, g, b] with values in 0–255 range
+ * @returns Relative luminance in 0–1 range (0 = black, 1 = white)
+ *
+ * @example
+ * ```ts
+ * relativeLuminance([255, 255, 255]) // → 1.0 (white)
+ * relativeLuminance([0, 0, 0])       // → 0.0 (black)
+ * relativeLuminance([79, 70, 229])   // → ~0.067 (indigo)
+ * ```
+ */
+declare function relativeLuminance(color: RGB): number;
+/**
+ * Calculate the WCAG contrast ratio between two colors.
+ *
+ * @param foreground - RGB tuple [r, g, b] for the foreground (text) color
+ * @param background - RGB tuple [r, g, b] for the background color
+ * @returns Contrast ratio ≥ 1.0 (e.g. 4.5 means "4.5:1")
+ *
+ * @example
+ * ```ts
+ * contrastRatio([0, 0, 0], [255, 255, 255])   // → 21.0 (max)
+ * contrastRatio([255, 255, 255], [0, 0, 0])   // → 21.0 (order doesn't matter)
+ * contrastRatio([79, 70, 229], [255, 255, 255]) // → ~4.56
+ * ```
+ */
+declare function contrastRatio(foreground: RGB, background: RGB): number;
+/**
+ * Check if a contrast ratio meets WCAG AA requirements.
+ *
+ * @param ratio - The contrast ratio to check
+ * @param textSize - "normal" (default, ≥ 4.5:1) or "large" (≥ 3:1)
+ * @returns `true` if the ratio meets the AA threshold
+ */
+declare function meetsAA(ratio: number, textSize?: TextSize): boolean;
+/**
+ * Check if a contrast ratio meets WCAG AAA requirements.
+ *
+ * @param ratio - The contrast ratio to check
+ * @param textSize - "normal" (default, ≥ 7:1) or "large" (≥ 4.5:1)
+ * @returns `true` if the ratio meets the AAA threshold
+ */
+declare function meetsAAA(ratio: number, textSize?: TextSize): boolean;
+/**
+ * Check if a contrast ratio meets WCAG AA for non-text elements (SC 1.4.11).
+ * This applies to UI component boundaries, focus indicators, and graphical objects.
+ *
+ * @param ratio - The contrast ratio to check
+ * @returns `true` if the ratio meets ≥ 3:1
+ */
+declare function meetsNonTextAA(ratio: number): boolean;
+/**
+ * Parse a space-separated RGB string (as used in `design-system.css`) into
+ * an RGB tuple.
+ *
+ * @param rgbString - Space-separated RGB channels, e.g. "79 70 229"
+ * @returns RGB tuple [r, g, b]
+ * @throws {Error} If the string is not a valid 3-channel RGB value
+ *
+ * @example
+ * ```ts
+ * parseRGBString("79 70 229")     // → [79, 70, 229]
+ * parseRGBString("255 255 255")   // → [255, 255, 255]
+ * ```
+ */
+declare function parseRGBString(rgbString: string): RGB;
+/**
+ * Convert an RGB tuple back to a space-separated string.
+ *
+ * @param color - RGB tuple [r, g, b]
+ * @returns Space-separated string, e.g. "79 70 229"
+ */
+declare function toRGBString(color: RGB): string;
+/**
+ * Parse a hex color string into an RGB tuple.
+ *
+ * @param hex - Hex color string (with or without #), supports 3 or 6 digits
+ * @returns RGB tuple [r, g, b]
+ * @throws {Error} If the string is not a valid hex color
+ *
+ * @example
+ * ```ts
+ * parseHex("#4F46E5")    // → [79, 70, 229]
+ * parseHex("4F46E5")     // → [79, 70, 229]
+ * parseHex("#fff")       // → [255, 255, 255]
+ * ```
+ */
+declare function parseHex(hex: string): RGB;
+/**
+ * Perform a comprehensive WCAG contrast check between two colors.
+ * Accepts the space-separated RGB strings used in `design-system.css`.
+ *
+ * @param fgRGBString - Foreground color as "R G B" string (e.g. "255 255 255")
+ * @param bgRGBString - Background color as "R G B" string (e.g. "79 70 229")
+ * @returns Full contrast result with ratio and pass/fail for each WCAG level
+ *
+ * @example
+ * ```ts
+ * const result = checkDSContrast("255 255 255", "79 70 229");
+ * // → {
+ * //   ratio: 4.56,
+ * //   aa: true,
+ * //   aaLarge: true,
+ * //   aaa: false,
+ * //   aaaLarge: true,
+ * //   nonTextAA: true,
+ * // }
+ * ```
+ */
+declare function checkDSContrast(fgRGBString: string, bgRGBString: string): ContrastResult;
+/**
+ * Perform a comprehensive WCAG contrast check between two hex colors.
+ *
+ * @param fgHex - Foreground hex color (e.g. "#FFFFFF")
+ * @param bgHex - Background hex color (e.g. "#4F46E5")
+ * @returns Full contrast result with ratio and pass/fail for each WCAG level
+ */
+declare function checkHexContrast(fgHex: string, bgHex: string): ContrastResult;
+/** A named color pair for batch auditing. */
+interface ColorPair {
+    /** Human-readable label for the pair (e.g. "primary on background"). */
+    label: string;
+    /** Foreground color as space-separated RGB string. */
+    fg: string;
+    /** Background color as space-separated RGB string. */
+    bg: string;
+}
+/** Result of a single pair in a batch audit. */
+interface AuditResult extends ContrastResult {
+    /** The label from the input pair. */
+    label: string;
+    /** The foreground RGB string. */
+    fg: string;
+    /** The background RGB string. */
+    bg: string;
+}
+/**
+ * Audit multiple color pairs against WCAG contrast requirements.
+ * Returns results for each pair, making it easy to identify failing
+ * combinations during design system QA.
+ *
+ * @param pairs - Array of labeled color pairs to check
+ * @returns Array of audit results, one per input pair
+ *
+ * @example
+ * ```ts
+ * const results = auditContrast([
+ *   { label: "primary text on bg", fg: "79 70 229", bg: "255 255 255" },
+ *   { label: "muted text on bg", fg: "113 113 122", bg: "255 255 255" },
+ *   { label: "danger on white", fg: "220 38 38", bg: "255 255 255" },
+ * ]);
+ *
+ * // Filter to just the failures:
+ * const failures = results.filter((r) => !r.aa);
+ * ```
+ */
+declare function auditContrast(pairs: ColorPair[]): AuditResult[];
+/**
+ * Critical color pairs from the Unified UI light theme that must meet
+ * WCAG AA contrast. Use with `auditContrast()` for automated checks.
+ *
+ * @example
+ * ```ts
+ * const results = auditContrast(DS_LIGHT_CRITICAL_PAIRS);
+ * const failures = results.filter((r) => !r.aa);
+ * if (failures.length > 0) {
+ *   console.error("WCAG AA failures:", failures);
+ * }
+ * ```
+ */
+declare const DS_LIGHT_CRITICAL_PAIRS: ColorPair[];
+/**
+ * Critical color pairs from the Unified UI dark theme that must meet
+ * WCAG AA contrast. Use with `auditContrast()` for automated checks.
+ */
+declare const DS_DARK_CRITICAL_PAIRS: ColorPair[];
+
+export { type AuditResult, type ColorPair, type ContrastResult, DS_DARK_CRITICAL_PAIRS, DS_LIGHT_CRITICAL_PAIRS, type RGB, type TextSize, WCAG_AAA_LARGE, WCAG_AAA_NORMAL, WCAG_AA_LARGE, WCAG_AA_NORMAL, WCAG_NON_TEXT_AA, auditContrast, checkDSContrast, checkHexContrast, contrastRatio, meetsAA, meetsAAA, meetsNonTextAA, parseHex, parseRGBString, relativeLuminance, toRGBString };

package/dist/{chunk-5NZDQWRV.mjs → utils/contrast.mjs}

@@ -1,9 +1,8 @@
-// src/utils/contrast.ts
-var WCAG_AA_NORMAL = 4.5;
-var WCAG_AA_LARGE = 3;
-var WCAG_AAA_NORMAL = 7;
-var WCAG_AAA_LARGE = 4.5;
-var WCAG_NON_TEXT_AA = 3;
+const WCAG_AA_NORMAL = 4.5;
+const WCAG_AA_LARGE = 3;
+const WCAG_AAA_NORMAL = 7;
+const WCAG_AAA_LARGE = 4.5;
+const WCAG_NON_TEXT_AA = 3;
 function linearize(channel) {
   const normalized = channel / 255;
   if (normalized <= 0.04045) {
@@ -96,7 +95,7 @@ function auditContrast(pairs) {
     };
   });
 }
-var DS_LIGHT_CRITICAL_PAIRS = [
+const DS_LIGHT_CRITICAL_PAIRS = [
   // Primary text on backgrounds
   { label: "foreground on background", fg: "9 9 11", bg: "255 255 255" },
   { label: "primary on background", fg: "79 70 229", bg: "255 255 255" },
@@ -169,7 +168,7 @@ var DS_LIGHT_CRITICAL_PAIRS = [
     bg: "255 255 255"
   }
 ];
-var DS_DARK_CRITICAL_PAIRS = [
+const DS_DARK_CRITICAL_PAIRS = [
   // Primary text on backgrounds
   { label: "foreground on background", fg: "250 250 250", bg: "9 9 11" },
   // Primary shifted to brand.400 (129 140 248) for AA on dark bg (6.67:1)
@@ -236,13 +235,23 @@ var DS_DARK_CRITICAL_PAIRS = [
     bg: "9 9 11"
   }
 ];
-
-// src/utils/types.ts
-function dsDataAttrs(name) {
-  return {
-    "data-ds": true,
-    "data-ds-component": name
-  };
-}
-
-export { DS_DARK_CRITICAL_PAIRS, DS_LIGHT_CRITICAL_PAIRS, WCAG_AAA_LARGE, WCAG_AAA_NORMAL, WCAG_AA_LARGE, WCAG_AA_NORMAL, WCAG_NON_TEXT_AA, auditContrast, checkDSContrast, checkHexContrast, contrastRatio, dsDataAttrs, meetsAA, meetsAAA, meetsNonTextAA, parseHex, parseRGBString, relativeLuminance, toRGBString };
+export {
+  DS_DARK_CRITICAL_PAIRS,
+  DS_LIGHT_CRITICAL_PAIRS,
+  WCAG_AAA_LARGE,
+  WCAG_AAA_NORMAL,
+  WCAG_AA_LARGE,
+  WCAG_AA_NORMAL,
+  WCAG_NON_TEXT_AA,
+  auditContrast,
+  checkDSContrast,
+  checkHexContrast,
+  contrastRatio,
+  meetsAA,
+  meetsAAA,
+  meetsNonTextAA,
+  parseHex,
+  parseRGBString,
+  relativeLuminance,
+  toRGBString
+};

package/dist/utils/focus-ring.cjs

@@ -0,0 +1,81 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var focus_ring_exports = {};
+__export(focus_ring_exports, {
+  focusRingClassList: () => focusRingClassList,
+  focusRingClasses: () => focusRingClasses,
+  focusRingCompactClassList: () => focusRingCompactClassList,
+  focusRingCompactClasses: () => focusRingCompactClasses,
+  focusRingGroupRingClasses: () => focusRingGroupRingClasses,
+  focusRingGroupTriggerClasses: () => focusRingGroupTriggerClasses,
+  focusRingInsetClassList: () => focusRingInsetClassList,
+  focusRingInsetClasses: () => focusRingInsetClasses,
+  focusRingVariantOverrides: () => focusRingVariantOverrides,
+  focusWithinRingClassList: () => focusWithinRingClassList,
+  focusWithinRingClasses: () => focusWithinRingClasses
+});
+module.exports = __toCommonJS(focus_ring_exports);
+const focusRingClasses = "focus-visible:outline-none focus-visible:border-border-strong";
+const focusRingClassList = [
+  "focus-visible:outline-none",
+  "focus-visible:border-border-strong"
+];
+const focusRingInsetClasses = "focus-visible:outline-none focus-visible:border-border-strong";
+const focusRingInsetClassList = [
+  "focus-visible:outline-none",
+  "focus-visible:border-border-strong"
+];
+const focusRingCompactClasses = "focus-visible:outline-none focus-visible:border-border-strong";
+const focusRingCompactClassList = [
+  "focus-visible:outline-none",
+  "focus-visible:border-border-strong"
+];
+const focusRingVariantOverrides = {
+  /** Override focus border color to danger red */
+  danger: "focus-visible:border-danger",
+  /** Override focus border color to success green */
+  success: "focus-visible:border-success",
+  /** Override focus border color to warning amber */
+  warning: "focus-visible:border-warning",
+  /** Override focus border color to info blue */
+  info: "focus-visible:border-info",
+  /** Override focus border color to current text color */
+  current: "focus-visible:border-current"
+};
+const focusRingGroupTriggerClasses = "focus-visible:outline-none";
+const focusRingGroupRingClasses = "group-focus-visible:border-border-strong";
+const focusWithinRingClasses = "focus-within:outline-none focus-within:border-border-strong";
+const focusWithinRingClassList = [
+  "focus-within:outline-none",
+  "focus-within:border-border-strong"
+];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  focusRingClassList,
+  focusRingClasses,
+  focusRingCompactClassList,
+  focusRingCompactClasses,
+  focusRingGroupRingClasses,
+  focusRingGroupTriggerClasses,
+  focusRingInsetClassList,
+  focusRingInsetClasses,
+  focusRingVariantOverrides,
+  focusWithinRingClassList,
+  focusWithinRingClasses
+});

package/dist/utils/focus-ring.d.cts

@@ -0,0 +1,80 @@
+/**
+ * Standard focus classes for interactive elements.
+ * Uses `focus-visible` for keyboard-only visibility.
+ * Applies a subtle border-color shift — no ring or outline.
+ */
+declare const focusRingClasses: "focus-visible:outline-none focus-visible:border-border-strong";
+/**
+ * Array variant of the standard focus classes.
+ * Useful when building CVA base class arrays.
+ *
+ * @example
+ * ```ts
+ * const buttonVariants = cva([...focusRingClassList, "inline-flex"], { ... });
+ * ```
+ */
+declare const focusRingClassList: readonly ["focus-visible:outline-none", "focus-visible:border-border-strong"];
+/**
+ * Focus classes without ring-offset, for elements inside containers.
+ * Same subtle border-color shift as the standard variant.
+ */
+declare const focusRingInsetClasses: "focus-visible:outline-none focus-visible:border-border-strong";
+/**
+ * Array variant of the inset focus classes.
+ */
+declare const focusRingInsetClassList: readonly ["focus-visible:outline-none", "focus-visible:border-border-strong"];
+/**
+ * Compact focus classes. For small interactive elements.
+ * Same subtle treatment as the standard variant.
+ */
+declare const focusRingCompactClasses: "focus-visible:outline-none focus-visible:border-border-strong";
+/**
+ * Array variant of the compact focus classes.
+ */
+declare const focusRingCompactClassList: readonly ["focus-visible:outline-none", "focus-visible:border-border-strong"];
+/**
+ * Focus variant strings for use with error/success/warning states.
+ * Replace the border color with the appropriate semantic color.
+ *
+ * @example
+ * ```ts
+ * cn(
+ *   focusRingClasses,
+ *   hasError && focusRingVariantOverrides.danger,
+ * )
+ * ```
+ */
+declare const focusRingVariantOverrides: {
+    /** Override focus border color to danger red */
+    readonly danger: "focus-visible:border-danger";
+    /** Override focus border color to success green */
+    readonly success: "focus-visible:border-success";
+    /** Override focus border color to warning amber */
+    readonly warning: "focus-visible:border-warning";
+    /** Override focus border color to info blue */
+    readonly info: "focus-visible:border-info";
+    /** Override focus border color to current text color */
+    readonly current: "focus-visible:border-current";
+};
+type FocusRingVariant = keyof typeof focusRingVariantOverrides;
+/**
+ * Classes to apply on the focusable child element (add `group` to parent).
+ */
+declare const focusRingGroupTriggerClasses: "focus-visible:outline-none";
+/**
+ * Classes to apply on the parent element that shows the focus indicator.
+ * The parent must have the `group` class.
+ * Uses a subtle border-color shift on the parent when a child is focused.
+ */
+declare const focusRingGroupRingClasses: "group-focus-visible:border-border-strong";
+/**
+ * Focus indicator that activates when any descendant receives focus.
+ * Apply to the wrapper element (e.g., an input wrapper with icons).
+ */
+declare const focusWithinRingClasses: "focus-within:outline-none focus-within:border-border-strong";
+/**
+ * Array variant of the focus-within classes.
+ */
+declare const focusWithinRingClassList: readonly ["focus-within:outline-none", "focus-within:border-border-strong"];
+
+export { type FocusRingVariant, focusRingClassList, focusRingClasses, focusRingCompactClassList, focusRingCompactClasses, focusRingGroupRingClasses, focusRingGroupTriggerClasses, focusRingInsetClassList, focusRingInsetClasses, focusRingVariantOverrides, focusWithinRingClassList, focusWithinRingClasses };

package/dist/utils/focus-ring.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Standard focus classes for interactive elements.
+ * Uses `focus-visible` for keyboard-only visibility.
+ * Applies a subtle border-color shift — no ring or outline.
+ */
+declare const focusRingClasses: "focus-visible:outline-none focus-visible:border-border-strong";
+/**
+ * Array variant of the standard focus classes.
+ * Useful when building CVA base class arrays.
+ *
+ * @example
+ * ```ts
+ * const buttonVariants = cva([...focusRingClassList, "inline-flex"], { ... });
+ * ```
+ */
+declare const focusRingClassList: readonly ["focus-visible:outline-none", "focus-visible:border-border-strong"];
+/**
+ * Focus classes without ring-offset, for elements inside containers.
+ * Same subtle border-color shift as the standard variant.
+ */
+declare const focusRingInsetClasses: "focus-visible:outline-none focus-visible:border-border-strong";
+/**
+ * Array variant of the inset focus classes.
+ */
+declare const focusRingInsetClassList: readonly ["focus-visible:outline-none", "focus-visible:border-border-strong"];
+/**
+ * Compact focus classes. For small interactive elements.
+ * Same subtle treatment as the standard variant.
+ */
+declare const focusRingCompactClasses: "focus-visible:outline-none focus-visible:border-border-strong";
+/**
+ * Array variant of the compact focus classes.
+ */
+declare const focusRingCompactClassList: readonly ["focus-visible:outline-none", "focus-visible:border-border-strong"];
+/**
+ * Focus variant strings for use with error/success/warning states.
+ * Replace the border color with the appropriate semantic color.
+ *
+ * @example
+ * ```ts
+ * cn(
+ *   focusRingClasses,
+ *   hasError && focusRingVariantOverrides.danger,
+ * )
+ * ```
+ */
+declare const focusRingVariantOverrides: {
+    /** Override focus border color to danger red */
+    readonly danger: "focus-visible:border-danger";
+    /** Override focus border color to success green */
+    readonly success: "focus-visible:border-success";
+    /** Override focus border color to warning amber */
+    readonly warning: "focus-visible:border-warning";
+    /** Override focus border color to info blue */
+    readonly info: "focus-visible:border-info";
+    /** Override focus border color to current text color */
+    readonly current: "focus-visible:border-current";
+};
+type FocusRingVariant = keyof typeof focusRingVariantOverrides;
+/**
+ * Classes to apply on the focusable child element (add `group` to parent).
+ */
+declare const focusRingGroupTriggerClasses: "focus-visible:outline-none";
+/**
+ * Classes to apply on the parent element that shows the focus indicator.
+ * The parent must have the `group` class.
+ * Uses a subtle border-color shift on the parent when a child is focused.
+ */
+declare const focusRingGroupRingClasses: "group-focus-visible:border-border-strong";
+/**
+ * Focus indicator that activates when any descendant receives focus.
+ * Apply to the wrapper element (e.g., an input wrapper with icons).
+ */
+declare const focusWithinRingClasses: "focus-within:outline-none focus-within:border-border-strong";
+/**
+ * Array variant of the focus-within classes.
+ */
+declare const focusWithinRingClassList: readonly ["focus-within:outline-none", "focus-within:border-border-strong"];
+
+export { type FocusRingVariant, focusRingClassList, focusRingClasses, focusRingCompactClassList, focusRingCompactClasses, focusRingGroupRingClasses, focusRingGroupTriggerClasses, focusRingInsetClassList, focusRingInsetClasses, focusRingVariantOverrides, focusWithinRingClassList, focusWithinRingClasses };

package/dist/utils/focus-ring.mjs

@@ -0,0 +1,47 @@
+const focusRingClasses = "focus-visible:outline-none focus-visible:border-border-strong";
+const focusRingClassList = [
+  "focus-visible:outline-none",
+  "focus-visible:border-border-strong"
+];
+const focusRingInsetClasses = "focus-visible:outline-none focus-visible:border-border-strong";
+const focusRingInsetClassList = [
+  "focus-visible:outline-none",
+  "focus-visible:border-border-strong"
+];
+const focusRingCompactClasses = "focus-visible:outline-none focus-visible:border-border-strong";
+const focusRingCompactClassList = [
+  "focus-visible:outline-none",
+  "focus-visible:border-border-strong"
+];
+const focusRingVariantOverrides = {
+  /** Override focus border color to danger red */
+  danger: "focus-visible:border-danger",
+  /** Override focus border color to success green */
+  success: "focus-visible:border-success",
+  /** Override focus border color to warning amber */
+  warning: "focus-visible:border-warning",
+  /** Override focus border color to info blue */
+  info: "focus-visible:border-info",
+  /** Override focus border color to current text color */
+  current: "focus-visible:border-current"
+};
+const focusRingGroupTriggerClasses = "focus-visible:outline-none";
+const focusRingGroupRingClasses = "group-focus-visible:border-border-strong";
+const focusWithinRingClasses = "focus-within:outline-none focus-within:border-border-strong";
+const focusWithinRingClassList = [
+  "focus-within:outline-none",
+  "focus-within:border-border-strong"
+];
+export {
+  focusRingClassList,
+  focusRingClasses,
+  focusRingCompactClassList,
+  focusRingCompactClasses,
+  focusRingGroupRingClasses,
+  focusRingGroupTriggerClasses,
+  focusRingInsetClassList,
+  focusRingInsetClasses,
+  focusRingVariantOverrides,
+  focusWithinRingClassList,
+  focusWithinRingClasses
+};

package/dist/utils/index.cjs

@@ -0,0 +1,107 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  DS_DARK_CRITICAL_PAIRS: () => import_contrast.DS_DARK_CRITICAL_PAIRS,
+  DS_LIGHT_CRITICAL_PAIRS: () => import_contrast.DS_LIGHT_CRITICAL_PAIRS,
+  WCAG_AAA_LARGE: () => import_contrast.WCAG_AAA_LARGE,
+  WCAG_AAA_NORMAL: () => import_contrast.WCAG_AAA_NORMAL,
+  WCAG_AA_LARGE: () => import_contrast.WCAG_AA_LARGE,
+  WCAG_AA_NORMAL: () => import_contrast.WCAG_AA_NORMAL,
+  WCAG_NON_TEXT_AA: () => import_contrast.WCAG_NON_TEXT_AA,
+  auditContrast: () => import_contrast.auditContrast,
+  checkDSContrast: () => import_contrast.checkDSContrast,
+  checkHexContrast: () => import_contrast.checkHexContrast,
+  cn: () => import_cn.cn,
+  composeRefs: () => import_cn.composeRefs,
+  contrastRatio: () => import_contrast.contrastRatio,
+  dsAttr: () => import_cn.dsAttr,
+  dsColorVar: () => import_cn.dsColorVar,
+  dsDataAttrs: () => import_types.dsDataAttrs,
+  dsStateAttr: () => import_cn.dsStateAttr,
+  dsVar: () => import_cn.dsVar,
+  focusRingClassList: () => import_focus_ring.focusRingClassList,
+  focusRingClasses: () => import_focus_ring.focusRingClasses,
+  focusRingCompactClassList: () => import_focus_ring.focusRingCompactClassList,
+  focusRingCompactClasses: () => import_focus_ring.focusRingCompactClasses,
+  focusRingGroupRingClasses: () => import_focus_ring.focusRingGroupRingClasses,
+  focusRingGroupTriggerClasses: () => import_focus_ring.focusRingGroupTriggerClasses,
+  focusRingInsetClassList: () => import_focus_ring.focusRingInsetClassList,
+  focusRingInsetClasses: () => import_focus_ring.focusRingInsetClasses,
+  focusRingVariantOverrides: () => import_focus_ring.focusRingVariantOverrides,
+  focusWithinRingClassList: () => import_focus_ring.focusWithinRingClassList,
+  focusWithinRingClasses: () => import_focus_ring.focusWithinRingClasses,
+  meetsAA: () => import_contrast.meetsAA,
+  meetsAAA: () => import_contrast.meetsAAA,
+  meetsNonTextAA: () => import_contrast.meetsNonTextAA,
+  mergeSlots: () => import_cn.mergeSlots,
+  noop: () => import_cn.noop,
+  parseHex: () => import_contrast.parseHex,
+  parseRGBString: () => import_contrast.parseRGBString,
+  relativeLuminance: () => import_contrast.relativeLuminance,
+  toRGBString: () => import_contrast.toRGBString,
+  typedKeys: () => import_cn.typedKeys
+});
+module.exports = __toCommonJS(utils_exports);
+var import_cn = require("./cn");
+var import_contrast = require("./contrast");
+var import_focus_ring = require("./focus-ring");
+var import_types = require("./types");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DS_DARK_CRITICAL_PAIRS,
+  DS_LIGHT_CRITICAL_PAIRS,
+  WCAG_AAA_LARGE,
+  WCAG_AAA_NORMAL,
+  WCAG_AA_LARGE,
+  WCAG_AA_NORMAL,
+  WCAG_NON_TEXT_AA,
+  auditContrast,
+  checkDSContrast,
+  checkHexContrast,
+  cn,
+  composeRefs,
+  contrastRatio,
+  dsAttr,
+  dsColorVar,
+  dsDataAttrs,
+  dsStateAttr,
+  dsVar,
+  focusRingClassList,
+  focusRingClasses,
+  focusRingCompactClassList,
+  focusRingCompactClasses,
+  focusRingGroupRingClasses,
+  focusRingGroupTriggerClasses,
+  focusRingInsetClassList,
+  focusRingInsetClasses,
+  focusRingVariantOverrides,
+  focusWithinRingClassList,
+  focusWithinRingClasses,
+  meetsAA,
+  meetsAAA,
+  meetsNonTextAA,
+  mergeSlots,
+  noop,
+  parseHex,
+  parseRGBString,
+  relativeLuminance,
+  toRGBString,
+  typedKeys
+});

package/dist/utils/index.d.cts

@@ -0,0 +1,6 @@
+export { AsProp, PolymorphicProps, PolymorphicPropsWithRef, PolymorphicRef, SlotClasses, cn, composeRefs, dsAttr, dsColorVar, dsStateAttr, dsVar, mergeSlots, noop, typedKeys } from './cn.cjs';
+export { AuditResult, ColorPair, ContrastResult, DS_DARK_CRITICAL_PAIRS, DS_LIGHT_CRITICAL_PAIRS, RGB, TextSize, WCAG_AAA_LARGE, WCAG_AAA_NORMAL, WCAG_AA_LARGE, WCAG_AA_NORMAL, WCAG_NON_TEXT_AA, auditContrast, checkDSContrast, checkHexContrast, contrastRatio, meetsAA, meetsAAA, meetsNonTextAA, parseHex, parseRGBString, relativeLuminance, toRGBString } from './contrast.cjs';
+export { FocusRingVariant, focusRingClassList, focusRingClasses, focusRingCompactClassList, focusRingCompactClasses, focusRingGroupRingClasses, focusRingGroupTriggerClasses, focusRingInsetClassList, focusRingInsetClasses, focusRingVariantOverrides, focusWithinRingClassList, focusWithinRingClasses } from './focus-ring.cjs';
+export { ChildrenProps, ComponentIntent, ComponentSize, Defined, MergedProps, OptionalChildrenProps, PartialExcept, PolymorphicComponent, RenderChildrenProps, RequireKeys, SlotConfig, SlotDefinition, SlotRenderFn, Slots, VariantKey, dsDataAttrs } from './types.cjs';
+import 'clsx';
+import 'react';