@jbrowse/bandage-core 8.2.0 → 9.0.0

package/dist/chunks/chunk-W2I4DOL4.js

@@ -1,230 +0,0 @@
-import {
-  canonicalStrand,
-  stepName,
-  tubeMapReads
-} from "./chunk-TEDQJPMI.js";
-import {
-  pathCssColor,
-  pathGreyCssColor
-} from "./chunk-7GBL7SJY.js";
-import {
-  pathOrigin
-} from "./chunk-ST2IBUAN.js";
-import {
-  isBackbone
-} from "./chunk-FYQWPEEY.js";
-
-// src/layout/tubeMapLayout.ts
-import { layoutTubeMap } from "@jbrowse/tubemap-core";
-function visitStrands(graph) {
-  const strands = /* @__PURE__ */ new Map();
-  for (const [segment, visits] of graph.pathVisits ?? []) {
-    for (const visit of visits) {
-      const key = `${visit.path}	${segment}`;
-      const list = strands.get(key);
-      if (list) {
-        list.push(visit.strand);
-      } else {
-        strands.set(key, [visit.strand]);
-      }
-    }
-  }
-  return strands;
-}
-function tubeMapTracks(graph) {
-  const nodeById = new Map(graph.nodes.map((n) => [n.id, n]));
-  const strands = visitStrands(graph);
-  const paths = (graph.paths ?? []).map((path, index) => ({ path, index }));
-  const reference = paths.findIndex(
-    (p) => pathOrigin(p.path.name).name === graph.referencePath
-  );
-  if (reference > 0) {
-    paths.unshift(...paths.splice(reference, 1));
-  }
-  return paths.flatMap(({ path, index }) => {
-    const visitName = pathOrigin(path.name).name;
-    const seen = /* @__PURE__ */ new Map();
-    const sequence = path.nodeIds.flatMap((id) => {
-      const node = nodeById.get(id);
-      if (!node) {
-        return [];
-      }
-      const k = seen.get(node.name) ?? 0;
-      seen.set(node.name, k + 1);
-      const strand = strands.get(`${visitName}	${node.name}`)?.[k] ?? canonicalStrand(node);
-      return [stepName(node, strand)];
-    });
-    return sequence.length > 0 ? [
-      {
-        id: index,
-        name: path.name,
-        sequence,
-        sourceTrackID: 0,
-        type: "haplotype"
-      }
-    ] : [];
-  });
-}
-function tubeMapNodes(graph) {
-  return graph.nodes.map((n) => ({
-    name: n.id,
-    seq: "",
-    sequenceLength: Math.max(1, n.length)
-  }));
-}
-function hasTubeMapPaths(graph) {
-  return (graph.paths?.length ?? 0) > 0;
-}
-var STACK_PX = 600;
-var MIN_TUBE_PX = 3;
-var MAX_TUBE_PX = 15;
-function tubeWidth(trackCount) {
-  return Math.max(
-    MIN_TUBE_PX,
-    Math.min(MAX_TUBE_PX, Math.floor(STACK_PX / Math.max(1, trackCount)))
-  );
-}
-function runTubeMap(graph) {
-  const paths = graph.paths ?? [];
-  const tracks = tubeMapTracks(graph);
-  const reads = graph.reads ? tubeMapReads(graph, graph.reads, paths.length) : [];
-  const tubeColor = reads.length > 0 ? pathGreyCssColor : pathCssColor;
-  const pathColors = paths.map((_, i) => tubeColor(i, paths.length));
-  const layout = layoutTubeMap(tubeMapNodes(graph), tracks, reads, {
-    nodeWidthOption: "compressed",
-    trackWidth: tubeWidth(tracks.length)
-  });
-  return layout ? { layout, pathColors } : void 0;
-}
-function drawnNodes(layout) {
-  const nodes = [];
-  layout.nodes.forEach((node) => {
-    if (node.order >= 0) {
-      nodes.push(node);
-    }
-  });
-  return nodes;
-}
-function centreline(node, yOffset, x0, x1) {
-  const y = node.y + node.contentHeight / 2 - yOffset;
-  return [
-    { x: x0, y },
-    { x: x1, y }
-  ];
-}
-function extentOf(layout, yOffset) {
-  return {
-    minY: layout.bounds.minY - yOffset,
-    maxY: layout.bounds.maxY - yOffset
-  };
-}
-function tubeMapLayout(graph) {
-  const run = hasTubeMapPaths(graph) ? runTubeMap(graph) : void 0;
-  if (!run) {
-    return void 0;
-  }
-  const { layout, pathColors } = run;
-  const yOffset = layout.bounds.minY;
-  const nodePositions = {};
-  for (const node of drawnNodes(layout)) {
-    nodePositions[node.name] = centreline(
-      node,
-      yOffset,
-      node.x,
-      node.x + node.pixelWidth
-    );
-  }
-  const { minY, maxY } = extentOf(layout, yOffset);
-  return {
-    nodePositions,
-    tubeMap: { layout, yOffset, pathColors },
-    extent: {
-      minX: layout.bounds.minX,
-      maxX: layout.bounds.maxX,
-      minY,
-      maxY
-    }
-  };
-}
-function tubeMapColumns(graph, layout) {
-  const nodeById = new Map(graph.nodes.map((n) => [n.id, n]));
-  const byOrder = /* @__PURE__ */ new Map();
-  for (const node of drawnNodes(layout)) {
-    const list = byOrder.get(node.order);
-    if (list) {
-      list.push(node);
-    } else {
-      byOrder.set(node.order, [node]);
-    }
-  }
-  const columns = [];
-  let end = -Infinity;
-  for (const order of [...byOrder.keys()].sort((a, b) => a - b)) {
-    const nodes = byOrder.get(order);
-    let bp0 = Infinity;
-    let bp1 = -Infinity;
-    for (const node of nodes) {
-      const graphNode = nodeById.get(node.name);
-      if (graphNode && isBackbone(graphNode)) {
-        bp0 = Math.min(bp0, graphNode.stable.start);
-        bp1 = Math.max(bp1, graphNode.stable.start + node.sequenceLength);
-      }
-    }
-    if (bp0 === Infinity) {
-      bp0 = bp1 = end;
-    }
-    if (bp0 < end) {
-      bp0 = end;
-      bp1 = Math.max(end, bp1);
-    }
-    end = Math.max(end, bp1);
-    columns.push({
-      order,
-      x0: Math.min(...nodes.map((n) => n.x)),
-      x1: Math.max(...nodes.map((n) => n.x + n.pixelWidth)),
-      bp0,
-      bp1
-    });
-  }
-  const first = columns.find((c) => c.bp0 !== -Infinity);
-  for (const column of columns) {
-    if (column.bp0 === -Infinity) {
-      column.bp0 = column.bp1 = first?.bp0 ?? 0;
-    }
-  }
-  return columns;
-}
-function pathsReachBackbone(graph) {
-  return graph.nodes.some(isBackbone) && hasTubeMapPaths(graph);
-}
-function tubeMapReferenceLayout(graph) {
-  const run = pathsReachBackbone(graph) ? runTubeMap(graph) : void 0;
-  if (!run) {
-    return void 0;
-  }
-  const { layout, pathColors } = run;
-  const columns = tubeMapColumns(graph, layout);
-  const byOrder = new Map(columns.map((c) => [c.order, c]));
-  const yOffset = layout.bounds.minY;
-  const nodePositions = {};
-  for (const node of drawnNodes(layout)) {
-    const column = byOrder.get(node.order);
-    nodePositions[node.name] = centreline(node, yOffset, column.bp0, column.bp1);
-  }
-  return {
-    nodePositions,
-    tubeMap: { layout, yOffset, columns, pathColors },
-    referenceAxis: true,
-    pixelRows: true,
-    extent: extentOf(layout, yOffset)
-  };
-}
-
-export {
-  visitStrands,
-  tubeMapTracks,
-  hasTubeMapPaths,
-  tubeWidth,
-  tubeMapLayout,
-  tubeMapReferenceLayout
-};