@charcuterie/ui 0.1.0

package/dist/Modal/Modal.d.ts

@@ -0,0 +1,66 @@
+import type { ComponentPropsWithRef, ReactNode } from "react";
+export type ModalSize = "full" | "lg" | "md" | "sm" | "xl";
+export type ModalProps = Omit<ComponentPropsWithRef<"dialog">, "onClose" | "open"> & {
+    /** The footer row. Buttons, usually. */
+    footer?: ReactNode;
+    heading: string;
+    headingLevel?: 2 | 3 | 4;
+    /**
+     * Escape and a backdrop press both close. Off for the one
+     * honest case — a destructive confirm the user has to answer —
+     * and off means Escape is *cancelled* rather than ignored, so
+     * the browser cannot close a dialog the app still owns.
+     */
+    isDismissable?: boolean;
+    isVisible: boolean;
+    /**
+     * Every route out lands here: the close button, Escape, a
+     * backdrop press. Wire it to a `useVisibility()`'s `hide`.
+     */
+    onClose: () => void;
+    size?: ModalSize;
+};
+/**
+ * Four repos, and **plex-channels and ripdeck independently
+ * converged on native `<dialog>`** — which is the design here
+ * rather than a shortcut. `showModal()` gives a focus trap,
+ * Escape, `::backdrop`, `inert` on everything behind it, and the
+ * **top layer**, from the platform, correctly, in every browser
+ * the fleet runs.
+ *
+ * What is not free — and the reason a component exists at all —
+ * is that a native `<dialog>` is a *self-owning* control: call
+ * `showModal()` and it decides it is open. That is the same
+ * conflict Radix has, and it gets the same answer as everywhere
+ * else in this library: **`isVisible` is the truth, and an effect
+ * makes the element agree with it.** Nothing here reads
+ * `dialogElement.open` as state; it is read only to avoid calling
+ * a method that would throw.
+ *
+ * ### Why it is not portalled
+ *
+ * The top layer is a *paint* concept: a `<dialog>` renders above
+ * everything while staying exactly where it is in the DOM. So it
+ * needs no portal — and that matters well past tidiness, because a
+ * portal moves the node to `document.body`, out of whatever
+ * element a test or an agent scoped its queries to.
+ * `canvas.getByRole("dialog")` finds this one. It would not find a
+ * portalled one, and the story would have to reach for `screen`
+ * and lose its scoping.
+ *
+ * ### `open:flex`, not `flex`
+ *
+ * A closed `<dialog>` is hidden by a UA rule that any
+ * `display: flex` of ours would beat — so the modal would render
+ * permanently, in the page flow, with no error. The layout is
+ * therefore behind Tailwind's `open:` variant, which is the
+ * `[open]` attribute the browser manages.
+ *
+ * ### The accessible name
+ *
+ * `heading` is required and is a string, not a `ReactNode`. A
+ * dialog with no name is announced as "dialog" and nothing else,
+ * which is what every hand-rolled modal in the inventory does.
+ */
+export declare const Modal: ({ children, className, footer, heading, headingLevel, isDismissable, isVisible, onClose, size, ...dialogProps }: ModalProps) => ReactNode;
+//# sourceMappingURL=Modal.d.ts.map

package/dist/Modal/Modal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Modal.d.ts","sourceRoot":"","sources":["../../src/Modal/Modal.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,qBAAqB,EACrB,SAAS,EACV,MAAM,OAAO,CAAA;AAOd,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAA;AAE1D,MAAM,MAAM,UAAU,GAAG,IAAI,CAC3B,qBAAqB,CAAC,QAAQ,CAAC,EAC/B,SAAS,GAAG,MAAM,CACnB,GAAG;IACF,wCAAwC;IACxC,MAAM,CAAC,EAAE,SAAS,CAAA;IAClB,OAAO,EAAE,MAAM,CAAA;IACf,YAAY,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;IACxB;;;;;OAKG;IACH,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,SAAS,EAAE,OAAO,CAAA;IAClB;;;OAGG;IACH,OAAO,EAAE,MAAM,IAAI,CAAA;IACnB,IAAI,CAAC,EAAE,SAAS,CAAA;CACjB,CAAA;AAqBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,eAAO,MAAM,KAAK,GAAI,iHAWnB,UAAU,KAAG,SAsHf,CAAA"}

package/dist/Modal/Modal.js

