@salt-ds/lab 1.0.0-alpha.0

package/dist-types/form-field-context/FormFieldContext.d.ts

@@ -0,0 +1,12 @@
+import { Dispatch, FocusEventHandler, RefObject, SetStateAction } from "react";
+import { useA11yValueValue } from "../form-field";
+export interface FormFieldContextValue {
+    inFormField: true;
+    ref: RefObject<HTMLDivElement>;
+    a11yProps: useA11yValueValue;
+    focused: boolean;
+    setFocused: Dispatch<SetStateAction<boolean>>;
+    onBlur: FocusEventHandler<HTMLElement>;
+    onFocus: FocusEventHandler<HTMLElement>;
+}
+export declare const FormFieldContext: import("react").Context<FormFieldContextValue>;

package/dist-types/form-field-context/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./FormFieldContext";
+export * from "./useFormFieldProps";

package/dist-types/form-field-context/useFormFieldProps.d.ts

@@ -0,0 +1,6 @@
+import { FormFieldContextValue } from "./FormFieldContext";
+interface useFormFieldPropsProps {
+    focusVisible?: boolean;
+}
+export declare function useFormFieldProps({ focusVisible, }?: useFormFieldPropsProps): Partial<FormFieldContextValue>;
+export {};

package/dist-types/form-group/FormGroup.d.ts

@@ -0,0 +1,9 @@
+import { HTMLAttributes } from "react";
+import "./FormGroup.css";
+export interface FormGroupProps extends HTMLAttributes<HTMLDivElement> {
+    /**
+     * Display group of elements in a compact row.
+     */
+    row?: boolean;
+}
+export declare const FormGroup: import("react").ForwardRefExoticComponent<FormGroupProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/form-group/index.d.ts

@@ -0,0 +1 @@
+export * from "./FormGroup";

package/dist-types/formatted-input/FormattedInput.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="react" />
+import { InputProps } from "../input";
+import "./FormattedInput.css";
+export declare type MaskFunction = (value: string | undefined) => boolean;
+export interface RifmOptions {
+    format?: (str: string) => string;
+    replace?: (str: string) => string;
+    append?: (str: string) => string;
+    mask?: boolean | MaskFunction;
+    accept?: RegExp;
+}
+export interface FormattedInputProps extends Omit<InputProps, "onChange"> {
+    mask?: string;
+    onChange?: (value: string) => void;
+    rifmOptions?: RifmOptions;
+    value?: string;
+    defaultValue?: string;
+}
+export declare const FormattedInput: import("react").ForwardRefExoticComponent<FormattedInputProps & import("react").RefAttributes<HTMLInputElement>>;

package/dist-types/formatted-input/index.d.ts

@@ -0,0 +1 @@
+export * from "./FormattedInput";

package/dist-types/formatted-input/internal/InputWithMask.d.ts

@@ -0,0 +1,9 @@
+import { InputHTMLAttributes } from "react";
+import { FormattedInputProps } from "../FormattedInput";
+export declare const baseName = "saltFormattedInput";
+export interface InputWithMaskProps extends InputHTMLAttributes<HTMLInputElement> {
+    mask?: FormattedInputProps["mask"];
+    textAlign?: FormattedInputProps["textAlign"];
+    value?: FormattedInputProps["value"];
+}
+export declare const InputWithMask: import("react").ForwardRefExoticComponent<InputWithMaskProps & import("react").RefAttributes<HTMLInputElement>>;

package/dist-types/index.d.ts

