@teaflask/assistant 0.3.0 → 0.7.0

package/dist/components/primitives/cx.js

@@ -1,6 +1,3 @@
-// Class-name joiner for the primitives layer — the package deliberately
-// carries no styling dependencies.
 export function cx(...parts) {
     return parts.filter(Boolean).join(" ");
 }
-//# sourceMappingURL=cx.js.map

package/dist/components/primitives/dialog.js

@@ -5,8 +5,6 @@ import { focusAutofocusTarget } from "./autofocus.js";
 import { cx } from "./cx.js";
 export function TfDialog({ open, onOpenChange, className, children, onPointerDown: onHostPointerDown, ...props }) {
     const dialogRef = useRef(null);
-    // The `open` prop stays authoritative: native closes are reported up,
-    // never applied locally, and this effect is the only writer.
     useEffect(() => {
         const dialog = dialogRef.current;
         if (dialog === null) {
@@ -14,34 +12,19 @@ export function TfDialog({ open, onOpenChange, className, children, onPointerDow
         }
         if (open && !dialog.open) {
             dialog.showModal();
-            // The composer marks itself with data-tf-autofocus; without a mark
-            // the native behavior (first focusable) stands.
             focusAutofocusTarget(dialog, () => dialog.open);
         }
         else if (!open && dialog.open) {
             dialog.close();
         }
     }, [open]);
-    // Esc. Cancelled so the close happens through the controlled cycle.
     const closeFromCancel = useCallback((event) => {
         event.preventDefault();
         onOpenChange(false);
     }, [onOpenChange]);
-    // Safety net for a native close that skipped `cancel` (a
-    // method="dialog" form, or a browser force-closing on repeated Esc).
     const closeFromNativeClose = useCallback(() => {
         onOpenChange(false);
     }, [onOpenChange]);
-    // With zero own padding, the only place a press lands on the dialog
-    // element itself is the ::backdrop. The click alone can't be trusted:
-    // it dispatches on the common ancestor of pointerdown and pointerup,
-    // so a text selection that starts in content and releases past the
-    // panel edge also "clicks" the dialog — only a press that BEGAN on the
-    // backdrop counts.
-    //
-    // Composed, not overridden: the spread below lands after every handler
-    // on the element, so a caller passing its own onPointerDown (the sheet's
-    // drag) would silently take this one's place and with it click-to-close.
     const pressBeganOnBackdropRef = useRef(false);
     const trackPressOrigin = useCallback((event) => {
         pressBeganOnBackdropRef.current = event.target === event.currentTarget;
@@ -53,17 +36,5 @@ export function TfDialog({ open, onOpenChange, className, children, onPointerDow
             onOpenChange(false);
         }
     }, [onOpenChange]);
-    return (
-    // eslint-disable-next-line jsx-a11y/no-noninteractive-element-interactions, jsx-a11y/click-events-have-key-events -- backdrop click-to-close; keyboard users close via Esc (the native cancel event)
-    _jsx("dialog", { ref: dialogRef, 
-        // `hidden` restates the UA's closed-dialog display so the open:flex
-        // override can't leak onto the closed-but-mounted element. The
-        // important marker's collision rationale is historical: it guarded
-        // against a host build re-declaring `.hidden` after this element's
-        // `open:flex` — with the tf: prefix no host build can generate a
-        // colliding name. Kept as ordering insurance between the sheet's
-        // own tf:hidden and tf:open:flex rules, immune to any future
-        // intra-sheet order or specificity drift.
-        className: cx("tf:hidden tf:p-0 tf:open:flex!", className), onCancel: closeFromCancel, onClose: closeFromNativeClose, onPointerDown: trackPressOrigin, onClick: closeFromBackdropClick, ...props, children: children }));
+    return (_jsx("dialog", { ref: dialogRef, className: cx("tf:hidden tf:p-0 tf:open:flex!", className), onCancel: closeFromCancel, onClose: closeFromNativeClose, onPointerDown: trackPressOrigin, onClick: closeFromBackdropClick, ...props, children: children }));
 }
-//# sourceMappingURL=dialog.js.map

package/dist/components/primitives/disclosure.js

@@ -3,33 +3,13 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { createContext, useContext, useState } from "react";
 import { cx } from "./cx.js";
 const DisclosureVisualStateContext = createContext(null);
-/** The disclosure's DOM-backed visual state, for summary content that
- *  renders differently open vs closed (the fold headline's collapsed
- *  step label — the same mirror the chevron rotates on). Only readable
- *  INSIDE the summary: the provider deliberately wraps the summary
- *  children alone, and the read is the DOM's `open` (see the nativeOpen
- *  comment below), never the prop — a visitor can collapse a force-opened
- *  details while the prop still reads true. Null outside any Disclosure
- *  summary. */
 export function useDisclosureVisualState() {
     return useContext(DisclosureVisualStateContext);
 }
 export function Disclosure({ summary, children, variant = "framed", open, className, summaryClassName, bodyClassName, rootDataAttributes, }) {
-    // The package cannot rely on a consuming application's Tailwind scan to
-    // emit selectors for arbitrary parent states such as
-    // `[summary:hover_&]` or `[[open]>summary_&]`. Keep the native details as
-    // the source of truth, mirror only the two visual facts the chevron
-    // needs, and hand them to the summary's affordance through context.
-    // This makes the behavior identical in the package fixture and in a host
-    // that consumes only the built JavaScript.
     const [nativeOpen, setNativeOpen] = useState(open === true);
     const [summaryActive, setSummaryActive] = useState(false);
-    return (
-    // No `group` class here on purpose: a group variant on a nestable
-    // disclosure matches ANY open ancestor (see DisclosureChevron below),
-    // so the hook stays unwired rather than inviting the next consumer
-    // to re-create the nested-chevron bug. Anchor on [open]>summary.
-    _jsxs("details", { ...rootDataAttributes, open: open, onToggle: (event) => {
+    return (_jsxs("details", { ...rootDataAttributes, open: open, onToggle: (event) => {
             setNativeOpen(event.currentTarget.open);
         }, className: cx(variant === "framed" && "tf:rounded-tf tf:border", className), children: [_jsx("summary", { onMouseEnter: () => {
                     setSummaryActive(true);
@@ -40,34 +20,8 @@ export function Disclosure({ summary, children, variant = "framed", open, classN
                 }, onBlur: () => {
                     setSummaryActive(false);
                 }, className: cx("tf:cursor-pointer tf:list-none tf:select-none tf:[&::-webkit-details-marker]:hidden", "tf:focus-visible:outline-2 tf:focus-visible:outline-offset-2 tf:focus-visible:outline-tf-ring", variant === "framed" &&
-                    "tf:flex tf:items-center tf:gap-2 tf:px-3 tf:py-1.5 tf:text-tf-label", summaryClassName), children: _jsx(DisclosureVisualStateContext.Provider
-                // nativeOpen ALONE, never `open === true || nativeOpen`: React
-                // re-writes the open attribute only when the prop VALUE changes,
-                // so after a visitor collapses a force-opened details the DOM is
-                // closed while the prop still reads true — the [open]>summary
-                // selector this mirror replaced always read the DOM, and so must
-                // the mirror. nativeOpen is seeded from the prop at mount and a
-                // later undefined→true flip lands through onToggle.
-                , { 
-                    // nativeOpen ALONE, never `open === true || nativeOpen`: React
-                    // re-writes the open attribute only when the prop VALUE changes,
-                    // so after a visitor collapses a force-opened details the DOM is
-                    // closed while the prop still reads true — the [open]>summary
-                    // selector this mirror replaced always read the DOM, and so must
-                    // the mirror. nativeOpen is seeded from the prop at mount and a
-                    // later undefined→true flip lands through onToggle.
-                    value: { open: nativeOpen, summaryActive }, children: summary }) }), _jsx("div", { className: cx(variant === "framed" && "tf:border-t tf:px-3 tf:py-2", bodyClassName), children: children })] }));
+                    "tf:flex tf:items-center tf:gap-2 tf:px-3 tf:py-1.5 tf:text-tf-label", summaryClassName), children: _jsx(DisclosureVisualStateContext.Provider, { value: { open: nativeOpen, summaryActive }, children: summary }) }), _jsx("div", { className: cx(variant === "framed" && "tf:border-t tf:px-3 tf:py-2", bodyClassName), children: children })] }));
 }
-// Rotates when its OWN Disclosure is open. Not the group-open hook:
-// every Tailwind group variant (named or not) compiles to an
-// ancestor-matching selector, so inside a nested Disclosure — a tool
-// row inside an open fold — the outer open details would keep an inner
-// chevron rotated forever. The [open]>summary anchor can't leak across
-// nesting levels, because a chevron's only <summary> ancestor is its
-// own (a details' body is never inside another details' summary).
-// The framed variant hides the native marker, so summaries that carry no
-// other trailing affordance MUST place this — a markerless summary reads
-// as an inert box, invisible as a control.
 export function DisclosureChevron({ revealOnInteraction = false, } = {}) {
     const visualState = useContext(DisclosureVisualStateContext);
     const isOpen = visualState?.open === true;
@@ -76,4 +30,3 @@ export function DisclosureChevron({ revealOnInteraction = false, } = {}) {
             ? "tf:transition-[opacity,transform]"
             : "tf:transition-transform"), children: _jsx("path", { d: "M6 4l4 4-4 4", fill: "none", stroke: "currentColor", strokeWidth: "1.5", strokeLinecap: "round", strokeLinejoin: "round" }) }));
 }