@@ -0,0 +1,111 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useUniqueId } from "@charcuterie/logic";
+import { useEffect, useRef } from "react";
+import { Button } from "../Button/Button.js";
+import { toClassName } from "../toClassName.js";
+import { lockScrollBehind } from "./lockScrollBehind.js";
+/**
+ * `85dvh` rather than `85vh` — on a phone the two differ by the
+ * address bar, and a dialog whose footer is under it is a dialog
+ * with no buttons.
+ */
+const SIZE_CLASS = {
+    sm: "max-h-[85dvh] w-full max-w-sm",
+    md: "max-h-[85dvh] w-full max-w-md",
+    lg: "max-h-[85dvh] w-full max-w-2xl",
+    // M5 added this, because the scale jumped from 42rem straight to
+    // the whole viewport and rip-deck's capture tail lands in the
+    // gap: a MakeMKV robot log is fixed-width `MSG:5072,0,1,"…"`
+    // lines that wrap badly at 42rem, and a full-screen dialog over a
+    // nine-bay dashboard hides the thing being diagnosed. 56rem is
+    // what that app's hand-rolled `<dialog>` used before the swap.
+    xl: "max-h-[85dvh] w-full max-w-4xl",
+    full: "h-[100dvh] max-h-[100dvh] w-full max-w-full rounded-none",
+};
+/**
+ * Four repos, and **plex-channels and ripdeck independently
+ * converged on native `<dialog>`** — which is the design here
+ * rather than a shortcut. `showModal()` gives a focus trap,
+ * Escape, `::backdrop`, `inert` on everything behind it, and the
+ * **top layer**, from the platform, correctly, in every browser
+ * the fleet runs.
+ *
+ * What is not free — and the reason a component exists at all —
+ * is that a native `<dialog>` is a *self-owning* control: call
+ * `showModal()` and it decides it is open. That is the same
+ * conflict Radix has, and it gets the same answer as everywhere
+ * else in this library: **`isVisible` is the truth, and an effect
+ * makes the element agree with it.** Nothing here reads
+ * `dialogElement.open` as state; it is read only to avoid calling
+ * a method that would throw.
+ *
+ * ### Why it is not portalled
+ *
+ * The top layer is a *paint* concept: a `<dialog>` renders above
+ * everything while staying exactly where it is in the DOM. So it
+ * needs no portal — and that matters well past tidiness, because a
+ * portal moves the node to `document.body`, out of whatever
+ * element a test or an agent scoped its queries to.
+ * `canvas.getByRole("dialog")` finds this one. It would not find a
+ * portalled one, and the story would have to reach for `screen`
+ * and lose its scoping.
+ *
+ * ### `open:flex`, not `flex`
+ *
+ * A closed `<dialog>` is hidden by a UA rule that any
+ * `display: flex` of ours would beat — so the modal would render
+ * permanently, in the page flow, with no error. The layout is
+ * therefore behind Tailwind's `open:` variant, which is the
+ * `[open]` attribute the browser manages.
+ *
+ * ### The accessible name
+ *
+ * `heading` is required and is a string, not a `ReactNode`. A
+ * dialog with no name is announced as "dialog" and nothing else,
+ * which is what every hand-rolled modal in the inventory does.
+ */
+export const Modal = ({ children, className, footer, heading, headingLevel = 2, isDismissable = true, isVisible, onClose, size = "md", ...dialogProps }) => {
+    const dialogRef = useRef(null);
+    const headingId = useUniqueId();
+    const Heading = `h${headingLevel}`;
+    useEffect(() => {
+        const dialogElement = dialogRef.current;
+        if (!dialogElement) {
+            return;
+        }
+        // Guarded both ways. `showModal()` on an already-open dialog
+        // throws `InvalidStateError`, and `close()` on a closed one
+        // fires a spurious `close` event — either turns a re-render
+        // into a bug.
+        if (isVisible && !dialogElement.open) {
+            dialogElement.showModal();
+        }
+        if (!isVisible && dialogElement.open) {
+            dialogElement.close();
+        }
+    }, [isVisible]);
+    useEffect(() => (isVisible ? lockScrollBehind() : undefined), [isVisible]);
+    return (_jsxs("dialog", { ...dialogProps, "aria-labelledby": headingId, className: toClassName(
+        // `m-auto` and `p-0` undo the UA stylesheet, which centres
+        // by margin and adds padding of its own.
+        "m-auto flex-col overflow-hidden rounded-lg border border-border-default bg-surface-overlay p-0 text-content-primary shadow-high backdrop:bg-scrim open:flex", SIZE_CLASS[size], className), onCancel: (cancelEvent) => {
+            // Escape. Cancelled rather than ignored when the dialog is
+            // not dismissable: letting the browser close it would
+            // leave `isVisible` true and the element shut, which is
+            // precisely the desync this component exists to prevent.
+            cancelEvent.preventDefault();
+            if (isDismissable) {
+                onClose();
+            }
+        }, onClick: (clickEvent) => {
+            // The backdrop is not an element — a press on it targets
+            // the `<dialog>` itself, while a press on the content
+            // targets something inside. Comparing target to
+            // currentTarget is the whole test.
+            if (isDismissable &&
+                clickEvent.target === clickEvent.currentTarget) {
+                onClose();
+            }
+        }, ref: dialogRef, children: [_jsxs("header", { className: "flex shrink-0 items-start justify-between gap-3 border-b border-border-subtle p-4", children: [_jsx(Heading, { className: "font-semibold text-lg leading-tight", id: headingId, children: heading }), isDismissable ? (_jsx(Button, { appearance: "ghost", intent: "neutral", onClick: onClose, size: "sm", children: "Close" })) : null] }), _jsx("div", { className: "min-h-0 flex-1 overflow-auto p-4", children: children }), footer ? (_jsx("footer", { className: "flex shrink-0 flex-wrap justify-end gap-2 border-t border-border-subtle p-4", children: footer })) : null] }));
+};
+//# sourceMappingURL=Modal.js.map

package/dist/Modal/Modal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Modal.js","sourceRoot":"","sources":["../../src/Modal/Modal.tsx"],"names":[],"mappings":"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"}

