@imfusion/web-ui 0.11.1-dev.7.gf073da2b → 0.11.1-dev.71.g25428988

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

@@ -0,0 +1,171 @@
+import { Combobox as ComboboxPrimitive } from '@base-ui/react/combobox';
+import { Separator as SeparatorPrimitive } from '@base-ui/react/separator';
+import { VariantProps } from 'class-variance-authority';
+import { comboboxRoot } from './combobox.cva';
+type UpstreamItem = React.ComponentProps<typeof ComboboxPrimitive.Item>;
+interface RootProps<Value = unknown, Multiple extends boolean | undefined = false> extends React.ComponentProps<typeof ComboboxPrimitive.Root<Value, Multiple>> {
+    /** Field width: `auto` keeps the compact minimum; `wide` raises it; `full` fills the parent. @default "auto" */
+    width?: VariantProps<typeof comboboxRoot>["width"];
+}
+/**
+ * Combobox.Root — text input with a filterable list of options, for choosing one or several.
+ *
+ * Wraps children in a div so a sibling Combobox.Label stacks above the field regardless of the parent's layout.
+ * Combobox.Portal is unaffected (it renders to document.body).
+ *
+ * @doc https://base-ui.com/react/components/combobox
+ * @llm https://base-ui.com/react/components/combobox.md
+ */
+export declare function Root<Value = unknown, Multiple extends boolean | undefined = false>({ width, className, style, ...props }: RootProps<Value, Multiple> & {
+    className?: string;
+    style?: React.CSSProperties;
+}): import("react/jsx-runtime").JSX.Element;
+export declare namespace Root {
+    var displayName: string;
+}
+/** Combobox.Label — visible label, for the trigger in the input-inside-popup pattern. Label an input with `Field.Label`. */
+export declare function Label(props: React.ComponentProps<typeof ComboboxPrimitive.Label>): import("react/jsx-runtime").JSX.Element;
+export declare namespace Label {
+    var displayName: string;
+}
+/** Combobox.InputGroup — the field box that holds the input, clear button, and trigger. */
+export declare function InputGroup(props: React.ComponentProps<typeof ComboboxPrimitive.InputGroup>): import("react/jsx-runtime").JSX.Element;
+export declare namespace InputGroup {
+    var displayName: string;
+}
+/** Combobox.Input — the text input that filters the list. An `inline` list is always open, so `aria-expanded` defaults to true. */
+export declare function Input(props: React.ComponentProps<typeof ComboboxPrimitive.Input>): import("react/jsx-runtime").JSX.Element;
+export declare namespace Input {
+    var displayName: string;
+}
+/** Combobox.Trigger — button that opens the popup. Without children it draws a chevron. */
+export declare function Trigger({ children, ...props }: React.ComponentProps<typeof ComboboxPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+export declare namespace Trigger {
+    var displayName: string;
+}
+/** Combobox.Icon — visual indicator (chevron) inside the trigger. */
+export declare function Icon(props: React.ComponentProps<typeof ComboboxPrimitive.Icon>): import("react/jsx-runtime").JSX.Element;
+export declare namespace Icon {
+    var displayName: string;
+}
+/** Combobox.Clear — button that clears the value. Without children it draws a cross. */
+export declare function Clear({ children, ...props }: React.ComponentProps<typeof ComboboxPrimitive.Clear>): import("react/jsx-runtime").JSX.Element;
+export declare namespace Clear {
+    var displayName: string;
+}
+/** Combobox.Value — renders the selected value, or the placeholder. */
+export declare function Value(props: React.ComponentProps<typeof ComboboxPrimitive.Value>): import("react/jsx-runtime").JSX.Element;
+export declare namespace Value {
+    var displayName: string;
+}
+/** Combobox.Chips — the field box of a multiple combobox, holding chips and the input. */
+export declare function Chips(props: React.ComponentProps<typeof ComboboxPrimitive.Chips>): import("react/jsx-runtime").JSX.Element;
+export declare namespace Chips {
+    var displayName: string;
+}
+/** Combobox.Chip — one selected value in the field. */
+export declare function Chip(props: React.ComponentProps<typeof ComboboxPrimitive.Chip>): import("react/jsx-runtime").JSX.Element;
+export declare namespace Chip {
+    var displayName: string;
+}
+/** Combobox.ChipRemove — button that removes its chip. Without children it draws a small cross; give it an `aria-label`. */
+export declare function ChipRemove({ children, ...props }: React.ComponentProps<typeof ComboboxPrimitive.ChipRemove>): import("react/jsx-runtime").JSX.Element;
+export declare namespace ChipRemove {
+    var displayName: string;
+}
+/** Combobox.Portal — portals the popup tree to document.body (or a custom container). */
+export declare function Portal(props: React.ComponentProps<typeof ComboboxPrimitive.Portal>): import("react/jsx-runtime").JSX.Element;
+export declare namespace Portal {
+    var displayName: string;
+}
+/** Combobox.Backdrop — overlay behind the popup (visible only in modal mode). */
+export declare function Backdrop(props: React.ComponentProps<typeof ComboboxPrimitive.Backdrop>): import("react/jsx-runtime").JSX.Element;
+export declare namespace Backdrop {
+    var displayName: string;
+}
+/** Combobox.Positioner — positions the popup relative to the field. */
+export declare function Positioner({ align, sideOffset, ...props }: React.ComponentProps<typeof ComboboxPrimitive.Positioner>): import("react/jsx-runtime").JSX.Element;
+export declare namespace Positioner {
+    var displayName: string;
+}
+/** Combobox.Popup — dropdown surface. It keeps the height it had when it opened while the list filters. */
+export declare function Popup(props: React.ComponentProps<typeof ComboboxPrimitive.Popup>): import("react/jsx-runtime").JSX.Element;
+export declare namespace Popup {
+    var displayName: string;
+}
+/** Combobox.Arrow — pointer arrow attached to the popup. */
+export declare function Arrow(props: React.ComponentProps<typeof ComboboxPrimitive.Arrow>): import("react/jsx-runtime").JSX.Element;
+export declare namespace Arrow {
+    var displayName: string;
+}
+/** Combobox.Status — live-region line for loading and result counts, announced to screen readers. */
+export declare function Status(props: React.ComponentProps<typeof ComboboxPrimitive.Status>): import("react/jsx-runtime").JSX.Element;
+export declare namespace Status {
+    var displayName: string;
+}
+/** Combobox.Empty — message shown while no item matches. */
+export declare function Empty(props: React.ComponentProps<typeof ComboboxPrimitive.Empty>): import("react/jsx-runtime").JSX.Element;
+export declare namespace Empty {
+    var displayName: string;
+}
+/** Combobox.List — items container. An `inline` list keeps the height it had when it mounted while it filters. */
+export declare function List(props: React.ComponentProps<typeof ComboboxPrimitive.List>): import("react/jsx-runtime").JSX.Element;
+export declare namespace List {
+    var displayName: string;
+}
+/** Combobox.Row — one row of a `grid` list. */
+export declare function Row(props: React.ComponentProps<typeof ComboboxPrimitive.Row>): import("react/jsx-runtime").JSX.Element;
+export declare namespace Row {
+    var displayName: string;
+}
+/** Combobox.Collection — renders a list of items inside a group. */
+export declare function Collection(props: React.ComponentProps<typeof ComboboxPrimitive.Collection>): import("react/jsx-runtime").JSX.Element;
+export declare namespace Collection {
+    var displayName: string;
+}
+interface ItemProps extends Omit<UpstreamItem, "value"> {
+    value: UpstreamItem["value"];
+}
+/** Combobox.Item — individual selectable option. */
+export declare function Item(props: ItemProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Item {
+    var displayName: string;
+}
+/**
+ * Combobox.ItemIndicator — marker inside the item. Without children a single combobox draws a check in the selected
+ * item, and a `multiple` combobox draws a checkbox box on every item, checked when selected.
+ */
+export declare function ItemIndicator({ children, keepMounted, render, ...props }: React.ComponentProps<typeof ComboboxPrimitive.ItemIndicator>): import("react/jsx-runtime").JSX.Element;
+export declare namespace ItemIndicator {
+    var displayName: string;
+}
+/** Combobox.ItemText — text label for an item, beside the indicator. */
+export declare function ItemText(props: React.ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
+export declare namespace ItemText {
+    var displayName: string;
+}
+/** Combobox.ItemDescription — a muted second line under an item's text, such as an email address. */
+export declare function ItemDescription(props: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+export declare namespace ItemDescription {
+    var displayName: string;
+}
+/** Combobox.Group — wrapper around a grouped set of items. */
+export declare function Group(props: React.ComponentProps<typeof ComboboxPrimitive.Group>): import("react/jsx-runtime").JSX.Element;
+export declare namespace Group {
+    var displayName: string;
+}
+/** Combobox.GroupLabel — heading for a Combobox.Group. */
+export declare function GroupLabel(props: React.ComponentProps<typeof ComboboxPrimitive.GroupLabel>): import("react/jsx-runtime").JSX.Element;
+export declare namespace GroupLabel {
+    var displayName: string;
+}
+/** Combobox.Separator — thin divider between items. */
+export declare function Separator(props: React.ComponentProps<typeof SeparatorPrimitive>): import("react/jsx-runtime").JSX.Element;
+export declare namespace Separator {
+    var displayName: string;
+}
+/** The upstream hook that builds a `filter` function from locale and match options. */
+export declare const useFilter: typeof ComboboxPrimitive.useFilter;
+/** Reads the filtered items inside a combobox, for a custom list renderer. */
+export declare const useFilteredItems: typeof ComboboxPrimitive.useFilteredItems;
+export {};

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

@@ -0,0 +1,2 @@
+import { ComponentMeta } from '../../types/meta';
+export declare const comboboxMeta: ComponentMeta;

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

@@ -0,0 +1,2 @@
+export * as Combobox from './combobox';
+export { comboboxMeta } from './combobox.meta';

package/dist/components/dialog/dialog.d.ts

@@ -1,3 +1,4 @@
+import { AlertDialog as AlertDialogPrimitive } from '@base-ui/react/alert-dialog';
 import { Dialog as DialogPrimitive } from '@base-ui/react/dialog';
 import { VariantProps } from 'class-variance-authority';
 import * as ScrollArea from '../scroll-area/scroll-area';
@@ -102,7 +103,7 @@ export declare function Close(props: React.ComponentProps<typeof DialogPrimitive
 export declare namespace Close {
     var displayName: string;
 }
-type ComposedProps = Omit<React.ComponentProps<typeof DialogPrimitive.Root>, "children"> & {
+type ContentProps = {
     /** Heading of the dialog. */
     title: React.ReactNode;
     /** Short uppercase label above the title. */
@@ -127,6 +128,7 @@ type ComposedProps = Omit<React.ComponentProps<typeof DialogPrimitive.Root>, "ch
     /** Content of the body. */
     children?: React.ReactNode;
 };
+type ComposedProps = Omit<React.ComponentProps<typeof DialogPrimitive.Root>, "children"> & ContentProps;
 type SimpleProps = ComposedProps & {
     /** Element rendered as the trigger, such as a `Button`. Omit it for a controlled dialog. */
     trigger?: React.ReactElement;
@@ -135,7 +137,7 @@ type SimpleProps = ComposedProps & {
  * Dialog.Simple — pre-composed dialog: trigger, header with title, description, and optional status, a scrolling body,
  * and either a close button in the header or a footer of `actions`. Root props pass through.
  */
-export declare function Simple({ trigger, headerVariant, size, ...props }: SimpleProps): import("react/jsx-runtime").JSX.Element;
+export declare function Simple({ trigger, headerVariant, size, eyebrow, title, description, status, actions, children, ...rootProps }: SimpleProps): import("react/jsx-runtime").JSX.Element;
 export declare namespace Simple {
     var displayName: string;
 }
@@ -144,8 +146,26 @@ type InlineProps = ComposedProps & {
     trigger: React.ReactNode;
 };
 /** Dialog.Inline — like Dialog.Simple, but the trigger is text inside a sentence. */
-export declare function Inline({ trigger, headerVariant, size, ...props }: InlineProps): import("react/jsx-runtime").JSX.Element;
+export declare function Inline({ trigger, headerVariant, size, eyebrow, title, description, status, actions, children, ...rootProps }: InlineProps): import("react/jsx-runtime").JSX.Element;
 export declare namespace Inline {
     var displayName: string;
 }
+type AlertProps = Omit<React.ComponentProps<typeof AlertDialogPrimitive.Root>, "children"> & Omit<ContentProps, "headerVariant" | "actions"> & {
+    /** Element rendered as the trigger, such as a `Button`. Omit it for a controlled dialog. */
+    trigger?: React.ReactElement;
+    /** Buttons of the footer, the only way out. Include a Cancel `Dialog.Close`. */
+    actions: React.ReactNode;
+};
+/**
+ * Dialog.Alert — pre-composed confirmation that interrupts the user, announced as an `alertdialog`. Always modal; a click
+ * on the overlay does not close it, Escape does. Like Dialog.Simple, without a header close button. Root props pass
+ * through.
+ *
+ * @see https://base-ui.com/react/components/alert-dialog
+ * @llm https://base-ui.com/react/components/alert-dialog.md
+ */
+export declare function Alert({ trigger, size, eyebrow, title, description, status, actions, children, ...rootProps }: AlertProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Alert {
+    var displayName: string;
+}
 export {};

package/dist/components/file-drop-zone/collect-files.d.ts

@@ -0,0 +1,56 @@
+export interface FileDropZoneItem {
+    file: File;
+    /** Folder-relative path with the root folder's name first (`"scans/s1.nii.gz"`), or the file name for a loose file. */
+    path: string;
+}
+export interface CollectResult {
+    accepted: FileDropZoneItem[];
+    rejected: FileDropZoneItem[];
+}
+interface CollectOptions {
+    accept?: string[];
+    directory: boolean;
+    multiple: boolean;
+}
+/** The part of a `FileSystemEntry` the walk reads. */
+export interface EntryLike {
+    readonly isFile: boolean;
+    readonly isDirectory: boolean;
+    readonly name: string;
+    readonly fullPath: string;
+}
+/** What the synchronous part of a `drop` handler can read; the drag data store is gone after the first `await`. */
+interface DropSource {
+    entry: EntryLike | null;
+    file: File | null;
+}
+/** The part of a `DataTransfer` that `snapshotDrop` reads. */
+interface DropData {
+    items: ArrayLike<{
+        kind: string;
+        webkitGetAsEntry: () => EntryLike | null;
+        getAsFile: () => File | null;
+    }>;
+    files: ArrayLike<File>;
+}
+export type DragState = "idle" | "accepting" | "rejecting";
+export declare function matchesAccept(file: File, accept?: string[]): boolean;
+/**
+ * A drag shows each item's MIME type but never its name, so only a type that is known to come from other extensions
+ * than the accepted ones is judged `"rejecting"`. A type missing from the table, an empty one, or an empty item list
+ * (Safari lists no items during a drag) stays `"accepting"`.
+ */
+export declare function classifyDrag(items: ArrayLike<{
+    kind: string;
+    type: string;
+}>, accept?: string[]): DragState;
+/** Reads every `webkitGetAsEntry()` and `getAsFile()` of a drop. Call it synchronously inside the `drop` handler. */
+export declare function snapshotDrop(dataTransfer: DropData): DropSource[];
+export declare function collectFromDrop(sources: DropSource[], options: CollectOptions): Promise<CollectResult>;
+/** Files from a picker. A folder pick carries `webkitRelativePath`, which includes the chosen folder's name. */
+export declare function collectFromFileList(files: File[], options: CollectOptions & {
+    fromFolder: boolean;
+}): CollectResult;
+/** Names the accepted types for copy: `[".png", ".jpg", ".jpeg", ".webp"]` becomes "PNG, JPEG or WebP". Empty without a list. */
+export declare function describeAccept(accept?: string[]): string;
+export {};

package/dist/components/file-drop-zone/file-drop-zone-context.d.ts

@@ -0,0 +1,15 @@
+export type FileDropZoneSize = "sm" | "md" | "lg";
+interface FileDropZoneContextValue {
+    size: FileDropZoneSize;
+    disabled: boolean;
+    directory: boolean;
+    /** Whether a `FileDropZone.File` is mounted. */
+    filled: boolean;
+    openPicker: (mode: "files" | "folder") => void;
+    setFilled: (filled: boolean) => void;
+    registerTitle: (id: string | null) => void;
+    registerDescription: (id: string | null) => void;
+}
+/** What `FileDropZone.Root` hands to its parts; a part outside a Root reads the inert defaults. */
+export declare const FileDropZoneContext: import('react').Context<FileDropZoneContextValue>;
+export {};

package/dist/components/file-drop-zone/file-drop-zone.d.ts

@@ -0,0 +1,185 @@
+import { VariantProps } from 'class-variance-authority';
+import { Button } from '../button';
+import { Icon, IconComponent } from '../icon';
+import { IconButton } from '../icon-button';
+import { DragState, FileDropZoneItem } from './collect-files';
+declare const root: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+type RootProps = React.ComponentProps<"div"> & VariantProps<typeof root> & {
+    /** Accepted file types: extensions (`".nii.gz"`), MIME types (`"image/png"`) or wildcards (`"image/*"`). Any file when empty. */
+    accept?: string[];
+    /** Whether more than one file can be added at once. With `false`, only the first accepted file is kept. */
+    multiple?: boolean;
+    /** Whether folders can be dropped or picked. They are scanned recursively. Needs `multiple`. */
+    directory?: boolean;
+    /** Blocks dropping and picking; the Triggers follow. */
+    disabled?: boolean;
+    /** Marks the zone as holding a problem. The message belongs in `Field.Error` or a `Callout`. */
+    invalid?: boolean;
+    /** Called once per drop or pick with the files that match `accept` and those that do not. */
+    onFilesAdded?: (accepted: FileDropZoneItem[], rejected: FileDropZoneItem[]) => void;
+    /**
+     * Called when a drag over the zone starts, changes or ends. `"rejecting"` is reported only for a dragged type the
+     * browser exposes and `accept` cannot produce; names and counts are unknown until the drop.
+     */
+    onDragStateChange?: (state: DragState) => void;
+    /** Words for the screen reader status after each drop or pick. Return `""` to stay silent. */
+    formatStatus?: (accepted: number, rejected: number) => string;
+};
+/**
+ * FileDropZone.Root — a group that collects files and folders by drop or by its Triggers and reports them through
+ * `onFilesAdded`. The Triggers are the keyboard and screen reader path; dropping is an enhancement.
+ */
+export declare function Root({ accept, multiple, directory, size, disabled, invalid, onFilesAdded, onDragStateChange, formatStatus, children, className, "aria-labelledby": ariaLabelledBy, "aria-describedby": ariaDescribedBy, onDragEnter, onDragOver, onDragLeave, onDrop, ...props }: RootProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Root {
+    var displayName: string;
+}
+/** FileDropZone.Title — names the group. */
+export declare function Title(props: React.ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
+export declare namespace Title {
+    var displayName: string;
+}
+/** FileDropZone.Description — describes the group, such as the accepted file types. */
+export declare function Description(props: React.ComponentProps<"p">): import("react/jsx-runtime").JSX.Element;
+export declare namespace Description {
+    var displayName: string;
+}
+/** FileDropZone.Actions — the row of Triggers. */
+export declare function Actions(props: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+export declare namespace Actions {
+    var displayName: string;
+}
+type FileProps = React.ComponentProps<"div"> & {
+    /** The single file the zone holds. Its name shows middle-truncated, with the last 12 characters kept, and its size in mono. */
+    file: globalThis.File;
+};
+/**
+ * FileDropZone.File — the file a single-file zone holds, in place of `Title` and `Description`. It names the group,
+ * describes it with the size, and sets `data-filled` on the Root while mounted. Long names truncate in the middle so the
+ * extension stays readable; the full name is the `title`.
+ */
+export declare function File({ file, className, ...props }: FileProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace File {
+    var displayName: string;
+}
+type IconButtonProps = React.ComponentProps<typeof IconButton>;
+type RemoveProps = Omit<IconButtonProps, "glyph" | "label"> & {
+    /** Accessible name of the button. Defaults to "Remove file". */
+    label?: string;
+    /** Defaults to `"ghost"` in an `sm` zone and `"outline"` otherwise. */
+    variant?: IconButtonProps["variant"];
+    /** Defaults to `"md"` in an `lg` zone and `"sm"` otherwise. */
+    size?: IconButtonProps["size"];
+    /** Defaults to the zone's `disabled`. */
+    disabled?: IconButtonProps["disabled"];
+};
+/** FileDropZone.Remove — an icon button that empties a filled zone. It carries no behavior of its own: `onClick` clears the consumer's state. */
+export declare function Remove({ label, variant, size, disabled, ...props }: RemoveProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Remove {
+    var displayName: string;
+}
+type GlyphProps = Omit<React.ComponentProps<typeof Icon>, "glyph"> & {
+    /** Icon component imported from `@imfusion/web-ui/icons`. Defaults to `UploadSquare`, or `Page` while a File is mounted. */
+    glyph?: IconComponent;
+};
+/** FileDropZone.Glyph — the large icon of the `lg` zone: the upload icon, or a page while a `FileDropZone.File` is mounted. It renders nothing in `sm` and `md`. */
+export declare function Glyph({ glyph, size, ...props }: GlyphProps): import("react/jsx-runtime").JSX.Element | null;
+export declare namespace Glyph {
+    var displayName: string;
+}
+type ButtonProps = React.ComponentProps<typeof Button>;
+type TriggerProps = ButtonProps & {
+    /** `"files"` opens the file picker, `"folder"` the folder picker. A folder Trigger needs `directory` on the Root. */
+    mode?: "files" | "folder";
+    /** Defaults to `"ghost"` in an `sm` zone and `"outline"` otherwise. */
+    variant?: ButtonProps["variant"];
+    /** Defaults to `"md"` in an `lg` zone and `"sm"` otherwise. */
+    size?: ButtonProps["size"];
+    /** Defaults to the zone's `disabled`. */
+    disabled?: ButtonProps["disabled"];
+};
+/** FileDropZone.Trigger — a Button that opens the picker. */
+export declare function Trigger({ mode, variant, size, disabled, onClick, ...props }: TriggerProps): import("react/jsx-runtime").JSX.Element | null;
+export declare namespace Trigger {
+    var displayName: string;
+}
+export interface FileDropZoneUploadItem {
+    /** Identifies the row in `onRemove`. */
+    id: string;
+    file: globalThis.File;
+    /** Shown instead of the file name, such as a folder-relative path. */
+    path?: string;
+    /** `"queued"` and `"error"` rows list the file with a Remove button; `"uploading"` and `"done"` rows show a progress bar. */
+    status: "queued" | "uploading" | "done" | "error";
+    /** From 0 to 100 while `"uploading"`; `null` while the amount is unknown. */
+    progress?: number | null;
+}
+interface UploadLabels {
+    chooseFiles: string;
+    chooseFolder: string;
+    /** Text of the upload button, from the number of queued items. */
+    upload: (queued: number) => string;
+    /** Text beside "Start over" once the upload has finished, from the number of items done and failed. */
+    uploaded: (done: number, failed: number) => string;
+    overall: string;
+    startOver: string;
+    uploading: string;
+    done: string;
+    failed: string;
+    waiting: string;
+    /** Accessible name of the file list. */
+    files: string;
+    dropToAdd: string;
+    cantAdd: string;
+    releaseToAdd: (multiple: boolean) => string;
+    /** Hint while a drag the zone cannot accept is over it, from the named accepted types ("" without `accept`). */
+    addTypes: (types: string) => string;
+    remove: (name: string) => string;
+    retry: string;
+    /** Accessible name of a row's Retry button. */
+    retryName: (name: string) => string;
+    /** The note under the zone. `types` is set only when every skipped file failed the `accept` check. */
+    skipped: (info: {
+        count: number;
+        paths: string[];
+        types: string;
+    }) => string;
+    /** Screen reader announcement when the upload starts. */
+    uploadingStatus: (count: number) => string;
+}
+type UploadProps = Omit<RootProps, "children" | "directory" | "title" | "onReset"> & {
+    /** The files to list, in order. The app owns this list and each item's `status` and `progress`. */
+    items: FileDropZoneUploadItem[];
+    /** Called with the `id` of the row whose Remove button was pressed. */
+    onRemove: (id: string) => void;
+    /** Called when the upload button is pressed. The app starts the upload and moves the queued items to `"uploading"`. */
+    onUpload: () => void;
+    /**
+     * Called with the `id` of a failed row whose Retry button was pressed. The app sends the file again and moves the row
+     * back to `"uploading"`. Failed rows show Retry only when this is set.
+     */
+    onRetry?: (id: string) => void;
+    /** Called by "Start over" once every item is done or failed. The button shows only when this is set. */
+    onReset?: () => void;
+    /** Heading of the card around the zone and the list. */
+    heading?: React.ReactNode;
+    /** Title of the zone. Defaults to "Drop files or a folder", or "Drop a file" without `multiple`. */
+    title?: React.ReactNode;
+    /** Text under the zone title. Defaults to the accepted types, such as "PNG, JPEG or WebP", and a note that folders are scanned. */
+    description?: React.ReactNode;
+    /** Whether the zone takes whole folders, with a "Choose folder" button. Needs `multiple`. */
+    folders?: boolean;
+    /** Replaces any of the English texts: the button texts, the drag copy, the row states, the skipped note, the finished text. */
+    labels?: Partial<UploadLabels>;
+};
+/**
+ * FileDropZone.Upload — the upload sequence in one piece: a zone, the list of collected files to check and remove, a
+ * `Progress` per row and overall once the upload runs, and the upload button. It is controlled and uploads nothing: the app
+ * keeps `items`, performs the upload, and reports each item's `status` and `progress`. Other props go to the zone.
+ */
+export declare function Upload({ items, onRemove, onUpload, onRetry, onReset, heading, title, description, folders, labels, size, multiple, accept, disabled, onFilesAdded, onDragStateChange, ...zoneProps }: UploadProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Upload {
+    var displayName: string;
+}
+export {};

package/dist/components/file-drop-zone/file-drop-zone.meta.d.ts

@@ -0,0 +1,2 @@
+import { ComponentMeta } from '../../types/meta';
+export declare const fileDropZoneMeta: ComponentMeta;

package/dist/components/file-drop-zone/format-bytes.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Formats a size such as "3.1 MB", in the unit that suits `scale` (the size itself by default). `digits` sets the decimals;
+ * by default one below ten units and none above. Bytes have none.
+ */
+export declare function formatBytes(bytes: number, scale?: number, digits?: number): string;

package/dist/components/file-drop-zone/index.d.ts

@@ -0,0 +1,4 @@
+export * as FileDropZone from './file-drop-zone';
+export type { FileDropZoneItem } from './collect-files';
+export type { FileDropZoneUploadItem } from './file-drop-zone';
+export { fileDropZoneMeta } from './file-drop-zone.meta';

package/dist/components/image/image.d.ts

@@ -0,0 +1,50 @@
+import { VariantProps } from 'class-variance-authority';
+declare const root: (props?: ({
+    radius?: "none" | "round" | "sm" | "md" | "lg" | null | undefined;
+    fit?: "contain" | "cover" | null | undefined;
+    border?: "none" | "single" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+type Props = Omit<React.ComponentProps<"img">, "width" | "height" | "alt" | "className" | "style" | "src" | "srcSet" | "sizes" | "loading" | "decoding"> & VariantProps<typeof root> & {
+    /** Address of the fallback `<img>`. */
+    src: string;
+    /** Width candidates of the fallback `<img>`. */
+    srcSet?: string;
+    /** Slot width the browser plans for, shared by both `<source>` elements and the `<img>`. */
+    sizes?: string;
+    /** `lazy` defers the request until the image nears the viewport. */
+    loading?: "lazy" | "eager";
+    /** `async` decodes off the main thread. */
+    decoding?: "async" | "sync" | "auto";
+    /** Describes the image. Pass `""` to mark it decorative. */
+    alt: string;
+    /** Intrinsic width in pixels. Together with `height` it reserves the box before the image loads. */
+    width: number;
+    /** Intrinsic height in pixels. */
+    height: number;
+    /** AVIF candidates for the `<picture>`, offered before WebP. */
+    avifSrcSet?: string;
+    /** WebP candidates for the `<picture>`, offered after AVIF. */
+    webpSrcSet?: string;
+    /** Hairline width in `border-size` steps. Applies with `border="single"`. */
+    borderWidth?: 1 | 2 | 3;
+    /** Width divided by height of the box. Defaults to `width / height`; the picture crops or letterboxes per `fit`. */
+    aspectRatio?: number;
+    /** Loads the image eagerly with high fetch priority. Set it on the page's largest image only. */
+    priority?: boolean;
+    /** Sizing and layout hook on the box around the picture. */
+    className?: string;
+    /** Sizing and layout hook on the box around the picture. */
+    style?: React.CSSProperties;
+};
+/**
+ * Image — a picture box with one `<source>` per format (AVIF, then WebP) and an `<img>` fallback. The browser picks the
+ * format and size. The box reserves `width` by `height` before the image arrives, pulses while it loads, and shows a
+ * glyph when it fails. Also called a photo, thumbnail or media.
+ *
+ * `ref` and every prop not named here reach the `<img>`.
+ */
+export declare function Image({ alt, width, height, avifSrcSet, webpSrcSet, priority, loading, decoding, radius, fit, border, borderWidth, aspectRatio, className, style, ref, ...props }: Props): import("react/jsx-runtime").JSX.Element;
+export declare namespace Image {
+    var displayName: string;
+}
+export {};

package/dist/components/image/image.meta.d.ts

@@ -0,0 +1,2 @@
+import { ComponentMeta } from '../../types/meta';
+export declare const imageMeta: ComponentMeta;

package/dist/components/image/index.d.ts

@@ -0,0 +1,2 @@
+export { Image } from './image';
+export { imageMeta } from './image.meta';

package/dist/components/logo/logo.d.ts

@@ -1,7 +1,7 @@
 import { ReactNode } from 'react';
 import { VariantProps } from 'class-variance-authority';
 declare const logo: (props?: ({
-    size?: "sm" | "md" | "lg" | "hero" | "xl" | "xs" | "fit" | null | undefined;
+    size?: "sm" | "md" | "lg" | "hero" | "xs" | "xl" | "fit" | null | undefined;
     variant?: "inherit" | "main" | "support" | "minor" | "brand" | "oncolor" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 type Props = Omit<React.ComponentProps<"span">, "children"> & VariantProps<typeof logo> & {

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

@@ -0,0 +1,2 @@
+export * as Menu from './menu';
+export { menuMeta } from './menu.meta';