@itwin/appui-react 4.8.3 → 4.9.0

package/lib/cjs/appui-react/layout/base/DragManager.d.ts

@@ -0,0 +1,183 @@
+/** @packageDocumentation
+ * @module Base
+ */
+import * as React from "react";
+import { BeEvent } from "@itwin/core-bentley";
+import type { SizeProps } from "@itwin/core-react";
+import { Point } from "@itwin/core-react";
+import type { PanelSide } from "../widget-panels/PanelTypes";
+import type { FloatingWidgetResizeHandle } from "../widget/FloatingWidget";
+import type { WidgetState } from "../state/WidgetState";
+import type { TabState } from "../state/TabState";
+import type { XAndY } from "../state/internal/NineZoneStateHelpers";
+import type { DropTargetState, TabDragDropTargetState, WidgetDragDropTargetState } from "../state/DropTargetState";
+/** @internal */
+export interface DragStartArgs {
+    initialPointerPosition: Point;
+    pointerPosition: Point;
+}
+/** @internal */
+export interface TabDragStartArgs extends DragStartArgs {
+    widgetSize: SizeProps;
+}
+/** @internal */
+export interface UseDragTabArgs {
+    tabId: TabState["id"];
+    onDrag?: (dragBy: XAndY) => void;
+    onDragEnd?: (target: TabDragDropTargetState) => void;
+}
+/** @internal */
+export declare function useDragTab(args: UseDragTabArgs): ({ initialPointerPosition, pointerPosition, widgetSize, }: TabDragStartArgs) => void;
+type UpdateWidgetDragItemFn = (id: WidgetDragItem["id"]) => void;
+/** @internal */
+export interface UseDragWidgetArgs {
+    widgetId: WidgetState["id"];
+    onDragStart?: (updateWidget: UpdateWidgetDragItemFn, initialPointerPosition: Point, pointerPosition: Point) => void;
+    onDrag?: (dragBy: Point) => void;
+    onDragEnd?: (target: WidgetDragDropTargetState) => void;
+}
+/** @internal */
+export declare function useDragWidget(args: UseDragWidgetArgs): ({ initialPointerPosition, pointerPosition }: DragStartArgs) => void;
+/** @internal */
+export interface UseDragPanelGripArgs {
+    side: PanelSide;
+    onDrag?: (pointerPosition: Point, lastPointerPosition: Point) => void;
+    onDragEnd?: () => void;
+}
+/** @internal */
+export declare function useDragPanelGrip(args: UseDragPanelGripArgs): ({ initialPointerPosition }: DragStartArgs) => void;
+/** @internal */
+export interface UseDragResizeHandleArgs {
+    widgetId: WidgetState["id"];
+    handle: FloatingWidgetResizeHandle;
+    onDrag?: (pointerPosition: Point) => void;
+}
+/** @internal */
+export declare function useDragResizeHandle(args: UseDragResizeHandleArgs): ({ initialPointerPosition }: DragStartArgs) => void;
+/** @internal */
+export interface UseDragToolSettingsArgs {
+    newFloatingWidgetId: WidgetDragItem["id"];
+}
+/** @internal */
+export declare function useDragToolSettings(args: UseDragToolSettingsArgs): ({ initialPointerPosition }: DragStartArgs) => void;
+/** @internal */
+export declare function useTarget<T extends Element>(target: DropTargetState): [
+    React.Ref<T>,
+    boolean
+];
+/** @internal */
+export interface UseTabTargetArgs {
+    widgetId: WidgetState["id"];
+    tabIndex: number;
+}
+/** @internal */
+export declare function useTabTarget<T extends Element>(args: UseTabTargetArgs): [
+    React.Ref<T>,
+    boolean
+];
+/** @internal */
+export interface UsePanelTargetArgs {
+    side: PanelSide;
+    newWidgetId: WidgetState["id"];
+}
+/** @internal */
+export declare function usePanelTarget<T extends Element>(args: UsePanelTargetArgs): [
+    React.Ref<T>,
+    boolean
+];
+/** @internal */
+export interface UseDragItemArgs<T extends DragItem> {
+    item: T;
+    isDragItem?: (item: T | undefined, dragged: DragItem) => boolean;
+    onDragStart?: DragEventHandler;
+    onDrag?: DragEventHandler;
+    onDragEnd?: DragEventHandler;
+}
+/** @internal */
+export declare function useDragItem<T extends DragItem>(args: UseDragItemArgs<T>): (info: DragInfo) => void;
+/** @internal */
+export declare function useDraggedItem(): DragItem | undefined;
+/** @internal */
+export declare function useIsDraggedItem(item: DragItem): boolean;
+/** @internal */
+export declare function useIsDraggedType(type: DragItem["type"]): boolean;
+/** @internal */
+export declare function useDraggedItemId<T extends DragItem>(type: T["type"]): T["id"] | undefined;
+/** @internal */
+export interface DragProviderProps {
+    children?: React.ReactNode;
+}
+/** @internal */
+export declare function DragProvider(props: DragProviderProps): React.JSX.Element;
+interface TabDragItem {
+    type: "tab";
+    id: TabState["id"];
+}
+interface WidgetDragItem {
+    type: "widget";
+    id: WidgetState["id"];
+}
+interface PanelGripDragItem {
+    type: "panelGrip";
+    id: PanelSide;
+}
+interface ResizeHandleDragItem {
+    type: "resizeHandle";
+    id: FloatingWidgetResizeHandle;
+    widgetId: WidgetState["id"];
+}
+/** @internal */
+export type DragItem = TabDragItem | WidgetDragItem | PanelGripDragItem | ResizeHandleDragItem;
+interface BaseDragInfo {
+    initialPointerPosition: Point;
+    lastPointerPosition: Point;
+    pointerPosition: Point;
+}
+interface TabDragInfo extends BaseDragInfo {
+    widgetSize: SizeProps;
+}
+type DragInfo = BaseDragInfo | TabDragInfo;
+interface HandleDragStartArgs {
+    item: DragItem;
+    info: DragInfo;
+}
+interface Dragged {
+    item: DragItem;
+    info: DragInfo;
+    target: DropTargetState | undefined;
+}
+type DragEventHandler = (item: DragItem, info: DragInfo, target: DropTargetState | undefined) => void;
+type DropTargetChangedEventHandler = (target: DropTargetState | undefined) => void;
+/** @internal */
+export declare class DragManager {
+    private _dragged;
+    private _onDragStartEmitter;
+    private _onDragUpdateEmitter;
+    private _onDragEmitter;
+    private _onDragEndEmitter;
+    private _onTargetChangedEmitter;
+    get draggedItem(): Dragged | undefined;
+    isTargeted(target: DropTargetState): boolean;
+    get onDragStart(): BeEvent<DragEventHandler>;
+    get onDragUpdate(): BeEvent<DragEventHandler>;
+    get onDrag(): BeEvent<DragEventHandler>;
+    get onDragEnd(): BeEvent<DragEventHandler>;
+    get onTargetChanged(): BeEvent<DropTargetChangedEventHandler>;
+    handleDragStart({ item, info }: HandleDragStartArgs): void;
+    handleDragUpdate(item: DragItem): void;
+    handleDrag(x: number, y: number): void;
+    handleDragEnd(): void;
+    handleTargetChanged(target: DropTargetState | undefined): void;
+}
+/** @internal */
+export declare const DragManagerContext: React.Context<DragManager>;
+/** @internal */
+export declare const DraggedWidgetIdContext: React.Context<string | undefined>;
+/** @internal */
+export declare const DraggedPanelSideContext: React.Context<PanelSide | undefined>;
+/** @internal */
+export declare const DraggedResizeHandleContext: React.Context<FloatingWidgetResizeHandle | undefined>;
+/** @internal */
+export declare function useTargeted(): DropTargetState | undefined;
+export {};
+//# sourceMappingURL=DragManager.d.ts.map

