@vuu-ui/vuu-ui-controls 0.0.26

package/types/split-button/SplitButton.d.ts

@@ -0,0 +1,11 @@
+import { PopupMenuProps } from "@vuu-ui/vuu-popups";
+import { ButtonProps } from "@salt-ds/core";
+import { HTMLAttributes } from "react";
+export interface SplitButtonProps extends Omit<HTMLAttributes<HTMLDivElement>, "onClick">, Pick<ButtonProps, "onClick"> {
+    ButtonProps?: Partial<Omit<ButtonProps, "onClick" | "variant">>;
+    PopupMenuProps?: Partial<PopupMenuProps>;
+    disabled?: boolean;
+    segmented?: boolean;
+    variant?: ButtonProps["variant"];
+}
+export declare const SplitButton: import("react").ForwardRefExoticComponent<SplitButtonProps & import("react").RefAttributes<HTMLDivElement>>;

package/types/split-button/SplitStateButton.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import { SplitButtonProps } from "./SplitButton";
+export interface SplitStateButtonProps extends SplitButtonProps {
+    selected: boolean;
+}
+export declare const SplitStateButton: import("react").ForwardRefExoticComponent<SplitStateButtonProps & import("react").RefAttributes<HTMLDivElement>>;

package/types/split-button/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./SplitButton";
+export * from "./SplitStateButton";

package/types/split-button/useSplitButton.d.ts

