@jbrowse/bandage-core 6.0.0 → 6.0.2

package/dist/chunks/chunk-3PLYZLYV.js

@@ -0,0 +1,513 @@
+import {
+  ROW_HEIGHT_PX
+} from "./chunk-CPMHA4W5.js";
+
+// src/util/geometry.ts
+function svgPath(points) {
+  const round = (v) => Math.round(v * 100) / 100;
+  return points.map((p, i) => `${i ? "L" : "M"}${round(p.x)},${round(p.y)}`).join("");
+}
+function projectLine(x1, y1, x2, y2, distance) {
+  const d = Math.hypot(y2 - y1, x2 - x1);
+  if (d === 0) {
+    return [x2, y2];
+  }
+  const vx = (x2 - x1) / d;
+  const vy = (y2 - y1) / d;
+  return [x2 + distance * vx, y2 + distance * vy];
+}
+function curvePointAt(c, t) {
+  const u = 1 - t;
+  const a = u * u * u;
+  const b = 3 * u * u * t;
+  const d = 3 * u * t * t;
+  const e = t * t * t;
+  return {
+    x: a * c.x0 + b * c.cx0 + d * c.cx1 + e * c.x1,
+    y: a * c.y0 + b * c.cy0 + d * c.cy1 + e * c.y1
+  };
+}
+function curveMidpoint(curves) {
+  const mid = curves[Math.floor(curves.length / 2)];
+  return mid ? curvePointAt(mid, 0.5) : void 0;
+}
+function curveBounds(curves) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const c of curves) {
+    minX = Math.min(minX, c.x0, c.cx0, c.cx1, c.x1);
+    maxX = Math.max(maxX, c.x0, c.cx0, c.cx1, c.x1);
+    minY = Math.min(minY, c.y0, c.cy0, c.cy1, c.y1);
+    maxY = Math.max(maxY, c.y0, c.cy0, c.cy1, c.y1);
+  }
+  return { minX, minY, maxX, maxY };
+}
+function subCurve(c, t0, t1) {
+  const p0 = curvePointAt(c, t0);
+  const p1 = curvePointAt(c, t1);
+  const dt = (t1 - t0) / 3;
+  const d0 = curveTangentAt(c, t0);
+  const d1 = curveTangentAt(c, t1);
+  return {
+    x0: p0.x,
+    y0: p0.y,
+    cx0: p0.x + d0.x * dt,
+    cy0: p0.y + d0.y * dt,
+    cx1: p1.x - d1.x * dt,
+    cy1: p1.y - d1.y * dt,
+    x1: p1.x,
+    y1: p1.y
+  };
+}
+function curveTangentAt(c, t) {
+  const u = 1 - t;
+  const a = 3 * u * u;
+  const b = 6 * u * t;
+  const d = 3 * t * t;
+  return {
+    x: a * (c.cx0 - c.x0) + b * (c.cx1 - c.cx0) + d * (c.x1 - c.cx1),
+    y: a * (c.cy0 - c.y0) + b * (c.cy1 - c.cy0) + d * (c.y1 - c.cy1)
+  };
+}
+function dashCurves(curves, dashWorld) {
+  const lengths = curves.map(
+    (c) => Math.hypot(c.cx0 - c.x0, c.cy0 - c.y0) + Math.hypot(c.cx1 - c.cx0, c.cy1 - c.cy0) + Math.hypot(c.x1 - c.cx1, c.y1 - c.cy1)
+  );
+  const total = lengths.reduce((a, b) => a + b, 0);
+  const spans = Math.max(3, Math.round(total / dashWorld) | 1);
+  const out = [];
+  for (let i = 0; i < spans; i += 2) {
+    const from = i / spans * total;
+    const to = (i + 1) / spans * total;
+    const dash = [];
+    let start = 0;
+    curves.forEach((c, k) => {
+      const length = lengths[k];
+      const end = start + length;
+      if (length > 0 && end > from && start < to) {
+        dash.push(
+          subCurve(
+            c,
+            Math.max(0, (from - start) / length),
+            Math.min(1, (to - start) / length)
+          )
+        );
+      }
+      start = end;
+    });
+    if (dash.length) {
+      out.push(dash);
+    }
+  }
+  return out;
+}
+function translateCurves(curves, dx, dy) {
+  const out = new Array(curves.length);
+  for (let i = 0; i < curves.length; i++) {
+    const c = curves[i];
+    out[i] = {
+      x0: c.x0 + dx,
+      y0: c.y0 + dy,
+      cx0: c.cx0 + dx,
+      cy0: c.cy0 + dy,
+      cx1: c.cx1 + dx,
+      cy1: c.cy1 + dy,
+      x1: c.x1 + dx,
+      y1: c.y1 + dy
+    };
+  }
+  return out;
+}
+function attachment(segments, side) {
+  const last = segments.length - 1;
+  return side === "end" ? { at: segments[last], inward: segments[last - 1] } : { at: segments[0], inward: segments[1] };
+}
+var TANGENT_SPAN_FACTOR = 0.5;
+var MAX_TANGENT = 80;
+function ownStrand(id) {
+  return id.endsWith("-") ? "-" : "+";
+}
+function strandSides(edge) {
+  const own = (id, strand) => (strand ?? ownStrand(id)) === ownStrand(id);
+  return {
+    from: own(edge.from, edge.fromStrand) ? "end" : "start",
+    to: own(edge.to, edge.toStrand) ? "start" : "end"
+  };
+}
+function spanOf(segments) {
+  let min = Infinity;
+  let max = -Infinity;
+  for (const s of segments) {
+    min = Math.min(min, s.x);
+    max = Math.max(max, s.x);
+  }
+  return { min, max };
+}
+function distanceToSpan(x, span) {
+  return Math.max(0, span.min - x, x - span.max);
+}
+function facingSide(segments, other, tieBreak) {
+  const startGap = distanceToSpan(segments[0].x, other);
+  const endGap = distanceToSpan(segments[segments.length - 1].x, other);
+  return startGap === endGap ? tieBreak : startGap < endGap ? "start" : "end";
+}
+function facingSides(fromSegments, toSegments) {
+  return {
+    from: facingSide(fromSegments, spanOf(toSegments), "end"),
+    to: facingSide(toSegments, spanOf(fromSegments), "start")
+  };
+}
+var APEX_FRACTION = 0.75;
+var BOW_CLEARANCE = 1.15;
+var ALONG_FRACTION = 0.35;
+var MAX_ROW_BOW_PX = 3 * ROW_HEIGHT_PX;
+function bowAround(p1x, p1y, p2x, p2y, toward, maxBow) {
+  const chord = Math.hypot(p2x - p1x, p2y - p1y);
+  const ux = chord === 0 ? 1 : (p2x - p1x) / chord;
+  const uy = chord === 0 ? 0 : (p2y - p1y) / chord;
+  let reach = 0;
+  let minAlong = Infinity;
+  let maxAlong = -Infinity;
+  for (const p of toward) {
+    const dx = p.x - p1x;
+    const dy = p.y - p1y;
+    const perp = dx * -uy + dy * ux;
+    if (Math.abs(perp) > Math.abs(reach)) {
+      reach = perp;
+    }
+    const along = dx * ux + dy * uy;
+    minAlong = Math.min(minAlong, along);
+    maxAlong = Math.max(maxAlong, along);
+  }
+  const span = toward.length ? maxAlong - minAlong : 0;
+  const uncapped = Math.max(
+    Math.abs(reach) * BOW_CLEARANCE / APEX_FRACTION,
+    span * ALONG_FRACTION
+  );
+  const size = maxBow === void 0 ? uncapped : Math.min(uncapped, maxBow);
+  return reach < 0 ? -size : size;
+}
+function yToXOf({ scaleX, scaleY }) {
+  return scaleY / scaleX;
+}
+var PATH_RIBBON_SPACING = 3;
+function drawnDirection(a, b, yToX) {
+  const dx = b.x - a.x;
+  const dy = (b.y - a.y) * yToX;
+  const len = Math.hypot(dx, dy);
+  return len === 0 ? void 0 : { x: dx / len, y: dy / len };
+}
+function pathRibbonOffsets(fromSegments, toSegments, count, axis, spacing = PATH_RIBBON_SPACING) {
+  const yToX = yToXOf(axis);
+  const dir = drawnDirection(
+    fromSegments[fromSegments.length - 1],
+    toSegments[0],
+    yToX
+  ) ?? drawnDirection(fromSegments[0], fromSegments.at(-1), yToX) ?? drawnDirection(toSegments[0], toSegments.at(-1), yToX) ?? { x: 1, y: 0 };
+  const offsets = [];
+  for (let i = 0; i < count; i++) {
+    const distance = (i - (count - 1) / 2) * spacing;
+    offsets.push({ x: -dir.y * distance, y: dir.x * distance / yToX });
+  }
+  return offsets;
+}
+function scaleYOf(points, yToX) {
+  return points.map((p) => ({ x: p.x, y: p.y * yToX }));
+}
+function unscaleYOf(curves, yToX) {
+  for (const c of curves) {
+    c.y0 /= yToX;
+    c.cy0 /= yToX;
+    c.cy1 /= yToX;
+    c.y1 /= yToX;
+  }
+  return curves;
+}
+var SELF_LOOP_MIN_PX = 12;
+var SELF_LOOP_MAX_PX = 40;
+function selfLoopReach(segments, scale) {
+  let length = 0;
+  for (let i = 1; i < segments.length; i++) {
+    length += Math.hypot(
+      segments[i].x - segments[i - 1].x,
+      segments[i].y - segments[i - 1].y
+    );
+  }
+  const nodePx = length * scale;
+  const reachPx = Math.min(
+    SELF_LOOP_MAX_PX,
+    Math.max(SELF_LOOP_MIN_PX, nodePx / 2)
+  );
+  return reachPx / Math.max(scale, Number.EPSILON);
+}
+function selfLinkOf(edge) {
+  if (edge.from !== edge.to) {
+    return false;
+  }
+  return edge.fromStrand && edge.toStrand && edge.fromStrand !== edge.toStrand ? edge.fromStrand === "+" ? "end" : "start" : true;
+}
+function edgeJoinOf(edge, stranded = false) {
+  const self = selfLinkOf(edge);
+  if (!stranded) {
+    return self;
+  }
+  const sides = strandSides(edge);
+  return self === false ? sides : sides.from === sides.to ? sides.from : true;
+}
+function hairpinCurves(attach, reach, offsetX, offsetY) {
+  const { at, inward } = attach;
+  const dx = inward ? at.x - inward.x : 1;
+  const dy = inward ? at.y - inward.y : 0;
+  const len = Math.hypot(dx, dy) || 1;
+  const ux = dx / len;
+  const uy = dy / len;
+  const px = at.x + offsetX;
+  const py = at.y + offsetY;
+  const nearX = px + ux * reach / 3;
+  const nearY = py + uy * reach / 3;
+  const apexX = px + ux * reach;
+  const apexY = py + uy * reach;
+  const sideX = -uy * reach / 2;
+  const sideY = ux * reach / 2;
+  return [
+    {
+      x0: px,
+      y0: py,
+      cx0: nearX,
+      cy0: nearY,
+      cx1: apexX + sideX,
+      cy1: apexY + sideY,
+      x1: apexX,
+      y1: apexY
+    },
+    {
+      x0: apexX,
+      y0: apexY,
+      cx0: apexX - sideX,
+      cy0: apexY - sideY,
+      cx1: nearX,
+      cy1: nearY,
+      x1: px,
+      y1: py
+    }
+  ];
+}
+function computeEdgeCurves(fromSegments, toSegments, join, offsetX, offsetY, axis, bypassed = [], maxBowIn) {
+  const scale = axis.scaleX;
+  const yToX = yToXOf(axis);
+  const maxBow = maxBowIn ?? (axis.pixelRows ? MAX_ROW_BOW_PX : void 0);
+  if (yToX !== 1) {
+    return unscaleYOf(
+      computeEdgeCurves(
+        scaleYOf(fromSegments, yToX),
+        scaleYOf(toSegments, yToX),
+        join,
+        offsetX,
+        offsetY * yToX,
+        { scaleX: scale, scaleY: scale },
+        scaleYOf(bypassed, yToX),
+        // the cap is a y measure and the body works in x units, so it converts
+        // with everything else that crosses this boundary
+        maxBow === void 0 ? void 0 : maxBow * yToX
+      ),
+      yToX
+    );
+  }
+  if (typeof join === "string") {
+    return hairpinCurves(
+      attachment(fromSegments, join),
+      selfLoopReach(fromSegments, scale),
+      offsetX,
+      offsetY
+    );
+  }
+  const loop = join === true;
+  const sides = loop ? { from: "end", to: "start" } : join || facingSides(fromSegments, toSegments);
+  const fromAttach = attachment(fromSegments, sides.from);
+  const toAttach = attachment(toSegments, sides.to);
+  const fromEnd = fromAttach.at;
+  const toStart = toAttach.at;
+  const p1x = fromEnd.x + offsetX;
+  const p1y = fromEnd.y + offsetY;
+  const p2x = toStart.x + offsetX;
+  const p2y = toStart.y + offsetY;
+  if (loop) {
+    let segDirX = 1;
+    let segDirY = 0;
+    if (fromAttach.inward) {
+      const dx = fromEnd.x - fromAttach.inward.x;
+      const dy = fromEnd.y - fromAttach.inward.y;
+      const len = Math.hypot(dx, dy);
+      if (len > 0) {
+        segDirX = dx / len;
+        segDirY = dy / len;
+      }
+    }
+    const ext = selfLoopReach(fromSegments, scale);
+    const perpX = -segDirY;
+    const perpY = segDirX;
+    const midX = (fromEnd.x + toStart.x) / 2 + offsetX + perpX * ext;
+    const midY = (fromEnd.y + toStart.y) / 2 + offsetY + perpY * ext;
+    const cp1x = p1x + segDirX * ext;
+    const cp1y = p1y + segDirY * ext;
+    const cp2x = p2x - segDirX * ext;
+    const cp2y = p2y - segDirY * ext;
+    return [
+      {
+        x0: p1x,
+        y0: p1y,
+        cx0: cp1x,
+        cy0: cp1y,
+        cx1: cp1x + perpX * ext,
+        cy1: cp1y + perpY * ext,
+        x1: midX,
+        y1: midY
+      },
+      {
+        x0: midX,
+        y0: midY,
+        cx0: cp2x + perpX * ext,
+        cy0: cp2y + perpY * ext,
+        cx1: cp2x,
+        cy1: cp2y,
+        x1: p2x,
+        y1: p2y
+      }
+    ];
+  } else {
+    const fromPrev = fromAttach.inward ?? {
+      x: fromEnd.x - (toStart.x - fromEnd.x),
+      y: fromEnd.y - (toStart.y - fromEnd.y)
+    };
+    const toNext = toAttach.inward ?? {
+      x: toStart.x - (fromEnd.x - toStart.x),
+      y: toStart.y - (fromEnd.y - toStart.y)
+    };
+    const dist = Math.hypot(p2x - p1x, p2y - p1y);
+    const tangentProj = (prev, at, towardX, towardY) => {
+      const dx = at.x - prev.x;
+      const dy = at.y - prev.y;
+      const len = Math.hypot(dx, dy);
+      const along = len === 0 ? 0 : (towardX * dx + towardY * dy) / len;
+      return Math.max(
+        0,
+        Math.min(dist * TANGENT_SPAN_FACTOR, MAX_TANGENT, along * 0.5)
+      );
+    };
+    const towardToX = toStart.x - fromEnd.x;
+    const towardToY = toStart.y - fromEnd.y;
+    const [cx1, cy1] = projectLine(
+      fromPrev.x,
+      fromPrev.y,
+      fromEnd.x,
+      fromEnd.y,
+      tangentProj(fromPrev, fromEnd, towardToX, towardToY)
+    );
+    const [cx2, cy2] = projectLine(
+      toNext.x,
+      toNext.y,
+      toStart.x,
+      toStart.y,
+      tangentProj(toNext, toStart, -towardToX, -towardToY)
+    );
+    const bulge = bypassed.length ? bowAround(p1x, p1y, p2x, p2y, bypassed, maxBow) : 0;
+    const chordLen = dist === 0 ? 1 : dist;
+    const ux = (p2x - p1x) / chordLen;
+    const uy = (p2y - p1y) / chordLen;
+    const bulgeX = -uy * bulge;
+    const bulgeY = ux * bulge;
+    const spreadX = ux * Math.abs(bulge);
+    const spreadY = uy * Math.abs(bulge);
+    return [
+      {
+        x0: p1x,
+        y0: p1y,
+        cx0: cx1 + offsetX + bulgeX - spreadX,
+        cy0: cy1 + offsetY + bulgeY - spreadY,
+        cx1: cx2 + offsetX + bulgeX + spreadX,
+        cy1: cy2 + offsetY + bulgeY + spreadY,
+        x1: p2x,
+        y1: p2y
+      }
+    ];
+  }
+}
+function nearerEnd(segments, to) {
+  const start = segments[0];
+  const end = segments.at(-1);
+  return Math.hypot(start.x - to.x, start.y - to.y) < Math.hypot(end.x - to.x, end.y - to.y) ? "start" : "end";
+}
+function routedEdgeCurves(fromSegments, toSegments, route, sides) {
+  const fromAttach = attachment(
+    fromSegments,
+    sides?.from ?? nearerEnd(fromSegments, route[0])
+  );
+  const toAttach = attachment(
+    toSegments,
+    sides?.to ?? nearerEnd(toSegments, route.at(-1))
+  );
+  const points = [fromAttach.at, ...route, toAttach.at];
+  const tangent = (i) => {
+    const p = points[i];
+    const span = (q) => Math.hypot(q.x - p.x, q.y - p.y);
+    const along = (inward, next) => {
+      const len = inward ? span(inward) : 0;
+      const reach = span(next);
+      return len === 0 ? { x: next.x - p.x, y: next.y - p.y } : {
+        x: (p.x - inward.x) / len * reach,
+        y: (p.y - inward.y) / len * reach
+      };
+    };
+    if (i === 0) {
+      return along(fromAttach.inward, points[1]);
+    }
+    if (i === points.length - 1) {
+      const out = along(toAttach.inward, points[i - 1]);
+      return { x: -out.x, y: -out.y };
+    }
+    return {
+      x: (points[i + 1].x - points[i - 1].x) / 2,
+      y: (points[i + 1].y - points[i - 1].y) / 2
+    };
+  };
+  const curves = [];
+  for (let i = 0; i < points.length - 1; i++) {
+    const a = points[i];
+    const b = points[i + 1];
+    const ta = tangent(i);
+    const tb = tangent(i + 1);
+    curves.push({
+      x0: a.x,
+      y0: a.y,
+      cx0: a.x + ta.x / 3,
+      cy0: a.y + ta.y / 3,
+      cx1: b.x - tb.x / 3,
+      cy1: b.y - tb.y / 3,
+      x1: b.x,
+      y1: b.y
+    });
+  }
+  return curves;
+}
+
+export {
+  svgPath,
+  projectLine,
+  curvePointAt,
+  curveMidpoint,
+  curveBounds,
+  dashCurves,
+  translateCurves,
+  ownStrand,
+  strandSides,
+  bowAround,
+  yToXOf,
+  PATH_RIBBON_SPACING,
+  pathRibbonOffsets,
+  selfLinkOf,
+  edgeJoinOf,
+  computeEdgeCurves,
+  routedEdgeCurves
+};

