wetrade-design
Version:
一款多语言支持Vue3的UI框架
1,442 lines (1,439 loc) • 65.9 kB
JavaScript
import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
import _toArray from "@babel/runtime/helpers/esm/toArray";
import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
/**
* 这个文件用于所有函数方法
*/
import { uuid } from './index';
import { Link, Node, Meta } from './model';
import { TreeNodeType, Direction, ToolsStatusEnum } from './types';
import { Y_DRAG_GAP, DRAG_NODE_HEIGHT, NODE_DISTANCE_X, NODE_DISTANCE_Y, NODE_W, NODE_H, MERGE_NODE_DISTANCE
// CONDITION_HEAD_NODE_HEIGHT,
// MINI_START_NODE_W,
// MINI_START_NODE_H,
} from './const';
// 获取某个节点的父子节点 入参是当前节点的currentNode
export function getCurrentFatherAdnSonNode(data, currentNode) {
if (Array.isArray(currentNode) && currentNode.length === 0) return;
var fatherAdnSon = new Set();
// 遍历二维数组，找到包含数字4的所有数组
data.forEach(function (subArray) {
// 获取父子节点
if (subArray.includes(currentNode[0])) {
// 移除数字4，剩下的就是兄弟节点
var otherElement = subArray.find(function (element) {
return element !== currentNode[0];
});
// 如果存在其他元素，添加到集合中
if (otherElement) {
fatherAdnSon.add(otherElement);
}
}
});
return fatherAdnSon;
}
// 获取某个节点的父节点 入参是当前节点currentNode
export function getCurrentFatherNode(data, currentNode) {
if (Array.isArray(currentNode) && currentNode.length === 0) return;
var fatherNode = new Set();
// 遍历二维数组，找到包含数字4的所有数组
data.forEach(function (subArray) {
// 获取父子节点
if (subArray[1] === currentNode[0]) {
fatherNode.add(subArray);
}
});
return fatherNode;
}
// 获取某个节点的子节点 入参是当前节点currentNode
export function getCurrentChildrenNode(data, currentNode) {
if (Array.isArray(currentNode) && currentNode.length === 0) return;
var childrenNode = new Set();
// 遍历二维数组，找到包含数字4的所有数组
data.forEach(function (subArray) {
// 获取父子节点
if (currentNode[1] === subArray[0]) {
childrenNode.add(subArray);
}
});
return childrenNode;
}
// 获取某个节点的所有兄弟节点 入参是当前节点[start,end]
export function getCurrentBrother(data, currentNode) {
if (Array.isArray(currentNode) && currentNode.length === 0) return;
var siblingsNode = new Set();
data.forEach(function (pair) {
if (pair.includes(currentNode[0]) && pair[0] === currentNode[0]) {
// 过滤当前节点
var isArrayEqual = pair.length === currentNode.length && pair.every(function (value, index) {
return value === currentNode[index];
});
if (!isArrayEqual) siblingsNode.add(pair);
}
});
return siblingsNode;
}
/** 根据id 获取节点
* @param {*} nodeId Array | string
* @param {*} nodeList
* @return {*}
*/
export function findNodeById(_ref) {
var nodeId = _ref.nodeId,
nodeList = _ref.nodeList;
if (Array.isArray(nodeId)) {
var nodeArr = nodeList.filter(function (node) {
return nodeId.includes(node.id);
});
return nodeArr || null;
} else {
var node = nodeList.find(function (node) {
return node.id === nodeId;
});
return node || null;
}
}
/** 根据endId 获取linkList中第一次出现的 下标
* @param {*} endId string
* @param {*} linkList
* @return {*}
*/
export function getLinkFirstIndexByEndId(_ref2) {
var endId = _ref2.endId,
linkList = _ref2.linkList;
return linkList.findIndex(function (v) {
return v.endId === endId;
});
}
/** 根据startId 获取linkList中第一次出现的 下标
* @param {*} endId string
* @param {*} linkList
* @return {*}
*/
export function getLinkFirstIndexByStartId(_ref3) {
var startId = _ref3.startId,
linkList = _ref3.linkList;
return linkList.findIndex(function (v) {
return v.startId === startId;
});
}
/** 新增节点（change nodeList）
* @param {*} addNode
* @param {*} nodeList
* @return {*}
*/
export function addNodeList(_ref4) {
var nodeList = _ref4.nodeList,
addNode = _ref4.addNode;
var addList = Array.isArray(addNode) ? addNode : [addNode];
nodeList.push.apply(nodeList, _toConsumableArray(addList));
}
/** 删除节点 （change nodeList）
* @param {*} delNodeIds Array | string
* @param {*} nodeList
* @return {*}
*/
export function delNodeList(_ref5) {
var nodeList = _ref5.nodeList,
delNodeIds = _ref5.delNodeIds;
var delIds = Array.isArray(delNodeIds) ? delNodeIds : [delNodeIds];
for (var i = nodeList.length - 1; i >= 0; i--) {
if (delIds.includes(nodeList[i].id)) {
nodeList.splice(i, 1);
}
}
}
/** 通过id 查找在linkList经过此元素之后的链路、关系、最后一个link的下标
* @param {*} linkList
* @param {*} nodeId
* @return {*}
*/
export function findLinkChildById(_ref6) {
var linkList = _ref6.linkList,
nodeId = _ref6.nodeId;
// 记录受影响的nodeId，包含自己
var affectedIds = [nodeId];
// 记录受影响的link，不包含与父节点的link（不包含endId===nodeId的link）
var childLinkList = [];
// 受影响的最后一个link的下标,包含以当前id为endId的link
var lastLinkIndex = getLinkFirstIndexByEndId({
endId: nodeId,
linkList: linkList
});
// 当前节点的父节点
var parentIds = [];
// 当前节点的子孙节点，不包含自己
var childIds = [];
linkList.find(function (item, index) {
if (item.endId === nodeId) {
parentIds.push(item.startId);
}
if (affectedIds.includes(item.startId)) {
if (!affectedIds.includes(item.endId)) affectedIds.push(item.endId);
childLinkList.push(item);
lastLinkIndex = index;
}
});
childIds = affectedIds.slice(1);
return {
affectedIds: affectedIds,
childLinkList: childLinkList,
lastLinkIndex: lastLinkIndex,
parentIds: parentIds,
childIds: childIds
};
}
/** 新增兄弟节点(点击【添】)-仅一个
* @param {*} linkList
* @param {*} nodeList
* @param {*} nodeId 点击的节点id
* @param {*} width 需要添加节点的宽度
* @param {*} height 需要添加节点的高度
* @param {*} meta 需要添加节点的meta
* @return {*}
*/
export function appendNode(_ref7) {
var linkList = _ref7.linkList,
nodeId = _ref7.nodeId,
nodeList = _ref7.nodeList,
width = _ref7.width,
height = _ref7.height,
meta = _ref7.meta;
var _findLinkChildById = findLinkChildById({
nodeId: nodeId,
linkList: linkList
}),
lastLinkIndex = _findLinkChildById.lastLinkIndex,
parentIds = _findLinkChildById.parentIds;
var _parentIds = _slicedToArray(parentIds, 1),
parentId = _parentIds[0];
var newNode = new Node({
width: width,
height: height,
meta: meta
});
var newLink = new Link({
startId: parentId,
endId: newNode.id
});
if (lastLinkIndex < 0) return;
linkList.splice(lastLinkIndex + 1, 0, newLink);
addNodeList({
nodeList: nodeList,
addNode: newNode
});
return {
node: newNode,
link: newLink
};
}
/** 新增兄弟节点(点击【添】)-模型
* @param {*} linkList
* @param {*} nodeList
* @param {*} nodeId 点击的节点id
* @param {*} addModuleLink 被添加的模型节点关系（如：[1,3][3,4]）
* @param {*} addModuleNode 被添加的模型节点
* @return {*}
*/
export function addModuleBrotherNode(_ref8) {
var linkList = _ref8.linkList,
nodeId = _ref8.nodeId,
nodeList = _ref8.nodeList,
addModuleLink = _ref8.addModuleLink,
addModuleNode = _ref8.addModuleNode;
var bool = Array.isArray(addModuleLink) && addModuleLink.length && Array.isArray(addModuleNode) && addModuleNode.length;
if (!bool) return;
var _findLinkChildById2 = findLinkChildById({
nodeId: nodeId,
linkList: linkList
}),
lastLinkIndex = _findLinkChildById2.lastLinkIndex,
parentIds = _findLinkChildById2.parentIds;
var _parentIds2 = _slicedToArray(parentIds, 1),
parentId = _parentIds2[0];
var newLink = new Link({
startId: parentId,
endId: addModuleLink[0].startId
});
if (linkList.length && lastLinkIndex < 0) return;
linkList.splice.apply(linkList, [lastLinkIndex + 1, 0, newLink].concat(_toConsumableArray(addModuleLink)));
addNodeList({
nodeList: nodeList,
addNode: addModuleNode
});
}
/** 新增子节点(点击【+】)-仅一个
* @param {*} linkList
* @param {*} nodeList
* @param {*} nodeId 点击的节点id
* @param {*} width 需要添加节点的宽度
* @param {*} height 需要添加节点的高度
* @param {*} meta 需要添加节点的meta
* @return {*}
*/
export function insertNode(_ref9) {
var linkList = _ref9.linkList,
nodeId = _ref9.nodeId,
nodeList = _ref9.nodeList,
width = _ref9.width,
height = _ref9.height,
meta = _ref9.meta;
var newNode = new Node({
width: width,
height: height,
meta: meta
});
var newLink = new Link({
startId: nodeId,
endId: newNode.id
});
// 将所有以当前id为startId的startId改成新节点的id
linkList.forEach(function (v) {
if (v.startId === nodeId) {
v.startId = newNode.id;
}
});
// 再找到当前id为endId的第一个下标(目前只有合并的空节点会有多个【当前id为endId】，空节点的删除在解除合并处理，所以此处不会考虑下标有多个的场景)
var index = getLinkFirstIndexByEndId({
endId: nodeId,
linkList: linkList
});
linkList.splice(index + 1, 0, newLink);
addNodeList({
nodeList: nodeList,
addNode: newNode
});
return {
node: newNode,
link: newLink
};
}
/** 新增子节点(点击【+】)-模型
* 不支持给有子节点的节点添加模型(因不知道将子节点拼接在模型节点的哪一个节点上)，如后续有相关需求再做调整
* @param {*} linkList
* @param {*} nodeList
* @param {*} nodeId 点击的节点id
* @param {*} addModuleLink 被添加的模型节点关系（如：[1,3][3,4]）
* @param {*} addModuleNode 被添加的模型节点
* @return {*}
*/
export function addModuleChildNode(_ref10) {
var linkList = _ref10.linkList,
nodeId = _ref10.nodeId,
nodeList = _ref10.nodeList,
addModuleLink = _ref10.addModuleLink,
addModuleNode = _ref10.addModuleNode;
var bool = Array.isArray(addModuleLink) && addModuleLink.length && Array.isArray(addModuleNode) && addModuleNode.length;
if (!bool) return;
var newLink = new Link({
startId: nodeId,
endId: addModuleLink[0].startId
});
// 找到当前id为endId的第一个下标
var index = getLinkFirstIndexByEndId({
endId: nodeId,
linkList: linkList
});
if (linkList.length && index < 0) return;
linkList.splice.apply(linkList, [index + 1, 0, newLink].concat(_toConsumableArray(addModuleLink)));
addNodeList({
nodeList: nodeList,
addNode: addModuleNode
});
}
/** 合并 节点
* @param {*} mergeNodeList 合并项list
* @param {*} nodeList
* @param {*} linkList
* @return {*}
*/
export function mergeNode(_ref11) {
var mergeNodeList = _ref11.mergeNodeList,
nodeList = _ref11.nodeList,
linkList = _ref11.linkList;
// 合并项目的nodeId集合
var mergeNodeIds = mergeNodeList.map(function (item) {
return item.id;
});
// 合并线的activeId
var activeId = new Date().getTime();
// 插入的位置-index
var spliceLinkList = [];
// 记录每个选中后受影响的link数组
var selectedChildLinkList = [];
// 合并节点
var newNode = new Node({
width: 0,
height: NODE_H,
meta: new Meta({
configKey: 'empty',
extParam: {
isMergeNode: true
}
})
});
nodeList.push(newNode);
mergeNodeIds.forEach(function (id) {
var _findLinkChildById3 = findLinkChildById({
linkList: linkList,
nodeId: id
}),
childLinkList = _findLinkChildById3.childLinkList;
if ((childLinkList === null || childLinkList === void 0 ? void 0 : childLinkList.length) > 0) {
childLinkList.forEach(function (item) {
if (item.startId === id) {
item.startId = newNode.id;
item.id = uuid(); // 重新赋值，否则无法重绘
}
});
selectedChildLinkList.push.apply(selectedChildLinkList, _toConsumableArray(childLinkList));
}
});
selectedChildLinkList.forEach(function (item) {
var index = linkList.findIndex(function (link) {
return link.id === item.id;
});
linkList.splice(index, 1);
});
linkList.forEach(function (item, i) {
// 处理需要插入的link集合
if (mergeNodeIds.includes(item.endId)) {
// 合并关系
var newLink = new Link({
startId: item.endId,
endId: newNode.id,
meta: {
activeId: activeId
}
});
spliceLinkList.push({
index: i + spliceLinkList.length,
link: newLink
});
}
// 修改合并时，可能合并项目后有子节点，则需要将此link的startId改为新的合并节点id
if (mergeNodeIds.includes(item.startId)) {
item.startId = newNode.id;
}
});
spliceLinkList.forEach(function (v) {
linkList.splice(v.index + 1, 0, v.link);
});
// 最后将合并影响的子孙节点都插入至合并节点后
var firstIndex = getLinkFirstIndexByEndId({
endId: newNode.id,
linkList: linkList
});
linkList.splice.apply(linkList, [firstIndex + 1, 0].concat(selectedChildLinkList));
}
/** 取消合并
* @param {*} activeId
* @param {*} nodeList
* @param {*} linkList
* @return {*}
*/
export function cancelMerge(_ref12) {
var activeId = _ref12.activeId,
nodeList = _ref12.nodeList,
linkList = _ref12.linkList;
// 需要删除的link的id
var delLinkIds = [];
// 合并节点id
var mergeNodeId = null;
// 第一个合并节点id
var firstMergeNodeId = null;
// 先处理已合并节点为startId的link
linkList.forEach(function (item) {
var _item$meta;
// 拿到第一个合并项、合并节点id、需要删除的linkId集合
if (((_item$meta = item.meta) === null || _item$meta === void 0 ? void 0 : _item$meta.activeId) === activeId) {
delLinkIds.push(item.id);
if (!firstMergeNodeId) firstMergeNodeId = item.startId;
if (!mergeNodeId) mergeNodeId = item.endId;
}
// 如果合并节点有子节点，则需要改子节点的startId
if (item.startId === mergeNodeId) {
item.startId = firstMergeNodeId;
}
});
// 删除link
for (var i = linkList.length - 1; i >= 0; i--) {
if (delLinkIds.includes(linkList[i].id)) {
linkList.splice(i, 1);
}
}
// nodeList中 删除合并节点
delNodeList({
nodeList: nodeList,
delNodeIds: mergeNodeId
});
}
/** 修改合并
* @param {*} oldMergeNodeList 初始合并项
* @param {*} mergeNodeList 新的合并项
* @param {*} nodeList
* @param {*} linkList
* @param {*} activeId
* @return {*}
*/
export function editMerge(_ref13) {
var activeId = _ref13.activeId,
mergeNodeList = _ref13.mergeNodeList,
nodeList = _ref13.nodeList,
linkList = _ref13.linkList;
// 旧的合并节点id
var odlMergeNodeId = null;
// 合并节点的子孙link
var oldMergeNodChildLinkList = [];
// 新的合并项的nodeId集合
var newMergeNodeIds = mergeNodeList.map(function (item) {
return item.id;
});
// 新的合并线的activeId
var NewActiveId = new Date().getTime();
// 插入的位置-index
var spliceLinkList = [];
// 记录每个选中后受影响的link数组
var selectedChildLinkList = [];
// 合并节点
var newNode = new Node({
width: 0,
height: NODE_H,
meta: new Meta({
configKey: 'empty',
extParam: {
isMergeNode: true
}
})
});
newMergeNodeIds.forEach(function (id) {
var _findLinkChildById4 = findLinkChildById({
linkList: linkList,
nodeId: id
}),
childLinkList = _findLinkChildById4.childLinkList;
if ((childLinkList === null || childLinkList === void 0 ? void 0 : childLinkList.length) > 0) {
childLinkList.forEach(function (item) {
if (item.startId === id) {
item.startId = newNode.id;
item.id = uuid(); // 重新赋值，否则无法重绘
}
});
selectedChildLinkList.push.apply(selectedChildLinkList, _toConsumableArray(childLinkList));
}
});
// 需要删除的link的id 需要在上一步之后获取，因为上一步修改子孙开始link的id
var delLinkIds = linkList.filter(function (item) {
var _item$meta2;
return ((_item$meta2 = item.meta) === null || _item$meta2 === void 0 ? void 0 : _item$meta2.activeId) === activeId;
}).map(function (val) {
return val.id;
});
// 先处理已合并节点为startId的link
linkList.forEach(function (item, i) {
var _item$meta3;
// 拿到旧的合并节点
if (((_item$meta3 = item.meta) === null || _item$meta3 === void 0 ? void 0 : _item$meta3.activeId) === activeId) {
if (!odlMergeNodeId) {
odlMergeNodeId = item.endId;
// 需要记录其=旧的合并节点的子孙link用于后续换位置
var _findLinkChildById5 = findLinkChildById({
linkList: linkList,
nodeId: odlMergeNodeId
}),
childLinkList = _findLinkChildById5.childLinkList;
var list = [];
childLinkList.forEach(function (v) {
if (v.startId === odlMergeNodeId) {
v.startId = newNode.id;
}
});
selectedChildLinkList.forEach(function (v) {
var index = childLinkList.findIndex(function (item) {
return item.id === v.id;
});
if (index < 0 && v.endId !== odlMergeNodeId) {
list.push(v);
}
});
oldMergeNodChildLinkList = [].concat(_toConsumableArray(childLinkList), list);
delLinkIds.push.apply(delLinkIds, _toConsumableArray(oldMergeNodChildLinkList.map(function (item) {
return item.id;
})));
}
}
// 处理需要插入的link集合
if (newMergeNodeIds.includes(item.endId)) {
// 合并关系
var newLink = new Link({
startId: item.endId,
endId: newNode.id,
meta: {
activeId: NewActiveId
}
});
spliceLinkList.push({
index: i + spliceLinkList.length,
link: newLink
});
}
// 如果旧的合并节点有子节点，则需要改子节点的startId
if (item.startId === odlMergeNodeId) {
item.startId = newNode.id;
}
});
// 先插入新的link
spliceLinkList.forEach(function (v) {
linkList.splice(v.index + 1, 0, v.link);
});
// 再删除link（包括旧的合并节点的子孙link）
for (var i = linkList.length - 1; i >= 0; i--) {
if (delLinkIds.includes(linkList[i].id)) {
linkList.splice(i, 1);
}
}
// 最后将旧的合并节点的子孙link插入到新的合并点
// [...selectedChildLinkList, ...oldMergeNodChildLinkList]
if (oldMergeNodChildLinkList.length) {
var firstIndex = getLinkFirstIndexByEndId({
endId: newNode.id,
linkList: linkList
});
linkList.splice.apply(linkList, [firstIndex + 1, 0].concat(_toConsumableArray(oldMergeNodChildLinkList)));
}
// nodeList中 删除原来的合并节点
delNodeList({
nodeList: nodeList,
delNodeIds: odlMergeNodeId
});
// 添加新的合并节点
nodeList.push(newNode);
}
var addGetNodeX = function addGetNodeX(_ref14, params) {
var _endNode$coordinateXF;
var _ref15 = _slicedToArray(_ref14, 2),
startNode = _ref15[0],
endNode = _ref15[1];
var offsetX = params.offsetX,
_params$nodeMap = params.nodeMap,
nodeMap = _params$nodeMap === void 0 ? {} : _params$nodeMap,
nodeWidth = params.nodeWidth;
var actualNodeWidth = typeof startNode.width === 'number' ? startNode.width : nodeWidth;
var calcCoordinateX = function calcCoordinateX() {
var _startNode$coordinate, _endOriginNode$meta, _endOriginNode$meta$e, _startOriginNode$meta, _startOriginNode$meta2;
var startNodeX = startNode === null || startNode === void 0 ? void 0 : (_startNode$coordinate = startNode.coordinate) === null || _startNode$coordinate === void 0 ? void 0 : _startNode$coordinate[0];
var endOriginNode = nodeMap[endNode.id];
var startOriginNode = nodeMap[startNode.id];
var isMergeNode = endOriginNode === null || endOriginNode === void 0 ? void 0 : (_endOriginNode$meta = endOriginNode.meta) === null || _endOriginNode$meta === void 0 ? void 0 : (_endOriginNode$meta$e = _endOriginNode$meta.extParam) === null || _endOriginNode$meta$e === void 0 ? void 0 : _endOriginNode$meta$e.isMergeNode;
var lastIsMerge = startOriginNode === null || startOriginNode === void 0 ? void 0 : (_startOriginNode$meta = startOriginNode.meta) === null || _startOriginNode$meta === void 0 ? void 0 : (_startOriginNode$meta2 = _startOriginNode$meta.extParam) === null || _startOriginNode$meta2 === void 0 ? void 0 : _startOriginNode$meta2.isMergeNode;
var value = startNodeX !== undefined ? startNodeX : startNode.getCoordinateX();
if (isMergeNode) {
value += actualNodeWidth + MERGE_NODE_DISTANCE;
} else if (lastIsMerge) {
value += offsetX - MERGE_NODE_DISTANCE;
} else {
value += actualNodeWidth + offsetX;
}
return value;
};
// X坐标依赖收集
if ((_endNode$coordinateXF = endNode.coordinateXFnList) !== null && _endNode$coordinateXF !== void 0 && _endNode$coordinateXF.length) {
endNode.coordinateXFnList.push(calcCoordinateX);
} else {
endNode.coordinateXFnList = [calcCoordinateX];
}
if (!endNode.getCoordinateX) {
endNode.getCoordinateX = function () {
var _endNode$coordinate, _endNode$coordinateXF2;
var endOriginNode = nodeMap[endNode.id];
var endNodeX = endNode === null || endNode === void 0 ? void 0 : (_endNode$coordinate = endNode.coordinate) === null || _endNode$coordinate === void 0 ? void 0 : _endNode$coordinate[0];
if (endNodeX !== undefined) return endNodeX;
if (((_endNode$coordinateXF2 = endNode.coordinateXFnList) === null || _endNode$coordinateXF2 === void 0 ? void 0 : _endNode$coordinateXF2.length) > 1) {
// 有多个值
var all = endNode.coordinateXFnList.map(function (fn) {
return fn();
});
endNodeX = Math.max.apply(Math, _toConsumableArray(all));
} else {
// 一个值
var _endNode$coordinateXF3 = _slicedToArray(endNode.coordinateXFnList, 1),
fnX = _endNode$coordinateXF3[0];
endNodeX = fnX();
}
var coordinate = endNode.coordinate || [];
coordinate = [endNodeX, coordinate[1]];
endOriginNode.coordinate = coordinate;
endNode.coordinate = coordinate;
return endNodeX;
};
}
};
var addGetNodeYFn = function addGetNodeYFn(tier) {
var currentTier = tier;
return function (_ref16, params) {
var _ref17 = _slicedToArray(_ref16, 2),
startNode = _ref17[0],
endNode = _ref17[1];
var offsetY = params.offsetY,
nodeHeight = params.nodeHeight,
lastEndId = params.lastEndId,
startId = params.startId,
_params$nodeMap2 = params.nodeMap,
nodeMap = _params$nodeMap2 === void 0 ? {} : _params$nodeMap2,
_params$origin = params.origin,
origin = _params$origin === void 0 ? [50, 50] : _params$origin;
if (!endNode.tier) {
// 连接到新节点了
if (lastEndId === startId) {
endNode.tier = startNode.tier;
} else {
// 出现断层
currentTier += 1;
endNode.tier = currentTier;
}
}
if (!endNode.getCoordinateY) {
endNode.getCoordinateY = function () {
var _endNode$coordinate2;
var endOriginNode = nodeMap[endNode.id];
var endNodeY = endNode === null || endNode === void 0 ? void 0 : (_endNode$coordinate2 = endNode.coordinate) === null || _endNode$coordinate2 === void 0 ? void 0 : _endNode$coordinate2[1];
if (endNodeY !== undefined) return endNodeY;
if (endNode.tier === 1) {
endNodeY = origin[1];
} else {
var _tier = endNode.tier - 1;
endNodeY = origin[1] + _tier * (offsetY + nodeHeight);
}
var coordinate = endNode.coordinate || [];
coordinate = [coordinate[0], endNodeY];
endOriginNode.coordinate = coordinate;
endNode.coordinate = coordinate;
return endNodeY;
};
}
};
};
var cloneNodeHooks = function cloneNodeHooks(nodeMap) {
var cloneNodeMap = {};
var addCloneNode = function addCloneNode(id) {
var copyNode = cloneNodeMap[id];
var realNode = nodeMap[id];
if (!copyNode) {
var _realNode$meta;
cloneNodeMap[id] = {
id: realNode.id,
configKey: realNode === null || realNode === void 0 ? void 0 : (_realNode$meta = realNode.meta) === null || _realNode$meta === void 0 ? void 0 : _realNode$meta.configKey,
// miniStartNode: realNode?.miniStartNode,
width: realNode.width,
height: realNode.height
};
return cloneNodeMap[id];
}
return copyNode;
};
var clearData = function clearData() {
cloneNodeMap = null;
};
return [cloneNodeMap, addCloneNode, clearData];
};
// 给链路集合relationList，补全从起始节点开始的一截链路
export var getCompletionPreRelationList = function getCompletionPreRelationList(relationList) {
// 开始节点
var _relationList$ = _slicedToArray(relationList[0], 1),
firstNode = _relationList$[0];
// 补全了开始一截链路的集合
var completionPreRelationList = [];
relationList.forEach(function (item, index) {
// 链路上的起始节点
var _item = _slicedToArray(item, 1),
firstNodeOfPath = _item[0];
// const lastNodeOfPath = item[item.length - 1];
if (firstNodeOfPath === firstNode) {
completionPreRelationList.push(item);
} else {
var preList = relationList.slice(0, index + 1);
var pathIndex = preList.findIndex(function (list) {
return list.includes(firstNodeOfPath);
});
var curPath = preList[pathIndex];
var startIndex = curPath.indexOf(firstNodeOfPath);
// const lastIndex = curPath.indexOf(lastNodeOfPath);
completionPreRelationList.push([].concat(_toConsumableArray(curPath.slice(0, startIndex)), _toConsumableArray(item)));
}
});
return completionPreRelationList;
};
var getInMergeIds = function getInMergeIds(_ref18) {
var relationList = _ref18.relationList,
mergeNodeIds = _ref18.mergeNodeIds;
var inMergeIds = [];
var completionPreRelationList = getCompletionPreRelationList(relationList);
if (relationList !== null && relationList !== void 0 && relationList.length && mergeNodeIds !== null && mergeNodeIds !== void 0 && mergeNodeIds.length) {
// 过滤找到所有在合并链路上节点id们，会有重复
mergeNodeIds.forEach(function (mergeId) {
var tempInMergeIds = [];
var newCompletionPreRelationList = completionPreRelationList.filter(function (item) {
return item.includes(mergeId);
});
var _newCompletionPreRela = _toArray(newCompletionPreRelationList),
firstPath = _newCompletionPreRela[0],
rest = _newCompletionPreRela.slice(1);
var lastPath = rest.pop();
// 要开始截断的id
var startId = null;
// 合并节点在最后链路中的索引
var mergeIdIndex = lastPath.indexOf(mergeId);
lastPath.forEach(function (ele, index) {
if (firstPath.includes(ele) && index < mergeIdIndex) {
startId = ele;
}
});
if (startId) {
// 取交集
newCompletionPreRelationList.forEach(function (item) {
var _tempInMergeIds;
(_tempInMergeIds = tempInMergeIds).push.apply(_tempInMergeIds, _toConsumableArray(item.slice(item.indexOf(startId) + 1, item.indexOf(mergeId))));
});
}
// 去重
tempInMergeIds = Array.from(new Set(tempInMergeIds));
inMergeIds.push.apply(inMergeIds, _toConsumableArray(tempInMergeIds));
});
}
return inMergeIds;
};
// 处理node节点上meta中的属性
var handlerMetaProp = function handlerMetaProp(_ref19) {
var nodeList = _ref19.nodeList,
linkList = _ref19.linkList;
// linkList的endId集合
var endIdList = linkList.map(function (item) {
return item.endId;
});
// 合并节点ids
var mergeNodeIds = endIdList.filter(function (item, index) {
return endIdList.indexOf(item) !== index;
});
mergeNodeIds = Array.from(new Set(mergeNodeIds));
// 不展示'+'icon的节点id集合
var canNotInsertNodeIds = [];
// 链路集合
var relationList = [];
var _nodeList = _slicedToArray(nodeList, 1),
firstNode = _nodeList[0];
// 开始轮询
linkList.forEach(function (link, index) {
var startId = link.startId,
endId = link.endId; // 开始节点和节数节点id
var _ref20 = linkList[index - 1] || {
endId: firstNode.id
},
lastEndId = _ref20.endId; // 上一个关系节点数据
if (lastEndId === startId) {
// 有序
if (!relationList.length) {
relationList[0] = [startId, endId];
} else {
relationList[relationList.length - 1].push(endId);
}
} else {
// 断层
relationList[relationList.length] = [startId, endId];
}
if (mergeNodeIds.includes(endId)) {
canNotInsertNodeIds.push(startId);
}
});
// 在合并链路上的节点id集合
var inMergeIds = getInMergeIds({
relationList: relationList,
mergeNodeIds: mergeNodeIds
});
// 去重
inMergeIds = Array.from(new Set(inMergeIds));
nodeList.forEach(function (item) {
var nodeId = item.id;
var extParam = item.meta.extParam;
// 是否为合并的特殊节点
extParam.isMergeNode = mergeNodeIds.includes(nodeId);
var _handlerShrinkNum = handlerShrinkNum({
nodeList: nodeList,
linkList: linkList,
item: item
}),
filterMyselfChildrenList = _handlerShrinkNum.filterMyselfChildrenList;
// 是否在合并链路上
extParam.inMerge = inMergeIds.includes(nodeId);
// canInsert 合并节点的父节点不展示增加按钮
// 结束节点(优先级最高)不展示增加节点(只能添加新字段，不能直接使用canInsert,因为旧数据保存的被合并节点的canInsert都为true)
extParam.canInsert = item.meta.configKey === 'end_rout_node' ? false : !canNotInsertNodeIds.includes(nodeId);
// 子孙节点中是否有工具为编辑态或错误
var hasError = filterMyselfChildrenList === null || filterMyselfChildrenList === void 0 ? void 0 : filterMyselfChildrenList.some(function (node) {
var _meta$extParam, _meta$extParam2;
var meta = node === null || node === void 0 ? void 0 : node.meta;
var toolsIsEdit = meta === null || meta === void 0 ? void 0 : (_meta$extParam = meta.extParam) === null || _meta$extParam === void 0 ? void 0 : _meta$extParam.toolsIsEdit;
var toolsStatusIsError = [ToolsStatusEnum.SELECT_ERROR, ToolsStatusEnum.EDIT_ERROR, ToolsStatusEnum.VERIFY_ERROR].includes(meta === null || meta === void 0 ? void 0 : (_meta$extParam2 = meta.extParam) === null || _meta$extParam2 === void 0 ? void 0 : _meta$extParam2.toolsStatus);
return (meta === null || meta === void 0 ? void 0 : meta.type) === TreeNodeType.TOOLS && (toolsStatusIsError || toolsIsEdit);
});
// 收起节点是否禁用
extParam.shrinkDisabled = extParam.inMerge || hasError;
});
};
var handlerShrinkNum = function handlerShrinkNum(_ref21) {
var _findLinkChildById6;
var nodeList = _ref21.nodeList,
linkList = _ref21.linkList,
item = _ref21.item;
var nodeId = item.id;
var extParam = item.meta.extParam;
// 子孙节点ids
var filterMyselfChildrenIds = (_findLinkChildById6 = findLinkChildById({
nodeId: nodeId,
linkList: linkList
})) === null || _findLinkChildById6 === void 0 ? void 0 : _findLinkChildById6.childIds;
// 子孙节点nodeList
var filterMyselfChildrenList = findNodeById({
nodeId: filterMyselfChildrenIds,
nodeList: nodeList
});
if (!extParam.isOpen) {
// 获取当前节点后面的节点数量 - 不包括合并节点和拖拽节点;
var filterAfterChildren = filterMyselfChildrenList === null || filterMyselfChildrenList === void 0 ? void 0 : filterMyselfChildrenList.filter(function (ele) {
var _ele$meta, _ele$meta$extParam;
return !ele.meta.extParam.isMergeNode && !((_ele$meta = ele.meta) !== null && _ele$meta !== void 0 && (_ele$meta$extParam = _ele$meta.extParam) !== null && _ele$meta$extParam !== void 0 && _ele$meta$extParam.isDragElement);
});
// 收起节点的收起数量
extParam.shrinkNum = filterAfterChildren.length;
}
return {
filterMyselfChildrenList: filterMyselfChildrenList
};
};
export var renderStgyGraph = function renderStgyGraph(params) {
var _ref22 = params || {},
_ref22$linkList = _ref22.linkList,
linkList = _ref22$linkList === void 0 ? [] : _ref22$linkList,
_ref22$nodeList = _ref22.nodeList,
nodeList = _ref22$nodeList === void 0 ? [] : _ref22$nodeList,
_ref22$renderLinkList = _ref22.renderLinkList,
renderLinkList = _ref22$renderLinkList === void 0 ? [] : _ref22$renderLinkList,
_ref22$nodeMap = _ref22.nodeMap,
nodeMap = _ref22$nodeMap === void 0 ? {} : _ref22$nodeMap,
_ref22$origin = _ref22.origin,
origin = _ref22$origin === void 0 ? [0, 0] : _ref22$origin,
_ref22$offsetY = _ref22.offsetY,
offsetY = _ref22$offsetY === void 0 ? NODE_DISTANCE_Y : _ref22$offsetY,
_ref22$offsetX = _ref22.offsetX,
offsetX = _ref22$offsetX === void 0 ? NODE_DISTANCE_X : _ref22$offsetX,
_ref22$nodeWidth = _ref22.nodeWidth,
nodeWidth = _ref22$nodeWidth === void 0 ? NODE_W : _ref22$nodeWidth,
_ref22$nodeHeight = _ref22.nodeHeight,
nodeHeight = _ref22$nodeHeight === void 0 ? NODE_H : _ref22$nodeHeight,
changeNodeAttributes = _ref22.changeNodeAttributes;
if (!(nodeList !== null && nodeList !== void 0 && nodeList.length) && !(renderLinkList !== null && renderLinkList !== void 0 && renderLinkList.length)) return;
if (nodeList.length === 1) {
var _nodeList2 = _slicedToArray(nodeList, 1),
beginNode = _nodeList2[0];
nodeMap[beginNode.id].coordinate = origin;
}
// 收起节点后页面只有一个渲染节点时，处理开始节点上meta中的属性，nodeList此时只有一个
if (!renderLinkList.length) {
nodeList.forEach(function (item) {
handlerShrinkNum({
nodeList: nodeList,
linkList: linkList,
item: item
});
});
return;
}
// 创建克隆map
var cloneHooksData = cloneNodeHooks(nodeMap);
var _cloneHooksData = _slicedToArray(cloneHooksData, 3),
addCloneNode = _cloneHooksData[1],
clearCloneNodeMap = _cloneHooksData[2];
// 节点 映射到的 所有父节点Map
var parentMap = {};
var subMap = {};
// 给第一个节点初始化数据
var _nodeList3 = _slicedToArray(nodeList, 1),
firstNode = _nodeList3[0];
firstNode.coordinate = origin;
var firstCloneNode = addCloneNode(renderLinkList[0].startId);
firstCloneNode.getCoordinateY = function () {
return origin[1];
};
firstCloneNode.getCoordinateX = function () {
return origin[0];
};
firstCloneNode.coordinate = origin;
firstCloneNode.tier = 1;
// 创建计算Y的函数
var addGetNodeY = addGetNodeYFn(firstCloneNode.tier);
// 链路集合
var relationList = [];
// 开始轮询
renderLinkList.forEach(function (link, index) {
var startId = link.startId,
endId = link.endId; // 开始节点和节数节点id
var _ref23 = renderLinkList[index - 1] || {
endId: firstNode.id
},
lastEndId = _ref23.endId; // 上一个关系节点数据
var startNode = addCloneNode(startId);
var endNode = addCloneNode(endId);
parentMap[endId] ? parentMap[endId].push(startId) : parentMap[endId] = [startId];
subMap[startId] ? subMap[startId].push(endId) : subMap[startId] = [endId];
if (lastEndId === startId) {
// 有序
if (!relationList.length) {
relationList[0] = [startId, endId];
} else {
relationList[relationList.length - 1].push(endId);
}
} else {
// 断层
relationList[relationList.length] = [startId, endId];
}
addGetNodeX([startNode, endNode], {
offsetX: offsetX,
nodeWidth: nodeWidth,
nodeMap: nodeMap
// miniStartNode,
});
addGetNodeY([startNode, endNode], {
offsetY: offsetY,
nodeHeight: nodeHeight,
lastEndId: lastEndId,
startId: startId,
nodeMap: nodeMap,
origin: origin
});
// 业务处理node属性
changeNodeAttributes === null || changeNodeAttributes === void 0 ? void 0 : changeNodeAttributes({
link: link,
index: index,
startNode: nodeMap[startId],
endNode: nodeMap[endId]
});
});
// 数据处理
handlerMetaProp({
nodeList: nodeList,
linkList: linkList
});
// 触发计算
Object.values(cloneHooksData[0]).forEach(function (node) {
var _node$getCoordinateX, _node$getCoordinateY;
(_node$getCoordinateX = node.getCoordinateX) === null || _node$getCoordinateX === void 0 ? void 0 : _node$getCoordinateX.call(node);
(_node$getCoordinateY = node.getCoordinateY) === null || _node$getCoordinateY === void 0 ? void 0 : _node$getCoordinateY.call(node);
});
// 清空缓存数据
clearCloneNodeMap();
cloneHooksData[0] = null;
return {
parentMap: parentMap,
subMap: subMap,
relationList: relationList
};
};
/**
* 展开收起 节点
* @param nodeId 操作节点id
* @param nodeList 节点集合
* @returns
*/
export function shrinkOrExpandNode(_ref24) {
var nodeId = _ref24.nodeId,
nodeList = _ref24.nodeList;
var node = findNodeById({
nodeId: nodeId,
nodeList: nodeList
});
node.meta.extParam.isOpen = !node.meta.extParam.isOpen;
}
/**
* 处理返回页面要渲染的nodeList和linkList
* @param nodeList 节点集合
* @param linkList 有序边集合
* @returns
*/
export function initShrinkNode(_ref25) {
var nodeList = _ref25.nodeList,
linkList = _ref25.linkList;
// 收起节点的节点集合
var shrinkNodeList = nodeList.filter(function (item) {
return !item.meta.extParam.isOpen;
});
// 收起节点ids
var shrinkIds = shrinkNodeList.map(function (item) {
return item.id;
});
// 不展示的nodeId集合
var hiddenIds = [];
var _iterator = _createForOfIteratorHelper(shrinkIds),
_step;
try {
var _loop = function _loop() {
var _hiddenIds;
var nodeId = _step.value;
var subChildIds = [nodeId];
var restShrinkIds = shrinkIds.filter(function (item) {
return item !== nodeId;
});
linkList.forEach(function (_ref26) {
var startId = _ref26.startId,
endId = _ref26.endId,
meta = _ref26.meta;
if (subChildIds.includes(startId)) {
// 子孙节点中截到下一个是收起节点为止
if (!subChildIds.includes(endId) && !restShrinkIds.includes(startId) && !(meta !== null && meta !== void 0 && meta.isDragElement)) {
subChildIds.push(endId);
}
}
});
(_hiddenIds = hiddenIds).push.apply(_hiddenIds, _toConsumableArray(subChildIds.slice(1)));
};
for (_iterator.s(); !(_step = _iterator.n()).done;) {
_loop();
}
// 去重
} catch (err) {
_iterator.e(err);
} finally {
_iterator.f();
}
hiddenIds = Array.from(new Set(hiddenIds));
// 页面要渲染的节点集合
var renderNodeList = nodeList.filter(function (item) {
return !hiddenIds.includes(item.id);
});
// 页面要渲染的边集合
var renderLinkList = linkList.filter(function (item) {
var startId = item.startId,
endId = item.endId;
return !hiddenIds.includes(startId) && !hiddenIds.includes(endId);
});
return {
renderNodeList: renderNodeList,
renderLinkList: renderLinkList
};
}
export var deleteMergeNodeRelation = function deleteMergeNodeRelation(id, params) {
var _ref27 = params || {},
_ref27$linkList = _ref27.linkList,
linkList = _ref27$linkList === void 0 ? [] : _ref27$linkList,
_ref27$mergeId = _ref27.mergeId,
mergeId = _ref27$mergeId === void 0 ? '' : _ref27$mergeId,
_ref27$broId = _ref27.broId,
broId = _ref27$broId === void 0 ? '' : _ref27$broId,
_ref27$delMerge = _ref27.delMerge,
delMerge = _ref27$delMerge === void 0 ? false : _ref27$delMerge;
if (!(linkList !== null && linkList !== void 0 && linkList.length)) return;
var _linkList$reduce = linkList.reduce(function (result, relation) {
var _result$effectIds;
var startId = relation.startId,
endId = relation.endId; // 开始节点和结束节点id
var canInsert = true;
// 删除 被删除节点的关系
if (endId === id || startId === id) {
canInsert = false;
}
if (delMerge && (startId === mergeId || endId === mergeId)) {
canInsert = false;
}
if ((_result$effectIds = result.effectIds) !== null && _result$effectIds !== void 0 && _result$effectIds.length) {
if (result.effectIds.includes(startId)) {
result.effectIds.push(endId);
result.effectRelation.push(relation);
canInsert = false;
}
}
if (startId === mergeId) {
canInsert = false;
result.effectIds.push(endId);
result.effectRelation.push(relation);
}
if (canInsert) {
result.newList.push(relation);
}
return result;
}, {
newList: [],
effectIds: [],
effectRelation: [] // 删除节点后面的全部关系数组
}),
newList = _linkList$reduce.newList,
effectRelation = _linkList$reduce.effectRelation;
var insertIndex = newList.findIndex(function (r) {
return r.endId === broId;
});
if (delMerge) {
effectRelation.forEach(function (r) {
if (r.startId === mergeId) {
r.startId = broId;
}
});
}
if (insertIndex !== -1) {
newList.splice.apply(newList, [insertIndex + (delMerge ? 1 : 2), 0].concat(_toConsumableArray(effectRelation)));
}
return newList;
};
// 删除一个节点的关系 并上下拼接
export var deleteSingleNodeRelation = function deleteSingleNodeRelation(id, params) {
var _ref28 = params || {},
_ref28$linkList = _ref28.linkList,
linkList = _ref28$linkList === void 0 ? [] : _ref28$linkList,
_ref28$hasJoin = _ref28.hasJoin,
hasJoin = _ref28$hasJoin === void 0 ? true : _ref28$hasJoin;
if (!(linkList !== null && linkList !== void 0 && linkList.length)) return;
var res = linkList.reduce(function (result, relation, index) {
var backupRelation = _objectSpread({}, relation);
var startId = backupRelation.startId,
endId = backupRelation.endId; // 开始节点和结束节点id
var _ref29 = linkList[index + 1] || {},
nextStartId = _ref29.startId,
nextEndId = _ref29.endId,
nextMete = _ref29.meta;
var canInsert = true;
if (!result.isStart) {
if (endId === id) {
// 遇到被删除的第一个关系
result.isStart = true;
if (!result.nodeParentId) {
// 记录 被删除的节点的 第一个父节点 方便后续凭借数据
result.nodeParentId = startId;
}
if (nextStartId === id && !result.nodeSubId) {
// 记录 被删除的节点 第一个子节点 方便后续拼接数据
result.nodeSubId = nextEndId;
}
// 如果下一个开始节点 是删除节点 需要前后拼接
if (nextStartId === id && nextEndId && hasJoin) {
backupRelation.startId = startId;
backupRelation.endId = nextEndId;
backupRelation.meta = nextMete;
} else {
canInsert = false;
}
}
} else {
// 如果开始节点等于删除节点 需要前后拼接
if (startId === id) {
if (result.nodeParentId && hasJoin) {
backupRelation.endId = endId;
backupRelation.startId = result.nodeParentId;
backupRelation.id = uuid();
} else {
canInsert = false;
}
} else if (endId === id) {
if (result.nodeSubId && hasJoin) {
backupRelation.startId = startId;
backupRelation.endId = result.nodeSubId;
} else {
canInsert = false;
}
}
}
// 插入数据 并且防止重复插入
if (canInsert) {
var relationKey = "".concat(backupRelation.startId, "+").concat(backupRelation.endId);
if (!result.hasRelation[relationKey]) {
result.newData.push(backupRelation);
result.hasRelation[relationKey] = true;
}
}
return result;
}, {
newData: [],
hasRelation: {},
isStart: false,
nodeParentId: null,
nodeSubId: null
});
return res.newData;
};
// 根据结束id 获取第一个线路
function findLinkByEndId(_ref30) {
var nodeId = _ref30.nodeId,
linkList = _ref30.linkList;
var link = linkList.find(function (link) {
return link.endId === nodeId;
});
return link || null;
}
function findLinkByStartId(_ref31) {
var nodeId = _ref31.nodeId,
linkList = _ref31.linkList;
var link = linkList.find(function (link) {
return link.startId === nodeId;
});
return link || null;
}
// 获取当前之后的子孙节点（包括自己）
function findChildrenNodeList(_ref32) {
var linkList = _ref32.linkList,
nodeId = _ref32.nodeId,
nodeMap = _ref32.nodeMap;
var _findLinkChildById7 = findLinkChildById({
linkList: linkList,
nodeId: nodeId
}),
affectedIds = _findLinkChildById7.affectedIds;
var childrenList = affectedIds.reduce(function (prev, currId) {
var _node$meta, _node$meta$extParam;
var node = nodeMap[currId];
if (!node) {
return _toConsumableArray(prev);
}
if (!(node !== null && node !== void 0 && (_node$meta = node.meta) !== null && _node$meta !== void 0 && (_node$meta$extParam = _node$meta.extParam) !== null && _node$meta$extParam !== void 0 && _node$meta$extParam.isDragElement)) {
return [].concat(_toConsumableArray(prev), [node]);
}
return _toConsumableArray(prev);
}, []);
return childrenList;
}
/**
* @Description: 获取nodeList中 最底部的y值
* @param {*} nodeList
* @return {*}
*/
function calcMaxY(nodeList) {
var maxYBottom = 0;
nodeList.forEach(function (node) {
maxYBottom = Math.max(maxYBottom, node.height + node.coordinate[1]);
});
return maxYBottom;
}
/**
* 节点是否可拖动
* @param param0
* @returns
*/
export function disabledNodeDrag(_ref33) {
var _sourceNode$meta, _sourceNode$meta$extP;
var sourceNode = _ref33.sourceNode,
linkList = _ref33.linkList,
draggable = _ref33.draggable;
if (!draggable) return true;
// 获取源节点的连线
var sourceLink = findLinkByEndId({
nodeId: sourceNode.id,
linkList: linkList
});
// 兜底判断 如果是源节点连线不存在则说明是起始节点，那么不可以拖动
if (!sourceLink) return true;
var isInMerge = (_sourceNode$meta = sourceNode.meta) === null || _sourceNode$meta === void 0 ? void 0 : (_sourceNode$meta$extP = _sourceNode$meta.extParam) === null || _sourceNode$meta$extP === void 0 ? void 0 : _sourceNode$meta$extP.inMerge;
if (isInMerge) return true;
if (sourceNode.meta.type === TreeNodeType.TOOLS) {
if (sourceNode.meta.extParam.toolsIsEdit) return true; // 编辑态不允许拖
// 除自己外是否有其他链路，如果有就可以拖动，没有的话说明没有同级节点
var otherLinkList = linkList.filter(function (link) {
return link.startId === (sourceLink === null || sourceLink === void 0 ? void 0 : sourceLink.startId) && link.endId !== (sourceLink === null || sourceLink === void 0 ? void 0 : sourceLink.endId);
});
return otherLinkList.length <= 0;
}
}
/**
* 根据元素坐标来查询目标节点 也就是要插入在哪个节点附近，找到节点后再根据节点的4个角的坐标来判断插入方向（上、下、右三个方向）
* @param x 水平偏移量
* @param offset 节点偏移量
*/
export function findNodeByCoordinate(_ref34) {
var _renderNodeList$slice, _targetNode$meta, _targetNode$meta$extP, _targetNodePointCoord;
var linkList = _ref34.linkList,
nodeList = _ref34.nodeList,
_ref34$offset = _ref34.offset,
offset = _ref34$offset === void 0 ? [] : _ref34$offset;
var filteredDragNodeList = nodeList.filter(function (node) {
var _node$meta2, _node$meta2$extParam;
return !((_node$meta2 = node.meta) !== null && _node$meta2 !== void 0 && (_node$meta2$extParam = _node$meta2.extParam) !== null && _node$meta2$extParam !== void 0 && _node$meta2$extParam.isDragElement);
});
// 页面上展示的渲染节点
var _initShrinkNode = initShrinkNode({
linkList: linkList,
nodeList: filteredDragNodeList
}),
renderNodeList = _initShrinkNode.renderNodeList;
var _offset = _slicedToArray(offset, 2),
x = _offset[0],
y = _offset[1];
// 找出离当前节点距离最近的点 用三角函数的方法 x^2+y^2 排序取最小值
var absX = Math.abs(x);
var absY = Math.abs(y);
renderNodeList.sort(function (prev, curr) {
var prevCenterX = prev.width ? prev.coordinate[0] + prev.width / 2 : prev.coordinate[0]; // x中心点
var prevCenterY = prev.height ? prev.coordinate[1] + prev.height / 2 : prev.coordinate[1]; // y中心点
var currCenterX = curr.width ? curr.coordinate[0] + curr.width / 2 : curr.coordinate[0]; // x中心点
var currCenterY = curr.height ? curr.coordinate[1] + curr.height / 2 : curr.coordinate[1]; // y中心点
var prevDistance = Math.abs(Math.pow(prevCenterX - absX, 2)) + Math.abs(Math.pow(prevCenterY - absY, 2));
var curDistance = Math.abs(Math.pow(currCenterX - absX, 2)) + Math.abs(Math.pow(currCenterY - absY, 2));
return prevDistance - curDistance;
});
var targetNode = (_renderNodeList$slice = renderNodeList.slice(0, 1)) === null || _renderNodeList$slice === void 0 ? void 0 : _renderNodeList$slice[0];
var isMergeNode = (_targetNode$meta = targetNode.meta) === null || _targetNode$meta === void 0 ? void 0 : (_targetNode$meta$extP = _targetNode$meta.extParam) === null || _targetNode$meta$extP === void 0 ? void 0 : _targetNode$meta$extP.isMergeNode;
var mergeOffset = 20;
// 插入节点4个端点的坐标
var targetNodePointCoordinate = [{
// 上 [x1, y1] 下标就是枚举值 Direction
coordinate: isMergeNode ? [targetNode.coordinate[0] - mergeOffset, targetNode.coordinate[1] - mergeOffset] : _toConsumableArray(targetNode.coordinate),
direction: Direction.TOP
}, {
// 右 [x1 + w, y1]
coordinate: isMergeNode ? [targetNode.coordinate[0] + mergeOffset, targetNode.coordinate[1] - mergeOffset] : [targetNode.coordinate[0] + targetNode.width, targetNode.coordinate[1]],
direction: Direction.RIGHT
}, {
// 下 [x1 + w, y1 + h]
coordinate: isMergeNode ? [targetNode.coordinate[0] + mergeOffset, targetNode.coordinate[1] + mergeOffset] : [targetNode.coordinate[0] + targetNode.width, targetNode.coordinate[1] + targetNode.height],
direction: Direction.BOTTOM
}, {
// 左 [x1, y1 + h]
coordinate: isMergeNode ? [targetNode.coordinate[0] - mergeOffset, targetNode.coordinate[1] + mergeOffset] : [targetNode.coordinate[0], targetNode.coordinate[1] + targetNode.height],
direction: Direction.LEFT
}];
targetNodePointCoordinate.sort(function (prev, curr) {
var prevDistance = Math.abs(Math.pow(prev.coordinate[0] - absX, 2)) + Math.abs(Math.pow(prev.coordinate[1] - absY, 2));
var curDistance = Math.abs(Math.pow(curr.coordinate[0] - absX, 2)) + Math.abs(Math.pow(curr.coordinate[1] - absY, 2));
return prevDistance - curDistance;
});
// 需要判断是否是最后节点 是最后节点的话 右边只有1个方向
return {
node: renderNodeList === null || renderNodeList === void 0 ? void 0 : renderNodeList[0],
direction: targetNodePointCoordinate === null || targetNodePointCoordinate === void 0 ? void 0 : (_targetNodePointCoord = targetNodePointCoordinate[0]) === null || _targetNodePointCoord === void 0 ? void 0 : _targetNodePointCoord.direction // 插入的方向
};
}
// 删除拖拽节点和连线
export function deleteDragNodeAndLink(_ref35) {
var nodeList = _ref35.nodeList,
linkList = _ref35.linkList;
var dragNodeIndex = nodeList.findIndex(function (node) {
var _node$meta3, _node$meta3$extParam;
return (_node$meta3 = node.meta) === null || _node$meta3 === void 0 ? void 0 : (_node$meta3$extParam = _node$meta3.extParam) === null || _node$meta3$extParam === void 0 ? void 0 : _node$meta3$extParam.isDragElement;
});
if (dragNodeIndex > -1) {
nodeList.splice(dragNodeIndex, 1);
var dragLinkIndex = linkList.findIndex(function (link) {
var _link$meta;
return (_link$meta = link.meta) === null || _link$meta === void 0 ? void 0 : _link$meta.isDragElement;
});
dragLinkIndex > -1 && linkList.splice(dragLinkIndex, 1);
}
}
/**
* 添加拖拽占位元素
* @param param0
* @returns
*/
export function appendDragNode(_ref36) {
var _targetNode$meta2, _targetNode$meta2$ext, _targetNode$meta3, _targetNode$meta3$ext, _targetNode$meta4, _targetNode$meta5;
var sourceNode = _ref36.sourceNode,
targetNode = _ref36.targetNode,
nodeList = _ref36.nodeList,
linkList = _ref36.linkList,
direction = _ref36.direction,
nodeMap = _ref36.nodeMap;
var isMergeTargetNode = targetNode === null || targetNode === void 0 ? void 0 : (_targetNode$meta2 = targetNode.meta) === null || _targetNode$meta2 === void 0 ? void 0 : (_targetNode$meta2$ext = _targetNode$meta2.