@@ -0,0 +1,288 @@
+import { PopupMenuProps } from "@vuu-ui/vuu-popups";
+import { FocusEventHandler, KeyboardEventHandler } from "react";
+import { SplitButtonProps } from "./SplitButton";
+export interface SplitButtonHookProps extends Pick<SplitButtonProps, "PopupMenuProps" | "ButtonProps" | "onClick" | "segmented"> {
+    classBase: string;
+}
+export declare const useSplitButton: ({ ButtonProps: ButtonPropsProp, PopupMenuProps, classBase, onClick, }: SplitButtonHookProps) => {
+    ButtonProps: {
+        onClick: import("react").MouseEventHandler<HTMLButtonElement> | undefined;
+        onKeyDown: KeyboardEventHandler<HTMLButtonElement>;
+        type?: "button" | "reset" | "submit" | undefined;
+        value?: string | number | readonly string[] | undefined;
+        children?: import("react").ReactNode;
+        title?: string | undefined;
+        defaultChecked?: boolean | undefined;
+        defaultValue?: string | number | readonly string[] | undefined;
+        suppressContentEditableWarning?: boolean | undefined;
+        suppressHydrationWarning?: boolean | undefined;
+        accessKey?: string | undefined;
+        autoFocus?: boolean | undefined;
+        className?: string | undefined;
+        contentEditable?: (boolean | "true" | "false") | "inherit" | undefined;
+        contextMenu?: string | undefined;
+        dir?: string | undefined;
+        draggable?: (boolean | "true" | "false") | undefined;
+        hidden?: boolean | undefined;
+        id?: string | undefined;
+        lang?: string | undefined;
+        nonce?: string | undefined;
+        placeholder?: string | undefined;
+        slot?: string | undefined;
+        spellCheck?: (boolean | "true" | "false") | undefined;
+        style?: import("react").CSSProperties | undefined;
+        tabIndex?: number | undefined;
+        translate?: "yes" | "no" | undefined;
+        radioGroup?: string | undefined;
+        role?: import("react").AriaRole | undefined;
+        about?: string | undefined;
+        content?: string | undefined;
+        datatype?: string | undefined;
+        inlist?: any;
+        prefix?: string | undefined;
+        property?: string | undefined;
+        rel?: string | undefined;
+        resource?: string | undefined;
+        rev?: string | undefined;
+        typeof?: string | undefined;
+        vocab?: string | undefined;
+        autoCapitalize?: string | undefined;
+        autoCorrect?: string | undefined;
+        autoSave?: string | undefined;
+        color?: string | undefined;
+        itemProp?: string | undefined;
+        itemScope?: boolean | undefined;
+        itemType?: string | undefined;
+        itemID?: string | undefined;
+        itemRef?: string | undefined;
+        results?: number | undefined;
+        security?: string | undefined;
+        unselectable?: "on" | "off" | undefined;
+        inputMode?: "search" | "text" | "none" | "tel" | "url" | "email" | "numeric" | "decimal" | undefined;
+        is?: string | undefined;
+        'aria-activedescendant'?: string | undefined;
+        'aria-atomic'?: (boolean | "true" | "false") | undefined;
+        'aria-autocomplete'?: "list" | "none" | "inline" | "both" | undefined;
+        'aria-busy'?: (boolean | "true" | "false") | undefined;
+        'aria-checked'?: boolean | "true" | "false" | "mixed" | undefined;
+        'aria-colcount'?: number | undefined;
+        'aria-colindex'?: number | undefined;
+        'aria-colspan'?: number | undefined;
+        'aria-controls'?: string | undefined;
+        'aria-current'?: boolean | "date" | "true" | "time" | "false" | "step" | "page" | "location" | undefined;
+        'aria-describedby'?: string | undefined;
+        'aria-details'?: string | undefined;
+        'aria-disabled'?: (boolean | "true" | "false") | undefined;
+        'aria-dropeffect'?: "copy" | "link" | "none" | "execute" | "move" | "popup" | undefined;
+        'aria-errormessage'?: string | undefined;
+        'aria-expanded'?: (boolean | "true" | "false") | undefined;
+        'aria-flowto'?: string | undefined;
+        'aria-grabbed'?: (boolean | "true" | "false") | undefined;
+        'aria-haspopup'?: boolean | "true" | "dialog" | "menu" | "false" | "grid" | "listbox" | "tree" | undefined;
+        'aria-hidden'?: (boolean | "true" | "false") | undefined;
+        'aria-invalid'?: boolean | "true" | "false" | "grammar" | "spelling" | undefined;
+        'aria-keyshortcuts'?: string | undefined;
+        'aria-label'?: string | undefined;
+        'aria-labelledby'?: string | undefined;
+        'aria-level'?: number | undefined;
+        'aria-live'?: "off" | "assertive" | "polite" | undefined;
+        'aria-modal'?: (boolean | "true" | "false") | undefined;
+        'aria-multiline'?: (boolean | "true" | "false") | undefined;
+        'aria-multiselectable'?: (boolean | "true" | "false") | undefined;
+        'aria-orientation'?: "vertical" | "horizontal" | undefined;
+        'aria-owns'?: string | undefined;
+        'aria-placeholder'?: string | undefined;
+        'aria-posinset'?: number | undefined;
+        'aria-pressed'?: boolean | "true" | "false" | "mixed" | undefined;
+        'aria-readonly'?: (boolean | "true" | "false") | undefined;
+        'aria-relevant'?: "text" | "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text additions" | "text removals" | undefined;
+        'aria-required'?: (boolean | "true" | "false") | undefined;
+        'aria-roledescription'?: string | undefined;
+        'aria-rowcount'?: number | undefined;
+        'aria-rowindex'?: number | undefined;
+        'aria-rowspan'?: number | undefined;
+        'aria-selected'?: (boolean | "true" | "false") | undefined;
+        'aria-setsize'?: number | undefined;
+        'aria-sort'?: "none" | "ascending" | "descending" | "other" | undefined;
+        'aria-valuemax'?: number | undefined;
+        'aria-valuemin'?: number | undefined;
+        'aria-valuenow'?: number | undefined;
+        'aria-valuetext'?: string | undefined;
+        dangerouslySetInnerHTML?: {
+            __html: string | TrustedHTML;
+        } | undefined;
+        onCopy?: import("react").ClipboardEventHandler<HTMLButtonElement> | undefined;
+        onCopyCapture?: import("react").ClipboardEventHandler<HTMLButtonElement> | undefined;
+        onCut?: import("react").ClipboardEventHandler<HTMLButtonElement> | undefined;
+        onCutCapture?: import("react").ClipboardEventHandler<HTMLButtonElement> | undefined;
+        onPaste?: import("react").ClipboardEventHandler<HTMLButtonElement> | undefined;
+        onPasteCapture?: import("react").ClipboardEventHandler<HTMLButtonElement> | undefined;
+        onCompositionEnd?: import("react").CompositionEventHandler<HTMLButtonElement> | undefined;
+        onCompositionEndCapture?: import("react").CompositionEventHandler<HTMLButtonElement> | undefined;
+        onCompositionStart?: import("react").CompositionEventHandler<HTMLButtonElement> | undefined;
+        onCompositionStartCapture?: import("react").CompositionEventHandler<HTMLButtonElement> | undefined;
+        onCompositionUpdate?: import("react").CompositionEventHandler<HTMLButtonElement> | undefined;
+        onCompositionUpdateCapture?: import("react").CompositionEventHandler<HTMLButtonElement> | undefined;
+        onFocus?: FocusEventHandler<HTMLButtonElement> | undefined;
+        onFocusCapture?: FocusEventHandler<HTMLButtonElement> | undefined;
+        onBlur?: FocusEventHandler<HTMLButtonElement> | undefined;
+        onBlurCapture?: FocusEventHandler<HTMLButtonElement> | undefined;
+        onChange?: import("react").FormEventHandler<HTMLButtonElement> | undefined;
+        onChangeCapture?: import("react").FormEventHandler<HTMLButtonElement> | undefined;
+        onBeforeInput?: import("react").FormEventHandler<HTMLButtonElement> | undefined;
+        onBeforeInputCapture?: import("react").FormEventHandler<HTMLButtonElement> | undefined;
+        onInput?: import("react").FormEventHandler<HTMLButtonElement> | undefined;
+        onInputCapture?: import("react").FormEventHandler<HTMLButtonElement> | undefined;
+        onReset?: import("react").FormEventHandler<HTMLButtonElement> | undefined;
+        onResetCapture?: import("react").FormEventHandler<HTMLButtonElement> | undefined;
+        onSubmit?: import("react").FormEventHandler<HTMLButtonElement> | undefined;
+        onSubmitCapture?: import("react").FormEventHandler<HTMLButtonElement> | undefined;
+        onInvalid?: import("react").FormEventHandler<HTMLButtonElement> | undefined;
+        onInvalidCapture?: import("react").FormEventHandler<HTMLButtonElement> | undefined;
+        onLoad?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onLoadCapture?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onError?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onErrorCapture?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onKeyDownCapture?: KeyboardEventHandler<HTMLButtonElement> | undefined;
+        onKeyPress?: KeyboardEventHandler<HTMLButtonElement> | undefined;
+        onKeyPressCapture?: KeyboardEventHandler<HTMLButtonElement> | undefined;
+        onKeyUp?: KeyboardEventHandler<HTMLButtonElement> | undefined;
+        onKeyUpCapture?: KeyboardEventHandler<HTMLButtonElement> | undefined;
+        onAbort?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onAbortCapture?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onCanPlay?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onCanPlayCapture?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onCanPlayThrough?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onCanPlayThroughCapture?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onDurationChange?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onDurationChangeCapture?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onEmptied?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onEmptiedCapture?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onEncrypted?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onEncryptedCapture?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onEnded?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onEndedCapture?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onLoadedData?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onLoadedDataCapture?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onLoadedMetadata?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onLoadedMetadataCapture?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onLoadStart?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onLoadStartCapture?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onPause?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onPauseCapture?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onPlay?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onPlayCapture?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onPlaying?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onPlayingCapture?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onProgress?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onProgressCapture?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onRateChange?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onRateChangeCapture?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onSeeked?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onSeekedCapture?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onSeeking?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onSeekingCapture?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onStalled?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onStalledCapture?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onSuspend?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onSuspendCapture?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onTimeUpdate?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onTimeUpdateCapture?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onVolumeChange?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onVolumeChangeCapture?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onWaiting?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onWaitingCapture?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onAuxClick?: import("react").MouseEventHandler<HTMLButtonElement> | undefined;
+        onAuxClickCapture?: import("react").MouseEventHandler<HTMLButtonElement> | undefined;
+        onClickCapture?: import("react").MouseEventHandler<HTMLButtonElement> | undefined;
+        onContextMenu?: import("react").MouseEventHandler<HTMLButtonElement> | undefined;
+        onContextMenuCapture?: import("react").MouseEventHandler<HTMLButtonElement> | undefined;
+        onDoubleClick?: import("react").MouseEventHandler<HTMLButtonElement> | undefined;
+        onDoubleClickCapture?: import("react").MouseEventHandler<HTMLButtonElement> | undefined;
+        onDrag?: import("react").DragEventHandler<HTMLButtonElement> | undefined;
+        onDragCapture?: import("react").DragEventHandler<HTMLButtonElement> | undefined;
+        onDragEnd?: import("react").DragEventHandler<HTMLButtonElement> | undefined;
+        onDragEndCapture?: import("react").DragEventHandler<HTMLButtonElement> | undefined;
+        onDragEnter?: import("react").DragEventHandler<HTMLButtonElement> | undefined;
+        onDragEnterCapture?: import("react").DragEventHandler<HTMLButtonElement> | undefined;
+        onDragExit?: import("react").DragEventHandler<HTMLButtonElement> | undefined;
+        onDragExitCapture?: import("react").DragEventHandler<HTMLButtonElement> | undefined;
+        onDragLeave?: import("react").DragEventHandler<HTMLButtonElement> | undefined;
+        onDragLeaveCapture?: import("react").DragEventHandler<HTMLButtonElement> | undefined;
+        onDragOver?: import("react").DragEventHandler<HTMLButtonElement> | undefined;
+        onDragOverCapture?: import("react").DragEventHandler<HTMLButtonElement> | undefined;
+        onDragStart?: import("react").DragEventHandler<HTMLButtonElement> | undefined;
+        onDragStartCapture?: import("react").DragEventHandler<HTMLButtonElement> | undefined;
+        onDrop?: import("react").DragEventHandler<HTMLButtonElement> | undefined;
+        onDropCapture?: import("react").DragEventHandler<HTMLButtonElement> | undefined;
+        onMouseDown?: import("react").MouseEventHandler<HTMLButtonElement> | undefined;
+        onMouseDownCapture?: import("react").MouseEventHandler<HTMLButtonElement> | undefined;
+        onMouseEnter?: import("react").MouseEventHandler<HTMLButtonElement> | undefined;
+        onMouseLeave?: import("react").MouseEventHandler<HTMLButtonElement> | undefined;
+        onMouseMove?: import("react").MouseEventHandler<HTMLButtonElement> | undefined;
+        onMouseMoveCapture?: import("react").MouseEventHandler<HTMLButtonElement> | undefined;
+        onMouseOut?: import("react").MouseEventHandler<HTMLButtonElement> | undefined;
+        onMouseOutCapture?: import("react").MouseEventHandler<HTMLButtonElement> | undefined;
+        onMouseOver?: import("react").MouseEventHandler<HTMLButtonElement> | undefined;
+        onMouseOverCapture?: import("react").MouseEventHandler<HTMLButtonElement> | undefined;
+        onMouseUp?: import("react").MouseEventHandler<HTMLButtonElement> | undefined;
+        onMouseUpCapture?: import("react").MouseEventHandler<HTMLButtonElement> | undefined;
+        onSelect?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onSelectCapture?: import("react").ReactEventHandler<HTMLButtonElement> | undefined;
+        onTouchCancel?: import("react").TouchEventHandler<HTMLButtonElement> | undefined;
+        onTouchCancelCapture?: import("react").TouchEventHandler<HTMLButtonElement> | undefined;
+        onTouchEnd?: import("react").TouchEventHandler<HTMLButtonElement> | undefined;
+        onTouchEndCapture?: import("react").TouchEventHandler<HTMLButtonElement> | undefined;
+        onTouchMove?: import("react").TouchEventHandler<HTMLButtonElement> | undefined;
+        onTouchMoveCapture?: import("react").TouchEventHandler<HTMLButtonElement> | undefined;
+        onTouchStart?: import("react").TouchEventHandler<HTMLButtonElement> | undefined;
+        onTouchStartCapture?: import("react").TouchEventHandler<HTMLButtonElement> | undefined;
+        onPointerDown?: import("react").PointerEventHandler<HTMLButtonElement> | undefined;
+        onPointerDownCapture?: import("react").PointerEventHandler<HTMLButtonElement> | undefined;
+        onPointerMove?: import("react").PointerEventHandler<HTMLButtonElement> | undefined;
+        onPointerMoveCapture?: import("react").PointerEventHandler<HTMLButtonElement> | undefined;
+        onPointerUp?: import("react").PointerEventHandler<HTMLButtonElement> | undefined;
+        onPointerUpCapture?: import("react").PointerEventHandler<HTMLButtonElement> | undefined;
+        onPointerCancel?: import("react").PointerEventHandler<HTMLButtonElement> | undefined;
+        onPointerCancelCapture?: import("react").PointerEventHandler<HTMLButtonElement> | undefined;
+        onPointerEnter?: import("react").PointerEventHandler<HTMLButtonElement> | undefined;
+        onPointerEnterCapture?: import("react").PointerEventHandler<HTMLButtonElement> | undefined;
+        onPointerLeave?: import("react").PointerEventHandler<HTMLButtonElement> | undefined;
+        onPointerLeaveCapture?: import("react").PointerEventHandler<HTMLButtonElement> | undefined;
+        onPointerOver?: import("react").PointerEventHandler<HTMLButtonElement> | undefined;
+        onPointerOverCapture?: import("react").PointerEventHandler<HTMLButtonElement> | undefined;
+        onPointerOut?: import("react").PointerEventHandler<HTMLButtonElement> | undefined;
+        onPointerOutCapture?: import("react").PointerEventHandler<HTMLButtonElement> | undefined;
+        onGotPointerCapture?: import("react").PointerEventHandler<HTMLButtonElement> | undefined;
+        onGotPointerCaptureCapture?: import("react").PointerEventHandler<HTMLButtonElement> | undefined;
+        onLostPointerCapture?: import("react").PointerEventHandler<HTMLButtonElement> | undefined;
+        onLostPointerCaptureCapture?: import("react").PointerEventHandler<HTMLButtonElement> | undefined;
+        onScroll?: import("react").UIEventHandler<HTMLButtonElement> | undefined;
+        onScrollCapture?: import("react").UIEventHandler<HTMLButtonElement> | undefined;
+        onWheel?: import("react").WheelEventHandler<HTMLButtonElement> | undefined;
+        onWheelCapture?: import("react").WheelEventHandler<HTMLButtonElement> | undefined;
+        onAnimationStart?: import("react").AnimationEventHandler<HTMLButtonElement> | undefined;
+        onAnimationStartCapture?: import("react").AnimationEventHandler<HTMLButtonElement> | undefined;
+        onAnimationEnd?: import("react").AnimationEventHandler<HTMLButtonElement> | undefined;
+        onAnimationEndCapture?: import("react").AnimationEventHandler<HTMLButtonElement> | undefined;
+        onAnimationIteration?: import("react").AnimationEventHandler<HTMLButtonElement> | undefined;
+        onAnimationIterationCapture?: import("react").AnimationEventHandler<HTMLButtonElement> | undefined;
+        onTransitionEnd?: import("react").TransitionEventHandler<HTMLButtonElement> | undefined;
+        onTransitionEndCapture?: import("react").TransitionEventHandler<HTMLButtonElement> | undefined;
+        form?: string | undefined;
+        disabled?: boolean | undefined;
+        name?: string | undefined;
+        key?: import("react").Key | null | undefined;
+        formAction?: string | undefined;
+        formEncType?: string | undefined;
+        formMethod?: string | undefined;
+        formNoValidate?: boolean | undefined;
+        formTarget?: string | undefined;
+        focusableWhenDisabled?: boolean | undefined;
+    };
+    PopupMenuProps: PopupMenuProps;
+    buttonRef: import("react").RefObject<HTMLButtonElement>;
+    rootRef: import("react").RefObject<HTMLDivElement>;
+    onBlur: FocusEventHandler<Element>;
+    onFocus: FocusEventHandler<Element>;
+};

