@mechane-ai/ui 0.2.2 → 0.3.0

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/alert-dialog.d.ts

@@ -0,0 +1,18 @@
+import { AlertDialog as BaseAlertDialog } from '@base-ui/react/alert-dialog';
+import type { ReactNode } from 'react';
+import type { OpenStateProperties } from './control-state.ts';
+type AlertDialogRootProps<Payload> = Omit<BaseAlertDialog.Root.Props<Payload>, 'open' | 'defaultOpen' | 'onOpenChange'> & OpenStateProperties<NonNullable<BaseAlertDialog.Root.Props<Payload>['onOpenChange']>>;
+declare function AlertDialogRoot<Payload = unknown>(props: AlertDialogRootProps<Payload>): ReactNode;
+export declare const AlertDialog: {
+    Root: typeof AlertDialogRoot;
+    Trigger: BaseAlertDialog.Trigger;
+    Portal: import("react").ForwardRefExoticComponent<Omit<import("@base-ui/react").DialogPortalProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    Backdrop: ({ className, style, ...props }: Omit<import("@base-ui/react").DialogBackdropProps, "ref"> & import("react").RefAttributes<HTMLDivElement>) => ReactNode;
+    Popup: ({ className, style, xstyle, ...props }: Omit<import("@base-ui/react").DialogPopupProps, "ref"> & import("react").RefAttributes<HTMLDivElement> & {
+        readonly xstyle?: import("./style-composition.ts").PlacementStyle;
+    }) => ReactNode;
+    Title: ({ className, style, ...props }: Omit<import("@base-ui/react").DialogTitleProps, "ref"> & import("react").RefAttributes<HTMLHeadingElement>) => ReactNode;
+    Description: ({ className, style, ...props }: Omit<import("@base-ui/react").DialogDescriptionProps, "ref"> & import("react").RefAttributes<HTMLParagraphElement>) => ReactNode;
+    Close: import("react").ForwardRefExoticComponent<Omit<import("@base-ui/react").DialogCloseProps, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
+};
+export {};

package/dist/packages/core/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 './control-state.ts';
+import type { PlacementStyle } from './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/{control-state.d.ts → packages/core/src/control-state.d.ts}

@@ -9,13 +9,13 @@ export type OpenStateProperties<Change> = {
     readonly defaultOpen?: Dialog.Root.Props['defaultOpen'];
     readonly onOpenChange?: Change;
 };
