@elliemae/ds-drag-and-drop 2.3.0-alpha.8 → 2.3.0-alpha.9

package/dist/types/hierarchy/customCollisionDetection.d.ts

@@ -0,0 +1,3 @@
+import { CollisionDetection } from '@dnd-kit/core';
+import { Item } from './types';
+export declare const customCollisionDetection: (activeId: string | null, activeParent: string | undefined, dndItems: Item[]) => CollisionDetection;

package/dist/types/hierarchy/getHierarchyKeyboardCoordinates.d.ts

@@ -0,0 +1,3 @@
+import { KeyboardCoordinateGetter } from '@dnd-kit/core';
+import { SensorContext } from './types';
+export declare const getHierarchyKeyboardCoordinates: (context: SensorContext, dragOverlayDataTestid: string, isHorizontalDnD: boolean) => KeyboardCoordinateGetter;

package/dist/types/hierarchy/index.d.ts

@@ -0,0 +1 @@
+export * from './useHierarchyDndkitConfig';

package/dist/types/hierarchy/types.d.ts

@@ -0,0 +1,80 @@
+import type { Active, Announcements, CollisionDetection, DragEndEvent, DragMoveEvent, DragOverEvent, DragStartEvent, MeasuringConfiguration, Modifier, Over, SensorDescriptor, SensorOptions } from '@dnd-kit/core';
+import { DroppableContainers } from '@dnd-kit/core/dist/store';
+import { Coordinates, DragCancelEvent, ViewRect } from '@dnd-kit/core/dist/types';
+import { MutableRefObject } from 'react';
+export declare type Item = {
+    id: string;
+    depth: number;
+    parentId: string;
+    index: number;
+};
+export declare type DndContextPropsType = {
+    announcements: Announcements;
+    modifiers: Modifier[];
+    sensors: SensorDescriptor<SensorOptions>[];
+    measuring: Partial<MeasuringConfiguration>;
+    collisionDetection: CollisionDetection;
+    onDragStart: (e: DragStartEvent) => void;
+    onDragMove: (e: DragMoveEvent) => void;
+    onDragOver: (e: DragOverEvent) => void;
+    onDragEnd: (e: DragEndEvent) => void;
+    onDragCancel: (e: DragCancelEvent) => void;
+};
+export declare type useHierarchyPreviewHandlersReturn = {
+    handlePreviewDragStart: (e: DragStartEvent) => void;
+    handlePreviewDragMove: (e: DragMoveEvent) => void;
+    handlePreviewDragEnd: (e: DragEndEvent) => void;
+    handlePreviewDragCancel: (e: DragCancelEvent) => void;
+};
+export declare type useHierarchyPreviewHandlersArgs = {
+    setActiveId: React.Dispatch<React.SetStateAction<string>>;
+    onPreviewResetState: () => void;
+    onPreviewDragStart: () => void;
+};
+export declare type useHierarchyActionHandlersArgs = useHierarchyPreviewHandlersReturn & {
+    dndItems: Item[];
+    onReorder: (movedItem: Item, indexes: {
+        targetIndex: number;
+        fromIndex: number;
+    }) => void;
+};
+export declare type useHierarchyActionHandlersReturn = {
+    onDragStart: (e: DragStartEvent) => void;
+    onDragMove: (e: DragMoveEvent) => void;
+    onDragOver: (e: DragOverEvent) => void;
+    onDragEnd: (e: DragEndEvent) => void;
+    onDragCancel: (e: DragCancelEvent) => void;
+};
+export declare type useHierarchyDndkitConfigArgs = {
+    indentationWidth?: number;
+    dragOverlayDataTestid: string;
+    flattenedItems: [Item, unknown][];
+    isHorizontalDnD?: boolean;
+    onReorder: (movedItem: Item, indexes: {
+        targetIndex: number;
+        fromIndex: number;
+    }) => void;
+    onPreviewResetState: () => void;
+    onPreviewDragStart: () => void;
+};
+export declare type useHierarchyDndkitConfigType = (args: useHierarchyDndkitConfigArgs) => useHierarchyDndkitConfigReturn;
+export declare type useHierarchyDndkitConfigReturn = {
+    dndContextProps: DndContextPropsType;
+    activeId: string | null;
+    overId: string | null;
+    activeIndex: number | undefined;
+};
+export declare type GetKeyboardCoordinatesArgs = {
+    items: Item[];
+    active: Active | null;
+    over: Over | null;
+    event: KeyboardEvent;
+    currentCoordinates: Coordinates;
+    droppableContainers: DroppableContainers;
+    collisionRect: ViewRect;
+    dragOverlayDataTestid: string;
+};
+export declare type SensorContext = MutableRefObject<{
+    items: Item[];
+    offset?: number;
+}>;

package/dist/types/hierarchy/useHierarchyActionHandlers.d.ts

