@oprt/react 0.0.0-stage → 0.1.0

package/dist/UploadQueue/index.js

@@ -0,0 +1,7 @@
+// src/UploadQueue/index.ts
+import { UploadQueue } from "./UploadQueue.js";
+import { UploadQueueManifest } from "./UploadQueue.manifest.js";
+export {
+  UploadQueue,
+  UploadQueueManifest
+};

package/dist/_internal/MotionPopover.js

@@ -0,0 +1,113 @@
+"use client";
+
+// src/_internal/MotionPopover.tsx
+import {
+  Popover,
+  PopoverContext,
+  useSlottedContext
+} from "react-aria-components";
+import { useLayoutEffect, useEffect, useRef } from "react";
+import clsx from "clsx";
+import { useMergedRefs } from "./mergeRefs.js";
+import { jsx } from "react/jsx-runtime";
+function canTakeFocus(element) {
+  return !!element && element.isConnected && !element.matches(":disabled");
+}
+function PopoverSurface({
+  domProps,
+  isExiting,
+  triggerRef,
+  returnFocusRef,
+  trigger,
+  placement,
+  focusManagement
+}) {
+  const surface = useRef(null);
+  const surfaceRef = useMergedRefs(
+    surface,
+    // RAC hands over a callback or an object ref; a legacy string ref is not one it uses.
+    domProps.ref
+  );
+  const wasExiting = useRef(isExiting);
+  const restoreFocus = useRef(false);
+  const previousPlacement = useRef(placement);
+  useLayoutEffect(() => {
+    const node = surface.current;
+    if (!node) return;
+    if (previousPlacement.current && previousPlacement.current !== placement) {
+      node.setAttribute("data-oprt-repositioned", "");
+    }
+    previousPlacement.current = placement;
+    if (!isExiting) {
+      node.removeAttribute("inert");
+      node.removeAttribute("aria-hidden");
+      if (wasExiting.current) node.removeAttribute("data-oprt-repositioned");
+    }
+    if (isExiting && !wasExiting.current)
+      restoreFocus.current = node.contains(document.activeElement);
+    if (!isExiting && wasExiting.current && focusManagement === "automatic" && trigger !== "ComboBox" && !node.contains(document.activeElement)) {
+      const target = node.querySelector("[data-focused], [role=menu], [role=listbox]");
+      target?.focus({ preventScroll: true });
+    }
+    node.toggleAttribute("inert", isExiting);
+    if (isExiting) node.setAttribute("aria-hidden", "true");
+    if (!isExiting && focusManagement === "manual" && wasExiting.current) {
+      node.querySelector("[data-oprt-popover-dialog]")?.focus({ preventScroll: true });
+    }
+    wasExiting.current = isExiting;
+  }, [isExiting, trigger, triggerRef, placement, focusManagement]);
+  useEffect(() => {
+    if (focusManagement === "automatic" && isExiting && restoreFocus.current) {
+      const active = document.activeElement;
+      if (active === document.body || surface.current?.contains(active)) {
+        const opener = returnFocusRef?.current;
+        const target = canTakeFocus(opener) ? opener : triggerRef?.current;
+        target?.focus({ preventScroll: true });
+      }
+      restoreFocus.current = false;
+    }
+  }, [isExiting, triggerRef, returnFocusRef, focusManagement]);
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      ...domProps,
+      "aria-labelledby": focusManagement === "manual" ? void 0 : domProps["aria-labelledby"],
+      ref: surfaceRef
+    }
+  );
+}
+function MotionPopover({
+  motionState,
+  className,
+  focusManagement = "automatic",
+  returnFocusRef,
+  ...props
+}) {
+  const context = useSlottedContext(PopoverContext);
+  const triggerRef = props.triggerRef ?? context?.triggerRef;
+  const overlayPolicy = focusManagement === "manual" ? { disableFocusManagement: true } : {};
+  return /* @__PURE__ */ jsx(
+    Popover,
+    {
+      ...props,
+      ...overlayPolicy,
+      className: clsx("oprt-motion oprt-motion-popover", className),
+      ...motionState.props,
+      render: (domProps, { isExiting, trigger, placement }) => /* @__PURE__ */ jsx(
+        PopoverSurface,
+        {
+          domProps: { ...domProps, ...motionState.props },
+          isExiting,
+          trigger,
+          placement,
+          triggerRef,
+          returnFocusRef,
+          focusManagement
+        }
+      )
+    }
+  );
+}
+export {
+  MotionPopover
+};

