@vuu-ui/vuu-data-react 0.13.45 → 0.13.46

package/types/vuu-ui-controls/src/date-picker/DatePickerPanel.d.ts

@@ -0,0 +1,10 @@
+import { type DateValue } from "@internationalized/date";
+import { type ComponentPropsWithoutRef, type SyntheticEvent } from "react";
+import { type CalendarProps, type RangeSelectionValueType } from "../calendar";
+export interface DatePickerPanelProps<SelectionVariantType> extends ComponentPropsWithoutRef<"div"> {
+    onSelect?: (event: SyntheticEvent, selectedDate?: SelectionVariantType) => void;
+    helperText?: string;
+    visibleMonths?: 1 | 2;
+    CalendarProps?: Partial<Omit<CalendarProps, "selectionVariant" | "selectedDate" | "defaultSelectedDate" | "onSelectedDateChange">>;
+}
+export declare const DatePickerPanel: import("react").ForwardRefExoticComponent<DatePickerPanelProps<DateValue | RangeSelectionValueType> & import("react").RefAttributes<HTMLDivElement>>;

package/types/vuu-ui-controls/src/date-picker/index.d.ts

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

package/types/vuu-ui-controls/src/drag-drop/DragDropProvider.d.ts

@@ -0,0 +1,38 @@
+import { ReactNode } from "react";
+import { DragDropState } from "./DragDropState";
+import { GlobalDropHandler, ResumeDragHandler } from "./useGlobalDragDrop";
+export type DragOutHandler = (id: string, dragDropState: DragDropState) => boolean;
+export type DragDropRegistrationFn = (id: string, resumeDrag: ResumeDragHandler | false, onDrop?: GlobalDropHandler) => void;
+export type EndOfDragOperationHandler = (id: string) => void;
+export interface DragDropContextProps {
+    dragSources?: Map<string, string[]>;
+    dropTargets?: Map<string, string[]>;
+    onDragOut?: DragOutHandler;
+    onEndOfDragOperation?: EndOfDragOperationHandler;
+    registerDragDropParty: DragDropRegistrationFn;
+}
+export type DragSources = {
+    [key: string]: {
+        dropTargets: string | string[];
+        payloadType?: string;
+    };
+};
+export interface DragDropProviderProps {
+    children: ReactNode;
+    dragSources: DragSources;
+}
+export type MeasuredTarget = {
+    bottom: number;
+    left: number;
+    right: number;
+    top: number;
+};
+export declare const DragDropProvider: ({ children, dragSources: dragSourcesProp, }: DragDropProviderProps) => import("react/jsx-runtime").JSX.Element;
+export interface DragDropProviderResult {
+    isDragSource?: boolean;
+    isDropTarget?: boolean;
+    onDragOut?: DragOutHandler;
+    onEndOfDragOperation?: (id: string) => void;
+    register: DragDropRegistrationFn;
+}
+export declare const useDragDropProvider: (id?: string) => DragDropProviderResult;

package/types/vuu-ui-controls/src/drag-drop/DragDropState.d.ts

@@ -0,0 +1,15 @@
+import { MouseOffset, MousePosition } from "./dragDropTypes";
+export declare class DragDropState {
+    /** Distance between start (top | left) of dragged element and point where user pressed to drag */
+    readonly mouseOffset: MouseOffset;
+    /** Element where the initial mousedown triggered the drag operation */
+    readonly initialDragElement: HTMLElement;
+    /** Element being dragged, (initial element cloned and rendered in portal). */
+    draggableElement: HTMLElement | null;
+    payload: unknown;
+    constructor(mousePosition: MousePosition, dragElement: HTMLElement);
+    /** Used to capture a ref to the Draggable ReactElement */
+    setDraggable: (el: HTMLElement | null) => void;
+    setPayload(payload: unknown): void;
+    private getMouseOffset;
+}

package/types/vuu-ui-controls/src/drag-drop/Draggable.d.ts

