@wire-ui/solid 0.1.0 → 0.2.0

package/dist/components/number-input/NumberInput.d.ts

@@ -0,0 +1,11 @@
+import { JSX } from 'solid-js';
+import { NumberInputDecrementProps, NumberInputFieldProps, NumberInputIncrementProps, NumberInputRootProps } from './NumberInput.types';
+declare function Root(props: NumberInputRootProps): JSX.Element;
+declare function Field(props: NumberInputFieldProps): JSX.Element;
+export declare const NumberInput: {
+    Root: typeof Root;
+    Field: typeof Field;
+    Increment: (props: NumberInputIncrementProps | NumberInputDecrementProps) => JSX.Element;
+    Decrement: (props: NumberInputIncrementProps | NumberInputDecrementProps) => JSX.Element;
+};
+export {};

package/dist/components/number-input/NumberInput.types.d.ts

@@ -0,0 +1,37 @@
+import { JSX } from 'solid-js';
+export interface NumberInputRootProps extends Omit<JSX.HTMLAttributes<HTMLDivElement>, 'onChange' | 'defaultValue'> {
+    /** Controlled value. Use `null` to represent an empty input. */
+    value?: number | null;
+    /** Initial value (uncontrolled). */
+    defaultValue?: number | null;
+    /** Called when the value changes. */
+    onChange?: (value: number | null) => void;
+    /** Minimum allowed value. */
+    min?: number;
+    /** Maximum allowed value. */
+    max?: number;
+    /** Increment / decrement step. Defaults to 1. */
+    step?: number;
+    /** Decimal precision. Defaults to step's decimal count. */
+    precision?: number;
+    /** Disable input + buttons. */
+    disabled?: boolean;
+    /** Read-only field (buttons still disabled). */
+    readOnly?: boolean;
+}
+export type NumberInputFieldProps = Omit<JSX.InputHTMLAttributes<HTMLInputElement>, 'value' | 'defaultValue' | 'onChange' | 'type'>;
+export type NumberInputIncrementProps = JSX.ButtonHTMLAttributes<HTMLButtonElement>;
+export type NumberInputDecrementProps = JSX.ButtonHTMLAttributes<HTMLButtonElement>;
+export interface NumberInputContextValue {
+    readonly value: number | null;
+    readonly min: number;
+    readonly max: number;
+    readonly step: number;
+    readonly precision: number;
+    readonly disabled: boolean;
+    readonly readOnly: boolean;
+    setValue: (value: number | null) => void;
+    increment: () => void;
+    decrement: () => void;
+    stepBy: (delta: number) => void;
+}

package/dist/components/number-input/index.d.ts

@@ -0,0 +1,2 @@
+export { NumberInput } from './NumberInput';
+export type { NumberInputRootProps, NumberInputFieldProps, NumberInputIncrementProps, NumberInputDecrementProps, } from './NumberInput.types';

package/dist/components/pagination/Pagination.d.ts

@@ -0,0 +1,25 @@
+import { JSX } from 'solid-js';
+import { PaginationButtonProps, PaginationEllipsisProps, PaginationItemProps, PaginationItemValue, PaginationListProps, PaginationRootProps } from './Pagination.types';
+/**
+ * Build the list of items: a mix of page numbers and 'ellipsis' markers.
+ * Mirrors the MUI / shadcn behavior.
+ */
+export declare function getPaginationItems(totalPages: number, page: number, siblingCount?: number, boundaryCount?: number): PaginationItemValue[];
+declare function Root(props: PaginationRootProps): JSX.Element;
+interface PaginationItemsProps {
+    children: (item: PaginationItemValue, index: number) => JSX.Element;
+}
+declare function Items(props: PaginationItemsProps): JSX.Element;
+declare function List(props: PaginationListProps): JSX.Element;
+declare function Item(props: PaginationItemProps): JSX.Element;
+declare function Ellipsis(props: PaginationEllipsisProps): JSX.Element;
+export declare const Pagination: {
+    Root: typeof Root;
+    List: typeof List;
+    Items: typeof Items;
+    Item: typeof Item;
+    Previous: (props: PaginationButtonProps) => JSX.Element;
+    Next: (props: PaginationButtonProps) => JSX.Element;
+    Ellipsis: typeof Ellipsis;
+};
+export {};

package/dist/components/pagination/Pagination.types.d.ts

