@mdesignable/core 1.0.0-beta.64

package/lib/drivers/ViewportResizeDriver.js

@@ -0,0 +1,98 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ViewportResizeDriver = void 0;
+var shared_1 = require("@mdesignable/shared");
+var events_1 = require("../events");
+var resize_observer_1 = require("@juggle/resize-observer");
+var shared_2 = require("@mdesignable/shared");
+var lodash_1 = require("lodash");
+var ViewportResizeDriver = /** @class */ (function (_super) {
+    __extends(ViewportResizeDriver, _super);
+    function ViewportResizeDriver() {
+        var _this = _super.apply(this, __spreadArray([], __read(arguments), false)) || this;
+        _this.request = null;
+        _this.resizeObserver = null;
+        _this.onResize = (0, lodash_1.debounce)(function (e) {
+            if (e.preventDefault)
+                e.preventDefault();
+            _this.request = requestAnimationFrame(function () {
+                cancelAnimationFrame(_this.request);
+                _this.dispatch(new events_1.ViewportResizeEvent({
+                    scrollX: _this.contentWindow.scrollX,
+                    scrollY: _this.contentWindow.scrollY,
+                    width: _this.contentWindow.innerWidth,
+                    height: _this.contentWindow.innerHeight,
+                    innerHeight: _this.contentWindow.innerHeight,
+                    innerWidth: _this.contentWindow.innerWidth,
+                    view: _this.contentWindow,
+                    target: e.target || _this.container,
+                }));
+            });
+        }, 500);
+        return _this;
+    }
+    ViewportResizeDriver.prototype.attach = function () {
+        if (this.contentWindow && this.contentWindow !== shared_2.globalThisPolyfill) {
+            this.addEventListener('resize', this.onResize);
+        }
+        else {
+            if (this.container && this.container !== document) {
+                this.resizeObserver = new resize_observer_1.ResizeObserver(this.onResize);
+                this.resizeObserver.observe(this.container);
+            }
+        }
+    };
+    ViewportResizeDriver.prototype.detach = function () {
+        if (this.contentWindow && this.contentWindow !== shared_2.globalThisPolyfill) {
+            this.removeEventListener('resize', this.onResize);
+        }
+        else if (this.resizeObserver) {
+            if (this.container && this.container !== document) {
+                this.resizeObserver.unobserve(this.container);
+                this.resizeObserver.disconnect();
+            }
+        }
+    };
+    return ViewportResizeDriver;
+}(shared_1.EventDriver));
+exports.ViewportResizeDriver = ViewportResizeDriver;

package/lib/drivers/ViewportScrollDriver.d.ts

@@ -0,0 +1,8 @@
+import { EventDriver } from '@mdesignable/shared';
+import { Engine } from '../models/Engine';
+export declare class ViewportScrollDriver extends EventDriver<Engine> {
+    request: any;
+    onScroll: (e: UIEvent) => void;
+    attach(): void;
+    detach(): void;
+}

package/lib/drivers/ViewportScrollDriver.js

@@ -0,0 +1,77 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ViewportScrollDriver = void 0;
+var shared_1 = require("@mdesignable/shared");
+var events_1 = require("../events");
+var ViewportScrollDriver = /** @class */ (function (_super) {
+    __extends(ViewportScrollDriver, _super);
+    function ViewportScrollDriver() {
+        var _this = _super.apply(this, __spreadArray([], __read(arguments), false)) || this;
+        _this.request = null;
+        _this.onScroll = function (e) {
+            e.preventDefault();
+            _this.request = shared_1.globalThisPolyfill.requestAnimationFrame(function () {
+                _this.dispatch(new events_1.ViewportScrollEvent({
+                    scrollX: _this.contentWindow.scrollX,
+                    scrollY: _this.contentWindow.scrollY,
+                    width: _this.contentWindow.document.body.clientWidth,
+                    height: _this.contentWindow.document.body.clientHeight,
+                    innerHeight: _this.contentWindow.innerHeight,
+                    innerWidth: _this.contentWindow.innerWidth,
+                    view: _this.contentWindow,
+                    target: e.target,
+                }));
+                cancelAnimationFrame(_this.request);
+            });
+        };
+        return _this;
+    }
+    ViewportScrollDriver.prototype.attach = function () {
+        this.addEventListener('scroll', this.onScroll);
+    };
+    ViewportScrollDriver.prototype.detach = function () {
+        this.removeEventListener('scroll', this.onScroll);
+    };
+    return ViewportScrollDriver;
+}(shared_1.EventDriver));
+exports.ViewportScrollDriver = ViewportScrollDriver;

