@labpane/ui 1.0.0 → 1.2.0

package/dist/ui/select.d.ts

@@ -0,0 +1,13 @@
+import * as React from "react";
+import * as SelectPrimitive from "@radix-ui/react-select";
+declare function Select({ value, defaultValue, onValueChange, ...props }: React.ComponentProps<typeof SelectPrimitive.Root>): React.JSX.Element;
+declare function SelectValue(props: React.ComponentProps<typeof SelectPrimitive.Value>): React.JSX.Element;
+declare const SelectTrigger: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & {
+    size?: "sm" | "default";
+    variant?: "default" | "ghost";
+} & React.RefAttributes<HTMLButtonElement>>;
+declare const SelectContent: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectItem: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    hint?: React.ReactNode;
+} & React.RefAttributes<HTMLDivElement>>;
+export { Select, SelectContent, SelectItem, SelectTrigger, SelectValue };

package/dist/ui/separator.d.ts

@@ -0,0 +1,6 @@
+import * as React from "react";
+declare const Separator: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    orientation?: "horizontal" | "vertical";
+    decorative?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+export { Separator };

package/dist/ui/settings.d.ts

@@ -0,0 +1,14 @@
+import * as React from "react";
+declare const SettingsSection: React.ForwardRefExoticComponent<Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, "ref">, "title"> & {
+    title: React.ReactNode;
+    description?: React.ReactNode;
+} & React.RefAttributes<HTMLElement>>;
+declare const SettingsRow: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    label: React.ReactNode;
+    description?: React.ReactNode;
+    htmlFor?: string;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const SettingsFooter: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    status?: React.ReactNode;
+} & React.RefAttributes<HTMLDivElement>>;
+export { SettingsSection, SettingsRow, SettingsFooter };

package/dist/ui/sheet.d.ts

@@ -0,0 +1,20 @@
+import * as React from "react";
+import * as SheetPrimitive from "@radix-ui/react-dialog";
+declare function Sheet({ open, defaultOpen, onOpenChange, ...props }: React.ComponentProps<typeof SheetPrimitive.Root>): React.JSX.Element;
+declare const SheetTrigger: React.ForwardRefExoticComponent<SheetPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const SheetClose: React.ForwardRefExoticComponent<SheetPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+declare const sheetSides: {
+    right: string;
+    left: string;
+    top: string;
+    bottom: string;
+};
+declare const SheetContent: React.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    side?: keyof typeof sheetSides;
+    showCloseButton?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const SheetHeader: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SheetFooter: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SheetTitle: React.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const SheetDescription: React.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+export { Sheet, SheetTrigger, SheetClose, SheetContent, SheetHeader, SheetFooter, SheetTitle, SheetDescription, };

package/dist/ui/side-panel.d.ts

@@ -0,0 +1,23 @@
+import * as React from "react";
+export type SidePanelLimits = {
+    minWidth: number;
+    maxWidth: number;
+    slack: number;
+    mainMinWidth: number;
+};
+export declare const sidePanelLimits: SidePanelLimits;
+export declare function resolveDrag(desired: number, available: number, limits: SidePanelLimits): {
+    open: boolean;
+    width: number;
+};
+declare const SidePanel: React.ForwardRefExoticComponent<Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, "ref">, "children"> & {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    width: number;
+    onWidthChange: (width: number) => void;
+    side?: "left" | "right";
+    label: string;
+    limits?: Partial<SidePanelLimits>;
+    children: React.ReactNode;
+} & React.RefAttributes<HTMLElement>>;
+export { SidePanel };

package/dist/ui/sidebar.d.ts

