haze-ui 1.32.0 → 1.34.0

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

@@ -0,0 +1,69 @@
+import type { ComponentPropsWithoutRef, Ref } from 'react';
+/**
+ * Heatmap — a GitHub-style activity calendar: week columns × weekday
+ * rows of squares, intensity-binned by value. Pure rendering from
+ * props (no hooks, RSC-safe): all i18n surface is label props
+ * (`getLabel` / `getMonthLabel` / `getWeekdayLabel` / `summary`)
+ * instead of LocaleProvider keys.
+ *
+ * Layout is one CSS grid: row 1 carries month labels (each spanning
+ * the week columns whose Saturday opens that month), column 1 the
+ * weekday labels, and every day square is placed by explicit
+ * gridRow/gridColumn — no nested wrappers, so labels and cells cannot
+ * drift apart. The date range aligns outward to full Sunday..Saturday
+ * weeks and defaults to the data's own extent.
+ *
+ * Accessibility: the calendar renders `role="img"` named by `summary`
+ * (one announcement for the whole graphic — screen readers would
+ * otherwise drown in hundreds of squares). Inside an image every child
+ * is presentational, so cells carry their `getLabel` text as a native
+ * `title` tooltip (and `data-date`/`data-level` for custom tooltip
+ * wiring) — an `aria-label` there would be swallowed by the img role
+ * and is prohibited on role-less elements besides.
+ */
+type HeatmapDatum = {
+    date: string;
+    value: number;
+};
+/**
+ * Semantic slot classes (AntD v6 `classNames` shape): keys mirror the
+ * data-slot values each part carries, appended after the component
+ * defaults so consumer classes can override them.
+ */
+type HeatmapClassNames = {
+    /** The grid root (`data-slot='heatmap'`). */
+    root?: string;
+    /** Every month label (`data-slot='month'`). */
+    month?: string;
+    /** Every weekday label (`data-slot='weekday'`). */
+    weekday?: string;
+    /** Every day square (`data-slot='cell'`). */
+    cell?: string;
+};
+type HeatmapProps = {
+    /** Activity data, one entry per `'YYYY-MM-DD'` date (later duplicates win). */
+    data?: HeatmapDatum[] | Record<string, number>;
+    /** Intensity bins above the empty level; default 4 (GitHub's scale). */
+    levels?: number;
+    /** First date of the range; defaults to the earliest datum. */
+    startDate?: string;
+    /** Last date of the range; defaults to the latest datum. */
+    endDate?: string;
+    /** Tooltip text of one day square (`title`, via `getLabel`). */
+    getLabel?: (datum: {
+        date: string;
+        value: number;
+    }) => string;
+    /** Month label for the week-group headers; defaults to English short names. */
+    getMonthLabel?: (month: number, year: number) => string;
+    /** Weekday label for row `weekday` (0 = Sunday); return '' to hide one. */
+    getWeekdayLabel?: (weekday: number) => string;
+    /** Accessible name of the whole calendar; default 'Activity heatmap'. */
+    summary?: string;
+    classNames?: HeatmapClassNames;
+    className?: string;
+    /** Forwarded to the grid root. */
+    ref?: Ref<HTMLDivElement>;
+} & Omit<ComponentPropsWithoutRef<'div'>, 'children'>;
+export default function Heatmap({ data, levels: levelsProp, startDate, endDate, getLabel, getMonthLabel, getWeekdayLabel, summary, classNames, className, style, ref, ...rest }: HeatmapProps): import("react").JSX.Element;
+export type { HeatmapProps, HeatmapClassNames, HeatmapDatum };

