@jfrader/ui 0.5.0 → 0.5.1

package/dist/types/components/elastic-slider/elastic-slider.d.ts

@@ -0,0 +1,53 @@
+import { type ComponentPropsWithRef, type ReactNode } from 'react';
+import { type SxProps } from '../../styling/sx';
+import { type SliderMark, type SliderPart as Part } from '../slider/use-slider-interaction';
+export type ElasticSliderMark = SliderMark;
+export type ElasticSliderSize = 'sm' | 'md';
+export interface ElasticSliderSlotProps {
+    label?: Part<'span'>;
+    readout?: Part<'span'>;
+    description?: Part<'div'>;
+    error?: Part<'div'>;
+    control?: Part<'div'>;
+    rail?: Part<'div'>;
+    track?: Part<'div'>;
+    fill?: Part<'div'>;
+    thumb?: Part<'div'>;
+    bubble?: Part<'span'>;
+    tick?: Part<'span'> | ((index: number) => Part<'span'>);
+    mark?: Part<'button'> | ((index: number) => Part<'button'>);
+    start?: Part<'div'>;
+    end?: Part<'div'>;
+}
+export interface ElasticSliderProps extends Omit<ComponentPropsWithRef<'div'>, 'defaultValue' | 'onChange' | 'children'>, SxProps {
+    label: ReactNode;
+    value?: number;
+    defaultValue?: number;
+    onValueChange?: (value: number) => void;
+    onValueCommit?: (value: number) => void;
+    description?: ReactNode;
+    error?: ReactNode;
+    invalid?: boolean;
+    disabled?: boolean;
+    min?: number;
+    max?: number;
+    step?: number;
+    largeStep?: number;
+    /** Detents. Normalized to the step lattice; invalid or out-of-domain marks are ignored. */
+    marks?: readonly ElasticSliderMark[];
+    locale?: Intl.LocalesArgument;
+    formatOptions?: Intl.NumberFormatOptions;
+    formatValue?: (value: number, formatter: Intl.NumberFormat) => string;
+    showValue?: boolean;
+    start?: ReactNode;
+    end?: ReactNode;
+    /** Short vibration when a touch drag latches onto a detent, where supported. Off under reduced motion. */
+    haptics?: boolean;
+    name?: string;
+    size?: ElasticSliderSize;
+    slotProps?: ElasticSliderSlotProps;
+}
+export declare function ElasticSlider(props: ElasticSliderProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export declare namespace ElasticSlider {
+    var displayName: string;
+}

package/dist/types/components/elastic-slider/index.d.ts

@@ -0,0 +1 @@
+export { ElasticSlider, type ElasticSliderProps, type ElasticSliderMark, type ElasticSliderSize, type ElasticSliderSlotProps, } from './elastic-slider';

package/dist/types/components/expanding-search/expanding-search.d.ts

@@ -0,0 +1,22 @@
+import { type ComponentPropsWithRef, type CSSProperties, type Ref } from 'react';
+import { type SxProps } from '../../styling/sx';
+import { type SearchFieldProps, type SearchFieldSize } from '../search-field';
+export type ExpandingSearchInputProps = Omit<ComponentPropsWithRef<'input'>, 'ref' | 'type' | 'role' | 'size' | 'value' | 'defaultValue' | 'children' | 'disabled' | 'dir' | 'className'>;
+export interface ExpandingSearchProps extends Omit<ComponentPropsWithRef<'div'>, 'children' | 'defaultValue' | 'onChange'>, SxProps, Pick<SearchFieldProps, 'value' | 'defaultValue' | 'onValueChange' | 'label' | 'description' | 'error' | 'clearable' | 'messages' | 'searchIcon' | 'clearIcon' | 'slotProps'> {
+    /** Accessible name of the collapsed button; also the input's fallback name. */
+    triggerLabel: string;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    anchor?: 'start' | 'end';
+    expandedWidth?: CSSProperties['inlineSize'];
+    size?: SearchFieldSize;
+    disabled?: boolean;
+    /** Native attributes and events of the search input. */
+    inputProps?: ExpandingSearchInputProps;
+    inputRef?: Ref<HTMLInputElement>;
+}
+export declare function ExpandingSearch({ ref, inputRef, triggerLabel, open: openProp, defaultOpen, onOpenChange, anchor, expandedWidth, size, disabled, value, defaultValue, onValueChange, label, description, error, clearable, messages, searchIcon, clearIcon, slotProps, inputProps, className, sx, dir, style, onKeyDown, onBlur, ...rootProps }: ExpandingSearchProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export declare namespace ExpandingSearch {
+    var displayName: string;
+}

package/dist/types/components/expanding-search/index.d.ts

@@ -0,0 +1 @@
+export { ExpandingSearch, type ExpandingSearchInputProps, type ExpandingSearchProps } from './expanding-search';

package/dist/types/components/menu/menu.d.ts

@@ -1,7 +1,8 @@
-import { type ComponentPropsWithRef, type ReactNode } from 'react';
-import { type Placement } from '@floating-ui/react';
-import { type Interpolation, type Theme } from '../../styling/css';
+import { type ComponentPropsWithRef, type CSSProperties, type HTMLProps, type MutableRefObject, type ReactNode } from 'react';
+import { type Placement, type UseInteractionsReturn } from '@floating-ui/react';
+import { type Interpolation, type SerializedStyles, type Theme } from '../../styling/css';
 import { type SxProps } from '../../styling/sx';
+import { useOverlayFloating, type OverlayFloatingOptions } from '../../overlay/use-overlay-floating';
 export interface MenuProps {
     open?: boolean;
     defaultOpen?: boolean;
@@ -21,6 +22,29 @@ export interface MenuItemProps extends Omit<ComponentPropsWithRef<'button'>, 'on
 }
 export interface MenuSeparatorProps extends ComponentPropsWithRef<'div'>, SxProps {
 }
+export type MenuItemTone = 'neutral' | 'danger';
+/** Positioning options a family may set on the shared controller; Menu keeps the defaults. */
+export type MenuPositioning = Pick<OverlayFloatingOptions, 'strategy' | 'gap' | 'transform' | 'onAvailableSize'>;
+export interface MenuControllerProps extends MenuProps {
+    positioning?: MenuPositioning;
+}
+type OverlayFloating = ReturnType<typeof useOverlayFloating>;
+interface MenuContextValue {
+    open: boolean;
+    nodeId: string | undefined;
+    requestOpen: () => void;
+    requestClose: (restoreFocus?: boolean) => void;
+    activeIndex: number | null;
+    refs: OverlayFloating['refs'];
+    floatingContext: OverlayFloating['context'];
+    floatingStyles: CSSProperties;
+    elementsRef: MutableRefObject<Array<HTMLElement | null>>;
+    labelsRef: MutableRefObject<Array<string | null>>;
+    disabledIndices: Set<number>;
+    getReferenceProps: UseInteractionsReturn['getReferenceProps'];
+    getFloatingProps: UseInteractionsReturn['getFloatingProps'];
+    getItemProps: UseInteractionsReturn['getItemProps'];
+}
 /**
  * Private seam for component families built on the menu controller (Menu, SplitButton): the
  * family names usage errors, `marker` is the part's data-ui and `styles` its own styles.
@@ -30,16 +54,35 @@ export interface MenuPartIdentity {
     marker: string;
     styles?: Interpolation<Theme>;
 }
+/** Item behavior a family may change: the part name in usage errors, the item role and whether
+ * selection closes the menu. */
+export interface MenuItemPartBehavior {
+    part?: string;
+    itemRole?: 'menuitem' | 'menuitemcheckbox';
+    closeOnSelect?: boolean;
+}
+export declare function useMenuContext(family: string, part: string): MenuContextValue;
+/**
+ * Runs each consumer handler before the matching interaction handler; a consumer
+ * `preventDefault()` vetoes the internal request (open, toggle, navigation).
+ */
+export declare function consumerHandlersFirst(props: HTMLProps<Element>, getProps: (userProps: HTMLProps<Element>) => Record<string, unknown>): Record<string, unknown>;
 /** Own styles of a menu item, for families that layer their own item styles on top. */
-export declare const menuItemStyles: import("@emotion/react").SerializedStyles[];
+export declare const menuItemStyles: SerializedStyles[];
 /** Own styles of a menu separator. */
-export declare const menuSeparatorStyles: import("@emotion/react").SerializedStyles;
+export declare const menuSeparatorStyles: SerializedStyles;
+/** Command tones for families whose items carry one (SplitButton, ContextMenu). */
+export declare const menuItemToneStyles: Record<MenuItemTone, SerializedStyles>;
+/** The shared menu controller (state, positioning, navigation, dismissal, focus return). */
+export declare function MenuController(props: MenuControllerProps): import("@emotion/react/jsx-runtime").JSX.Element;
 declare function MenuRoot(props: MenuProps): import("@emotion/react/jsx-runtime").JSX.Element;
 export declare function MenuTriggerPart({ family, marker, styles, ref, className, sx, ...props }: MenuTriggerProps & MenuPartIdentity): import("@emotion/react/jsx-runtime").JSX.Element;
 declare function MenuTrigger(props: MenuTriggerProps): import("@emotion/react/jsx-runtime").JSX.Element;
-export declare function MenuContentPart({ family, marker, styles, ref, style, children, className, sx, 'aria-label': ariaLabel, 'aria-labelledby': ariaLabelledBy, ...rest }: MenuContentProps & MenuPartIdentity): import("@emotion/react/jsx-runtime").JSX.Element | null;
+export declare function MenuContentPart({ family, marker, styles, ref, style, children, className, sx, 'aria-label': ariaLabel, 'aria-labelledby': ariaLabelledBy, defaultLabelledBy, ...rest }: MenuContentProps & MenuPartIdentity & {
+    defaultLabelledBy?: string;
+}): import("@emotion/react/jsx-runtime").JSX.Element | null;
 declare function MenuContent(props: MenuContentProps): import("@emotion/react/jsx-runtime").JSX.Element;
-export declare function MenuItemPart({ family, marker, styles, ref, onSelect, disabled, onClick, className, sx, ...rest }: MenuItemProps & MenuPartIdentity): import("@emotion/react/jsx-runtime").JSX.Element;
+export declare function MenuItemPart({ family, marker, styles, ref, onSelect, disabled, part, itemRole, closeOnSelect, onClick, className, sx, ...rest }: MenuItemProps & MenuPartIdentity & MenuItemPartBehavior): import("@emotion/react/jsx-runtime").JSX.Element;
 declare function MenuItem(props: MenuItemProps): import("@emotion/react/jsx-runtime").JSX.Element;
 export declare function MenuSeparatorPart({ marker, styles, ref, className, sx, ...props }: MenuSeparatorProps & Omit<MenuPartIdentity, 'family'>): import("@emotion/react/jsx-runtime").JSX.Element;
 declare function MenuSeparator(props: MenuSeparatorProps): import("@emotion/react/jsx-runtime").JSX.Element;

package/dist/types/components/pagination/pagination.d.ts

@@ -12,7 +12,7 @@ export interface PaginationProps extends Omit<ComponentPropsWithRef<'nav'>, 'onC
     nextLabel?: string;
     locale?: string;
 }
-export declare function Pagination({ ref, page, totalPages, onPageChange, siblingCount, label, previousLabel, nextLabel, locale, className, sx, ...rest }: PaginationProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export declare function Pagination({ ref, page, totalPages, onPageChange, siblingCount, label, previousLabel, nextLabel, locale, className, sx, 'aria-label': ariaLabel, 'aria-labelledby': ariaLabelledBy, ...rest }: PaginationProps): import("@emotion/react/jsx-runtime").JSX.Element;
 export declare namespace Pagination {
     var displayName: string;
 }

package/dist/types/components/radio-cards/radio-cards.d.ts

@@ -31,7 +31,7 @@ export interface RadioCardsItemProps extends Omit<ComponentPropsWithRef<'input'>
 export type RadioCardsLabelProps = ComponentPropsWithRef<'span'> & SxProps;
 export type RadioCardsDescriptionProps = ComponentPropsWithRef<'span'> & SxProps;
 declare function RadioCardsRoot({ ref, value: valueProp, defaultValue, onValueChange, name: nameProp, required, disabled, invalid, error, layout, minColumnWidth, size, className, sx, style, children, onKeyDown, 'aria-labelledby': labelledBy, 'aria-describedby': describedBy, 'aria-invalid': ariaInvalid, ...rest }: RadioCardsProps): import("@emotion/react/jsx-runtime").JSX.Element;
-declare function RadioCardsItem({ ref, value, label, description, meta, icon, disabledReason, disabled: disabledProp, required: requiredProp, onChange, slotProps, className, sx, 'aria-label': ariaLabel, 'aria-labelledby': labelledBy, 'aria-describedby': describedBy, 'aria-invalid': ariaInvalid, ...rest }: RadioCardsItemProps): import("@emotion/react/jsx-runtime").JSX.Element;
+declare function RadioCardsItem({ ref, value, label, description, meta, icon, disabledReason, dir, disabled: disabledProp, required: requiredProp, onChange, slotProps, className, sx, 'aria-label': ariaLabel, 'aria-labelledby': labelledBy, 'aria-describedby': describedBy, 'aria-invalid': ariaInvalid, ...rest }: RadioCardsItemProps): import("@emotion/react/jsx-runtime").JSX.Element;
 declare function RadioCardsLabel(props: RadioCardsLabelProps): import("@emotion/react/jsx-runtime").JSX.Element;
 declare function RadioCardsDescription(props: RadioCardsDescriptionProps): import("@emotion/react/jsx-runtime").JSX.Element;
 export declare const RadioCards: typeof RadioCardsRoot & {

package/dist/types/components/radio-group/radio-group.d.ts

@@ -26,7 +26,7 @@ export interface RadioGroupRadioProps extends Omit<ComponentPropsWithRef<'input'
     };
 }
 declare function RadioGroupRoot({ ref, value: valueProp, defaultValue, onValueChange, name: nameProp, disabled, orientation, className, sx, ...rest }: RadioGroupProps): import("@emotion/react/jsx-runtime").JSX.Element;
-declare function RadioGroupRadio({ ref, value, label, description, disabled: disabledProp, onChange, slotProps, className, sx, 'aria-labelledby': ariaLabelledByProp, 'aria-describedby': ariaDescribedByProp, ...rest }: RadioGroupRadioProps): import("@emotion/react/jsx-runtime").JSX.Element;
+declare function RadioGroupRadio({ ref, value, label, description, disabled: disabledProp, onChange, slotProps, className, sx, dir, 'aria-labelledby': ariaLabelledByProp, 'aria-describedby': ariaDescribedByProp, ...rest }: RadioGroupRadioProps): import("@emotion/react/jsx-runtime").JSX.Element;
 export declare const RadioGroup: typeof RadioGroupRoot & {
     Radio: typeof RadioGroupRadio;
 };

package/dist/types/components/slider/slider-style.d.ts

@@ -0,0 +1,14 @@
+export declare const sliderRootStyle: import("@emotion/react").SerializedStyles;
+export declare const sliderHeaderStyle: import("@emotion/react").SerializedStyles;
+export declare const sliderLabelStyle: import("@emotion/react").SerializedStyles;
+export declare const sliderReadoutStyle: import("@emotion/react").SerializedStyles;
+export declare const sliderDescriptionStyle: import("@emotion/react").SerializedStyles;
+export declare const sliderErrorStyle: import("@emotion/react").SerializedStyles;
+export declare const sliderRowStyle: import("@emotion/react").SerializedStyles;
+export declare const sliderControlStyle: import("@emotion/react").SerializedStyles;
+export declare const sliderSizeStyles: {
+    sm: import("@emotion/react").SerializedStyles;
+    md: import("@emotion/react").SerializedStyles;
+};
+export declare const sliderMarksStyle: import("@emotion/react").SerializedStyles;
+export declare const sliderMarkStyle: import("@emotion/react").SerializedStyles;

package/dist/types/components/slider/slider.d.ts

@@ -1,15 +1,8 @@
 import { type ComponentPropsWithRef, type ReactNode } from 'react';
-import { type Interpolation, type Theme } from '../../styling/css';
 import { type SxProps } from '../../styling/sx';
-export type SliderValue = number | readonly [number, number];
-export type SliderMark = number | {
-    value: number;
-    label?: ReactNode;
-};
+import { type SliderMark, type SliderPart as Part } from './use-slider-interaction';
+export type { SliderMark, SliderValue } from './use-slider-interaction';
 export type SliderSize = 'sm' | 'md';
-type Part<E extends 'div' | 'span' | 'button'> = ComponentPropsWithRef<E> & {
-    css?: Interpolation<Theme>;
-};
 export interface SliderSlotProps {
     label?: Part<'span'>;
     readout?: Part<'span'>;
@@ -67,4 +60,3 @@ export declare function Slider(props: SliderProps): import("@emotion/react/jsx-r
 export declare namespace Slider {
     var displayName: string;
 }
-export {};

package/dist/types/components/slider/use-slider-interaction.d.ts

@@ -0,0 +1,79 @@
+import { type ComponentPropsWithRef, type KeyboardEvent, type PointerEvent, type ReactNode, type RefCallback, type RefObject } from 'react';
+import type { Interpolation, Theme } from '../../styling/css';
+export type SliderValue = number | readonly [number, number];
+export type SliderMark = number | {
+    value: number;
+    label?: ReactNode;
+};
+export type SliderPart<E extends 'div' | 'span' | 'button'> = ComponentPropsWithRef<E> & {
+    css?: Interpolation<Theme>;
+};
+/** Pointer position for one gesture sample, in domain units plus the geometry to convert them. */
+export interface SliderPointerSample {
+    /** Unclamped domain value under the pointer (grab offset applied). */
+    raw: number;
+    /** Bounds the dragged thumb may take. */
+    low: number;
+    high: number;
+    /** CSS pixels per domain unit along the control. */
+    pxPerUnit: number;
+    rtl: boolean;
+    pointerType: string;
+}
+export declare function joinIds(...values: (string | false | undefined)[]): string | undefined;
+export declare function hasContent(node: ReactNode): boolean;
+export declare function indexedPart<E extends 'div' | 'span' | 'button'>(part: SliderPart<E> | ((index: number) => SliderPart<E>) | undefined, index: number): SliderPart<E> | undefined;
+export declare function useSliderFormat(locale: Intl.LocalesArgument, formatOptions: Intl.NumberFormatOptions | undefined, formatValue: ((value: number, formatter: Intl.NumberFormat) => string) | undefined): {
+    formatter: Intl.NumberFormat;
+    format: (n: number) => string;
+};
+export interface SliderInteractionOptions {
+    /** Public component name used in configuration errors. */
+    component: string;
+    range: boolean;
+    value: SliderValue | undefined;
+    defaultValue: SliderValue | undefined;
+    min: number;
+    max: number;
+    step: number;
+    largeStep: number | undefined;
+    minStepsBetweenThumbs: number;
+    disabled: boolean;
+    onValueChange: (next: SliderValue) => void;
+    onValueCommit: (next: SliderValue) => void;
+    /** Visual feedback hook: runs for every accepted pointer sample, before the value request. */
+    onPointerSample?: (sample: SliderPointerSample) => void;
+    /** Maps a pointer sample to the raw domain target (e.g. magnetic detents). Defaults to `raw`. */
+    resolvePointer?: (sample: SliderPointerSample) => number;
+    /** Runs once when a gesture ends: completed (pointerup) or cancelled (cancel, lost capture, disable, reset). */
+    onGestureEnd?: (completed: boolean) => void;
+}
+export interface SliderInteraction {
+    id: string;
+    controlRef: RefObject<HTMLDivElement | null>;
+    current: SliderValue;
+    values: number[] | readonly [number, number];
+    active: number | null;
+    bounds: (index: number) => number[];
+    percent: (n: number) => number;
+    normalizeMarks: (marks: readonly SliderMark[]) => {
+        value: number;
+        label?: ReactNode;
+    }[];
+    /** Handlers for the pointer-capture control; consumer slot handlers run first and may veto. */
+    controlHandlers: (part: SliderPart<'div'> | undefined) => {
+        ref: RefCallback<HTMLDivElement>;
+        onPointerDown: (e: PointerEvent<HTMLDivElement>) => void;
+        onPointerMove: (e: PointerEvent<HTMLDivElement>) => void;
+        onPointerUp: (e: PointerEvent<HTMLDivElement>) => void;
+        onPointerCancel: (e: PointerEvent<HTMLDivElement>) => void;
+        onLostPointerCapture: (e: PointerEvent<HTMLDivElement>) => void;
+    };
+    /** Root `onKeyDown` tail: routes movement keys from a thumb inside this control. */
+    handleRootKeyDown: (event: KeyboardEvent<HTMLDivElement>) => void;
+    /** Activation of a mark shortcut: one change + commit for a changed request, nothing otherwise. */
+    selectMark: (markValue: number) => void;
+    /** Remembers the last focused thumb for equidistant range presses. */
+    noteFocus: (index: number) => void;
+}
+export declare function useSliderInteraction(options: SliderInteractionOptions): SliderInteraction;

package/dist/types/components/split-button/split-button.d.ts

@@ -2,8 +2,8 @@ import { type ComponentPropsWithRef, type ReactNode } from 'react';
 import { type Placement } from '@floating-ui/react';
 import { type SxProps } from '../../styling/sx';
 import { type ButtonProps, type ButtonSize, type ButtonTone, type ButtonVariant } from '../button';
-import { type MenuContentProps, type MenuItemProps, type MenuSeparatorProps } from '../menu/menu';
-export type SplitButtonItemTone = 'neutral' | 'danger';
+import { type MenuItemTone, type MenuContentProps, type MenuItemProps, type MenuSeparatorProps } from '../menu/menu';
+export type SplitButtonItemTone = MenuItemTone;
 export interface SplitButtonProps extends Omit<ComponentPropsWithRef<'div'>, 'role'>, SxProps {
     /** Appearance of the Action; the Trigger uses the matching subdued fill. */
     variant?: ButtonVariant;

package/dist/types/components/tabs/tabs.d.ts

@@ -18,7 +18,7 @@ export interface TabsPanelProps extends ComponentPropsWithRef<'div'>, SxProps {
 }
 declare function TabsRoot({ ref, value: valueProp, defaultValue, onValueChange, orientation, activation, className, sx, ...rest }: TabsProps): import("@emotion/react/jsx-runtime").JSX.Element;
 declare function TabsList({ ref, onKeyDown, className, sx, ...rest }: TabsListProps): import("@emotion/react/jsx-runtime").JSX.Element;
-declare function TabsTab({ ref, value, disabled, onClick, onFocus, className, sx, ...rest }: TabsTabProps): import("@emotion/react/jsx-runtime").JSX.Element;
+declare function TabsTab({ ref, value, disabled, onClick, onFocus, onPointerDown, className, sx, ...rest }: TabsTabProps): import("@emotion/react/jsx-runtime").JSX.Element;
 declare function TabsPanel({ ref, value, tabIndex, 'aria-labelledby': ariaLabelledByProp, className, sx, ...rest }: TabsPanelProps): import("@emotion/react/jsx-runtime").JSX.Element;
 export declare const Tabs: typeof TabsRoot & {
     List: typeof TabsList;

package/dist/types/components/text-field/text-field.d.ts

@@ -12,7 +12,7 @@ export interface TextFieldProps extends Omit<ComponentPropsWithRef<'input'>, 'si
     onValueChange?: (value: string) => void;
     slotProps?: FieldSlotProps<TextFieldPartProps>;
 }
-export declare function TextField({ ref, label, description, error, size, onChange, onValueChange, slotProps, className, sx, required, id: idProp, 'aria-describedby': ariaDescribedByProp, 'aria-invalid': ariaInvalidProp, ...rest }: TextFieldProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export declare function TextField({ ref, label, description, error, size, onChange, onValueChange, slotProps, className, sx, required, id: idProp, dir, 'aria-describedby': ariaDescribedByProp, 'aria-invalid': ariaInvalidProp, ...rest }: TextFieldProps): import("@emotion/react/jsx-runtime").JSX.Element;
 export declare namespace TextField {
     var displayName: string;
 }

package/dist/types/components/textarea/textarea.d.ts

@@ -15,7 +15,7 @@ export interface TextareaProps extends ComponentPropsWithRef<'textarea'>, SxProp
     onValueChange?: (value: string) => void;
     slotProps?: FieldSlotProps<TextareaPartProps>;
 }
-export declare function Textarea({ ref, label, description, error, size, resize, autoResize, rows, onChange, onValueChange, slotProps, className, sx, required, id: idProp, 'aria-describedby': ariaDescribedByProp, 'aria-invalid': ariaInvalidProp, ...rest }: TextareaProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export declare function Textarea({ ref, label, description, error, size, resize, autoResize, rows, onChange, onValueChange, slotProps, className, sx, dir, required, id: idProp, 'aria-describedby': ariaDescribedByProp, 'aria-invalid': ariaInvalidProp, ...rest }: TextareaProps): import("@emotion/react/jsx-runtime").JSX.Element;
 export declare namespace Textarea {
     var displayName: string;
 }

package/dist/types/components/theme-switch/index.d.ts

@@ -0,0 +1 @@
+export { ThemeSwitch, type ThemeSwitchProps, type ThemeSwitchValue, type ThemeSwitchTransition, type ThemeSwitchChangeDetails, } from './theme-switch';

package/dist/types/components/theme-switch/theme-switch.d.ts

@@ -0,0 +1,33 @@
+import { type ReactNode } from 'react';
+import { type SwitchPartProps, type SwitchProps } from '../switch';
+export type ThemeSwitchValue = 'light' | 'dark';
+export type ThemeSwitchTransition = 'reveal' | 'eclipse' | 'split' | 'rise';
+export interface ThemeSwitchChangeDetails {
+    transition: ThemeSwitchTransition;
+    trigger: HTMLInputElement;
+    reducedMotion: boolean;
+}
+export interface ThemeSwitchProps extends Omit<SwitchProps, 'value' | 'defaultValue' | 'checked' | 'defaultChecked' | 'onCheckedChange' | 'children' | 'slotProps'> {
+    value?: ThemeSwitchValue;
+    defaultValue?: ThemeSwitchValue;
+    onValueChange?: (next: ThemeSwitchValue, details: ThemeSwitchChangeDetails) => void;
+    label: ReactNode;
+    iconOnly?: boolean;
+    lightIcon?: ReactNode;
+    darkIcon?: ReactNode;
+    transition?: ThemeSwitchTransition;
+    loading?: boolean;
+    slotProps?: SwitchProps['slotProps'] & {
+        iconFrame?: SwitchPartProps;
+        lightIcon?: SwitchPartProps;
+        darkIcon?: SwitchPartProps;
+    };
+}
+/** Composes Switch: Space toggles dark appearance; the accessible name stays stable.
+ * The consumer applies the requested theme. The ref reaches Switch's native input.
+ * The decorative icon frame is a hidden label for the input, so clicking the glyph toggles too.
+ */
+export declare function ThemeSwitch({ value: valueProp, defaultValue, onValueChange, label, iconOnly, lightIcon, darkIcon, transition, loading, className, sx, slotProps, onChange, onClick, dir, id: idProp, ...rest }: ThemeSwitchProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export declare namespace ThemeSwitch {
+    var displayName: string;
+}

package/dist/types/components/tooltip/tooltip.d.ts

@@ -18,7 +18,7 @@ export interface TooltipContentProps extends ComponentPropsWithRef<'div'>, SxPro
 }
 declare function TooltipRoot(props: TooltipProps): import("@emotion/react/jsx-runtime").JSX.Element;
 declare function TooltipTrigger({ ref, 'aria-describedby': ariaDescribedByProp, className, sx, ...rest }: TooltipTriggerProps): import("@emotion/react/jsx-runtime").JSX.Element;
-declare function TooltipContent({ ref, style, className, sx, ...rest }: TooltipContentProps): import("@emotion/react/jsx-runtime").JSX.Element | null;
+declare function TooltipContent(props: TooltipContentProps): import("@emotion/react/jsx-runtime").JSX.Element | null;
 export declare const Tooltip: typeof TooltipRoot & {
     Trigger: typeof TooltipTrigger;
     Content: typeof TooltipContent;

package/dist/types/index.d.ts

@@ -15,7 +15,9 @@ export * from './components/chip-group';
 export * from './components/code-block';
 export * from './components/command-palette';
 export * from './components/combobox';
+export * from './components/comment-thread';
 export * from './components/container';
+export * from './components/context-menu';
 export * from './components/copy-button';
 export * from './components/countdown';
 export * from './components/date-picker';
@@ -23,8 +25,10 @@ export * from './components/date-range-picker';
 export * from './components/dialog';
 export * from './components/divider';
 export * from './components/drawer';
+export * from './components/elastic-slider';
 export * from './components/empty-state';
 export * from './components/expandable-card';
+export * from './components/expanding-search';
 export * from './components/file-dropzone';
 export * from './components/filter-toolbar';
 export * from './components/flex';
@@ -67,6 +71,7 @@ export * from './components/text-field';
 export * from './components/textarea';
 export { ThemeProvider, useTheme, type ThemeProviderProps } from './components/theme-provider/theme-provider';
 export * from './components/theme-root';
+export * from './components/theme-switch';
 export * from './components/time-picker';
 export * from './components/timeline';
 export * from './components/toast';

package/dist/types/overlay/overlay-layer.d.ts

@@ -21,6 +21,26 @@ export declare function OverlayLayer({ children }: {
 export declare namespace OverlayLayer {
     var displayName: string;
 }
+/**
+ * A layer for a menu. Its node joins the tree under the enclosing layer like any other, but the
+ * menu's own hooks see no parent node: useRole and useListNavigation read a parent node as a parent
+ * menu (a menuitem trigger, cross-axis open/close keys). The menu's content re-provides the node
+ * through `LayerContent`, so layers opened inside it nest under it.
+ */
+export declare function MenuLayer({ children }: {
+    children: (nodeId: string | undefined) => ReactNode;
+}): import("@emotion/react/jsx-runtime").JSX.Element;
+export declare namespace MenuLayer {
+    var displayName: string;
+}
+/** Makes `nodeId` the parent of layers rendered inside `children`. */
+export declare function LayerContent({ nodeId, children }: {
+    nodeId: string | undefined;
+    children: ReactNode;
+}): import("@emotion/react/jsx-runtime").JSX.Element;
+export declare namespace LayerContent {
+    var displayName: string;
+}
 /**
  * Root boundary for an overlay that does not take part in layer nesting. Inside a layer it gets
  * its own empty tree and no parent node, so it never reads the enclosing layer as its parent.

package/dist/types/overlay/use-overlay-floating.d.ts

@@ -1,4 +1,4 @@
-import { type OpenChangeReason, type Placement, type UseFloatingReturn } from '@floating-ui/react';
+import { type OpenChangeReason, type Placement, type Strategy, type UseFloatingReturn } from '@floating-ui/react';
 export interface OverlayFloatingOptions {
     open: boolean;
     onOpenChange: (open: boolean, event?: Event, reason?: OpenChangeReason) => void;
@@ -9,6 +9,13 @@ export interface OverlayFloatingOptions {
     boundary?: Element | null;
     /** Receives the space left for the surface inside the boundary after each positioning pass. */
     onAvailableSize?: (size: OverlayAvailableSize) => void;
+    /** CSS positioning strategy. Defaults to `absolute`. */
+    strategy?: Strategy;
+    /** Gap between the anchor and the surface, in px. Defaults to `ANCHOR_GAP`. */
+    gap?: number;
+    /** Position with `transform` (default) or with `left`/`top`, which leaves `transform` and
+     * `scale` free for the surface's own animation. */
+    transform?: boolean;
 }
 export interface OverlayAvailableSize {
     width: number;
@@ -18,4 +25,4 @@ export interface OverlayAvailableSize {
  * Shared positioning for Popover, Tooltip and Menu. `autoUpdate` only runs while both
  * elements are mounted, so a closed (unmounted) surface does no positioning work.
  */
-export declare function useOverlayFloating({ open, onOpenChange, placement, nodeId, boundary, onAvailableSize, }: OverlayFloatingOptions): UseFloatingReturn<HTMLButtonElement>;
+export declare function useOverlayFloating({ open, onOpenChange, placement, nodeId, boundary, onAvailableSize, strategy, gap, transform, }: OverlayFloatingOptions): UseFloatingReturn<HTMLButtonElement>;

package/dist/{use-overlay-floating-DvJifLpF.js → use-overlay-floating-Bx2jBKAA.js}

@@ -2,8 +2,8 @@
 import { autoUpdate as e, flip as t, offset as n, shift as r, size as i, useFloating as a } from "@floating-ui/react";
 //#region src/overlay/use-overlay-floating.ts
 var o = 8, s = 8;
-function c({ open: c, onOpenChange: l, placement: u, nodeId: d, boundary: f, onAvailableSize: p }) {
-	let m = {
+function c({ open: c, onOpenChange: l, placement: u, nodeId: d, boundary: f, onAvailableSize: p, strategy: m, gap: h = o, transform: g }) {
+	let _ = {
 		padding: s,
 		...f ? { boundary: f } : {}
 	};
@@ -12,12 +12,14 @@ function c({ open: c, onOpenChange: l, placement: u, nodeId: d, boundary: f, onA
 		onOpenChange: l,
 		placement: u,
 		nodeId: d,
+		strategy: m,
+		transform: g,
 		middleware: [
-			n(o),
-			t(m),
-			r(m),
+			n(h),
+			t(_),
+			r(_),
 			p && i({
-				...m,
+				..._,
 				apply: ({ availableWidth: e, availableHeight: t }) => p({
 					width: e,
 					height: t