@@ -0,0 +1,13 @@
+import { CSSProperties, HTMLAttributes, MutableRefObject, TransitionEventHandler } from "react";
+export interface DraggableProps extends HTMLAttributes<HTMLDivElement> {
+    wrapperClassName: string;
+    element: HTMLElement;
+    onDropped?: () => void;
+    onTransitionEnd?: TransitionEventHandler;
+    scale?: number;
+    style: CSSProperties;
+}
+export declare const Draggable: import("react").ForwardRefExoticComponent<DraggableProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const createDragSpacer: (transitioning?: MutableRefObject<boolean>) => HTMLElement;
+export declare const createDropIndicatorPosition: () => HTMLElement;
+export declare const createDropIndicator: (transitioning?: MutableRefObject<boolean>) => HTMLElement;

package/types/vuu-ui-controls/src/drag-drop/dragDropTypes.d.ts

@@ -0,0 +1,100 @@
+import { MouseEventHandler, ReactElement, RefObject } from "react";
+import type { orientationType } from "@vuu-ui/vuu-utils";
+import { DragDropState } from "./DragDropState";
+export type ViewportRange = {
+    atEnd: boolean;
+    atStart: boolean;
+    from: number;
+    to: number;
+};
+type dimension = "width" | "height" | "scrollWidth" | "scrollHeight";
+type dimensions = {
+    size: dimension;
+    depth: dimension;
+    scrollDepth: dimension;
+};
+export type dimensionsType = {
+    horizontal: dimensions;
+    vertical: dimensions;
+};
+export type dragStrategy = "drop-indicator" | "natural-movement" | "drag-copy" | "drop-only";
+export type Direction = "fwd" | "bwd";
+export declare const FWD: Direction;
+export declare const BWD: Direction;
+export interface MousePosition {
+    clientX: number;
+    clientY: number;
+}
+export interface MouseOffset {
+    x: number;
+    y: number;
+}
+export type Rect = {
+    height: number;
+    left: number;
+    top: number;
+    width: number;
+};
+export interface DragHookResult {
+    draggable?: ReactElement;
+    dropIndicator?: ReactElement;
+    draggedItemIndex?: number;
+    isDragging: boolean;
+    isScrolling: RefObject<boolean>;
+    onMouseDown?: MouseEventHandler;
+    revealOverflowedItems?: boolean;
+}
+export interface InternalDragHookResult extends Omit<DragHookResult, "isDragging" | "isScrolling"> {
+    beginDrag: (dragElement: HTMLElement) => void;
+    drag: (dragPos: number, mouseMoveDirection: "fwd" | "bwd") => void;
+    drop: () => DropOptions;
+    handleScrollStart?: (scrollDirection: "fwd" | "bwd") => void;
+    handleScrollStop?: (scrollDirection: "fwd" | "bwd", _scrollPos: number, atEnd: boolean) => void;
+    /**
+     * Draggable item has been dragged out of container. Remove any local drop
+     * indicators. Dragged element itself should not yet be removed from DOM.
+     */
+    releaseDrag?: () => void;
+}
+export interface DropOptions {
+    fromIndex: number;
+    toIndex: number;
+    isExternal?: boolean;
+    payload?: unknown;
+}
+export type DragStartHandler = (dragDropState: DragDropState) => void;
+export type DropHandler = (options: DropOptions) => void;
+export interface DragDropProps {
+    allowDragDrop?: boolean | dragStrategy;
+    containerRef: RefObject<HTMLElement | null>;
+    /** this is the className that will be assigned during drag to the dragged element  */
+    draggableClassName: string;
+    extendedDropZone?: boolean;
+    getDragPayload?: (dragElement: HTMLElement) => unknown;
+    id?: string;
+    isDragSource?: boolean;
+    isDropTarget?: boolean;
+    itemQuery?: string;
+    onDragStart?: DragStartHandler;
+    onDrop: DropHandler;
+    onDropSettle?: (toIndex: number) => void;
+    orientation: orientationType;
+    /**
+     * The scrolling container does not necessarily have to be a
+     * descendant of the container, it may be an ancestor element;
+     */
+    scrollingContainerRef?: RefObject<HTMLElement | null>;
+    viewportRange?: ViewportRange;
+}
+export type DragDropHook = (props: DragDropProps) => DragHookResult;
+export interface InternalDragDropProps extends Omit<DragDropProps, "draggableClassName" | "id" | "onDrop"> {
+    isDragSource?: boolean;
+    isDropTarget?: boolean;
+    selected?: unknown;
+}
+export type DragDropContext = {
+    dragElement: HTMLElement;
+    dragPayload: unknown;
+    mouseOffset: MouseOffset;
+};
+export {};