package/dist/types/components/Heatmap/heatmap-styles.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Shared Heatmap skin — the GitHub-style activity calendar chrome the
+ * `Heatmap` component wears. Living in its own module keeps the
+ * component file free of style internals (react-refresh boundary) and
+ * lets it register as RSC-safe (the module is hook-free and only
+ * re-exports Linaria constants). split-css groups the emitted CSS into
+ * `haze-ui/css/heatmap.css`.
+ *
+ * Intensity bins are a single class, not one class per level: every
+ * cell carries its own `--haze-heatmap-mix` percentage (inline style,
+ * level / levels · 100%) and the `color-mix()` background recomputes
+ * against whatever `--haze-color-primary` / `--haze-color-bg-subtle`
+ * resolve to — light, dark and brand-preset themes all follow for
+ * free, at any `levels` count, with zero per-level classes.
+ */
+/** The calendar grid: row 1 = month labels, rows 2-8 = Sun..Sat. */
+export declare const heatmapBase: import("@linaria/core").LinariaClassName;
+/** A month label spanning its week columns along the top row. */
+export declare const heatmapMonth: import("@linaria/core").LinariaClassName;
+/** The Sun..Sat gutter labels down the first column. */
+export declare const heatmapWeekday: import("@linaria/core").LinariaClassName;
+/** One day square; `data-level` carries the bin, the mix % the tint. */
+export declare const heatmapCell: import("@linaria/core").LinariaClassName;
+/** Dates with no activity (or value 0) — the flat faint square. */
+export declare const heatmapCellEmpty: import("@linaria/core").LinariaClassName;

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

@@ -0,0 +1,2 @@
+export { default as Heatmap } from './Heatmap.js';
+export type { HeatmapProps, HeatmapClassNames, HeatmapDatum } from './Heatmap.js';

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

@@ -1,2 +1,2 @@
-export { default as Highlight } from './Highlight';
-export type { HighlightProps } from './Highlight';
+export { default as Highlight } from './Highlight.js';
+export type { HighlightProps } from './Highlight.js';

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

@@ -1,7 +1,7 @@
 import type { ReactNode } from 'react';
 import type { ControlOrValue } from 'react-use-control';
-import type { CollisionPadding } from '../../utils/collision';
-import type { FloatingPlacement } from '../../utils/floating';
+import type { CollisionPadding } from '../../utils/collision.js';
+import type { FloatingPlacement } from '../../utils/floating.js';
 /**
  * HoverCard — a non-modal floating preview (avatar card, link summary)
  * anchored to its trigger.
@@ -20,6 +20,10 @@ import type { FloatingPlacement } from '../../utils/floating';
  * the panel cancels the pending close (the "resting zone"). Escape
  * closes at once (native popover light dismiss / the fallback path's
  * document keydown, both owned by useFloating).
+ *
+ * `interactive` upgrades the card to React Aria's PreviewTrigger
+ * semantics: focusable content, focus handoff trigger ↔ card, Escape
+ * returning focus to the trigger — see the prop for the contract.
  */
 type HoverCardProps = {
     /** Card content, rendered inside the floating panel. */
@@ -31,6 +35,19 @@ type HoverCardProps = {
      * before the card closes — long enough to travel into the panel.
      */
     closeDelay?: number;
+    /**
+     * Interactive card contents (React Aria PreviewTrigger semantics):
+     * focusable elements inside `content` join the Tab order and focus
+     * may travel between the trigger and the card without closing it.
+     * The pointer grace after leaving the trigger/panel defaults to
+     * 300 ms in this mode (vs 120 ms otherwise; an explicit `closeDelay`
+     * or a ConfigProvider default still overrides). While focus rests
+     * inside the card, pointer leaves alone no longer close it — Escape
+     * or tabbing out does, and Escape hands focus back to the trigger.
+     * Focus is deliberately NOT trapped: a hover card is a preview, not
+     * a modal, so Tab must keep reaching the rest of the page.
+     */
+    interactive?: boolean;
     /**
      * Panel placement relative to the trigger, in the floating utils'
      * physical convention ('bottom-span' aligns the panel's inline-start
@@ -45,5 +62,5 @@ type HoverCardProps = {
     /** The trigger — render a focusable element for keyboard access. */
     children: ReactNode;
 };
-export default function HoverCard({ content, openDelay: openDelayProp, closeDelay: closeDelayProp, placement, open: openControl, collisionPadding, className, children, }: HoverCardProps): import("react").JSX.Element;
+export default function HoverCard({ content, openDelay: openDelayProp, closeDelay: closeDelayProp, interactive, placement, open: openControl, collisionPadding, className, children, }: HoverCardProps): import("react").JSX.Element;
 export type { HoverCardProps };

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

@@ -1,2 +1,2 @@
-export { default as HoverCard } from './HoverCard';
-export type { HoverCardProps } from './HoverCard';
+export { default as HoverCard } from './HoverCard.js';
+export type { HoverCardProps } from './HoverCard.js';

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

@@ -1,2 +1,2 @@
-export { default as Icon } from './Icon';
-export type { IconProps } from './Icon';
+export { default as Icon } from './Icon.js';
+export type { IconProps } from './Icon.js';

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

@@ -19,6 +19,10 @@ type ImageProps = {
      * rendering and behavior are unchanged). `true` turns on every control;
      * an object opts out per control: `zoom: false` drops the zoom
      * buttons, wheel zoom and drag pan, `rotate: false` the rotate button.
+     *
+     * Inside an `ImagePreviewGroup` this prop only opts the image in or
+     * out of the shared gallery: clicking delegates to the group's single
+     * overlay, and the group's own `preview` config governs its controls.
      */
     preview?: boolean | ImagePreviewConfig;
 } & Omit<ComponentPropsWithoutRef<'img'>, 'src' | 'alt'>;

