@salt-ds/lab 0.0.0-snapshot-20230419162206

package/dist-types/tabs/useEditableItem.d.ts

@@ -0,0 +1,17 @@
+import { KeyboardEvent } from "react";
+import { OverflowItem } from "../responsive";
+export declare type ExitEditModeHandler = (originalValue: string, editedValue: string, allowDeactivation: boolean, tabIndex: number) => void;
+export interface Editable {
+    editing: boolean;
+    onEnterEditMode: () => void;
+    onExitEditMode: ExitEditModeHandler;
+    setEditing: (value: boolean) => void;
+}
+export interface EditableItemHookProps extends Partial<Editable> {
+    highlightedIdx: number;
+    indexPositions: OverflowItem[];
+}
+export interface EditableItemHookResult extends Editable {
+    onKeyDown: (evt: KeyboardEvent) => void;
+}
+export declare const useEditableItem: ({ editing: editingProp, highlightedIdx, indexPositions, onEnterEditMode: onEnterEditModeProp, onExitEditMode: onExitEditModeProp, }: EditableItemHookProps) => EditableItemHookResult;

package/dist-types/tabs/useItemsWithIds.d.ts

@@ -0,0 +1,3 @@
+import { ReactNode } from "react";
+import { TabDescriptor } from "./TabsTypes";
+export declare const useItemsWithIds: (children: ReactNode, id?: string) => [TabDescriptor[], (id: string) => TabDescriptor];

package/dist-types/tabs/useKeyboardNavigation.d.ts

@@ -0,0 +1,29 @@
+import { FocusEvent, FocusEventHandler, KeyboardEvent, MouseEvent, MouseEventHandler } from "react";
+import { OverflowItem } from "../responsive";
+declare type orientationType = "horizontal" | "vertical";
+export interface ContainerNavigationProps {
+    onBlur: FocusEventHandler;
+    onFocus: FocusEventHandler;
+    onMouseDownCapture: MouseEventHandler;
+    onMouseLeave: MouseEventHandler;
+}
+interface TabstripNavigationHookProps {
+    defaultHighlightedIdx?: number;
+    highlightedIdx?: number;
+    indexPositions: OverflowItem[];
+    keyBoardActivation?: "manual" | "automatic";
+    orientation: orientationType;
+    selectedIndex: number;
+}
+interface TabstripNavigationHookResult {
+    containerProps: ContainerNavigationProps;
+    highlightedIdx: number;
+    focusTab: (tabIndex: number, immediateFocus?: boolean, withKeyboard?: boolean) => void;
+    focusVisible: number;
+    focusIsWithinComponent: boolean;
+    onClick: (evt: MouseEvent, tabIndex: number) => void;
+    onFocus: (evt: FocusEvent<HTMLElement>) => void;
+    onKeyDown: (evt: KeyboardEvent) => void;
+}
+export declare const useKeyboardNavigation: ({ defaultHighlightedIdx, highlightedIdx: highlightedIdxProp, indexPositions, keyBoardActivation, orientation, selectedIndex: selectedTabIndex, }: TabstripNavigationHookProps) => TabstripNavigationHookResult;
+export {};

package/dist-types/tabs/useSelection.d.ts

@@ -0,0 +1,14 @@
+import { KeyboardEvent, MouseEvent } from "react";
+export declare const isTabElement: (el: HTMLElement) => boolean;
+export declare const useSelection: ({ defaultSelected, highlightedIdx, onSelectionChange, selected: selectedProp, }: {
+    defaultSelected?: number | undefined;
+    highlightedIdx: number;
+    onSelectionChange?: ((tabIndex: number) => void) | undefined;
+    selected?: number | undefined;
+}) => {
+    activateTab: (tabIndex: number) => void;
+    isControlled: boolean;
+    onClick: (evt: MouseEvent<Element>, tabIndex: number) => void;
+    onKeyDown: (evt: KeyboardEvent) => void;
+    selected: number;
+};

