ebaoferc 0.0.1 → 0.0.2-beta.1

package/dist/components/MindGraph/react/component/index.js

@@ -0,0 +1,227 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import React, { forwardRef, useCallback, useEffect, useImperativeHandle, useMemo, useRef, useState } from 'react';
+import { Mind } from "../../core";
+import Classnames from 'classnames';
+import { Scrollbar } from "../scrollbar";
+import { classNameWrapper } from "../tools/class-name-wrapper";
+import { Nodes } from "./nodes";
+
+// @ts-ignore-next-line
+import Style from "./index.module.less";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+export var View = /*#__PURE__*/forwardRef(function (props, ref) {
+  var className = props.className,
+    style = props.style,
+    settingOptions = props.options,
+    data = props.data,
+    anchor = props.anchor,
+    render = props.render,
+    onUpdated = props.onUpdated,
+    scrollbar = props.scrollbar,
+    _props$wheelMoveSpeed = props.wheelMoveSpeed,
+    wheelMoveSpeed = _props$wheelMoveSpeed === void 0 ? 0.5 : _props$wheelMoveSpeed,
+    onDragEnd = props.onDragEnd,
+    onDragStart = props.onDragStart,
+    onDrag = props.onDrag;
+  var _useState = useState(),
+    _useState2 = _slicedToArray(_useState, 2),
+    mind = _useState2[0],
+    setMind = _useState2[1];
+  var _useState3 = useState(),
+    _useState4 = _slicedToArray(_useState3, 2),
+    viewport = _useState4[0],
+    setViewport = _useState4[1];
+  var _useState5 = useState(),
+    _useState6 = _slicedToArray(_useState5, 2),
+    container = _useState6[0],
+    setContainer = _useState6[1];
+  var _useState7 = useState(),
+    _useState8 = _slicedToArray(_useState7, 2),
+    transform = _useState8[0],
+    setTransform = _useState8[1];
+  var _useState9 = useState(false),
+    _useState10 = _slicedToArray(_useState9, 2),
+    isInDragMove = _useState10[0],
+    setIsInDragMove = _useState10[1];
+  var _useState11 = useState(0),
+    _useState12 = _slicedToArray(_useState11, 2),
+    renderChangeToggle = _useState12[0],
+    setRenderChangeToggle = _useState12[1];
+  // 脑图更新事件引用
+  var onUpdatedRef = useRef(onUpdated);
+  useImperativeHandle(ref, function () {
+    return {
+      mind: mind
+    };
+  }, [mind]);
+
+  // 同步事件
+  useEffect(function () {
+    onUpdatedRef.current = onUpdated;
+  }, [onUpdated]);
+
+  // 组件销毁，脑图注销事件绑定
+  useEffect(function () {
+    return function () {
+      mind && mind.unbind();
+    };
+  }, [mind]);
+
+  // transform 值变化事件
+  var onTransformChange = useCallback(function (transform) {
+    setTransform(function (pre) {
+      if (transform.x === (pre === null || pre === void 0 ? void 0 : pre.x) && transform.y === (pre === null || pre === void 0 ? void 0 : pre.y) && transform.scale === (pre === null || pre === void 0 ? void 0 : pre.scale)) {
+        return pre;
+      } else {
+        return _objectSpread({}, transform);
+      }
+    });
+  }, []);
+
+  // 可视节点变化事件
+  var onNodeVisibleChange = useCallback(function (_nodes) {
+    // 可渲染节点变化，引起node内容重渲染
+    setRenderChangeToggle(function (pre) {
+      return pre + 1;
+    });
+  }, []);
+  var onZoomStart = useCallback(function (e) {
+    if (e && e.type === 'mousedown') {
+      setIsInDragMove(true);
+    }
+  }, []);
+  var onZoomEnd = useCallback(function (e) {
+    if (e && e.type === 'mouseup') {
+      setIsInDragMove(false);
+    }
+  }, []);
+  var options = useMemo(function () {
+    // 展开，防止修改源数据
+    var wrapper = _objectSpread({}, settingOptions || {});
+    wrapper.callback = _objectSpread({}, wrapper.callback || {});
+    wrapper.event = _objectSpread({}, wrapper.event || {});
+    var _wrapper$event$onZoom = wrapper.event.onZoomEventTrigger,
+      _wrapper$event$onZoom2 = _wrapper$event$onZoom === void 0 ? {} : _wrapper$event$onZoom,
+      startOutside = _wrapper$event$onZoom2.start,
+      zoomOutside = _wrapper$event$onZoom2.zoom,
+      endOutside = _wrapper$event$onZoom2.end;
+    var _wrapper$callback = wrapper.callback,
+      onTransformChangeOutside = _wrapper$callback.onTransformChange,
+      onNodeVisibleChangeOutside = _wrapper$callback.onNodeVisibleChange;
+    // 包裹事件处理
+    wrapper.callback.onTransformChange = function (t) {
+      onTransformChange(t);
+      onTransformChangeOutside && onTransformChangeOutside(t);
+    };
+    wrapper.callback.onNodeVisibleChange = function (n) {
+      onNodeVisibleChange(n);
+      onNodeVisibleChangeOutside && onNodeVisibleChangeOutside(n);
+    };
+
+    // 注入 zoom 事件触发器
+    // 因为 zoom 相关手势会被立刻 stopImmediatePropagation，故而外部无法通过事件注册监听到
+    wrapper.event.onZoomEventTrigger = {
+      end: function end(e) {
+        endOutside && endOutside(e);
+        onZoomEnd(e);
+      },
+      start: function start(e) {
+        startOutside && startOutside(e);
+        onZoomStart(e);
+      },
+      zoom: function zoom(e) {
+        return zoomOutside && zoomOutside(e);
+      }
+    };
+    return wrapper;
+  }, [settingOptions, onTransformChange, onNodeVisibleChange, onZoomStart, onZoomEnd]);
+
+  // 获取到对应dom，初始化mind
+  useEffect(function () {
+    if (viewport && container) {
+      setMind(new Mind.Graphic(viewport, container));
+    }
+  }, [viewport, container]);
+
+  // 同步 anchor
+  useEffect(function () {
+    if (mind) {
+      mind.setAnchor(anchor);
+    }
+  }, [mind, anchor]);
+
+  // 同步 data,options(引动重渲染)
+  useEffect(function () {
+    if (mind && data) {
+      mind.setOptions(options);
+      // 启动重新渲染操作
+      mind.setData(data);
+      // 通知外部，数据更新已经完成
+      onUpdatedRef.current && onUpdatedRef.current(mind);
+    }
+  }, [mind, data, options]);
+  useEffect(function () {
+    // 重布局计算
+    mind === null || mind === void 0 || mind.refresh();
+  }, [render]);
+  useEffect(function () {
+    if (viewport) {
+      var callback = function callback(event) {
+        // 禁止默认事件（右滑快捷返回）
+        event.preventDefault();
+        if (mind) {
+          mind.translate({
+            x: -event.deltaX * wheelMoveSpeed,
+            y: -event.deltaY * wheelMoveSpeed
+          });
+        }
+      };
+      viewport.addEventListener('wheel', callback, {
+        passive: false
+      });
+      return function () {
+        return viewport.removeEventListener('wheel', callback);
+      };
+    }
+  }, [viewport, mind, wheelMoveSpeed]);
+  return /*#__PURE__*/_jsxs("div", {
+    className: Classnames(classNameWrapper(Style, 'root'), className),
+    children: [/*#__PURE__*/_jsx("div", {
+      className: Classnames(classNameWrapper(Style, 'viewport'), _defineProperty({}, classNameWrapper(Style, 'viewport--drag-move'), isInDragMove)),
+      style: style,
+      ref: setViewport,
+      children: /*#__PURE__*/_jsx("div", {
+        className: classNameWrapper(Style, 'container'),
+        ref: setContainer,
+        children: /*#__PURE__*/_jsx(Nodes, {
+          mind: mind,
+          onDragEnd: onDragEnd,
+          onDragStart: onDragStart,
+          onDrag: onDrag,
+          data: data,
+          render: render,
+          renderChangeToggle: renderChangeToggle
+        })
+      })
+    }), scrollbar && /*#__PURE__*/_jsx(Scrollbar, {
+      viewport: viewport,
+      container: container,
+      mind: mind,
+      transform: transform,
+      options: options
+    })]
+  });
+});
+View.displayName = 'MindReact.View';

