@jfrader/ui 0.5.0 → 0.6.0

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

@@ -0,0 +1,118 @@
+import { type ComponentPropsWithRef, type ReactNode } from 'react';
+import { type SxProps } from '../../styling/sx';
+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`. */
+export type CommentThreadEvent = {
+    type: 'reply';
+    comment: ThreadComment;
+    parentId: string | null;
+} | {
+    type: 'edit';
+    id: string;
+    body: string;
+} | {
+    type: 'delete';
+    id: string;
+} | {
+    type: 'react';
+    id: string;
+    emoji: string;
+    added: boolean;
+};
+export interface CommentThreadLabels extends ThreadReactionLabels {
+    /** Region name when there is no `title`, `aria-label` or `aria-labelledby`. */
+    thread: string;
+    /** Accessible name of the new-comment field. */
+    composer: string;
+    placeholder: string;
+    resolve: string;
+    resolved: string;
+    reopen: string;
+    empty: string;
+    reply: string;
+    edit: string;
+    delete: string;
+    cancel: string;
+    send: string;
+    save: string;
+    edited: string;
+    /** Accessible name of the edit field. */
+    editComment: string;
+    /** Prompt that names the inline delete confirmation. */
+    deleteConfirm: string;
+    deletedText: string;
+    /** Name of a deleted comment's article. */
+    deletedComment: string;
+    hideReplies: string;
+    cancelReply: string;
+    /** Name of the mention suggestions list. */
+    mentions: string;
+    invalidTime: string;
+    /** Accessible name of a reply field. */
+    replyingTo: (name: string) => string;
+    showReplies: (count: number) => string;
+    commentCount: (count: number) => string;
+    peopleCount: (count: number) => string;
+    /** Announced when comments from others arrive. */
+    newComments: (count: number) => string;
+}
+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?: ThreadTextareaProps;
+    /** Extra Button props for every Send/Save button; `onClick` runs first and may `preventDefault()`. */
+    send?: ThreadButtonProps;
+};
+export interface CommentThreadProps extends Omit<ComponentPropsWithRef<'section'>, 'defaultValue' | 'onChange' | 'children' | 'title'>, SxProps {
+    /** Comment tree (controlled). Treated as immutable. */
+    value?: readonly ThreadComment[];
+    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. */
+    currentUser: CommentAuthor;
+    /** Mention candidates; defaults to every author plus `currentUser`. Deduped by id. */
+    people?: readonly CommentAuthor[];
+    resolvedValue?: boolean;
+    defaultResolvedValue?: boolean;
+    onResolvedValueChange?: (resolved: boolean) => void;
+    /** Ids whose replies are shown (controlled). */
+    expandedValue?: readonly string[];
+    /** Defaults to every comment that has replies at first render. */
+    defaultExpandedValue?: readonly string[];
+    onExpandedValueChange?: (ids: string[]) => void;
+    title?: ReactNode;
+    headingLevel?: CommentThreadHeadingLevel;
+    /** Emoji offered by the picker, deduped; `[]` removes the picker. */
+    reactions?: readonly string[];
+    /** Maximum reply edges below a root comment; deeper replies attach to the deepest allowed ancestor. */
+    maxDepth?: number;
+    /** Reference instant in epoch ms for relative times. Pass the same value on server and client. */
+    now: number;
+    locale?: Intl.LocalesArgument;
+    /** IANA zone for full dates. */
+    timeZone?: string;
+    /** Id for a newly submitted comment; called once per accepted submit interaction. */
+    getNewId?: () => string;
+    placeholder?: string;
+    /** Accessible name of the new-comment field; defaults to `labels.composer`. */
+    composerLabel?: string;
+    /** Blocks every mutation. */
+    disabled?: boolean;
+    /** Hides mutation controls; reply disclosure still works. */
+    readOnly?: boolean;
+    size?: CommentThreadSize;
+    labels?: Partial<CommentThreadLabels>;
+    slotProps?: CommentThreadSlotProps;
+}
+export declare function CommentThread({ ref, value, defaultValue, onValueChange, currentUser, people: peopleProp, resolvedValue, defaultResolvedValue, onResolvedValueChange, expandedValue, defaultExpandedValue, onExpandedValueChange, title, headingLevel, reactions: offeredProp, maxDepth: maxDepthProp, now, locale, timeZone, getNewId, placeholder, composerLabel, disabled, readOnly, size, labels: labelProps, slotProps, className, sx, onFocus, onBlur, 'aria-label': ariaLabel, 'aria-labelledby': ariaLabelledBy, 'aria-describedby': ariaDescribedBy, ...rest }: CommentThreadProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export declare namespace CommentThread {
+    var displayName: string;
+}

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

@@ -0,0 +1 @@
+export { CommentThread, type CommentAuthor, type CommentReaction, type CommentThreadEvent, type CommentThreadHeadingLevel, type CommentThreadLabels, type CommentThreadPartProps, type CommentThreadProps, type CommentThreadSize, type CommentThreadSlotProps, type ThreadComment, } from './comment-thread';

package/dist/types/components/context-menu/context-menu.d.ts

@@ -0,0 +1,55 @@
+import { type ComponentPropsWithRef, type ReactNode } from 'react';
+import { type SxProps } from '../../styling/sx';
+import { type MenuItemTone } from '../menu/menu';
+export type ContextMenuItemTone = MenuItemTone;
+export interface ContextMenuProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children?: ReactNode;
+}
+export interface ContextMenuTargetProps extends ComponentPropsWithRef<'div'>, SxProps {
+    /** Also open on a plain click or tap (and Enter/Space on the Target). Only for inert objects:
+     * interactive children would lose their own click. */
+    openOnClick?: boolean;
+    /** Leave the browser's native context menu alone. */
+    disabled?: boolean;
+}
+export interface ContextMenuTriggerProps extends ComponentPropsWithRef<'button'>, SxProps {
+}
+export interface ContextMenuContentProps extends ComponentPropsWithRef<'div'>, SxProps {
+}
+export interface ContextMenuItemProps extends Omit<ComponentPropsWithRef<'button'>, 'onSelect'>, SxProps {
+    /** Called once when the item is activated. The menu then closes unless a click handler called
+     * `event.preventDefault()`. */
+    onSelect?: () => void;
+    disabled?: boolean;
+    tone?: ContextMenuItemTone;
+    /** Decorative icon before the label. */
+    icon?: ReactNode;
+}
+export interface ContextMenuCheckboxItemProps extends Omit<ContextMenuItemProps, 'value' | 'defaultValue'> {
+    value?: boolean;
+    defaultValue?: boolean;
+    onValueChange?: (checked: boolean) => void;
+    /** Close the menu after toggling. Off by default so several options can be toggled in a row. */
+    closeOnSelect?: boolean;
+}
+export interface ContextMenuSeparatorProps extends ComponentPropsWithRef<'div'>, SxProps {
+}
+declare function ContextMenuRoot({ open, defaultOpen, onOpenChange, children }: ContextMenuProps): import("@emotion/react/jsx-runtime").JSX.Element;
+declare function ContextMenuTarget({ ref, id, openOnClick, disabled, 'aria-labelledby': ariaLabelledBy, className, sx, ...rest }: ContextMenuTargetProps): import("@emotion/react/jsx-runtime").JSX.Element;
+declare function ContextMenuTrigger({ ref, id, className, sx, ...rest }: ContextMenuTriggerProps): import("@emotion/react/jsx-runtime").JSX.Element;
+declare function ContextMenuContent({ ref, style, dir, onKeyDown, ...props }: ContextMenuContentProps): import("@emotion/react/jsx-runtime").JSX.Element;
+declare function ContextMenuItem({ tone, icon, children, ...props }: ContextMenuItemProps): import("@emotion/react/jsx-runtime").JSX.Element;
+declare function ContextMenuCheckboxItem({ value, defaultValue, onValueChange, onSelect, closeOnSelect, tone, icon, children, ...props }: ContextMenuCheckboxItemProps): import("@emotion/react/jsx-runtime").JSX.Element;
+declare function ContextMenuSeparator(props: ContextMenuSeparatorProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export declare const ContextMenu: typeof ContextMenuRoot & {
+    Target: typeof ContextMenuTarget;
+    Trigger: typeof ContextMenuTrigger;
+    Content: typeof ContextMenuContent;
+    Item: typeof ContextMenuItem;
+    CheckboxItem: typeof ContextMenuCheckboxItem;
+    Separator: typeof ContextMenuSeparator;
+};
+export {};

package/dist/types/components/context-menu/index.d.ts

@@ -0,0 +1,2 @@
+export { ContextMenu } from './context-menu';
+export type { ContextMenuCheckboxItemProps, ContextMenuContentProps, ContextMenuItemProps, ContextMenuItemTone, ContextMenuProps, ContextMenuSeparatorProps, ContextMenuTargetProps, ContextMenuTriggerProps, } from './context-menu';

package/dist/types/components/date-range-picker/date-range-picker.d.ts

@@ -94,7 +94,7 @@ export interface DateRangePickerContentProps extends Omit<ComponentPropsWithRef<
     };
 }
 declare function DateRangePickerRoot(props: DateRangePickerProps): import("@emotion/react/jsx-runtime").JSX.Element;
-declare function DateRangePickerTrigger({ ref, id: idProp, size, icon, placeholder, className, sx, onKeyDown, onKeyUp, 'aria-label': ariaLabel, 'aria-labelledby': ariaLabelledBy, 'aria-describedby': ariaDescribedBy, 'aria-invalid': ariaInvalidProp, ...rest }: DateRangePickerTriggerProps): import("@emotion/react/jsx-runtime").JSX.Element;
+declare function DateRangePickerTrigger({ ref, id: idProp, form, size, icon, placeholder, className, sx, onKeyDown, onKeyUp, 'aria-label': ariaLabel, 'aria-labelledby': ariaLabelledBy, 'aria-describedby': ariaDescribedBy, 'aria-invalid': ariaInvalidProp, ...rest }: DateRangePickerTriggerProps): import("@emotion/react/jsx-runtime").JSX.Element;
 declare function DateRangePickerContent(props: DateRangePickerContentProps): import("@emotion/react/jsx-runtime").JSX.Element | null;
 export declare const DateRangePicker: typeof DateRangePickerRoot & {
     Trigger: typeof DateRangePickerTrigger;

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

@@ -1,4 +1,5 @@
 import { type ComponentPropsWithRef, type ReactNode } from 'react';
+import { type SurfaceAppearance } from '../../styling/surface';
 import { type SxProps } from '../../styling/sx';
 export type DrawerSide = 'inline-start' | 'inline-end' | 'top' | 'bottom';
 export type DrawerSize = 'sm' | 'md' | 'lg';
@@ -21,6 +22,11 @@ export interface DrawerContentProps extends Omit<ComponentPropsWithRef<'dialog'>
     withDescription?: boolean;
 }
 export interface DrawerPanelProps extends ComponentPropsWithRef<'div'>, SxProps {
+    /**
+     * `contrast` (default) wears the dark theme plus the elevated-charcoal overrides on any page theme;
+     * `default` keeps whatever theme is in scope.
+     */
+    appearance?: SurfaceAppearance;
 }
 export interface DrawerHeaderProps extends ComponentPropsWithRef<'div'>, SxProps {
 }
@@ -38,7 +44,7 @@ export interface DrawerCloseProps extends ComponentPropsWithRef<'button'>, SxPro
 declare function DrawerRoot({ open: openProp, defaultOpen, onOpenChange, side, size, draggable, children, }: DrawerProps): import("@emotion/react/jsx-runtime").JSX.Element;
 declare function DrawerTrigger({ ref, onClick, className, sx, ...rest }: DrawerTriggerProps): import("@emotion/react/jsx-runtime").JSX.Element;
 declare function DrawerContent({ ref, className, sx, ...props }: DrawerContentProps): import("@emotion/react/jsx-runtime").JSX.Element;
-declare function DrawerPanel({ ref, className, sx, ...props }: DrawerPanelProps): import("@emotion/react/jsx-runtime").JSX.Element;
+declare function DrawerPanel({ ref, className, appearance, style, sx, ...props }: DrawerPanelProps): import("@emotion/react/jsx-runtime").JSX.Element;
 declare function DrawerHeader({ ref, className, sx, ...props }: DrawerHeaderProps): import("@emotion/react/jsx-runtime").JSX.Element;
 declare function DrawerBody({ ref, className, sx, ...props }: DrawerBodyProps): import("@emotion/react/jsx-runtime").JSX.Element;
 declare function DrawerFooter({ ref, className, sx, ...props }: DrawerFooterProps): import("@emotion/react/jsx-runtime").JSX.Element;

package/dist/types/components/expanding-search/expanding-search.d.ts

@@ -0,0 +1,22 @@
+import { type ComponentPropsWithRef, type CSSProperties, type Ref } from 'react';
+import { type SxProps } from '../../styling/sx';
+import { type SearchFieldProps, type SearchFieldSize } from '../search-field';
+export type ExpandingSearchInputProps = Omit<ComponentPropsWithRef<'input'>, 'ref' | 'type' | 'role' | 'size' | 'value' | 'defaultValue' | 'children' | 'disabled' | 'dir' | 'className'>;
+export interface ExpandingSearchProps extends Omit<ComponentPropsWithRef<'div'>, 'children' | 'defaultValue' | 'onChange'>, SxProps, Pick<SearchFieldProps, 'value' | 'defaultValue' | 'onValueChange' | 'label' | 'description' | 'error' | 'clearable' | 'messages' | 'searchIcon' | 'clearIcon' | 'slotProps'> {
+    /** Accessible name of the collapsed button; also the input's fallback name. */
+    triggerLabel: string;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    anchor?: 'start' | 'end';
+    expandedWidth?: CSSProperties['inlineSize'];
+    size?: SearchFieldSize;
+    disabled?: boolean;
+    /** Native attributes and events of the search input. */
+    inputProps?: ExpandingSearchInputProps;
+    inputRef?: Ref<HTMLInputElement>;
+}
+export declare function ExpandingSearch({ ref, inputRef, triggerLabel, open: openProp, defaultOpen, onOpenChange, anchor, expandedWidth, size, disabled, value, defaultValue, onValueChange, label, description, error, clearable, messages, searchIcon, clearIcon, slotProps, inputProps, className, sx, dir, style, onKeyDown, onBlur, ...rootProps }: ExpandingSearchProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export declare namespace ExpandingSearch {
+    var displayName: string;
+}

package/dist/types/components/expanding-search/index.d.ts

@@ -0,0 +1 @@
+export { ExpandingSearch, type ExpandingSearchInputProps, type ExpandingSearchProps } from './expanding-search';

package/dist/types/components/keycap-keyboard/index.d.ts

@@ -0,0 +1,2 @@
+export { KeycapKeyboard } from './keycap-keyboard';
+export type { KeycapKeyboardProps, KeycapKeyboardSlotProps, KeycapSpec } from './keycap-keyboard';

package/dist/types/components/keycap-keyboard/keycap-keyboard.d.ts

@@ -0,0 +1,32 @@
+import { type ComponentPropsWithRef, type ReactNode } from 'react';
+import { type Interpolation, type Theme } from '../../styling/css';
+import { type SxProps } from '../../styling/sx';
+export interface KeycapSpec {
+    code: string;
+    legend: ReactNode;
+    units?: number;
+}
+export interface KeycapKeyboardSlotProps {
+    className?: string;
+    css?: Interpolation<Theme>;
+}
+export interface KeycapKeyboardProps extends Omit<ComponentPropsWithRef<'div'>, 'children' | 'defaultValue' | 'onChange' | 'tabIndex' | 'role' | 'onKeyDown' | 'onKeyUp'>, SxProps {
+    layout?: 'compact' | 'letters';
+    rows?: readonly (readonly KeycapSpec[])[];
+    value?: readonly string[];
+    defaultValue?: readonly string[];
+    onValueChange?: (codes: readonly string[]) => void;
+    eventTarget?: HTMLInputElement | HTMLTextAreaElement | null;
+    tone?: 'neutral' | 'accent';
+    paused?: boolean;
+    slotProps?: {
+        row?: KeycapKeyboardSlotProps;
+        key?: KeycapKeyboardSlotProps;
+        legend?: KeycapKeyboardSlotProps;
+    };
+}
+/** Decorative physical keyboard; text, focus and shortcut descriptions belong to the consumer. */
+export declare function KeycapKeyboard({ ref, layout, rows, value, defaultValue, onValueChange, eventTarget, tone, paused, slotProps, className, sx, style, ...rest }: KeycapKeyboardProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export declare namespace KeycapKeyboard {
+    var displayName: string;
+}

package/dist/types/components/lightbox-gallery/index.d.ts

@@ -0,0 +1,2 @@
+export { LightboxGallery } from './lightbox-gallery';
+export type { LightboxGalleryImage, LightboxGalleryLabels, LightboxGalleryProps, LightboxGallerySlotProps, } from './lightbox-gallery';

package/dist/types/components/lightbox-gallery/lightbox-gallery.d.ts

@@ -0,0 +1,74 @@
+import { type ComponentPropsWithRef, type ReactNode } from 'react';
+import { vars } from '@jfrader/tokens/vars';
+import { type Interpolation, type Theme } from '../../styling/css';
+import { type SxProps } from '../../styling/sx';
+export interface LightboxGalleryImage {
+    id: string;
+    src: string;
+    width: number;
+    height: number;
+    alt: string;
+    title?: string;
+    caption?: ReactNode;
+    srcSet?: string;
+    sizes?: string;
+}
+type Slot<Tag extends keyof React.JSX.IntrinsicElements> = Omit<ComponentPropsWithRef<Tag>, 'children'> & {
+    css?: Interpolation<Theme>;
+};
+export interface LightboxGallerySlotProps {
+    grid?: Slot<'ul'>;
+    tile?: Omit<Slot<'button'>, 'type'>;
+    image?: Omit<Slot<'img'>, 'src' | 'srcSet' | 'sizes' | 'alt' | 'width' | 'height'>;
+    viewer?: Omit<Slot<'dialog'>, 'open'> & {
+        withDescription?: boolean;
+    };
+    stage?: Slot<'div'>;
+    title?: Slot<'h2'>;
+    caption?: Slot<'p'>;
+    thumbnails?: Slot<'div'>;
+    controls?: Slot<'div'>;
+    status?: Slot<'div'>;
+}
+export interface LightboxGalleryLabels {
+    open: string;
+    close: string;
+    previous: string;
+    next: string;
+    zoom: string;
+    zoomIn: string;
+    zoomOut: string;
+    reset: string;
+    panLeft: string;
+    panRight: string;
+    panUp: string;
+    panDown: string;
+    empty: string;
+    unavailable: string;
+    imageUnavailable: string;
+    loading: string;
+    thumbnails: string;
+    position: (position: string, total: string) => string;
+    zoomPercent: (percent: string) => string;
+}
+export interface LightboxGalleryProps extends Omit<ComponentPropsWithRef<'div'>, 'children' | 'defaultValue'>, SxProps {
+    images: readonly LightboxGalleryImage[];
+    label: string;
+    minColumnWidth?: number;
+    gap?: keyof typeof vars.space;
+    value?: string | null;
+    defaultValue?: string | null;
+    onValueChange?: (id: string | null) => void;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    maxZoom?: number;
+    labels?: Partial<LightboxGalleryLabels>;
+    locale?: Intl.LocalesArgument;
+    slotProps?: LightboxGallerySlotProps;
+}
+export declare function LightboxGallery({ ref, images, label, minColumnWidth, gap, value, defaultValue, onValueChange, open: openProp, defaultOpen, onOpenChange, maxZoom, labels: labelOverrides, locale, slotProps, className, sx, ...rest }: LightboxGalleryProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export declare namespace LightboxGallery {
+    var displayName: string;
+}
+export {};

package/dist/types/components/link-unfurl/index.d.ts

@@ -0,0 +1,2 @@
+export { LinkUnfurl } from './link-unfurl';
+export type { LinkUnfurlLabels, LinkUnfurlMessage, LinkUnfurlPreview, LinkUnfurlPreviewRequestContext, LinkUnfurlPreviewStatus, LinkUnfurlProps, LinkUnfurlSlotProps, LinkUnfurlSuggestion, } from './link-unfurl';

package/dist/types/components/link-unfurl/link-unfurl.d.ts

@@ -0,0 +1,94 @@
+import { type ComponentPropsWithoutRef, type ComponentPropsWithRef, type ReactNode } from 'react';
+import { type Interpolation, type Theme } from '../../styling/css';
+import { type SxProps } from '../../styling/sx';
+export type LinkUnfurlPreviewStatus = 'pending' | 'ready' | 'none' | 'error';
+export interface LinkUnfurlPreview {
+    /** The detected link this record belongs to (from `onPreviewRequest`'s context). */
+    linkId: string;
+    /** The request this record answers; records for any other request id are ignored. */
+    requestId: string;
+    url: string;
+    status: LinkUnfurlPreviewStatus;
+    site?: string;
+    title?: string;
+    description?: ReactNode;
+    /** Informative image; `alt` describes it, or pass `''` when the image adds nothing. */
+    image?: {
+        src: string;
+        alt: string;
+    };
+    /** Decorative site icon URL. */
+    favicon?: string;
+    /** Shown instead of `labels.noPreview` when the status is `error`. */
+    error?: string;
+}
+export interface LinkUnfurlPreviewRequestContext {
+    linkId: string;
+    requestId: string;
+    signal: AbortSignal;
+}
+export interface LinkUnfurlSuggestion {
+    url: string;
+    label: string;
+}
+export interface LinkUnfurlMessage {
+    text: string;
+    previews: LinkUnfurlPreview[];
+}
+export interface LinkUnfurlLabels {
+    send: string;
+    expand: string;
+    collapse: string;
+    remove: string;
+    retry: string;
+    pending: string;
+    noPreview: string;
+    sent: string;
+    error: string;
+    /** Keyboard description read with the field. */
+    hint: string;
+}
+interface SlotStyle {
+    className?: string;
+    css?: Interpolation<Theme>;
+}
+type PartProps<E extends 'div' | 'a' | 'img' | 'p' | 'button'> = Omit<ComponentPropsWithoutRef<E>, 'children' | 'id' | 'className' | 'dangerouslySetInnerHTML'> & SlotStyle;
+export interface LinkUnfurlSlotProps {
+    field?: Omit<ComponentPropsWithRef<'textarea'>, 'children' | 'id' | 'value' | 'defaultValue' | 'readOnly' | 'className' | 'dangerouslySetInnerHTML'> & SlotStyle;
+    lane?: PartProps<'div'>;
+    /** Handlers that the item's layout animation owns are not accepted. */
+    chip?: Omit<PartProps<'div'>, 'onAnimationStart' | 'onDrag' | 'onDragStart' | 'onDragEnd'>;
+    card?: Omit<PartProps<'div'>, 'hidden' | 'inert'>;
+    title?: Omit<PartProps<'a'>, 'href'>;
+    image?: Omit<PartProps<'img'>, 'src' | 'alt'>;
+    controls?: PartProps<'div'>;
+    send?: Omit<PartProps<'button'>, 'type' | 'disabled'>;
+    status?: Omit<PartProps<'div'>, 'role' | 'aria-live' | 'aria-atomic'>;
+    error?: Omit<PartProps<'p'>, 'role'>;
+}
+export interface LinkUnfurlProps extends Omit<ComponentPropsWithRef<'div'>, 'children' | 'defaultValue' | 'onChange'>, SxProps {
+    /** Visible label of the message field. */
+    label: string;
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (text: string) => void;
+    previews?: LinkUnfurlPreview[];
+    onPreviewRequest?: (url: string, context: LinkUnfurlPreviewRequestContext) => void;
+    expanded?: string[];
+    defaultExpanded?: string[];
+    onExpandedChange?: (ids: string[]) => void;
+    suggestions?: LinkUnfurlSuggestion[];
+    /** Enables sending; a returned promise keeps the composer pending until it settles. */
+    onSend?: (message: LinkUnfurlMessage) => void | Promise<unknown>;
+    labels?: Partial<LinkUnfurlLabels>;
+    /** Locale for the joined status announcements. */
+    locale?: Intl.LocalesArgument;
+    /** `'none'` commits every change without animation, on top of the user's reduced-motion setting. */
+    motion?: 'auto' | 'none';
+    slotProps?: LinkUnfurlSlotProps;
+}
+export declare function LinkUnfurl({ ref, label, value: valueProp, defaultValue, onValueChange, previews, onPreviewRequest, expanded: expandedProp, defaultExpanded, onExpandedChange, suggestions, onSend, labels: labelsProp, locale, motion: motionMode, slotProps, className, sx, ...rest }: LinkUnfurlProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export declare namespace LinkUnfurl {
+    var displayName: string;
+}
+export {};

package/dist/types/components/locale-switcher/index.d.ts

@@ -0,0 +1,2 @@
+export { LocaleSwitcher } from './locale-switcher';
+export type { LocaleSwitcherLinkProps, LocaleSwitcherOption, LocaleSwitcherProps, LocaleSwitcherSize, LocaleSwitcherSlotProps, LocaleSwitcherVariant, } from './locale-switcher';

package/dist/types/components/locale-switcher/locale-switcher.d.ts

@@ -0,0 +1,58 @@
+import { type ComponentPropsWithoutRef, 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';
+export type LocaleSwitcherVariant = 'menu' | 'swap' | 'inline';
+export type LocaleSwitcherSize = 'sm' | 'md' | 'lg';
+/** Props an option's `render` callback spreads onto the link it returns. */
+export interface LocaleSwitcherLinkProps extends Omit<ComponentPropsWithRef<'a'>, 'href' | 'children'> {
+    href: string;
+    children: ReactNode;
+    'data-ui': string;
+}
+export interface LocaleSwitcherOption {
+    value: string;
+    /** The language's native name ("Español", "English"). */
+    label: ReactNode;
+    /** BCP 47 tag of the label and of the linked page; rendered as `lang` and `hreflang`. */
+    lang?: string;
+    href: string;
+    /** Replaces the native <a> (e.g. with a router link). Spread ALL supplied props onto it. */
+    render?: (props: LocaleSwitcherLinkProps) => ReactNode;
+}
+type SlotStyle = {
+    className?: string;
+    css?: Interpolation<Theme>;
+};
+export interface LocaleSwitcherSlotProps {
+    /** Menu variant's trigger button. */
+    trigger?: Omit<ComponentPropsWithoutRef<'button'>, 'children' | 'className' | 'aria-labelledby'> & SlotStyle;
+    /** Menu variant's popup. */
+    content?: Omit<ComponentPropsWithoutRef<'div'>, 'children' | 'className'> & SlotStyle;
+    /** Every option element (menu items, the swap link, inline links and the current label). */
+    option?: SlotStyle;
+}
+export interface LocaleSwitcherProps extends Omit<ComponentPropsWithRef<'nav'>, 'children'>, SxProps {
+    options: readonly LocaleSwitcherOption[];
+    /** The current option's value. */
+    value: string;
+    variant?: LocaleSwitcherVariant;
+    size?: LocaleSwitcherSize;
+    /** Menu: names the trigger's action ("Change language"); read before the current label. */
+    triggerLabel?: string;
+    /** Inline: accessible name of the navigation landmark. */
+    label?: string;
+    /** Menu: decorative icon before the current label; `null` removes it. */
+    icon?: ReactNode;
+    /** Menu open state. */
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    placement?: Placement;
+    slotProps?: LocaleSwitcherSlotProps;
+}
+export declare function LocaleSwitcher({ ref, options, value, variant, size, triggerLabel, label, icon, open, defaultOpen, onOpenChange, placement, slotProps, className, sx, ...rest }: LocaleSwitcherProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export declare namespace LocaleSwitcher {
+    var displayName: string;
+}
+export {};

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

@@ -1,7 +1,8 @@
-import { type ComponentPropsWithRef, type ReactNode } from 'react';
-import { type Placement } from '@floating-ui/react';
-import { type Interpolation, type Theme } from '../../styling/css';
+import { type ComponentPropsWithRef, type CSSProperties, type HTMLAttributes, type HTMLProps, type MutableRefObject, type ReactNode, type RefCallback } from 'react';
+import { type Placement, type UseInteractionsReturn } from '@floating-ui/react';
+import { type Interpolation, type SerializedStyles, type Theme } from '../../styling/css';
 import { type SxProps } from '../../styling/sx';
+import { useOverlayFloating, type OverlayFloatingOptions } from '../../overlay/use-overlay-floating';
 export interface MenuProps {
     open?: boolean;
     defaultOpen?: boolean;
@@ -21,6 +22,29 @@ export interface MenuItemProps extends Omit<ComponentPropsWithRef<'button'>, 'on
 }
 export interface MenuSeparatorProps extends ComponentPropsWithRef<'div'>, SxProps {
 }
+export type MenuItemTone = 'neutral' | 'danger';
+/** Positioning options a family may set on the shared controller; Menu keeps the defaults. */
+export type MenuPositioning = Pick<OverlayFloatingOptions, 'strategy' | 'gap' | 'transform' | 'onAvailableSize'>;
+export interface MenuControllerProps extends MenuProps {
+    positioning?: MenuPositioning;
+}
+type OverlayFloating = ReturnType<typeof useOverlayFloating>;
+interface MenuContextValue {
+    open: boolean;
+    nodeId: string | undefined;
+    requestOpen: () => void;
+    requestClose: (restoreFocus?: boolean) => void;
+    activeIndex: number | null;
+    refs: OverlayFloating['refs'];
+    floatingContext: OverlayFloating['context'];
+    floatingStyles: CSSProperties;
+    elementsRef: MutableRefObject<Array<HTMLElement | null>>;
+    labelsRef: MutableRefObject<Array<string | null>>;
+    disabledIndices: Set<number>;
+    getReferenceProps: UseInteractionsReturn['getReferenceProps'];
+    getFloatingProps: UseInteractionsReturn['getFloatingProps'];
+    getItemProps: UseInteractionsReturn['getItemProps'];
+}
 /**
  * Private seam for component families built on the menu controller (Menu, SplitButton): the
  * family names usage errors, `marker` is the part's data-ui and `styles` its own styles.
@@ -30,16 +54,59 @@ export interface MenuPartIdentity {
     marker: string;
     styles?: Interpolation<Theme>;
 }
+/** Props a menu item's `render` callback spreads onto the element it returns. */
+export interface MenuItemRenderProps extends HTMLAttributes<HTMLElement> {
+    ref: RefCallback<HTMLElement> | null;
+    'data-ui': string;
+}
+/** Item behavior a family may change: the part name in usage errors, the item role, whether
+ * selection closes the menu, `busy` (an item that stays focusable and navigable but ignores
+ * activation, exposed as aria-busy and aria-disabled) and `render`, which replaces the native
+ * button (e.g. with an <a href>). */
+export interface MenuItemPartBehavior {
+    part?: string;
+    itemRole?: 'menuitem' | 'menuitemcheckbox' | 'menuitemradio';
+    closeOnSelect?: boolean;
+    busy?: boolean;
+    render?: (props: MenuItemRenderProps) => ReactNode;
+}
+export declare function useMenuContext(family: string, part: string): MenuContextValue;
+/**
+ * Runs each consumer handler before the matching interaction handler; a consumer
+ * `preventDefault()` vetoes the internal request (open, toggle, navigation).
+ */
+export declare function consumerHandlersFirst(props: HTMLProps<Element>, getProps: (userProps: HTMLProps<Element>) => Record<string, unknown>): Record<string, unknown>;
+export declare const joinIds: (...ids: Array<string | undefined>) => string | undefined;
 /** Own styles of a menu item, for families that layer their own item styles on top. */
-export declare const menuItemStyles: import("@emotion/react").SerializedStyles[];
+export declare const menuItemStyles: SerializedStyles[];
 /** Own styles of a menu separator. */
-export declare const menuSeparatorStyles: import("@emotion/react").SerializedStyles;
+export declare const menuSeparatorStyles: SerializedStyles;
+/** Command tones for families whose items carry one (SplitButton, ContextMenu). */
+export declare const menuItemToneStyles: Record<MenuItemTone, SerializedStyles>;
+/**
+ * Returns focus to a closed overlay's trigger, unless the trigger left the document or became
+ * inert (its owner is being removed) or something else already holds focus.
+ */
+export declare function restoreTriggerFocus(trigger: HTMLElement | null): void;
+/** The shared menu controller (state, positioning, navigation, dismissal, focus return). */
+export declare function MenuController(props: MenuControllerProps): import("@emotion/react/jsx-runtime").JSX.Element;
 declare function MenuRoot(props: MenuProps): import("@emotion/react/jsx-runtime").JSX.Element;
 export declare function MenuTriggerPart({ family, marker, styles, ref, className, sx, ...props }: MenuTriggerProps & MenuPartIdentity): import("@emotion/react/jsx-runtime").JSX.Element;
 declare function MenuTrigger(props: MenuTriggerProps): import("@emotion/react/jsx-runtime").JSX.Element;
-export declare function MenuContentPart({ family, marker, styles, ref, style, children, className, sx, 'aria-label': ariaLabel, 'aria-labelledby': ariaLabelledBy, ...rest }: MenuContentProps & MenuPartIdentity): import("@emotion/react/jsx-runtime").JSX.Element | null;
+export declare function MenuContentPart({ family, marker, styles, ref, style, children, className, sx, 'aria-label': ariaLabel, 'aria-labelledby': ariaLabelledBy, defaultLabelledBy, ...rest }: MenuContentProps & MenuPartIdentity & {
+    defaultLabelledBy?: string;
+}): import("@emotion/react/jsx-runtime").JSX.Element | null;
+/**
+ * The menu's item collection: items rendered inside register with its list navigation and
+ * typeahead, and layers opened inside nest under the menu. Families that build their own surface
+ * around the menu element (UserMenu) render it inside the element carrying the floating props.
+ */
+export declare function MenuCollection({ family, children }: {
+    family: string;
+    children?: ReactNode;
+}): import("@emotion/react/jsx-runtime").JSX.Element;
 declare function MenuContent(props: MenuContentProps): import("@emotion/react/jsx-runtime").JSX.Element;
-export declare function MenuItemPart({ family, marker, styles, ref, onSelect, disabled, onClick, className, sx, ...rest }: MenuItemProps & MenuPartIdentity): import("@emotion/react/jsx-runtime").JSX.Element;
+export declare function MenuItemPart({ family, marker, styles, ref, onSelect, disabled, part, itemRole, closeOnSelect, busy, render, onClick, onKeyDown, className, sx, ...rest }: MenuItemProps & MenuPartIdentity & MenuItemPartBehavior): import("@emotion/react/jsx-runtime").JSX.Element;
 declare function MenuItem(props: MenuItemProps): import("@emotion/react/jsx-runtime").JSX.Element;
 export declare function MenuSeparatorPart({ marker, styles, ref, className, sx, ...props }: MenuSeparatorProps & Omit<MenuPartIdentity, 'family'>): import("@emotion/react/jsx-runtime").JSX.Element;
 declare function MenuSeparator(props: MenuSeparatorProps): import("@emotion/react/jsx-runtime").JSX.Element;