package/types/tabstrip/Tab.d.ts

@@ -0,0 +1,26 @@
+import { MenuActionHandler } from "@vuu-ui/vuu-data-types";
+import { KeyboardEvent, MouseEvent } from "react";
+export declare const Tab: import("react").ForwardRefExoticComponent<Omit<import("react").HTMLAttributes<HTMLElement>, "onKeyUp" | "onClick"> & {
+    ariaControls?: string | undefined;
+    closeable?: boolean | undefined;
+    draggable?: boolean | undefined;
+    dragging?: boolean | undefined;
+    editable?: boolean | undefined;
+    editing?: boolean | undefined;
+    focused?: boolean | undefined;
+    focusVisible?: boolean | undefined;
+    focusedChildIndex?: number | undefined;
+    location?: string | undefined;
+    selected?: boolean | undefined;
+    showMenuButton?: boolean | undefined;
+    index?: number | undefined;
+    label?: string | undefined;
+    onClick?: ((e: MouseEvent<HTMLElement, globalThis.MouseEvent>, index: number) => void) | undefined;
+    onClose?: ((index: number) => void) | undefined;
+    onEnterEditMode?: (() => void) | undefined;
+    onExitEditMode?: import("./TabsTypes").exitEditHandler | undefined;
+    onKeyUp?: ((e: KeyboardEvent<Element>, index: number) => void) | undefined;
+    onMenuAction?: MenuActionHandler | undefined;
+    onMenuClose?: (() => void) | undefined;
+    orientation?: "vertical" | "horizontal" | undefined;
+} & import("react").RefAttributes<HTMLDivElement>>;