package/lib/drivers/index.d.ts

@@ -0,0 +1,6 @@
+export * from './DragDropDriver';
+export * from './MouseClickDriver';
+export * from './MouseMoveDriver';
+export * from './ViewportResizeDriver';
+export * from './ViewportScrollDriver';
+export * from './KeyboardDriver';

package/lib/drivers/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./DragDropDriver"), exports);
+__exportStar(require("./MouseClickDriver"), exports);
+__exportStar(require("./MouseMoveDriver"), exports);
+__exportStar(require("./ViewportResizeDriver"), exports);
+__exportStar(require("./ViewportScrollDriver"), exports);
+__exportStar(require("./KeyboardDriver"), exports);

package/lib/effects/index.d.ts

@@ -0,0 +1,11 @@
+export * from './useCursorEffect';
+export * from './useViewportEffect';
+export * from './useDragDropEffect';
+export * from './useResizeEffect';
+export * from './useSelectionEffect';
+export * from './useFreeSelectionEffect';
+export * from './useKeyboardEffect';
+export * from './useAutoScrollEffect';
+export * from './useWorkspaceEffect';
+export * from './useContentEditableEffect';
+export * from './useTranslateEffect';

package/lib/effects/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./useCursorEffect"), exports);
+__exportStar(require("./useViewportEffect"), exports);
+__exportStar(require("./useDragDropEffect"), exports);
+__exportStar(require("./useResizeEffect"), exports);
+__exportStar(require("./useSelectionEffect"), exports);
+__exportStar(require("./useFreeSelectionEffect"), exports);
+__exportStar(require("./useKeyboardEffect"), exports);
+__exportStar(require("./useAutoScrollEffect"), exports);
+__exportStar(require("./useWorkspaceEffect"), exports);
+__exportStar(require("./useContentEditableEffect"), exports);
+__exportStar(require("./useTranslateEffect"), exports);

package/lib/effects/useAutoScrollEffect.d.ts

@@ -0,0 +1,2 @@
+import { Engine } from '../models';
+export declare const useAutoScrollEffect: (engine: Engine) => void;

