@jbrowse/bandage-core 9.9.2 → 9.10.0

package/README.md

@@ -25,6 +25,9 @@ npm install @jbrowse/bandage-core
   and the `bandage-figure` CLI makes one from a JSON spec with no browser:
   `npx -p @jbrowse/bandage-core bandage-figure spec.json -o figure.svg`. See
   [docs/figures.md](docs/figures.md)
+- Figure data: `figureData` returns what `figureSvg` would paint as columnar
+  tables, for another graphics system to draw;
+  [ggbandage](https://github.com/GMOD/ggbandage) draws them in ggplot2
 
 Nothing here imports React, MobX or a JBrowse host. BandageJS's
 [`src/main.ts`](https://github.com/cmdcolin/BandageJS/blob/main/src/main.ts) is

package/dist/bubbles/superbubbles.js

@@ -1,11 +1,11 @@
 import {
   graphBubbles,
   superbubblesFromGraph
-} from "../chunks/chunk-ROQGMTFB.js";
+} from "../chunks/chunk-5GZEPPEW.js";
+import "../chunks/chunk-CLOP7UVD.js";
 import "../chunks/chunk-A6PSWTLX.js";
 import "../chunks/chunk-EHUBJDDB.js";
 import "../chunks/chunk-XKWD2RY3.js";
-import "../chunks/chunk-CLOP7UVD.js";
 import "../chunks/chunk-FX4RDMDN.js";
 import "../chunks/chunk-HNQPEMYE.js";
 import "../chunks/chunk-IGJCTPFB.js";

package/dist/chunks/{chunk-IZ3W5IU2.js → chunk-2FLBFVMO.js}

@@ -5,18 +5,15 @@ import {
   stripGeneGaps,
   walkStripFrame,
   walkStripLabelsTree
-} from "./chunk-MECWJY2R.js";
-import {
-  Canvas2DRenderer
-} from "./chunk-WBCOREDZ.js";
-import {
-  layoutGeometryInputs
-} from "./chunk-LOCJN3BZ.js";
+} from "./chunk-DMH4NL2M.js";
 import {
   walkRowsKey,
   walkRowsKeyTree,
   walkRowsTree
-} from "./chunk-P6O4RSOQ.js";
+} from "./chunk-FJZ2TB46.js";
+import {
+  Canvas2DRenderer
+} from "./chunk-WBCOREDZ.js";
 import {
   genePins
 } from "./chunk-BUBZ32IC.js";
@@ -25,16 +22,31 @@ import {
   exonOutlineTree,
   exonStretches
 } from "./chunk-3S3YVOJ7.js";