package/types/vuu-ui-controls/src/drag-drop/drop-target-utils.d.ts

@@ -0,0 +1,82 @@
+import { orientationType } from "@vuu-ui/vuu-utils";
+import { ViewportRange } from "./dragDropTypes";
+import { Direction, Rect } from "./dragDropTypes";
+export declare const NOT_OVERFLOWED = ":not(.wrapped)";
+export declare const NOT_HIDDEN = ":not([aria-hidden=\"true\"])";
+export type MeasuredDropTarget = {
+    /**
+      The index position currently occupied by this item. If draggable
+      is dropped here, this will be the destination drop position.
+    */
+    currentIndex: number;
+    element: HTMLElement;
+    id: string;
+    index: number;
+    isDraggedItem: boolean;
+    isExternal?: boolean;
+    isLast?: boolean;
+    isOverflowIndicator?: boolean;
+    start: number;
+    end: number;
+    mid: number;
+    size: number;
+};
+export type targetType = {
+    element: HTMLElement | null;
+    index: number;
+    isLast?: boolean;
+};
+/** clones and removes id */
+export declare const cloneElement: <T extends HTMLElement>(element: T) => T;
+type MousePosKey = keyof Pick<MouseEvent, "clientX" | "clientY">;
+type DOMRectKey = keyof Omit<DOMRect, "toJSON">;
+type DOMRectDimensionKey = keyof Pick<DOMRect, "width" | "height">;
+type Dimension = keyof Pick<DOMRect, "width" | "height">;
+type ElementDimension = keyof Pick<HTMLElement, "scrollHeight" | "scrollWidth" | "clientHeight" | "clientWidth" | "scrollTop" | "scrollLeft">;
+type ElementPosition = "x" | "y";
+export declare const measureElementSizeAndPosition: (element: HTMLElement, dimension?: Dimension, includeAutoMargin?: boolean) => number[];
+export declare const dimensions: (orientation: orientationType) => {
+    CLIENT_POS: MousePosKey;
+    CLIENT_SIZE: ElementDimension;
+    CONTRA: DOMRectKey;
+    CONTRA_CLIENT_POS: MousePosKey;
+    CONTRA_END: DOMRectDimensionKey;
+    CONTRA_POS: ElementPosition;
+    DIMENSION: DOMRectDimensionKey;
+    END: DOMRectKey;
+    POS: ElementPosition;
+    SCROLL_POS: ElementDimension;
+    SCROLL_SIZE: ElementDimension;
+    START: DOMRectKey;
+} | {
+    CLIENT_POS: MousePosKey;
+    CLIENT_SIZE: ElementDimension;
+    CONTRA: DOMRectKey;
+    CONTRA_CLIENT_POS: MousePosKey;
+    CONTRA_END: DOMRectDimensionKey;
+    CONTRA_POS: ElementPosition;
+    DIMENSION: DOMRectDimensionKey;
+    END: DOMRectKey;
+    POS: ElementPosition;
+    SCROLL_POS: ElementDimension;
+    SCROLL_SIZE: ElementDimension;
+    START: DOMRectKey;
+};
+export declare const getItemById: (measuredItems: MeasuredDropTarget[], id: string) => MeasuredDropTarget | undefined;
+export declare const removeDraggedItem: (measuredItems: MeasuredDropTarget[], index: number) => void;
+export type dropZone = "start" | "end";
+export declare const measureDropTargets: (container: HTMLElement, orientation: orientationType, itemQuery?: string, viewportRange?: ViewportRange, draggedItemId?: string) => MeasuredDropTarget[];
+export declare const getIndexOfDraggedItem: (dropTargets: MeasuredDropTarget[]) => number;
+export declare const mutateDropTargetsSwitchDropTargetPosition: (dropTargets: MeasuredDropTarget[], direction: Direction) => void;
+export declare const getNextDropTarget: (dropTargets: MeasuredDropTarget[], pos: number, draggedItemSize: number, mouseMoveDirection: Direction) => MeasuredDropTarget;
+/**
+ * An item within a scrollable container might have a width or height greater than that of
+ * the container. If we drag such an item, we don't want the draggable to be larger than
+ * the container.
+ */
+export declare function constrainRect(targetRect: Rect, constraintRect: Rect): Rect;
+export declare const dropTargetsDebugString: (dropTargets: MeasuredDropTarget[]) => string;
+export declare const getItemParentContainer: (container: HTMLElement | null, itemQuery: string) => HTMLElement | null;
+export declare const getScrollableContainer: (container: HTMLElement | null, itemQuery: string) => HTMLElement | null;
+export declare const isContainerScrollable: (scrollableContainer: HTMLElement | null, orientation: orientationType) => boolean;
+export {};