@@ -0,0 +1,65 @@
+export type { SelectHandler, SelectionChangeHandler, SelectionStrategy, useCollectionItems, } from "./common-hooks";
+export type { ListChangeHandler as ListChangeHandlerDeprecated, ListSelectHandler as ListSelectHandlerDeprecated, } from "./list-deprecated";
+export { ListItemBase as ListItemBaseDeprecated, useListItem as useListItemDeprecated, } from "./list-deprecated";
+export * from "./accordion";
+export * from "./app-header";
+export * from "./avatar";
+export * from "./badge";
+export * from "./banner";
+export * from "./breadcrumbs";
+export * from "./button-bar";
+export * from "./calendar";
+export * from "./card";
+export * from "./carousel";
+export * from "./cascading-menu";
+export * from "./checkbox";
+export * from "./color-chooser";
+export * from "./combo-box";
+export * from "./combo-box-deprecated";
+export * from "./contact-details";
+export * from "./content-status";
+export * from "./control-label";
+export * from "./deck-item";
+export * from "./deck-layout";
+export * from "./dialog";
+export * from "./dropdown";
+export * from "./editable-label";
+export * from "./file-drop-zone";
+export * from "./form-field";
+export * from "./form-field-context";
+export * from "./form-group";
+export * from "./formatted-input";
+export * from "./input";
+export * from "./layer-layout";
+export * from "./list";
+export * from "./logo";
+export * from "./menu-button";
+export * from "./metric";
+export * from "./overlay";
+export * from "./pagination";
+export * from "./panel";
+export * from "./parent-child-item";
+export * from "./parent-child-layout";
+export * from "./pill";
+export * from "./popper";
+export * from "./portal";
+export * from "./progress";
+export * from "./query-input";
+export * from "./radio-button";
+export * from "./responsive";
+export * from "./scrim";
+export * from "./search-input";
+export * from "./skip-link";
+export * from "./slider";
+export * from "./spinner";
+export * from "./split-layout";
+export * from "./stepper-input";
+export * from "./switch";
+export * from "./tabs";
+export * from "./toggle-button";
+export * from "./tokenized-input";
+export * from "./toolbar";
+export * from "./tooltip";
+export * from "./tree";
+export * from "./utils";
+export * from "./window";

package/dist-types/input/Input.d.ts

@@ -0,0 +1,77 @@
+import { ChangeEvent, ElementType, FocusEventHandler, HTMLAttributes, InputHTMLAttributes, KeyboardEventHandler, MouseEventHandler, ReactNode } from "react";
+import "./Input.css";
+export interface InputProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange" | "defaultValue"> {
+    /**
+     * Determines the position of the text cursor on focus of the input.
+     *
+     * start = place cursor at the beginning<br>
+     * end = place cursor at the end<br>
+     * \# = index to place the cursor<br>
+     */
+    cursorPositionOnFocus?: "start" | "end" | number;
+    /**
+     * The value of the `input` element, required for an uncontrolled component.
+     */
+    defaultValue?: HTMLInputElement["defaultValue"];
+    /**
+     * If `true`, the component is disabled.
+     */
+    disabled?: HTMLInputElement["disabled"];
+    /**
+     * The marker to use in an empty read only Input.
+     * Use `''` to disable this feature. Defaults to '—'.
+     */
+    emptyReadOnlyMarker?: string;
+    /**
+     * Determines what gets highlighted on focus of the input.
+     *
+     * If `true` all text will be highlighted.
+     * If an array text between those indices will be highlighted
+     * e.g. [0,1] will highlight the first character.
+     */
+    highlightOnFocus?: boolean | number[];
+    /**
+     * The HTML element to render the Input, e.g. 'input', a custom React component.
+     */
+    inputComponent?: ElementType;
+    /**
+     * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Attributes) applied to the `input` element.
+     */
+    inputProps?: InputHTMLAttributes<HTMLInputElement>;
+    onBlur?: FocusEventHandler<HTMLInputElement>;
+    /**
+     * Callback for change event.
+     */
+    onChange?: (event: ChangeEvent<HTMLInputElement>, value: string) => void;
+    onFocus?: FocusEventHandler<HTMLInputElement>;
+    onKeyDown?: KeyboardEventHandler<HTMLInputElement>;
+    onKeyUp?: KeyboardEventHandler<HTMLInputElement>;
+    onMouseUp?: MouseEventHandler<HTMLInputElement>;
+    onMouseMove?: MouseEventHandler<HTMLInputElement>;
+    onMouseDown?: MouseEventHandler<HTMLInputElement>;
+    /**
+     * If `true`, the component is read only.
+     */
+    readOnly?: boolean;
+    /**
+     *
+     * Determines the alignment of the input text.
+     */
+    textAlign?: "left" | "right" | "center";
+    type?: HTMLInputElement["type"];
+    /**
+     * The value of the `input` element, required for a controlled component.
+     */
+    value?: HTMLInputElement["value"];
+    renderSuffix?: (state: {
+        disabled?: boolean;
+        error?: boolean;
+        focused?: boolean;
+        margin?: "dense" | "none" | "normal";
+        required?: boolean;
+        startAdornment?: ReactNode;
+    }) => ReactNode;
+    endAdornment?: ReactNode;
+    startAdornment?: ReactNode;
+}
+export declare const Input: import("react").ForwardRefExoticComponent<InputProps & import("react").RefAttributes<HTMLInputElement>>;

