@vuu-ui/vuu-ui-controls 0.8.20-debug → 0.8.21-debug

package/types/calendar/internal/CalendarDay.d.ts

@@ -0,0 +1,15 @@
+import { TooltipProps } from "@salt-ds/core";
+import { ComponentPropsWithRef, ReactElement } from "react";
+import { DateValue } from "@internationalized/date";
+import { DayStatus } from "../useCalendarDay";
+import "./CalendarDay.css";
+export type DateFormatter = (day: Date) => string | undefined;
+export interface CalendarDayProps extends Omit<ComponentPropsWithRef<"button">, "children"> {
+    day: DateValue;
+    formatDate?: DateFormatter;
+    renderDayContents?: (date: DateValue, status: DayStatus) => ReactElement;
+    status?: DayStatus;
+    month: DateValue;
+    TooltipProps?: Partial<TooltipProps>;
+}
+export declare const CalendarDay: import("react").ForwardRefExoticComponent<Omit<CalendarDayProps, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;

package/types/calendar/internal/CalendarMonth.d.ts

@@ -0,0 +1,12 @@
+import { ComponentPropsWithRef } from "react";
+import { DateValue } from "@internationalized/date";
+import { CalendarDayProps } from "./CalendarDay";
+import "./CalendarMonth.css";
+export interface CalendarMonthProps extends ComponentPropsWithRef<"div"> {
+    date: DateValue;
+    hideOutOfRangeDates?: boolean;
+    renderDayContents?: CalendarDayProps["renderDayContents"];
+    isVisible?: boolean;
+    TooltipProps?: CalendarDayProps["TooltipProps"];
+}
+export declare const CalendarMonth: import("react").ForwardRefExoticComponent<Omit<CalendarMonthProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;

package/types/calendar/internal/CalendarNavigation.d.ts

@@ -0,0 +1,21 @@
+import { ButtonProps } from "@salt-ds/core";
+import { ComponentPropsWithRef } from "react";
+import { DropdownProps } from "../../dropdown";
+import "./CalendarNavigation.css";
+import { DateValue } from "@internationalized/date";
+type DropdownItem = {
+    value: DateValue;
+    disabled?: boolean;
+};
+type dateDropdownProps = DropdownProps<DropdownItem>;
+export interface CalendarNavigationProps extends ComponentPropsWithRef<"div"> {
+    MonthDropdownProps?: dateDropdownProps;
+    YearDropdownProps?: dateDropdownProps;
+    onMonthSelect?: dateDropdownProps["onChange"];
+    onYearSelect?: dateDropdownProps["onChange"];
+    onNavigateNext?: ButtonProps["onClick"];
+    onNavigatePrevious?: ButtonProps["onClick"];
+    hideYearDropdown?: boolean;
+}
+export declare const CalendarNavigation: import("react").ForwardRefExoticComponent<Omit<CalendarNavigationProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+export {};

package/types/calendar/internal/CalendarWeekHeader.d.ts

@@ -0,0 +1,6 @@
+import { ComponentPropsWithRef } from "react";
+import "./CalendarWeekHeader.css";
+export type CalendarWeekHeaderProps = ComponentPropsWithRef<"div">;
+export declare const CalendarWeekHeader: import("react").ForwardRefExoticComponent<Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void) | import("react").RefObject<HTMLDivElement> | null | undefined;
+}, "ref"> & import("react").RefAttributes<HTMLDivElement>>;

package/types/calendar/internal/useFocusManagement.d.ts

@@ -0,0 +1,9 @@
+import { FocusEventHandler, KeyboardEventHandler, MouseEventHandler } from "react";
+import { DateValue } from "@internationalized/date";
+export declare function useFocusManagement({ date }: {
+    date: DateValue;
+}): {
+    handleClick: MouseEventHandler<HTMLButtonElement>;
+    handleKeyDown: KeyboardEventHandler<HTMLButtonElement>;
+    handleFocus: FocusEventHandler<HTMLButtonElement>;
+};