package/dist/Modal/lockScrollBehind.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The one thing `showModal()` does not do.
+ *
+ * A native modal makes everything behind it `inert` — unclickable,
+ * untabbable, invisible to a screen reader — and then lets you
+ * scroll it anyway. On a phone that reads as the dialog sliding
+ * around; on a long page it loses the user's place entirely.
+ *
+ * Counted rather than boolean, because nested dialogs are legal
+ * (`showModal()` stacks in the top layer) and a naive
+ * lock/unlock pair has the inner one's cleanup unlock the page
+ * while the outer is still open. The original value is captured
+ * on the *first* lock, so restoring is a restore rather than a
+ * guess at what an app's own stylesheet wanted.
+ *
+ * Not a React hook: this is process-wide state, and two components
+ * sharing it through module scope is the honest expression of
+ * that. `Modal` calls it from an effect and returns the release as
+ * the cleanup.
+ */
+export declare const lockScrollBehind: () => (() => void);
+//# sourceMappingURL=lockScrollBehind.d.ts.map

package/dist/Modal/lockScrollBehind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lockScrollBehind.d.ts","sourceRoot":"","sources":["../../src/Modal/lockScrollBehind.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAMH,eAAO,MAAM,gBAAgB,QAAO,CAAC,MAAM,IAAI,CAiC9C,CAAA"}

package/dist/Modal/lockScrollBehind.js

@@ -0,0 +1,48 @@
+/**
+ * The one thing `showModal()` does not do.
+ *
+ * A native modal makes everything behind it `inert` — unclickable,
+ * untabbable, invisible to a screen reader — and then lets you
+ * scroll it anyway. On a phone that reads as the dialog sliding
+ * around; on a long page it loses the user's place entirely.
+ *
+ * Counted rather than boolean, because nested dialogs are legal
+ * (`showModal()` stacks in the top layer) and a naive
+ * lock/unlock pair has the inner one's cleanup unlock the page
+ * while the outer is still open. The original value is captured
+ * on the *first* lock, so restoring is a restore rather than a
+ * guess at what an app's own stylesheet wanted.
+ *
+ * Not a React hook: this is process-wide state, and two components
+ * sharing it through module scope is the honest expression of
+ * that. `Modal` calls it from an effect and returns the release as
+ * the cleanup.
+ */
+let lockCount = 0;
+let previousOverflow = "";
+export const lockScrollBehind = () => {
+    if (typeof document === "undefined") {
+        return () => { };
+    }
+    const { documentElement } = document;
+    if (lockCount === 0) {
+        previousOverflow = documentElement.style.overflow;
+        documentElement.style.overflow = "hidden";
+    }
+    lockCount += 1;
+    let isReleased = false;
+    return () => {
+        // Idempotent, because React 19's StrictMode runs an effect's
+        // cleanup twice and a double decrement would unlock the page
+        // under a dialog that is still open.
+        if (isReleased) {
+            return;
+        }
+        isReleased = true;
+        lockCount -= 1;
+        if (lockCount === 0) {
+            documentElement.style.overflow = previousOverflow;
+        }
+    };
+};
+//# sourceMappingURL=lockScrollBehind.js.map

package/dist/Modal/lockScrollBehind.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lockScrollBehind.js","sourceRoot":"","sources":["../../src/Modal/lockScrollBehind.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,IAAI,SAAS,GAAG,CAAC,CAAA;AAEjB,IAAI,gBAAgB,GAAG,EAAE,CAAA;AAEzB,MAAM,CAAC,MAAM,gBAAgB,GAAG,GAAiB,EAAE;IACjD,IAAI,OAAO,QAAQ,KAAK,WAAW,EAAE,CAAC;QACpC,OAAO,GAAG,EAAE,GAAE,CAAC,CAAA;IACjB,CAAC;IAED,MAAM,EAAE,eAAe,EAAE,GAAG,QAAQ,CAAA;IAEpC,IAAI,SAAS,KAAK,CAAC,EAAE,CAAC;QACpB,gBAAgB,GAAG,eAAe,CAAC,KAAK,CAAC,QAAQ,CAAA;QAEjD,eAAe,CAAC,KAAK,CAAC,QAAQ,GAAG,QAAQ,CAAA;IAC3C,CAAC;IAED,SAAS,IAAI,CAAC,CAAA;IAEd,IAAI,UAAU,GAAG,KAAK,CAAA;IAEtB,OAAO,GAAG,EAAE;QACV,6DAA6D;QAC7D,6DAA6D;QAC7D,qCAAqC;QACrC,IAAI,UAAU,EAAE,CAAC;YACf,OAAM;QACR,CAAC;QAED,UAAU,GAAG,IAAI,CAAA;QAEjB,SAAS,IAAI,CAAC,CAAA;QAEd,IAAI,SAAS,KAAK,CAAC,EAAE,CAAC;YACpB,eAAe,CAAC,KAAK,CAAC,QAAQ,GAAG,gBAAgB,CAAA;QACnD,CAAC;IACH,CAAC,CAAA;AACH,CAAC,CAAA"}

package/dist/Popover/Popover.d.ts

