@buggyorg/graphlib2kgraph/lib/api.js

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.convertPort = convertPort;
exports.convertNode = convertNode;
exports.convertNodes = convertNodes;
exports.convertEdge = convertEdge;
exports.convertEdges = convertEdges;
exports.convertGraph = convertGraph;

var _graphtools = require('@buggyorg/graphtools');

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function convertPort(nodeName, type, port, portType) {
  return {
    id: nodeName + '_' + port + '_' + portType,
    meta: {
      type: type,
      name: port
    }
  };
}

function convertNode(node) {
  return {
    id: node.v,
    labels: [{ text: node.value.id || node.v, name: node.v }],
    ports: _lodash2.default.concat(_lodash2.default.map(node.value.inputPorts, _lodash2.default.partial(convertPort, node.v, _lodash2.default, _lodash2.default, 'in')), _lodash2.default.map(node.value.outputPorts, _lodash2.default.partial(convertPort, node.v, _lodash2.default, _lodash2.default, 'out'))),
    meta: Object.assign({}, node.value, { style: _lodash2.default.get(node, 'value.meta.style') })
  };
}

function convertNodes(nodes) {
  return _lodash2.default.map(nodes, convertNode);
}

function convertEdge(graph, edge) {
  var sourceHierarchy = false;
  var targetHierarchy = false;
  if (graph.parent(edge.v) === edge.w) {
    sourceHierarchy = true;
  } else if (graph.parent(edge.w) === edge.v) {
    targetHierarchy = true;
  } else if (edge.v === edge.w) {
    sourceHierarchy = true;
    targetHierarchy = true;
  }
  return {
    id: edge.v + edge.w,
    source: edge.v,
    sourcePort: edge.v + '_' + edge.value.outPort + (targetHierarchy ? '_in' : '_out'),
    target: edge.w,
    targetPort: edge.w + '_' + edge.value.inPort + (sourceHierarchy ? '_out' : '_in'),
    meta: {
      sourceType: graph.node(edge.v)[targetHierarchy ? 'inputPorts' : 'outputPorts'][edge.value.outPort],
      targetType: graph.node(edge.w)[sourceHierarchy ? 'outputPorts' : 'inputPorts'][edge.value.inPort],
      sourceNode: edge.v,
      sourcePort: edge.value.outPort,
      targetNode: edge.w,
      targetPort: edge.value.inPort,
      style: _lodash2.default.get(edge, 'value.meta.style')
    }
  };
}

function convertEdges(graph, edges) {
  return _lodash2.default.map(edges, _lodash2.default.partial(convertEdge, graph, _lodash2.default));
}

function combineNodes(graph, node, childMap, edgeMap) {
  if (_lodash2.default.has(childMap, node.id)) {
    node.children = _lodash2.default.map(childMap[node.id], _lodash2.default.partial(combineNodes, graph, _lodash2.default, childMap, edgeMap));
  }
  if (_lodash2.default.has(edgeMap, node.id)) {
    node.edges = convertEdges(graph, edgeMap[node.id]);
  }
  return node;
}

var edgeParent = function edgeParent(graph, edge) {
  var outP = edge.v;
  var inP = edge.w;
  if (outP === inP) {
    return outP;
  } else if (graph.parent(outP) === graph.parent(inP)) {
    return graph.parent(outP);
  } else if (graph.parent(outP) === inP) {
    return inP;
  } else {
    return outP;
  }
};

function setEdgeParent(edge, graph) {
  return _lodash2.default.merge({}, edge, { parent: edgeParent(graph, edge) });
}

function convertGraph(graph) {
  var editGraph = _graphtools.utils.edit(graph);
  var nodes = (0, _lodash2.default)(editGraph.nodes).groupBy('parent').mapValues(convertNodes).value();
  var edges = (0, _lodash2.default)(editGraph.edges).map(_lodash2.default.partial(setEdgeParent, _lodash2.default, graph)).groupBy('parent').value();
  return {
    id: 'root',
    // nodes[undefined] returns all nodes that have no parent
    children: _lodash2.default.map(nodes[undefined], _lodash2.default.partial(combineNodes, graph, _lodash2.default, nodes, edges)),
    edges: convertEdges(graph, edges[undefined])
  };
}