neatkit 0.7.0 → 0.8.0

package/dist/components/Portal/utils/scroll-container.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Resolves the nearest scroller an overlay should lock within its Boundary.
+ *
+ * An overlay is positioned within its boundary rather than the viewport, so
+ * it travels with the content behind it, and locking nothing is correct when
+ * no scroller lies in between.
+ *
+ * @param boundary - The boundary owning the overlay requesting the lock.
+ * @param ownerDocument - The document containing the boundary.
+ *
+ * @returns The enclosing scroller, or null when the overlay locks nothing.
+ */
+export declare function resolveScrollContainer(boundary: Element | null, ownerDocument: Document): Element | Document | null;

package/dist/components/Radio/Radio.d.ts

@@ -1,4 +1,5 @@
 import { type CSSProperties, type InputHTMLAttributes, type ReactNode } from "react";
+import RadioGroup from "./components/RadioGroup";
 import "./styles/radio.css";
 /** A type representing properties for the Radio component. */
 export type RadioProps = Omit<InputHTMLAttributes<HTMLInputElement>, "checked" | "children" | "className" | "defaultChecked" | "name" | "onChange" | "required" | "style" | "type" | "value"> & {
@@ -19,7 +20,7 @@ export type RadioProps = Omit<InputHTMLAttributes<HTMLInputElement>, "checked" |
  *
  * @returns The rendered Radio option.
  */
-declare const Radio: import("react").ForwardRefExoticComponent<Omit<InputHTMLAttributes<HTMLInputElement>, "defaultChecked" | "className" | "style" | "children" | "onChange" | "name" | "type" | "value" | "required" | "checked"> & {
+declare const RadioRoot: import("react").ForwardRefExoticComponent<Omit<InputHTMLAttributes<HTMLInputElement>, "defaultChecked" | "className" | "style" | "children" | "onChange" | "name" | "type" | "value" | "required" | "checked"> & {
     /** The clickable and accessible label for the Radio option. */
     children: ReactNode;
     /** The additional class name applied to the Radio label root. */
@@ -29,4 +30,11 @@ declare const Radio: import("react").ForwardRefExoticComponent<Omit<InputHTMLAtt
     /** The string submitted when the Radio option is selected. */
     value: string;
 } & import("react").RefAttributes<HTMLInputElement>>;
+/** A type representing the complete compound Radio component. */
+type RadioComponent = typeof RadioRoot & {
+    /** A labelled set of mutually exclusive Radio options. */
+    Group: typeof RadioGroup;
+};
+/** The compound Radio component and its grouping form. */
+declare const Radio: RadioComponent;
 export default Radio;

package/dist/components/{RadioGroup → Radio/components}/RadioGroup.d.ts

@@ -1,8 +1,8 @@
 import { type ChangeEventHandler, type HTMLAttributes, type ReactNode } from "react";
-import "./styles/radio-group.css";
+import "../styles/radio-group.css";
 /** A type representing the visual direction of Radio options. */
 export type RadioGroupOrientation = "horizontal" | "vertical";
-/** A type representing properties for the RadioGroup component. */
+/** A type representing properties for the Radio.Group component. */
 export type RadioGroupProps = Omit<HTMLAttributes<HTMLDivElement>, "children" | "defaultValue" | "onChange"> & {
     /** The Radio options belonging to the group. */
     children: ReactNode;
@@ -26,6 +26,13 @@ export type RadioGroupProps = Omit<HTMLAttributes<HTMLDivElement>, "children" |
 /**
  * Renders a native radio group with shared form and validation state.
  *
+ * @note Radio children are deliberately not validated, unlike Checkbox.Group.
+ * The browser groups radios by their shared `name` and enforces `required`
+ * across that group, so this component never reads its children and content
+ * may be wrapped or arranged freely. Checkbox.Group has no such native
+ * primitive and must inspect each option during render, which is why it
+ * rejects wrappers. The divergence follows the platform, not a preference.
+ *
  * @param props - The properties that configure the RadioGroup.
  * @param forwardedReference - The reference assigned to the group root.
  *

package/dist/components/Radio/index.d.ts

@@ -1,2 +1,3 @@
 export { default } from "./Radio";
 export type { RadioProps } from "./Radio";
+export type { RadioGroupOrientation, RadioGroupProps, } from "./components/RadioGroup";

package/dist/components/Select/Select.d.ts

@@ -62,8 +62,6 @@ export type CustomSelectProps = Omit<ButtonHTMLAttributes<HTMLButtonElement>, "c
     options: readonly SelectOption[];
     /** The guidance displayed when no option is selected. */
     placeholder?: string;
-    /** The optional element receiving the listbox portal. */
-    portalContainer?: Element | null;
     /** The inline styles applied to the composite Select root. */
     style?: CSSProperties;
     /** Whether the custom Select communicates that a value is required. */

package/dist/components/Select/utils/listbox-position.d.ts

@@ -0,0 +1,28 @@
+import type { EdgeBounds } from "../../Portal/utils/floating-position";
+/** A type representing the fitted position of a Select listbox. */
+export type ListboxPosition = {
+    /** The boundary-relative horizontal position. */
+    left: number;
+    /** The maximum height available in the selected vertical direction. */
+    maxHeight: number;
+    /** The minimum width inherited from the trigger. */
+    minWidth: number;
+    /** The boundary-relative vertical position. */
+    top: number;
+};
+/**
+ * Calculates the listbox position and height fitted inside a boundary.
+ *
+ * Every rectangle is expressed in the same coordinate space, so the returned
+ * coordinates share that space and callers convert them once.
+ *
+ * A boundary shorter than the readable minimum is deliberately exceeded,
+ * because a listbox collapsed to a few pixels shows nothing at all.
+ *
+ * @param triggerBounds - The bounds of the trigger anchoring the listbox.
+ * @param listboxBounds - The measured listbox bounds, when it is mounted.
+ * @param boundaryBounds - The bounds the listbox must remain inside.
+ *
+ * @returns The fitted listbox coordinates and size constraints.
+ */
+export declare function calculateListboxPosition(triggerBounds: DOMRect, listboxBounds: DOMRect | undefined, boundaryBounds: EdgeBounds): ListboxPosition;

package/dist/components/Sidebar/Sidebar.d.ts

@@ -0,0 +1,108 @@
+import { type HTMLAttributes, type ReactNode, type RefObject } from "react";
+import SidebarFooter from "./components/SidebarFooter";
+import SidebarGroup from "./components/SidebarGroup";
+import SidebarItem from "./components/SidebarItem";
+import { type SidebarSide, type SidebarStyle } from "./components/SidebarPanel";
+import SidebarTrigger from "./components/SidebarTrigger";
+import SidebarUser from "./components/SidebarUser";
+import { type SidebarOpenChangeReason, type SidebarVariant } from "./utils/state";
+import "./styles/sidebar.css";
+export type { SidebarFooterProps } from "./components/SidebarFooter";
+export type { SidebarGroupPresentation, SidebarGroupProps, } from "./components/SidebarGroup";
+export type { SidebarItemProps } from "./components/SidebarItem";
+export type { SidebarSide } from "./components/SidebarPanel";
+export type { SidebarTriggerProps } from "./components/SidebarTrigger";
+export type { SidebarUserAction, SidebarUserProps, } from "./components/SidebarUser";
+export type { SidebarOpenChangeReason, SidebarVariant } from "./utils/state";
+/** A type representing the complete compound Sidebar component. */
+type SidebarComponent = typeof SidebarRoot & {
+    /** The region pinned to the bottom of the Sidebar. */
+    Footer: typeof SidebarFooter;
+    /** A related set of Sidebar items forming one navigation region. */
+    Group: typeof SidebarGroup;
+    /** One navigation destination or action inside a group. */
+    Item: typeof SidebarItem;
+    /** The control disclosing an overlay Sidebar. */
+    Trigger: typeof SidebarTrigger;
+    /** A person's avatar, name, and optional trailing control. */
+    User: typeof SidebarUser;
+};
+/** A type representing properties for the Sidebar component. */
+export type SidebarProps = Omit<HTMLAttributes<HTMLElement>, "children" | "id" | "role" | "style" | "tabIndex"> & {
+    /** The regions and groups composing the Sidebar. */
+    children?: ReactNode;
+    /** Whether an uncontrolled overlay Sidebar is initially open. */
+    defaultOpen?: boolean;
+    /** The preferred element focused when the overlay Sidebar opens. */
+    initialFocusReference?: RefObject<HTMLElement | null>;
+    /** The distance the inline Sidebar is pinned below its scroll container. */
+    top?: string;
+    /** Whether document scrolling is locked while the overlay is open. */
+    lockScroll?: boolean;
+    /** The controlled open state of the overlay Sidebar. */
+    open?: boolean;
+    /** Whether focus returns to the Trigger after the overlay closes. */
+    restoreFocus?: boolean;
+    /** The edge the overlay Sidebar occupies. */
+    side?: SidebarSide;
+    /** The styles applied to the Sidebar panel. */
+    style?: SidebarStyle;
+    /** The responsive behavior selecting the Sidebar presentation. */
+    variant?: SidebarVariant;
+    /** The width of the Sidebar as a valid CSS length. */
+    width?: string;
+    /** The callback invoked when an interaction requests a changed state. */
+    onOpenChange?: (open: boolean, reason: SidebarOpenChangeReason) => void;
+};
+/**
+ * Renders a navigation panel beside content or as a disclosed overlay.
+ *
+ * An overlay Sidebar is always dismissable through Escape and an outside
+ * press, because it traps focus behind a modal dialog that renders no close
+ * control of its own.
+ *
+ * The panel advertises its own state for styling, and those attributes are
+ * part of the public contract: `data-variant` reports the presentation as
+ * `inline` or `overlay`, `data-side` the edge it occupies, and `data-state`
+ * whether a disclosed panel is `open` or `closing`. Select them beside a
+ * consumer class to style one presentation without a prop for each.
+ *
+ * The Sidebar publishes its state to the surrounding boundary, so a
+ * Trigger placed anywhere inside that boundary can disclose it. The boundary
+ * is also what the responsive presentation measures, so a narrow Boundary
+ * presents an overlay even on a wide display.
+ *
+ * @param props - The properties that configure the Sidebar.
+ * @param forwardedReference - The reference assigned to the panel element.
+ *
+ * @returns The inline, disclosed, or unmounted Sidebar panel.
+ */
+declare const SidebarRoot: import("react").ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLElement>, "id" | "style" | "tabIndex" | "role" | "children"> & {
+    /** The regions and groups composing the Sidebar. */
+    children?: ReactNode;
+    /** Whether an uncontrolled overlay Sidebar is initially open. */
+    defaultOpen?: boolean;
+    /** The preferred element focused when the overlay Sidebar opens. */
+    initialFocusReference?: RefObject<HTMLElement | null>;
+    /** The distance the inline Sidebar is pinned below its scroll container. */
+    top?: string;
+    /** Whether document scrolling is locked while the overlay is open. */
+    lockScroll?: boolean;
+    /** The controlled open state of the overlay Sidebar. */
+    open?: boolean;
+    /** Whether focus returns to the Trigger after the overlay closes. */
+    restoreFocus?: boolean;
+    /** The edge the overlay Sidebar occupies. */
+    side?: SidebarSide;
+    /** The styles applied to the Sidebar panel. */
+    style?: SidebarStyle;
+    /** The responsive behavior selecting the Sidebar presentation. */
+    variant?: SidebarVariant;
+    /** The width of the Sidebar as a valid CSS length. */
+    width?: string;
+    /** The callback invoked when an interaction requests a changed state. */
+    onOpenChange?: (open: boolean, reason: SidebarOpenChangeReason) => void;
+} & import("react").RefAttributes<HTMLElement>>;
+/** The compound Sidebar component and its composable regions. */
+declare const Sidebar: SidebarComponent;
+export default Sidebar;

package/dist/components/Sidebar/components/SidebarFooter.d.ts

@@ -0,0 +1,19 @@
+import { type HTMLAttributes, type ReactNode } from "react";
+/** A type representing properties for the Sidebar.Footer component. */
+export type SidebarFooterProps = HTMLAttributes<HTMLDivElement> & {
+    /** The content pinned to the bottom of the Sidebar. */
+    children?: ReactNode;
+};
+/**
+ * Renders the region pinned to the bottom of a Sidebar.
+ *
+ * @param props - The native properties that configure the footer.
+ * @param forwardedReference - The reference assigned to the footer element.
+ *
+ * @returns The rendered Sidebar footer.
+ */
+declare const SidebarFooter: import("react").ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
+    /** The content pinned to the bottom of the Sidebar. */
+    children?: ReactNode;
+} & import("react").RefAttributes<HTMLDivElement>>;
+export default SidebarFooter;

package/dist/components/Sidebar/components/SidebarGroup.d.ts

@@ -0,0 +1,42 @@
+import { type HTMLAttributes, type ReactNode } from "react";
+/** A type representing the presentations that render a Sidebar group. */
+export type SidebarGroupPresentation = "both" | "inline" | "overlay";
+/** A type representing properties for the Sidebar.Group component. */
+export type SidebarGroupProps = Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+    /** The Sidebar items rendered inside the group. */
+    children?: ReactNode;
+    /** The visible heading naming the group's navigation region. */
+    label?: ReactNode;
+    /**
+     * The Sidebar presentations that render the group.
+     *
+     * Restricting a group suits navigation duplicated elsewhere in a wide
+     * layout, such as links an application bar already provides.
+     */
+    presentation?: SidebarGroupPresentation;
+};
+/**
+ * Renders a related set of Sidebar items as one navigation region.
+ *
+ * A group becomes a navigation landmark only when it carries an accessible
+ * name, because repeated unnamed landmarks cannot be told apart.
+ *
+ * @param props - The label and native properties that configure the group.
+ * @param forwardedReference - The reference assigned to the group element.
+ *
+ * @returns The rendered Sidebar group.
+ */
+declare const SidebarGroup: import("react").ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+    /** The Sidebar items rendered inside the group. */
+    children?: ReactNode;
+    /** The visible heading naming the group's navigation region. */
+    label?: ReactNode;
+    /**
+     * The Sidebar presentations that render the group.
+     *
+     * Restricting a group suits navigation duplicated elsewhere in a wide
+     * layout, such as links an application bar already provides.
+     */
+    presentation?: SidebarGroupPresentation;
+} & import("react").RefAttributes<HTMLElement>>;
+export default SidebarGroup;