-export type ValueStateProperties<Value, Change> = {
+export type ValueStateProperties<Value, Change, DefaultValue = Value> = {
     readonly value: Value;
     readonly defaultValue?: never;
     readonly onValueChange: Change;
 } | {
     readonly value?: never;
-    readonly defaultValue?: Value;
+    readonly defaultValue?: DefaultValue;
     readonly onValueChange?: Change;
 };
 export type ReadOnlyValueProperties<Value, Change> = {
@@ -24,6 +24,22 @@ export type ReadOnlyValueProperties<Value, Change> = {
     readonly onValueChange?: Change;
     readonly readOnly: true;
 };
+export type CheckedStateProperties<Change> = {
+    readonly checked: boolean;
+    readonly defaultChecked?: never;
+    readonly onCheckedChange: Change;
+    readonly readOnly?: boolean;
+} | {
+    readonly checked: boolean;
+    readonly defaultChecked?: never;
+    readonly onCheckedChange?: Change;
+    readonly readOnly: true;
+} | {
+    readonly checked?: never;
+    readonly defaultChecked?: boolean;
+    readonly onCheckedChange?: Change;
+    readonly readOnly?: boolean;
+};
 export type TextValueProperties<Value, Change, ValueChange> = {
     readonly value: Value;
     readonly defaultValue?: never;

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

@@ -1,7 +1,8 @@
 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: string;
+    readonly value: CopySource;
     readonly label: string;
 };
 export declare function CopyValue({ value, label, children, className, style, disabled, onClick, ...props }: CopyValueProps): ReactNode;

package/dist/packages/core/src/details-controls.d.ts

@@ -0,0 +1,23 @@
+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 type SettingsRowProps = {
+    readonly label: string;
+    readonly description?: string;
+    readonly controlId: string;
+    readonly children: ReactNode;
+};
+export type TimestampProps = {
+    readonly dateTime: string;
+    readonly label: string;
+    readonly title?: string;
+};
+export declare function Avatar({ label, fallback, src, size }: AvatarProps): ReactNode;
+export declare function SettingsRow({ label, description, controlId, children }: SettingsRowProps): ReactNode;
+export declare function Timestamp({ dateTime, label, title }: TimestampProps): 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 './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/field-styles.d.ts

@@ -0,0 +1,66 @@
+import * as stylex from '@stylexjs/stylex';
+export declare const fieldStyles: Readonly<{
+    readonly root: Readonly<{
+        readonly display: stylex.StyleXClassNameFor<"display", "flex">;
+        readonly flexDirection: stylex.StyleXClassNameFor<"flexDirection", "column">;
+        readonly gap: stylex.StyleXClassNameFor<"gap", string>;
+        readonly minWidth: stylex.StyleXClassNameFor<"minWidth", 0>;
+        readonly fontFamily: stylex.StyleXClassNameFor<"fontFamily", string>;
+    }>;
+    readonly label: Readonly<{
+        readonly color: stylex.StyleXClassNameFor<"color", string>;
+        readonly fontSize: stylex.StyleXClassNameFor<"fontSize", string>;
+        readonly lineHeight: stylex.StyleXClassNameFor<"lineHeight", string>;
+    }>;
+    readonly description: Readonly<{
+        readonly margin: stylex.StyleXClassNameFor<"margin", 0>;
+        readonly color: stylex.StyleXClassNameFor<"color", string>;
+        readonly fontSize: stylex.StyleXClassNameFor<"fontSize", string>;
+        readonly lineHeight: stylex.StyleXClassNameFor<"lineHeight", string>;
+    }>;
+    readonly error: Readonly<{
+        readonly color: stylex.StyleXClassNameFor<"color", string>;
+        readonly fontSize: stylex.StyleXClassNameFor<"fontSize", string>;
+        readonly lineHeight: stylex.StyleXClassNameFor<"lineHeight", string>;
+    }>;
+    readonly input: Readonly<{
+        readonly display: stylex.StyleXClassNameFor<"display", "block">;
+        readonly boxSizing: stylex.StyleXClassNameFor<"boxSizing", "border-box">;
+        readonly width: stylex.StyleXClassNameFor<"width", "100%">;
+        readonly minHeight: stylex.StyleXClassNameFor<"minHeight", string>;
+        readonly backgroundColor: stylex.StyleXClassNameFor<"backgroundColor", string>;
+        readonly color: stylex.StyleXClassNameFor<"color", string>;
+        readonly borderWidth: stylex.StyleXClassNameFor<"borderWidth", 1>;
+        readonly borderStyle: stylex.StyleXClassNameFor<"borderStyle", "solid">;
+        readonly borderColor: stylex.StyleXClassNameFor<"borderColor", string>;
+        readonly borderRadius: stylex.StyleXClassNameFor<"borderRadius", string>;
+        readonly paddingBlock: stylex.StyleXClassNameFor<"paddingBlock", string>;
+        readonly paddingInline: stylex.StyleXClassNameFor<"paddingInline", string>;
+        readonly fontFamily: stylex.StyleXClassNameFor<"fontFamily", string>;
+        readonly WebkitFontSmoothing: stylex.StyleXClassNameFor<"WebkitFontSmoothing", "antialiased">;
+        readonly fontSize: stylex.StyleXClassNameFor<"fontSize", string>;
+        readonly lineHeight: stylex.StyleXClassNameFor<"lineHeight", string>;
+        readonly ':focus-visible': stylex.StyleXClassNameFor<":focus-visible", {
+            readonly outlineWidth: stylex.StyleXVar<string>;
+            readonly outlineStyle: "solid";
+            readonly outlineColor: stylex.StyleXVar<string>;
+            readonly outlineOffset: 1;
+        }>;
+        readonly ':is([data-invalid], [aria-invalid="true"])': stylex.StyleXClassNameFor<":is([data-invalid], [aria-invalid=\"true\"])", {
+            readonly borderColor: stylex.StyleXVar<string>;
+        }>;
+        readonly ':disabled': stylex.StyleXClassNameFor<":disabled", {
+            readonly color: stylex.StyleXVar<string>;
+            readonly backgroundColor: stylex.StyleXVar<string>;
+            readonly cursor: "not-allowed";
+        }>;
+        readonly '::placeholder': stylex.StyleXClassNameFor<"::placeholder", {
+            readonly color: stylex.StyleXVar<string>;
+        }>;
+    }>;
+    readonly textarea: Readonly<{
+        readonly minHeight: stylex.StyleXClassNameFor<"minHeight", 144>;
+        readonly resize: stylex.StyleXClassNameFor<"resize", "vertical">;
+        readonly lineHeight: stylex.StyleXClassNameFor<"lineHeight", string>;
+    }>;
+}>;

package/dist/packages/core/src/form-controls.d.ts

@@ -0,0 +1,81 @@
+import { Fieldset as BaseFieldset } from '@base-ui/react/fieldset';
+import { Input as BaseInput } from '@base-ui/react/input';
+import { NumberField as BaseNumberField } from '@base-ui/react/number-field';
+import { Slider as BaseSlider } from '@base-ui/react/slider';
+import type { ComponentProps, ReactNode } from 'react';
+import type { ReadOnlyValueProperties, ValueStateProperties } from './control-state.ts';
+import type { InputProps } from './forms.tsx';
+import type { PlacementStyle } from './style-composition.ts';
+type FieldsetRootProps = ComponentProps<typeof BaseFieldset.Root> & {
+    readonly xstyle?: PlacementStyle;
+};
+type FieldsetLegendProps = ComponentProps<typeof BaseFieldset.Legend>;
+type InputGroupRootProps = ComponentProps<'div'> & {
+    readonly xstyle?: PlacementStyle;
+};
+type InputGroupAddonProps = ComponentProps<'span'>;
+type NumberFieldRootProps = Omit<ComponentProps<typeof BaseNumberField.Root>, 'value' | 'defaultValue' | 'onValueChange' | 'locale'> & (ValueStateProperties<number | null, NonNullable<BaseNumberField.Root.Props['onValueChange']>, number> | ReadOnlyValueProperties<number | null, NonNullable<BaseNumberField.Root.Props['onValueChange']>>) & {
+    readonly locale: string;
+    readonly xstyle?: PlacementStyle;
+};
+type NumberFieldGroupProps = ComponentProps<typeof BaseNumberField.Group>;
+type NumberFieldInputProps = ComponentProps<typeof BaseNumberField.Input>;
+type NumberFieldIncrementProps = ComponentProps<typeof BaseNumberField.Increment>;
+type NumberFieldDecrementProps = ComponentProps<typeof BaseNumberField.Decrement>;
+type SliderRootProps<Value extends number | ReadonlyArray<number>> = Omit<BaseSlider.Root.Props<Value>, 'value' | 'defaultValue' | 'onValueChange' | 'locale'> & ValueStateProperties<Value, NonNullable<BaseSlider.Root.Props<Value>['onValueChange']>> & {
+    readonly locale: string;
+    readonly xstyle?: PlacementStyle;
+};
+type SliderControlProps = ComponentProps<typeof BaseSlider.Control>;
+type SliderTrackProps = ComponentProps<typeof BaseSlider.Track>;
+type SliderIndicatorProps = ComponentProps<typeof BaseSlider.Indicator>;
+type SliderThumbProps = ComponentProps<typeof BaseSlider.Thumb>;
+type SliderLabelProps = ComponentProps<typeof BaseSlider.Label>;
+type SliderValueProps = ComponentProps<typeof BaseSlider.Value>;
+type FilePickerProps = Omit<ComponentProps<typeof BaseInput>, 'type' | 'value' | 'defaultValue' | 'onValueChange'> & {
+    readonly xstyle?: PlacementStyle;
+};
+declare function FieldsetRoot({ className, style, xstyle, ...props }: FieldsetRootProps): ReactNode;
+declare function FieldsetLegend({ className, style, ...props }: FieldsetLegendProps): ReactNode;
+declare function InputGroupRoot({ xstyle, ...props }: InputGroupRootProps): ReactNode;
+declare function InputGroupAddon(props: InputGroupAddonProps): ReactNode;
+declare function InputGroupInput({ className, style, xstyle, ...props }: InputProps): ReactNode;
+declare function NumberFieldRoot({ className, style, xstyle, ...props }: NumberFieldRootProps): ReactNode;
+declare function NumberFieldGroup({ className, style, ...props }: NumberFieldGroupProps): ReactNode;
+declare function NumberFieldInput({ className, style, ...props }: NumberFieldInputProps): ReactNode;
+declare function NumberFieldIncrement({ children, 'aria-label': label, className, style, ...props }: NumberFieldIncrementProps): ReactNode;
+declare function NumberFieldDecrement({ children, 'aria-label': label, className, style, ...props }: NumberFieldDecrementProps): ReactNode;
+declare function SliderRoot<Value extends number | ReadonlyArray<number>>({ className, style, xstyle, ...props }: SliderRootProps<Value>): ReactNode;
+declare function SliderControl({ className, style, ...props }: SliderControlProps): ReactNode;
+declare function SliderTrack({ className, style, ...props }: SliderTrackProps): ReactNode;
+declare function SliderIndicator({ className, style, ...props }: SliderIndicatorProps): ReactNode;
+declare function SliderThumb({ className, style, ...props }: SliderThumbProps): ReactNode;
+declare function SliderLabel({ className, style, ...props }: SliderLabelProps): ReactNode;
+declare function SliderValue({ className, style, ...props }: SliderValueProps): ReactNode;
+export declare function FilePicker({ className, style, xstyle, ...props }: FilePickerProps): ReactNode;
+export declare const Fieldset: {
+    Root: typeof FieldsetRoot;
+    Legend: typeof FieldsetLegend;
+};
+export declare const InputGroup: {
+    Root: typeof InputGroupRoot;
+    Addon: typeof InputGroupAddon;
+    Input: typeof InputGroupInput;
+};
+export declare const NumberField: {
+    Root: typeof NumberFieldRoot;
+    Group: typeof NumberFieldGroup;
+    Input: typeof NumberFieldInput;
+    Increment: typeof NumberFieldIncrement;
+    Decrement: typeof NumberFieldDecrement;
+};
+export declare const Slider: {
+    Root: typeof SliderRoot;
+    Label: typeof SliderLabel;
+    Value: typeof SliderValue;
+    Control: typeof SliderControl;
+    Track: typeof SliderTrack;
+    Indicator: typeof SliderIndicator;
+    Thumb: typeof SliderThumb;
+};
+export {};

package/dist/{forms.d.ts → packages/core/src/forms.d.ts}

@@ -10,7 +10,7 @@ type FieldLabelProps = ComponentProps<typeof BaseField.Label>;
 type FieldDescriptionProps = ComponentProps<typeof BaseField.Description>;
 type FieldErrorProps = ComponentProps<typeof BaseField.Error>;
 type BaseInputProps = ComponentProps<typeof BaseInput>;
-type InputProps = Omit<BaseInputProps, 'value' | 'defaultValue' | 'onChange' | 'onValueChange' | 'readOnly'> & TextValueProperties<NonNullable<BaseInputProps['value']>, NonNullable<BaseInputProps['onChange']>, NonNullable<BaseInputProps['onValueChange']>> & {
+export type InputProps = Omit<BaseInputProps, 'value' | 'defaultValue' | 'onChange' | 'onValueChange' | 'readOnly'> & TextValueProperties<NonNullable<BaseInputProps['value']>, NonNullable<BaseInputProps['onChange']>, NonNullable<BaseInputProps['onValueChange']>> & {
     readonly xstyle?: PlacementStyle;
 };
 type NativeTextareaProps = ComponentProps<'textarea'>;

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

@@ -0,0 +1,32 @@
+export { Button, IconButton, TextButton, TextLink } from './actions.tsx';
+export { Badge, Heading, Identifier, Muted, Prose, Status, Subheading, Text } from './text.tsx';
+export { Field, Input, Textarea } from './forms.tsx';
+export { Select } from './select.tsx';
+export { Dialog } from './dialog.tsx';
+export { Drawer } from './drawer.tsx';
+export { Tooltip } from './tooltip.tsx';
+export { Columns, Divider, EmptyState, Notice, Panel, Row, Stack } from './surfaces.tsx';
+export { Metric, MetricGrid } from './metrics.tsx';
+export { CopyValue } from './copy-value.tsx';
+export { Loading } from './loading.tsx';
+export { Tabs } from './tabs.tsx';
+export { SkipLink } from './skip-link.tsx';
+export { Checkbox, RadioGroup, Switch, ToggleGroup } from './selection.tsx';
+export { Combobox } from './combobox.tsx';
+export { Fieldset, InputGroup, NumberField, Slider, FilePicker } from './form-controls.tsx';
+export { themeProps } from './theme.ts';
+export { Menu } from './menu.tsx';
+export { Popover } from './popover.tsx';
+export { Preview } from './preview.tsx';
+export { AlertDialog } from './alert-dialog.tsx';
+export { Toast } from './toast.tsx';
+export { Accordion, Collapsible } from './disclosure.tsx';
+export { Breadcrumb, Kbd } from './navigation.tsx';
+export { Skeleton, SkeletonText, Spinner } from './skeleton.tsx';
+export type { SkeletonProps, SkeletonTextProps, SpinnerProps } from './skeleton.tsx';
+export { Progress, Meter } from './progress.tsx';
+export type { ProgressProps, MeterProps } from './progress.tsx';
+export { Avatar, SettingsRow, Timestamp } from './details-controls.tsx';
+export type { AvatarProps, SettingsRowProps, TimestampProps } from './details-controls.tsx';
+export { Trace } from './trace.tsx';
+export type { TraceStatus, TraceRootProps, TraceGroupProps, TraceItemProps } from './trace.tsx';

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

@@ -0,0 +1,51 @@
+import { Menu as BaseMenu } from '@base-ui/react/menu';
+import type { ComponentProps, ReactNode } from 'react';
+import type { OpenStateProperties } from './control-state.ts';
+type MenuRootProps<Payload> = Omit<BaseMenu.Root.Props<Payload>, 'open' | 'defaultOpen' | 'onOpenChange'> & OpenStateProperties<NonNullable<BaseMenu.Root.Props<Payload>['onOpenChange']>>;
+type MenuPositionerProps = ComponentProps<typeof BaseMenu.Positioner>;
+type MenuPopupProps = ComponentProps<typeof BaseMenu.Popup>;
+type MenuItemProps = ComponentProps<typeof BaseMenu.Item>;
+type MenuLinkItemProps = ComponentProps<typeof BaseMenu.LinkItem>;
+type MenuGroupLabelProps = ComponentProps<typeof BaseMenu.GroupLabel>;
+type MenuSeparatorProps = ComponentProps<typeof BaseMenu.Separator>;
+type MenuCheckboxItemProps = Omit<ComponentProps<typeof BaseMenu.CheckboxItem>, 'checked' | 'defaultChecked' | 'onCheckedChange'> & {
+    readonly checked: boolean;
+    readonly onCheckedChange: NonNullable<BaseMenu.CheckboxItem.Props['onCheckedChange']>;
+};
+type MenuRadioGroupProps = Omit<ComponentProps<typeof BaseMenu.RadioGroup>, 'value' | 'defaultValue' | 'onValueChange'> & {
+    readonly value: string;
+    readonly onValueChange: NonNullable<BaseMenu.RadioGroup.Props['onValueChange']>;
+};
+type MenuRadioItemProps = ComponentProps<typeof BaseMenu.RadioItem>;
+type MenuSubmenuTriggerProps = ComponentProps<typeof BaseMenu.SubmenuTrigger>;
+type MenuSubmenuRootProps = Omit<BaseMenu.SubmenuRoot.Props, 'open' | 'defaultOpen' | 'onOpenChange'> & OpenStateProperties<NonNullable<BaseMenu.SubmenuRoot.Props['onOpenChange']>>;
+declare function MenuRoot<Payload = unknown>(props: MenuRootProps<Payload>): ReactNode;
+declare function MenuSubmenuRoot(props: MenuSubmenuRootProps): ReactNode;
+declare function MenuPositioner({ className, style, sideOffset, ...props }: MenuPositionerProps): ReactNode;
+declare function MenuPopup({ className, style, ...props }: MenuPopupProps): ReactNode;
+declare function MenuItem({ className, style, ...props }: MenuItemProps): ReactNode;
+declare function MenuLinkItem({ className, style, ...props }: MenuLinkItemProps): ReactNode;
+declare function MenuGroupLabel({ className, style, ...props }: MenuGroupLabelProps): ReactNode;
+declare function MenuSeparator({ className, style, ...props }: MenuSeparatorProps): ReactNode;
+declare function MenuCheckboxItem({ className, style, children, ...props }: MenuCheckboxItemProps): ReactNode;
+declare function MenuRadioGroup(props: MenuRadioGroupProps): ReactNode;
+declare function MenuRadioItem({ className, style, children, ...props }: MenuRadioItemProps): ReactNode;
+declare function MenuSubmenuTrigger({ className, style, ...props }: MenuSubmenuTriggerProps): ReactNode;
+export declare const Menu: {
+    Root: typeof MenuRoot;
+    Trigger: BaseMenu.Trigger;
+    Portal: import("react").ForwardRefExoticComponent<Omit<import("@base-ui/react").MenuPortalProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    Positioner: typeof MenuPositioner;
+    Popup: typeof MenuPopup;
+    Item: typeof MenuItem;
+    LinkItem: typeof MenuLinkItem;
+    Group: import("react").ForwardRefExoticComponent<Omit<import("@base-ui/react").MenuGroupProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    GroupLabel: typeof MenuGroupLabel;
+    Separator: typeof MenuSeparator;
+    CheckboxItem: typeof MenuCheckboxItem;
+    RadioGroup: typeof MenuRadioGroup;
+    RadioItem: typeof MenuRadioItem;
+    SubmenuRoot: typeof MenuSubmenuRoot;
+    SubmenuTrigger: typeof MenuSubmenuTrigger;
+};
+export {};

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

@@ -0,0 +1,24 @@
+import type { ComponentProps, ReactNode } from 'react';
+type BreadcrumbRootProps = Omit<ComponentProps<'nav'>, 'aria-label'> & {
+    readonly 'aria-label': string;
+};
+type BreadcrumbListProps = ComponentProps<'ol'>;
+type BreadcrumbItemProps = ComponentProps<'li'>;
+type BreadcrumbCurrentProps = ComponentProps<'span'>;
+type KbdProps = Omit<ComponentProps<'kbd'>, 'children'> & {
+    readonly children: string;
+};
+declare function BreadcrumbRoot(props: BreadcrumbRootProps): ReactNode;
+declare function BreadcrumbList(props: BreadcrumbListProps): ReactNode;
+declare function BreadcrumbItem(props: BreadcrumbItemProps): ReactNode;
+declare function BreadcrumbCurrent(props: BreadcrumbCurrentProps): ReactNode;
+declare function BreadcrumbSeparator(): ReactNode;
+export declare function Kbd(props: KbdProps): ReactNode;
+export declare const Breadcrumb: {
+    Root: typeof BreadcrumbRoot;
+    List: typeof BreadcrumbList;
+    Item: typeof BreadcrumbItem;
+    Current: typeof BreadcrumbCurrent;
+    Separator: typeof BreadcrumbSeparator;
+};
+export {};

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

@@ -0,0 +1,24 @@
+import { Popover as BasePopover } from '@base-ui/react/popover';
+import type { ComponentProps, ReactNode } from 'react';
+import type { OpenStateProperties } from './control-state.ts';
+type PopoverRootProps<Payload> = Omit<BasePopover.Root.Props<Payload>, 'open' | 'defaultOpen' | 'onOpenChange'> & OpenStateProperties<NonNullable<BasePopover.Root.Props<Payload>['onOpenChange']>>;
+type PopoverPositionerProps = ComponentProps<typeof BasePopover.Positioner>;
+type PopoverPopupProps = ComponentProps<typeof BasePopover.Popup>;
+type PopoverTitleProps = ComponentProps<typeof BasePopover.Title>;
+type PopoverDescriptionProps = ComponentProps<typeof BasePopover.Description>;
+declare function PopoverRoot<Payload = unknown>(props: PopoverRootProps<Payload>): ReactNode;
+declare function PopoverPositioner({ className, style, sideOffset, ...props }: PopoverPositionerProps): ReactNode;
+declare function PopoverPopup({ className, style, ...props }: PopoverPopupProps): ReactNode;
+declare function PopoverTitle({ className, style, ...props }: PopoverTitleProps): ReactNode;
+declare function PopoverDescription({ className, style, ...props }: PopoverDescriptionProps): ReactNode;
+export declare const Popover: {
+    Root: typeof PopoverRoot;
+    Trigger: BasePopover.Trigger;
+    Portal: import("react").ForwardRefExoticComponent<Omit<import("@base-ui/react").PopoverPortalProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    Positioner: typeof PopoverPositioner;
+    Popup: typeof PopoverPopup;
+    Title: typeof PopoverTitle;
+    Description: typeof PopoverDescription;
+    Close: import("react").ForwardRefExoticComponent<Omit<import("@base-ui/react").PopoverCloseProps, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
+};
+export {};

package/dist/packages/core/src/popup-styles.d.ts

@@ -0,0 +1,84 @@
+import * as stylex from '@stylexjs/stylex';
+export declare const popupStyles: Readonly<{
+    readonly positioner: Readonly<{
+        readonly zIndex: stylex.StyleXClassNameFor<"zIndex", string>;
+        readonly outlineWidth: stylex.StyleXClassNameFor<"outlineWidth", 0>;
+    }>;
+    readonly surface: Readonly<{
+        readonly boxSizing: stylex.StyleXClassNameFor<"boxSizing", "border-box">;
+        readonly maxWidth: stylex.StyleXClassNameFor<"maxWidth", "min(360px, calc(100vw - 24px))">;
+        readonly maxHeight: stylex.StyleXClassNameFor<"maxHeight", "var(--available-height)">;
+        readonly overflowY: stylex.StyleXClassNameFor<"overflowY", "auto">;
+        readonly overscrollBehavior: stylex.StyleXClassNameFor<"overscrollBehavior", "contain">;
+        readonly borderWidth: stylex.StyleXClassNameFor<"borderWidth", 1>;
+        readonly borderStyle: stylex.StyleXClassNameFor<"borderStyle", "solid">;
+        readonly borderColor: stylex.StyleXClassNameFor<"borderColor", string>;
+        readonly borderRadius: stylex.StyleXClassNameFor<"borderRadius", string>;
+        readonly boxShadow: stylex.StyleXClassNameFor<"boxShadow", string>;
+        readonly backgroundColor: stylex.StyleXClassNameFor<"backgroundColor", string>;
+        readonly color: stylex.StyleXClassNameFor<"color", string>;
+        readonly fontFamily: stylex.StyleXClassNameFor<"fontFamily", string>;
+        readonly WebkitFontSmoothing: stylex.StyleXClassNameFor<"WebkitFontSmoothing", "antialiased">;
+        readonly fontSize: stylex.StyleXClassNameFor<"fontSize", string>;
+        readonly lineHeight: stylex.StyleXClassNameFor<"lineHeight", string>;
+        readonly outlineWidth: stylex.StyleXClassNameFor<"outlineWidth", 0>;
+    }>;
+    readonly content: Readonly<{
+        readonly display: stylex.StyleXClassNameFor<"display", "flex">;
+        readonly flexDirection: stylex.StyleXClassNameFor<"flexDirection", "column">;
+        readonly gap: stylex.StyleXClassNameFor<"gap", string>;
+        readonly padding: stylex.StyleXClassNameFor<"padding", string>;
+    }>;
+    readonly menu: Readonly<{
+        readonly minWidth: stylex.StyleXClassNameFor<"minWidth", 192>;
+        readonly padding: stylex.StyleXClassNameFor<"padding", string>;
+    }>;
+    readonly item: Readonly<{
+        readonly display: stylex.StyleXClassNameFor<"display", "flex">;
+        readonly boxSizing: stylex.StyleXClassNameFor<"boxSizing", "border-box">;
+        readonly alignItems: stylex.StyleXClassNameFor<"alignItems", "center">;
+        readonly gap: stylex.StyleXClassNameFor<"gap", string>;
+        readonly minHeight: stylex.StyleXClassNameFor<"minHeight", string>;
+        readonly paddingInline: stylex.StyleXClassNameFor<"paddingInline", string>;
+        readonly paddingBlock: stylex.StyleXClassNameFor<"paddingBlock", string>;
+        readonly borderRadius: stylex.StyleXClassNameFor<"borderRadius", string>;
+        readonly cursor: stylex.StyleXClassNameFor<"cursor", "pointer">;
+        readonly textDecorationLine: stylex.StyleXClassNameFor<"textDecorationLine", "none">;
+        readonly color: stylex.StyleXClassNameFor<"color", string>;
+        readonly outlineWidth: stylex.StyleXClassNameFor<"outlineWidth", 0>;
+        readonly ':is([data-highlighted])': stylex.StyleXClassNameFor<":is([data-highlighted])", {
+            readonly backgroundColor: stylex.StyleXVar<string>;
+        }>;
+        readonly ':is([data-disabled])': stylex.StyleXClassNameFor<":is([data-disabled])", {
+            readonly opacity: stylex.StyleXVar<string>;
+            readonly cursor: "default";
+        }>;
+        readonly ':focus-visible': stylex.StyleXClassNameFor<":focus-visible", {
+            readonly outlineWidth: stylex.StyleXVar<string>;
+            readonly outlineStyle: "solid";
+            readonly outlineColor: stylex.StyleXVar<string>;
+            readonly outlineOffset: "-2px";
+        }>;
+    }>;
+    readonly label: Readonly<{
+        readonly paddingInline: stylex.StyleXClassNameFor<"paddingInline", string>;
+        readonly paddingBlock: stylex.StyleXClassNameFor<"paddingBlock", string>;
+        readonly color: stylex.StyleXClassNameFor<"color", string>;
+        readonly fontSize: stylex.StyleXClassNameFor<"fontSize", string>;
+        readonly lineHeight: stylex.StyleXClassNameFor<"lineHeight", string>;
+    }>;
+    readonly separator: Readonly<{
+        readonly height: stylex.StyleXClassNameFor<"height", 1>;
+        readonly borderWidth: stylex.StyleXClassNameFor<"borderWidth", 0>;
+        readonly backgroundColor: stylex.StyleXClassNameFor<"backgroundColor", string>;
+        readonly marginBlock: stylex.StyleXClassNameFor<"marginBlock", string>;
+    }>;
+    readonly indicator: Readonly<{
+        readonly width: stylex.StyleXClassNameFor<"width", string>;
+        readonly height: stylex.StyleXClassNameFor<"height", string>;
+        readonly display: stylex.StyleXClassNameFor<"display", "inline-flex">;
+        readonly alignItems: stylex.StyleXClassNameFor<"alignItems", "center">;
+        readonly justifyContent: stylex.StyleXClassNameFor<"justifyContent", "center">;
+        readonly flexShrink: stylex.StyleXClassNameFor<"flexShrink", 0>;
+    }>;
+}>;

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

@@ -0,0 +1,17 @@
+import { PreviewCard as BasePreview } from '@base-ui/react/preview-card';
+import type { ComponentProps, ReactNode } from 'react';
+import type { OpenStateProperties } from './control-state.ts';
+type PreviewRootProps<Payload> = Omit<BasePreview.Root.Props<Payload>, 'open' | 'defaultOpen' | 'onOpenChange'> & OpenStateProperties<NonNullable<BasePreview.Root.Props<Payload>['onOpenChange']>>;
+type PreviewPositionerProps = ComponentProps<typeof BasePreview.Positioner>;
+type PreviewPopupProps = ComponentProps<typeof BasePreview.Popup>;
+declare function PreviewRoot<Payload = unknown>(props: PreviewRootProps<Payload>): ReactNode;
+declare function PreviewPositioner({ className, style, sideOffset, ...props }: PreviewPositionerProps): ReactNode;
+declare function PreviewPopup({ className, style, ...props }: PreviewPopupProps): ReactNode;
+export declare const Preview: {
+    Root: typeof PreviewRoot;
+    Trigger: BasePreview.Trigger;
+    Portal: import("react").ForwardRefExoticComponent<Omit<import("@base-ui/react").PreviewCardPortalProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    Positioner: typeof PreviewPositioner;
+    Popup: typeof PreviewPopup;
+};
+export {};

package/dist/packages/core/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;