package/dist-types/input/StaticInputAdornment.d.ts

@@ -0,0 +1,4 @@
+import { HTMLAttributes } from "react";
+import "./StaticInputAdornment.css";
+export declare type StaticInputAdornmentProps = HTMLAttributes<HTMLDivElement>;
+export declare const StaticInputAdornment: import("react").ForwardRefExoticComponent<StaticInputAdornmentProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/input/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Input";
+export * from "./StaticInputAdornment";

package/dist-types/input/useCursorOnFocus.d.ts

@@ -0,0 +1,24 @@
+import { MouseEvent, MutableRefObject } from "react";
+export interface useCursorOnFocusProps {
+    /**
+     * Determines the position of the text cursor on focus of the input.
+     *
+     * start = place cursor at the beginning
+     * end = place cursor at the end
+     * \# = index to place the cursor
+     */
+    cursorPositionOnFocus?: "start" | "end" | number;
+    /**
+     * Determines what gets highlighted on focus of the input.
+     *
+     * If `true` all text will be highlighted.
+     * If an array text between those indices will be highlighted
+     * e.g. [0,1] will highlight the first character.
+     */
+    highlightOnFocus?: boolean | number[];
+}
+export declare function useCursorOnFocus(inputRef: MutableRefObject<HTMLInputElement | null>, { cursorPositionOnFocus, highlightOnFocus }: useCursorOnFocusProps): {
+    handleMouseDown: () => void;
+    handleMouseMove: (event: MouseEvent) => void;
+    handleMouseUp: () => void;
+};

package/dist-types/layer-layout/LayerLayout.d.ts

@@ -0,0 +1,33 @@
+import { HTMLAttributes } from "react";
+import { Breakpoints } from "@salt-ds/core";
+import { ScrimProps } from "../scrim";
+import "./LayerLayout.css";
+export declare const LAYER_POSITIONS: readonly ["center", "left", "top", "right", "bottom"];
+export declare type LayerPositions = typeof LAYER_POSITIONS[number];
+export interface LayerLayoutProps extends HTMLAttributes<HTMLDivElement> {
+    /**
+     * Disable the scrim.
+     */
+    disableScrim?: boolean;
+    /**
+     * Defines the layer position within the screen.
+     */
+    position?: LayerPositions;
+    /**
+     * Breakpoint at which the layer will become fullscreen.
+     */
+    fullScreenAtBreakpoint?: keyof Breakpoints;
+    /**
+     * Disable all animations.
+     */
+    disableAnimations?: boolean;
+    /**
+     * Display or hide the component.
+     */
+    isOpen?: boolean;
+    /**
+     * Props to be passed to the Scrim component.
+     */
+    scrimProps?: Partial<ScrimProps>;
+}
+export declare const LayerLayout: import("react").ForwardRefExoticComponent<LayerLayoutProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/layer-layout/index.d.ts

@@ -0,0 +1 @@
+export * from "./LayerLayout";

package/dist-types/list/Highlighter.d.ts

@@ -0,0 +1,7 @@
+import { ReactElement } from "react";
+import "./Highlighter.css";
+export interface HighlighterProps {
+    matchPattern?: RegExp | string;
+    text?: string;
+}
+export declare const Highlighter: (props: HighlighterProps) => ReactElement<HighlighterProps>;

package/dist-types/list/List.d.ts