-//# sourceMappingURL=disclosure.js.map

package/dist/components/primitives/file-input.js

@@ -1,17 +1,9 @@
 "use client";
 import { jsx as _jsx } from "react/jsx-runtime";
 import { forwardRef } from "react";
-// The package's one file control: a visually hidden native input a
-// visible button drives via ref (the shell ImageRow pattern). Hidden
-// rather than styled — a native file control cannot wear the register,
-// so the affordance is always a TfButton and this is its mechanism.
-// forwardRef rather than ref-as-prop: the peer range admits React 18.3,
-// where a function component receives no ref through props.
 export const TfFileInput = forwardRef(function TfFileInput({ accept, multiple = false, onPickFiles }, ref) {
     return (_jsx("input", { ref: ref, type: "file", accept: accept, multiple: multiple, className: "tf:sr-only", tabIndex: -1, "aria-hidden": "true", onChange: (event) => {
             onPickFiles(event.target.files);
-            // Clearing lets the same file re-fire a change event.
             event.target.value = "";
         } }));
 });
-//# sourceMappingURL=file-input.js.map

package/dist/components/primitives/floating-panel.js

@@ -6,19 +6,12 @@ import { focusAutofocusTarget } from "./autofocus.js";
 import { cx } from "./cx.js";
 import { useDockReflow } from "./use-dock-reflow.js";
 import { useSwipeDismiss } from "./use-swipe-dismiss.js";