@@ -0,0 +1,66 @@
+import type { Placement } from "@floating-ui/react";
+import type { ReactElement, ReactNode } from "react";
+export type PopoverProps = {
+    children: ReactNode;
+    className?: string;
+    /**
+     * Required, and it becomes the panel's `aria-label`. A
+     * `role="dialog"` takes **no accessible name from its content**,
+     * so an unnamed one is announced as "dialog" and is unfindable
+     * by `getByRole("dialog", { name })` — the same trap `Spinner`
+     * walked into in M3 with `role="status"`.
+     */
+    heading: string;
+    isVisible: boolean;
+    /**
+     * Outside press and Escape both land here, through floating-ui's
+     * `useDismiss`. Wire it to a `useVisibility()`'s `hide`.
+     */
+    onDismiss: () => void;
+    placement?: Placement;
+    /**
+     * The control the panel hangs off. **Cloned, not wrapped** — an
+     * extra `<div>` around a button is how a toolbar's layout
+     * quietly changes.
+     */
+    trigger: ReactElement;
+};
+/**
+ * Replaces mux-magic's `@radix-ui/react-popover` re-export, and it
+ * is a rewrite rather than a swap for one reason: Radix owns
+ * `open`, so wrapping it leaves `useVisibility` and Radix both
+ * believing they hold it. `@floating-ui/react` is the layer Radix,
+ * Base UI, and Ark UI are all *built on*, and it is controlled by
+ * construction — you pass state in and it never stores any.
+ *
+ * What floating-ui is used for is what only it can do: collision
+ * handling (`flip`, `shift`), a real dismiss layer, and focus
+ * management. Positioning strategy, the top layer, and the ARIA
+ * wiring come from the platform and from `useRole`.
+ *
+ * ### The top layer, from the platform — not a portal
+ *
+ * `popover="manual"` puts the panel in the top layer, which is
+ * what a portal is normally reached for: no `z-index` contest, and
+ * no `overflow: hidden` ancestor clipping it. Unlike a portal it
+ * **stays where it is in the DOM**, so `canvas.getByRole("dialog")`
+ * still finds it and a story keeps its scoping. Same argument as
+ * `Modal`, one layer down.
+ *
+ * `manual`, not `auto`, and that is the state-ownership decision
+ * again: `auto` brings the UA's own light-dismiss, which closes the
+ * element by itself and leaves `isVisible` true. `useDismiss` does
+ * the same job through our callback, so Charcuterie stays the only
+ * thing that decides.
+ *
+ * ### Two UA defaults that have to be undone
+ *
+ * `[popover]` ships `position: fixed; inset: 0; margin: auto`,
+ * which centres the panel in the viewport and fights every
+ * coordinate floating-ui computes — hence `inset-auto m-0`, and
+ * `strategy: "fixed"` so the numbers are viewport-relative like the
+ * top layer itself. Getting either wrong reads as a positioning
+ * bug rather than as a UA default.
+ */
+export declare const Popover: ({ children, className, heading, isVisible, onDismiss, placement, trigger, }: PopoverProps) => ReactNode;
+//# sourceMappingURL=Popover.d.ts.map

package/dist/Popover/Popover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Popover.d.ts","sourceRoot":"","sources":["../../src/Popover/Popover.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAYnD,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAIpD,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,EAAE,SAAS,CAAA;IACnB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB;;;;;;OAMG;IACH,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,OAAO,CAAA;IAClB;;;OAGG;IACH,SAAS,EAAE,MAAM,IAAI,CAAA;IACrB,SAAS,CAAC,EAAE,SAAS,CAAA;IACrB;;;;OAIG;IACH,OAAO,EAAE,YAAY,CAAA;CACtB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,OAAO,GAAI,6EAQrB,YAAY,KAAG,SA2EjB,CAAA"}

package/dist/Popover/Popover.js

