@jbrowse/bandage-core 0.1.20 → 4.0.24

package/README.md

@@ -34,6 +34,7 @@ the worked example.
 Lives in the plugin repo as a pnpm workspace package. The plugin imports its
 source directly, so a change here needs no publish to reach the plugin.
 
-The core releases with the plugin: `pnpm version patch` at the repo root bumps
-both, and `publish.yml` and `publish-core.yml` each publish one from the `v*`
-tag.
+The core releases with the plugin, at the plugin's version: `pnpm version patch`
+at the repo root sets both, and `publish.yml` and `publish-core.yml` each
+publish one from the `v*` tag. `publish-core.yml` also runs by hand to publish a
+version a failed run left behind.

package/dist/chunks/{chunk-3XDR3ZBS.js → chunk-4AOHEU76.js}

@@ -3558,6 +3558,9 @@ var Canvas2DRenderer = class extends Canvas2DRenderingBackendBase {
     }
     const ctx = this.ctx;
     const { width, height } = ctx.canvas;
+    if (clearColor[3] < 1) {
+      ctx.clearRect(0, 0, width, height);
+    }
     ctx.fillStyle = normalizedRgbToCssRgba(
       [clearColor[0], clearColor[1], clearColor[2]],
       clearColor[3]
@@ -3742,8 +3745,8 @@ function occupancy(frame, reserved = []) {
 function placeLabels(candidates, frame, take) {
   const out = [];
   const row = LABEL_PX + LABEL_PAD * 2;
-  for (const c of candidates) {
-    const w = labelWidth(c.text);
+  const place = (c, text) => {
+    const w = labelWidth(text);
     const direction = c.y > frame.height / 2 ? -1 : 1;
     for (let tries = 0; tries <= (c.stack ?? 0); tries++) {
       const y = c.y + direction * tries * row;
@@ -3754,13 +3757,19 @@ function placeLabels(candidates, frame, take) {
         y1: y + LABEL_PAD
       };
       if (offFrame(box, frame)) {
-        break;
+        return void 0;
       }
       if (insideFrame(box, frame) && take(box)) {
-        out.push({ ...c, y, w });
-        break;
+        return { ...c, text, y, w };
       }
     }
+    return void 0;
+  };
+  for (const c of candidates) {
+    const placed = place(c, c.text) ?? (c.fallback === void 0 ? void 0 : place(c, c.fallback));
+    if (placed) {
+      out.push(placed);
+    }
   }
   return out;
 }

package/dist/cli/figure.js

@@ -10,7 +10,7 @@ import {
   referencePathQuery,
   referenceSamplesOf,
   resolveReferenceSample
-} from "../chunks/chunk-3XDR3ZBS.js";
+} from "../chunks/chunk-4AOHEU76.js";
 
 // src/cli/figure.ts
 import { open, readFile, writeFile } from "node:fs/promises";

package/dist/index.js

@@ -95,7 +95,7 @@ import {
   wellKnownSample,
   yToXOf,
   zoomAbout
-} from "./chunks/chunk-3XDR3ZBS.js";
+} from "./chunks/chunk-4AOHEU76.js";
 
 // src/index.ts
 import { getDpr } from "@jbrowse/render-core/canvas2dUtils";
@@ -466,27 +466,30 @@ function wheelZoomFactor(e) {
 
 // src/referenceStrip.ts
 import { abgrToCssRgba } from "@jbrowse/core/util/colorBits";
-var REFERENCE_STRIP_PX = 10;
+var REFERENCE_STRIP_PX = 12;
 var REFERENCE_STRIP_ZONE_PX = REFERENCE_STRIP_PX + 8;
-var OVERHANG_PX = 5;
+var OVERHANG_PX = 8;
+var OVERHANG_CAP_PX = OVERHANG_PX + 3;
+var PALE = abgrToCssRgba(fadeAbgr(LIFT_BACKDROP_COLOR, FADED_ALPHA));
 function referenceStripBlocks(graph, {
   colorScheme,
   referenceRamp,
-  walkNodes,
-  walkColors
+  walks
 }) {
   const range = { ...computeColorSchemeRange(graph), referenceRamp };
   const out = [];
   graph.nodes.forEach((node, index) => {
     if (isBackbone(node)) {
-      const own = walkNodes ? walkColors?.get(node.id) ?? LIFT_BACKDROP_COLOR : getNodeColor(node, index, colorScheme, range);
-      const faded = !!walkNodes && !walkNodes.has(node.id);
+      const colors = walks ? walks.map((w) => {
+        const lane = w.colors.get(node.id);
+        return lane === void 0 ? PALE : abgrToCssRgba(lane);
+      }) : [abgrToCssRgba(getNodeColor(node, index, colorScheme, range))];
       out.push({
         node: node.id,
         bp0: node.stable.start,
         bp1: node.stable.start + node.length,
-        color: abgrToCssRgba(faded ? fadeAbgr(own, FADED_ALPHA) : own),
-        faded
+        colors,
+        faded: colors.includes(PALE)
       });
     }
   });
@@ -532,7 +535,7 @@ function stripPixels(blocks, frame, width, dpr) {
     const [x0, x1] = span(frame, b.bp0, b.bp1);
     const px0 = Math.round(x0 * dpr);
     return {
-      color: b.color,
+      colors: b.colors,
       x0,
       px0,
       px1: Math.max(Math.round(x1 * dpr), px0 + 1)
@@ -540,22 +543,33 @@ function stripPixels(blocks, frame, width, dpr) {
   }).filter((b) => b.px1 > 0 && b.px0 < width * dpr).sort((a, b) => a.x0 - b.x0);
   const out = [];
   let claimed = -Infinity;
-  for (const { color, px0, px1 } of placed) {
+  const tierEnds = [-Infinity, -Infinity];
+  for (const { colors, px0, px1 } of placed) {
     const start = Math.max(px0, claimed);
     if (px1 > start) {
-      out.push({ color, x0: start / dpr, x1: px1 / dpr });
+      const tier = tierEnds[0] < start ? 0 : 1;
+      tierEnds[tier] = px1;
+      out.push({ colors, x0: start / dpr, x1: px1 / dpr, tier });
       claimed = px1;
     }
   }
   return out;
 }
-function drawOverhang(ctx, tipX, inward) {
-  const mid = REFERENCE_STRIP_PX / 2;
-  const baseX = tipX + inward * (OVERHANG_PX + 1);
-  ctx.moveTo(tipX + inward, mid);
-  ctx.lineTo(baseX, mid - OVERHANG_PX / 1.4);
-  ctx.lineTo(baseX, mid + OVERHANG_PX / 1.4);
+function drawOverhang(ctx, edgeX, inward, ink) {
+  const capX = inward > 0 ? edgeX : edgeX - OVERHANG_CAP_PX;
+  ctx.clearRect(capX, 0, OVERHANG_CAP_PX, REFERENCE_STRIP_PX);
+  const tipX = edgeX + inward;
+  const baseX = tipX + inward * OVERHANG_PX;
+  ctx.beginPath();
+  ctx.moveTo(tipX, REFERENCE_STRIP_PX / 2);
+  ctx.lineTo(baseX, 0);
+  ctx.lineTo(baseX, REFERENCE_STRIP_PX);
   ctx.closePath();
+  ctx.fillStyle = ink;
+  ctx.fill();
+}
+function rowEdge(row, rows, dpr) {
+  return Math.round(row * REFERENCE_STRIP_PX * dpr / rows) / dpr;
 }
 function drawReferenceStrip(ctx, blocks, frame, {
   width,
@@ -564,26 +578,22 @@ function drawReferenceStrip(ctx, blocks, frame, {
   dpr = 1
 }) {
   const ink = darkMode ? "#ffffff" : "#18181c";
-  ctx.fillStyle = darkMode ? "#1f1f1f" : "#ffffff";
-  ctx.fillRect(0, 0, width, REFERENCE_STRIP_ZONE_PX);
+  ctx.clearRect(0, 0, width, REFERENCE_STRIP_ZONE_PX);
   for (const b of stripPixels(blocks, frame, width, dpr)) {
-    ctx.fillStyle = b.color;
-    ctx.fillRect(b.x0, 0, b.x1 - b.x0, REFERENCE_STRIP_PX);
+    const rows = b.colors.length > 1 ? b.colors.length : 2;
+    b.colors.forEach((color, i) => {
+      const row = b.colors.length > 1 ? i : b.tier;
+      const y0 = rowEdge(row, rows, dpr);
+      ctx.fillStyle = color;
+      ctx.fillRect(b.x0, y0, b.x1 - b.x0, rowEdge(row + 1, rows, dpr) - y0);
+    });
   }
   const overhang = stripOverhang(blocks, frame, width);
-  if (overhang.left > 0 || overhang.right > 0) {
-    ctx.beginPath();
-    if (overhang.left > 0) {
-      drawOverhang(ctx, 0, 1);
-    }
-    if (overhang.right > 0) {
-      drawOverhang(ctx, width, -1);
-    }
-    ctx.fillStyle = ink;
-    ctx.fill();
-    ctx.strokeStyle = darkMode ? "#1f1f1f" : "#ffffff";
-    ctx.lineWidth = 1;
-    ctx.stroke();
+  if (overhang.left > 0) {
+    drawOverhang(ctx, 0, 1, ink);
+  }
+  if (overhang.right > 0) {
+    drawOverhang(ctx, width, -1, ink);
   }
   if (lit) {
     const [x0, x1] = span(frame, lit.start, lit.end);
@@ -1770,6 +1780,7 @@ function layoutLabels(m) {
         x,
         y: y + m.contigThickness + GENE_PIN_DROP_PX,
         text: note ? `${pin.gene.name} \xB7 ${note}` : pin.gene.name,
+        fallback: note ? `${pin.gene.name} \u2026` : void 0,
         stack: GENE_STACK
       };
     }),

package/dist/types/overlayLabels.d.ts

@@ -13,6 +13,7 @@ export interface LabelCandidate<T> {
     y: number;
     text: string;
     stack?: number;
+    fallback?: string;
 }
 export interface PlacedLabel<T> extends LabelCandidate<T> {
     w: number;

package/dist/types/referenceStrip.d.ts

@@ -1,20 +1,21 @@
 import type { ResolvedColorScheme } from './colorSchemes.js';
 import type { ReferenceRamp } from './renderer/GeometryBuilder.js';
 import type { Graph, NodeSegment } from './types.js';
-export declare const REFERENCE_STRIP_PX = 10;
+export declare const REFERENCE_STRIP_PX = 12;
 export declare const REFERENCE_STRIP_ZONE_PX: number;
 export interface StripBlock {
     node: string;
     bp0: number;
     bp1: number;
-    color: string;
+    colors: string[];
     faded: boolean;
 }
-export declare function referenceStripBlocks(graph: Graph, { colorScheme, referenceRamp, walkNodes, walkColors, }: {
+export declare function referenceStripBlocks(graph: Graph, { colorScheme, referenceRamp, walks, }: {
     colorScheme: ResolvedColorScheme;
     referenceRamp?: ReferenceRamp;
-    walkNodes?: ReadonlySet<string>;
-    walkColors?: ReadonlyMap<string, number>;
+    walks?: readonly {
+        colors: ReadonlyMap<string, number>;
+    }[];
 }): StripBlock[];
 export interface BpFrame {
     scale: number;
@@ -41,9 +42,10 @@ export interface StripLit {
     };
 }
 export declare function stripPixels(blocks: readonly StripBlock[], frame: BpFrame, width: number, dpr: number): {
-    color: string;
+    colors: string[];
     x0: number;
     x1: number;
+    tier: number;
 }[];
 export declare function drawReferenceStrip(ctx: CanvasRenderingContext2D, blocks: readonly StripBlock[], frame: BpFrame, { width, lit, darkMode, dpr, }: {
     width: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbrowse/bandage-core",
-  "version": "0.1.20",
+  "version": "4.0.24",
   "description": "Pangenome graph layout and drawing with no host: GFA in, the Bandage force-directed engine and reference-anchored layouts, a Canvas2D renderer, hit testing and labels out",
   "license": "GPL-3.0-or-later",
   "repository": {