@exsto/ds 0.0.0-stage → 0.0.1-rc.10

package/dist/ui/src/components/ui/marker/index.d.ts

@@ -0,0 +1 @@
+export * from './marker';

package/dist/ui/src/components/ui/marker/marker.d.ts

@@ -0,0 +1,9 @@
+import { useRender } from '@base-ui/react/use-render';
+import { VariantProps } from 'class-variance-authority';
+import type * as React from 'react';
+export declare const markerVariants: (props?: ({
+    variant?: "default" | "separator" | "border" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export declare const Marker: ({ className, variant, render, ...props }: useRender.ComponentProps<"div"> & VariantProps<typeof markerVariants>) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+export declare const MarkerIcon: ({ className, ...props }: React.ComponentProps<"span">) => React.JSX.Element;
+export declare const MarkerContent: ({ className, ...props }: React.ComponentProps<"span">) => React.JSX.Element;

package/dist/ui/src/components/ui/menubar/index.d.ts

@@ -0,0 +1 @@
+export * from './menubar';

package/dist/ui/src/components/ui/menubar/menubar.d.ts

@@ -0,0 +1,28 @@
+import { Menu as MenuPrimitive } from '@base-ui/react/menu';
+import { Menubar as MenubarPrimitive } from '@base-ui/react/menubar';
+import { DropdownMenu, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger } from '../dropdown-menu';
+import type * as React from 'react';
+export declare const Menubar: ({ className, ...props }: MenubarPrimitive.Props) => React.JSX.Element;
+export declare const MenubarMenu: ({ ...props }: React.ComponentProps<typeof DropdownMenu>) => React.JSX.Element;
+export declare const MenubarGroup: ({ ...props }: React.ComponentProps<typeof DropdownMenuGroup>) => React.JSX.Element;
+export declare const MenubarPortal: ({ ...props }: React.ComponentProps<typeof DropdownMenuPortal>) => React.JSX.Element;
+export declare const MenubarTrigger: ({ className, ...props }: React.ComponentProps<typeof DropdownMenuTrigger>) => React.JSX.Element;
+export declare const MenubarContent: ({ className, align, alignOffset, sideOffset, ...props }: React.ComponentProps<typeof DropdownMenuContent>) => React.JSX.Element;
+export declare const MenubarItem: ({ className, inset, variant, ...props }: React.ComponentProps<typeof DropdownMenuItem>) => React.JSX.Element;
+export declare const MenubarCheckboxItem: ({ className, children, checked, inset, ...props }: MenuPrimitive.CheckboxItem.Props & {
+    inset?: boolean;
+}) => React.JSX.Element;
+export declare const MenubarRadioGroup: ({ ...props }: React.ComponentProps<typeof DropdownMenuRadioGroup>) => React.JSX.Element;
+export declare const MenubarRadioItem: ({ className, children, inset, ...props }: MenuPrimitive.RadioItem.Props & {
+    inset?: boolean;
+}) => React.JSX.Element;
+export declare const MenubarLabel: ({ className, inset, ...props }: React.ComponentProps<typeof DropdownMenuLabel> & {
+    inset?: boolean;
+}) => React.JSX.Element;
+export declare const MenubarSeparator: ({ className, ...props }: React.ComponentProps<typeof DropdownMenuSeparator>) => React.JSX.Element;
+export declare const MenubarShortcut: ({ className, ...props }: React.ComponentProps<typeof DropdownMenuShortcut>) => React.JSX.Element;
+export declare const MenubarSub: ({ ...props }: React.ComponentProps<typeof DropdownMenuSub>) => React.JSX.Element;
+export declare const MenubarSubTrigger: ({ className, inset, ...props }: React.ComponentProps<typeof DropdownMenuSubTrigger> & {
+    inset?: boolean;
+}) => React.JSX.Element;
+export declare const MenubarSubContent: ({ className, ...props }: React.ComponentProps<typeof DropdownMenuSubContent>) => React.JSX.Element;

package/dist/ui/src/components/ui/message/index.d.ts

@@ -0,0 +1 @@
+export * from './message';

package/dist/ui/src/components/ui/message/message.d.ts

@@ -0,0 +1,9 @@
+import type * as React from 'react';
+export declare const MessageGroup: ({ className, ...props }: React.ComponentProps<"div">) => React.JSX.Element;
+export declare const Message: ({ className, align, ...props }: React.ComponentProps<"div"> & {
+    align?: "start" | "end";
+}) => React.JSX.Element;
+export declare const MessageAvatar: ({ className, ...props }: React.ComponentProps<"div">) => React.JSX.Element;
+export declare const MessageContent: ({ className, ...props }: React.ComponentProps<"div">) => React.JSX.Element;
+export declare const MessageHeader: ({ className, ...props }: React.ComponentProps<"div">) => React.JSX.Element;
+export declare const MessageFooter: ({ className, ...props }: React.ComponentProps<"div">) => React.JSX.Element;

package/dist/ui/src/components/ui/message-scroller/index.d.ts

@@ -0,0 +1 @@
+export * from './message-scroller';

package/dist/ui/src/components/ui/message-scroller/message-scroller.d.ts

@@ -0,0 +1,10 @@
+import { MessageScroller as MessageScrollerPrimitive } from '@shadcn/react/message-scroller';
+import { Button } from '../button';
+export { useMessageScroller, useMessageScrollerScrollable, useMessageScrollerVisibility } from '@shadcn/react/message-scroller';
+import type * as React from 'react';
+export declare const MessageScrollerProvider: (props: React.ComponentProps<typeof MessageScrollerPrimitive.Provider>) => React.JSX.Element;
+export declare const MessageScroller: ({ className, ...props }: React.ComponentProps<typeof MessageScrollerPrimitive.Root>) => React.JSX.Element;
+export declare const MessageScrollerViewport: ({ className, ...props }: React.ComponentProps<typeof MessageScrollerPrimitive.Viewport>) => React.JSX.Element;
+export declare const MessageScrollerContent: ({ className, ...props }: React.ComponentProps<typeof MessageScrollerPrimitive.Content>) => React.JSX.Element;
+export declare const MessageScrollerItem: ({ className, scrollAnchor, ...props }: React.ComponentProps<typeof MessageScrollerPrimitive.Item>) => React.JSX.Element;
+export declare const MessageScrollerButton: ({ direction, className, children, render, variant, size, ...props }: React.ComponentProps<typeof MessageScrollerPrimitive.Button> & Pick<React.ComponentProps<typeof Button>, "variant" | "size">) => React.JSX.Element;

package/dist/ui/src/components/ui/native-select/index.d.ts

@@ -0,0 +1 @@
+export * from './native-select';

package/dist/ui/src/components/ui/native-select/native-select.d.ts

@@ -0,0 +1,8 @@
+import type * as React from 'react';
+type TNativeSelectProps = Omit<React.ComponentProps<'select'>, 'size'> & {
+    size?: 'sm' | 'default';
+};
+export declare const NativeSelect: ({ className, size, ...props }: TNativeSelectProps) => React.JSX.Element;
+export declare const NativeSelectOption: ({ className, ...props }: React.ComponentProps<"option">) => React.JSX.Element;
+export declare const NativeSelectOptGroup: ({ className, ...props }: React.ComponentProps<"optgroup">) => React.JSX.Element;
+export {};

package/dist/ui/src/components/ui/navigation-menu/index.d.ts

@@ -0,0 +1 @@
+export * from './navigation-menu';

package/dist/ui/src/components/ui/navigation-menu/navigation-menu.d.ts

@@ -0,0 +1,10 @@
+import { NavigationMenu as NavigationMenuPrimitive } from '@base-ui/react/navigation-menu';
+export declare const NavigationMenu: ({ align, className, children, ...props }: NavigationMenuPrimitive.Root.Props & Pick<NavigationMenuPrimitive.Positioner.Props, "align">) => import('react').JSX.Element;
+export declare const NavigationMenuList: ({ className, ...props }: React.ComponentPropsWithRef<typeof NavigationMenuPrimitive.List>) => import('react').JSX.Element;
+export declare const NavigationMenuItem: ({ className, ...props }: React.ComponentPropsWithRef<typeof NavigationMenuPrimitive.Item>) => import('react').JSX.Element;
+export declare const navigationMenuTriggerStyle: (props?: import('class-variance-authority/types').ClassProp | undefined) => string;
+export declare const NavigationMenuTrigger: ({ className, children, ...props }: NavigationMenuPrimitive.Trigger.Props) => import('react').JSX.Element;
+export declare const NavigationMenuContent: ({ className, ...props }: NavigationMenuPrimitive.Content.Props) => import('react').JSX.Element;
+export declare const NavigationMenuPositioner: ({ className, side, sideOffset, align, alignOffset, ...props }: NavigationMenuPrimitive.Positioner.Props) => import('react').JSX.Element;
+export declare const NavigationMenuLink: ({ className, ...props }: NavigationMenuPrimitive.Link.Props) => import('react').JSX.Element;
+export declare const NavigationMenuIndicator: ({ className, ...props }: React.ComponentPropsWithRef<typeof NavigationMenuPrimitive.Icon>) => import('react').JSX.Element;

package/dist/ui/src/components/ui/pagination/index.d.ts

@@ -0,0 +1 @@
+export * from './pagination';

package/dist/ui/src/components/ui/pagination/pagination.behavior.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/ui/src/components/ui/pagination/pagination.d.ts

@@ -0,0 +1,18 @@
+import type * as React from 'react';
+export type TPaginationRangeItem = number | 'ellipsis';
+/**
+ * Compute the ordered list of page numbers and ellipsis markers to render.
+ * First and last pages are always included. `siblingCount` controls how many
+ * page numbers appear on each side of the current page.
+ */
+export declare const getPaginationRange: (page: number, count: number, siblingCount?: number) => TPaginationRangeItem[];
+/** Clamp a page number to the valid [1, count] range (count <= 0 yields 1). */
+export declare const clampPage: (page: number, count: number) => number;
+export interface IPaginationProps extends Omit<React.ComponentPropsWithoutRef<'nav'>, 'className' | 'children'> {
+    page: number;
+    count: number;
+    onPageChange: (page: number) => void;
+    siblingCount?: number;
+    className?: string;
+}
+export declare const Pagination: ({ page, count, onPageChange, siblingCount, className, ...props }: IPaginationProps) => React.JSX.Element;

package/dist/ui/src/components/ui/pagination/pagination.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/ui/src/components/ui/popover/index.d.ts

@@ -0,0 +1 @@
+export * from './popover';

package/dist/ui/src/components/ui/popover/popover.d.ts

@@ -0,0 +1,8 @@
+import { Popover as PopoverPrimitive } from '@base-ui/react/popover';
+import type * as React from 'react';
+export declare const Popover: ({ ...props }: PopoverPrimitive.Root.Props) => React.JSX.Element;
+export declare const PopoverTrigger: ({ ...props }: PopoverPrimitive.Trigger.Props) => React.JSX.Element;
+export declare const PopoverContent: ({ className, align, alignOffset, side, sideOffset, anchor, ...props }: PopoverPrimitive.Popup.Props & Pick<PopoverPrimitive.Positioner.Props, "align" | "alignOffset" | "anchor" | "side" | "sideOffset">) => React.JSX.Element;
+export declare const PopoverHeader: ({ className, ...props }: React.ComponentProps<"div">) => React.JSX.Element;
+export declare const PopoverTitle: ({ className, ...props }: PopoverPrimitive.Title.Props) => React.JSX.Element;
+export declare const PopoverDescription: ({ className, ...props }: PopoverPrimitive.Description.Props) => React.JSX.Element;

package/dist/ui/src/components/ui/progress/index.d.ts

@@ -0,0 +1 @@
+export * from './progress';

package/dist/ui/src/components/ui/progress/progress.behavior.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Progress tones: a closed set of theme tokens, never a free class string.
+ *
+ * PATH TAKEN: classes and attributes do not depend on layout, so happy-dom is enough. The
+ * tokens' contrast is measured from the real tokens.css below, and the rendered colours in
+ * the browser by e2e/progress-tone.spec.ts.
+ */
+export {};

package/dist/ui/src/components/ui/progress/progress.d.ts

@@ -0,0 +1,47 @@
+import { Progress as ProgressPrimitive } from '@base-ui/react/progress';
+import { VariantProps } from 'class-variance-authority';
+/**
+ * The tones: a closed set of semantic colours rather than a class string, so a bar cannot carry a
+ * colour the theme does not define and dark mode and a re-theme keep working. Each is the theme token
+ * the fill uses; the track is a 20% tint of the same token.
+ */
+declare const TONE_TOKEN: {
+    readonly default: "var(--primary)";
+    readonly info: "var(--info)";
+    readonly success: "var(--success)";
+    readonly warning: "var(--warning)";
+    readonly destructive: "var(--destructive)";
+};
+export type TProgressTone = keyof typeof TONE_TOKEN;
+/**
+ * Colours an app can set without a class string. --progress-color replaces the fill (any colour, such as an
+ * app's own status tokens); --progress-track replaces the track, which does not follow the fill: an app
+ * that wants a neutral track sets it to var(--muted). Both are read where the bar is, so they follow the
+ * theme and can be set on :root or on any ancestor.
+ */
+export declare const progressFill: (tone: TProgressTone) => string;
+export declare const progressTrack: (tone: TProgressTone) => string;
+/**
+ * How the fill eases its width. The defaults are the 300ms ease-in-out it always had; an app retunes them
+ * with --progress-duration and --progress-ease, or turns the easing off with `animated={false}` when the
+ * number it shows is itself animated and the bar is driven from the same clock.
+ */
+export declare const PROGRESS_DURATION = "var(--progress-duration, 300ms)";
+export declare const PROGRESS_EASE = "var(--progress-ease, cubic-bezier(0.4, 0, 0.2, 1))";
+declare const progressTrackVariants: (props?: ({
+    size?: "default" | "sm" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface IProgressProps extends Omit<ProgressPrimitive.Root.Props, 'value'> {
+    value?: number | null;
+    /** The bar's colour: a share of a total reads as `warning` when nearly used up, `success` when done. */
+    tone?: TProgressTone;
+    /** 4px (`sm`) or 8px (default) tall. */
+    size?: VariantProps<typeof progressTrackVariants>['size'];
+    /**
+     * Whether the fill eases when `value` changes. Turn it off when the value already moves smoothly
+     * (driven from an animated number's clock), or the bar eases a second time behind it.
+     */
+    animated?: boolean;
+}
+export declare const Progress: ({ value, tone, size, animated, className, ...props }: IProgressProps) => import('react').JSX.Element;
+export {};

package/dist/ui/src/components/ui/questionnaire/index.d.ts

@@ -0,0 +1 @@
+export * from './questionnaire';

package/dist/ui/src/components/ui/questionnaire/questionnaire.d.ts

@@ -0,0 +1,18 @@
+import { Questionnaire as QuestionnairePrimitive } from '@shadcn/react/questionnaire';
+import { Button } from '../button';
+import type * as React from 'react';
+export declare const Questionnaire: ({ className, ...props }: React.ComponentProps<typeof QuestionnairePrimitive.Root>) => React.JSX.Element;
+export declare const QuestionnaireProgress: ({ className, ...props }: React.ComponentProps<typeof QuestionnairePrimitive.Progress>) => React.JSX.Element;
+export declare const QuestionnaireItem: ({ className, ...props }: React.ComponentProps<typeof QuestionnairePrimitive.Item>) => React.JSX.Element;
+export declare const QuestionnaireTitle: ({ className, ...props }: React.ComponentProps<typeof QuestionnairePrimitive.Title>) => React.JSX.Element;
+export declare const QuestionnaireDescription: ({ className, ...props }: React.ComponentProps<typeof QuestionnairePrimitive.Description>) => React.JSX.Element;
+export declare const QuestionnaireChoices: ({ className, ...props }: React.ComponentProps<typeof QuestionnairePrimitive.Choices>) => React.JSX.Element;
+export declare const QuestionnaireChoice: ({ children, className, ...props }: React.ComponentProps<typeof QuestionnairePrimitive.Choice>) => React.JSX.Element;
+export declare const QuestionnaireChoiceDescription: ({ className, ...props }: React.ComponentProps<"span">) => React.JSX.Element;
+export declare const QuestionnaireInput: ({ className, ...props }: React.ComponentProps<typeof QuestionnairePrimitive.Input>) => React.JSX.Element;
+export declare const QuestionnaireError: ({ className, ...props }: React.ComponentProps<typeof QuestionnairePrimitive.Error>) => React.JSX.Element;
+export declare const QuestionnaireActions: ({ className, ...props }: React.ComponentProps<"div">) => React.JSX.Element;
+export declare const QuestionnairePrevious: ({ children, className, size, variant, ...props }: React.ComponentProps<typeof QuestionnairePrimitive.Previous> & Pick<React.ComponentProps<typeof Button>, "size" | "variant">) => React.JSX.Element;
+export declare const QuestionnaireSkip: ({ children, className, size, variant, ...props }: React.ComponentProps<typeof QuestionnairePrimitive.Skip> & Pick<React.ComponentProps<typeof Button>, "size" | "variant">) => React.JSX.Element;
+export declare const QuestionnaireNext: ({ children, className, size, variant, ...props }: React.ComponentProps<typeof QuestionnairePrimitive.Next> & Pick<React.ComponentProps<typeof Button>, "size" | "variant">) => React.JSX.Element;
+export declare const QuestionnaireSubmit: ({ children, className, size, variant, ...props }: React.ComponentProps<typeof QuestionnairePrimitive.Submit> & Pick<React.ComponentProps<typeof Button>, "size" | "variant">) => React.JSX.Element;

package/dist/ui/src/components/ui/radio-group/index.d.ts

@@ -0,0 +1 @@
+export * from './radio-group';

package/dist/ui/src/components/ui/radio-group/radio-group.d.ts

@@ -0,0 +1,10 @@
+import { Radio } from '@base-ui/react/radio';
+import { RadioGroup as RadioGroupPrimitive } from '@base-ui/react/radio-group';
+export interface IRadioGroupProps extends RadioGroupPrimitive.Props {
+    orientation?: 'horizontal' | 'vertical';
+}
+export declare const RadioGroup: ({ className, orientation, ...props }: IRadioGroupProps) => import('react').JSX.Element;
+export interface IRadioGroupItemProps extends Radio.Root.Props {
+    className?: string;
+}
+export declare const RadioGroupItem: ({ className, ...props }: IRadioGroupItemProps) => import('react').JSX.Element;

package/dist/ui/src/components/ui/resizable/index.d.ts

@@ -0,0 +1 @@
+export * from './resizable';

package/dist/ui/src/components/ui/resizable/resizable.d.ts

@@ -0,0 +1,6 @@
+import * as ResizablePrimitive from 'react-resizable-panels';
+export declare const ResizablePanelGroup: ({ className, ...props }: ResizablePrimitive.GroupProps) => import('react').JSX.Element;
+export declare const ResizablePanel: ({ ...props }: ResizablePrimitive.PanelProps) => import('react').JSX.Element;
+export declare const ResizableHandle: ({ withHandle, className, ...props }: ResizablePrimitive.SeparatorProps & {
+    withHandle?: boolean;
+}) => import('react').JSX.Element;

package/dist/ui/src/components/ui/scroll-area/index.d.ts

@@ -0,0 +1 @@
+export * from './scroll-area';

package/dist/ui/src/components/ui/scroll-area/scroll-area.behavior.test.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Edge-fade wiring and the sizing contract for ScrollArea.
+ *
+ * PATH TAKEN: the fades are cut by a mask in scroll-fade.css, keyed off the
+ * overflow flags Base UI keeps on the root (data-overflow-y-start and friends).
+ * happy-dom has neither layout nor a stylesheet, so what is checked here is the
+ * contract the stylesheet reads: which axis the component declares, and that
+ * nothing of the painted version is left behind. The mask itself, and the flags
+ * flipping at the right moment, are measured in a real browser by
+ * e2e/scroll-area-fade.spec.ts.
+ */
+export {};

package/dist/ui/src/components/ui/scroll-area/scroll-area.d.ts

@@ -0,0 +1,85 @@
+import { ScrollArea as BaseScrollArea } from '@base-ui/react/scroll-area';
+import { ComponentProps, RefObject } from 'react';
+/**
+ * When the bar shows: 'hover' on area hover or while scrolling (default),
+ * 'scroll' only while scrolling, 'always' permanent. In every mode the bar is
+ * mounted only while that axis actually overflows, so 'always' means "always
+ * when there is something to scroll", never a bar on a list that fits.
+ */
+export type TScrollbarVisibility = 'hover' | 'scroll' | 'always';
+/**
+ * Surface the edge fades blended into, back when they were painted.
+ *
+ * @deprecated The fades are cut into the content by a mask, so they match any
+ * surface without being told which one. Still accepted, and ignored.
+ */
+export type TScrollAreaFadeFrom = 'card' | 'background' | 'sidebar' | 'popover';
+export interface IScrollBarProps extends ComponentProps<typeof BaseScrollArea.Scrollbar> {
+    visibility?: TScrollbarVisibility;
+}
+export declare const ScrollBar: ({ className, orientation, visibility, ...props }: IScrollBarProps) => import('react').JSX.Element;
+export interface IScrollAreaProps extends ComponentProps<typeof BaseScrollArea.Root> {
+    /** Which axes get a styled scrollbar; content decides what actually overflows. */
+    orientation?: 'horizontal' | 'vertical' | 'both';
+    /** Scrollbar reveal behavior (mirrors the Radix ScrollArea `type` prop). */
+    type?: TScrollbarVisibility;
+    /** Edge fades hinting at clipped content; each one shows only while its own edge hides something. */
+    fade?: boolean;
+    /**
+     * @deprecated No longer read. The fades mask the content, so they sit correctly
+     * on any surface; passing this does nothing and is safe to delete.
+     */
+    fadeFrom?: TScrollAreaFadeFrom;
+    /** Places both bars, for a host that gives them a gutter of their own (a sidebar menu). */
+    scrollbarClassName?: string;
+    viewportId?: string;
+    /** Access to the scrollable viewport (e.g. to reset scroll position on route changes). */
+    viewportRef?: RefObject<HTMLDivElement | null>;
+    viewportClassName?: string;
+    /** Published on the viewport as data-scroll-restoration-id, for a router that restores scroll position. */
+    scrollRestorationId?: string;
+    /**
+     * Whether the viewport is a tab stop of its own (default). Turn it off inside a
+     * widget that already owns focus, a menu above all: its items are the tab
+     * stops, and a focusable wrapper between the role and its items is both
+     * redundant and an aria-required-children violation.
+     */
+    focusable?: boolean;
+    /** @deprecated Use `viewportId`. */
+    viewPortId?: string;
+    /** @deprecated Use `viewportRef`. */
+    viewPortRef?: RefObject<HTMLDivElement | null>;
+    /** @deprecated Use `viewportClassName`. */
+    viewPortClassName?: string;
+    /** Places the vertical bar only; `scrollbarClassName` covers both. */
+    scrollVerticalClassName?: string;
+    /** Places the horizontal bar only; `scrollbarClassName` covers both. */
+    scrollHorizontalClassName?: string;
+}
+/**
+ * Themed scroll container (Base UI): overflowing content scrolls INSIDE the component
+ * with a slim overlay scrollbar instead of exposing a native browser scrollbar. House
+ * rule: wide/tall content (tables, lists, code) always goes through this, never a bare
+ * overflow-* utility.
+ *
+ * Cap the height with a plain class on the component itself, e.g.
+ * `<ScrollArea className="max-h-88">`. The viewport picks the cap up through
+ * `max-h-inherit`, which matters because the viewport is the element that actually
+ * scrolls: a cap that lands only on the root leaves tall content spilling out
+ * underneath with no scrollbar, and that reads as a working height right up until the
+ * content outgrows it.
+ *
+ * `fade` fades out each edge that is currently hiding content, rather than always
+ * fading one: a permanent fade is a lie half the time, dimming the last row that fits
+ * and promising more below when the reader is already at the end. It is cut into the
+ * content by a mask (@edyn/theme/scroll-fade.css), so it needs no surface colour and
+ * reads correctly over a tint, a gradient or a glow. A host that keeps something
+ * unscrolled at the top, such as a sticky table header, exempts that band by setting
+ * --scroll-fade-offset on the ScrollArea. The static faded-* utilities in
+ * @edyn/theme/utilities.css are the other tool, for DECORATIVE edges that do not
+ * track scroll position.
+ *
+ * The viewport publishes its size as --scroll-area-width/--scroll-area-height CSS vars
+ * so children can size against the visible area.
+ */
+export declare const ScrollArea: ({ className, children, orientation, type, fade, fadeFrom, scrollbarClassName, viewportId, viewportRef, viewportClassName, scrollRestorationId, focusable, viewPortId, viewPortRef, viewPortClassName, scrollVerticalClassName, scrollHorizontalClassName, ...props }: IScrollAreaProps) => import('react').JSX.Element;

package/dist/ui/src/components/ui/select/index.d.ts

@@ -0,0 +1 @@
+export * from './select';

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

@@ -0,0 +1,17 @@
+import { Select as SelectPrimitive } from '@base-ui/react/select';
+import type * as React from 'react';
+export declare const Select: <TValue>({ ...props }: SelectPrimitive.Root.Props<TValue>) => React.JSX.Element;
+export type TSelectTriggerSize = 'sm' | 'default';
+export interface ISelectTriggerProps extends SelectPrimitive.Trigger.Props {
+    size?: TSelectTriggerSize;
+}
+export declare const SelectTrigger: ({ className, size, children, ...props }: ISelectTriggerProps) => React.JSX.Element;
+export declare const SelectValue: ({ className, ...props }: SelectPrimitive.Value.Props) => React.JSX.Element;
+export interface ISelectContentProps extends SelectPrimitive.Popup.Props {
+    portalContainer?: SelectPrimitive.Portal.Props['container'];
+}
+export declare const SelectContent: ({ className, children, portalContainer, ...props }: ISelectContentProps) => React.JSX.Element;
+export declare const SelectGroup: ({ className, ...props }: SelectPrimitive.Group.Props) => React.JSX.Element;
+export declare const SelectLabel: ({ className, ...props }: SelectPrimitive.GroupLabel.Props) => React.JSX.Element;
+export declare const SelectItem: ({ className, children, ...props }: SelectPrimitive.Item.Props) => React.JSX.Element;
+export declare const SelectSeparator: ({ className, ...props }: React.ComponentProps<"div">) => React.JSX.Element;

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

@@ -0,0 +1 @@
+export * from './separator';

package/dist/ui/src/components/ui/separator/separator.behavior.test.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Orientation styling for Separator, and a guard for the bug class behind it.
+ *
+ * Base UI publishes orientation as `data-orientation="horizontal|vertical"`. It
+ * has no `data-horizontal` / `data-vertical` attribute, so a bare
+ * `data-vertical:` variant compiles to a selector that matches nothing: the
+ * component looks styled, and silently is not. A vertical Separator came out
+ * with no width at all that way.
+ *
+ * PATH TAKEN: happy-dom renders no layout, so this asserts the class the
+ * component chose per orientation plus the attribute Base UI emitted, and the
+ * second block greps the package for the dead variant form.
+ */
+export {};

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

@@ -0,0 +1,16 @@
+import { Separator as SeparatorPrimitive } from '@base-ui/react/separator';
+/**
+ * Hairline rule between content, announced as `role="separator"`.
+ *
+ * The orientation styles are branched in TS rather than written as
+ * `data-[orientation=*]:` variants on purpose. A variant carries two
+ * selectors' worth of specificity, so it would outrank a plain class passed in
+ * by the caller: the sidebar's own `w-auto` lost to `w-full` that way. Branching
+ * emits one plain class per axis, which `cn` can dedupe and a caller can
+ * override.
+ *
+ * Vertical uses `self-stretch` instead of `h-full`: a percentage height needs a
+ * definite parent, and the usual host is an `items-center` row whose height
+ * comes from its content.
+ */
+export declare const Separator: ({ className, orientation, ...props }: SeparatorPrimitive.Props) => import('react').JSX.Element;

package/dist/ui/src/components/ui/sheet/index.d.ts

@@ -0,0 +1 @@
+export * from './sheet';

package/dist/ui/src/components/ui/sheet/sheet.d.ts

@@ -0,0 +1,13 @@
+import { Dialog as SheetPrimitive } from '@base-ui/react/dialog';
+import type * as React from 'react';
+export declare const Sheet: ({ ...props }: SheetPrimitive.Root.Props) => React.JSX.Element;
+export declare const SheetTrigger: ({ ...props }: SheetPrimitive.Trigger.Props) => React.JSX.Element;
+export declare const SheetClose: ({ ...props }: SheetPrimitive.Close.Props) => React.JSX.Element;
+export declare const SheetContent: ({ className, children, side, showCloseButton, ...props }: SheetPrimitive.Popup.Props & {
+    side?: "top" | "right" | "bottom" | "left";
+    showCloseButton?: boolean;
+}) => React.JSX.Element;
+export declare const SheetHeader: ({ className, ...props }: React.ComponentProps<"div">) => React.JSX.Element;
+export declare const SheetFooter: ({ className, ...props }: React.ComponentProps<"div">) => React.JSX.Element;
+export declare const SheetTitle: ({ className, ...props }: SheetPrimitive.Title.Props) => React.JSX.Element;
+export declare const SheetDescription: ({ className, ...props }: SheetPrimitive.Description.Props) => React.JSX.Element;

package/dist/ui/src/components/ui/sidebar/index.d.ts

@@ -0,0 +1 @@
+export * from './sidebar';

package/dist/ui/src/components/ui/sidebar/sidebar.d.ts

@@ -0,0 +1,63 @@
+import { useRender } from '@base-ui/react/use-render';
+import { VariantProps } from 'class-variance-authority';
+import { Button } from '../button';
+import { Input } from '../input';
+import { Separator } from '../separator';
+import { TooltipContent } from '../tooltip';
+import * as React from 'react';
+type TSidebarContextProps = {
+    state: 'expanded' | 'collapsed';
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    openMobile: boolean;
+    setOpenMobile: (open: boolean) => void;
+    isMobile: boolean;
+    toggleSidebar: () => void;
+};
+export declare const useSidebar: () => TSidebarContextProps;
+export declare const SidebarProvider: ({ defaultOpen, open: openProp, onOpenChange: setOpenProp, className, style, children, ...props }: React.ComponentProps<"div"> & {
+    defaultOpen?: boolean;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}) => React.JSX.Element;
+export declare const Sidebar: ({ side, variant, collapsible, className, children, dir, ...props }: React.ComponentProps<"div"> & {
+    side?: "left" | "right";
+    variant?: "sidebar" | "floating" | "inset";
+    collapsible?: "offcanvas" | "icon" | "none";
+}) => React.JSX.Element;
+export declare const SidebarTrigger: ({ className, onClick, ...props }: React.ComponentProps<typeof Button>) => React.JSX.Element;
+export declare const SidebarRail: ({ className, ...props }: React.ComponentProps<"button">) => React.JSX.Element;
+export declare const SidebarInset: ({ className, ...props }: React.ComponentProps<"main">) => React.JSX.Element;
+export declare const SidebarInput: ({ className, ...props }: React.ComponentProps<typeof Input>) => React.JSX.Element;
+export declare const SidebarHeader: ({ className, ...props }: React.ComponentProps<"div">) => React.JSX.Element;
+export declare const SidebarFooter: ({ className, ...props }: React.ComponentProps<"div">) => React.JSX.Element;
+export declare const SidebarSeparator: ({ className, ...props }: React.ComponentProps<typeof Separator>) => React.JSX.Element;
+export declare const SidebarContent: ({ className, ...props }: React.ComponentProps<"div">) => React.JSX.Element;
+export declare const SidebarGroup: ({ className, ...props }: React.ComponentProps<"div">) => React.JSX.Element;
+export declare const SidebarGroupLabel: ({ className, render, ...props }: useRender.ComponentProps<"div"> & React.ComponentProps<"div">) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+export declare const SidebarGroupAction: ({ className, render, ...props }: useRender.ComponentProps<"button"> & React.ComponentProps<"button">) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+export declare const SidebarGroupContent: ({ className, ...props }: React.ComponentProps<"div">) => React.JSX.Element;
+export declare const SidebarMenu: ({ className, ...props }: React.ComponentProps<"ul">) => React.JSX.Element;
+export declare const SidebarMenuItem: ({ className, ...props }: React.ComponentProps<"li">) => React.JSX.Element;
+declare const sidebarMenuButtonVariants: (props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export declare const SidebarMenuButton: ({ render, isActive, variant, size, tooltip, className, ...props }: useRender.ComponentProps<"button"> & React.ComponentProps<"button"> & {
+    isActive?: boolean;
+    tooltip?: string | React.ComponentProps<typeof TooltipContent>;
+} & VariantProps<typeof sidebarMenuButtonVariants>) => React.JSX.Element;
+export declare const SidebarMenuAction: ({ className, render, showOnHover, ...props }: useRender.ComponentProps<"button"> & React.ComponentProps<"button"> & {
+    showOnHover?: boolean;
+}) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+export declare const SidebarMenuBadge: ({ className, ...props }: React.ComponentProps<"div">) => React.JSX.Element;
+export declare const SidebarMenuSkeleton: ({ className, showIcon, ...props }: React.ComponentProps<"div"> & {
+    showIcon?: boolean;
+}) => React.JSX.Element;
+export declare const SidebarMenuSub: ({ className, ...props }: React.ComponentProps<"ul">) => React.JSX.Element;
+export declare const SidebarMenuSubItem: ({ className, ...props }: React.ComponentProps<"li">) => React.JSX.Element;
+export declare const SidebarMenuSubButton: ({ render, size, isActive, className, ...props }: useRender.ComponentProps<"a"> & React.ComponentProps<"a"> & {
+    size?: "sm" | "md";
+    isActive?: boolean;
+}) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+export {};

package/dist/ui/src/components/ui/skeleton/index.d.ts

@@ -0,0 +1 @@
+export * from './skeleton';

package/dist/ui/src/components/ui/skeleton/skeleton.d.ts

@@ -0,0 +1 @@
+export declare const Skeleton: ({ className, ...props }: React.ComponentProps<"div">) => import('react').JSX.Element;

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

@@ -0,0 +1 @@
+export * from './slider';

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

@@ -0,0 +1,17 @@
+import { Slider as SliderPrimitive } from '@base-ui/react/slider';
+export type TSliderValue = number | readonly number[];
+export interface ISliderProps<TValue extends TSliderValue = number> {
+    value?: TValue;
+    defaultValue?: TValue;
+    min?: number;
+    max?: number;
+    step?: number;
+    disabled?: boolean;
+    onValueChange?: (value: TValue extends number ? number : TValue, eventDetails: SliderPrimitive.Root.ChangeEventDetails) => void;
+    onValueCommitted?: (value: TValue extends number ? number : TValue, eventDetails: SliderPrimitive.Root.CommitEventDetails) => void;
+    className?: string;
+    name?: string;
+    minStepsBetweenValues?: number;
+    'aria-label'?: string;
+}
+export declare const Slider: <TValue extends TSliderValue = number>({ className, value, defaultValue, min, max, step, disabled, onValueChange, onValueCommitted, name, minStepsBetweenValues, "aria-label": ariaLabel, ...props }: ISliderProps<TValue>) => import('react').JSX.Element;

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

@@ -0,0 +1 @@
+export * from './spinner';

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

@@ -0,0 +1,5 @@
+import { VariantProps } from 'class-variance-authority';
+export declare const spinnerVariants: (props?: ({
+    size?: "default" | "xs" | "sm" | "lg" | "xl" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export declare const Spinner: ({ className, size, ...props }: React.ComponentProps<"svg"> & VariantProps<typeof spinnerVariants>) => import('react').JSX.Element;

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

@@ -0,0 +1 @@
+export * from './switch';

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

@@ -0,0 +1,4 @@
+import { Switch as SwitchPrimitive } from '@base-ui/react/switch';
+export declare const Switch: ({ className, size, ...props }: SwitchPrimitive.Root.Props & {
+    size?: "sm" | "default";
+}) => import('react').JSX.Element;

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

@@ -0,0 +1 @@
+export * from './table';

package/dist/ui/src/components/ui/table/table.behavior.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Structure test for the Table primitives.
+ *
+ * Uses happy-dom (registered by test-setup.ts) and the React-in-bun-test
+ * pattern: render with createRoot + flushSync, then query the real DOM. Guards
+ * that the primitives produce a semantic <table> (thead/tbody/th/td/caption) and
+ * the shadcn overflow wrapper, so consumers get a real, accessible table.
+ */
+export {};

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

@@ -0,0 +1,9 @@
+import type * as React from 'react';
+export declare const Table: ({ className, ...props }: React.ComponentProps<"table">) => React.JSX.Element;
+export declare const TableHeader: ({ className, ...props }: React.ComponentProps<"thead">) => React.JSX.Element;
+export declare const TableBody: ({ className, ...props }: React.ComponentProps<"tbody">) => React.JSX.Element;
+export declare const TableFooter: ({ className, ...props }: React.ComponentProps<"tfoot">) => React.JSX.Element;
+export declare const TableRow: ({ className, ...props }: React.ComponentProps<"tr">) => React.JSX.Element;
+export declare const TableHead: ({ className, ...props }: React.ComponentProps<"th">) => React.JSX.Element;
+export declare const TableCell: ({ className, ...props }: React.ComponentProps<"td">) => React.JSX.Element;
+export declare const TableCaption: ({ className, ...props }: React.ComponentProps<"caption">) => React.JSX.Element;

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

@@ -0,0 +1 @@
+export * from './tabs';