4f:I[314491,["/_next/static/immutable/chunks/3arlv5bvukoo2.js","/_next/static/immutable/chunks/39v64hmfyo-sr.js","/_next/static/immutable/chunks/2nvof3-29tvc3.js","/_next/static/immutable/chunks/3tjobt77z_9dj.js","/_next/static/immutable/chunks/04j_o97cgxn2x.js","/_next/static/immutable/chunks/3upr08c9vtj8w.js","/_next/static/immutable/chunks/1ww0328si-u8x.js","/_next/static/immutable/chunks/11mfl5ymqld9-.js","/_next/static/immutable/chunks/2xxcqy6ppds3l.js","/_next/static/immutable/chunks/3j06ow7w40nxu.js","/_next/static/immutable/chunks/31nn7jwsjvqii.js","/_next/static/immutable/chunks/43_s7jweyypoh.js","/_next/static/immutable/chunks/0p6vao205o1jc.js","/_next/static/immutable/chunks/1_kyvgkyokw92.js","/_next/static/immutable/chunks/1lo-zn37dolb5.js","/_next/static/immutable/chunks/1v8k6yxw1rg0u.js"],"FilesView"] 50:T4d7,"use client"; import { createContext, useContext } from "react"; import type { Provider } from "react"; export interface InternalContext { Provider: Provider; useRequired: () => T; useOptional: () => T | undefined; } /** * A typed context plus its two readers. `useRequired` throws a named error outside its * provider (the compound-component contract); `useOptional` returns `undefined` (the * degrade-gracefully contract — a field reader with no field, a group item outside its * group). * * A context VALUE is a plain object rebuilt when its scalar inputs change, and the * rebuild is what makes consumers re-render. Never wrap one in `useMemo(..., [])`. */ export function createInternalContext(displayName: string): InternalContext { const Context = createContext(undefined); Context.displayName = displayName; function useRequired(): T { const value = useContext(Context); if (value === undefined) { throw new Error(`${displayName} is missing: this component must be rendered inside its provider.`); } return value; } function useOptional(): T | undefined { return useContext(Context); } return { Provider: Context.Provider, useRequired, useOptional }; } 51:T602,"use client"; import { useEffect, useLayoutEffect, useRef, useSyncExternalStore } from "react"; /** * `useLayoutEffect` in the browser, `useEffect` on the server. Everything whose * absence is visible in the first painted frame — position, focus, scroll lock, a * transition leg — runs through this. * * The branch is taken once at module scope, never in a render path, so it costs * nothing per render and cannot desynchronise a hydration. */ export const useIsomorphicLayoutEffect: typeof useLayoutEffect = typeof document !== "undefined" ? useLayoutEffect : useEffect; const emptySubscribe = () => () => {}; const getSnapshot = () => true; const getServerSnapshot = () => false; /** * `false` on the server AND during the hydration render, `true` from the first * post-hydration render on. useSyncExternalStore, not useState+useEffect: no extra * commit, and tear-free under concurrent rendering. */ export function useIsHydrated(): boolean { return useSyncExternalStore(emptySubscribe, getSnapshot, getServerSnapshot); } /** Nothing a caller can produce is this symbol, so it is a safe "not created yet". */ const UNSET = Symbol("useConstant.unset"); /** * Lazily create a per-instance value exactly once. StrictMode-safe only because every * `create*` factory in this contract is allocation-only — no listeners, no timers. */ export function useConstant(create: () => T): T { const ref = useRef(UNSET); if (ref.current === UNSET) ref.current = create(); return ref.current as T; } 52:Tde3,"use client"; import { useCallback, useRef } from "react"; import type { Ref, RefCallback } from "react"; /** * Non-hook form, for use inside an existing callback ref. * * Returns the cleanup a React 19 callback ref may hand back, or `undefined`. * React 19 runs that cleanup on detach INSTEAD of calling the ref with * `null`, so a composer that swallowed the return value would silently drop * the consumer's teardown. React 18 has no such channel and ignores whatever * a callback ref returns — which is why the value is passed on rather than * acted upon here, and why every caller must still be able to cope with a * plain `assignRef(ref, null)` detach. */ export function assignRef( ref: Ref | undefined | null, node: T | null ): (() => void) | undefined { if (typeof ref === "function") { const cleanup = ref(node); return typeof cleanup === "function" ? (cleanup as () => void) : undefined; } if (ref) (ref as { current: T | null }).current = node; return undefined; } /** Merges any number of refs into one callback ref. Skips nullish entries. */ export function useComposedRefs(...refs: Array | undefined | null>): RefCallback { // The teardown owed for the CURRENT attachment: one entry per incoming // ref, either the cleanup that ref returned or a null-write standing in // for the one it did not. Held in a ref rather than a closure variable so // it survives the composed callback changing identity mid-life, which is // exactly when a detach of the old callback is followed by an attach of // the new one. const pending = useRef void> | null>(null); const detach = useCallback(() => { const cleanups = pending.current; pending.current = null; if (!cleanups) return; for (const cleanup of cleanups) cleanup(); }, []); // The rest array IS the dependency list: the composed callback's identity // changes exactly when one of the incoming refs does, never on every render. // A call site always passes the same number of refs, so the list length is // stable — which is the one thing a dynamic dependency list must guarantee. // `detach` is appended and permanently identity-stable, so the length stays // stable too. return useCallback>( (node) => { // Returns NOTHING, on purpose, on both React versions. // // React 18 treats a ref callback that returns a function as a // mistake and logs "Unexpected return value from a callback ref" // once per attach — for a package whose peer range is // `^18 || ^19`, that is dev-console noise on every element wired // through here, and a hard failure in any consumer whose CI fails // on console.error. React 19's cleanup channel would accept a // returned function and call it INSTEAD of passing `null`, but it // buys nothing: `detach()` at the head of this callback plus the // `node === null` branch below already release the previous // attachment on both versions, and `detach` is idempotent, so no // cleanup can run twice or be skipped. One code path, one // observable behaviour, no warning. detach(); if (node === null) return; pending.current = refs.map((ref) => { const cleanup = assignRef(ref, node); // A ref that returned no cleanup keeps the pre-19 contract: it // is cleared by being called with `null`. A ref that DID return // one must never also be nulled — running its cleanup is the // whole of its teardown. return cleanup ?? (() => assignRef(ref, null)); }); }, [...refs, detach] ); } 53:T406,"use client"; import { useCallback, useState } from "react"; import type { RefCallback } from "react"; /** * The node, and the callback ref that publishes it. THE way a component hands an * element to an internals hook (convention C-1). * * Returns state, not a ref, so a hook keyed on `[node]` re-runs the moment the node * appears — which is the only correct behaviour for a node whose existence is * conditional (a presence-mounted panel, an `{#if}`-equivalent branch). The setter * identity is stable for the life of the component. */ export function useElementRef(): [T | null, RefCallback] { const [node, setNode] = useState(null); // Block body, never a concise arrow: React 19 reads a returned value as a // cleanup function (convention C-3). The `[]` deps keep the identity stable // for the life of the component, so React never detaches and reattaches. const ref = useCallback>((next) => { setNode(next); }, []); return [node, ref]; } 54:T4f3,"use client"; import { useCallback, useInsertionEffect, useRef } from "react"; /** * A permanently identity-stable wrapper that always calls the most recent `fn`. * `undefined` yields a stable no-op returning `undefined`. * * The ref is written inside `useInsertionEffect`, NOT during render. Insertion effects * run before every layout effect, so a listener always sees the current callback, and * a concurrent render that React throws away can never publish a stale one. This is * the React counterpart of the getter-object call sites the Svelte sources use. * * Every `on*` option on every internals hook goes through this. It is also why * anchor-position's `newOpts.onPlacement !== options.onPlacement` reset branch is * unreachable from the hook path: the identity never changes. */ export function useEventCallback( fn: ((...args: A) => R) | undefined ): (...args: A) => R | undefined { // Seeded with the first render's `fn` so a call made before the first // insertion effect — a mount-time layout effect — already reaches it. const ref = useRef<((...args: A) => R) | undefined>(fn); useInsertionEffect(() => { ref.current = fn; }, [fn]); return useCallback((...args: A) => ref.current?.(...args), []); } 55:T877,"use client"; import { useCallback, useRef } from "react"; import type { RefCallback } from "react"; import { useIsomorphicLayoutEffect } from "./ssr"; import { useLiveRef } from "./use-live-ref"; /** * Keeps the `inert` ATTRIBUTE on an element in sync with a boolean, imperatively. * * Not a JSX prop, because there is no spelling of one that works across this * package's peer range: `inert={true}` is dropped with a warning by React 18 * (which knows no such attribute and refuses to guess), and `inert=""` is * rejected by React 19 (which knows it as a boolean). The attribute itself is * what `:not([inert])` selectors and assistive technology key on, so it is * written straight to the node instead — one mechanism, identical output on 18 * and 19. * * The returned callback ref is identity-stable, so React never detaches and * reattaches it; it applies the current value the instant a node arrives (which * is what covers a node that REMOUNTS while the flag is unchanged), and the * layout effect applies every later change to the node already held. Layout, not * passive: inertness that lands a frame late is a frame in which a collapsed * region is still clickable and still reachable by Tab. * * Compose it with `useComposedRefs` when the element already has a ref. * * SSR: an element is never inert in the server HTML — an attribute this hook * writes at commit cannot exist before hydration. Divergence from the Svelte * source, which SSRs `inert` inline; observable only in the pre-hydration frame. */ export function useInertAttribute(inert: boolean): RefCallback { const nodeRef = useRef(null); const inertRef = useLiveRef(inert); // Block body, never a concise arrow: React 19 reads a returned value as a // cleanup function (convention C-3), and `toggleAttribute` returns a boolean. const ref = useCallback>( (node) => { nodeRef.current = node; if (node) node.toggleAttribute("inert", inertRef.current); }, [inertRef] ); useIsomorphicLayoutEffect(() => { nodeRef.current?.toggleAttribute("inert", inert); }, [inert]); return ref; } 4e:["$","div",null,{"className":"mt-3 flex min-h-0 min-w-0 flex-1 flex-col gap-3","children":[null,["$","$L4f",null,{"files":[{"path":"react/src/internals/dom/context.ts","content":"$50","type":"registry:lib","target":"@ui/fancy/internals/dom/context.ts"},{"path":"react/src/internals/dom/ssr.ts","content":"$51","type":"registry:lib","target":"@ui/fancy/internals/dom/ssr.ts"},{"path":"react/src/internals/dom/types.ts","content":"\"use client\";\n\n/**\n * Structural ref type. NOT React.RefObject / React.MutableRefObject: those changed\n * shape between @types/react 18 and 19 (19 dropped the mutable/readonly split), and\n * this package's peer range is `^18 || ^19`. A structural type is assignable from\n * every variant either version emits.\n */\nexport type ElementRef = { readonly current: T | null };\n","type":"registry:lib","target":"@ui/fancy/internals/dom/types.ts"},{"path":"react/src/internals/dom/use-composed-refs.ts","content":"$52","type":"registry:lib","target":"@ui/fancy/internals/dom/use-composed-refs.ts"},{"path":"react/src/internals/dom/use-element-ref.ts","content":"$53","type":"registry:lib","target":"@ui/fancy/internals/dom/use-element-ref.ts"},{"path":"react/src/internals/dom/use-event-callback.ts","content":"$54","type":"registry:lib","target":"@ui/fancy/internals/dom/use-event-callback.ts"},{"path":"react/src/internals/dom/use-inert-attribute.ts","content":"$55","type":"registry:lib","target":"@ui/fancy/internals/dom/use-inert-attribute.ts"},{"path":"react/src/internals/dom/use-live-ref.ts","content":"\"use client\";\n\nimport { useInsertionEffect, useRef } from \"react\";\n\n/**\n * A read-only ref mirroring `value`, written in `useInsertionEffect` for the same\n * reason as `useEventCallback`. The React counterpart of a Svelte getter for a\n * NON-callback value: a long-lived closure (a document listener, an observer\n * callback, a stack entry) reads `ref.current` and sees the latest render's value\n * without being rebuilt.\n */\nexport function useLiveRef(value: T): { readonly current: T } {\n\tconst ref = useRef(value);\n\n\tuseInsertionEffect(() => {\n\t\tref.current = value;\n\t}, [value]);\n\n\treturn ref;\n}\n","type":"registry:lib","target":"@ui/fancy/internals/dom/use-live-ref.ts"}],"className":"h-[70svh] min-h-80"}]]}]