@mechane-ai/elements 0.0.0-stage → 0.4.0

package/dist/packages/content/src/code/use-highlighted-code.d.ts

@@ -0,0 +1,9 @@
+import type { ThemedToken } from '@pierre/highlights';
+type HighlightResult = {
+    readonly code: string;
+    readonly language: string;
+    readonly lines: ReadonlyArray<ReadonlyArray<ThemedToken>>;
+    readonly hasFailed: boolean;
+};
+export declare function useHighlightedCode(code: string, language: string): HighlightResult | undefined;
+export {};

package/dist/packages/content/src/content-link.d.ts

@@ -0,0 +1,8 @@
+import type { ReactNode } from 'react';
+export type ContentLinkProps = {
+    readonly href?: string | undefined;
+    readonly children: ReactNode;
+    readonly title?: string | undefined;
+};
+export declare function contentHref(value: string | undefined): string | undefined;
+export declare function ContentLink({ href, children, title }: ContentLinkProps): ReactNode;

package/dist/packages/content/src/diff/diff-source.d.ts

@@ -0,0 +1,32 @@
+import type { ReactNode } from 'react';
+export type DiffFile = {
+    readonly name: string;
+    readonly code: string;
+    readonly language?: string | undefined;
+};
+export type DiffAnnotation = {
+    readonly file: string;
+    readonly side: 'old' | 'new';
+    readonly line: number;
+    readonly content: ReactNode;
+};
+export type DiffSource = {
+    readonly patch: string;
+    readonly before?: never;
+    readonly after?: never;
+} | {
+    readonly patch?: never;
+    readonly before: DiffFile;
+    readonly after: DiffFile | null;
+} | {
+    readonly patch?: never;
+    readonly before: null;
+    readonly after: DiffFile;
+};
+export type DiffViewerProps = DiffSource & {
+    readonly label: string;
+    readonly layout?: 'unified' | 'split';
+    readonly wrap?: boolean;
+    readonly annotations?: ReadonlyArray<DiffAnnotation>;
+    readonly maxHeight?: number;
+};

package/dist/packages/content/src/diff/diff-viewer.d.ts

@@ -0,0 +1,3 @@
+import type { ReactNode } from 'react';
+import type { DiffViewerProps } from './diff-source.ts';
+export declare function DiffViewer(props: DiffViewerProps): ReactNode;

package/dist/packages/content/src/diff/index.d.ts

@@ -0,0 +1,2 @@
+export type { DiffFile, DiffAnnotation, DiffSource, DiffViewerProps } from './diff-source.ts';
+export { DiffViewer } from './diff-viewer.tsx';

package/dist/packages/content/src/diff/pierre-diff.d.ts

@@ -0,0 +1,14 @@
+import type { FileDiffMetadata } from '@pierre/diffs';
+import type { ReactNode } from 'react';
+import type { DiffAnnotation, DiffSource } from './diff-source.ts';
+type PierreDiffProps = {
+    readonly files: ReadonlyArray<FileDiffMetadata>;
+    readonly layout: 'unified' | 'split';
+    readonly wrap: boolean;
+    readonly annotations: ReadonlyArray<DiffAnnotation>;
+    readonly maxHeight: number;
+    readonly label: string;
+};
+export declare function prepareDiff(source: DiffSource): ReadonlyArray<FileDiffMetadata>;
+export declare function PierreDiff({ files, layout, wrap, annotations, maxHeight, label }: PierreDiffProps): ReactNode;
+export {};

package/dist/packages/content/src/index.d.ts

@@ -0,0 +1,8 @@
+export type { JsonValue, JsonViewerProps } from './json-viewer.tsx';
+export { JsonViewer } from './json-viewer.tsx';
+export type { LogViewerProps } from './log-viewer.tsx';
+export { LogViewer } from './log-viewer.tsx';
+export type { StackFrame, StackTraceProps } from './stack-trace.tsx';
+export { StackTrace } from './stack-trace.tsx';
+export type { TraceStatus, TraceRootProps, TraceGroupProps, TraceItemProps } from './trace.tsx';
+export { Trace } from './trace.tsx';

package/dist/packages/content/src/json-viewer.d.ts

