@exponential_app/eui-react 0.0.0-stage → 0.2.1

package/dist/types/natives/shared.d.ts

@@ -0,0 +1,35 @@
+import { type ReactNode } from "react";
+import { arr, bool, builtinIconName, failingCheck, failingChecks, formatFileSize, num, objects, phrase, str } from "@exponential_app/eui/web";
+import type { UiNode } from "@exponential_app/eui";
+export type Attrs = Record<string, unknown>;
+export { str, num, bool, arr, objects, phrase, formatFileSize, failingChecks, failingCheck, builtinIconName };
+export type PartFn = ((name: string, ...states: (string | false | undefined | null)[]) => Attrs) & {
+    /** The same with part-level recipe props (`{kind: "keyword"}`). */
+    with: (name: string, extra: Record<string, unknown>, ...states: (string | false | undefined | null)[]) => Attrs;
+    /** A PER-ITEM placed part (round 2 §6): `data-xui-id="<id>.<part>.<item>"`
+     *  (`item` = an index or a row key: `tab.1`, `cell.alice.0`). */
+    at: (name: string, item: string | number, ...states: (string | false | undefined | null)[]) => Attrs;
+    /** `at` with part-level recipe props. */
+    atWith: (name: string, item: string | number, extra: Record<string, unknown>, ...states: (string | false | undefined | null)[]) => Attrs;
+    /** The painted id of the node (`<id><instance suffix>`). */
+    domId: string;
+};
+/** `part(name, …states)` → the attributes of one part element of `node`. */
+export declare function useParts(node: UiNode, props: Record<string, unknown>): PartFn;
+export declare function TextPart({ part, text, as: Tag, id, htmlFor }: {
+    part: Attrs;
+    text: unknown;
+    as?: `span` | `label` | `div` | `p`;
+    id?: string;
+    htmlFor?: string;
+}): import("react/jsx-runtime").JSX.Element | null;
+export declare function Hidden({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+/** The glyph of an owned part (`CodeBlock.copy`, `Table.sortIcon.asc`),
+ *  through the host's registry first, then the renderer's fallbacks. */
+export declare function BuiltinIcon({ slot, className, size }: {
+    slot: string;
+    className?: string;
+    size?: number;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/natives/table.d.ts

@@ -0,0 +1,5 @@
+import { type NativeProps } from "../node-view.js";
+import { sortRows, type TableColumn } from "@exponential_app/eui/web";
+export { sortRows };
+export type { TableColumn };
+export declare function TableNative({ node, props, rootProps, emit, scope, domId }: NativeProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/natives/text.d.ts

@@ -0,0 +1,4 @@
+import type { NativeProps } from "../node-view.js";
+export declare function TextNative({ props, rootProps }: NativeProps): import("react/jsx-runtime").JSX.Element;
+export declare function MarkdownNative({ props, rootProps }: NativeProps): import("react/jsx-runtime").JSX.Element;
+export declare function IconNative({ props, rootProps }: NativeProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/node-view.d.ts

@@ -0,0 +1,73 @@
+import { Fragment, type CSSProperties } from "react";
+import type { UiNode } from "@exponential_app/eui";
+import { type SurfaceContextValue } from "./context.js";
+import type { ExtensionComponentProps } from "./host.js";
+export interface NativeProps extends ExtensionComponentProps {
+    /** The data scope (template item) this node renders under. */
+    scope: string;
+    /** The node's id as painted (`data-xui-id`): its id + the template
+     *  instance suffix. DOM ids derive from it (`<id>.error`). */
+    domId: string;
+}
+/** The id a node's style rules are keyed by. */
+export declare function styleIdOf(node: UiNode): string;
+/** The attributes every painted root carries. */
+export declare function useRootProps(node: UiNode, props: Record<string, unknown>, domId?: string, recipeProps?: Record<string, unknown>, style?: CSSProperties): Record<string, unknown>;
+/** `className` on top of the renderer's own. */
+export declare function withClass(rootProps: Record<string, unknown>, ...extra: (string | false | undefined | null)[]): Record<string, unknown>;
+/** A painter's own inline style merged over the root's (the dynamic style
+ *  variables live there and must survive). */
+export declare function mergeStyle(rootProps: Record<string, unknown>, style: CSSProperties | undefined): CSSProperties | undefined;
+/** Forced states on a part element (`data-xs`). */
+export declare function forced(states: readonly string[], ...extra: (string | false | undefined)[]): string | undefined;
+/** Run one of a node's actions (round-1 contract §1 `runAction`): the
+ *  function args AND the event context resolve against the data WITH the
+ *  component's own write applied (round 4 `withOwnWrites`: `own` = what
+ *  the component just wrote, by prop, so the context of an Input's
+ *  `change` reads the text just typed, even before React has re-rendered
+ *  the write), then `set` writes (relative paths against the node's scope), any other
+ *  function runs, then the event reaches the host with the component's
+ *  payload merged OVER the author's context (the payload wins a clashing
+ *  key, like the Rust core's `fire`: the author's context was resolved
+ *  before the write, the payload carries the value just written). */
+export declare function runNodeAction(ctx: SurfaceContextValue, node: UiNode, domId: string, scope: string, event: string, payload?: Record<string, unknown>, own?: Record<string, unknown>): Promise<void> | void;
+export declare function useEmitter(node: UiNode, scope: string, domId?: string): (event: string, payload?: Record<string, unknown>, own?: Record<string, unknown>) => Promise<void> | void;
+/** A node, or nothing when its `visible` resolves falsy (no layout, not in
+ *  the a11y tree). Memoized on the node: a parent re-render does not cascade;
+ *  a context change (theme, locale…) still reaches every node, a data,
+ *  breakpoint or `data-xq` change only the nodes that read the new value
+ *  (`useLive`, VAPP-141). */
+export declare const NodeView: import("react").NamedExoticComponent<{
+    node: UiNode;
+}>;
+/** A node's own style `direction` (round 2 §2: any node, inherited),
+ *  matching `@media` blocks included (`nodeDirections` is the reference). */
+export declare function ownDirection(node: UiNode, ctx?: Pick<SurfaceContextValue, `theme` | `xq`>): `ltr` | `rtl` | undefined;
+export interface TemplateItem {
+    /** The item's instance key (its React key; escaped, its id suffix): the
+     *  `template.key` value; the index when the template has no key; `#<index>`
+     *  when the key is missing, null, empty or a DUPLICATE of an earlier item
+     *  (so ids stay unique). */
+    key: string;
+    /** The item's data pointer (its scope). */
+    path: string;
+    index: number;
+}
+/** The items of a node's data template (`template.key` = a pointer relative
+ *  to each item whose value identifies it). Instance ids ACCUMULATE: an
+ *  item's nodes are `<id><outer suffixes>.<key>`, so a nested template's
+ *  items stay unique across the outer items (`cell.a.0`, `cell.b.0`). */
+export declare function templateItems(ctx: SurfaceContextValue, node: UiNode, scope: string): {
+    items: TemplateItem[];
+    tpl: UiNode;
+} | null;
+/** A template item's instance suffix: the enclosing one + `.<key>`, the
+ *  key escaped (`instanceSegment`: `.` → `~1`, `~` → `~0`) as the core's
+ *  `templateInstances`, so `a.b` never reads as two levels. */
+export declare const itemInstance: (instance: string, key: string) => string;
+/** One template item: its scope + instance suffix around the node. */
+export declare function TemplateItemView({ tpl, item }: {
+    tpl: UiNode;
+    item: TemplateItem;
+}): import("react/jsx-runtime").JSX.Element;
+export { Fragment };

package/dist/types/platform.d.ts

@@ -0,0 +1,12 @@
+/** `matchMedia(query).matches`, live; `fallback` without `matchMedia`
+ *  (SSR, jsdom). */
+export declare function useMediaQuery(query: string, fallback?: boolean): boolean;
+export interface BoxSize {
+    width: number;
+    height: number;
+    /** False until the first measurement. */
+    measured: boolean;
+}
+/** An element's border box in layout px (NEW-82: unzoomed, untransformed;
+ *  `layoutSize`), live (ResizeObserver, disconnected on unmount). */
+export declare function useElementSize(el: HTMLElement | null, initialWidth?: number): BoxSize;

package/dist/types/primitives/alert-dialog.d.ts

@@ -0,0 +1,14 @@
+import * as React from "react";
+import { AlertDialog as AlertDialogPrimitive } from "radix-ui";
+declare function AlertDialog({ ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogTrigger({ ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogPortal({ ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Portal>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogOverlay({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Overlay>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogContent({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogHeader({ className, ...props }: React.ComponentProps<`div`>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogFooter({ className, ...props }: React.ComponentProps<`div`>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogTitle({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Title>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogDescription({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Description>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogAction({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Action>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogCancel({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Cancel>): import("react/jsx-runtime").JSX.Element;
+export { AlertDialog, AlertDialogPortal, AlertDialogOverlay, AlertDialogTrigger, AlertDialogContent, AlertDialogHeader, AlertDialogFooter, AlertDialogTitle, AlertDialogDescription, AlertDialogAction, AlertDialogCancel };

package/dist/types/primitives/alert.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import type { VariantProps } from "class-variance-authority";
+import { alertVariants } from "@exponential_app/eui/web/primitives";
+declare function Alert({ className, variant, ...props }: React.ComponentProps<`div`> & VariantProps<typeof alertVariants>): import("react/jsx-runtime").JSX.Element;
+declare function AlertTitle({ className, ...props }: React.ComponentProps<`div`>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDescription({ className, ...props }: React.ComponentProps<`div`>): import("react/jsx-runtime").JSX.Element;
+export { Alert, AlertTitle, AlertDescription, alertVariants };

package/dist/types/primitives/avatar-color.d.ts

@@ -0,0 +1 @@
+export { AVATAR_HUE_COUNT, avatarHueIndex } from "@exponential_app/eui/web/primitives";

package/dist/types/primitives/avatar.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+import { Avatar as AvatarPrimitive } from "radix-ui";
+declare function Avatar({ className, ...props }: React.ComponentProps<typeof AvatarPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function AvatarImage({ className, ...props }: React.ComponentProps<typeof AvatarPrimitive.Image>): import("react/jsx-runtime").JSX.Element;
+declare function AvatarFallback({ className, userId, style, ...props }: React.ComponentProps<typeof AvatarPrimitive.Fallback> & {
+    userId?: string | null;
+}): import("react/jsx-runtime").JSX.Element;
+export { Avatar, AvatarImage, AvatarFallback };

package/dist/types/primitives/badge.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+import { type BadgeTone } from "@exponential_app/eui/web/primitives";
+export declare function Badge({ count, max, tone, className, ...props }: Omit<React.ComponentProps<`span`>, `children`> & {
+    count: number;
+    /** Past this the badge reads `${max}+`. */
+    max?: number;
+    tone?: BadgeTone;
+}): import("react/jsx-runtime").JSX.Element | null;

package/dist/types/primitives/breadcrumb.d.ts

@@ -0,0 +1,11 @@
+import * as React from "react";
+declare function Breadcrumb({ ...props }: React.ComponentProps<`nav`>): import("react/jsx-runtime").JSX.Element;
+declare function BreadcrumbList({ className, ...props }: React.ComponentProps<`ol`>): import("react/jsx-runtime").JSX.Element;
+declare function BreadcrumbItem({ className, ...props }: React.ComponentProps<`li`>): import("react/jsx-runtime").JSX.Element;
+declare function BreadcrumbLink({ asChild, className, ...props }: React.ComponentProps<`a`> & {
+    asChild?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function BreadcrumbPage({ className, ...props }: React.ComponentProps<`span`>): import("react/jsx-runtime").JSX.Element;
+declare function BreadcrumbSeparator({ children, className, ...props }: React.ComponentProps<`li`>): import("react/jsx-runtime").JSX.Element;
+declare function BreadcrumbEllipsis({ className, ...props }: React.ComponentProps<`span`>): import("react/jsx-runtime").JSX.Element;
+export { Breadcrumb, BreadcrumbList, BreadcrumbItem, BreadcrumbLink, BreadcrumbPage, BreadcrumbSeparator, BreadcrumbEllipsis };

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

@@ -0,0 +1,7 @@
+import * as React from "react";
+import type { VariantProps } from "class-variance-authority";
+import { buttonVariants } from "@exponential_app/eui/web/primitives";
+declare function Button({ className, variant, size, asChild, ...props }: React.ComponentProps<`button`> & VariantProps<typeof buttonVariants> & {
+    asChild?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+export { Button, buttonVariants };

package/dist/types/primitives/calendar.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+import { DayPicker, type DayButton } from "react-day-picker";
+import { Button } from "./button.js";
+declare function Calendar({ className, classNames, showOutsideDays, captionLayout, buttonVariant, formatters, components, ...props }: React.ComponentProps<typeof DayPicker> & {
+    buttonVariant?: React.ComponentProps<typeof Button>[`variant`];
+}): import("react/jsx-runtime").JSX.Element;
+declare function CalendarDayButton({ className, day, modifiers, ...props }: React.ComponentProps<typeof DayButton>): import("react/jsx-runtime").JSX.Element;
+export { Calendar, CalendarDayButton };

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

@@ -0,0 +1,9 @@
+import * as React from "react";
+declare function Card({ className, ...props }: React.ComponentProps<`div`>): import("react/jsx-runtime").JSX.Element;
+declare function CardHeader({ className, ...props }: React.ComponentProps<`div`>): import("react/jsx-runtime").JSX.Element;
+declare function CardTitle({ className, ...props }: React.ComponentProps<`div`>): import("react/jsx-runtime").JSX.Element;
+declare function CardDescription({ className, ...props }: React.ComponentProps<`div`>): import("react/jsx-runtime").JSX.Element;
+declare function CardAction({ className, ...props }: React.ComponentProps<`div`>): import("react/jsx-runtime").JSX.Element;
+declare function CardContent({ className, ...props }: React.ComponentProps<`div`>): import("react/jsx-runtime").JSX.Element;
+declare function CardFooter({ className, ...props }: React.ComponentProps<`div`>): import("react/jsx-runtime").JSX.Element;
+export { Card, CardHeader, CardFooter, CardTitle, CardAction, CardDescription, CardContent, };

package/dist/types/primitives/checkbox.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import { Checkbox as CheckboxPrimitive } from "radix-ui";
+declare function Checkbox({ className, ...props }: React.ComponentProps<typeof CheckboxPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+export { Checkbox };

package/dist/types/primitives/choice-tiles.d.ts

@@ -0,0 +1,60 @@
+import * as React from "react";
+import { type ChoiceTileOption, type TileState } from "@exponential_app/eui/web/primitives";
+export { choiceColumns, choiceToggle, choiceValues } from "@exponential_app/eui/web/primitives";
+export type { ChoiceTileOption, TileState } from "@exponential_app/eui/web/primitives";
+type Attrs = Record<string, unknown>;
+export interface ChoiceTilesFrameProps {
+    options: readonly ChoiceTileOption[];
+    /** The picked values. */
+    picked: readonly string[];
+    multiple: boolean;
+    columns: number;
+    disabled?: boolean;
+    invalid?: boolean;
+    dir?: `ltr` | `rtl`;
+    /** A pick (already toggled for `multiple`): the next picked values. */
+    onPick: (next: string[], value: string) => void;
+    rootProps?: Attrs;
+    tileProps: (state: TileState) => Attrs;
+    pictureProps: (state: TileState) => Attrs;
+    labelProps: (state: TileState) => Attrs;
+    descriptionProps: (state: TileState) => Attrs;
+    /** The picture's content (the frame keeps the box; a missing picture gets
+     *  the placeholder). */
+    renderPicture: (src: string | null, state: TileState) => React.ReactNode;
+    /** Under the tiles (the field's errors), spanning every column. */
+    after?: React.ReactNode;
+    rootRef?: React.Ref<HTMLDivElement>;
+}
+/** The headless tiles: a `radiogroup` of `radio` buttons (single) or a
+ *  `group` of `checkbox` buttons (multiple). The picked tile (else the
+ *  first enabled one) is the tab stop; arrows move focus with wrap (a single
+ *  pick follows focus); Space/Enter toggle (the button's own click). Every
+ *  tile has a picture box once ANY option has an image, so a row keeps one
+ *  height. */
+export declare function ChoiceTilesFrame({ options, picked, multiple, columns, disabled, invalid, dir, onPick, rootProps, tileProps, pictureProps, labelProps, descriptionProps, renderPicture, after, rootRef }: ChoiceTilesFrameProps): import("react/jsx-runtime").JSX.Element;
+export interface ChoiceTilesProps {
+    options: readonly ChoiceTileOption[];
+    /** The pick: a string (single) or the picked values (multiple). */
+    value: string | readonly string[] | null | undefined;
+    multiple?: boolean;
+    /** Tiles per row, 1–4 (default 2). */
+    columns?: number;
+    disabled?: boolean;
+    /** Paints the destructive border (a required answer missing). */
+    invalid?: boolean;
+    /** The next value: a string for a single pick, the values for `multiple`. */
+    onChange?: (value: string | string[]) => void;
+    /** The picture element (the app passes an authorised <img> for
+     *  `/api/attachments/{id}`); default a plain lazy <img>. */
+    renderImage?: (src: string, alt: string) => React.ReactNode;
+    className?: string;
+    "aria-label"?: string;
+    "aria-labelledby"?: string;
+    "data-testid"?: string;
+    dir?: `ltr` | `rtl`;
+}
+/** THE picture choice (EXP-1280): the plan card's question blocks and the
+ *  standalone ask, at the eUI `ChoiceTiles` look. */
+declare function ChoiceTiles({ options, value, multiple, columns, disabled, invalid, onChange, renderImage, className, dir, ...rest }: ChoiceTilesProps): import("react/jsx-runtime").JSX.Element;
+export { ChoiceTiles };

package/dist/types/primitives/cn.d.ts

@@ -0,0 +1 @@
+export { cn, getInitials } from "@exponential_app/eui/web/primitives";

package/dist/types/primitives/code-block.d.ts

@@ -0,0 +1,32 @@
+import * as React from "react";
+import type { VariantProps } from "class-variance-authority";
+import { CODE_TOKEN_CLASS, codeBlockLineVariants, codeBlockVariants } from "@exponential_app/eui/web/primitives";
+import { Button } from "./button.js";
+declare function CodeBlock({ className, variant, size, ...props }: React.ComponentProps<`div`> & VariantProps<typeof codeBlockVariants> & {
+    size?: `default` | `sm`;
+}): import("react/jsx-runtime").JSX.Element;
+declare function CodeBlockHeader({ className, ...props }: React.ComponentProps<`div`>): import("react/jsx-runtime").JSX.Element;
+declare function CodeBlockTitle({ className, ...props }: React.ComponentProps<`div`>): import("react/jsx-runtime").JSX.Element;
+declare function CodeBlockActions({ className, ...props }: React.ComponentProps<`div`>): import("react/jsx-runtime").JSX.Element;
+/** The copy action: ui-copy → ui-check for 2s, announced politely. A copy
+ *  that did not happen (no clipboard, a refusal) changes nothing. */
+declare function CodeBlockCopyButton({ value, variant, size, className, onClick, labels, ...props }: React.ComponentProps<typeof Button> & {
+    value: string;
+    labels?: {
+        copy: string;
+        copied: string;
+    };
+}): import("react/jsx-runtime").JSX.Element;
+declare function CodeBlockContent({ className, children, style, wrap, lineNumbers, startLine, language, maxLines, ...props }: React.ComponentProps<`pre`> & {
+    wrap?: boolean;
+    lineNumbers?: boolean;
+    startLine?: number;
+    /** A catalog language (`ts`, `json`, `ansi`…): string children are
+     *  tokenized and coloured per token kind. */
+    language?: string;
+    /** Lines shown before the block scrolls; 0 = unbounded. */
+    maxLines?: number;
+}): import("react/jsx-runtime").JSX.Element;
+declare function CodeBlockLine({ className, variant, children, ...props }: React.ComponentProps<`span`> & VariantProps<typeof codeBlockLineVariants>): import("react/jsx-runtime").JSX.Element;
+declare function CodeBlockFooter({ className, ...props }: React.ComponentProps<`div`>): import("react/jsx-runtime").JSX.Element;
+export { CodeBlock, CodeBlockHeader, CodeBlockTitle, CodeBlockActions, CodeBlockCopyButton, CodeBlockContent, CodeBlockLine, CodeBlockFooter, CODE_TOKEN_CLASS, };

package/dist/types/primitives/collapsible.d.ts

@@ -0,0 +1,6 @@
+import * as React from "react";
+import { Collapsible as CollapsiblePrimitive } from "radix-ui";
+declare function Collapsible({ ...props }: React.ComponentProps<typeof CollapsiblePrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function CollapsibleTrigger({ ...props }: React.ComponentProps<typeof CollapsiblePrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function CollapsibleContent({ ...props }: React.ComponentProps<typeof CollapsiblePrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+export { Collapsible, CollapsibleTrigger, CollapsibleContent };

package/dist/types/primitives/command.d.ts

@@ -0,0 +1,49 @@
+import * as React from "react";
+import { type CommandFilter } from "@exponential_app/eui/web/primitives";
+type CommandProps = Omit<React.ComponentProps<`div`>, `onChange` | `defaultValue`> & {
+    /** The selected item's value (controlled). */
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    /** Score an item against the query (0 hides it); default `commandScore`. */
+    filter?: CommandFilter;
+    /** `false` = the host filters: every item shows, in its own order. */
+    shouldFilter?: boolean;
+    /** Arrow keys wrap around. */
+    loop?: boolean;
+    /** The accessible label (a visually hidden <label> for the input). */
+    label?: string;
+};
+declare function Command({ className, value, defaultValue, onValueChange, filter, shouldFilter, loop, label, children, onKeyDown, ...props }: CommandProps): import("react/jsx-runtime").JSX.Element;
+type CommandInputProps = Omit<React.ComponentProps<`input`>, `value` | `defaultValue` | `onChange` | `type`> & {
+    /** The query (controlled). */
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (query: string) => void;
+    /** The clear button's accessible name. */
+    clearLabel?: string;
+};
+declare function CommandInput({ className, value, defaultValue, onValueChange, clearLabel, ref, ...props }: CommandInputProps): import("react/jsx-runtime").JSX.Element;
+declare function CommandList({ className, children, "aria-label": ariaLabel, ...props }: React.ComponentProps<`div`>): import("react/jsx-runtime").JSX.Element;
+declare function CommandEmpty({ className, ...props }: React.ComponentProps<`div`>): import("react/jsx-runtime").JSX.Element | null;
+declare function CommandGroup({ className, heading, value, forceMount, children, ...props }: Omit<React.ComponentProps<`div`>, `value`> & {
+    heading?: React.ReactNode;
+    value?: string;
+    forceMount?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+type CommandItemProps = Omit<React.ComponentProps<`div`>, `value` | `onSelect`> & {
+    /** The value it filters and selects by (default: its text, trimmed). */
+    value?: string;
+    keywords?: string[];
+    onSelect?: (value: string) => void;
+    disabled?: boolean;
+    /** Always rendered, whatever the query. */
+    forceMount?: boolean;
+};
+declare function CommandItem({ className, value, keywords, onSelect, disabled, forceMount, children, ...props }: CommandItemProps): import("react/jsx-runtime").JSX.Element | null;
+declare function CommandSeparator({ className, alwaysRender, ...props }: React.ComponentProps<`div`> & {
+    alwaysRender?: boolean;
+}): import("react/jsx-runtime").JSX.Element | null;
+declare function CommandShortcut({ className, ...props }: React.ComponentProps<`span`>): import("react/jsx-runtime").JSX.Element;
+export { Command, CommandInput, CommandList, CommandEmpty, CommandGroup, CommandItem, CommandSeparator, CommandShortcut };
+export type { CommandProps, CommandInputProps, CommandItemProps };

package/dist/types/primitives/context-ring.d.ts

@@ -0,0 +1,15 @@
+import { type ComponentProps } from "react";
+import { type RingTone } from "@exponential_app/eui/web/primitives";
+import { Button } from "./button.js";
+export { RING_RADIUS, RING_SIZE, RING_STROKE, RING_TONE_CLASS, ringGeometry } from "@exponential_app/eui/web/primitives";
+export type { RingGeometry, RingTone } from "@exponential_app/eui/web/primitives";
+interface ContextRingProps extends ComponentProps<typeof Button> {
+    /** How full the context window is — null while nothing measured it. */
+    percent: number | null | undefined;
+    /** Which of the three tones to paint. Default: `normal`. */
+    tone?: RingTone;
+    /** Draw the empty track anyway (the run has other usage worth opening).
+     *  Without it, a run with no context window renders NOTHING. */
+    showEmpty?: boolean;
+}
+export declare const ContextRing: import("react").ForwardRefExoticComponent<Omit<ContextRingProps, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;

package/dist/types/primitives/dialog-arms.d.ts

@@ -0,0 +1,2 @@
+export { MOBILE_ALERT, MOBILE_ARMS, MOBILE_PAGE, MOBILE_SHEET, MOBILE_SHEET_FULL } from "@exponential_app/eui/web/primitives";
+export type { DialogMobileArm } from "@exponential_app/eui/web/primitives";

package/dist/types/primitives/dialog.d.ts

@@ -0,0 +1,32 @@
+import * as React from "react";
+import { Dialog as DialogPrimitive } from "radix-ui";
+import { Button } from "./button.js";
+import { type DialogMobileArm } from "./dialog-arms.js";
+declare function Dialog({ ...props }: React.ComponentProps<typeof DialogPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function DialogTrigger({ ...props }: React.ComponentProps<typeof DialogPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function DialogPortal({ ...props }: React.ComponentProps<typeof DialogPrimitive.Portal>): import("react/jsx-runtime").JSX.Element;
+declare function DialogClose({ ...props }: React.ComponentProps<typeof DialogPrimitive.Close>): import("react/jsx-runtime").JSX.Element;
+declare function DialogOverlay({ className, ...props }: React.ComponentProps<typeof DialogPrimitive.Overlay>): import("react/jsx-runtime").JSX.Element;
+/** The `< sm` presentation of the enclosing dialog, for chrome that differs
+ * per arm (the ✕, DialogCancel). `null` outside a DialogContent. */
+declare const DialogPresentationContext: React.Context<DialogMobileArm | null>;
+declare function DialogContent({ className, children, showCloseButton, mobile, ref, onInteractOutside, ...props }: React.ComponentProps<typeof DialogPrimitive.Content> & {
+    showCloseButton?: boolean;
+    /** How the dialog presents below `sm` (EXP-687). Defaults to the bottom
+     * `sheet`; the `sm:` presentation is identical for every arm. See
+     * ui/dialog-arms.ts for what each one means. */
+    mobile?: DialogMobileArm;
+}): import("react/jsx-runtime").JSX.Element;
+declare function DialogHeader({ className, ...props }: React.ComponentProps<`div`>): import("react/jsx-runtime").JSX.Element;
+declare function DialogBody({ className, ...props }: React.ComponentProps<`div`>): import("react/jsx-runtime").JSX.Element;
+declare function DialogFooter({ className, ...props }: React.ComponentProps<`div`>): import("react/jsx-runtime").JSX.Element;
+/**
+ * The Cancel of a dialog footer (EXP-687). Hidden on a phone for the sheet
+ * arms — a sheet is dismissed by dragging it down or tapping outside, so a
+ * Cancel button is redundant chrome — and visible for `alert`/`page`, where
+ * native platforms keep it. Desktop is unchanged: a ghost button.
+ */
+declare function DialogCancel({ className, children, ...props }: React.ComponentProps<typeof Button>): import("react/jsx-runtime").JSX.Element;
+declare function DialogTitle({ className, ...props }: React.ComponentProps<typeof DialogPrimitive.Title>): import("react/jsx-runtime").JSX.Element;
+declare function DialogDescription({ className, ...props }: React.ComponentProps<typeof DialogPrimitive.Description>): import("react/jsx-runtime").JSX.Element;
+export { Dialog, DialogBody, DialogCancel, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogPresentationContext, DialogTitle, DialogTrigger, };

package/dist/types/primitives/disclosure-header.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+export declare function DisclosureHeader({ open, onToggle, chevron, className, children, ...props }: Omit<React.ComponentProps<`button`>, `onClick` | `type` | `aria-expanded` | `children`> & {
+    open: boolean;
+    onToggle: () => void;
+    chevron?: `leading` | `trailing`;
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/primitives/dock-card.d.ts

@@ -0,0 +1,43 @@
+import * as React from "react";
+import { type DockCardTint } from "@exponential_app/eui/web/primitives";
+type Glyph = React.ComponentType<{
+    className?: string;
+    "data-slot"?: string;
+    "aria-hidden"?: boolean;
+}>;
+export type DockCardProps = Omit<React.ComponentProps<`div`>, `title` | `children`> & {
+    tint?: DockCardTint;
+    /** The kind glyph (a component; the card sizes and tints it). */
+    icon?: Glyph;
+    label: React.ReactNode;
+    caption?: React.ReactNode;
+    meta?: React.ReactNode;
+    title: React.ReactNode;
+    /** The card opens: the trailing chevron, a button role, Enter / Space. */
+    onOpen?: () => void;
+    /** Without `onOpen`: a trailing node (a banner's action). */
+    trailing?: React.ReactNode;
+    /** A card behind the front one while piled: its chrome peeks, its words do not. */
+    hidden?: boolean;
+    /** The accessible name of a card that opens (default: no override). */
+    openLabel?: string;
+};
+export declare function DockCard({ tint, icon: Icon, label, caption, meta, title, onOpen, trailing, hidden, openLabel, className, onKeyDown, ...props }: DockCardProps): import("react/jsx-runtime").JSX.Element;
+export interface DockPileItem {
+    id: string;
+    /** The card (a `DockCard`; pass `hidden` for the ones behind the front). */
+    node: React.ReactNode;
+    /** A known height (px) instead of the measured one (specimens, tests). */
+    height?: number;
+}
+export type DockPileProps = Omit<React.ComponentProps<`div`>, `children`> & {
+    /** Oldest first: the LAST item is the front card. */
+    items: readonly DockPileItem[];
+    /** Fanned: every card at full size, `gap` apart. */
+    expanded: boolean;
+    /** A pointer entering/leaving the pile or the focus moving in/out of it. */
+    onExpandedChange?: (expanded: boolean) => void;
+};
+export declare function DockPile({ items, expanded, onExpandedChange, className, style, ...props }: DockPileProps): import("react/jsx-runtime").JSX.Element;
+export { DOCK_CARD_CLASSES, DOCK_PILE_CLASSES, DOCK_PILE_CONSTANTS, dockPileGeometry } from "@exponential_app/eui/web/primitives";
+export type { DockCardTint } from "@exponential_app/eui/web/primitives";

package/dist/types/primitives/dropdown-menu.d.ts

@@ -0,0 +1,26 @@
+import * as React from "react";
+import { DropdownMenu as DropdownMenuPrimitive } from "radix-ui";
+declare function DropdownMenu({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuPortal({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Portal>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuTrigger({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuContent({ className, sideOffset, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuGroup({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Group>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuItem({ className, inset, variant, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Item> & {
+    inset?: boolean;
+    variant?: `default` | `destructive`;
+}): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuCheckboxItem({ className, children, checked, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.CheckboxItem>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuRadioGroup({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.RadioGroup>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuRadioItem({ className, children, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.RadioItem>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuLabel({ className, inset, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Label> & {
+    inset?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuSeparator({ className, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Separator>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuShortcut({ className, ...props }: React.ComponentProps<`span`>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuSub({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Sub>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuSubTrigger({ className, inset, children, variant, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.SubTrigger> & {
+    inset?: boolean;
+    variant?: `default` | `destructive`;
+}): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuSubContent({ className, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.SubContent>): import("react/jsx-runtime").JSX.Element;
+export { DropdownMenu, DropdownMenuPortal, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuGroup, DropdownMenuLabel, DropdownMenuItem, DropdownMenuCheckboxItem, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubTrigger, DropdownMenuSubContent, };

package/dist/types/primitives/empty-state.d.ts

@@ -0,0 +1,19 @@
+import type { ComponentProps } from "react";
+import type { LucideIcon } from "lucide-react";
+import { type EmptyStateSize } from "@exponential_app/eui/web/primitives";
+export { EMPTY_STATE_SIZES } from "@exponential_app/eui/web/primitives";
+export type { EmptyStateSize } from "@exponential_app/eui/web/primitives";
+export declare function EmptyState({ icon: Icon, title, description, size, className, children, }: {
+    icon?: LucideIcon;
+    title: string;
+    description?: string;
+    size?: EmptyStateSize;
+    className?: string;
+    children?: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function ListEmpty({ className, children, ...props }: Omit<ComponentProps<`p`>, `title`>): import("react/jsx-runtime").JSX.Element;
+export declare function EmptyCta({ icon: Icon, title, description, className, type, ...props }: Omit<ComponentProps<`button`>, `children` | `title`> & {
+    icon: LucideIcon;
+    title: string;
+    description: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/primitives/glass-card.d.ts

@@ -0,0 +1,3 @@
+import * as React from "react";
+export { GLASS_CARD_CLASS, GLASS_CARD_CLASSES } from "@exponential_app/eui/web/primitives";
+export declare function GlassCard({ className, ...props }: React.ComponentProps<`div`>): import("react/jsx-runtime").JSX.Element;

package/dist/types/primitives/hover-card.d.ts

@@ -0,0 +1,6 @@
+import * as React from "react";
+import { HoverCard as HoverCardPrimitive } from "radix-ui";
+declare function HoverCard({ openDelay, closeDelay, ...props }: React.ComponentProps<typeof HoverCardPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function HoverCardTrigger({ ...props }: React.ComponentProps<typeof HoverCardPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function HoverCardContent({ className, align, sideOffset, ...props }: React.ComponentProps<typeof HoverCardPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+export { HoverCard, HoverCardTrigger, HoverCardContent };

package/dist/types/primitives/icon-disc.d.ts

@@ -0,0 +1,10 @@
+import type { LucideIcon } from "lucide-react";
+import { type IconDiscTone } from "@exponential_app/eui/web/primitives";
+export { ICON_DISC_TONES } from "@exponential_app/eui/web/primitives";
+export type { IconDiscTone } from "@exponential_app/eui/web/primitives";
+export declare function IconDisc({ icon: Icon, tone, strokeWidth, className, }: {
+    icon: LucideIcon;
+    tone?: IconDiscTone;
+    strokeWidth?: number;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;