package/types/calendar/internal/utils.d.ts

@@ -0,0 +1,15 @@
+import { DateFormatter, DateValue } from "@internationalized/date";
+export declare function getCurrentLocale(): string;
+export declare function getDateFormatter(options?: Intl.DateTimeFormatOptions): DateFormatter;
+export declare function formatDate(date: DateValue, options?: Intl.DateTimeFormatOptions): string;
+export declare function getCalender(): import("@internationalized/date").Calendar;
+type WeekdayFormat = Intl.DateTimeFormatOptions["weekday"];
+export declare function daysForLocale(weekday?: WeekdayFormat): string[];
+export declare function monthsForLocale(currentYear: DateValue): (import("@internationalized/date").CalendarDate | import("@internationalized/date").CalendarDateTime | import("@internationalized/date").ZonedDateTime)[];
+export declare function generateVisibleDays(currentMonth: DateValue): {
+    date: DateValue;
+    dateOfMonth: number;
+    isCurrentMonth: boolean;
+}[];
+export declare function monthDiff(a: DateValue, b: DateValue): number;
+export {};

package/types/calendar/useCalendar.d.ts

@@ -0,0 +1,57 @@
+import { DateValue } from "@internationalized/date";
+import { SyntheticEvent } from "react";
+import { UseMultiSelectionCalendarProps, UseOffsetSelectionCalendarProps, UseRangeSelectionCalendarProps, UseSingleSelectionCalendarProps } from "./useSelection";
+export type UnselectableInfo = {
+    emphasis: "medium";
+    tooltip: string;
+} | {
+    emphasis: "low";
+    tooltip?: string;
+};
+interface BaseUseCalendarProps {
+    defaultVisibleMonth?: DateValue;
+    onVisibleMonthChange?: (event: SyntheticEvent, visibleMonth: DateValue) => void;
+    isDayUnselectable?: (date: DateValue) => UnselectableInfo | boolean | void;
+    visibleMonth?: DateValue;
+    hideOutOfRangeDates?: boolean;
+    hideYearDropdown?: boolean;
+    minDate?: DateValue;
+    maxDate?: DateValue;
+}
+export type useCalendarProps = (Omit<UseSingleSelectionCalendarProps, "isDaySelectable"> | Omit<UseMultiSelectionCalendarProps, "isDaySelectable"> | Omit<UseRangeSelectionCalendarProps, "isDaySelectable"> | Omit<UseOffsetSelectionCalendarProps, "isDaySelectable">) & BaseUseCalendarProps;
+export declare function useCalendar(props: useCalendarProps): {
+    state: {
+        selectedDate: DateValue | import("./useSelection").RangeSelectionValueType | {
+            startDate?: DateValue | undefined;
+            endDate?: DateValue | undefined;
+        } | DateValue[] | null | undefined;
+        hoveredDate: import("@internationalized/date").CalendarDate | import("@internationalized/date").CalendarDateTime | import("@internationalized/date").ZonedDateTime | null | undefined;
+        visibleMonth: DateValue;
+        focusedDate: DateValue;
+        minDate: DateValue | undefined;
+        maxDate: DateValue | undefined;
+        selectionVariant: "default" | "range" | "offset" | "multiselect";
+        hideOutOfRangeDates: boolean | undefined;
+        calendarFocused: boolean;
+    };
+    helpers: {
+        setSelectedDate: (event: SyntheticEvent<HTMLButtonElement, Event>, newSelectedDate: DateValue) => void;
+        isSelected: (date: DateValue) => boolean;
+        setHoveredDate: (event: SyntheticEvent<Element, Event>, date: DateValue | null) => void;
+        isHovered: (date: DateValue) => boolean;
+        isSelectedSpan: (date: DateValue) => boolean;
+        isHoveredSpan: (date: DateValue) => boolean;
+        isSelectedStart: (date: DateValue) => boolean;
+        isSelectedEnd: (date: DateValue) => boolean;
+        isHoveredOffset: (date: DateValue) => boolean;
+        setVisibleMonth: (event: SyntheticEvent, newVisibleMonth: DateValue) => void;
+        setFocusedDate: (event: SyntheticEvent, date: DateValue) => void;
+        setCalendarFocused: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+        isDayUnselectable: (date: DateValue) => boolean | void | UnselectableInfo;
+        isDayVisible: (date: DateValue) => boolean;
+        isOutsideAllowedDates: (date: DateValue) => boolean;
+        isOutsideAllowedMonths: (date: DateValue) => boolean;
+        isOutsideAllowedYears: (date: DateValue) => boolean;
+    };
+};
+export {};

