schematex 0.6.10 → 0.7.0

package/dist/{chunk-HL5PS6MG.js → chunk-EENA7KNU.js}

@@ -250,6 +250,9 @@ function parseHeaderProps(propsStr) {
       case "mode":
         if (["phylogram", "cladogram", "chronogram"].includes(val)) {
           result.mode = val;
+        } else if (val === "dendrogram") {
+          result.mode = "cladogram";
+          result.dendrogram = true;
         }
         break;
       case "branch-width":
@@ -313,6 +316,7 @@ function parsePhylo(text2) {
   let root = null;
   let scaleLabel;
   let outgroup;
+  let cut;
   const clades = [];
   const indentLines = [];
   let inIndentTree = false;
@@ -340,6 +344,12 @@ function parsePhylo(text2) {
       outgroup = trimmed.slice(9).trim();
       continue;
     }
+    if (/^cut\b/i.test(trimmed)) {
+      const cutStr = trimmed.replace(/^cut\s*:?\s*/i, "").trim();
+      const cutVal = Number(cutStr);
+      if (!Number.isNaN(cutVal)) cut = cutVal;
+      continue;
+    }
     if (trimmed.startsWith("clade ")) {
       const clade = parseCladeLine(trimmed);
       if (clade) clades.push(clade);
@@ -368,6 +378,9 @@ function parsePhylo(text2) {
   if (!root) {
     throw new PhyloParseError("No tree definition found (newick: or indent tree)");
   }
+  const metadata = {};
+  if (headerProps.dendrogram) metadata.dendrogram = "true";
+  if (cut !== void 0) metadata.cut = String(cut);
   return {
     type: "phylo",
     title: title2,
@@ -379,11 +392,25 @@ function parsePhylo(text2) {
     scaleLabel,
     mrsd: headerProps.mrsd,
     outgroup,
-    metadata: {}
+    metadata
   };
 }
 
-// src/diagrams/phylo/layout.ts
+// src/diagrams/phylo/dendrogram.ts
+var TIP_SPACING = 24;
+var PADDING_LEFT = 20;
+var PADDING_RIGHT = 20;
+var PADDING_TOP = 24;
+var PADDING_BOTTOM = 52;
+function isDendrogram(ast) {
+  return ast.metadata?.dendrogram === "true";
+}
+function getCut(ast) {
+  const raw = ast.metadata?.cut;
+  if (raw === void 0) return void 0;
+  const val = Number(raw);
+  return Number.isNaN(val) ? void 0 : val;
+}
 function collectLeaves(node) {
   if (node.isLeaf) return [node];
   const leaves = [];
@@ -392,6 +419,166 @@ function collectLeaves(node) {
   }
   return leaves;
 }
+function estimateLabelWidth(node) {
+  const label = node.label ?? node.id;
+  return label.length * 7.2 + 6;
+}
+function computeHeights(node, out) {
+  if (node.isLeaf) {
+    out.set(node.id, 0);
+    return 0;
+  }
+  let max = 0;
+  for (const child of node.children) {
+    const childHeight = computeHeights(child, out);
+    const branch = child.branchLength ?? 0;
+    const reach = childHeight + branch;
+    if (reach > max) max = reach;
+  }
+  out.set(node.id, max);
+  return max;
+}
+function computeClusters(ast, heights, cutValue) {
+  const clusters = [];
+  function visit(node, parentHeight) {
+    const h = heights.get(node.id) ?? 0;
+    if (h <= cutValue && parentHeight > cutValue) {
+      clusters.push({ rootId: node.id, leafIds: collectLeaves(node).map((l) => l.id) });
+      return;
+    }
+    if (h > cutValue) {
+      for (const child of node.children) visit(child, h);
+    } else {
+      clusters.push({ rootId: node.id, leafIds: collectLeaves(node).map((l) => l.id) });
+    }
+  }
+  visit(ast.root, Number.POSITIVE_INFINITY);
+  return clusters;
+}
+function layoutDendrogram(ast) {
+  const leaves = collectLeaves(ast.root);
+  const numLeaves = leaves.length;
+  const heights = /* @__PURE__ */ new Map();
+  const maxHeight = computeHeights(ast.root, heights);
+  const maxLabelWidth = Math.max(...leaves.map(estimateLabelWidth), 60);
+  const availableWidth = Math.max(320, numLeaves * 36 + maxLabelWidth + 120);
+  const plotWidth = availableWidth - PADDING_LEFT - PADDING_RIGHT - maxLabelWidth;
+  const scale = maxHeight > 0 ? plotWidth / maxHeight : plotWidth;
+  const baselineX = PADDING_LEFT + plotWidth;
+  const heightToX = (h) => baselineX - h * scale;
+  const nodeMap = /* @__PURE__ */ new Map();
+  let leafIdx = 0;
+  function assignLeaf(node) {
+    if (node.isLeaf) {
+      const y = PADDING_TOP + leafIdx * TIP_SPACING;
+      nodeMap.set(node.id, { node, x: baselineX, y });
+      leafIdx++;
+      return;
+    }
+    for (const child of node.children) assignLeaf(child);
+  }
+  assignLeaf(ast.root);
+  function assignInternal(node) {
+    const existing = nodeMap.get(node.id);
+    if (node.isLeaf && existing) return existing.y;
+    const childYs = node.children.map(assignInternal);
+    const y = (Math.min(...childYs) + Math.max(...childYs)) / 2;
+    const x = heightToX(heights.get(node.id) ?? 0);
+    if (existing) {
+      existing.y = y;
+      existing.x = x;
+    } else {
+      nodeMap.set(node.id, { node, x, y });
+    }
+    return y;
+  }
+  assignInternal(ast.root);
+  const cut = getCut(ast);
+  const leafCluster = /* @__PURE__ */ new Map();
+  let clusterCount = 0;
+  if (cut !== void 0) {
+    const clusters = computeClusters(ast, heights, cut);
+    clusterCount = clusters.length;
+    clusters.forEach((cluster, idx) => {
+      for (const leafId of cluster.leafIds) leafCluster.set(leafId, idx);
+    });
+  }
+  function subtreeCluster(node) {
+    const ids = collectLeaves(node).map((l) => l.id);
+    const first = leafCluster.get(ids[0]);
+    if (first === void 0) return void 0;
+    for (const id of ids) {
+      if (leafCluster.get(id) !== first) return void 0;
+    }
+    return first;
+  }
+  const branches = [];
+  function generate(node) {
+    if (node.children.length === 0) return;
+    const parent = nodeMap.get(node.id);
+    if (!parent) return;
+    const childLayouts = node.children.map((c) => nodeMap.get(c.id)).filter((l) => l !== void 0);
+    if (childLayouts.length === 0) return;
+    const minY = Math.min(...childLayouts.map((c) => c.y));
+    const maxY = Math.max(...childLayouts.map((c) => c.y));
+    branches.push({
+      path: `M ${parent.x},${minY} V ${maxY}`,
+      fromId: node.id,
+      toId: node.id,
+      isConnector: true
+    });
+    for (const child of node.children) {
+      const childLayout = nodeMap.get(child.id);
+      if (!childLayout) continue;
+      const cluster = subtreeCluster(child);
+      branches.push({
+        path: `M ${parent.x},${childLayout.y} H ${childLayout.x}`,
+        fromId: node.id,
+        toId: child.id,
+        cladeId: cluster !== void 0 ? `cut${cluster}` : void 0,
+        isConnector: false
+      });
+    }
+    for (const child of node.children) generate(child);
+  }
+  generate(ast.root);
+  const allNodes = Array.from(nodeMap.values());
+  const maxX = Math.max(
+    ...allNodes.map((n) => n.x + (n.node.isLeaf ? estimateLabelWidth(n.node) : 0))
+  );
+  const maxNodeY = Math.max(...allNodes.map((n) => n.y));
+  const width = Math.max(maxX + PADDING_RIGHT, availableWidth);
+  const height = maxNodeY + PADDING_TOP + PADDING_BOTTOM;
+  return {
+    width,
+    height,
+    nodes: allNodes,
+    branches,
+    ast,
+    scale,
+    // Dendrogram-specific extras stashed for the renderer (see types below).
+    dendrogram: {
+      maxHeight,
+      baselineX,
+      plotLeftX: PADDING_LEFT,
+      scale,
+      cut,
+      clusterCount,
+      leafCluster,
+      heights
+    }
+  };
+}
+
+// src/diagrams/phylo/layout.ts
+function collectLeaves2(node) {
+  if (node.isLeaf) return [node];
+  const leaves = [];
+  for (const child of node.children) {
+    leaves.push(...collectLeaves2(child));
+  }
+  return leaves;
+}
 function maxRootToTip(node, distSoFar) {
   if (node.isLeaf) return distSoFar;
   let maxDist = distSoFar;
@@ -410,7 +597,7 @@ function maxDepth(node) {
   }
   return max;
 }
-function estimateLabelWidth(node) {
+function estimateLabelWidth2(node) {
   const label = node.label ?? node.id;
   return label.length * 7.2 + 6;
 }
@@ -445,20 +632,23 @@ function markCladeBranches(node, memberSet, cladeId, result) {
   }
   return false;
 }
-var TIP_SPACING = 20;
-var PADDING_LEFT = 20;
-var PADDING_RIGHT = 20;
-var PADDING_TOP = 20;
-var PADDING_BOTTOM = 40;
+var TIP_SPACING2 = 20;
+var PADDING_LEFT2 = 20;
+var PADDING_RIGHT2 = 20;
+var PADDING_TOP2 = 20;
+var PADDING_BOTTOM2 = 40;
 function layoutPhylo(ast) {
-  const leaves = collectLeaves(ast.root);
+  if (isDendrogram(ast)) {
+    return layoutDendrogram(ast);
+  }
+  const leaves = collectLeaves2(ast.root);
   const numLeaves = leaves.length;
-  const tipSpacing = TIP_SPACING;
-  const maxLabelWidth = Math.max(...leaves.map(estimateLabelWidth), 60);
+  const tipSpacing = TIP_SPACING2;
+  const maxLabelWidth = Math.max(...leaves.map(estimateLabelWidth2), 60);
   const maxDist = maxRootToTip(ast.root, 0);
   const isCladogram = ast.mode === "cladogram";
   const availableWidth = Math.max(300, numLeaves * 30 + maxLabelWidth + 100);
-  const plotWidth = availableWidth - PADDING_LEFT - PADDING_RIGHT - maxLabelWidth;
+  const plotWidth = availableWidth - PADDING_LEFT2 - PADDING_RIGHT2 - maxLabelWidth;
   let scale;
   if (isCladogram || maxDist === 0) {
     const depth = maxDepth(ast.root);
@@ -470,7 +660,7 @@ function layoutPhylo(ast) {
   let leafIdx = 0;
   function assignLeafY(node) {
     if (node.isLeaf) {
-      const y = PADDING_TOP + leafIdx * tipSpacing;
+      const y = PADDING_TOP2 + leafIdx * tipSpacing;
       nodeMap.set(node.id, { node, x: 0, y });
       leafIdx++;
       return;
@@ -496,12 +686,12 @@ function layoutPhylo(ast) {
   function assignX(node, parentX, depth) {
     let x;
     if (node === ast.root) {
-      x = PADDING_LEFT;
+      x = PADDING_LEFT2;
     } else if (isCladogram) {
       if (node.isLeaf) {
-        x = PADDING_LEFT + plotWidth;
+        x = PADDING_LEFT2 + plotWidth;
       } else {
-        x = PADDING_LEFT + depth * (plotWidth / maxDepth(ast.root));
+        x = PADDING_LEFT2 + depth * (plotWidth / maxDepth(ast.root));
       }
     } else {
       x = parentX + (node.branchLength ?? 0) * scale;
@@ -512,7 +702,7 @@ function layoutPhylo(ast) {
       assignX(child, x, depth + 1);
     }
   }
-  assignX(ast.root, PADDING_LEFT, 0);
+  assignX(ast.root, PADDING_LEFT2, 0);
   if (isCladogram) {
     assignCladogramInternalX(ast.root, nodeMap);
   }
@@ -565,7 +755,7 @@ function layoutPhylo(ast) {
   }
   generateBranches(ast.root);
   const allNodes = Array.from(nodeMap.values());
-  let maxX = Math.max(...allNodes.map((n) => n.x + (n.node.isLeaf ? estimateLabelWidth(n.node) : 0)));
+  let maxX = Math.max(...allNodes.map((n) => n.x + (n.node.isLeaf ? estimateLabelWidth2(n.node) : 0)));
   let maxCladeLabelWidth = 0;
   for (const clade of ast.clades) {
     if (clade.label && clade.highlight && clade.highlight !== "branch") {
@@ -575,8 +765,8 @@ function layoutPhylo(ast) {
   }
   maxX += maxCladeLabelWidth;
   const maxNodeY = Math.max(...allNodes.map((n) => n.y));
-  const width = Math.max(maxX + PADDING_RIGHT, availableWidth);
-  const height = maxNodeY + PADDING_TOP + PADDING_BOTTOM;
+  const width = Math.max(maxX + PADDING_RIGHT2, availableWidth);
+  const height = maxNodeY + PADDING_TOP2 + PADDING_BOTTOM2;
   return {
     width,
     height,
@@ -598,9 +788,9 @@ function assignCladogramInternalX(node, nodeMap) {
   const layout = nodeMap.get(node.id);
   if (layout) {
     layout.x = minChildX - 40;
-    if (layout.x < PADDING_LEFT) layout.x = PADDING_LEFT;
+    if (layout.x < PADDING_LEFT2) layout.x = PADDING_LEFT2;
   }
-  return layout?.x ?? PADDING_LEFT;
+  return layout?.x ?? PADDING_LEFT2;
 }
 
 // src/diagrams/phylo/renderer.ts
@@ -624,12 +814,25 @@ function buildCSS(ast, t) {
 .schematex-phylo-clade-bg-${c.id} { fill: ${color}; fill-opacity: 0.12; }
 .schematex-phylo-clade-label-${c.id} { fill: ${color}; }`;
   });
+  const cutColors = [];
+  if (ast.metadata?.dendrogram === "true" && ast.metadata?.cut !== void 0) {
+    for (let i = 0; i < t.cladeColors.length; i++) {
+      cutColors.push(
+        `.schematex-phylo-clade-cut${i} { stroke: ${t.cladeColors[i % t.cladeColors.length]}; }`
+      );
+    }
+  }
   return `
 .schematex-phylo {${cssCustomProperties(t)}
   font-family: system-ui, -apple-system, sans-serif;
 }
 .schematex-phylo-branch { fill: none; stroke: ${t.text}; stroke-width: ${STROKE_WIDTH.normal}; stroke-linecap: round; }
 .schematex-phylo-branch-connector { fill: none; stroke: ${t.text}; stroke-width: ${STROKE_WIDTH.normal}; }
+.schematex-phylo-dendro-axis line { stroke: ${t.text}; stroke-width: ${STROKE_WIDTH.thin}; }
+.schematex-phylo-dendro-axis text { font-size: 10px; fill: ${t.textMuted}; text-anchor: middle; }
+.schematex-phylo-dendro-cut { stroke: ${t.supportBad}; stroke-width: ${STROKE_WIDTH.normal}; stroke-dasharray: 5 4; fill: none; }
+.schematex-phylo-dendro-cut-label { font-size: 10px; fill: ${t.supportBad}; text-anchor: start; }
+${cutColors.join("\n")}
 .schematex-phylo-tip-label { font-size: ${FONT_SIZE.label}px; fill: ${t.text}; dominant-baseline: central; }
 .schematex-phylo-tip-label-italic { font-style: italic; }
 .schematex-phylo-support-label { font-size: ${FONT_SIZE.small}px; fill: ${t.textMuted}; text-anchor: middle; dominant-baseline: auto; }
@@ -734,6 +937,75 @@ function renderCladeBackgrounds(layout, t) {
   }
   return elements;
 }
+function niceStep(maxHeight, targetTicks) {
+  if (maxHeight <= 0) return 1;
+  const rough = maxHeight / targetTicks;
+  const mag = Math.pow(10, Math.floor(Math.log10(rough)));
+  const norm = rough / mag;
+  let step;
+  if (norm < 1.5) step = 1;
+  else if (norm < 3) step = 2;
+  else if (norm < 7) step = 5;
+  else step = 10;
+  return step * mag;
+}
+function formatTick(value) {
+  if (value === 0) return "0";
+  if (Math.abs(value) < 0.01) return value.toExponential(0);
+  return String(Math.round(value * 1e3) / 1e3);
+}
+function renderDendrogramAxis(layout, t) {
+  const d = layout.dendrogram;
+  if (!d) return "";
+  const axisY = layout.height - 28;
+  const elements = [];
+  elements.push(
+    line({ x1: d.plotLeftX, y1: axisY, x2: d.baselineX, y2: axisY })
+  );
+  const step = niceStep(d.maxHeight, 5);
+  for (let h = 0; h <= d.maxHeight + step * 1e-3; h += step) {
+    const x = d.baselineX - h * d.scale;
+    elements.push(line({ x1: x, y1: axisY, x2: x, y2: axisY + 4 }));
+    elements.push(
+      text({ x, y: axisY + 16, "text-anchor": "middle" }, formatTick(h))
+    );
+  }
+  if (layout.ast.scaleLabel) {
+    elements.push(
+      text(
+        {
+          x: (d.plotLeftX + d.baselineX) / 2,
+          y: axisY + 28,
+          "text-anchor": "middle",
+          "font-size": "9",
+          fill: t.textMuted
+        },
+        layout.ast.scaleLabel
+      )
+    );
+  }
+  return group({ class: "schematex-phylo-dendro-axis" }, elements);
+}
+function renderCutLine(layout) {
+  const d = layout.dendrogram;
+  if (!d || d.cut === void 0) return "";
+  const x = d.baselineX - d.cut * d.scale;
+  const topY = 8;
+  const bottomY = layout.height - 32;
+  return group({}, [
+    line({
+      x1: x,
+      y1: topY,
+      x2: x,
+      y2: bottomY,
+      class: "schematex-phylo-dendro-cut"
+    }),
+    text(
+      { x: x + 4, y: topY + 4, class: "schematex-phylo-dendro-cut-label" },
+      `cut = ${formatTick(d.cut)}`
+    )
+  ]);
+}
 function renderPhylo(layout) {
   const { ast, nodes, branches } = layout;
   const t = resolveBiologyTheme(ast.metadata?.theme ?? "default");
@@ -810,15 +1082,24 @@ function renderPhylo(layout) {
     }
   }
   const cladeBgElements = renderCladeBackgrounds(layout, t);
-  const scaleBarEl = renderScaleBar(layout, t, ast.scaleLabel);
+  const isDendro = layout.dendrogram !== void 0;
+  const scaleBarEl = isDendro ? "" : renderScaleBar(layout, t, ast.scaleLabel);
+  const dendroAxisEl = isDendro ? renderDendrogramAxis(layout, t) : "";
+  const cutLineEl = isDendro ? renderCutLine(layout) : "";
   const titleEl = ast.title ? text(
     { x: totalWidth / 2, y: 20, class: "schematex-phylo-title" },
     ast.title
   ) : "";
   const leafCount = nodes.filter((n) => n.node.isLeaf).length;
+  const isDendrogramMode = layout.dendrogram !== void 0;
+  const descMode = isDendrogramMode ? "dendrogram" : ast.mode;
+  const descTitle = isDendrogramMode ? "Dendrogram" : "Phylogenetic Tree";
+  const cutSuffix = isDendrogramMode && layout.dendrogram?.cut !== void 0 ? `, cut at ${layout.dendrogram.cut} into ${layout.dendrogram.clusterCount} clusters` : "";
   const svgContent = [
-    title(`Phylogenetic Tree${ast.title ? `: ${ast.title}` : ""}`),
-    desc(`Phylogenetic tree with ${leafCount} taxa, ${ast.mode} mode, ${ast.layout} layout`),
+    title(`${descTitle}${ast.title ? `: ${ast.title}` : ""}`),
+    desc(
+      `${isDendrogramMode ? "Dendrogram" : "Phylogenetic tree"} with ${leafCount} taxa, ${descMode} mode, ${ast.layout} layout${cutSuffix}`
+    ),
     el("style", {}, css)
   ];
   if (titleEl) svgContent.push(titleEl);
@@ -857,6 +1138,22 @@ function renderPhylo(layout) {
       )
     );
   }
+  if (dendroAxisEl) {
+    svgContent.push(
+      group(
+        { transform: transformY ? `translate(0,${transformY})` : void 0 },
+        [dendroAxisEl]
+      )
+    );
+  }
+  if (cutLineEl) {
+    svgContent.push(
+      group(
+        { transform: transformY ? `translate(0,${transformY})` : void 0 },
+        [cutLineEl]
+      )
+    );
+  }
   return svgRoot(
     {
       class: "schematex-diagram schematex-phylo",
@@ -884,5 +1181,5 @@ var phylo = {
 };
 
 export { PhyloParseError, layoutPhylo, parsePhylo, phylo, renderPhylo };
-//# sourceMappingURL=chunk-HL5PS6MG.js.map
-//# sourceMappingURL=chunk-HL5PS6MG.js.map
+//# sourceMappingURL=chunk-EENA7KNU.js.map
+//# sourceMappingURL=chunk-EENA7KNU.js.map