package/types/vuu-ui-controls/src/drag-drop/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./dragDropTypes";
+export * from "./DragDropProvider";
+export * from "./DragDropState";
+export * from "./useDragDrop";
+export * from "./drop-target-utils";
+export * from "./useGlobalDragDrop";

package/types/vuu-ui-controls/src/drag-drop/useAutoScroll.d.ts

@@ -0,0 +1,11 @@
+import { RefObject } from "react";
+export type ScrollStopHandler = (scrollDirection: "fwd" | "bwd", scrollPos: number, atEnd: boolean) => void;
+export declare const useAutoScroll: ({ containerRef, onScrollingStopped, orientation, }: {
+    containerRef: RefObject<HTMLElement | null>;
+    onScrollingStopped?: ScrollStopHandler;
+    orientation?: "horizontal" | "vertical";
+}) => {
+    isScrolling: RefObject<boolean>;
+    startScrolling: (direction: "fwd" | "bwd", scrollRate: number, scrollUnit?: number) => void;
+    stopScrolling: (atEnd?: boolean) => void;
+};

package/types/vuu-ui-controls/src/drag-drop/useDragDisplacers.d.ts

@@ -0,0 +1,17 @@
+import type { orientationType } from "@vuu-ui/vuu-utils";
+import { Direction } from "./dragDropTypes";
+import { MeasuredDropTarget } from "./drop-target-utils";
+export type DragDisplacersHookResult = {
+    displaceItem: (dropTargets: MeasuredDropTarget[], dropTarget: MeasuredDropTarget, size: number, useTransition?: boolean, direction?: Direction | "static", orientation?: "horizontal" | "vertical") => number;
+    displaceLastItem: (dropTargets: MeasuredDropTarget[], dropTarget: MeasuredDropTarget, size: number, useTransition?: boolean, direction?: Direction | "static", orientation?: "horizontal" | "vertical") => number;
+    clearSpacers: (useAnimation?: boolean) => void;
+    /** Insert the sized spacer at start or end of collection */
+    setTerminalSpacer: (container: HTMLElement, position: "start" | "end", size: number) => void;
+};
+export type DragDisplacersHook = (orientation: orientationType) => DragDisplacersHookResult;
+/**
+ * Manage a pair of displacer elements to smoothly display a moving gap between
+ * list items of any kind. Designed to be used in a drag drop operation. The 'static'
+ * direction option should be used at drag start or following scroll.
+ */
+export declare const useDragDisplacers: DragDisplacersHook;

package/types/vuu-ui-controls/src/drag-drop/useDragDrop.d.ts

@@ -0,0 +1,2 @@
+import { DragDropHook } from "./dragDropTypes";
+export declare const useDragDrop: DragDropHook;

package/types/vuu-ui-controls/src/drag-drop/useDragDropCopy.d.ts

@@ -0,0 +1,6 @@
+import type { InternalDragDropProps, InternalDragHookResult } from "./dragDropTypes";
+export declare const NULL_DROP_OPTIONS: {
+    readonly fromIndex: -1;
+    readonly toIndex: -1;
+};
+export declare const useDragDropCopy: ({ selected, viewportRange, }: InternalDragDropProps) => InternalDragHookResult;