@@ -0,0 +1,88 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useClonedChild } from "@charcuterie/logic";
+import { autoUpdate, FloatingFocusManager, flip, offset, shift, useDismiss, useFloating, useInteractions, useRole, } from "@floating-ui/react";
+import { toClassName } from "../toClassName.js";
+/**
+ * Replaces mux-magic's `@radix-ui/react-popover` re-export, and it
+ * is a rewrite rather than a swap for one reason: Radix owns
+ * `open`, so wrapping it leaves `useVisibility` and Radix both
+ * believing they hold it. `@floating-ui/react` is the layer Radix,
+ * Base UI, and Ark UI are all *built on*, and it is controlled by
+ * construction — you pass state in and it never stores any.
+ *
+ * What floating-ui is used for is what only it can do: collision
+ * handling (`flip`, `shift`), a real dismiss layer, and focus
+ * management. Positioning strategy, the top layer, and the ARIA
+ * wiring come from the platform and from `useRole`.
+ *
+ * ### The top layer, from the platform — not a portal
+ *
+ * `popover="manual"` puts the panel in the top layer, which is
+ * what a portal is normally reached for: no `z-index` contest, and
+ * no `overflow: hidden` ancestor clipping it. Unlike a portal it
+ * **stays where it is in the DOM**, so `canvas.getByRole("dialog")`
+ * still finds it and a story keeps its scoping. Same argument as
+ * `Modal`, one layer down.
+ *
+ * `manual`, not `auto`, and that is the state-ownership decision
+ * again: `auto` brings the UA's own light-dismiss, which closes the
+ * element by itself and leaves `isVisible` true. `useDismiss` does
+ * the same job through our callback, so Charcuterie stays the only
+ * thing that decides.
+ *
+ * ### Two UA defaults that have to be undone
+ *
+ * `[popover]` ships `position: fixed; inset: 0; margin: auto`,
+ * which centres the panel in the viewport and fights every
+ * coordinate floating-ui computes — hence `inset-auto m-0`, and
+ * `strategy: "fixed"` so the numbers are viewport-relative like the
+ * top layer itself. Getting either wrong reads as a positioning
+ * bug rather than as a UA default.
+ */
+export const Popover = ({ children, className, heading, isVisible, onDismiss, placement = "bottom-start", trigger, }) => {
+    const { context, floatingStyles, refs } = useFloating({
+        // Read-only. Charcuterie remains the sole owner; floating-ui
+        // is told what is true and never decides it.
+        open: isVisible,
+        onOpenChange: (isNextVisible) => {
+            if (!isNextVisible) {
+                onDismiss();
+            }
+        },
+        placement,
+        middleware: [offset(8), flip(), shift({ padding: 8 })],
+        strategy: "fixed",
+        whileElementsMounted: autoUpdate,
+    });
+    // `useRole` writes `aria-expanded`, `aria-haspopup`, and
+    // `aria-controls` on the trigger and `id` + `role="dialog"` on
+    // the panel, from one source. Hand-writing them alongside is how
+    // an `aria-controls` ends up pointing at an id that moved.
+    const { getFloatingProps, getReferenceProps } = useInteractions([
+        useDismiss(context),
+        useRole(context, { role: "dialog" }),
+    ]);
+    const clonedTrigger = useClonedChild(trigger, {
+        ...getReferenceProps(),
+        ref: refs.setReference,
+    });
+    return (_jsxs(_Fragment, { children: [clonedTrigger, isVisible ? (_jsx(FloatingFocusManager, { context: context, modal: false, children: _jsx("div", { ...getFloatingProps(), "aria-label": heading, className: toClassName("inset-auto m-0 max-w-xs rounded-md border border-border-default bg-surface-overlay p-3 text-content-primary text-sm shadow-medium", className), popover: "manual", 
+                    // Duplicated from `getFloatingProps()` on purpose, and
+                    // the two cannot differ — `useRole(context, { role:
+                    // "dialog" })` above is where it comes from. Stated
+                    // here because a linter cannot see a role through a
+                    // spread, and neither can the next reader.
+                    role: "dialog", ref: (node) => {
+                        refs.setFloating(node);
+                        // In a ref callback rather than an effect, because a
+                        // `[popover]` is `display: none` until it is shown —
+                        // and `FloatingFocusManager` is a *child*, so its
+                        // effect runs first and would be focusing into a
+                        // hidden element. Refs are set during commit, before
+                        // any of that.
+                        if (node && !node.matches(":popover-open")) {
+                            node.showPopover();
+                        }
+                    }, style: floatingStyles, children: children }) })) : null] }));
+};
+//# sourceMappingURL=Popover.js.map

package/dist/Popover/Popover.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Popover.js","sourceRoot":"","sources":["../../src/Popover/Popover.tsx"],"names":[],"mappings":";AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AAEnD,OAAO,EACL,UAAU,EACV,oBAAoB,EACpB,IAAI,EACJ,MAAM,EACN,KAAK,EACL,UAAU,EACV,WAAW,EACX,eAAe,EACf,OAAO,GACR,MAAM,oBAAoB,CAAA;AAG3B,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AA4B/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,CAAC,EACtB,QAAQ,EACR,SAAS,EACT,OAAO,EACP,SAAS,EACT,SAAS,EACT,SAAS,GAAG,cAAc,EAC1B,OAAO,GACM,EAAa,EAAE;IAC5B,MAAM,EAAE,OAAO,EAAE,cAAc,EAAE,IAAI,EAAE,GAAG,WAAW,CAAC;QACpD,6DAA6D;QAC7D,6CAA6C;QAC7C,IAAI,EAAE,SAAS;QACf,YAAY,EAAE,CAAC,aAAa,EAAE,EAAE;YAC9B,IAAI,CAAC,aAAa,EAAE,CAAC;gBACnB,SAAS,EAAE,CAAA;YACb,CAAC;QACH,CAAC;QACD,SAAS;QACT,UAAU,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,KAAK,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC;QACtD,QAAQ,EAAE,OAAO;QACjB,oBAAoB,EAAE,UAAU;KACjC,CAAC,CAAA;IAEF,yDAAyD;IACzD,+DAA+D;IAC/D,iEAAiE;IACjE,2DAA2D;IAC3D,MAAM,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,GAC3C,eAAe,CAAC;QACd,UAAU,CAAC,OAAO,CAAC;QACnB,OAAO,CAAC,OAAO,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;KACrC,CAAC,CAAA;IAEJ,MAAM,aAAa,GAAG,cAAc,CAAC,OAAO,EAAE;QAC5C,GAAG,iBAAiB,EAAE;QACtB,GAAG,EAAE,IAAI,CAAC,YAAY;KACvB,CAAC,CAAA;IAEF,OAAO,CACL,8BACG,aAAa,EAEb,SAAS,CAAC,CAAC,CAAC,CACX,KAAC,oBAAoB,IACnB,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,KAAK,YAEZ,iBACM,gBAAgB,EAAE,gBACV,OAAO,EACnB,SAAS,EAAE,WAAW,CACpB,mIAAmI,EACnI,SAAS,CACV,EACD,OAAO,EAAC,QAAQ;oBAChB,uDAAuD;oBACvD,oDAAoD;oBACpD,oDAAoD;oBACpD,oDAAoD;oBACpD,2CAA2C;oBAC3C,IAAI,EAAC,QAAQ,EACb,GAAG,EAAE,CAAC,IAAI,EAAE,EAAE;wBACZ,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAA;wBAEtB,qDAAqD;wBACrD,qDAAqD;wBACrD,kDAAkD;wBAClD,iDAAiD;wBACjD,qDAAqD;wBACrD,eAAe;wBACf,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC,EAAE,CAAC;4BAC3C,IAAI,CAAC,WAAW,EAAE,CAAA;wBACpB,CAAC;oBACH,CAAC,EACD,KAAK,EAAE,cAAc,YAEpB,QAAQ,GACL,GACe,CACxB,CAAC,CAAC,CAAC,IAAI,IACP,CACJ,CAAA;AACH,CAAC,CAAA"}