@@ -0,0 +1,81 @@
+import * as React from "react";
+import { TooltipContent } from "./tooltip.js";
+type SidebarState = {
+    state: "expanded" | "collapsed";
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    openMobile: boolean;
+    setOpenMobile: (open: boolean) => void;
+    isMobile: boolean;
+    toggleSidebar: () => void;
+};
+declare function useSidebar(): SidebarState;
+declare const SidebarProvider: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    defaultOpen?: boolean;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    shortcut?: string | null;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const Sidebar: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    side?: "left" | "right";
+    variant?: "sidebar" | "floating" | "inset";
+    collapsible?: "offcanvas" | "icon" | "none";
+} & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarTrigger: React.ForwardRefExoticComponent<Omit<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+    variant?: import("./button.js").ButtonVariant | null;
+    size?: import("./button.js").ButtonSize | null;
+    asChild?: boolean;
+} & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const SidebarRail: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const SidebarInset: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+declare const SidebarInput: React.ForwardRefExoticComponent<Omit<Omit<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;
+declare const SidebarHeader: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarFooter: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarContent: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarGroup: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarGroupContent: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarSeparator: React.ForwardRefExoticComponent<Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    orientation?: "horizontal" | "vertical";
+    decorative?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarGroupLabel: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarGroupAction: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLButtonElement>>;
+declare const SidebarMenu: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React.RefAttributes<HTMLUListElement>>;
+declare const SidebarMenuItem: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React.RefAttributes<HTMLLIElement>>;
+declare const menuButtonVariants: {
+    default: string;
+    outline: string;
+};
+declare const menuButtonSizes: {
+    default: string;
+    sm: string;
+    lg: string;
+};
+declare const SidebarMenuButton: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+    asChild?: boolean;
+    isActive?: boolean;
+    variant?: keyof typeof menuButtonVariants;
+    size?: keyof typeof menuButtonSizes;
+    tooltip?: string | React.ComponentProps<typeof TooltipContent>;
+} & React.RefAttributes<HTMLButtonElement>>;
+declare const SidebarMenuAction: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+    asChild?: boolean;
+    showOnHover?: boolean;
+} & React.RefAttributes<HTMLButtonElement>>;
+declare const SidebarMenuBadge: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarMenuSkeleton: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    showIcon?: boolean;
+    width?: string;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarMenuSub: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React.RefAttributes<HTMLUListElement>>;
+declare const SidebarMenuSubItem: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React.RefAttributes<HTMLLIElement>>;
+declare const SidebarMenuSubButton: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, "ref"> & {
+    asChild?: boolean;
+    size?: "sm" | "md";
+    isActive?: boolean;
+} & React.RefAttributes<HTMLAnchorElement>>;
+export { Sidebar, SidebarContent, SidebarFooter, SidebarGroup, SidebarGroupAction, SidebarGroupContent, SidebarGroupLabel, SidebarHeader, SidebarInput, SidebarInset, SidebarMenu, SidebarMenuAction, SidebarMenuBadge, SidebarMenuButton, SidebarMenuItem, SidebarMenuSkeleton, SidebarMenuSub, SidebarMenuSubButton, SidebarMenuSubItem, SidebarProvider, SidebarRail, SidebarSeparator, SidebarTrigger, useSidebar, };

package/dist/ui/skeleton.d.ts

@@ -0,0 +1,3 @@
+import * as React from "react";
+declare const Skeleton: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Skeleton };

package/dist/ui/spinner.d.ts

@@ -0,0 +1,3 @@
+import * as React from "react";
+declare const Spinner: React.ForwardRefExoticComponent<Omit<React.SVGProps<SVGSVGElement>, "ref"> & React.RefAttributes<SVGSVGElement>>;
+export { Spinner };

package/dist/ui/stat.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+declare const Stats: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDListElement>, HTMLDListElement>, "ref"> & React.RefAttributes<HTMLDListElement>>;
+declare const Stat: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const StatLabel: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+declare const StatValue: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+declare const StatDetail: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+export { Stats, Stat, StatLabel, StatValue, StatDetail };

package/dist/ui/steps.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+declare const Steps: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+declare const Step: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+    active?: boolean;
+    index: number;
+} & React.RefAttributes<HTMLButtonElement>>;
+export { Steps, Step };

package/dist/ui/switch.d.ts

@@ -0,0 +1,6 @@
+import * as React from "react";
+import * as SwitchPrimitive from "@radix-ui/react-switch";
+declare const Switch: React.ForwardRefExoticComponent<Omit<SwitchPrimitive.SwitchProps & React.RefAttributes<HTMLButtonElement>, "ref"> & {
+    size?: "default" | "sm";
+} & React.RefAttributes<HTMLButtonElement>>;
+export { Switch };