package/types/vuu-ui-controls/src/drag-drop/useDragDropIndicator.d.ts

@@ -0,0 +1,2 @@
+import { InternalDragDropProps, InternalDragHookResult } from "./dragDropTypes";
+export declare const useDragDropIndicator: ({ orientation, containerRef, itemQuery, selected, viewportRange, }: InternalDragDropProps) => InternalDragHookResult;

package/types/vuu-ui-controls/src/drag-drop/useDragDropNaturalMovement.d.ts

@@ -0,0 +1,2 @@
+import { InternalDragDropProps, InternalDragHookResult } from "./dragDropTypes";
+export declare const useDragDropNaturalMovement: ({ containerRef, orientation, itemQuery, selected, viewportRange, }: InternalDragDropProps) => InternalDragHookResult;

package/types/vuu-ui-controls/src/drag-drop/useDropIndicator.d.ts

@@ -0,0 +1,8 @@
+import { dropZone, MeasuredDropTarget } from "./drop-target-utils";
+export declare const SPACER_SIZE = 0;
+export type DropIndicatorHookResult = {
+    positionDropIndicator: (dropTarget: MeasuredDropTarget, dropZone: dropZone) => HTMLElement;
+    clearSpacer: () => void;
+};
+export type DropIndicatorHook = () => DropIndicatorHookResult;
+export declare const useDropIndicator: DropIndicatorHook;

package/types/vuu-ui-controls/src/drag-drop/useGlobalDragDrop.d.ts

@@ -0,0 +1,11 @@
+import { MeasuredTarget } from "./DragDropProvider";
+import { DragDropState } from "./DragDropState";
+export type ResumeDragHandler = (dragDropState: DragDropState) => boolean;
+export type GlobalDropHandler = (dragDropState: DragDropState) => void;
+export declare const useGlobalDragDrop: ({ onDragOverDropTarget, onDrop, }: {
+    onDragOverDropTarget: (dropTargetId: string, dragDropState: DragDropState) => boolean;
+    onDrop: (dropTargetId: string, dragDropState: DragDropState) => void;
+}) => {
+    measuredDropTargetsRef: import("react").RefObject<Record<string, MeasuredTarget> | undefined>;
+    resumeDrag: ResumeDragHandler;
+};

package/types/vuu-ui-controls/src/editable/index.d.ts

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

package/types/vuu-ui-controls/src/editable/useEditableText.d.ts

@@ -0,0 +1,19 @@
+import type { DataValueValidationChecker } from "@vuu-ui/vuu-data-types";
+import { VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
+import type { DataItemEditHandler } from "@vuu-ui/vuu-table-types";
+import { FocusEventHandler, FormEventHandler, KeyboardEvent } from "react";
+export interface EditableTextHookProps<T extends VuuRowDataItemType = VuuRowDataItemType> {
+    clientSideEditValidationCheck?: DataValueValidationChecker;
+    value?: T;
+    onEdit?: DataItemEditHandler;
+    type?: "string" | "number" | "boolean";
+}
+export declare const useEditableText: <T extends string | number | boolean = string>({ clientSideEditValidationCheck, value, onEdit, type, }: EditableTextHookProps<T>) => {
+    inputProps: {
+        onBlur: FocusEventHandler<HTMLElement>;
+        onKeyDown: (evt: KeyboardEvent<HTMLElement>) => void;
+    };
+    onChange: FormEventHandler;
+    value: string;
+    warningMessage: string | undefined;
+};

package/types/vuu-ui-controls/src/editable-label/EditableLabel.d.ts

@@ -0,0 +1,19 @@
+import { ForwardedRef, HTMLAttributes } from "react";
+export type ExitEditModeHandler = (originalLabel: string | undefined, editedLabel: string | undefined, allowDeactivation?: boolean, editCancelled?: boolean) => void;
+export interface EditAPI {
+    beginEdit: () => void;
+}
+export declare const NullEditAPI: EditAPI;
+export interface EditableLabelProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange"> {
+    className?: string;
+    defaultEditing?: boolean;
+    defaultValue?: string;
+    editLabelApiRef?: ForwardedRef<EditAPI>;
+    editing?: boolean;
+    onEnterEditMode?: () => void;
+    onChange?: (value: string) => void;
+    onExitEditMode: ExitEditModeHandler;
+    defaultIsEditing?: boolean;
+    value?: string;
+}
+export declare const EditableLabel: import("react").ForwardRefExoticComponent<EditableLabelProps & import("react").RefAttributes<HTMLDivElement>>;