package/types/calendar/useCalendarDay.d.ts

@@ -0,0 +1,19 @@
+import { DateValue } from "@internationalized/date";
+import { RefObject } from "react";
+export type DayStatus = {
+    outOfRange?: boolean;
+    selected?: boolean;
+    today?: boolean;
+    unselectable?: "medium" | "low" | false;
+    focused?: boolean;
+    hidden?: boolean;
+};
+export interface useCalendarDayProps {
+    date: DateValue;
+    month: DateValue;
+}
+export declare function useCalendarDay({ date, month }: useCalendarDayProps, ref: RefObject<HTMLElement>): {
+    status: DayStatus;
+    dayProps: Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">;
+    unselectableReason: string | undefined;
+};

package/types/calendar/useSelection.d.ts

@@ -0,0 +1,75 @@
+import { KeyboardEventHandler, MouseEventHandler, SyntheticEvent } from "react";
+import { CalendarDate, DateValue } from "@internationalized/date";
+interface BaseUseSelectionCalendarProps<SelectionVariantType> {
+    hoveredDate?: DateValue | null;
+    selectedDate?: SelectionVariantType | null;
+    defaultSelectedDate?: SelectionVariantType;
+    onSelectedDateChange?: (event: SyntheticEvent, selectedDate: SelectionVariantType) => void;
+    isDaySelectable: (date?: DateValue) => boolean;
+    onHoveredDateChange?: (event: SyntheticEvent, hoveredDate: DateValue | null) => void;
+}
+type SingleSelectionValueType = DateValue;
+type MultiSelectionValueType = DateValue[];
+export type RangeSelectionValueType = {
+    startDate?: DateValue;
+    endDate?: DateValue;
+};
+type OffsetSelectionValueType = {
+    startDate?: DateValue;
+    endDate?: DateValue;
+};
+export interface UseOffsetSelectionCalendarProps extends Omit<BaseUseSelectionCalendarProps<OffsetSelectionValueType>, "startDateOffset" | "endDateOffset"> {
+    selectionVariant: "offset";
+    startDateOffset?: (date: DateValue) => DateValue;
+    endDateOffset?: (date: DateValue) => DateValue;
+}
+export interface UseRangeSelectionCalendarProps extends BaseUseSelectionCalendarProps<RangeSelectionValueType> {
+    selectionVariant: "range";
+}
+export interface UseMultiSelectionCalendarProps extends BaseUseSelectionCalendarProps<MultiSelectionValueType> {
+    selectionVariant: "multiselect";
+}
+export interface UseSingleSelectionCalendarProps extends BaseUseSelectionCalendarProps<SingleSelectionValueType> {
+    selectionVariant: "default";
+}
+export type useSelectionCalendarProps = UseSingleSelectionCalendarProps | UseMultiSelectionCalendarProps | UseRangeSelectionCalendarProps | UseOffsetSelectionCalendarProps;
+export declare function useSelectionCalendar(props: useSelectionCalendarProps): {
+    state: {
+        selectedDate: DateValue | RangeSelectionValueType | OffsetSelectionValueType | MultiSelectionValueType | null | undefined;
+        hoveredDate: CalendarDate | import("@internationalized/date").CalendarDateTime | import("@internationalized/date").ZonedDateTime | null | undefined;
+    };
+    helpers: {
+        setSelectedDate: (event: SyntheticEvent<HTMLButtonElement>, newSelectedDate: DateValue) => void;
+        isSelected: (date: DateValue) => boolean;
+        setHoveredDate: (event: SyntheticEvent, date: DateValue | null) => void;
+        isHovered: (date: DateValue) => boolean;
+        isSelectedSpan: (date: DateValue) => boolean;
+        isHoveredSpan: (date: DateValue) => boolean;
+        isSelectedStart: (date: DateValue) => boolean;
+        isSelectedEnd: (date: DateValue) => boolean;
+        isHoveredOffset: (date: DateValue) => boolean;
+    };
+};
+export declare function useSelectionDay({ date }: {
+    date: DateValue;
+}): {
+    handleClick: MouseEventHandler<HTMLButtonElement>;
+    handleKeyDown: KeyboardEventHandler<HTMLButtonElement>;
+    handleMouseOver: MouseEventHandler<HTMLButtonElement>;
+    handleMouseLeave: MouseEventHandler<HTMLButtonElement>;
+    status: {
+        selected: boolean;
+        selectedSpan: boolean;
+        hoveredSpan: boolean;
+        selectedStart: boolean;
+        selectedEnd: boolean;
+        hovered: boolean;
+        hoveredOffset: boolean;
+    };
+    dayProps: {
+        className: string;
+        "aria-pressed": string | undefined;
+        "aria-disabled": string | undefined;
+    };
+};
+export {};