@@ -0,0 +1,7 @@
+import { ForwardedRef, ReactElement } from "react";
+import { ScrollingAPI, SelectionStrategy } from "../common-hooks";
+import { ListProps } from "./listTypes";
+import "./List.css";
+export declare const List: <Item = string, Selection_1 extends SelectionStrategy = "default">(props: ListProps<Item, Selection_1> & {
+    ref?: ForwardedRef<ScrollingAPI<Item>> | undefined;
+}) => ReactElement<ListProps<Item, Selection_1>, string | import("react").JSXElementConstructor<any>>;

package/dist-types/list/ListItem.d.ts

@@ -0,0 +1,5 @@
+import { HTMLAttributes } from "react";
+import { ListItemType } from "./listTypes";
+import "./ListItem.css";
+export declare const ListItemProxy: import("react").ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & import("react").RefAttributes<HTMLDivElement>>;
+export declare const ListItem: ListItemType<unknown>;

package/dist-types/list/ListItemGroup.d.ts

@@ -0,0 +1,6 @@
+import { HTMLAttributes } from "react";
+export interface ListItemGroupProps extends HTMLAttributes<HTMLDivElement> {
+    children?: JSX.Element | JSX.Element[];
+    label?: string;
+}
+export declare const ListItemGroup: (_: ListItemGroupProps) => null;

package/dist-types/list/ListItemHeader.d.ts

@@ -0,0 +1,5 @@
+import { HTMLAttributes } from "react";
+export interface ListItemHeaderProps extends HTMLAttributes<HTMLDivElement> {
+    label?: string;
+}
+export declare const ListItemHeader: (_: ListItemHeaderProps) => null;

package/dist-types/list/VirtualizedList.d.ts

@@ -0,0 +1,7 @@
+import { ForwardedRef, ReactElement } from "react";
+import { SelectionStrategy } from "../common-hooks";
+import { ListProps } from "./listTypes";
+import "./List.css";
+export declare const VirtualizedList: <Item = string, Selection_1 extends SelectionStrategy = "default">(props: ListProps<Item, Selection_1> & {
+    ref?: ForwardedRef<HTMLDivElement> | undefined;
+}) => ReactElement<ListProps<Item, Selection_1>, string | import("react").JSXElementConstructor<any>>;

package/dist-types/list/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./Highlighter";
+export * from "./ListItem";
+export * from "./List";
+export * from "./listTypes";
+export * from "./ListItemHeader";
+export * from "./ListItemGroup";
+export * from "./useList";
+export * from "./VirtualizedList";

package/dist-types/list/keyset.d.ts

@@ -0,0 +1,9 @@
+export declare class KeySet {
+    private keys;
+    private free;
+    private nextKeyValue;
+    constructor(from?: number, to?: number);
+    next(): number;
+    reset(from: number, to: number): void;
+    keyFor(rowIndex: number): number | undefined;
+}

package/dist-types/list/listTypes.d.ts