package/dist/_internal/aria.js

@@ -0,0 +1,40 @@
+"use client";
+
+// src/_internal/aria.ts
+import { createElement, useCallback } from "react";
+import { useMergedRefs } from "./mergeRefs.js";
+function definedOnly(props) {
+  const out = {};
+  for (const [k, v] of Object.entries(props)) if (v !== void 0) out[k] = v;
+  return out;
+}
+function useAriaInvalidRef(forwarded, invalid) {
+  const sync = useCallback(
+    (node) => {
+      if (!node) return;
+      if (invalid) node.setAttribute("aria-invalid", "true");
+      else node.removeAttribute("aria-invalid");
+    },
+    [invalid]
+  );
+  return useMergedRefs(sync, forwarded);
+}
+function renderInvalidButton(invalid) {
+  return (props) => createElement("button", invalid ? { ...props, "aria-invalid": "true" } : props);
+}
+function switchValidationProps({
+  invalid,
+  required
+}) {
+  return {
+    ...invalid ? { isInvalid: true } : {},
+    ...required ? { isRequired: true } : {},
+    validationBehavior: "aria"
+  };
+}
+export {
+  definedOnly,
+  renderInvalidButton,
+  switchValidationProps,
+  useAriaInvalidRef
+};

package/dist/_internal/bytes.js

@@ -0,0 +1,18 @@
+// src/_internal/bytes.tsx
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function isByteCount(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+var NUMBER_UNIT_SPACE = "\xA0";
+function ByteCountLabel({ value }) {
+  if (!isByteCount(value)) return /* @__PURE__ */ jsx(Fragment, { children: "Invalid file size." });
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx("span", { className: "font-mono tabular-nums", children: value }),
+    `${NUMBER_UNIT_SPACE}bytes`
+  ] });
+}
+export {
+  ByteCountLabel,
+  NUMBER_UNIT_SPACE,
+  isByteCount
+};

package/dist/_internal/controlStyles.js