package/lib/effects/useAutoScrollEffect.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAutoScrollEffect = void 0;
+var models_1 = require("../models");
+var events_1 = require("../events");
+var shared_1 = require("@mdesignable/shared");
+var useAutoScrollEffect = function (engine) {
+    var xScroller = null;
+    var yScroller = null;
+    var xScrollerAnimationStop = null;
+    var yScrollerAnimationStop = null;
+    var scrolling = function (point, viewport) {
+        if (engine.cursor.status === models_1.CursorStatus.Dragging) {
+            xScroller = (0, shared_1.calcAutoScrollBasicInfo)(point, 'x', viewport.rect);
+            yScroller = (0, shared_1.calcAutoScrollBasicInfo)(point, 'y', viewport.rect);
+            if (xScroller) {
+                if (xScrollerAnimationStop) {
+                    xScrollerAnimationStop();
+                }
+                xScrollerAnimationStop = (0, shared_1.scrollAnimate)(viewport.scrollContainer, 'x', xScroller.direction, xScroller.speed);
+            }
+            else {
+                if (xScrollerAnimationStop) {
+                    xScrollerAnimationStop();
+                }
+            }
+            if (yScroller) {
+                if (yScrollerAnimationStop) {
+                    yScrollerAnimationStop();
+                }
+                yScrollerAnimationStop = (0, shared_1.scrollAnimate)(viewport.scrollContainer, 'y', yScroller.direction, yScroller.speed);
+            }
+            else {
+                if (yScrollerAnimationStop) {
+                    yScrollerAnimationStop();
+                }
+            }
+        }
+    };
+    engine.subscribeTo(events_1.DragStartEvent, function () {
+        engine.workbench.eachWorkspace(function (workspace) {
+            workspace.viewport.takeDragStartSnapshot();
+        });
+    });
+    engine.subscribeTo(events_1.DragMoveEvent, function (event) {
+        engine.workbench.eachWorkspace(function (workspace) {
+            var viewport = workspace.viewport;
+            var outline = workspace.outline;
+            var point = new shared_1.Point(event.data.topClientX, event.data.topClientY);
+            if (outline.isPointInViewport(point)) {
+                scrolling(point, outline);
+            }
+            else if (viewport.isPointInViewport(point)) {
+                scrolling(point, viewport);
+            }
+        });
+    });
+    engine.subscribeTo(events_1.DragStopEvent, function () {
+        xScroller = null;
+        yScroller = null;
+        if (xScrollerAnimationStop) {
+            xScrollerAnimationStop();
+        }
+        if (yScrollerAnimationStop) {
+            yScrollerAnimationStop();
+        }
+    });
+};
+exports.useAutoScrollEffect = useAutoScrollEffect;

package/lib/effects/useContentEditableEffect.d.ts

@@ -0,0 +1,2 @@
+import { Engine } from '../models';
+export declare const useContentEditableEffect: (engine: Engine) => void;