package/dist/types/components/Image/ImageGalleryContext.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Registration protocol between `ImagePreviewGroup` and the `Image`
+ * children rendered inside it (AntD `Image.PreviewGroup` shape): each
+ * child with `preview` enabled contributes its `src`/`alt` to the
+ * shared gallery and delegates its click to the group's single overlay
+ * instead of opening one of its own.
+ */
+/** What a child `<Image preview>` contributes to the shared gallery. */
+export type GalleryImage = {
+    src: string;
+    alt: string;
+};
+type ImageGalleryContextValue = {
+    /**
+     * False while the group runs `preview={false}` — children stay inert
+     * (no registration, no click behavior) instead of falling back to
+     * their own single-image overlays.
+     */
+    enabled: boolean;
+    /** Adds an entry, returns the id used to unregister/activate it. */
+    register: (image: GalleryImage) => number;
+    unregister: (id: number) => void;
+    /** Opens the shared overlay on the entry with this id. */
+    activate: (id: number) => void;
+};
+export declare const ImageGalleryProvider: import("react").Provider<ImageGalleryContextValue | null>;
+/** The enclosing gallery, or null outside an `ImagePreviewGroup`. */
+export declare function useImageGallery(): ImageGalleryContextValue | null;
+export {};

package/dist/types/components/Image/ImagePreview.d.ts

@@ -1,4 +1,5 @@
 import type { ControlOrValue } from 'react-use-control';