package/dist/components/MindGraph/react/component/index.module.less

@@ -0,0 +1,72 @@
+.viewport,.root{
+  width: 100%;
+  height: 100%;
+  position: relative;
+  overflow: hidden;
+}
+
+.viewport{
+  &--drag-move{
+    cursor: pointer;
+  }
+}
+
+.container{
+  position: relative;
+}
+
+.nodes{
+  position: relative;
+}
+
+.node-wrapper{
+  position: absolute;
+  top: 0;
+  left: 0;
+}
+
+.drag-mirror-node{
+  cursor: pointer;
+}
+
+.temporary-line{
+  position: absolute;
+  pointer-events: none;
+}
+
+// default set
+.node-wrapper--dragging{
+  &>*{
+    outline: 2px solid #c04851;
+  }
+}
+
+// default set
+.node-wrapper--attached{
+  &>*{
+    outline: 2px solid #2775b6;
+  }
+}
+
+// default set
+.drag-mirror-node{
+  opacity: 0.6;
+
+  &>*{
+    outline: 2px solid #2775b6;
+  }
+}
+
+:global{
+  // default set
+  .mind {
+    &__lines{
+      stroke: #2775b6;
+      stroke-width: 3px;
+    }
+
+    &__temporary-line{
+      opacity: 0.6;
+    }
+  }
+}

