@oprt/react 0.0.0-stage → 0.1.0

package/dist/_internal/motion.js

@@ -0,0 +1,138 @@
+"use client";
+
+// src/_internal/motion.ts
+import {
+  createContext,
+  useCallback,
+  useContext,
+  useEffect,
+  useRef,
+  useState
+} from "react";
+import { callingComponent, devValidate } from "./devValidate.js";
+var MotionContext = createContext("auto");
+var MOTION_VALUES = ["auto", "none"];
+var MOTION_PROPS = {
+  motion: { type: "enum", values: MOTION_VALUES, default: "auto" }
+};
+function useMotion(mode = "auto", component) {
+  if (process.env.NODE_ENV !== "production" && !MOTION_VALUES.includes(mode)) {
+    devValidate(component ?? callingComponent() ?? "OPERATOR component", MOTION_PROPS, {
+      motion: mode
+    });
+  }
+  const inherited = useContext(MotionContext);
+  const [ready, setReady] = useState(false);
+  const [keyboard, setKeyboard] = useState(false);
+  const pointer = useRef(false);
+  const frame = useRef();
+  const contactCleanup = useRef();
+  const clearContact = useCallback(() => {
+    contactCleanup.current?.();
+    contactCleanup.current = void 0;
+  }, []);
+  const cancel = useCallback(() => {
+    if (frame.current !== void 0) cancelAnimationFrame(frame.current);
+  }, []);
+  const afterPaint = useCallback(
+    (callback) => {
+      cancel();
+      frame.current = requestAnimationFrame(() => {
+        frame.current = requestAnimationFrame(() => {
+          frame.current = void 0;
+          callback();
+        });
+      });
+    },
+    [cancel]
+  );
+  useEffect(() => {
+    afterPaint(() => setReady(true));
+    return () => {
+      cancel();
+      clearContact();
+    };
+  }, [afterPaint, cancel, clearContact]);
+  const resume = useCallback(
+    () => afterPaint(() => {
+      setReady(true);
+      setKeyboard(false);
+      pointer.current = false;
+    }),
+    [afterPaint]
+  );
+  const handlers = {
+    onPointerDownCapture: (event) => {
+      cancel();
+      clearContact();
+      pointer.current = true;
+      setReady(true);
+      setKeyboard(false);
+      const root = event.currentTarget;
+      const release = (event2) => {
+        if (event2 && !root.contains(event2.target)) pointer.current = false;
+        clearContact();
+        resume();
+      };
+      const abandon = () => {
+        pointer.current = false;
+        release();
+      };
+      document.addEventListener("pointerup", release, true);
+      document.addEventListener("pointercancel", abandon, true);
+      window.addEventListener("blur", abandon);
+      contactCleanup.current = () => {
+        document.removeEventListener("pointerup", release, true);
+        document.removeEventListener("pointercancel", abandon, true);
+        window.removeEventListener("blur", abandon);
+      };
+    },
+    onKeyDownCapture: () => {
+      cancel();
+      pointer.current = false;
+      setKeyboard(true);
+    },
+    onKeyUpCapture: resume,
+    onBlurCapture: (event) => {
+      if (!event.currentTarget.contains(event.relatedTarget)) resume();
+    },
+    onClickCapture: (event) => {
+      if (event.detail === 0 && !pointer.current) setKeyboard(true);
+      resume();
+    }
+  };
+  const effective = mode === "none" || inherited === "none" || !ready || keyboard ? "none" : "auto";
+  return {
+    mode: effective,
+    props: { "data-oprt-motion": effective, ...handlers },
+    settleInput: () => {
+      cancel();
+      pointer.current = false;
+      setKeyboard(true);
+      resume();
+    }
+  };
+}
+function composeMotionHandlers(motion, consumer) {
+  const captures = { ...motion };
+  for (const key of [
+    "onPointerDownCapture",
+    "onKeyDownCapture",
+    "onKeyUpCapture",
+    "onBlurCapture",
+    "onClickCapture"
+  ]) {
+    const internal = motion[key];
+    const external = consumer[key];
+    captures[key] = ((event) => {
+      internal?.(event);
+      external?.(event);
+    });
+  }
+  return captures;
+}
+export {
+  MotionContext,
+  composeMotionHandlers,
+  useMotion
+};

