compasso 0.2.0 → 0.4.0

package/dist/org-chart/index.cjs

@@ -0,0 +1,853 @@
+'use strict';
+
+// src/org-chart/types.ts
+var ORG_REPORT_KINDS = ["line", "assistant", "dotted"];
+var ORG_VACANCIES = ["filled", "vacant"];
+
+// src/org-chart/labels.ts
+var ORG_CHART_TITLE_LABELS_EN = {
+  reportKinds: { line: "Reports to", assistant: "Assistant to", dotted: "Dotted-line report to" },
+  vacant: "(vacant)"
+};
+var ORG_CHART_SVG_LABELS_EN = {
+  legend: { line: "Reports to", assistant: "Assistant", dotted: "Dotted-line / matrix", vacant: "Vacant position" },
+  ariaLabel: "Organizational chart"
+};
+
+// src/org-chart/validate.ts
+var ORG_MAX_MATRIX_EDGES_PER_NODE = 5;
+var OrgChartValidationError = class extends Error {
+  issues;
+  constructor(issues) {
+    super(`invalid org chart: ${issues.map((i) => i.message).join("; ")}`);
+    this.name = "OrgChartValidationError";
+    this.issues = issues;
+  }
+};
+function listIds(ids) {
+  if (ids.length === 1) return String(ids[0]);
+  return `${ids.slice(0, -1).join(", ")} and ${ids[ids.length - 1]}`;
+}
+function sortIssues(issues) {
+  const unique = /* @__PURE__ */ new Map();
+  for (const issue of issues) unique.set(`${issue.code} ${issue.message}`, issue);
+  return [...unique.values()].sort(
+    (a, b) => a.code !== b.code ? a.code < b.code ? -1 : 1 : a.message < b.message ? -1 : a.message > b.message ? 1 : 0
+  );
+}
+var GRAPH_BLOCKING = /* @__PURE__ */ new Set([
+  "duplicate-id",
+  "unknown-manager",
+  "unknown-report",
+  "multiple-managers"
+]);
+function orgChartIssues(input) {
+  if (input.positions.length === 0 && input.reports.length === 0) return [];
+  const issues = [];
+  const push = (code, message) => {
+    issues.push({ code, message });
+  };
+  const positionById = /* @__PURE__ */ new Map();
+  const dupPositionIds = /* @__PURE__ */ new Set();
+  for (const p of input.positions) {
+    if (positionById.has(p.id)) dupPositionIds.add(p.id);
+    else positionById.set(p.id, p);
+  }
+  for (const id of [...dupPositionIds].sort((a, b) => a - b)) {
+    push("duplicate-id", `duplicate position id ${id}`);
+  }
+  const reportById = /* @__PURE__ */ new Map();
+  const dupReportIds = /* @__PURE__ */ new Set();
+  for (const r of input.reports) {
+    if (reportById.has(r.id)) dupReportIds.add(r.id);
+    else reportById.set(r.id, r);
+  }
+  for (const id of [...dupReportIds].sort((a, b) => a - b)) {
+    push("duplicate-id", `duplicate report id ${id}`);
+  }
+  if (issues.length > 0) {
+    return sortIssues(issues);
+  }
+  const reports = [...reportById.values()].sort((a, b) => a.id - b.id);
+  const solidParents = /* @__PURE__ */ new Map();
+  const assistantReportEdge = /* @__PURE__ */ new Map();
+  const solidManagedEdges = /* @__PURE__ */ new Map();
+  const dottedDegree = /* @__PURE__ */ new Map();
+  for (const r of reports) {
+    const hasManager = positionById.has(r.managerId);
+    const hasReport = positionById.has(r.reportId);
+    if (!hasManager) {
+      push("unknown-manager", `report ${r.id} managerId ${r.managerId} is not a declared position`);
+    }
+    if (!hasReport) {
+      push("unknown-report", `report ${r.id} reportId ${r.reportId} is not a declared position`);
+    }
+    if (r.managerId === r.reportId) {
+      push("self-report", `report ${r.id} has managerId === reportId (${r.managerId})`);
+    }
+    if (r.kind !== "dotted") {
+      const arr = solidParents.get(r.reportId) ?? [];
+      arr.push(r.id);
+      solidParents.set(r.reportId, arr);
+      const managed = solidManagedEdges.get(r.managerId) ?? [];
+      managed.push(r.id);
+      solidManagedEdges.set(r.managerId, managed);
+    }
+    if (r.kind === "assistant" && r.managerId !== r.reportId && !assistantReportEdge.has(r.reportId)) {
+      assistantReportEdge.set(r.reportId, r.id);
+    }
+    if (r.kind === "dotted" && r.managerId !== r.reportId) {
+      if (positionById.has(r.managerId)) dottedDegree.set(r.managerId, (dottedDegree.get(r.managerId) ?? 0) + 1);
+      if (positionById.has(r.reportId)) dottedDegree.set(r.reportId, (dottedDegree.get(r.reportId) ?? 0) + 1);
+    }
+  }
+  for (const [reportId, edgeIds] of [...solidParents.entries()].sort((a, b) => a[0] - b[0])) {
+    if (edgeIds.length > 1) {
+      push(
+        "multiple-managers",
+        `position ${reportId} is the report of solid edges ${listIds(edgeIds.sort((a, b) => a - b))} \u2014 keep one solid line, make the rest kind "dotted"`
+      );
+    }
+  }
+  for (const [positionId, assistEdgeId] of [...assistantReportEdge.entries()].sort((a, b) => a[0] - b[0])) {
+    const managed = solidManagedEdges.get(positionId);
+    if (managed !== void 0 && managed.length > 0) {
+      const firstManaged = Math.min(...managed);
+      push(
+        "assistant-has-reports",
+        `position ${positionId} is an assistant (report of edge ${assistEdgeId}) but manages solid edge ${firstManaged} \u2014 assistants are leaves`
+      );
+    }
+  }
+  for (const [positionId, count] of [...dottedDegree.entries()].sort((a, b) => a[0] - b[0])) {
+    if (count > ORG_MAX_MATRIX_EDGES_PER_NODE) {
+      push(
+        "too-many-matrix-edges",
+        `position ${positionId} has ${count} dotted (matrix) connections \u2014 at most ${ORG_MAX_MATRIX_EDGES_PER_NODE} are supported per position`
+      );
+    }
+  }
+  if (!issues.some((i) => GRAPH_BLOCKING.has(i.code))) {
+    const solidChildren = /* @__PURE__ */ new Map();
+    for (const r of reports) {
+      if (r.kind === "dotted") continue;
+      if (r.managerId === r.reportId) continue;
+      const arr = solidChildren.get(r.managerId) ?? [];
+      arr.push(r.reportId);
+      solidChildren.set(r.managerId, arr);
+    }
+    for (const arr of solidChildren.values()) arr.sort((a, b) => a - b);
+    const color = /* @__PURE__ */ new Map();
+    const seenCycles = /* @__PURE__ */ new Set();
+    const dfs = (start) => {
+      const stack = [{ id: start, nextChild: 0 }];
+      color.set(start, 1);
+      while (stack.length > 0) {
+        const frame = stack[stack.length - 1];
+        const children = solidChildren.get(frame.id) ?? [];
+        if (frame.nextChild >= children.length) {
+          color.set(frame.id, 2);
+          stack.pop();
+          continue;
+        }
+        const child = children[frame.nextChild];
+        frame.nextChild += 1;
+        const c = color.get(child) ?? 0;
+        if (c === 1) {
+          const from = stack.findIndex((f) => f.id === child);
+          const cycle = stack.slice(from).map((f) => f.id);
+          const minIdx = cycle.indexOf(Math.min(...cycle));
+          const rotated = [...cycle.slice(minIdx), ...cycle.slice(0, minIdx)];
+          const key = rotated.join(">");
+          if (!seenCycles.has(key)) {
+            seenCycles.add(key);
+            push("cycle", `cycle: ${[...rotated, rotated[0]].join(" \u2192 ")}`);
+          }
+        } else if (c === 0) {
+          color.set(child, 1);
+          stack.push({ id: child, nextChild: 0 });
+        }
+      }
+    };
+    for (const p of [...positionById.values()].sort((a, b) => a.id - b.id)) {
+      if ((color.get(p.id) ?? 0) === 0) dfs(p.id);
+    }
+  }
+  return sortIssues(issues);
+}
+function validateOrgChart(input) {
+  const issues = orgChartIssues(input);
+  if (issues.length > 0) throw new OrgChartValidationError(issues);
+}
+
+// src/core/xml.ts
+function xmlEscape(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+
+// src/core/geometry.ts
+function pathData(points) {
+  return points.map((p, i) => `${i === 0 ? "M" : "L"} ${p.x} ${p.y}`).join(" ");
+}
+
+// src/core/text.ts
+var CHAR_W = 0.6;
+function estimateTextWidth(text, fontPx) {
+  return text.length * fontPx * CHAR_W;
+}
+function wrapLabel(label, perLine, maxLines = 2) {
+  if (label.length <= perLine) return [label];
+  const cap = (s) => s.length > perLine ? s.slice(0, Math.max(1, perLine - 1)) + "\u2026" : s;
+  const lines = [""];
+  for (const word of label.split(/\s+/)) {
+    const last = lines.length - 1;
+    const current = lines[last];
+    if (current === "" || (current + " " + word).length <= perLine) {
+      lines[last] = current === "" ? word : `${current} ${word}`;
+    } else if (lines.length < maxLines) {
+      lines.push(word);
+    } else {
+      lines[last] = `${current} ${word}`;
+    }
+  }
+  if (lines.length > 1 && lines[lines.length - 1] === "") lines.pop();
+  return lines.map(cap);
+}
+function wrapLabelBalanced(label, maxLines) {
+  const perLine = Math.min(26, Math.max(14, Math.ceil(label.length / 2) + 2));
+  return wrapLabel(label, perLine, maxLines);
+}
+function clampLabel(label, maxChars) {
+  if (maxChars === void 0 || label.length <= maxChars) return label;
+  return label.slice(0, Math.max(1, maxChars - 1)) + "\u2026";
+}
+var FONT_FAMILY = "Helvetica, Arial, sans-serif";
+
+// src/core/legend.ts
+var LEGEND_ROW_H = 18;
+var LEGEND_PAD = 16;
+var LEGEND_SWATCH_W = 22;
+var LEGEND_GAP = 14;
+var LEGEND_FONT = 11;
+var LEGEND_TEXT_FILL = "#52525b";
+function legendBlock(entries, startY) {
+  if (entries.length === 0) return { svg: "", width: 0, height: startY };
+  const rows = entries.map((entry, i) => {
+    const rowCenterY = startY + i * LEGEND_ROW_H + LEGEND_ROW_H / 2;
+    const textX = LEGEND_PAD + LEGEND_SWATCH_W + LEGEND_GAP;
+    return entry.swatch(LEGEND_PAD, rowCenterY) + `<text x="${textX}" y="${rowCenterY + LEGEND_FONT * 0.32}" font-family="${FONT_FAMILY}" font-size="${LEGEND_FONT}" fill="${LEGEND_TEXT_FILL}">${xmlEscape(entry.label)}</text>`;
+  });
+  const widestLabel = entries.reduce((m, e) => Math.max(m, estimateTextWidth(e.label, LEGEND_FONT)), 0);
+  return {
+    svg: `<g data-compasso-legend="true">${rows.join("")}</g>`,
+    width: LEGEND_PAD + LEGEND_SWATCH_W + LEGEND_GAP + widestLabel + LEGEND_PAD,
+    height: startY + entries.length * LEGEND_ROW_H + LEGEND_PAD / 2
+  };
+}
+
+// src/core/stroke.ts
+var EDGE_STROKE = {
+  distant: { width: 1.5, dash: [4, 4], opacity: 0.55 }};
+
+// src/org-chart/layout.ts
+var ORG_LABEL_FONT = 12;
+var ORG_TITLE_FONT = 10;
+var ORG_LABEL_LINE_H = 14;
+var PADDING = 32;
+var ORG_SIBLING_GAP = 28;
+var ORG_TREE_GAP = 56;
+var ORG_CORRIDOR = 30;
+var ORG_MIN_BOX_W = 120;
+var ORG_BOX_PAD_X = 12;
+var ORG_BOX_PAD_Y = 9;
+var ORG_ASSIST_GAP = 24;
+var ORG_ASSIST_BAND_DROP = 14;
+var ORG_MATRIX_GUTTER_GAP = 28;
+var ORG_MATRIX_LANE_PITCH = 14;
+var ORG_MATRIX_ESCAPE_STEP = 2;
+var ORG_STEM_ID_BASE = 1e6;
+var ORG_BUS_ID_BASE = 2e6;
+var ORG_DROP_ID_BASE = 3e6;
+var ORG_ASSIST_ID_BASE = 4e6;
+var ORG_DOTTED_ID_BASE = 5e6;
+var round = (n) => Math.round(n * 100) / 100;
+var drawnLeftEdge = (cx, boxW) => round(round(cx) - round(boxW) / 2);
+var drawnRightEdge = (cx, boxW) => drawnLeftEdge(cx, boxW) + round(boxW);
+function packSubtree(node, gaps) {
+  const { ownHalfL, ownHalfR, children } = node;
+  if (children.length === 0) {
+    return { halfL: ownHalfL, halfR: ownHalfR, offsets: [] };
+  }
+  const xs = [0];
+  for (let i = 1; i < children.length; i++) {
+    xs.push(xs[i - 1] + children[i - 1].halfR + gaps.siblingGap + children[i].halfL);
+  }
+  const first = children[0];
+  const last = children[children.length - 1];
+  const axis = (xs[0] + xs[xs.length - 1]) / 2;
+  const offsets = xs.map((x) => x - axis);
+  const halfL = Math.max(ownHalfL, axis - (xs[0] - first.halfL));
+  const halfR = Math.max(ownHalfR, xs[xs.length - 1] + last.halfR - axis);
+  return { halfL, halfR, offsets };
+}
+function measurePosition(position, maxLabelChars, vacantWord) {
+  const nameLines = position.name === "" ? [] : wrapLabelBalanced(clampLabel(position.name, maxLabelChars), 2);
+  const titleLines = position.title === null ? [] : wrapLabelBalanced(clampLabel(position.title, maxLabelChars), 2);
+  const subtitleLines = position.subtitle === null ? [] : wrapLabelBalanced(clampLabel(position.subtitle, maxLabelChars), 1);
+  const vacantMarker = position.vacancy === "vacant" ? vacantWord : null;
+  let innerW = 0;
+  for (const l of nameLines) innerW = Math.max(innerW, estimateTextWidth(l, ORG_LABEL_FONT));
+  for (const l of titleLines) innerW = Math.max(innerW, estimateTextWidth(l, ORG_TITLE_FONT));
+  for (const l of subtitleLines) innerW = Math.max(innerW, estimateTextWidth(l, ORG_TITLE_FONT));
+  if (vacantMarker !== null) innerW = Math.max(innerW, estimateTextWidth(vacantMarker, ORG_TITLE_FONT));
+  const boxW = Math.max(ORG_MIN_BOX_W, innerW + ORG_BOX_PAD_X * 2);
+  const lineCount = nameLines.length + titleLines.length + subtitleLines.length + (vacantMarker !== null ? 1 : 0);
+  const boxH = ORG_BOX_PAD_Y * 2 + lineCount * ORG_LABEL_LINE_H;
+  return { boxW, boxH, nameLines, titleLines, subtitleLines, vacantMarker };
+}
+function positionTitle(position, vacantWord) {
+  if (position.hover !== void 0) return position.hover;
+  if (position.title !== null) {
+    return position.name === "" ? position.title : `${position.name} \u2014 ${position.title}`;
+  }
+  if (position.name !== "") return position.name;
+  return vacantWord;
+}
+function computeOrgChartLayout(input, opts = {}) {
+  if (input.positions.length === 0 && input.reports.length === 0) {
+    return { width: PADDING * 2, height: PADDING * 2, nodes: [], elements: [], rootPositionIds: [] };
+  }
+  validateOrgChart(input);
+  const titleLabels = opts.titleLabels ?? ORG_CHART_TITLE_LABELS_EN;
+  const vacantWord = titleLabels.vacant;
+  const positionById = new Map(input.positions.map((p) => [p.id, p]));
+  const reports = [...input.reports].sort((a, b) => a.id - b.id);
+  const solidReports = reports.filter((r) => r.kind !== "dotted");
+  const lineChildIds = /* @__PURE__ */ new Map();
+  const assistChildIds = /* @__PURE__ */ new Map();
+  const solidParentReportId = /* @__PURE__ */ new Set();
+  for (const r of solidReports) {
+    solidParentReportId.add(r.reportId);
+    const bucket = r.kind === "assistant" ? assistChildIds : lineChildIds;
+    const arr = bucket.get(r.managerId) ?? [];
+    arr.push(r);
+    bucket.set(r.managerId, arr);
+  }
+  for (const arr of lineChildIds.values()) arr.sort((a, b) => a.reportId - b.reportId);
+  for (const arr of assistChildIds.values()) arr.sort((a, b) => a.reportId - b.reportId);
+  const rootPositionIds = input.positions.map((p) => p.id).filter((id) => !solidParentReportId.has(id)).sort((a, b) => a - b);
+  const newInst = (position, depth, assistReport) => {
+    const m = measurePosition(position, opts.maxLabelChars, vacantWord);
+    return {
+      position,
+      m,
+      style: position.vacancy === "vacant" ? "dashed" : "solid",
+      title: positionTitle(position, vacantWord),
+      depth,
+      lineChildren: [],
+      assistants: [],
+      ownHalfL: m.boxW / 2,
+      ownHalfR: m.boxW / 2,
+      spanL: 0,
+      spanR: 0,
+      offsets: [],
+      cx: 0,
+      assistReport,
+      assistTop: 0
+    };
+  };
+  const allInsts = [];
+  const build = (positionId, depth, assistReport) => {
+    const position = positionById.get(positionId);
+    const inst = newInst(position, depth, assistReport);
+    allInsts.push(inst);
+    for (const r of assistChildIds.get(positionId) ?? []) {
+      const a = build(r.reportId, depth + 1, r);
+      inst.assistants.push({ inst: a, report: r });
+    }
+    for (const r of lineChildIds.get(positionId) ?? []) {
+      inst.lineChildren.push(build(r.reportId, depth + 1, null));
+    }
+    return inst;
+  };
+  const roots = rootPositionIds.map((id) => build(id, 0, null));
+  for (const inst of allInsts) {
+    if (inst.assistants.length > 0) {
+      const widest = inst.assistants.reduce((m, a) => Math.max(m, a.inst.m.boxW), 0);
+      inst.ownHalfL = inst.m.boxW / 2 + ORG_ASSIST_GAP + widest;
+    }
+  }
+  const gaps = { siblingGap: ORG_SIBLING_GAP };
+  const pack = (inst) => {
+    for (const c of inst.lineChildren) pack(c);
+    const result = packSubtree(
+      {
+        ownHalfL: inst.ownHalfL,
+        ownHalfR: inst.ownHalfR,
+        children: inst.lineChildren.map((c) => ({ halfL: c.spanL, halfR: c.spanR }))
+      },
+      gaps
+    );
+    inst.spanL = result.halfL;
+    inst.spanR = result.halfR;
+    inst.offsets = result.offsets;
+  };
+  for (const root of roots) pack(root);
+  let cursor = PADDING;
+  for (const root of roots) {
+    root.cx = cursor + root.spanL;
+    const placeX = (inst) => {
+      inst.lineChildren.forEach((c, i) => {
+        c.cx = inst.cx + inst.offsets[i];
+        placeX(c);
+      });
+    };
+    placeX(root);
+    cursor = root.cx + root.spanR + ORG_TREE_GAP;
+  }
+  const canvasRight = roots.length === 0 ? PADDING : cursor - ORG_TREE_GAP;
+  const rowInsts = [];
+  for (const inst of allInsts) (rowInsts[inst.depth] ??= []).push(inst);
+  const depthCount = rowInsts.length;
+  const assistStackH = (inst) => {
+    if (inst.assistants.length === 0) return 0;
+    return inst.assistants.reduce((s, a) => s + a.inst.m.boxH + ORG_ASSIST_BAND_DROP, 0) + ORG_ASSIST_BAND_DROP;
+  };
+  const rowH = [];
+  for (let d = 0; d < depthCount; d++) {
+    const lineBoxes = (rowInsts[d] ?? []).filter((i) => i.assistReport === null);
+    rowH.push(lineBoxes.reduce((m, i) => Math.max(m, i.m.boxH), 0));
+  }
+  const assistZone = [];
+  for (let d = 0; d < depthCount; d++) {
+    let tallest = 0;
+    for (const inst of rowInsts[d] ?? []) tallest = Math.max(tallest, assistStackH(inst));
+    assistZone.push(tallest);
+  }
+  const rowTop = [PADDING];
+  for (let d = 0; d < depthCount - 1; d++) {
+    rowTop.push(rowTop[d] + rowH[d] + assistZone[d] + ORG_CORRIDOR);
+  }
+  const busY = (d) => rowTop[d + 1] - ORG_CORRIDOR / 2;
+  const last = depthCount - 1;
+  const height = Math.ceil(rowTop[last] + rowH[last] + assistZone[last] + PADDING);
+  const nodes = [];
+  const elements = [];
+  const reportTitle = (kind, label) => {
+    const word = titleLabels.reportKinds[kind];
+    return label !== null && label !== void 0 ? `${word} \xB7 ${label}` : word;
+  };
+  const pushNode = (inst) => {
+    nodes.push({
+      positionId: inst.position.id,
+      cx: round(inst.cx),
+      top: round(rowTop[inst.depth]),
+      boxW: round(inst.m.boxW),
+      boxH: round(inst.m.boxH),
+      style: inst.style,
+      nameLines: inst.m.nameLines,
+      titleLines: inst.m.titleLines,
+      subtitleLines: inst.m.subtitleLines,
+      vacantMarker: inst.m.vacantMarker,
+      isAssistant: inst.assistReport !== null,
+      depth: inst.depth,
+      title: inst.title
+    });
+  };
+  const emit = (inst) => {
+    const d = inst.depth;
+    let bandY = rowTop[d] + rowH[d] + ORG_ASSIST_BAND_DROP;
+    for (const { inst: a, report } of inst.assistants) {
+      const assistRight = inst.cx - ORG_ASSIST_GAP;
+      a.cx = assistRight - a.m.boxW / 2;
+      const assistTop = bandY;
+      a.assistTop = assistTop;
+      const assistMidY = assistTop + a.m.boxH / 2;
+      nodes.push({
+        positionId: a.position.id,
+        cx: round(a.cx),
+        top: round(assistTop),
+        boxW: round(a.m.boxW),
+        boxH: round(a.m.boxH),
+        style: a.style,
+        nameLines: a.m.nameLines,
+        titleLines: a.m.titleLines,
+        subtitleLines: a.m.subtitleLines,
+        vacantMarker: a.m.vacantMarker,
+        isAssistant: true,
+        depth: a.depth,
+        title: a.title
+      });
+      elements.push({
+        edgeId: ORG_ASSIST_ID_BASE + report.reportId,
+        kind: "assist",
+        points: [
+          { x: round(inst.cx), y: round(assistMidY) },
+          { x: drawnRightEdge(a.cx, a.m.boxW), y: round(assistMidY) }
+        ],
+        dashed: false,
+        title: reportTitle("assistant", report.label)
+      });
+      bandY += a.m.boxH + ORG_ASSIST_BAND_DROP;
+    }
+    pushNode(inst);
+    if (inst.lineChildren.length === 0) return;
+    const by = busY(d);
+    const boxBottom = rowTop[d] + inst.m.boxH;
+    elements.push({
+      edgeId: ORG_STEM_ID_BASE + inst.position.id,
+      kind: "stem",
+      points: [
+        { x: round(inst.cx), y: round(boxBottom) },
+        { x: round(inst.cx), y: round(by) }
+      ],
+      dashed: false,
+      title: reportTitle("line", null)
+    });
+    const childCxs = inst.lineChildren.map((c) => c.cx);
+    if (inst.lineChildren.length > 1) {
+      elements.push({
+        edgeId: ORG_BUS_ID_BASE + inst.position.id,
+        kind: "bus",
+        points: [
+          { x: round(Math.min(...childCxs)), y: round(by) },
+          { x: round(Math.max(...childCxs)), y: round(by) }
+        ],
+        dashed: false,
+        title: reportTitle("line", null)
+      });
+    }
+    for (const c of inst.lineChildren) {
+      elements.push({
+        edgeId: ORG_DROP_ID_BASE + c.position.id,
+        kind: "drop",
+        points: [
+          { x: round(c.cx), y: round(by) },
+          { x: round(c.cx), y: round(rowTop[c.depth]) }
+        ],
+        dashed: false,
+        title: reportTitle("line", null)
+      });
+    }
+    for (const c of inst.lineChildren) emit(c);
+  };
+  for (const root of roots) emit(root);
+  const instByPos = new Map(allInsts.map((i) => [i.position.id, i]));
+  const escapeByPos = /* @__PURE__ */ new Map();
+  for (const inst of allInsts) {
+    const isAssist = inst.assistReport !== null;
+    const boxTop = isAssist ? inst.assistTop : rowTop[inst.depth];
+    const leftEdge = drawnLeftEdge(inst.cx, inst.m.boxW);
+    const rightEdge = drawnRightEdge(inst.cx, inst.m.boxW);
+    if (isAssist) {
+      const managerInst = instByPos.get(inst.assistReport.managerId);
+      escapeByPos.set(inst.position.id, {
+        side: -1,
+        boxEdge: leftEdge,
+        escCol: managerInst.cx - managerInst.spanL,
+        midY: boxTop + inst.m.boxH / 2,
+        boxH: inst.m.boxH
+      });
+    } else {
+      escapeByPos.set(inst.position.id, {
+        side: 1,
+        boxEdge: rightEdge,
+        escCol: inst.cx + inst.spanR,
+        midY: boxTop + inst.m.boxH / 2,
+        boxH: inst.m.boxH
+      });
+    }
+  }
+  const nodeById = new Map(nodes.map((n) => [n.positionId, n]));
+  const dottedReports = reports.filter(
+    (r) => r.kind === "dotted" && nodeById.has(r.managerId) && nodeById.has(r.reportId) && r.managerId !== r.reportId
+  );
+  let maxBoxBottom = PADDING;
+  for (const n of nodes) maxBoxBottom = Math.max(maxBoxBottom, n.top + n.boxH);
+  let laneCount = 0;
+  let channelLanes = 0;
+  if (dottedReports.length > 0) {
+    const laneOf = /* @__PURE__ */ new Map();
+    laneCount = allocateLanes(
+      dottedReports.map((r) => {
+        const rep = escapeByPos.get(r.reportId);
+        const mgr = escapeByPos.get(r.managerId);
+        return {
+          lo: Math.min(rep.midY, mgr.midY),
+          hi: Math.max(rep.midY, mgr.midY),
+          set: (lane) => laneOf.set(r.id, lane)
+        };
+      })
+    );
+    channelLanes = dottedReports.length * 2;
+    const channelTop = maxBoxBottom + ORG_MATRIX_GUTTER_GAP;
+    const exitSlot = /* @__PURE__ */ new Map();
+    const nextExitY = (posId, mid, boxH) => {
+      const slot = exitSlot.get(posId) ?? 0;
+      exitSlot.set(posId, slot + 1);
+      if (slot === 0) return mid;
+      const step = Math.min(6, Math.max(2, (boxH / 2 - 6) / Math.max(1, Math.ceil(slot / 2))));
+      const sign = slot % 2 === 1 ? -1 : 1;
+      return mid + sign * Math.ceil(slot / 2) * step;
+    };
+    const geoms = dottedReports.map((r, i) => {
+      const rep = escapeByPos.get(r.reportId);
+      const mgr = escapeByPos.get(r.managerId);
+      return {
+        r,
+        i,
+        repMidY: round(nextExitY(r.reportId, rep.midY, rep.boxH)),
+        mgrMidY: round(nextExitY(r.managerId, mgr.midY, mgr.boxH)),
+        repBoxEdge: round(rep.boxEdge),
+        mgrBoxEdge: round(mgr.boxEdge),
+        repChY: round(channelTop + 2 * i * ORG_MATRIX_LANE_PITCH),
+        mgrChY: round(channelTop + (2 * i + 1) * ORG_MATRIX_LANE_PITCH),
+        laneX: round(canvasRight + ORG_MATRIX_GUTTER_GAP + laneOf.get(r.id) * ORG_MATRIX_LANE_PITCH),
+        repEscX: 0,
+        mgrEscX: 0
+      };
+    });
+    const verts = [];
+    for (const g of geoms) {
+      const rep = escapeByPos.get(g.r.reportId);
+      const mgr = escapeByPos.get(g.r.managerId);
+      verts.push({
+        escCol: rep.escCol,
+        side: rep.side,
+        lo: Math.min(g.repMidY, g.repChY),
+        hi: Math.max(g.repMidY, g.repChY),
+        assign: (x) => g.repEscX = x
+      });
+      verts.push({
+        escCol: mgr.escCol,
+        side: mgr.side,
+        lo: Math.min(g.mgrMidY, g.mgrChY),
+        hi: Math.max(g.mgrMidY, g.mgrChY),
+        assign: (x) => g.mgrEscX = x
+      });
+    }
+    const VERT_EPS = 0.01;
+    const ordered = verts.map((v, idx) => ({ v, key: geoms[Math.floor(idx / 2)].r.id * 2 + idx % 2 })).sort((a, b) => a.key - b.key).map((e) => e.v);
+    const placed = [];
+    const yOverlap = (aLo, aHi, bLo, bHi) => Math.min(aHi, bHi) - Math.max(aLo, bLo) > VERT_EPS;
+    for (const v of ordered) {
+      let band = v.side === 1 ? Math.max(canvasRight - v.escCol, ORG_MATRIX_GUTTER_GAP) : v.escCol;
+      for (const n of nodes) {
+        const bLeft = n.cx - n.boxW / 2;
+        const bRight = n.cx + n.boxW / 2;
+        if (n.top + n.boxH <= v.lo + VERT_EPS || n.top >= v.hi - VERT_EPS) continue;
+        if (v.side === 1 && bLeft > v.escCol + VERT_EPS) band = Math.min(band, bLeft - v.escCol);
+        else if (v.side === -1 && bRight < v.escCol - VERT_EPS) band = Math.min(band, v.escCol - bRight);
+      }
+      let lane = 0;
+      let candidate = round(v.escCol);
+      while (placed.some((p) => Math.abs(p.x - candidate) < VERT_EPS && yOverlap(p.lo, p.hi, v.lo, v.hi))) {
+        lane += 1;
+        candidate = round(v.escCol + v.side * lane * ORG_MATRIX_ESCAPE_STEP);
+      }
+      if (lane > 0 && lane * ORG_MATRIX_ESCAPE_STEP >= band - VERT_EPS) {
+        throw new Error(
+          `org-chart: escape-column-overflow \u2014 escape vertical nudged ${lane * ORG_MATRIX_ESCAPE_STEP}px from its base column exceeds the ${round(band)}px box-free band`
+        );
+      }
+      placed.push({ x: candidate, lo: v.lo, hi: v.hi });
+      v.assign(candidate);
+    }
+    for (const g of geoms) {
+      elements.push({
+        edgeId: ORG_DOTTED_ID_BASE + g.r.id,
+        kind: "dotted",
+        points: collapseDegenerate([
+          { x: g.repBoxEdge, y: g.repMidY },
+          // out the report box's edge
+          { x: g.repEscX, y: g.repMidY },
+          // → box-free escape column (in own gutter lane)
+          { x: g.repEscX, y: g.repChY },
+          // → down into the bottom traverse channel
+          { x: g.laneX, y: g.repChY },
+          // → across (below all boxes) to the right gutter lane
+          { x: g.laneX, y: g.mgrChY },
+          // → down the right gutter (right of every box)
+          { x: g.mgrEscX, y: g.mgrChY },
+          // → back across (below all boxes) to the manager column
+          { x: g.mgrEscX, y: g.mgrMidY },
+          // → up the box-free escape column
+          { x: g.mgrBoxEdge, y: g.mgrMidY }
+          // → into the manager box's edge
+        ]),
+        dashed: true,
+        title: reportTitle("dotted", g.r.label)
+      });
+    }
+  }
+  const width = dottedReports.length > 0 ? Math.ceil(canvasRight + ORG_MATRIX_GUTTER_GAP + (laneCount - 1) * ORG_MATRIX_LANE_PITCH + ORG_MATRIX_GUTTER_GAP + PADDING) : Math.ceil(canvasRight + PADDING);
+  const finalHeight = channelLanes > 0 ? Math.ceil(maxBoxBottom + ORG_MATRIX_GUTTER_GAP + (channelLanes - 1) * ORG_MATRIX_LANE_PITCH + PADDING) : height;
+  return { width, height: finalHeight, nodes, elements, rootPositionIds };
+}
+function collapseDegenerate(points) {
+  const out = [];
+  for (const p of points) {
+    const prev = out[out.length - 1];
+    if (prev === void 0 || prev.x !== p.x || prev.y !== p.y) out.push(p);
+  }
+  return out;
+}
+function allocateLanes(items) {
+  const lanes = [];
+  for (const it of items) {
+    let chosen = -1;
+    for (let l = 0; l < lanes.length; l++) {
+      if (lanes[l].every((o) => it.hi <= o.lo || it.lo >= o.hi)) {
+        chosen = l;
+        break;
+      }
+    }
+    if (chosen === -1) {
+      chosen = lanes.length;
+      lanes.push([]);
+    }
+    lanes[chosen].push({ lo: it.lo, hi: it.hi });
+    it.set(chosen);
+  }
+  return lanes.length;
+}
+
+// src/org-chart/svg.ts
+var GLYPH_STROKE = "#52525b";
+var LABEL_FILL = "#3f3f46";
+var EDGE_INK = "#71717a";
+var GLYPH_ATTRS = `fill="transparent" stroke="${GLYPH_STROKE}" stroke-width="2"`;
+var VACANT_DASH = `stroke-dasharray="6,4"`;
+var DOTTED = EDGE_STROKE.distant;
+var round2 = (n) => Math.round(n * 100) / 100;
+var ORG_BOX_PAD_Y2 = 9;
+function boxSvg(n) {
+  const left = round2(n.cx - n.boxW / 2);
+  const pieces = [`<title>${xmlEscape(n.title)}</title>`];
+  if (n.style === "dashed") {
+    pieces.push(
+      `<rect x="${left}" y="${n.top}" width="${n.boxW}" height="${n.boxH}" rx="2" ${GLYPH_ATTRS} ${VACANT_DASH}/>`
+    );
+    const ix = round2(left + 3);
+    const iy = round2(n.top + 3);
+    const iw = round2(n.boxW - 6);
+    const ih = round2(n.boxH - 6);
+    pieces.push(`<rect x="${ix}" y="${iy}" width="${iw}" height="${ih}" rx="2" ${GLYPH_ATTRS} ${VACANT_DASH}/>`);
+  } else {
+    pieces.push(`<rect x="${left}" y="${n.top}" width="${n.boxW}" height="${n.boxH}" rx="2" ${GLYPH_ATTRS}/>`);
+  }
+  let lineIndex = 0;
+  const firstBaseline = (i) => round2(n.top + ORG_BOX_PAD_Y2 + ORG_LABEL_LINE_H / 2 + i * ORG_LABEL_LINE_H + ORG_LABEL_FONT * 0.32);
+  const textBlock = (lines, font) => {
+    if (lines.length === 0) return "";
+    const tspans = lines.map((line, i) => `<tspan x="${n.cx}" y="${firstBaseline(lineIndex + i)}">${xmlEscape(line)}</tspan>`).join("");
+    lineIndex += lines.length;
+    return `<text text-anchor="middle" font-family="${FONT_FAMILY}" font-size="${font}" fill="${LABEL_FILL}">${tspans}</text>`;
+  };
+  pieces.push(textBlock(n.nameLines, ORG_LABEL_FONT));
+  pieces.push(textBlock(n.titleLines, ORG_TITLE_FONT));
+  pieces.push(textBlock(n.subtitleLines, ORG_TITLE_FONT));
+  if (n.vacantMarker !== null) pieces.push(textBlock([n.vacantMarker], ORG_TITLE_FONT));
+  return `<g data-node-id="p${n.positionId}">${pieces.filter((p) => p !== "").join("")}</g>`;
+}
+function elementSvg(el) {
+  const head = `<g data-edge-id="${el.edgeId}"><title>${xmlEscape(el.title)}</title>`;
+  if (el.dashed) {
+    const dash = DOTTED.dash === null ? "" : ` stroke-dasharray="${DOTTED.dash[0]},${DOTTED.dash[1]}"`;
+    return head + `<path d="${pathData(el.points)}" fill="none" stroke="${EDGE_INK}" stroke-width="${DOTTED.width}" stroke-opacity="${DOTTED.opacity}"${dash}/></g>`;
+  }
+  if (el.points.length === 2) {
+    const a = el.points[0];
+    const b = el.points[1];
+    return head + `<line x1="${a.x}" y1="${a.y}" x2="${b.x}" y2="${b.y}" stroke="${EDGE_INK}" stroke-width="1.5" stroke-opacity="0.75"/></g>`;
+  }
+  return head + `<path d="${pathData(el.points)}" fill="none" stroke="${EDGE_INK}" stroke-width="1.5" stroke-opacity="0.75"/></g>`;
+}
+var MINI_ATTRS = `fill="transparent" stroke="${GLYPH_STROKE}" stroke-width="1.5"`;
+function lineSwatch(x, y) {
+  const x1 = round2(x + 2);
+  const x2 = round2(x + LEGEND_SWATCH_W - 2);
+  return `<line x1="${x1}" y1="${y}" x2="${x2}" y2="${y}" stroke="${EDGE_INK}" stroke-width="1.5" stroke-opacity="0.75"/>`;
+}
+function assistantSwatch(x, y) {
+  const stemX = round2(x + LEGEND_SWATCH_W - 4);
+  const boxX = round2(x + 1);
+  return `<line x1="${stemX}" y1="${round2(y - 4)}" x2="${stemX}" y2="${y}" stroke="${EDGE_INK}" stroke-width="1.5" stroke-opacity="0.75"/><line x1="${stemX}" y1="${y}" x2="${round2(boxX + 8)}" y2="${y}" stroke="${EDGE_INK}" stroke-width="1.5" stroke-opacity="0.75"/><rect x="${boxX}" y="${round2(y - 3.5)}" width="8" height="7" rx="1" ${MINI_ATTRS}/>`;
+}
+function dottedSwatch(x, y) {
+  const x1 = round2(x + 2);
+  const x2 = round2(x + LEGEND_SWATCH_W - 2);
+  const dash = DOTTED.dash === null ? "" : ` stroke-dasharray="${DOTTED.dash[0]},${DOTTED.dash[1]}"`;
+  return `<line x1="${x1}" y1="${y}" x2="${x2}" y2="${y}" stroke="${EDGE_INK}" stroke-width="${DOTTED.width}" stroke-opacity="${DOTTED.opacity}"${dash}/>`;
+}
+function vacantSwatch(x, y) {
+  const cx = round2(x + LEGEND_SWATCH_W / 2);
+  const bx = round2(cx - 8);
+  const by = round2(y - 5);
+  return `<rect x="${bx}" y="${by}" width="16" height="10" rx="1" ${MINI_ATTRS} stroke-dasharray="3,2"/><rect x="${round2(bx + 2)}" y="${round2(by + 2)}" width="12" height="6" rx="1" ${MINI_ATTRS} stroke-dasharray="3,2"/>`;
+}
+function orgChartLayoutSvg(layout, opts = {}) {
+  const labels = opts.labels ?? ORG_CHART_SVG_LABELS_EN;
+  const parts = [];
+  for (const el of layout.elements) parts.push(elementSvg(el));
+  for (const n of layout.nodes) parts.push(boxSvg(n));
+  let width = layout.width;
+  let height = layout.height;
+  if (opts.legend !== false && layout.nodes.length > 0) {
+    const hasSolid = layout.elements.some((e) => e.kind === "stem" || e.kind === "bus" || e.kind === "drop");
+    const hasAssistant = layout.nodes.some((n) => n.isAssistant);
+    const hasDotted = layout.elements.some((e) => e.kind === "dotted");
+    const hasVacant = layout.nodes.some((n) => n.style === "dashed");
+    const entries = [];
+    if (hasSolid) entries.push({ swatch: lineSwatch, label: labels.legend.line });
+    if (hasAssistant) entries.push({ swatch: assistantSwatch, label: labels.legend.assistant });
+    if (hasDotted) entries.push({ swatch: dottedSwatch, label: labels.legend.dotted });
+    if (hasVacant) entries.push({ swatch: vacantSwatch, label: labels.legend.vacant });
+    const block = legendBlock(entries, layout.height);
+    if (block.svg !== "") {
+      parts.push(block.svg);
+      width = Math.max(width, block.width);
+      height = block.height;
+    }
+  }
+  const w = Math.ceil(width);
+  const h = Math.ceil(height);
+  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${w} ${h}" width="${w}" height="${h}" role="img" aria-label="${xmlEscape(labels.ariaLabel)}">` + parts.join("") + `</svg>`;
+}
+
+// src/org-chart/render.ts
+function orgChartSvg(input, opts = {}) {
+  const layout = computeOrgChartLayout(input, {
+    ...opts.maxLabelChars !== void 0 ? { maxLabelChars: opts.maxLabelChars } : {},
+    ...opts.titleLabels !== void 0 ? { titleLabels: opts.titleLabels } : {}
+  });
+  const svg = orgChartLayoutSvg(layout, {
+    ...opts.legend === false ? { legend: false } : {},
+    ...opts.svgLabels !== void 0 ? { labels: opts.svgLabels } : {}
+  });
+  return { svg, layout };
+}
+
+exports.ORG_ASSIST_ID_BASE = ORG_ASSIST_ID_BASE;
+exports.ORG_BUS_ID_BASE = ORG_BUS_ID_BASE;
+exports.ORG_CHART_SVG_LABELS_EN = ORG_CHART_SVG_LABELS_EN;
+exports.ORG_CHART_TITLE_LABELS_EN = ORG_CHART_TITLE_LABELS_EN;
+exports.ORG_DOTTED_ID_BASE = ORG_DOTTED_ID_BASE;
+exports.ORG_DROP_ID_BASE = ORG_DROP_ID_BASE;
+exports.ORG_LABEL_FONT = ORG_LABEL_FONT;
+exports.ORG_LABEL_LINE_H = ORG_LABEL_LINE_H;
+exports.ORG_MAX_MATRIX_EDGES_PER_NODE = ORG_MAX_MATRIX_EDGES_PER_NODE;
+exports.ORG_REPORT_KINDS = ORG_REPORT_KINDS;
+exports.ORG_STEM_ID_BASE = ORG_STEM_ID_BASE;
+exports.ORG_TITLE_FONT = ORG_TITLE_FONT;
+exports.ORG_VACANCIES = ORG_VACANCIES;
+exports.OrgChartValidationError = OrgChartValidationError;
+exports.computeOrgChartLayout = computeOrgChartLayout;
+exports.estimateTextWidth = estimateTextWidth;
+exports.orgChartIssues = orgChartIssues;
+exports.orgChartLayoutSvg = orgChartLayoutSvg;
+exports.orgChartSvg = orgChartSvg;
+exports.packSubtree = packSubtree;
+exports.validateOrgChart = validateOrgChart;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map