@@ -0,0 +1,39 @@
+import { JSX } from 'solid-js';
+export interface PaginationRootProps extends Omit<JSX.HTMLAttributes<HTMLElement>, 'onChange'> {
+    /** Total number of pages (>= 1). */
+    totalPages: number;
+    /** Controlled current page (1-based). */
+    page?: number;
+    /** Initial page (1-based, uncontrolled). */
+    defaultPage?: number;
+    /** Called when the page changes. */
+    onChange?: (page: number) => void;
+    /** How many sibling pages to show on each side of the current page. Default 1. */
+    siblingCount?: number;
+    /** How many pages to always show at the start/end (boundary). Default 1. */
+    boundaryCount?: number;
+}
+export type PaginationListProps = JSX.HTMLAttributes<HTMLUListElement>;
+export interface PaginationItemProps extends JSX.LiHTMLAttributes<HTMLLIElement> {
+    /** Page number (1-based). */
+    page: number;
+    /** Disable the button. */
+    disabled?: boolean;
+}
+export interface PaginationButtonProps extends JSX.ButtonHTMLAttributes<HTMLButtonElement> {
+    /** Disable the button. */
+    disabled?: boolean;
+}
+export type PaginationEllipsisProps = JSX.HTMLAttributes<HTMLLIElement>;
+/** A page entry computed by the Pagination engine. `'ellipsis'` marks a gap. */
+export type PaginationItemValue = number | 'ellipsis';
+export interface PaginationContextValue {
+    readonly page: number;
+    readonly totalPages: number;
+    readonly items: PaginationItemValue[];
+    readonly canPrev: boolean;
+    readonly canNext: boolean;
+    goTo: (page: number) => void;
+    prev: () => void;
+    next: () => void;
+}

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

@@ -0,0 +1,2 @@
+export { Pagination, getPaginationItems } from './Pagination';
+export type { PaginationRootProps, PaginationListProps, PaginationItemProps, PaginationButtonProps, PaginationEllipsisProps, PaginationItemValue, } from './Pagination.types';

package/dist/components/resizable-panels/ResizablePanels.d.ts

@@ -0,0 +1,13 @@
+import { JSX } from 'solid-js';
+import { PanelGroupProps, PanelHandleProps, PanelProps } from './ResizablePanels.types';
+declare function Group(props: PanelGroupProps): JSX.Element;
+declare function Panel(props: PanelProps): JSX.Element;
+declare function Handle(props: PanelHandleProps & {
+    'aria-label'?: string;
+}): JSX.Element;
+export declare const ResizablePanels: {
+    Group: typeof Group;
+    Panel: typeof Panel;
+    Handle: typeof Handle;
+};
+export {};

package/dist/components/resizable-panels/ResizablePanels.types.d.ts

@@ -0,0 +1,28 @@
+import { JSX } from 'solid-js';
+export type PanelOrientation = 'horizontal' | 'vertical';
+export interface PanelGroupProps extends Omit<JSX.HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    orientation?: PanelOrientation;
+    /** Controlled sizes (percentages, summing to ~100). One per Panel. */
+    sizes?: number[];
+    /** Initial sizes (uncontrolled). */
+    defaultSizes?: number[];
+    /** Called whenever sizes change. */
+    onSizesChange?: (sizes: number[]) => void;
+}
+export interface PanelProps extends JSX.HTMLAttributes<HTMLDivElement> {
+    /** Default size in percent of the group. */
+    defaultSize?: number;
+    /** Minimum size in percent. */
+    minSize?: number;
+    /** Maximum size in percent. */
+    maxSize?: number;
+}
+export interface PanelHandleProps extends JSX.HTMLAttributes<HTMLDivElement> {
+    /** Disable resizing on this handle. */
+    disabled?: boolean;
+}
+export interface PanelConfig {
+    defaultSize?: number;
+    minSize?: number;
+    maxSize?: number;
+}

package/dist/components/resizable-panels/index.d.ts

@@ -0,0 +1,2 @@
+export { ResizablePanels } from './ResizablePanels';
+export type { PanelOrientation, PanelGroupProps, PanelProps, PanelHandleProps, PanelConfig, } from './ResizablePanels.types';

package/dist/components/skeleton/Skeleton.d.ts

@@ -0,0 +1,3 @@
+import { SkeletonProps } from './Skeleton.types';
+declare function Skeleton(props: SkeletonProps): import("solid-js").JSX.Element;
+export { Skeleton };