+import {
+  geneLabelCandidates
+} from "./chunk-DRG4236Y.js";
+import {
+  nodesUnderBox
+} from "./chunk-FP4H7SFT.js";
+import {
+  serializeEl
+} from "./chunk-NNODIW4U.js";
+import {
+  layoutGeometryInputs
+} from "./chunk-LOCJN3BZ.js";
+import {
+  version
+} from "./chunk-2VTM3DHG.js";
 import {
   axisScaleOf
-} from "./chunk-ZBLKAWSD.js";
+} from "./chunk-PT37VS5B.js";
 import {
   facetLifts,
   walkLift
-} from "./chunk-EE37PVQY.js";
+} from "./chunk-MVMP6AGI.js";
 import {
   encodingStops
-} from "./chunk-F5BYHLIN.js";
+} from "./chunk-KYY5363X.js";
 import {
   rangeText,
   walkKey
@@ -42,10 +54,7 @@ import {
 import {
   buildGeometry,
   computeReferenceRamp
-} from "./chunk-F4BKWWLS.js";
-import {
-  version
-} from "./chunk-BQ33OOLC.js";
+} from "./chunk-4IYP43W6.js";
 import {
   walkRowLabels,
   walkRowsExtent
@@ -53,19 +62,18 @@ import {
 import {
   pathLegend,
   walkLabelsOf
-} from "./chunk-EDASNMLY.js";
+} from "./chunk-XZ2BLAA6.js";
 import {
   nodeInk
 } from "./chunk-PBENCR5L.js";
+import {
+  FIT_PADDING,
+  drawingBounds,
+  fitTransform
+} from "./chunk-HRAU4VTB.js";
 import {
   referenceLabel
 } from "./chunk-RAKOB6IV.js";
-import {
-  geneLabelCandidates
-} from "./chunk-DRG4236Y.js";
-import {
-  nodesUnderBox
-} from "./chunk-FP4H7SFT.js";
 import {
   LABEL_CHAR_PX,
   LABEL_PAD,
@@ -77,8 +85,9 @@ import {
   resolveColorScheme
 } from "./chunk-JKJWSY4V.js";
 import {
-  serializeEl
-} from "./chunk-NNODIW4U.js";
+  deletionDrawing,
+  deletionEdges
+} from "./chunk-N6FECAXP.js";
 import {
   FACET_GAP_PX,
   FACET_PAD_PX,
@@ -87,15 +96,6 @@ import {
   facetGrid,
   facetSettingOf
 } from "./chunk-XV4P5KEQ.js";
-import {
-  FIT_PADDING,
-  drawingBounds,
-  fitTransform
-} from "./chunk-FPTI3WAV.js";
-import {
-  deletionDrawing,
-  deletionEdges
-} from "./chunk-N6FECAXP.js";
 
 // src/figure.ts
 var FONT = 'font-family="Helvetica, Arial, sans-serif" font-size="11"';

package/dist/chunks/{chunk-BQ33OOLC.js → chunk-2VTM3DHG.js}

@@ -1,5 +1,5 @@
 // src/version.ts
-var version = "9.9.2";
+var version = "9.10.0";
 
 export {
   version

package/dist/chunks/{chunk-F4BKWWLS.js → chunk-4IYP43W6.js}

@@ -3,19 +3,19 @@ import {
   fadeAbgr,
   packAbgr
 } from "./chunk-G2FD7S3C.js";
+import {
+  baseEdgeCurves
+} from "./chunk-WFB5TXRA.js";
 import {
   PATH_LIGHTNESS,
   PATH_SATURATION,
   nameHue,
   pathHueAt
-} from "./chunk-EDASNMLY.js";
+} from "./chunk-XZ2BLAA6.js";
 import {
   meanDepth,
   nodeWidthPx
 } from "./chunk-PBENCR5L.js";
-import {
-  baseEdgeCurves
-} from "./chunk-WFB5TXRA.js";
 import {
   referenceMidpoints
 } from "./chunk-ES2N6V56.js";

package/dist/chunks/{chunk-RK3MF4FD.js → chunk-BDWQQK33.js}

@@ -2,7 +2,7 @@ import {
   LIFT_BACKDROP_CSS,
   computeColorSchemeRange,
   getNodeColor
-} from "./chunk-F4BKWWLS.js";
+} from "./chunk-4IYP43W6.js";
 import {
   abgrToCssRgba
 } from "./chunk-G2FD7S3C.js";

package/dist/chunks/{chunk-HOZI3FBG.js → chunk-CXKZYLYS.js}

@@ -6,7 +6,7 @@ import {
 import {
   pathCssColor,
   pathGreyCssColor
-} from "./chunk-EDASNMLY.js";
+} from "./chunk-XZ2BLAA6.js";
 import {
   pathOrigin
 } from "./chunk-IGJCTPFB.js";

package/dist/chunks/{chunk-MECWJY2R.js → chunk-DMH4NL2M.js}

@@ -2,16 +2,16 @@ import {
   alongRow,
   boxesGenes,
   rowPitch
-} from "./chunk-P6O4RSOQ.js";
-import {
-  LABEL_CHAR_PX
-} from "./chunk-AB35TJST.js";
+} from "./chunk-FJZ2TB46.js";
 import {
   el
 } from "./chunk-NNODIW4U.js";
 import {
   pathOrigin
 } from "./chunk-IGJCTPFB.js";
+import {
+  LABEL_CHAR_PX
+} from "./chunk-AB35TJST.js";
 
 // src/layout/walkStrip.ts
 function walkStripApplies(o) {

package/dist/chunks/{chunk-P6O4RSOQ.js → chunk-FJZ2TB46.js}

@@ -3,16 +3,16 @@ import {
   RAMP_GRADIENT_STOPS,
   rampHueCss,
   rampStops
-} from "./chunk-YS7VA5SI.js";
+} from "./chunk-K5NYTPLC.js";
+import {
+  el
+} from "./chunk-NNODIW4U.js";
 import {
   REFERENCE_RAMP_ALT_CSS
-} from "./chunk-F4BKWWLS.js";
+} from "./chunk-4IYP43W6.js";
 import {
   LABEL_CHAR_PX
 } from "./chunk-AB35TJST.js";