package/dist-types/tabs/useTabs.d.ts

@@ -0,0 +1,17 @@
+import { ReactNode } from "react";
+import { TabDescriptor } from "./TabsTypes";
+export interface TabsHookProps {
+    activeTabIndex?: number;
+    children: ReactNode;
+    defaultActiveTabIndex?: number;
+    id?: string;
+    onActiveChange?: (tabIndex: number) => void;
+}
+export interface TabsHookResult {
+    activeTabIndex?: number;
+    id: string;
+    onActiveChange?: (tabIndex: number) => void;
+    tabPanel?: ReactNode;
+    tabs: TabDescriptor[];
+}
+export declare const useTabs: ({ activeTabIndex: activeTabIndexProp, children, defaultActiveTabIndex, id: idProp, onActiveChange, }: TabsHookProps) => TabsHookResult;

package/dist-types/tabs/useTabstrip.d.ts

@@ -0,0 +1,42 @@
+import { RefObject } from "react";
+import { ContainerNavigationProps } from "./useKeyboardNavigation";
+import { dragStrategy, DragHookResult } from "./drag-drop";
+import { ExitEditModeHandler, EditableItemHookResult } from "./useEditableItem";
+import { OverflowCollectionHookResult } from "../responsive";
+import { composableTabProps, navigationProps, TabDescriptor, TabElement } from "./TabsTypes";
+interface tabstripHookProps {
+    activeTabIndex?: number;
+    allowDragDrop?: boolean | dragStrategy;
+    collectionHook: OverflowCollectionHookResult;
+    defaultActiveTabIndex?: number;
+    defaultTabs?: TabDescriptor[];
+    editing?: boolean;
+    enableAddTab: boolean;
+    idRoot: string;
+    innerContainerRef: RefObject<HTMLDivElement>;
+    keyBoardActivation?: "manual" | "automatic";
+    onActiveChange?: (tabIndex: number) => void;
+    onCloseTab?: (indexPosition: number) => void;
+    onEnterEditMode?: () => void;
+    onExitEditMode?: ExitEditModeHandler;
+    onMoveTab?: (fromIndex: number, toIndex: number) => void;
+    orientation: "horizontal" | "vertical";
+    promptForNewTabName?: boolean;
+    tabs?: TabDescriptor[] | TabElement[];
+}
+interface tabstripHookResult extends DragHookResult, Pick<EditableItemHookResult, "editing"> {
+    activateTab: (tabIndex: number) => void;
+    activeTabIndex: number;
+    addTab: (indexPosition?: number) => void;
+    closeTab: (indexPosition: number) => void;
+    containerProps: ContainerNavigationProps;
+    controlledSelection: boolean;
+    highlightedIdx: number;
+    focusVisible: number;
+    focusIsWithinComponent: boolean;
+    focusTab: (tabIndex: number, immediateFocus?: boolean) => void;
+    navigationProps: navigationProps;
+    tabProps: composableTabProps;
+}
+export declare const useTabstrip: ({ activeTabIndex: activeTabIndexProp, allowDragDrop, collectionHook, defaultActiveTabIndex, editing: editingProp, idRoot, innerContainerRef, keyBoardActivation, onActiveChange, onCloseTab, onEnterEditMode, onExitEditMode, onMoveTab, orientation, promptForNewTabName, }: tabstripHookProps) => tabstripHookResult & DragHookResult;
+export {};

package/dist-types/toggle-button/ToggleButton.d.ts

@@ -0,0 +1,13 @@
+import { ButtonProps } from "@salt-ds/core";
+import { SyntheticEvent } from "react";
+import "./ToggleButton.css";
+export declare type ToggleButtonToggleEventHandler = (event: SyntheticEvent<HTMLButtonElement>, toggled: boolean) => void;
+export interface ToggleButtonProps extends ButtonProps {
+    "aria-label"?: string;
+    "data-button-index"?: number;
+    toggled?: boolean;
+    tooltipText?: string;
+    disableTooltip?: boolean;
+    onToggle?: ToggleButtonToggleEventHandler;
+}
+export declare const ToggleButton: import("react").ForwardRefExoticComponent<ToggleButtonProps & import("react").RefAttributes<HTMLButtonElement>>;

