@jbrowse/bandage-core 11.7.3 → 11.9.0

package/dist/chunks/{chunk-XKPXOIWD.js → chunk-JVT3XTKN.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-OPPVSPEF.js";
 import {
   orientToReference
-} from "./chunk-ZZZ6NVLW.js";
+} from "./chunk-NAYS472K.js";
 import {
   seededNodes
 } from "./chunk-CKUVEHSS.js";
@@ -27,7 +27,7 @@ import {
 import {
   mergeRuns,
   splitRuns
-} from "./chunk-2VMKQKVO.js";
+} from "./chunk-HNNP5QUN.js";
 import {
   spreadFor
 } from "./chunk-HKYXWZQS.js";
@@ -39,7 +39,7 @@ import {
 import {
   deletionDrawing,
   deletionEdges
-} from "./chunk-P276TWPM.js";
+} from "./chunk-3GORESBG.js";
 import {
   anchorGraph
 } from "./chunk-3YBP46PB.js";

package/dist/chunks/{chunk-SDI6BVG7.js → chunk-KKHXMJEE.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-5OJZV6YT.js";
 import {
   ownStrand
-} from "./chunk-VACK24HF.js";
+} from "./chunk-JJV2GT2Z.js";
 
 // src/tubeMap/reads.ts
 function stepName(node, strand) {

package/dist/chunks/{chunk-G7SG4XMK.js → chunk-LODKC7PJ.js}

@@ -13,6 +13,7 @@ import {
 } from "./chunk-BSOZW3FC.js";
 import {
   panSNContig,
+  panSNHaplotype,
   panSNSample
 } from "./chunk-2JL2JVZ2.js";
 
@@ -466,6 +467,12 @@ function walkRowRuns(source, region, o = {}) {
     meta: rowOf(pieces),
     row: i + 1
   }));
+  const metas = [referenceRow, ...rows.map((r) => r.meta)];
+  if (new Set(metas.map((m) => m.label)).size < metas.length) {
+    for (const meta of metas) {
+      meta.label = panSNHaplotype(meta.name) ?? meta.label;
+    }
+  }
   rows.sort(
     (a, b) => Number(b.meta.complete) - Number(a.meta.complete) || b.meta.bp - a.meta.bp || a.meta.label.localeCompare(b.meta.label)
   );

package/dist/chunks/{chunk-AJQRKN3X.js → chunk-N3DCLT7M.js}

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

package/dist/chunks/{chunk-ZZZ6NVLW.js → chunk-NAYS472K.js}

@@ -1,6 +1,6 @@
 import {
   ownStrand
-} from "./chunk-VACK24HF.js";
+} from "./chunk-JJV2GT2Z.js";
 import {
   isBackbone
 } from "./chunk-RJWPJCIB.js";

package/dist/chunks/{chunk-AWJJSA7D.js → chunk-NWEVR2OQ.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-FX4RDMDN.js";
 import {
   formatBp
-} from "./chunk-N73RA4DR.js";
+} from "./chunk-AURNOR27.js";
 
 // src/bubbles/classifyBubble.ts
 var REPEAT_GROWTH = 10;

package/dist/chunks/{chunk-33KUO34R.js → chunk-P2GJBFNA.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-HMXCN6PG.js";
 import {
   edgeCurvesOf
-} from "./chunk-P276TWPM.js";
+} from "./chunk-3GORESBG.js";
 
 // src/util/edgeCurves.ts
 var cache = weakMemo();

package/dist/chunks/{chunk-IHM43Y7B.js → chunk-RT4U3DH3.js}

@@ -1,6 +1,6 @@
 import {
   tubeSpan
-} from "./chunk-W5YRBEWQ.js";
+} from "./chunk-I53QYITQ.js";
 
 // src/tubeMap/genes.ts
 function tubeMapGenes(byRefName, genes) {

package/dist/chunks/{chunk-XTCIKBWM.js → chunk-S6E3PMH7.js}

@@ -1,6 +1,6 @@
 import {
   pathSteps
-} from "./chunk-63XWYNID.js";
+} from "./chunk-BDS5VZYZ.js";
 import {
   pathOrigin
 } from "./chunk-3YBP46PB.js";