@@ -0,0 +1 @@
+export declare const useHierarchyActionHandlers: ({ handlePreviewDragStart, handlePreviewDragMove, handlePreviewDragEnd, handlePreviewDragCancel, onReorder, dndItems, }: UseHierarchyActionHandlersArgs) => UseHierarchyActionHandlersReturn;

package/dist/types/hierarchy/useHierarchyAnnouncements.d.ts

@@ -0,0 +1,3 @@
+import { Announcements } from '@dnd-kit/core';
+import { Item } from './types';
+export declare const useHierarchyAnnouncements: (visibleItemsDictionary: Record<string, Item>) => Announcements;

package/dist/types/hierarchy/useHierarchyDndkitConfig.d.ts

@@ -0,0 +1,2 @@
+import type { UseHierarchyDndkitConfigType } from './types';
+export declare const useHierarchyDndkitConfig: UseHierarchyDndkitConfigType;

package/dist/types/hierarchy/useHierarchyPreviewHandlers.d.ts

@@ -0,0 +1,2 @@
+import type { useHierarchyPreviewHandlersReturn, useHierarchyPreviewHandlersArgs } from './types';
+export declare const useHierarchyPreviewHandlers: ({ setActiveId, onPreviewResetState, onPreviewDragStart, }: useHierarchyPreviewHandlersArgs) => useHierarchyPreviewHandlersReturn;

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './hierarchy';
+export * from './tree';

package/dist/types/tree/constants.d.ts

@@ -0,0 +1,6 @@
+export declare enum DropIndicatorPosition {
+    None = 0,
+    Before = 1,
+    After = 2,
+    Inside = 3
+}

package/dist/types/tree/customCollisionDetection.d.ts

@@ -0,0 +1,4 @@
+import { CollisionDetection } from '@dnd-kit/core';
+import { DropIndicatorPosition } from './constants';
+import { Item } from './types';
+export declare const customCollisionDetection: (activeId: string, visibleItemsDictionary: Record<string, Item>, setDropIndicatorPosition: React.Dispatch<React.SetStateAction<DropIndicatorPosition>>, maxDragAndDropLevel: number, lastPosition: string, setLastPosition: React.Dispatch<React.SetStateAction<string>>) => CollisionDetection;

package/dist/types/tree/getTreeKeyboardCoordinates.d.ts

@@ -0,0 +1,3 @@
+import { KeyboardCoordinateGetter } from '@dnd-kit/core';
+import type { SensorContext } from './types';
+export declare const getTreeKeyboardCoordinates: (context: SensorContext, isHorizontalDnD: boolean, maxDragAndDropLevel: number) => KeyboardCoordinateGetter;

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

@@ -0,0 +1 @@
+export * from './useTreeDndkitConfig';

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