package/dist-types/toggle-button/ToggleButtonGroup.d.ts

@@ -0,0 +1,19 @@
+import { ButtonVariant } from "@salt-ds/core";
+import { HTMLAttributes, ReactElement, SyntheticEvent } from "react";
+import { Orientation } from "./internal/ToggleButtonGroupContext";
+import "./ToggleButtonGroup.css";
+export declare type ToggleButtonGroupChangeEventHandler = (event: SyntheticEvent<HTMLButtonElement>, index: number, toggled: boolean) => void;
+export interface ToggleButtonGroupProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange"> {
+    "aria-label"?: string;
+    disabled?: boolean;
+    disableTooltip?: boolean;
+    defaultSelectedIndex?: number;
+    focusableWhenDisabled?: boolean;
+    selectedIndex?: number;
+    orientation?: Orientation;
+    variant?: ButtonVariant;
+    width?: number;
+    children: Array<ReactElement>;
+    onChange?: ToggleButtonGroupChangeEventHandler;
+}
+export declare const ToggleButtonGroup: import("react").ForwardRefExoticComponent<ToggleButtonGroupProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/toggle-button/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./ToggleButton";
+export * from "./ToggleButtonGroup";

package/dist-types/toggle-button/internal/ToggleButtonGroupContext.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="react" />
+import { ButtonVariant } from "@salt-ds/core";
+export declare type Orientation = "horizontal" | "vertical";
+export interface ToggleButtonGroupContextProps {
+    disabled?: boolean;
+    disableFocus?: boolean;
+    disableTooltip?: boolean;
+    focusableWhenDisabled?: boolean;
+    register: (node: HTMLButtonElement | null, index: number) => void;
+    unregister: (index: number) => void;
+    orientation?: Orientation;
+    variant?: ButtonVariant;
+}
+export declare const ToggleButtonGroupContext: import("react").Context<ToggleButtonGroupContextProps | undefined>;

package/dist-types/tokenized-input/TokenizedInput.d.ts

@@ -0,0 +1,20 @@
+import { UseTooltipProps } from "@salt-ds/core";
+import { ComponentType } from "react";
+import { TokenizedInputBaseProps } from "./TokenizedInputBase";
+import "./TokenizedInput.css";
+export declare type StringToItem<Item> = (selectedItems: Array<Item>, value: string) => Item | null | undefined;
+export declare type ChangeHandler<Item> = (selectedItems: Item[] | undefined) => void;
+export interface TokenizedInputProps<Item> extends Omit<TokenizedInputBaseProps<Item>, "activeIndices" | "focused" | "highlightedIndex" | "helpers" | "onRemoveItem"> {
+    Tooltip?: ComponentType;
+    delimiter?: string | Array<string>;
+    disableAddOnBlur?: boolean;
+    initialSelectedItems?: Array<Item>;
+    onChange?: ChangeHandler<Item>;
+    onCollapse?: () => void;
+    onExpand?: () => void;
+    stringToItem?: StringToItem<Item>;
+    tooltipEnterDelay?: UseTooltipProps["enterDelay"];
+    tooltipLeaveDelay?: UseTooltipProps["leaveDelay"];
+    tooltipPlacement?: UseTooltipProps["placement"];
+}
+export declare const TokenizedInput: import("react").ForwardRefExoticComponent<TokenizedInputProps<unknown> & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/tokenized-input/TokenizedInputBase.d.ts