package/dist/_internal/navigationLandmark.js

@@ -0,0 +1,13 @@
+"use client";
+
+// src/_internal/navigationLandmark.ts
+import { createContext, useContext } from "react";
+var InsideNavigationLandmarkContext = createContext(false);
+var InsideNavigationLandmarkProvider = InsideNavigationLandmarkContext.Provider;
+function useInsideNavigationLandmark() {
+  return useContext(InsideNavigationLandmarkContext);
+}
+export {
+  InsideNavigationLandmarkProvider,
+  useInsideNavigationLandmark
+};

package/dist/_internal/numberText.js

@@ -0,0 +1,176 @@
+"use client";
+
+// src/_internal/numberText.tsx
+import { Fragment } from "react";
+import clsx from "clsx";
+import { jsx, jsxs } from "react/jsx-runtime";
+var DIGIT = "\\p{Nd}";
+var SPACE = "[\\u00a0\\u202f\\u2009 ]";
+var NO_BREAK = "[\\u00a0\\u202f\\u2009]";
+var BIDI = "[\\u200e\\u200f\\u061c]*";
+var SIGN = "[+\\-\\u2212\\u00b1~\\u2248<>\\u2264\\u2265]{1,2}";
+var CURRENCY = `(?:(?:[A-Z]{1,3}\\p{Sc}|\\p{Sc})${SPACE}?|[A-Z]{3}${SPACE})`;
+var PERCENT_FIRST = `[%\\u2030\\u066a]${SPACE}?`;
+var PREFIX = `${BIDI}(?:${SIGN})?${BIDI}(?:${CURRENCY}|${PERCENT_FIRST})?(?:${SIGN})?`;
+var SEPARATOR = "[,\\u00a0\\u202f\\u2009'\\u2019\\u066c ]";
+var DECIMAL = "[.,\\u066b]";
+var EXPONENT = `(?:[eE][+\\-\\u2212]?${DIGIT}+)?`;
+var LETTER = "(?:\\p{L}\\p{M}*)";
+var LETTERS = `${LETTER}{1,3}`;
+var SUFFIX = `(?:${[
+  // A degree or prime mark and its letter (the C of 12 degrees C), and the Devanagari abbreviation
+  // sign that hi-IN ends it with.
+  `${SPACE}?${BIDI}[\\u00b0\\u2032\\u2033]${LETTER}?\\u0970?`,
+  // A percent or per mille sign, which may follow a space.
+  `${SPACE}?${BIDI}[%\\u2030\\u066a]`,
+  // A currency sign, which may follow a space and be followed by a country ($US, $ US).
+  `${SPACE}?${BIDI}\\p{Sc}(?:${NO_BREAK}?${LETTERS})?`,
+  // A currency sign of up to three letters (US$), which may follow a space.
+  `${SPACE}?${BIDI}\\p{L}{1,3}\\p{Sc}`,
+  // One to three letters (k, M, kPa, kr, a code such as USD), attached or after a no-break space.
+  `${NO_BREAK}?${BIDI}${LETTERS}`,
+  // A unit divided by another (km/h) or raised to a power (m/s squared), written against the digits.
+  // After a space the unit is read word by word (readNumber), as before.
+  `${LETTERS}[/\\u00b7\\u22c5]${LETTERS}[\\u00b2\\u00b3]?`
+].join("|")})?`;
+var REST = `(?:${DECIMAL}${DIGIT}+)?${EXPONENT}${SUFFIX}${BIDI}`;
+var NUMBER = {
+  // 1,234,567.89 and 1 234 567,89: groups of three, however they are separated.
+  western: new RegExp(
+    `^(${PREFIX}${DIGIT}{1,3})((${SEPARATOR})${DIGIT}{3}(?:\\3${DIGIT}{3})*)(${REST})$`,
+    "u"
+  ),
+  // 12,34,567.89 (Indian lakh grouping): a last group of three, groups of two before it.
+  indian: new RegExp(
+    `^(${PREFIX}${DIGIT}{1,2})((${SEPARATOR})${DIGIT}{2}(?:\\3${DIGIT}{2})*\\3${DIGIT}{3})(${REST})$`,
+    "u"
+  ),
+  // 1.234.567,89: dots group, a comma is the decimal mark. One dot group needs the comma, so that a
+  // decimal like 1.234 is never taken for 1234.
+  dotted: new RegExp(
+    `^(${PREFIX}${DIGIT}{1,3})((?:\\.${DIGIT}{3})+)((?:,${DIGIT}+)?${EXPONENT}${SUFFIX}${BIDI})$`,
+    "u"
+  ),
+  // Not grouped: digits with an optional decimal part. It never breaks at all.
+  plain: new RegExp(
+    `^${PREFIX}(?:${DIGIT}+(?:${DECIMAL}${DIGIT}+)?|${DECIMAL}${DIGIT}+)${EXPONENT}${SUFFIX}${BIDI}$`,
+    "u"
+  )
+};
+var GROUP = new RegExp(`(${SEPARATOR})(${DIGIT}+)`, "gu");
+var EXACT_DIGITS = 15;
+var WHOLE_DIGITS = /(?:^|[^.,\u066b\p{Nd}])(\p{Nd}+)/u;
+var SIMPLE_NUMBER = /^[+-]?\d{1,15}(?:\.\d+)?$/;
+function numberParts(text) {
+  if (SIMPLE_NUMBER.test(text)) return { lead: [], tail: text };
+  for (const kind of ["western", "indian", "dotted"]) {
+    const match = NUMBER[kind].exec(text);
+    if (!match) continue;
+    const rest = match[match.length - 1];
+    const groups = Array.from(match[2].matchAll(kind === "dotted" ? /(\.)(\p{Nd}+)/gu : GROUP));
+    if (kind === "dotted" && groups.length < 2 && !rest.startsWith(",")) continue;
+    const lead = [];
+    let digits = match[1];
+    for (const [, separator, next] of groups) {
+      lead.push(digits + separator);
+      digits = next;
+    }
+    return { lead, tail: digits + rest };
+  }
+  if (!NUMBER.plain.test(text)) return null;
+  return (WHOLE_DIGITS.exec(text)?.[1].length ?? 0) > EXACT_DIGITS ? null : { lead: [], tail: text };
+}
+function unitWords(unit) {
+  const trimmed = unit?.trim();
+  if (!trimmed) return null;
+  const space = trimmed.search(/\s/);
+  return space === -1 ? { first: trimmed, rest: "" } : { first: trimmed.slice(0, space), rest: trimmed.slice(space).trim() };
+}
+var segmenter = typeof Intl !== "undefined" && "Segmenter" in Intl ? new Intl.Segmenter(void 0, { granularity: "grapheme" }) : null;
+function splitLast(text) {
+  if (segmenter) {
+    let start = 0;
+    let last2 = "";
+    for (const { segment, index } of segmenter.segment(text)) {
+      start = index;
+      last2 = segment;
+    }
+    return [text.slice(0, start), last2];
+  }
+  const characters = Array.from(text);
+  const last = characters.pop() ?? "";
+  return [characters.join(""), last];
+}
+var GAP = /[\u0020\u00a0\u202f\u2009]+/gu;
+var STARTS_WITH_DIGIT = /^\p{Nd}/u;
+var FIRST_WORD = /^\S+/u;
+var UNIT_CHARACTERS = /^[\p{L}\p{M}%\u2030\u00b0\u2032\u2033/\u00b7\u22c5\u00b2\u00b3\u00b9\u2070-\u2079\u207b()'.-]{1,8}$/u;
+var UNIT_MARK = /[\p{L}%\u2030\u00b0]/u;
+var isUnitWord = (word) => UNIT_CHARACTERS.test(word) && UNIT_MARK.test(word);
+function readNumber(value, unit) {
+  if (typeof value !== "string" && typeof value !== "number") return null;
+  const text = String(value).trim();
+  const words = unitWords(unit);
+  const whole = numberParts(text);
+  if (words) {
+    return whole && { ...whole, gap: " ", first: words.first, rest: words.rest && ` ${words.rest}` };
+  }
+  if (whole) return { ...whole, gap: "", first: "", rest: "" };
+  const gaps = Array.from(text.matchAll(GAP)).reverse();
+  for (const gap of gaps) {
+    const after = text.slice(gap.index + gap[0].length);
+    if (!after || STARTS_WITH_DIGIT.test(after)) continue;
+    const parts = numberParts(text.slice(0, gap.index));
+    if (!parts) continue;
+    const first = FIRST_WORD.exec(after)[0];
+    return isUnitWord(first) ? { ...parts, gap: gap[0], first, rest: after.slice(first.length) } : { ...parts, gap: "", first: "", rest: gap[0] + after };
+  }
+  return null;
+}
+var isNumberText = (value) => readNumber(value) !== null;
+function NumberText(props) {
+  return numberText(props);
+}
+function numberText({ value, unit, className }) {
+  const reading = readNumber(value, unit);
+  if (!reading) {
+    const text = String(value);
+    const words = unitWords(unit);
+    if (!words) return /* @__PURE__ */ jsx("span", { className, children: text });
+    const [head, last] = splitLast(text);
+    return /* @__PURE__ */ jsxs("span", { className, children: [
+      head,
+      /* @__PURE__ */ jsx("span", { className: "whitespace-nowrap", children: `${last}\xA0${words.first}` }),
+      words.rest && ` ${words.rest}`
+    ] });
+  }
+  const { lead, tail, gap, first, rest } = reading;
+  const run = tail + gap + first;
+  if (lead.length === 0 && !rest) {
+    return /* @__PURE__ */ jsx(
+      "span",
+      {
+        "data-oprt-number": "",
+        className: className?.includes("whitespace-nowrap") && className.split(/\s+/).includes("whitespace-nowrap") ? className : clsx(className, "whitespace-nowrap"),
+        children: run
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs("span", { "data-oprt-number": "", className, children: [
+    lead.map((piece, index) => /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx("span", { className: "whitespace-nowrap", children: piece }),
+      /* @__PURE__ */ jsx("wbr", {})
+    ] }, index)),
+    /* @__PURE__ */ jsx("span", { "data-oprt-number-run": "", className: "whitespace-nowrap", children: run }),
+    rest
+  ] });
+}
+export {
+  NumberText,
+  isNumberText,
+  numberParts,
+  numberText,
+  readNumber,
+  splitLast,
+  unitWords
+};

package/dist/_internal/overlay.js

@@ -0,0 +1,53 @@
+"use client";
+
+// src/_internal/overlay.ts
+import { cva } from "class-variance-authority";
+import { Fragment, isValidElement } from "react";
+function toPlacement(side, align) {
+  if (align === "center") return side;
+  if (side === "left" || side === "right") return `${side} ${align === "start" ? "top" : "bottom"}`;
+  return `${side} ${align}`;
+}
+var SCREEN_MARGIN = 16;
+var CONTENT_WIDTH_ABOVE_OR_BELOW = "data-[placement=top]:w-max data-[placement=bottom]:w-max";
+var MARGIN_BESIDE = "data-[placement=left]:ml-2u data-[placement=right]:mr-2u";
+var TOOLTIP_WIDTH = `max-w-[min(20rem,calc(100vw-var(--oprt-space-4)))] ${CONTENT_WIDTH_ABOVE_OR_BELOW} ${MARGIN_BESIDE}`;
+var POPOVER_WIDTH = `max-w-[min(var(--oprt-popover-max-width,30rem),calc(100vw-var(--oprt-space-4)))] ${CONTENT_WIDTH_ABOVE_OR_BELOW} ${MARGIN_BESIDE}`;
+var MENU_OFFSET = 4;
+var MENU_SURFACE = `z-50 min-w-[10rem] ${POPOVER_WIDTH} overflow-y-auto overscroll-contain border border-oprt-border bg-oprt-surface-1 py-1u font-sans`;
+var MENU_ROW = "flex min-h-oprt-md items-center justify-between gap-3u border border-transparent px-3u py-[calc((var(--oprt-height-md)-2px-var(--oprt-line-base))/2)]";
+var FORCED_ACTIVE_ROW = "forced-colors:[outline-style:none] forced-colors:data-[focused]:[forced-color-adjust:none] forced-colors:data-[focused]:bg-[color:Highlight] forced-colors:data-[focused]:border-[color:Highlight] forced-colors:data-[focused]:text-[color:HighlightText] forced-colors:data-[focused]:shadow-none forced-colors:data-[disabled]:text-[color:GrayText]";
+var menuItemStyles = cva(
+  `${MENU_ROW} text-oprt-base font-medium outline-hidden cursor-pointer data-[focused]:bg-oprt-surface-3 data-[focus-visible]:border-oprt-border-focus data-[focus-visible]:shadow-oprt-focus data-[disabled]:opacity-50 data-[disabled]:cursor-not-allowed ${FORCED_ACTIVE_ROW}`,
+  {
+    variants: { danger: { true: "text-oprt-error", false: "text-oprt-text" } },
+    defaultVariants: { danger: false }
+  }
+);
+var MENU_ITEM_TEXT = "min-w-0 oprt-wrap-anywhere";
+var MENU_ITEM_LABEL = "uppercase tracking-oprt-caps [&_code]:normal-case [&_code]:tracking-normal [&_kbd]:normal-case [&_kbd]:tracking-normal";
+var MENU_ITEM_DESCRIPTION = "block text-oprt-sm normal-case tracking-normal";
+var DESTRUCTIVE_ACTION = "Destructive action";
+var MENU_ITEM_SHORTCUT = "shrink-0 font-mono text-oprt-sm normal-case tracking-normal text-oprt-text-dim forced-colors:[color:inherit]";
+var MENU_EMPTY = "m-0 px-3u py-2u text-oprt-base normal-case text-oprt-text-dim";
+function isSingleElement(node) {
+  return isValidElement(node) && node.type !== Fragment;
+}
+export {
+  DESTRUCTIVE_ACTION,
+  FORCED_ACTIVE_ROW,
+  MENU_EMPTY,
+  MENU_ITEM_DESCRIPTION,
+  MENU_ITEM_LABEL,
+  MENU_ITEM_SHORTCUT,
+  MENU_ITEM_TEXT,
+  MENU_OFFSET,
+  MENU_ROW,
+  MENU_SURFACE,
+  POPOVER_WIDTH,
+  SCREEN_MARGIN,
+  TOOLTIP_WIDTH,
+  isSingleElement,
+  menuItemStyles,
+  toPlacement
+};

package/dist/_internal/segmentField.js

@@ -0,0 +1,125 @@
+"use client";
+
+// src/_internal/segmentField.ts
+import {
+  createContext,
+  useCallback,
+  useRef,
+  useState
+} from "react";
+import { useIsomorphicLayoutEffect } from "./useIsomorphicLayoutEffect.js";
+function sameSnapshot(a, b) {
+  return a.value === b.value && a.empty === b.empty && a.valid === b.valid;
+}
+function useReportSegments(segments, read, report) {
+  const last = useRef(null);
+  useIsomorphicLayoutEffect(() => {
+    const snapshot = read(segments);
+    const previous = last.current;
+    if (previous && previous.report === report && sameSnapshot(previous.snapshot, snapshot)) return;
+    last.current = { snapshot, report };
+    report(snapshot);
+  }, [segments, read, report]);
+}
+function firstSegmentFocus(disabled, keep) {
+  return {
+    tabIndex: -1,
+    onFocus: (event) => {
+      if (event.target !== event.currentTarget || disabled || keep?.(event)) return;
+      event.currentTarget.querySelector("[role=spinbutton]")?.focus();
+    }
+  };
+}
+var FIELD_BOX_STYLES = "flex min-h-oprt-md min-w-0 items-center border border-oprt-border-control bg-oprt-surface-2 px-1u focus-visible:outline-hidden data-[focus-visible]:border-oprt-border-focus data-[focus-visible]:shadow-oprt-focus data-[invalid]:border-oprt-error data-[disabled]:cursor-not-allowed data-[disabled]:text-oprt-text-dim";
+var SEGMENT_STYLES = "flex min-h-3u min-w-3u items-center justify-center px-0.5u font-mono text-oprt-base font-medium tabular-nums focus:outline-hidden forced-colors:data-[focused]:outline-solid forced-colors:data-[focused]:outline-2 forced-colors:data-[focused]:-outline-offset-2 forced-colors:data-[focused]:outline-[CanvasText] data-[type=literal]:min-w-0 data-[type=literal]:px-0 data-[placeholder]:text-oprt-text-placeholder data-[disabled]:data-[placeholder]:text-oprt-text-dim data-[focused]:bg-oprt-surface-3 data-[focus-visible]:shadow-oprt-focus data-[disabled]:cursor-not-allowed";
+var FIELD_LABEL_STYLES = "m-0 min-w-0 font-medium oprt-wrap-anywhere";
+var FIELD_COLUMNS = "grid min-w-0 grid-cols-[repeat(auto-fit,minmax(min(100%,calc(24*var(--oprt-space-1))),1fr))] items-start gap-2u";
+var EDITING_KEYS = /* @__PURE__ */ new Set([
+  "Backspace",
+  "Delete",
+  "ArrowUp",
+  "ArrowDown",
+  "PageUp",
+  "PageDown",
+  "Home",
+  "End"
+]);
+function isEditingKey(event) {
+  return !event.altKey && !event.ctrlKey && !event.metaKey && (/^[0-9]$/.test(event.key) || EDITING_KEYS.has(event.key));
+}
+function useSegmentDraft({
+  value,
+  displayed,
+  valid,
+  inactive
+}) {
+  const initial = {
+    base: value,
+    snapshot: { value: displayed, empty: displayed === null, valid },
+    rejected: false,
+    rejection: null
+  };
+  const [draft, setDraft] = useState(initial);
+  const current = draft.base === value ? draft : initial;
+  const raw = useRef(current.snapshot);
+  const rejectBlur = useRef(false);
+  const report = useCallback(
+    (snapshot) => {
+      raw.current = snapshot;
+      setDraft(
+        (previous) => previous.base === value && sameSnapshot(previous.snapshot, snapshot) ? previous : previous.base === value ? { ...previous, snapshot } : { base: value, snapshot, rejected: false, rejection: null }
+      );
+    },
+    [value]
+  );
+  const beginEdit = () => {
+    if (inactive) return;
+    rejectBlur.current = false;
+    setDraft(
+      (previous) => previous.rejected ? { ...previous, rejected: false, rejection: null } : previous
+    );
+  };
+  return {
+    snapshot: current.snapshot,
+    rejected: current.rejected,
+    /** The message for the rejected edit, or null to use the field's general one. */
+    rejection: current.rejected ? current.rejection : null,
+    /** The field holds something other than `value`: an edit, or a rejected one. */
+    pending: current.rejected || current.snapshot.value !== displayed || current.snapshot.empty !== (displayed === null),
+    report,
+    editProps: {
+      onKeyDownCapture: (event) => {
+        if (isEditingKey(event)) beginEdit();
+      },
+      onBeforeInputCapture: beginEdit,
+      onBlurCapture: (event) => {
+        if (event.currentTarget.contains(event.relatedTarget)) return;
+        rejectBlur.current = !raw.current.valid;
+        if (rejectBlur.current)
+          setDraft((previous) => ({ ...previous, rejected: true, rejection: null }));
+      }
+    },
+    /** Whether React Aria's next change is the constrained value it emits after a rejected blur. */
+    blurRejected: () => rejectBlur.current,
+    /** Starts a new choice (opening the calendar): React Aria's next change is the operator's. */
+    releaseBlur: () => {
+      rejectBlur.current = false;
+    },
+    /** Rejects the operator's edit, with a message that says why (the bound it crossed), if any. */
+    reject: (message) => setDraft((previous) => ({ ...previous, rejected: true, rejection: message ?? null })),
+    accept: () => setDraft((previous) => ({ ...previous, rejected: false, rejection: null }))
+  };
+}
+var SegmentGroupContext = createContext(null);
+export {
+  FIELD_BOX_STYLES,
+  FIELD_COLUMNS,
+  FIELD_LABEL_STYLES,
+  SEGMENT_STYLES,
+  SegmentGroupContext,
+  firstSegmentFocus,
+  isEditingKey,
+  sameSnapshot,
+  useReportSegments,
+  useSegmentDraft
+};

package/dist/_internal/suggestions.js

@@ -0,0 +1,20 @@
+// src/_internal/suggestions.ts
+var SUGGESTION_OVERRIDES = {
+  Button: {
+    variant: {
+      success: "'success' is not a Button variant. Use variant='primary' for positive actions, or a Badge (variant='success') to display status.",
+      error: "'error' is not a Button variant. Use variant='danger' for destructive actions.",
+      warning: "'warning' is not a Button variant. Use variant='danger', or an Alert/Badge to display status.",
+      info: "'info' is not a Button variant. Use variant='secondary' or 'tertiary'."
+    }
+  },
+  Badge: {
+    variant: {
+      primary: "'primary' is not a Badge variant. Use 'neutral', or a status variant (success/warning/error/info).",
+      danger: "'danger' is not a Badge variant. Use 'error' for failed/critical status."
+    }
+  }
+};
+export {
+  SUGGESTION_OVERRIDES
+};

package/dist/_internal/timestamp.js

@@ -0,0 +1,25 @@
+// src/_internal/timestamp.ts
+var MAX_TIME = 864e13;
+function isValidTimestamp(value, options = {}) {
+  if (typeof value !== "number" || !Number.isFinite(value) || Math.abs(value) > MAX_TIME) {
+    return false;
+  }
+  if (options.integer === true && !Number.isInteger(value)) return false;
+  if (options.years === "1-9999") {
+    const year = new Date(value).getUTCFullYear();
+    if (year < 1 || year > 9999) return false;
+  }
+  return true;
+}
+function formatUtcTimestamp(value, options = {}) {
+  if (!isValidTimestamp(value)) return null;
+  const iso = new Date(value).toISOString();
+  const separator = iso.indexOf("T");
+  const clock = iso.slice(separator + 1, -1);
+  const shown = options.precision === "milliseconds" ? clock : clock.slice(0, 8);
+  return `${iso.slice(0, separator)} ${shown} UTC`;
+}
+export {
+  formatUtcTimestamp,
+  isValidTimestamp
+};

package/dist/_internal/unavailable.js

@@ -0,0 +1,13 @@
+"use client";
+
+// src/_internal/unavailable.ts
+import { createContext, useContext } from "react";
+var FocusableWhenUnavailableContext = createContext(false);
+var FocusableWhenUnavailableProvider = FocusableWhenUnavailableContext.Provider;
+function useFocusableWhenUnavailable() {
+  return useContext(FocusableWhenUnavailableContext);
+}
+export {
+  FocusableWhenUnavailableProvider,
+  useFocusableWhenUnavailable
+};

package/dist/_internal/useActionFocus.js

@@ -0,0 +1,27 @@
+"use client";
+
+// src/_internal/useActionFocus.ts
+import {
+  useImperativeHandle,
+  useRef
+} from "react";
+import { useRestoreFocusOnRemoval } from "./useRestoreFocusOnRemoval.js";
+function useActionFocus(ref, { onFocusCapture, onBlurCapture } = {}) {
+  const root = useRef(null);
+  useImperativeHandle(ref, () => root.current, []);
+  const restore = useRestoreFocusOnRemoval(root);
+  return {
+    ref: root,
+    onFocusCapture: (event) => {
+      onFocusCapture?.(event);
+      restore.onFocusCapture(event);
+    },
+    onBlurCapture: (event) => {
+      onBlurCapture?.(event);
+      restore.onBlurCapture(event);
+    }
+  };
+}
+export {
+  useActionFocus
+};

package/dist/_internal/useElementWidth.js

@@ -0,0 +1,37 @@
+"use client";
+
+// src/_internal/useElementWidth.ts
+import { useEffect, useRef, useState } from "react";
+import { useIsomorphicLayoutEffect } from "./useIsomorphicLayoutEffect.js";
+function createResizeObserver(callback) {
+  return typeof ResizeObserver === "undefined" ? null : new ResizeObserver(callback);
+}
+function useElementWidth(ref, { initial, min = 0, select }) {
+  const [value, setValue] = useState(initial);
+  const measured = useRef(null);
+  const latest = useRef({ min, select });
+  useIsomorphicLayoutEffect(() => {
+    latest.current = { min, select };
+  });
+  useEffect(() => {
+    const element = ref.current;
+    if (!element) return;
+    const observer = createResizeObserver((entries) => {
+      const width = entries[entries.length - 1]?.contentRect.width;
+      if (width === void 0 || !Number.isFinite(width) || width <= latest.current.min) return;
+      measured.current = width;
+      const choose = latest.current.select;
+      setValue(choose ? choose(width) : width);
+    });
+    observer?.observe(element);
+    return () => observer?.disconnect();
+  }, [ref]);
+  useEffect(() => {
+    if (select && measured.current !== null) setValue(select(measured.current));
+  }, [select]);
+  return value;
+}
+export {
+  createResizeObserver,
+  useElementWidth
+};

package/dist/_internal/useIsMounted.js

@@ -0,0 +1,18 @@
+"use client";
+
+// src/_internal/useIsMounted.ts
+import { useCallback, useRef } from "react";
+import { useIsomorphicLayoutEffect } from "./useIsomorphicLayoutEffect.js";
+function useIsMounted() {
+  const mounted = useRef(false);
+  useIsomorphicLayoutEffect(() => {
+    mounted.current = true;
+    return () => {
+      mounted.current = false;
+    };
+  }, []);
+  return useCallback(() => mounted.current, []);
+}
+export {
+  useIsMounted
+};

package/dist/_internal/useIsomorphicLayoutEffect.js

@@ -0,0 +1,8 @@
+"use client";
+
+// src/_internal/useIsomorphicLayoutEffect.ts
+import { useEffect, useLayoutEffect } from "react";
+var useIsomorphicLayoutEffect = typeof document === "undefined" ? useEffect : useLayoutEffect;
+export {
+  useIsomorphicLayoutEffect
+};