package/dist/components/Sidebar/components/SidebarItem.d.ts

@@ -0,0 +1,43 @@
+import { type ComponentPropsWithRef, type ComponentPropsWithoutRef, type ElementType, type ReactElement, type ReactNode } from "react";
+import { type IconType } from "../../Icon";
+/** A type representing properties owned by the Sidebar.Item component. */
+type SidebarItemOwnProps = {
+    /** Whether the item represents the current page or view. */
+    active?: boolean;
+    /** The label displayed inside the item. */
+    children?: ReactNode;
+    /** Whether the item is present but unavailable. */
+    disabled?: boolean;
+    /** The icon displayed before the item label. */
+    icon?: IconType;
+};
+/** A type representing the reference accepted by a polymorphic element. */
+type SidebarItemReference<Component extends ElementType> = ComponentPropsWithRef<Component>["ref"];
+/** A type representing properties for a polymorphic Sidebar item. */
+export type SidebarItemProps<Component extends ElementType = "button"> = SidebarItemOwnProps & {
+    /**
+     * The intrinsic element or custom component used as the item control.
+     *
+     * Custom components own their native semantics and must forward the
+     * class name, reference, event handlers, and ARIA properties to their
+     * interactive root.
+     */
+    as?: Component;
+} & Omit<ComponentPropsWithoutRef<Component>, keyof SidebarItemOwnProps | "as">;
+/** A type representing the public polymorphic Sidebar item component. */
+type SidebarItemComponent = <Component extends ElementType = "button">(props: SidebarItemProps<Component> & {
+    ref?: SidebarItemReference<Component>;
+}) => ReactElement | null;
+/**
+ * Renders one navigation destination or action inside a Sidebar group.
+ *
+ * Items carrying a navigation target report the current page, while action
+ * items report the current selection instead.
+ *
+ * @param props - The properties that configure the item and its element.
+ * @param forwardedReference - The reference assigned to the item control.
+ *
+ * @returns The rendered Sidebar item and its list container.
+ */
+declare const SidebarItem: SidebarItemComponent;
+export default SidebarItem;

