@zyncat/ui 0.10.0 → 0.12.0

package/dist/{multi-select.d.ts → types/components/composites/select/MultiSelect.d.ts}

@@ -1,11 +1,11 @@
-import * as react from 'react';
-import { ReactNode, HTMLAttributes } from 'react';
-import { S as SelectOption, a as SelectGroup } from './types-SGMShK7R.js';
-import { D as DataAttributes } from './dom-props-C0jrllBw.js';
-import { D as DisableableAnimation } from './timing-7JA_zQHP.js';
-import './motion-scale-Canq4stZ.js';
-
-interface MultiSelectProps {
+import './select.css';
+import type { HTMLAttributes, ReactNode } from 'react';
+import type { DataAttributes } from '../../../dom-props';
+import type { DisableableAnimation } from '../../../motion/timing';
+import type { ActivateOn } from '../../internal/utils/activation';
+import { type SelectGroup, type SelectOption } from './core';
+export type { SelectOption, SelectGroup } from './core';
+export interface MultiSelectProps {
     /** The choices - a flat `SelectOption[]`, or `SelectGroup[]` to render labeled sections. @default [] */
     options: SelectOption[] | SelectGroup[];
     /** Controlled value - the array of selected option `value`s. Omit for uncontrolled (use `defaultValue`). */
@@ -36,9 +36,10 @@ interface MultiSelectProps {
     ariaLabel?: string;
     /** Standard <div> attributes (className, style, data-*, ...) forwarded to the select root. */
     htmlProps?: HTMLAttributes<HTMLDivElement> & DataAttributes;
+    /** Whether the trigger and the options fire on `pointerdown` (snappier) or wait for `click`.
+     *  @default 'pointerdown' */
+    activateOn?: ActivateOn;
     /** Menu open/close timing - motion tokens only, or `null` to disable. @default duration 'base' + ease 'entrance'/'exit' */
     animation?: DisableableAnimation;
 }
-declare function MultiSelect({ options, value: controlledValue, defaultValue, onChange, placeholder, size, disabled, invalid, loading, searchable, searchPlaceholder, leadingIcon, id, ariaLabel, htmlProps, animation, }: MultiSelectProps): react.JSX.Element;
-
-export { MultiSelect, type MultiSelectProps, SelectGroup, SelectOption };
+export declare function MultiSelect({ options, value: controlledValue, defaultValue, onChange, placeholder, size, disabled, invalid, loading, searchable, searchPlaceholder, leadingIcon, id, ariaLabel, htmlProps, activateOn, animation, }: MultiSelectProps): import("react").JSX.Element;

package/dist/{select.d.ts → types/components/composites/select/Select.d.ts}

@@ -1,12 +1,11 @@
-import * as react from 'react';
-import { ReactNode, HTMLAttributes } from 'react';
-import { S as SelectOption, a as SelectGroup } from './types-SGMShK7R.js';
-import { ButtonProps } from './button.js';
-import { D as DisableableAnimation } from './timing-7JA_zQHP.js';
-import { D as DataAttributes } from './dom-props-C0jrllBw.js';
-import './motion-scale-Canq4stZ.js';
-
-interface SelectProps {
+import './select.css';
+import type { HTMLAttributes, ReactNode } from 'react';
+import type { DataAttributes } from '../../../dom-props';
+import type { DisableableAnimation } from '../../../motion/timing';
+import type { ActivateOn } from '../../internal/utils/activation';
+import { type SelectGroup, type SelectOption, type SelectTriggerHtmlProps } from './core';
+export type { SelectOption, SelectGroup } from './core';
+export interface SelectProps {
     /** The choices - a flat `SelectOption[]`, or `SelectGroup[]` to render labeled sections. @default [] */
     options: SelectOption[] | SelectGroup[];
     /** Controlled value - matches an option's `value`, or `null` for none. Omit for uncontrolled (use `defaultValue`). */
@@ -37,13 +36,16 @@ interface SelectProps {
     ariaLabel?: string;
     /** Standard <div> attributes (className, style, data-*, ...) forwarded to the select root. */
     htmlProps?: HTMLAttributes<HTMLDivElement> & DataAttributes;
+    /** Whether the trigger and the options fire on `pointerdown` (snappier) or wait for `click`.
+     *  @default 'pointerdown' */
+    activateOn?: ActivateOn;
     /** Menu open/close timing - motion tokens only, or `null` to disable. @default duration 'base' + ease 'entrance'/'exit' */
     animation?: DisableableAnimation;
-    /** Trigger props */
-    triggerProps?: ButtonProps;
+    /** Standard <button> attributes (className, style, aria-*, data-*, ...) merged onto the trigger.
+     *  `onClick` and `onKeyDown` run before the built-in open/close and arrow-key handling, which
+     *  cannot be replaced - the trigger is the combobox. */
+    triggerProps?: SelectTriggerHtmlProps;
     /** Show check icon on selected value */
     showCheck?: boolean;
 }
-declare function Select({ options, value: controlledValue, defaultValue, onChange, placeholder, size, disabled, invalid, loading, searchable, searchPlaceholder, leadingIcon, id, ariaLabel, htmlProps, animation, triggerProps, showCheck, }: SelectProps): react.JSX.Element;
-
-export { Select, SelectGroup, SelectOption, type SelectProps };
+export declare function Select({ options, value: controlledValue, defaultValue, onChange, placeholder, size, disabled, invalid, loading, searchable, searchPlaceholder, leadingIcon, id, ariaLabel, htmlProps, activateOn, animation, triggerProps, showCheck, }: SelectProps): import("react").JSX.Element;

package/dist/types/components/composites/select/core/index.d.ts

@@ -0,0 +1,4 @@
+export { useListbox, type ListboxState } from './use-listbox';
+export { SelectTrigger, type SelectTriggerHtmlProps } from './trigger';
+export { ListboxPanel } from './panel';
+export type { SelectOption, SelectGroup } from './types';

package/dist/types/components/composites/select/core/menu.d.ts

@@ -0,0 +1,13 @@
+import { type ReactNode, type RefObject } from 'react';
+import type { DisableableAnimation } from '../../../../motion/timing';
+export interface SelectMenuProps {
+    open: boolean;
+    menuId: string;
+    requestClose: () => void;
+    triggerRef: RefObject<HTMLButtonElement | null>;
+    multiple?: boolean;
+    /** Open/close timing - motion tokens only, or `null` to disable. */
+    animation?: DisableableAnimation;
+    children?: ReactNode;
+}
+export declare function SelectMenu({ open, menuId, requestClose, triggerRef, multiple, animation, children }: SelectMenuProps): import("react").JSX.Element;

package/dist/types/components/composites/select/core/panel.d.ts

@@ -0,0 +1,18 @@
+import '../../../internal/menu/menu-surface.css';
+import { type ReactNode } from 'react';
+import type { DisableableAnimation } from '../../../../motion/timing';
+import { type ActivateOn } from '../../../internal/utils/activation';
+import type { ListboxState } from './use-listbox';
+export interface ListboxPanelProps {
+    lb: ListboxState;
+    loading: boolean;
+    searchable: boolean;
+    searchPlaceholder?: string;
+    ariaLabel?: string;
+    multiple?: boolean;
+    activateOn?: ActivateOn;
+    /** Menu open/close timing - motion tokens only, or `null` to disable. */
+    animation?: DisableableAnimation;
+    check?: (selected: boolean) => ReactNode;
+}
+export declare function ListboxPanel({ lb, loading, searchable, searchPlaceholder, ariaLabel, multiple, activateOn, animation, check, }: ListboxPanelProps): import("react").JSX.Element;

package/dist/types/components/composites/select/core/trigger.d.ts

@@ -0,0 +1,16 @@
+import type { ButtonHTMLAttributes, ReactNode } from 'react';
+import type { DataAttributes } from '../../../../dom-props';
+import { type ActivateOn } from '../../../internal/utils/activation';
+import type { ListboxState } from './use-listbox';
+export type SelectTriggerHtmlProps = Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'type'> & DataAttributes;
+export interface SelectTriggerProps extends SelectTriggerHtmlProps {
+    lb: ListboxState;
+    invalid?: boolean;
+    ariaLabel?: string;
+    leading?: ReactNode;
+    text?: ReactNode;
+    isPlaceholder?: boolean;
+    count?: number;
+    activateOn?: ActivateOn;
+}
+export declare function SelectTrigger({ lb, invalid, ariaLabel, leading, text, isPlaceholder, count, className, activateOn, onClick, onPointerDown, onKeyDown, ...rest }: SelectTriggerProps): import("react").JSX.Element;

package/dist/{types-SGMShK7R.d.ts → types/components/composites/select/core/types.d.ts}

@@ -1,6 +1,6 @@
-import { ReactNode } from 'react';
-
-interface SelectOption {
+import type { ReactNode } from 'react';
+import { type NormalizedGroup as CollectionGroup } from '../../../internal/collection/collection';
+export interface SelectOption {
     /** The stored value - what `onChange` returns and `value` matches; must be unique. */
     value: string;
     /** Primary row text, and the trigger label once selected; also matched by `searchable`. */
@@ -11,12 +11,19 @@ interface SelectOption {
     icon?: ReactNode;
     /** Not selectable - skipped by keyboard nav and typeahead, and marked `aria-disabled`. @default false */
     disabled?: boolean;
+    /** Text used for `searchable` filtering and typeahead. Required when `label` is not a string. */
+    searchText?: string;
 }
-interface SelectGroup {
+export interface SelectGroup {
     /** Section heading rendered above the options; omit for an unlabeled group. */
     label?: string;
     /** The options in this section. */
     options: SelectOption[];
 }
-
-export type { SelectOption as S, SelectGroup as a };
+export type NormalizedGroup = CollectionGroup<SelectOption>;
+export declare const normalize: (options: SelectOption[] | SelectGroup[]) => {
+    groups: NormalizedGroup[];
+    flat: SelectOption[];
+};
+export declare const optionText: (o: SelectOption) => string;
+export declare const matches: (o: SelectOption, q: string) => boolean;

package/dist/types/components/composites/select/core/use-listbox.d.ts

@@ -0,0 +1,42 @@
+import { type KeyboardEvent } from 'react';
+import { type SelectGroup, type SelectOption } from './types';
+export interface UseListboxArgs {
+    options: SelectOption[] | SelectGroup[];
+    disabled: boolean;
+    loading: boolean;
+    searchable: boolean;
+    id?: string;
+    idPrefix: string;
+    isSelected: (value: string) => boolean;
+    onCommit: (opt: SelectOption) => void;
+    closeOnCommit: boolean;
+}
+export type ListboxState = ReturnType<typeof useListbox>;
+export declare function useListbox({ options, disabled, loading, searchable, id, idPrefix, isSelected, onCommit, closeOnCommit, }: UseListboxArgs): {
+    open: boolean;
+    query: string;
+    setQuery: import("react").Dispatch<import("react").SetStateAction<string>>;
+    triggerRef: import("react").RefObject<HTMLButtonElement>;
+    listRef: import("react").RefObject<HTMLDivElement>;
+    searchRef: import("react").RefObject<HTMLInputElement>;
+    baseId: string;
+    menuId: string;
+    listId: string;
+    optId: (value: string) => string;
+    adId: string;
+    groups: import("./types").NormalizedGroup[];
+    flat: SelectOption[];
+    navItems: SelectOption[];
+    glide: {
+        ref: import("react").RefObject<HTMLSpanElement>;
+        enter: (target: HTMLElement | null) => void;
+        leave: () => void;
+    };
+    isSelected: (value: string) => boolean;
+    show: () => void;
+    requestClose: () => void;
+    commit: (opt: SelectOption) => void;
+    activeIdx: number;
+    setActiveIdx: import("react").Dispatch<import("react").SetStateAction<number>>;
+    onMenuKeyDown: (e: KeyboardEvent) => void;
+};

package/dist/{sheet.d.ts → types/components/composites/sheet/Sheet.d.ts}

@@ -1,18 +1,19 @@
-import * as react from 'react';
-import { ReactElement, HTMLAttributes, ReactNode } from 'react';
-import { D as DisableableAnimation } from './timing-7JA_zQHP.js';
-import { D as DataAttributes } from './dom-props-C0jrllBw.js';
-import './motion-scale-Canq4stZ.js';
-
-interface SheetProps {
+import './sheet.css';
+import { type HTMLAttributes, type ReactElement, type ReactNode } from 'react';
+import type { DataAttributes } from '../../../dom-props';
+import type { DisableableAnimation } from '../../../motion/timing';
+import type { ActivateOn } from '../../internal/utils/activation';
+export interface SheetProps {
     /** Controlled open state. Omit to stay uncontrolled. */
     open?: boolean;
     /** Initial state when uncontrolled. Default false. */
     defaultOpen?: boolean;
     /** Fires whenever the open state changes. Pair with `open` for controlled use. */
     onOpenChange?: (open: boolean) => void;
-    /** Cloned to open the sheet on click. */
+    /** Cloned to open the sheet. */
     trigger?: ReactElement | null;
+    /** Whether the trigger fires on `pointerdown` (snappier) or waits for `click`. @default 'click' */
+    activateOn?: ActivateOn;
     /** Edge the sheet slides in from. Default 'right'. */
     side?: 'right' | 'bottom';
     /** Scrim/Esc dismissal + drag-to-edge. Default true. */
@@ -29,6 +30,4 @@ interface SheetProps {
     /** The ENTIRE surface - paint AND semantics. Drive dismissal with `open`/`onOpenChange`. */
     children: ReactNode;
 }
-declare function Sheet({ open: controlledOpen, defaultOpen, onOpenChange, trigger, side, dismissible, container, id, htmlProps, animation, children, }: SheetProps): react.JSX.Element;
-
-export { Sheet, type SheetProps };
+export declare function Sheet({ open: controlledOpen, defaultOpen, onOpenChange, trigger, activateOn, side, dismissible, container, id, htmlProps, animation, children, }: SheetProps): import("react").JSX.Element;

package/dist/types/components/composites/sheet/use-sheet-drag.d.ts

@@ -0,0 +1,13 @@
+import { type PointerEvent as ReactPointerEvent, type RefObject } from 'react';
+export declare function useSheetDrag({ side, panelRef, enabled, requestClose, }: {
+    side: 'right' | 'bottom';
+    panelRef: RefObject<HTMLElement>;
+    enabled: boolean;
+    requestClose: () => void;
+}): {
+    onPointerDown: (e: ReactPointerEvent) => void;
+    'data-drag': string;
+} | {
+    onPointerDown?: undefined;
+    'data-drag'?: undefined;
+};

package/dist/{table.d.ts → types/components/composites/table/Table.d.ts}

@@ -1,10 +1,10 @@
-import * as react from 'react';
-import { ReactNode, HTMLAttributes } from 'react';
-import { D as DataAttributes } from './dom-props-C0jrllBw.js';
-
-type TableAlign = 'start' | 'end' | 'center';
-type TableHideBelow = 'sm' | 'md';
-interface TableColumn<Row = any> {
+import './table.css';
+import { type HTMLAttributes, type ReactNode } from 'react';
+import type { DataAttributes } from '../../../dom-props';
+import { type ActivateOn } from '../../internal/utils/activation';
+export type TableAlign = 'start' | 'end' | 'center';
+export type TableHideBelow = 'sm' | 'md';
+export interface TableColumn<Row = any> {
     /** Unique column id; also the default data accessor (row[key]). */
     key: string;
     /** Header cell content; omit for a header-less column (e.g. an actions column). */
@@ -26,13 +26,13 @@ interface TableColumn<Row = any> {
     /** Custom cell renderer. Defaults to row[key]. */
     render?: (row: Row) => ReactNode;
 }
-interface TableSort {
+export interface TableSort {
     /** `key` of the column being sorted by. */
     key: string;
     /** Sort direction - `asc` or `desc`. */
     dir: 'asc' | 'desc';
 }
-interface TableProps<Row = any> {
+export interface TableProps<Row = any> {
     /** Column defs, rendered left to right. */
     columns: TableColumn<Row>[];
     /** The row data; sorted locally per the active sort before render. */
@@ -65,11 +65,11 @@ interface TableProps<Row = any> {
     footer?: ReactNode;
     /** Makes rows clickable (checkbox cell excluded). */
     onRowClick?: (row: Row) => void;
+    /** Whether a sortable header fires on `pointerdown` (snappier) or waits for `click`. @default 'pointerdown' */
+    activateOn?: ActivateOn;
     /** Size the table here - the internal scroller absorbs the constraint. */
     className?: string;
     /** Standard <div> attributes (style, data-*, aria-*, ...) forwarded to the table wrapper. */
     htmlProps?: Omit<HTMLAttributes<HTMLDivElement>, 'className'> & DataAttributes;
 }
-declare function Table<Row = any>({ columns, rows, rowKey, ariaLabel, selectable, onSelectionChange, bulkActions, selectionLabel, defaultSort, onSortChange, density, pinFirst, loading, empty, footer, onRowClick, className, htmlProps, }: TableProps<Row>): react.JSX.Element;
-
-export { Table, type TableAlign, type TableColumn, type TableHideBelow, type TableProps, type TableSort };
+export declare function Table<Row = any>({ columns, rows, rowKey, ariaLabel, selectable, onSelectionChange, bulkActions, selectionLabel, defaultSort, onSortChange, density, pinFirst, loading, empty, footer, onRowClick, activateOn, className, htmlProps, }: TableProps<Row>): import("react").JSX.Element;

package/dist/{tabs.d.ts → types/components/composites/tabs/Tabs.d.ts}

@@ -1,11 +1,10 @@
-import * as react from 'react';
-import { ReactNode, CSSProperties, HTMLAttributes } from 'react';
-import { D as DisableableAnimation } from './timing-7JA_zQHP.js';
-import { D as DataAttributes } from './dom-props-C0jrllBw.js';
-import './motion-scale-Canq4stZ.js';
-
+import './tabs.css';
+import { type CSSProperties, type HTMLAttributes, type ReactNode } from 'react';
+import type { DataAttributes } from '../../../dom-props';
+import { type DisableableAnimation } from '../../../motion/timing';
+import { type ActivateOn } from '../../internal/utils/activation';
 /** One tab in the row. */
-interface TabItem {
+export interface TabItem {
     /** Stable identity - also used in the tab/panel id pair. */
     value: string;
     /** Visible tab text. */
@@ -35,16 +34,18 @@ interface TabsOwnProps {
     name?: string;
     /** Accessible name for the tablist (e.g. "Section views"). */
     ariaLabel?: string;
+    /** Whether a tab switches on `pointerdown` (snappier) or waits for `click`. @default 'pointerdown' */
+    activateOn?: ActivateOn;
     /** Extra class(es) merged onto the root. */
     className?: string;
     /** Inline styles merged onto the root. */
     style?: CSSProperties;
 }
-interface TabsProps extends TabsOwnProps {
+export interface TabsProps extends TabsOwnProps {
     /** Standard <div> attributes (data-*, aria-*, ...) forwarded to the root. */
     htmlProps?: Omit<HTMLAttributes<HTMLDivElement>, keyof TabsOwnProps> & DataAttributes;
 }
-declare function Tabs({ items, value, onChange, name, ariaLabel, className, style, htmlProps }: TabsProps): react.JSX.Element;
+export declare function Tabs({ items, value, onChange, name, ariaLabel, activateOn, className, style, htmlProps, }: TabsProps): import("react").JSX.Element;
 interface TabPanelOwnProps {
     /** The active tab's value - changing it cuts to the new content. */
     tab: string;
@@ -62,10 +63,9 @@ interface TabPanelOwnProps {
     /** Inline styles merged onto the root. */
     style?: CSSProperties;
 }
-interface TabPanelProps extends TabPanelOwnProps {
+export interface TabPanelProps extends TabPanelOwnProps {
     /** Standard <div> attributes (data-*, aria-*, ...) forwarded to the root. */
     htmlProps?: Omit<HTMLAttributes<HTMLDivElement>, keyof TabPanelOwnProps> & DataAttributes;
 }
-declare function TabPanel({ tab, name, dir, className, style, children, animation, htmlProps }: TabPanelProps): react.JSX.Element;
-
-export { type TabItem, TabPanel, type TabPanelProps, Tabs, type TabsProps };
+export declare function TabPanel({ tab, name, dir, className, style, children, animation, htmlProps }: TabPanelProps): import("react").JSX.Element;
+export {};

package/dist/types/components/composites/toast/Toast.d.ts

@@ -0,0 +1,10 @@
+import './toast.css';
+import { type HTMLAttributes, type ReactElement } from 'react';
+import type { DataAttributes } from '../../../dom-props';
+import { type ToasterConfig } from './toast-store';
+export interface ToasterProps extends Partial<ToasterConfig> {
+    /** Standard <ol> attributes (className, style, data-*, ...) forwarded to the toast viewport. */
+    htmlProps?: HTMLAttributes<HTMLOListElement> & DataAttributes;
+}
+export declare function Toaster({ htmlProps, ...props }: ToasterProps): ReactElement;
+export { toast } from './toast-store';

package/dist/{toast-store.d.ts → types/components/composites/toast/toast-store.d.ts}

@@ -1,15 +1,15 @@
-type ToastTone = 'default' | 'success' | 'danger' | 'warning' | 'info' | 'loading' | 'custom';
-interface ToastAction {
+export type ToastTone = 'default' | 'success' | 'danger' | 'warning' | 'info' | 'loading' | 'custom';
+export interface ToastAction {
     label: string;
     onClick: () => void;
 }
-interface ToastOptions {
+export interface ToastOptions {
     id?: string | number;
     duration?: number;
     description?: string | null;
     action?: ToastAction | null;
 }
-interface ToastRecord {
+export interface ToastRecord {
     id: string;
     tone: ToastTone;
     message: string | null;
@@ -23,13 +23,13 @@ interface ToastRecord {
     dismissible: boolean;
     expiresAt?: number;
 }
-interface ToastSnapshot {
+export interface ToastSnapshot {
     toasts: ToastRecord[];
     paused: boolean;
     expanded: boolean;
 }
-type ToastPosition = 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';
-interface ToasterConfig {
+export type ToastPosition = 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';
+export interface ToasterConfig {
     position: ToastPosition;
     duration: number;
     visibleToasts: number;
@@ -37,7 +37,7 @@ interface ToasterConfig {
     offset: number;
     expand: boolean;
 }
-declare const DEFAULT_TOASTER_CONFIG: ToasterConfig;
+export declare const DEFAULT_TOASTER_CONFIG: ToasterConfig;
 interface ToastStore {
     toasts: ToastRecord[];
     paused: boolean;
@@ -58,12 +58,12 @@ interface ToastStore {
     setExpanded(v: boolean): void;
 }
 type PromiseMsg<V> = string | ((v: V) => string);
-interface ToastPromiseMsgs<T> {
+export interface ToastPromiseMsgs<T> {
     loading?: string;
     success?: PromiseMsg<T>;
     error?: PromiseMsg<unknown>;
 }
-interface ToastApi {
+export interface ToastApi {
     (message: string, opts?: ToastOptions): string;
     success(m: string, o?: ToastOptions): string;
     error(m: string, o?: ToastOptions): string;
@@ -80,7 +80,5 @@ interface ToastApi {
     }): string;
 }
 declare const toast: ToastApi;
-
-declare const UIToast: ToastStore;
-
-export { DEFAULT_TOASTER_CONFIG, type ToastAction, type ToastApi, type ToastOptions, type ToastPosition, type ToastPromiseMsgs, type ToastRecord, type ToastSnapshot, type ToastTone, type ToasterConfig, UIToast, toast };
+export { toast };
+export declare const UIToast: ToastStore;

package/dist/{tooltip.d.ts → types/components/composites/tooltip/Tooltip.d.ts}

@@ -1,10 +1,8 @@
-import * as react from 'react';
-import { ReactNode, ReactElement, HTMLAttributes } from 'react';
-import { D as DataAttributes } from './dom-props-C0jrllBw.js';
-
-type Placement = 'top' | 'bottom' | 'left' | 'right';
-
-interface TooltipProps {
+import './tooltip.css';
+import { type HTMLAttributes, type ReactElement, type ReactNode } from 'react';
+import type { DataAttributes } from '../../../dom-props';
+import { type Placement } from './tooltip-store';
+export interface TooltipProps {
     /** The hint - a string or small node; never interactive content. */
     content: ReactNode;
     /** Optional keyboard hint, rendered as mono metadata ("⌘↩", "S"). */
@@ -25,6 +23,4 @@ interface TooltipProps {
     /** Standard <span> attributes forwarded to the anchor wrapper. */
     htmlProps?: HTMLAttributes<HTMLSpanElement> & DataAttributes;
 }
-declare function Tooltip({ content, shortcut, placement, disabled, openDelay, closeDelay, id, children, htmlProps, }: TooltipProps): react.JSX.Element;
-
-export { Tooltip, type TooltipProps };
+export declare function Tooltip({ content, shortcut, placement, disabled, openDelay, closeDelay, id, children, htmlProps, }: TooltipProps): import("react").JSX.Element;

package/dist/types/components/composites/tooltip/tooltip-host.d.ts

@@ -0,0 +1 @@
+export declare function TooltipHost(): import("react").ReactPortal;

package/dist/types/components/composites/tooltip/tooltip-store.d.ts

@@ -0,0 +1,29 @@
+import { type ReactNode } from 'react';
+export type Placement = 'top' | 'bottom' | 'left' | 'right';
+export interface ActivePayload {
+    id: string;
+    content: ReactNode;
+    shortcut?: string | null;
+    placement: Placement;
+    anchor: () => HTMLElement | null;
+    rect: () => DOMRect;
+}
+export declare const OPEN_DELAY = 350;
+export declare const CLOSE_GRACE = 140;
+export declare const TOOLTIP_DOM_ID = "pds-tooltip";
+export declare const store: {
+    active: ActivePayload | null;
+    described: HTMLElement | null;
+    closeTimer: ReturnType<typeof setTimeout> | 0;
+    warmUntil: number;
+    listeners: Set<() => void>;
+    get: () => ActivePayload;
+    subscribe(l: () => void): () => boolean;
+    emit(): void;
+    isWarm: () => boolean;
+    describe(el: HTMLElement | null): void;
+    open(payload: ActivePayload): void;
+    close(id: string, grace?: number): void;
+    closeNow(): void;
+};
+export declare function useHostElection(): boolean;

package/dist/types/components/compound/support-rail/SupportRail.d.ts

@@ -0,0 +1,41 @@
+import './support-rail.css';
+import { type HTMLAttributes, type ReactNode } from 'react';
+import type { DataAttributes } from '../../../dom-props';
+import type { SupportRailStyle } from '../../../tokens/component-styles.generated';
+import type { SupportAction } from '../../internal/support/types';
+export type { SupportAction };
+export interface SupportRailOwnProps {
+    /** The rows, in order. Each renders a button carrying its label, optional description and optional meta. @default [] */
+    actions: SupportAction[];
+    /** Panel heading, and the panel's accessible name. @default 'Talk to us' */
+    title?: string;
+    /** Small uppercase mono line under the heading - opening hours, queue depth, a shift note. */
+    status?: string;
+    /** Container edge the rail pins to. Flips the needle, the collapse origin, the drag axis and the vertical label. @default 'right' */
+    side?: 'right' | 'left';
+    /** Controlled open state. Omit to stay uncontrolled. */
+    open?: boolean;
+    /** Initial state when uncontrolled. @default false */
+    defaultOpen?: boolean;
+    /** Fires whenever the open state changes. Pair with `open` for controlled use. */
+    onOpenChange?: (open: boolean) => void;
+    /** Fires when a row commits - gets its `id` and the full action. The rail stays open; render what happens next in `children`. */
+    onSelect?: (id: string, action: SupportAction) => void;
+    /** The vertical mono word on the needle. Doubles as the needle's accessible name. @default 'Support' */
+    needleLabel?: string;
+    /** Availability dot on the needle, with an ambient halo. @default false */
+    live?: boolean;
+    /** Arbitrary content below the rows; it takes the leftover height and scrolls. */
+    children?: ReactNode;
+    /** Pinned bottom strip - on-shift avatars, an SLA line, a link out. */
+    footer?: ReactNode;
+    /** Extra class(es) merged onto the rail root. */
+    className?: string;
+    /** Inline styles merged onto the rail root - the place to retune the `--support-rail-*` properties. */
+    style?: SupportRailStyle;
+}
+export interface SupportRailProps extends SupportRailOwnProps {
+    /** Standard <div> attributes (aria-*, data-*, id, ...) forwarded to the rail root. */
+    htmlProps?: Omit<HTMLAttributes<HTMLDivElement>, keyof SupportRailOwnProps> & DataAttributes;
+}
+export declare function SupportRail({ actions, title, status, side, open: controlledOpen, defaultOpen, onOpenChange, onSelect, needleLabel, live, children, footer, className, style, htmlProps, }: SupportRailProps): import("react").JSX.Element;

package/dist/types/components/dev/MotionDevtools.d.ts

@@ -0,0 +1,24 @@
+import './motion-devtools.css';
+export type MotionDevtoolsPlacement = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+export interface MotionDevtoolsProps {
+    /** Which corner of the viewport to pin to. @default 'bottom-right' */
+    placement?: MotionDevtoolsPlacement;
+    /** Distance from the viewport edges, in px. @default 16 */
+    offset?: number;
+    /** Quick-select slow-down factors (1 = real time). @default [1, 2, 4, 8, 16] */
+    presets?: number[];
+    /** Upper bound of the fine slider. @default 16 */
+    maxFactor?: number;
+    /** Slow-down factor to start at. @default 1 */
+    defaultFactor?: number;
+    /** Scale setTimeout/setInterval too, so duration-coupled JS cleanups don't truncate
+     *  slowed CSS. Exposed as a live toggle in the panel. @default true */
+    scaleTimers?: boolean;
+    /** Remember the chosen factor across reloads (localStorage). @default true */
+    persist?: boolean;
+    /** Start with the full panel open rather than collapsed to its header. @default false */
+    defaultOpen?: boolean;
+}
+export declare function MotionDevtools({ placement, offset, presets, maxFactor, defaultFactor, scaleTimers, persist, defaultOpen, }: MotionDevtoolsProps): import("react").ReactPortal;
+export { motionSlowmo, type SlowmoState } from './slowmo-engine';
+export default MotionDevtools;

package/dist/types/components/dev/slowmo-engine.d.ts

@@ -0,0 +1,27 @@
+export interface SlowmoState {
+    /** 1 = real time. >1 = that many times slower (4 = quarter speed). */
+    factor: number;
+    /** Freeze motion in place - useful for inspecting a transition mid-flight. */
+    paused: boolean;
+}
+export interface SlowmoOptions {
+    /** Also scale setTimeout/setInterval so duration-coupled JS cleanups don't truncate
+     *  slowed CSS. Turn off if stretched app timers get in your way. @default true */
+    scaleTimers: boolean;
+}
+export declare function shouldBeActive(factor: number, paused: boolean): boolean;
+/** Imperative control surface - drive slow-mo from a console, a hotkey, or the panel.
+ *  Safe to call during SSR (no-ops the DOM work, still tracks state for hydration). */
+export declare const motionSlowmo: {
+    /** Current state (a copy). */
+    get(): SlowmoState;
+    /** Merge a partial state. factor is clamped to [1, 64]. */
+    set(patch: Partial<SlowmoState>): void;
+    /** Tune engine behaviour (e.g. stop scaling timers). Applies immediately if active. */
+    configure(patch: Partial<SlowmoOptions>): void;
+    /** Convenience: back to real time and unpaused. */
+    reset(): void;
+    /** Subscribe to state changes; returns an unsubscribe fn. */
+    subscribe(cb: (s: SlowmoState) => void): () => void;
+};
+export type MotionSlowmo = typeof motionSlowmo;