package/types/tabstrip/TabMenu.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="react" />
+import { MenuActionHandler } from "@vuu-ui/vuu-data-types";
+export interface TabMenuProps {
+    allowClose: boolean;
+    allowRename: boolean;
+    index: number;
+    location?: string;
+    onMenuAction: MenuActionHandler;
+    onMenuClose?: () => void;
+    /**
+     * The id of associated component, if available
+     */
+    controlledComponentId?: string;
+    /**
+     * The label of Tab, if available
+     */
+    controlledComponentTitle?: string;
+}
+export declare const TabMenu: ({ allowClose, allowRename, controlledComponentId, controlledComponentTitle, location, onMenuAction, onMenuClose, index, }: TabMenuProps) => JSX.Element;

package/types/tabstrip/TabMenuOptions.d.ts

@@ -0,0 +1,10 @@
+import { ContextMenuItemDescriptor } from "@vuu-ui/vuu-data-types";
+export type MenuOptions = {
+    [key: string]: unknown;
+};
+export interface TabMenuOptions {
+    tabIndex: number;
+}
+export declare const isTabMenuOptions: (options: unknown) => options is TabMenuOptions;
+export declare const closeCommand: (options?: MenuOptions) => ContextMenuItemDescriptor;
+export declare const renameCommand: (options?: MenuOptions) => ContextMenuItemDescriptor;