package/lib/cjs/appui-react/layout/base/DragManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DragManager.d.ts","sourceRoot":"","sources":["../../../../../src/appui-react/layout/base/DragManager.tsx"],"names":[],"mappings":"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"}

package/lib/cjs/appui-react/layout/base/DragManager.js

@@ -0,0 +1,497 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTargeted = exports.DraggedResizeHandleContext = exports.DraggedPanelSideContext = exports.DraggedWidgetIdContext = exports.DragManagerContext = exports.DragManager = exports.DragProvider = exports.useDraggedItemId = exports.useIsDraggedType = exports.useIsDraggedItem = exports.useDraggedItem = exports.useDragItem = exports.usePanelTarget = exports.useTabTarget = exports.useTarget = exports.useDragToolSettings = exports.useDragResizeHandle = exports.useDragPanelGrip = exports.useDragWidget = exports.useDragTab = void 0;
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+ * See LICENSE.md in the project root for license terms and full copyright notice.
+ *--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Base
+ */
+const React = require("react");
+const lodash_1 = require("lodash");
+const core_bentley_1 = require("@itwin/core-bentley");
+const core_react_1 = require("@itwin/core-react");
+const NineZone_1 = require("./NineZone");
+const DropTargetState_1 = require("../state/DropTargetState");
+/** @internal */
+function useDragTab(args) {
+    const { tabId, onDrag, onDragEnd } = args;
+    const item = React.useMemo(() => {
+        return {
+            type: "tab",
+            id: tabId,
+        };
+    }, [tabId]);
+    const handleDrag = React.useCallback((_item, info) => {
+        const dragBy = info.lastPointerPosition.getOffsetTo(info.pointerPosition);
+        onDrag && onDrag(dragBy);
+    }, [onDrag]);
+    const handleDragEnd = React.useCallback((_item, info, target) => {
+        // istanbul ignore next
+        if (!onDragEnd)
+            return;
+        let tabTarget;
+        if (target && (0, DropTargetState_1.isTabDragDropTargetState)(target)) {
+            tabTarget = target;
+        }
+        else {
+            const tabInfo = info;
+            const newFloatingWidgetId = (0, NineZone_1.getUniqueId)();
+            const size = tabInfo.widgetSize;
+            tabTarget = {
+                type: "floatingWidget",
+                newFloatingWidgetId,
+                size,
+            };
+        }
+        onDragEnd(tabTarget);
+    }, [onDragEnd]);
+    const onDragStart = useDragItem({
+        item,
+        onDrag: handleDrag,
+        onDragEnd: handleDragEnd,
+    });
+    const handleDragStart = React.useCallback(({ initialPointerPosition, pointerPosition, widgetSize, }) => {
+        onDragStart({
+            initialPointerPosition,
+            pointerPosition,
+            lastPointerPosition: initialPointerPosition,
+            widgetSize,
+        });
+    }, [onDragStart]);
+    return handleDragStart;
+}
+exports.useDragTab = useDragTab;
+/** @internal */
+function useDragWidget(args) {
+    const { widgetId, onDragStart, onDrag, onDragEnd } = args;
+    const dragManager = React.useContext(exports.DragManagerContext);
+    const widgetItem = React.useMemo(() => {
+        return {
+            type: "widget",
+            id: widgetId,
+        };
+    }, [widgetId]);
+    const handleDragStart = React.useCallback((_item, info) => {
+        onDragStart &&
+            onDragStart((id) => {
+                dragManager.handleDragUpdate({
+                    type: "widget",
+                    id,
+                });
+            }, info.initialPointerPosition, info.pointerPosition);
+    }, [dragManager, onDragStart]);
+    const handleDrag = React.useCallback((_item, info) => {
+        const dragBy = info.lastPointerPosition.getOffsetTo(info.pointerPosition);
+        onDrag && onDrag(dragBy);
+    }, [onDrag]);
+    const handleDragEnd = React.useCallback((_item, _info, target) => {
+        if (!onDragEnd)
+            return;
+        let widgetTarget;
+        if (target && (0, DropTargetState_1.isWidgetDragDropTargetState)(target)) {
+            widgetTarget = target;
+        }
+        else {
+            widgetTarget = {
+                type: "window",
+            };
+        }
+        onDragEnd(widgetTarget);
+    }, [onDragEnd]);
+    const isDragItem = React.useCallback((item, dragged) => {
+        return !!item && defaultIsDragItem(item, dragged);
+    }, []);
+    const onItemDragStart = useDragItem({
+        item: widgetItem,
+        isDragItem,
+        onDragStart: handleDragStart,
+        onDrag: handleDrag,
+        onDragEnd: handleDragEnd,
+    });
+    const handleWidgetDragStart = React.useCallback(({ initialPointerPosition, pointerPosition }) => {
+        onItemDragStart({
+            initialPointerPosition,
+            pointerPosition,
+            lastPointerPosition: initialPointerPosition,
+        });
+    }, [onItemDragStart]);
+    return handleWidgetDragStart;
+}
+exports.useDragWidget = useDragWidget;
+/** @internal */
+function useDragPanelGrip(args) {
+    const { side, onDrag, onDragEnd } = args;
+    const gripItem = React.useMemo(() => {
+        return {
+            type: "panelGrip",
+            id: side,
+        };
+    }, [side]);
+    const handleDrag = React.useCallback((_item, info) => {
+        onDrag && onDrag(info.pointerPosition, info.lastPointerPosition);
+    }, [onDrag]);
+    const handleDragEnd = React.useCallback(() => {
+        onDragEnd && onDragEnd();
+    }, [onDragEnd]);
+    const onItemDragStart = useDragItem({
+        item: gripItem,
+        onDrag: handleDrag,
+        onDragEnd: handleDragEnd,
+    });
+    const handleDragStart = React.useCallback(({ initialPointerPosition }) => {
+        onItemDragStart({
+            initialPointerPosition,
+            pointerPosition: initialPointerPosition,
+            lastPointerPosition: initialPointerPosition,
+        });
+    }, [onItemDragStart]);
+    return handleDragStart;
+}
+exports.useDragPanelGrip = useDragPanelGrip;
+/** @internal */
+function useDragResizeHandle(args) {
+    const { handle, onDrag, widgetId } = args;
+    const resizeHandleItem = React.useMemo(() => {
+        return {
+            type: "resizeHandle",
+            id: handle,
+            widgetId,
+        };
+    }, [handle, widgetId]);
+    const isDragItem = React.useCallback((item, draggedItem) => {
+        return (!!item &&
+            isResizeHandleDragItem(draggedItem) &&
+            defaultIsDragItem(item, draggedItem) &&
+            item.widgetId === draggedItem.widgetId);
+    }, []);
+    const handleDrag = React.useCallback((_item, info) => {
+        onDrag && onDrag(info.pointerPosition);
+    }, [onDrag]);
+    const onItemDragStart = useDragItem({
+        item: resizeHandleItem,
+        isDragItem,
+        onDrag: handleDrag,
+    });
+    const handleDragStart = React.useCallback(({ initialPointerPosition }) => {
+        onItemDragStart({
+            initialPointerPosition,
+            pointerPosition: initialPointerPosition,
+            lastPointerPosition: initialPointerPosition,
+        });
+    }, [onItemDragStart]);
+    return handleDragStart;
+}
+exports.useDragResizeHandle = useDragResizeHandle;
+/** @internal */
+function useDragToolSettings(args) {
+    const { newFloatingWidgetId } = args;
+    const item = React.useMemo(() => {
+        return {
+            type: "widget",
+            id: newFloatingWidgetId,
+        };
+    }, [newFloatingWidgetId]);
+    const onDragStart = useDragItem({
+        item,
+    });
+    const handleDragStart = React.useCallback(({ initialPointerPosition }) => {
+        onDragStart({
+            initialPointerPosition,
+            pointerPosition: initialPointerPosition,
+            lastPointerPosition: initialPointerPosition,
+        });
+    }, [onDragStart]);
+    return handleDragStart;
+}
+exports.useDragToolSettings = useDragToolSettings;
+/** @internal */
+function useTarget(target) {
+    const dragManager = React.useContext(exports.DragManagerContext);
+    const [targeted, setTargeted] = React.useState(false);
+    const targetedRef = React.useRef(false);
+    const onTargeted = React.useCallback((doTarget) => {
+        const isTargeted = dragManager.isTargeted(target);
+        if (doTarget && !isTargeted) {
+            dragManager.handleTargetChanged(target);
+        }
+        else if (!doTarget && isTargeted) {
+            dragManager.handleTargetChanged(undefined);
+        }
+        setTargeted(doTarget);
+    }, [dragManager, target]);
+    const ref = React.useRef(null);
+    React.useEffect(() => {
+        return dragManager.onDrag.addListener((_item, info) => {
+            const targetedElement = document.elementFromPoint(info.pointerPosition.x, info.pointerPosition.y);
+            const newTargeted = targetedElement === ref.current;
+            newTargeted !== targetedRef.current && onTargeted(newTargeted);
+            targetedRef.current = newTargeted;
+        });
+    }, [onTargeted, dragManager]);
+    React.useEffect(() => {
+        return dragManager.onDragEnd.addListener(() => {
+            targetedRef.current && onTargeted(false);
+            targetedRef.current = false;
+        });
+    }, [onTargeted, dragManager]);
+    return [ref, targeted];
+}
+exports.useTarget = useTarget;
+/** @internal */
+function useTabTarget(args) {
+    const { tabIndex, widgetId } = args;
+    const target = React.useMemo(() => ({
+        type: "tab",
+        tabIndex,
+        widgetId,
+    }), [tabIndex, widgetId]);
+    return useTarget(target);
+}
+exports.useTabTarget = useTabTarget;
+/** @internal */
+function usePanelTarget(args) {
+    const { side, newWidgetId } = args;
+    const target = React.useMemo(() => ({
+        type: "panel",
+        side,
+        newWidgetId,
+    }), [side, newWidgetId]);
+    return useTarget(target);
+}
+exports.usePanelTarget = usePanelTarget;
+function defaultIsDragItem(item, dragged) {
+    return dragged.type === item.type && dragged.id === item.id;
+}
+/** @internal */
+function useDragItem(args) {
+    const dragManager = React.useContext(exports.DragManagerContext);
+    const { item, isDragItem, onDragStart, onDrag, onDragEnd } = args;
+    const handleDragStart = React.useCallback((info) => {
+        item &&
+            dragManager.handleDragStart({
+                item,
+                info,
+            });
+    }, [dragManager, item]);
+    React.useEffect(() => {
+        return dragManager.onDragStart.addListener((draggedItem, info, target) => {
+            const handleEvent = isDragItem
+                ? isDragItem(item, draggedItem)
+                : defaultIsDragItem(item, draggedItem);
+            if (!handleEvent)
+                return;
+            onDragStart && onDragStart(draggedItem, info, target);
+        });
+    }, [dragManager, onDragStart, item, isDragItem]);
+    React.useEffect(() => {
+        return dragManager.onDrag.addListener((draggedItem, info, target) => {
+            const handleEvent = isDragItem
+                ? isDragItem(item, draggedItem)
+                : defaultIsDragItem(item, draggedItem);
+            if (!handleEvent)
+                return;
+            onDrag && onDrag(draggedItem, info, target);
+        });
+    }, [dragManager, onDrag, item, isDragItem]);
+    React.useEffect(() => {
+        return dragManager.onDragEnd.addListener((draggedItem, info, target) => {
+            const handleEvent = isDragItem
+                ? isDragItem(item, draggedItem)
+                : defaultIsDragItem(item, draggedItem);
+            if (!handleEvent)
+                return;
+            onDragEnd && onDragEnd(draggedItem, info, target);
+        });
+    }, [dragManager, onDragEnd, item, isDragItem]);
+    return handleDragStart;
+}
+exports.useDragItem = useDragItem;
+/** @internal */
+function useDraggedItem() {
+    var _a;
+    const dragManager = React.useContext(exports.DragManagerContext);
+    const [draggedItem, setDraggedItem] = React.useState((_a = dragManager.draggedItem) === null || _a === void 0 ? void 0 : _a.item);
+    React.useEffect(() => {
+        return dragManager.onDragStart.addListener((item) => {
+            setDraggedItem(item);
+        });
+    }, [dragManager]);
+    React.useEffect(() => {
+        return dragManager.onDragUpdate.addListener((item) => {
+            setDraggedItem(item);
+        });
+    }, [dragManager]);
+    React.useEffect(() => {
+        return dragManager.onDragEnd.addListener(() => {
+            setDraggedItem(undefined);
+        });
+    }, [dragManager]);
+    return draggedItem;
+}
+exports.useDraggedItem = useDraggedItem;
+/** @internal */
+function useIsDraggedItem(item) {
+    const draggedItem = useDraggedItem();
+    return (!!draggedItem &&
+        draggedItem.id === item.id &&
+        draggedItem.type === item.type);
+}
+exports.useIsDraggedItem = useIsDraggedItem;
+/** @internal */
+function useIsDraggedType(type) {
+    const draggedItem = useDraggedItem();
+    return !!draggedItem && draggedItem.type === type;
+}
+exports.useIsDraggedType = useIsDraggedType;
+/** @internal */
+function useDraggedItemId(type) {
+    const draggedItem = useDraggedItem();
+    if (draggedItem && draggedItem.type === type) {
+        return draggedItem.id;
+    }
+    return undefined;
+}
+exports.useDraggedItemId = useDraggedItemId;
+/** @internal */
+function DragProvider(props) {
+    const dragManager = React.useRef(new DragManager());
+    React.useEffect(() => {
+        const mouseMove = (e) => {
+            dragManager.current.handleDrag(e.clientX, e.clientY);
+        };
+        document.addEventListener("mousemove", mouseMove);
+        return () => {
+            document.removeEventListener("mousemove", mouseMove);
+        };
+    }, []);
+    React.useEffect(() => {
+        const mouseUp = () => {
+            dragManager.current.handleDragEnd();
+        };
+        document.addEventListener("mouseup", mouseUp);
+        return () => {
+            document.removeEventListener("mouseup", mouseUp);
+        };
+    }, []);
+    return (React.createElement(exports.DragManagerContext.Provider, { value: dragManager.current },
+        React.createElement(DraggedWidgetIdProvider, null,
+            React.createElement(DraggedPanelSideProvider, null,
+                React.createElement(DraggedResizeHandleProvider, null, props.children)))));
+}
+exports.DragProvider = DragProvider;
+function DraggedWidgetIdProvider(props) {
+    const draggedWidgetId = useDraggedItemId("widget");
+    return (React.createElement(exports.DraggedWidgetIdContext.Provider, { value: draggedWidgetId }, props.children));
+}
+function DraggedPanelSideProvider(props) {
+    const draggedSide = useDraggedItemId("panelGrip");
+    return (React.createElement(exports.DraggedPanelSideContext.Provider, { value: draggedSide }, props.children));
+}
+function DraggedResizeHandleProvider(props) {
+    const draggedHandle = useDraggedItemId("resizeHandle");
+    return (React.createElement(exports.DraggedResizeHandleContext.Provider, { value: draggedHandle }, props.children));
+}
+function isResizeHandleDragItem(item) {
+    return item.type === "resizeHandle";
+}
+/** @internal */
+class DragManager {
+    constructor() {
+        this._onDragStartEmitter = new core_bentley_1.BeEvent();
+        this._onDragUpdateEmitter = new core_bentley_1.BeEvent();
+        this._onDragEmitter = new core_bentley_1.BeEvent();
+        this._onDragEndEmitter = new core_bentley_1.BeEvent();
+        this._onTargetChangedEmitter = new core_bentley_1.BeEvent();
+    }
+    get draggedItem() {
+        return this._dragged;
+    }
+    isTargeted(target) {
+        if (!this._dragged)
+            return false;
+        if (!this._dragged.target)
+            return false;
+        return (0, lodash_1.isEqual)(this._dragged.target, target);
+    }
+    get onDragStart() {
+        return this._onDragStartEmitter;
+    }
+    get onDragUpdate() {
+        return this._onDragUpdateEmitter;
+    }
+    get onDrag() {
+        return this._onDragEmitter;
+    }
+    get onDragEnd() {
+        return this._onDragEndEmitter;
+    }
+    get onTargetChanged() {
+        return this._onTargetChangedEmitter;
+    }
+    handleDragStart({ item, info }) {
+        this._dragged = {
+            item,
+            info,
+            target: undefined,
+        };
+        this._onDragStartEmitter.raiseEvent(this._dragged.item, this._dragged.info, this._dragged.target);
+    }
+    handleDragUpdate(item) {
+        // istanbul ignore next
+        if (!this._dragged)
+            return;
+        this._dragged.item = item;
+        this._onDragUpdateEmitter.raiseEvent(this._dragged.item, this._dragged.info, this._dragged.target);
+    }
+    handleDrag(x, y) {
+        if (!this._dragged)
+            return;
+        this._dragged.info.lastPointerPosition = this._dragged.info.pointerPosition;
+        this._dragged.info.pointerPosition = new core_react_1.Point(x, y);
+        this._onDragEmitter.raiseEvent(this._dragged.item, this._dragged.info, this._dragged.target);
+    }
+    handleDragEnd() {
+        if (!this._dragged)
+            return;
+        const item = this._dragged.item;
+        const info = this._dragged.info;
+        const target = this._dragged.target;
+        this._dragged = undefined;
+        this._onDragEndEmitter.raiseEvent(item, info, target);
+        target && this._onTargetChangedEmitter.raiseEvent(undefined);
+    }
+    handleTargetChanged(target) {
+        if (!this._dragged)
+            return;
+        this._dragged.target = target;
+        this._onTargetChangedEmitter.raiseEvent(target);
+    }
+}
+exports.DragManager = DragManager;
+/** @internal */
+exports.DragManagerContext = React.createContext(null);
+exports.DragManagerContext.displayName = "nz:DragManagerContext";
+/** @internal */
+exports.DraggedWidgetIdContext = React.createContext(undefined);
+exports.DraggedWidgetIdContext.displayName = "nz:DraggedWidgetIdContext";
+/** @internal */
+exports.DraggedPanelSideContext = React.createContext(undefined);
+exports.DraggedPanelSideContext.displayName = "nz:DraggedPanelSideContext";
+/** @internal */
+exports.DraggedResizeHandleContext = React.createContext(undefined);
+exports.DraggedResizeHandleContext.displayName = "nz:DraggedResizeHandleContext";
+/** @internal */
+function useTargeted() {
+    const dragManager = React.useContext(exports.DragManagerContext);
+    const [targeted, setTargeted] = React.useState();
+    React.useEffect(() => {
+        return dragManager.onTargetChanged.addListener((t) => {
+            setTargeted(t);
+        });
+    }, [dragManager]);
+    return targeted;
+}
+exports.useTargeted = useTargeted;
+//# sourceMappingURL=DragManager.js.map