schematex 0.2.2 → 0.2.4

package/dist/{chunk-Z3WOHHG3.js → chunk-J2LVOWVY.js}

@@ -3,14 +3,16 @@ import { text, title, desc, el, defs, group, svgRoot, rect, path, polygon, circl
 
 // src/diagrams/flowchart/parser.ts
 var FlowchartParseError = class extends Error {
-  constructor(message, line2, col) {
-    super(`[line ${line2}:${col}] ${message}`);
+  constructor(message, line2, column, source) {
+    super(`[line ${line2}:${column}] ${message}`);
     this.line = line2;
-    this.col = col;
+    this.column = column;
+    this.source = source;
     this.name = "FlowchartParseError";
   }
   line;
-  col;
+  column;
+  source;
 };
 var DIRECTIONS = /* @__PURE__ */ new Set(["TB", "TD", "BT", "LR", "RL"]);
 function parseShapeSuffix(line2, pos) {
@@ -711,13 +713,53 @@ var FC_CONST = {
   // flow-direction gap between layers
   dummyWidth: 1,
   padding: 24,
+  /** Latin/digit avg width at 12px font. CJK uses cjkCharWidth instead. */
   charWidth: 6.8,
-  // approx font-size 12 proportional width
+  /** Full-width glyph width at 12px (CJK ideograph, kana, hangul, fullwidth). */
+  cjkCharWidth: 12.5,
   labelHPad: 16,
   minNodeWidth: 72,
-  maxLabelWidth: 220,
+  /**
+   * Cap on per-line label width. Until line-wrapping lands, this clamp is
+   * a soft contract: nodes never grow past this, and any overflow becomes
+   * the caller's problem. Set generously so common CJK sentences (≤30
+   * full-width chars) still fit without truncation or text overflow.
+   */
+  maxLabelWidth: 420,
   crossingSweepIters: 24
 };
+var SHAPE_SLANT = {
+  parallelogram: 20,
+  trapezoid: 16
+};
+var CLUSTER_GEO = {
+  pad: 24,
+  titleH: 20,
+  /** Extra visible separation between two sequential cluster bboxes. */
+  gap: 12
+};
+function isFullWidth(code) {
+  if (code >= 12288 && code <= 12351) return true;
+  if (code >= 12352 && code <= 12447) return true;
+  if (code >= 12448 && code <= 12543) return true;
+  if (code >= 13312 && code <= 19903) return true;
+  if (code >= 19968 && code <= 40959) return true;
+  if (code >= 44032 && code <= 55215) return true;
+  if (code >= 63744 && code <= 64255) return true;
+  if (code >= 65280 && code <= 65376) return true;
+  if (code >= 65504 && code <= 65510) return true;
+  if (code >= 131072 && code <= 196607) return true;
+  return false;
+}
+function measureLabelWidth(label) {
+  let w = 0;
+  for (const ch of label) {
+    const code = ch.codePointAt(0) ?? 0;
+    if (isFullWidth(code)) w += FC_CONST.cjkCharWidth;
+    else w += FC_CONST.charWidth;
+  }
+  return w;
+}
 function greedyFAS(nodeIds, edges) {
   const outAdj = /* @__PURE__ */ new Map();
   const inAdj = /* @__PURE__ */ new Map();
@@ -1036,6 +1078,46 @@ function laneBasedXCoords(layerNodes, pathOf, nodeSpacingX, segments) {
       }
     }
   }
+  const clusterLanes = laneOrder.filter((l) => l !== null);
+  if (clusterLanes.length >= 2 && laneOrder.includes(null)) {
+    const tmpPartition = layerNodes.map(
+      (layer) => {
+        const m = /* @__PURE__ */ new Map();
+        for (const n of layer) {
+          if (n.isDummy) continue;
+          const lane = laneOf(n.id);
+          if (!m.has(lane)) m.set(lane, []);
+          m.get(lane).push(n);
+        }
+        return m;
+      }
+    );
+    const clusterOccupiedLayers = /* @__PURE__ */ new Set();
+    for (let li = 0; li < tmpPartition.length; li++) {
+      for (const lane of clusterLanes) {
+        if ((tmpPartition[li].get(lane) ?? []).length > 0) {
+          clusterOccupiedLayers.add(li);
+        }
+      }
+    }
+    let nullIsBoundary = true;
+    for (let li = 0; li < tmpPartition.length; li++) {
+      const nm = tmpPartition[li].get(null) ?? [];
+      if (nm.length > 0 && clusterOccupiedLayers.has(li)) {
+        nullIsBoundary = false;
+        break;
+      }
+    }
+    if (nullIsBoundary) {
+      const mid = Math.floor(clusterLanes.length / 2);
+      laneOrder.length = 0;
+      laneOrder.push(
+        ...clusterLanes.slice(0, mid),
+        null,
+        ...clusterLanes.slice(mid)
+      );
+    }
+  }
   const lanesPerLayer = layerNodes.map(
     (layer) => {
       const m = /* @__PURE__ */ new Map();
@@ -1110,22 +1192,52 @@ function laneBasedXCoords(layerNodes, pathOf, nodeSpacingX, segments) {
   }
   return result;
 }
+function hasOverlappingTopLevelClusters(ast, layerMap, sgParent) {
+  const topLevel = ast.subgraphs.filter((sg) => !sgParent.get(sg.id));
+  if (topLevel.length < 2) return false;
+  const collect = (sgId) => {
+    const sg = ast.subgraphs.find((s) => s.id === sgId);
+    if (!sg) return [];
+    const ids = [...sg.children];
+    for (const childSgId of sg.subgraphs) ids.push(...collect(childSgId));
+    return ids;
+  };
+  const ranges = topLevel.map((sg) => {
+    const ids = collect(sg.id);
+    if (ids.length === 0) return { min: 0, max: -1 };
+    const layers = ids.map((id) => layerMap.get(id) ?? 0);
+    return { min: Math.min(...layers), max: Math.max(...layers) };
+  });
+  for (let i = 0; i < ranges.length; i++) {
+    for (let j = i + 1; j < ranges.length; j++) {
+      const a = ranges[i];
+      const b = ranges[j];
+      if (a.max < a.min || b.max < b.min) continue;
+      if (a.min <= b.max && b.min <= a.max) return true;
+    }
+  }
+  return false;
+}
 function layoutFlowchart(ast) {
   const dir = ast.direction;
   const isHorizontalDir = dir === "LR" || dir === "RL";
   const sizeOf = (n) => {
+    const rawTextW = measureLabelWidth(n.label);
     const labelW = Math.min(
       FC_CONST.maxLabelWidth,
-      Math.ceil(n.label.length * FC_CONST.charWidth) + FC_CONST.labelHPad * 2
+      Math.ceil(rawTextW) + FC_CONST.labelHPad * 2
     );
     let shapeW = Math.max(FC_CONST.minNodeWidth, labelW);
     let shapeH = FC_CONST.nodeHeight;
     if (n.shape === "diamond") {
-      shapeW = Math.max(shapeW, labelW * 1.25);
+      shapeW = Math.max(shapeW, labelW * 1.4);
       shapeH = Math.max(shapeH, 52);
     }
-    if (n.shape === "parallelogram" || n.shape === "parallelogram-alt" || n.shape === "trapezoid" || n.shape === "trapezoid-alt") {
-      shapeW += 20;
+    if (n.shape === "parallelogram" || n.shape === "parallelogram-alt") {
+      shapeW += 2 * SHAPE_SLANT.parallelogram + 8;
+    }
+    if (n.shape === "trapezoid" || n.shape === "trapezoid-alt") {
+      shapeW += 2 * SHAPE_SLANT.trapezoid + 8;
     }
     if (n.shape === "stadium" || n.shape === "round") {
       shapeW = Math.max(shapeW, shapeH + 20);
@@ -1136,7 +1248,10 @@ function layoutFlowchart(ast) {
       shapeH = side;
     }
     if (n.shape === "hexagon") {
-      shapeW = Math.max(shapeW, labelW + 44);
+      shapeW = Math.max(shapeW, labelW + 48);
+    }
+    if (n.shape === "asymmetric") {
+      shapeW += 24;
     }
     if (n.shape === "cylinder") {
       shapeH = Math.max(shapeH, 52);
@@ -1273,8 +1388,9 @@ function layoutFlowchart(ast) {
   const layerNodes = ordered.map(
     (layer) => layer.map((id) => lnodes.get(id))
   );
+  const useLane = ast.subgraphs.length > 0 && hasOverlappingTopLevelClusters(ast, layerMap, sgParent);
   let xMap;
-  if (ast.subgraphs.length > 0) {
+  if (useLane) {
     xMap = laneBasedXCoords(
       layerNodes,
       pathOf,
@@ -1288,7 +1404,6 @@ function layoutFlowchart(ast) {
     xMap = bkXCoords(bkLayers, segments, FC_CONST.nodeSpacingX);
   }
   const isHorizontal = dir === "LR" || dir === "RL";
-  const layerGap = FC_CONST.layerSpacingY;
   const layerHeights = layerNodes.map((layer) => {
     let maxH = 0;
     for (const n of layer) {
@@ -1298,17 +1413,56 @@ function layoutFlowchart(ast) {
     return maxH > 0 ? maxH : FC_CONST.nodeHeight;
   });
   const hasClusters = ast.subgraphs.length > 0;
-  const CLUSTER_OVERHEAD_TITLE = hasClusters ? 44 : 0;
-  const CLUSTER_OVERHEAD_SIDE = hasClusters ? 24 : 0;
+  const CLUSTER_OVERHEAD_TITLE = hasClusters ? CLUSTER_GEO.pad + CLUSTER_GEO.titleH : 0;
+  const CLUSTER_OVERHEAD_SIDE = hasClusters ? CLUSTER_GEO.pad : 0;
   const extraTopPad = isHorizontal ? CLUSTER_OVERHEAD_SIDE : CLUSTER_OVERHEAD_TITLE;
   const extraLeftPad = isHorizontal ? CLUSTER_OVERHEAD_TITLE : CLUSTER_OVERHEAD_SIDE;
+  const topLevelOf = (sgId) => {
+    let cur = sgId;
+    let safety = 32;
+    while (safety-- > 0) {
+      const p = sgParent.get(cur);
+      if (!p) return cur;
+      cur = p;
+    }
+    return cur;
+  };
+  const clustersAtLayer = layerNodes.map(() => /* @__PURE__ */ new Set());
+  for (let li = 0; li < layerNodes.length; li++) {
+    for (const n of layerNodes[li]) {
+      if (n.isDummy) continue;
+      const parent = parentOf.get(n.id);
+      if (!parent) continue;
+      clustersAtLayer[li].add(topLevelOf(parent));
+    }
+  }
+  const layerGapAt = (li) => {
+    const a = clustersAtLayer[li] ?? /* @__PURE__ */ new Set();
+    const b = clustersAtLayer[li + 1] ?? /* @__PURE__ */ new Set();
+    let hasExit = false;
+    for (const c of a) if (!b.has(c)) {
+      hasExit = true;
+      break;
+    }
+    let hasEntry = false;
+    for (const c of b) if (!a.has(c)) {
+      hasEntry = true;
+      break;
+    }
+    let required = 0;
+    if (hasExit) required += CLUSTER_GEO.pad;
+    if (hasEntry) required += CLUSTER_GEO.pad + CLUSTER_GEO.titleH;
+    if (hasExit && hasEntry) required += CLUSTER_GEO.gap;
+    return Math.max(FC_CONST.layerSpacingY, required);
+  };
   const layerCenterY = [];
   {
     let y = FC_CONST.padding + extraTopPad;
     for (let li = 0; li < layerHeights.length; li++) {
       y += layerHeights[li] / 2;
       layerCenterY.push(y);
-      y += layerHeights[li] / 2 + layerGap;
+      y += layerHeights[li] / 2;
+      if (li < layerHeights.length - 1) y += layerGapAt(li);
     }
   }
   let minX = Infinity;
@@ -1452,8 +1606,7 @@ function layoutFlowchart(ast) {
     }
     return 0;
   }
-  const CLUSTER_PAD = 24;
-  const CLUSTER_TITLE_H = 20;
+  const { pad: CLUSTER_PAD, titleH: CLUSTER_TITLE_H } = CLUSTER_GEO;
   const clusters = ast.subgraphs.map((sg) => {
     const memberIds = collectDescendantNodeIds(sg.id);
     const members = outNodes.filter((n) => memberIds.includes(n.node.id));
@@ -1554,23 +1707,23 @@ function shapeSVG(shape, w, h) {
       return polygon({ points, class: "sx-fc-node sx-fc-node-diamond" });
     }
     case "parallelogram": {
-      const slant = 20;
+      const slant = SHAPE_SLANT.parallelogram;
       const points = `${slant},0 ${w},0 ${w - slant},${h} 0,${h}`;
       return polygon({ points, class: "sx-fc-node" });
     }
     // ── M2 additional shapes ────────────────────────────────────
     case "parallelogram-alt": {
-      const slant = 20;
+      const slant = SHAPE_SLANT.parallelogram;
       const points = `0,0 ${w - slant},0 ${w},${h} ${slant},${h}`;
       return polygon({ points, class: "sx-fc-node" });
     }
     case "trapezoid": {
-      const slant = 16;
+      const slant = SHAPE_SLANT.trapezoid;
       const points = `0,0 ${w},0 ${w - slant},${h} ${slant},${h}`;
       return polygon({ points, class: "sx-fc-node" });
     }
     case "trapezoid-alt": {
-      const slant = 16;
+      const slant = SHAPE_SLANT.trapezoid;
       const points = `${slant},0 ${w - slant},0 ${w},${h} 0,${h}`;
       return polygon({ points, class: "sx-fc-node" });
     }
@@ -1869,5 +2022,5 @@ var flowchart = {
 };
 
 export { FC_CONST, flowchart, layoutFlowchart, parseFlowchart, renderFlowchart, renderFlowchartAST };
-//# sourceMappingURL=chunk-Z3WOHHG3.js.map
-//# sourceMappingURL=chunk-Z3WOHHG3.js.map
+//# sourceMappingURL=chunk-J2LVOWVY.js.map
+//# sourceMappingURL=chunk-J2LVOWVY.js.map