-/** Where focus actually is, from the panel's own tree: getRootNode(),
- * never the document, which retargets activeElement to the shadow HOST
- * inside the script-tag distribution — the contains() guard would always
- * fail and the captured opener would be the host. */
 function _activeElementNear(panel) {
     const root = panel.getRootNode();
     return root instanceof Document || root instanceof ShadowRoot
         ? root.activeElement
         : null;
 }
-/** Restores focus to the remembered opener, but only when the close is
- * taking focus away from the user — i.e. focus still lives inside the
- * panel. A user who opened the panel and moved on keeps their place. */
 function _returnFocusToOpener(panel, opener) {
     if (!panel.contains(_activeElementNear(panel))) {
         return;
@@ -30,8 +23,6 @@ function _returnFocusToOpener(panel, opener) {
 export function TfFloatingPanel({ open, onOpenChange, corner = "bottom-right", dock = "floating", focusOnOpen, className, children, ...props }) {
     const panelRef = useRef(null);
     const parkOnForcedHide = usePopoverPresence(panelRef, open, focusOnOpen);
-    // Esc closes the surface it is pressed in, and nothing else: scoped to
-    // keydowns that reach the panel, stopped so one keystroke does one thing.
     const closeFromEscape = useCallback((event) => {
         if (event.key !== "Escape" || event.defaultPrevented) {
             return;
@@ -42,10 +33,6 @@ export function TfFloatingPanel({ open, onOpenChange, corner = "bottom-right", d
     const dismiss = useCallback(() => {
         onOpenChange(false);
     }, [onOpenChange]);
-    // Downward swipe on the grab region dismisses — confined to the handle
-    // because the content scrolls the same axis. Docked, the gesture is
-    // off: a full-height pane reads as page furniture, and furniture that
-    // flies away under a drag reads as breakage.
     const swipe = useSwipeDismiss({
         axis: "y",
         direction: 1,
@@ -55,59 +42,15 @@ export function TfFloatingPanel({ open, onOpenChange, corner = "bottom-right", d
         handleSelector: "[data-tf-swipe-handle]",
     });
     useDockReflow(panelRef, dock);
-    return (
-    // eslint-disable-next-line jsx-a11y/no-noninteractive-element-interactions -- the keydown is the panel's own Esc-to-close; the pointer handlers are the handle's swipe. Keyboard users close via Esc.
-    _jsx("div", { ref: panelRef, popover: "manual", role: "dialog", "data-tf-assistant": "", "data-tf-floating-panel": corner, "data-tf-panel-dock": dock, "data-tf-glass": dock === "floating" ? "" : undefined, onToggle: parkOnForcedHide, onKeyDown: closeFromEscape, onPointerDown: swipe.onPointerDown, onPointerMove: swipe.onPointerMove, onPointerUp: swipe.onPointerUp, onPointerCancel: swipe.onPointerCancel, onClickCapture: swipe.onClickCapture, className: cx(
-        // `hidden` restates the UA's closed-popover display and is the
-        // whole display without popover support; the important marker is
-        // ordering insurance between tf:hidden and tf:open:flex.
-        "tf:m-0 tf:hidden tf:p-0 tf:open:flex!", "tf:flex-col tf:overflow-hidden tf:text-tf-foreground", dock === "sidebar"
-            ? // Flush full-height, edge to edge, never an inset column: the
-                // Portal Lift rule inverted — no shadow, square corners, a
-                // hairline left border (in styles.css, not a border-l utility:
-                // border utilities ride an @property registration Chromium honours
-                // only in document sheets; this must paint everywhere). A fixed 26rem
-                // on ultrawide too — a pane, not a proportion; max-w guards an
-                // inflated host rem. left-auto is load-bearing: the UA popover
-                // style is inset:0, and left+right 0 resolves to the LEFT edge in LTR.
+    return (_jsx("div", { ref: panelRef, popover: "manual", role: "dialog", "data-tf-assistant": "", "data-tf-floating-panel": corner, "data-tf-panel-dock": dock, "data-tf-glass": dock === "floating" ? "" : undefined, onToggle: parkOnForcedHide, onKeyDown: closeFromEscape, onPointerDown: swipe.onPointerDown, onPointerMove: swipe.onPointerMove, onPointerUp: swipe.onPointerUp, onPointerCancel: swipe.onPointerCancel, onClickCapture: swipe.onClickCapture, className: cx("tf:m-0 tf:hidden tf:p-0 tf:open:flex!", "tf:flex-col tf:overflow-hidden", dock === "sidebar"
+            ?
                 "tf:inset-y-0 tf:right-0 tf:left-auto tf:h-dvh tf:w-104 tf:max-w-[calc(100vw-2rem)] tf:rounded-none tf:bg-tf-background tf:shadow-none"
-            : cx(
-            // A floating corner card, never flush: the viewport-edge margins
-            // signal "the page is still there". Compose-window proportions
-            // (~44vw): the 24rem floor is the phone card, 46rem caps the
-            // ultrawide so the panel stays a card, never a pane.
-            "tf:inset-auto tf:bottom-4 tf:w-[clamp(24rem,44vw,46rem)] tf:max-w-[calc(100vw-2rem)]", 
-            // Fixed height under viewport-relative caps so the panel never
-            // jumps between empty and busy: ~68dvh is the compose-window
-            // register, 52rem stops tall monitors growing a tower, and the
-            // 6rem headroom term keeps the software-keyboard behavior.
-            "tf:h-[min(68dvh,52rem,calc(100dvh-6rem))]", 
-            // The floating-surface chrome comes from the liquid-glass
-            // material (data-tf-glass, styles.css). The 24px corner is the
-            // panel step of the radius ladder (the composer slab wears the
-            // same literal), not derived from --tf-radius so a host's
-            // control-radius theme can't unround the surface.
-            "tf:rounded-3xl tf:border", corner === "bottom-left" ? "tf:left-4" : "tf:right-4"), className), ...props, children: children }));
+            : cx("tf:inset-auto tf:bottom-4 tf:w-[clamp(24rem,44vw,46rem)] tf:max-w-[calc(100vw-2rem)]", "tf:h-[min(68dvh,52rem,calc(100dvh-6rem))]", "tf:rounded-3xl tf:border", corner === "bottom-left" ? "tf:left-4" : "tf:right-4"), className), ...props, children: children }));
 }
-/**
- * The popover discipline: `open` shows and hides the top-layer panel
- * (focus captured on a gesture's open, returned on close), a hide the
- * panel did not initiate parks it, and the way-is-clear watcher restores
- * it. Returns the toggle handler that detects the forced hide.
- */
 function usePopoverPresence(panelRef, open, focusOnOpen) {
     const openerRef = useRef(null);
     const focusOnOpenRef = useLatestRef(focusOnOpen);
-    // Parked by a modal (or a meddling host script): hidden while `open`
-    // still says true, waiting for the way to clear. A ref, not state:
-    // nothing rendered depends on it and the watcher reads it live.
     const yieldedRef = useRef(false);
-    // The `open` prop stays authoritative: external hides are parked or
-    // reported, never applied locally, and this effect is the only writer.
-    // Inert is written here for the whole not-open stretch, not rendered:
-    // inert={!open} would commit before this effect and blur the focused
-    // descendant, so the focus return's "still inside" check could never
-    // pass. On open it lifts BEFORE showPopover(); on close it lands after.
     useEffect(() => {
         const panel = panelRef.current;
         if (panel === null) {
@@ -127,8 +70,6 @@ function usePopoverPresence(panelRef, open, focusOnOpen) {
             }
             else if (!open) {
                 if (showing) {
-                    // Before hidePopover(), while "focus is still inside" is still
-                    // observable.
                     _returnFocusToOpener(panel, openerRef.current);
                     panel.hidePopover();
                 }
@@ -139,18 +80,11 @@ function usePopoverPresence(panelRef, open, focusOnOpen) {
             panel.setAttribute("inert", "");
         }
     }, [panelRef, open, focusOnOpenRef]);
-    // The yield detector. Our own hide only ever runs with `open` already
-    // false, so a closed-toggle arriving while `open` is true was forced
-    // from outside — a modal's hide-all-popovers, or a host script.
     const parkOnForcedHide = useCallback((event) => {
         if (event.newState === "closed" && open) {
             yieldedRef.current = true;
         }
     }, [open]);
-    // The way-is-clear watcher, listening for the whole open stretch and
-    // acting only while parked. `close` doesn't bubble, so the document
-    // hears it in the capture phase; fullscreen exits hide popovers through
-    // the same spec step. Restoration never touches focus.
     useEffect(() => {
         const panel = panelRef.current;
         if (!open || panel === null || typeof panel.showPopover !== "function") {
@@ -158,9 +92,6 @@ function usePopoverPresence(panelRef, open, focusOnOpen) {
         }
         const doc = panel.ownerDocument;
         const restoreWhenClear = () => {
-            // fullscreenchange fires on the way IN too, and entering fullscreen
-            // is itself a popover-hiding step — without the fullscreenElement
-            // check this would pop the panel over the fullscreen element.
             if (!yieldedRef.current ||
                 doc.querySelector("dialog:modal") !== null ||
                 doc.fullscreenElement !== null) {
@@ -180,4 +111,3 @@ function usePopoverPresence(panelRef, open, focusOnOpen) {
     }, [panelRef, open]);
     return parkOnForcedHide;
 }
-//# sourceMappingURL=floating-panel.js.map

package/dist/components/primitives/kbd.js

@@ -1,20 +1,6 @@
 "use client";
 import { jsx as _jsx } from "react/jsx-runtime";
 import { cx } from "./cx.js";
-// A key cap: the question panel's ↑ ↓ ↵ hints at the right edge of the
-// active answer row. Hairline on a transparent ground (so it sits on the
-// emphasis wash in light and dark alike), the badge step, the control
-// radius — an instrument marking, never a decoration — and always
-// aria-hidden at the call site: the hint duplicates what the radiogroup's
-// description already tells assistive tech, so it must not be read twice.
-// Never wraps: a two-token cap ("Ctrl ↵") must stay one line inside its
-// 20px height. Geist Sans, not mono: the visual spec keeps the mono face
-// for code alone; the glyphs themselves are icons at the call site,
-// because a host font cannot be trusted to carry U+21B5.
-// WithoutRef on purpose: a plain function component cannot forward a ref
-// under React 18.3, so admitting one in the props type would type-check a
-// silent no-op (tests/ref-prop-surface.test.ts holds the line).
 export function Kbd({ className, ...props }) {
     return (_jsx("kbd", { className: cx("tf:inline-flex tf:h-5 tf:min-w-5 tf:items-center tf:justify-center tf:gap-0.5 tf:rounded-tf", "tf:border tf:border-tf-input tf:bg-tf-transparent tf:px-1 tf:font-tf-sans tf:text-xs", "tf:leading-none tf:whitespace-nowrap tf:text-tf-muted-foreground", className), ...props }));
 }
-//# sourceMappingURL=kbd.js.map

package/dist/components/primitives/textarea.js

@@ -8,10 +8,6 @@ const VARIANT_CLASSES = {
         "tf:focus-visible:outline-2 tf:focus-visible:outline-offset-1 tf:focus-visible:outline-tf-ring",
     bare: "tf:border-0 tf:bg-transparent tf:px-2 tf:py-1.5 tf:text-tf-body tf:focus-visible:outline-none",
 };
-// forwardRef rather than ref-as-prop: the peer range admits React 18.3,
-// where a function component receives no ref through props — and the
-// composer's caret machinery anchors to this element.
 export const TfTextarea = forwardRef(function TfTextarea({ variant = "framed", className, ...props }, ref) {
     return (_jsx("textarea", { ref: ref, className: cx("tf:w-full tf:resize-none tf:text-tf-foreground", "tf:placeholder:text-tf-muted-foreground", "tf:disabled:cursor-not-allowed tf:disabled:opacity-50", VARIANT_CLASSES[variant], className), ...props }));
 });
-//# sourceMappingURL=textarea.js.map

package/dist/components/primitives/use-dock-reflow.js

@@ -2,15 +2,6 @@
 import { useEffect } from "react";
 import { dockReflowFor } from "../../core/dock-reflow.js";
 const REDUCED_MOTION_QUERY = "(prefers-reduced-motion: reduce)";
-/** Keeps the host page pushed exactly while the docked panel is actually
- * visible. Visibility, not the mode setting or the open prop: a host
- * modal that force-hides (parks) the panel must un-push the page, and
- * the way-is-clear restore must re-push it. The native `toggle` event is
- * the one signal that fires on every show and hide regardless of who
- * drove it — our own show/hide effect, the modal's spec-mandated
- * hide-all-popovers, a meddling host script, the watcher's re-show — so
- * it is the single source of truth here, and the React onToggle prop
- * stays the park detector's alone. */
 export function useDockReflow(panelRef, dock) {
     useEffect(() => {
         const panel = panelRef.current;
@@ -20,16 +11,9 @@ export function useDockReflow(panelRef, dock) {
             return;
         }
         const controller = dockReflowFor(panel.ownerDocument.documentElement);
-        // Both switches the stylesheet answers, answered here too: the OS
-        // preference and the host's data-reduce-motion kill switch — an
-        // inline transition is invisible to those CSS selectors.
         const reduceMotion = () => (panel.ownerDocument.defaultView ?? window).matchMedia(REDUCED_MOTION_QUERY).matches || panel.closest('[data-reduce-motion="true"]') !== null;
         const syncPushToVisibility = () => {
             if (panel.matches(":popover-open")) {
-                // The rendered width, not the nominal 26rem: offsetWidth is
-                // layout width (the sidebar pins scale to 1), and it already
-                // reflects a host root font-size inflating rem and the
-                // max-width clamp on narrow viewports.
                 controller.push(panel.offsetWidth, reduceMotion());
             }
             else {
@@ -37,16 +21,10 @@ export function useDockReflow(panelRef, dock) {
             }
         };
         panel.addEventListener("toggle", syncPushToVisibility);
-        // A dock-mode switch on an already-open panel changes no popover
-        // state and fires no toggle; this one call covers it.
         syncPushToVisibility();
         return () => {
             panel.removeEventListener("toggle", syncPushToVisibility);
-            // Mode switch, close, or unmount: the un-push still animates —
-            // the controller lives on the documentElement's lifetime, which
-            // outlives this panel.
             controller.release();
         };
     }, [panelRef, dock]);
 }
-//# sourceMappingURL=use-dock-reflow.js.map

package/dist/components/primitives/use-swipe-dismiss.js

@@ -1,30 +1,9 @@
 "use client";
 import { useCallback, useEffect, useRef, } from "react";
-// The swipe-to-dismiss machine, shared by every surface that leaves with
-// a push: the edge sheet along x toward its own edge, the corner panel
-// down along y. Axis and closing direction are the only gesture parameters;
-// everything else here is a fixed bug that must not be copied twice.
-// The scroll conflict is deliberately NOT a parameter: content that
-// scrolls along the dismissal axis cannot be disambiguated by axis, so
-// such a surface confines the drag to a grab region (`handleSelector`);
-// content scrolling only across the axis lets the axis test arbitrate.
-// Past this fraction of the panel's own extent along the axis, the
-// release commits to a close instead of springing back: far enough that
-// a lazy scroll never dismisses, near enough that a push needn't go all the way.
 const DISMISS_TRAVEL_FRACTION = 0.25;
-// Or past this speed, however far it got: a flick is an intent.
 const DISMISS_VELOCITY_PX_PER_MS = 0.5;
-// How stale a velocity reading may be and still count as a flick: speed is
-// sampled only on pointermove, so without this a flick-then-hold-then-lift
-// dismisses a panel the thumb deliberately parked.
 const FLICK_GOES_STALE_AFTER_MS = 100;
-// Slop before a press becomes a drag. Below it the gesture is undecided
-// and the scrollable content underneath keeps the pointer.
 const DRAG_SLOP_PX = 8;
-/** Takes the drag decoration back off the panel and hands the pointer
- * back. Every way a gesture can end runs this: the marker and offset are
- * written on an element that outlives the close, and left behind they
- * render every later open shoved aside with its slide switched off. */
 function _releasePanel(panel, pointerId) {
     delete panel.dataset.tfSwipeDragging;
     panel.style.removeProperty("--_tf-swipe-drag");
@@ -34,20 +13,8 @@ function _releasePanel(panel, pointerId) {
 }
 export function useSwipeDismiss({ axis, direction, open, enabled = true, onDismiss, handleSelector, }) {
     const drag = useRef(null);
-    // Whether the last gesture ended as a swipe rather than a press — the
-    // one thing the click handler below needs to know.
     const swipedRatherThanTapped = useRef(false);
-    // The panel, remembered from whichever handler last saw it: the open
-    // effect must strip a gesture's decoration with no event to read.
     const panelRef = useRef(null);
-    // Every change of open state ends whatever gesture was in flight. The
-    // flag clears on OPEN only: the exit is a CSS transition (allow-discrete
-    // on display/overlay), so the panel stays hit-testable through the slide
-    // out and a dismissing swipe's compatibility click still lands on the
-    // row under the thumb — the flag must survive the close to swallow it,
-    // and must be gone before a reopened, keyboard-driven panel's Enter
-    // click. The drag releases on every change: a close landing mid-gesture
-    // (Esc, the host) never reaches endDrag or cancelDrag.
     useEffect(() => {
         if (open) {
             swipedRatherThanTapped.current = false;
@@ -58,22 +25,12 @@ export function useSwipeDismiss({ axis, direction, open, enabled = true, onDismi
             _releasePanel(panelRef.current, inFlight.pointerId);
         }
     }, [open, enabled]);
-    // Touch only, and only after the movement proves itself along the axis:
-    // a thumb travelling across it keeps scrolling; a mouse has Esc.
     const beginDrag = useCallback((event) => {
-        // Whatever the last gesture was, it is over. Clearing here — before
-        // every early return — bounds the swallow to a single click: the
-        // flag never waits for the first tap after the surface reopens.
         swipedRatherThanTapped.current = false;
-        // Recorded before every early return: the open effect needs the
-        // element even for a gesture this handler declines to track.
         panelRef.current = event.currentTarget;
         if (!enabled || !_pressBeginsDrag(event, handleSelector)) {
             return;
         }
-        // A second finger doesn't get to retarget a gesture already under way:
-        // overwriting the state would strand the first pointer's cleanup and
-        // leave the marker and offset on the panel for the rest of the session.
         if (drag.current !== null) {
             return;
         }
@@ -88,8 +45,6 @@ export function useSwipeDismiss({ axis, direction, open, enabled = true, onDismi
     }, [axis, direction]);
     const endDrag = useCallback((event) => {
         const state = drag.current;
-        // Only the pointer that owns the gesture ends it — and it always takes
-        // the decoration off on its way out, committed or not.
         if (event.pointerId !== state?.pointerId) {
             return;
         }
@@ -99,19 +54,11 @@ export function useSwipeDismiss({ axis, direction, open, enabled = true, onDismi
         if (!state.committed) {
             return;
         }
-        // A committed swipe moved the panel under the thumb, so the press was
-        // never a tap — yet the touch sequence is about to synthesize a click
-        // where it started, and pointer capture doesn't retarget click on
-        // WebKit: a swipe begun on a conversation row would open it.
         swipedRatherThanTapped.current = true;
         if (_dragDismisses(state, _sampleOf(event, axis), panel, axis, direction)) {
             onDismiss();
         }
     }, [axis, direction, onDismiss]);
-    // The browser taking the gesture away is not a dismissal: a pinch
-    // starting, or the UA claiming the pointer for its own pan, cancels with
-    // the finger still down and no decision made — the panel goes back to
-    // rest. Never shared with endDrag, which would close under the thumb.
     const cancelDrag = useCallback((event) => {
         const state = drag.current;
         if (event.pointerId !== state?.pointerId) {
@@ -120,9 +67,6 @@ export function useSwipeDismiss({ axis, direction, open, enabled = true, onDismi
         drag.current = null;
         _releasePanel(event.currentTarget, event.pointerId);
     }, []);
-    // Capture phase, so the content underneath never sees it. One click only:
-    // the flag is set by a committed swipe and cleared by the next press, the
-    // next open, or this handler — it can never outlive the gesture.
     const swallowTheClickAfterASwipe = useCallback((event) => {
         if (!swipedRatherThanTapped.current) {
             return;
@@ -147,18 +91,10 @@ function _sampleOf(event, axis) {
         timeStamp: event.timeStamp,
     };
 }
-/** Whether a press is a candidate drag at all: touch, not on the panel
- *  element itself, and inside the grab region when one is declared. */
 function _pressBeginsDrag(event, handleSelector) {
-    // A press that lands on the panel element itself belongs to the
-    // surface (the dialog's ::backdrop is the only place that happens),
-    // not to us.
     if (event.pointerType !== "touch" || event.target === event.currentTarget) {
         return false;
     }
-    // The grab-region gate: content that scrolls along the dismissal
-    // axis makes a bare axis test a coin flip, so such surfaces confine
-    // the gesture to a handle and presses elsewhere never dismiss.
     if (handleSelector !== undefined &&
         !(event.target instanceof Element &&
             event.target.closest(handleSelector) !== null)) {
@@ -177,36 +113,24 @@ function _beginDragStateOf(sample) {
         committed: false,
     };
 }
-/** Advances the gesture by one move: an undecided press is either handed
- *  to the content (null) or committed to the panel; a committed drag
- *  records its speed and writes the live offset. */
 function _trackedDragOf(state, sample, panel, direction) {
     const dMain = sample.main - state.startMain;
     const dCross = sample.cross - state.startCross;
-    // Travel toward dismissal counts; the other way is nothing, and the
-    // panel never stretches past its resting place.
     const closing = direction * dMain;
     if (!state.committed) {
         if (Math.abs(dCross) >= DRAG_SLOP_PX &&
             Math.abs(dCross) >= Math.abs(dMain)) {
-            // Decided across the axis: the gesture is the content's, not ours.
             return null;
         }
         if (closing < DRAG_SLOP_PX) {
             return state;
         }
         state.committed = true;
-        // The marker first, and the capture defensively: a pointer that
-        // ended between two moves makes setPointerCapture throw, and losing
-        // the capture only costs the tail of the gesture — losing the marker
-        // would leave the transition running under the thumb.
         panel.dataset.tfSwipeDragging = "";
         try {
             panel.setPointerCapture(sample.pointerId);
         }
         catch {
-            // Capture is an optimisation here; the handlers are on the
-            // panel and the gesture stays inside it either way.
         }
     }
     const elapsed = sample.timeStamp - state.lastT;
@@ -216,28 +140,13 @@ function _trackedDragOf(state, sample, panel, direction) {
         state.lastT = sample.timeStamp;
     }
     const offset = Math.max(0, closing);
-    // A DOM style property, not the banned JSX style prop: the live
-    // offset is a per-frame number and the stylesheet reads it through
-    // the surface's transform variable.
     panel.style.setProperty("--_tf-swipe-drag", `${String(direction * offset)}px`);
     return state;
 }
-/** The release verdict for a committed drag: a flick still fresh at the
- *  lift, or travel past the panel's own quarter, dismisses. */
 function _dragDismisses(state, sample, panel, axis, direction) {
-    // Where the panel actually ended up, not how far the finger went: a
-    // swipe pulled back past rest clamps to rest (the Math.max above) and
-    // must spring back too — |dMain| would count the pull-back as travel
-    // and dismiss the panel the finger just rescued.
     const travelled = Math.max(0, direction * (sample.main - state.startMain));
-    // A speed nobody has measured recently is not a flick: velocity is
-    // sampled on pointermove alone, so a finger that flicked, stopped and
-    // lifted still carries the flick's number. Parking means parking.
     const stillMoving = sample.timeStamp - state.lastT <= FLICK_GOES_STALE_AFTER_MS;
     const flicked = stillMoving && direction * state.velocity > DISMISS_VELOCITY_PX_PER_MS;
-    // The panel's own extent, not the viewport: capped below nominal on
-    // the narrowest phones, a quarter of nominal would be a third on screen.
     const extent = axis === "x" ? panel.offsetWidth : panel.offsetHeight;
     return flicked || travelled > extent * DISMISS_TRAVEL_FRACTION;
 }
-//# sourceMappingURL=use-swipe-dismiss.js.map