package/dist/components/skeleton/Skeleton.types.d.ts

@@ -0,0 +1,5 @@
+import { JSX } from 'solid-js';
+export interface SkeletonProps extends JSX.HTMLAttributes<HTMLDivElement> {
+    /** When false, render children instead of the skeleton (handy for conditional loading). */
+    loading?: boolean;
+}

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

@@ -0,0 +1,2 @@
+export { Skeleton } from './Skeleton';
+export type { SkeletonProps } from './Skeleton.types';

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

@@ -0,0 +1,4 @@
+import { JSX } from 'solid-js';
+import { SpinnerProps } from './Spinner.types';
+declare function Spinner(props: SpinnerProps): JSX.Element;
+export { Spinner };

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

@@ -0,0 +1,7 @@
+import { JSX } from 'solid-js';
+export interface SpinnerProps extends JSX.HTMLAttributes<HTMLSpanElement> {
+    /** Accessible label announced to screen readers. Defaults to "Loading". */
+    label?: string;
+    /** Hides the visual element from screen readers (the label is still announced). Defaults to true. */
+    decorative?: boolean;
+}

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

@@ -0,0 +1,2 @@
+export { Spinner } from './Spinner';
+export type { SpinnerProps } from './Spinner.types';

package/dist/components/tag/Tag.d.ts

@@ -0,0 +1,10 @@
+import { TagLabelProps, TagRemoveProps, TagRootProps } from './Tag.types';
+declare function Root(props: TagRootProps): import("solid-js").JSX.Element;
+declare function Label(props: TagLabelProps): import("solid-js").JSX.Element;
+declare function Remove(props: TagRemoveProps): import("solid-js").JSX.Element;
+export declare const Tag: {
+    Root: typeof Root;
+    Label: typeof Label;
+    Remove: typeof Remove;
+};
+export {};

package/dist/components/tag/Tag.types.d.ts

@@ -0,0 +1,10 @@
+import { JSX } from 'solid-js';
+export interface TagRootProps extends JSX.HTMLAttributes<HTMLSpanElement> {
+    /** Disabled state: removes interaction and applies data-disabled. */
+    disabled?: boolean;
+}
+export type TagLabelProps = JSX.HTMLAttributes<HTMLSpanElement>;
+export interface TagRemoveProps extends JSX.ButtonHTMLAttributes<HTMLButtonElement> {
+    /** Accessible label for the remove button. Defaults to "Remove". */
+    'aria-label'?: string;
+}

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

@@ -0,0 +1,2 @@
+export { Tag } from './Tag';
+export type { TagRootProps, TagLabelProps, TagRemoveProps } from './Tag.types';

package/dist/components/tag-input/TagInput.d.ts

@@ -0,0 +1,16 @@
+import { JSX } from 'solid-js';
+import { TagInputFieldProps, TagInputListProps, TagInputRootProps } from './TagInput.types';
+declare function Root(props: TagInputRootProps): JSX.Element;
+interface TagInputItemsProps {
+    children: (tag: string, index: number, remove: () => void) => JSX.Element;
+}
+declare function Items(props: TagInputItemsProps): JSX.Element;
+declare function List(props: TagInputListProps): JSX.Element;
+declare function Field(props: TagInputFieldProps): JSX.Element;
+export declare const TagInput: {
+    Root: typeof Root;
+    List: typeof List;
+    Items: typeof Items;
+    Field: typeof Field;
+};
+export {};

package/dist/components/tag-input/TagInput.types.d.ts

@@ -0,0 +1,29 @@
+import { JSX } from 'solid-js';
+export interface TagInputRootProps extends Omit<JSX.HTMLAttributes<HTMLDivElement>, 'onChange' | 'defaultValue'> {
+    /** Controlled list of tags. */
+    value?: string[];
+    /** Initial list (uncontrolled). */
+    defaultValue?: string[];
+    /** Called when tags are added or removed. */
+    onChange?: (value: string[]) => void;
+    /** Disable input + remove buttons. */
+    disabled?: boolean;
+    /** Maximum number of tags. */
+    maxTags?: number;
+    /** Reject duplicate values (case-sensitive). Defaults to true. */
+    allowDuplicates?: boolean;
+    /** Characters that commit the current input as a tag. Defaults to ['Enter', ',']. */
+    commitKeys?: string[];
+    /** Optional validator — return false to reject the tag. */
+    validate?: (tag: string, current: string[]) => boolean;
+}
+export type TagInputListProps = JSX.HTMLAttributes<HTMLDivElement>;
+export type TagInputFieldProps = Omit<JSX.InputHTMLAttributes<HTMLInputElement>, 'value' | 'defaultValue' | 'onChange'>;
+export interface TagInputContextValue {
+    readonly tags: string[];
+    readonly disabled: boolean;
+    readonly maxTags?: number;
+    addTag: (raw: string) => boolean;
+    removeTag: (index: number) => void;
+    readonly commitKeys: string[];
+}