@@ -0,0 +1,11 @@
+import type { ReactNode } from 'react';
+export type JsonValue = null | boolean | number | string | ReadonlyArray<JsonValue> | {
+    readonly [key: string]: JsonValue;
+};
+export type JsonViewerProps = {
+    readonly value: JsonValue;
+    readonly label: string;
+    readonly maxDepth?: number;
+    readonly maxEntries?: number;
+};
+export declare function JsonViewer({ value, label, maxDepth, maxEntries }: JsonViewerProps): ReactNode;

package/dist/packages/content/src/link.d.ts

@@ -0,0 +1,2 @@
+export type { ContentLinkProps } from './content-link.tsx';
+export { ContentLink } from './content-link.tsx';

package/dist/packages/content/src/log-viewer.d.ts

@@ -0,0 +1,9 @@
+import type { ReactNode } from 'react';
+export type LogViewerProps = {
+    readonly output: string;
+    readonly label: string;
+    readonly maxLines?: number;
+    readonly maxHeight?: number;
+    readonly isRunning?: boolean;
+};
+export declare function LogViewer({ output, label, maxLines, maxHeight, isRunning, }: LogViewerProps): ReactNode;

package/dist/packages/content/src/markdown/index.d.ts

@@ -0,0 +1,2 @@
+export type { MarkdownProps } from './markdown.tsx';
+export { Markdown } from './markdown.tsx';

package/dist/packages/content/src/markdown/markdown.d.ts

@@ -0,0 +1,7 @@
+import type { ReactNode } from 'react';
+export type MarkdownProps = {
+    readonly children: string;
+    readonly streaming?: boolean;
+    readonly label?: string;
+};
+export declare function Markdown({ children, streaming, label }: MarkdownProps): ReactNode;

package/dist/packages/content/src/pierre-theme.d.ts

@@ -0,0 +1,36 @@
+export declare const highlightTheme: {
+    readonly name: 'Elements';
+    readonly appearance: 'light';
+    readonly cssVariables: {
+        readonly prefix: '--elements-syntax-';
+        readonly defaults: {
+            readonly foreground: import("@stylexjs/stylex").StyleXVar<string>;
+            readonly background: import("@stylexjs/stylex").StyleXVar<string>;
+            readonly keyword: import("@stylexjs/stylex").StyleXVar<string>;
+            readonly string: import("@stylexjs/stylex").StyleXVar<string>;
+            readonly comment: import("@stylexjs/stylex").StyleXVar<string>;
+            readonly number: import("@stylexjs/stylex").StyleXVar<string>;
+            readonly type: import("@stylexjs/stylex").StyleXVar<string>;
+            readonly punctuation: import("@stylexjs/stylex").StyleXVar<string>;
+        };
+    };
+    readonly style: {
+        readonly 'editor.background': 'background';
+        readonly 'editor.foreground': 'foreground';
+        readonly syntax: {
+            readonly keyword: {
+                readonly color: 'keyword';
+                readonly font_weight: 600;
+            };
+            readonly string: 'string';
+            readonly comment: 'comment';
+            readonly number: 'number';
+            readonly type: 'type';
+            readonly function: 'foreground';
+            readonly operator: 'punctuation';
+            readonly punctuation: 'punctuation';
+        };
+    };
+};
+export declare const pierreCSS: string;
+export declare const treeCSS: string;

package/dist/packages/content/src/stack-trace.d.ts

@@ -0,0 +1,16 @@
+import type { ReactNode } from 'react';
+export type StackFrame = {
+    readonly id: string;
+    readonly name: string;
+    readonly file?: string;
+    readonly line?: number;
+    readonly column?: number;
+    readonly href?: string;
+    readonly code?: string;
+    readonly language?: string;
+};
+export type StackTraceProps = {
+    readonly message: string;
+    readonly frames: ReadonlyArray<StackFrame>;
+};
+export declare function StackTrace({ message, frames }: StackTraceProps): ReactNode;

package/dist/packages/content/src/trace.d.ts