package/dist/ProgressBar/ProgressBar.d.ts

@@ -0,0 +1,51 @@
+import type { IntentName } from "@charcuterie/tokens";
+import type { ComponentPropsWithRef, ReactNode } from "react";
+import type { ProgressThreshold } from "./progressValue.ts";
+export type ProgressBarSize = "lg" | "md" | "sm";
+export type ProgressBarProps = Omit<ComponentPropsWithRef<"div">, "children"> & {
+    intent?: IntentName;
+    /**
+     * Indeterminate means "working, no measurable progress yet" — not
+     * zero and not unknown-therefore-full. rip-deck's is the
+     * AACS/BD+ preamble: ~25 s of a real Blu-ray emitting nothing, in
+     * which a full bar reads as a finished rip and an empty one as a
+     * wedged drive.
+     */
+    isIndeterminate?: boolean;
+    isLabelVisible?: boolean;
+    isValueShown?: boolean;
+    /** Required. A progressbar with no name is a grey rectangle. */
+    label: string;
+    max?: number;
+    size?: ProgressBarSize;
+    thresholds?: readonly ProgressThreshold[];
+    value?: number;
+};
+/**
+ * The union of what the fleet has: rip-deck's ARIA and its
+ * indeterminate sweep, plus threshold colours nobody has yet.
+ *
+ * Five repos hand-roll a progress bar and **only rip-deck's has
+ * `role="progressbar"`** — the other four are a `<div>` with a
+ * percentage width, invisible to assistive technology and to
+ * `getByRole("progressbar")`.
+ *
+ * Three corrections to rip-deck's version, which is otherwise the
+ * best in the fleet:
+ *
+ *  - **The role goes on the track, not the fill.** rip-deck puts
+ *    `role="progressbar"` on the inner filled element, so the
+ *    widget's box is the *filled portion* — a 4% rip is a
+ *    progressbar 4px wide as far as AT and a Playwright bounding
+ *    box are concerned.
+ *  - **The name comes from a real label**, wired with
+ *    `aria-labelledby` when it is visible and `VisuallyHidden` when
+ *    it is not, rather than a hardcoded `aria-label` string that
+ *    cannot be translated or reused.
+ *  - **`aria-valuenow` is omitted while indeterminate**, which is
+ *    what tells AT "unknown" rather than "zero". rip-deck gets this
+ *    right by rendering a separate element; stating it on one
+ *    element is the same answer without the duplication.
+ */
+export declare const ProgressBar: ({ className, intent, isIndeterminate, isLabelVisible, isValueShown, label, max, size, thresholds, value, ...divProps }: ProgressBarProps) => ReactNode;
+//# sourceMappingURL=ProgressBar.d.ts.map

package/dist/ProgressBar/ProgressBar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProgressBar.d.ts","sourceRoot":"","sources":["../../src/ProgressBar/ProgressBar.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AACrD,OAAO,KAAK,EACV,qBAAqB,EACrB,SAAS,EACV,MAAM,OAAO,CAAA;AAKd,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AAO3D,MAAM,MAAM,eAAe,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAA;AAEhD,MAAM,MAAM,gBAAgB,GAAG,IAAI,CACjC,qBAAqB,CAAC,KAAK,CAAC,EAC5B,UAAU,CACX,GAAG;IACF,MAAM,CAAC,EAAE,UAAU,CAAA;IACnB;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,gEAAgE;IAChE,KAAK,EAAE,MAAM,CAAA;IACb,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,IAAI,CAAC,EAAE,eAAe,CAAA;IACtB,UAAU,CAAC,EAAE,SAAS,iBAAiB,EAAE,CAAA;IACzC,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAQD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,WAAW,GAAI,wHAYzB,gBAAgB,KAAG,SAqFrB,CAAA"}

package/dist/ProgressBar/ProgressBar.js

