haze-ui 1.26.0 → 1.27.0

package/dist/types/components/Slider/SliderCore.d.ts

@@ -1,11 +1,40 @@
-import type { ComponentPropsWithoutRef } from 'react';
+import type { ComponentPropsWithoutRef, Ref } from 'react';
 type SliderCoreProps = {
-    value: number;
-    onChange: (value: number) => void;
+    /** `number` in single mode, `[low, high]` when `range` is set. An
+     * inverted tuple renders normalized (low ≤ high). */
+    value: number | [number, number];
+    /** Notifies the next value: `number` in single mode, `[low, high]` in
+     * range mode — a thumb driven past the other snaps against it, so the
+     * pair stays ordered. */
+    onChange: (value: number | [number, number]) => void;
     /** Native change event passthrough — invoked with the DOM event after
-     * `onChange`, so a spread can never override the controlled callback. */
+     * `onChange`, so a spread can never override the controlled callback.
+     * In range mode the event is the changing input's. */
     onNativeChange?: ComponentPropsWithoutRef<'input'>['onChange'];
+    /**
+     * Range mode: the single input becomes two stacked native inputs
+     * (low thumb first in DOM and tab order) over a shared rail with a
+     * primary-colored fill between the thumbs. Each thumb steps
+     * independently, clamps to the shared min/max, and snaps against the
+     * other thumb instead of crossing it. The stacked inputs' tracks are
+     * transparent and pointer-transparent — only their thumbs take
+     * pointer input.
+     */
+    range?: boolean;
     className?: string;
-} & Omit<ComponentPropsWithoutRef<'input'>, 'type' | 'value' | 'onChange'>;
-export default function SliderCore({ value, onChange, onNativeChange, className, ...rest }: SliderCoreProps): import("react").JSX.Element;
+    /**
+     * Single mode: forwarded to the input untouched. Range mode: a
+     * `[lowLabel, highLabel]` tuple labels each thumb; a bare string
+     * labels both thumbs (two identically named sliders are ambiguous —
+     * prefer the tuple). All other forwarded native props (min, max,
+     * step, disabled, …) apply to both inputs.
+     */
+    'aria-label'?: string | [string, string];
+    /**
+     * Forwarded to the `<input type='range'>` — the only input in single
+     * mode, the low thumb (first tab stop) in range mode.
+     */
+    ref?: Ref<HTMLInputElement>;
+} & Omit<ComponentPropsWithoutRef<'input'>, 'type' | 'value' | 'onChange' | 'aria-label'>;
+export default function SliderCore({ value, onChange, onNativeChange, range, className, onKeyDown, 'aria-label': ariaLabel, ref, ...rest }: SliderCoreProps): import("react").JSX.Element;
 export type { SliderCoreProps };

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