@@ -0,0 +1,35 @@
+import type { ReactNode } from 'react';
+export type TraceStatus = 'pending' | 'running' | 'complete' | 'failed' | 'skipped' | 'unknown';
+export type TraceRootProps = {
+    readonly label: string;
+    readonly children: ReactNode;
+};
+export type TraceGroupProps = {
+    readonly label: string;
+    readonly children: ReactNode;
+};
+type TraceSelection = {
+    readonly selected: boolean;
+    readonly onSelect: (id: string) => void;
+} | {
+    readonly selected?: never;
+    readonly onSelect?: never;
+};
+export type TraceItemProps = TraceSelection & {
+    readonly id: string;
+    readonly label: string;
+    readonly status: TraceStatus;
+    readonly statusLabel: string;
+    readonly description?: string;
+    readonly detail?: ReactNode;
+    readonly children?: ReactNode;
+};
+declare function TraceRoot({ label, children }: TraceRootProps): ReactNode;
+declare function TraceGroup({ label, children }: TraceGroupProps): ReactNode;
+declare function TraceItem({ id, label, status, statusLabel, description, detail, selected, onSelect, children, }: TraceItemProps): ReactNode;
+export declare const Trace: {
+    Root: typeof TraceRoot;
+    Item: typeof TraceItem;
+    Group: typeof TraceGroup;
+};
+export {};

package/dist/packages/content/src/tree/file-tree-types.d.ts

@@ -0,0 +1,12 @@
+export type FileStatus = {
+    readonly path: string;
+    readonly status: 'added' | 'deleted' | 'ignored' | 'modified' | 'renamed' | 'untracked';
+};
+export type FileTreeProps = {
+    readonly paths: ReadonlyArray<string>;
+    readonly label: string;
+    readonly selectedPaths: ReadonlyArray<string>;
+    readonly onSelectedPathsChange: (paths: ReadonlyArray<string>) => void;
+    readonly statuses?: ReadonlyArray<FileStatus>;
+    readonly height?: number;
+};

package/dist/packages/content/src/tree/file-tree.d.ts

@@ -0,0 +1,3 @@
+import type { ReactNode } from 'react';
+import type { FileTreeProps } from './file-tree-types.ts';
+export declare function FileTree(props: FileTreeProps): ReactNode;

package/dist/packages/content/src/tree/index.d.ts

@@ -0,0 +1,2 @@
+export type { FileStatus, FileTreeProps } from './file-tree-types.ts';
+export { FileTree } from './file-tree.tsx';

package/dist/packages/content/src/tree/pierre-tree.d.ts

@@ -0,0 +1,3 @@
+import type { ReactNode } from 'react';
+import type { FileTreeProps } from './file-tree-types.ts';
+export declare function PierreTree({ paths, label, selectedPaths, onSelectedPathsChange, statuses, height, }: FileTreeProps): ReactNode;

package/dist/packages/core/src/actions.d.ts

@@ -0,0 +1,31 @@
+import { Button as BaseButton } from '@base-ui/react/button';
+import type { ComponentProps, ReactNode } from 'react';
+import type { ControlStyle, PlacementStyle } from '../../foundations/src/style-composition.ts';
+type ButtonVariant = 'solid' | 'outline' | 'ghost';
+type ButtonTone = 'neutral' | 'danger';
+type ControlSize = 'sm' | 'md';
+type PendingProps = {
+    readonly pending?: boolean;
+    readonly pendingLabel?: string | undefined;
+};
+type ButtonProps = ComponentProps<typeof BaseButton> & PendingProps & {
+    readonly variant?: ButtonVariant;
+    readonly tone?: ButtonTone;
+    readonly size?: ControlSize;
+    readonly xstyle?: ControlStyle;
+};
+type IconButtonProps = Omit<ButtonProps, 'aria-label' | 'pendingLabel'> & {
+    readonly 'aria-label': string;
+};
+type TextButtonProps = ComponentProps<typeof BaseButton> & PendingProps & {
+    readonly tone?: ButtonTone;
+    readonly xstyle?: PlacementStyle;
+};
+type TextLinkProps = ComponentProps<'a'> & {
+    readonly xstyle?: PlacementStyle;
+};
+export declare function Button({ variant, tone, size, pending, pendingLabel, children, className, style, xstyle, disabled, ...props }: ButtonProps): ReactNode;
+export declare function IconButton({ size, children, xstyle, ...props }: IconButtonProps): ReactNode;
+export declare function TextButton({ tone, pending, pendingLabel, children, className, style, xstyle, disabled, ...props }: TextButtonProps): ReactNode;
+export declare function TextLink({ xstyle, ...props }: TextLinkProps): ReactNode;
+export {};

