ag-grid-community

import type { HorizontalDirection, VerticalDirection } from '../agStack/constants/direction'; import type { AgDraggingEvent } from '../agStack/interfaces/iDragAndDrop'; import type { RowDragCancelEvent, RowDragEndEvent, RowDragEnterEvent, RowDragLeaveEvent, RowDragMoveEvent } from '../events'; import type { AgGridCommon } from '../interfaces/iCommon'; import type { DragItem } from '../interfaces/iDragItem'; import type { IRowNode } from '../interfaces/iRowNode'; import type { DragAndDropIcon, DragSourceType } from './dragAndDropService'; export type RowDragVisibility = 'suppress' | 'visible' | 'hidden' | 'disabled'; export type RowDropTargetPosition = 'above' | 'inside' | 'below' | 'none'; export interface IsRowValidDropPositionResult<TData = any> { /** The rows that are being dropped, can be used to filter the rows. If empty, the operation is aborted. */ rows?: IRowNode<TData>[] | null; /** The position of the rows relative to the target row. If "none" the drop is not allowed */ position?: RowDropTargetPosition; /** The new parent row the rows will have after dropped */ newParent?: IRowNode<TData> | null; /** The target row node where the row is being dropped. */ target?: IRowNode<TData> | null; /** True if the drop is allowed, false otherwise */ allowed?: boolean; /** * True if the drop target can be highlighted, matching the `position` value. * Can be set to true during unmanaged row dragging to show the drop position indicator. */ highlight?: boolean; /** True if relevant information about the drop target are changed and the drag ghost need to be updated */ changed?: boolean; } export type IsRowValidDropPositionCallback<TData = any, TContext = any> = (params: IsRowValidDropPositionParams<TData, TContext>) => IsRowValidDropPositionResult<TData> | null | boolean; export interface DragSource { /** The type of the drag source, used by the drop target to know where the drag originated from. */ type: DragSourceType; /** Can be used to identify a specific component as the source */ sourceId?: string; /** Element which, when dragged, will kick off the DnD process */ eElement: Element; /** If eElement is dragged, then the dragItem is the object that gets passed around. */ getDragItem: () => DragItem; /** This name appears in the drag and drop image component when dragging. */ dragItemName: ((draggingEvent?: DraggingEvent | null) => string | null | undefined) | string | null; /** Icon to show when not over a drop zone */ getDefaultIconName?: () => DragAndDropIcon; /** The drag source DOM Data Key, this is useful to detect if the origin grid is the same as the target grid. */ dragSourceDomDataKey?: string; /** After how many pixels of dragging should the drag operation start. Default is 4. */ dragStartPixels?: number; /** Callback for drag started */ onDragStarted?: () => void; /** Callback for drag stopped */ onDragStopped?: () => void; /** Callback for drag cancelled */ onDragCancelled?: () => void; /** Callback for entering the grid */ onGridEnter?: (dragItem: DragItem | null) => void; /** Callback for exiting the grid */ onGridExit?: (dragItem: DragItem | null) => void; } export interface DraggingEvent<TData = any, TContext = any> extends AgGridCommon<TData, TContext> { /** The mouse event that triggered the dragging event */ event: MouseEvent; /** The X position in pixel relative to the drop target */ x: number; /** The Y position in pixel relative to the drop target */ y: number; /** The vertical direction of the drag, can be 'up', 'down' or null */ vDirection: VerticalDirection | null; /** The horizontal direction of the drag, can be 'left', 'right' or null */ hDirection: HorizontalDirection | null; /** The drag source that initiated the drag */ dragSource: DragSource; /** The drag item that is being dragged */ dragItem: DragItem; fromNudge: boolean; /** The target element where the drop is happening */ dropZoneTarget: HTMLElement; } export interface IsRowValidDropPositionParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> { /** The dragging event that originated this drop operation */ draggingEvent: DraggingEvent<TData, TContext> | null; /** True if the grid is managing row dragging, false if using unmanaged row dragging */ rowDragManaged: boolean; /** True if the grid is suppressing move when row dragging, false otherwise */ suppressMoveWhenRowDragging: boolean; /** True if this rows comes from the same grid, false if is coming from another grid */ sameGrid: boolean; /** True if the drop zone is within this grid, false otherwise */ withinGrid: boolean; /** The root row node that contains all the rows */ rootNode: IRowNode<TData>; /** The vertical pixel location the mouse is over, with `0` meaning the top of the first row. * This can be compared to the `rowNode.rowHeight` and `rowNode.rowTop` to work out the mouse position relative to rows. * The provided attributes `overIndex` and `overNode` means the `y` property is mostly redundant. * The `y` property can be handy if you want more information such as 'how close is the mouse to the top or bottom of the row?' */ y: number; /** True if the current row dragged is not the same as the target row */ moved: boolean; /** The row node the mouse is dragging over or undefined if over no row. Might be different than `target`. */ overNode: IRowNode<TData> | undefined; /** The row index the mouse is dragging over or -1 if over no row. */ overIndex: number; /** The pointer position relative to the current over node */ pointerPos: RowDropTargetPosition; /** The position of the rows relative to the target row */ position: RowDropTargetPosition; /** The source row node that was dragged, if any */ source: IRowNode<TData>; /** The target row node where the row is being dropped. */ target: IRowNode<TData> | null; /** The new parent row the rows will have after dropped */ newParent: IRowNode<TData> | null; /** The rows that are being dropped */ rows: IRowNode<TData>[]; /** True if the drop is allowed, false otherwise */ allowed: boolean; } /** This is used internally instead of `GridDraggingEvent` to type `dropTarget` for row dragging */ export interface RowDraggingEvent<TData = any, TContext = any> extends AgDraggingEvent<DragSourceType, DragItem, DragAndDropIcon, RowDraggingEvent, RowsDrop<TData, TContext>>, AgGridCommon<TData, TContext> { } /** * This is only used internally * @internal AG_GRID_INTERNAL - Not for public use. Can change / be removed at any time. */ export interface RowsDrop<TData = any, TContext = any> extends Omit<IsRowValidDropPositionParams<TData, TContext>, 'draggingEvent'> { /** The dragging event that originated this drop operation */ draggingEvent: RowDraggingEvent<TData, TContext> | null; /** True if the grid is using tree data mode. */ treeData: boolean; /** True if the drop target can be highlighted while moving, matching the `position` value. */ highlight: boolean; /** The vertical pixel offset relative to the target row */ yDelta: number; /** True if the drop needs to happen as a child of the target node */ inside: boolean; /** True when executing a managed drop and rows were moved */ droppedManaged: boolean; } export interface RowsDropParams<TData = any, TContext = any> extends IsRowValidDropPositionParams<TData, TContext> { } export interface RowDropZoneEvents { /** Callback function that will be executed when the rowDrag enters the target. */ onDragEnter?: (params: RowDragEnterEvent) => void; /** Callback function that will be executed when the rowDrag leaves the target */ onDragLeave?: (params: RowDragLeaveEvent) => void; /** * Callback function that will be executed when the rowDrag is dragged inside the target. * Note: this gets called multiple times. */ onDragging?: (params: RowDragMoveEvent) => void; /** Callback function that will be executed when the rowDrag drops rows within the target. */ onDragStop?: (params: RowDragEndEvent) => void; onDragCancel?: (params: RowDragCancelEvent) => void; } export interface RowDropZoneParams extends RowDropZoneEvents { /** A callback method that returns the DropZone HTMLElement. */ getContainer: () => HTMLElement; }