@@ -0,0 +1,26 @@
+// src/_internal/controlStyles.ts
+import { FORCED_ACTIVE_ROW, MENU_EMPTY, MENU_ROW, POPOVER_WIDTH } from "./overlay.js";
+var FORCED_NO_RESTING_OUTLINE = "forced-colors:[outline-style:none]";
+var FORCED_FOCUS_OUTLINE = "forced-colors:data-[focus-visible]:outline-solid forced-colors:data-[focus-visible]:outline-2 forced-colors:data-[focus-visible]:outline-offset-2 forced-colors:data-[focus-visible]:outline-[color:CanvasText]";
+var FORCED_FOCUS_WITHIN = "forced-colors:focus-within:outline-solid forced-colors:focus-within:outline-2 forced-colors:focus-within:outline-offset-2 forced-colors:focus-within:outline-[color:CanvasText]";
+var FORCED_CHECKBOX_BOX = "forced-colors:group-data-[focus-visible]/checkbox:outline-solid forced-colors:group-data-[focus-visible]/checkbox:outline-2 forced-colors:group-data-[focus-visible]/checkbox:outline-offset-2 forced-colors:group-data-[focus-visible]/checkbox:outline-[color:CanvasText] forced-colors:group-data-[disabled]/checkbox:border-[color:GrayText] forced-colors:group-data-[disabled]/checkbox:text-[color:GrayText]";
+var FORCED_RADIO = "forced-colors:data-[focus-visible]:[&_.oprt-radio-box]:outline-solid forced-colors:data-[focus-visible]:[&_.oprt-radio-box]:outline-2 forced-colors:data-[focus-visible]:[&_.oprt-radio-box]:outline-offset-2 forced-colors:data-[focus-visible]:[&_.oprt-radio-box]:outline-[color:CanvasText] forced-colors:data-[disabled]:text-[color:GrayText] forced-colors:data-[disabled]:[&_.oprt-radio-box]:border-[color:GrayText] forced-colors:data-[disabled]:[&_.oprt-radio-inner]:text-[color:GrayText]";
+var FORCED_SLIDER_TRACK = "forced-colors:[forced-color-adjust:none] forced-colors:border forced-colors:border-[color:CanvasText] forced-colors:bg-[color:Canvas] forced-colors:data-[disabled]:border-[color:GrayText]";
+var FORCED_SLIDER_FILL = "forced-colors:bg-[color:Highlight] forced-colors:data-[disabled]:bg-[color:GrayText]";
+var FORCED_SLIDER_THUMB = "forced-colors:bg-[color:Canvas] forced-colors:border-[color:CanvasText] forced-colors:group-data-[focus-visible]/slider:outline-solid forced-colors:group-data-[focus-visible]/slider:outline-2 forced-colors:group-data-[focus-visible]/slider:outline-offset-2 forced-colors:group-data-[focus-visible]/slider:outline-[color:CanvasText] forced-colors:group-data-[focus-visible]/slider:border-[color:CanvasText] forced-colors:group-data-[focus-visible]/slider:shadow-none forced-colors:group-data-[invalid]/slider:border-[color:CanvasText] forced-colors:group-data-[disabled]/slider:[&&]:border-[color:GrayText]";
+var LISTBOX_SURFACE = `z-50 min-w-[min(var(--trigger-width),calc(100vw-var(--oprt-space-4)))] ${POPOVER_WIDTH} overflow-auto overscroll-contain border border-oprt-accent bg-oprt-surface-1 font-sans shadow-oprt-focus`;
+var LISTBOX_ROW = `${MENU_ROW} cursor-pointer font-sans text-oprt-base font-medium normal-case text-oprt-text outline-hidden data-[focused]:bg-oprt-surface-3 data-[focus-visible]:border-oprt-border-focus data-[focus-visible]:shadow-oprt-focus data-[selected]:text-oprt-accent data-[disabled]:cursor-not-allowed data-[disabled]:opacity-50 ${FORCED_ACTIVE_ROW}`;
+var LISTBOX_EMPTY = MENU_EMPTY;
+export {
+  FORCED_CHECKBOX_BOX,
+  FORCED_FOCUS_OUTLINE,
+  FORCED_FOCUS_WITHIN,
+  FORCED_NO_RESTING_OUTLINE,
+  FORCED_RADIO,
+  FORCED_SLIDER_FILL,
+  FORCED_SLIDER_THUMB,
+  FORCED_SLIDER_TRACK,
+  LISTBOX_EMPTY,
+  LISTBOX_ROW,
+  LISTBOX_SURFACE
+};

package/dist/_internal/date.js