package/dist/packages/core/src/avatar.d.ts

@@ -0,0 +1,10 @@
+import type { ReactNode } from 'react';
+type AvatarSize = 'sm' | 'md' | 'lg';
+export type AvatarProps = {
+    readonly label: string;
+    readonly fallback: string;
+    readonly src?: string;
+    readonly size?: AvatarSize;
+};
+export declare function Avatar({ label, fallback, src, size }: AvatarProps): ReactNode;
+export {};

package/dist/packages/core/src/copy-value.d.ts

@@ -0,0 +1,9 @@
+import { Button as BaseButton } from '@base-ui/react/button';
+import type { ComponentProps, ReactNode } from 'react';
+type CopySource = string | (() => string);
+type CopyValueProps = Omit<ComponentProps<typeof BaseButton>, 'value'> & {
+    readonly value: CopySource;
+    readonly label: string;
+};
+export declare function CopyValue({ value, label, children, className, style, disabled, onClick, ...props }: CopyValueProps): ReactNode;
+export {};

package/dist/packages/core/src/disclosure.d.ts

@@ -0,0 +1,33 @@
+import { Accordion as BaseAccordion } from '@base-ui/react/accordion';
+import { Collapsible as BaseCollapsible } from '@base-ui/react/collapsible';
+import type { ComponentProps, ReactNode } from 'react';
+import type { OpenStateProperties, ValueStateProperties } from '../../foundations/src/control-state.ts';
+type AccordionRootProps<Value> = Omit<BaseAccordion.Root.Props<Value>, 'value' | 'defaultValue' | 'onValueChange'> & ValueStateProperties<Array<Value>, NonNullable<BaseAccordion.Root.Props<Value>['onValueChange']>>;
+type AccordionItemProps = ComponentProps<typeof BaseAccordion.Item>;
+type AccordionHeaderProps = ComponentProps<typeof BaseAccordion.Header>;
+type AccordionTriggerProps = ComponentProps<typeof BaseAccordion.Trigger>;
+type AccordionPanelProps = ComponentProps<typeof BaseAccordion.Panel>;
+type CollapsibleRootProps = Omit<BaseCollapsible.Root.Props, 'open' | 'defaultOpen' | 'onOpenChange'> & OpenStateProperties<NonNullable<BaseCollapsible.Root.Props['onOpenChange']>>;
+type CollapsibleTriggerProps = ComponentProps<typeof BaseCollapsible.Trigger>;
+type CollapsiblePanelProps = ComponentProps<typeof BaseCollapsible.Panel>;
+declare function AccordionRoot<Value = string>({ className, style, ...props }: AccordionRootProps<Value>): ReactNode;
+declare function AccordionItem({ className, style, ...props }: AccordionItemProps): ReactNode;
+declare function AccordionHeader({ className, style, ...props }: AccordionHeaderProps): ReactNode;
+declare function AccordionTrigger({ className, style, children, ...props }: AccordionTriggerProps): ReactNode;
+declare function AccordionPanel({ className, style, ...props }: AccordionPanelProps): ReactNode;
+declare function CollapsibleRoot({ className, style, ...props }: CollapsibleRootProps): ReactNode;
+declare function CollapsibleTrigger({ className, style, children, ...props }: CollapsibleTriggerProps): ReactNode;
+declare function CollapsiblePanel({ className, style, ...props }: CollapsiblePanelProps): ReactNode;
+export declare const Accordion: {
+    Root: typeof AccordionRoot;
+    Item: typeof AccordionItem;
+    Header: typeof AccordionHeader;
+    Trigger: typeof AccordionTrigger;
+    Panel: typeof AccordionPanel;
+};
+export declare const Collapsible: {
+    Root: typeof CollapsibleRoot;
+    Trigger: typeof CollapsibleTrigger;
+    Panel: typeof CollapsiblePanel;
+};
+export {};

package/dist/packages/core/src/index.d.ts

@@ -0,0 +1,7 @@
+export { Button, IconButton, TextButton, TextLink } from './actions.tsx';
+export type { AvatarProps } from './avatar.tsx';
+export { Avatar } from './avatar.tsx';
+export { CopyValue } from './copy-value.tsx';
+export { Accordion, Collapsible } from './disclosure.tsx';
+export { Panel, Row, Stack, Columns, Divider } from './surfaces.tsx';
+export { Text, Heading, Subheading, Muted, Identifier, Prose, Badge, Status } from './text.tsx';

