@jbrowse/bandage-core 10.2.6 → 10.3.0

package/dist/chunks/{chunk-CWFNEKST.js → chunk-A7H753BA.js}

@@ -34,13 +34,13 @@ function mismatchesByStep(record, lengths) {
   const startOf = (k) => starts[known[k]];
   const endOf = (k) => startOf(k) + lengths[known[k]];
   let first = 0;
-  const stepAt = (pos2, atEnd = false) => {
+  const stepAt = (pos2) => {
     while (first < known.length && endOf(first) < pos2) {
       first++;
     }
     for (let k = first; k < known.length && startOf(k) <= pos2; k++) {
       const end = endOf(k);
-      if (pos2 < end || atEnd && pos2 === end) {
+      if (pos2 < end) {
         return { s: known[k], local: pos2 - startOf(k), room: end - pos2 };
       }
     }
@@ -74,7 +74,7 @@ function mismatchesByStep(record, lengths) {
       }
       pos += 1;
     } else if (op.op === "insertion") {
-      const at = stepAt(pos, pos === record.pathEnd);
+      const at = pos > record.pathStart && pos < record.pathEnd ? stepAt(pos) : void 0;
       if (at) {
         add(at.s, { type: "insertion", pos: at.local, seq: op.seq });
       }

package/dist/chunks/{chunk-FB5RKZQY.js → chunk-AMX4OQAW.js}

@@ -3,40 +3,37 @@ import {
 } from "./chunk-JMABOQWL.js";
 import {
   layoutModeByValue
-} from "./chunk-TKIJ5535.js";
+} from "./chunk-MD5VPXXT.js";
 import {
   parseRegion
-} from "./chunk-VQWHMWLF.js";
+} from "./chunk-M5NPD55W.js";
 import {
   version
-} from "./chunk-YYMW5XOF.js";
+} from "./chunk-PTQPTDZH.js";
 import {
   axisScaleOf
-} from "./chunk-BS4UZ44I.js";
-import {
-  walkKey
-} from "./chunk-4ETPXDO6.js";
+} from "./chunk-WONB6LMC.js";
 import {
   figureScene
-} from "./chunk-HFVGGB3U.js";
+} from "./chunk-XUT4HXVE.js";
 import {
   abgrAlpha,
   abgrBlue,
   abgrGreen,
   abgrRed
 } from "./chunk-G2FD7S3C.js";
+import {
+  FIGURE_DEFAULTS
+} from "./chunk-ZPBEUOBM.js";
 import {
   engineSettingsOf,
   fitTransform,
   forceLayout,
   loadGraph
-} from "./chunk-2QLLQJ72.js";
+} from "./chunk-KWHWNOTY.js";
 import {
   isBackbone
-} from "./chunk-FYQWPEEY.js";
-import {
-  facetCells
-} from "./chunk-XV4P5KEQ.js";
+} from "./chunk-RJWPJCIB.js";
 
 // src/figureData.ts
 function columns(keys) {
@@ -59,19 +56,18 @@ 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 width = o.width ?? FIGURE_DEFAULTS.width;
+  const height = o.height ?? FIGURE_DEFAULTS.height;
   const pixelRows = layout.pixelRows ?? false;
   const {
     bounds,
     colorScheme,
     drawnDeletions,
     lift,
-    facet,
-    panels: facetted,
+    facets,
     labelOf,
     referenceName,
-    reference,
+    keyText,
     geometry
   } = figureScene(graph, layout, o);
   const fit = fitTransform(bounds, width, height, pixelRows);
@@ -80,20 +76,15 @@ function figureData(graph, layout, o = {}) {
   }
   const axis = axisScaleOf(fit.scale, pixelRows);
   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);