@@ -1,8 +1,11 @@
-import type { ComponentPropsWithoutRef } from 'react';
+import type { ComponentPropsWithoutRef, Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
 type SwitchProps = {
     checked?: ControlOrValue<boolean>;
     size?: 'sm' | 'md' | 'lg';
+    /** Forwarded to the underlying switch `<button>` — form bridges and
+     * `ref.current.focus()` reach. */
+    ref?: Ref<HTMLButtonElement>;
 } & Omit<ComponentPropsWithoutRef<'button'>, 'type' | 'checked' | 'onChange'>;
-export default function Switch({ checked: checkedControl, size, className, onClick, ...rest }: SwitchProps): import("react").JSX.Element;
+export default function Switch({ checked: checkedControl, size, className, onClick, ref, ...rest }: SwitchProps): import("react").JSX.Element;
 export type { SwitchProps };

package/dist/types/components/Switch/SwitchCore.d.ts

@@ -1,4 +1,4 @@
-import type { ComponentPropsWithoutRef } from 'react';
+import type { ComponentPropsWithoutRef, Ref } from 'react';
 type SwitchCoreProps = {
     checked: boolean;
     onChange: (checked: boolean) => void;
@@ -7,6 +7,8 @@ type SwitchCoreProps = {
     onNativeClick?: ComponentPropsWithoutRef<'button'>['onClick'];
     size?: 'sm' | 'md' | 'lg';
     className?: string;
+    /** Forwarded to the switch `<button>` element. */
+    ref?: Ref<HTMLButtonElement>;
 } & Omit<ComponentPropsWithoutRef<'button'>, 'type' | 'checked' | 'onChange'>;
-export default function SwitchCore({ checked, onChange, onNativeClick, size, className, ...rest }: SwitchCoreProps): import("react").JSX.Element;
+export default function SwitchCore({ checked, onChange, onNativeClick, size, className, ref, ...rest }: SwitchCoreProps): import("react").JSX.Element;
 export type { SwitchCoreProps };

package/dist/types/components/Tabs/TabList.d.ts

@@ -3,5 +3,12 @@ type TabListProps = {
     className?: string;
     children: ReactNode;
 };
+/**
+ * The tab strip: a roving-tabindex list per the WAI-ARIA tabs pattern —
+ * ←/→ move between tabs with wrapping and automatic activation
+ * (selection follows focus), Home/End jump to the ends. Under
+ * `dir="rtl"` the horizontal arrows mirror (← advances), read from the
+ * DOM at event time so the keys follow the mirrored strip.
+ */
 export default function TabList({ className, children }: TabListProps): import("react").JSX.Element;
 export type { TabListProps };

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

@@ -1,9 +1,16 @@
 import type { ReactNode } from 'react';
 import type { ControlOrValue } from 'react-use-control';
+import type { TabsClassNames } from './TabsContext';
 type TabsProps = {
     value?: ControlOrValue<string>;
+    /**
+     * Semantic slot classes (AntD v6 `classNames` shape): declared once
+     * here and distributed to every part through context — see
+     * {@link TabsClassNames}. Omitting it changes nothing.
+     */
+    classNames?: TabsClassNames;
     className?: string;
     children: ReactNode;
 };
-export default function Tabs({ value: valueControl, className, children, }: TabsProps): import("react").JSX.Element;
+export default function Tabs({ value: valueControl, classNames, className, children, }: TabsProps): import("react").JSX.Element;
 export type { TabsProps };

package/dist/types/components/Tabs/TabsContext.d.ts

@@ -1,7 +1,27 @@
 import type { Dispatch, SetStateAction } from 'react';
+/**
+ * Semantic slot classes (AntD v6 `classNames` shape) for the Tabs
+ * family: declared once on the `<Tabs>` root and distributed to every
+ * part through context — the sub-components stay prop-light while one
+ * record themes the whole strip. Consumer classes are appended at the
+ * end of each part's class list (able to override component defaults);
+ * per-part `className` props remain for one-off tweaks and still land
+ * after the slot class.
+ */
+export type TabsClassNames = {
+    /** The wrapper `<div>` `<Tabs>` renders. */
+    root?: string;
+    /** The `<TabList>` strip (`role="tablist"`). */
+    list?: string;
+    /** Every `<Tab>` button (`role="tab"`). */
+    tab?: string;
+    /** Every `<TabPanel>` (`role="tabpanel"`). */
+    panel?: string;
+};
 type TabsContextValue = {
     value: string;
     setValue: Dispatch<SetStateAction<string>>;
+    classNames: TabsClassNames | undefined;
 };
 export declare const TabsProvider: import("react").Provider<TabsContextValue | undefined>;
 export declare function useTabsContext(): TabsContextValue;

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

@@ -1,5 +1,6 @@
 export { default as Tabs } from './Tabs';
 export type { TabsProps } from './Tabs';
+export type { TabsClassNames } from './TabsContext';
 export { default as TabList } from './TabList';
 export type { TabListProps } from './TabList';
 export { default as Tab } from './Tab';

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

@@ -2,6 +2,18 @@ import type { ReactNode } from 'react';
 type TagGroupProps = {
     children: ReactNode;
     className?: string;
+    /**
+     * Opt-in drag-and-drop reordering (@dnd-kit optional peers). Each chip
+     * becomes draggable; keyboard: focus a chip, Space lifts, arrows move,
+     * Space drops, Escape cancels.
+     */
+    sortable?: boolean;
+    /**
+     * Receives `nextOrder` — the new sequence of original child indices —
+     * after a completed drag. Reorder the children you pass accordingly;
+     * without a handler a drop only animates back to the source position.
+     */
+    onReorder?: (nextOrder: number[]) => void;
 };
-export default function TagGroup({ children, className }: TagGroupProps): import("react").JSX.Element;
+export default function TagGroup({ children, className, sortable, onReorder, }: TagGroupProps): import("react").JSX.Element;
 export type { TagGroupProps };

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

@@ -1,3 +1,4 @@
+import type { Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
 type TagInputProps = {
     value?: ControlOrValue<string[]>;
@@ -5,6 +6,13 @@ type TagInputProps = {
     placeholder?: string;
     maxTags?: number;
     disabled?: boolean;
+    /**
+     * Opt-in drag-and-drop tag reordering (@dnd-kit optional peers). Order
+     * changes leave through `onChange` with the new array — the same single
+     * exit as add/remove. Keyboard: focus a tag's label, Space lifts,
+     * arrows move, Space drops, Escape cancels.
+     */
+    sortable?: boolean;
     className?: string;
     /**
      * 字段 id（FormItem 桥生成）：必须挂到内部可聚焦的 input 上而非根
@@ -16,6 +24,9 @@ type TagInputProps = {
     'aria-invalid'?: boolean;
     /** 指向 FormItem 渲染的错误 span（id={errorId}），透传给内部 input。 */
     'aria-describedby'?: string;
+    /** Forwarded to the inner text `<input>` (not the root div) — the
+     * element form bridges and `ref.current.focus()` reach. */
+    ref?: Ref<HTMLInputElement>;
 };
-export default function TagInput({ value: valueControl, onChange, placeholder, maxTags, disabled, className, id, 'aria-invalid': ariaInvalid, 'aria-describedby': ariaDescribedby, }: TagInputProps): import("react").JSX.Element;
+export default function TagInput({ value: valueControl, onChange, placeholder, maxTags, disabled, sortable, className, id, 'aria-invalid': ariaInvalid, 'aria-describedby': ariaDescribedby, ref, }: TagInputProps): import("react").JSX.Element;
 export type { TagInputProps };

package/dist/types/components/TagInput/TagInputCore.d.ts

@@ -1,9 +1,17 @@
+import type { Ref } from 'react';
 type TagInputCoreProps = {
     value: string[];
     onChange: (value: string[]) => void;
     placeholder?: string;
     maxTags?: number;
     disabled?: boolean;
+    /**
+     * Opt-in drag-and-drop tag reordering (@dnd-kit optional peers). Order
+     * changes leave through `onChange` with the new array — the same single
+     * exit as add/remove. Keyboard: focus a tag's label, Space lifts,
+     * arrows move, Space drops, Escape cancels.
+     */
+    sortable?: boolean;
     className?: string;
     /**
      * 字段 id（FormItem 桥生成）：必须挂到内部可聚焦的 input 上而非根
@@ -15,6 +23,8 @@ type TagInputCoreProps = {
     'aria-invalid'?: boolean;
     /** 指向 FormItem 渲染的错误 span（id={errorId}），透传给内部 input。 */
     'aria-describedby'?: string;
+    /** Forwarded to the inner text `<input>` (not the root div). */
+    ref?: Ref<HTMLInputElement>;
 };
-export default function TagInputCore({ value: tags, onChange, placeholder, maxTags, disabled, className, id, 'aria-invalid': ariaInvalid, 'aria-describedby': ariaDescribedby, }: TagInputCoreProps): import("react").JSX.Element;
+export default function TagInputCore({ value: tags, onChange, placeholder, maxTags, disabled, sortable, className, id, 'aria-invalid': ariaInvalid, 'aria-describedby': ariaDescribedby, ref, }: TagInputCoreProps): import("react").JSX.Element;
 export type { TagInputCoreProps };

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

@@ -1,8 +1,11 @@
-import type { ComponentPropsWithoutRef } from 'react';
+import type { ComponentPropsWithoutRef, Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
 type TextareaProps = {
     value?: ControlOrValue<string>;
     size?: 'sm' | 'md' | 'lg';
+    /** Forwarded to the underlying `<textarea>` — the element form bridges
+     * (react-f0rm `focusRef`), tests and `ref.current.focus()` reach. */
+    ref?: Ref<HTMLTextAreaElement>;
 } & Omit<ComponentPropsWithoutRef<'textarea'>, 'value'>;
-export default function Textarea({ value: valueControl, size, className, onChange, ...rest }: TextareaProps): import("react").JSX.Element;
+export default function Textarea({ value: valueControl, size, className, onChange, ref, ...rest }: TextareaProps): import("react").JSX.Element;
 export type { TextareaProps };

package/dist/types/components/Textarea/TextareaCore.d.ts

@@ -1,4 +1,4 @@
-import type { ComponentPropsWithoutRef } from 'react';
+import type { ComponentPropsWithoutRef, Ref } from 'react';
 type TextareaCoreProps = {
     value: string;
     onChange: (value: string) => void;
@@ -7,6 +7,8 @@ type TextareaCoreProps = {
     onNativeChange?: ComponentPropsWithoutRef<'textarea'>['onChange'];
     size?: 'sm' | 'md' | 'lg';
     className?: string;
+    /** Forwarded to the `<textarea>` element. */
+    ref?: Ref<HTMLTextAreaElement>;
 } & Omit<ComponentPropsWithoutRef<'textarea'>, 'value' | 'onChange' | 'size'>;
-export default function TextareaCore({ value, onChange, onNativeChange, size, className, ...rest }: TextareaCoreProps): import("react").JSX.Element;
+export default function TextareaCore({ value, onChange, onNativeChange, size, className, ref, ...rest }: TextareaCoreProps): import("react").JSX.Element;
 export type { TextareaCoreProps };

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

@@ -1,10 +1,13 @@
-import type { ComponentPropsWithoutRef } from 'react';
+import type { ComponentPropsWithoutRef, Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
 type TimePickerProps = {
     value?: ControlOrValue<string>;
     onChange?: (value: string) => void;
     placeholder?: string;
     className?: string;
+    /** Forwarded to the underlying `<input>` — the element form bridges
+     * and `ref.current.focus()` reach. */
+    ref?: Ref<HTMLInputElement>;
 } & Omit<ComponentPropsWithoutRef<'input'>, 'value' | 'onChange' | 'type' | 'placeholder'>;
-export default function TimePicker({ value: valueControl, onChange, placeholder, className, ...rest }: TimePickerProps): import("react").JSX.Element;
+export default function TimePicker({ value: valueControl, onChange, placeholder, className, ref, ...rest }: TimePickerProps): import("react").JSX.Element;
 export type { TimePickerProps };

package/dist/types/components/TimePicker/TimePickerCore.d.ts

@@ -1,9 +1,11 @@
-import type { ComponentPropsWithoutRef } from 'react';
+import type { ComponentPropsWithoutRef, Ref } from 'react';
 type TimePickerCoreProps = {
     value: string;
     onChange: (value: string) => void;
     placeholder?: string;
     className?: string;
+    /** Forwarded to the `<input>` element. */
+    ref?: Ref<HTMLInputElement>;
 } & Omit<ComponentPropsWithoutRef<'input'>, 'value' | 'onChange' | 'type' | 'placeholder'>;
-export default function TimePickerCore({ value, onChange, placeholder, className, ...rest }: TimePickerCoreProps): import("react").JSX.Element;
+export default function TimePickerCore({ value, onChange, placeholder, className, ref, ...rest }: TimePickerCoreProps): import("react").JSX.Element;
 export type { TimePickerCoreProps };

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

@@ -1,9 +1,38 @@
 import type { ComponentPropsWithRef, ReactNode } from 'react';
+/**
+ * Semantic slot classes (AntD v6 `classNames` shape) for the toast
+ * family. Toasts are usually fired imperatively (`useToast()` /
+ * `toast()`), so the record is accepted by `ToastContainer` and flows
+ * to every toast it renders; a directly rendered `<Toast>` accepts the
+ * same record and reads the item slots. Consumer classes are appended
+ * at the end of each part's class list (able to override component
+ * defaults).
+ */
+type ToastClassNames = {
+    /**
+     * The fixed-position toast stack. Only `ToastContainer` renders this
+     * part — a directly rendered `<Toast>` ignores the key.
+     */
+    viewport?: string;
+    /** One toast: the `role="status"`/`"alert"` card. */
+    item?: string;
+    /** The body wrapper around the toast content. */
+    content?: string;
+    /** The dismiss × button. */
+    close?: string;
+};
 type ToastProps = {
     variant?: 'info' | 'success' | 'warning' | 'danger';
     onClose: () => void;
     duration: number;
     children: ReactNode;
+    /**
+     * Semantic slot classes (AntD v6 `classNames` shape) — see
+     * {@link ToastClassNames}. Only `item`/`content`/`close` apply to a
+     * directly rendered toast; `viewport` is a `ToastContainer` part.
+     * Omitting it changes nothing.
+     */
+    classNames?: ToastClassNames;
 } & Omit<ComponentPropsWithRef<'div'>, 'children' | 'onClose'>;
-export default function Toast({ variant, onClose, duration, children, className, ...rest }: ToastProps): import("react").JSX.Element;
-export type { ToastProps };
+export default function Toast({ variant, onClose, duration, children, classNames, className, ...rest }: ToastProps): import("react").JSX.Element;
+export type { ToastProps, ToastClassNames };

package/dist/types/components/Toast/ToastContainer.d.ts

@@ -1,4 +1,5 @@
 import type { ReactNode } from 'react';
+import type { ToastClassNames } from './Toast';
 type ToastPlacement = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
 type ToastContainerProps = {
     children: ReactNode;
@@ -6,6 +7,15 @@ type ToastContainerProps = {
     maxCount?: number;
     /** Viewport edge the stack is pinned to. */
     placement?: ToastPlacement;
+    /**
+     * Semantic slot classes (AntD v6 `classNames` shape) for the whole
+     * toast family — `viewport` lands on the fixed stack this container
+     * renders, `item`/`content`/`close` flow to every toast (see
+     * {@link ToastClassNames}). Toasts are fired imperatively through
+     * `useToast()`/`toast()`, so this prop is the one place to theme
+     * them. Omitting it changes nothing.
+     */
+    classNames?: ToastClassNames;
 };
 export declare const toastPlacements: {
     readonly 'top-left': import("@linaria/core").LinariaClassName;
@@ -13,5 +23,5 @@ export declare const toastPlacements: {
     readonly 'bottom-left': import("@linaria/core").LinariaClassName;
     readonly 'bottom-right': import("@linaria/core").LinariaClassName;
 };
-export default function ToastContainer({ children, maxCount, placement, }: ToastContainerProps): import("react").JSX.Element;
+export default function ToastContainer({ children, maxCount, placement, classNames, }: ToastContainerProps): import("react").JSX.Element;
 export type { ToastContainerProps, ToastPlacement };

package/dist/types/components/Toast/ToastContext.d.ts

@@ -1,15 +1,56 @@
 import type { ReactNode } from 'react';
+type ToastVariant = 'info' | 'success' | 'warning' | 'danger';
 type ToastItem = {
     id: number;
-    variant: 'info' | 'success' | 'warning' | 'danger';
+    variant: ToastVariant;
     content: ReactNode;
     duration: number;
 };
+/**
+ * Patch accepted by `toast.update(id, patch)` and `useToast().update(id,
+ * patch)`. Only fields present in the patch change; an omitted (or
+ * undefined) field keeps the toast's current value.
+ */
+type ToastUpdateOptions = {
+    /** Replacement message content. */
+    content?: ReactNode;
+    /** Replacement color variant. */
+    variant?: ToastVariant;
+    /** New auto-dismiss budget in ms. Changing it re-arms the countdown
+     * from the full value; leaving it out keeps the running countdown. */
+    duration?: number;
+};
+/** The `toast.promise` phases whose default copy lives in the locale pack. */
+type ToastDeferredCopyKey = 'loading' | 'success' | 'error';
+/**
+ * Sentinel ReactNode standing in for promise-phase copy that resolves
+ * against the locale pack at render time: `toast.promise` may fire from
+ * outside any React tree, so it cannot read `useStrings` itself — the
+ * container resolves the marker when it renders the toast. The sentinel
+ * rides the `content` channel as an opaque marker (cast once at the
+ * factory below); only the container ever interprets it.
+ */
+type ToastDeferredCopy = {
+    readonly deferredCopy: ToastDeferredCopyKey;
+};
+/** Creates the locale-deferred sentinel for one promise phase. */
+declare function deferredToastCopy(key: ToastDeferredCopyKey): ReactNode;
+declare function deferredCopyKey(node: ReactNode): ToastDeferredCopyKey | null;
+/**
+ * Pure merge of an update patch onto a toast item: keys absent (or
+ * undefined) in the patch keep the item's current value, so an update
+ * never clobbers fields it did not name.
+ */
+declare function applyToastPatch(item: ToastItem, patch: ToastUpdateOptions): ToastItem;
 type ToastContextValue = {
     toasts: ToastItem[];
-    addToast: (toast: Omit<ToastItem, 'id'>) => void;
+    addToast: (toast: Omit<ToastItem, 'id'>) => number;
     removeToast: (id: number) => void;
+    /** Patches a live toast in place — the same id and React key, so the
+     * enter/exit animations never replay (see `toast.update`). */
+    updateToast: (id: number, patch: ToastUpdateOptions) => void;
 };
 export declare const ToastProvider: import("react").Provider<ToastContextValue | undefined>;
 export declare function useToastContext(): ToastContextValue;
-export type { ToastItem, ToastContextValue };
+export { applyToastPatch, deferredCopyKey, deferredToastCopy, };
+export type { ToastDeferredCopy, ToastDeferredCopyKey, ToastItem, ToastContextValue, ToastUpdateOptions, ToastVariant, };

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

@@ -1,5 +1,5 @@
 export { default as Toast } from './Toast';
-export type { ToastProps } from './Toast';
+export type { ToastProps, ToastClassNames } from './Toast';
 export { default as ToastContainer } from './ToastContainer';
 export type { ToastContainerProps } from './ToastContainer';
 export { default as useToast } from './useToast';

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

@@ -1,6 +1,5 @@
 import type { ReactNode } from 'react';
-import type { ToastItem } from './ToastContext';
-type ToastVariant = ToastItem['variant'];
+import type { ToastDeferredCopyKey, ToastItem, ToastUpdateOptions, ToastVariant } from './ToastContext';
 /** Options accepted by `toast()` — the same call shape `useToast()` takes. */
 type ToastOptions = {
     variant?: ToastVariant;
@@ -8,10 +7,29 @@ type ToastOptions = {
 };
 /** Options accepted by the variant sugar methods (`toast.success()` …). */
 type ToastVariantOptions = Omit<ToastOptions, 'variant'>;
+/** Copy for one `toast.promise` phase: a literal, or derived from the
+ * settled value / rejection when the promise settles. */
+type ToastPhaseContent<T> = ReactNode | ((data: T) => ReactNode);
+/** Options accepted by `toast.promise(promise, options)`. */
+type ToastPromiseOptions<T> = {
+    /** Copy shown while the promise is pending. Defaults to the locale
+     * pack's `toast.loading`. The loading toast never auto-dismisses. */
+    loading?: ReactNode;
+    /** Copy shown once the promise resolves; a function receives the
+     * resolved value. Defaults to the locale pack's `toast.success`. */
+    success?: ToastPhaseContent<T>;
+    /** Copy shown once the promise rejects; a function receives the
+     * rejection value. Defaults to the locale pack's `toast.error`. */
+    error?: ToastPhaseContent<unknown>;
+    /** Auto-dismiss delay in ms applied once the promise settles — the
+     * loading toast stays until then. Defaults to 3000. */
+    duration?: number;
+};
 /** Sink a mounted `ToastContainer` registers to receive imperative calls. */
 type ToastChannel = {
     onToast: (item: ToastItem) => void;
     onDismiss: (id?: number) => void;
+    onUpdate: (id: number, patch: ToastUpdateOptions) => void;
 };
 /**
  * The single id sequence, shared by this module and the container's
@@ -21,7 +39,8 @@ export declare function nextToastId(): number;
 /**
  * Fires a toast without `useToast` — module-level, callable from anywhere
  * (outside React, in event callbacks, before a container has mounted).
- * Returns the toast id, usable with `toast.dismiss(id)`.
+ * Returns the toast id, usable with `toast.dismiss(id)` and
+ * `toast.update(id, patch)`.
  *
  * Mirrors the `useToast()` call shape (content + `{variant, duration}`,
  * defaulting to `info` / 3000ms). With no container mounted the toast is
@@ -35,7 +54,19 @@ declare namespace toast {
     var warning: (content: ReactNode, options?: ToastVariantOptions) => number;
     var danger: (content: ReactNode, options?: ToastVariantOptions) => number;
     var dismiss: (id?: number) => void;
+    var update: (id: number, patch: ToastUpdateOptions) => void;
+    var promise: <T>(p: Promise<T>, options?: ToastPromiseOptions<T>) => Promise<T>;
 }
+/**
+ * Shared engine behind `toast.promise` and `useToast().promise`: fires the
+ * loading toast through `show` (persistent — duration 0), then patches it
+ * in place when the promise settles, so the toast never remounts and its
+ * animations never replay. Returns the original promise untouched:
+ * rejections keep propagating to the caller's `await`/`catch`, and a
+ * loading toast dismissed before settling is simply not found by the
+ * update — it never resurrects.
+ */
+export declare function driveToastPromise<T>(show: (content: ReactNode, options?: ToastOptions) => number, updateById: (id: number, patch: ToastUpdateOptions) => void, promise: Promise<T>, options?: ToastPromiseOptions<T>): Promise<T>;
 /**
  * Called from `ToastContainer`'s mount effect. The first subscriber also
  * replays everything queued before any container existed, in call order;
@@ -43,4 +74,4 @@ declare namespace toast {
  */
 export declare function subscribeToastChannel(channel: ToastChannel): () => void;
 export { toast };
-export type { ToastOptions, ToastVariant, ToastVariantOptions };
+export type { ToastDeferredCopyKey, ToastOptions, ToastPhaseContent, ToastPromiseOptions, ToastUpdateOptions, ToastVariant, ToastVariantOptions, };

package/dist/types/components/Toast/useToast.d.ts

@@ -1,5 +1,17 @@
 import type { ReactNode } from 'react';
-export default function useToast(): (content: ReactNode, options?: {
-    variant?: "info" | "success" | "warning" | "danger";
-    duration?: number;
-}) => void;
+import type { ToastOptions, ToastPromiseOptions, ToastUpdateOptions } from './toast';
+/**
+ * The `useToast()` return value: the toast trigger itself (returns the id,
+ * usable with `update`) plus `update` and `promise` — one-to-one with the
+ * module-level `toast` API, but routed through the enclosing container's
+ * context instead of the first-mounted channel subscriber.
+ */
+type ShowToast = {
+    (content: ReactNode, options?: ToastOptions): number;
+    /** Patches a toast in place — see `toast.update`. */
+    update: (id: number, patch: ToastUpdateOptions) => void;
+    /** Loading → success/danger lifecycle — see `toast.promise`. */
+    promise: <T>(promise: Promise<T>, options?: ToastPromiseOptions<T>) => Promise<T>;
+};
+export default function useToast(): ShowToast;
+export type { ShowToast };

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

@@ -0,0 +1,19 @@
+import type { ComponentPropsWithoutRef, Ref } from 'react';
+import type { ControlOrValue } from 'react-use-control';
+type ToggleProps = {
+    /** Whether the toggle is pressed; a control for full external ownership. */
+    pressed?: ControlOrValue<boolean>;
+    size?: 'sm' | 'md' | 'lg';
+    /** Equal padding on all sides — for icon-only square toggles. */
+    square?: boolean;
+    /** Forwarded to the underlying `<button>` — form bridges and
+     * `ref.current.focus()` reach. */
+    ref?: Ref<HTMLButtonElement>;
+} & Omit<ComponentPropsWithoutRef<'button'>, 'type' | 'aria-pressed'>;
+/**
+ * A momentary pressed-state button (aria-pressed) for one-shot modes —
+ * bold, mute, grid/list view. `pressed` is one prop, two modes: a plain
+ * boolean leaves state internal, a control hands ownership to the caller.
+ */
+export default function Toggle({ pressed: pressedControl, size, square, className, onClick, ref, ...rest }: ToggleProps): import("react").JSX.Element;
+export type { ToggleProps };

package/dist/types/components/Toggle/ToggleCore.d.ts

@@ -0,0 +1,23 @@
+import type { ComponentPropsWithoutRef, Ref } from 'react';
+type ToggleCoreProps = {
+    pressed: boolean;
+    onPressedChange: (pressed: boolean) => void;
+    /** Native click event passthrough — invoked with the DOM event after
+     * `onPressedChange`, so a spread can never override the controlled callback. */
+    onNativeClick?: ComponentPropsWithoutRef<'button'>['onClick'];
+    size?: 'sm' | 'md' | 'lg';
+    /** Equal padding on all sides — for icon-only square toggles. */
+    square?: boolean;
+    className?: string;
+    /** Forwarded to the `<button>` element. */
+    ref?: Ref<HTMLButtonElement>;
+} & Omit<ComponentPropsWithoutRef<'button'>, 'type' | 'aria-pressed'>;
+/**
+ * The controlled half of Toggle: a momentary pressed-state button
+ * (`<button aria-pressed>`) — one-shot commands like bold/mute, not the
+ * on/off *setting* that Switch's `role="switch"` carries. State never
+ * lives here: it renders `pressed` and reports clicks through
+ * `onPressedChange`, so the sugar (or any owner) owns the truth.
+ */
+export default function ToggleCore({ pressed, onPressedChange, onNativeClick, size, square, className, ref, ...rest }: ToggleCoreProps): import("react").JSX.Element;
+export type { ToggleCoreProps };

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

@@ -0,0 +1,4 @@
+export { default as Toggle } from './Toggle';
+export type { ToggleProps } from './Toggle';
+export { default as ToggleCore } from './ToggleCore';
+export type { ToggleCoreProps } from './ToggleCore';

package/dist/types/components/Toolbar/ToolbarToggle.d.ts

@@ -0,0 +1,19 @@
+import type { ComponentPropsWithoutRef } from 'react';
+import type { ControlOrValue } from 'react-use-control';
+/**
+ * A toolbar item that toggles: ToolbarButton's skin and roving behavior
+ * with a pressed state of its own. `pressed` is self-contained by
+ * default (no external wiring needed) and switches to external ownership
+ * when passed a control. The pressed look is keyed off `aria-pressed`,
+ * so the visual state can never drift from what assistive tech announces.
+ */
+type ToolbarToggleProps = {
+    /** Whether the item is pressed; a control for full external ownership. */
+    pressed?: ControlOrValue<boolean>;
+    variant?: 'solid' | 'outline' | 'ghost';
+    size?: 'sm' | 'md' | 'lg';
+    /** Equal padding on all sides — for icon-only square items. */
+    square?: boolean;
+} & Omit<ComponentPropsWithoutRef<'button'>, 'type' | 'aria-pressed'>;
+export default function ToolbarToggle({ pressed: pressedControl, variant, size, square, className, onClick, ...rest }: ToolbarToggleProps): import("react").JSX.Element;
+export type { ToolbarToggleProps };

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

@@ -4,3 +4,5 @@ export { default as ToolbarButton } from './ToolbarButton';
 export type { ToolbarButtonProps } from './ToolbarButton';
 export { default as ToolbarSeparator } from './ToolbarSeparator';
 export type { ToolbarSeparatorProps } from './ToolbarSeparator';
+export { default as ToolbarToggle } from './ToolbarToggle';
+export type { ToolbarToggleProps } from './ToolbarToggle';

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

@@ -4,9 +4,9 @@ import type { FloatingPlacement } from '../../utils/floating';
 /** Why the tour closed: the last step's Done button vs. an early exit. */
 type TourCloseReason = 'done' | 'skip';
 /**
- * Step-card placement relative to the spotlighted target — physical
- * semantics, the anchorable subset of FloatingPlacement ('point' has no
- * meaning without a floating trigger pair).
+ * Step-card placement relative to the spotlighted target — logical
+ * semantics (mirrors under RTL, like FloatingPlacement), the anchorable
+ * subset ('point' has no meaning without a floating trigger pair).
  */
 type TourPlacement = Exclude<FloatingPlacement, 'point'>;
 type TourStep = {

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

@@ -1,3 +1,3 @@
-import type { TreeProps } from './types';
-export default function Tree({ treeData, multiple, checkable, checkStrictly, selectable, disabled, blockNode, showLine, showIcon, switcherIcon, loadingIcon, titleRender, iconRender, expandedKeys: expandedKeysControl, selectedKeys: selectedKeysControl, checkedKeys: checkedKeysControl, className, onExpand, onSelect, onCheck, }: TreeProps): import("react").JSX.Element;
-export type { TreeProps };
+import type { TreeProps, TreeVirtualizedConfig } from './types';
+export default function Tree({ treeData, multiple, checkable, checkStrictly, selectable, disabled, blockNode, showLine, showIcon, switcherIcon, loadingIcon, titleRender, iconRender, virtualized, expandedKeys: expandedKeysControl, selectedKeys: selectedKeysControl, checkedKeys: checkedKeysControl, className, onExpand, onSelect, onCheck, }: TreeProps): import("react").JSX.Element;
+export type { TreeProps, TreeVirtualizedConfig };