@@ -0,0 +1,50 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useUniqueId } from "@charcuterie/logic";
+import { INTENT_SOLID_FILL_CLASS } from "../intentStyles.js";
+import { toClassName } from "../toClassName.js";
+import { VisuallyHidden } from "../VisuallyHidden/VisuallyHidden.js";
+import { getProgressIntent, toProgressPercent, toProgressValue, } from "./progressValue.js";
+const TRACK_SIZE_CLASS = {
+    sm: "h-1",
+    md: "h-2",
+    lg: "h-3",
+};
+/**
+ * The union of what the fleet has: rip-deck's ARIA and its
+ * indeterminate sweep, plus threshold colours nobody has yet.
+ *
+ * Five repos hand-roll a progress bar and **only rip-deck's has
+ * `role="progressbar"`** — the other four are a `<div>` with a
+ * percentage width, invisible to assistive technology and to
+ * `getByRole("progressbar")`.
+ *
+ * Three corrections to rip-deck's version, which is otherwise the
+ * best in the fleet:
+ *
+ *  - **The role goes on the track, not the fill.** rip-deck puts
+ *    `role="progressbar"` on the inner filled element, so the
+ *    widget's box is the *filled portion* — a 4% rip is a
+ *    progressbar 4px wide as far as AT and a Playwright bounding
+ *    box are concerned.
+ *  - **The name comes from a real label**, wired with
+ *    `aria-labelledby` when it is visible and `VisuallyHidden` when
+ *    it is not, rather than a hardcoded `aria-label` string that
+ *    cannot be translated or reused.
+ *  - **`aria-valuenow` is omitted while indeterminate**, which is
+ *    what tells AT "unknown" rather than "zero". rip-deck gets this
+ *    right by rendering a separate element; stating it on one
+ *    element is the same answer without the duplication.
+ */
+export const ProgressBar = ({ className, intent = "accent", isIndeterminate = false, isLabelVisible = false, isValueShown = false, label, max = 100, size = "md", thresholds, value = 0, ...divProps }) => {
+    const labelId = useUniqueId();
+    const percent = toProgressPercent(value, max);
+    const clampedValue = toProgressValue(value, max);
+    const fillIntent = getProgressIntent(percent, intent, thresholds);
+    return (_jsxs("div", { ...divProps, className: toClassName("flex flex-col gap-1", className), children: [isLabelVisible || isValueShown ? (_jsxs("div", { className: "flex items-baseline justify-between gap-2 text-sm", children: [isLabelVisible ? (_jsx("span", { className: "text-content-secondary", id: labelId, children: label })) : (_jsx(VisuallyHidden, { id: labelId, children: label })), isValueShown && !isIndeterminate ? (_jsxs("span", { className: "text-content-muted tabular-nums", children: [percent, "%"] })) : null] })) : (_jsx(VisuallyHidden, { id: labelId, children: label })), _jsx("div", { "aria-busy": isIndeterminate || undefined, "aria-labelledby": labelId, "aria-valuemax": max, "aria-valuemin": 0, "aria-valuenow": isIndeterminate ? undefined : clampedValue, className: toClassName("relative w-full overflow-hidden rounded-full bg-surface-sunken", TRACK_SIZE_CLASS[size]), role: "progressbar", children: isIndeterminate ? (_jsx("span", { className: toClassName(
+                    // The sweep animates `inset-inline-start`, so it runs
+                    // the other way in RTL for free — and its
+                    // reduced-motion fallback hatches the whole track
+                    // rather than parking at one end.
+                    "charcuterie-sweep absolute inset-y-0 w-2/5 rounded-full", INTENT_SOLID_FILL_CLASS[fillIntent]) })) : (_jsx("span", { className: toClassName("block h-full rounded-full transition-[inline-size] duration-(--duration-normal) ease-standard", INTENT_SOLID_FILL_CLASS[fillIntent]), style: { inlineSize: `${percent}%` } })) })] }));
+};
+//# sourceMappingURL=ProgressBar.js.map