package/dist/components/tag-input/index.d.ts

@@ -0,0 +1,2 @@
+export { TagInput } from './TagInput';
+export type { TagInputRootProps, TagInputListProps, TagInputFieldProps } from './TagInput.types';

package/dist/components/toast/Toast.d.ts

@@ -0,0 +1,24 @@
+import { JSX } from 'solid-js';
+import { ToastCloseProps, ToastData, ToastDescriptionProps, ToastProviderProps, ToastRootProps, ToastStatus, ToastTitleProps, ToastViewportProps } from './Toast.types';
+export declare function useToast(): {
+    toast: (toast: Omit<ToastData, "id"> & {
+        id?: string;
+    }) => string;
+    dismiss: (id: string) => void;
+    readonly toasts: ToastData<Record<string, unknown>>[];
+};
+declare function Provider(props: ToastProviderProps): JSX.Element;
+declare function Viewport(props: ToastViewportProps): JSX.Element;
+declare function Root(props: ToastRootProps): JSX.Element;
+declare function Title(props: ToastTitleProps): JSX.Element;
+declare function Description(props: ToastDescriptionProps): JSX.Element;
+declare function Close(props: ToastCloseProps): JSX.Element;
+export declare const Toast: {
+    Provider: typeof Provider;
+    Viewport: typeof Viewport;
+    Root: typeof Root;
+    Title: typeof Title;
+    Description: typeof Description;
+    Close: typeof Close;
+};
+export type { ToastStatus, ToastData };

package/dist/components/toast/Toast.types.d.ts

@@ -0,0 +1,36 @@
+import { JSX } from 'solid-js';
+export type ToastStatus = 'default' | 'success' | 'warning' | 'danger' | 'info';
+/** A single toast in the queue. Consumers can extend with arbitrary fields via the generic. */
+export interface ToastData<T extends Record<string, unknown> = Record<string, unknown>> {
+    id: string;
+    title?: JSX.Element;
+    description?: JSX.Element;
+    status?: ToastStatus;
+    /** Auto-dismiss timeout in ms. 0 or negative = persistent. Defaults to 5000. */
+    duration?: number;
+    /** Pause auto-dismiss while pointer is over the toast. Defaults to true. */
+    pauseOnHover?: boolean;
+    /** Custom data passed through to the consumer's render-prop. */
+    data?: T;
+}
+export interface ToastProviderProps {
+    children?: JSX.Element;
+    /** Default duration applied to toasts that don't specify one. */
+    defaultDuration?: number;
+}
+export interface ToastViewportProps extends Omit<JSX.HTMLAttributes<HTMLDivElement>, 'children'> {
+    /** Render-prop receiving each toast and a dismiss callback. */
+    children: (toast: ToastData, dismiss: () => void) => JSX.Element;
+}
+export type ToastRootProps = JSX.HTMLAttributes<HTMLDivElement>;
+export type ToastTitleProps = JSX.HTMLAttributes<HTMLDivElement>;
+export type ToastDescriptionProps = JSX.HTMLAttributes<HTMLDivElement>;
+export type ToastCloseProps = JSX.ButtonHTMLAttributes<HTMLButtonElement>;
+export interface ToastContextValue {
+    readonly toasts: ToastData[];
+    add: (toast: Omit<ToastData, 'id'> & {
+        id?: string;
+    }) => string;
+    dismiss: (id: string) => void;
+    readonly defaultDuration: number;
+}

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

@@ -0,0 +1,2 @@
+export { Toast, useToast } from './Toast';
+export type { ToastStatus, ToastData, ToastProviderProps, ToastViewportProps, ToastRootProps, ToastTitleProps, ToastDescriptionProps, ToastCloseProps, } from './Toast.types';

