haze-ui 1.26.0 → 1.28.0

package/dist/types/components/Select/select-options.d.ts

@@ -0,0 +1,53 @@
+import type { ReactNode } from 'react';
+/** One selectable entry extracted from the Select's JSX children. */
+export type SelectOptionData = {
+    value: string;
+    label: ReactNode;
+};
+/**
+ * One rendering slot of the Select's children: a top-level option, or a
+ * labelled group of options (from `<OptionGroup>` / plain `<optgroup>`).
+ * The flat keyboard-navigation order is the depth-first traversal of
+ * this structure, so highlighting runs continuously across groups.
+ */
+export type SelectEntryData = {
+    kind: 'option';
+    option: SelectOptionData;
+} | {
+    kind: 'group';
+    label: string;
+    options: SelectOptionData[];
+};
+/**
+ * Flattens the Select's children — <Option> and plain <option> elements
+ * are both accepted — into the {value, label} list. <OptionGroup> /
+ * <optgroup> wrappers contribute their nested options in document
+ * order. Children without a resolvable value are ignored, the same way
+ * a native select treats stray non-option nodes.
+ */
+export declare function extractSelectOptions(children: ReactNode): SelectOptionData[];
+/**
+ * Extracts the Select's children preserving the grouping structure:
+ * top-level options stay single entries, <OptionGroup>/<optgroup>
+ * wrappers become group entries with their nested options. Group
+ * nesting is not recursive — a native <optgroup> cannot contain another
+ * group — and groups left without any resolvable option are dropped.
+ */
+export declare function extractSelectEntries(children: ReactNode): SelectEntryData[];
+/** Depth-first flattening of the entry structure (groups in document
+ * order) — the order keyboard navigation walks. */
+export declare function flattenSelectEntries(entries: SelectEntryData[]): SelectOptionData[];
+/**
+ * Textual form of an option's label for string-only contexts: the
+ * search filter and the `+N` overflow tooltip. String/number labels
+ * pass through; element labels contribute their concatenated text
+ * content (nested arrays and elements are walked).
+ */
+export declare function selectOptionText(label: ReactNode): string;
+/**
+ * Case-insensitive substring filter over the entry structure. An empty
+ * (or whitespace-only) query returns the entries unchanged; groups
+ * whose options all miss the query are dropped entirely, keeping the
+ * rendered list free of orphaned headers.
+ */
+export declare function filterSelectEntries(entries: SelectEntryData[], query: string): SelectEntryData[];

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

@@ -0,0 +1,51 @@
+import type { ComponentPropsWithoutRef } from 'react';
+import type { ControlOrValue } from 'react-use-control';
+/**
+ * Handwriting signature pad on a `<canvas>`.
+ *
+ * `value` is the committed signature as a PNG `data:` URL (empty string
+ * when the pad is blank) — it is an *output*: committed on every stroke
+ * end, `Undo` and `Clear` follow the same path. Painting an initial
+ * `data:` URL back onto the canvas is not supported (the canvas is the
+ * input device; persist the committed string, e.g. into a form field).
+ * `onChange` fires with the new string on every commit.
+ *
+ * Pointer Events drive the drawing (`setPointerCapture` keeps the
+ * stroke alive outside the canvas bounds); the drawing scales for
+ * high-DPI screens via `devicePixelRatio`. When the canvas 2d context
+ * is unavailable (jsdom, ancient engines) the pad degrades to a notice
+ * instead of a broken input — the Watermark precedent.
+ *
+ * Visible copy is localized through the LocaleProvider packs
+ * (`signature` section): `clearLabel`, `undoLabel` and
+ * `unsupportedLabel` override the pack per instance.
+ */
+type SignatureProps = {
+    /** Committed signature as a PNG data URL; a Control receives every
+     * commit live, a plain string seeds the committed state. */
+    value?: ControlOrValue<string>;
+    /** Fires with the committed data URL (or `''` when blank) on stroke
+     * end, undo and clear. */
+    onChange?: (value: string) => void;
+    /** Label of the clear button. Default from `signature.clear`. */
+    clearLabel?: string;
+    /** Label of the undo button. Default from `signature.undo`. */
+    undoLabel?: string;
+    /** Notice rendered instead of the pad when the canvas 2d context
+     * is unavailable. Default from `signature.unsupported`. */
+    unsupportedLabel?: string;
+    /** Canvas CSS width in px. */
+    width?: number;
+    /** Canvas CSS height in px. */
+    height?: number;
+    /** Locks drawing and the toolbar. */
+    disabled?: boolean;
+    /** Pen stroke color; any CSS color. Defaults to the theme's
+     * `--haze-color-text` (resolved from the canvas element at stroke
+     * time — a canvas cannot consume `var()` directly). */
+    penColor?: string;
+    /** Pen stroke width in px. */
+    penWidth?: number;
+} & Omit<ComponentPropsWithoutRef<'div'>, 'onChange'>;
+export default function Signature({ value: valueControl, onChange, clearLabel, undoLabel, unsupportedLabel, width, height, disabled, penColor, penWidth, className, ...rest }: SignatureProps): import("react").JSX.Element;
+export type { SignatureProps };

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

