@alilc/lowcode-shell/es/model/dragon.js

Shell Layer for AliLowCodeEngine

import _extends from "@babel/runtime/helpers/extends";
import _createClass from "@babel/runtime/helpers/createClass";
import { dragonSymbol, nodeSymbol } from '../symbols';
import LocateEvent from './locate-event';
import { DragObject } from './drag-object';
import { globalContext } from '@alilc/lowcode-editor-core';
export var innerDragonSymbol = Symbol('innerDragonSymbol');
export var Dragon = /*#__PURE__*/function () {
  function Dragon(innerDragon, workspaceMode) {
    this.workspaceMode = workspaceMode;
    this[innerDragonSymbol] = void 0;
    this[innerDragonSymbol] = innerDragon;
  }
  Dragon.create = function create(dragon, workspaceMode) {
    if (!dragon) {
      return null;
    }
    return new Dragon(dragon, workspaceMode);
  }

  /**
   * is dragging or not
   */;
  var _proto = Dragon.prototype;
  /**
   * 绑定 dragstart 事件
   * @param func
   * @returns
   */
  _proto.onDragstart = function onDragstart(func) {
    return this[dragonSymbol].onDragstart(function (e) {
      return func(LocateEvent.create(e));
    });
  }

  /**
   * 绑定 drag 事件
   * @param func
   * @returns
   */;
  _proto.onDrag = function onDrag(func) {
    return this[dragonSymbol].onDrag(function (e) {
      return func(LocateEvent.create(e));
    });
  }

  /**
   * 绑定 dragend 事件
   * @param func
   * @returns
   */;
  _proto.onDragend = function onDragend(func) {
    return this[dragonSymbol].onDragend(function (o) {
      var dragObject = DragObject.create(o.dragObject);
      var copy = o.copy;
      return func({
        dragObject: dragObject,
        copy: copy
      });
    });
  }

  /**
   * 设置拖拽监听的区域 shell，以及自定义拖拽转换函数 boost
   * @param shell 拖拽监听的区域
   * @param boost 拖拽转换函数
   */;
  _proto.from = function from(shell, boost) {
    return this[dragonSymbol].from(shell, boost);
  }

  /**
   * boost your dragObject for dragging(flying) 发射拖拽对象
   *
   * @param dragObject 拖拽对象
   * @param boostEvent 拖拽初始时事件
   */;
  _proto.boost = function boost(dragObject, boostEvent, fromRglNode) {
    return this[dragonSymbol].boost(_extends({}, dragObject, {
      nodes: dragObject.nodes.map(function (node) {
        return node[nodeSymbol];
      })
    }), boostEvent, fromRglNode === null || fromRglNode === void 0 ? void 0 : fromRglNode[nodeSymbol]);
  }

  /**
   * 添加投放感应区
   */;
  _proto.addSensor = function addSensor(sensor) {
    return this[dragonSymbol].addSensor(sensor);
  }

  /**
   * 移除投放感应
   */;
  _proto.removeSensor = function removeSensor(sensor) {
    return this[dragonSymbol].removeSensor(sensor);
  };
  return _createClass(Dragon, [{
    key: dragonSymbol,
    get: function get() {
      if (this.workspaceMode) {
        return this[innerDragonSymbol];
      }
      var workspace = globalContext.get('workspace');
      var editor = globalContext.get('editor');
      if (workspace.isActive) {
        editor = workspace.window.editor;
      }
      var designer = editor.get('designer');
      return designer.dragon;
    }
  }, {
    key: "dragging",
    get: function get() {
      return this[dragonSymbol].dragging;
    }
  }]);
}();