package/dist/components/tree-view/TreeView.d.ts

@@ -0,0 +1,7 @@
+import { JSX } from 'solid-js';
+import { TreeViewRootProps } from './TreeView.types';
+declare function Root(props: TreeViewRootProps): JSX.Element;
+export declare const TreeView: {
+    Root: typeof Root;
+};
+export {};

package/dist/components/tree-view/TreeView.types.d.ts

@@ -0,0 +1,46 @@
+import { JSX } from 'solid-js';
+/** Node descriptor — the consumer's data; passed through to renderers. */
+export interface TreeNode<T = unknown> {
+    id: string;
+    label?: JSX.Element;
+    children?: TreeNode<T>[];
+    disabled?: boolean;
+    data?: T;
+}
+export type TreeSelectionMode = 'none' | 'single' | 'multiple';
+export interface TreeViewRootProps extends Omit<JSX.HTMLAttributes<HTMLDivElement>, 'onChange' | 'defaultValue' | 'onSelectionChange'> {
+    /** Tree data. */
+    nodes: TreeNode[];
+    /** Controlled expanded ids. */
+    expanded?: string[];
+    /** Initial expanded ids (uncontrolled). */
+    defaultExpanded?: string[];
+    /** Called when the expanded set changes. */
+    onExpandedChange?: (expanded: string[]) => void;
+    /** Selection behavior. */
+    selectionMode?: TreeSelectionMode;
+    /** Controlled selection. */
+    selected?: string[];
+    /** Initial selection (uncontrolled). */
+    defaultSelected?: string[];
+    /** Called when selection changes. */
+    onSelectionChange?: (selected: string[]) => void;
+    /** Render-prop: receives a node + its render-state for each visible row. */
+    renderItem: (node: TreeNode, state: TreeItemState) => JSX.Element;
+}
+export interface TreeItemState {
+    level: number;
+    expanded: boolean;
+    selected: boolean;
+    hasChildren: boolean;
+    disabled: boolean;
+    toggle: () => void;
+    select: () => void;
+}
+export interface TreeViewContextValue {
+    readonly expanded: Set<string>;
+    readonly selected: Set<string>;
+    readonly selectionMode: TreeSelectionMode;
+    toggleExpanded: (id: string) => void;
+    selectNode: (id: string) => void;
+}

package/dist/components/tree-view/index.d.ts

@@ -0,0 +1,2 @@
+export { TreeView } from './TreeView';
+export type { TreeNode, TreeSelectionMode, TreeItemState, TreeViewRootProps, } from './TreeView.types';

package/dist/index.d.ts

@@ -1,31 +1,50 @@
-export { Accordion, Alert, Avatar, Badge, Button, Card, Checkbox, Divider, Drawer, Dropdown, Icon, Image, Input, List, Modal, OTP, Password, ProgressBar, Radio, Rating, Search, Select, Switch, Textarea, Timeago, Tooltip, } from './components';
+export { Accordion, Alert, AspectRatio, Avatar, Badge, Breadcrumb, Button, Calendar, Card, Checkbox, Combobox, ContextMenu, DatePicker, Divider, Drawer, Dropdown, FileUpload, Form, Icon, Image, Input, List, MenuBar, Modal, NavigationMenu, NumberInput, OTP, Pagination, getPaginationItems, Password, ProgressBar, Radio, Rating, ResizablePanels, Search, Select, Skeleton, Spinner, Switch, Tag, TagInput, Textarea, Timeago, Toast, useToast, Tooltip, TreeView, } from './components';
 export { iconNames, iconSizes } from './components/icon';
-export { createClickOutside, createInteractiveState } from './primitives';
-export type { InteractiveStateOptions, InteractiveStateResult } from './primitives';
+export { createClickOutside, createControllableState, createDebounce, createDebouncedCallback, createDisclosure, createFloating, createFocusTrap, createFocusVisible, createId, createIntersectionObserver, createInteractiveState, createKeyboard, createMediaQuery, createMergedRefs, createReduceMotion, createResizeObserver, createScrollLock, createThrottle, createThrottledCallback, } from './primitives';
+export type { CreateControllableStateOptions, CreateDisclosureOptions, CreateDisclosureResult, CreateFloatingOptions, CreateFloatingResult, FloatingSide, FloatingAlign, FloatingStrategy, CreateFocusTrapOptions, CreateFocusVisibleResult, CreateIntersectionObserverOptions, InteractiveStateOptions, InteractiveStateResult, KeyboardMap, KeyHandler, KeyboardHandlerOptions, CreateKeyboardOptions, ElementSize, } from './primitives';
 export type { Size, Status, HorizontalPosition, BaseFormFieldProps, BaseOption } from './types';
 export type { AccordionRootProps, AccordionRootSingleProps, AccordionRootMultipleProps, AccordionItemProps, AccordionTriggerProps, AccordionContentProps, } from './components/accordion';
 export type { AlertRootProps, AlertTitleProps, AlertDescriptionProps, AlertDismissProps } from './components/alert';