@@ -0,0 +1,102 @@
+import { Active, Announcements, CollisionDetection, DragCancelEvent, DragEndEvent, DragMoveEvent, DragOverEvent, DragStartEvent, DroppableContainers, MeasuringConfiguration, Modifier, Over, ViewRect } from '@dnd-kit/core';
+import type { SensorDescriptor, SensorOptions } from '@dnd-kit/core/dist/sensors';
+import type { SortingStrategy } from '@dnd-kit/sortable';
+import { Coordinates } from '@dnd-kit/core/dist/types';
+import React, { MutableRefObject } from 'react';
+import { DropIndicatorPosition } from './constants';
+export declare type Item<T = unknown> = {
+    uid: string;
+    depth: number;
+    parentId: string | null;
+    realIndex: number;
+    childrenCount: number;
+    original: T;
+};
+export declare type DndContextPropsType = {
+    announcements: Announcements;
+    modifiers: Modifier[];
+    sensors: SensorDescriptor<SensorOptions>[];
+    measuring: Partial<MeasuringConfiguration>;
+    collisionDetection: CollisionDetection;
+    onDragStart: (e: DragStartEvent) => void;
+    onDragMove: (e: DragMoveEvent) => void;
+    onDragOver: (e: DragOverEvent) => void;
+    onDragEnd: (e: DragEndEvent) => void;
+    onDragCancel: (e: DragCancelEvent) => void;
+};
+export declare type SortableContextPropsType = {
+    items: string[];
+    strategy: SortingStrategy;
+};
+export declare type UseTreePreviewHandlersReturn = {
+    handlePreviewDragStart: (e: DragStartEvent) => void;
+    handlePreviewDragMove: (e: DragMoveEvent) => void;
+    handlePreviewDragOver: (e: DragOverEvent) => void;
+    handlePreviewDragEnd: (e: DragEndEvent) => void;
+    handlePreviewDragCancel: (e: DragCancelEvent) => void;
+};
+export declare type UseTreePreviewHandlersArgs = {
+    setOverId: React.Dispatch<React.SetStateAction<string>>;
+    setActiveId: React.Dispatch<React.SetStateAction<string>>;
+    setDropIndicatorPosition: React.Dispatch<React.SetStateAction<DropIndicatorPosition>>;
+};
+export declare type UseTreeActionHandlersArgs<T = unknown> = UseTreePreviewHandlersReturn & {
+    dropIndicatorPosition: DropIndicatorPosition;
+    flattenedItems: Item[];
+    projected: {
+        depth: number;
+        parentId: string;
+    } | null;
+    onReorder: <S = T>(newData: Item<S>[], indexes: {
+        targetIndex: number;
+        fromIndex: number;
+    }, considerExpanding: string) => void;
+    isDropValid: boolean;
+};
+export declare type UseTreeActionHandlersReturn = {
+    onDragStart: (e: DragStartEvent) => void;
+    onDragMove: (e: DragMoveEvent) => void;
+    onDragOver: (e: DragOverEvent) => void;
+    onDragEnd: (e: DragEndEvent) => void;
+    onDragCancel: (e: DragCancelEvent) => void;
+};
+export declare type UseTreeDndkitConfigArgs<T> = {
+    flattenedItems: Item[];
+    visibleItems: Item[];
+    isHorizontalDnD?: boolean;
+    isExpandable: boolean;
+    onReorder: <S = T>(newData: Item<S>[], indexes: {
+        targetIndex: number;
+        fromIndex: number;
+    }, considerExpanding: string) => void;
+    getIsDropValid: <S = T>(active: Item<S>, over: Item<S>, dropIndicatorPosition: 'none' | 'before' | 'after' | 'inside') => boolean;
+    maxDragAndDropLevel: number;
+};
+export declare type UseTreeDndkitConfigReturn = {
+    dndContextProps: DndContextPropsType;
+    sortableContextProps: SortableContextPropsType;
+    activeId: string;
+    activeIndex: number;
+    overId: string;
+    depth: number;
+    dropIndicatorPosition: DropIndicatorPosition;
+    isDropValid: boolean;
+    visibleItems: Item[];
+};
+export declare type UseTreeDndkitConfigType = <T = unknown>(args: UseTreeDndkitConfigArgs<T>) => UseTreeDndkitConfigReturn;
+export declare type GetKeyboardCoordinatesArgs = {
+    items: Item[];
+    active: Active;
+    over: Over;
+    event: KeyboardEvent;
+    currentCoordinates: Coordinates;
+    droppableContainers: DroppableContainers;
+    collisionRect: ViewRect;
+    dropIndicatorPosition: DropIndicatorPosition;
+    maxDragAndDropLevel: number;
+};
+export declare type SensorContext = MutableRefObject<{
+    items: Item[];
+    dropIndicatorPosition: DropIndicatorPosition;
+    setDropIndicatorPosition: React.Dispatch<React.SetStateAction<DropIndicatorPosition>>;
+}>;

package/dist/types/tree/useTreeActionHandlers.d.ts

@@ -0,0 +1,2 @@
+import type { UseTreeActionHandlersReturn, UseTreeActionHandlersArgs } from './types';
+export declare const useTreeActionHandlers: ({ handlePreviewDragStart, handlePreviewDragMove, handlePreviewDragOver, handlePreviewDragEnd, handlePreviewDragCancel, onReorder, flattenedItems, projected, dropIndicatorPosition, isDropValid, }: UseTreeActionHandlersArgs) => UseTreeActionHandlersReturn;

package/dist/types/tree/useTreeAnnouncements.d.ts

@@ -0,0 +1,4 @@
+import { Announcements } from '@dnd-kit/core';
+import { DropIndicatorPosition } from './constants';
+import { Item } from './types';
+export declare const useTreeAnnouncements: (visibleItemsDictionary: Record<string, Item>, dropIndicatorPosition: DropIndicatorPosition) => Announcements;

package/dist/types/tree/useTreeDndkitConfig.d.ts

@@ -0,0 +1,2 @@
+import type { UseTreeDndkitConfigType } from './types';
+export declare const useTreeDndkitConfig: UseTreeDndkitConfigType;

package/dist/types/tree/useTreePreviewHandlers.d.ts

@@ -0,0 +1,2 @@
+import type { UseTreePreviewHandlersReturn, UseTreePreviewHandlersArgs } from './types';
+export declare const useTreePreviewHandlers: ({ setOverId, setActiveId, setDropIndicatorPosition, }: UseTreePreviewHandlersArgs) => UseTreePreviewHandlersReturn;

package/dist/types/tree/utilities.d.ts

@@ -0,0 +1,7 @@
+import { DropIndicatorPosition } from './constants';
+import { Item } from './types';
+export declare const getProjection: (items: Item[], visibleItemsDictionary: Record<string, Item>, overId: string, dropIndicatorPosition: DropIndicatorPosition, isExpandable: boolean) => {
+    depth: number;
+    parentId: string;
+};
+export declare const removeChildrenOf: (items: Item[], id: string) => Item[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elliemae/ds-drag-and-drop",
-  "version": "2.3.0-alpha.8",
+  "version": "2.3.0-alpha.9",
   "license": "MIT",
   "description": "ICE MT - Dimsum - Drag And Drop",
   "files": [