@@ -0,0 +1,179 @@
+// src/_internal/date.ts
+import {
+  CalendarDate,
+  parseDate,
+  Time,
+  fromAbsolute,
+  toCalendarDate,
+  toCalendarDateTime,
+  toZoned
+} from "@internationalized/date";
+import { isValidTimestamp } from "./timestamp.js";
+function parseTimeOnly(value) {
+  if (typeof value !== "string" || !/^(?:[01]\d|2[0-3]):[0-5]\d$/.test(value)) return null;
+  const [hour, minute] = value.split(":").map(Number);
+  return new Time(hour, minute);
+}
+function formatTimeOnly(value) {
+  return `${String(value.hour).padStart(2, "0")}:${String(value.minute).padStart(2, "0")}`;
+}
+function timeConfiguration(value, min, max) {
+  const time = parseTimeOnly(value);
+  const minimum = min === void 0 ? new Time(0, 0) : parseTimeOnly(min);
+  const maximum = max === void 0 ? new Time(23, 59) : parseTimeOnly(max);
+  const invalidBounds = !minimum || !maximum || minimum.compare(maximum) > 0;
+  const error = invalidBounds ? "Invalid time bounds. Use HH:mm times with the minimum before or equal to the maximum." : value !== null && !time ? "Invalid time. Use HH:mm from 00:00 through 23:59." : time && minimum && time.compare(minimum) < 0 ? `Choose a time at or after ${min}.` : time && maximum && time.compare(maximum) > 0 ? `Choose a time at or before ${max}.` : null;
+  return {
+    time,
+    min: invalidBounds ? new Time(0, 0) : minimum,
+    max: invalidBounds ? new Time(23, 59) : maximum,
+    invalidBounds,
+    error
+  };
+}
+function readTimeSegments(segments) {
+  const fields = ["hour", "minute"].map(
+    (type) => segments.find((segment) => segment.type === type)
+  );
+  if (fields.every((field) => field?.isPlaceholder))
+    return { value: null, empty: true, valid: true };
+  if (fields.some((field) => !field || field.isPlaceholder || field.value == null))
+    return { value: null, empty: false, valid: false };
+  const value = fields.map((field) => String(field.value).padStart(2, "0")).join(":");
+  return { value, empty: false, valid: !!parseTimeOnly(value) };
+}
+function validTimeZone(timeZone) {
+  if (typeof timeZone !== "string") return false;
+  if (!timeZone || timeZone.trim() !== timeZone || /^[+-]/.test(timeZone)) return false;
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone }).format(0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function validInstant(value) {
+  return isValidTimestamp(value, { integer: true });
+}
+function resolveWallTime(date, time, timeZone) {
+  if (!validTimeZone(timeZone))
+    return { status: "invalid", error: "Invalid time zone. Supply an IANA time zone." };
+  const day = parseDateOnly(date);
+  const clock = parseTimeOnly(time);
+  if (!day || !clock) return { status: "invalid", error: "Enter a complete, valid date and time." };
+  const wall = toCalendarDateTime(day, clock);
+  try {
+    const earlier = toZoned(wall, timeZone, "earlier");
+    const later = toZoned(wall, timeZone, "later");
+    if (toCalendarDateTime(earlier).compare(wall) !== 0 || toCalendarDateTime(later).compare(wall) !== 0) {
+      return {
+        status: "invalid",
+        error: `This time does not exist in ${timeZone} because the clock moves forward. Choose another time.`
+      };
+    }
+    return {
+      status: "valid",
+      earlier: earlier.toDate().getTime(),
+      later: later.toDate().getTime()
+    };
+  } catch {
+    return {
+      status: "invalid",
+      error: "This date and time cannot be resolved in the supplied zone."
+    };
+  }
+}
+function instantWallTime(value, timeZone) {
+  if (value === null) return { date: null, time: null, occurrence: null, error: null };
+  if (!validInstant(value))
+    return {
+      date: null,
+      time: null,
+      occurrence: null,
+      error: "Invalid instant. Supply finite epoch milliseconds."
+    };
+  if (!validTimeZone(timeZone))
+    return {
+      date: null,
+      time: null,
+      occurrence: null,
+      error: "Invalid time zone. Supply an IANA time zone."
+    };
+  try {
+    const zoned = fromAbsolute(value, timeZone);
+    const date = toCalendarDate(zoned).toString();
+    const time = formatTimeOnly(zoned);
+    if (zoned.toDate().getTime() !== value || !parseDateOnly(date))
+      return {
+        date: null,
+        time: null,
+        occurrence: null,
+        error: "The date must use a year from 0001 through 9999."
+      };
+    const resolved = resolveWallTime(date, time, timeZone);
+    let occurrence = null;
+    if (resolved.status === "valid" && resolved.earlier !== resolved.later) {
+      occurrence = fromAbsolute(resolved.later, timeZone).offset === zoned.offset ? "later" : "earlier";
+    }
+    return { date, time, occurrence, error: null };
+  } catch {
+    return {
+      date: null,
+      time: null,
+      occurrence: null,
+      error: "Invalid instant for the supplied time zone."
+    };
+  }
+}
+function parseDateOnly(value) {
+  if (typeof value !== "string" || !/^\d{4}-\d{2}-\d{2}$/.test(value)) return null;
+  try {
+    const date = parseDate(value);
+    return date.year >= 1 && date.year <= 9999 && date.toString() === value ? date : null;
+  } catch {
+    return null;
+  }
+}
+function dateConfiguration(value, min, max) {
+  const date = parseDateOnly(value);
+  const minimum = min === void 0 ? new CalendarDate(1, 1, 1) : parseDateOnly(min);
+  const maximum = max === void 0 ? new CalendarDate(9999, 12, 31) : parseDateOnly(max);
+  const invalidBounds = !minimum || !maximum || minimum.compare(maximum) > 0;
+  const error = invalidBounds ? "Invalid date bounds. Use YYYY-MM-DD dates with the minimum before or equal to the maximum." : value !== null && !date ? "Invalid date. Use a real Gregorian date in YYYY-MM-DD format." : date && minimum && date.compare(minimum) < 0 ? `Choose a date on or after ${min}.` : date && maximum && date.compare(maximum) > 0 ? `Choose a date on or before ${max}.` : null;
+  return {
+    date,
+    min: invalidBounds ? new CalendarDate(1, 1, 1) : minimum,
+    max: invalidBounds ? new CalendarDate(9999, 12, 31) : maximum,
+    invalidBounds,
+    error
+  };
+}
+function dateWithinBounds(date, min, max) {
+  return date.compare(min) >= 0 && date.compare(max) <= 0;
+}
+function readDateSegments(segments) {
+  const fields = ["year", "month", "day"].map(
+    (type) => segments.find((segment) => segment.type === type)
+  );
+  const empty = fields.every((field) => field?.isPlaceholder);
+  if (empty) return { value: null, empty: true, valid: true };
+  if (fields.some((field) => !field || field.isPlaceholder || field.value == null)) {
+    return { value: null, empty: false, valid: false };
+  }
+  const value = fields.map((field, index) => String(field.value).padStart(index === 0 ? 4 : 2, "0")).join("-");
+  return { value, empty: false, valid: parseDateOnly(value) !== null };
+}
+export {
+  dateConfiguration,
+  dateWithinBounds,
+  formatTimeOnly,
+  instantWallTime,
+  parseDateOnly,
+  parseTimeOnly,
+  readDateSegments,
+  readTimeSegments,
+  resolveWallTime,
+  timeConfiguration,
+  validInstant,
+  validTimeZone
+};

package/dist/_internal/devValidate.js

@@ -0,0 +1,51 @@
+// src/_internal/devValidate.ts
+import { SUGGESTION_OVERRIDES } from "./suggestions.js";
+var seen = /* @__PURE__ */ new Set();
+var own = (table, key) => Object.prototype.hasOwnProperty.call(table, key);
+function editorialSuggestion(component, prop, value) {
+  if (!own(SUGGESTION_OVERRIDES, component)) return void 0;
+  const byProp = SUGGESTION_OVERRIDES[component];
+  if (!own(byProp, prop)) return void 0;
+  const byValue = byProp[prop];
+  return own(byValue, value) ? byValue[value] : void 0;
+}
+function callingComponent() {
+  for (const frame of (new Error().stack ?? "").split("\n").slice(1)) {
+    if (/\/_internal\/|node_modules\/(?:\.pnpm\/[^/]*\/node_modules\/)?react(?:-dom)?\//.test(frame))
+      continue;
+    const file = /([^/\\()\s]+?)\.(?:[cm]?[jt]sx?)(?:\?[^:)\s]*)?:\d+:\d+\)?\s*$/.exec(frame)?.[1];
+    if (file !== void 0) return /^[A-Z]/.test(file) ? file : void 0;
+  }
+  return void 0;
+}
+function devValidate(component, manifestProps, received) {
+  if (process.env.NODE_ENV === "production") return;
+  for (const [prop, value] of Object.entries(received)) {
+    if (typeof value !== "string") continue;
+    const def = own(manifestProps, prop) ? manifestProps[prop] : void 0;
+    if (!def || def.type !== "enum") continue;
+    if (def.values.includes(value)) continue;
+    const key = `${component}.${prop}.${value}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    const suggestion = editorialSuggestion(component, prop, value) ?? `Valid values for \`${prop}\`: ${def.values.join(", ")}` + (def.default !== void 0 ? ` (default: ${def.default}).` : ".");
+    console.error(
+      JSON.stringify(
+        {
+          component,
+          error: "INVALID_PROP_VALUE",
+          prop,
+          received: value,
+          valid_values: def.values,
+          suggestion
+        },
+        null,
+        2
+      )
+    );
+  }
+}
+export {
+  callingComponent,
+  devValidate
+};