+import type { GalleryImage } from './ImageGalleryContext.js';
 type ImagePreviewProps = {
     src: string;
     alt: string;
@@ -8,6 +9,19 @@ type ImagePreviewProps = {
     zoom?: boolean;
     /** The rotate control is available (default true). */
     rotate?: boolean;
+    /**
+     * Gallery entries, handed over by ImagePreviewGroup. Two or more
+     * switch the overlay into gallery mode: prev/next arrows flanking the
+     * image, an `n / total` counter in the toolbar, ArrowLeft/ArrowRight
+     * keys (wrap-around at both ends) and — unless `showThumbnails` is
+     * false — a keyboard-focusable thumbnail strip that stays in sync
+     * with the active entry.
+     */
+    images?: readonly GalleryImage[];
+    /** Active gallery entry, shared with the group (defaults to 0). */
+    index?: ControlOrValue<number>;
+    /** The thumbnail strip is rendered in gallery mode (default true). */
+    showThumbnails?: boolean;
 };
-export default function ImagePreview({ src, alt, open: openControl, zoom, rotate, }: ImagePreviewProps): import("react").JSX.Element;
+export default function ImagePreview({ src, alt, open: openControl, zoom, rotate, images, index: indexControl, showThumbnails, }: ImagePreviewProps): import("react").JSX.Element;
 export type { ImagePreviewProps };

package/dist/types/components/Image/ImagePreviewGroup.d.ts

@@ -0,0 +1,23 @@
+import type { ReactNode } from 'react';
+import type { ControlOrValue } from 'react-use-control';
+import type { ImagePreviewConfig } from './Image.js';
+type ImagePreviewGroupProps = {
+    children: ReactNode;
+    /**
+     * The gallery's active image. A plain number is the uncontrolled
+     * starting position; pass a control to drive navigation from the
+     * outside (thumbnail clicks, arrows and keys all commit through it).
+     */
+    index?: ControlOrValue<number>;
+    /**
+     * Shared overlay configuration, same shape as Image's `preview` prop:
+     * `true` (default) turns on every control, an object opts out per
+     * control (`zoom: false`, `rotate: false`), `false` disables the
+     * overlay for every child.
+     */
+    preview?: boolean | ImagePreviewConfig;
+    /** The thumbnail strip is rendered (default true). */
+    showThumbnails?: boolean;
+};
+export default function ImagePreviewGroup({ children, index: indexControl, preview, showThumbnails, }: ImagePreviewGroupProps): import("react").JSX.Element;
+export type { ImagePreviewGroupProps };

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

@@ -1,2 +1,4 @@
-export { default as Image } from './Image';
-export type { ImageProps, ImagePreviewConfig } from './Image';
+export { default as Image } from './Image.js';
+export { default as ImagePreviewGroup } from './ImagePreviewGroup.js';
+export type { ImageProps, ImagePreviewConfig } from './Image.js';
+export type { ImagePreviewGroupProps } from './ImagePreviewGroup.js';

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

@@ -0,0 +1,67 @@
+import type { ComponentPropsWithoutRef, Ref } from 'react';
+import type { ControlOrValue } from 'react-use-control';
+import type { CropRect } from './image-crop-geometry.js';
+/**
+ * Interactive image cropper — the avatar/photo companion to Upload.
+ *
+ * The source image is painted onto a `<canvas>` sized to its natural
+ * pixels (max detail; CSS scales it down), and the crop box is a DOM
+ * overlay positioned in percentages of the same box, so `value` needs no
+ * pixel measurement to render. `value` is the crop rectangle normalized
+ * to the image (every field 0..1) and fully controllable; every commit
+ * path (drag, handle resize, keyboard) runs through the same clamp
+ * pipeline, so an illegal rect can never display.
+ *
+ * Keyboard (the part competitors skip): the crop box is focusable and
+ * labeled. Arrow keys move it (1% of the image per press), Shift + arrow
+ * keys resize it — the Resizable handle's pointer-free contract in
+ * normalized space. A `visually-hidden` description announces the live
+ * geometry so screen readers track drags too.
+ *
+ * `ref.getCroppedCanvas()` rasterizes the current crop into a fresh
+ * `HTMLCanvasElement` (`null` when the image has not loaded or the 2d
+ * context is unavailable — jsdom without a mock). When the 2d context is
+ * unavailable the whole cropper degrades to a notice (Signature
+ * precedent): without paint there is no image to crop.
+ */
+type ImageCropProps = {
+    /** Image source URL. */
+    src: string;
+    /** Accessible name of the rendered image (carried by the canvas). */
+    alt: string;
+    /** Crop rectangle normalized to the image (every field 0..1); a
+     * Control receives every commit live, a plain object seeds it. */
+    value?: ControlOrValue<CropRect>;
+    /** Fires with the new normalized rect on every pointer frame and
+     * keyboard step. */
+    onChange?: (rect: CropRect) => void;
+    /** Locks the crop's pixel-space aspect ratio (width / height, e.g. `1`
+     * for avatars). Height derives from width; a rect that cannot fit
+     * refits from its height budget. */
+    aspect?: number;
+    /** Overlay mask of the crop box: rectangular frame or a full-radius
+     * circle for avatars (pair with `aspect={1}` for a true circle). */
+    shape?: 'rect' | 'circle';
+    /** Accessible label of the focusable crop region. */
+    cropLabel?: string;
+    /** Notice rendered when the canvas 2d context is unavailable. */
+    unsupportedLabel?: string;
+    /** Notice rendered when `src` fails to load. */
+    errorLabel?: string;
+    /** Locks dragging, handle resizing and keyboard operation. */
+    disabled?: boolean;
+    /** Passed to the loader `<img>`; `anonymous` is required for
+     * CORS-clean hosts or `getCroppedCanvas` output stays tainted. */
+    crossOrigin?: 'anonymous' | 'use-credentials';
+    className?: string;
+    ref?: Ref<ImageCropHandle>;
+} & Omit<ComponentPropsWithoutRef<'div'>, 'onChange'>;
+/** Imperative surface exposed through the component `ref`. */
+type ImageCropHandle = {
+    /** Fresh canvas holding the current crop at native pixel resolution,
+     * or `null` when the image has not loaded / 2d context is missing. */
+    getCroppedCanvas: () => HTMLCanvasElement | null;
+};
+export default function ImageCrop({ src, alt, value: valueControl, onChange, aspect, shape, cropLabel, unsupportedLabel, errorLabel, disabled, crossOrigin, className, ref, ...rest }: ImageCropProps): import("react").JSX.Element;
+export type { ImageCropProps, ImageCropHandle };
+export type { CropRect } from './image-crop-geometry.js';

package/dist/types/components/ImageCrop/image-crop-geometry.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Pure geometry for ImageCrop — every exported helper works in normalized
+ * space (0..1 relative to the image's own pixel box) so pointer, keyboard
+ * and aspect math share one clamp story. Unit tests exercise these
+ * directly (the signature-points precedent).
+ */
+/** Normalized crop rectangle: top-left corner (x, y) and size, every
+ * field 0..1 relative to the image's own pixel box. */
+export type CropRect = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+/** Natural pixel size of the loaded source image. */
+export type NaturalSize = {
+    width: number;
+    height: number;
+};
+/** Corner handles of the crop box. */
+export type CropCorner = 'nw' | 'ne' | 'sw' | 'se';
+/** Size floor for the crop box on both axes — a box smaller than this is
+ * no longer grabbable and crops to a degenerate image. */
+export declare const MIN_CROP = 0.05;
+/** Keyboard step for arrow keys: 1% of the image per press (the Resizable
+ * handle's fully-pointer-free contract, scaled to normalized space). */
+export declare const KEYBOARD_STEP = 0.01;
+/** Fit a rect to a locked pixel-space aspect ratio. Width drives; when
+ * the derived height overflows the unit square the height clamps to 1
+ * and the width re-derives from it. Position keeps x/y, clamped so the
+ * box stays inside the image. */
+export declare function fitAspect(rect: CropRect, aspect: number, natural: NaturalSize): CropRect;
+/** Clamp any rect into a legal crop: sizes into [MIN_CROP, 1] — with an
+ * aspect refit when the ratio is locked — and the position so the box
+ * stays inside the unit square. Display and every commit path run
+ * through this, so a stale or consumer-supplied value can never paint an
+ * illegal box. */
+export declare function normalizeRect(rect: CropRect, aspect: number | undefined, natural: NaturalSize): CropRect;
+/** Centered default crop covering 80% of the image (aspect-refit first —
+ * a square crop of a wide image saturates height before width, then the
+ * smaller box recenters). */
+export declare function defaultRect(aspect: number | undefined, natural: NaturalSize): CropRect;
+/** Translate by (dx, dy) — position clamps inside the image, size is
+ * frozen (the keyboard move contract). */
+export declare function moveRect(rect: CropRect, dx: number, dy: number): CropRect;
+/** Keyboard resize anchored at the top-left corner: dw/dh grow the box
+ * towards the right/bottom. With a locked aspect both axes drive the
+ * shared width (dh is translated through the aspect factor), so all four
+ * Shift+arrow keys stay functional. */
+export declare function resizeRect(rect: CropRect, dw: number, dh: number, aspect: number | undefined, natural: NaturalSize): CropRect;
+/** Corner-handle resize: the opposite corner stays anchored and the
+ * dragged corner follows the normalized pointer. Dragging across the
+ * anchor floors at MIN_CROP instead of inverting; a locked aspect fits
+ * width-first, clamped to the space the anchor leaves. */
+export declare function resizeFromAnchor(start: CropRect, corner: CropCorner, pointer: {
+    x: number;
+    y: number;
+}, aspect: number | undefined, natural: NaturalSize): CropRect;
+/** Frame-relative normalized pointer position from client coordinates.
+ * The width/height guards keep a zero-sized rect (jsdom, not-yet-laid-out
+ * frames) from producing NaN instead of merely useless numbers. */
+export declare function pointerToNormalized(clientX: number, clientY: number, frame: DOMRect): {
+    x: number;
+    y: number;
+};

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

@@ -0,0 +1,3 @@
+export { default as ImageCrop } from './ImageCrop.js';
+export type { ImageCropHandle, ImageCropProps } from './ImageCrop.js';
+export type { CropRect } from './image-crop-geometry.js';

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

@@ -1,2 +1,2 @@
-export { default as Indicator } from './Indicator';
-export type { IndicatorProps } from './Indicator';
+export { default as Indicator } from './Indicator.js';
+export type { IndicatorProps } from './Indicator.js';

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

@@ -0,0 +1,17 @@
+import type { ComponentPropsWithoutRef, ReactNode } from 'react';
+import type { ControlOrValue } from 'react-use-control';
+type InlineCitationProps = {
+    /** Citation number shown in the badge and card header. */
+    index?: number;
+    /** When present the card title becomes an external link (new tab). */
+    href?: string;
+    /** Source title rendered in the card; links out when `href` is set. */
+    title?: ReactNode;
+    /** Excerpt quoted from the source, rendered under the title. */
+    snippet?: ReactNode;
+    /** Controllable open state of the source card. */
+    open?: ControlOrValue<boolean>;
+    className?: string;
+} & Omit<ComponentPropsWithoutRef<'span'>, 'title' | 'children'>;
+export default function InlineCitation({ index, href, title, snippet, open: openControl, className, ...rest }: InlineCitationProps): import("react").JSX.Element;
+export type { InlineCitationProps };

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

@@ -0,0 +1,2 @@
+export { default as InlineCitation } from './InlineCitation.js';
+export type { InlineCitationProps } from './InlineCitation.js';

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

@@ -1,2 +1,2 @@
-export { default as InlineCompletion } from './InlineCompletion';
-export type { InlineCompletionProps } from './InlineCompletion';
+export { default as InlineCompletion } from './InlineCompletion.js';
+export type { InlineCompletionProps } from './InlineCompletion.js';

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

@@ -1,2 +1,2 @@
-export { default as InlineEdit } from './InlineEdit';
-export type { InlineEditProps } from './InlineEdit';
+export { default as InlineEdit } from './InlineEdit.js';
+export type { InlineEditProps } from './InlineEdit.js';

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

@@ -1,4 +1,4 @@
-export { default as Input } from './Input';
-export type { InputProps } from './Input';
-export { default as InputCore } from './InputCore';
-export type { InputCoreProps } from './InputCore';
+export { default as Input } from './Input.js';
+export type { InputProps } from './Input.js';
+export { default as InputCore } from './InputCore.js';
+export type { InputCoreProps } from './InputCore.js';

package/dist/types/components/Input/input-styles.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Shared Input size skin — the per-size padding/typography classes the
+ * `InputCore` component wears (the `Input` sugar delegates to it).
+ * Living in their own module keeps the component file free of style
+ * internals (react-refresh boundary) and lets the size map ship as a
+ * public constant for consumers and tests asserting the ConfigProvider
+ * `Input.size` tier (the shadcn `buttonVariants` / NumberInput
+ * `inputSizes` precedent); split-css groups the module with the Input
+ * family's css.
+ */
+export declare const sizes: {
+    readonly sm: import("@linaria/core").LinariaClassName;
+    readonly md: import("@linaria/core").LinariaClassName;
+    readonly lg: import("@linaria/core").LinariaClassName;
+};

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

@@ -0,0 +1,47 @@
+import type { ComponentPropsWithoutRef, ReactNode, Ref } from 'react';
+/**
+ * Semantic slot classes for InputGroup (AntD v6 `classNames` shape;
+ * keys follow the data-slot names). The `addon` slot is inherited by
+ * every InputGroupAddon child through context, so addons are re-skinned
+ * once on the group.
+ */
+type InputGroupClassNames = {
+    /** The wrapper (data-slot='input-group'). */
+    root?: string;
+    /** Every addon (data-slot='addon'). */
+    addon?: string;
+};
+type InputGroupOwnProps = {
+    /** Group-wide size: the size every child field that accepts one
+     * wears unless it sets its own, and the size the addons take —
+     * mirrors Input's steps so row edges align. */
+    size?: 'sm' | 'md' | 'lg';
+    /** Slot classes (see {@link InputGroupClassNames}); `addon` is
+     * inherited by InputGroupAddon children. */
+    classNames?: InputGroupClassNames;
+};
+type InputGroupProps = InputGroupOwnProps & {
+    /** The cluster's fields and addons — `Input`/`Select` children with
+     * `InputGroupAddon` (and optionally a trailing `Button`) around
+     * them. The group fills in `size` where a child leaves it unset;
+     * non-element nodes pass through untouched. */
+    children: ReactNode;
+    className?: string;
+    /** Forwarded to the wrapper `<div>` (data-slot='input-group'). */
+    ref?: Ref<HTMLDivElement>;
+} & Omit<ComponentPropsWithoutRef<'div'>, keyof InputGroupOwnProps | 'className' | 'children'>;
+/**
+ * A field cluster: prefix/suffix addons (`InputGroupAddon` — icon,
+ * text) hugging an `Input`, `Select` or textarea-based field, all
+ * merged into one attached control via CSS on the wrapper (corner
+ * radii and seam borders collapse positionally — children render
+ * as-authored). A trailing `Button` child attaches the same way, which
+ * is the classic search-box shape.
+ *
+ * The composition layer keeps zero state: the field's value stays
+ * controlled/uncontrolled exactly as the field itself defines it, and
+ * every part stays individually focusable with its own accessible
+ * name — label the field, not the wrapper.
+ */
+export default function InputGroup({ size, classNames, className, children, ref, ...rest }: InputGroupProps): import("react").JSX.Element;
+export type { InputGroupClassNames, InputGroupProps };

package/dist/types/components/InputGroup/InputGroupAddon.d.ts

@@ -0,0 +1,22 @@
+import type { ComponentPropsWithoutRef, ReactNode } from 'react';
+type InputGroupAddonProps = {
+    /** Addon content — an icon, a text prefix/suffix ("https://", a
+     * currency glyph), any inline node. Text stays in the accessibility
+     * tree: it is often the field's semantic prefix, so the addon is
+     * never aria-hidden as a whole; wrap purely decorative icons in
+     * aria-hidden yourself. */
+    children?: ReactNode;
+    /** Own size — defaults to the enclosing InputGroup's size. */
+    size?: 'sm' | 'md' | 'lg';
+    className?: string;
+} & Omit<ComponentPropsWithoutRef<'span'>, 'children' | 'size' | 'className'>;
+/**
+ * The tinted cell attached to a field's leading or trailing edge —
+ * placement is positional (render it before or after the field), and
+ * the group's merging rules round the outer corner and suppress the
+ * inner one on whichever side it lands. Non-interactive by design: it
+ * is a label surface, not a control; a clickable tail belongs in the
+ * group as a `Button` child.
+ */
+export default function InputGroupAddon({ children, size, className, ...rest }: InputGroupAddonProps): import("react").JSX.Element;
+export type { InputGroupAddonProps };

package/dist/types/components/InputGroup/InputGroupContext.d.ts

@@ -0,0 +1,21 @@
+/**
+ * What an InputGroup hands down to its subtree: the group's resolved
+ * `size` and the inherited `classNames.addon` slot. `InputGroupAddon`
+ * consumes it; field children (`Input`, `Select`, …) pick the size up
+ * through prop injection instead — they are not wired to this context.
+ */
+type InputGroupValue = {
+    size: 'sm' | 'md' | 'lg';
+    /** The group's `classNames.addon` slot, inherited by every
+     * InputGroupAddon child (TagGroup's item-slot precedent). */
+    addonClass?: string;
+};
+declare const InputGroupContext: import("react").Context<InputGroupValue | undefined>;
+declare const InputGroupProvider: import("react").Provider<InputGroupValue | undefined>;
+/**
+ * Reads the enclosing InputGroup's resolved size. Returns `undefined`
+ * outside a group (a standalone InputGroupAddon falls back to `md`).
+ */
+declare function useInputGroup(): InputGroupValue | undefined;
+export { InputGroupContext, InputGroupProvider, useInputGroup };
+export type { InputGroupValue };

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

@@ -0,0 +1,6 @@
+export { default as InputGroup } from './InputGroup.js';
+export type { InputGroupProps, InputGroupClassNames } from './InputGroup.js';
+export { default as InputGroupAddon } from './InputGroupAddon.js';
+export type { InputGroupAddonProps } from './InputGroupAddon.js';
+export { useInputGroup } from './InputGroupContext.js';
+export type { InputGroupValue } from './InputGroupContext.js';

package/dist/types/components/InputGroup/input-group-styles.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Shared InputGroup skin — the attached-field merging rules the group
+ * wrapper wears, plus the addon classes `InputGroupAddon` applies.
+ * Living in its own module keeps the component files free of style
+ * internals (react-refresh boundary); split-css groups the emitted CSS
+ * into `haze-ui/css/input-group.css`.
+ *
+ * ## Merging model
+ *
+ * Same recipe as ButtonGroup, applied to a field row: every child
+ * except the first loses its leading edge (a -1px margin pulls it over
+ * the previous child's trailing border and its leading border turns
+ * transparent, so exactly one 1px seam paints) and every child except
+ * the last loses its trailing corner radii. Addons therefore attach to
+ * `Input`/`Select`/`Button` children without either side knowing about
+ * the other — the children render as-authored.
+ *
+ * Sizing mirrors `InputCore`'s per-size paddings (see addonSizes), so
+ * an addon and the field it hugs are the same height at every step.
+ */
+export declare const group: import("@linaria/core").LinariaClassName;
+/**
+ * The addon surface: a tinted, bordered cell distinct from the field,
+ * sized by its own paddings (addonSizes) so text/icons align with the
+ * field's content box. Corner rounding is positional — the group's
+ * merging rules keep the outer edges rounded and suppress the inner
+ * ones, whatever side the addon sits on.
+ */
+export declare const addon: import("@linaria/core").LinariaClassName;
+export declare const addonSizes: {
+    readonly sm: import("@linaria/core").LinariaClassName;
+    readonly md: import("@linaria/core").LinariaClassName;
+    readonly lg: import("@linaria/core").LinariaClassName;
+};

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

@@ -1,2 +1,2 @@
-export { default as JsonView } from './JsonView';
-export type { JsonViewProps, MoreLabelFn } from './JsonView';
+export { default as JsonView } from './JsonView.js';
+export type { JsonViewProps, MoreLabelFn } from './JsonView.js';

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

@@ -1,6 +1,8 @@
-import type { ComponentPropsWithoutRef } from 'react';
+import type { ComponentPropsWithoutRef, Ref } from 'react';
 type KbdProps = {
     size?: 'sm' | 'md';
+    /** Forwarded to the root kbd element (data-slot='kbd'). */
+    ref?: Ref<HTMLElement>;
 } & Omit<ComponentPropsWithoutRef<'kbd'>, 'size'>;
-export default function Kbd({ size, className, ...rest }: KbdProps): import("react").JSX.Element;
+export default function Kbd({ size, className, ref, ...rest }: KbdProps): import("react").JSX.Element;
 export type { KbdProps };

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

@@ -1,2 +1,2 @@
-export { default as Kbd } from './Kbd';
-export type { KbdProps } from './Kbd';
+export { default as Kbd } from './Kbd.js';
+export type { KbdProps } from './Kbd.js';