@imfusion/web-ui 0.5.0

package/dist/components/select/select.d.ts

@@ -0,0 +1,278 @@
+import { Select as SelectPrimitive } from '@base-ui/react/select';
+type UpstreamRoot = React.ComponentProps<typeof SelectPrimitive.Root>;
+type UpstreamLabel = React.ComponentProps<typeof SelectPrimitive.Label>;
+type UpstreamTrigger = React.ComponentProps<typeof SelectPrimitive.Trigger>;
+type UpstreamValue = React.ComponentProps<typeof SelectPrimitive.Value>;
+type UpstreamIcon = React.ComponentProps<typeof SelectPrimitive.Icon>;
+type UpstreamPortal = React.ComponentProps<typeof SelectPrimitive.Portal>;
+type UpstreamBackdrop = React.ComponentProps<typeof SelectPrimitive.Backdrop>;
+type UpstreamPositioner = React.ComponentProps<typeof SelectPrimitive.Positioner>;
+type UpstreamPopup = React.ComponentProps<typeof SelectPrimitive.Popup>;
+type UpstreamArrow = React.ComponentProps<typeof SelectPrimitive.Arrow>;
+type UpstreamList = React.ComponentProps<typeof SelectPrimitive.List>;
+type UpstreamItem = React.ComponentProps<typeof SelectPrimitive.Item>;
+type UpstreamItemIndicator = React.ComponentProps<typeof SelectPrimitive.ItemIndicator>;
+type UpstreamItemText = React.ComponentProps<typeof SelectPrimitive.ItemText>;
+type UpstreamGroup = React.ComponentProps<typeof SelectPrimitive.Group>;
+type UpstreamGroupLabel = React.ComponentProps<typeof SelectPrimitive.GroupLabel>;
+type UpstreamSeparator = React.ComponentProps<typeof SelectPrimitive.Separator>;
+type UpstreamScrollUpArrow = React.ComponentProps<typeof SelectPrimitive.ScrollUpArrow>;
+type UpstreamScrollDownArrow = React.ComponentProps<typeof SelectPrimitive.ScrollDownArrow>;
+type RootProps = {
+    value?: UpstreamRoot["value"];
+    defaultValue?: UpstreamRoot["defaultValue"];
+    onValueChange?: UpstreamRoot["onValueChange"];
+    /** @default false */
+    defaultOpen?: UpstreamRoot["defaultOpen"];
+    open?: UpstreamRoot["open"];
+    onOpenChange?: UpstreamRoot["onOpenChange"];
+    onOpenChangeComplete?: UpstreamRoot["onOpenChangeComplete"];
+    /** @default false */
+    multiple?: UpstreamRoot["multiple"];
+    /** @default false */
+    disabled?: UpstreamRoot["disabled"];
+    /** @default false */
+    readOnly?: UpstreamRoot["readOnly"];
+    /** @default false */
+    required?: UpstreamRoot["required"];
+    /** @default true */
+    modal?: UpstreamRoot["modal"];
+    /** @default true */
+    highlightItemOnHover?: UpstreamRoot["highlightItemOnHover"];
+    items?: UpstreamRoot["items"];
+    isItemEqualToValue?: UpstreamRoot["isItemEqualToValue"];
+    itemToStringLabel?: UpstreamRoot["itemToStringLabel"];
+    itemToStringValue?: UpstreamRoot["itemToStringValue"];
+    autoComplete?: UpstreamRoot["autoComplete"];
+    form?: UpstreamRoot["form"];
+    inputRef?: UpstreamRoot["inputRef"];
+    actionsRef?: UpstreamRoot["actionsRef"];
+    name?: UpstreamRoot["name"];
+    id?: UpstreamRoot["id"];
+    children?: React.ReactNode;
+};
+/**
+ * Select.Root — accessible select / listbox primitive.
+ *
+ * Renders a thin wrapper div so that a sibling Select.Label stacks above the
+ * Select.Trigger regardless of the parent's layout. Select.Portal is unaffected
+ * (it renders to document.body).
+ *
+ * @doc https://base-ui.com/react/components/select
+ * @llm https://base-ui.com/react/components/select.md
+ */
+export declare function Root({ className, style, ...props }: RootProps & {
+    className?: string;
+    style?: React.CSSProperties;
+}): import("react/jsx-runtime").JSX.Element;
+export declare namespace Root {
+    var displayName: string;
+}
+type LabelProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
+    className?: UpstreamLabel["className"];
+    style?: UpstreamLabel["style"];
+    render?: UpstreamLabel["render"];
+};
+/** Select.Label — visible label for the trigger. */
+export declare function Label({ className, ...props }: LabelProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Label {
+    var displayName: string;
+}
+type TriggerProps = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "className" | "style"> & {
+    /** @default true */
+    nativeButton?: UpstreamTrigger["nativeButton"];
+    className?: UpstreamTrigger["className"];
+    style?: UpstreamTrigger["style"];
+    render?: UpstreamTrigger["render"];
+};
+/** Select.Trigger — button that opens the popup. */
+export declare function Trigger({ className, ...props }: TriggerProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Trigger {
+    var displayName: string;
+}
+type ValueProps = Omit<React.HTMLAttributes<HTMLSpanElement>, "children" | "className" | "style"> & {
+    placeholder?: React.ReactNode;
+    children?: UpstreamValue["children"];
+    className?: UpstreamValue["className"];
+    style?: UpstreamValue["style"];
+    render?: UpstreamValue["render"];
+};
+/** Select.Value — renders the currently-selected value (or placeholder). */
+export declare function Value({ className, children, ...props }: ValueProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Value {
+    var displayName: string;
+}
+type IconProps = Omit<React.HTMLAttributes<HTMLSpanElement>, "className" | "style"> & {
+    className?: UpstreamIcon["className"];
+    style?: UpstreamIcon["style"];
+    render?: UpstreamIcon["render"];
+};
+/** Select.Icon — visual indicator (chevron) next to the value. */
+export declare function Icon({ className, ...props }: IconProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Icon {
+    var displayName: string;
+}
+type PortalProps = {
+    container?: UpstreamPortal["container"];
+    className?: UpstreamPortal["className"];
+    style?: UpstreamPortal["style"];
+    render?: UpstreamPortal["render"];
+    children?: React.ReactNode;
+};
+/** Select.Portal — portals the popup tree to document.body (or a custom container). */
+export declare function Portal(props: PortalProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Portal {
+    var displayName: string;
+}
+type BackdropProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
+    className?: UpstreamBackdrop["className"];
+    style?: UpstreamBackdrop["style"];
+    render?: UpstreamBackdrop["render"];
+};
+/** Select.Backdrop — overlay behind the popup (visible only in modal mode). */
+export declare function Backdrop({ className, ...props }: BackdropProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Backdrop {
+    var displayName: string;
+}
+type PositionerProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
+    /** @default false */
+    alignItemWithTrigger?: UpstreamPositioner["alignItemWithTrigger"];
+    /** @default false */
+    disableAnchorTracking?: UpstreamPositioner["disableAnchorTracking"];
+    /** @default "start" */
+    align?: UpstreamPositioner["align"];
+    /** @default 0 */
+    alignOffset?: UpstreamPositioner["alignOffset"];
+    /** @default "bottom" */
+    side?: UpstreamPositioner["side"];
+    /** @default 0 */
+    sideOffset?: UpstreamPositioner["sideOffset"];
+    /** @default 'clipping-ancestors' */
+    collisionBoundary?: UpstreamPositioner["collisionBoundary"];
+    /** @default 5 */
+    collisionPadding?: UpstreamPositioner["collisionPadding"];
+    /** @default { fallbackAxisSide: 'none' } */
+    collisionAvoidance?: UpstreamPositioner["collisionAvoidance"];
+    className?: UpstreamPositioner["className"];
+    style?: UpstreamPositioner["style"];
+    render?: UpstreamPositioner["render"];
+};
+/** Select.Positioner — positions the popup relative to the trigger. */
+export declare function Positioner({ className, align, alignItemWithTrigger, ...props }: PositionerProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Positioner {
+    var displayName: string;
+}
+type PopupProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
+    className?: UpstreamPopup["className"];
+    style?: UpstreamPopup["style"];
+    render?: UpstreamPopup["render"];
+};
+/** Select.Popup — dropdown surface. */
+export declare function Popup({ className, ...props }: PopupProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Popup {
+    var displayName: string;
+}
+type ArrowProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
+    className?: UpstreamArrow["className"];
+    style?: UpstreamArrow["style"];
+    render?: UpstreamArrow["render"];
+};
+/** Select.Arrow — pointer arrow attached to the popup. */
+export declare function Arrow({ className, ...props }: ArrowProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Arrow {
+    var displayName: string;
+}
+type ListProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
+    className?: UpstreamList["className"];
+    style?: UpstreamList["style"];
+    render?: UpstreamList["render"];
+};
+/** Select.List — items container. */
+export declare function List({ className, ...props }: ListProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace List {
+    var displayName: string;
+}
+type ItemProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
+    value: UpstreamItem["value"];
+    /** @default false */
+    disabled?: UpstreamItem["disabled"];
+    className?: UpstreamItem["className"];
+    style?: UpstreamItem["style"];
+    render?: UpstreamItem["render"];
+};
+/** Select.Item — individual selectable option. */
+export declare function Item({ className, ...props }: ItemProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Item {
+    var displayName: string;
+}
+type ItemIndicatorProps = Omit<React.HTMLAttributes<HTMLSpanElement>, "className" | "style"> & {
+    className?: UpstreamItemIndicator["className"];
+    style?: UpstreamItemIndicator["style"];
+    render?: UpstreamItemIndicator["render"];
+};
+/** Select.ItemIndicator — visual marker (e.g. checkmark) inside the selected item. */
+export declare function ItemIndicator({ className, ...props }: ItemIndicatorProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace ItemIndicator {
+    var displayName: string;
+}
+type ItemTextProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
+    className?: UpstreamItemText["className"];
+    style?: UpstreamItemText["style"];
+    render?: UpstreamItemText["render"];
+};
+/** Select.ItemText — text label for an item. */
+export declare function ItemText({ className, ...props }: ItemTextProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace ItemText {
+    var displayName: string;
+}
+type GroupProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
+    className?: UpstreamGroup["className"];
+    style?: UpstreamGroup["style"];
+    render?: UpstreamGroup["render"];
+};
+/** Select.Group — wrapper around a grouped set of items. */
+export declare function Group({ className, ...props }: GroupProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Group {
+    var displayName: string;
+}
+type GroupLabelProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
+    className?: UpstreamGroupLabel["className"];
+    style?: UpstreamGroupLabel["style"];
+    render?: UpstreamGroupLabel["render"];
+};
+/** Select.GroupLabel — heading for a Select.Group. */
+export declare function GroupLabel({ className, ...props }: GroupLabelProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace GroupLabel {
+    var displayName: string;
+}
+type SeparatorProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
+    className?: UpstreamSeparator["className"];
+    style?: UpstreamSeparator["style"];
+    render?: UpstreamSeparator["render"];
+};
+/** Select.Separator — thin divider between items. */
+export declare function Separator({ className, ...props }: SeparatorProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Separator {
+    var displayName: string;
+}
+type ScrollUpArrowProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
+    className?: UpstreamScrollUpArrow["className"];
+    style?: UpstreamScrollUpArrow["style"];
+    render?: UpstreamScrollUpArrow["render"];
+};
+/** Select.ScrollUpArrow — indicator that more items exist above. */
+export declare function ScrollUpArrow({ className, ...props }: ScrollUpArrowProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace ScrollUpArrow {
+    var displayName: string;
+}
+type ScrollDownArrowProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
+    className?: UpstreamScrollDownArrow["className"];
+    style?: UpstreamScrollDownArrow["style"];
+    render?: UpstreamScrollDownArrow["render"];
+};
+/** Select.ScrollDownArrow — indicator that more items exist below. */
+export declare function ScrollDownArrow({ className, ...props }: ScrollDownArrowProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace ScrollDownArrow {
+    var displayName: string;
+}
+export {};

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

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

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

@@ -0,0 +1,2 @@
+export { Separator } from './separator';
+export { separatorMeta } from './separator.meta';

package/dist/components/separator/separator.d.ts

@@ -0,0 +1,15 @@
+import { VariantProps } from 'class-variance-authority';
+declare const separator: (props?: ({
+    variant?: "solid" | "dashed" | "dotted" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+type Props = React.HTMLAttributes<HTMLDivElement> & VariantProps<typeof separator> & {
+    orientation?: "horizontal" | "vertical";
+};
+/**
+ * Separator — visual divider between content sections.
+ *
+ * @see https://base-ui.com/react/components/separator
+ * @llm https://base-ui.com/react/components/separator.md
+ */
+export declare function Separator({ orientation, variant, className, ...props }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

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

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

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

@@ -0,0 +1,2 @@
+export * as Slider from './slider';
+export { sliderMeta } from './slider.meta';

package/dist/components/slider/slider.d.ts

@@ -0,0 +1,111 @@
+import { Slider as SliderPrimitive } from '@base-ui/react/slider';
+type UpstreamRoot = React.ComponentProps<typeof SliderPrimitive.Root>;
+type UpstreamLabel = React.ComponentProps<typeof SliderPrimitive.Label>;
+type UpstreamValue = React.ComponentProps<typeof SliderPrimitive.Value>;
+type UpstreamControl = React.ComponentProps<typeof SliderPrimitive.Control>;
+type UpstreamTrack = React.ComponentProps<typeof SliderPrimitive.Track>;
+type UpstreamIndicator = React.ComponentProps<typeof SliderPrimitive.Indicator>;
+type UpstreamThumb = React.ComponentProps<typeof SliderPrimitive.Thumb>;
+type RootProps = Omit<React.HTMLAttributes<HTMLDivElement>, "defaultValue" | "className" | "style"> & {
+    value?: number | number[];
+    defaultValue?: number | number[];
+    onValueChange?: UpstreamRoot["onValueChange"];
+    onValueCommitted?: UpstreamRoot["onValueCommitted"];
+    min?: number;
+    max?: number;
+    step?: number;
+    largeStep?: number;
+    minStepsBetweenValues?: number;
+    disabled?: boolean;
+    orientation?: "horizontal" | "vertical";
+    name?: string;
+    form?: string;
+    locale?: UpstreamRoot["locale"];
+    thumbAlignment?: UpstreamRoot["thumbAlignment"];
+    thumbCollisionBehavior?: UpstreamRoot["thumbCollisionBehavior"];
+    format?: Intl.NumberFormatOptions;
+    className?: UpstreamRoot["className"];
+    style?: UpstreamRoot["style"];
+    render?: UpstreamRoot["render"];
+};
+/**
+ * Slider.Root — value selector along a continuous or stepped track.
+ *
+ * @doc https://base-ui.com/react/components/slider
+ * @llm https://base-ui.com/react/components/slider.md
+ */
+export declare function Root({ value, defaultValue, onValueChange, onValueCommitted, min, max, step, largeStep, minStepsBetweenValues, disabled, orientation, name, form, locale, thumbAlignment, thumbCollisionBehavior, format, className, ...props }: RootProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Root {
+    var displayName: string;
+}
+type LabelProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
+    className?: UpstreamLabel["className"];
+    style?: UpstreamLabel["style"];
+    render?: UpstreamLabel["render"];
+};
+/** Slider.Label — accessible label for the slider. */
+export declare function Label({ className, ...props }: LabelProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Label {
+    var displayName: string;
+}
+type ValueProps = Omit<React.HTMLAttributes<HTMLOutputElement>, "children" | "className" | "style"> & {
+    children?: UpstreamValue["children"];
+    className?: UpstreamValue["className"];
+    style?: UpstreamValue["style"];
+    render?: UpstreamValue["render"];
+};
+/** Slider.Value — live numeric readout. */
+export declare function Value({ className, children, ...props }: ValueProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Value {
+    var displayName: string;
+}
+type ControlProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
+    className?: UpstreamControl["className"];
+    style?: UpstreamControl["style"];
+    render?: UpstreamControl["render"];
+};
+/** Slider.Control — interactive container for track + thumb. */
+export declare function Control({ className, ...props }: ControlProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Control {
+    var displayName: string;
+}
+type TrackProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
+    className?: UpstreamTrack["className"];
+    style?: UpstreamTrack["style"];
+    render?: UpstreamTrack["render"];
+};
+/** Slider.Track — the static rail. */
+export declare function Track({ className, ...props }: TrackProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Track {
+    var displayName: string;
+}
+type IndicatorProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
+    className?: UpstreamIndicator["className"];
+    style?: UpstreamIndicator["style"];
+    render?: UpstreamIndicator["render"];
+};
+/** Slider.Indicator — filled portion of the track. */
+export declare function Indicator({ className, ...props }: IndicatorProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Indicator {
+    var displayName: string;
+}
+type ThumbProps = Omit<React.HTMLAttributes<HTMLDivElement>, "onBlur" | "onFocus" | "className" | "style"> & {
+    index?: number;
+    tabIndex?: number;
+    /** @default false */
+    disabled?: boolean;
+    inputRef?: React.Ref<HTMLInputElement>;
+    getAriaLabel?: UpstreamThumb["getAriaLabel"];
+    getAriaValueText?: UpstreamThumb["getAriaValueText"];
+    onBlur?: UpstreamThumb["onBlur"];
+    onFocus?: UpstreamThumb["onFocus"];
+    className?: UpstreamThumb["className"];
+    style?: UpstreamThumb["style"];
+    render?: UpstreamThumb["render"];
+};
+/** Slider.Thumb — draggable handle. */
+export declare function Thumb({ index, className, ...props }: ThumbProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Thumb {
+    var displayName: string;
+}
+export {};

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

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

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

@@ -0,0 +1,2 @@
+export { Spinner } from './spinner';
+export { spinnerMeta } from './spinner.meta';

package/dist/components/spinner/spinner.d.ts

@@ -0,0 +1,19 @@
+import { VariantProps } from 'class-variance-authority';
+declare const spinner: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+type Props = Omit<React.HTMLAttributes<HTMLSpanElement>, "role"> & VariantProps<typeof spinner> & {
+    /** Accessible label announced by assistive tech. */
+    label?: string;
+};
+/**
+ * Loading indicator built from the animated ImFusion glyph — two filled bands
+ * and an empty diagonal channel that continuously rotates, breathes, and sways.
+ *
+ * The motion is a live per-frame morph of the two paths (the channel geometry is
+ * recomputed each frame in {@link frameGeometry}), driven by a single
+ * `requestAnimationFrame` loop that rewrites the two `d` attributes directly —
+ * no React re-render per frame. The loop pauses while the tab is hidden.
+ */
+export declare function Spinner({ size, label, className, ...props }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/spinner/spinner.geometry.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Spinner geometry — the animated ImFusion glyph.
+ *
+ * The mark is two filled bands separated by an empty diagonal channel (see
+ * `logo/imfusion/imfusion.tsx`). This module reproduces that structure as a
+ * *morphing* shape: the channel rotates, breathes (its width pulses, never
+ * closing), and its interior nodes sway — so the loader reads as the mark
+ * alive, not a generic ring.
+ *
+ * The motion is a live per-frame morph: a single `requestAnimationFrame` loop
+ * in the component (spinner.tsx) calls {@link frameGeometry} each frame and
+ * writes the two returned path `d` strings straight onto the SVG paths — no
+ * React re-render per frame, no SMIL. (SMIL/CSS `d` morphing was tried and
+ * dropped: neither is GPU-composited, and CSS `d` isn't supported in Safari.)
+ *
+ * Everything is tunable from the {@link KNOBS} block. The values there were
+ * dialled in against rendered evidence at 16/20/24/96px; the shape is a
+ * balance — extreme values pinch the channel shut or spike the bands, so nudge
+ * rather than leap. `frameGeometry(t)` is pure and deterministic: feed it a
+ * time in ms and it returns the two band path `d`s for that instant.
+ */
+/** Design-space edge length; the SVG viewBox is `0 0 D D`. */
+export declare const D = 100;
+/**
+ * The two band path `d` strings at time `tms` (ms) — the shape at any instant
+ * of the loop, as `[topBand, bottomBand]`. Pure and deterministic; the rAF loop
+ * in the component calls this each frame and writes the results to the paths.
+ */
+export declare function frameGeometry(tms: number): [string, string];
+/**
+ * The period over which the whole composition returns to its start pose — the
+ * least-common-multiple-ish window of rotation, breathe, and sway. Rotation is
+ * `ROT_S`; breathe/sway are shorter and phase-relative. We loop over the
+ * rotation period and let breathe/sway ride within it; `SWAY_RATIO` is chosen
+ * so the combined motion reads continuous rather than obviously repeating.
+ */
+export declare const LOOP_MS: number;

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

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

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

@@ -0,0 +1,2 @@
+export { Stack } from './stack';
+export { stackMeta } from './stack.meta';

package/dist/components/stack/stack.d.ts

@@ -0,0 +1,18 @@
+import { VariantProps } from 'class-variance-authority';
+declare const stack: (props?: ({
+    gap?: "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "10" | null | undefined;
+    align?: "center" | "end" | "start" | "stretch" | null | undefined;
+    justify?: "center" | "end" | "start" | "between" | "around" | "evenly" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+type Props = React.HTMLAttributes<HTMLDivElement> & VariantProps<typeof stack>;
+/**
+ * Stack — vertical layout primitive.
+ *
+ * Copied and adapted from Mantine's Stack; no upstream runtime
+ * dependency. Pure column flex container with token-driven gap and constrained
+ * align/justify unions.
+ *
+ * @see https://mantine.dev/core/stack/
+ */
+export declare function Stack({ gap, align, justify, className, ...props }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

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

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

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

@@ -0,0 +1,2 @@
+export * as Switch from './switch';
+export { switchMeta } from './switch.meta';

package/dist/components/switch/switch.d.ts

@@ -0,0 +1,45 @@
+import { Switch as SwitchPrimitive } from '@base-ui/react/switch';
+type UpstreamRoot = React.ComponentProps<typeof SwitchPrimitive.Root>;
+type UpstreamThumb = React.ComponentProps<typeof SwitchPrimitive.Thumb>;
+type RootProps = Omit<React.HTMLAttributes<HTMLSpanElement>, "className" | "style"> & {
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onCheckedChange?: UpstreamRoot["onCheckedChange"];
+    /** @default false */
+    disabled?: boolean;
+    /** @default false */
+    readOnly?: boolean;
+    /** @default false */
+    required?: boolean;
+    name?: string;
+    value?: string;
+    uncheckedValue?: string;
+    form?: string;
+    inputRef?: React.Ref<HTMLInputElement>;
+    /** @default false */
+    nativeButton?: boolean;
+    className?: UpstreamRoot["className"];
+    style?: UpstreamRoot["style"];
+    render?: UpstreamRoot["render"];
+};
+/**
+ * Switch.Root — toggleable on/off control.
+ *
+ * @doc https://base-ui.com/react/components/switch
+ * @llm https://base-ui.com/react/components/switch.md
+ */
+export declare function Root({ className, ...props }: RootProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Root {
+    var displayName: string;
+}
+type ThumbProps = Omit<React.HTMLAttributes<HTMLSpanElement>, "className" | "style"> & {
+    className?: UpstreamThumb["className"];
+    style?: UpstreamThumb["style"];
+    render?: UpstreamThumb["render"];
+};
+/** Switch.Thumb — the movable indicator inside the track. */
+export declare function Thumb({ className, ...props }: ThumbProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Thumb {
+    var displayName: string;
+}
+export {};

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

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

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

@@ -0,0 +1,2 @@
+export * as Table from './table';
+export { tableMeta } from './table.meta';

package/dist/components/table/table.d.ts

@@ -0,0 +1,66 @@
+type RootProps = React.TableHTMLAttributes<HTMLTableElement>;
+type HeaderProps = React.HTMLAttributes<HTMLTableSectionElement>;
+type BodyProps = React.HTMLAttributes<HTMLTableSectionElement>;
+type RowProps = React.HTMLAttributes<HTMLTableRowElement>;
+type HeaderCellProps = React.ThHTMLAttributes<HTMLTableCellElement>;
+type CellProps = React.TdHTMLAttributes<HTMLTableCellElement>;
+type HeaderButtonProps = React.ButtonHTMLAttributes<HTMLButtonElement>;
+/** Table.Root — the `<table>` element. */
+export declare function Root({ className, ...props }: RootProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Root {
+    var displayName: string;
+}
+/** Table.Header — the `<thead>` section. */
+export declare function Header({ className, ...props }: HeaderProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Header {
+    var displayName: string;
+}
+/** Table.Body — the `<tbody>` section. */
+export declare function Body({ className, ...props }: BodyProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Body {
+    var displayName: string;
+}
+/** Table.Row — a `<tr>` in header or body. */
+export declare function Row({ className, ...props }: RowProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Row {
+    var displayName: string;
+}
+/** Table.HeaderCell — a `<th>` header cell. */
+export declare function HeaderCell({ className, ...props }: HeaderCellProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace HeaderCell {
+    var displayName: string;
+}
+/** Table.Cell — a `<td>` data cell. */
+export declare function Cell({ className, ...props }: CellProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Cell {
+    var displayName: string;
+}
+/**
+ * Table.HeaderButton — inline action button for header cells. Generic by
+ * design: sorting toggles, filter toggles, column menus all render through it
+ * rather than each inventing a button. Icon/indicator goes in `children`.
+ */
+export declare function HeaderButton({ className, type, ...props }: HeaderButtonProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace HeaderButton {
+    var displayName: string;
+}
+/** The sort state of a column: `false` = sortable but unsorted, else the active direction. */
+type SortDirection = false | "asc" | "desc";
+type SortableHeaderCellProps = Omit<HeaderCellProps, "aria-sort"> & {
+    /** Current sort state. `false` renders the affordance in its unsorted rest state. */
+    sortDirection: SortDirection;
+    /** Toggle handler. Omit to render a plain, non-sortable header cell instead. */
+    onToggle?: React.MouseEventHandler<HTMLButtonElement>;
+};
+/**
+ * Table.SortableHeaderCell — a partial: a header cell whose label is a sort
+ * toggle, pre-composing HeaderCell + HeaderButton so the `aria-sort` state and
+ * direction indicator don't get re-derived per consumer app. Headless-upstream-
+ * agnostic: feed it `sortDirection` and `onToggle` (e.g. from a TanStack
+ * column). Omit `onToggle` and it renders a plain non-sortable header cell.
+ */
+export declare function SortableHeaderCell({ sortDirection, onToggle, children, ...props }: SortableHeaderCellProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace SortableHeaderCell {
+    var displayName: string;
+}
+export {};

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

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

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

@@ -0,0 +1,2 @@
+export * as Tabs from './tabs';
+export { tabsMeta } from './tabs.meta';