-import {
-  el
-} from "./chunk-NNODIW4U.js";
 import {
   ROW_HEIGHT_PX
 } from "./chunk-CPMHA4W5.js";

package/dist/chunks/{chunk-IJRNMO4D.js → chunk-FUUJ76KD.js}

@@ -6,7 +6,7 @@ import {
   hasTubeMapPaths,
   tubeMapLayout,
   tubeMapReferenceLayout
-} from "./chunk-HOZI3FBG.js";
+} from "./chunk-CXKZYLYS.js";
 import {
   anchoredLayout
 } from "./chunk-L3O7AWLI.js";

package/dist/chunks/{chunk-FPTI3WAV.js → chunk-HRAU4VTB.js}

@@ -1,9 +1,12 @@
-import {
-  orientToReference
-} from "./chunk-PUG7LXDF.js";
 import {
   seededNodes
 } from "./chunk-IGVV37VI.js";
+import {
+  smoothChain
+} from "./chunk-OPPVSPEF.js";
+import {
+  orientToReference
+} from "./chunk-PUG7LXDF.js";
 import {
   convertGFAToGraph
 } from "./chunk-J7YKQ5YW.js";
@@ -148,11 +151,13 @@ async function forceLayout(graph, settings, engine) {
   const drawn = new Map(
     scaling.nodes.map((n) => [n.id, drawnNodeLength(scaling.opts, n.length)])
   );
-  const positions = splitRuns(
-    result.nodePositions,
-    merged.runs,
-    (id) => drawn.get(id) ?? 0
+  const smoothed = Object.fromEntries(
+    Object.entries(result.nodePositions).map(([id, line]) => [
+      id,
+      smoothChain(line)
+    ])
   );
+  const positions = splitRuns(smoothed, merged.runs, (id) => drawn.get(id) ?? 0);
   const { nodePositions, deletionRoutes } = takeRoutes(
     graph.nodes.some(isBackbone) ? orientToReference(graph, positions) : positions,
     routed.routes

package/dist/chunks/{chunk-YGN4KL7W.js → chunk-IZI7KIVX.js}

@@ -1,6 +1,6 @@
 import {
   ENGINE_DEFAULTS
-} from "./chunk-FPTI3WAV.js";
+} from "./chunk-HRAU4VTB.js";
 
 // src/figureSettings.ts
 var FIGURE_DEFAULTS = {

package/dist/chunks/{chunk-YS7VA5SI.js → chunk-K5NYTPLC.js}

@@ -1,6 +1,6 @@
 import {
   REFERENCE_RAMP_MAX_HUE
-} from "./chunk-F4BKWWLS.js";
+} from "./chunk-4IYP43W6.js";
 
 // src/referenceRampCss.ts
 function rampHueCss(hue) {

package/dist/chunks/{chunk-F5BYHLIN.js → chunk-KYY5363X.js}

@@ -2,7 +2,7 @@ import {
   REFERENCE_RAMP_ALT_COLOR,
   REFERENCE_RAMP_MAX_HUE,
   hslToRgb
-} from "./chunk-F4BKWWLS.js";
+} from "./chunk-4IYP43W6.js";
 import {
   packAbgr
 } from "./chunk-G2FD7S3C.js";

package/dist/chunks/{chunk-WVBYR6Y7.js → chunk-LZWSZRUY.js}

@@ -1,6 +1,6 @@
 import {
   pathSteps
-} from "./chunk-HOZI3FBG.js";
+} from "./chunk-CXKZYLYS.js";
 import {
   pathOrigin
 } from "./chunk-IGJCTPFB.js";

package/dist/chunks/{chunk-EE37PVQY.js → chunk-MVMP6AGI.js}

@@ -1,7 +1,7 @@
 import {
   encodedColor,
   resolveEncoding
-} from "./chunk-F5BYHLIN.js";
+} from "./chunk-KYY5363X.js";
 import {
   pathOrigin
 } from "./chunk-IGJCTPFB.js";

