frontend-admin / Daocheng-Yading

  export type Identifier = string | symbol
  export type SourceType = Identifier
  export type TargetType = Identifier | Identifier[]
  export type Unsubscribe = () => void
  export type Listener = () => void
  
  export interface XYCoord {
  	x: number
  	y: number
  }
  
  export enum HandlerRole {
  	SOURCE = 'SOURCE',
  	TARGET = 'TARGET',
  }
  
  export interface Backend {
  	setup(): void
  	teardown(): void
  	connectDragSource(sourceId: any, node?: any, options?: any): Unsubscribe
  	connectDragPreview(sourceId: any, node?: any, options?: any): Unsubscribe
  	connectDropTarget(targetId: any, node?: any, options?: any): Unsubscribe
  	profile(): Record<string, number>
  }
  
  export interface DragDropMonitor {
  	subscribeToStateChange(
  		listener: Listener,
  		options?: {
  			handlerIds?: Identifier[]
  		},
  	): Unsubscribe
  	subscribeToOffsetChange(listener: Listener): Unsubscribe
  	canDragSource(sourceId: Identifier | undefined): boolean
  	canDropOnTarget(targetId: Identifier | undefined): boolean
  
  	/**
  	 * Returns true if a drag operation is in progress, and either the owner initiated the drag, or its isDragging()
  	 * is defined and returns true.
  	 */
  	isDragging(): boolean
  	isDraggingSource(sourceId: Identifier | undefined): boolean
  	isOverTarget(
  		targetId: Identifier | undefined,
  		options?: {
  			shallow?: boolean
  		},
  	): boolean
  
  	/**
  	 * Returns a string or a symbol identifying the type of the current dragged item. Returns null if no item is being dragged.
  	 */
  	getItemType(): Identifier | null
  
  	/**
  	 * Returns a plain object representing the currently dragged item. Every drag source must specify it by returning an object
  	 * from its beginDrag() method. Returns null if no item is being dragged.
  	 */
  	getItem(): any
  	getSourceId(): Identifier | null
  	getTargetIds(): Identifier[]
  	/**
  	 * Returns a plain object representing the last recorded drop result. The drop targets may optionally specify it by returning an
  	 * object from their drop() methods. When a chain of drop() is dispatched for the nested targets, bottom up, any parent that
  	 * explicitly returns its own result from drop() overrides the child drop result previously set by the child. Returns null if
  	 * called outside endDrag().
  	 */
  	getDropResult(): any
  	/**
  	 * Returns true if some drop target has handled the drop event, false otherwise. Even if a target did not return a drop result,
  	 * didDrop() returns true. Use it inside endDrag() to test whether any drop target has handled the drop. Returns false if called
  	 * outside endDrag().
  	 */
  	didDrop(): boolean
  	isSourcePublic(): boolean | null
  	/**
  	 * Returns the { x, y } client offset of the pointer at the time when the current drag operation has started.
  	 * Returns null if no item is being dragged.
  	 */
  	getInitialClientOffset(): XYCoord | null
  	/**
  	 * Returns the { x, y } client offset of the drag source component's root DOM node at the time when the current drag
  	 * operation has started. Returns null if no item is being dragged.
  	 */
  	getInitialSourceClientOffset(): XYCoord | null
  
  	/**
  	 * Returns the last recorded { x, y } client offset of the pointer while a drag operation is in progress.
  	 * Returns null if no item is being dragged.
  	 */
  	getClientOffset(): XYCoord | null
  
  	/**
  	 * Returns the projected { x, y } client offset of the drag source component's root DOM node, based on its position at the time
  	 * when the current drag operation has started, and the movement difference. Returns null if no item is being dragged.
  	 */
  	getSourceClientOffset(): XYCoord | null
  
  	/**
  	 * Returns the { x, y } difference between the last recorded client offset of the pointer and the client offset when the current
  	 * drag operation has started. Returns null if no item is being dragged.
  	 */
  	getDifferenceFromInitialOffset(): XYCoord | null
  }
  
  export interface HandlerRegistry {
  	addSource(type: SourceType, source: DragSource): Identifier
  	addTarget(type: TargetType, target: DropTarget): Identifier
  	containsHandler(handler: DragSource | DropTarget): boolean
  	getSource(sourceId: Identifier, includePinned?: boolean): DragSource
  	getSourceType(sourceId: Identifier): SourceType
  	getTargetType(targetId: Identifier): TargetType
  	getTarget(targetId: Identifier): DropTarget
  	isSourceId(handlerId: Identifier): boolean
  	isTargetId(handlerId: Identifier): boolean
  	removeSource(sourceId: Identifier): void
  	removeTarget(targetId: Identifier): void
  	pinSource(sourceId: Identifier): void
  	unpinSource(): void
  }
  
  export interface Action<Payload> {
  	type: Identifier
  	payload: Payload
  }
  export interface SentinelAction {
  	type: Identifier
  }
  
  export type ActionCreator<Payload> = (args: any[]) => Action<Payload>
  
  export interface BeginDragOptions {
  	publishSource?: boolean
  	clientOffset?: XYCoord
  	getSourceClientOffset?: (sourceId: Identifier | undefined) => XYCoord
  }
  
  export interface InitCoordsPayload {
  	clientOffset: XYCoord | null
  	sourceClientOffset: XYCoord | null
  }
  
  export interface BeginDragPayload {
  	itemType: Identifier
  	item: any
  	sourceId: Identifier
  	clientOffset: XYCoord | null
  	sourceClientOffset: XYCoord | null
  	isSourcePublic: boolean
  }
  
  export interface HoverPayload {
  	targetIds: Identifier[]
  	clientOffset: XYCoord | null
  }
  
  export interface HoverOptions {
  	clientOffset?: XYCoord
  }
  
  export interface DropPayload {
  	dropResult: any
  }
  
  export interface TargetIdPayload {
  	targetId: Identifier
  }
  
  export interface SourceIdPayload {
  	sourceId: Identifier
  }
  
  export interface DragDropActions {
  	beginDrag(
  		sourceIds?: Identifier[],
  		options?: any,
  	): Action<BeginDragPayload> | undefined
  	publishDragSource(): SentinelAction | undefined
  	hover(targetIds: Identifier[], options?: any): Action<HoverPayload>
  	drop(options?: any): void
  	endDrag(): SentinelAction
  }
  
  export interface DragDropManager {
  	getMonitor(): DragDropMonitor
  	getBackend(): Backend
  	getRegistry(): HandlerRegistry
  	getActions(): DragDropActions
  	dispatch(action: any): void
  }
  
  export type BackendFactory = (
  	manager: DragDropManager,
  	globalContext?: any,
  	configuration?: any,
  ) => Backend
  
  export interface DragSource {
  	beginDrag(monitor: DragDropMonitor, targetId: Identifier): void
  	endDrag(monitor: DragDropMonitor, targetId: Identifier): void
  	canDrag(monitor: DragDropMonitor, targetId: Identifier): boolean
  	isDragging(monitor: DragDropMonitor, targetId: Identifier): boolean
  }
  
  export interface DropTarget {
  	canDrop(monitor: DragDropMonitor, targetId: Identifier): boolean
  	hover(monitor: DragDropMonitor, targetId: Identifier): void
  	drop(monitor: DragDropMonitor, targetId: Identifier): any
  }