package/types/tabstrip/TabsTypes.d.ts

@@ -0,0 +1,127 @@
+import type { AriaAttributes, HTMLAttributes, KeyboardEvent, MouseEvent, ReactElement } from "react";
+import { orientationType } from "@vuu-ui/vuu-utils";
+import type { EditableLabelProps } from "../editable-label";
+import type { MenuActionHandler } from "@vuu-ui/vuu-data-types";
+export type ExitTabEditModeHandler = (originalValue: string, editedValue: string, allowDeactivation: boolean, tabIndex: number) => void;
+export interface FocusAPI {
+    focus: () => void;
+}
+export type navigationProps = Pick<TabProps, "onFocus" | "onKeyDown">;
+export type composableTabProps = navigationProps & Pick<TabProps, "onClick" | "onEnterEditMode" | "onExitEditMode" | "onMouseDown">;
+export type TabstripVariant = "primary" | "tertiary";
+export interface TabstripProps extends HTMLAttributes<HTMLDivElement> {
+    /**
+     *  index value of Active Tab.
+     */
+    activeTabIndex: number;
+    /**
+     * Boolean that enables add new tab
+     */
+    allowAddTab?: boolean;
+    /**
+     * when true Tabs may be re-arranged by dragging individual Tabs to new position within Tabstrip.
+     */
+    allowDragDrop?: boolean;
+    /**
+     * when true Tabs may be closed by user. This can be overridden on each individual Tab
+     */
+    allowCloseTab?: boolean;
+    /**
+     * when true Tab labels may be edited by user. This can be overridden on each individual Tab
+     */
+    allowRenameTab?: boolean;
+    animateSelectionThumb?: boolean;
+    /**
+     * Boolean that indicates if tabs are centered on the container
+     */
+    centered?: boolean;
+    /**
+     *  index value of Selected Tab, used in uncontrolled mode
+     */
+    defaultActiveTabIndex?: number;
+    editing?: boolean;
+    keyBoardActivation?: "manual" | "automatic";
+    /**
+     * A custom context menu location for TabMenu, applied to all tabs
+     */
+    location?: string;
+    /**
+     * callback that fires when user has clicked Add Tab button.
+     * client is responsible for re-render with additional tab.
+     * It is also responsibility of client to select tne new tab
+     * by setting activeTabIndex, if that is the desired behaviour.
+     */
+    onAddTab?: () => void;
+    /**
+     * callback that fires when tab selection changes
+     */
+    onActiveChange?: (tabIndex: number) => void;
+    /**
+     * callback that fires when user has opted to remove tab.
+     * client is responsible for re-render with tab removed.
+     * It is also responsibility of client to select tne new tab
+     * by setting activeTabIndex, a suggested value for this is
+     * provided by newActiveTabIndex.
+     */
+    onCloseTab?: (tabIndex: number, newActiveTabIndex: number) => void;
+    onMoveTab?: (fromIndex: number, toIndex: number) => void;
+    /**
+     * vertical or horizontal (default)
+     */
+    orientation?: orientationType;
+    onEnterEditMode?: () => void;
+    onExitEditMode?: ExitTabEditModeHandler;
+    /**
+     * Boolean that indicates whether to enable overflow dropdown or not
+     */
+    overflowMenu?: boolean;
+    promptForNewTabName?: boolean;
+    /**
+     * Should each tab render a popup menu. Default is false if tab is
+     * not closeable, not renameable and has no tab-location , otherwise true.
+     */
+    showTabMenuButton?: boolean;
+    /**
+     * An optional classname that will be added to each tab
+     */
+    tabClassName?: string;
+    /**
+     * An optional classifier, used to create a classname, intended
+     * for promary vs secondary bavigation.
+     */
+    variant?: "primary" | "secondary";
+}
+export type exitEditHandler = (originalValue: string, editedValue: string, allowDeactivation: boolean, tabIndex: number) => void;
+export interface responsiveDataAttributes {
+    "data-index": number;
+    "data-overflowed"?: boolean;
+    "data-priority": number;
+}
+export type TabProps = Omit<HTMLAttributes<HTMLElement>, "onClick" | "onKeyUp"> & {
+    ariaControls?: AriaAttributes["aria-controls"];
+    closeable?: boolean;
+    draggable?: boolean;
+    dragging?: boolean;
+    editable?: boolean;
+    editing?: EditableLabelProps["editing"];
+    focused?: boolean;
+    focusVisible?: boolean;
+    focusedChildIndex?: number;
+    location?: string;
+    selected?: boolean;
+    showMenuButton?: boolean;
+    /**
+     * index is injected by the Tabstrip is need not be specified by client
+     */
+    index?: number;
+    label?: EditableLabelProps["defaultValue"];
+    onClick?: (e: MouseEvent<HTMLElement>, index: number) => void;
+    onClose?: (index: number) => void;
+    onEnterEditMode?: () => void;
+    onExitEditMode?: exitEditHandler;
+    onKeyUp?: (e: KeyboardEvent, index: number) => void;
+    onMenuAction?: MenuActionHandler;
+    onMenuClose?: () => void;
+    orientation?: "horizontal" | "vertical";
+};
+export type TabElement = ReactElement<TabProps>;

