@diagrammo/dgmo 0.46.0 → 0.48.0

package/dist/chunk-725LDASD.js

@@ -0,0 +1,422 @@
+import {
+  acyclicOrient
+} from "./chunk-YGJTDXVR.js";
+
+// src/swimlane/layout.ts
+var MARGIN = 30;
+var COL_GAP = 64;
+var NODE_W = 124;
+var NODE_H = 44;
+var DIAMOND = 56;
+var TERM_D = 40;
+var INTRA_GAP = 16;
+var LANE_PAD = 22;
+var MIN_LANE = NODE_H + 2 * LANE_PAD;
+var LANE_HEADER = 116;
+var PHASE_HEADER = 30;
+var BACK_CHANNEL = 28;
+var BACK_STEP = 18;
+function nodeSize(shape) {
+  if (shape === "exclusive" || shape === "parallel")
+    return { w: DIAMOND, h: DIAMOND };
+  if (shape === "terminal") return { w: TERM_D, h: TERM_D };
+  return { w: NODE_W, h: NODE_H };
+}
+function compactRanks(ids, edges, laneOf, floors) {
+  const adj = /* @__PURE__ */ new Map();
+  const indeg = /* @__PURE__ */ new Map();
+  for (const id of ids) {
+    adj.set(id, []);
+    indeg.set(id, 0);
+  }
+  for (const e of edges) {
+    adj.get(e.from)?.push(e.to);
+    indeg.set(e.to, (indeg.get(e.to) ?? 0) + 1);
+  }
+  const rank = new Map(ids.map((id) => [id, 0]));
+  const laneMaxIn = /* @__PURE__ */ new Map();
+  for (const id of ids) laneMaxIn.set(id, /* @__PURE__ */ new Map());
+  const queue = ids.filter((id) => (indeg.get(id) ?? 0) === 0);
+  for (let qi = 0; qi < queue.length; qi++) {
+    const u = queue[qi];
+    const lu = laneOf(u);
+    const accIn = laneMaxIn.get(u);
+    const fl = floors?.get(u);
+    if (fl !== void 0 && (rank.get(u) ?? 0) < fl) rank.set(u, fl);
+    const sameLaneAnc = accIn.get(lu);
+    if (sameLaneAnc !== void 0 && (rank.get(u) ?? 0) <= sameLaneAnc) {
+      rank.set(u, sameLaneAnc + 1);
+    }
+    const ru = rank.get(u);
+    const accOut = new Map(accIn);
+    accOut.set(lu, Math.max(accOut.get(lu) ?? -1, ru));
+    for (const w of adj.get(u) ?? []) {
+      const cand = ru + (laneOf(w) === lu ? 1 : 0);
+      if (cand > (rank.get(w) ?? 0)) rank.set(w, cand);
+      const wIn = laneMaxIn.get(w);
+      for (const [lane, r] of accOut)
+        if (r > (wIn.get(lane) ?? -1)) wIn.set(lane, r);
+      const d = (indeg.get(w) ?? 0) - 1;
+      indeg.set(w, d);
+      if (d === 0) queue.push(w);
+    }
+  }
+  return rank;
+}
+function layoutSwimlane(parsed) {
+  const dir = parsed.direction;
+  const isLR = dir === "LR";
+  const nodeById = new Map(parsed.nodes.map((n) => [n.id, n]));
+  const ids = parsed.nodes.map((n) => n.id);
+  const size = new Map(parsed.nodes.map((n) => [n.id, nodeSize(n.shape)]));
+  const flowLenOf = (id) => {
+    const s = size.get(id);
+    return isLR ? s.w : s.h;
+  };
+  const crossLenOf = (id) => {
+    const s = size.get(id);
+    return isLR ? s.h : s.w;
+  };
+  const realEdges = parsed.edges.map((e, idx) => ({ from: e.source, to: e.target, idx })).filter(
+    (e) => e.from !== e.to && nodeById.has(e.from) && nodeById.has(e.to)
+  );
+  const { dag } = acyclicOrient(ids, realEdges);
+  const laneOf = (id) => nodeById.get(id).lane;
+  const baseRank = compactRanks(
+    ids,
+    dag.map((d) => ({ from: d.from, to: d.to })),
+    laneOf
+  );
+  let finalRank = /* @__PURE__ */ new Map();
+  for (const id of ids) finalRank.set(id, baseRank.get(id) ?? 0);
+  {
+    const laneIdx = new Map(parsed.lanes.map((l, i) => [l.id, i]));
+    const dagEdges = dag.map((d) => ({ from: d.from, to: d.to }));
+    const floors = /* @__PURE__ */ new Map();
+    for (let pass = 0; pass < ids.length; pass++) {
+      let changed = false;
+      for (const e of realEdges) {
+        if ((finalRank.get(e.to) ?? 0) >= (finalRank.get(e.from) ?? 0))
+          continue;
+        for (const leg of [e.from, e.to]) {
+          const legRank = finalRank.get(leg);
+          const legLane = laneIdx.get(laneOf(leg));
+          for (const id of ids) {
+            if (id === e.from || id === e.to) continue;
+            if (finalRank.get(id) !== legRank) continue;
+            if ((laneIdx.get(laneOf(id)) ?? 0) <= legLane) continue;
+            if ((floors.get(id) ?? 0) <= legRank) {
+              floors.set(id, legRank + 1);
+              changed = true;
+            }
+          }
+        }
+      }
+      if (!changed) break;
+      finalRank = compactRanks(ids, dagEdges, laneOf, floors);
+    }
+  }
+  const usedRanks = Array.from(
+    new Set(ids.map((id) => finalRank.get(id)))
+  ).sort((a, b) => a - b);
+  const rankIndex = new Map(usedRanks.map((r, i) => [r, i]));
+  const R = usedRanks.length;
+  const riOf = (id) => rankIndex.get(finalRank.get(id)) ?? 0;
+  const contentFlowStart = LANE_HEADER + MARGIN;
+  const colFlowLen = Array.from({ length: R }, () => 0);
+  for (const id of ids) {
+    const ri = riOf(id);
+    colFlowLen[ri] = Math.max(colFlowLen[ri], flowLenOf(id));
+  }
+  const flowCenter = [];
+  const colLen = [];
+  {
+    let acc = contentFlowStart;
+    for (let ri = 0; ri < R; ri++) {
+      const len = Math.max(colFlowLen[ri], NODE_W);
+      colLen[ri] = len;
+      flowCenter[ri] = acc + len / 2;
+      acc += len + COL_GAP;
+    }
+  }
+  const gapMid = (gi) => flowCenter[gi] + colLen[gi] / 2 + COL_GAP / 2;
+  const totalFlow = (R > 0 ? flowCenter[R - 1] + Math.max(colFlowLen[R - 1], NODE_W) / 2 : contentFlowStart) + MARGIN;
+  const contentCrossStart = (parsed.phases.length ? PHASE_HEADER : 0) + MARGIN;
+  const cellNodes = /* @__PURE__ */ new Map();
+  for (const n of parsed.nodes) {
+    const key = `${n.lane}\0${riOf(n.id)}`;
+    (cellNodes.get(key) ?? cellNodes.set(key, []).get(key)).push(n.id);
+  }
+  const cellCross = (laneId, ri) => {
+    const arr = cellNodes.get(`${laneId}\0${ri}`) ?? [];
+    if (arr.length === 0) return 0;
+    return arr.reduce((s, id) => s + crossLenOf(id), 0) + INTRA_GAP * (arr.length - 1);
+  };
+  const laneCrossStart = /* @__PURE__ */ new Map();
+  const laneThick = /* @__PURE__ */ new Map();
+  const laneCenter = /* @__PURE__ */ new Map();
+  {
+    let acc = contentCrossStart;
+    for (const lane of parsed.lanes) {
+      let maxCell = 0;
+      for (let ri = 0; ri < R; ri++)
+        maxCell = Math.max(maxCell, cellCross(lane.id, ri));
+      const thick = Math.max(MIN_LANE, maxCell + 2 * LANE_PAD);
+      laneCrossStart.set(lane.id, acc);
+      laneThick.set(lane.id, thick);
+      laneCenter.set(lane.id, acc + thick / 2);
+      acc += thick;
+    }
+  }
+  const laneCrossEnd = (() => {
+    let acc = contentCrossStart;
+    for (const lane of parsed.lanes) acc += laneThick.get(lane.id);
+    return acc;
+  })();
+  const nodeFlow = /* @__PURE__ */ new Map();
+  const nodeCross = /* @__PURE__ */ new Map();
+  for (const [key, arr] of cellNodes) {
+    const sep = key.indexOf("\0");
+    const laneId = key.slice(0, sep);
+    const center = laneCenter.get(laneId) ?? contentCrossStart;
+    const stackH = arr.reduce((s, id) => s + crossLenOf(id), 0) + INTRA_GAP * (arr.length - 1);
+    let c = center - stackH / 2;
+    for (const id of arr) {
+      const cl = crossLenOf(id);
+      nodeCross.set(id, c + cl / 2);
+      c += cl + INTRA_GAP;
+      nodeFlow.set(id, flowCenter[riOf(id)]);
+    }
+  }
+  let backCount = 0;
+  for (const e of realEdges)
+    if ((finalRank.get(e.to) ?? 0) < (finalRank.get(e.from) ?? 0)) backCount++;
+  const needsBack = backCount > 0;
+  const backReserve = needsBack ? BACK_CHANNEL + BACK_STEP * (backCount - 1) : 0;
+  const totalCross = laneCrossEnd + backReserve + MARGIN;
+  const project = (flow, cross) => isLR ? { x: flow, y: cross } : { x: cross, y: flow };
+  const layoutNodes = parsed.nodes.map((n) => {
+    const s = size.get(n.id);
+    const p = project(nodeFlow.get(n.id), nodeCross.get(n.id));
+    return {
+      id: n.id,
+      label: n.label,
+      shape: n.shape,
+      event: n.event,
+      lane: n.lane,
+      ...n.phase !== void 0 && { phase: n.phase },
+      ...n.color !== void 0 && { color: n.color },
+      tags: n.tags,
+      x: p.x,
+      y: p.y,
+      width: s.w,
+      height: s.h,
+      lineNumber: n.lineNumber
+    };
+  });
+  const CHANNEL_GAP = 16;
+  const bendOffset = new Array(parsed.edges.length).fill(0);
+  {
+    const groups = /* @__PURE__ */ new Map();
+    parsed.edges.forEach((e, i) => {
+      const s = nodeById.get(e.source);
+      const t = nodeById.get(e.target);
+      if (!s || !t || s.id === t.id) return;
+      const sR = finalRank.get(s.id) ?? 0;
+      const tR = finalRank.get(t.id) ?? 0;
+      if (tR <= sR) return;
+      if (Math.abs((nodeCross.get(s.id) ?? 0) - (nodeCross.get(t.id) ?? 0)) < 0.5)
+        return;
+      const key = `${e.target}\0${sR}`;
+      (groups.get(key) ?? groups.set(key, []).get(key)).push(i);
+    });
+    for (const idxs of groups.values()) {
+      if (idxs.length < 2) continue;
+      idxs.sort(
+        (a, b) => (nodeCross.get(parsed.edges[a].source) ?? 0) - (nodeCross.get(parsed.edges[b].source) ?? 0)
+      );
+      idxs.forEach((idx, k) => {
+        bendOffset[idx] = (k - (idxs.length - 1) / 2) * CHANNEL_GAP;
+      });
+    }
+  }
+  const BLOCK_CLEAR = 4;
+  const routeBackLeg = (selfId, flow, fromCross, toCross, ri, towardFlow) => {
+    let firstBlockTop = Infinity;
+    for (const id of ids) {
+      if (id === selfId) continue;
+      const fh = flowLenOf(id) / 2 + BLOCK_CLEAR;
+      if (Math.abs(nodeFlow.get(id) - flow) >= fh) continue;
+      const ch = crossLenOf(id) / 2;
+      const c = nodeCross.get(id);
+      if (c + ch <= fromCross || c - ch >= toCross) continue;
+      firstBlockTop = Math.min(firstBlockTop, c - ch);
+    }
+    if (firstBlockTop === Infinity) return { flow };
+    const leftGap = ri - 1;
+    const rightGap = ri < R - 1 ? ri : -1;
+    let gi = towardFlow < flow ? leftGap : rightGap;
+    if (gi < 0) gi = towardFlow < flow ? rightGap : leftGap;
+    if (gi < 0) return { flow };
+    return { flow: gapMid(gi), jogCross: (fromCross + firstBlockTop) / 2 };
+  };
+  let backIdx = 0;
+  const layoutEdges = [];
+  parsed.edges.forEach((e, ei) => {
+    const s = nodeById.get(e.source);
+    const t = nodeById.get(e.target);
+    if (!s || !t || s.id === t.id) return;
+    const sFlow = nodeFlow.get(s.id);
+    const sCross = nodeCross.get(s.id);
+    const tFlow = nodeFlow.get(t.id);
+    const tCross = nodeCross.get(t.id);
+    const sFlowHalf = flowLenOf(s.id) / 2;
+    const tFlowHalf = flowLenOf(t.id) / 2;
+    const sCrossHalf = crossLenOf(s.id) / 2;
+    const tCrossHalf = crossLenOf(t.id) / 2;
+    const sRank = finalRank.get(s.id) ?? 0;
+    const tRank = finalRank.get(t.id) ?? 0;
+    let pts;
+    let back = false;
+    if (tRank > sRank) {
+      const a = sFlow + sFlowHalf;
+      const b = tFlow - tFlowHalf;
+      if (Math.abs(sCross - tCross) < 0.5) {
+        pts = [project(a, sCross), project(b, tCross)];
+      } else {
+        const mid = (a + b) / 2 + bendOffset[ei];
+        pts = [
+          project(a, sCross),
+          project(mid, sCross),
+          project(mid, tCross),
+          project(b, tCross)
+        ];
+      }
+    } else if (tRank === sRank) {
+      const downward = tCross >= sCross;
+      const a = sCross + (downward ? sCrossHalf : -sCrossHalf);
+      const b = tCross + (downward ? -tCrossHalf : tCrossHalf);
+      if (Math.abs(sFlow - tFlow) < 0.5) {
+        pts = [project(sFlow, a), project(tFlow, b)];
+      } else {
+        const midC = (a + b) / 2;
+        pts = [
+          project(sFlow, a),
+          project(sFlow, midC),
+          project(tFlow, midC),
+          project(tFlow, b)
+        ];
+      }
+    } else {
+      back = true;
+      const channelC = laneCrossEnd + BACK_CHANNEL + BACK_STEP * backIdx;
+      backIdx++;
+      const sBottom = sCross + sCrossHalf;
+      const tBottom = tCross + tCrossHalf;
+      const sLeg = routeBackLeg(
+        s.id,
+        sFlow,
+        sBottom,
+        channelC,
+        riOf(s.id),
+        tFlow
+      );
+      const tLeg = routeBackLeg(
+        t.id,
+        tFlow,
+        tBottom,
+        channelC,
+        riOf(t.id),
+        sFlow
+      );
+      pts = [
+        project(sFlow, sBottom),
+        ...sLeg.jogCross !== void 0 ? [project(sFlow, sLeg.jogCross), project(sLeg.flow, sLeg.jogCross)] : [],
+        project(sLeg.flow, channelC),
+        project(tLeg.flow, channelC),
+        ...tLeg.jogCross !== void 0 ? [project(tLeg.flow, tLeg.jogCross), project(tFlow, tLeg.jogCross)] : [],
+        project(tFlow, tBottom)
+      ];
+    }
+    layoutEdges.push({
+      source: e.source,
+      target: e.target,
+      ...e.label !== void 0 && { label: e.label },
+      points: pts,
+      back,
+      lineNumber: e.lineNumber
+    });
+  });
+  const projectBand = (flowStart, flowExtent, crossStart, crossExtent) => isLR ? { x: flowStart, y: crossStart, width: flowExtent, height: crossExtent } : { x: crossStart, y: flowStart, width: crossExtent, height: flowExtent };
+  const lanes = parsed.lanes.map((lane) => {
+    const box = projectBand(
+      0,
+      totalFlow,
+      laneCrossStart.get(lane.id),
+      laneThick.get(lane.id)
+    );
+    return {
+      id: lane.id,
+      label: lane.label,
+      ...lane.color !== void 0 && { color: lane.color },
+      ...box,
+      headerSize: LANE_HEADER,
+      lineNumber: lane.lineNumber
+    };
+  });
+  const phaseOrder = new Map(parsed.phases.map((ph, i) => [ph.id, i]));
+  const colMinPhase = Array.from(
+    { length: R },
+    () => void 0
+  );
+  for (const n of parsed.nodes) {
+    if (n.phase === void 0) continue;
+    const po = phaseOrder.get(n.phase);
+    if (po === void 0) continue;
+    const ri = riOf(n.id);
+    const cur = colMinPhase[ri];
+    if (cur === void 0 || po < cur) colMinPhase[ri] = po;
+  }
+  const colPhase = Array.from({ length: R }, () => 0);
+  let carry = 0;
+  for (let ri = 0; ri < R; ri++) {
+    const v = colMinPhase[ri];
+    if (v !== void 0 && v > carry) carry = v;
+    colPhase[ri] = carry;
+  }
+  const colMid = (i, j) => (flowCenter[i] + flowCenter[j]) / 2;
+  const phaseBands = [];
+  if (parsed.phases.length > 0 && R > 0) {
+    let start = 0;
+    for (let ri = 1; ri <= R; ri++) {
+      if (ri === R || colPhase[ri] !== colPhase[start]) {
+        const a = start;
+        const b = ri - 1;
+        const phase = parsed.phases[colPhase[start]];
+        const leftEdge = a === 0 ? 0 : colMid(a - 1, a);
+        const rightEdge = b === R - 1 ? totalFlow : colMid(b, b + 1);
+        phaseBands.push({
+          id: phase.id,
+          label: phase.label,
+          ...projectBand(leftEdge, rightEdge - leftEdge, 0, totalCross),
+          headerSize: PHASE_HEADER,
+          lineNumber: phase.lineNumber
+        });
+        start = ri;
+      }
+    }
+  }
+  return {
+    nodes: layoutNodes,
+    edges: layoutEdges,
+    lanes,
+    phases: phaseBands,
+    width: isLR ? totalFlow : totalCross,
+    height: isLR ? totalCross : totalFlow
+  };
+}
+
+export {
+  layoutSwimlane
+};
+//# sourceMappingURL=chunk-725LDASD.js.map