package/types/vuu-ui-controls/src/editable-label/index.d.ts

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

package/types/vuu-ui-controls/src/expando-input/ExpandoInput.d.ts

@@ -0,0 +1,6 @@
+import { CommitHandler } from "@vuu-ui/vuu-utils";
+import { VuuInputProps } from "../vuu-input";
+export interface ExpandoInputProps extends Omit<VuuInputProps, "onCommit"> {
+    onCommit?: CommitHandler;
+}
+export declare const ExpandoInput: import("react").ForwardRefExoticComponent<ExpandoInputProps & import("react").RefAttributes<HTMLDivElement>>;

package/types/vuu-ui-controls/src/expando-input/index.d.ts

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

package/types/vuu-ui-controls/src/icon-button/Icon.d.ts

@@ -0,0 +1,6 @@
+import { HTMLAttributes } from "react";
+export interface IconProps extends HTMLAttributes<HTMLSpanElement> {
+    name: string;
+    size?: number;
+}
+export declare const Icon: ({ className, name, size, style: styleProp, ...htmlAttributes }: IconProps) => import("react/jsx-runtime").JSX.Element;

package/types/vuu-ui-controls/src/icon-button/IconButton.d.ts

@@ -0,0 +1,6 @@
+import { ButtonProps } from "@salt-ds/core";
+export interface IconButtonProps extends Omit<ButtonProps, "children"> {
+    icon: string;
+    size?: number;
+}
+export declare const IconButton: import("react").ForwardRefExoticComponent<IconButtonProps & import("react").RefAttributes<HTMLButtonElement>>;

package/types/vuu-ui-controls/src/icon-button/ToggleIconButton.d.ts

@@ -0,0 +1,5 @@
+import { IconButtonProps } from "./IconButton";
+export interface ToggleIconButtonProps extends Omit<IconButtonProps, "icon"> {
+    isExpanded: boolean;
+}
+export declare const ToggleIconButton: ({ className, isExpanded, size, variant, ...props }: ToggleIconButtonProps) => import("react/jsx-runtime").JSX.Element;

package/types/vuu-ui-controls/src/icon-button/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./Icon";
+export * from "./IconButton";
+export * from "./ToggleIconButton";

package/types/vuu-ui-controls/src/index.d.ts

@@ -0,0 +1,30 @@
+export * from "./calendar";
+export * from "./column-picker";
+export * from "./common-hooks";
+export { ContextPanelProvider, useContextPanel, useHideContextPanel, } from "./context-panel-provider/ContextPanelProvider";
+export * from "./cycle-state-button";
+export * from "./date-input";
+export * from "./date-picker";
+export * from "./drag-drop";
+export * from "./editable";
+export * from "./editable-label";
+export * from "./expando-input";
+export * from "./icon-button";
+export * from "./instrument-picker";
+export * from "./measured-container";
+export { ModalProvider, useModal } from "./modal-provider/ModalProvider";
+export * from "./overflow-container";
+export * from "./price-ticker";
+export { Prompt, type PromptProps } from "./prompt/Prompt";
+export { SortableList, SortableOption } from "./sortable-list/SortableList";
+export * from "./split-button";
+export * from "./table-search";
+export * from "./tabs-next";
+export * from "./tabstrip";
+export { TimeInput, type TimeInputProps } from "./time-input/TimeInput";
+export * from "./toolbar";
+export * from "./utils";
+export * from "./vuu-date-picker";
+export * from "./vuu-input";
+export { VuuTimePicker, type VuuTimePickerProps, } from "./vuu-time-picker/VuuTimePicker";
+export * from "./vuu-typeahead-input";

package/types/vuu-ui-controls/src/instrument-picker/TablePicker.d.ts