package/dist/packages/core/src/surfaces.d.ts

@@ -0,0 +1,18 @@
+import type { ComponentProps, ReactNode } from 'react';
+type PanelProps = ComponentProps<'section'> & {
+    readonly padded?: boolean;
+};
+type RowProps = ComponentProps<'div'> & {
+    readonly between?: boolean;
+};
+type StackProps = ComponentProps<'div'> & {
+    readonly compact?: boolean;
+};
+type ColumnsProps = ComponentProps<'div'>;
+type DividerProps = ComponentProps<'hr'>;
+export declare function Panel({ padded, ...props }: PanelProps): ReactNode;
+export declare function Row({ between, ...props }: RowProps): ReactNode;
+export declare function Stack({ compact, ...props }: StackProps): ReactNode;
+export declare function Columns(props: ColumnsProps): ReactNode;
+export declare function Divider(props: DividerProps): ReactNode;
+export {};

package/dist/packages/core/src/text.d.ts

@@ -0,0 +1,30 @@
+import type { ComponentProps, ReactNode } from 'react';
+import type { PlacementStyle } from '../../foundations/src/style-composition.ts';
+type TextVariant = 'body' | 'caption' | 'mono' | 'prose';
+type TextTone = 'ink' | 'muted';
+type StatusTone = 'neutral' | 'positive' | 'warning' | 'negative';
+type TextProps = ComponentProps<'span'> & {
+    readonly variant?: TextVariant;
+    readonly tone?: TextTone;
+    readonly xstyle?: PlacementStyle;
+};
+type HeadingProps = ComponentProps<'h1'>;
+type SubheadingProps = ComponentProps<'h2'>;
+type MutedProps = ComponentProps<'p'>;
+type IdentifierProps = ComponentProps<'span'>;
+type ProseProps = ComponentProps<'pre'>;
+type BadgeProps = ComponentProps<'span'> & {
+    readonly tone?: StatusTone;
+};
+type StatusProps = ComponentProps<'span'> & {
+    readonly tone?: StatusTone;
+};
+export declare function Text({ variant, tone, xstyle, ...props }: TextProps): ReactNode;
+export declare function Heading(props: HeadingProps): ReactNode;
+export declare function Subheading(props: SubheadingProps): ReactNode;
+export declare function Muted(props: MutedProps): ReactNode;
+export declare function Identifier(props: IdentifierProps): ReactNode;
+export declare function Prose(props: ProseProps): ReactNode;
+export declare function Badge({ children, tone, ...props }: BadgeProps): ReactNode;
+export declare function Status({ children, tone, ...props }: StatusProps): ReactNode;
+export {};

package/dist/packages/feedback/src/feedback.d.ts

@@ -0,0 +1,11 @@
+import type { ComponentProps, ReactNode } from 'react';
+type EmptyStateProps = Omit<ComponentProps<'div'>, 'title'> & {
+    readonly title: string;
+    readonly action?: ReactNode;
+};
+type NoticeProps = ComponentProps<'div'> & {
+    readonly error?: boolean;
+};
+export declare function EmptyState({ title, children, action, ...props }: EmptyStateProps): ReactNode;
+export declare function Notice({ error, ...props }: NoticeProps): ReactNode;
+export {};

package/dist/packages/feedback/src/index.d.ts

@@ -0,0 +1,7 @@
+export { EmptyState, Notice } from './feedback.tsx';
+export { Loading } from './loading.tsx';
+export type { ProgressProps, MeterProps } from './progress.tsx';
+export { Progress, Meter } from './progress.tsx';
+export type { SkeletonProps, SkeletonTextProps, SpinnerProps } from './skeleton.tsx';
+export { Skeleton, SkeletonText, Spinner } from './skeleton.tsx';
+export { Toast } from './toast.tsx';

package/dist/packages/feedback/src/loading.d.ts

@@ -0,0 +1,7 @@
+import type { ReactNode } from 'react';
+type LoadingProps = {
+    readonly label: string;
+    readonly shape?: 'rows' | 'detail';
+};
+export declare function Loading({ label, shape }: LoadingProps): ReactNode;
+export {};

package/dist/packages/feedback/src/progress.d.ts