package/types/common-hooks/isPlainObject.d.ts

@@ -0,0 +1 @@
+export declare const isPlainObject: (obj: unknown) => boolean;

package/types/date-picker/DatePicker.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import { DateValue } from "@internationalized/date";
+import { BaseDatePickerProps } from "./types";
+import "./DatePicker.css";
+export declare const DatePicker: (props: BaseDatePickerProps<DateValue>) => JSX.Element;

package/types/date-picker/DateRangePicker.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import { BaseDatePickerProps } from "./types";
+import { RangeSelectionValueType } from "../calendar";
+import "./DatePicker.css";
+export declare const DateRangePicker: (props: BaseDatePickerProps<RangeSelectionValueType>) => JSX.Element;

package/types/date-picker/index.d.ts

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

package/types/date-picker/input/DatePickerInput.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+import { DateValue } from "@internationalized/date";
+import { BasePickerInputProps } from "./types";
+import "./DatePickerInput.css";
+type Props = BasePickerInputProps<DateValue>;
+export declare const DatePickerInput: React.FC<Props>;
+export {};

package/types/date-picker/input/DateRangePickerInput.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import { BasePickerInputProps } from "./types";
+import { RangeSelectionValueType } from "../../calendar";
+import "./DateRangePickerInput.css";
+type Props = BasePickerInputProps<RangeSelectionValueType>;
+export declare const DateRangePickerInput: React.FC<Props>;
+export {};

package/types/date-picker/input/types.d.ts

@@ -0,0 +1,6 @@
+import { PickerSelectionType } from "../types";
+export interface BasePickerInputProps<T extends PickerSelectionType> {
+    onChange: (selected: T) => void;
+    value?: T;
+    className?: string;
+}

package/types/date-picker/internal/CalendarIconButton.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import "./CalendarIconButton.css";
+export declare const CalendarIconButton: import("react").ForwardRefExoticComponent<Omit<import("@salt-ds/core").ButtonProps & import("react").RefAttributes<HTMLButtonElement>, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;

package/types/date-picker/types.d.ts