package/lib/effects/useContentEditableEffect.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useContentEditableEffect = void 0;
+var path_1 = require("@formily/path");
+var shared_1 = require("@mdesignable/shared");
+var events_1 = require("../events");
+function getAllRanges(sel) {
+    var ranges = [];
+    for (var i = 0; i < sel.rangeCount; i++) {
+        var range = sel.getRangeAt(i);
+        ranges[i] = {
+            collapsed: range.collapsed,
+            startOffset: range.startOffset,
+            endOffset: range.endOffset,
+        };
+    }
+    return ranges;
+}
+function setEndOfContenteditable(contentEditableElement) {
+    var range = document.createRange();
+    range.selectNodeContents(contentEditableElement);
+    range.collapse(false);
+    var selection = shared_1.globalThisPolyfill.getSelection();
+    selection.removeAllRanges();
+    selection.addRange(range);
+}
+function createCaretCache(el) {
+    var currentSelection = shared_1.globalThisPolyfill.getSelection();
+    if (currentSelection.containsNode(el))
+        return;
+    var ranges = getAllRanges(currentSelection);
+    return function (offset) {
+        if (offset === void 0) { offset = 0; }
+        var sel = shared_1.globalThisPolyfill.getSelection();
+        var firstNode = el.childNodes[0];
+        if (!firstNode)
+            return;
+        sel.removeAllRanges();
+        ranges.forEach(function (item) {
+            var range = document.createRange();
+            range.collapse(item.collapsed);
+            range.setStart(firstNode, item.startOffset + offset);
+            range.setEnd(firstNode, item.endOffset + offset);
+            sel.addRange(range);
+        });
+    };
+}
+var useContentEditableEffect = function (engine) {
+    var globalState = {
+        activeElements: new Map(),
+        queue: [],
+        requestTimer: null,
+        isComposition: false,
+    };
+    function onKeyDownHandler(event) {
+        if (event.key === 'Enter') {
+            event.stopPropagation();
+            event.preventDefault();
+        }
+    }
+    function onInputHandler(event) {
+        var _this = this;
+        var node = globalState.activeElements.get(this);
+        event.stopPropagation();
+        event.preventDefault();
+        if (node) {
+            var target_1 = event.target;
+            var handler = function () {
+                globalState.queue.length = 0;
+                if (globalState.isComposition)
+                    return;
+                var restore = createCaretCache(target_1);
+                path_1.Path.setIn(node.props, _this.getAttribute(engine.props.contentEditableAttrName), target_1 === null || target_1 === void 0 ? void 0 : target_1.textContent);
+                (0, shared_1.requestIdle)(function () {
+                    node.takeSnapshot('update:node:props');
+                    restore();
+                });
+            };
+            globalState.queue.push(handler);
+            clearTimeout(globalState.requestTimer);
+            globalState.requestTimer = setTimeout(handler, 600);
+        }
+    }
+    function onSelectionChangeHandler() {
+        clearTimeout(globalState.requestTimer);
+        globalState.requestTimer = setTimeout(globalState.queue[globalState.queue.length - 1], 600);
+    }
+    function onCompositionHandler(event) {
+        if (event.type === 'compositionend') {
+            globalState.isComposition = false;
+            onInputHandler(event);
+        }
+        else {
+            clearTimeout(globalState.requestTimer);
+            globalState.isComposition = true;
+        }
+    }
+    function onPastHandler(event) {
+        event.preventDefault();
+        var node = globalState.activeElements.get(this);
+        var text = event.clipboardData.getData('text');
+        var selObj = shared_1.globalThisPolyfill.getSelection();
+        var target = event.target;
+        var selRange = selObj.getRangeAt(0);
+        var restore = createCaretCache(target);
+        selRange.deleteContents();
+        selRange.insertNode(document.createTextNode(text));
+        path_1.Path.setIn(node.props, this.getAttribute(engine.props.contentEditableAttrName), target.textContent);
+        restore(text.length);
+    }
+    function findTargetNodeId(element) {
+        if (!element)
+            return;
+        var nodeId = element.getAttribute(engine.props.contentEditableNodeIdAttrName);
+        if (nodeId)
+            return nodeId;
+        var parent = element.closest("*[".concat(engine.props.nodeIdAttrName, "]"));
+        if (parent)
+            return parent.getAttribute(engine.props.nodeIdAttrName);
+    }
+    engine.subscribeTo(events_1.MouseClickEvent, function (event) {
+        var _a;
+        var target = event.data.target;
+        var editableElement = (_a = target === null || target === void 0 ? void 0 : target.closest) === null || _a === void 0 ? void 0 : _a.call(target, "*[".concat(engine.props.contentEditableAttrName, "]"));
+        if (editableElement &&
+            editableElement.getAttribute('contenteditable') === 'true')
+            return;
+        globalState.activeElements.forEach(function (node, element) {
+            globalState.activeElements.delete(element);
+            element.removeAttribute('contenteditable');
+            element.removeAttribute('spellcheck');
+            element.removeEventListener('input', onInputHandler);
+            element.removeEventListener('compositionstart', onCompositionHandler);
+            element.removeEventListener('compositionupdate', onCompositionHandler);
+            element.removeEventListener('compositionend', onCompositionHandler);
+            element.removeEventListener('past', onPastHandler);
+            document.removeEventListener('selectionchange', onSelectionChangeHandler);
+        });
+    });
+    engine.subscribeTo(events_1.MouseDoubleClickEvent, function (event) {
+        var _a;
+        var target = event.data.target;
+        var editableElement = (_a = target === null || target === void 0 ? void 0 : target.closest) === null || _a === void 0 ? void 0 : _a.call(target, "*[".concat(engine.props.contentEditableAttrName, "]"));
+        var workspace = engine.workbench.activeWorkspace;
+        var tree = workspace.operation.tree;
+        if (editableElement) {
+            var editable = editableElement.getAttribute('contenteditable');
+            if (editable === 'false' || !editable) {
+                var nodeId = findTargetNodeId(editableElement);
+                if (nodeId) {
+                    var targetNode = tree.findById(nodeId);
+                    if (targetNode) {
+                        globalState.activeElements.set(editableElement, targetNode);
+                        editableElement.setAttribute('spellcheck', 'false');
+                        editableElement.setAttribute('contenteditable', 'true');
+                        editableElement.focus();
+                        editableElement.addEventListener('input', onInputHandler);
+                        editableElement.addEventListener('compositionstart', onCompositionHandler);
+                        editableElement.addEventListener('compositionupdate', onCompositionHandler);
+                        editableElement.addEventListener('compositionend', onCompositionHandler);
+                        editableElement.addEventListener('keydown', onKeyDownHandler);
+                        editableElement.addEventListener('paste', onPastHandler);
+                        document.addEventListener('selectionchange', onSelectionChangeHandler);
+                        setEndOfContenteditable(editableElement);
+                    }
+                }
+            }
+        }
+    });
+};
+exports.useContentEditableEffect = useContentEditableEffect;