@@ -0,0 +1,10 @@
+import type { ReactNode } from 'react';
+export type ProgressProps = {
+    readonly label: string;
+    readonly value: number | null;
+    readonly max: number;
+    readonly valueLabel: string;
+};
+export type MeterProps = ProgressProps;
+export declare function Progress({ label, value, max, valueLabel }: ProgressProps): ReactNode;
+export declare function Meter({ label, value, max, valueLabel }: MeterProps): ReactNode;

package/dist/packages/feedback/src/skeleton.d.ts

@@ -0,0 +1,18 @@
+import type { ReactNode } from 'react';
+type SkeletonShape = 'rectangle' | 'circle';
+export type SkeletonProps = {
+    readonly width?: number | `${number}%`;
+    readonly height?: number;
+    readonly shape?: SkeletonShape;
+};
+export type SkeletonTextProps = {
+    readonly lines?: number;
+};
+export type SpinnerProps = {
+    readonly label: string;
+    readonly showLabel?: boolean;
+};
+export declare function Skeleton({ width, height, shape }: SkeletonProps): ReactNode;
+export declare function SkeletonText({ lines }: SkeletonTextProps): ReactNode;
+export declare function Spinner({ label, showLabel }: SpinnerProps): ReactNode;
+export {};

package/dist/packages/feedback/src/toast.d.ts

@@ -0,0 +1,28 @@
+import { Toast as BaseToast } from '@base-ui/react/toast';
+import type { ComponentProps, ReactNode } from 'react';
+type ToastViewportProps = ComponentProps<typeof BaseToast.Viewport>;
+type ToastRootProps = ComponentProps<typeof BaseToast.Root>;
+type ToastContentProps = ComponentProps<typeof BaseToast.Content>;
+type ToastTitleProps = ComponentProps<typeof BaseToast.Title>;
+type ToastDescriptionProps = ComponentProps<typeof BaseToast.Description>;
+type ToastCloseProps = ComponentProps<typeof BaseToast.Close>;
+declare function ToastViewport({ className, style, ...props }: ToastViewportProps): ReactNode;
+declare function ToastRoot({ className, style, ...props }: ToastRootProps): ReactNode;
+declare function ToastContent({ className, style, ...props }: ToastContentProps): ReactNode;
+declare function ToastTitle({ className, style, ...props }: ToastTitleProps): ReactNode;
+declare function ToastDescription({ className, style, ...props }: ToastDescriptionProps): ReactNode;
+declare function ToastClose(props: ToastCloseProps): ReactNode;
+export declare const Toast: {
+    Provider: import("react").FC<import("@base-ui/react").ToastProviderProps>;
+    Portal: import("react").ForwardRefExoticComponent<Omit<import("@base-ui/react").ToastPortalProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    Viewport: typeof ToastViewport;
+    Root: typeof ToastRoot;
+    Content: typeof ToastContent;
+    Title: typeof ToastTitle;
+    Description: typeof ToastDescription;
+    Close: typeof ToastClose;
+    Action: import("react").ForwardRefExoticComponent<Omit<import("@base-ui/react").ToastActionProps, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
+    useManager: typeof BaseToast.useToastManager;
+    createManager: typeof BaseToast.createToastManager;
+};
+export {};

package/dist/packages/forms/src/combobox.d.ts