package/dist/components/Sidebar/components/SidebarOverlay.d.ts

@@ -0,0 +1,38 @@
+import { type RefObject } from "react";
+import type { SidebarState } from "../utils/state";
+import { type SidebarPanelProps } from "./SidebarPanel";
+/**
+ * A type representing properties for the mounted Sidebar overlay layer.
+ *
+ * The forwarded panel properties are derived rather than restated, so the
+ * consumer attributes the root spreads through here stay described by one
+ * declaration. The overlay supplies the presentation, open state, and
+ * identifier itself, and a top offset applies to no overlay.
+ */
+type SidebarOverlayProps = Omit<SidebarPanelProps, "top" | "open" | "panelId" | "panelReference" | "presentation" | "state"> & {
+    /** The elements treated as part of the overlay dismissal layer. */
+    boundaries: readonly RefObject<HTMLElement | null>[];
+    /** The preferred element focused when the Sidebar opens. */
+    initialFocusReference?: RefObject<HTMLElement | null>;
+    /** Whether scrolling is locked while the Sidebar is open. */
+    lockScroll: boolean;
+    /** The document owning the mounted overlay layer. */
+    ownerDocument: Document;
+    /** Assigns the mounted panel to internal and consumer references. */
+    panelReference: (element: HTMLElement | null) => void;
+    /** The visual phase exposed to transition styles. */
+    presenceState: "closing" | "open";
+    /** Whether focus returns to its prior owner when the Sidebar closes. */
+    restoreFocus: boolean;
+    /** The shared Sidebar state supplied by its provider. */
+    sidebar: SidebarState;
+};
+/**
+ * Renders and coordinates one mounted Sidebar overlay layer.
+ *
+ * @param props - The panel, document, and transition properties.
+ *
+ * @returns The open or exiting Sidebar overlay.
+ */
+export default function SidebarOverlay(props: SidebarOverlayProps): import("react").JSX.Element;
+export {};