@@ -0,0 +1,32 @@
+import { ChangeEventHandler, FocusEventHandler, ForwardedRef, HTMLAttributes, KeyboardEventHandler, ReactElement, ReactEventHandler, Ref, SyntheticEvent } from "react";
+import { ButtonProps } from "@salt-ds/core";
+import { TokenizedInputHelpers, TokenizedInputState } from "./useTokenizedInput";
+import { InputProps } from "../input";
+export declare type RemoveItemHandler = (itemIndex: number) => void;
+export declare type ItemToString<Item> = (item: Item) => string;
+export declare type ExpandButtonProps = Pick<ButtonProps, "role" | "aria-roledescription" | "aria-describedby"> & {
+    accessibleText?: string;
+};
+export interface TokenizedInputBaseProps<Item> extends Partial<TokenizedInputState<Item>>, Omit<HTMLAttributes<HTMLDivElement>, "onFocus" | "onBlur" | "onChange" | "onKeyUp" | "onKeyDown"> {
+    ExpandButtonProps?: ExpandButtonProps;
+    InputProps?: Pick<InputProps, "aria-describedby" | "inputProps">;
+    disabled?: boolean;
+    expandButtonRef?: Ref<HTMLButtonElement>;
+    helpers: TokenizedInputHelpers<Item>;
+    inputRef?: Ref<HTMLInputElement>;
+    itemToString?: ItemToString<Item>;
+    onFocus?: FocusEventHandler<HTMLInputElement | HTMLButtonElement>;
+    onBlur?: FocusEventHandler<HTMLInputElement | HTMLButtonElement>;
+    onKeyUp?: KeyboardEventHandler<HTMLInputElement>;
+    onKeyDown?: KeyboardEventHandler<HTMLInputElement | HTMLButtonElement>;
+    onRemoveItem?: RemoveItemHandler;
+    onInputBlur?: FocusEventHandler<HTMLInputElement>;
+    onInputFocus?: FocusEventHandler<HTMLInputElement>;
+    onInputChange?: ChangeEventHandler<HTMLInputElement>;
+    onInputSelect?: ReactEventHandler<HTMLInputElement>;
+    onClick?: (event: SyntheticEvent<HTMLElement>) => void;
+    onClear?: ReactEventHandler;
+}
+export declare const TokenizedInputBase: <Item>(p: TokenizedInputBaseProps<Item> & {
+    ref?: ForwardedRef<HTMLDivElement> | undefined;
+}) => ReactElement<TokenizedInputBaseProps<Item>, string | import("react").JSXElementConstructor<any>>;

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

@@ -0,0 +1,3 @@
+export * from "./TokenizedInput";
+export * from "./TokenizedInputBase";
+export * from "./useTokenizedInput";

package/dist-types/tokenized-input/internal/InputPill.d.ts

@@ -0,0 +1,31 @@
+import { MutableRefObject } from "react";
+import { PillProps } from "../../pill";
+export declare type InputPillProps = Omit<PillProps<"basic" | "closable">, "variant" | "onDelete" | "clickable"> & {
+    /**
+     * An ref object holds pills index map to width.
+     */
+    pillsRef: MutableRefObject<{
+        [index: number]: number | undefined;
+    }>;
+    /**
+     * Index of the pill within Input.
+     */
+    index: number;
+    /**
+     * Whether the pill is the last visible one within Input.
+     */
+    lastVisible?: boolean;
+    /**
+     * Whether the pill is highlighted.
+     */
+    highlighted?: boolean;
+    /**
+     * Whether the pill is active.
+     */
+    active?: boolean;
+    /**
+     * Callback when pill is deleted.
+     */
+    onDelete?: (index: number) => void;
+};
+export declare const InputPill: import("react").NamedExoticComponent<InputPillProps>;

package/dist-types/tokenized-input/internal/InputRuler.d.ts

@@ -0,0 +1,9 @@
+import { InputHTMLAttributes } from "react";
+import "./InputRuler.css";
+/**
+ * This hidden component is used to wrap a copy of an input value
+ * so that we can use it to determine the input width dynamically
+ */
+export declare const InputRuler: import("react").ForwardRefExoticComponent<{
+    value: InputHTMLAttributes<HTMLInputElement>["value"];
+} & import("react").RefAttributes<HTMLSpanElement>>;