@@ -0,0 +1,81 @@
+import { Combobox as BaseCombobox } from '@base-ui/react/combobox';
+import type { ComponentProps, ReactNode } from 'react';
+import type { OpenStateProperties, ReadOnlyValueProperties, ValueStateProperties } from '../../foundations/src/control-state.ts';
+import type { PlacementStyle } from '../../foundations/src/style-composition.ts';
+type InputQueryProperties<Change> = {
+    readonly inputValue: string;
+    readonly defaultInputValue?: never;
+    readonly onInputValueChange: Change;
+} | {
+    readonly inputValue?: never;
+    readonly defaultInputValue?: string;
+    readonly onInputValueChange?: Change;
+};
+type ComboboxRootProps<Value, Multiple extends boolean | undefined, Item> = Omit<BaseCombobox.Root.Props<Value, Multiple, Item>, 'value' | 'defaultValue' | 'onValueChange' | 'open' | 'defaultOpen' | 'onOpenChange' | 'inputValue' | 'defaultInputValue' | 'onInputValueChange'> & OpenStateProperties<NonNullable<BaseCombobox.Root.Props<Value, Multiple, Item>['onOpenChange']>> & InputQueryProperties<NonNullable<BaseCombobox.Root.Props<Value, Multiple, Item>['onInputValueChange']>> & (ValueStateProperties<Exclude<BaseCombobox.Root.Props<Value, Multiple, Item>['value'], undefined>, NonNullable<BaseCombobox.Root.Props<Value, Multiple, Item>['onValueChange']>> | ReadOnlyValueProperties<Exclude<BaseCombobox.Root.Props<Value, Multiple, Item>['value'], undefined>, NonNullable<BaseCombobox.Root.Props<Value, Multiple, Item>['onValueChange']>>);
+type ComboboxInputGroupProps = ComponentProps<typeof BaseCombobox.InputGroup> & {
+    readonly xstyle?: PlacementStyle;
+};
+type ComboboxLabelProps = ComponentProps<typeof BaseCombobox.Label>;
+type ComboboxValueProps<Value> = Omit<ComponentProps<typeof BaseCombobox.Value>, 'children'> & {
+    readonly children?: ReactNode | ((value: Value) => ReactNode);
+};
+type ComboboxInputProps = ComponentProps<typeof BaseCombobox.Input>;
+type ComboboxTriggerProps = ComponentProps<typeof BaseCombobox.Trigger>;
+type ComboboxClearProps = ComponentProps<typeof BaseCombobox.Clear>;
+type ComboboxPositionerProps = ComponentProps<typeof BaseCombobox.Positioner> & {
+    readonly xstyle?: PlacementStyle;
+};
+type ComboboxPopupProps = ComponentProps<typeof BaseCombobox.Popup>;
+type ComboboxListProps<Item> = Omit<ComponentProps<typeof BaseCombobox.List>, 'children'> & {
+    readonly children?: ReactNode | ((item: Item, index: number) => ReactNode);
+};
+type ComboboxItemProps = ComponentProps<typeof BaseCombobox.Item>;
+type ComboboxIndicatorProps = ComponentProps<typeof BaseCombobox.ItemIndicator>;
+type ComboboxEmptyProps = ComponentProps<typeof BaseCombobox.Empty>;
+type ComboboxStatusProps = ComponentProps<typeof BaseCombobox.Status>;
+type ComboboxGroupLabelProps = ComponentProps<typeof BaseCombobox.GroupLabel>;
+type ComboboxChipsProps = ComponentProps<typeof BaseCombobox.Chips>;
+type ComboboxChipProps = ComponentProps<typeof BaseCombobox.Chip>;
+type ComboboxChipRemoveProps = ComponentProps<typeof BaseCombobox.ChipRemove>;
+declare function ComboboxRoot<Value, Multiple extends boolean | undefined = false, Item = Value>(props: ComboboxRootProps<Value, Multiple, Item>): ReactNode;
+declare function ComboboxInputGroup({ className, style, xstyle, ...props }: ComboboxInputGroupProps): ReactNode;
+declare function ComboboxLabel({ className, style, ...props }: ComboboxLabelProps): ReactNode;
+declare function ComboboxValue<Value>(props: ComboboxValueProps<Value>): ReactNode;
+declare function ComboboxInput({ className, style, ...props }: ComboboxInputProps): ReactNode;
+declare function ComboboxTrigger({ children, 'aria-label': label, className, style, ...props }: ComboboxTriggerProps): ReactNode;
+declare function ComboboxClear({ children, 'aria-label': label, className, style, ...props }: ComboboxClearProps): ReactNode;
+declare function ComboboxPositioner({ sideOffset, className, style, xstyle, ...props }: ComboboxPositionerProps): ReactNode;
+declare function ComboboxPopup({ className, style, ...props }: ComboboxPopupProps): ReactNode;
+declare function ComboboxList<Item>({ className, style, ...props }: ComboboxListProps<Item>): ReactNode;
+declare function ComboboxItem({ className, style, ...props }: ComboboxItemProps): ReactNode;
+declare function ComboboxIndicator({ children, className, style, ...props }: ComboboxIndicatorProps): ReactNode;
+declare function ComboboxEmpty({ className, style, ...props }: ComboboxEmptyProps): ReactNode;
+declare function ComboboxStatus({ className, style, ...props }: ComboboxStatusProps): ReactNode;
+declare function ComboboxGroupLabel({ className, style, ...props }: ComboboxGroupLabelProps): ReactNode;
+declare function ComboboxChips({ className, style, ...props }: ComboboxChipsProps): ReactNode;
+declare function ComboboxChip({ className, style, ...props }: ComboboxChipProps): ReactNode;
+declare function ComboboxChipRemove({ children, className, style, ...props }: ComboboxChipRemoveProps): ReactNode;
+export declare const Combobox: {
+    Root: typeof ComboboxRoot;
+    Label: typeof ComboboxLabel;
+    InputGroup: typeof ComboboxInputGroup;
+    Input: typeof ComboboxInput;
+    Trigger: typeof ComboboxTrigger;
+    Clear: typeof ComboboxClear;
+    Portal: import("react").ForwardRefExoticComponent<Omit<import("@base-ui/react").ComboboxPortalProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    Positioner: typeof ComboboxPositioner;
+    Popup: typeof ComboboxPopup;
+    List: typeof ComboboxList;
+    Item: typeof ComboboxItem;
+    ItemIndicator: typeof ComboboxIndicator;
+    Empty: typeof ComboboxEmpty;
+    Status: typeof ComboboxStatus;
+    Group: import("react").ForwardRefExoticComponent<Omit<import("@base-ui/react").ComboboxGroupProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    GroupLabel: typeof ComboboxGroupLabel;
+    Chips: typeof ComboboxChips;
+    Chip: typeof ComboboxChip;
+    ChipRemove: typeof ComboboxChipRemove;
+    Value: typeof ComboboxValue;
+    Collection: typeof BaseCombobox.Collection;
+};
+export {};