+  if (facets) {
+    const ordered = facets.panels.map((panel, i) => ({ panel, cell: facets.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);
+      const key = keyText(walk);
       panels.push({
         highlight: panel,
         name: labelOf(walk.name),
-        key: key.delta + key.outside + key.reversed,
+        key: key.note,
         range: key.scale ?? ""
       });
     }

package/dist/chunks/{chunk-RPRHR56C.js → chunk-BS6HPYCZ.js}

@@ -1,13 +1,13 @@
 import {
   polylineSlice
-} from "./chunk-N73TI3VG.js";
+} from "./chunk-BZFOFC4D.js";
 import {
   svgPath
-} from "./chunk-7SRWJLSC.js";
+} from "./chunk-UBQSRCWR.js";
 import {
   firstNodeAtOrAfter,
   isAnchored
-} from "./chunk-FYQWPEEY.js";
+} from "./chunk-RJWPJCIB.js";
 
 // src/genes/genePins.ts
 function genePins(graph, genes, positions) {

package/dist/chunks/chunk-BSOZW3FC.js

@@ -0,0 +1,30 @@
+// src/util/groups.ts
+function pushTo(map, key, value) {
+  const list = map.get(key);
+  if (list) {
+    list.push(value);
+  } else {
+    map.set(key, [value]);
+  }
+}
+function addTo(map, key, value) {
+  const set = map.get(key);
+  if (set) {
+    set.add(value);
+  } else {
+    map.set(key, /* @__PURE__ */ new Set([value]));
+  }
+}
+function groupBy(items, keyOf) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    pushTo(groups, keyOf(item), item);
+  }
+  return groups;
+}
+
+export {
+  pushTo,
+  addTo,
+  groupBy
+};

package/dist/chunks/{chunk-CU6P5RUG.js → chunk-BVYR7IFN.js}

@@ -1,30 +1,36 @@
 import {
   encodedColor,
   resolveEncoding
-} from "./chunk-VQC7KELB.js";
+} from "./chunk-V7J6U4XC.js";
 import {
   pathOrigin
-} from "./chunk-M6LK4GII.js";
+} from "./chunk-LGJBB5BP.js";
 import {
   panSNContig
-} from "./chunk-BPLIXMH7.js";
+} from "./chunk-4XWZNPQ2.js";
 
 // src/walkHighlight.ts
 var isReference = (graph, name) => !!graph.referencePath && pathOrigin(name).name === graph.referencePath;
 function piecesOf(graph, name) {
   return (graph.paths ?? []).filter((p) => p.name === name).sort((a, b) => (a.start ?? 0) - (b.start ?? 0));
 }
+var nodesById = (graph) => new Map(graph.nodes.map((n) => [n.id, n]));
+function graphIndex(graph) {
+  const edgeAt = /* @__PURE__ */ new Map();
+  graph.edges.forEach((e, i) => {
+    edgeAt.set(`${e.from}>${e.to}`, i);
+  });
+  return { byId: nodesById(graph), edgeAt };
+}
 function walkHighlight(graph, name) {
+  return highlightOf(graph, name, graphIndex(graph));
+}
+function highlightOf(graph, name, { byId, edgeAt }) {
   const pieces = piecesOf(graph, name);
   const first = pieces[0];
   if (!first) {
     return void 0;
   }
-  const byId = new Map(graph.nodes.map((n) => [n.id, n]));
-  const edgeAt = /* @__PURE__ */ new Map();
-  graph.edges.forEach((e, i) => {
-    edgeAt.set(`${e.from}>${e.to}`, i);
-  });
   const lengthOf = (id) => byId.get(id)?.length ?? 0;
   const bpOf = (path) => path.nodeIds.reduce((sum, id) => sum + lengthOf(id), 0);
   const bp = pieces.reduce((sum, piece) => sum + bpOf(piece), 0);
@@ -83,8 +89,7 @@ function walkHighlight(graph, name) {
     referenceBp: referenceSpan()
   };
 }