package/dist-types/tokenized-input/internal/calcFirstHiddenIndex.d.ts

@@ -0,0 +1,4 @@
+export declare function calcFirstHiddenIndex({ containerWidth, pillWidths, }?: {
+    containerWidth?: number;
+    pillWidths?: number[];
+}): number | null;

package/dist-types/tokenized-input/internal/defaultItemToString.d.ts

@@ -0,0 +1 @@
+export declare const defaultItemToString: (item: any) => string;

package/dist-types/tokenized-input/internal/getCursorPosition.d.ts

@@ -0,0 +1,2 @@
+import { MutableRefObject } from "react";
+export declare const getCursorPosition: (inputRef: MutableRefObject<HTMLInputElement | null>) => number;

package/dist-types/tokenized-input/internal/isPlainObject.d.ts

@@ -0,0 +1,4 @@
+export declare type PlainObject = {
+    [name: string]: any;
+};
+export declare const isPlainObject: (obj: any) => obj is PlainObject;

package/dist-types/tokenized-input/internal/useResizeObserver.d.ts

@@ -0,0 +1,6 @@
+import { Ref } from "react";
+/**
+ * This monitors the size of a component and calls `onSizeChange` callback
+ * every time when size changes.
+ */
+export declare function useResizeObserver<Element extends HTMLElement>(onSizeChange: (entries: ResizeObserverEntry[], observer?: ResizeObserver) => void): Ref<Element>;

package/dist-types/tokenized-input/internal/useWidth.d.ts

@@ -0,0 +1,6 @@
+import { Density } from "@salt-ds/core";
+export declare const getWidth: (node: HTMLElement | null) => number;
+/**
+ * This records the width of a component when it's rendered
+ */
+export declare const useWidth: (density: Density) => [(newNode: any) => void, number];

package/dist-types/tokenized-input/useTokenizedInput.d.ts

@@ -0,0 +1,39 @@
+import { Ref } from "react";
+import { TokenizedInputProps } from "./TokenizedInput";
+import { TokenizedInputBaseProps } from "./TokenizedInputBase";
+export interface TokenizedInputState<Item> {
+    activeIndices: Array<number>;
+    expanded: boolean | undefined;
+    focused: boolean;
+    highlightedIndex: number | undefined;
+    selectedItems: Array<Item>;
+    value: string | undefined;
+}
+export interface TokenizedInputHelpers<Item> {
+    cancelBlur: () => void;
+    setFocused: (expanded: boolean) => void;
+    setHighlightedIndex: (value?: number) => void;
+    setValue: (value: string) => void;
+    setSelectedItems: (selectedItems: Array<Item>) => void;
+    updateExpanded: (expanded: boolean) => void;
+}
+declare type useTokenizedInputResult<Item> = {
+    /**
+     * Used to do auto focus. It should be set to the actual input node.
+     */
+    inputRef: Ref<HTMLInputElement>;
+    /**
+     * The tokenized input state
+     */
+    state: TokenizedInputState<Item>;
+    /**
+     * Utility functions for modifying tokenized input state
+     */
+    helpers: TokenizedInputHelpers<Item>;
+    /**
+     * Properties applied to a basic tokenized input component
+     */
+    inputProps: Omit<TokenizedInputBaseProps<Item>, "helpers">;
+};
+export declare function useTokenizedInput<Item>(props: TokenizedInputProps<Item>): useTokenizedInputResult<Item>;
+export {};