package/dist/components/MindGraph/react/component/nodes.d.ts

@@ -0,0 +1,13 @@
+import { Mind } from '../../core';
+import { MindReact } from '../index';
+interface NodesProps {
+    renderChangeToggle: number;
+    mind?: Mind.Graphic;
+    data: MindReact.Root;
+    render: MindReact.Render;
+    onDragStart?: MindReact.DragStartEvent;
+    onDrag?: MindReact.DragEvent;
+    onDragEnd?: MindReact.DragEndEvent;
+}
+export declare const Nodes: (props: NodesProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/MindGraph/react/component/nodes.js

@@ -0,0 +1,153 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import * as React from 'react';
+import { useCallback, useMemo, useRef, useState } from 'react';
+import { Mind } from "../../core";
+import Classnames from 'classnames';
+import { useDrag } from "../hook/use-drag";
+import { classNameWrapper } from "../tools/class-name-wrapper";
+
+// @ts-ignore-next-line
+import Style from "./index.module.less";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+export var Nodes = function Nodes(props) {
+  var mind = props.mind,
+    data = props.data,
+    render = props.render,
+    renderChangeToggle = props.renderChangeToggle,
+    onDrag = props.onDrag,
+    onDragEnd = props.onDragEnd,
+    onDragStart = props.onDragStart;
+  // 尺寸缓存器
+  var sizeCacheMap = useRef(new Map());
+  // 包裹节点的容器容器引用
+  var _useState = useState(null),
+    _useState2 = _slicedToArray(_useState, 2),
+    nodesContainer = _useState2[0],
+    setNodesContainer = _useState2[1];
+  var renderNodes = useMemo(function () {
+    if (data) {
+      var preSizeCacheMap = new Map(sizeCacheMap.current);
+      sizeCacheMap.current = new Map();
+      return Mind._Helper.rootToNodeArray(data, function (node) {
+        // 缓存中没有，则创建
+        if (!preSizeCacheMap.has(node.id)) {
+          sizeCacheMap.current.set(node.id, {
+            size: {
+              height: -1,
+              width: -1
+            },
+            updateToDate: false
+          });
+        }
+        // 已存在，沿用老数据
+        else {
+          sizeCacheMap.current.set(node.id, preSizeCacheMap.get(node.id));
+        }
+      });
+    }
+    return [];
+  }, [data]);
+  var getNodeSize = useCallback(function (id) {
+    var _sizeCacheMap$current;
+    return (_sizeCacheMap$current = sizeCacheMap.current.get(id)) === null || _sizeCacheMap$current === void 0 ? void 0 : _sizeCacheMap$current.size;
+  }, []);
+  var _useDrag = useDrag({
+      data: data,
+      draggableNodeWrapperQualifier: ".".concat(Style['node-wrapper'], "[data-node-draggable=\"true\"]:not(.").concat(Style['drag-mirror-node'], ")"),
+      mind: mind,
+      nodeWrapperClassName: Style['node-wrapper'],
+      nodesContainer: nodesContainer,
+      onDrag: onDrag,
+      onDragEnd: onDragEnd,
+      onDragStart: onDragStart,
+      renderChangeToggle: renderChangeToggle,
+      renderNodes: renderNodes,
+      sizeof: getNodeSize
+    }),
+    isInDragging = _useDrag.isInDragging,
+    dragNode = _useDrag.dragNode,
+    dragMirrorPosition = _useDrag.dragMirrorPosition,
+    dragAttachedNode = _useDrag.dragAttachedNode;
+  var nodes = useMemo(function () {
+    return renderNodes.map(function (node) {
+      var position = (mind === null || mind === void 0 ? void 0 : mind.getNodeAnchorCoordinate(node.id)) || {
+        x: 0,
+        y: 0
+      };
+      var visible = (mind === null || mind === void 0 ? void 0 : mind.judgeNodeVisible(node.id)) || node.alwaysVisible;
+      var sizeCache = sizeCacheMap.current.get(node.id);
+      // 以下情况需要更新其数据
+      // - 缓存过期
+      // - 尺寸不存在
+      // - 禁用尺寸缓存
+      // - 外部设置需要更新尺寸
+      var needUpdateSize = !sizeCache.updateToDate || sizeCache.size.width < 0 || node.disableSizeCache || node.needUpdateSize;
+      // node size 优先级最高，外界已测量好尺寸，故而，无需再次测量
+      if (node.size) {
+        needUpdateSize = false;
+        sizeCache.size.width = node.size.width;
+        sizeCache.size.height = node.size.height;
+      }
+      // 当不需要更新尺寸的时候，直接使用缓存
+      if (!needUpdateSize) {
+        ;
+        node.sizeof = function () {
+          return {
+            height: sizeCache.size.height,
+            width: sizeCache.size.width
+          };
+        };
+      }
+      // - 受保护节点，一直存在
+      // - 当节点可见时，需要存在
+      // - 当需要刷新size时，节点需要存在
+      var exist = visible || node.beProtected || needUpdateSize;
+      // 根节点不允许拖拽
+      var draggable = !!node.draggable && node.id !== data.node.id;
+      return exist && /*#__PURE__*/_jsx("div", {
+        className: Classnames(classNameWrapper(Style, 'node-wrapper'), _defineProperty(_defineProperty({}, classNameWrapper(Style, 'node-wrapper--dragging'), node.id === (dragNode === null || dragNode === void 0 ? void 0 : dragNode.id) && isInDragging), classNameWrapper(Style, 'node-wrapper--attached'), node.id === (dragAttachedNode === null || dragAttachedNode === void 0 ? void 0 : dragAttachedNode.id) && isInDragging)),
+        style: {
+          transform: "translateX(".concat(position.x, "px) translateY(").concat(position.y, "px)"),
+          visibility: visible ? 'visible' : 'hidden'
+        },
+        "data-node-id": String(node.id),
+        "data-node-draggable": String(draggable),
+        ref: function ref(element) {
+          if (element && needUpdateSize) {
+            // 标识已经获取了最新数据
+            sizeCache.updateToDate = true;
+            sizeCache.size.width = element.clientWidth;
+            sizeCache.size.height = element.clientHeight;
+            node.sizeof = function () {
+              return sizeCache.size;
+            };
+            // 更新完成之后设置为false
+            node.needUpdateSize = false;
+          }
+        },
+        children: render(node, false)
+      }, node.id);
+    });
+  }, [mind, renderNodes, renderChangeToggle, render, dragNode, dragAttachedNode, isInDragging]);
+  return /*#__PURE__*/_jsxs("div", {
+    className: classNameWrapper(Style, 'nodes'),
+    ref: setNodesContainer,
+    children: [nodes, dragNode && isInDragging && /*#__PURE__*/_jsx("div", {
+      className: Classnames(classNameWrapper(Style, 'node-wrapper'), classNameWrapper(Style, 'drag-mirror-node')),
+      style: {
+        transform: "translateX(".concat(dragMirrorPosition.x, "px) translateY(").concat(dragMirrorPosition.y, "px)")
+      },
+      children: render(dragNode, true)
+    })]
+  });
+};

package/dist/components/MindGraph/react/hook/use-drag.d.ts

@@ -0,0 +1,20 @@
+import { Mind } from '../../core';
+import { MindReact } from '../index';
+export declare const useDrag: (context: {
+    mind?: import("../../core/graphic").Graphic | undefined;
+    draggableNodeWrapperQualifier: string;
+    nodeWrapperClassName: string;
+    nodesContainer: HTMLDivElement | null;
+    onDragStart?: MindReact.DragStartEvent | undefined;
+    onDrag?: MindReact.DragEvent | undefined;
+    onDragEnd?: MindReact.DragEndEvent | undefined;
+    sizeof: (id: string) => Mind.Size | undefined;
+    renderNodes: MindReact.Node[];
+    data: MindReact.Root;
+    renderChangeToggle: number;
+}) => {
+    dragAttachedNode: MindReact.Node | undefined;
+    dragMirrorPosition: Mind.Coordinate;
+    dragNode: MindReact.Node | undefined;
+    isInDragging: boolean;
+};

package/dist/components/MindGraph/react/hook/use-drag.js

@@ -0,0 +1,191 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+/* eslint-disable @typescript-eslint/indent */
+// @ts-nocheck
+import { useEffect, useRef, useState } from 'react';
+import { Mind } from "../../core";
+import * as D3 from 'd3';
+import { useShadowState } from "./use-shadow-state";
+export var useDrag = function useDrag(context) {
+  var mind = context.mind,
+    draggableNodeWrapperQualifier = context.draggableNodeWrapperQualifier,
+    nodeWrapperClassName = context.nodeWrapperClassName,
+    nodesContainer = context.nodesContainer,
+    onDrag = context.onDrag,
+    onDragEnd = context.onDragEnd,
+    onDragStart = context.onDragStart,
+    sizeof = context.sizeof,
+    renderNodes = context.renderNodes,
+    data = context.data,
+    renderChangeToggle = context.renderChangeToggle;
+
+  // 被拖动的节点
+  var _useShadowState = useShadowState(undefined),
+    _useShadowState2 = _slicedToArray(_useShadowState, 3),
+    dragNode = _useShadowState2[0],
+    setDragNode = _useShadowState2[1],
+    dragNodeShadow = _useShadowState2[2];
+  // 被拖动节点附着的节点
+  var _useShadowState3 = useShadowState(undefined),
+    _useShadowState4 = _slicedToArray(_useShadowState3, 3),
+    dragAttachedNode = _useShadowState4[0],
+    setDragAttachedNode = _useShadowState4[1],
+    dragAttachedNodeShadow = _useShadowState4[2];
+  // 拖动操作控制器
+  var dragController = useRef(undefined);
+  // 拖动镜像节点位置
+  var _useShadowState5 = useShadowState({
+      x: 0,
+      y: 0
+    }),
+    _useShadowState6 = _slicedToArray(_useShadowState5, 3),
+    dragMirrorPosition = _useShadowState6[0],
+    setDragMirrorPosition = _useShadowState6[1],
+    dragMirrorPositionShadow = _useShadowState6[2];
+  // 当前是否正在拖动
+  var _useState = useState(false),
+    _useState2 = _slicedToArray(_useState, 2),
+    isInDragging = _useState2[0],
+    setIsInDragging = _useState2[1];
+  // 拖动节点镜像节点相关信息
+  var dragMirrorInfo = useRef({
+    origin: {
+      x: 0,
+      y: 0
+    },
+    size: {
+      height: 0,
+      width: 0
+    },
+    start: {
+      x: 0,
+      y: 0
+    }
+  });
+  var dragOrientation = useRef(undefined);
+  useEffect(function () {
+    if (mind && nodesContainer) {
+      D3.select(nodesContainer).selectAll(draggableNodeWrapperQualifier).call(D3.drag().on('start', function (e) {
+        var dragElement = e.sourceEvent.path.find(function (item) {
+          return item.className.includes(nodeWrapperClassName);
+        });
+        if (dragElement) {
+          var dragId = dragElement.getAttribute('data-node-id');
+          var origin = mind.getNodeAnchorCoordinate(dragId);
+          var size = sizeof(dragId);
+          if (origin) {
+            // 记录开始点
+            dragMirrorInfo.current.start.x = e.x;
+            dragMirrorInfo.current.start.y = e.y;
+            // 原点（左上角原始位置）
+            dragMirrorInfo.current.origin.x = origin.x;
+            dragMirrorInfo.current.origin.y = origin.y;
+            setDragMirrorPosition({
+              x: origin.x,
+              y: origin.y
+            });
+          }
+          if (size) {
+            // 记录拖动节点尺寸
+            dragMirrorInfo.current.size.width = size.width;
+            dragMirrorInfo.current.size.height = size.height;
+          }
+          var _dragNode = mind.getNode(dragId);
+          if (_dragNode) {
+            // 调用拖动开始事件
+            onDragStart && onDragStart({
+              node: _dragNode
+            });
+            setDragNode(_dragNode);
+            dragController.current = mind.dragControllerBuilder(dragId);
+          }
+        }
+      }).on('drag', function (e) {
+        if (dragController.current) {
+          var scale = mind.getTransform().scale;
+          var diff = {
+            x: (e.x - dragMirrorInfo.current.start.x) / scale,
+            y: (e.y - dragMirrorInfo.current.start.y) / scale
+          };
+          var mirrorCenter = {
+            x: diff.x + dragMirrorInfo.current.origin.x + dragMirrorInfo.current.size.width / 2,
+            y: diff.y + dragMirrorInfo.current.origin.y + dragMirrorInfo.current.size.height / 2
+          };
+          setDragMirrorPosition({
+            x: diff.x + dragMirrorInfo.current.origin.x,
+            y: diff.y + dragMirrorInfo.current.origin.y
+          });
+          var target = dragController.current.drag(_objectSpread({}, mirrorCenter), renderNodes.filter(function (node) {
+            return node.droppable === undefined ? true : node.droppable;
+          }));
+          dragOrientation.current = target === null || target === void 0 ? void 0 : target.orientation;
+          // 调用拖动中事件
+          onDrag && onDrag({
+            attach: target && target.attach && target.orientation ? {
+              orientation: target.orientation,
+              parent: target.attach
+            } : undefined,
+            mirrorPosition: _objectSpread({}, mirrorCenter),
+            node: dragNodeShadow.current
+          });
+          setIsInDragging(true);
+          setDragAttachedNode(target === null || target === void 0 ? void 0 : target.attach);
+        }
+      }).on('end', function () {
+        // 通知控制器已经结束拖动
+        if (dragController.current) {
+          var attachNode = dragAttachedNodeShadow.current;
+          var index = -1;
+          if (attachNode) {
+            var children = attachNode.children;
+            // 根节点
+            if (attachNode.id === data.node.id) {
+              children = dragOrientation.current === Mind.Orientation.positive ? data.positive : data.negative;
+            }
+            index = dragController.current.calcDropIndex(children, {
+              x: dragMirrorPositionShadow.current.x + dragMirrorInfo.current.size.width / 2,
+              y: dragMirrorPositionShadow.current.y + dragMirrorInfo.current.size.height / 2
+            }, dragNodeShadow.current, attachNode);
+          }
+          dragController.current.end();
+          dragController.current = undefined;
+
+          // 调用拖动结束事件
+          onDragEnd && onDragEnd({
+            attach: dragAttachedNodeShadow.current && dragOrientation.current ? {
+              index: index,
+              orientation: dragOrientation.current,
+              parent: dragAttachedNodeShadow.current
+            } : undefined,
+            node: dragNodeShadow.current,
+            original: {
+              orientation: mind.getNodeOrientation(dragNodeShadow.current.id),
+              parent: mind.getParent(dragNodeShadow.current.id)
+            }
+          });
+        }
+        // 清空数据
+        setDragNode(undefined);
+        setDragAttachedNode(undefined);
+        setIsInDragging(false);
+        dragOrientation.current = undefined;
+      }));
+    }
+  }, [mind, renderChangeToggle, data, renderNodes, onDragStart, onDrag, onDragEnd, nodesContainer]);
+  return {
+    dragAttachedNode: dragAttachedNode,
+    dragMirrorPosition: dragMirrorPosition,
+    dragNode: dragNode,
+    isInDragging: isInDragging
+  };
+};