@yorz/cli 0.1.4 → 0.1.5

package/dist/dagre-VKFMJZFB-blEDoYen.js

@@ -1,522 +0,0 @@
-#!/usr/bin/env node
-import { c as clear$2, w as write, a as adjustClustersAndEdges, f as findNonClusterChild, b as clusterDb, s as sortNodesByHierarchy } from "./chunk-RYQCIY6F-DQacsGpB.js";
-import { _ as __name, am as markers_default, an as clear2, ao as clear, ap as clear$1, l as log, c as getConfig2, aq as updateNodeBounds, ar as setNodeElem, ae as insertNode, as as getSubGraphTitleMargins, af as positionNode, ad as insertCluster, at as insertEdge, au as positionEdgeLabel, av as insertEdgeLabel } from "./mermaid.core-Dy_tFRs7.js";
-import { G as Graph } from "./graph-CE8jV7cI.js";
-import { l as layout } from "./layout-DQAYh_L7.js";
-var clamp = /* @__PURE__ */ __name((value, min, max) => Math.max(min, Math.min(max, value)), "clamp");
-var getDefaultSelfLoopSide = /* @__PURE__ */ __name((rankdir = "TB") => {
-  switch (rankdir) {
-    case "BT":
-      return "bottom";
-    case "LR":
-      return "right";
-    case "RL":
-      return "left";
-    case "TB":
-    default:
-      return "top";
-  }
-}, "getDefaultSelfLoopSide");
-var shouldMergeSelfLoopSegments = /* @__PURE__ */ __name((diagramType) => diagramType === "flowchart" || diagramType === "flowchart-v2" || diagramType === "stateDiagram", "shouldMergeSelfLoopSegments");
-var getSelfLoopSide = /* @__PURE__ */ __name((graph, node, segments, originalNodeId, rankdir) => {
-  const layoutHints = [];
-  const dummyNodeIds = /* @__PURE__ */ new Set();
-  segments.forEach(({ start, end }) => {
-    if (start !== originalNodeId) {
-      dummyNodeIds.add(start);
-    }
-    if (end !== originalNodeId) {
-      dummyNodeIds.add(end);
-    }
-  });
-  dummyNodeIds.forEach((id) => {
-    const dummyNode = graph.node(id);
-    if (typeof dummyNode?.x === "number" && typeof dummyNode?.y === "number") {
-      layoutHints.push(dummyNode);
-    }
-  });
-  if (layoutHints.length === 0) {
-    segments.forEach(({ edge }) => {
-      (edge.points ?? []).forEach((point) => {
-        if (typeof point?.x === "number" && typeof point?.y === "number") {
-          layoutHints.push(point);
-        }
-      });
-    });
-  }
-  if (layoutHints.length === 0) {
-    return getDefaultSelfLoopSide(rankdir);
-  }
-  const center = layoutHints.reduce(
-    (acc, point) => ({
-      x: acc.x + point.x / layoutHints.length,
-      y: acc.y + point.y / layoutHints.length
-    }),
-    { x: 0, y: 0 }
-  );
-  const dx = center.x - node.x;
-  const dy = center.y - node.y;
-  if (Math.abs(dx) > Math.abs(dy)) {
-    return dx > 0 ? "right" : "left";
-  }
-  if (Math.abs(dy) > 0) {
-    return dy > 0 ? "bottom" : "top";
-  }
-  return getDefaultSelfLoopSide(rankdir);
-}, "getSelfLoopSide");
-var getSelfLoopPoints = /* @__PURE__ */ __name((node, side = "top", yOffset = 0, labelWidth = 0) => {
-  const x = node.x;
-  const y = node.y - yOffset;
-  const halfWidth = node.width / 2;
-  const halfHeight = node.height / 2;
-  const maxSpan = Math.max(36, Math.min(100, node.width * 0.8));
-  const span = clamp(Math.max(labelWidth, node.width * 0.35), 36, maxSpan);
-  const depth = clamp(Math.min(node.width, node.height) * 0.45, 24, 48);
-  switch (side) {
-    case "bottom": {
-      const bottom = y + halfHeight;
-      return [
-        { x: x - span / 2, y: bottom },
-        { x: x - span / 2, y: bottom + depth },
-        { x: x + span / 2, y: bottom + depth },
-        { x: x + span / 2, y: bottom }
-      ];
-    }
-    case "right": {
-      const right = x + halfWidth;
-      return [
-        { x: right, y: y - span / 2 },
-        { x: right + depth, y: y - span / 2 },
-        { x: right + depth, y: y + span / 2 },
-        { x: right, y: y + span / 2 }
-      ];
-    }
-    case "left": {
-      const left = x - halfWidth;
-      return [
-        { x: left, y: y - span / 2 },
-        { x: left - depth, y: y - span / 2 },
-        { x: left - depth, y: y + span / 2 },
-        { x: left, y: y + span / 2 }
-      ];
-    }
-    case "top":
-    default: {
-      const top = y - halfHeight;
-      return [
-        { x: x - span / 2, y: top },
-        { x: x - span / 2, y: top - depth },
-        { x: x + span / 2, y: top - depth },
-        { x: x + span / 2, y: top }
-      ];
-    }
-  }
-}, "getSelfLoopPoints");
-var getSelfLoopLabelPosition = /* @__PURE__ */ __name((node, points, side = "top", yOffset = 0, label = {}) => {
-  const gap = 4;
-  const x = node.x;
-  const y = node.y - yOffset;
-  const labelWidth = label.width ?? 0;
-  const labelHeight = label.height ?? 0;
-  switch (side) {
-    case "bottom":
-      return { x, y: Math.max(...points.map((point) => point.y)) + labelHeight / 2 + gap };
-    case "right":
-      return { x: Math.max(...points.map((point) => point.x)) + labelWidth / 2 + gap, y };
-    case "left":
-      return { x: Math.min(...points.map((point) => point.x)) - labelWidth / 2 - gap, y };
-    case "top":
-    default:
-      return { x, y: Math.min(...points.map((point) => point.y)) - labelHeight / 2 - gap };
-  }
-}, "getSelfLoopLabelPosition");
-var getEdgesToRender = /* @__PURE__ */ __name((graph, yOffset = 0, { mergeSelfLoops = true } = {}) => {
-  const selfLoopEdgeGroups = /* @__PURE__ */ new Map();
-  const edgesToRender = [];
-  const rankdir = graph.graph()?.rankdir;
-  graph.edges().forEach((e) => {
-    const edge = graph.edge(e);
-    if (mergeSelfLoops && edge.selfLoop) {
-      const key = edge.selfLoop.id;
-      if (!selfLoopEdgeGroups.has(key)) {
-        selfLoopEdgeGroups.set(key, []);
-      }
-      selfLoopEdgeGroups.get(key).push({ edge, start: e.v, end: e.w });
-    } else {
-      edgesToRender.push({ edge, start: e.v, end: e.w });
-    }
-  });
-  selfLoopEdgeGroups.forEach((segments) => {
-    if (segments.length !== 3) {
-      segments.forEach((segment) => edgesToRender.push(segment));
-      return;
-    }
-    segments.sort((a, b) => a.edge.selfLoop.order - b.edge.selfLoop.order);
-    const [firstSegment, middleSegment, lastSegment] = segments;
-    const originalEdge = firstSegment.edge.originalEdge ?? middleSegment.edge.originalEdge ?? lastSegment.edge.originalEdge ?? middleSegment.edge;
-    const node = graph.node(originalEdge.start);
-    if (!node) {
-      segments.forEach((segment) => edgesToRender.push(segment));
-      return;
-    }
-    const label = {
-      width: middleSegment.edge.width,
-      height: middleSegment.edge.height
-    };
-    const side = getSelfLoopSide(graph, node, segments, originalEdge.start, rankdir);
-    const points = getSelfLoopPoints(node, side, yOffset, label.width ?? 0);
-    const labelPosition = getSelfLoopLabelPosition(node, points, side, yOffset, label);
-    const mergedEdge = {
-      ...middleSegment.edge,
-      ...originalEdge,
-      id: originalEdge.id,
-      points,
-      start: originalEdge.start,
-      end: originalEdge.end,
-      x: labelPosition.x,
-      y: labelPosition.y,
-      width: label.width,
-      height: label.height,
-      labelStyle: middleSegment.edge.labelStyle,
-      fromCluster: firstSegment.edge.fromCluster ?? middleSegment.edge.fromCluster ?? lastSegment.edge.fromCluster,
-      toCluster: firstSegment.edge.toCluster ?? middleSegment.edge.toCluster ?? lastSegment.edge.toCluster
-    };
-    delete mergedEdge.selfLoop;
-    delete mergedEdge.originalEdge;
-    edgesToRender.push({ edge: mergedEdge, start: mergedEdge.start, end: mergedEdge.end });
-  });
-  return edgesToRender;
-}, "getEdgesToRender");
-var recursiveRender = /* @__PURE__ */ __name(async (_elem, graph, diagramType, id, parentCluster, siteConfig) => {
-  log.warn("Graph in recursive render:XAX", write(graph), parentCluster);
-  const dir = graph.graph().rankdir;
-  log.trace("Dir in recursive render - dir:", dir);
-  const elem = _elem.insert("g").attr("class", "root");
-  if (!graph.nodes()) {
-    log.info("No nodes found for", graph);
-  } else {
-    log.info("Recursive render XXX", graph.nodes());
-  }
-  if (graph.edges().length > 0) {
-    log.info("Recursive edges", graph.edge(graph.edges()[0]));
-  }
-  const clusters = elem.insert("g").attr("class", "clusters");
-  const edgePaths = elem.insert("g").attr("class", "edgePaths");
-  const edgeLabels = elem.insert("g").attr("class", "edgeLabels");
-  const nodes = elem.insert("g").attr("class", "nodes");
-  const mergeSelfLoops = shouldMergeSelfLoopSegments(diagramType);
-  await Promise.all(
-    graph.nodes().map(async function(v) {
-      const node = graph.node(v);
-      if (parentCluster !== void 0) {
-        const data = JSON.parse(JSON.stringify(parentCluster.clusterData));
-        log.trace(
-          "Setting data for parent cluster XXX\n Node.id = ",
-          v,
-          "\n data=",
-          data.height,
-          "\nParent cluster",
-          parentCluster.height
-        );
-        graph.setNode(parentCluster.id, data);
-        if (!graph.parent(v)) {
-          log.trace("Setting parent", v, parentCluster.id);
-          graph.setParent(v, parentCluster.id, data);
-        }
-      }
-      log.info("(Insert) Node XXX" + v + ": " + JSON.stringify(graph.node(v)));
-      if (node?.clusterNode) {
-        log.info("Cluster identified XBX", v, node.width, graph.node(v));
-        const { ranksep, nodesep } = graph.graph();
-        node.graph.setGraph({
-          ...node.graph.graph(),
-          ranksep: ranksep + 25,
-          nodesep
-        });
-        const o = await recursiveRender(
-          nodes,
-          node.graph,
-          diagramType,
-          id,
-          graph.node(v),
-          siteConfig
-        );
-        const newEl = o.elem;
-        updateNodeBounds(node, newEl);
-        node.diff = o.diff || 0;
-        log.info(
-          "New compound node after recursive render XAX",
-          v,
-          "width",
-          // node,
-          node.width,
-          "height",
-          node.height
-          // node.x,
-          // node.y
-        );
-        setNodeElem(newEl, node);
-      } else {
-        if (graph.children(v).length > 0) {
-          log.trace(
-            "Cluster - the non recursive path XBX",
-            v,
-            node.id,
-            node,
-            node.width,
-            "Graph:",
-            graph
-          );
-          log.trace(findNonClusterChild(node.id, graph));
-          clusterDb.set(node.id, { id: findNonClusterChild(node.id, graph), node });
-        } else {
-          log.trace("Node - the non recursive path XAX", v, nodes, graph.node(v), dir);
-          await insertNode(nodes, graph.node(v), { config: siteConfig, dir });
-        }
-      }
-    })
-  );
-  const processEdges = /* @__PURE__ */ __name(async () => {
-    const edgePromises = graph.edges().map(async function(e) {
-      const edge = graph.edge(e.v, e.w, e.name);
-      log.info("Edge " + e.v + " -> " + e.w + ": " + JSON.stringify(e));
-      log.info("Edge " + e.v + " -> " + e.w + ": ", e, " ", JSON.stringify(graph.edge(e)));
-      log.info(
-        "Fix",
-        clusterDb,
-        "ids:",
-        e.v,
-        e.w,
-        "Translating: ",
-        clusterDb.get(e.v),
-        clusterDb.get(e.w)
-      );
-      if (mergeSelfLoops && edge.selfLoop) {
-        if (edge.selfLoop.order !== 1) {
-          return;
-        }
-        const segmentId = edge.id;
-        edge.id = edge.selfLoop.id;
-        await insertEdgeLabel(edgeLabels, edge);
-        edge.id = segmentId;
-        return;
-      }
-      await insertEdgeLabel(edgeLabels, edge);
-    });
-    await Promise.all(edgePromises);
-  }, "processEdges");
-  await processEdges();
-  log.info("Graph before layout:", JSON.stringify(write(graph)));
-  log.info("############################################# XXX");
-  log.info("###                Layout                 ### XXX");
-  log.info("############################################# XXX");
-  layout(graph);
-  log.info("Graph after layout:", JSON.stringify(write(graph)));
-  let diff = 0;
-  let { subGraphTitleTotalMargin } = getSubGraphTitleMargins(siteConfig);
-  await Promise.all(
-    sortNodesByHierarchy(graph).map(async function(v) {
-      const node = graph.node(v);
-      log.info(
-        "Position XBX => " + v + ": (" + node.x,
-        "," + node.y,
-        ") width: ",
-        node.width,
-        " height: ",
-        node.height
-      );
-      if (node?.clusterNode) {
-        node.y += subGraphTitleTotalMargin;
-        log.info(
-          "A tainted cluster node XBX1",
-          v,
-          node.id,
-          node.width,
-          node.height,
-          node.x,
-          node.y,
-          graph.parent(v)
-        );
-        clusterDb.get(node.id).node = node;
-        positionNode(node);
-      } else {
-        if (graph.children(v).length > 0) {
-          log.info(
-            "A pure cluster node XBX1",
-            v,
-            node.id,
-            node.x,
-            node.y,
-            node.width,
-            node.height,
-            graph.parent(v)
-          );
-          node.height += subGraphTitleTotalMargin;
-          graph.node(node.parentId);
-          const halfPadding = node?.padding / 2 || 0;
-          const labelHeight = node?.labelBBox?.height || 0;
-          const offsetY = labelHeight - halfPadding || 0;
-          log.debug("OffsetY", offsetY, "labelHeight", labelHeight, "halfPadding", halfPadding);
-          await insertCluster(clusters, node);
-          clusterDb.get(node.id).node = node;
-        } else {
-          const parent = graph.node(node.parentId);
-          node.y += subGraphTitleTotalMargin / 2;
-          log.info(
-            "A regular node XBX1 - using the padding",
-            node.id,
-            "parent",
-            node.parentId,
-            node.width,
-            node.height,
-            node.x,
-            node.y,
-            "offsetY",
-            node.offsetY,
-            "parent",
-            parent,
-            parent?.offsetY,
-            node
-          );
-          positionNode(node);
-        }
-      }
-    })
-  );
-  const edgeOffsetY = subGraphTitleTotalMargin / 2;
-  const edgesToRender = getEdgesToRender(graph, edgeOffsetY, { mergeSelfLoops });
-  edgesToRender.forEach(function({ edge, start, end }) {
-    log.info("Edge " + start + " -> " + end + ": " + JSON.stringify(edge), edge);
-    edge.points.forEach((point) => point.y += edgeOffsetY);
-    const startNode = graph.node(start);
-    const endNode = graph.node(end);
-    const paths = insertEdge(edgePaths, edge, clusterDb, diagramType, startNode, endNode, id);
-    positionEdgeLabel(edge, paths);
-  });
-  graph.nodes().forEach(function(v) {
-    const n = graph.node(v);
-    log.info(v, n.type, n.diff);
-    if (n.isGroup) {
-      diff = n.diff;
-    }
-  });
-  log.warn("Returning from recursive render XAX", elem, diff);
-  return { elem, diff };
-}, "recursiveRender");
-var render = /* @__PURE__ */ __name(async (data4Layout, svg) => {
-  const graph = new Graph({
-    multigraph: true,
-    compound: true
-  }).setGraph({
-    rankdir: data4Layout.direction,
-    nodesep: data4Layout.config?.nodeSpacing || data4Layout.config?.flowchart?.nodeSpacing || data4Layout.nodeSpacing,
-    ranksep: data4Layout.config?.rankSpacing || data4Layout.config?.flowchart?.rankSpacing || data4Layout.rankSpacing,
-    marginx: 8,
-    marginy: 8
-  }).setDefaultEdgeLabel(function() {
-    return {};
-  });
-  const element = svg.select("g");
-  markers_default(element, data4Layout.markers, data4Layout.type, data4Layout.diagramId);
-  clear2();
-  clear();
-  clear$1();
-  clear$2();
-  data4Layout.nodes.forEach((node) => {
-    graph.setNode(node.id, { ...node });
-    if (node.parentId) {
-      graph.setParent(node.id, node.parentId);
-    }
-  });
-  log.debug("Edges:", data4Layout.edges);
-  data4Layout.edges.forEach((edge) => {
-    if (edge.start === edge.end) {
-      const nodeId = edge.start;
-      const specialId1 = nodeId + "---" + nodeId + "---1";
-      const specialId2 = nodeId + "---" + nodeId + "---2";
-      const node = graph.node(nodeId);
-      graph.setNode(specialId1, {
-        domId: specialId1,
-        id: specialId1,
-        parentId: node.parentId,
-        labelStyle: "",
-        label: "",
-        padding: 0,
-        shape: "labelRect",
-        // shape: 'rect',
-        style: "",
-        width: 10,
-        height: 10
-      });
-      graph.setParent(specialId1, node.parentId);
-      graph.setNode(specialId2, {
-        domId: specialId2,
-        id: specialId2,
-        parentId: node.parentId,
-        labelStyle: "",
-        padding: 0,
-        // shape: 'rect',
-        shape: "labelRect",
-        label: "",
-        style: "",
-        width: 10,
-        height: 10
-      });
-      graph.setParent(specialId2, node.parentId);
-      const originalEdge = structuredClone(edge);
-      const edge1 = structuredClone(edge);
-      const edgeMid = structuredClone(edge);
-      const edge2 = structuredClone(edge);
-      edge1.originalEdge = originalEdge;
-      edge1.selfLoop = { id: originalEdge.id, order: 0 };
-      edgeMid.originalEdge = originalEdge;
-      edgeMid.selfLoop = { id: originalEdge.id, order: 1 };
-      edge2.originalEdge = originalEdge;
-      edge2.selfLoop = { id: originalEdge.id, order: 2 };
-      edge1.label = "";
-      edge1.arrowTypeEnd = "none";
-      edge1.endLabelLeft = "";
-      edge1.endLabelRight = "";
-      edge1.startLabelLeft = "";
-      edge1.id = nodeId + "-cyclic-special-1";
-      edgeMid.startLabelRight = "";
-      edgeMid.startLabelLeft = "";
-      edgeMid.endLabelLeft = "";
-      edgeMid.endLabelRight = "";
-      edgeMid.arrowTypeStart = "none";
-      edgeMid.arrowTypeEnd = "none";
-      edgeMid.id = nodeId + "-cyclic-special-mid";
-      edge2.label = "";
-      edge2.startLabelRight = "";
-      edge2.startLabelLeft = "";
-      edge2.arrowTypeStart = "none";
-      if (node.isGroup) {
-        edge1.fromCluster = nodeId;
-        edge2.toCluster = nodeId;
-      }
-      edge2.id = nodeId + "-cyclic-special-2";
-      edge2.arrowTypeStart = "none";
-      graph.setEdge(nodeId, specialId1, edge1, nodeId + "-cyclic-special-0");
-      graph.setEdge(specialId1, specialId2, edgeMid, nodeId + "-cyclic-special-1");
-      graph.setEdge(specialId2, nodeId, edge2, nodeId + "-cyclic-special-2");
-    } else {
-      graph.setEdge(edge.start, edge.end, { ...edge }, edge.id);
-    }
-  });
-  log.warn("Graph at first:", JSON.stringify(write(graph)));
-  adjustClustersAndEdges(graph);
-  log.warn("Graph after XAX:", JSON.stringify(write(graph)));
-  const siteConfig = getConfig2();
-  await recursiveRender(
-    element,
-    graph,
-    data4Layout.type,
-    data4Layout.diagramId,
-    void 0,
-    siteConfig
-  );
-}, "render");
-export {
-  getEdgesToRender,
-  render
-};