-export type { AvatarRootProps, AvatarImageProps, AvatarFallbackProps, AvatarImageStatus, } from './components/avatar';
+export type { AspectRatioProps } from './components/aspect-ratio';
+export type { AvatarRootProps, AvatarImageProps, AvatarFallbackProps, AvatarImageStatus } from './components/avatar';
 export type { BadgeProps } from './components/badge';
+export type { BreadcrumbRootProps, BreadcrumbListProps, BreadcrumbItemProps, BreadcrumbLinkProps, BreadcrumbSeparatorProps, } from './components/breadcrumb';
 export type { ButtonProps } from './components/button';
+export type { WeekStart, CalendarRootProps, CalendarNavProps, CalendarPrevButtonProps, CalendarNextButtonProps, CalendarTitleProps, CalendarGridProps, CalendarDay, } from './components/calendar';
 export type { CardProps } from './components/card';
 export type { CheckboxRootProps, CheckboxItemProps, CheckboxIndicatorProps, CheckboxLabelProps, } from './components/checkbox';
+export type { ComboboxOption, ComboboxRootProps, ComboboxInputProps, ComboboxTriggerProps, ComboboxContentProps, ComboboxEmptyProps, ComboboxItemRenderProps, ComboboxItemsProps, } from './components/combobox';
+export type { ContextMenuRootProps, ContextMenuTriggerProps, ContextMenuContentProps, ContextMenuItemProps, ContextMenuSeparatorProps, } from './components/context-menu';
+export type { DatePickerRootProps, DatePickerTriggerProps, DatePickerValueProps, DatePickerContentProps, } from './components/date-picker';
 export type { DividerProps } from './components/divider';
 export type { DrawerRootProps, DrawerPortalProps, DrawerOverlayProps, DrawerContentProps, DrawerHeaderProps, DrawerCloseProps, } from './components/drawer';
 export type { DropdownRootProps, DropdownTriggerProps, DropdownMenuProps, DropdownPosition, } from './components/dropdown';
+export type { FileUploadRootProps, FileUploadInputProps, FileUploadTriggerProps, FileUploadDropzoneProps, } from './components/file-upload';
+export type { FormRootProps, FormFieldProps, FormLabelProps, FormControlProps, FormDescriptionProps, FormErrorProps, } from './components/form';
 export type { IconName, IconSize, IconProps } from './components/icon';
 export type { ImageProps } from './components/image';
 export type { InputRootProps, InputFieldProps, InputLabelProps, InputErrorProps } from './components/input';
 export type { ListProps } from './components/list';
+export type { MenuBarRootProps, MenuBarMenuProps, MenuBarTriggerProps, MenuBarContentProps, MenuBarItemProps, MenuBarSeparatorProps, } from './components/menu-bar';
 export type { ModalRootProps, ModalPortalProps, ModalOverlayProps, ModalContentProps, ModalCloseProps, } from './components/modal';
+export type { NavigationMenuRootProps, NavigationMenuListProps, NavigationMenuItemProps, NavigationMenuTriggerProps, NavigationMenuContentProps, NavigationMenuLinkProps, } from './components/navigation-menu';
+export type { NumberInputRootProps, NumberInputFieldProps, NumberInputIncrementProps, NumberInputDecrementProps, } from './components/number-input';
 export type { OTPRootProps, OTPSlotProps, OTPSeparatorProps } from './components/otp';
+export type { PaginationRootProps, PaginationListProps, PaginationItemProps, PaginationButtonProps, PaginationEllipsisProps, PaginationItemValue, } from './components/pagination';
 export type { PasswordRootProps, PasswordFieldProps, PasswordToggleProps, PasswordLabelProps, PasswordErrorProps, } from './components/password';
 export type { ProgressBarProps } from './components/progress-bar';
 export type { RadioRootProps, RadioItemProps, RadioIndicatorProps, RadioLabelProps } from './components/radio';
 export type { RatingProps } from './components/rating';