package/dist/components/Sidebar/components/SidebarPanel.d.ts

@@ -0,0 +1,47 @@
+import type { CSSProperties, HTMLAttributes, ReactNode, Ref } from "react";
+import type { SidebarPresentation } from "../utils/state";
+/** A type representing the edge an overlay Sidebar occupies. */
+export type SidebarSide = "end" | "start";
+/** A type representing CSS custom properties accepted by Sidebar styles. */
+type SidebarCustomProperties = {
+    [CustomProperty in `--${string}`]?: string | number;
+};
+/** A type representing native Sidebar styles and CSS custom properties. */
+export type SidebarStyle = CSSProperties & SidebarCustomProperties;
+/** A type representing properties used to implement the Sidebar panel. */
+export type SidebarPanelProps = Omit<HTMLAttributes<HTMLElement>, "children" | "style"> & {
+    /** The regions and groups composing the Sidebar. */
+    children?: ReactNode;
+    /** The distance the inline panel is pinned below its scroll container. */
+    top?: string;
+    /** The identifier associating the panel with its Trigger. */
+    panelId?: string;
+    /** The reference assigned to the rendered panel element. */
+    panelReference: Ref<HTMLElement>;
+    /** The presentation currently rendered by the Sidebar. */
+    presentation: SidebarPresentation;
+    /** Whether the Sidebar is currently disclosed as an overlay. */
+    open: boolean;
+    /** The edge the overlay panel occupies. */
+    side: SidebarSide;
+    /** The visual phase exposed to transition styles. */
+    state?: "closing" | "open";
+    /** The styles applied to the panel. */
+    style?: SidebarStyle;
+    /** The width of the Sidebar as a CSS length. */
+    width?: string;
+};
+/**
+ * Renders the Sidebar panel shared by both of its presentations.
+ *
+ * Authoring the panel once keeps both presentations in step, though it does
+ * not preserve the element itself: an overlay is portalled into the boundary
+ * while an inline panel stays in place, so crossing the responsive breakpoint
+ * remounts the panel and restarts anything stateful inside it.
+ *
+ * @param props - The presentation, state, and native panel properties.
+ *
+ * @returns The rendered Sidebar panel.
+ */
+export default function SidebarPanel(props: SidebarPanelProps): import("react").JSX.Element;
+export {};