package/dist/chunks/chunk-NGODVSCA.js

@@ -0,0 +1,292 @@
+import {
+  layoutEngine
+} from "./chunk-VK6XMP6B.js";
+import {
+  layoutModeByValue
+} from "./chunk-FUUJ76KD.js";
+import {
+  parseRegion
+} from "./chunk-73RSLGZT.js";
+import {
+  layoutGeometryInputs
+} from "./chunk-LOCJN3BZ.js";
+import {
+  version
+} from "./chunk-2VTM3DHG.js";
+import {
+  axisScaleOf
+} from "./chunk-PT37VS5B.js";
+import {
+  facetLifts,
+  walkLift
+} from "./chunk-MVMP6AGI.js";
+import {
+  walkKey
+} from "./chunk-2LQ5BWT7.js";
+import {
+  buildGeometry,
+  computeReferenceRamp
+} from "./chunk-4IYP43W6.js";
+import {
+  abgrAlpha,
+  abgrBlue,
+  abgrGreen,
+  abgrRed
+} from "./chunk-G2FD7S3C.js";
+import {
+  pathLegend,
+  walkLabelsOf
+} from "./chunk-XZ2BLAA6.js";
+import {
+  drawingBounds,
+  engineSettingsOf,
+  fitTransform,
+  forceLayout,
+  loadGraph
+} from "./chunk-HRAU4VTB.js";
+import {
+  referenceLabel
+} from "./chunk-RAKOB6IV.js";
+import {
+  resolveColorScheme
+} from "./chunk-JKJWSY4V.js";
+import {
+  deletionDrawing,
+  deletionEdges
+} from "./chunk-N6FECAXP.js";
+import {
+  isBackbone
+} from "./chunk-FYQWPEEY.js";
+import {
+  facetCells,
+  facetSettingOf
+} from "./chunk-XV4P5KEQ.js";
+
+// src/figureData.ts
+function columns(keys) {
+  const out = Object.fromEntries(
+    keys.map((k) => [k, []])
+  );
+  return {
+    out,
+    push(row) {
+      for (const k of keys) {
+        out[k].push(row[k]);
+      }
+    }
+  };
+}
+var hex = (v) => v.toString(16).padStart(2, "0");
+var cssHex = (c) => `#${hex(abgrRed(c))}${hex(abgrGreen(c))}${hex(abgrBlue(c))}`;
+var alphaOf = (c) => abgrAlpha(c) / 255;
+function figureData(graph, layout, o = {}) {
+  if (layout.tubeMap) {
+    throw new Error("figure data has no tables for a tube map yet");
+  }
+  const width = o.width ?? 1200;
+  const height = o.height ?? 800;
+  const region = o.region;
+  const pixelRows = layout.pixelRows ?? false;
+  const bounds = drawingBounds(layout, {
+    region: o.fitToDrawing ? void 0 : region
+  });
+  const fit = fitTransform(bounds, width, height, pixelRows);
+  if (!fit) {
+    throw new Error("the layout drew nothing to fit");
+  }
+  const axis = axisScaleOf(fit.scale, pixelRows);
+  const nodeById = new Map(graph.nodes.map((node) => [node.id, node]));
+  const colorScheme = resolveColorScheme(o.colorScheme ?? "auto", graph);
+  const rampDomain = o.colorDomain ?? region;
+  const referenceRamp = colorScheme === "reference-position" ? computeReferenceRamp(graph, rampDomain) : void 0;
+  const drawnDeletions = deletionDrawing(
+    graph,
+    deletionEdges(graph),
+    o.showDeletionEdges
+  );
+  const layers = o.walks ?? [];
+  const walkRamp = layers.some((l) => l.color?.field === "reference") ? referenceRamp ?? computeReferenceRamp(graph, rampDomain) : void 0;
+  const lift = layers.length > 0 ? walkLift(graph, layers, walkRamp) : void 0;
+  const facet = facetSettingOf(o.facet);
+  const facetted = facet.field && lift && lift.walks.length > 1 ? facetLifts(graph, lift, layers, walkRamp) : void 0;
+  const labels = walkLabelsOf(
+    graph.paths?.length ? pathLegend(graph.paths) : []
+  );
+  const labelOf = (name) => labels.get(name) ?? name;
+  const referenceName = o.referenceName ?? referenceLabel(graph, region);
+  const reference = lift?.referenceDomain && {
+    ...lift.referenceDomain,
+    name: referenceName
+  };
+  const panels = [];
+  if (facetted) {
+    const place = facetCells(
+      facetted.map((p) => p.walks[0].name),
+      facet.field || "walk",
+      facet.domain
+    );
+    const ordered = facetted.map((panel, i) => ({ panel, cell: place.cells[i] })).sort((a, b) => a.cell - b.cell);
+    for (const { panel } of ordered) {
+      const walk = panel.walks[0];
+      const key = walkKey(walk, reference);
+      panels.push({
+        highlight: panel,
+        name: labelOf(walk.name),
+        key: key.delta + key.outside + key.reversed,
+        range: key.scale ?? ""
+      });
+    }
+  } else {
+    panels.push({ highlight: lift, name: "", key: "", range: "" });
+  }
+  const nodes = columns([
+    "panel",
+    "node",
+    "stroke",
+    "x",
+    "y",
+    "color",
+    "alpha",
+    "width"
+  ]);
+  const edges = columns([
+    "panel",
+    "edge",
+    "curve",
+    "x0",
+    "y0",
+    "cx0",
+    "cy0",
+    "cx1",
+    "cy1",
+    "x1",
+    "y1",
+    "color",
+    "alpha",
+    "width",
+    "deletion"
+  ]);
+  const arrows = columns([
+    "panel",
+    "edge",
+    "x",
+    "y",
+    "angle",
+    "length",
+    "halfWidth",
+    "color",
+    "alpha"
+  ]);
+  for (const { highlight, name: panel } of panels) {
+    const batch = buildGeometry({
+      ...layoutGeometryInputs(layout, drawnDeletions),
+      graph,
+      nodeById,
+      colorScheme,
+      contigThickness: o.contigThickness ?? 6,
+      connectorThickness: o.connectorThickness ?? 2,
+      drawPaths: false,
+      nodeWidth: o.nodeWidth ?? "depth",
+      linearLayout: o.linearLayout,
+      highlight,
+      axis,
+      referenceRamp
+    });
+    for (const [node, run] of batch.nodeStrokeRuns) {
+      for (let i = run.start; i < run.start + run.count; i++) {
+        const s = batch.nodeStrokes[i];
+        for (const p of s.points) {
+          nodes.push({
+            panel,
+            node,
+            stroke: i,
+            x: p.x,
+            y: p.y,
+            color: cssHex(s.color),
+            alpha: alphaOf(s.color),
+            width: s.thickness * 2
+          });
+        }
+      }
+    }
+    for (const [edge, run] of batch.edgeCurveRuns) {
+      for (let i = run.start; i < run.start + run.count; i++) {
+        const b = batch.edgeCurves[i];
+        for (const c of b.curves) {
+          edges.push({
+            panel,
+            edge,
+            curve: i,
+            ...c,
+            color: cssHex(b.color),
+            alpha: alphaOf(b.color),
+            width: b.thickness * 2,
+            deletion: drawnDeletions.bypassed.has(edge)
+          });
+        }
+      }
+    }
+    for (const [edge, run] of batch.arrowRuns) {
+      for (let i = run.start; i < run.start + run.count; i++) {
+        const a = batch.arrows[i];
+        arrows.push({
+          panel,
+          edge,
+          x: a.x,
+          y: a.y,
+          angle: a.angle,
+          length: a.length,
+          halfWidth: a.halfWidth,
+          color: cssHex(a.color),
+          alpha: alphaOf(a.color)
+        });
+      }
+    }
+  }
+  return {
+    meta: {
+      generator: `@jbrowse/bandage-core@${version}`,
+      width,
+      scaleX: axis.scaleX,
+      scaleY: axis.scaleY,
+      pixelRows,
+      referenceAxis: layout.referenceAxis ?? false,
+      colorScheme,
+      referenceName: referenceName ?? null
+    },
+    panels: {
+      panel: panels.map((p) => p.name),
+      key: panels.map((p) => p.key),
+      range: panels.map((p) => p.range)
+    },
+    nodes: nodes.out,
+    edges: edges.out,
+    arrows: arrows.out,
+    nodeInfo: {
+      node: graph.nodes.map((n) => n.id),
+      name: graph.nodes.map((n) => n.name),
+      length: graph.nodes.map((n) => n.length),
+      depth: graph.nodes.map((n) => n.depth),
+      backbone: graph.nodes.map((n) => isBackbone(n))
+    },
+    rowLabels: {
+      label: (layout.rowLabels ?? []).map((r) => r.label),
+      y: (layout.rowLabels ?? []).map((r) => r.y)
+    }
+  };
+}
+async function gfaFigureData(text, name, spec = {}) {
+  const region = spec.region ? parseRegion(spec.region) : void 0;
+  const graph = loadGraph(text, name, { referencePath: spec.referencePath });
+  const layout = layoutModeByValue(spec.layout ?? "force").run(graph, region) ?? (await forceLayout(graph, engineSettingsOf(spec), layoutEngine)).result;
+  return figureData(graph, layout, {
+    ...spec,
+    region,
+    walks: spec.walks?.map((w) => typeof w === "string" ? { walk: w } : w)
+  });
+}
+
+export {
+  figureData,
+  gfaFigureData
+};