@@ -0,0 +1,2 @@
+export { default as Signature } from './Signature';
+export type { SignatureProps } from './Signature';

package/dist/types/components/Signature/signature-points.d.ts

@@ -0,0 +1,31 @@
+/** Canvas-space point of a signature stroke. */
+export type SignaturePoint = {
+    x: number;
+    y: number;
+};
+/** Euclidean distance between two points. */
+export declare function pointDistance(a: SignaturePoint, b: SignaturePoint): number;
+/**
+ * Map pointer client coordinates onto the canvas coordinate space
+ * (CSS pixels after the high-DPI `ctx.scale` — device pixels never leak
+ * into stroke data). `rect` is the canvas's `getBoundingClientRect()`.
+ */
+export declare function getCanvasPoint(clientX: number, clientY: number, rect: {
+    left: number;
+    top: number;
+}): SignaturePoint;
+/**
+ * Drop points that move less than `minDistance` from their predecessor
+ * (pointer-event streams over-sample stationary contact). The first and
+ * last points of the stroke are always kept — the last one carries the
+ * stroke's true endpoint. An input of fewer than two points returns a
+ * copy unchanged.
+ */
+export declare function normalizeStroke(stroke: SignaturePoint[], minDistance: number): SignaturePoint[];
+/**
+ * Compact deterministic serialization of a stroke set —
+ * `"x,y x,y|x,y"` — used to detect whether a commit (stroke end, undo,
+ * clear) actually changed the drawing, so redundant events are not
+ * fired.
+ */
+export declare function serializeStrokes(strokes: SignaturePoint[][]): string;

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