package/dist/components/Sidebar/components/SidebarTrigger.d.ts

@@ -0,0 +1,47 @@
+import { type MouseEvent, type ReactElement, type Ref } from "react";
+import type { SidebarVariant } from "../utils/state";
+/** A type representing the properties applied to a cloned Trigger child. */
+type SidebarTriggerChildProps = {
+    /** The panel association announced while the Sidebar is open. */
+    "aria-controls"?: string;
+    /** The disclosure state announced for the Sidebar. */
+    "aria-expanded"?: boolean;
+    /** The kind of interface the control discloses. */
+    "aria-haspopup"?: "dialog";
+    /** The class names applied to the control. */
+    className?: string;
+    /** The responsive behavior selecting stylesheet visibility. */
+    "data-sidebar-variant"?: SidebarVariant;
+    /** The callback invoked when the control is activated. */
+    onClick?: (event: MouseEvent<HTMLElement>) => void;
+    /** The reference assigned to the control. */
+    ref?: Ref<HTMLElement>;
+};
+/** A type representing properties for the Sidebar.Trigger component. */
+export type SidebarTriggerProps = {
+    /**
+     * The single control that opens the overlay Sidebar.
+     *
+     * Custom components must forward the class name, reference, click handler,
+     * and ARIA properties to their interactive root.
+     */
+    children: ReactElement;
+};
+/**
+ * Connects an existing control to the overlay Sidebar it opens.
+ *
+ * The Trigger renders no element of its own, and renders nothing at all
+ * until a Sidebar publishes to the surrounding boundary. A server render
+ * resolves no presentation, so server markup carries no control and
+ * hydration adds one rather than withdrawing one the page should never
+ * have shown. A Trigger whose boundary holds no Sidebar stays absent for
+ * the same reason: there is nothing for it to disclose, and the control
+ * returns as soon as a Sidebar publishes.
+ *
+ * @param props - The single control receiving Sidebar behavior.
+ *
+ * @returns The control extended with Sidebar disclosure behavior, or
+ * nothing while no Sidebar is connected.
+ */
+export default function SidebarTrigger(props: SidebarTriggerProps): ReactElement<SidebarTriggerChildProps, string | import("react").JSXElementConstructor<any>> | null;
+export {};

