@diagrammo/dgmo 0.46.0 → 0.48.0

package/dist/chunk-4OHACBGX.js

@@ -0,0 +1,606 @@
+import {
+  measureText
+} from "./chunk-WCT3NYCV.js";
+import {
+  formatDuration,
+  formatScheduleValue,
+  formatSlackValue,
+  formatSprintCell
+} from "./chunk-L3UHP6TD.js";
+
+// src/pert/layout.ts
+import dagre from "@dagrejs/dagre";
+var DEFAULT_NODE_HEIGHT = 90;
+var MILESTONE_NODE_HEIGHT = DEFAULT_NODE_HEIGHT;
+var COLLAPSED_GROUP_HEIGHT = 90;
+var DIAGRAM_PADDING = 20;
+var GROUP_PADDING = 18;
+var GROUP_TOP_PADDING = 28;
+var SWIMLANE_SLOT_SEP = 40;
+var SWIMLANE_GAP = 24;
+var NODE_CELL_FONT_SIZE = 11;
+var NODE_NAME_FONT_SIZE = 13;
+var MILESTONE_NAME_FONT_SIZE = 12;
+var CELL_PAD_X = 8;
+var NAME_PAD_X = 6;
+var NAME_PIN_WIDTH = 13 + 4;
+var MIN_CELL_WIDTH = 30;
+var MIN_NODE_WIDTH = 120;
+var MAX_NODE_WIDTH = 280;
+var MIN_MILESTONE_WIDTH = 80;
+var MAX_MILESTONE_WIDTH = 160;
+function computeNodeSizing(resolved) {
+  const unit = resolved.options.timeUnit;
+  const sprintMode = resolved.options.sprintMode;
+  const sprintNumber = resolved.options.sprintNumber ?? 1;
+  const projectStart = resolved.projectStart;
+  const fmtSchedule = (v, isTbd) => sprintMode ? formatSprintCell(v, sprintNumber, isTbd ? "?" : null) : formatScheduleValue(v, projectStart, unit, isTbd ? "?" : null);
+  const fmtSlack = (v, isTbd) => formatSlackValue(v, projectStart, unit, isTbd ? "?" : null);
+  const fmtDur = (v, isTbd) => formatDuration(v, unit, isTbd ? "?" : null);
+  let maxOuterW = 0;
+  let maxMidW = 0;
+  let maxNameW = 0;
+  let maxMilestoneTopW = 0;
+  let maxMilestoneSlackW = 0;
+  let maxMilestoneNameW = 0;
+  for (const r of resolved.activities) {
+    const isTbd = r.es === null;
+    if (r.activity.isMilestone) {
+      const dateStr = fmtSchedule(r.es, isTbd);
+      const slackStr2 = fmtSlack(r.slack, isTbd);
+      const slackHidden = !isTbd && /^0[a-z]?$/.test(slackStr2);
+      maxMilestoneTopW = Math.max(
+        maxMilestoneTopW,
+        measureText(dateStr, NODE_CELL_FONT_SIZE)
+      );
+      if (!slackHidden) {
+        maxMilestoneSlackW = Math.max(
+          maxMilestoneSlackW,
+          measureText(slackStr2, NODE_CELL_FONT_SIZE)
+        );
+      }
+      maxMilestoneNameW = Math.max(
+        maxMilestoneNameW,
+        measureText(`\u25C6 ${r.activity.name}`, MILESTONE_NAME_FONT_SIZE)
+      );
+      continue;
+    }
+    const esStr = fmtSchedule(r.es, isTbd);
+    const efStr = fmtSchedule(r.ef, isTbd);
+    const lsStr = fmtSchedule(r.ls, isTbd);
+    const lfStr = fmtSchedule(r.lf, isTbd);
+    const durStr = fmtDur(r.mu, isTbd);
+    const slackStr = fmtSlack(r.slack, isTbd);
+    maxOuterW = Math.max(
+      maxOuterW,
+      measureText(esStr, NODE_CELL_FONT_SIZE),
+      measureText(efStr, NODE_CELL_FONT_SIZE),
+      measureText(lsStr, NODE_CELL_FONT_SIZE),
+      measureText(lfStr, NODE_CELL_FONT_SIZE)
+    );
+    maxMidW = Math.max(
+      maxMidW,
+      measureText(durStr, NODE_CELL_FONT_SIZE),
+      measureText(slackStr, NODE_CELL_FONT_SIZE)
+    );
+    maxNameW = Math.max(
+      maxNameW,
+      measureText(r.activity.name, NODE_NAME_FONT_SIZE)
+    );
+  }
+  for (const rg of resolved.groups) {
+    maxNameW = Math.max(
+      maxNameW,
+      measureText(rg.group.name, NODE_NAME_FONT_SIZE)
+    );
+  }
+  const outerCell = Math.ceil(maxOuterW) + 2 * CELL_PAD_X;
+  const midCell = Math.ceil(maxMidW) + 2 * CELL_PAD_X;
+  const outerNeeded = Math.max(MIN_CELL_WIDTH, outerCell);
+  const midNeeded = Math.max(MIN_CELL_WIDTH, midCell);
+  const cellsTotalW = 2 * outerNeeded + midNeeded;
+  const nameTextW = Math.ceil(maxNameW);
+  const nameTotalW = nameTextW + NAME_PIN_WIDTH + 2 * NAME_PAD_X;
+  const activityWidth = Math.max(
+    MIN_NODE_WIDTH,
+    Math.min(MAX_NODE_WIDTH, Math.max(cellsTotalW, nameTotalW))
+  );
+  let midColW = midNeeded;
+  let outerColW = (activityWidth - midColW) / 2;
+  if (midColW > outerColW) {
+    outerColW = activityWidth / 3;
+    midColW = activityWidth - 2 * outerColW;
+  }
+  const mTop = Math.ceil(maxMilestoneTopW) + 2 * CELL_PAD_X;
+  const mSlack = maxMilestoneSlackW > 0 ? Math.ceil(maxMilestoneSlackW) + 2 * CELL_PAD_X : 0;
+  const mName = Math.ceil(maxMilestoneNameW) + NAME_PIN_WIDTH + 2 * NAME_PAD_X;
+  const milestoneWidth = Math.max(
+    MIN_MILESTONE_WIDTH,
+    Math.min(MAX_MILESTONE_WIDTH, Math.max(mTop, mSlack, mName))
+  );
+  return { activityWidth, milestoneWidth, outerColW, midColW };
+}
+function nodeDimensions(resolved, id, sizing, overrides) {
+  if (overrides?.[id]) {
+    return { width: overrides[id].width, height: overrides[id].height };
+  }
+  const r = resolved.activities.find((a) => a.activity.id === id);
+  if (r?.activity.isMilestone) {
+    return { width: sizing.milestoneWidth, height: MILESTONE_NODE_HEIGHT };
+  }
+  return { width: sizing.activityWidth, height: DEFAULT_NODE_HEIGHT };
+}
+function layoutPert(resolved) {
+  return relayoutPert(resolved, {});
+}
+function relayoutPert(resolved, overrides, collapsedGroupIds = /* @__PURE__ */ new Set()) {
+  if (resolved.activities.length === 0) {
+    return { nodes: [], edges: [], groups: [], width: 0, height: 0 };
+  }
+  const memberToGroup = /* @__PURE__ */ new Map();
+  for (const rg of resolved.groups) {
+    if (collapsedGroupIds.has(rg.group.id)) {
+      for (const aid of rg.group.activityIds) {
+        memberToGroup.set(aid, rg.group.id);
+      }
+    }
+  }
+  const dagreId = (id) => memberToGroup.get(id) ?? id;
+  const g = new dagre.graphlib.Graph();
+  g.setGraph({
+    rankdir: resolved.options.direction,
+    nodesep: 50,
+    ranksep: 60,
+    edgesep: 18,
+    marginx: DIAGRAM_PADDING,
+    marginy: DIAGRAM_PADDING
+  });
+  g.setDefaultEdgeLabel(() => ({}));
+  const sizing = computeNodeSizing(resolved);
+  for (const r of resolved.activities) {
+    if (memberToGroup.has(r.activity.id)) continue;
+    const { width, height } = nodeDimensions(
+      resolved,
+      r.activity.id,
+      sizing,
+      overrides
+    );
+    g.setNode(r.activity.id, { width, height });
+  }
+  for (const rg of resolved.groups) {
+    if (collapsedGroupIds.has(rg.group.id)) {
+      g.setNode(rg.group.id, {
+        width: sizing.activityWidth,
+        height: COLLAPSED_GROUP_HEIGHT
+      });
+    }
+  }
+  const seenEdges = /* @__PURE__ */ new Set();
+  for (const e of resolved.edges) {
+    const src = dagreId(e.source);
+    const tgt = dagreId(e.target);
+    if (src === tgt) continue;
+    const k = `${src}|${tgt}`;
+    if (seenEdges.has(k)) continue;
+    seenEdges.add(k);
+    g.setEdge(src, tgt, {});
+  }
+  dagre.layout(g);
+  const swimApplied = applySwimLanes(
+    g,
+    resolved,
+    memberToGroup,
+    collapsedGroupIds
+  );
+  if (!swimApplied) {
+    centerByCriticality(g, resolved, memberToGroup, collapsedGroupIds);
+    reduceCrossings(g, resolved.options.direction);
+  }
+  const nodes = resolved.activities.filter((r) => !memberToGroup.has(r.activity.id)).map((r) => {
+    const pos = g.node(r.activity.id);
+    return {
+      id: r.activity.id,
+      x: pos.x,
+      y: pos.y,
+      width: pos.width,
+      height: pos.height
+    };
+  });
+  const edges = Array.from(seenEdges).map((k) => {
+    const [source, target] = k.split("|");
+    const data = g.edge(source, target);
+    return { source, target, points: data?.points ?? [] };
+  });
+  const nodeMap = /* @__PURE__ */ new Map();
+  for (const n of nodes) nodeMap.set(n.id, n);
+  for (const rg of resolved.groups) {
+    if (collapsedGroupIds.has(rg.group.id)) {
+      const vn = g.node(rg.group.id);
+      nodeMap.set(rg.group.id, {
+        x: vn.x,
+        y: vn.y,
+        width: vn.width,
+        height: vn.height
+      });
+    }
+  }
+  const groups = resolved.groups.map((rg) => {
+    const classification = rg.group.classification ?? "cluster";
+    if (collapsedGroupIds.has(rg.group.id)) {
+      const vn = nodeMap.get(rg.group.id);
+      if (!vn) {
+        return {
+          id: rg.group.id,
+          x: 0,
+          y: 0,
+          width: 0,
+          height: 0,
+          classification,
+          collapsed: true
+        };
+      }
+      return {
+        id: rg.group.id,
+        x: vn.x - vn.width / 2,
+        y: vn.y - vn.height / 2,
+        width: vn.width,
+        height: vn.height,
+        classification,
+        collapsed: true
+      };
+    }
+    const members = rg.group.activityIds.map((id) => nodeMap.get(id)).filter(
+      (n) => n !== void 0
+    );
+    if (members.length === 0) {
+      return {
+        id: rg.group.id,
+        x: 0,
+        y: 0,
+        width: 0,
+        height: 0,
+        classification
+      };
+    }
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    for (const m of members) {
+      const left = m.x - m.width / 2;
+      const right = m.x + m.width / 2;
+      const top = m.y - m.height / 2;
+      const bottom = m.y + m.height / 2;
+      if (left < minX) minX = left;
+      if (right > maxX) maxX = right;
+      if (top < minY) minY = top;
+      if (bottom > maxY) maxY = bottom;
+    }
+    return {
+      id: rg.group.id,
+      x: minX - GROUP_PADDING,
+      y: minY - GROUP_TOP_PADDING,
+      width: maxX - minX + GROUP_PADDING * 2,
+      height: maxY - minY + GROUP_TOP_PADDING + GROUP_PADDING,
+      classification
+    };
+  });
+  let totalW = 0;
+  let totalH = 0;
+  for (const n of nodes) {
+    const right = n.x + n.width / 2;
+    const bottom = n.y + n.height / 2;
+    if (right > totalW) totalW = right;
+    if (bottom > totalH) totalH = bottom;
+  }
+  for (const grp of groups) {
+    if (grp.x + grp.width > totalW) totalW = grp.x + grp.width;
+    if (grp.y + grp.height > totalH) totalH = grp.y + grp.height;
+  }
+  return {
+    nodes,
+    edges,
+    groups,
+    width: totalW + DIAGRAM_PADDING,
+    height: totalH + DIAGRAM_PADDING
+  };
+}
+function applySwimLanes(g, resolved, _memberToGroup, collapsedGroupIds) {
+  const expanded = resolved.groups.filter(
+    (rg) => !collapsedGroupIds.has(rg.group.id)
+  );
+  if (expanded.length === 0) return false;
+  const isLR = resolved.options.direction !== "TB";
+  const rankAxis = isLR ? "x" : "y";
+  const slotAxis = isLR ? "y" : "x";
+  let spineIdx = 1;
+  let spineMembers = 0;
+  expanded.forEach((rg, i) => {
+    if (rg.group.activityIds.length > spineMembers) {
+      spineMembers = rg.group.activityIds.length;
+      spineIdx = i + 1;
+    }
+  });
+  const laneOf = /* @__PURE__ */ new Map();
+  expanded.forEach((rg, i) => {
+    for (const aid of rg.group.activityIds) laneOf.set(aid, i + 1);
+  });
+  for (const id of g.nodes()) {
+    if (!laneOf.has(id)) laneOf.set(id, spineIdx);
+  }
+  const spineMemberSet = new Set(
+    expanded[spineIdx - 1]?.group.activityIds ?? []
+  );
+  const numLanes = expanded.length + 1;
+  const rankBuckets = /* @__PURE__ */ new Map();
+  for (const id of g.nodes()) {
+    const node = g.node(id);
+    if (!node) continue;
+    const rankKey = Math.round(node[rankAxis]);
+    const laneIdx = laneOf.get(id) ?? spineIdx;
+    let byLane = rankBuckets.get(rankKey);
+    if (!byLane) {
+      byLane = /* @__PURE__ */ new Map();
+      rankBuckets.set(rankKey, byLane);
+    }
+    if (!byLane.has(laneIdx)) byLane.set(laneIdx, []);
+    byLane.get(laneIdx).push(id);
+  }
+  const laneSlots = new Array(numLanes).fill(0);
+  for (const byLane of rankBuckets.values()) {
+    for (const [li, members] of byLane) {
+      if (members.length > laneSlots[li]) laneSlots[li] = members.length;
+    }
+  }
+  const slotSize = isLR ? DEFAULT_NODE_HEIGHT : g.node(g.nodes()[0])?.width ?? DEFAULT_NODE_HEIGHT;
+  const laneSize = new Array(numLanes).fill(0);
+  for (let i = 1; i < numLanes; i++) {
+    const slots = laneSlots[i];
+    if (slots === 0) {
+      laneSize[i] = 0;
+      continue;
+    }
+    const slotsExtent = slots * slotSize + Math.max(0, slots - 1) * SWIMLANE_SLOT_SEP;
+    laneSize[i] = GROUP_TOP_PADDING + slotsExtent + GROUP_PADDING;
+  }
+  const laneOrder = [
+    spineIdx,
+    ...Array.from({ length: expanded.length }, (_, i) => i + 1).filter(
+      (i) => i !== spineIdx
+    )
+  ];
+  const laneStart = new Array(numLanes).fill(0);
+  let cursor = DIAGRAM_PADDING;
+  for (const li of laneOrder) {
+    laneStart[li] = cursor;
+    if (laneSize[li] > 0) cursor += laneSize[li] + SWIMLANE_GAP;
+  }
+  const critOf = (id) => {
+    const r = resolved.activities.find((a) => a.activity.id === id);
+    if (r) {
+      return r.criticality !== null ? r.criticality : r.isCriticalPath ? 1 : 0;
+    }
+    const rg = resolved.groups.find((x) => x.group.id === id);
+    if (!rg) return 0;
+    let m = 0;
+    for (const aid of rg.group.activityIds) {
+      const ar = resolved.activities.find((a) => a.activity.id === aid);
+      if (!ar) continue;
+      const c = ar.criticality !== null ? ar.criticality : ar.isCriticalPath ? 1 : 0;
+      if (c > m) m = c;
+    }
+    return m;
+  };
+  const oldSlot = /* @__PURE__ */ new Map();
+  for (const id of g.nodes()) {
+    oldSlot.set(id, g.node(id)[slotAxis]);
+  }
+  for (const byLane of rankBuckets.values()) {
+    for (const [li, members] of byLane) {
+      const slotStripStart = laneStart[li] + GROUP_TOP_PADDING;
+      const sorted = [...members].sort((a, b) => {
+        const aSpine = spineMemberSet.has(a) ? 0 : 1;
+        const bSpine = spineMemberSet.has(b) ? 0 : 1;
+        if (aSpine !== bSpine) return aSpine - bSpine;
+        const ca = critOf(a);
+        const cb = critOf(b);
+        if (cb !== ca) return cb - ca;
+        return (oldSlot.get(a) ?? 0) - (oldSlot.get(b) ?? 0);
+      });
+      sorted.forEach((id, idx) => {
+        const node = g.node(id);
+        node[slotAxis] = slotStripStart + slotSize / 2 + idx * (slotSize + SWIMLANE_SLOT_SEP);
+      });
+    }
+  }
+  const dir = resolved.options.direction;
+  for (const e of g.edges()) {
+    const src = g.node(e.v);
+    const tgt = g.node(e.w);
+    if (!src || !tgt) continue;
+    const data = g.edge(e);
+    if (!data) continue;
+    data.points = smoothEdge(src, tgt, dir);
+  }
+  return true;
+}
+function centerByCriticality(g, resolved, memberToGroup, collapsedGroupIds) {
+  const critById = /* @__PURE__ */ new Map();
+  for (const r of resolved.activities) {
+    if (memberToGroup.has(r.activity.id)) continue;
+    const c = r.criticality !== null ? r.criticality : r.isCriticalPath ? 1 : 0;
+    critById.set(r.activity.id, c);
+  }
+  for (const rg of resolved.groups) {
+    if (!collapsedGroupIds.has(rg.group.id)) continue;
+    let maxC = 0;
+    for (const aid of rg.group.activityIds) {
+      const r = resolved.activities.find((x) => x.activity.id === aid);
+      if (!r) continue;
+      const c = r.criticality !== null ? r.criticality : r.isCriticalPath ? 1 : 0;
+      if (c > maxC) maxC = c;
+    }
+    critById.set(rg.group.id, maxC);
+  }
+  const rankAxis = resolved.options.direction === "TB" ? "y" : "x";
+  const slotAxis = resolved.options.direction === "TB" ? "x" : "y";
+  const buckets = /* @__PURE__ */ new Map();
+  for (const id of g.nodes()) {
+    const node = g.node(id);
+    if (!node) continue;
+    const key = Math.round(node[rankAxis]);
+    if (!buckets.has(key)) buckets.set(key, []);
+    buckets.get(key).push(id);
+  }
+  const shifts = /* @__PURE__ */ new Map();
+  for (const ids of buckets.values()) {
+    if (ids.length < 2) continue;
+    const slots = ids.map((id) => g.node(id)[slotAxis]).sort((a, b) => a - b);
+    const currentSlot = /* @__PURE__ */ new Map();
+    for (const id of ids) currentSlot.set(id, g.node(id)[slotAxis]);
+    const sortedDesc = [...ids].sort((a, b) => {
+      const ca = critById.get(a) ?? 0;
+      const cb = critById.get(b) ?? 0;
+      if (cb !== ca) return cb - ca;
+      return (currentSlot.get(a) ?? 0) - (currentSlot.get(b) ?? 0);
+    });
+    const top = [];
+    const bottom = [];
+    let middle = null;
+    sortedDesc.forEach((id, i) => {
+      if (i === 0) middle = id;
+      else if (i % 2 === 1) top.unshift(id);
+      else bottom.push(id);
+    });
+    const newOrder = middle ? [...top, middle, ...bottom] : [...top, ...bottom];
+    newOrder.forEach((id, i) => {
+      const node = g.node(id);
+      const oldVal = node[slotAxis];
+      const newVal = slots[i];
+      shifts.set(id, newVal - oldVal);
+      node[slotAxis] = newVal;
+    });
+  }
+  if (shifts.size > 0) {
+    const dir = resolved.options.direction;
+    for (const e of g.edges()) {
+      if (!shifts.has(e.v) && !shifts.has(e.w)) continue;
+      const src = g.node(e.v);
+      const tgt = g.node(e.w);
+      if (!src || !tgt) continue;
+      const data = g.edge(e);
+      if (!data) continue;
+      data.points = smoothEdge(src, tgt, dir);
+    }
+  }
+}
+function smoothEdge(src, tgt, direction) {
+  if (direction === "TB") {
+    const sy = src.y + src.height / 2;
+    const ty = tgt.y - tgt.height / 2;
+    const span2 = ty - sy;
+    const pad2 = Math.max(20, Math.abs(span2) * 0.3);
+    return [
+      { x: src.x, y: sy },
+      { x: src.x, y: sy + Math.sign(span2 || 1) * pad2 },
+      { x: tgt.x, y: ty - Math.sign(span2 || 1) * pad2 },
+      { x: tgt.x, y: ty }
+    ];
+  }
+  const sx = src.x + src.width / 2;
+  const tx = tgt.x - tgt.width / 2;
+  const span = tx - sx;
+  const pad = Math.max(20, Math.abs(span) * 0.3);
+  return [
+    { x: sx, y: src.y },
+    { x: sx + Math.sign(span || 1) * pad, y: src.y },
+    { x: tx - Math.sign(span || 1) * pad, y: tgt.y },
+    { x: tx, y: tgt.y }
+  ];
+}
+function reduceCrossings(g, direction) {
+  const isLR = direction !== "TB";
+  const rankAxis = isLR ? "x" : "y";
+  const slotAxis = isLR ? "y" : "x";
+  const buckets = /* @__PURE__ */ new Map();
+  for (const id of g.nodes()) {
+    const node = g.node(id);
+    if (!node) continue;
+    const key = Math.round(node[rankAxis]);
+    if (!buckets.has(key)) buckets.set(key, []);
+    buckets.get(key).push(id);
+  }
+  const edges = g.edges().map((e) => ({ v: e.v, w: e.w }));
+  const countCrossings = () => {
+    let total = 0;
+    for (let i = 0; i < edges.length; i++) {
+      const a = edges[i];
+      const a1 = g.node(a.v);
+      const a2 = g.node(a.w);
+      if (!a1 || !a2) continue;
+      for (let j = i + 1; j < edges.length; j++) {
+        const b = edges[j];
+        if (a.v === b.v || a.v === b.w || a.w === b.v || a.w === b.w) continue;
+        const b1 = g.node(b.v);
+        const b2 = g.node(b.w);
+        if (!b1 || !b2) continue;
+        if (segmentsCross(a1, a2, b1, b2)) total++;
+      }
+    }
+    return total;
+  };
+  const MAX_ITER = 8;
+  let baseline = countCrossings();
+  if (baseline === 0) return;
+  for (let iter = 0; iter < MAX_ITER; iter++) {
+    let improved = false;
+    for (const ids of buckets.values()) {
+      if (ids.length < 2) continue;
+      const sorted = ids.slice().sort(
+        (a, b) => g.node(a)[slotAxis] - g.node(b)[slotAxis]
+      );
+      for (let i = 0; i < sorted.length - 1; i++) {
+        const a = sorted[i];
+        const b = sorted[i + 1];
+        const an = g.node(a);
+        const bn = g.node(b);
+        const av = an[slotAxis];
+        const bv = bn[slotAxis];
+        an[slotAxis] = bv;
+        bn[slotAxis] = av;
+        const after = countCrossings();
+        if (after < baseline) {
+          baseline = after;
+          improved = true;
+        } else {
+          an[slotAxis] = av;
+          bn[slotAxis] = bv;
+        }
+      }
+    }
+    if (!improved || baseline === 0) break;
+  }
+  for (const e of g.edges()) {
+    const src = g.node(e.v);
+    const tgt = g.node(e.w);
+    if (!src || !tgt) continue;
+    const data = g.edge(e);
+    if (!data) continue;
+    data.points = smoothEdge(src, tgt, direction);
+  }
+}
+function segmentsCross(a1, a2, b1, b2) {
+  const ccw = (p, q, r) => (q.x - p.x) * (r.y - p.y) - (q.y - p.y) * (r.x - p.x);
+  const d1 = ccw(b1, b2, a1);
+  const d2 = ccw(b1, b2, a2);
+  const d3 = ccw(a1, a2, b1);
+  const d4 = ccw(a1, a2, b2);
+  return (d1 > 0 && d2 < 0 || d1 < 0 && d2 > 0) && (d3 > 0 && d4 < 0 || d3 < 0 && d4 > 0);
+}
+
+export {
+  computeNodeSizing,
+  layoutPert,
+  relayoutPert
+};
+//# sourceMappingURL=chunk-4OHACBGX.js.map