package/dist/ui/tab-state.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+export type TabState = {
+    active: boolean;
+    visible: boolean;
+};
+export declare const TabStateContext: React.Context<TabState>;
+export declare function useTabActive(): boolean;
+export declare function useTabVisible(): boolean;

package/dist/ui/table-layout.d.ts

@@ -0,0 +1,19 @@
+import * as React from "react";
+export declare function useTableWindow(count: number, rowHeight?: number): {
+    scrollRef: React.RefObject<HTMLDivElement | null>;
+    range: {
+        start: number;
+        end: number;
+    };
+    reveal: (index: number) => void;
+    viewportHeight: number;
+};
+export declare function useColumnResize(): {
+    widths: Record<string, number>;
+    change: (id: string, width: number) => void;
+    start: (event: React.PointerEvent<HTMLElement>, id: string, initial: number) => void;
+};
+export declare function useLoadMore(root: React.RefObject<HTMLElement | null>, onLoadMore: (() => void | Promise<void>) | undefined, hasMore: boolean): {
+    sentinel: React.RefObject<HTMLTableRowElement | null>;
+    loading: boolean;
+};

package/dist/ui/table-model.d.ts

@@ -0,0 +1,42 @@
+import type * as React from "react";
+export type SortDirection = "asc" | "desc";
+export type TableSort = {
+    column: string;
+    direction: SortDirection;
+};
+export type SortValue = string | number | boolean | null | undefined;
+export type TableColumn<T> = {
+    id: string;
+    header: React.ReactNode;
+    headerDetail?: React.ReactNode;
+    srOnly?: boolean;
+    rowHeader?: boolean;
+    className?: string | ((row: T, index: number) => string | undefined);
+    headClassName?: string;
+    cell: (row: T, index: number) => React.ReactNode;
+    sortValue?: (row: T) => SortValue;
+    sort?: boolean;
+    align?: "start" | "end" | "center";
+    numeric?: boolean;
+    width?: string;
+    hideBelow?: "sm" | "md" | "lg";
+};
+export declare function compareValues(left: SortValue, right: SortValue): number;
+export declare function sortRows<T>(rows: readonly T[], columns: TableColumn<T>[], sort: TableSort | null): readonly T[];
+export declare const isSortable: <T>(column: TableColumn<T>) => boolean;
+export declare function nextSort<T>(column: TableColumn<T>, current: TableSort | null): TableSort;
+export declare function pageOf<T>(rows: readonly T[], pageSize: number | undefined, page: number): {
+    size: number;
+    pages: number;
+    current: number;
+    offset: number;
+    rows: readonly T[];
+};
+export declare function visibleRowRange(count: number, scrollTop: number, height: number, rowHeight: number, overscan?: number): {
+    start: number;
+    end: number;
+};
+export declare const clampColumnWidth: (width: number) => number;
+export declare function column<T>(id: string, header: string, value: (row: T) => SortValue, cell?: (row: T) => React.ReactNode): TableColumn<T>;
+export declare const mono: <T>(id: string, header: string, value: (row: T) => unknown) => TableColumn<T>;
+export declare const num: <T>(id: string, header: string, value: (row: T) => number, digits?: number, headerDetail?: string) => TableColumn<T>;

package/dist/ui/table-screen.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+declare const TableScreen: React.ForwardRefExoticComponent<Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "title"> & {
+    title: React.ReactNode;
+    description?: React.ReactNode;
+    actions?: React.ReactNode;
+    tabs?: React.ReactNode;
+    error?: React.ReactNode;
+} & React.RefAttributes<HTMLDivElement>>;
+export { TableScreen };

package/dist/ui/table.d.ts

@@ -1,30 +1,41 @@
 import * as React from "react";