package/dist/components/Sidebar/components/SidebarUser.d.ts

@@ -0,0 +1,59 @@
+import { type HTMLAttributes, type ReactNode } from "react";
+import { type ButtonProps } from "../../Button";
+import { type IconType } from "../../Icon";
+/** A type representing one consistently styled Sidebar user action. */
+export type SidebarUserAction = Omit<ButtonProps<"button">, "as" | "children" | "className" | "fullWidth" | "icon" | "iconAlignment" | "shape" | "style" | "textAlignment" | "type" | "variant"> & {
+    /** The icon identifying the action. */
+    icon: IconType;
+    /** The short Tooltip label and base accessible name for the action. */
+    label: string;
+};
+/** A type representing properties for the Sidebar.User component. */
+export type SidebarUserProps = Omit<HTMLAttributes<HTMLDivElement>, "children" | "onClick"> & {
+    /**
+     * The controls operating on the represented person.
+     *
+     * Each action is keyed by its label, so labels must be unique.
+     */
+    actions?: readonly SidebarUserAction[];
+    /** The secondary line displayed beneath the name. */
+    description?: ReactNode;
+    /** The image displayed until loading fails. */
+    image?: string;
+    /** Whether the details are replaced by a loading indicator. */
+    loading?: boolean;
+    /** The display name shown for the represented person. */
+    name: string;
+    /** The callback invoked when the details are activated. */
+    onClick?: () => void;
+};
+/**
+ * Renders a person's avatar, name, and its consistently styled actions.
+ *
+ * The details and the actions are separately operable, so an activatable
+ * identity does not absorb the controls beside it.
+ *
+ * @param props - The identity, state, and native properties.
+ * @param forwardedReference - The reference assigned to the root element.
+ *
+ * @returns The rendered Sidebar user row.
+ */
+declare const SidebarUser: import("react").ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement>, "children" | "onClick"> & {
+    /**
+     * The controls operating on the represented person.
+     *
+     * Each action is keyed by its label, so labels must be unique.
+     */
+    actions?: readonly SidebarUserAction[];
+    /** The secondary line displayed beneath the name. */
+    description?: ReactNode;
+    /** The image displayed until loading fails. */
+    image?: string;
+    /** Whether the details are replaced by a loading indicator. */
+    loading?: boolean;
+    /** The display name shown for the represented person. */
+    name: string;
+    /** The callback invoked when the details are activated. */
+    onClick?: () => void;
+} & import("react").RefAttributes<HTMLDivElement>>;
+export default SidebarUser;

package/dist/components/Sidebar/hooks/usePresentation.d.ts