package/dist/chunks/{chunk-BLDUBB7X.js → chunk-SZYFZNCO.js}

@@ -1,10 +1,10 @@
 import {
   bubbleSegmentIds,
   classifyBubble
-} from "./chunk-AWJJSA7D.js";
+} from "./chunk-NWEVR2OQ.js";
 import {
   svgPath
-} from "./chunk-VACK24HF.js";
+} from "./chunk-JJV2GT2Z.js";
 import {
   isBackbone
 } from "./chunk-RJWPJCIB.js";

package/dist/chunks/{chunk-T3MEG5D3.js → chunk-T2UNTWU5.js}

@@ -3,25 +3,30 @@ import {
 } from "./chunk-CO6RGQAD.js";
 import {
   layoutModeByValue
-} from "./chunk-VNF236GG.js";
+} from "./chunk-ARXDNQLF.js";
 import {
   parseRegion
 } from "./chunk-FNDNSDKW.js";
 import {
   genePins
-} from "./chunk-BFUS3ENH.js";
+} from "./chunk-HEYIAMTC.js";
 import {
   version
-} from "./chunk-AJQRKN3X.js";
+} from "./chunk-N3DCLT7M.js";
 import {
   axisScaleOf
-} from "./chunk-F4CDC72I.js";
+} from "./chunk-3DHGSHC3.js";
 import {
   figureScene
-} from "./chunk-UTDMFVC7.js";
+} from "./chunk-I5CHAYDZ.js";
 import {
   encodingStops
-} from "./chunk-6RB5ZQ34.js";
+} from "./chunk-UEWIGD52.js";
+import {
+  laneSlideAt,
+  passesKey,
+  threadsPasses
+} from "./chunk-3BDQQTXY.js";
 import {
   abgrAlpha,
   abgrBlue,
@@ -30,13 +35,13 @@ import {
 } from "./chunk-G2FD7S3C.js";
 import {
   FIGURE_DEFAULTS
-} from "./chunk-4SN7R4UF.js";
+} from "./chunk-2MXFG3W7.js";
 import {
   engineSettingsOf,
   fitTransform,
   forceLayout,
   loadGraph
-} from "./chunk-XKPXOIWD.js";
+} from "./chunk-JVT3XTKN.js";
 import {
   referenceVisitStarts
 } from "./chunk-3YBP46PB.js";
@@ -86,15 +91,29 @@ function figureData(graph, layout, o = {}) {
   }
   const axis = axisScaleOf(fit.scale, pixelRows);
   const panels = [];
-  const keys = columns(["panel", "walk", "note", "scale", "stops"]);
+  const keys = columns([
+    "panel",
+    "walk",
+    "name",
+    "color",
+    "note",
+    "scale",
+    "stops",
+    "field"
+  ]);
+  const threadKeys = columns(["panel", "note"]);
   const pushKey = (walk, panel) => {
     const key = keyText(walk);
+    const stops = encodingStops(walk.encoding).map((s) => cssHex(s.abgr));
     keys.push({
       panel,
       walk: labelOf(walk.name),
+      name: walk.name,
+      color: walk.encoding.field === "walk" ? stops[0] : "",
       note: key.note,
       scale: key.scale ?? "",
-      stops: encodingStops(walk.encoding).map((s) => cssHex(s.abgr)).join(",")
+      stops: stops.join(","),
+      field: walk.encoding.field
     });
     return key;
   };