package/dist/_internal/fieldIds.js

@@ -0,0 +1,50 @@
+"use client";
+
+// src/_internal/fieldIds.ts
+import { createContext, useContext } from "react";
+import { useHydratedId } from "./hydration.js";
+var FieldContext = createContext(null);
+function joinIds(...ids) {
+  const joined = /* @__PURE__ */ new Set();
+  for (const id of ids) {
+    if (!id) continue;
+    for (const token of id.split(/\s+/)) if (token) joined.add(token);
+  }
+  return joined.size > 0 ? [...joined].join(" ") : void 0;
+}
+function usePartIds(parts, options = {}) {
+  const { id, readRendered } = options;
+  const generated = useHydratedId(() => id === void 0 ? readRendered?.() : void 0);
+  const base = id ?? generated;
+  const ids = { base };
+  for (const part of parts) ids[part] = `${base}-${part}`;
+  return ids;
+}
+function ariaInvalidValue(value) {
+  if (value === void 0) return void 0;
+  return value === true || value === "true";
+}
+function ariaInvalidToken(value) {
+  return typeof value === "string" && value !== "true" && value !== "false" ? value : void 0;
+}
+function useFieldWiring(own, options) {
+  const field = useContext(FieldContext);
+  const namedByField = options.label === "labelledby" && !own["aria-label"] && !options.ownLabel;
+  const invalid = own.invalid ?? ariaInvalidValue(own["aria-invalid"]) ?? field?.invalid ?? false;
+  return {
+    id: own.id ?? field?.id,
+    labelledBy: own["aria-labelledby"] ?? (namedByField ? field?.labelId : void 0),
+    describedBy: own["aria-describedby"] ?? field?.describedBy,
+    invalid,
+    // Its own `invalid` decides first, so a token shows only where `invalid` was not given.
+    ariaInvalid: invalid ? true : own.invalid == null ? ariaInvalidToken(own["aria-invalid"]) : void 0,
+    required: own.required ?? field?.required ?? false,
+    field
+  };
+}
+export {
+  FieldContext,
+  joinIds,
+  useFieldWiring,
+  usePartIds
+};