package/dist/chunks/chunk-OPPVSPEF.js

@@ -0,0 +1,57 @@
+// src/layout/smoothChains.ts
+var STEP_TURN = Math.PI / 24;
+function turnAt(line, i) {
+  const a = line[i - 1];
+  const b = line[i];
+  const c = line[i + 1];
+  if (!a || !c) {
+    return 0;
+  }
+  const t = Math.abs(
+    Math.atan2(c.y - b.y, c.x - b.x) - Math.atan2(b.y - a.y, b.x - a.x)
+  );
+  return t > Math.PI ? 2 * Math.PI - t : t;
+}
+function centripetal(p0, p1, p2, p3, u) {
+  const knot = (a, b) => Math.max(Math.hypot(b.x - a.x, b.y - a.y) ** 0.5, 1e-9);
+  const t1 = knot(p0, p1);
+  const t2 = t1 + knot(p1, p2);
+  const t3 = t2 + knot(p2, p3);
+  const t = t1 + u * (t2 - t1);
+  const lerp = (a, b, ta, tb) => {
+    const f = (t - ta) / (tb - ta);
+    return { x: a.x + (b.x - a.x) * f, y: a.y + (b.y - a.y) * f };
+  };
+  const a1 = lerp(p0, p1, 0, t1);
+  const a2 = lerp(p1, p2, t1, t2);
+  const a3 = lerp(p2, p3, t2, t3);
+  return lerp(lerp(a1, a2, 0, t2), lerp(a2, a3, t1, t3), t1, t2);
+}
+var reflect = (p, about) => ({
+  x: 2 * about.x - p.x,
+  y: 2 * about.y - p.y
+});
+function smoothChain(line) {
+  if (line.length < 3) {
+    return line;
+  }
+  const out = [line[0]];
+  for (let i = 0; i + 1 < line.length; i++) {
+    const p1 = line[i];
+    const p2 = line[i + 1];
+    const steps = Math.ceil(
+      Math.max(turnAt(line, i), turnAt(line, i + 1)) / STEP_TURN
+    );
+    const p0 = line[i - 1] ?? reflect(p2, p1);
+    const p3 = line[i + 2] ?? reflect(p1, p2);
+    for (let s = 1; s < steps; s++) {
+      out.push(centripetal(p0, p1, p2, p3, s / steps));
+    }
+    out.push(p2);
+  }
+  return out;
+}
+
+export {
+  smoothChain
+};

package/dist/chunks/{chunk-ZBLKAWSD.js → chunk-PT37VS5B.js}

@@ -1,6 +1,6 @@
 import {
   clampZoom
-} from "./chunk-FPTI3WAV.js";
+} from "./chunk-HRAU4VTB.js";
 
 // src/viewport.ts
 function axisScaleOf(scale, pixelRows) {