+export type { PanelOrientation, PanelGroupProps, PanelProps, PanelHandleProps, PanelConfig, } from './components/resizable-panels';
 export type { SearchRootProps, SearchInputProps, SearchContentProps, SearchItemProps, SearchEmptyProps, SearchOption, } from './components/search';
 export type { SelectRootProps, SelectTriggerProps, SelectValueProps, SelectContentProps, SelectItemProps, SelectSeparatorProps, SelectGroupProps, SelectGroupLabelProps, } from './components/select';
+export type { SkeletonProps } from './components/skeleton';
+export type { SpinnerProps } from './components/spinner';
 export type { SwitchRootProps, SwitchThumbProps } from './components/switch';
+export type { TagRootProps, TagLabelProps, TagRemoveProps } from './components/tag';
+export type { TagInputRootProps, TagInputListProps, TagInputFieldProps } from './components/tag-input';
 export type { TextareaRootProps, TextareaFieldProps, TextareaLabelProps, TextareaErrorProps, } from './components/textarea';
 export type { TimeagoProps, TimeagoFormatConfig, TimeagoPlural } from './components/timeago';
+export type { ToastStatus, ToastData, ToastProviderProps, ToastViewportProps, ToastRootProps, ToastTitleProps, ToastDescriptionProps, ToastCloseProps, } from './components/toast';
 export type { TooltipRootProps, TooltipTriggerProps, TooltipContentProps } from './components/tooltip';
+export type { TreeNode, TreeSelectionMode, TreeItemState, TreeViewRootProps } from './components/tree-view';

package/dist/primitives/create-controllable-state.d.ts

@@ -0,0 +1,26 @@
+export interface CreateControllableStateOptions<T> {
+    /** Controlled value — when provided, state is owned by the parent */
+    value?: T;
+    /** Initial value when uncontrolled */
+    defaultValue?: T;
+    /** Called when the value changes (in both controlled and uncontrolled modes) */
+    onChange?: (value: T) => void;
+}
+type ControllableSetter<T> = (next: T | undefined | ((prev: T | undefined) => T | undefined)) => void;
+/**
+ * Unified state for components that can be controlled or uncontrolled.
+ *
+ * - If `value` is provided on `options`, the state is controlled — the setter only fires `onChange`.
+ * - If `value` is undefined, the state is uncontrolled — the setter updates internal state and fires `onChange`.
+ *
+ * Pass `options` as a plain object or with getters to make `value` reactive:
+ * `{ get value() { return props.value; }, onChange: props.onValueChange }`
+ *
+ * @example
+ * const [open, setOpen] = createControllableState({ get value() { return props.open }, defaultValue: false, onChange: props.onOpenChange })
+ */
+export declare function createControllableState<T>(options: CreateControllableStateOptions<T> & {
+    defaultValue: T;
+}): [() => T, ControllableSetter<T>];
+export declare function createControllableState<T>(options: CreateControllableStateOptions<T>): [() => T | undefined, ControllableSetter<T | undefined>];
+export {};

package/dist/primitives/create-debounce.d.ts

@@ -0,0 +1,19 @@
+import { Accessor } from 'solid-js';
+/**
+ * Returns a reactive value debounced — only updates after `delay` ms have passed without a change.
+ *
+ * Pass the input as an accessor so Solid can track changes reactively.
+ *
+ * @example
+ * const debouncedQuery = createDebounce(() => query(), 250)
+ * createEffect(() => { search(debouncedQuery()) })
+ */
+export declare function createDebounce<T>(value: Accessor<T>, delay: number): Accessor<T>;
+/**
+ * Returns a stable, debounced callback that fires `delay` ms after the most recent invocation.
+ * Always calls the latest `callback` reference, so closure-captured values stay fresh.
+ *
+ * @example
+ * const debouncedSave = createDebouncedCallback((value: string) => save(value), 500)
+ */
+export declare function createDebouncedCallback<Args extends unknown[]>(callback: (...args: Args) => void, delay: number): (...args: Args) => void;

package/dist/primitives/create-disclosure.d.ts