package/types/tabstrip/Tabstrip.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { TabstripProps } from "./TabsTypes";
+export declare const Tabstrip: ({ activeTabIndex: activeTabIndexProp, allowAddTab, allowCloseTab, allowDragDrop, allowRenameTab, animateSelectionThumb, children, className: classNameProp, id: idProp, keyBoardActivation, location, onActiveChange, onAddTab, onCloseTab, onExitEditMode, onMoveTab, orientation, showTabMenuButton, style: styleProp, tabClassName, variant, ...htmlAttributes }: TabstripProps) => JSX.Element;

package/types/tabstrip/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./Tabstrip";
+export * from "./Tab";
+export * from "./TabsTypes";
+export * from "./tabstrip-dom-utils";

package/types/tabstrip/tabstrip-dom-utils.d.ts

@@ -0,0 +1,2 @@
+export declare const getIndexOfSelectedTab: (container: HTMLElement | null) => number;
+export declare const getIndexOfEditedItem: (container: HTMLElement | null) => number;

package/types/tabstrip/useAnimatedSelectionThumb.d.ts

@@ -0,0 +1,7 @@
+import { orientationType } from "@vuu-ui/vuu-utils";
+import { CSSProperties, RefObject } from "react";
+export declare const useAnimatedSelectionThumb: (containerRef: RefObject<HTMLElement>, activeTabIndex: number, orientation?: orientationType) => {
+    containerStyle: CSSProperties;
+    resumeAnimation: () => void;
+    suspendAnimation: () => void;
+};

