@jbrowse/bandage-core 9.9.2 → 10.0.0

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

@@ -1,3 +1,6 @@
+import {
+  PathVisits
+} from "./chunk-RAEABQNW.js";
 import {
   panSNSample
 } from "./chunk-BPLIXMH7.js";
@@ -7,6 +10,32 @@ function walkFields(panSN) {
   const [sample = "", haplotype = "", ...contig] = panSN.split("#");
   return { sample, haplotype, contig: contig.join("#") };
 }
+function namesByList(lists, names, listCount, pathNames) {
+  const starts = new Int32Array(listCount + 1);
+  for (const list of lists) {
+    starts[list + 1]++;
+  }
+  for (let i = 0; i < listCount; i++) {
+    starts[i + 1] += starts[i];
+  }
+  const fill = starts.slice(0, listCount);
+  const grouped = new Int32Array(lists.length);
+  lists.forEach((list, i) => {
+    grouped[fill[list]++] = names[i];
+  });
+  const listed = new Int32Array(pathNames.length).fill(-1);
+  return Array.from({ length: listCount }, (_, list) => {
+    const out = [];
+    for (let i = starts[list]; i < starts[list + 1]; i++) {
+      const k = grouped[i];
+      if (listed[k] !== list) {
+        listed[k] = list;
+        out.push(pathNames[k]);
+      }
+    }
+    return out;
+  });
+}
 function graphFromTables({ nodes: n, links: l, walks: w }, name = "Imported GFA") {
   const count = n.names.length;
   const declared = n.lengths.length;
@@ -95,27 +124,54 @@ function graphFromTables({ nodes: n, links: l, walks: w }, name = "Imported GFA"
     }
     edgeLists.push(list);
   }
+  const adjacency = new Int32Array(count + 1);
+  for (let a = 0; a < count; a++) {
+    adjacency[a + 1] = adjacency[a] + (neighbours[a]?.length ?? 0) / 2;
+  }
+  const adjacentNode = new Int32Array(adjacency[count]);
+  const adjacentList = new Int32Array(adjacency[count]);
+  neighbours.forEach((near, a) => {
+    for (let j = 0; j < near.length; j += 2) {
+      adjacentNode[adjacency[a] + j / 2] = near[j];
+      adjacentList[adjacency[a] + j / 2] = near[j + 1];
+    }
+  });
+  const listOf = (a, b) => {
+    for (let j = adjacency[a]; j < adjacency[a + 1]; j++) {
+      if (adjacentNode[j] === b) {
+        return adjacentList[j];
+      }
+    }
+    return -1;
+  };
   const nameIndex = /* @__PURE__ */ new Map();
   const pathNames = [];
-  const crossing = Array.from({ length: lists }, () => []);
+  const crossedList = new Int32Array(w.offsets[w.names.length] ?? 0);
+  const crossedName = new Int32Array(crossedList.length);
+  let crossings = 0;
   const lastWalk = new Int32Array(lists).fill(-1);
   const paths = [];
   const anchorPaths = [];
-  const visits = new Array(count);
-  const filled = new Int32Array(count);
+  const totalSteps = w.offsets[w.names.length] ?? 0;
+  const visitPath = new Int32Array(totalSteps);
+  const visitStart = new Float64Array(totalSteps);
+  const visitReversed = new Uint8Array(totalSteps);
+  const fill = new Int32Array(count).fill(-1);
   const visitOrder = [];