package/dist/chunk-5DH3KYFH.js

@@ -0,0 +1,21 @@
+// src/utils/note-box/constants.ts
+var NOTE_MAX_W = 200;
+var NOTE_FOLD = 10;
+var NOTE_PAD_H = 8;
+var NOTE_PAD_V = 6;
+var NOTE_FONT_SIZE = 10;
+var NOTE_LINE_H = 14;
+var NOTE_GAP = 22;
+var NOTE_BULLET_INDENT = 10;
+
+export {
+  NOTE_MAX_W,
+  NOTE_FOLD,
+  NOTE_PAD_H,
+  NOTE_PAD_V,
+  NOTE_FONT_SIZE,
+  NOTE_LINE_H,
+  NOTE_GAP,
+  NOTE_BULLET_INDENT
+};
+//# sourceMappingURL=chunk-5DH3KYFH.js.map

package/dist/chunk-5MLYVTYM.js

@@ -0,0 +1,76 @@
+import {
+  extractColor,
+  measureIndent
+} from "./chunk-Y3J7VR52.js";
+import {
+  makeDgmoError
+} from "./chunk-CXK4DZH3.js";
+
+// src/utils/notes/parse.ts
+function parseNoteHeader(rest) {
+  const t = rest.trim();
+  const quoted = t.match(/^"([^"]+)"\s*(.*)$/);
+  if (quoted) {
+    return { ref: quoted[1].trim(), inlineBody: quoted[2].trim() };
+  }
+  const m = t.match(/^(\S+)\s*(.*)$/);
+  if (m) {
+    return { ref: m[1], inlineBody: m[2].trim() };
+  }
+  return { ref: t, inlineBody: "" };
+}
+function collectNoteBody(lines, noteIndex, noteIndent, inlineBody) {
+  const parts = [];
+  if (inlineBody) parts.push(inlineBody);
+  let lastIndex = noteIndex;
+  let endLineNumber = noteIndex + 1;
+  for (let j = noteIndex + 1; j < lines.length; j++) {
+    const raw = lines[j];
+    const trimmed = raw.trim();
+    if (!trimmed) break;
+    if (measureIndent(raw) <= noteIndent) break;
+    parts.push(trimmed);
+    lastIndex = j;
+    endLineNumber = j + 1;
+  }
+  return { body: parts.join("\n"), endLineNumber, lastIndex };
+}
+function tryCollectNote(lines, index, indent, palette, diagnostics) {
+  const trimmed = lines[index].trim();
+  const m = trimmed.match(/^note\s+(.+)$/i);
+  if (!m || /^note\s+->/i.test(trimmed)) return null;
+  const lineNumber = index + 1;
+  const { label: headerNoColor, color } = extractColor(
+    m[1],
+    palette,
+    diagnostics,
+    lineNumber
+  );
+  const { ref, inlineBody } = parseNoteHeader(headerNoColor);
+  const collected = collectNoteBody(lines, index, indent, inlineBody);
+  if (!collected.body.trim()) {
+    diagnostics.push(
+      makeDgmoError(
+        lineNumber,
+        `Note on "${ref}" has no text \u2014 ignored.`,
+        "warning"
+      )
+    );
+    return { lastIndex: collected.lastIndex };
+  }
+  return {
+    note: {
+      ref,
+      body: collected.body,
+      ...color && { color },
+      lineNumber,
+      endLineNumber: collected.endLineNumber
+    },
+    lastIndex: collected.lastIndex
+  };
+}
+
+export {
+  tryCollectNote
+};
+//# sourceMappingURL=chunk-5MLYVTYM.js.map