-function laneColors(graph, walk, encoding, ramp) {
-  const byId = new Map(graph.nodes.map((n) => [n.id, n]));
+function laneColors(byId, walk, encoding, ramp) {
   const colors = /* @__PURE__ */ new Map();
   for (const [id, progress] of walk.progress) {
     const node = byId.get(id);
@@ -94,7 +99,7 @@ function laneColors(graph, walk, encoding, ramp) {
   }
   return colors;
 }
-function reversedNodes(graph, walk) {
+function reversedNodes(graph, byId, walk) {
   const reversed = /* @__PURE__ */ new Set();
   let bp = 0;
   const referencePath = graph.referencePath;
@@ -107,7 +112,6 @@ function reversedNodes(graph, walk) {
   }
   const own = visits.pathIndex(pathOrigin(walk.name).name);
   const theirs = visits.pathIndex(referencePath);
-  const byId = new Map(graph.nodes.map((n) => [n.id, n]));
   for (const id of walk.progress.keys()) {
     const node = byId.get(id);
     const slot = node ? visits.slot(node.name) : -1;
@@ -121,9 +125,10 @@ function reversedNodes(graph, walk) {
   return { reversed, bp };
 }
 function walkLift(graph, layers, ramp) {
+  const index = graphIndex(graph);
   const seen = /* @__PURE__ */ new Set();
   const lifted = layers.filter((layer) => !seen.has(layer.walk) && seen.add(layer.walk)).flatMap((layer) => {
-    const walk = walkHighlight(graph, layer.walk);
+    const walk = highlightOf(graph, layer.walk, index);
     return walk ? [{ walk, layer }] : [];
   }).sort((a, b) => Number(b.walk.reference) - Number(a.walk.reference));
   if (lifted.length === 0) {
@@ -137,11 +142,11 @@ function walkLift(graph, layers, ramp) {
       walk.reference ? 0 : picked++,
       lifted.length === 1
     );
-    const { reversed, bp } = reversedNodes(graph, walk);
+    const { reversed, bp } = reversedNodes(graph, index.byId, walk);
     return {
       ...walk,
       encoding,
-      colors: laneColors(graph, walk, encoding, ramp),
+      colors: laneColors(index.byId, walk, encoding, ramp),
       reversed,
       reversedBp: bp
     };
@@ -150,6 +155,7 @@ function walkLift(graph, layers, ramp) {
 }
 var FACET_COLOR = { field: "progress", scheme: "red" };
 function facetLifts(graph, lift, layers, ramp) {
+  const byId = nodesById(graph);
   return lift.walks.map((walk) => {
     const stated = layers.find((l) => l.walk === walk.name)?.color;
     const encoding = resolveEncoding(
@@ -162,7 +168,7 @@ function facetLifts(graph, lift, layers, ramp) {
         {
           ...walk,
           encoding,
-          colors: laneColors(graph, walk, encoding, ramp)
+          colors: laneColors(byId, walk, encoding, ramp)
         }
       ],
       ramp

package/dist/chunks/{chunk-XXT2JCAC.js → chunk-BX4AUMZE.js}

@@ -1,5 +1,9 @@
 // src/tubeMap/mismatches.ts
-import { forward, getXCoordinateOfBaseWithinNode } from "@jbrowse/tubemap-core";
+import {
+  forward,
+  getXCoordinateOfBaseWithinNode,
+  mirroredMismatch
+} from "@jbrowse/tubemap-core";
 function readMismatches(read, layout) {
   const marks = [];
   const entries = read.sequenceNew ?? [];
@@ -7,22 +11,16 @@ function readMismatches(read, layout) {
   entries.forEach((entry, i) => {
     const nodeIndex = layout.nodeMap.get(forward(entry.nodeName));
     const node = nodeIndex === void 0 ? void 0 : layout.nodes[nodeIndex];
-    const y = visits[i]?.y;
-    if (node && y !== void 0) {
-      const base = { readId: read.id, y, height: read.width };
+    const visit = visits[i];
+    if (node && visit?.y !== void 0) {
+      const base = { readId: read.id, y: visit.y, height: read.width };
       const at = (pos) => getXCoordinateOfBaseWithinNode(node, pos);
-      for (const mm of entry.mismatches) {
+      for (const edit of entry.mismatches) {
+        const mm = visit.isForward ? edit : mirroredMismatch(edit, node.sequenceLength);
         const x0 = at(mm.pos);
         if (x0 !== null) {
           if (mm.type === "insertion") {
-            const softClip = i === 0 && mm.pos === read.firstNodeOffset || i === entries.length - 1 && mm.pos === read.finalNodeCoverLength;
-            marks.push({
-              ...base,
-              kind: "insertion",
-              x: x0,
-              seq: mm.seq,
-              softClip
-            });
+            marks.push({ ...base, kind: "insertion", x: x0, seq: mm.seq });
           } else if (mm.type === "deletion" && mm.length !== void 0) {
             const x1 = at(mm.pos + mm.length);
             if (x1 !== null) {

package/dist/chunks/{chunk-N73TI3VG.js → chunk-BZFOFC4D.js}

@@ -1,10 +1,13 @@
 import {
   ownStrand,
   strandSides
-} from "./chunk-7SRWJLSC.js";
+} from "./chunk-UBQSRCWR.js";
+import {
+  pushTo
+} from "./chunk-BSOZW3FC.js";
 import {
   isBackbone
-} from "./chunk-FYQWPEEY.js";
+} from "./chunk-RJWPJCIB.js";
 
 // src/layout/mergeRuns.ts
 function flip(strand) {
@@ -14,13 +17,7 @@ function mergeRuns(graph, alone = /* @__PURE__ */ new Set()) {
   const sides = graph.edges.map(strandSides);
   const at = /* @__PURE__ */ new Map();
   const attach = (id, side, ei) => {
-    const key = `${id}|${side}`;
-    const list = at.get(key);
-    if (list) {
-      list.push(ei);
-    } else {
-      at.set(key, [ei]);
-    }
+    pushTo(at, `${id}|${side}`, ei);
   };
   graph.edges.forEach((edge, ei) => {
     attach(edge.from, sides[ei].from, ei);

package/dist/chunks/{chunk-4ETPXDO6.js → chunk-CGFPFBT2.js}

@@ -1,7 +1,7 @@
 import {
   formatBp,
   groupDigits
-} from "./chunk-PTABFYQ7.js";
+} from "./chunk-PFRQBCGC.js";
 
 // src/walkKey.ts
 function rangeText(contig, start, end) {

package/dist/chunks/{chunk-24WITXQY.js → chunk-CGMSKIEO.js}

@@ -3,27 +3,20 @@ import {
   edgeJoinOf,
   routedEdgeCurves,
   strandSides
-} from "./chunk-7SRWJLSC.js";
+} from "./chunk-UBQSRCWR.js";
+import {
+  groupBy
+} from "./chunk-BSOZW3FC.js";
 import {
   firstNodeAtOrAfter,
   isBackbone
-} from "./chunk-FYQWPEEY.js";
+} from "./chunk-RJWPJCIB.js";
 
 // src/deletionEdges.ts
 var MIN_DELETION_BP = 1;
 function bypassedPoints(nodePositions, bypassed) {
   return bypassed.flatMap((id) => nodePositions[id] ?? []);
 }
-function deletionArcCurves(nodePositions, deletion, axis, route, stranded = false) {
-  return edgeCurvesOf(
-    nodePositions,
-    deletion,
-    axis,
-    deletion.bypassed,
-    route,
-    stranded
-  );
-}
 function edgeCurvesOf(nodePositions, edge, axis, bypassed, route, stranded) {
   const from = nodePositions[edge.from];
   const to = nodePositions[edge.to];
@@ -44,17 +37,10 @@ function edgeCurvesOf(nodePositions, edge, axis, bypassed, route, stranded) {
   );
 }
 function backboneBySequence(graph) {
-  const bySequence = /* @__PURE__ */ new Map();
-  for (const node of graph.nodes) {
-    if (isBackbone(node)) {
-      const list = bySequence.get(node.stable.refName);
-      if (list) {
-        list.push(node);
-      } else {
-        bySequence.set(node.stable.refName, [node]);
-      }
-    }
-  }
+  const bySequence = groupBy(
+    graph.nodes.filter(isBackbone),
+    (node) => node.stable.refName
+  );
   for (const list of bySequence.values()) {
     list.sort((a, b) => a.stable.start - b.stable.start);
   }
@@ -167,8 +153,6 @@ function deletionDrawing(graph, deletions, show = true) {
 }
 
 export {
-  bypassedPoints,
-  deletionArcCurves,
   edgeCurvesOf,
   deletionEdges,
   closableDeletions,

package/dist/chunks/{chunk-IGVV37VI.js → chunk-CKUVEHSS.js}

@@ -1,12 +1,12 @@
 import {
   buildNeighbors
-} from "./chunk-ES2N6V56.js";
+} from "./chunk-VX656OAZ.js";
 import {
   drawnNodeLength
-} from "./chunk-6JEWNXCQ.js";
+} from "./chunk-34BOZKIE.js";
 import {
   isBackbone
-} from "./chunk-FYQWPEEY.js";
+} from "./chunk-RJWPJCIB.js";
 
 // src/layout/referenceSeeds.ts
 var LANE_GAP = 30;

package/dist/chunks/{chunk-JBCZIBFC.js → chunk-CRCD3ODN.js}

@@ -51,7 +51,6 @@ function nodeInk(graph, nodeById, contigThickness, nodeWidth) {
 export {
   NODE_WIDTHS,
   meanDepth,
-  depthWidthFactor,
   nodeWidthPx,
   maxNodeWidthPx,
   nodeInk

package/dist/chunks/{chunk-PSMKPSO4.js → chunk-DBLV7PGG.js}

@@ -1,14 +1,14 @@
 import {
   PathVisits
-} from "./chunk-RAEABQNW.js";
+} from "./chunk-ZPZ7GNBT.js";
 import {
+  panSNFields,
   panSNSample
-} from "./chunk-BPLIXMH7.js";
+} from "./chunk-4XWZNPQ2.js";
 
 // src/gfa/graphTables.ts
-function walkFields(panSN) {
-  const [sample = "", haplotype = "", ...contig] = panSN.split("#");
-  return { sample, haplotype, contig: contig.join("#") };
+function pLineName(name, start, end) {
+  return start === 0 ? name : `${name}:${start}-${end}`;
 }
 function namesByList(lists, names, listCount, pathNames) {
   const starts = new Int32Array(listCount + 1);
@@ -160,17 +160,27 @@ function graphFromTables({ nodes: n, links: l, walks: w }, name = "Imported GFA"
   const visitOrder = [];
   const blocks = [0];
   const pathSamples = [];
+  const edgeNameIndex = /* @__PURE__ */ new Map();
+  const edgeNames = [];
   for (const p of drawnWalks) {
-    const { sample, haplotype, contig } = walkFields(w.names[p]);
-    const pathName = `${sample}#${+haplotype}#${contig}`;
-    let named = nameIndex.get(pathName);
+    const walkName = w.names[p];
+    const fields = panSNFields(walkName);
+    const start = w.starts[p];
+    const visitName = fields ? `${fields.sample}#${fields.haplotype}#${fields.contig}` : walkName;
+    const pathName = fields ? visitName : pLineName(walkName, start, w.ends[p]);
+    let named = nameIndex.get(visitName);
     if (named === void 0) {
       named = pathNames.length;
-      nameIndex.set(pathName, named);
-      pathNames.push(pathName);
-      pathSamples.push(panSNSample(pathName));
+      nameIndex.set(visitName, named);
+      pathNames.push(visitName);
+      pathSamples.push(panSNSample(visitName));
+    }
+    let edgeNamed = edgeNameIndex.get(pathName);
+    if (edgeNamed === void 0) {
+      edgeNamed = edgeNames.length;
+      edgeNameIndex.set(pathName, edgeNamed);
+      edgeNames.push(pathName);
     }
-    const start = w.starts[p];
     const visitSample = pathSamples[named];
     const first = w.offsets[p];
     const nodeIds = new Array(w.offsets[p + 1] - first);
@@ -194,21 +204,14 @@ function graphFromTables({ nodes: n, links: l, walks: w }, name = "Imported GFA"
         if (list >= 0 && lastWalk[list] !== p) {
           lastWalk[list] = p;
           crossedList[crossings] = list;
-          crossedName[crossings++] = named;
+          crossedName[crossings++] = edgeNamed;
         }
       }
       prev = node;
     }
-    paths.push({
-      name: pathName,
-      nodeIds,
-      start,
-      sample,
-      haplotype: +haplotype,
-      contig
-    });
+    paths.push({ name: pathName, nodeIds, start, ...fields });
     anchorPaths.push({
-      name: pathName,
+      name: visitName,
       sample: visitSample,
       start,
       length: pos - start
@@ -218,7 +221,7 @@ function graphFromTables({ nodes: n, links: l, walks: w }, name = "Imported GFA"
     crossedList.subarray(0, crossings),
     crossedName,
     lists,
-    pathNames
+    edgeNames
   );
   edges.forEach((edge, i) => {
     const names = listNames[edgeLists[i]];
@@ -260,13 +263,16 @@ function graphTablesGFA({ nodes, links, walks }) {
     );
   }
   for (let p = 0; p < walks.names.length; p++) {
-    const { sample, haplotype, contig } = walkFields(walks.names[p]);
-    let body = "";
+    const name = walks.names[p];
+    const fields = panSNFields(name);
+    const start = walks.starts[p];
+    const end = walks.ends[p];
+    const steps = [];
     for (let s = walks.offsets[p]; s < walks.offsets[p + 1]; s++) {
-      body += (walks.reversed[s] ? "<" : ">") + names[walks.steps[s]];
+      steps.push([names[walks.steps[s]], walks.reversed[s]]);
     }
     lines.push(
-      `W	${sample}	${haplotype}	${contig}	${walks.starts[p]}	${walks.ends[p]}	${body}`
+      fields ? `W	${fields.sample}	${fields.haplotype}	${fields.contig}	${start}	${end}	${steps.map(([id, rev]) => (rev ? "<" : ">") + id).join("")}` : `P	${pLineName(name, start, end)}	${steps.map(([id, rev]) => id + (rev ? "-" : "+")).join(",")}	*`
     );
   }
   return lines.join("\n");

package/dist/chunks/{chunk-JA2HJIYS.js → chunk-E4ZM4OOJ.js}

@@ -1,13 +1,13 @@
 import {
   bubbleSegmentIds,
   classifyBubble
-} from "./chunk-URZ3CH2R.js";
+} from "./chunk-A4JDEUAI.js";
 import {
   svgPath
-} from "./chunk-7SRWJLSC.js";
+} from "./chunk-UBQSRCWR.js";
 import {
   isBackbone
-} from "./chunk-FYQWPEEY.js";
+} from "./chunk-RJWPJCIB.js";
 
 // src/bubbles/bubbleHalos.ts
 var WHOLE_FRACTION = 0.9;
@@ -64,8 +64,6 @@ function bubbleHalos(graph, bubbles, positions, repeats = []) {
 }
 
 export {
-  WHOLE_FRACTION,
   coversGraph,
-  SMALL_VARIANT_BP,
   bubbleHalos
 };