package/types/tabstrip/useKeyboardNavigation.d.ts

@@ -0,0 +1,29 @@
+import { orientationType } from "@vuu-ui/vuu-utils";
+import { FocusEvent, FocusEventHandler, KeyboardEvent, MouseEvent as ReactMouseEvent, MouseEventHandler, RefObject } from "react";
+export interface ContainerNavigationProps {
+    onBlur: FocusEventHandler;
+    onFocus: FocusEventHandler;
+    onMouseDownCapture: MouseEventHandler;
+    onMouseLeave: MouseEventHandler;
+}
+interface TabstripNavigationHookProps {
+    containerRef: RefObject<HTMLElement>;
+    defaultHighlightedIdx?: number;
+    highlightedIdx?: number;
+    keyBoardActivation?: "manual" | "automatic";
+    orientation: orientationType;
+    selectedIndex: number | null;
+}
+interface TabstripNavigationHookResult {
+    containerProps: ContainerNavigationProps;
+    highlightedIdx: number;
+    focusTab: (tabIndex: number, immediateFocus?: boolean, withKeyboard?: boolean, delay?: number) => void;
+    focusVisible: number;
+    focusIsWithinComponent: boolean;
+    onClick: (evt: ReactMouseEvent, tabIndex: number) => void;
+    onFocus: (evt: FocusEvent<HTMLElement>) => void;
+    onKeyDown: (evt: KeyboardEvent) => void;
+    setHighlightedIdx: (highlightedIndex: number) => void;
+}
+export declare const useKeyboardNavigation: ({ containerRef, defaultHighlightedIdx, highlightedIdx: highlightedIdxProp, keyBoardActivation, orientation, selectedIndex: selectedTabIndex, }: TabstripNavigationHookProps) => TabstripNavigationHookResult;
+export {};