@@ -0,0 +1,10 @@
+import type { DataSourceRowObject, TableSchema } from "@vuu-ui/vuu-data-types";
+import { type TableProps } from "@vuu-ui/vuu-table";
+import { type HTMLAttributes } from "react";
+export interface TablePickerProps extends Omit<HTMLAttributes<HTMLElement>, "onSelect">, Pick<TableProps, "onSelect"> {
+    TableProps?: Pick<TableProps, "config">;
+    rowToString?: (row: DataSourceRowObject) => string;
+    schema: TableSchema;
+    searchColumns?: string[];
+}
+export declare const TablePicker: ({ TableProps, onSelect, rowToString, schema, searchColumns, ...htmlAttributes }: TablePickerProps) => import("react/jsx-runtime").JSX.Element;

package/types/vuu-ui-controls/src/instrument-picker/index.d.ts

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

package/types/vuu-ui-controls/src/instrument-picker/useTablePicker.d.ts

@@ -0,0 +1,47 @@
+import { ChangeEvent, KeyboardEventHandler, RefCallback } from "react";
+import type { TableConfig, TableRowSelectHandler } from "@vuu-ui/vuu-table-types";
+import type { TablePickerProps } from "./TablePicker";
+export interface TablePickerHookProps extends Pick<TablePickerProps, "TableProps" | "onSelect" | "rowToString" | "schema" | "searchColumns"> {
+    defaultIsOpen?: boolean;
+    isOpen?: boolean;
+}
+export declare const useTablePicker: ({ TableProps, onSelect, rowToString, schema, searchColumns, }: TablePickerHookProps) => {
+    containerRef: RefCallback<HTMLDivElement>;
+    dataSource: import("@vuu-ui/vuu-data-types").DataSource;
+    highlightedIndex: number | undefined;
+    floatingUIProps: {
+        reference: ((node: import("@floating-ui/react-dom").ReferenceType | null) => void) & ((node: import("@floating-ui/react").ReferenceType | null) => void);
+        floating: ((node: HTMLElement | null) => void) & ((node: HTMLElement | null) => void);
+        placement: import("@floating-ui/utils").Placement;
+        strategy: import("@floating-ui/utils").Strategy;
+        middlewareData: import("@floating-ui/core").MiddlewareData;
+        x: number;
+        y: number;
+        isPositioned: boolean;
+        update: () => void;
+        floatingStyles: React.CSSProperties;
+        refs: {
+            reference: import("react").MutableRefObject<import("@floating-ui/react-dom").ReferenceType | null>;
+            floating: React.MutableRefObject<HTMLElement | null>;
+            setReference: (node: import("@floating-ui/react-dom").ReferenceType | null) => void;
+            setFloating: (node: HTMLElement | null) => void;
+        } & import("@floating-ui/react").ExtendedRefs<import("@floating-ui/react").ReferenceType>;
+    };
+    inputProps: {
+        inputProps: {
+            autoComplete: string;
+            onKeyDown: KeyboardEventHandler<HTMLElement>;
+        };
+        onChange: (evt: ChangeEvent<HTMLInputElement>) => void;
+    };
+    interactionPropGetters: import("@floating-ui/react").UseInteractionsReturn;
+    onKeyDown: KeyboardEventHandler<HTMLElement>;
+    open: boolean;
+    tableConfig: TableConfig;
+    tableHandlers: {
+        onSelect: TableRowSelectHandler;
+    };
+    tableRef: import("react").RefObject<HTMLDivElement | null>;
+    value: string;
+    width: number;
+};

package/types/vuu-ui-controls/src/measured-container/MeasuredContainer.d.ts

@@ -0,0 +1,14 @@
+import { HTMLAttributes } from "react";
+import { MeasuredSize } from "./useMeasuredContainer";
+export interface MeasuredContainerProps extends Omit<HTMLAttributes<HTMLDivElement>, "onResize"> {
+    /**
+     * A numeric value for height will result in a fixed height. To adapt to container
+     * use either a percentage height or 'auto'. Always use 'auto' when rendering
+     * within a column based flex container, together with a flex value (use the
+     * --vuuMeasuredContainer-flex CSS custom property))
+     */
+    height?: number | string;
+    onResize?: (size: MeasuredSize) => void;
+    width?: number | string;
+}
+export declare const MeasuredContainer: import("react").ForwardRefExoticComponent<MeasuredContainerProps & import("react").RefAttributes<HTMLDivElement>>;