package/dist/_internal/hydration.js

@@ -0,0 +1,74 @@
+"use client";
+
+// src/_internal/hydration.ts
+import { useId, useRef, useState, useSyncExternalStore } from "react";
+import { useIsomorphicLayoutEffect } from "./useIsomorphicLayoutEffect.js";
+function keyForIds(...forwardedIds) {
+  return forwardedIds.join(" ");
+}
+var subscribeNoop = () => () => {
+};
+var getClientSnapshot = () => true;
+var getServerSnapshot = () => false;
+var PROBE_ATTRIBUTE = "data-oprt-hydration";
+function markupCarries(probe) {
+  for (const element of document.querySelectorAll(`[${PROBE_ATTRIBUTE}]`)) {
+    if (element.getAttribute(PROBE_ATTRIBUTE) === probe) return true;
+  }
+  return false;
+}
+var warnedAbout = /* @__PURE__ */ new Set();
+var HOOK_NAME = "useHydrationRoot";
+function callerOfHook() {
+  const lines = new Error().stack?.split("\n") ?? [];
+  const own = lines.findIndex((line) => line.includes(HOOK_NAME));
+  return (lines[own >= 0 ? own + 1 : 3] ?? "an unknown component").trim();
+}
+function warnProbeMissing(origin) {
+  const where = origin ?? "an unknown component";
+  if (warnedAbout.has(where)) return;
+  warnedAbout.add(where);
+  console.warn(
+    `${HOOK_NAME}: no element in the document carries this root's probeProps, so it remounts after every hydration and a keyboard user loses their place. Spread hydration.probeProps on an element the component renders. Called from ${where}`
+  );
+}
+function useHydrationRoot(...forwardedIds) {
+  const probe = useId();
+  const hydrated = useSyncExternalStore(subscribeNoop, getClientSnapshot, getServerSnapshot);
+  const hydratingMount = useRef();
+  if (hydratingMount.current === void 0) hydratingMount.current = !hydrated;
+  const [disagrees, setDisagrees] = useState(false);
+  const clientOnly = useRef(hydrated);
+  const origin = useRef();
+  if (process.env.NODE_ENV !== "production" && origin.current === void 0) {
+    origin.current = callerOfHook();
+  }
+  useIsomorphicLayoutEffect(() => {
+    if (!hydrated || !hydratingMount.current) return;
+    hydratingMount.current = false;
+    if (!markupCarries(probe)) setDisagrees(true);
+  }, [hydrated, probe]);
+  useIsomorphicLayoutEffect(() => {
+    if (process.env.NODE_ENV === "production" || !clientOnly.current) return;
+    if (!markupCarries(probe)) warnProbeMissing(origin.current);
+  }, [probe]);
+  return {
+    key: `${disagrees ? "client" : "server"} ${keyForIds(...forwardedIds)}`,
+    probeProps: { [PROBE_ATTRIBUTE]: probe }
+  };
+}
+function useHydratedId(readRenderedId) {
+  const reactId = useId();
+  const [renderedId, setRenderedId] = useState();
+  const read = useRef(readRenderedId);
+  useIsomorphicLayoutEffect(() => {
+    const id = read.current();
+    if (id && id !== reactId) setRenderedId(id);
+  }, [reactId]);
+  return renderedId ?? reactId;
+}
+export {
+  keyForIds,
+  useHydratedId,
+  useHydrationRoot
+};