@@ -0,0 +1,15 @@
+import { DateValue } from "@internationalized/date";
+import { CalendarProps } from "../calendar/Calendar";
+import { RangeSelectionValueType } from "../calendar";
+export type PickerSelectionType = DateValue | RangeSelectionValueType;
+export interface BaseDatePickerProps<T = PickerSelectionType> extends Pick<CalendarProps, "hideOutOfRangeDates" | "hideYearDropdown"> {
+    onSelectedDateChange: (selected: T) => void;
+    selectedDate: T | undefined;
+    closeOnSelection?: boolean;
+    onBlur?: () => void;
+    className?: string;
+}
+export interface BaseDatePickerDropdownProps<T = PickerSelectionType> extends BaseDatePickerProps<T> {
+    visibleMonth: DateValue | undefined;
+    onVisibleMonthChange: (d: DateValue) => void;
+}

package/types/date-picker/useBaseDatePicker.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="react" />
+import { BaseDatePickerProps } from "./types";
+import { DateValue } from "@internationalized/date";
+import { PickerSelectionType } from "./types";
+import { RangeSelectionValueType } from "../calendar";
+type InheritedProps<T extends PickerSelectionType> = Pick<BaseDatePickerProps<T>, "onBlur" | "selectedDate">;
+type Props = ({
+    variant: "range";
+} & InheritedProps<RangeSelectionValueType>) | ({
+    variant: "default";
+} & InheritedProps<DateValue>);
+export declare function useBaseDatePicker(props: Props): {
+    handleOnBlur: import("react").FocusEventHandler<HTMLDivElement>;
+    visibleMonth: DateValue | undefined;
+    handleVisibleMonthChange: import("react").Dispatch<import("react").SetStateAction<DateValue | undefined>>;
+};
+export {};

package/types/date-picker/useBaseDatePickerDropdown.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+import { DateValue } from "@internationalized/date";
+import { PickerSelectionType } from "./types";
+import { BaseDatePickerDropdownProps } from "./types";
+type Props<T extends PickerSelectionType> = Pick<BaseDatePickerDropdownProps<T>, "onSelectedDateChange" | "onVisibleMonthChange"> & {
+    shouldCloseOnSelectionChange: (v: T) => boolean;
+};
+export declare function useBaseDatePickerDropdown<T extends PickerSelectionType>({ onVisibleMonthChange, onSelectedDateChange, shouldCloseOnSelectionChange, }: Props<T>): {
+    isOpen: boolean;
+    handleOpenChange: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    triggererRef: import("react").RefObject<HTMLButtonElement>;
+    handleVisibleMonthChange: (_: React.SyntheticEvent, d: DateValue) => void;
+    handleDateSelection: (_: React.SyntheticEvent, d: T) => void;
+};
+export {};

package/types/drag-drop/DragDropState.d.ts