@@ -0,0 +1,188 @@
+import React, { FocusEventHandler, ForwardedRef, HTMLAttributes, KeyboardEvent, KeyboardEventHandler, MouseEventHandler, PropsWithChildren, Ref, RefObject } from "react";
+import { CollectionHookResult, CollectionItem, ListHandlers, NavigationHookResult, ScrollingAPI, SelectHandler, SelectionChangeHandler, SelectionHookResult, SelectionProps, SelectionStrategy, ViewportTrackingResult } from "../common-hooks";
+export declare type ComponentType<T = unknown> = (props: PropsWithChildren<T>) => JSX.Element;
+export declare type ListItemType<T = unknown> = ComponentType<ListItemProps<T> & {
+    ref?: Ref<HTMLDivElement>;
+}>;
+export interface ListItemProps<T = unknown> extends HTMLAttributes<HTMLDivElement> {
+    children?: React.ReactNode;
+    disabled?: boolean;
+    item?: T;
+    itemHeight?: number | string;
+    itemTextHighlightPattern?: RegExp | string;
+    label?: string;
+    showCheckbox?: boolean;
+    /**
+     * selectable is a marker, used by List, not used by ListItem itself
+     */
+    selectable?: boolean;
+    selected?: boolean;
+}
+export interface ListScrollHandles<Item> {
+    scrollToIndex: (itemIndex: number) => void;
+    scrollToItem: (item: Item) => void;
+    scrollTo: (scrollOffset: number) => void;
+}
+export interface ListProps<Item = string, Selection extends SelectionStrategy = "default"> extends SelectionProps<Item, Selection>, Omit<HTMLAttributes<HTMLDivElement>, "onSelect" | "defaultValue"> {
+    /**
+     * The component used to render a ListItem instead of the default. This must itself render a ListItem,
+     * must implement props that extend ListItemProps and must forward ListItem props to the ListItem.
+     */
+    ListItem?: ListItemType<Item>;
+    /**
+     * The component used when there are no items.
+     */
+    ListPlaceholder?: ComponentType<HTMLAttributes<unknown>>;
+    borderless?: boolean;
+    /**
+     * Adds checkbox to list. Defaults to true for multiselect strategy. Only supported for
+     * multiple select strategies (multi selection and extended selection)
+     */
+    checkable?: boolean;
+    className?: string;
+    collapsibleHeaders?: boolean;
+    defaultHighlightedIndex?: number;
+    disabled?: boolean;
+    disableFocus?: boolean;
+    /**
+     * Use to turn off typeahead search functionality within List. Defaulst to false;
+     */
+    disableTypeToSelect?: boolean;
+    displayedItemCount?: number;
+    emptyMessage?: string;
+    focusVisible?: number;
+    /**
+     * Used for providing customized item height. It should return a number or a string if item height
+     * is in percentage. .
+     *
+     * @param {number} index The item index.
+     */
+    getItemHeight?: (index: number) => number;
+    /**
+     * Used for providing customized item ids.
+     * deprecated
+     * @param {number} index The item index.
+     */
+    getItemId?: (index: number) => string;
+    /**
+     * Height of the component.
+     */
+    height?: number | string;
+    highlightedIndex?: number;
+    /**
+     * The total number of items.
+     *
+     * Used for keyboard navigation (when `End` key is pressed) and when the list is virtualized.
+     */
+    itemCount?: number;
+    /**
+     * Size of the gap between list items. Defaults to zero.
+     */
+    itemGapSize?: number;
+    /**
+     * Height of an item. I can be a number or a string if item height is in percentage. If omitted
+     * default height values from Salt theme will be used.
+     *
+     * Note that when using a percentage value, the list must have a height.
+     */
+    itemHeight?: number | string;
+    /**
+     * Used for providing text highlight.
+     *
+     * It can be a capturing regex or a string for a straightforward string matching.
+     */
+    itemTextHighlightPattern?: RegExp | string;
+    /**
+     * Item `toString` function when list is not used declaratively and its items are objects
+     * instead of strings. The string value is also used in tooltip when item text is truncated.
+     *
+     * If omitted, component will look for a `label` property on the data object.
+     *
+     * @param {object} item The item.
+     */
+    itemToString?: (item: Item) => string;
+    listHandlers?: ListHandlers;
+    /**
+     * Maximum list height.
+     */
+    maxHeight?: number | string;
+    /**
+     * Maximum list width.
+     */
+    maxWidth?: number | string;
+    /**
+     * Minimum list height.
+     */
+    minHeight?: number | string;
+    /**
+     * Minimum list width.
+     */
+    minWidth?: number | string;
+    onHighlight?: (index: number) => void;
+    /**
+     * If `true`, the component will remember the last keyboard-interacted position
+     * and highlight it when list is focused again.
+     */
+    restoreLastFocus?: boolean;
+    scrollingApiRef?: ForwardedRef<ScrollingAPI<Item>>;
+    /**
+     * The keyboard keys used to effect selection, defaults to SPACE and ENTER
+     * TODO maybe this belongs on the SelectionProps interface ?
+     */
+    selectionKeys?: string[];
+    showEmptyMessage?: boolean;
+    source?: ReadonlyArray<Item>;
+    stickyHeaders?: boolean;
+    /**
+     * When set to `true`, 'Tab' key selects current highlighted item before focus is blurred away
+     * from the component. This would be the desirable behaviour for any dropdown menu based
+     * components like dropdown, combobox.
+     *
+     * @default false
+     */
+    tabToSelect?: boolean;
+    /**
+     * Width of the component.
+     */
+    width?: number | string;
+}
+export interface ListControlProps {
+    "aria-activedescendant"?: string;
+    onBlur: FocusEventHandler;
+    onFocus: FocusEventHandler;
+    onKeyDown: KeyboardEventHandler;
+    onMouseDownCapture: MouseEventHandler;
+    onMouseLeave: MouseEventHandler;
+}
+export interface ListHookProps<Item, Selection extends SelectionStrategy> extends Omit<SelectionProps<CollectionItem<Item>, Selection>, "onSelect" | "onSelectionChange"> {
+    collapsibleHeaders?: boolean;
+    collectionHook: CollectionHookResult<Item>;
+    containerRef: RefObject<HTMLElement>;
+    contentRef?: RefObject<HTMLElement>;
+    defaultHighlightedIndex?: number;
+    disabled?: boolean;
+    disableAriaActiveDescendant?: boolean;
+    disableHighlightOnFocus?: boolean;
+    disableTypeToSelect?: boolean;
+    focusVisible?: boolean;
+    highlightedIndex?: number;
+    label?: string;
+    listHandlers?: ListHandlers;
+    onHighlight?: (index: number) => void;
+    onKeyboardNavigation?: (event: React.KeyboardEvent, currentIndex: number) => void;
+    onKeyDown?: (evt: KeyboardEvent) => void;
+    onSelect?: SelectHandler<Item>;
+    onSelectionChange?: SelectionChangeHandler<Item, Selection>;
+    restoreLastFocus?: boolean;
+    selectionKeys?: string[];
+    stickyHeaders?: boolean;
+    tabToSelect?: boolean;
+}
+export interface ListHookResult<Item, Selection extends SelectionStrategy> extends Partial<ViewportTrackingResult<Item>>, Pick<SelectionHookResult<Item, Selection>, "selected" | "setSelected">, Partial<Omit<NavigationHookResult, "listProps">> {
+    keyboardNavigation: RefObject<boolean>;
+    listHandlers: ListHandlers;
+    listItemHeaderHandlers: Partial<ListHandlers>;
+    listControlProps: ListControlProps;
+    setHighlightedIndex: (index: number) => void;
+    setIgnoreFocus: (ignoreFocus: boolean) => void;
+}