package/dist/chunk-76OWZ3BA.js

@@ -0,0 +1,130 @@
+import {
+  PYRAMID_REGISTRY,
+  measureIndent,
+  parseFirstLine,
+  splitNameAndMeta,
+  tryParseSharedOption,
+  warnUnknownMetaKeys
+} from "./chunk-Y3J7VR52.js";
+import {
+  makeDgmoError,
+  makeFail
+} from "./chunk-CXK4DZH3.js";
+
+// src/pyramid/parser.ts
+var MAX_LAYERS = 15;
+function parsePyramid(content) {
+  const options = {};
+  const result = {
+    type: "pyramid",
+    title: "",
+    titleLineNumber: 0,
+    layers: [],
+    inverted: false,
+    options,
+    diagnostics: [],
+    error: null
+  };
+  const lines = content.split("\n");
+  let headerParsed = false;
+  let currentLayer = null;
+  const fail = makeFail(result);
+  const warn = (line, message, severity = "warning") => {
+    result.diagnostics.push(makeDgmoError(line, message, severity));
+  };
+  const flushLayer = () => {
+    if (currentLayer) {
+      result.layers.push(currentLayer);
+      currentLayer = null;
+    }
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const lineNum = i + 1;
+    const raw = lines[i];
+    const trimmed = raw.trim();
+    if (!trimmed || trimmed.startsWith("//")) continue;
+    const indent = measureIndent(raw);
+    if (!headerParsed) {
+      const firstLineResult = parseFirstLine(trimmed);
+      if (firstLineResult?.chartType === "pyramid") {
+        result.title = firstLineResult.title ?? "";
+        result.titleLineNumber = lineNum;
+        headerParsed = true;
+        continue;
+      }
+      return fail(lineNum, 'Expected "pyramid [Title]" as the first line.');
+    }
+    if (indent === 0 && trimmed.toLowerCase() === "inverted") {
+      result.inverted = true;
+      continue;
+    }
+    if (indent === 0 && tryParseSharedOption(trimmed, options)) {
+      continue;
+    }
+    if (indent === 0) {
+      flushLayer();
+      const split = splitNameAndMeta(
+        trimmed,
+        PYRAMID_REGISTRY,
+        /* @__PURE__ */ new Map(),
+        void 0,
+        result.diagnostics,
+        lineNum
+      );
+      warnUnknownMetaKeys(
+        split.meta,
+        PYRAMID_REGISTRY,
+        (msg) => warn(lineNum, msg),
+        split.name
+      );
+      const label = split.name;
+      const restMeta = { ...split.meta };
+      const color = split.color ?? restMeta["color"];
+      delete restMeta["color"];
+      const description = [];
+      const descFromMeta = restMeta["description"];
+      if (descFromMeta) description.push(descFromMeta);
+      delete restMeta["description"];
+      if (!label) {
+        warn(lineNum, "Empty layer label.");
+        continue;
+      }
+      currentLayer = {
+        label,
+        lineNumber: lineNum,
+        ...color !== void 0 && { color },
+        description,
+        metadata: restMeta
+      };
+      continue;
+    }
+    if (!currentLayer) {
+      warn(
+        lineNum,
+        `Indented description "${trimmed}" has no layer above it \u2014 add a layer name on a non-indented line first. (\xA723)`
+      );
+      continue;
+    }
+    const descLine = trimmed.startsWith("- ") ? `\u2022 ${trimmed.substring(2)}` : trimmed;
+    currentLayer.description.push(descLine);
+  }
+  flushLayer();
+  if (result.layers.length < 2) {
+    return fail(
+      result.titleLineNumber || 1,
+      "pyramid requires at least 2 layers."
+    );
+  }
+  if (result.layers.length > MAX_LAYERS) {
+    return fail(
+      result.titleLineNumber || 1,
+      `pyramid supports at most ${MAX_LAYERS} layers; got ${result.layers.length}.`
+    );
+  }
+  return result;
+}
+
+export {
+  parsePyramid
+};
+//# sourceMappingURL=chunk-76OWZ3BA.js.map