@vuu-ui/vuu-table 0.8.12 → 0.8.13

package/types/vuu-table/src/{table-next/table-cell → table-cell}/TableGroupCell.d.ts

@@ -1,4 +1,4 @@
 /// <reference types="react" />
-import { TableCellProps } from "@vuu-ui/vuu-datagrid-types";
+import { TableCellProps } from "@vuu-ui/vuu-table-types";
 import "./TableGroupCell.css";
 export declare const TableGroupCell: ({ column, onClick, row }: TableCellProps) => JSX.Element;

package/types/vuu-table/src/{table-next/table-config.d.ts → table-config.d.ts}

@@ -1,4 +1,4 @@
-import { ColumnDescriptor, TableConfig } from "@vuu-ui/vuu-datagrid-types";
+import { ColumnDescriptor, TableConfig } from "@vuu-ui/vuu-table-types";
 export type MoveColumnTableConfigAction = {
     type: "col-move";
     column: ColumnDescriptor;

package/types/vuu-table/src/{table-next/table-dom-utils.d.ts → table-dom-utils.d.ts}

@@ -4,4 +4,6 @@ export declare const headerCellQuery: (colIdx: number) => string;
 export declare const dataCellQuery: (rowIdx: number, colIdx: number) => string;
 export declare const getTableCell: (containerRef: RefObject<HTMLElement>, [rowIdx, colIdx]: CellPos) => HTMLElement;
 export declare const cellIsEditable: (cell: HTMLDivElement) => boolean;
-export declare const cellIsTextInput: (cell: HTMLDivElement) => boolean;
+export declare const cellIsTextInput: (cell: HTMLElement) => boolean;
+export declare function getRowIndex(rowEl?: HTMLElement): number;
+export declare const closestRowIndex: (el: HTMLElement) => number;

package/types/vuu-table/src/table-header/TableHeader.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="react" />
+import { ColumnDescriptor, RuntimeColumnDescriptor, TableConfig, TableHeadings } from "@vuu-ui/vuu-table-types";
+import { VuuSortType } from "packages/vuu-protocol-types";
+import { TableColumnResizeHandler } from "../column-resizing";
+export type ColumnSortHandler = (column: ColumnDescriptor, addToExistingSort: boolean, sortType?: VuuSortType) => void;
+export interface TableHeaderProps {
+    classBase?: string;
+    columns: RuntimeColumnDescriptor[];
+    headings: TableHeadings;
+    onResizeColumn: TableColumnResizeHandler;
+    onMoveColumn: (columns: ColumnDescriptor[]) => void;
+    onMoveGroupColumn: (columns: ColumnDescriptor[]) => void;
+    onRemoveGroupColumn: (column: RuntimeColumnDescriptor) => void;
+    onSortColumn: ColumnSortHandler;
+    tableConfig: TableConfig;
+    tableId: string;
+}
+export declare const TableHeader: ({ classBase, columns, headings, onMoveColumn, onMoveGroupColumn, onRemoveGroupColumn, onResizeColumn, onSortColumn, tableConfig, tableId, }: TableHeaderProps) => JSX.Element;

package/types/vuu-table/src/table-header/useTableHeader.d.ts

@@ -0,0 +1,15 @@
+import { ColumnDescriptor } from "@vuu-ui/vuu-table-types";
+import { MouseEventHandler } from "react";
+import { TableHeaderProps } from "./TableHeader";
+export interface TableHeaderHookProps extends Pick<TableHeaderProps, "columns" | "onMoveColumn" | "onSortColumn" | "tableConfig"> {
+    label?: string;
+    onMoveColumn: (columns: ColumnDescriptor[]) => void;
+    onSortColumn: (column: ColumnDescriptor, addToExistingSort: boolean) => void;
+}
+export declare const useTableHeader: ({ columns, onMoveColumn, onSortColumn, tableConfig, }: TableHeaderHookProps) => {
+    containerRef: import("react").RefObject<HTMLDivElement>;
+    draggableColumn: JSX.Element | undefined;
+    draggedColumnIndex: number | undefined;
+    onClick: MouseEventHandler<HTMLDivElement>;
+    onMouseDown: MouseEventHandler<Element> | undefined;
+};

package/types/vuu-table/src/useCell.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import { RuntimeColumnDescriptor } from "@vuu-ui/vuu-table-types";
+export declare const useCell: (column: RuntimeColumnDescriptor, classBase: string, isHeader?: boolean) => {
+    className: string;
+    style: import("react").CSSProperties;
+};

package/types/vuu-table/src/useCellEditing.d.ts

@@ -0,0 +1,10 @@
+import { FocusEventHandler, KeyboardEvent as ReactKeyboardEvent, MouseEvent } from "react";
+export interface CellEditingHookProps {
+    navigate: () => void;
+}
+export declare const useCellEditing: ({ navigate }: CellEditingHookProps) => {
+    onBlur: FocusEventHandler<Element>;
+    onDoubleClick: (e: MouseEvent<HTMLElement>) => void;
+    onFocus: FocusEventHandler<Element>;
+    onKeyDown: (e: ReactKeyboardEvent<HTMLElement>) => void;
+};

package/types/vuu-table/src/useControlledTableNavigation.d.ts

@@ -0,0 +1,7 @@
+import { KeyboardEventHandler } from "react";
+export declare const useControlledTableNavigation: (initialValue: number, rowCount: number) => {
+    highlightedIndexRef: import("react").MutableRefObject<number | undefined>;
+    onHighlight: (idx: number) => void;
+    onKeyDown: KeyboardEventHandler<Element>;
+    tableRef: import("react").RefObject<HTMLDivElement>;
+};

package/types/vuu-table/src/{table-next/useDataSource.d.ts → useDataSource.d.ts}

@@ -1,17 +1,19 @@
-import { DataSource, DataSourceSubscribedMessage, VuuFeatureInvocationMessage, VuuFeatureMessage } from "@vuu-ui/vuu-data";
+/// <reference types="react" />
+import { DataSource, DataSourceSubscribedMessage, VuuFeatureInvocationMessage } from "@vuu-ui/vuu-data";
 import { DataSourceRow } from "@vuu-ui/vuu-data-types";
 import { VuuRange } from "@vuu-ui/vuu-protocol-types";
 export interface DataSourceHookProps {
     dataSource: DataSource;
-    onFeatureEnabled?: (message: VuuFeatureMessage) => void;
     onFeatureInvocation?: (message: VuuFeatureInvocationMessage) => void;
     onSizeChange: (size: number) => void;
     onSubscribed: (subscription: DataSourceSubscribedMessage) => void;
     range?: VuuRange;
     renderBufferSize?: number;
 }
-export declare const useDataSource: ({ dataSource, onFeatureEnabled, onFeatureInvocation, onSizeChange, onSubscribed, range, renderBufferSize, }: DataSourceHookProps) => {
+export declare const useDataSource: ({ dataSource, onFeatureInvocation, onSizeChange, onSubscribed, range, renderBufferSize, }: DataSourceHookProps) => {
     data: DataSourceRow[];
+    dataRef: import("react").MutableRefObject<DataSourceRow[]>;
+    getSelectedRows: () => DataSourceRow[];
     range: VuuRange;
     setRange: (range: VuuRange) => void;
 };

package/types/vuu-table/src/{table-next/useKeyboardNavigation.d.ts → useKeyboardNavigation.d.ts}

@@ -1,7 +1,7 @@
 import { VuuRange } from "@vuu-ui/vuu-protocol-types";
 import { KeyboardEvent, MouseEvent, RefObject } from "react";
 import { ScrollRequestHandler } from "./useTableScroll";
-import { TableNavigationStyle } from "../table/dataTableTypes";
+import { TableNavigationStyle } from "./Table";
 export declare const isNavigationKey: (key: string, navigationStyle: TableNavigationStyle) => key is NavigationKey;
 type ArrowKey = "ArrowUp" | "ArrowDown" | "ArrowLeft" | "ArrowRight";
 type PageKey = "Home" | "End" | "PageUp" | "PageDown";
@@ -10,20 +10,27 @@ export declare const isPagingKey: (key: string) => key is PageKey;
 export interface NavigationHookProps {
     containerRef: RefObject<HTMLElement>;
     columnCount?: number;
+    defaultHighlightedIndex?: number;
+    disableFocus?: boolean;
     disableHighlightOnFocus?: boolean;
+    highlightedIndex?: number;
     label?: string;
     navigationStyle: TableNavigationStyle;
     viewportRange: VuuRange;
+    onHighlight?: (idx: number) => void;
     requestScroll?: ScrollRequestHandler;
     restoreLastFocus?: boolean;
     rowCount?: number;
     selected?: unknown;
     viewportRowCount: number;
 }
-export declare const useKeyboardNavigation: ({ columnCount, containerRef, disableHighlightOnFocus, navigationStyle, requestScroll, rowCount, viewportRowCount, }: NavigationHookProps) => {
+export declare const useKeyboardNavigation: ({ columnCount, containerRef, disableFocus, defaultHighlightedIndex, disableHighlightOnFocus, highlightedIndex: highlightedIndexProp, navigationStyle, requestScroll, onHighlight, rowCount, viewportRowCount, }: NavigationHookProps) => {
+    highlightedIndexRef: import("react").MutableRefObject<number | undefined>;
     navigate: () => void;
     onClick: (evt: MouseEvent) => void;
     onFocus: () => void;
     onKeyDown: (e: KeyboardEvent) => void;
+    onMouseLeave: (() => void) | undefined;
+    onMouseMove: ((evt: MouseEvent) => void) | undefined;
 };
 export {};

package/types/vuu-table/src/useSelection.d.ts

@@ -0,0 +1,14 @@
+import { RowClickHandler, SelectionChangeHandler, TableSelectionModel } from "@vuu-ui/vuu-table-types";
+import { DataSourceRow } from "packages/vuu-data-types";
+import { KeyboardEventHandler, MutableRefObject } from "react";
+export interface SelectionHookProps {
+    highlightedIndexRef: MutableRefObject<number | undefined>;
+    selectionKeys?: string[];
+    selectionModel: TableSelectionModel;
+    onSelect?: (row: DataSourceRow) => void;
+    onSelectionChange: SelectionChangeHandler;
+}
+export declare const useSelection: ({ highlightedIndexRef, selectionKeys, selectionModel, onSelect, onSelectionChange, }: SelectionHookProps) => {
+    onKeyDown: KeyboardEventHandler<HTMLElement>;
+    onRowClick: RowClickHandler;
+};

package/types/vuu-table/src/useTable.d.ts

@@ -0,0 +1,66 @@
+import { DataSourceRow } from "@vuu-ui/vuu-data-types";
+import { ColumnDescriptor, DataCellEditHandler, RowClickHandler, RuntimeColumnDescriptor, TableConfig, TableSelectionModel } from "@vuu-ui/vuu-table-types";
+import { MeasuredProps, MeasuredSize } from "@vuu-ui/vuu-layout";
+import { VuuSortType } from "@vuu-ui/vuu-protocol-types";
+import { FocusEvent, KeyboardEvent, RefObject } from "react";
+import { TableColumnResizeHandler } from "./column-resizing";
+import { TableProps } from "./Table";
+export interface TableHookProps extends MeasuredProps, Pick<TableProps, "allowDragDrop" | "availableColumns" | "config" | "dataSource" | "disableFocus" | "highlightedIndex" | "id" | "navigationStyle" | "onAvailableColumnsChange" | "onConfigChange" | "onDragStart" | "onDrop" | "onFeatureInvocation" | "onHighlight" | "onSelect" | "onSelectionChange" | "onRowClick" | "renderBufferSize"> {
+    containerRef: RefObject<HTMLDivElement>;
+    headerHeight: number;
+    rowHeight: number;
+    selectionModel: TableSelectionModel;
+    size: MeasuredSize;
+}
+export declare const useTable: ({ allowDragDrop, availableColumns, config, containerRef, dataSource, disableFocus, headerHeight, highlightedIndex: highlightedIndexProp, id, navigationStyle, onAvailableColumnsChange, onConfigChange, onDragStart, onDrop, onFeatureInvocation, onHighlight, onRowClick: onRowClickProp, onSelect, onSelectionChange, renderBufferSize, rowHeight, selectionModel, size, }: TableHookProps) => {
+    draggableRow: JSX.Element | undefined;
+    onBlur: import("react").FocusEventHandler<Element>;
+    onDoubleClick: (e: import("react").MouseEvent<HTMLElement, MouseEvent>) => void;
+    onFocus: (e: FocusEvent<HTMLElement>) => void;
+    onKeyDown: (e: KeyboardEvent<HTMLElement>) => void;
+    onMouseDown: import("react").MouseEventHandler<Element> | undefined;
+    columnMap: import("@vuu-ui/vuu-utils").ColumnMap;
+    columns: RuntimeColumnDescriptor[];
+    data: DataSourceRow[];
+    handleContextMenuAction: import("@vuu-ui/vuu-data-types").MenuActionHandler;
+    headings: import("@vuu-ui/vuu-table-types").TableHeadings;
+    highlightedIndex: number | undefined;
+    menuBuilder: import("@vuu-ui/vuu-data-types").MenuBuilder<string, unknown>;
+    onContextMenu: (evt: import("react").MouseEvent<HTMLElement, MouseEvent>) => void;
+    onDataEdited: DataCellEditHandler;
+    onMoveColumn: (columns: ColumnDescriptor[]) => void;
+    onMoveGroupColumn: (columns: ColumnDescriptor[]) => void;
+    onRemoveGroupColumn: (column: RuntimeColumnDescriptor) => void;
+    onRowClick: RowClickHandler;
+    onSortColumn: (column: ColumnDescriptor, extendSort?: any, sortType?: VuuSortType) => void;
+    onResizeColumn: TableColumnResizeHandler;
+    onToggleGroup: (row: DataSourceRow, column: RuntimeColumnDescriptor) => void;
+    scrollProps: {
+        scrollbarContainerRef: (el: HTMLDivElement | null) => void;
+        contentContainerRef: (el: HTMLDivElement | null) => void;
+    };
+    tableAttributes: {
+        columnDefaultWidth?: number | undefined;
+        columnFormatHeader?: "capitalize" | "uppercase" | undefined;
+        columnSeparators?: boolean | undefined;
+        rowSeparators?: boolean | undefined;
+        zebraStripes?: boolean | undefined;
+    };
+    tableConfig: Readonly<TableConfig>;
+    viewportMeasurements: {
+        contentHeight: number;
+        horizontalScrollbarHeight: number;
+        maxScrollContainerScrollHorizontal: number;
+        maxScrollContainerScrollVertical: number;
+        pinnedWidthLeft: number;
+        pinnedWidthRight: number;
+        rowCount: number;
+        contentWidth: number;
+        totalHeaderHeight: number;
+        verticalScrollbarWidth: number;
+        viewportBodyHeight: number;
+    };
+    onClick: (evt: import("react").MouseEvent<Element, MouseEvent>) => void;
+    onMouseLeave: (() => void) | undefined;
+    onMouseMove: ((evt: import("react").MouseEvent<Element, MouseEvent>) => void) | undefined;
+};

package/types/vuu-table/src/useTableContextMenu.d.ts

@@ -0,0 +1,11 @@
+import { DataSource } from "@vuu-ui/vuu-data";
+import { DataSourceRow } from "@vuu-ui/vuu-data-types";
+import { RuntimeColumnDescriptor } from "@vuu-ui/vuu-table-types";
+import { MouseEvent } from "react";
+export interface TableContextMenuHookProps {
+    columns: RuntimeColumnDescriptor[];
+    data: DataSourceRow[];
+    dataSource: DataSource;
+    getSelectedRows: () => DataSourceRow[];
+}
+export declare const useTableContextMenu: ({ columns, data, dataSource, getSelectedRows, }: TableContextMenuHookProps) => (evt: MouseEvent<HTMLElement>) => void;

package/types/vuu-table/src/{table-next/useTableModel.d.ts → useTableModel.d.ts}

@@ -1,5 +1,5 @@
-import { ColumnDescriptor, KeyedColumnDescriptor, PinLocation, TableAttributes, TableConfig, TableHeadings } from "@vuu-ui/vuu-datagrid-types";
-import { DataSourceConfig } from "@vuu-ui/vuu-data";
+import { ColumnDescriptor, RuntimeColumnDescriptor, PinLocation, TableAttributes, TableConfig, TableHeadings } from "@vuu-ui/vuu-table-types";
+import { DataSource, DataSourceConfig } from "@vuu-ui/vuu-data";
 import { TableSchema } from "@vuu-ui/vuu-data/src/message-utils";
 import { VuuTable } from "@vuu-ui/vuu-protocol-types";
 import { Reducer } from "react";
@@ -9,7 +9,7 @@ import { Reducer } from "react";
  * data-related config from DataSource.
  */
 export interface TableModel extends TableAttributes {
-    columns: KeyedColumnDescriptor[];
+    columns: RuntimeColumnDescriptor[];
     headings: TableHeadings;
 }
 /**
@@ -23,21 +23,20 @@ interface InternalTableModel extends TableModel {
 export interface ColumnActionInit {
     type: "init";
     tableConfig: TableConfig;
-    dataSourceConfig?: DataSourceConfig;
+    dataSource: DataSource;
 }
 export interface ColumnActionHide {
     type: "hideColumns";
-    columns: KeyedColumnDescriptor[];
+    columns: RuntimeColumnDescriptor[];
 }
 export interface ColumnActionShow {
     type: "showColumns";
-    columns: KeyedColumnDescriptor[];
+    columns: RuntimeColumnDescriptor[];
 }
 export interface ColumnActionMove {
     type: "moveColumn";
-    column: KeyedColumnDescriptor;
+    column: RuntimeColumnDescriptor;
     moveBy?: 1 | -1;
-    moveTo?: number;
 }
 export interface ColumnActionPin {
     type: "pinColumn";
@@ -47,7 +46,7 @@ export interface ColumnActionPin {
 export type ResizePhase = "begin" | "resize" | "end";
 export interface ColumnActionResize {
     type: "resizeColumn";
-    column: KeyedColumnDescriptor;
+    column: RuntimeColumnDescriptor;
     phase: ResizePhase;
     width?: number;
 }
@@ -61,10 +60,10 @@ export interface ColumnActionUpdate {
 }
 export interface ColumnActionUpdateProp {
     align?: ColumnDescriptor["align"];
-    column: KeyedColumnDescriptor;
+    column: RuntimeColumnDescriptor;
     hidden?: ColumnDescriptor["hidden"];
     label?: ColumnDescriptor["label"];
-    resizing?: KeyedColumnDescriptor["resizing"];
+    resizing?: RuntimeColumnDescriptor["resizing"];
     type: "updateColumnProp";
     width?: ColumnDescriptor["width"];
 }
@@ -90,15 +89,14 @@ export type PersistentColumnAction = ColumnActionPin | ColumnActionHide | Column
 export type GridModelAction = ColumnActionHide | ColumnActionInit | ColumnActionMove | ColumnActionPin | ColumnActionResize | ColumnActionSetTableSchema | ColumnActionShow | ColumnActionUpdate | ColumnActionUpdateProp | ColumnActionTableConfig;
 export type GridModelReducer = Reducer<InternalTableModel, GridModelAction>;
 export type ColumnActionDispatch = (action: GridModelAction) => void;
-export declare const useTableModel: (tableConfigProp: TableConfig, dataSourceConfig?: DataSourceConfig) => {
-    columns: KeyedColumnDescriptor[];
+export declare const useTableModel: (tableConfigProp: TableConfig, dataSource: DataSource) => {
+    columns: RuntimeColumnDescriptor[];
     dispatchColumnAction: import("react").Dispatch<GridModelAction>;
     headings: TableHeadings;
     tableAttributes: {
         columnDefaultWidth?: number | undefined;
         columnFormatHeader?: "capitalize" | "uppercase" | undefined;
         columnSeparators?: boolean | undefined;
-        showHighlightedRow?: boolean | undefined;
         rowSeparators?: boolean | undefined;
         zebraStripes?: boolean | undefined;
     };

package/types/vuu-table/src/{table-next/useTableViewport.d.ts → useTableViewport.d.ts}

@@ -3,11 +3,11 @@
  * and virtualisation of the table. This includes measurements required
  * to support pinned columns.
  */
-import { KeyedColumnDescriptor, TableHeadings } from "@vuu-ui/vuu-datagrid-types";
+import { RuntimeColumnDescriptor, TableHeadings } from "@vuu-ui/vuu-table-types";
 import { MeasuredSize } from "@vuu-ui/vuu-layout";
 import { RowAtPositionFunc, RowOffsetFunc } from "@vuu-ui/vuu-utils";
 export interface TableViewportHookProps {
-    columns: KeyedColumnDescriptor[];
+    columns: RuntimeColumnDescriptor[];
     headerHeight: number;
     headings: TableHeadings;
     rowCount: number;

package/types/vuu-table/src/{table-next/useVirtualViewport.d.ts → useVirtualViewport.d.ts}

@@ -1,9 +1,9 @@
-import { KeyedColumnDescriptor } from "@vuu-ui/vuu-datagrid-types";
+import { RuntimeColumnDescriptor } from "@vuu-ui/vuu-table-types";
 import { VuuRange } from "@vuu-ui/vuu-protocol-types";
 import { RowAtPositionFunc } from "@vuu-ui/vuu-utils";
 import { ViewportMeasurements } from "@vuu-ui/vuu-table";
 export interface VirtualViewportHookProps {
-    columns: KeyedColumnDescriptor[];
+    columns: RuntimeColumnDescriptor[];
     getRowAtPosition: RowAtPositionFunc;
     setRange: (range: VuuRange) => void;
     viewportMeasurements: ViewportMeasurements;

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

@@ -0,0 +1,15 @@
+import { MouseOffset } from "./dragDropTypesNext";
+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(evt: MouseEvent, dragElement: HTMLElement);
+    /** Used to capture a ref to the Draggable JSX.Element */
+    setDraggable: (el: HTMLElement | null) => void;
+    setPayload(payload: unknown): void;
+    private getMouseOffset;
+}

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

@@ -0,0 +1,91 @@
+import { MouseEventHandler, RefObject } from "react";
+import { 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 MouseOffset {
+    x: number;
+    y: number;
+}
+export type Rect = {
+    height: number;
+    left: number;
+    top: number;
+    width: number;
+};
+export interface DragHookResult {
+    draggable?: JSX.Element;
+    dropIndicator?: JSX.Element;
+    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: () => void;
+    handleScrollStart?: () => 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 = (fromIndex: number, toIndex: number, options: DropOptions) => void;
+export interface DragDropProps {
+    allowDragDrop?: boolean | dragStrategy;
+    /** 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;
+    onDragStart?: DragStartHandler;
+    onDrop: DropHandler;
+    onDropSettle?: (toIndex: number) => void;
+    orientation: orientationType;
+    containerRef: RefObject<HTMLElement>;
+    itemQuery?: string;
+    viewportRange?: ViewportRange;
+}
+export type DragDropHook = (props: DragDropProps) => DragHookResult;
+export interface InternalDragDropProps extends Omit<DragDropProps, "draggableClassName" | "id"> {
+    isDragSource?: boolean;
+    isDropTarget?: boolean;
+    selected?: unknown;
+}
+export type DragDropContext = {
+    dragElement: HTMLElement;
+    dragPayload: unknown;
+    mouseOffset: MouseOffset;
+};
+export {};

package/types/vuu-layout/src/Component.d.ts

@@ -1,7 +0,0 @@
-import React, { HTMLAttributes } from 'react';
-import './Component.css';
-export interface ComponentProps extends HTMLAttributes<HTMLDivElement> {
-    resizeable?: boolean;
-}
-declare const Component: React.FunctionComponent<ComponentProps>;
-export default Component;

package/types/vuu-layout/src/DraggableLayout.d.ts

@@ -1,7 +0,0 @@
-import { HTMLAttributes } from "react";
-import "./DraggableLayout.css";
-export interface DraggableLayoutProps extends HTMLAttributes<HTMLDivElement> {
-    dropTarget?: boolean;
-    resizeable?: boolean;
-}
-export declare const DraggableLayout: import("react").ForwardRefExoticComponent<DraggableLayoutProps & import("react").RefAttributes<HTMLDivElement>>;

package/types/vuu-layout/src/dock-layout/DockLayout.d.ts

@@ -1,10 +0,0 @@
-import { HTMLAttributes, ReactElement } from "react";
-import "./DockLayout.css";
-export interface DockLayoutProps extends HTMLAttributes<HTMLDivElement> {
-    children: ReactElement[];
-}
-declare const DockLayout: {
-    (props: DockLayoutProps): JSX.Element;
-    displayName: string;
-};
-export default DockLayout;

package/types/vuu-layout/src/dock-layout/Drawer.d.ts

@@ -1,18 +0,0 @@
-import { HTMLAttributes } from "react";
-import "./Drawer.css";
-export interface DrawerProps extends HTMLAttributes<HTMLDivElement> {
-    clickToOpen?: boolean;
-    defaultOpen?: boolean;
-    inline?: boolean;
-    open?: boolean;
-    peekaboo?: boolean;
-    position?: "left" | "right" | "top" | "bottom";
-    sizeOpen?: number;
-    sizeClosed?: number;
-    toggleButton?: "start" | "end";
-}
-declare const Drawer: {
-    ({ children, className: classNameProp, clickToOpen, defaultOpen, sizeOpen, sizeClosed, style: styleProp, open: openProp, position, inline, onClick, peekaboo, toggleButton, ...props }: DrawerProps): JSX.Element;
-    displayName: string;
-};
-export default Drawer;

package/types/vuu-layout/src/dock-layout/index.d.ts

@@ -1,2 +0,0 @@
-export { default as DockLayout } from "./DockLayout";
-export { default as Drawer } from "./Drawer";