package/dist-types/list/useList.d.ts

@@ -0,0 +1,3 @@
+import { SelectionStrategy } from "../common-hooks";
+import { ListHookProps, ListHookResult } from "./listTypes";
+export declare const useList: <Item, Selection_1 extends SelectionStrategy = "default">({ collapsibleHeaders, collectionHook: dataHook, containerRef, contentRef, defaultHighlightedIndex, defaultSelected, disabled, disableAriaActiveDescendant, disableHighlightOnFocus, disableTypeToSelect, highlightedIndex: highlightedIndexProp, label, listHandlers: listHandlersProp, onSelect, onSelectionChange, onHighlight, onKeyboardNavigation, onKeyDown, restoreLastFocus, selected, selectionStrategy, selectionKeys, stickyHeaders, tabToSelect, }: ListHookProps<Item, Selection_1>) => ListHookResult<Item, Selection_1>;

package/dist-types/list/useListHeight.d.ts

@@ -0,0 +1,15 @@
+import { RefObject } from "react";
+export interface ListHeightHookProps {
+    borderless?: boolean;
+    displayedItemCount: number;
+    getItemHeight?: (index: number) => number;
+    height?: number | string;
+    itemCount: number;
+    itemGapSize: number;
+    itemHeight?: number | string;
+    rowHeightRef: RefObject<HTMLElement | null>;
+}
+export interface HeightHookResult {
+    preferredHeight: number | undefined;
+}
+export declare const useListHeight: ({ borderless, displayedItemCount, getItemHeight, height, itemCount, itemGapSize, itemHeight: itemHeightProp, rowHeightRef, }: ListHeightHookProps) => HeightHookResult;

package/dist-types/list/useVirtualization.d.ts