package/dist/packages/forms/src/dates/calendar.d.ts

@@ -0,0 +1,32 @@
+import type { ReactNode } from 'react';
+export type CalendarDate = {
+    readonly year: number;
+    readonly month: number;
+    readonly day: number;
+};
+export type CalendarRange = {
+    readonly from: CalendarDate;
+    readonly to?: CalendarDate | undefined;
+};
+export type CalendarEnvironment = {
+    readonly locale: string;
+    readonly timeZone: string;
+    readonly today: CalendarDate;
+    readonly initialMonth: CalendarDate;
+    readonly minimum?: CalendarDate;
+    readonly maximum?: CalendarDate;
+    readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+};
+export type CalendarProps = CalendarEnvironment & {
+    readonly label: string;
+    readonly autoFocus?: boolean;
+} & ({
+    readonly mode: 'single';
+    readonly value: CalendarDate | undefined;
+    readonly onValueChange: (value: CalendarDate | undefined) => void;
+} | {
+    readonly mode: 'range';
+    readonly value: CalendarRange | undefined;
+    readonly onValueChange: (value: CalendarRange | undefined) => void;
+});
+export declare function Calendar(props: CalendarProps): ReactNode;

package/dist/packages/forms/src/dates/date-range-picker.d.ts

@@ -0,0 +1,16 @@
+import type { ReactNode } from 'react';
+import type { CalendarEnvironment, CalendarRange } from './calendar.tsx';
+export type DateRangePreset = {
+    readonly id: string;
+    readonly label: string;
+    readonly value: CalendarRange;
+};
+export type DateRangePickerProps = {
+    readonly label: string;
+    readonly value: CalendarRange | undefined;
+    readonly onValueChange: (value: CalendarRange | undefined) => void;
+    readonly formatValue: (value: CalendarRange) => string;
+    readonly presets?: ReadonlyArray<DateRangePreset>;
+    readonly disabled?: boolean;
+} & CalendarEnvironment;
+export declare function DateRangePicker({ label, value, onValueChange, formatValue, presets, disabled, ...environment }: DateRangePickerProps): ReactNode;

package/dist/packages/forms/src/dates/index.d.ts

@@ -0,0 +1,4 @@
+export type { CalendarDate, CalendarRange, CalendarEnvironment, CalendarProps } from './calendar.tsx';
+export { Calendar } from './calendar.tsx';
+export type { DateRangePreset, DateRangePickerProps } from './date-range-picker.tsx';
+export { DateRangePicker } from './date-range-picker.tsx';