@@ -103,19 +122,30 @@ function figureData(graph, layout, o = {}) {
     for (const { panel } of ordered) {
       const walk = panel.walks[0];
       const name = labelOf(walk.name);
+      const firstKeyRow = keys.out.panel.length;
       const key = pushKey(walk, name);
       panels.push({
         highlight: panel,
         name,
         key: key.note,
-        range: key.scale ?? ""
+        range: key.scale ?? "",
+        firstKeyRow
       });
     }
   } else {
     for (const walk of lift?.walks ?? []) {
       pushKey(walk, "");
     }
-    panels.push({ highlight: lift, name: "", key: "", range: "" });
+    if (threadsPasses(lift?.walks ?? [])) {
+      threadKeys.push({ panel: "", note: passesKey(lift?.walks ?? []) });
+    }
+    panels.push({
+      highlight: lift,
+      name: "",
+      key: "",
+      range: "",
+      firstKeyRow: 0
+    });
   }
   const pins = columns(["gene", "x", "y", "covered", "bp"]);
   const exons = columns(["gene", "node", "stretch", "x", "y"]);
@@ -146,7 +176,12 @@ function figureData(graph, layout, o = {}) {
     "y",
     "color",
     "alpha",
-    "width"
+    "width",
+    "walk",
+    "pass",
+    "nx",
+    "ny",
+    "offset"
   ]);
   const edges = columns([
     "panel",
@@ -163,7 +198,15 @@ function figureData(graph, layout, o = {}) {
     "color",
     "alpha",
     "width",
-    "deletion"
+    "deletion",
+    "walk",
+    "pass",
+    "nx",
+    "ny",
+    "offset",
+    "nx1",
+    "ny1",
+    "offset1"
   ]);
   const arrows = columns([
     "panel",
@@ -176,12 +219,18 @@ function figureData(graph, layout, o = {}) {
     "color",
     "alpha"
   ]);
-  for (const { highlight, name: panel } of panels) {
+  for (const { highlight, name: panel, firstKeyRow } of panels) {
     const batch = geometry(highlight, axis);
+    const keyRowOf = (walk) => walk === void 0 ? null : firstKeyRow + walk;
+    const screen = ({ normal, offsetX }) => ({
+      nx: normal.nx,
+      ny: normal.ny,
+      offset: offsetX * axis.scaleX
+    });
     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) {
+        s.points.forEach((p, k) => {
           nodes.push({
             panel,
             node,
@@ -190,15 +239,28 @@ function figureData(graph, layout, o = {}) {
             y: p.y,
             color: cssHex(s.color),
             alpha: alphaOf(s.color),
-            width: s.thickness * 2
+            width: s.thickness * 2,
+            walk: keyRowOf(s.walk),
+            pass: s.pass ?? null,
+            nx: s.normals?.[k]?.nx ?? 0,
+            ny: s.normals?.[k]?.ny ?? 0,
+            offset: (s.offsetX ?? 0) * axis.scaleX
           });
-        }
+        });
       }
     }
     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) {
+        const n = b.curves.length;
+        const start = b.normal && { normal: b.normal, offsetX: b.offsetX ?? 0 };
+        const finish = b.endNormal && {
+          normal: b.endNormal,
+          offsetX: b.endOffsetX ?? 0
+        };
+        const slideAlong = (along) => start && finish ? screen(laneSlideAt(start, finish, along)) : { nx: 0, ny: 0, offset: 0 };
+        b.curves.forEach((c, k) => {
+          const end = slideAlong((k + 1) / n);
           edges.push({
             panel,
             edge,
@@ -207,9 +269,15 @@ function figureData(graph, layout, o = {}) {
             color: cssHex(b.color),
             alpha: alphaOf(b.color),
             width: b.thickness * 2,
-            deletion: drawnDeletions.bypassed.has(edge)
+            deletion: drawnDeletions.bypassed.has(edge),
+            walk: keyRowOf(b.walk),
+            pass: b.pass ?? null,
+            ...slideAlong(k / n),
+            nx1: end.nx,
+            ny1: end.ny,
+            offset1: end.offset
           });
-        }
+        });
       }
     }
     for (const [edge, run] of batch.arrowRuns) {
@@ -253,6 +321,7 @@ function figureData(graph, layout, o = {}) {
       range: panels.map((p) => p.range)
     },
     keys: keys.out,
+    threadKeys: threadKeys.out,
     pins: pins.out,
     exons: exons.out,
     walkNames: [...new Set((graph.paths ?? []).map((p) => p.name))],

package/dist/chunks/{chunk-QJC63NFR.js → chunk-TQ26XEFL.js}

@@ -1,10 +1,10 @@
 import {
   nodesUnderBox
-} from "./chunk-LH436HS2.js";
+} from "./chunk-4JDO7ZLN.js";
 import {
   graphLabels,
   rowLabelBox
-} from "./chunk-N73RA4DR.js";
+} from "./chunk-AURNOR27.js";
 import {
   LABEL_CHAR_PX,
   LABEL_PAD,

package/dist/chunks/{chunk-6RB5ZQ34.js → chunk-UEWIGD52.js}

@@ -1,7 +1,7 @@
 import {
   REFERENCE_RAMP_ALT_COLOR,
   hslToRgb
-} from "./chunk-VXKL2ZLR.js";
+} from "./chunk-GDZQFELP.js";
 import {
   packAbgr
 } from "./chunk-G2FD7S3C.js";
