@sabrenski/spire-ui-vue 0.1.1 → 0.2.0

package/dist/components/DialMenu/DialAction.vue.d.ts

@@ -0,0 +1,25 @@
+import { DialActionProps, DialColor } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLButtonElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<DialActionProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<DialActionProps> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+}>, {
+    disabled: boolean;
+    color: DialColor;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLButtonElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/DialMenu/DialMenu.vue.d.ts

@@ -0,0 +1,45 @@
+import { DialMenuProps, DialPlacement } from './types';
+declare function toggle(): void;
+declare function open(): void;
+declare function close(): void;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        trigger?(_: {
+            toggle: typeof toggle;
+            isOpen: boolean;
+            open: typeof open;
+            close: typeof close;
+        }): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<DialMenuProps, {
+    open: typeof open;
+    close: typeof close;
+    toggle: typeof toggle;
+    isOpen: import('vue').Ref<boolean, boolean>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<DialMenuProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {
+    modelValue: boolean;
+    disabled: boolean;
+    pattern: import('./types').DialPattern;
+    placement: DialPlacement;
+    trigger: import('./types').DialTriggerMode;
+    gap: number;
+    direction: import('./types').DialDirection;
+    arcSpread: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/DialMenu/DialTrigger.vue.d.ts

@@ -0,0 +1,25 @@
+import { DialTriggerProps } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLButtonElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<DialTriggerProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<DialTriggerProps> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+}>, {
+    disabled: boolean;
+    open: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLButtonElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,4 @@
+export { default as DialMenu } from './DialMenu.vue';
+export { default as DialAction } from './DialAction.vue';
+export { default as DialTrigger } from './DialTrigger.vue';
+export * from './types';

package/dist/components/DialMenu/types.d.ts

@@ -0,0 +1,63 @@
+import { InjectionKey, Ref } from 'vue';
+export type DialPattern = 'linear' | 'arc';
+export type DialDirection = 'up' | 'down' | 'left' | 'right' | 'up-left' | 'up-right' | 'down-left' | 'down-right';
+export type DialPlacement = 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+export type DialTriggerMode = 'click' | 'hover';
+export type DialColor = 'neutral' | 'primary' | 'secondary' | 'success' | 'warning' | 'danger';
+export interface DialMenuProps {
+    /** Open state (v-model) */
+    modelValue?: boolean;
+    /** Animation pattern for action buttons */
+    pattern?: DialPattern;
+    /** Direction actions fan out (for linear) or arc center direction */
+    direction?: DialDirection;
+    /** Arc spread angle in degrees (for arc pattern) */
+    arcSpread?: number;
+    /** Fixed position on screen */
+    placement?: DialPlacement;
+    /** Gap/radius between action buttons (in rem) */
+    gap?: number;
+    /** Trigger interaction mode */
+    trigger?: DialTriggerMode;
+    /** Disable the entire menu */
+    disabled?: boolean;
+}
+export interface DialTriggerProps {
+    /** Whether the menu is open */
+    open?: boolean;
+    /** Disable the trigger */
+    disabled?: boolean;
+}
+export interface DialActionProps {
+    /** Icon name for the action */
+    icon?: string;
+    /** Accessible label (required for accessibility) */
+    label: string;
+    /** Color variant */
+    color?: DialColor;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Tooltip text shown on hover */
+    tooltip?: string;
+}
+export declare const DIAL_MENU_INJECTION_KEY: InjectionKey<DialMenuContext>;
+export interface DialMenuContext {
+    /** Register an action and get its index */
+    registerAction: () => number;
+    /** Unregister an action */
+    unregisterAction: (index: number) => void;
+    /** Total number of registered actions */
+    actionCount: Ref<number>;
+    /** Current pattern */
+    pattern: Ref<DialPattern>;
+    /** Current direction */
+    direction: Ref<DialDirection>;
+    /** Gap between actions */
+    gap: Ref<number>;
+    /** Arc spread angle */
+    arcSpread: Ref<number>;
+    /** Whether menu is open */
+    isOpen: Ref<boolean>;
+    /** Close the menu */
+    close: () => void;
+}

package/dist/components/Dropdown/Dropdown.vue.d.ts

@@ -34,8 +34,8 @@ declare const __VLS_component: import('vue').DefineComponent<DropdownProps, {
     isDisabled: boolean;
     trigger: import('./types').DropdownTriggerMode;
     strategy: import('./types').DropdownStrategy;
-    closeOnSelect: boolean;
     offset: number;
+    closeOnSelect: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLSpanElement>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;

package/dist/components/LineChart/LineChart.vue.d.ts

@@ -49,11 +49,11 @@ declare const __VLS_component: import('vue').DefineComponent<LineChartProps, {},
     showTooltip: boolean;
     animated: boolean;
     animationDuration: number;
+    strokeWidth: number;
     curve: import('./types').LineChartCurve;
     areaOpacity: number;
     showPoints: boolean;
     pointRadius: number;
-    strokeWidth: number;
     showToolbar: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
     containerRef: HTMLDivElement;

package/dist/components/LineChart/LineChartPath.vue.d.ts

@@ -23,12 +23,12 @@ declare const _default: import('vue').DefineComponent<LineChartPathProps, {}, {}
     animated: boolean;
     animationDuration: number;
     hoveredIndex: number | null;
+    strokeWidth: number;
     dashed: boolean;
     curve: LineChartCurve;
     areaOpacity: number;
     showPoints: boolean;
     pointRadius: number;
-    strokeWidth: number;
     baseline: number;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
     pathRef: SVGPathElement;

package/dist/components/Modal/Modal.vue.d.ts

@@ -34,6 +34,8 @@ declare const __VLS_component: import('vue').DefineComponent<ModalProps, {
     closeOnEscape: boolean;
     closeOnBackdrop: boolean;
     preventScroll: boolean;
+    backdrop: boolean;
+    floating: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
     dialogRef: HTMLDialogElement;
 }, HTMLDialogElement>;

package/dist/components/Modal/types.d.ts

@@ -17,4 +17,8 @@ export interface ModalProps {
     closeOnEscape?: boolean;
     /** Prevent body scroll when modal is open */
     preventScroll?: boolean;
+    /** Show backdrop overlay (disabling also enables body scrolling) */
+    backdrop?: boolean;
+    /** Float the drawer with rounded corners and margin on all sides (drawer placements only) */
+    floating?: boolean;
 }

package/dist/components/Navbar/Navbar.vue.d.ts

@@ -14,9 +14,9 @@ declare const __VLS_component: import('vue').DefineComponent<NavbarProps, {}, {}
     height: NavbarHeight;
     blur: boolean;
     transparent: boolean;
+    maxWidth: import('./types').NavbarMaxWidth;
     hideOnScroll: boolean;
     scrollThreshold: number;
-    maxWidth: import('./types').NavbarMaxWidth;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;

package/dist/components/Navbar/NavbarMenu.vue.d.ts

@@ -4,6 +4,7 @@ declare function __VLS_template(): {
     slots: {
         trigger?(_: {}): any;
         default?(_: {}): any;
+        default?(_: {}): any;
     };
     refs: {
         triggerRef: HTMLButtonElement;
@@ -14,11 +15,11 @@ declare function __VLS_template(): {
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
 declare const __VLS_component: import('vue').DefineComponent<NavbarMenuProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<NavbarMenuProps> & Readonly<{}>, {
     trigger: import('./types').NavbarMenuTrigger;
-    fullWidth: boolean;
+    columns: NavbarMenuColumns;
     offset: number;
+    fullWidth: boolean;
     openDelay: number;
     closeDelay: number;
-    columns: NavbarMenuColumns;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
     triggerRef: HTMLButtonElement;
     panelRef: HTMLDivElement;

package/dist/components/SearchInput/SearchInput.vue.d.ts

@@ -0,0 +1,40 @@
+import { SearchInputProps, SearchInputSize, SearchResult } from './types';
+declare function expand(): void;
+declare function collapse(): void;
+declare const _default: import('vue').DefineComponent<SearchInputProps, {
+    expand: typeof expand;
+    collapse: typeof collapse;
+    focus: () => void | undefined;
+    inputRef: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    search: (query: string) => any;
+    clear: () => any;
+    "update:modelValue": (value: string) => any;
+    select: (result: SearchResult) => any;
+    expand: () => any;
+    collapse: () => any;
+}, string, import('vue').PublicProps, Readonly<SearchInputProps> & Readonly<{
+    onSearch?: ((query: string) => any) | undefined;
+    onClear?: (() => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    onSelect?: ((result: SearchResult) => any) | undefined;
+    onExpand?: (() => any) | undefined;
+    onCollapse?: (() => any) | undefined;
+}>, {
+    size: SearchInputSize;
+    disabled: boolean;
+    loading: boolean;
+    placeholder: string;
+    clearable: boolean;
+    minQueryLength: number;
+    debounceMs: number;
+    expanded: boolean;
+    collapsible: boolean;
+    collapseOnBlur: boolean;
+    noResultsText: string;
+    maxResults: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    wrapperRef: HTMLDivElement;
+    inputRef: HTMLInputElement;
+}, any>;
+export default _default;

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

@@ -0,0 +1,2 @@
+export { default as SearchInput } from './SearchInput.vue';
+export type { SearchInputProps, SearchInputSize, SearchResult, } from './types';

package/dist/components/SearchInput/types.d.ts

@@ -0,0 +1,48 @@
+import { Component } from 'vue';
+export type SearchInputSize = 'sm' | 'md' | 'lg';
+export interface SearchResult {
+    /** Unique identifier for the result */
+    id: string | number;
+    /** Display label for the result */
+    label: string;
+    /** Optional description shown below the label */
+    description?: string;
+    /** Optional icon (name string or Component) */
+    icon?: string | Component;
+    /** Whether this result is disabled */
+    disabled?: boolean;
+    /** Additional data to pass through on selection */
+    data?: unknown;
+}
+export interface SearchInputProps {
+    /** v-model value for the search query */
+    modelValue?: string;
+    /** Placeholder text when input is empty */
+    placeholder?: string;
+    /** Size variant */
+    size?: SearchInputSize;
+    /** Disable the input */
+    disabled?: boolean;
+    /** Show clear button when input has value */
+    clearable?: boolean;
+    /** Start in expanded state (only applies when collapsible is true) */
+    expanded?: boolean;
+    /** Enable collapsible pill behavior (default: true). When false, input is always expanded */
+    collapsible?: boolean;
+    /** Collapse back to icon when clicking outside (only applies when collapsible is true) */
+    collapseOnBlur?: boolean;
+    /** Array of search results to display */
+    results?: SearchResult[];
+    /** Show loading spinner in dropdown */
+    loading?: boolean;
+    /** Debounce delay for search event in milliseconds */
+    debounceMs?: number;
+    /** Minimum characters before showing results */
+    minQueryLength?: number;
+    /** Text to show when no results found */
+    noResultsText?: string;
+    /** Maximum number of results to display */
+    maxResults?: number;
+    /** Width of expanded input (CSS value) */
+    expandedWidth?: string;
+}

package/dist/components/Sparkline/Sparkline.vue.d.ts

@@ -14,10 +14,10 @@ declare const _default: import('vue').DefineComponent<SparklineProps, {}, {}, {}
     showTooltip: boolean;
     animated: boolean;
     animationDuration: number;
+    fillOpacity: number;
+    strokeWidth: number;
     responsive: boolean;
     curve: import('./types').SparklineCurve;
-    strokeWidth: number;
-    fillOpacity: number;
     highlightOnHover: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
     containerRef: HTMLDivElement;

package/dist/components/Sparkline/SparklineLine.vue.d.ts

@@ -14,9 +14,9 @@ declare const _default: import('vue').DefineComponent<SparklineLineProps, {}, {}
     area: boolean;
     animated: boolean;
     animationDuration: number;
+    strokeWidth: number;
     curve: SparklineCurve;
     areaOpacity: number;
-    strokeWidth: number;
     baseline: number;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
     pathRef: SVGPathElement;

package/dist/components/Table/Table.vue.d.ts

@@ -35,11 +35,12 @@ declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {
     rowHeight: number;
     overscan: number;
     emptyMessage: string;
+    animated: boolean;
+    maxHeight: string;
+    columns: ColumnDefinition<Record<string, unknown>>[];
     hoverable: boolean;
     selectionMode: import('./types').SelectionMode;
     selectedKeys: Set<string | number> | Array<string | number>;
-    maxHeight: string;
-    columns: ColumnDefinition<Record<string, unknown>>[];
     rowKey: string | ((row: Record<string, unknown>, index: number) => string | number);
     sortState: SortState;
     stickyHeader: boolean;

package/dist/components/Table/types.d.ts

@@ -74,6 +74,8 @@ export interface TableProps<T = Record<string, unknown>> {
     overscan?: number;
     /** Enable client-side sorting using column sortFn or default string comparison */
     clientSideSorting?: boolean;
+    /** Enable row animations for sorting, filtering, add/remove (default: true) */
+    animated?: boolean;
 }
 export interface TableHeaderProps {
     /** Enable sticky positioning */
@@ -213,5 +215,7 @@ export interface TableContext<T = Record<string, unknown>> {
     getRowKey: (row: T, index: number) => string | number;
     /** Unique table ID for ARIA */
     tableId: string;
+    /** Row animations enabled */
+    animated: Ref<boolean>;
 }
 export declare const TABLE_INJECTION_KEY: InjectionKey<TableContext>;

package/dist/components/Timer/Timer.vue.d.ts

@@ -0,0 +1,60 @@
+import { TimerProps, TimerFormat, TimerSize } from './types';
+declare function start(): void;
+declare function pause(): void;
+declare function reset(): void;
+declare function toggle(): void;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        display?(_: {
+            time: number;
+            formatted: string;
+        }): any;
+        controls?(_: {
+            start: typeof start;
+            pause: typeof pause;
+            reset: typeof reset;
+            toggle: typeof toggle;
+            isRunning: boolean;
+            currentTime: number;
+        }): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<TimerProps, {
+    start: typeof start;
+    pause: typeof pause;
+    reset: typeof reset;
+    toggle: typeof toggle;
+    isRunning: import('vue').Ref<boolean, boolean>;
+    currentTime: import('vue').Ref<number, number>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    reset: () => any;
+    start: () => any;
+    pause: () => any;
+    tick: (time: number) => any;
+    complete: () => any;
+}, string, import('vue').PublicProps, Readonly<TimerProps> & Readonly<{
+    onReset?: (() => any) | undefined;
+    onStart?: (() => any) | undefined;
+    onPause?: (() => any) | undefined;
+    onTick?: ((time: number) => any) | undefined;
+    onComplete?: (() => any) | undefined;
+}>, {
+    size: TimerSize;
+    animated: boolean;
+    mode: import('./types').TimerMode;
+    format: TimerFormat;
+    duration: number;
+    autoStart: boolean;
+    showControls: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,2 @@
+export { default as Timer } from './Timer.vue';
+export type { TimerProps, TimerMode, TimerFormat, TimerSize } from './types';

package/dist/components/Timer/types.d.ts

@@ -0,0 +1,19 @@
+export type TimerMode = 'stopwatch' | 'countdown';
+export type TimerFormat = 'auto' | 'ss' | 'mm:ss' | 'hh:mm:ss';
+export type TimerSize = 'sm' | 'md' | 'lg' | 'xl';
+export interface TimerProps {
+    /** Timer mode */
+    mode?: TimerMode;
+    /** Duration in seconds for countdown mode */
+    duration?: number;
+    /** Start automatically on mount */
+    autoStart?: boolean;
+    /** Time display format */
+    format?: TimerFormat;
+    /** Show built-in controls */
+    showControls?: boolean;
+    /** Size variant */
+    size?: TimerSize;
+    /** Enable slide animation on digit changes */
+    animated?: boolean;
+}

package/dist/components/Tree/Tree.vue.d.ts

@@ -0,0 +1,22 @@
+import { TreeProps, TreeNodeId } from './types';
+declare function expandAll(): void;
+declare function collapseAll(): void;
+declare const _default: import('vue').DefineComponent<TreeProps, {
+    expandAll: typeof expandAll;
+    collapseAll: typeof collapseAll;
+    expandedKeys: import('vue').ComputedRef<Set<TreeNodeId> & Omit<Set<TreeNodeId>, keyof Set<any>>>;
+    selectedKeys: import('vue').ComputedRef<Set<TreeNodeId> & Omit<Set<TreeNodeId>, keyof Set<any>>>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:selected": (value: TreeNodeId[]) => any;
+    "update:expanded": (value: TreeNodeId[]) => any;
+}, string, import('vue').PublicProps, Readonly<TreeProps> & Readonly<{
+    "onUpdate:selected"?: ((value: TreeNodeId[]) => any) | undefined;
+    "onUpdate:expanded"?: ((value: TreeNodeId[]) => any) | undefined;
+}>, {
+    selected: TreeNodeId[];
+    expanded: TreeNodeId[];
+    selectable: boolean;
+    multiSelect: boolean;
+    showLines: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/components/Tree/TreeNode.vue.d.ts

@@ -0,0 +1,5 @@
+import { TreeNodeProps } from './types';
+declare const _default: import('vue').DefineComponent<TreeNodeProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<TreeNodeProps> & Readonly<{}>, {
+    level: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

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

@@ -0,0 +1,3 @@
+export { default as Tree } from './Tree.vue';
+export { default as TreeNode } from './TreeNode.vue';
+export type { TreeNodeData, TreeNodeId, TreeProps, TreeNodeProps, TreeContext, } from './types';

package/dist/components/Tree/types.d.ts

@@ -0,0 +1,55 @@
+import { InjectionKey, Ref } from 'vue';
+export type TreeNodeId = string | number;
+export interface TreeNodeData {
+    /** Unique identifier for the node */
+    id: TreeNodeId;
+    /** Display label for the node */
+    label: string;
+    /** Optional icon name */
+    icon?: string;
+    /** Child nodes */
+    children?: TreeNodeData[];
+    /** Whether the node is disabled */
+    disabled?: boolean;
+}
+export interface TreeProps {
+    /** Tree data structure */
+    nodes: TreeNodeData[];
+    /** Selected node IDs (v-model:selected) */
+    selected?: TreeNodeId[];
+    /** Expanded node IDs (v-model:expanded) */
+    expanded?: TreeNodeId[];
+    /** Enable node selection */
+    selectable?: boolean;
+    /** Allow multiple selection */
+    multiSelect?: boolean;
+    /** Show connecting lines between nodes */
+    showLines?: boolean;
+}
+export interface TreeNodeProps {
+    /** Node data */
+    node: TreeNodeData;
+    /** Nesting level (0 = root) */
+    level: number;
+}
+export interface TreeContext {
+    /** Set of expanded node IDs */
+    expandedKeys: Ref<Set<TreeNodeId>>;
+    /** Set of selected node IDs */
+    selectedKeys: Ref<Set<TreeNodeId>>;
+    /** Whether selection is enabled */
+    selectable: Ref<boolean>;
+    /** Whether multi-select is enabled */
+    multiSelect: Ref<boolean>;
+    /** Whether to show connecting lines */
+    showLines: Ref<boolean>;
+    /** Toggle node expansion */
+    toggleExpand: (id: TreeNodeId) => void;
+    /** Toggle node selection */
+    toggleSelect: (id: TreeNodeId) => void;
+    /** Check if node is expanded */
+    isExpanded: (id: TreeNodeId) => boolean;
+    /** Check if node is selected */
+    isSelected: (id: TreeNodeId) => boolean;
+}
+export declare const TREE_INJECTION_KEY: InjectionKey<TreeContext>;

package/dist/components/index.d.ts

@@ -11,6 +11,7 @@ export * from './Carousel';
 export * from './Checkbox';
 export * from './ColorPicker';
 export * from './DatePicker';
+export * from './DialMenu';
 export * from './Divider';
 export * from './Card';
 export * from './DataList';
@@ -40,6 +41,7 @@ export * from './Popover';
 export * from './Progress';
 export * from './Radio';
 export * from './Rating';
+export * from './SearchInput';
 export * from './Select';
 export * from './Sidebar';
 export * from './Slider';
@@ -53,6 +55,8 @@ export * from './Text';
 export * from './Textarea';
 export * from './RichTextEditor';
 export * from './TimeInput';
+export * from './Timer';
 export * from './Toast';
 export * from './Tooltip';
+export * from './Tree';
 export * from './User';