@@ -1,4 +1,4 @@
-import { MouseOffset } from "./dragDropTypesNext";
+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;
@@ -7,7 +7,7 @@ export declare class DragDropState {
     /** Element being dragged, (initial element cloned and rendered in portal). */
     draggableElement: HTMLElement | null;
     payload: unknown;
-    constructor(evt: MouseEvent, dragElement: HTMLElement);
+    constructor(mousePosition: MousePosition, dragElement: HTMLElement);
     /** Used to capture a ref to the Draggable JSX.Element */
     setDraggable: (el: HTMLElement | null) => void;
     setPayload(payload: unknown): void;

package/types/drag-drop/DropIndicator.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="react" />
-import { Rect } from "./dragDropTypesNext";
+import { Rect } from "./dragDropTypes";
 import "./DropIndicator.css";
 export declare const DropIndicator: import("react").ForwardRefExoticComponent<{
     className?: string | undefined;

package/types/drag-drop/{dragDropTypesNext.d.ts → dragDropTypes.d.ts}

@@ -21,6 +21,10 @@ export type dragStrategy = "drop-indicator" | "natural-movement" | "drag-copy" |
 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;

package/types/drag-drop/drop-target-utils.d.ts

@@ -1,6 +1,6 @@
 import { orientationType } from "@vuu-ui/vuu-utils";
-import { ViewportRange } from "./dragDropTypesNext";
-import { Direction, Rect } from "./dragDropTypesNext";
+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 = {
@@ -32,31 +32,31 @@ type Dimension = keyof Pick<DOMRect, "width" | "height">;
 type ElementPosition = "x" | "y";
 export declare const measureElementSizeAndPosition: (element: HTMLElement, dimension?: Dimension, includeAutoMargin?: boolean) => number[];
 export declare const dimensions: (orientation: orientationType) => {
-    CLIENT_POS: "clientX" | "clientY";
-    CLIENT_SIZE: "clientHeight" | "clientWidth" | "scrollHeight" | "scrollLeft" | "scrollTop" | "scrollWidth";
-    CONTRA: "width" | "height" | "x" | "y" | "left" | "top" | "right" | "bottom";
-    CONTRA_CLIENT_POS: "clientX" | "clientY";
+    CLIENT_POS: "clientY" | "clientX";
+    CLIENT_SIZE: "scrollTop" | "scrollHeight" | "scrollWidth" | "clientHeight" | "clientWidth" | "scrollLeft";
+    CONTRA: "width" | "height" | "left" | "right" | "top" | "bottom" | "x" | "y";
+    CONTRA_CLIENT_POS: "clientY" | "clientX";
     CONTRA_END: "width" | "height";
     CONTRA_POS: ElementPosition;
     DIMENSION: "width" | "height";
-    END: "width" | "height" | "x" | "y" | "left" | "top" | "right" | "bottom";
+    END: "width" | "height" | "left" | "right" | "top" | "bottom" | "x" | "y";
     POS: ElementPosition;
-    SCROLL_POS: "clientHeight" | "clientWidth" | "scrollHeight" | "scrollLeft" | "scrollTop" | "scrollWidth";
-    SCROLL_SIZE: "clientHeight" | "clientWidth" | "scrollHeight" | "scrollLeft" | "scrollTop" | "scrollWidth";
-    START: "width" | "height" | "x" | "y" | "left" | "top" | "right" | "bottom";
+    SCROLL_POS: "scrollTop" | "scrollHeight" | "scrollWidth" | "clientHeight" | "clientWidth" | "scrollLeft";
+    SCROLL_SIZE: "scrollTop" | "scrollHeight" | "scrollWidth" | "clientHeight" | "clientWidth" | "scrollLeft";
+    START: "width" | "height" | "left" | "right" | "top" | "bottom" | "x" | "y";
 } | {
-    CLIENT_POS: "clientX" | "clientY";
-    CLIENT_SIZE: "clientHeight" | "clientWidth" | "scrollHeight" | "scrollLeft" | "scrollTop" | "scrollWidth";
-    CONTRA: "width" | "height" | "x" | "y" | "left" | "top" | "right" | "bottom";
-    CONTRA_CLIENT_POS: "clientX" | "clientY";
+    CLIENT_POS: "clientY" | "clientX";
+    CLIENT_SIZE: "scrollTop" | "scrollHeight" | "scrollWidth" | "clientHeight" | "clientWidth" | "scrollLeft";
+    CONTRA: "width" | "height" | "left" | "right" | "top" | "bottom" | "x" | "y";
+    CONTRA_CLIENT_POS: "clientY" | "clientX";
     CONTRA_END: "width" | "height";
     CONTRA_POS: ElementPosition;
     DIMENSION: "width" | "height";
-    END: "width" | "height" | "x" | "y" | "left" | "top" | "right" | "bottom";
+    END: "width" | "height" | "left" | "right" | "top" | "bottom" | "x" | "y";
     POS: ElementPosition;
-    SCROLL_POS: "clientHeight" | "clientWidth" | "scrollHeight" | "scrollLeft" | "scrollTop" | "scrollWidth";
-    SCROLL_SIZE: "clientHeight" | "clientWidth" | "scrollHeight" | "scrollLeft" | "scrollTop" | "scrollWidth";
-    START: "width" | "height" | "x" | "y" | "left" | "top" | "right" | "bottom";
+    SCROLL_POS: "scrollTop" | "scrollHeight" | "scrollWidth" | "clientHeight" | "clientWidth" | "scrollLeft";
+    SCROLL_SIZE: "scrollTop" | "scrollHeight" | "scrollWidth" | "clientHeight" | "clientWidth" | "scrollLeft";
+    START: "width" | "height" | "left" | "right" | "top" | "bottom" | "x" | "y";
 };
 export declare const getItemById: (measuredItems: MeasuredDropTarget[], id: string) => MeasuredDropTarget | undefined;
 export declare const removeDraggedItem: (measuredItems: MeasuredDropTarget[], index: number) => void;

package/types/drag-drop/index.d.ts

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

package/types/drag-drop/useAutoScroll.d.ts

@@ -3,7 +3,7 @@ export type ScrollStopHandler = (scrollDirection: "fwd" | "bwd", scrollPos: numb
 export declare const useAutoScroll: ({ containerRef, onScrollingStopped, orientation, }: {
     containerRef: RefObject<HTMLElement>;
     onScrollingStopped?: ScrollStopHandler | undefined;
-    orientation?: "vertical" | "horizontal" | undefined;
+    orientation?: "horizontal" | "vertical" | undefined;
 }) => {
     isScrolling: import("react").MutableRefObject<boolean>;
     startScrolling: (direction: "fwd" | "bwd", scrollRate: number, scrollUnit?: any) => void;

package/types/drag-drop/useDragDisplacers.d.ts

@@ -1,5 +1,5 @@
 import type { orientationType } from "@vuu-ui/vuu-utils";
-import { Direction } from "./dragDropTypesNext";
+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") => void;

package/types/drag-drop/useDragDrop.d.ts

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

package/types/drag-drop/useDragDropCopy.d.ts

@@ -1,2 +1,2 @@
-import { InternalDragDropProps, InternalDragHookResult } from "./dragDropTypesNext";
+import { InternalDragDropProps, InternalDragHookResult } from "./dragDropTypes";
 export declare const useDragDropCopy: ({ selected, viewportRange, }: InternalDragDropProps) => InternalDragHookResult;

package/types/drag-drop/useDragDropIndicator.d.ts

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

package/types/drag-drop/{useDragDropNaturalMovementNext.d.ts → useDragDropNaturalMovement.d.ts}

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

package/types/index.d.ts

@@ -1,6 +1,8 @@
+export * from "./calendar";
 export * from "./combo-box";
 export * from "./common-hooks";
 export * from "./cycle-state-button";
+export * from "./date-picker";
 export * from "./drag-drop";
 export * from "./dropdown";
 export * from "./editable";

package/types/tabstrip/Tab.d.ts

@@ -1,7 +1,7 @@
 import { MenuActionHandler } from "@vuu-ui/vuu-data-types";
 import { KeyboardEvent, MouseEvent } from "react";
 import "./Tab.css";
-export declare const Tab: import("react").ForwardRefExoticComponent<Omit<import("react").HTMLAttributes<HTMLElement>, "onKeyUp" | "onClick"> & {
+export declare const Tab: import("react").ForwardRefExoticComponent<Omit<import("react").HTMLAttributes<HTMLElement>, "onClick" | "onKeyUp"> & {
     ariaControls?: string | undefined;
     closeable?: boolean | undefined;
     draggable?: boolean | undefined;
@@ -23,5 +23,5 @@ export declare const Tab: import("react").ForwardRefExoticComponent<Omit<import(
     onKeyUp?: ((e: KeyboardEvent<Element>, index: number) => void) | undefined;
     onMenuAction?: MenuActionHandler | undefined;
     onMenuClose?: (() => void) | undefined;
-    orientation?: "vertical" | "horizontal" | undefined;
+    orientation?: "horizontal" | "vertical" | undefined;
 } & import("react").RefAttributes<HTMLDivElement>>;

package/types/drag-drop/useDragDropNext.d.ts

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