package/dist/chunks/chunk-3S3YVOJ7.js

@@ -0,0 +1,69 @@
+import {
+  el
+} from "./chunk-NNODIW4U.js";
+
+// src/genes/exonOutline.ts
+var EXON_COLOR = "#daa520";
+var EXON_GAP_PX = 1;
+var EXON_LINE_PX = 2;
+var MIN_LANE_PX = 4;
+function exonStretches(pins, halfWidthPx, lift, pathOf = (d) => d) {
+  const inkPx = (nodeId) => {
+    const own = halfWidthPx(nodeId) * 2;
+    return lift?.nodeIds.has(nodeId) ? Math.max(own, lift.walks.length * MIN_LANE_PX) : own;
+  };
+  return pins.flatMap(
+    (pin) => pin.exonsByNode.map(({ nodeId, d }) => ({
+      key: `${pin.gene.name}-${pin.gene.start}-${nodeId}`,
+      d: pathOf(d),
+      inner: inkPx(nodeId) + 2 * EXON_GAP_PX
+    }))
+  );
+}
+function exonOutlineTree(stretches, o) {
+  if (stretches.length === 0) {
+    return void 0;
+  }
+  const stroke = (s, color, width) => el("path", {
+    d: s.d,
+    fill: "none",
+    stroke: color,
+    "stroke-width": width,
+    "stroke-linecap": "round",
+    "stroke-linejoin": "round",
+    "vector-effect": o.transform ? "non-scaling-stroke" : void 0
+  });
+  return el(
+    "g",
+    {},
+    el(
+      "mask",
+      {
+        id: o.id,
+        maskUnits: "userSpaceOnUse",
+        x: 0,
+        y: 0,
+        width: o.width,
+        height: o.height
+      },
+      el(
+        "g",
+        { transform: o.transform },
+        ...stretches.map((s) => stroke(s, "#fff", s.inner + 2 * EXON_LINE_PX)),
+        ...stretches.map((s) => stroke(s, "#000", s.inner))
+      )
+    ),
+    el("rect", {
+      width: o.width,
+      height: o.height,
+      fill: EXON_COLOR,
+      mask: `url(#${o.id})`
+    })
+  );
+}
+
+export {
+  EXON_COLOR,
+  exonStretches,
+  exonOutlineTree
+};