bits-ui 2.6.2 → 2.8.0

package/dist/bits/select/select.svelte.d.ts

@@ -1,15 +1,14 @@
 import { Previous } from "runed";
-import { DOMContext } from "svelte-toolbelt";
-import type { Box, ReadableBoxedValues, WritableBoxedValues } from "../../internal/box.svelte.js";
-import type { BitsEvent, BitsFocusEvent, BitsKeyboardEvent, BitsMouseEvent, BitsPointerEvent, WithRefProps } from "../../internal/types.js";
+import { DOMContext, type ReadableBoxedValues, type WritableBoxedValues, type Box } from "svelte-toolbelt";
+import type { BitsEvent, BitsFocusEvent, BitsKeyboardEvent, BitsMouseEvent, BitsPointerEvent, OnChangeFn, WithRefOpts } from "../../internal/types.js";
 export declare const INTERACTION_KEYS: string[];
 export declare const FIRST_KEYS: string[];
 export declare const LAST_KEYS: string[];
 export declare const FIRST_LAST_KEYS: string[];
 export declare const SELECTION_KEYS: string[];
 export declare const CONTENT_MARGIN = 10;
-declare const selectAttrs: import("../../internal/attrs.js").BitsAttrs<readonly ["trigger", "content", "item", "viewport", "scroll-up-button", "scroll-down-button", "group", "group-label", "separator", "arrow", "input", "content-wrapper", "item-text", "value"]>;
-type SelectBaseRootStateProps = ReadableBoxedValues<{
+declare const selectAttrs: import("../../internal/attrs.js").CreateBitsAttrsReturn<readonly ["trigger", "content", "item", "viewport", "scroll-up-button", "scroll-down-button", "group", "group-label", "separator", "arrow", "input", "content-wrapper", "item-text", "value"]>;
+interface SelectBaseRootStateOpts extends ReadableBoxedValues<{
     disabled: boolean;
     required: boolean;
     name: string;
@@ -21,14 +20,15 @@ type SelectBaseRootStateProps = ReadableBoxedValues<{
         disabled?: boolean;
     }[];
     allowDeselect: boolean;
-}> & WritableBoxedValues<{
+    onOpenChangeComplete: OnChangeFn<boolean>;
+}>, WritableBoxedValues<{
     open: boolean;
     inputValue: string;
-}> & {
+}> {
     isCombobox: boolean;
-};
-declare class SelectBaseRootState {
-    readonly opts: SelectBaseRootStateProps;
+}
+declare abstract class SelectBaseRootState {
+    readonly opts: SelectBaseRootStateOpts;
     touchedInput: boolean;
     inputNode: HTMLElement | null;
     contentNode: HTMLElement | null;
@@ -41,7 +41,7 @@ declare class SelectBaseRootState {
     isUsingKeyboard: boolean;
     isCombobox: boolean;
     domContext: DOMContext;
-    constructor(opts: SelectBaseRootStateProps);
+    constructor(opts: SelectBaseRootStateOpts);
     setHighlightedNode(node: HTMLElement | null, initial?: boolean): void;
     getCandidateNodes(): HTMLElement[];
     setHighlightedToFirstCandidate(): void;
@@ -53,41 +53,69 @@ declare class SelectBaseRootState {
     toggleMenu(): void;
     getBitsAttr: typeof selectAttrs.getAttr;
 }
-type SelectSingleRootStateProps = SelectBaseRootStateProps & WritableBoxedValues<{
+interface SelectSingleRootStateOpts extends SelectBaseRootStateOpts, WritableBoxedValues<{
     value: string;
-}>;
-declare class SelectSingleRootState extends SelectBaseRootState {
-    readonly opts: SelectSingleRootStateProps;
+}> {
+}
+export declare class SelectSingleRootState extends SelectBaseRootState {
+    readonly opts: SelectSingleRootStateOpts;
     readonly isMulti: false;
     readonly hasValue: boolean;
     readonly currentLabel: string;
     readonly candidateLabels: string[];
     readonly dataTypeaheadEnabled: boolean;
-    constructor(opts: SelectSingleRootStateProps);
+    constructor(opts: SelectSingleRootStateOpts);
     includesItem(itemValue: string): boolean;
     toggleItem(itemValue: string, itemLabel?: string): void;
     setInitialHighlightedNode(): void;
 }
-type SelectMultipleRootStateProps = SelectBaseRootStateProps & WritableBoxedValues<{
+interface SelectMultipleRootStateOpts extends SelectBaseRootStateOpts, WritableBoxedValues<{
     value: string[];
-}>;
+}> {
+}
 declare class SelectMultipleRootState extends SelectBaseRootState {
-    readonly opts: SelectMultipleRootStateProps;
+    readonly opts: SelectMultipleRootStateOpts;
     readonly isMulti: true;
     readonly hasValue: boolean;
-    constructor(opts: SelectMultipleRootStateProps);
+    constructor(opts: SelectMultipleRootStateOpts);
     includesItem(itemValue: string): boolean;
     toggleItem(itemValue: string, itemLabel?: string): void;
     setInitialHighlightedNode(): void;
 }
-type SelectRootState = SelectSingleRootState | SelectMultipleRootState;
-type SelectInputStateProps = WithRefProps & ReadableBoxedValues<{
+interface SelectRootStateOpts extends ReadableBoxedValues<{
+    disabled: boolean;
+    required: boolean;
+    loop: boolean;
+    scrollAlignment: "nearest" | "center";
+    name: string;
+    items: {
+        value: string;
+        label: string;
+        disabled?: boolean;
+    }[];
+    allowDeselect: boolean;
+    onOpenChangeComplete: OnChangeFn<boolean>;
+}>, WritableBoxedValues<{
+    open: boolean;
+    inputValue: string;
+}> {
+    isCombobox: boolean;
+    type: "single" | "multiple";
+    value: Box<string> | Box<string[]>;
+}
+export declare class SelectRootState {
+    static create(props: SelectRootStateOpts): SelectRoot;
+}
+type SelectRoot = SelectSingleRootState | SelectMultipleRootState;
+interface SelectInputStateOpts extends WithRefOpts, ReadableBoxedValues<{
     clearOnDeselect: boolean;
-}>;
-declare class SelectInputState {
-    readonly opts: SelectInputStateProps;
-    readonly root: SelectRootState;
-    constructor(opts: SelectInputStateProps, root: SelectRootState);
+}> {
+}
+export declare class SelectInputState {
+    static create(opts: SelectInputStateOpts): SelectInputState;
+    readonly opts: SelectInputStateOpts;
+    readonly root: SelectRoot;
+    constructor(opts: SelectInputStateOpts, root: SelectRoot);
     onkeydown(e: BitsKeyboardEvent): void;
     oninput(e: BitsEvent<Event, HTMLInputElement>): void;
     readonly props: {
@@ -103,11 +131,13 @@ declare class SelectInputState {
         readonly oninput: (e: BitsEvent<Event, HTMLInputElement>) => void;
     };
 }
-type SelectComboTriggerStateProps = WithRefProps;
-declare class SelectComboTriggerState {
-    readonly opts: SelectComboTriggerStateProps;
+interface SelectComboTriggerStateOpts extends WithRefOpts {
+}
+export declare class SelectComboTriggerState {
+    static create(opts: SelectComboTriggerStateOpts): SelectComboTriggerState;
+    readonly opts: SelectComboTriggerStateOpts;
     readonly root: SelectBaseRootState;
-    constructor(opts: SelectComboTriggerStateProps, root: SelectBaseRootState);
+    constructor(opts: SelectComboTriggerStateOpts, root: SelectBaseRootState);
     onkeydown(e: BitsKeyboardEvent): void;
     /**
      * `pointerdown` fires before the `focus` event, so we can prevent the default
@@ -124,12 +154,14 @@ declare class SelectComboTriggerState {
         readonly onkeydown: (e: BitsKeyboardEvent) => void;
     };
 }
-type SelectTriggerStateProps = WithRefProps;
-declare class SelectTriggerState {
+interface SelectTriggerStateOpts extends WithRefOpts {
+}
+export declare class SelectTriggerState {
     #private;
-    readonly opts: SelectTriggerStateProps;
-    readonly root: SelectRootState;
-    constructor(opts: SelectTriggerStateProps, root: SelectRootState);
+    static create(opts: SelectTriggerStateOpts): SelectTriggerState;
+    readonly opts: SelectTriggerStateOpts;
+    readonly root: SelectRoot;
+    constructor(opts: SelectTriggerStateOpts, root: SelectRoot);
     onkeydown(e: BitsKeyboardEvent): void;
     onclick(e: BitsMouseEvent): void;
     onpointerdown(e: BitsPointerEvent): void;
@@ -149,18 +181,20 @@ declare class SelectTriggerState {
         readonly onpointerup: (e: BitsPointerEvent) => void;
     };
 }
-type SelectContentStateProps = WithRefProps & ReadableBoxedValues<{
+interface SelectContentStateOpts extends WithRefOpts, ReadableBoxedValues<{
     onInteractOutside: (e: PointerEvent) => void;
     onEscapeKeydown: (e: KeyboardEvent) => void;
-}>;
-declare class SelectContentState {
+}> {
+}
+export declare class SelectContentState {
     #private;
-    readonly opts: SelectContentStateProps;
-    readonly root: SelectRootState;
+    static create(opts: SelectContentStateOpts): SelectContentState;
+    readonly opts: SelectContentStateOpts;
+    readonly root: SelectRoot;
     viewportNode: HTMLElement | null;
     isPositioned: boolean;
     domContext: DOMContext;
-    constructor(opts: SelectContentStateProps, root: SelectRootState);
+    constructor(opts: SelectContentStateOpts, root: SelectRoot);
     onpointermove(_: BitsPointerEvent): void;
     onInteractOutside: (e: PointerEvent) => void;
     onEscapeKeydown: (e: KeyboardEvent) => void;
@@ -193,21 +227,23 @@ declare class SelectContentState {
         onPlaced: () => void;
     };
 }
-type SelectItemStateProps = WithRefProps<ReadableBoxedValues<{
+interface SelectItemStateOpts extends WithRefOpts, ReadableBoxedValues<{
     value: string;
     disabled: boolean;
     label: string;
     onHighlight: () => void;
     onUnhighlight: () => void;
-}>>;
-declare class SelectItemState {
-    readonly opts: SelectItemStateProps;
-    readonly root: SelectRootState;
+}> {
+}
+export declare class SelectItemState {
+    static create(opts: SelectItemStateOpts): SelectItemState;
+    readonly opts: SelectItemStateOpts;
+    readonly root: SelectRoot;
     readonly isSelected: boolean;
     readonly isHighlighted: boolean;
     readonly prevHighlighted: Previous<boolean>;
     mounted: boolean;
-    constructor(opts: SelectItemStateProps, root: SelectRootState);
+    constructor(opts: SelectItemStateOpts, root: SelectRoot);
     handleSelect(): void;
     snippetProps: {
         selected: boolean;
@@ -221,7 +257,7 @@ declare class SelectItemState {
      */
     onpointerup(e: BitsPointerEvent): void;
     onpointermove(e: BitsPointerEvent): void;
-    props: {
+    readonly props: {
         readonly id: string;
         readonly role: "option";
         readonly "aria-selected": "true" | undefined;
@@ -235,35 +271,41 @@ declare class SelectItemState {
         readonly onpointerup: (e: BitsPointerEvent) => void;
     };
 }
-type SelectGroupStateProps = WithRefProps;
-declare class SelectGroupState {
-    readonly opts: SelectGroupStateProps;
+interface SelectGroupStateOpts extends WithRefOpts {
+}
+export declare class SelectGroupState {
+    static create(opts: SelectGroupStateOpts): SelectGroupState;
+    readonly opts: SelectGroupStateOpts;
     readonly root: SelectBaseRootState;
     labelNode: HTMLElement | null;
-    constructor(opts: SelectGroupStateProps, root: SelectBaseRootState);
+    constructor(opts: SelectGroupStateOpts, root: SelectBaseRootState);
     readonly props: {
         readonly id: string;
         readonly role: "group";
         readonly "aria-labelledby": string | undefined;
     };
 }
-type SelectGroupHeadingStateProps = WithRefProps;
-declare class SelectGroupHeadingState {
-    readonly opts: SelectGroupHeadingStateProps;
+interface SelectGroupHeadingStateOpts extends WithRefOpts {
+}
+export declare class SelectGroupHeadingState {
+    static create(opts: SelectGroupHeadingStateOpts): SelectGroupHeadingState;
+    readonly opts: SelectGroupHeadingStateOpts;
     readonly group: SelectGroupState;
-    constructor(opts: SelectGroupHeadingStateProps, group: SelectGroupState);
+    constructor(opts: SelectGroupHeadingStateOpts, group: SelectGroupState);
     readonly props: {
         readonly id: string;
     };
 }
-type SelectHiddenInputStateProps = ReadableBoxedValues<{
+interface SelectHiddenInputStateOpts extends ReadableBoxedValues<{
     value: string;
-}>;
-declare class SelectHiddenInputState {
-    readonly opts: SelectHiddenInputStateProps;
+}> {
+}
+export declare class SelectHiddenInputState {
+    static create(opts: SelectHiddenInputStateOpts): SelectHiddenInputState;
+    readonly opts: SelectHiddenInputStateOpts;
     readonly root: SelectBaseRootState;
-    shouldRender: boolean;
-    constructor(opts: SelectHiddenInputStateProps, root: SelectBaseRootState);
+    readonly shouldRender: boolean;
+    constructor(opts: SelectHiddenInputStateOpts, root: SelectBaseRootState);
     onfocus(e: BitsFocusEvent): void;
     readonly props: {
         readonly disabled: true | undefined;
@@ -273,13 +315,15 @@ declare class SelectHiddenInputState {
         readonly onfocus: (e: BitsFocusEvent) => void;
     };
 }
-type SelectViewportStateProps = WithRefProps;
-declare class SelectViewportState {
-    readonly opts: SelectViewportStateProps;
+interface SelectViewportStateOpts extends WithRefOpts {
+}
+export declare class SelectViewportState {
+    static create(opts: SelectViewportStateOpts): SelectViewportState;
+    readonly opts: SelectViewportStateOpts;
     readonly content: SelectContentState;
-    root: SelectBaseRootState;
+    readonly root: SelectBaseRootState;
     prevScrollTop: number;
-    constructor(opts: SelectViewportStateProps, content: SelectContentState);
+    constructor(opts: SelectViewportStateOpts, content: SelectContentState);
     readonly props: {
         readonly id: string;
         readonly role: "presentation";
@@ -290,19 +334,20 @@ declare class SelectViewportState {
         };
     };
 }
-type SelectScrollButtonImplStateProps = WithRefProps & ReadableBoxedValues<{
+interface SelectScrollButtonImplStateOpts extends WithRefOpts, ReadableBoxedValues<{
     delay: (tick: number) => number;
-}>;
-declare class SelectScrollButtonImplState {
-    readonly opts: SelectScrollButtonImplStateProps;
+}> {
+}
+export declare class SelectScrollButtonImplState {
+    readonly opts: SelectScrollButtonImplStateOpts;
     readonly content: SelectContentState;
-    root: SelectBaseRootState;
+    readonly root: SelectBaseRootState;
     autoScrollTimer: number | null;
     userScrollTimer: number;
     isUserScrolling: boolean;
     onAutoScroll: () => void;
     mounted: boolean;
-    constructor(opts: SelectScrollButtonImplStateProps, content: SelectContentState);
+    constructor(opts: SelectScrollButtonImplStateOpts, content: SelectContentState);
     handleUserScroll(): void;
     clearAutoScrollInterval(): void;
     onpointerdown(_: BitsPointerEvent): void;
@@ -319,10 +364,11 @@ declare class SelectScrollButtonImplState {
         readonly onpointerleave: (_: BitsPointerEvent) => void;
     };
 }
-declare class SelectScrollDownButtonState {
+export declare class SelectScrollDownButtonState {
+    static create(opts: SelectScrollButtonImplStateOpts): SelectScrollDownButtonState;
     readonly scrollButtonState: SelectScrollButtonImplState;
-    content: SelectContentState;
-    root: SelectBaseRootState;
+    readonly content: SelectContentState;
+    readonly root: SelectBaseRootState;
     canScrollDown: boolean;
     scrollIntoViewTimer: ReturnType<typeof globalThis.setTimeout> | null;
     constructor(scrollButtonState: SelectScrollButtonImplState);
@@ -343,10 +389,11 @@ declare class SelectScrollDownButtonState {
         readonly onpointerleave: (_: BitsPointerEvent) => void;
     };
 }
-declare class SelectScrollUpButtonState {
+export declare class SelectScrollUpButtonState {
+    static create(opts: SelectScrollButtonImplStateOpts): SelectScrollUpButtonState;
     readonly scrollButtonState: SelectScrollButtonImplState;
-    content: SelectContentState;
-    root: SelectBaseRootState;
+    readonly content: SelectContentState;
+    readonly root: SelectBaseRootState;
     canScrollUp: boolean;
     constructor(scrollButtonState: SelectScrollButtonImplState);
     /**
@@ -366,37 +413,4 @@ declare class SelectScrollUpButtonState {
         readonly onpointerleave: (_: BitsPointerEvent) => void;
     };
 }
-type InitSelectProps = {
-    type: "single" | "multiple";
-    value: Box<string> | Box<string[]>;
-} & ReadableBoxedValues<{
-    disabled: boolean;
-    required: boolean;
-    loop: boolean;
-    scrollAlignment: "nearest" | "center";
-    name: string;
-    items: {
-        value: string;
-        label: string;
-        disabled?: boolean;
-    }[];
-    allowDeselect: boolean;
-}> & WritableBoxedValues<{
-    open: boolean;
-    inputValue: string;
-}> & {
-    isCombobox: boolean;
-};
-export declare function useSelectRoot(props: InitSelectProps): SelectRootState;
-export declare function useSelectInput(props: SelectInputStateProps): SelectInputState;
-export declare function useSelectContent(props: SelectContentStateProps): SelectContentState;
-export declare function useSelectTrigger(props: SelectTriggerStateProps): SelectTriggerState;
-export declare function useSelectComboTrigger(props: SelectComboTriggerStateProps): SelectComboTriggerState;
-export declare function useSelectItem(props: SelectItemStateProps): SelectItemState;
-export declare function useSelectViewport(props: SelectViewportStateProps): SelectViewportState;
-export declare function useSelectScrollUpButton(props: SelectScrollButtonImplStateProps): SelectScrollUpButtonState;
-export declare function useSelectScrollDownButton(props: SelectScrollButtonImplStateProps): SelectScrollDownButtonState;
-export declare function useSelectGroup(props: SelectGroupStateProps): SelectGroupState;
-export declare function useSelectGroupHeading(props: SelectGroupHeadingStateProps): SelectGroupHeadingState;
-export declare function useSelectHiddenInput(props: SelectHiddenInputStateProps): SelectHiddenInputState;
 export {};