@@ -0,0 +1,25 @@
+import { Accessor } from 'solid-js';
+export interface CreateDisclosureOptions {
+    /** Initial open state */
+    defaultOpen?: boolean;
+    /** Called whenever the open state changes */
+    onOpenChange?: (open: boolean) => void;
+}
+export interface CreateDisclosureResult {
+    /** Reactive accessor for the current open state */
+    isOpen: Accessor<boolean>;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+    setOpen: (value: boolean) => void;
+}
+/**
+ * Manages a boolean open/close state with stable open/close/toggle handlers.
+ *
+ * Use this for modals, drawers, dropdowns, accordions — anything with a binary
+ * open state that doesn't need to be controlled from the outside.
+ *
+ * @example
+ * const { isOpen, open, close, toggle } = createDisclosure({ defaultOpen: false })
+ */
+export declare function createDisclosure(options?: CreateDisclosureOptions): CreateDisclosureResult;

package/dist/primitives/create-floating.d.ts

@@ -0,0 +1,43 @@
+import { Accessor, JSX } from 'solid-js';
+export type FloatingSide = 'top' | 'right' | 'bottom' | 'left';
+export type FloatingAlign = 'start' | 'center' | 'end';
+export type FloatingStrategy = 'absolute' | 'fixed';
+export interface CreateFloatingOptions {
+    /** Whether the floating element is open (positioning only runs when open) */
+    open?: boolean;
+    /** Preferred side relative to the reference element */
+    side?: FloatingSide;
+    /** Alignment along the chosen side */
+    align?: FloatingAlign;
+    /** Gap in pixels between reference and floating element */
+    offset?: number;
+    /** Positioning strategy — `fixed` is safer inside transformed/clipping ancestors */
+    strategy?: FloatingStrategy;
+    /** Flip to the opposite side when there isn't enough room */
+    flip?: boolean;
+    /** Shift the floating element along its main axis to stay in the viewport */
+    shift?: boolean;
+}
+export interface CreateFloatingResult {
+    x: Accessor<number>;
+    y: Accessor<number>;
+    side: Accessor<FloatingSide>;
+    align: Accessor<FloatingAlign>;
+    strategy: FloatingStrategy;
+    floatingStyles: () => JSX.CSSProperties;
+    update: () => void;
+}
+/**
+ * Positions a floating element relative to a reference element.
+ *
+ * Lightweight, zero-dependency positioning for tooltips, popovers, dropdowns, and similar UI.
+ * Recomputes on scroll and resize while open. Pass element accessors so Solid can track
+ * ref changes reactively.
+ *
+ * @example
+ * let referenceEl: HTMLButtonElement | undefined;
+ * let floatingEl: HTMLDivElement | undefined;
+ * const { floatingStyles, side } = createFloating(() => referenceEl, () => floatingEl, { get open() { return isOpen() }, side: 'bottom' })
+ * return <div ref={floatingEl} style={floatingStyles()} data-side={side()}>...</div>
+ */
+export declare function createFloating<R extends HTMLElement, F extends HTMLElement>(referenceRef: Accessor<R | null | undefined>, floatingRef: Accessor<F | null | undefined>, options?: CreateFloatingOptions): CreateFloatingResult;

package/dist/primitives/create-focus-trap.d.ts

@@ -0,0 +1,24 @@
+import { Accessor } from 'solid-js';
+export interface CreateFocusTrapOptions {
+    /** Whether the trap is active */
+    active?: boolean;
+    /** Restore focus to the previously focused element when the trap deactivates */
+    returnFocus?: boolean;
+    /** Element to focus initially. Defaults to the first focusable child. */
+    initialFocus?: Accessor<HTMLElement | null | undefined> | HTMLElement | null | undefined;
+}
+/**
+ * Traps keyboard focus inside the given container while active.
+ *
+ * Cycles Tab / Shift+Tab between the first and last focusable descendants. On activation,
+ * focus moves to `initialFocus` (or the first focusable child). On deactivation, focus
+ * returns to whatever was focused before, unless `returnFocus` is false.
+ *
+ * Pass `options` as a plain object or with getters to make `active` reactive:
+ * `{ get active() { return isOpen() } }`
+ *
+ * @example
+ * let dialogEl: HTMLDivElement | undefined;
+ * createFocusTrap(() => dialogEl, { get active() { return isOpen() } })
+ */
+export declare function createFocusTrap(containerRef: Accessor<HTMLElement | null | undefined>, options?: CreateFocusTrapOptions): void;