package/dist-types/toolbar/Toolbar.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import { ToolbarProps } from "./ToolbarProps";
+import "./Toolbar.css";
+/**
+ * The core Toolbar implementation, without the external wrapper provided by Toolbar.js
+ */
+export declare const Toolbar: import("react").ForwardRefExoticComponent<ToolbarProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/toolbar/ToolbarButton.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import { ButtonProps } from "@salt-ds/core";
+import "./ToolbarButton.css";
+export declare type ToolbarButtonProps = ButtonProps & {
+    overflowLabel?: string;
+    label?: string;
+};
+export declare const ToolbarButton: import("react").ForwardRefExoticComponent<ButtonProps & {
+    overflowLabel?: string | undefined;
+    label?: string | undefined;
+} & import("react").RefAttributes<HTMLButtonElement>>;

package/dist-types/toolbar/ToolbarProps.d.ts

@@ -0,0 +1,45 @@
+import { TooltipProps } from "@salt-ds/core";
+import { ComponentType, HTMLAttributes, ReactNode } from "react";
+export declare type OrientationShape = "vertical" | "horizontal";
+export interface ToolbarAlignmentProps {
+    alignCenter?: true | undefined;
+    alignEnd?: true | undefined;
+    alignStart?: true | undefined;
+}
+export interface ToolbarProps extends HTMLAttributes<HTMLDivElement> {
+    /**
+     * Used by custom elements to render a custom tooltip
+     */
+    TooltipComponent?: ComponentType<Partial<TooltipProps>>;
+    /**
+     * The content of the component.
+     */
+    children?: ReactNode;
+    /**
+     * Disable all toolbar items
+     */
+    disabled?: boolean;
+    /**
+     * The orientation of the component
+     */
+    orientation?: OrientationShape;
+    /**
+     * Overflow menu icon
+     */
+    overflowButtonIcon?: JSX.Element;
+    /**
+     * Text to display next to overflow menu icon
+     */
+    overflowButtonLabel?: string;
+    /**
+     * Placement of the Overflow, default is 'end'
+     */
+    overflowButtonPlacement?: "start" | "end";
+    /**
+     * If `true`, toolbar will adapt to the size of its container. It adds and removes toolbar buttons
+     * from the overflow menu automatically as the size of the container changes.
+     *
+     * The default is `true`. Set it to `false` to revert back to non-responsive version.
+     */
+    responsive?: boolean;
+}

package/dist-types/toolbar/Tooltray.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { TooltrayProps } from "./TooltrayProps";
+import "./Tooltray.css";
+export declare const Tooltray: (props: TooltrayProps) => JSX.Element;

package/dist-types/toolbar/TooltrayProps.d.ts

@@ -0,0 +1,17 @@
+import { HTMLAttributes } from "react";
+import { OrientationShape, ToolbarAlignmentProps } from "./ToolbarProps";
+declare type collapsibleType = "dynamic" | "instant";
+declare type booleanAttribute = "true" | "false";
+export interface TooltrayProps extends ToolbarAlignmentProps, HTMLAttributes<HTMLDivElement> {
+    collapse?: boolean;
+    collapsed?: boolean;
+    collapsible?: boolean;
+    disabled?: boolean;
+    "data-collapsible"?: collapsibleType;
+    "data-collapsed"?: booleanAttribute;
+    isInsidePanel?: boolean;
+    overflowButtonIcon?: JSX.Element;
+    overflowButtonLabel?: string;
+    orientation?: OrientationShape;
+}
+export {};

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

@@ -0,0 +1,6 @@
+export * from "./Toolbar";
+export * from "./Tooltray";
+export * from "./ToolbarButton";
+export * from "./ToolbarProps";
+export * from "./TooltrayProps";
+export * from "./toolbar-field";

package/dist-types/toolbar/internal/ToolbarButtonRefsContext.d.ts

@@ -0,0 +1,6 @@
+import { RefObject } from "react";
+declare type refsMap<T> = {
+    [key: string]: RefObject<T>;
+};
+declare const _default: import("react").Context<refsMap<HTMLButtonElement>>;
+export default _default;

package/dist-types/toolbar/internal/ToolbarHiddenItemIdsContext.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare const _default: import("react").Context<{}>;
+export default _default;