package/types/vuu-ui-controls/src/measured-container/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./MeasuredContainer";
+export * from "./useMeasuredContainer";

package/types/vuu-ui-controls/src/measured-container/useMeasuredContainer.d.ts

@@ -0,0 +1,23 @@
+import { CSSProperties, RefObject } from "react";
+import { MeasuredContainerProps } from "./MeasuredContainer";
+export interface ClientSize {
+    clientHeight: number;
+    clientWidth: number;
+}
+export interface MeasuredProps extends Pick<MeasuredContainerProps, "height" | "onResize" | "width"> {
+    defaultHeight?: number;
+    defaultWidth?: number;
+}
+export type CssSize = Pick<CSSProperties, "height" | "width">;
+export interface MeasuredSize {
+    height: number;
+    width: number;
+}
+export interface MeasuredContainerHookResult {
+    containerRef: RefObject<HTMLDivElement | null>;
+    cssSize: CssSize;
+    outerSize: CssSize;
+    innerSize?: MeasuredSize;
+}
+export declare const reduceSizeHeight: (size: MeasuredSize, value: number) => MeasuredSize;
+export declare const useMeasuredContainer: ({ defaultHeight, defaultWidth, height, onResize: onResizeProp, width, }: MeasuredProps) => MeasuredContainerHookResult;

package/types/vuu-ui-controls/src/measured-container/useResizeObserver.d.ts

@@ -0,0 +1,15 @@
+import { RefObject } from "react";
+export declare const WidthHeight: string[];
+export declare const WidthOnly: string[];
+export type measurements<T = string | number> = {
+    height?: T;
+    clientHeight?: number;
+    clientWidth?: number;
+    contentHeight?: number;
+    contentWidth?: number;
+    scrollHeight?: number;
+    scrollWidth?: number;
+    width?: T;
+};
+export type ResizeHandler = (measurements: measurements<number>) => void;
+export declare function useResizeObserver(ref: RefObject<Element | HTMLElement | null>, dimensions: readonly string[], onResize: ResizeHandler, reportInitialSize?: boolean): void;

package/types/vuu-ui-controls/src/modal-provider/ModalProvider.d.ts

@@ -0,0 +1,13 @@
+import { ReactElement, ReactNode } from "react";
+import { PromptProps } from "../prompt/Prompt";
+export type ShowDialog = (dialogContent: ReactElement, title: string, dialogActionButtons?: ReactElement[], hideCloseButton?: boolean) => void;
+export type ShowPrompt = (promptContent: ReactElement, promptProps: PromptProps) => void;
+export declare const ModalProvider: ({ children }: {
+    children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const useModal: () => {
+    showDialog: ShowDialog;
+    closeDialog: () => void;
+    showPrompt: ShowPrompt;
+    closePrompt: () => void;
+};

package/types/vuu-ui-controls/src/overflow-container/OverflowContainer.d.ts

@@ -0,0 +1,15 @@
+import { PopupMenuProps } from "@vuu-ui/vuu-popups";
+import { orientationType } from "@vuu-ui/vuu-utils";
+import React, { HTMLAttributes } from "react";
+import { OverflowItem } from "./overflow-utils";
+export interface OverflowContainerProps extends HTMLAttributes<HTMLDivElement> {
+    PopupMenuProps?: Partial<PopupMenuProps>;
+    allowDragDrop?: boolean;
+    debugId?: string;
+    onMoveItem?: (fromIndex: number, toIndex: number) => void;
+    onSwitchWrappedItemIntoView?: (overflowItem: OverflowItem) => void;
+    orientation?: orientationType;
+    overflowIcon?: string;
+    overflowPosition?: "start" | "end" | number;
+}
+export declare const OverflowContainer: React.ForwardRefExoticComponent<OverflowContainerProps & React.RefAttributes<HTMLDivElement>>;

package/types/vuu-ui-controls/src/overflow-container/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./OverflowContainer";
+export * from "./overflow-utils";