@jfrader/ui 0.5.0 → 0.6.0

package/dist/types/components/next/emotion-registry.d.ts

@@ -0,0 +1,16 @@
+import { type ReactNode } from 'react';
+export interface EmotionRegistryProps {
+    /** Emotion cache key: the class name prefix and the `data-emotion` attribute value. */
+    cacheKey?: string;
+    children?: ReactNode;
+}
+/**
+ * Emotion SSR registry for the App Router: one shared cache and a flush that only
+ * sends the styles inserted since the last pass, so the server and client trees
+ * match on hydration. Without it, Emotion inserts <style> nodes inline during SSR
+ * and the hydration diff mismatches.
+ */
+export declare function EmotionRegistry({ cacheKey, children }: EmotionRegistryProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export declare namespace EmotionRegistry {
+    var displayName: string;
+}

package/dist/types/components/next/index.d.ts

@@ -0,0 +1,2 @@
+export { EmotionRegistry } from './emotion-registry';
+export type { EmotionRegistryProps } from './emotion-registry';

package/dist/types/components/next/registry.d.ts

@@ -0,0 +1,21 @@
+import { type EmotionCache } from '@emotion/cache';
+export interface PendingStyle {
+    name: string;
+    isGlobal: boolean;
+}
+export interface CollectedStyles {
+    globals: {
+        name: string;
+        styles: string;
+    }[];
+    names: string[];
+    styles: string;
+}
+export interface EmotionRegistryCache {
+    cache: EmotionCache;
+    /** Returns the styles inserted since the previous call and forgets them. */
+    flush: () => PendingStyle[];
+}
+export declare function createEmotionRegistry(key: string): EmotionRegistryCache;
+/** Splits flushed styles into one payload per global and one shared payload for scoped rules. */
+export declare function collectStyles(pending: readonly PendingStyle[], inserted: EmotionCache['inserted']): CollectedStyles;

package/dist/types/components/now-playing/index.d.ts

@@ -0,0 +1 @@
+export { NowPlaying, NowPlayingLevels, type NowPlayingProps, type NowPlayingTrack, type NowPlayingLabels, type NowPlayingSlotProps, type NowPlayingLevelsProps, } from './now-playing';

package/dist/types/components/now-playing/now-playing.d.ts

@@ -0,0 +1,88 @@
+import { type ComponentPropsWithRef, type ReactNode } from 'react';
+import { type Interpolation, type Theme } from '../../styling/css';
+import { type SxProps } from '../../styling/sx';
+import { type ButtonProps } from '../button';
+import { type SliderProps } from '../slider';
+export interface NowPlayingTrack {
+    id: string;
+    title: string;
+    artist: string;
+    duration: number | null;
+    artwork?: string;
+    artworkAlt?: string;
+}
+type Part<T extends 'div' | 'span' | 'img'> = ComponentPropsWithRef<T> & {
+    css?: Interpolation<Theme>;
+};
+export interface NowPlayingSlotProps {
+    mini?: Part<'div'>;
+    full?: Part<'div'>;
+    artwork?: Part<'img'>;
+    title?: Part<'span'>;
+    artist?: Part<'span'>;
+    expand?: Omit<ButtonProps, 'sx' | 'render'>;
+    collapse?: Omit<ButtonProps, 'sx' | 'render'>;
+    seek?: Omit<Extract<SliderProps, {
+        type?: 'single';
+    }>, 'sx' | 'type' | 'value' | 'defaultValue' | 'onValueChange' | 'label' | 'dir' | 'min' | 'max' | 'step' | 'largeStep' | 'locale' | 'formatValue' | 'formatOptions' | 'showValue'>;
+    waveform?: Part<'div'>;
+    controls?: Part<'div'>;
+    status?: Part<'span'>;
+    error?: Part<'div'>;
+}
+export interface NowPlayingLabels {
+    play: string;
+    pause: string;
+    previous: string;
+    next: string;
+    expand: string;
+    collapse: string;
+    seek: string;
+    empty: string;
+    unavailable: string;
+    busy: string;
+    playing: string;
+    paused: string;
+    position: (elapsed: string, duration: string) => string;
+}
+export interface NowPlayingProps extends Omit<ComponentPropsWithRef<'section'>, 'defaultValue' | 'children' | 'onChange'>, SxProps {
+    tracks: readonly NowPlayingTrack[];
+    value?: number;
+    defaultValue?: number;
+    onValueChange?: (index: number) => void;
+    playing?: boolean;
+    defaultPlaying?: boolean;
+    onPlayingChange?: (playing: boolean) => void;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    position?: number;
+    defaultPosition?: number;
+    onPositionChange?: (seconds: number) => void;
+    busy?: boolean;
+    error?: ReactNode;
+    waveform?: readonly number[];
+    label?: string;
+    labels?: Partial<NowPlayingLabels>;
+    locale?: Intl.LocalesArgument;
+    /**
+     * Seconds per arrow step. Slider requires the duration to be a whole number of steps, so a
+     * step that does not divide it is rounded to the nearest one that does (180s with 7 → 180/26).
+     * Defaults to the largest step of at most one second that divides the duration.
+     */
+    seekStep?: number;
+    seekLargeStep?: number;
+    slotProps?: NowPlayingSlotProps;
+}
+export interface NowPlayingLevelsProps extends ComponentPropsWithRef<'span'>, SxProps {
+    playing?: boolean;
+}
+export declare function NowPlayingLevels({ ref, playing: playingProp, className, sx, ...rest }: NowPlayingLevelsProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export declare namespace NowPlayingLevels {
+    var displayName: string;
+}
+declare function NowPlayingRoot({ ref, tracks, value, defaultValue, onValueChange, playing, defaultPlaying, onPlayingChange, open, defaultOpen, onOpenChange, position, defaultPosition, onPositionChange, busy, error, waveform, label, labels: labelsProp, locale, seekStep, seekLargeStep, slotProps, className, sx, onKeyDown, 'aria-label': ariaLabel, 'aria-labelledby': ariaLabelledBy, 'aria-describedby': ariaDescribedBy, ...rest }: NowPlayingProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export declare const NowPlaying: typeof NowPlayingRoot & {
+    Levels: typeof NowPlayingLevels;
+};
+export {};

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/photo-grid/index.d.ts

@@ -0,0 +1,2 @@
+export { PhotoGrid } from './photo-grid';
+export type { PhotoGridProps, PhotoGridPhoto, PhotoGridLabels, PhotoGridSlotProps } from './photo-grid';

package/dist/types/components/photo-grid/photo-grid.d.ts

@@ -0,0 +1,82 @@
+import { type ComponentPropsWithRef, type ReactNode } from 'react';
+import { type Interpolation, type Theme } from '../../styling/css';
+import { type SxProps } from '../../styling/sx';
+export interface PhotoGridPhoto {
+    id: string;
+    src: string;
+    srcSet?: string;
+    sizes?: string;
+    alt: string;
+    width: number;
+    height: number;
+    title: string;
+    detail?: ReactNode;
+}
+type Slot<Tag extends keyof React.JSX.IntrinsicElements> = Omit<ComponentPropsWithRef<Tag>, 'children'> & {
+    css?: Interpolation<Theme>;
+};
+type ActionSlot = Omit<Slot<'button'>, 'type' | 'disabled' | 'aria-pressed'>;
+export interface PhotoGridSlotProps {
+    header?: Slot<'header'>;
+    title?: Slot<'h2'>;
+    density?: Slot<'div'>;
+    list?: Slot<'ul'>;
+    item?: Slot<'li'>;
+    photo?: ActionSlot;
+    favorite?: ActionSlot;
+    viewer?: Omit<Slot<'dialog'>, 'open'>;
+    stage?: Slot<'div'>;
+    filmstrip?: Omit<Slot<'input'>, 'type' | 'value' | 'defaultValue' | 'min' | 'max' | 'step' | 'disabled'>;
+    controls?: Slot<'div'>;
+    status?: Slot<'div'>;
+}
+export interface PhotoGridLabels {
+    larger: string;
+    smaller: string;
+    density: string;
+    empty: string;
+    unavailable: string;
+    imageUnavailable: string;
+    close: string;
+    previous: string;
+    next: string;
+    filmstrip: string;
+    zoomIn: string;
+    zoomOut: string;
+    resetZoom: string;
+    panLeft: string;
+    panRight: string;
+    panUp: string;
+    panDown: string;
+    favorite: (title: string, favorite: boolean) => string;
+    openPhoto: (title: string, alt: string, favorite: boolean) => string;
+    position: (position: string, total: string, title: string) => string;
+    columns: (columns: string) => string;
+}
+export interface PhotoGridProps extends Omit<ComponentPropsWithRef<'div'>, 'children' | 'defaultValue'>, SxProps {
+    photos: readonly PhotoGridPhoto[];
+    title: string;
+    /** Preferred columns. Narrow containers reduce effective columns without changing this axis. */
+    densitySteps?: readonly number[];
+    density?: number;
+    defaultDensity?: number;
+    onDensityChange?: (columns: number) => void;
+    favorites?: readonly string[];
+    defaultFavorites?: readonly string[];
+    onFavoritesChange?: (ids: string[]) => void;
+    onFavoriteChange?: (id: string, favorite: boolean) => void;
+    value?: string | null;
+    defaultValue?: string | null;
+    onValueChange?: (id: string | null) => void;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    labels?: Partial<PhotoGridLabels>;
+    locale?: Intl.LocalesArgument;
+    slotProps?: PhotoGridSlotProps;
+}
+export declare function PhotoGrid({ ref, photos, title, densitySteps, density: densityProp, defaultDensity, onDensityChange, favorites: favoritesProp, defaultFavorites, onFavoritesChange, onFavoriteChange, value: valueProp, defaultValue, onValueChange, open: openProp, defaultOpen, onOpenChange, labels: labelOverrides, locale, slotProps, className, sx, onKeyDown, ...rest }: PhotoGridProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export declare namespace PhotoGrid {
+    var displayName: string;
+}
+export {};

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/sheet-stack/index.d.ts

@@ -0,0 +1,2 @@
+export { SheetStack, useSheetStack } from './sheet-stack';
+export type { SheetStackActions, SheetStackBackProps, SheetStackCloseProps, SheetStackContentProps, SheetStackDescriptionProps, SheetStackFooterProps, SheetStackHeadingLevel, SheetStackProps, SheetStackTitleProps, SheetStackTriggerProps, SheetStackVariant, } from './sheet-stack';

package/dist/types/components/sheet-stack/sheet-stack.d.ts

@@ -0,0 +1,78 @@
+import { type ComponentPropsWithRef, type ReactNode } from 'react';
+import { type SxProps } from '../../styling/sx';
+export type SheetStackVariant = 'auto' | 'sheet' | 'dialog';
+export type SheetStackHeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
+export interface SheetStackProps {
+    /** Open sheet keys, bottom first. */
+    value?: readonly string[];
+    defaultValue?: readonly string[];
+    onValueChange?: (value: string[]) => void;
+    /** `auto` lays out as a sheet below `breakpoint` and as a centered dialog at or above it. */
+    variant?: SheetStackVariant;
+    /** Layer inline size in CSS px where `auto` switches to the dialog layout. */
+    breakpoint?: number;
+    /** Draws the layer inside the nearest positioned ancestor; modality stays document-wide. */
+    contained?: boolean;
+    children: ReactNode;
+}
+export interface SheetStackTriggerProps extends ComponentPropsWithRef<'button'>, SxProps {
+    /** Key of the sheet this trigger pushes. */
+    value: string;
+}
+export interface SheetStackContentProps extends Omit<ComponentPropsWithRef<'div'>, 'onCancel'>, SxProps {
+    /** Stable key, unique within the stack. */
+    value: string;
+    /** False refuses Escape, backdrop and drag dismissal; Back and Close still work. */
+    dismissible?: boolean;
+    /** Dismissal request (Escape, backdrop, drag) on this sheet while on top; `preventDefault()` vetoes it. */
+    onCancel?: (event: Event) => void;
+    /** Set false to keep structured content out of the sheet's accessible description. */
+    withDescription?: boolean;
+}
+export interface SheetStackTitleProps extends ComponentPropsWithRef<'h2'>, SxProps {
+    level?: SheetStackHeadingLevel;
+}
+export interface SheetStackDescriptionProps extends ComponentPropsWithRef<'p'>, SxProps {
+}
+export interface SheetStackFooterProps extends ComponentPropsWithRef<'div'>, SxProps {
+}
+export interface SheetStackBackProps extends Omit<ComponentPropsWithRef<'button'>, 'aria-label'>, SxProps {
+    /** Localized accessible name, e.g. "Back to Settings". */
+    label: string;
+}
+export interface SheetStackCloseProps extends Omit<ComponentPropsWithRef<'button'>, 'aria-label'>, SxProps {
+    /** Localized accessible name, e.g. "Close all". */
+    label: string;
+}
+export interface SheetStackActions {
+    /** The open keys, bottom first. */
+    value: readonly string[];
+    /** Opens `key` on top; an open key truncates the stack back to it. */
+    push: (key: string) => void;
+    /** Closes the top sheet. */
+    pop: () => void;
+    /** Truncates the stack back to the open `key`. */
+    popTo: (key: string) => void;
+    /** Closes every sheet. */
+    close: () => void;
+}
+/** The stack's state and actions; throws outside `<SheetStack>`. */
+export declare function useSheetStack(): SheetStackActions;
+declare function SheetStackRoot({ value: valueProp, defaultValue, onValueChange, variant, breakpoint, contained, children, }: SheetStackProps): import("@emotion/react/jsx-runtime").JSX.Element;
+declare function SheetStackTrigger({ ref, value, onClick, className, sx, ...rest }: SheetStackTriggerProps): import("@emotion/react/jsx-runtime").JSX.Element;
+declare function SheetStackContent({ ref, value, className, sx, ...props }: SheetStackContentProps): import("react").ReactPortal | null;
+declare function SheetStackTitle({ ref, level, className, sx, children, ...props }: SheetStackTitleProps): import("@emotion/react/jsx-runtime").JSX.Element | null;
+declare function SheetStackDescription({ ref, className, sx, children, ...props }: SheetStackDescriptionProps): import("@emotion/react/jsx-runtime").JSX.Element | null;
+declare function SheetStackFooter({ ref, className, sx, ...props }: SheetStackFooterProps): import("@emotion/react/jsx-runtime").JSX.Element;
+declare function SheetStackBack({ ref, label, onClick, className, sx, children, ...rest }: SheetStackBackProps): import("@emotion/react/jsx-runtime").JSX.Element;
+declare function SheetStackClose({ ref, label, onClick, className, sx, children, ...rest }: SheetStackCloseProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export declare const SheetStack: typeof SheetStackRoot & {
+    Trigger: typeof SheetStackTrigger;
+    Content: typeof SheetStackContent;
+    Title: typeof SheetStackTitle;
+    Description: typeof SheetStackDescription;
+    Footer: typeof SheetStackFooter;
+    Back: typeof SheetStackBack;
+    Close: typeof SheetStackClose;
+};
+export {};

package/dist/types/components/shortcut-recorder/index.d.ts

@@ -0,0 +1,2 @@
+export { ShortcutRecorder, normalizeShortcut, matchesShortcut, formatShortcut, useShortcutPlatform, usePressedShortcutKeys, defaultShortcutMessages, } from './shortcut-recorder';
+export type { ShortcutRecorderProps, ShortcutKeysProps, ShortcutListProps, ShortcutPlatform, ShortcutBinding, ShortcutListGroup, ShortcutMessages, KeyboardEventLike, } from './shortcut-recorder';

package/dist/types/components/shortcut-recorder/shortcut-recorder.d.ts

@@ -0,0 +1,117 @@
+import { type ComponentPropsWithRef, type ReactNode } from 'react';
+import { type SxProps } from '../../styling/sx';
+import { type FieldPartProps } from '../field/field-anatomy';
+export type ShortcutPlatform = 'mac' | 'other';
+export interface ShortcutBinding {
+    shortcut: string;
+    label: string;
+}
+export interface ShortcutListGroup {
+    label: string;
+    items: readonly {
+        label: string;
+        shortcut: string;
+        keywords?: string;
+    }[];
+}
+export interface ShortcutMessages {
+    placeholder: string;
+    recording: string;
+    canceled: string;
+    cleared: string;
+    noShortcut: string;
+    clearLabel: string;
+    cancelLabel: string;
+    confirmLabel: string;
+    reset: (spoken: string) => string;
+    set: (spoken: string) => string;
+    requireModifier: (platform: ShortcutPlatform) => string;
+    conflict: (spoken: string, binding: ShortcutBinding, reserved: boolean) => string;
+    listLabel: string;
+    searchLabel: string;
+    searchPlaceholder: string;
+    empty: string;
+    results: (count: number) => string;
+    keyName: (id: string, platform: ShortcutPlatform) => {
+        label: string;
+        spoken: string;
+    };
+}
+export interface KeyboardEventLike {
+    code: string;
+    key: string;
+    ctrlKey: boolean;
+    altKey: boolean;
+    shiftKey: boolean;
+    metaKey: boolean;
+    repeat?: boolean;
+    isComposing?: boolean;
+    getModifierState?: (key: string) => boolean;
+}
+export declare function normalizeShortcut(shortcut: string, platform: ShortcutPlatform): string | null;
+export declare function matchesShortcut(event: KeyboardEventLike, shortcut: string, platform: ShortcutPlatform): boolean;
+export declare const defaultShortcutMessages: ShortcutMessages;
+export declare function formatShortcut(shortcut: string, platform: ShortcutPlatform, messages?: ShortcutMessages): {
+    text: string;
+    spoken: string;
+};
+export declare function useShortcutPlatform(override?: ShortcutPlatform): ShortcutPlatform;
+export declare function usePressedShortcutKeys(enabled?: boolean): ReadonlySet<string>;
+export interface ShortcutKeysProps extends ComponentPropsWithRef<'span'>, SxProps {
+    shortcut: string;
+    platform?: ShortcutPlatform;
+    pressed?: ReadonlySet<string>;
+    size?: 'sm' | 'md';
+    messages?: ShortcutMessages;
+    locale?: Intl.LocalesArgument;
+    slotProps?: {
+        key?: FieldPartProps;
+    };
+}
+declare function ShortcutKeys({ shortcut, platform: platformProp, pressed, size, messages, locale: _locale, slotProps, className, sx, ...rest }: ShortcutKeysProps): import("@emotion/react/jsx-runtime").JSX.Element;
+type RecorderSlot = 'root' | 'label' | 'control' | 'recorder' | 'actions' | 'reset' | 'clear' | 'message' | 'confirm' | 'cancel' | 'description' | 'error' | 'status' | 'key';
+export interface ShortcutRecorderProps extends Omit<ComponentPropsWithRef<'button'>, 'value' | 'defaultValue'>, SxProps {
+    value?: string | null;
+    defaultValue?: string | null;
+    onValueChange?: (value: string | null, details: {
+        replaced?: ShortcutBinding;
+    }) => void;
+    recording?: boolean;
+    defaultRecording?: boolean;
+    onRecordingChange?: (recording: boolean) => void;
+    resetValue?: string | null;
+    bindings?: readonly ShortcutBinding[];
+    reservedBindings?: readonly ShortcutBinding[];
+    warnReserved?: boolean;
+    requireModifier?: boolean;
+    platform?: ShortcutPlatform;
+    label?: ReactNode;
+    description?: ReactNode;
+    error?: ReactNode;
+    hideLabel?: boolean;
+    size?: 'sm' | 'md' | 'lg';
+    locale?: Intl.LocalesArgument;
+    messages?: ShortcutMessages;
+    readOnly?: boolean;
+    slotProps?: Partial<Record<RecorderSlot, FieldPartProps>>;
+}
+declare function ShortcutRecorderRoot({ ref, value, defaultValue, onValueChange, recording, defaultRecording, onRecordingChange, resetValue, bindings, reservedBindings, warnReserved, requireModifier, platform: platformProp, label, description, error, hideLabel, size, locale, messages, readOnly, disabled, name, dir, slotProps, className, sx, onClick, onKeyDown, onKeyUp, onBlur, onFocus, 'aria-labelledby': labelledBy, 'aria-describedby': describedBy, 'aria-invalid': invalid, id, children: _children, ...rest }: ShortcutRecorderProps): import("@emotion/react/jsx-runtime").JSX.Element;
+type ListSlot = 'root' | 'search' | 'groups' | 'group' | 'heading' | 'item' | 'keys' | 'empty' | 'status';
+export interface ShortcutListProps extends ComponentPropsWithRef<'section'>, SxProps {
+    groups: readonly ShortcutListGroup[];
+    searchable?: boolean;
+    highlightPressed?: boolean;
+    platform?: ShortcutPlatform;
+    locale?: Intl.LocalesArgument;
+    messages?: ShortcutMessages;
+    inputValue?: string;
+    defaultInputValue?: string;
+    onInputChange?: (value: string) => void;
+    slotProps?: Partial<Record<ListSlot, FieldPartProps>>;
+}
+declare function ShortcutList({ groups, searchable, highlightPressed, platform, locale, messages, inputValue, defaultInputValue, onInputChange, slotProps, className, sx, ref, ...rest }: ShortcutListProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export declare const ShortcutRecorder: typeof ShortcutRecorderRoot & {
+    Keys: typeof ShortcutKeys;
+    List: typeof ShortcutList;
+};
+export {};

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/stretch-refresh/index.d.ts

@@ -0,0 +1 @@
+export { StretchRefresh, type StretchRefreshProps, type StretchRefreshSlotProps, type StretchRefreshLabels, } from './stretch-refresh';

package/dist/types/components/stretch-refresh/stretch-refresh.d.ts

@@ -0,0 +1,49 @@
+import { type ComponentPropsWithRef, type ReactNode } from 'react';
+import { type Interpolation, type Theme } from '../../styling/css';
+import { type SxProps } from '../../styling/sx';
+import { type ButtonProps } from '../button';
+type Slot<E extends 'div' | 'header' | 'h2' | 'ul' | 'li'> = Omit<ComponentPropsWithRef<E>, 'children'> & {
+    css?: Interpolation<Theme>;
+};
+export interface StretchRefreshSlotProps<T> {
+    header?: Slot<'header'>;
+    title?: Slot<'h2'>;
+    subtitle?: Slot<'div'>;
+    feed?: Slot<'div'>;
+    list?: Slot<'ul'>;
+    item?: Slot<'li'> | ((item: T, index: number) => Slot<'li'>);
+    indicator?: Omit<Slot<'div'>, 'aria-hidden'>;
+    refreshButton?: Omit<ButtonProps, 'children' | 'type' | 'disabled' | 'loading' | 'render' | 'sx'>;
+    status?: Omit<Slot<'div'>, 'role' | 'aria-atomic'>;
+    empty?: Slot<'div'>;
+}
+export interface StretchRefreshLabels {
+    refresh?: string;
+    refreshing?: string;
+    pull?: string;
+    release?: string;
+    done?: string;
+    error?: string;
+}
+export interface StretchRefreshProps<T> extends Omit<ComponentPropsWithRef<'div'>, 'children' | 'title'>, SxProps {
+    title: ReactNode;
+    headingLevel?: 2 | 3 | 4 | 5 | 6;
+    subtitle?: ReactNode;
+    items: readonly T[];
+    getKey: (item: T) => string;
+    renderItem: (item: T, index: number) => ReactNode;
+    onRefresh: () => Promise<string | void>;
+    refreshing?: boolean;
+    defaultRefreshing?: boolean;
+    onRefreshingChange?: (refreshing: boolean) => void;
+    disabled?: boolean;
+    threshold?: number;
+    emptyContent?: ReactNode;
+    labels?: StretchRefreshLabels;
+    slotProps?: StretchRefreshSlotProps<T>;
+}
+export declare function StretchRefresh<T>({ title, headingLevel, subtitle, items, getKey, renderItem, onRefresh, refreshing, defaultRefreshing, onRefreshingChange, disabled, threshold: thresholdProp, emptyContent, labels, slotProps, ref, className, sx, onKeyDown, ...props }: StretchRefreshProps<T>): import("@emotion/react/jsx-runtime").JSX.Element;
+export declare namespace StretchRefresh {
+    var displayName: string;
+}
+export {};