package/dist-types/toolbar/internal/renderToolbarItems.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { orientationType, OverflowCollectionHookResult, OverflowItem } from "../../responsive";
+export declare const renderToolbarItems: (collectionHook: OverflowCollectionHookResult, overflowedItems: OverflowItem<"child">[] | undefined, orientation: orientationType) => JSX.Element[];

package/dist-types/toolbar/internal/renderTrayTools.d.ts

@@ -0,0 +1,4 @@
+import { ReactNode } from "react";
+import { OverflowCollectionHookResult, OverflowItem } from "../../responsive/overflowTypes";
+import { OrientationShape } from "../ToolbarProps";
+export declare const renderTrayTools: (collectionHook: OverflowCollectionHookResult, overflowedItems: OverflowItem[], orientation: OrientationShape, collapsed?: string | boolean | undefined) => ReactNode;

package/dist-types/toolbar/overflow-panel/OverflowPanel.d.ts

@@ -0,0 +1,14 @@
+import React from "react";
+import { DropdownBaseProps } from "../../dropdown";
+import "./OverflowPanel.css";
+export interface DropdownPanelProps extends DropdownBaseProps {
+    /**
+     * Trigger button icon
+     */
+    triggerButtonIcon?: JSX.Element;
+    /**
+     * Trigger button text
+     */
+    triggerButtonLabel?: string;
+}
+export declare const OverflowPanel: React.ForwardRefExoticComponent<DropdownPanelProps & React.RefAttributes<HTMLDivElement>>;

package/dist-types/toolbar/overflow-panel/OverflowSeparator.d.ts

@@ -0,0 +1,12 @@
+import { HTMLAttributes, ReactElement } from "react";
+import "./OverflowSeparator.css";
+export interface OverflowSeparatorProps extends HTMLAttributes<HTMLDivElement> {
+    children?: never;
+    focusable?: boolean;
+}
+export declare const OverflowSeparator: {
+    (props: OverflowSeparatorProps): ReactElement;
+    defaultProps: {
+        focusable: boolean;
+    };
+};

package/dist-types/toolbar/toolbar-field/ToolbarField.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { ToolbarFieldProps } from "./toolbarFieldTypes";
+export declare const ToolbarField: import("react").ForwardRefExoticComponent<ToolbarFieldProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/toolbar/toolbar-field/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./ToolbarField";
+export * from "./toolbarFieldTypes";

package/dist-types/toolbar/toolbar-field/toolbarFieldTypes.d.ts

@@ -0,0 +1,4 @@
+import { FormFieldProps } from "../../form-field";
+export interface ToolbarFieldProps extends FormFieldProps {
+    inOverflowPanel?: undefined | true;
+}

package/dist-types/toolbar/toolbar-field/useToolbarField.d.ts

@@ -0,0 +1,4 @@
+import { ReactNode } from "react";
+import { ToolbarFieldProps } from "./toolbarFieldTypes";
+export declare const getToolbarFormFieldProps: (child: ReactNode, isOverflowPanel?: boolean) => ToolbarFieldProps;
+export declare const useToolbarField: (props: ToolbarFieldProps) => ToolbarFieldProps;

package/dist-types/tree/Tree.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import { SelectionStrategy } from "../common-hooks";
+import { TreeProps } from "./treeTypes";
+import "./Tree.css";
+export declare const Tree: import("react").ForwardRefExoticComponent<TreeProps<unknown, SelectionStrategy> & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/tree/TreeNode.d.ts

@@ -0,0 +1,13 @@
+import { HTMLAttributes, MouseEventHandler, ReactNode } from "react";
+import "./TreeNode.css";
+export interface TreeNodeProps extends Omit<HTMLAttributes<HTMLLIElement>, "onMouseEnter"> {
+    children?: ReactNode;
+    description?: string;
+    highlighted?: boolean;
+    idx?: number;
+    isLeaf?: boolean;
+    label?: string;
+    onMouseEnter?: MouseEventHandler;
+    selected?: boolean;
+}
+export declare const TreeNode: ({ "aria-level": ariaLevel, children, className: classNameProp, description, highlighted, idx, isLeaf, label, onMouseEnter, selected, ...props }: TreeNodeProps) => JSX.Element;

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

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