package/lib/effects/useCursorEffect.d.ts

@@ -0,0 +1,2 @@
+import { Engine } from '../models';
+export declare const useCursorEffect: (engine: Engine) => void;

package/lib/effects/useCursorEffect.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useCursorEffect = void 0;
+var models_1 = require("../models");
+var events_1 = require("../events");
+var shared_1 = require("@mdesignable/shared");
+var useCursorEffect = function (engine) {
+    engine.subscribeTo(events_1.MouseMoveEvent, function (event) {
+        engine.cursor.setStatus(engine.cursor.status === models_1.CursorStatus.Dragging ||
+            engine.cursor.status === models_1.CursorStatus.DragStart
+            ? engine.cursor.status
+            : models_1.CursorStatus.Normal);
+        if (engine.cursor.status === models_1.CursorStatus.Dragging)
+            return;
+        engine.cursor.setPosition(event.data);
+    });
+    engine.subscribeTo(events_1.DragStartEvent, function (event) {
+        engine.cursor.setStatus(models_1.CursorStatus.DragStart);
+        engine.cursor.setDragStartPosition(event.data);
+    });
+    engine.subscribeTo(events_1.DragMoveEvent, function (event) {
+        engine.cursor.setStatus(models_1.CursorStatus.Dragging);
+        engine.cursor.setPosition(event.data);
+    });
+    engine.subscribeTo(events_1.DragStopEvent, function (event) {
+        engine.cursor.setStatus(models_1.CursorStatus.DragStop);
+        engine.cursor.setDragEndPosition(event.data);
+        engine.cursor.setDragStartPosition(null);
+        (0, shared_1.requestIdle)(function () {
+            engine.cursor.setStatus(models_1.CursorStatus.Normal);
+        });
+    });
+    engine.subscribeTo(events_1.MouseMoveEvent, function (event) {
+        var _a, _b;
+        var currentWorkspace = (_a = event === null || event === void 0 ? void 0 : event.context) === null || _a === void 0 ? void 0 : _a.workspace;
+        if (!currentWorkspace)
+            return;
+        var operation = currentWorkspace.operation;
+        if (engine.cursor.status !== models_1.CursorStatus.Normal) {
+            operation.hover.clear();
+            return;
+        }
+        var target = event.data.target;
+        var el = (_b = target === null || target === void 0 ? void 0 : target.closest) === null || _b === void 0 ? void 0 : _b.call(target, "\n      *[".concat(engine.props.nodeIdAttrName, "],\n      *[").concat(engine.props.outlineNodeIdAttrName, "]\n    "));
+        if (!(el === null || el === void 0 ? void 0 : el.getAttribute)) {
+            return;
+        }
+        var nodeId = el.getAttribute(engine.props.nodeIdAttrName);
+        var outlineNodeId = el.getAttribute(engine.props.outlineNodeIdAttrName);
+        var node = operation.tree.findById(nodeId || outlineNodeId);
+        if (node) {
+            operation.hover.setHover(node);
+        }
+        else {
+            operation.hover.clear();
+        }
+    });
+};
+exports.useCursorEffect = useCursorEffect;

package/lib/effects/useDragDropEffect.d.ts

@@ -0,0 +1,2 @@
+import { Engine } from '../models';
+export declare const useDragDropEffect: (engine: Engine) => void;