@@ -0,0 +1,14 @@
+import type { BoundaryWidthStore } from "../../Boundary/contexts/BoundaryContext";
+import type { SidebarPresentation, SidebarVariant } from "../utils/state";
+/**
+ * Resolves the presentation a Sidebar renders inside its boundary.
+ *
+ * The boundary is measured rather than the viewport, so a narrow Boundary on a
+ * wide display still presents its Sidebar as an overlay.
+ *
+ * @param variant - The responsive behavior requested by the consumer.
+ * @param width - The boundary width store, when a boundary exists.
+ *
+ * @returns The explicit, measured, or pending Sidebar presentation.
+ */
+export declare function usePresentation(variant: SidebarVariant, width: BoundaryWidthStore | undefined): SidebarPresentation;

package/dist/components/Sidebar/hooks/useSidebar.d.ts

@@ -0,0 +1,9 @@
+import { type SidebarState } from "../utils/state";
+/**
+ * Returns the Sidebar state published to the surrounding boundary.
+ *
+ * @param componentName - The subcomponent name reported when unconnected.
+ *
+ * @returns The published Sidebar state when one exists.
+ */
+export declare function useSidebar(componentName: string): SidebarState | undefined;

package/dist/components/Sidebar/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from "./Sidebar";
+export type { SidebarFooterProps, SidebarGroupPresentation, SidebarGroupProps, SidebarItemProps, SidebarOpenChangeReason, SidebarProps, SidebarSide, SidebarTriggerProps, SidebarUserAction, SidebarUserProps, SidebarVariant, } from "./Sidebar";

package/dist/components/Sidebar/utils/state.d.ts

@@ -0,0 +1,62 @@
+/** A type representing the responsive behavior of a Sidebar. */
+export type SidebarVariant = "inline" | "overlay" | "responsive";
+/**
+ * A type representing the presentation a Sidebar currently renders.
+ *
+ * The pending presentation covers server rendering and hydration, where the
+ * boundary is not yet measured and stylesheets select the presentation.
+ */
+export type SidebarPresentation = "inline" | "overlay" | "pending";
+/** A type representing an interaction requesting a Sidebar state change. */
+export type SidebarOpenChangeReason = "escape" | "item" | "outside" | "trigger" | "variant";
+/** A type representing the state one Sidebar publishes to its boundary. */
+export type SidebarState = {
+    /** The identifier applied to the Sidebar panel. */
+    id: string;
+    /** Whether the overlay Sidebar is currently open. */
+    open: boolean;
+    /** The presentation currently rendered by the Sidebar. */
+    presentation: SidebarPresentation;
+    /** The responsive behavior requested for the Sidebar. */
+    variant: SidebarVariant;
+    /** Adds a mounted Trigger to the overlay dismissal layer. */
+    registerTrigger: (element: HTMLElement) => void;
+    /** Removes an unmounted Trigger from the overlay dismissal layer. */
+    unregisterTrigger: (element: HTMLElement) => void;
+    /** Requests a change to the overlay open state. */
+    requestOpenChange: (open: boolean, reason: SidebarOpenChangeReason) => void;
+};
+/**
+ * Publishes a Sidebar's state while no other Sidebar holds the boundary.
+ *
+ * @param boundary - The boundary the publishing Sidebar occupies.
+ * @param owner - The token identifying the publishing Sidebar.
+ * @param state - The state shared with the boundary's descendants.
+ *
+ * @returns Whether the publishing Sidebar holds the boundary.
+ */
+export declare function publishSidebarState(boundary: Element, owner: symbol, state: SidebarState): boolean;
+/**
+ * Releases a boundary when the requesting Sidebar still holds it.
+ *
+ * @param boundary - The boundary being released.
+ * @param owner - The token identifying the releasing Sidebar.
+ */
+export declare function releaseSidebarState(boundary: Element, owner: symbol): void;
+/**
+ * Reads the Sidebar state registered for a boundary.
+ *
+ * @param boundary - The boundary whose Sidebar is read, when one exists.
+ *
+ * @returns The registered state, or undefined while none is registered.
+ */
+export declare function readSidebarState(boundary: Element | null): SidebarState | undefined;
+/**
+ * Subscribes a listener to a boundary's Sidebar registration.
+ *
+ * @param boundary - The boundary being observed, when one exists.
+ * @param listener - The listener notified after every change.
+ *
+ * @returns The teardown removing the registered listener.
+ */
+export declare function subscribeToSidebarState(boundary: Element | null, listener: () => void): () => void;