package/dist-types/tree/treeTypes.d.ts

@@ -0,0 +1,42 @@
+import { HTMLAttributes, RefObject } from "react";
+import { CollectionHookResult, CollectionItem, ListHandlers, SelectionHookResult, SelectionProps, SelectionStrategy } from "../common-hooks";
+import { ListControlProps } from "../list/listTypes";
+export interface TreeNode {
+    checked?: boolean;
+    childNodes?: TreeNode[];
+    description?: string;
+    expanded?: boolean;
+    icon?: string;
+    iconSize?: number;
+    id: string;
+    indeterminate?: boolean;
+    name?: string;
+    selected?: boolean;
+}
+export interface TreeProps<T, Selection extends SelectionStrategy> extends SelectionProps<T, Selection>, Omit<HTMLAttributes<HTMLDivElement>, "onSelect"> {
+    disabled?: boolean;
+    groupSelection?: string;
+    height?: number;
+    onHighlight?: () => void;
+    onToggle?: (node: T) => void;
+    revealSelected?: boolean;
+    source?: T[];
+    width?: number;
+}
+export interface TreeHookProps<Item, Selection extends SelectionStrategy> extends SelectionProps<CollectionItem<Item>, Selection> {
+    collectionHook: CollectionHookResult<Item>;
+    containerRef: RefObject<HTMLElement>;
+    contentRef?: RefObject<HTMLElement>;
+    disabled?: boolean;
+    groupSelection?: string;
+    onHighlight?: (index: number) => void;
+    onToggle?: (node: Item) => void;
+}
+export interface TreeHookResult<Item, Selection extends SelectionStrategy> extends Pick<SelectionHookResult<Item, Selection>, "selected" | "setSelected"> {
+    focusVisible: number;
+    highlightedIdx: number;
+    highlightItemAtIndex: (index: number) => void;
+    listHandlers: ListHandlers;
+    listProps: ListControlProps;
+    listItemHandlers: Pick<ListHandlers, "onClick">;
+}

package/dist-types/tree/use-tree-keyboard-navigation.d.ts

@@ -0,0 +1,15 @@
+import { KeyboardEvent } from "react";
+import { CollectionItem, CollectionHookResult } from "../common-hooks";
+export declare const getNodeParentPath: ({ id }: CollectionItem<any>) => string | null | undefined;
+interface TreeNavigationHookProps<Item> {
+    collectionHook: CollectionHookResult<Item>;
+    highlightedIdx: number;
+    highlightItemAtIndex: (index: number) => void;
+}
+interface TreeNavigationHookResult {
+    listHandlers: {
+        onKeyDown: (evt: KeyboardEvent) => void;
+    };
+}
+export declare const useKeyboardNavigation: <Item>({ collectionHook, highlightedIdx, highlightItemAtIndex, }: TreeNavigationHookProps<Item>) => TreeNavigationHookResult;
+export {};

package/dist-types/tree/useTree.d.ts

@@ -0,0 +1,3 @@
+import { SelectionStrategy } from "../common-hooks";
+import { TreeHookProps, TreeHookResult } from "./treeTypes";
+export declare const useTree: <Item, Selection_1 extends SelectionStrategy = "default">({ collectionHook, containerRef, contentRef, defaultSelected, disabled, groupSelection, onSelect, onSelectionChange, onToggle, onHighlight: onHighlightProp, selected: selectedProp, selectionStrategy, }: TreeHookProps<Item, Selection_1>) => TreeHookResult<Item, Selection_1>;

package/dist-types/utils/escapeRegExp.d.ts

@@ -0,0 +1 @@
+export declare function escapeRegExp(string: string): string;