@@ -1,7 +1,32 @@
-import type { ComponentPropsWithoutRef } from 'react';
+import type { ComponentPropsWithoutRef, Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
 type SliderProps = {
-    value?: ControlOrValue<number>;
-} & Omit<ComponentPropsWithoutRef<'input'>, 'type' | 'value'>;
-export default function Slider({ value: valueControl, className, onChange, ...rest }: SliderProps): import("react").JSX.Element;
+    /** `number` in single mode, `[low, high]` when `range` is set. */
+    value?: ControlOrValue<number | [number, number]>;
+    /**
+     * Range mode (two thumbs; see SliderCoreProps.range). The uncontrolled
+     * default is `[min ?? 0, max ?? 100]` in this mode, `50` otherwise.
+     */
+    range?: boolean;
+    /**
+     * Value callback for both modes: `number` in single mode,
+     * `[low, high]` when `range` is set — fired after the value updates.
+     * The native input `change` event stays available through `onChange`
+     * (the historical contract; in range mode it fires for the input
+     * currently changing).
+     */
+    onValuesChange?: (value: number | [number, number]) => void;
+    /**
+     * Forwarded to the input. In range mode a `[lowLabel, highLabel]`
+     * tuple labels each thumb; a bare string labels both thumbs (two
+     * identically named sliders are ambiguous — prefer the tuple).
+     */
+    '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' | 'aria-label'>;
+export default function Slider({ value: valueControl, range, className, onChange, onValuesChange, ref, ...rest }: SliderProps): import("react").JSX.Element;
 export type { SliderProps };

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/Sources/Sources.d.ts

@@ -0,0 +1,37 @@
+import type { ComponentPropsWithoutRef, ReactNode } from 'react';
+import type { ControlOrValue } from 'react-use-control';
+/** One cited source: a numbered entry whose title optionally links out. */
+type SourceItem = {
+    /** Stable identity — the list key and the unit of `expanded`. */
+    id: string;
+    title: ReactNode;
+    /** When present the title becomes an external link (safe rel, new tab). */
+    url?: string;
+    /** Excerpt quoted from the source; revealed on hover/focus or `expanded`. */
+    snippet?: ReactNode;
+};
+type SourcesProps = {
+    items: SourceItem[];
+    /**
+     * Compact footnote form: an inline `nav` of `[1] [2] [3]` badges
+     * (each linking out when `url` is set) instead of the full list.
+     */
+    compact?: boolean;
+    /**
+     * Ids of the items whose snippet stays expanded regardless of
+     * hover/focus. Controllable: pass a control to own the toggle state.
+     */
+    expanded?: ControlOrValue<readonly string[]>;
+    /** Accessible name for the list (`compact`: the nav landmark).
+     * Default from `sources.label` in the locale packs. */
+    label?: string;
+    /** `aria-label` of a collapsed item's excerpt toggle button.
+     * Default from `sources.expand`. */
+    expandLabel?: string;
+    /** `aria-label` of an expanded item's excerpt toggle button.
+     * Default from `sources.collapse`. */
+    collapseLabel?: string;
+    className?: string;
+} & Omit<ComponentPropsWithoutRef<'ol'>, 'children'>;
+export default function Sources({ items, compact, expanded: expandedControl, label, expandLabel, collapseLabel, className, ...rest }: SourcesProps): import("react").JSX.Element;
+export type { SourcesProps, SourceItem };

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

@@ -0,0 +1,2 @@
+export { default as Sources } from './Sources';
+export type { SourcesProps, SourceItem } from './Sources';

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/SortableTagGroup.d.ts

@@ -0,0 +1,20 @@
+import type { ReactNode } from 'react';
+/**
+ * Drag-and-drop reorderable variant of TagGroup — built on @dnd-kit
+ * (optional peers), so this module statically imports the dnd runtime;
+ * the plain TagGroup stays free of it. Each chip becomes draggable;
+ * keyboard: focus a chip, Space lifts, arrows move, Space drops, Escape
+ * cancels.
+ */
+type SortableTagGroupProps = {
+    children: ReactNode;
+    className?: string;
+    /**
+     * 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 SortableTagGroup({ children, className, onReorder, }: SortableTagGroupProps): import("react").JSX.Element;
+export type { SortableTagGroupProps };

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

@@ -3,5 +3,8 @@ type TagGroupProps = {
     children: ReactNode;
     className?: string;
 };
+/** Plain non-draggable tag row. For drag-and-drop reordering use
+ * SortableTagGroup (which statically imports the dnd-kit optional peers);
+ * this base component stays free of the dnd runtime. */
 export default function TagGroup({ children, className }: TagGroupProps): import("react").JSX.Element;
 export type { TagGroupProps };

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

@@ -1,4 +1,6 @@
 export { default as TagGroup } from './TagGroup';
 export { default as TagGroupItem } from './TagGroupItem';
+export { default as SortableTagGroup } from './SortableTagGroup';
 export type { TagGroupProps } from './TagGroup';
 export type { TagGroupItemProps } from './TagGroupItem';
+export type { SortableTagGroupProps } from './SortableTagGroup';

package/dist/types/components/TagGroup/tag-group-styles.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Shared skin of the TagGroup family: the plain passthrough (TagGroup) and
+ * the dnd-backed variant (SortableTagGroup) render the same wrapper, so
+ * the class lives in one prefixed sibling file (Linaria slugs derive from
+ * the file basename — bare `styles.ts` siblings collide across families).
+ */
+export declare const group: import("@linaria/core").LinariaClassName;

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

@@ -0,0 +1,34 @@
+import type { Ref } from 'react';
+import type { ControlOrValue } from 'react-use-control';
+type SortableTagInputProps = {
+    value?: ControlOrValue<string[]>;
+    onChange?: (value: string[]) => void;
+    placeholder?: string;
+    maxTags?: number;
+    disabled?: boolean;
+    className?: string;
+    /**
+     * 字段 id（FormItem 桥生成）：必须挂到内部可聚焦的 input 上而非根
+     * div，<label htmlFor> 与错误 span 的 aria 链路才能接到焦点元素——
+     * 根 div 不聚焦，挂那里等于断链。
+     */
+    id?: string;
+    /** 由 FormItem 桥传入，随字段错误态变化，透传给内部 input。 */
+    '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>;
+};
+/**
+ * Controllable-state sugar over `SortableTagInputCore`: drag-and-drop tag
+ * reordering built on the @dnd-kit optional peers — install
+ * `@dnd-kit/core`, `@dnd-kit/sortable` and `@dnd-kit/utilities` to use
+ * it (the plain `TagInput` never touches them). Reorders 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.
+ */
+export default function SortableTagInput({ value: valueControl, onChange, placeholder, maxTags, disabled, className, id, 'aria-invalid': ariaInvalid, 'aria-describedby': ariaDescribedby, ref, }: SortableTagInputProps): import("react").JSX.Element;
+export type { SortableTagInputProps };

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

@@ -0,0 +1,18 @@
+import type { TagInputCoreProps } from './TagInputCore';
+/**
+ * Props for `SortableTagInputCore` — the full `TagInputCoreProps` field
+ * set (value/onChange/placeholder/maxTags/disabled/className/id/aria/ref)
+ * minus the internal injection seams, which drag reordering replaces.
+ */
+type SortableTagInputCoreProps = Omit<TagInputCoreProps, 'renderTag' | 'wrapTagList'>;
+/**
+ * Drag-and-drop tag reordering over the @dnd-kit optional peers. This
+ * component statically imports `@dnd-kit/core`, `@dnd-kit/sortable` and
+ * `@dnd-kit/utilities` — install the trio to use it (the plain
+ * `TagInputCore` never touches them). Reorders 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.
+ */
+export default function SortableTagInputCore(props: SortableTagInputCoreProps): import("react").JSX.Element;
+export type { SortableTagInputCoreProps };

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[]>;
@@ -16,6 +17,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, 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,3 +1,4 @@
+import type { Ref } from 'react';
 type TagInputCoreProps = {
     value: string[];
     onChange: (value: string[]) => void;
@@ -15,6 +16,9 @@ type TagInputCoreProps = {
     '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 TagInputCore({ value: tags, onChange, placeholder, maxTags, disabled, className, id, 'aria-invalid': ariaInvalid, 'aria-describedby': ariaDescribedby, }: TagInputCoreProps): import("react").JSX.Element;
-export type { TagInputCoreProps };
+export default function TagInputCore({ value: tags, onChange, placeholder, maxTags, disabled, renderTag, wrapTagList, className, id, 'aria-invalid': ariaInvalid, 'aria-describedby': ariaDescribedby, ref, }: TagInputCoreProps): import("react").JSX.Element;
+export type { TagInputCoreProps, TagSlot, TagListSlot };

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

@@ -2,3 +2,7 @@ export { default as TagInput } from './TagInput';
 export type { TagInputProps } from './TagInput';
 export { default as TagInputCore } from './TagInputCore';
 export type { TagInputCoreProps } from './TagInputCore';
+export { default as SortableTagInput } from './SortableTagInput';
+export type { SortableTagInputProps } from './SortableTagInput';
+export { default as SortableTagInputCore } from './SortableTagInputCore';
+export type { SortableTagInputCoreProps } from './SortableTagInputCore';

package/dist/types/components/TagInput/tag-input-styles.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Shared TagInput skin — the tag list, chip, remove-button and drag classes
+ * `TagInputCore` and `SortableTagInputCore` both wear. Component-prefixed
+ * basename (never bare `styles.ts`): Linaria derives class slugs from the
+ * file basename, so two bare-named sibling style files would collide into
+ * the same `haze-styles__*` classes (Badge/Button e2e precedent).
+ */
+export declare const listWrap: import("@linaria/core").LinariaClassName;
+export declare const tag: import("@linaria/core").LinariaClassName;
+export declare const removeBtn: import("@linaria/core").LinariaClassName;
+export declare const tagHandle: import("@linaria/core").LinariaClassName;
+export declare const tagDragging: import("@linaria/core").LinariaClassName;

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 };