package/types/tabstrip/useSelection.d.ts

@@ -0,0 +1,13 @@
+import { KeyboardEvent, MouseEvent } from "react";
+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/types/tabstrip/useTabstrip.d.ts

@@ -0,0 +1,49 @@
+import type { MenuActionHandler } from "@vuu-ui/vuu-data-types";
+import type { OverflowItem } from "@vuu-ui/vuu-ui-controls";
+import { orientationType } from "@vuu-ui/vuu-utils";
+import { KeyboardEvent, MouseEvent as ReactMouseEvent, RefObject } from "react";
+export type ExitEditModeHandler = (originalValue: string, editedValue: string, allowDeactivation: boolean, tabIndex: number) => void;
+export interface TabstripHookProps {
+    activeTabIndex: number;
+    allowDragDrop: boolean;
+    animateSelectionThumb: boolean;
+    containerRef: RefObject<HTMLElement>;
+    onActiveChange?: (tabIndex: number) => void;
+    onAddTab?: () => void;
+    onCloseTab?: (tabIndex: number, newActiveTabIndex: number) => void;
+    onExitEditMode?: ExitEditModeHandler;
+    onMoveTab?: (fromIndex: number, toIndex: number) => void;
+    orientation: orientationType;
+    keyBoardActivation?: "manual" | "automatic";
+}
+export declare const useTabstrip: ({ activeTabIndex: activeTabIndexProp, allowDragDrop, animateSelectionThumb, containerRef, onActiveChange, onAddTab, onCloseTab, onExitEditMode, onMoveTab, orientation, keyBoardActivation, }: TabstripHookProps) => {
+    draggable?: JSX.Element | undefined;
+    dropIndicator?: JSX.Element | undefined;
+    draggedItemIndex?: number | undefined;
+    isDragging: boolean;
+    isScrolling: RefObject<boolean>;
+    revealOverflowedItems?: boolean | undefined;
+    activeTabIndex: number;
+    containerStyle: import("react").CSSProperties;
+    focusVisible: number;
+    containerProps: {
+        onSwitchWrappedItemIntoView: (item: OverflowItem) => void;
+        onBlur: import("react").FocusEventHandler<Element>;
+        onFocus: import("react").FocusEventHandler<Element>;
+        onMouseDownCapture: import("react").MouseEventHandler<Element>;
+        onMouseLeave: import("react").MouseEventHandler<Element>;
+    };
+    navigationProps: {
+        onFocus: (evt: import("react").FocusEvent<HTMLElement, Element>) => void;
+        onKeyDown: (evt: KeyboardEvent) => void;
+    };
+    onClickAddTab: () => void;
+    tabProps: {
+        onClick: (evt: ReactMouseEvent<HTMLElement>, tabIndex: number) => void;
+        onKeyDown: (evt: KeyboardEvent) => void;
+        onExitEditMode: ExitEditModeHandler;
+        onMenuAction: MenuActionHandler;
+        onMenuClose: () => void;
+        onMouseDown: import("react").MouseEventHandler<Element> | undefined;
+    };
+};

package/types/toolbar/Toolbar.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="react" />
+import { OverflowContainerProps } from "../overflow-container";
+import { SelectionStrategy, SpecialKeyMultipleSelection } from "../common-hooks";
+export type ActiveItemChangeHandler = (itemIndex: number[]) => void;
+export type NavigationOutOfBoundsHandler = (direction: "start" | "end") => void;
+export interface ToolbarProps extends OverflowContainerProps {
+    activeItemIndex?: number[];
+    alignItems?: "start" | "center" | "end";
+    defaultActiveItemIndex?: number[];
+    onActiveChange?: ActiveItemChangeHandler;
+    /**
+     * Indicates that user has used Arrow key navigation to move beyond the
+     * last or before the first item. A higher level component may want to
+     * use this to implement a seamless navigation across components.
+     */
+    onNavigateOutOfBounds?: NavigationOutOfBoundsHandler;
+    selectionStrategy?: SelectionStrategy | SpecialKeyMultipleSelection;
+    showSeparators?: boolean;
+}
+export declare const Toolbar: ({ activeItemIndex: activeItemIndexProp, alignItems, defaultActiveItemIndex, children, className, id: idProp, onActiveChange, onNavigateOutOfBounds, orientation, selectionStrategy, showSeparators, ...props }: ToolbarProps) => JSX.Element;