+  const blocks = [0];
+  const pathSamples = [];
   for (const p of drawnWalks) {
     const { sample, haplotype, contig } = walkFields(w.names[p]);
     const pathName = `${sample}#${+haplotype}#${contig}`;
     let named = nameIndex.get(pathName);
-    const repeat = named !== void 0;
     if (named === void 0) {
       named = pathNames.length;
       nameIndex.set(pathName, named);
       pathNames.push(pathName);
+      pathSamples.push(panSNSample(pathName));
     }
     const start = w.starts[p];
-    const visitSample = panSNSample(pathName);
+    const visitSample = pathSamples[named];
     const first = w.offsets[p];
     const nodeIds = new Array(w.offsets[p + 1] - first);
     let pos = start;
@@ -123,25 +179,22 @@ function graphFromTables({ nodes: n, links: l, walks: w }, name = "Imported GFA"
     for (let s = first; s < w.offsets[p + 1]; s++) {
       const node = w.steps[s];
       nodeIds[s - first] = ids[node];
-      if (filled[node] === 0) {
-        visits[node] = new Array(traversals[node]);
+      if (fill[node] === -1) {
+        fill[node] = blocks.at(-1);
+        blocks.push(fill[node] + traversals[node]);
         visitOrder.push(node);
       }
-      visits[node][filled[node]++] = {
-        path: pathName,
-        sample: visitSample,
-        start: pos,
-        strand: w.reversed[s] ? "-" : "+"
-      };
+      const at = fill[node]++;
+      visitPath[at] = named;
+      visitStart[at] = pos;
+      visitReversed[at] = w.reversed[s];
       pos += node < declared ? n.lengths[node] : 0;
       if (prev >= 0) {
-        const list = pairList(prev, node);
-        if (list !== void 0 && lastWalk[list] !== p) {
+        const list = listOf(prev, node);
+        if (list >= 0 && lastWalk[list] !== p) {
           lastWalk[list] = p;
-          const names = crossing[list];
-          if (!repeat || !names.includes(named)) {
-            names.push(named);
-          }
+          crossedList[crossings] = list;
+          crossedName[crossings++] = named;
         }
       }
       prev = node;
@@ -161,10 +214,16 @@ function graphFromTables({ nodes: n, links: l, walks: w }, name = "Imported GFA"
       length: pos - start
     });
   }
+  const listNames = namesByList(
+    crossedList.subarray(0, crossings),
+    crossedName,
+    lists,
+    pathNames
+  );
   edges.forEach((edge, i) => {
-    const names = crossing[edgeLists[i]];
+    const names = listNames[edgeLists[i]];
     if (names.length > 0) {
-      edge.pathIds = names.map((k) => pathNames[k]);
+      edge.pathIds = names;
     }
   });
   const walked = drawnWalks.length > 0;
@@ -174,7 +233,15 @@ function graphFromTables({ nodes: n, links: l, walks: w }, name = "Imported GFA"
     edges,
     paths: walked ? paths : void 0,
     anchorPaths: walked ? anchorPaths : void 0,
-    pathVisits: walked ? new Map(visitOrder.map((node) => [n.names[node], visits[node]])) : void 0,
+    pathVisits: walked ? new PathVisits({
+      segments: visitOrder.map((node) => n.names[node]),
+      offsets: Int32Array.from(blocks),
+      path: visitPath.subarray(0, blocks.at(-1)),
+      start: visitStart.subarray(0, blocks.at(-1)),
+      reversed: visitReversed.subarray(0, blocks.at(-1)),
+      paths: pathNames,
+      samples: pathSamples
+    }) : void 0,
     anchoredBy: nodes.some((node) => node.stable) ? "tags" : void 0
   };
 }

package/dist/chunks/chunk-Q6IOQP4J.js

@@ -0,0 +1,292 @@
+import {
+  layoutEngine
+} from "./chunk-VK6XMP6B.js";
+import {
+  layoutModeByValue
+} from "./chunk-ICXMWYOA.js";
+import {
+  parseRegion
+} from "./chunk-FLFBYSJO.js";
+import {
+  layoutGeometryInputs
+} from "./chunk-LOCJN3BZ.js";
+import {
+  version
+} from "./chunk-CDPYXHVR.js";
+import {
+  axisScaleOf
+} from "./chunk-OOLNLCIO.js";
+import {
+  facetLifts,
+  walkLift
+} from "./chunk-QIVPRZ4H.js";
+import {
+  walkKey
+} from "./chunk-2LQ5BWT7.js";
+import {
+  buildGeometry,
+  computeReferenceRamp
+} from "./chunk-NP356MC2.js";
+import {
+  abgrAlpha,
+  abgrBlue,
+  abgrGreen,
+  abgrRed
+} from "./chunk-G2FD7S3C.js";
+import {
+  pathLegend,
+  walkLabelsOf
+} from "./chunk-REE4GUDM.js";
+import {
+  drawingBounds,
+  engineSettingsOf,
+  fitTransform,
+  forceLayout,
+  loadGraph
+} from "./chunk-W4GZCVUK.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-LTUWJKHD.js → chunk-Q7LYHGGQ.js}

@@ -4,12 +4,16 @@ import {
 import {
   wellKnownSample
 } from "./chunk-RAKOB6IV.js";
+import {
+  gfaTables
+} from "./chunk-G45YY72K.js";
 import {
   panSNMatchesPrefix,
   panSNSample
 } from "./chunk-BPLIXMH7.js";
 
 // src/gbzWindow.ts
+import { isReverse, nodeId } from "@gmod/gbz-base";
 var NoReferenceSampleError = class extends Error {
   constructor(anchor, referenceSamples) {
     super(
@@ -82,13 +86,12 @@ var GBZ_CUT_DEFAULTS = {
   snarls: "contained",
   limit: 1e5
 };
-async function cutWindowGFA(db, query, start, end, opts) {
-  if (!query) {
-    return "";
-  }
-  const subgraphs = await db.getSubgraphs({ ...opts, path: query, start, end, haplotypes: "all" }).catch((error) => {
+async function windowCuts(db, query, start, end, opts) {
+  return db.getSubgraphs({ ...opts, path: query, start, end, haplotypes: "all" }).catch((error) => {
     throw nodeLimitError(error, opts.limit, end - start) ?? error;
   });
+}
+async function joinedGFA(db, subgraphs) {
   const paths = await db.paths();
   return joinCuts(
     await Promise.all(subgraphs.map((subgraph) => subgraph.toGFA())),
@@ -97,6 +100,109 @@ async function cutWindowGFA(db, query, start, end, opts) {
     )
   );
 }
+async function cutWindowGFA(db, query, start, end, opts) {
+  return query ? joinedGFA(db, await windowCuts(db, query, start, end, opts)) : "";
+}
+async function cutWindowTables(db, query, start, end, opts) {
+  if (!query) {
+    return "";
+  }
+  const subgraphs = await windowCuts(db, query, start, end, opts);
+  if (subgraphs.length === 1) {
+    return compactTables(subgraphs[0].toCompactSubgraph());
+  }
+  const text = await joinedGFA(db, subgraphs);
+  return text && gfaTables(text) || text;
+}
+function segmentIndex(ids, names) {
+  let low = Infinity;
+  let high = -Infinity;
+  for (const id of ids) {
+    low = Math.min(low, id);
+    high = Math.max(high, id);
+  }
+  const span = high - low + 1;
+  const table = ids.length > 0 && span <= 16 * ids.length ? new Int32Array(span).fill(-1) : void 0;
+  const extra = /* @__PURE__ */ new Map();
+  ids.forEach((id, i) => {
+    if (table) {
+      table[id - low] = i;
+    } else {
+      extra.set(id, i);
+    }
+  });
+  return (handle) => {
+    const id = nodeId(handle);
+    const tabled = table !== void 0 && id >= low && id <= high;
+    const i = tabled ? table[id - low] : extra.get(id) ?? -1;
+    if (i >= 0) {
+      return i;
+    }
+    if (tabled) {
+      table[id - low] = names.length;
+    } else {
+      extra.set(id, names.length);
+    }
+    names.push(String(id));
+    return names.length - 1;
+  };
+}
+var WALK_NAME = /^(.*)\[(\d+)-(\d+)\]$/;
+function compactTables(cut) {
+  const names = Array.from(cut.nodeIds, String);
+  const indexOf = segmentIndex(cut.nodeIds, names);
+  const declared = cut.nodeIds.length;
+  const linkCount = cut.edges.length / 2;
+  const from = new Int32Array(linkCount);
+  const to = new Int32Array(linkCount);
+  const strands = new Uint8Array(linkCount);
+  for (let k = 0; k < linkCount; k++) {
+    const a = cut.edges[2 * k];
+    const b = cut.edges[2 * k + 1];
+    from[k] = indexOf(a);
+    to[k] = indexOf(b);
+    strands[k] = (isReverse(a) ? 1 : 0) | (isReverse(b) ? 2 : 0);
+  }
+  const walks = cut.paths.filter((path) => path.steps.length > 0);
+  const offsets = new Int32Array(walks.length + 1);
+  walks.forEach((walk, p) => {
+    offsets[p + 1] = offsets[p] + walk.steps.length;
+  });
+  const steps = new Int32Array(offsets[walks.length]);
+  const reversed = new Uint8Array(steps.length);
+  const starts = new Float64Array(walks.length);
+  const ends = new Float64Array(walks.length);
+  const walkNames = walks.map((walk, p) => {
+    const named = WALK_NAME.exec(walk.name);
+    starts[p] = named ? +named[2] : 0;
+    ends[p] = named ? +named[3] : -1;
+    let at = offsets[p];
+    for (const handle of walk.steps) {
+      steps[at] = indexOf(handle);
+      reversed[at++] = isReverse(handle) ? 1 : 0;
+    }
+    return named ? named[1] : walk.name;
+  });
+  return {
+    nodes: {
+      names,
+      lengths: Int32Array.from(cut.nodeSequences, (s) => s.length),
+      refs: new Int32Array(declared).fill(-1),
+      starts: new Float64Array(declared),
+      ranks: new Int32Array(declared),
+      refNames: []
+    },
+    links: { from, to, strands },
+    walks: {
+      names: walkNames,
+      starts,
+      ends,
+      offsets,
+      steps,
+      reversed
+    }
+  };
+}
 
 export {
   NoReferenceSampleError,
@@ -108,5 +214,7 @@ export {
   referencePathQuery,
   nodeLimitError,
   GBZ_CUT_DEFAULTS,
-  cutWindowGFA
+  cutWindowGFA,
+  cutWindowTables,
+  compactTables
 };

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

@@ -1,10 +1,10 @@
 import {
   encodedColor,
   resolveEncoding
-} from "./chunk-F5BYHLIN.js";
+} from "./chunk-VOWI544A.js";
 import {
   pathOrigin
-} from "./chunk-IGJCTPFB.js";
+} from "./chunk-EMUUNWRU.js";
 import {
   panSNContig
 } from "./chunk-BPLIXMH7.js";
@@ -90,14 +90,19 @@ function reversedNodes(graph, walk) {
   if (!referencePath || walk.reference) {
     return { reversed, bp };
   }
-  const walkPath = pathOrigin(walk.name).name;
+  const visits = graph.pathVisits;
+  if (!visits) {
+    return { reversed, bp };
+  }
+  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 visits = node ? graph.pathVisits?.get(node.name) : void 0;
-    const own = visits?.find((v) => v.path === walkPath)?.strand;
-    const theirs = visits?.find((v) => v.path === referencePath)?.strand;
-    if (own && theirs && own !== theirs) {
+    const slot = node ? visits.slot(node.name) : -1;
+    const a = slot < 0 ? -1 : visits.firstBy(slot, own);
+    const b = slot < 0 ? -1 : visits.firstBy(slot, theirs);
+    if (a >= 0 && b >= 0 && visits.reversed[a] !== visits.reversed[b]) {
       reversed.add(id);
       bp += node.length;
     }

package/dist/chunks/{chunk-J7YKQ5YW.js → chunk-QXAB2FLJ.js}

@@ -4,7 +4,7 @@ import {
 import {
   pathOrigin,
   surveyPaths
-} from "./chunk-IGJCTPFB.js";
+} from "./chunk-EMUUNWRU.js";
 
 // src/gfa/gfaConverter.ts
 function surveySegments(gfaGraph) {