package/dist/ProgressBar/ProgressBar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProgressBar.js","sourceRoot":"","sources":["../../src/ProgressBar/ProgressBar.tsx"],"names":[],"mappings":";AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAOhD,OAAO,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAA;AAC5D,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAC/C,OAAO,EAAE,cAAc,EAAE,MAAM,qCAAsC,CAAA;AAErE,OAAO,EACL,iBAAiB,EACjB,iBAAiB,EACjB,eAAe,GAChB,MAAM,oBAAoB,CAAA;AA2B3B,MAAM,gBAAgB,GAAoC;IACxD,EAAE,EAAE,KAAK;IACT,EAAE,EAAE,KAAK;IACT,EAAE,EAAE,KAAK;CACV,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,EAC1B,SAAS,EACT,MAAM,GAAG,QAAQ,EACjB,eAAe,GAAG,KAAK,EACvB,cAAc,GAAG,KAAK,EACtB,YAAY,GAAG,KAAK,EACpB,KAAK,EACL,GAAG,GAAG,GAAG,EACT,IAAI,GAAG,IAAI,EACX,UAAU,EACV,KAAK,GAAG,CAAC,EACT,GAAG,QAAQ,EACM,EAAa,EAAE;IAChC,MAAM,OAAO,GAAG,WAAW,EAAE,CAAA;IAE7B,MAAM,OAAO,GAAG,iBAAiB,CAAC,KAAK,EAAE,GAAG,CAAC,CAAA;IAE7C,MAAM,YAAY,GAAG,eAAe,CAAC,KAAK,EAAE,GAAG,CAAC,CAAA;IAEhD,MAAM,UAAU,GAAG,iBAAiB,CAClC,OAAO,EACP,MAAM,EACN,UAAU,CACX,CAAA;IAED,OAAO,CACL,kBACM,QAAQ,EACZ,SAAS,EAAE,WAAW,CACpB,qBAAqB,EACrB,SAAS,CACV,aAEA,cAAc,IAAI,YAAY,CAAC,CAAC,CAAC,CAChC,eAAK,SAAS,EAAC,mDAAmD,aAC/D,cAAc,CAAC,CAAC,CAAC,CAChB,eACE,SAAS,EAAC,wBAAwB,EAClC,EAAE,EAAE,OAAO,YAEV,KAAK,GACD,CACR,CAAC,CAAC,CAAC,CACF,KAAC,cAAc,IAAC,EAAE,EAAE,OAAO,YACxB,KAAK,GACS,CAClB,EAEA,YAAY,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,CAClC,gBAAM,SAAS,EAAC,iCAAiC,aAC9C,OAAO,SACH,CACR,CAAC,CAAC,CAAC,IAAI,IACJ,CACP,CAAC,CAAC,CAAC,CACF,KAAC,cAAc,IAAC,EAAE,EAAE,OAAO,YACxB,KAAK,GACS,CAClB,EAED,2BACa,eAAe,IAAI,SAAS,qBACtB,OAAO,mBACT,GAAG,mBACH,CAAC,mBAEd,eAAe,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,YAAY,EAE5C,SAAS,EAAE,WAAW,CACpB,gEAAgE,EAChE,gBAAgB,CAAC,IAAI,CAAC,CACvB,EACD,IAAI,EAAC,aAAa,YAEjB,eAAe,CAAC,CAAC,CAAC,CACjB,eACE,SAAS,EAAE,WAAW;oBACpB,sDAAsD;oBACtD,0CAA0C;oBAC1C,kDAAkD;oBAClD,kCAAkC;oBAClC,yDAAyD,EACzD,uBAAuB,CAAC,UAAU,CAAC,CACpC,GACD,CACH,CAAC,CAAC,CAAC,CACF,eACE,SAAS,EAAE,WAAW,CACpB,+FAA+F,EAC/F,uBAAuB,CAAC,UAAU,CAAC,CACpC,EACD,KAAK,EAAE,EAAE,UAAU,EAAE,GAAG,OAAO,GAAG,EAAE,GACpC,CACH,GACG,IACF,CACP,CAAA;AACH,CAAC,CAAA"}

package/dist/ProgressBar/progressValue.d.ts

@@ -0,0 +1,44 @@
+import type { IntentName } from "@charcuterie/tokens";
+/**
+ * A threshold is "from this percentage upward, use this intent".
+ * Order does not matter — the highest matching entry wins — because
+ * a caller sorting a config array by hand is a bug waiting for the
+ * day someone appends to it.
+ */
+export type ProgressThreshold = {
+    from: number;
+    intent: IntentName;
+};
+/**
+ * Clamped, rounded, and NaN-proof, in a file a Node test can reach
+ * without a browser.
+ *
+ * All three cases are real. rip-deck's `fillPercent` comes from a
+ * ripper's stdout, and a progress value that arrives as `-1`,
+ * `101`, or `NaN` from a log parse currently renders as a bar that
+ * overflows its track or vanishes. `max: 0` is the one that looks
+ * hypothetical and is not: it is "0 of 0 files done", which every
+ * empty queue produces on its first render.
+ */
+export declare const toProgressPercent: (value: number, max: number) => number;
+/**
+ * The same clamp in the value's own units, for `aria-valuenow`.
+ *
+ * Reporting the raw prop there would hand assistive technology a
+ * `valuenow` outside its own `valuemin`/`valuemax` — which some
+ * screen readers render as a nonsense percentage and others drop
+ * entirely — while the bar on screen showed the clamped one. The
+ * two must not disagree.
+ */
+export declare const toProgressValue: (value: number, max: number) => number;
+/**
+ * The threshold colour, or the component's own intent when no
+ * threshold applies.
+ *
+ * This is the piece rip-deck hardcodes as `FILL_CLASS` keyed by a
+ * rip state, and mux-magic does not have at all. Generalising it to
+ * "percentage → intent" covers both the "green when done" case and
+ * the "amber past 80% of the disk" case with one mechanism.
+ */
+export declare const getProgressIntent: (percent: number, intent: IntentName, thresholds?: readonly ProgressThreshold[]) => IntentName;
+//# sourceMappingURL=progressValue.d.ts.map

package/dist/ProgressBar/progressValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"progressValue.d.ts","sourceRoot":"","sources":["../../src/ProgressBar/progressValue.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAErD;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,UAAU,CAAA;CACnB,CAAA;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB,GAC5B,OAAO,MAAM,EACb,KAAK,MAAM,WAcZ,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,GAC1B,OAAO,MAAM,EACb,KAAK,MAAM,WAOZ,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,GAC5B,SAAS,MAAM,EACf,QAAQ,UAAU,EAClB,aAAa,SAAS,iBAAiB,EAAE,KACxC,UAWF,CAAA"}