@@ -33,9 +33,40 @@ function resolveEncoding(layer, reference, picked, alone = true) {
   const field = isField(askedField) ? askedField : alone ? "progress" : "walk";
   const family = reference ? "grey" : FAMILIES[picked % FAMILIES.length];
   const scheme = isScheme(askedScheme) ? askedScheme === "rainbow" && field !== "reference" ? family : askedScheme : family;
-  return { field, scheme };
+  const round = Math.floor(picked / FAMILIES.length) % SHADES.length;
+  return field === "walk" && scheme === family && round > 0 ? { field, scheme, shade: SHADES[round] } : alone || field === "walk" ? { field, scheme } : { field, scheme, darkest: TOGETHER_DARKEST };
 }
+var TOGETHER_DARKEST = 0.55;
 var BASE_T = 0.5;
+var SHADES = [BASE_T, 0.85, 0.2];
+var STRETCH_GAP = 0.08;
+var rampsOn = ({ field, scheme }) => field !== "walk" && scheme !== "rainbow";
+function splitFamilies(encodings) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const e of encodings) {
+    if (rampsOn(e)) {
+      counts.set(e.scheme, (counts.get(e.scheme) ?? 0) + 1);
+    }
+  }
+  const seen = /* @__PURE__ */ new Map();
+  return encodings.map((e) => {
+    const k = rampsOn(e) ? counts.get(e.scheme) : 1;
+    if (k < 2) {
+      return e;
+    }
+    const j = seen.get(e.scheme) ?? 0;
+    seen.set(e.scheme, j + 1);
+    const half = STRETCH_GAP / 2;
+    return {
+      ...e,
+      stretch: [
+        j / k + (j > 0 ? half : 0),
+        (j + 1) / k - (j < k - 1 ? half : 0)
+      ]
+    };
+  });
+}
+var along = ({ stretch }, t) => stretch ? stretch[0] + (stretch[1] - stretch[0]) * t : t;
 var toLinear = (c) => c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
 var toGamma = (c) => c <= 31308e-7 ? c * 12.92 : 1.055 * c ** (1 / 2.4) - 0.055;
 function oklab(hex) {
@@ -72,7 +103,7 @@ function oklabEnds(scheme) {
   }
   return endsCache.get(scheme);
 }
