@jfrader/ui 0.5.1 → 0.7.0

package/dist/{trigger-style-B1KVC8O1.js → trigger-style-CtOrdPk4.js}

@@ -1,5 +1,5 @@
 'use client';
-import { r as e } from "./sx-Dx9JUKp5.js";
+import { i as e } from "./css-BYJhdGh-.js";
 import { vars as t } from "@jfrader/tokens/vars";
 //#region src/styling/trigger-style.ts
 var n = e({

package/dist/types/components/activity-rings/activity-rings.d.ts

@@ -0,0 +1,113 @@
+import { type ComponentPropsWithoutRef, type ComponentPropsWithRef } from 'react';
+import { type Interpolation, type Theme } from '../../styling/css';
+import { type SxProps } from '../../styling/sx';
+export type ActivityTone = 'accent' | 'warning' | 'success' | 'info';
+export type ActivityRingsSize = 'sm' | 'md' | 'lg';
+export type ActivityValues = Readonly<Record<string, number | null>>;
+export interface ActivityMetric {
+    /** Stable, nonempty, unique identity. */
+    id: string;
+    label: string;
+    /** Positive target; nonpositive or nonfinite goals render the metric as unavailable. */
+    goal: number;
+    /** Unit supported by `Intl.NumberFormat` (`'kilometer'`, `'minute'`, `'hour'`, …); otherwise use `formatValue`. */
+    unit?: string;
+    tone?: ActivityTone;
+    /** Formats amounts for units Intl does not support. Use Intl in the formatter. */
+    formatValue?: (value: number, locale: string | undefined) => string;
+}
+export interface ActivityDay {
+    id: string;
+    /** Civil date, `YYYY-MM-DD`. */
+    date: string;
+    values: ActivityValues;
+}
+/** `open` is below goal, `closed` at or above it; `unknown` has no finite value. */
+export type ActivityRingStatus = 'unknown' | 'unavailable' | 'open' | 'closed';
+export interface ActivityRingsLabels {
+    /** Region name when no consumer name is given. */
+    root: string;
+    /** Day picker group label. */
+    days: string;
+    legend: string;
+    unknown: string;
+    unavailable: string;
+    goalMet: string;
+    noSelection: string;
+    empty: string;
+    amount: (value: string, goal: string) => string;
+    summary: (met: string, total: string) => string;
+}
+type PartElement = 'svg' | 'ul' | 'button' | 'div' | 'fieldset' | 'label' | 'p';
+export type ActivityRingsPartProps<T extends PartElement> = Omit<ComponentPropsWithoutRef<T>, 'children'> & {
+    css?: Interpolation<Theme>;
+};
+type DataSource = {
+    /** Standalone values when there is no day picker. */
+    values?: ActivityValues;
+    days?: never;
+} | {
+    /** Days win over standalone values; supplying both is a type error. */
+    days: readonly ActivityDay[];
+    values?: never;
+};
+interface ActivityRingsSlotProps {
+    rings?: ActivityRingsPartProps<'svg'>;
+    legend?: ActivityRingsPartProps<'ul'>;
+    dayPicker?: ActivityRingsPartProps<'fieldset'>;
+    dayLabel?: ActivityRingsPartProps<'label'>;
+    summary?: ActivityRingsPartProps<'p'>;
+}
+/** Metric slot props shared by the toggle-button and plain-row legend elements. */
+export type ActivityRingsMetricProps = Pick<ActivityRingsPartProps<'button'> & ActivityRingsPartProps<'div'>, keyof ActivityRingsPartProps<'button'> & keyof ActivityRingsPartProps<'div'>>;
+/**
+ * The metric slot targets a toggle button when `interactiveLegend` is `true`, or a row when false
+ * or omitted. A runtime boolean accepts only props shared by both elements.
+ */
+type LegendMode = {
+    /** Legend rows become toggle buttons that isolate one ring. */
+    interactiveLegend: true;
+    slotProps?: ActivityRingsSlotProps & {
+        metric?: ActivityRingsPartProps<'button'>;
+    };
+} | {
+    interactiveLegend?: false;
+    slotProps?: ActivityRingsSlotProps & {
+        metric?: ActivityRingsPartProps<'div'>;
+    };
+} | {
+    interactiveLegend?: boolean;
+    slotProps?: ActivityRingsSlotProps & {
+        metric?: ActivityRingsMetricProps;
+    };
+};
+export type ActivityRingsProps = Omit<ComponentPropsWithRef<'section'>, 'children' | 'defaultValue' | 'onChange'> & SxProps & DataSource & LegendMode & {
+    /** Rendered outside → inside. */
+    metrics: readonly ActivityMetric[];
+    /** Selected day id. A missing id renders the no-selection summary. */
+    value?: string | null;
+    /** Seeds the selected day once; defaults to the last day. */
+    defaultValue?: string | null;
+    onValueChange?: (dayId: string) => void;
+    focusedMetric?: string | null;
+    defaultFocusedMetric?: string | null;
+    onFocusedMetricChange?: (metricId: string | null) => void;
+    /** Fires once when a same-day value observed below its goal reaches it. */
+    onRingClose?: (metricId: string, dayId: string | null) => void;
+    size?: ActivityRingsSize;
+    locale?: string;
+    /** English defaults. */
+    labels?: Partial<ActivityRingsLabels>;
+    /** Keeps the legend for assistive tech while removing it visually. */
+    hideLegend?: boolean;
+};
+/**
+ * Compare each metric with its goal using the UsageMeter value rules. The SVG is decorative;
+ * the legend gives amounts, goals, and percentages. The optional day picker uses native radios
+ * with arrows and Home/End. Enable legend toggle buttons to isolate a ring with Enter/Space.
+ */
+export declare function ActivityRings({ ref, metrics, values: valuesProp, days: daysProp, value, defaultValue, onValueChange, focusedMetric, defaultFocusedMetric, onFocusedMetricChange, interactiveLegend, onRingClose, size, locale, labels: labelsProp, hideLegend, slotProps, className, sx, 'aria-label': ariaLabel, 'aria-labelledby': labelledBy, ...rest }: ActivityRingsProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export declare namespace ActivityRings {
+    var displayName: string;
+}
+export {};

package/dist/types/components/activity-rings/index.d.ts

@@ -0,0 +1,2 @@
+export { ActivityRings } from './activity-rings';
+export type { ActivityDay, ActivityMetric, ActivityRingStatus, ActivityRingsLabels, ActivityRingsMetricProps, ActivityRingsPartProps, ActivityRingsProps, ActivityRingsSize, ActivityTone, ActivityValues, } from './activity-rings';

package/dist/types/components/avatar-group/avatar-group.d.ts

@@ -14,7 +14,7 @@ export interface AvatarGroupPartProps {
     css?: Interpolation<Theme>;
 }
 export interface AvatarGroupProps extends Omit<ComponentPropsWithRef<'div'>, 'children' | 'role'>, SxProps {
-    /** Stable display order of people; immutable input. */
+    /** People in display order. Treat this array as immutable. */
     members: readonly AvatarGroupMember[];
     /** Maximum number of visible people; overflow does not consume a person slot. Defaults to 4. */
     max?: number;
@@ -22,7 +22,7 @@ export interface AvatarGroupProps extends Omit<ComponentPropsWithRef<'div'>, 'ch
     size?: AvatarSize;
     /** Fallback accessible name for the group landmark. Defaults to 'Team members'. */
     label?: string;
-    /** Locale for formatting count numerals; pin for deterministic SSR. Defaults to ambient Intl locale. */
+    /** Locale for counts. Set it for SSR; otherwise uses the environment's Intl locale. */
     locale?: Intl.LocalesArgument;
     /** Formats the accessible name of the overflow image. Defaults to English plural wording. */
     getOverflowLabel?: (hidden: number, formatted: string) => string;
@@ -34,7 +34,7 @@ export interface AvatarGroupProps extends Omit<ComponentPropsWithRef<'div'>, 'ch
         overflow?: AvatarGroupPartProps;
         summary?: AvatarGroupPartProps;
     };
-    /** Shared styling overrides passed down to each child Avatar. Cannot override id/name/status. */
+    /** Style overrides for each Avatar. Cannot override id/name/status. */
     avatarProps?: Pick<AvatarProps, 'slotProps' | 'sx' | 'className'>;
 }
 export declare function AvatarGroup({ ref, members, max, size, label, locale, getOverflowLabel, getSummaryLabel, slotProps, avatarProps, className, sx, ...rest }: AvatarGroupProps): import("@emotion/react/jsx-runtime").JSX.Element;

package/dist/types/components/billing-toggle/billing-toggle.d.ts

@@ -0,0 +1,57 @@
+import { type ComponentPropsWithRef, type ComponentPropsWithoutRef, type ReactNode } from 'react';
+import { type Interpolation, type Theme } from '../../styling/css';
+import { type SxProps } from '../../styling/sx';
+import { type SegmentedControlItemProps } from '../segmented-control';
+export type BillingToggleSize = 'md' | 'lg';
+export type BillingToggleTone = 'neutral' | 'accent' | 'success';
+type SlotProps<Element extends 'span' | 'del'> = ComponentPropsWithoutRef<Element> & {
+    css?: Interpolation<Theme>;
+};
+export interface BillingToggleProps extends Omit<ComponentPropsWithRef<'div'>, 'defaultValue' | 'onChange'>, SxProps {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    disabled?: boolean;
+    size?: BillingToggleSize;
+    tone?: BillingToggleTone;
+    locale?: Intl.LocalesArgument;
+}
+export interface BillingToggleListProps extends Omit<ComponentPropsWithRef<'div'>, 'defaultValue' | 'onChange'>, SxProps {
+}
+export interface BillingToggleLabelProps extends ComponentPropsWithRef<'span'>, SxProps {
+}
+export interface BillingToggleItemProps extends Omit<SegmentedControlItemProps, 'accessory'> {
+    badge?: ReactNode;
+    activeBadge?: ReactNode;
+    slotProps?: {
+        label?: SlotProps<'span'>;
+        badge?: SlotProps<'span'>;
+        selection?: SlotProps<'span'>;
+    };
+}
+export interface BillingTogglePriceProps extends Omit<ComponentPropsWithRef<'span'>, 'children'>, SxProps {
+    amount: number;
+    currency: string;
+    locale?: Intl.LocalesArgument;
+    formatOptions?: Omit<Intl.NumberFormatOptions, 'style' | 'currency'>;
+    was?: number;
+    period?: ReactNode;
+    previousLabel?: string;
+    slotProps?: {
+        amount?: SlotProps<'span'>;
+        previous?: SlotProps<'del'>;
+        period?: SlotProps<'span'>;
+    };
+}
+declare function BillingToggleRoot({ ref, value: valueProp, defaultValue, onValueChange, disabled, size, tone, locale, className, sx, children, ...rest }: BillingToggleProps): import("@emotion/react/jsx-runtime").JSX.Element;
+declare function BillingToggleLabel({ ref, id: idProp, className, sx, children, ...rest }: BillingToggleLabelProps): import("@emotion/react/jsx-runtime").JSX.Element | null;
+declare function BillingToggleList({ ref, className, sx, children, ...rest }: BillingToggleListProps): import("@emotion/react/jsx-runtime").JSX.Element;
+declare function BillingToggleItem({ badge, activeBadge, slotProps, children, className, sx, ...rest }: BillingToggleItemProps): import("@emotion/react/jsx-runtime").JSX.Element;
+declare function BillingTogglePrice({ ref, amount, currency, locale: localeProp, formatOptions, was, period, previousLabel, slotProps, className, sx, ...rest }: BillingTogglePriceProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export declare const BillingToggle: typeof BillingToggleRoot & {
+    List: typeof BillingToggleList;
+    Item: typeof BillingToggleItem;
+    Label: typeof BillingToggleLabel;
+    Price: typeof BillingTogglePrice;
+};
+export {};

package/dist/types/components/billing-toggle/index.d.ts

@@ -0,0 +1,2 @@
+export { BillingToggle } from './billing-toggle';
+export type { BillingToggleProps, BillingToggleListProps, BillingToggleItemProps, BillingToggleLabelProps, BillingTogglePriceProps, BillingToggleSize, BillingToggleTone, } from './billing-toggle';

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

@@ -20,15 +20,15 @@ export interface ButtonProps extends Omit<ComponentPropsWithRef<'button'>, 'colo
     /** Consumer style overrides, merged after the component's own styles. */
     css?: Interpolation<Theme>;
     /**
-     * Replaces the native button. Spread ALL supplied props onto the operative element and attach
-     * the supplied ref. Both that ref and the forwarded ref refer to the rendered element, which
-     * need not be a button; the public forwarded-ref type remains HTMLButtonElement for compatibility.
-     * Overridden handlers, className and style win; compose behavior manually to retain both:
+     * Replaces the native button. Spread all supplied props onto the element and attach the supplied
+     * ref. Both refs target that element, even when it is not a button. The public ref type remains
+     * HTMLButtonElement for compatibility.
+     * Your handlers, className, and style override the supplied ones. Compose handlers to keep both:
      * `onClick={(e) => { p.onClick?.(e); mine(e); }}`.
-     * Only this render path joins data-ui markers into a token list; library selectors should use
+     * This render path joins data-ui markers into a token list. Library selectors should use
      * `[data-ui~="button"]`. The default button always has data-ui="button".
-     * Disabled anchors receive aria-disabled and remain focusable. Primary click/Enter activation
-     * is blocked by the supplied handler; auxiliary/middle-click navigation is NOT covered.
+     * Disabled anchors receive aria-disabled and stay focusable. The supplied handler blocks primary
+     * click and Enter activation; it does not block auxiliary or middle-click navigation.
      */
     render?: (props: ButtonRenderProps) => ReactNode;
 }

package/dist/types/components/button-group/button-group.d.ts

@@ -0,0 +1,72 @@
+import { type ComponentPropsWithRef, type ReactNode } from 'react';
+import { type Placement } from '@floating-ui/react';
+import { type Interpolation, type Theme } from '../../styling/css';
+import { type SxProps } from '../../styling/sx';
+import { type ButtonProps, type ButtonSize, type ButtonTone, type ButtonVariant } from '../button';
+import { type MenuContentProps, type MenuItemProps, type MenuSeparatorProps, type MenuItemTone } from '../menu/menu';
+export type ButtonGroupOrientation = 'horizontal' | 'vertical';
+export interface ButtonGroupProps extends Omit<ComponentPropsWithRef<'div'>, 'role'>, SxProps {
+    variant?: ButtonVariant;
+    tone?: ButtonTone;
+    size?: ButtonSize;
+    orientation?: ButtonGroupOrientation;
+    collapseLabels?: boolean;
+    disabled?: boolean;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    placement?: Placement;
+}
+export interface ButtonGroupItemProps extends Omit<ButtonProps, 'render'> {
+    iconOnly?: boolean;
+    label?: string;
+    reserveLabels?: readonly string[];
+}
+export interface ButtonGroupLinkProps extends Omit<ComponentPropsWithRef<'a'>, 'color'>, SxProps {
+    href: string;
+    css?: Interpolation<Theme>;
+    disabled?: boolean;
+    variant?: ButtonVariant;
+    tone?: ButtonTone;
+    size?: ButtonSize;
+    iconOnly?: boolean;
+    label?: string;
+    startIcon?: ReactNode;
+    reserveLabels?: readonly string[];
+}
+export interface ButtonGroupLabelProps extends Omit<ComponentPropsWithRef<'span'>, 'role' | 'tabIndex'>, SxProps {
+    css?: Interpolation<Theme>;
+}
+export type ButtonGroupTriggerProps = Omit<ButtonGroupItemProps, 'loading' | 'reserveLabels' | 'iconOnly'> & ({
+    'aria-label': string;
+} | {
+    'aria-labelledby': string;
+});
+export interface ButtonGroupContentProps extends Omit<MenuContentProps, 'role'> {
+    css?: Interpolation<Theme>;
+}
+export interface ButtonGroupMenuItemProps extends MenuItemProps {
+    tone?: MenuItemTone;
+    css?: Interpolation<Theme>;
+}
+export interface ButtonGroupSeparatorProps extends MenuSeparatorProps {
+    css?: Interpolation<Theme>;
+}
+declare function ButtonGroupRoot({ ref, variant, tone, size, orientation, collapseLabels, disabled, open, defaultOpen, onOpenChange, placement, children, className, sx, onKeyDown, onPointerOver, onPointerLeave, onPointerCancel, onFocus, onBlur, ...rest }: ButtonGroupProps): import("@emotion/react/jsx-runtime").JSX.Element;
+declare function ButtonGroupItem({ ref, variant, tone, size, disabled, iconOnly, label, reserveLabels, children, startIcon, endIcon, css: cssProp, sx, ...rest }: ButtonGroupItemProps): import("@emotion/react/jsx-runtime").JSX.Element;
+declare function ButtonGroupLink({ ref, href, disabled, variant, tone, size, iconOnly, label, startIcon, reserveLabels, children, className, css: cssProp, sx, onClick, onAuxClick, onKeyDown, ...rest }: ButtonGroupLinkProps): import("@emotion/react/jsx-runtime").JSX.Element;
+declare function ButtonGroupLabel({ className, sx, ...props }: ButtonGroupLabelProps): import("@emotion/react/jsx-runtime").JSX.Element;
+declare function ButtonGroupTrigger({ ref, variant, tone, size, disabled, children, startIcon, endIcon, css: cssProp, sx, ...rest }: ButtonGroupTriggerProps): import("@emotion/react/jsx-runtime").JSX.Element;
+declare function ButtonGroupContent({ dir, 'aria-labelledby': labelledBy, ...props }: ButtonGroupContentProps): import("@emotion/react/jsx-runtime").JSX.Element;
+declare function ButtonGroupMenuItem({ tone, disabled, onClick, onSelect, ...props }: ButtonGroupMenuItemProps): import("@emotion/react/jsx-runtime").JSX.Element;
+declare function ButtonGroupSeparator(props: ButtonGroupSeparatorProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export declare const ButtonGroup: typeof ButtonGroupRoot & {
+    Item: typeof ButtonGroupItem;
+    Link: typeof ButtonGroupLink;
+    Label: typeof ButtonGroupLabel;
+    Trigger: typeof ButtonGroupTrigger;
+    Content: typeof ButtonGroupContent;
+    MenuItem: typeof ButtonGroupMenuItem;
+    Separator: typeof ButtonGroupSeparator;
+};
+export {};

package/dist/types/components/button-group/index.d.ts

@@ -0,0 +1,2 @@
+export { ButtonGroup } from './button-group';
+export type { ButtonGroupProps, ButtonGroupOrientation, ButtonGroupItemProps, ButtonGroupLinkProps, ButtonGroupLabelProps, ButtonGroupTriggerProps, ButtonGroupContentProps, ButtonGroupMenuItemProps, ButtonGroupSeparatorProps, } from './button-group';

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

@@ -1,5 +1,6 @@
 import { type ComponentPropsWithRef } from 'react';
 import { type Interpolation, type Theme } from '../../styling/css';
+import { type SurfaceAppearance } from '../../styling/surface';
 import { type SxProps } from '../../styling/sx';
 export type CardVariant = 'flat' | 'raised';
 export type CardHeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
@@ -17,6 +18,11 @@ export interface CardSlotProps {
 }
 export interface CardProps extends ComponentPropsWithRef<'div'>, SxProps {
     variant?: CardVariant;
+    /**
+     * `contrast` uses the dark palette with a charcoal surface on any page theme.
+     * Omit this prop or use `default` to keep the enclosing theme.
+     */
+    appearance?: SurfaceAppearance;
     slotProps?: CardSlotProps;
 }
 export type CardHeaderProps = ComponentPropsWithRef<'div'> & SxProps;
@@ -26,7 +32,7 @@ export interface CardTitleProps extends ComponentPropsWithRef<'h3'>, SxProps {
 export type CardDescriptionProps = ComponentPropsWithRef<'p'> & SxProps;
 export type CardContentProps = ComponentPropsWithRef<'div'> & SxProps;
 export type CardFooterProps = ComponentPropsWithRef<'div'> & SxProps;
-declare function CardRoot({ ref, variant, slotProps, className, sx, ...rest }: CardProps): import("@emotion/react/jsx-runtime").JSX.Element;
+declare function CardRoot({ ref, variant, appearance, slotProps, className, style, sx, ...rest }: CardProps): import("@emotion/react/jsx-runtime").JSX.Element;
 declare function CardHeader({ ref, className, sx, ...rest }: CardHeaderProps): import("@emotion/react/jsx-runtime").JSX.Element;
 declare function CardTitle({ ref, level, className, sx, ...rest }: CardTitleProps): import("@emotion/react/jsx-runtime").JSX.Element;
 declare function CardDescription({ ref, className, sx, ...rest }: CardDescriptionProps): import("@emotion/react/jsx-runtime").JSX.Element;

package/dist/types/components/chat-thread/chat-thread.d.ts

@@ -0,0 +1,130 @@
+import { type ComponentPropsWithRef } from 'react';
+import { type SxProps } from '../../styling/sx';
+import { type ThreadAuthor, type ThreadTimestamp } from '../thread/thread-core';
+import { type ThreadButtonProps, type ThreadPartProps, type ThreadReactionLabels, type ThreadSize, type ThreadTextareaProps } from '../thread/thread-parts';
+export type ChatParticipant = ThreadAuthor;
+export type ChatThreadSize = ThreadSize;
+export type ChatMessageStatus = 'sending' | 'sent' | 'delivered' | 'read' | 'failed';
+export interface ChatAttachment {
+    id: string;
+    name: string;
+    kind: 'image' | 'file';
+    url?: string;
+    size?: number;
+    width?: number;
+    height?: number;
+    alt?: string;
+}
+export interface ChatReaction {
+    emoji: string;
+    count: number;
+    mine?: boolean;
+}
+export interface ChatMessage {
+    id: string;
+    authorId: string;
+    text?: string;
+    createdAt: ThreadTimestamp;
+    attachments?: readonly ChatAttachment[];
+    reactions?: readonly ChatReaction[];
+    status?: ChatMessageStatus;
+}
+export interface ChatDraft {
+    text: string;
+    files: File[];
+}
+export type ChatThreadEvent = {
+    type: 'send';
+    message: ChatMessage;
+    draft: ChatDraft;
+} | {
+    type: 'react';
+    id: string;
+    emoji: string;
+    added: boolean;
+};
+export interface ChatThreadLabels extends ThreadReactionLabels {
+    conversation: string;
+    transcript: string;
+    composer: string;
+    placeholder: string;
+    send: string;
+    attach: string;
+    attachments: string;
+    sending: string;
+    sent: string;
+    delivered: string;
+    read: string;
+    failed: string;
+    retry: string;
+    jumpToLatest: string;
+    unknownAuthor: string;
+    empty: string;
+    invalidTime: string;
+    sendFailed: string;
+    removeFile: (name: string) => string;
+    readBy: (names: string) => string;
+    typing: (names: string) => string;
+    newMessages: (count: number) => string;
+    showAttachments: (count: number) => string;
+    fileRejected: (reason: 'type' | 'size' | 'count', name: string) => string;
+}
+type ChatThreadPart = 'viewport' | 'scroller' | 'log' | 'list' | 'message' | 'bubble' | 'time' | 'attachments' | 'receipt' | 'reaction';
+export type ChatThreadSlotProps = Partial<Record<ChatThreadPart, ThreadPartProps>> & {
+    jumpButton?: ThreadButtonProps;
+};
+export type ChatThreadComposerSlotProps = Partial<Record<'tray' | 'file' | 'error', ThreadPartProps>> & {
+    form?: ComponentPropsWithRef<'form'>;
+    textarea?: ThreadTextareaProps;
+    attachButton?: ThreadButtonProps;
+    fileInput?: Omit<ComponentPropsWithRef<'input'>, 'type' | 'multiple' | 'accept' | 'disabled'>;
+    removeButton?: ThreadButtonProps;
+    sendButton?: ThreadButtonProps;
+};
+export interface ChatThreadComposerProps extends Omit<ComponentPropsWithRef<'div'>, 'defaultValue' | 'onChange' | 'children'>, SxProps {
+    value?: ChatDraft;
+    defaultValue?: ChatDraft;
+    onValueChange?: (draft: ChatDraft) => void;
+    onSend: (draft: ChatDraft) => void | Promise<void>;
+    allowAttachments?: boolean;
+    accept?: string;
+    maxFiles?: number;
+    maxFileSize?: number;
+    disabled?: boolean;
+    placeholder?: string;
+    label?: string;
+    locale?: Intl.LocalesArgument;
+    size?: ChatThreadSize;
+    labels?: Partial<ChatThreadLabels>;
+    slotProps?: ChatThreadComposerSlotProps;
+}
+export interface ChatThreadProps extends Omit<ComponentPropsWithRef<'div'>, 'defaultValue' | 'onChange' | 'children'>, SxProps {
+    participants: readonly ChatParticipant[];
+    currentUserId: string;
+    value?: readonly ChatMessage[];
+    defaultValue?: readonly ChatMessage[];
+    onValueChange?: (next: ChatMessage[], event: ChatThreadEvent) => void;
+    now: number;
+    locale?: Intl.LocalesArgument;
+    timeZone?: string;
+    typing?: readonly string[];
+    readBy?: Readonly<Record<string, string>>;
+    onSend?: (draft: ChatDraft) => void | Promise<void>;
+    onReact?: (id: string, emoji: string) => void;
+    onRetry?: (id: string) => void | Promise<void>;
+    reactions?: readonly string[];
+    groupWindow?: number;
+    composer?: boolean;
+    disabled?: boolean;
+    composerProps?: Omit<ChatThreadComposerProps, 'onSend'>;
+    getNewId?: () => string;
+    size?: ChatThreadSize;
+    labels?: Partial<ChatThreadLabels>;
+    slotProps?: ChatThreadSlotProps;
+}
+declare function Composer(props: ChatThreadComposerProps): import("@emotion/react/jsx-runtime").JSX.Element;
+declare function ChatThreadRoot({ ref, participants, currentUserId, value, defaultValue, onValueChange, now, locale, timeZone, typing, readBy, onSend, onReact, onRetry, reactions, groupWindow, composer, disabled, composerProps, getNewId, size, labels: labelProps, slotProps, className, sx, ...rest }: ChatThreadProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export declare const ChatThread: typeof ChatThreadRoot & {
+    Composer: typeof Composer;
+};
+export {};

package/dist/types/components/chat-thread/index.d.ts

@@ -0,0 +1,2 @@
+export { ChatThread } from './chat-thread';
+export type { ChatAttachment, ChatDraft, ChatMessage, ChatMessageStatus, ChatParticipant, ChatReaction, ChatThreadComposerProps, ChatThreadComposerSlotProps, ChatThreadEvent, ChatThreadLabels, ChatThreadProps, ChatThreadSize, ChatThreadSlotProps, } from './chat-thread';

package/dist/types/components/chip-group/chip-group.d.ts

@@ -45,8 +45,8 @@ export interface ChipGroupMultipleProps extends ChipGroupBaseProps {
     onValueChange?: (value: string[]) => void;
 }
 export type ChipGroupProps = ChipGroupSingleProps | ChipGroupMultipleProps;
-/** Clearable pressed-button filters. Arrows (horizontal RTL-aware), Home/End move focus only;
- * Enter/Space toggle. Multiple values are emitted in option order, not activation order. */
+/** Choose and clear filters. Arrows and Home/End move focus; horizontal arrows reverse in RTL.
+ * Enter/Space toggle selection. Multiple values are reported in option order. */
 export declare function ChipGroup({ ref, options, type, value: valueProp, defaultValue, onValueChange, label, allowEmpty, disabled, size, maxVisible, expanded: expandedProp, defaultExpanded, onExpandedChange, locale, moreLabel, lessLabel, slotProps, className, sx, onKeyDown, onBlur, 'aria-label': ariaLabel, 'aria-labelledby': ariaLabelledBy, ...rest }: ChipGroupProps): import("@emotion/react/jsx-runtime").JSX.Element;
 export declare namespace ChipGroup {
     var displayName: string;

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

@@ -12,14 +12,14 @@ export interface ComboboxProps {
     onOpenChange?: (open: boolean) => void;
     /** Renders a hidden input so the value takes part in native form submission. */
     name?: string;
-    /** Decides whether an option label matches the typed query. Defaults to a case-insensitive substring match. */
+    /** Matches an option label to the query. Defaults to a case-insensitive substring match. */
     filter?: (label: string, query: string) => boolean;
     /** Fires with the new input text when the user types and when a selection or Escape writes a label. */
     onInputChange?: (query: string) => void;
     children?: ReactNode;
 }
 export interface ComboboxInputProps extends Omit<TextFieldProps, 'value' | 'defaultValue' | 'onValueChange'> {
-    /** Root `name` is the canonical form name; an Input `name` submits an extra text entry. */
+    /** Root `name` submits the selected value. Input `name` submits an extra text entry. */
     name?: string;
     /** Controlled input text. */
     inputValue?: string;

package/dist/types/components/command-palette/command-palette.d.ts

@@ -6,7 +6,7 @@ export interface CommandPaletteProps {
     onOpenChange?: (open: boolean) => void;
     /** Accessible name of the dialog, input and listbox. */
     label?: string;
-    /** Decides whether an item's label (or keywords) matches the query. Case-insensitive substring by default. */
+    /** Matches an item's label or keywords to the query. Defaults to a case-insensitive substring match. */
     filter?: (text: string, query: string) => boolean;
     /** Rendered by CommandPalette.Empty when nothing matches. */
     emptyMessage?: ReactNode;

package/dist/types/components/comment-thread/comment-thread.d.ts

@@ -1,14 +1,14 @@
 import { type ComponentPropsWithRef, type ReactNode } from 'react';
 import { type SxProps } from '../../styling/sx';
-import { type ThreadAuthor, type ThreadComment, type ThreadReaction } from './thread-core';
-import { type ThreadButtonProps, type ThreadPartProps, type ThreadReactionLabels, type ThreadSize, type ThreadTextareaProps } from './thread-parts';
-export type { ThreadComment } from './thread-core';
+import { type ThreadAuthor, type ThreadComment, type ThreadReaction } from '../thread/thread-core';
+import { type ThreadButtonProps, type ThreadPartProps, type ThreadReactionLabels, type ThreadSize, type ThreadTextareaProps } from '../thread/thread-parts';
+export type { ThreadComment } from '../thread/thread-core';
 export type CommentAuthor = ThreadAuthor;
 export type CommentReaction = ThreadReaction;
 export type CommentThreadSize = ThreadSize;
 export type CommentThreadHeadingLevel = 2 | 3 | 4 | 5 | 6;
 export type CommentThreadPartProps = ThreadPartProps;
-/** What a proposed tree changes; `parentId` is where a reply actually attached after `maxDepth`. */
+/** Describes a proposed change. `parentId` is the reply's attachment point after applying `maxDepth`. */
 export type CommentThreadEvent = {
     type: 'reply';
     comment: ThreadComment;
@@ -65,9 +65,9 @@ export interface CommentThreadLabels extends ThreadReactionLabels {
 }
 type CommentThreadPart = 'header' | 'title' | 'list' | 'item' | 'article' | 'time' | 'body' | 'replies' | 'actions' | 'reaction' | 'composer' | 'resolved' | 'status';
 export type CommentThreadSlotProps = Partial<Record<CommentThreadPart, CommentThreadPartProps>> & {
-    /** Extra Textarea props for every composer and editor; handlers are composed with the thread's. */
+    /** Textarea props for every composer and editor. Handlers are combined with the thread's handlers. */
     textarea?: ThreadTextareaProps;
-    /** Extra Button props for every Send/Save button; `onClick` runs first and may `preventDefault()`. */
+    /** Button props for Send/Save. `onClick` runs first and can call `preventDefault()`. */
     send?: ThreadButtonProps;
 };
 export interface CommentThreadProps extends Omit<ComponentPropsWithRef<'section'>, 'defaultValue' | 'onChange' | 'children' | 'title'>, SxProps {
@@ -76,7 +76,7 @@ export interface CommentThreadProps extends Omit<ComponentPropsWithRef<'section'
     defaultValue?: readonly ThreadComment[];
     /** The full proposed tree plus what changed. */
     onValueChange?: (next: ThreadComment[], event: CommentThreadEvent) => void;
-    /** Whose comments are editable; authorization stays on the server. */
+    /** Determines whose comments can be edited. Enforce authorization on the server. */
     currentUser: CommentAuthor;
     /** Mention candidates; defaults to every author plus `currentUser`. Deduped by id. */
     people?: readonly CommentAuthor[];

package/dist/types/components/copy-button/copy-button.d.ts

@@ -15,17 +15,17 @@ export interface CopyButtonSlotProps {
 export interface CopyButtonProps extends Omit<ComponentPropsWithRef<'button'>, 'children' | 'value' | 'defaultValue' | 'color' | 'type'>, SxProps {
     /** The string written to the clipboard. An empty string is a valid payload. */
     text: string;
-    /** Accessible name and idle face, e.g. "Copy command". */
+    /** Accessible name and label while idle, e.g. "Copy command". */
     label: string;
-    /** Face and announcement while the write is in flight. */
+    /** Label and announcement while copying. */
     pendingLabel: string;
-    /** Face and announcement after a successful write. */
+    /** Label and announcement after copying succeeds. */
     copiedLabel: string;
-    /** Face and announcement after a failed or unavailable write. */
+    /** Label and announcement when copying fails or is unavailable. */
     errorLabel: string;
     /** Hides the visible label; the accessible name and announcements stay. */
     iconOnly?: boolean;
-    /** Decorative icon per face; a supplied key replaces the default, including `null` for none. */
+    /** Icon for each state. A supplied key replaces the default; `null` removes it. */
     icons?: CopyButtonIcons;
     value?: CopyButtonValue;
     defaultValue?: CopyButtonValue;
@@ -34,7 +34,7 @@ export interface CopyButtonProps extends Omit<ComponentPropsWithRef<'button'>, '
     onCopied?: (text: string) => void;
     /** Called once per failed write, including a missing Clipboard API. */
     onCopyError?: (error: unknown) => void;
-    /** Milliseconds before `copied`/`error` request `idle`; 0 keeps the result face. */
+    /** Milliseconds before `copied`/`error` request `idle`; 0 keeps the result label. */
     resetAfterMs?: number;
     variant?: ButtonVariant;
     tone?: ButtonTone;

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

@@ -20,7 +20,7 @@ export interface CountdownProps extends Omit<ComponentPropsWithRef<'div'>, 'chil
     pendingLabel?: ReactNode;
     invalidLabel?: ReactNode;
     invalidText?: string;
-    /** Authoritative epoch-ms source. Background callbacks run at the first executable wake-up. */
+    /** Clock source in epoch milliseconds. Background callbacks run when execution next becomes possible. */
     clock?: () => number;
     /** Shared server snapshot for identical SSR and hydration output. */
     initialNow?: number;
@@ -30,7 +30,7 @@ export interface CountdownProps extends Omit<ComponentPropsWithRef<'div'>, 'chil
     completionIcon?: ReactNode;
     slotProps?: Partial<Record<'label' | 'content' | 'unit' | 'number' | 'complete' | 'icon' | 'description', CountdownPartProps>>;
 }
-/** Noninteractive ARIA timer. Tab and every other key pass through; no focus or editable state. */
+/** Show an ARIA timer without controls. Tab and other keys pass through; it cannot be focused or edited. */
 export declare function Countdown({ ref, target, variant, units, label, locale, unitDisplay, completeLabel, completeText, pendingLabel, invalidLabel, invalidText, clock, initialNow, onComplete, announceCompletion, completionIcon, slotProps, className, sx, 'aria-labelledby': externalLabel, 'aria-describedby': externalDescription, 'aria-label': ariaLabel, ...rest }: CountdownProps): import("@emotion/react/jsx-runtime").JSX.Element;
 export declare namespace Countdown {
     var displayName: string;