@@ -0,0 +1,19 @@
+import { RefObject, UIEvent } from "react";
+import { CollectionItem } from "../common-hooks";
+/**
+ * [ item key, total height before the item, next row index, CollectionItem<Item>]
+ * e.g. first item: [0, 0, 1, data[0]]
+ */
+export declare type Row<Item> = [number, number, number, CollectionItem<Item>];
+interface VirtualizationHookProps<Item> {
+    viewportRef: RefObject<HTMLElement>;
+    data: CollectionItem<Item>[];
+    itemGapSize?: number;
+}
+interface VirtualizationHookResult<Item> {
+    rows: Row<Item>[];
+    contentHeight: number;
+    onVerticalScroll: (e: UIEvent<HTMLElement>) => void;
+}
+export declare const useVirtualization: <Item>({ viewportRef, data, itemGapSize, }: VirtualizationHookProps<Item>) => VirtualizationHookResult<Item>;
+export {};

package/dist-types/list-deprecated/List.d.ts

@@ -0,0 +1,6 @@
+import { ForwardedRef, ReactElement } from "react";
+import { ListScrollHandles } from "./ListBase";
+import { ListProps, ListSelectionVariant } from "./ListProps";
+export declare const List: <Item = string, Variant extends ListSelectionVariant = "default">(props: ListProps<Item, Variant> & {
+    ref?: ForwardedRef<ListScrollHandles<Item>> | undefined;
+}) => ReactElement<ListProps<Item, Variant>, string | import("react").JSXElementConstructor<any>>;

package/dist-types/list-deprecated/ListBase.d.ts

@@ -0,0 +1,27 @@
+import { ForwardedRef, HTMLAttributes, ReactElement, Ref } from "react";
+import { ListBaseProps } from "./ListProps";
+import "./List.css";
+export interface ListboxContextProps<Item> {
+    borderless?: boolean;
+    className?: string;
+    disabled?: boolean;
+    disableFocus?: boolean;
+    getItemId?: (index: number) => string;
+    getItemHeight?: (index?: number) => number;
+    id?: string;
+    itemToString?: (item: Item) => string;
+    listRef?: Ref<any>;
+    style?: any;
+    onScroll?: (evt: any) => void;
+}
+export interface ListboxProps extends HTMLAttributes<HTMLDivElement> {
+    onScroll?: (evt: any) => void;
+}
+export interface ListScrollHandles<Item> {
+    scrollToIndex: (itemIndex: number) => void;
+    scrollToItem: (item: Item) => void;
+    scrollTo: (scrollOffset: number) => void;
+}
+export declare const ListBase: <Item>(p: ListBaseProps<Item> & {
+    ref?: ForwardedRef<ListScrollHandles<Item>> | undefined;
+}) => ReactElement<ListBaseProps<Item>, string | import("react").JSXElementConstructor<any>>;

package/dist-types/list-deprecated/ListItem.d.ts

@@ -0,0 +1,11 @@
+import { ForwardedRef, ReactElement } from "react";
+import { ListItemBaseProps } from "./ListItemBase";
+export interface ListItemProps<Item = string> extends Omit<ListItemBaseProps, "focusVisible" | "highlighted" | "selected" | "tooltipText"> {
+    item?: Item;
+    itemToString?: (item: Item) => string;
+}
+declare type GenericListItem = <Item = string>(p: ListItemProps<Item> & {
+    ref?: ForwardedRef<HTMLDivElement>;
+}) => ReactElement<ListItemProps<Item>>;
+declare const _ListItem: GenericListItem;
+export { _ListItem as ListItem };

package/dist-types/list-deprecated/ListItemBase.d.ts

@@ -0,0 +1,12 @@
+import { HTMLAttributes } from "react";
+import "./ListItem.css";
+export interface ListItemBaseProps extends HTMLAttributes<HTMLDivElement> {
+    disabled?: boolean;
+    deselectable?: boolean;
+    focusVisible?: boolean;
+    highlighted?: boolean;
+    itemTextHighlightPattern?: RegExp | string;
+    selected?: boolean;
+    tooltipText?: string;
+}
+export declare const ListItemBase: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<ListItemBaseProps & import("react").RefAttributes<HTMLDivElement>>>;