package/dist/_internal/mergeRefs.js

@@ -0,0 +1,68 @@
+"use client";
+
+// src/_internal/mergeRefs.ts
+import {
+  useMemo,
+  useRef,
+  version
+} from "react";
+var supportsRefCleanup = Number.parseInt(version, 10) >= 19;
+function setRef(ref, node) {
+  if (typeof ref === "function") return ref(node);
+  if (ref !== null && typeof ref === "object") ref.current = node;
+}
+function mergeRefs(...refs) {
+  return (node) => {
+    if (node === null) {
+      for (const ref of refs) setRef(ref, null);
+      return;
+    }
+    const cleanups = refs.map((ref) => {
+      const result = setRef(ref, node);
+      return typeof result === "function" ? result : null;
+    });
+    if (!supportsRefCleanup) return;
+    return () => {
+      refs.forEach((ref, index) => {
+        const cleanup = cleanups[index];
+        if (cleanup) cleanup();
+        else setRef(ref, null);
+      });
+    };
+  };
+}
+function useMergedRefs(...refs) {
+  return useMemo(() => mergeRefs(...refs), refs);
+}
+function useInputRefObject(setNode) {
+  const node = useRef(null);
+  const cleanup = useRef(null);
+  return useMemo(
+    () => ({
+      get current() {
+        return node.current;
+      },
+      set current(next) {
+        const previous = node.current;
+        node.current = next;
+        if (previous !== null) {
+          const run = cleanup.current;
+          cleanup.current = null;
+          if (run) run();
+          else setNode(null);
+        }
+        if (next !== null) {
+          const result = setNode(next);
+          cleanup.current = typeof result === "function" ? result : null;
+        }
+      }
+    }),
+    [setNode]
+  );
+}
+export {
+  mergeRefs,
+  setRef,
+  useInputRefObject,
+  useMergedRefs
+};