-function schemeRgb(scheme, t) {
+function schemeRgb(scheme, t, darkest = 0) {
   const x = Math.max(0, Math.min(1, t));
   const ends = oklabEnds(scheme);
   if (!ends) {
@@ -83,27 +114,32 @@ function schemeRgb(scheme, t) {
     ).map((c) => c * 255);
   }
   const [from, to] = ends;
-  return oklabToRgb(from.map((v, i) => v + (to[i] - v) * x));
+  const light = from[0];
+  const dark = to[0];
+  const reach = dark < darkest && light > darkest ? (light - darkest) / (light - dark) : 1;
+  return oklabToRgb(from.map((v, i) => v + (to[i] - v) * x * reach));
 }
-function schemeCss(scheme, t) {
-  const [r, g, b] = schemeRgb(scheme, t).map(Math.round);
+function schemeCss(scheme, t, darkest) {
+  const [r, g, b] = schemeRgb(scheme, t, darkest).map(Math.round);
   return `rgb(${r}, ${g}, ${b})`;
 }
-function schemeColor(scheme, t) {
-  const [r, g, b] = schemeRgb(scheme, t).map(Math.round);
+function schemeColor(scheme, t, darkest) {
+  const [r, g, b] = schemeRgb(scheme, t, darkest).map(Math.round);
   return packAbgr(r, g, b, 255);
 }
-function encodedColor({ field, scheme }, t) {
-  return field === "walk" ? schemeColor(scheme, BASE_T) : t === void 0 ? NO_VALUE_COLOR : schemeColor(scheme, t);
+function encodedColor(encoding, t) {
+  const { field, scheme, darkest, shade = BASE_T } = encoding;
+  return field === "walk" ? schemeColor(scheme, shade) : t === void 0 ? NO_VALUE_COLOR : schemeColor(scheme, along(encoding, t), darkest);
 }
 var NO_VALUE_COLOR = REFERENCE_RAMP_ALT_COLOR;
-function encodingStops({ field, scheme }) {
+function encodingStops(encoding) {
+  const { field, scheme, darkest, shade = BASE_T } = encoding;
   const stop = (offset, t) => ({
     offset,
-    color: schemeCss(scheme, t),
-    abgr: schemeColor(scheme, t)
+    color: schemeCss(scheme, t, darkest),
+    abgr: schemeColor(scheme, t, darkest)
   });
-  return field === "walk" ? [stop(0, BASE_T)] : Array.from({ length: 7 }, (_, i) => stop(i / 6, i / 6));
+  return field === "walk" ? [stop(0, shade)] : Array.from({ length: 7 }, (_, i) => stop(i / 6, along(encoding, i / 6)));
 }
 function encodingSwatchCss(encoding) {
   const stops = encodingStops(encoding);
@@ -114,6 +150,7 @@ export {
   WALK_FIELDS,
   WALK_SCHEMES,
   resolveEncoding,
+  splitFamilies,
   schemeRgb,
   schemeCss,
   schemeColor,

package/dist/chunks/{chunk-SENPGW4O.js → chunk-VCUOYVLC.js}

@@ -1,6 +1,6 @@
 import {
   walkRows
-} from "./chunk-BXE3SBBN.js";
+} from "./chunk-C3KAPREU.js";
 import {
   ROW_HEIGHT_PX
 } from "./chunk-CPMHA4W5.js";

package/dist/chunks/{chunk-CL6ELLVF.js → chunk-VNCHWWLG.js}

@@ -1,6 +1,6 @@
 import {
   pathSteps
-} from "./chunk-63XWYNID.js";
+} from "./chunk-BDS5VZYZ.js";
 import {
   pathOrigin
 } from "./chunk-3YBP46PB.js";

package/dist/chunks/{chunk-GD6RUZU5.js → chunk-VQ353UDK.js}

@@ -1,6 +1,6 @@
 import {
   groupDigits
-} from "./chunk-N73RA4DR.js";
+} from "./chunk-AURNOR27.js";
 import {
   pathOrigin
 } from "./chunk-3YBP46PB.js";
@@ -52,18 +52,24 @@ function pathLegend(paths, colors) {
       firstOf.set(path.name, i);
     }
   });
-  const entries = [...firstOf].map(([name, i]) => ({ name, i }));
+  const entries = [...firstOf].map(([name2, i]) => ({ name: name2, i }));
   const named = entries.map((e) => labelTiers(e.name));
-  const candidates = [0, 1, 2].flatMap((t) => [
-    entries.map((_, k) => named[k][t]),
-    entries.map((e, k) => offsetTiers(e.name, named[k])[t])
-  ]);
+  const name = (t) => entries.map((_, k) => named[k][t]);
+  const offset = (t) => entries.map((e, k) => offsetTiers(e.name, named[k])[t]);
+  const candidates = [
+    name(0),
+    name(1),
+    offset(0),
+    name(2),
+    offset(1),
+    offset(2)
+  ];
   const distinct = candidates.find(
     (labels2) => new Set(labels2).size === entries.length
   );
   const labels = distinct ?? candidates.at(-1);
-  return entries.map(({ name, i }, k) => ({
-    name,
+  return entries.map(({ name: name2, i }, k) => ({
+    name: name2,
     label: labels[k],
     color: colors?.[i] ?? pathCssColor(i, paths.length)
   }));

package/dist/chunks/{chunk-QLLKALSH.js → chunk-VTGQCLGI.js}

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

package/dist/chunks/{chunk-Z4HXW6ZH.js → chunk-ZWBQ4RRK.js}

@@ -1,10 +1,11 @@
 import {
   encodedColor,
-  resolveEncoding
-} from "./chunk-6RB5ZQ34.js";
+  resolveEncoding,
+  splitFamilies
+} from "./chunk-UEWIGD52.js";
 import {
   rampFraction
-} from "./chunk-VXKL2ZLR.js";
+} from "./chunk-GDZQFELP.js";
 import {
   gapParts
 } from "./chunk-LG2UK4MB.js";
@@ -54,6 +55,8 @@ function highlightOf(graph, name, { byId, edgeAt }) {
   const nodeIds = /* @__PURE__ */ new Set();
   const edgeIndexes = /* @__PURE__ */ new Set();
   const progress = /* @__PURE__ */ new Map();
+  const passes = /* @__PURE__ */ new Map();
+  let mostPasses = 1;
   let before = 0;
   for (const piece of pieces) {
     if (range) {
@@ -61,6 +64,9 @@ function highlightOf(graph, name, { byId, edgeAt }) {
     }
     piece.nodeIds.forEach((id, i) => {
       nodeIds.add(id);
+      const passed = (passes.get(id) ?? 0) + 1;
+      passes.set(id, passed);
+      mostPasses = Math.max(mostPasses, passed);
       if (i > 0) {
         const a = piece.nodeIds[i - 1];
         const index = edgeAt.get(`${a}>${id}`) ?? edgeAt.get(`${id}>${a}`);
@@ -107,6 +113,9 @@ function highlightOf(graph, name, { byId, edgeAt }) {
     nodeIds,
     edgeIndexes,
     progress,
+    passes,
+    mostPasses,
+    route: pieces.map((piece) => piece.nodeIds),
     steps: pieces.reduce((sum, piece) => sum + piece.nodeIds.length, 0),
     bp,
     referenceBp: referenceSpan(),
@@ -159,13 +168,18 @@ function walkLift(graph, layers, ramp) {
     return void 0;
   }
   let picked = 0;
-  const walks = lifted.map(({ walk, layer }) => {
-    const encoding = resolveEncoding(
-      layer,
-      walk.reference,
-      walk.reference ? 0 : picked++,
-      lifted.length === 1
-    );
+  const encodings = splitFamilies(
+    lifted.map(
+      ({ walk, layer }) => resolveEncoding(
+        layer,
+        walk.reference,
+        walk.reference ? 0 : picked++,
+        lifted.length === 1
+      )
+    )
+  );
+  const walks = lifted.map(({ walk }, i) => {
+    const encoding = encodings[i];
     const { reversed, bp } = reversedNodes(graph, index.byId, walk);
     return {
       ...walk,