@openchoreo/cell-diagram 1.2.0-rc.1

package/dist/utils/projectUtils.esm.js

@@ -0,0 +1,969 @@
+import { DiagramModel, PortModelAlignment } from '@projectstorm/react-diagrams';
+import 'react/jsx-runtime';
+import '@projectstorm/react-canvas-core';
+import { COMPONENT_NODE, CONNECTION_NODE, MAIN_CELL, CIRCLE_WIDTH, LINE_MIN_WIDTH, DIAGRAM_END, DOT_WIDTH, BORDER_NODE, BORDER_GAP, MAIN_CELL_DEFAULT_HEIGHT } from '../resources/constants.esm.js';
+import 'gsap';
+import { CellBounds } from '../components/Cell/CellNode/CellModel.esm.js';
+import '@projectstorm/react-diagrams-core';
+import '@projectstorm/geometry';
+import '@projectstorm/react-diagrams-defaults';
+import { ConnectionType, ComponentType } from '../types.esm.js';
+import { getEmptyNodeName, getNodePortId, getCellLinkName, getCellPortMetadata } from '../components/Cell/cell-util.esm.js';
+import { ConnectionModel, Orientation } from '../components/Connection/ConnectionNode/ConnectionModel.esm.js';
+import { getComponentName, getComponentNameById, getComponentLinkName } from '../components/Component/component-node-util.esm.js';
+import { getConnectionNameById } from '../components/Connection/connection-node-util.esm.js';
+import { getExternalLinkName, getExternalNodeName } from '../components/External/external-node-util.esm.js';
+import { DagreEngine } from '../resources/Dagre/DagreEngine.esm.js';
+import 'react';
+import '@mui/material/Fade';
+import '@mui/material/Box';
+import '@mui/material/Tooltip';
+import '@mui/icons-material/OpenInNewRounded';
+import '../components/Project/ProjectNode/styles.esm.js';
+import '../components/Project/ProjectPort/styles.esm.js';
+import '../components/Cell/CellNode/styles.esm.js';
+import '../components/DiagramContext/DiagramContext.esm.js';
+import '../theme/ThemeContext.esm.js';
+import '../theme/CellDiagramThemeProvider.esm.js';
+import '../components/SharedLink/SharedLink.esm.js';
+import '../components/Project/AdvancedLink/AdvancedLinkFactory.esm.js';
+import { ComponentModel } from '../components/Component/ComponentNode/ComponentModel.esm.js';
+import '../components/Component/ComponentNode/styles.esm.js';
+import '../components/MoreVertMenu/MoreVertMenu.esm.js';
+import { ComponentLinkModel } from '../components/Component/ComponentLink/ComponentLinkModel.esm.js';
+import '../components/ObservationLabel/ObservationLabel.esm.js';
+import '../components/TooltipLabel/TooltipLabel.esm.js';
+import '@mui/material/Popper';
+import '../components/Connection/ConnectionNode/styles.esm.js';
+import { CellLinkModel } from '../components/Cell/CellLink/CellLinkModel.esm.js';
+import { EmptyModel } from '../components/Cell/EmptyNode/EmptyModel.esm.js';
+import '../components/Cell/EmptyNode/styles.esm.js';
+import { ExternalModel } from '../components/External/ExternalNode/ExternalModel.esm.js';
+import '../components/External/ExternalNode/styles.esm.js';
+import { ExternalLinkModel } from '../components/External/ExternalLink/ExternalLinkModel.esm.js';
+import '../components/OverlayLoader/OverlayLayerWidget.esm.js';
+import '../components/PromptScreen/PromptScreen.esm.js';
+import '../components/Header/Header.esm.js';
+import '../components/Controls/DiagramControls.esm.js';
+
+function getDiagramDataFromProject(project) {
+  const componentNodes = generateComponentNodes(project);
+  const connectorNodes = generateConnectorNodes(project);
+  const connectionNodes = generateConnectionNodes(project);
+  const externalNodes = generateExternalNodes();
+  const emptyNodes = generateEmptyNodes(project.name, [
+    ...connectionNodes.values(),
+    ...connectorNodes.values()
+  ]);
+  const gateways = getCellGateways(project);
+  const observationSummary = getObservationSummary(project);
+  const componentLinks = generateComponentLinks(project, componentNodes);
+  const cellLinks = generateCellLinks(
+    project,
+    emptyNodes,
+    componentNodes
+  );
+  const connectorLinks = generateConnectorLinks(
+    emptyNodes,
+    connectorNodes
+  );
+  const connectionLinks = generateConnectionLinks(emptyNodes, connectionNodes);
+  const externalLinks = generateExternalLinks(
+    emptyNodes,
+    externalNodes,
+    gateways
+  );
+  const externalConnectionLinks = generateExternalConnectionLinks(project, componentNodes, connectionNodes);
+  return {
+    nodes: {
+      componentNodes,
+      connectionNodes,
+      connectorNodes,
+      externalNodes,
+      emptyNodes
+    },
+    links: {
+      componentLinks,
+      cellLinks,
+      connectorLinks,
+      connectionLinks,
+      externalLinks,
+      externalConnectionLinks
+    },
+    gateways,
+    observationSummary
+  };
+}
+function getComponentDiagramWidth(models) {
+  const tempModel = new DiagramModel();
+  tempModel.addAll(
+    ...models.nodes.componentNodes.values(),
+    ...models.links.componentLinks.values(),
+    ...models.nodes.emptyNodes.values(),
+    ...models.links.cellLinks.values()
+  );
+  const dagreEngine = new DagreEngine({
+    graph: {
+      rankdir: "LR",
+      ranksep: 200,
+      edgesep: 100,
+      nodesep: 150,
+      ranker: "tight-tree"
+    }
+  });
+  dagreEngine.redistribute(tempModel);
+  return calculateCellWidth(tempModel);
+}
+function getComponentDiagramBoundaries(model) {
+  let minX = DIAGRAM_END;
+  let minY = DIAGRAM_END;
+  let maxX = 0;
+  let maxY = 0;
+  model.getNodes().forEach((node) => {
+    if (!isRenderInsideCell(node)) {
+      return;
+    }
+    const nodePosition = node.getPosition().clone();
+    minX = Math.min(minX, nodePosition.x);
+    minY = Math.min(minY, nodePosition.y);
+    maxX = Math.max(maxX, nodePosition.x + node.width);
+    maxY = Math.max(maxY, nodePosition.y + node.height);
+  });
+  return { maxX, minX, maxY, minY };
+}
+function calculateCellWidth(model) {
+  const { maxX, minX, maxY, minY } = getComponentDiagramBoundaries(model);
+  const layoutWidth = Math.max(
+    maxX - minX,
+    maxY - minY,
+    MAIN_CELL_DEFAULT_HEIGHT
+  );
+  const cellWidth = layoutWidth * 3 / 2;
+  return cellWidth;
+}
+function manualDistribute(model) {
+  const { maxX, minX, maxY, minY } = getComponentDiagramBoundaries(model);
+  const layoutCenterX = (maxX + minX) / 2;
+  const layoutCenterY = (maxY + minY) / 2;
+  const cellNode = model.getNode(MAIN_CELL);
+  if (!cellNode) {
+    return model;
+  }
+  const cellWidth = cellNode.width;
+  const cellNodePosition = cellNode.getPosition().clone();
+  cellNodePosition.x = layoutCenterX - cellWidth / 2;
+  cellNodePosition.y = layoutCenterY - cellWidth / 2;
+  cellNode.setPosition(cellNodePosition);
+  updateBoundNodePositions(cellNode, model);
+  return model;
+}
+function updateBoundNodePositions(cellNode, model) {
+  const externalLinkOffset = Math.max(100, cellNode.width / 10);
+  let nextConnectorNodeOffset = externalLinkOffset;
+  let externalConsumerOffset = 0;
+  model.getNodes().forEach((node) => {
+    if (node instanceof ComponentModel && node.isExternalConsumer()) {
+      const cellPosition = cellNode.getPosition();
+      node.setPosition(
+        cellPosition.x - 200 - externalConsumerOffset,
+        cellPosition.y - 200
+      );
+      externalConsumerOffset += node.width + 50;
+    }
+  });
+  for (const key in cellNode.getPorts()) {
+    if (Object.prototype.hasOwnProperty.call(cellNode.getPorts(), key)) {
+      const port = cellNode.getPorts()[key];
+      const { bound, align, args } = getCellPortMetadata(port.getID());
+      if (!bound || !align) {
+        return;
+      }
+      const connectionId = args?.length > 0 ? args[0] : void 0;
+      if (bound === CellBounds.SouthBound && align === PortModelAlignment.BOTTOM) {
+        const portPosition = port.getPosition().clone();
+        const connectionNode = model.getNode(
+          getConnectionNameById(connectionId)
+        );
+        const defaultNodeWidth = CIRCLE_WIDTH + 24;
+        if (connectionNode) {
+          portPosition.x = portPosition.x - connectionNode.width / 2;
+          portPosition.y = portPosition.y + nextConnectorNodeOffset;
+          connectionNode.setPosition(portPosition);
+          if (nextConnectorNodeOffset === externalLinkOffset && connectionNode.width > defaultNodeWidth) {
+            nextConnectorNodeOffset = externalLinkOffset + connectionNode.height;
+          } else {
+            nextConnectorNodeOffset = externalLinkOffset;
+          }
+        }
+      }
+      if (connectionId && bound === CellBounds.SouthBound && align === PortModelAlignment.TOP) {
+        const portPosition = port.getPosition().clone();
+        model.getNode(getEmptyNodeName(CellBounds.SouthBound, connectionId)).setPosition(portPosition);
+      }
+      if (connectionId && bound === CellBounds.EastBound && align === PortModelAlignment.RIGHT) {
+        const portPosition = port.getPosition().clone();
+        const connectionNode = model.getNode(
+          getConnectionNameById(connectionId)
+        );
+        if (connectionNode) {
+          portPosition.x = portPosition.x + externalLinkOffset;
+          portPosition.y = portPosition.y - connectionNode.height / 2 + 7.5;
+          connectionNode.setPosition(portPosition);
+        }
+      }
+      if (connectionId && bound === CellBounds.EastBound && align === PortModelAlignment.LEFT) {
+        const portPosition = port.getPosition().clone();
+        model.getNode(getEmptyNodeName(CellBounds.EastBound, connectionId)).setPosition(portPosition);
+      }
+      if (bound === CellBounds.WestBound && align === PortModelAlignment.LEFT) {
+        const nodePosition = port.getPosition().clone();
+        nodePosition.x = nodePosition.x - LINE_MIN_WIDTH * 2;
+        model.getNode(getEmptyNodeName(CellBounds.WestBound)).setPosition(nodePosition);
+        const portPosition = port.getPosition().clone();
+        portPosition.x = portPosition.x - externalLinkOffset;
+        model.getNode(getExternalNodeName(bound))?.setPosition(portPosition);
+      }
+      if (bound === CellBounds.NorthBound && align === PortModelAlignment.TOP) {
+        const nodePosition = port.getPosition().clone();
+        nodePosition.y = nodePosition.y - LINE_MIN_WIDTH * 2;
+        model.getNode(getEmptyNodeName(CellBounds.NorthBound)).setPosition(nodePosition);
+        const portPosition = port.getPosition().clone();
+        portPosition.y = portPosition.y - externalLinkOffset;
+        model.getNode(getExternalNodeName(bound))?.setPosition(portPosition);
+      }
+    }
+  }
+  const cellPositionNorth = cellNode.getPosition().clone();
+  cellPositionNorth.y = cellPositionNorth.y - (externalLinkOffset + CIRCLE_WIDTH / 2) - BORDER_GAP;
+  model.getNode(getEmptyNodeName(CellBounds.NorthBound, BORDER_NODE))?.setPosition(cellPositionNorth.clone());
+  const cellPositionSouth = cellNode.getPosition().clone();
+  cellPositionSouth.y = cellPositionSouth.y + (cellNode.width - CIRCLE_WIDTH) + BORDER_GAP;
+  model.getNode(getEmptyNodeName(CellBounds.SouthBound, BORDER_NODE))?.setPosition(cellPositionSouth.clone());
+}
+function isRenderInsideCell(node) {
+  return node.getType() === COMPONENT_NODE && !node.isExternalConsumer() || node.getType() === CONNECTION_NODE && isConnectorConnection(node.connection) && !!node.connection.onPlatform;
+}
+function generateComponentNodes(project) {
+  const nodes = /* @__PURE__ */ new Map();
+  project.components?.forEach((component, _key) => {
+    const componentNode = new ComponentModel(component);
+    nodes.set(componentNode.getID(), componentNode);
+    component.connections?.forEach((connection) => {
+      if (isConnectorConnection(connection) && connection.onPlatform) {
+        const connectionNode = new ConnectionModel(connection);
+        nodes.set(connectionNode.getID(), connectionNode);
+      }
+    });
+  });
+  project.configurations?.forEach((connection, _key) => {
+    if (isConnectorConnection(connection) && connection.onPlatform) {
+      const connectionNode = new ConnectionModel(connection);
+      nodes.set(connectionNode.getID(), connectionNode);
+    }
+  });
+  return nodes;
+}
+function generateConnectionNodes(project) {
+  const nodes = /* @__PURE__ */ new Map();
+  project.components?.forEach((component, _key) => {
+    component.connections?.forEach((connection) => {
+      if (isExternalConnection(project.id, connection, true)) {
+        const connectionNode = new ConnectionModel(
+          connection,
+          Orientation.HORIZONTAL
+        );
+        nodes.set(connectionNode.getID(), connectionNode);
+      }
+    });
+  });
+  return nodes;
+}
+function generateConnectorNodes(project) {
+  const nodes = /* @__PURE__ */ new Map();
+  project.components?.forEach((component, _key) => {
+    component.connections?.forEach((connection) => {
+      if (isConnectorConnection(connection) && !connection.onPlatform) {
+        const connectionNode = new ConnectionModel(connection);
+        nodes.set(connectionNode.getID(), connectionNode);
+      }
+    });
+  });
+  project.configurations?.forEach((connection, _key) => {
+    if (isConnectorConnection(connection) && !connection.onPlatform) {
+      const connectionNode = new ConnectionModel(connection);
+      nodes.set(connectionNode.getID(), connectionNode);
+    }
+  });
+  return nodes;
+}
+function generateExternalNodes() {
+  const nodes = /* @__PURE__ */ new Map();
+  const northBoundExternalNode = new ExternalModel(CellBounds.NorthBound);
+  nodes.set(northBoundExternalNode.getID(), northBoundExternalNode);
+  const westBoundExternalNode = new ExternalModel(CellBounds.WestBound);
+  nodes.set(westBoundExternalNode.getID(), westBoundExternalNode);
+  return nodes;
+}
+function generateEmptyNodes(projectId, connectionNodes) {
+  const nodes = /* @__PURE__ */ new Map();
+  const northBoundEmptyNode = new EmptyModel(
+    CellBounds.NorthBound,
+    CIRCLE_WIDTH + LINE_MIN_WIDTH * 4
+  );
+  northBoundEmptyNode.setPosition(0, DIAGRAM_END * -1);
+  nodes.set(northBoundEmptyNode.getID(), northBoundEmptyNode);
+  const westBoundEmptyNode = new EmptyModel(
+    CellBounds.WestBound,
+    CIRCLE_WIDTH + LINE_MIN_WIDTH * 4
+  );
+  westBoundEmptyNode.setPosition(DIAGRAM_END * -1, 0);
+  nodes.set(westBoundEmptyNode.getID(), westBoundEmptyNode);
+  let count = 0;
+  connectionNodes.forEach((connectionNode, _key) => {
+    if (isConnectorConnection(connectionNode.connection)) {
+      const connectionEmptyNode = new EmptyModel(
+        CellBounds.SouthBound,
+        DOT_WIDTH,
+        connectionNode.connection.id
+      );
+      connectionEmptyNode.setPosition(count++ * 30, DIAGRAM_END);
+      nodes.set(connectionEmptyNode.getID(), connectionEmptyNode);
+    } else if (isExternalConnection(projectId, connectionNode.connection, true)) {
+      const connectionEmptyNode = new EmptyModel(
+        CellBounds.EastBound,
+        DOT_WIDTH,
+        connectionNode.connection.id
+      );
+      connectionEmptyNode.setPosition(DIAGRAM_END, count++ * 30);
+      nodes.set(connectionEmptyNode.getID(), connectionEmptyNode);
+    }
+  });
+  const northBoundBorderEmptyNode = new EmptyModel(
+    CellBounds.NorthBound,
+    CIRCLE_WIDTH,
+    BORDER_NODE
+  );
+  nodes.set(northBoundBorderEmptyNode.getID(), northBoundBorderEmptyNode);
+  const southBoundBorderEmptyNode = new EmptyModel(
+    CellBounds.SouthBound,
+    CIRCLE_WIDTH,
+    BORDER_NODE
+  );
+  nodes.set(southBoundBorderEmptyNode.getID(), southBoundBorderEmptyNode);
+  return nodes;
+}
+function getCellGateways(project) {
+  const gateways = {
+    internet: false,
+    intranet: false
+  };
+  project.components?.forEach((component, _key) => {
+    for (const serviceId in component.services) {
+      if (Object.prototype.hasOwnProperty.call(component.services, serviceId)) {
+        const service = component.services[serviceId];
+        if (service.deploymentMetadata?.gateways.internet.isExposed) {
+          gateways.internet = true;
+        }
+        if (service.deploymentMetadata?.gateways.intranet.isExposed) {
+          gateways.intranet = true;
+        }
+      }
+    }
+  });
+  return gateways;
+}
+function getObservationSummary(project) {
+  let maxRequestCount = 0;
+  const calculateRequestCount = (observations) => {
+    if (observations && observations.length > 0) {
+      const requestCount = observations.reduce(
+        (acc, obs) => acc + obs.requestCount,
+        0
+      );
+      if (requestCount > maxRequestCount) {
+        maxRequestCount = requestCount;
+      }
+    }
+  };
+  project.components?.forEach((component, _key) => {
+    for (const serviceId in component.services) {
+      if (Object.prototype.hasOwnProperty.call(component.services, serviceId)) {
+        const service = component.services[serviceId];
+        calculateRequestCount(
+          service.deploymentMetadata?.gateways.internet.observations
+        );
+        calculateRequestCount(
+          service.deploymentMetadata?.gateways.intranet.observations
+        );
+      }
+    }
+    if (component.connections.length > 0) {
+      component.connections.forEach((connection) => {
+        calculateRequestCount(connection.observations);
+      });
+    }
+  });
+  return { requestCount: { max: maxRequestCount, min: 0 } };
+}
+function generateComponentLinks(project, nodes) {
+  const links = /* @__PURE__ */ new Map();
+  project.components?.forEach((component, _key) => {
+    if (component.type === ComponentType.EXTERNAL_CONSUMER) {
+      return;
+    }
+    const componentId = getComponentName(component);
+    const callingComponent = nodes.get(
+      componentId
+    );
+    component.connections.forEach((connection) => {
+      const connectionMetadata = getConnectionMetadata(connection);
+      if (connectionMetadata && !isConnectorConnection(connection) && isInternalComponent(project.id, connection)) {
+        const associatedComponent = nodes.get(
+          getComponentNameById(
+            connectionMetadata.component
+          )
+        );
+        if (callingComponent && associatedComponent) {
+          const sourcePort = callingComponent.getPort(`right-${callingComponent.getID()}`);
+          const targetPort = associatedComponent.getPort(`left-${associatedComponent.getID()}`);
+          if (sourcePort && targetPort) {
+            const linkId = getComponentLinkName(
+              sourcePort.getID(),
+              targetPort.getID()
+            );
+            const link = new ComponentLinkModel(linkId);
+            links.set(
+              linkId,
+              createLinks(sourcePort, targetPort, link)
+            );
+            link.setSourceNode(callingComponent.getID());
+            link.setTargetNode(associatedComponent.getID());
+            if (connection.observations && connection.observations.length > 0) {
+              link.setObservations(
+                connection.observations,
+                connection.observationOnly
+              );
+            }
+            if (connection.tooltip) {
+              link.setTooltip(connection.tooltip);
+            }
+          }
+        }
+      }
+      if (isConnectorConnection(connection) && connection.onPlatform) {
+        const associatedComponent = nodes.get(
+          getConnectionNameById(connection.id)
+        );
+        if (callingComponent && associatedComponent) {
+          const sourcePort = callingComponent.getPort(`bottom-${callingComponent.getID()}`);
+          const targetPort = associatedComponent.getPort(`top-${associatedComponent.getID()}`);
+          if (sourcePort && targetPort) {
+            const linkId = getComponentLinkName(
+              sourcePort.getID(),
+              targetPort.getID()
+            );
+            const link = new ComponentLinkModel(linkId);
+            links.set(
+              linkId,
+              createLinks(sourcePort, targetPort, link)
+            );
+            link.setSourceNode(callingComponent.getID());
+            link.setTargetNode(associatedComponent.getID());
+            if (connection.observations && connection.observations.length > 0) {
+              link.setObservations(
+                connection.observations,
+                connection.observationOnly
+              );
+            }
+            if (connection.tooltip) {
+              link.setTooltip(connection.tooltip);
+            }
+          }
+        }
+      }
+    });
+  });
+  return links;
+}
+function generateConnectorLinks(emptyNodes, connectorNodes) {
+  const links = /* @__PURE__ */ new Map();
+  connectorNodes?.forEach((connectionNode, _key) => {
+    const southBoundEmptyNode = emptyNodes.get(
+      getEmptyNodeName(CellBounds.SouthBound, connectionNode.connection.id)
+    );
+    if (!southBoundEmptyNode) {
+      return;
+    }
+    const sourcePort = southBoundEmptyNode.getPort(
+      getNodePortId(southBoundEmptyNode.getID(), PortModelAlignment.BOTTOM)
+    );
+    const targetPort = connectionNode.getPort(
+      `top-${connectionNode.getID()}`
+    );
+    if (sourcePort && targetPort) {
+      const linkId = getExternalLinkName(
+        sourcePort.getID(),
+        targetPort.getID()
+      );
+      const link = new ExternalLinkModel(linkId);
+      links.set(
+        linkId,
+        createLinks(sourcePort, targetPort, link)
+      );
+      link.setSourceNode(southBoundEmptyNode.getID());
+      link.setTargetNode(connectionNode.getID());
+    }
+  });
+  return links;
+}
+function generateConnectionLinks(emptyNodes, connectionNodes) {
+  const links = /* @__PURE__ */ new Map();
+  connectionNodes?.forEach((connectionNode, _key) => {
+    const eastboundEmptyNode = emptyNodes.get(
+      getEmptyNodeName(CellBounds.EastBound, connectionNode.connection.id)
+    );
+    if (!eastboundEmptyNode) {
+      return;
+    }
+    const sourcePort = eastboundEmptyNode.getPort(
+      getNodePortId(eastboundEmptyNode.getID(), PortModelAlignment.RIGHT)
+    );
+    const targetPort = connectionNode.getPort(
+      `left-${connectionNode.getID()}`
+    );
+    if (sourcePort && targetPort) {
+      const linkId = getExternalLinkName(
+        sourcePort.getID(),
+        targetPort.getID()
+      );
+      const link = new ExternalLinkModel(linkId);
+      links.set(
+        linkId,
+        createLinks(sourcePort, targetPort, link)
+      );
+      link.setSourceNode(eastboundEmptyNode.getID());
+      link.setTargetNode(connectionNode.getID());
+    }
+  });
+  return links;
+}
+function generateCellLinks(project, emptyNodes, nodes) {
+  const links = /* @__PURE__ */ new Map();
+  project.components?.forEach((component, _key) => {
+    const componentId = getComponentName(component);
+    const targetComponent = nodes.get(
+      componentId
+    );
+    if (targetComponent) {
+      let isExposed = false;
+      let tooltip = "";
+      const observations = [];
+      let observationOnly = false;
+      for (const serviceId in component.services) {
+        if (Object.prototype.hasOwnProperty.call(component.services, serviceId)) {
+          const service = component.services[serviceId];
+          const internet = service.deploymentMetadata?.gateways.internet;
+          isExposed = isExposed || !!internet?.isExposed;
+          if (internet?.observations && internet.observations.length > 0) {
+            observations.push(
+              ...internet.observations.map((obs) => {
+                if (service.label) {
+                  obs.label = service.label;
+                }
+                return obs;
+              })
+            );
+            observationOnly = observationOnly || !!internet?.observationOnly;
+          }
+          tooltip = internet?.tooltip ?? "";
+        }
+      }
+      const northBoundEmptyNode = emptyNodes.get(
+        getEmptyNodeName(CellBounds.NorthBound)
+      );
+      if (isExposed && northBoundEmptyNode) {
+        const sourcePort = northBoundEmptyNode.getPort(
+          getNodePortId(northBoundEmptyNode.getID(), PortModelAlignment.BOTTOM)
+        );
+        const targetPort = targetComponent.getPort(
+          `top-${targetComponent.getID()}`
+        );
+        if (sourcePort && targetPort) {
+          const linkId = getCellLinkName(
+            sourcePort.getID(),
+            targetPort.getID()
+          );
+          const link = new CellLinkModel(linkId);
+          links.set(
+            linkId,
+            createLinks(sourcePort, targetPort, link)
+          );
+          link.setSourceNode(northBoundEmptyNode.getID());
+          link.setTargetNode(targetComponent.getID());
+          if (observations?.length > 0) {
+            link.setObservations(observations, observationOnly);
+          }
+          if (tooltip) {
+            link.setTooltip(tooltip);
+          }
+        }
+      }
+    }
+    if (targetComponent) {
+      let isExposed = false;
+      let tooltip = "";
+      const observations = [];
+      let observationOnly = false;
+      for (const serviceId in component.services) {
+        if (Object.prototype.hasOwnProperty.call(component.services, serviceId)) {
+          const service = component.services[serviceId];
+          const intranet = service.deploymentMetadata?.gateways.intranet;
+          isExposed = isExposed || !!intranet?.isExposed;
+          if (intranet?.observations && intranet.observations.length > 0) {
+            observations.push(...intranet.observations);
+          }
+          observationOnly = observationOnly || !!intranet?.observationOnly;
+          tooltip = intranet?.tooltip ?? "";
+        }
+      }
+      const northBoundEmptyNode = emptyNodes.get(
+        getEmptyNodeName(CellBounds.WestBound)
+      );
+      if (isExposed && northBoundEmptyNode) {
+        const sourcePort = northBoundEmptyNode.getPort(
+          getNodePortId(northBoundEmptyNode.getID(), PortModelAlignment.RIGHT)
+        );
+        const targetPort = targetComponent.getPort(
+          `left-${targetComponent.getID()}`
+        );
+        if (sourcePort && targetPort) {
+          const linkId = getCellLinkName(
+            sourcePort.getID(),
+            targetPort.getID()
+          );
+          const link = new CellLinkModel(linkId);
+          links.set(
+            linkId,
+            createLinks(sourcePort, targetPort, link)
+          );
+          link.setSourceNode(northBoundEmptyNode.getID());
+          link.setTargetNode(targetComponent.getID());
+          if (observations.length > 0) {
+            link.setObservations(observations, observationOnly);
+          }
+          if (tooltip) {
+            link.setTooltip(tooltip);
+          }
+        }
+      }
+    }
+    component.connections.forEach((connection) => {
+      if (isConnectorConnection(connection)) {
+        const southBoundEmptyNode = emptyNodes.get(
+          getEmptyNodeName(CellBounds.SouthBound, connection.id)
+        );
+        if (targetComponent && southBoundEmptyNode) {
+          const sourcePort = targetComponent.getPort(
+            `bottom-${targetComponent.getID()}`
+          );
+          const targetPort = southBoundEmptyNode.getPort(
+            getNodePortId(southBoundEmptyNode.getID(), PortModelAlignment.TOP)
+          );
+          if (sourcePort && targetPort) {
+            const linkId = getCellLinkName(
+              sourcePort.getID(),
+              targetPort.getID()
+            );
+            const link = new CellLinkModel(linkId);
+            links.set(
+              linkId,
+              createLinks(sourcePort, targetPort, link)
+            );
+            link.setSourceNode(targetComponent.getID());
+            link.setTargetNode(southBoundEmptyNode.getID());
+            if (connection.observations && connection.observations.length > 0) {
+              link.setObservations(
+                connection.observations,
+                connection.observationOnly
+              );
+            }
+            if (connection.tooltip) {
+              link.setTooltip(connection.tooltip);
+            }
+          }
+        }
+      } else if (isExternalConnection(project.id, connection, true)) {
+        if (targetComponent && targetComponent.isExternalConsumer()) {
+          return;
+        }
+        const eastBoundEmptyNode = emptyNodes.get(
+          getEmptyNodeName(CellBounds.EastBound, connection.id)
+        );
+        if (targetComponent && eastBoundEmptyNode) {
+          const sourcePort = targetComponent.getPort(
+            `right-${targetComponent.getID()}`
+          );
+          const targetPort = eastBoundEmptyNode.getPort(
+            getNodePortId(eastBoundEmptyNode.getID(), PortModelAlignment.LEFT)
+          );
+          if (sourcePort && targetPort) {
+            const linkId = getCellLinkName(
+              sourcePort.getID(),
+              targetPort.getID()
+            );
+            const link = new CellLinkModel(linkId);
+            links.set(
+              linkId,
+              createLinks(sourcePort, targetPort, link)
+            );
+            link.setSourceNode(targetComponent.getID());
+            link.setTargetNode(eastBoundEmptyNode.getID());
+            if (connection.observations && connection.observations.length > 0) {
+              link.setObservations(
+                connection.observations,
+                connection.observationOnly
+              );
+            }
+            if (connection.tooltip) {
+              link.setTooltip(connection.tooltip);
+            }
+          }
+        }
+      }
+    });
+    if (targetComponent && targetComponent.isExternalConsumer()) {
+      for (const connection of component.connections) {
+        let targetEmptyNode = null;
+        let targetBound = null;
+        let destinationComponentNode = null;
+        const metadata = getConnectionMetadata(connection);
+        for (const cmp of project.components) {
+          if (cmp.id === metadata.component) {
+            destinationComponentNode = nodes.get(
+              getComponentName(cmp)
+            );
+            const services = Object.values(cmp.services);
+            targetBound = CellBounds.WestBound;
+            for (const service of services) {
+              if (service.deploymentMetadata?.gateways.internet.isExposed) {
+                targetBound = CellBounds.NorthBound;
+                break;
+              }
+            }
+          }
+        }
+        if (targetBound) {
+          targetEmptyNode = emptyNodes.get(getEmptyNodeName(targetBound)) ?? null;
+        }
+        if (targetEmptyNode) {
+          const sourcePort = targetComponent.getPort(
+            `bottom-${targetComponent.getID()}`
+          );
+          const targetPort = targetEmptyNode.getPort(
+            getNodePortId(
+              targetEmptyNode.getID(),
+              targetBound === CellBounds.NorthBound ? PortModelAlignment.TOP : PortModelAlignment.LEFT
+            )
+          );
+          if (sourcePort && targetPort) {
+            const linkId = getCellLinkName(
+              sourcePort.getID(),
+              targetPort.getID()
+            );
+            const link = new CellLinkModel(linkId);
+            link.setSourceNode(targetComponent.getID());
+            link.setTargetNode(targetEmptyNode.getID());
+            link.setIsExternalConsumerLink(true);
+            link.setDestinationNode(destinationComponentNode);
+            links.set(
+              linkId,
+              createLinks(sourcePort, targetPort, link)
+            );
+          }
+        }
+      }
+    }
+  });
+  return links;
+}
+function generateExternalLinks(emptyNodes, externalNodes, gateways) {
+  const links = /* @__PURE__ */ new Map();
+  const eastBoundEmptyNode = emptyNodes.get(
+    getEmptyNodeName(CellBounds.EastBound)
+  );
+  if (eastBoundEmptyNode) {
+    const eastBoundLink = createExternalLink(
+      eastBoundEmptyNode,
+      externalNodes,
+      CellBounds.EastBound,
+      PortModelAlignment.RIGHT
+    );
+    if (eastBoundLink) {
+      links.set(eastBoundLink.getID(), eastBoundLink);
+    }
+  }
+  const northBoundEmptyNode = emptyNodes.get(
+    getEmptyNodeName(CellBounds.NorthBound)
+  );
+  if (northBoundEmptyNode && gateways.internet) {
+    const northBoundLink = createExternalLink(
+      northBoundEmptyNode,
+      externalNodes,
+      CellBounds.NorthBound,
+      PortModelAlignment.TOP,
+      true
+    );
+    if (northBoundLink) {
+      links.set(northBoundLink.getID(), northBoundLink);
+    }
+  }
+  const westBoundEmptyNode = emptyNodes.get(
+    getEmptyNodeName(CellBounds.WestBound)
+  );
+  if (westBoundEmptyNode && gateways.intranet) {
+    const westBoundLink = createExternalLink(
+      westBoundEmptyNode,
+      externalNodes,
+      CellBounds.WestBound,
+      PortModelAlignment.LEFT,
+      true
+    );
+    if (westBoundLink) {
+      links.set(westBoundLink.getID(), westBoundLink);
+    }
+  }
+  return links;
+}
+function generateExternalConnectionLinks(project, nodes, connectionNodes) {
+  const links = /* @__PURE__ */ new Map();
+  project.components?.forEach((component, _key) => {
+    const componentId = getComponentName(component);
+    const targetComponent = nodes.get(
+      componentId
+    );
+    component.connections.forEach((connection) => {
+      if (isExternalConnection(project.id, connection, true) && targetComponent && targetComponent.isExternalConsumer()) {
+        const connectionNode = connectionNodes.get(
+          getConnectionNameById(connection.id)
+        );
+        if (targetComponent && connectionNode) {
+          const sourcePort = targetComponent.getPort(
+            `right-${targetComponent.getID()}`
+          );
+          const targetPort = connectionNode.getPort(
+            getNodePortId(connectionNode.getID(), PortModelAlignment.LEFT)
+          );
+          if (sourcePort && targetPort) {
+            const linkId = getCellLinkName(
+              sourcePort.getID(),
+              targetPort.getID()
+            );
+            const link = new ExternalLinkModel(linkId, true);
+            links.set(
+              linkId,
+              createLinks(sourcePort, targetPort, link)
+            );
+            link.setSourceNode(targetComponent.getID());
+            link.setTargetNode(connectionNode.getID());
+            if (connection.observations && connection.observations.length > 0) {
+              link.setObservations(
+                connection.observations,
+                connection.observationOnly
+              );
+            }
+            if (connection.tooltip) {
+              link.setTooltip(connection.tooltip);
+            }
+          }
+        }
+      }
+    });
+  });
+  return links;
+}
+function createLinks(sourcePort, targetPort, link) {
+  link.setSourcePort(sourcePort);
+  link.setTargetPort(targetPort);
+  sourcePort.addLink(link);
+  return link;
+}
+function createExternalLink(emptyNode, externalNodes, bounds, alignment, switchArrow = false) {
+  const sourcePort = emptyNode.getPort(
+    getNodePortId(emptyNode.getID(), alignment)
+  );
+  const targetNode = externalNodes.get(getExternalNodeName(bounds));
+  const targetPort = targetNode?.getPort(
+    `${getOppositeAlignment(alignment)}-${targetNode.getID()}`
+  );
+  if (sourcePort && targetNode && targetPort) {
+    const linkId = getExternalLinkName(sourcePort.getID(), targetPort.getID());
+    const link = new ExternalLinkModel(linkId);
+    if (switchArrow) {
+      link.setSourceNode(targetNode.getID());
+      link.setTargetNode(emptyNode.getID());
+      return createLinks(targetPort, sourcePort, link);
+    }
+    link.setSourceNode(emptyNode.getID());
+    link.setTargetNode(targetNode.getID());
+    return createLinks(sourcePort, targetPort, link);
+  }
+  return void 0;
+}
+function getOppositeAlignment(alignment) {
+  switch (alignment) {
+    case PortModelAlignment.LEFT:
+      return PortModelAlignment.RIGHT;
+    case PortModelAlignment.RIGHT:
+      return PortModelAlignment.LEFT;
+    case PortModelAlignment.TOP:
+      return PortModelAlignment.BOTTOM;
+    case PortModelAlignment.BOTTOM:
+      return PortModelAlignment.TOP;
+    default:
+      return alignment;
+  }
+}
+function getConnectionMetadata(connection) {
+  const ids = connection.id.split(":");
+  if (ids.length === 3) {
+    return {
+      type: connection.type,
+      organization: ids[0],
+      project: ids[1],
+      component: ids[2]
+    };
+  } else if (ids.length === 4) {
+    return {
+      type: connection.type,
+      organization: ids[0],
+      project: ids[1],
+      component: ids[2],
+      service: ids[3]
+    };
+  } else if (isConnectorConnection(connection) && ids.length === 2) {
+    return {
+      type: connection.type,
+      organization: ids[0],
+      package: ids[1]
+    };
+  }
+  return null;
+}
+function isInternalComponent(projectId, connection) {
+  const metadata = getConnectionMetadata(connection);
+  return !!metadata && metadata.project === projectId;
+}
+function isExternalConnection(projectId, connection, skipPlatform) {
+  const metadata = getConnectionMetadata(connection);
+  return Boolean(
+    (!isConnectorConnection(connection) || !connection.type) && // Some connections doesn't have connection type
+    (skipPlatform) && // Skip platform fields for some connections
+    metadata && metadata.project !== projectId
+  );
+}
+function isConnectorConnection(connection) {
+  return connection.type === ConnectionType.Connector || connection.type === ConnectionType.Datastore;
+}
+
+export { calculateCellWidth, getComponentDiagramBoundaries, getComponentDiagramWidth, getConnectionMetadata, getDiagramDataFromProject, isConnectorConnection, isExternalConnection, isInternalComponent, isRenderInsideCell, manualDistribute, updateBoundNodePositions };
+//# sourceMappingURL=projectUtils.esm.js.map