-import { type ReactNode } from "react";
-export type TableColumn<T> = {
-    id: string;
-    header: string;
-    headerDetail?: string;
-    rowHeader?: boolean;
-    numeric?: boolean;
-    cell: (row: T) => React.ReactNode;
-    sortValue: (row: T) => string | number | null | undefined;
-};
-type Sort = {
-    column: string;
-    direction: "asc" | "desc";
-};
-export declare function Table<T>({ label, columns, rows, rowKey, loading, empty, defaultSort, onRowActivate, rowLabel, }: {
-    label: string;
+import { type TableColumn, type TableSort } from "./table-model.js";
+export type { SortDirection, SortValue, TableColumn, TableSort, } from "./table-model.js";
+export { column, mono, num } from "./table-model.js";
+export type TableProps<T> = {
+    label?: string;
+    caption?: string;
     columns: TableColumn<T>[];
     rows: readonly T[];
     rowKey: (row: T, index: number) => string;
-    loading?: boolean;
     empty?: React.ReactNode;
-    defaultSort?: Sort | null;
+    className?: string;
+    tableClassName?: string;
+    scrollClassName?: string;
+    rowClassName?: (row: T) => string | undefined;
+    loading?: boolean;
+    skeletonRows?: number;
+    sort?: TableSort | null;
+    defaultSort?: TableSort | null;
+    onSortChange?: (sort: TableSort | null) => void;
+    clientSort?: boolean;
+    sortDisabled?: boolean;
     onRowActivate?: (row: T) => void;
     rowLabel?: (row: T) => string;
+    selectedKey?: string | null;
+    pageSize?: number;
+    rowHeight?: number;
+    onLoadMore?: () => void | Promise<void>;
+    hasMore?: boolean;
+    banner?: React.ReactNode;
+    tabs?: React.ReactNode;
+    footerStart?: React.ReactNode;
+    footerCenter?: React.ReactNode;
+    footerEnd?: React.ReactNode;
+};
+declare function Table<T>({ label, caption, columns, rows, rowKey, empty, className, tableClassName, scrollClassName, rowClassName, loading, skeletonRows, sort, defaultSort, onSortChange, clientSort, sortDisabled, onRowActivate, rowLabel, selectedKey, pageSize, rowHeight, onLoadMore, hasMore, banner, tabs, footerStart, footerCenter, footerEnd, }: TableProps<T>): React.JSX.Element;
+declare function TableStack({ title, detail, }: {
+    title: React.ReactNode;
+    detail?: React.ReactNode;
 }): React.JSX.Element;
-export declare function column<T>(id: string, header: string, value: (row: T) => string | number | null | undefined, cell?: (row: T) => ReactNode): TableColumn<T>;
-export declare const mono: <T>(id: string, header: string, value: (row: T) => unknown) => TableColumn<T>;
-export declare const num: <T>(id: string, header: string, value: (row: T) => number, digits?: number, headerDetail?: string) => TableColumn<T>;
-export {};
+export { Table, TableStack };

package/dist/ui/tabs.d.ts

@@ -0,0 +1,13 @@
+import * as React from "react";
+import * as TabsPrimitive from "@radix-ui/react-tabs";
+declare const Tabs: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const tabsListVariants: {
+    default: string;
+    line: string;
+};
+declare const TabsList: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    variant?: keyof typeof tabsListVariants;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const TabsTrigger: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const TabsContent: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Tabs, TabsList, TabsTrigger, TabsContent };

package/dist/ui/textarea.d.ts

@@ -0,0 +1,3 @@
+import * as React from "react";
+declare const Textarea: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.TextareaHTMLAttributes<HTMLTextAreaElement>, HTMLTextAreaElement>, "ref"> & React.RefAttributes<HTMLTextAreaElement>>;
+export { Textarea };

package/dist/ui/theme.d.ts

@@ -0,0 +1,22 @@
+import * as React from "react";
+export declare const themeColors: readonly ["background", "foreground", "card", "card-foreground", "popover", "popover-foreground", "primary", "primary-foreground", "link", "secondary", "secondary-foreground", "muted", "muted-foreground", "accent", "accent-foreground", "destructive", "destructive-foreground", "destructive-muted", "success", "success-foreground", "warning", "warning-foreground", "info", "info-foreground", "border", "input", "input-background", "ring", "overlay", "chart-1", "chart-2", "chart-3", "chart-4", "chart-5", "sidebar", "sidebar-foreground", "sidebar-primary", "sidebar-primary-foreground", "sidebar-accent", "sidebar-accent-foreground", "sidebar-border", "sidebar-ring"];
+export type ThemeColor = (typeof themeColors)[number];
+export type ThemeColors = Partial<Record<ThemeColor, string>>;
+export type Theme = {
+    light?: ThemeColors;
+    dark?: ThemeColors;
+    fonts?: {
+        sans?: string;
+        mono?: string;
+        display?: string;
+    };
+    radius?: string;
+    radiusDialog?: string;
+};
+export declare function themeCss(theme: Theme, selector?: string): string;
+export declare function ThemeStyle({ theme, selector, }: {
+    theme: Theme;
+    selector?: string;
+}): React.ReactElement<{
+    "data-slot": string;
+}, string | React.JSXElementConstructor<any>>;

package/dist/ui/time-series-chart.d.ts

@@ -0,0 +1,19 @@
+import * as React from "react";
+import { type ChartOptions, type SeriesPoint } from "./time-series-model.js";
+export { DAY, DEFAULT_OPTIONS, type ChartOptions, type SeriesPoint, } from "./time-series-model.js";
+export type TimeSeriesChartProps = {
+    points: SeriesPoint[];
+    series: {
+        key: string;
+        color: string;
+    }[];
+    start: number;
+    options: ChartOptions;
+    onOptionsChange: (options: ChartOptions) => void;
+    title?: string;
+    subtitle?: string;
+    unit?: string;
+    label: string;
+};
+declare const TimeSeriesChart: React.ForwardRefExoticComponent<TimeSeriesChartProps & React.RefAttributes<HTMLDivElement>>;
+export { TimeSeriesChart };

package/dist/ui/time-series-model.d.ts

@@ -0,0 +1,90 @@
+/** Pure chart geometry: no DOM, React, clock or storage. */
+export declare const DAY = 86400000;
+export type Range = [number, number];
+export type SeriesPoint = {
+    time: number;
+    total: number;
+    values: Record<string, number>;
+    annotation?: string;
+    carried?: boolean;
+};
+export type ChartOptions = {
+    logarithmic: boolean;
+    logBase: number;
+    sma: boolean;
+    ema: boolean;
+    bollinger: boolean;
+    forecast: boolean;
+};
+export declare const DEFAULT_OPTIONS: ChartOptions;
+export declare const FORECAST_DAYS = 90;
+export declare const INDICATOR_PERIOD = 20;
+export declare function nearestPoint(points: SeriesPoint[], time: number): number;
+export declare function clampRange(range: Range, bounds: Range, minimum?: number): Range;
+export declare function zoomRange(range: Range, factor: number, anchor: number, bounds: Range): Range;
+export declare function indicators(points: SeriesPoint[], period?: number): {
+    time: number;
+    ema: number;
+    sma: number | null;
+    upper: number | null;
+    lower: number | null;
+}[];
+/** Fits the last 90 daily values, then anchors the projection to the latest actual value. */
+export declare function regression(points: SeriesPoint[]): {
+    slope: number;
+    r2: number;
+    points: {
+        time: number;
+        value: number;
+    }[];
+} | null;
+export declare function niceTicks(maximum: number, count?: number): number[];
+export declare function chartModel(points: SeriesPoint[], keys: string[], range: Range, width: number, height: number, options: ChartOptions, lockedDomain?: Range): {
+    plot: {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+    };
+    domain: Range;
+    x: (time: number) => number;
+    y: (value: number) => number;
+    timeAt: (pixel: number) => number;
+    bands: {
+        key: string;
+        path: string;
+    }[];
+    totalPath: string;
+    xTicks: {
+        value: number;
+        pixel: number;
+    }[];
+    yTicks: {
+        value: number;
+        pixel: number;
+    }[];
+    positions: {
+        x: number;
+        y: number;
+    }[];
+    computed: {
+        time: number;
+        ema: number;
+        sma: number | null;
+        upper: number | null;
+        lower: number | null;
+    }[];
+    smaPath: string;
+    emaPath: string;
+    upperPath: string;
+    lowerPath: string;
+    forecast: {
+        slope: number;
+        r2: number;
+        points: {
+            time: number;
+            value: number;
+        }[];
+    } | null;
+    forecastPath: string;
+};

package/dist/ui/timing-tracks.d.ts

@@ -0,0 +1,27 @@
+import * as React from "react";
+export type TimingSpan = {
+    id: string;
+    start: number;
+    end: number;
+    label: string;
+    detail?: string;
+    color?: string;
+    /** A bound or observation window, not a measured execution interval. */
+    uncertain?: boolean;
+};
+export type TimingTrack = {
+    id: string;
+    label: string;
+    spans: TimingSpan[];
+};
+export type TimingTracksProps = {
+    tracks: TimingTrack[];
+    from: number;
+    to: number;
+    label?: string;
+    unit?: string;
+    onSelect?: (span: TimingSpan) => void;
+};
+/** Shared-clock tracks supplied by the caller. Deliberately no clock conversion. */
+declare const TimingTracks: React.ForwardRefExoticComponent<TimingTracksProps & React.RefAttributes<HTMLDivElement>>;
+export { TimingTracks };

package/dist/ui/toggle.d.ts

@@ -0,0 +1,22 @@
+import * as React from "react";
+import * as TogglePrimitive from "@radix-ui/react-toggle";
+import * as ToggleGroupPrimitive from "@radix-ui/react-toggle-group";
+declare const toggleVariants: {
+    default: string;
+    outline: string;
+};
+declare const toggleSizes: {
+    default: string;
+    sm: string;
+    lg: string;
+};
+type ToggleStyle = {
+    variant?: keyof typeof toggleVariants;
+    size?: keyof typeof toggleSizes;
+};
+declare const Toggle: React.ForwardRefExoticComponent<Omit<TogglePrimitive.ToggleProps & React.RefAttributes<HTMLButtonElement>, "ref"> & ToggleStyle & React.RefAttributes<HTMLButtonElement>>;
+declare const ToggleGroup: React.ForwardRefExoticComponent<((Omit<ToggleGroupPrimitive.ToggleGroupMultipleProps & React.RefAttributes<HTMLDivElement>, "ref"> | Omit<ToggleGroupPrimitive.ToggleGroupSingleProps & React.RefAttributes<HTMLDivElement>, "ref">) & ToggleStyle & {
+    spacing?: number;
+}) & React.RefAttributes<HTMLDivElement>>;
+declare const ToggleGroupItem: React.ForwardRefExoticComponent<Omit<ToggleGroupPrimitive.ToggleGroupItemProps & React.RefAttributes<HTMLButtonElement>, "ref"> & ToggleStyle & React.RefAttributes<HTMLButtonElement>>;
+export { Toggle, ToggleGroup, ToggleGroupItem };

package/dist/ui/tooltip.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import * as TooltipPrimitive from "@radix-ui/react-tooltip";
+declare function TooltipProvider({ delayDuration, ...props }: React.ComponentProps<typeof TooltipPrimitive.Provider>): React.JSX.Element;
+declare function Tooltip({ open, defaultOpen, onOpenChange, ...props }: React.ComponentProps<typeof TooltipPrimitive.Root>): React.JSX.Element;
+declare const TooltipTrigger: React.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const TooltipContent: React.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };

package/dist/ui/topbar.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+declare const Topbar: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+declare const TopbarActions: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Topbar, TopbarActions };

package/dist/ui/use-chart-width.d.ts

@@ -0,0 +1,5 @@
+/** Measures a chart container with a ResizeObserver. Zero widths (hidden tabs, display none) keep the last size. */
+export declare function useChartWidth(): {
+    container: import("react").RefObject<HTMLDivElement | null>;
+    width: number;
+};

package/dist/ui/use-mobile.d.ts

@@ -0,0 +1 @@
+export declare function useIsMobile(): boolean;