@jbrowse/bandage-core 10.0.0 → 10.0.1

package/dist/chunks/chunk-Q6FRNVDU.js

@@ -1,531 +0,0 @@
-import {
-  stressPlacement
-} from "./chunk-LYJ4US66.js";
-import {
-  isBackbone
-} from "./chunk-FYQWPEEY.js";
-
-// src/layout/stressEngine.ts
-var QUALITY = [
-  { walks: 2, iterations: 15 },
-  { walks: 4, iterations: 30 },
-  { walks: 8, iterations: 60 },
-  { walks: 12, iterations: 90 },
-  { walks: 16, iterations: 120 }
-];
-var UNTANGLE_PASSES = 20;
-var UNTANGLE_LINKS = 3;
-var UNTANGLE_PUSH = 0.3;
-var SMOOTH_PASSES = 2;
-var MAX_HOPS = 200;
-var REFERENCE_HOPS = 20;
-var EPS = 0.1;
-var WARM = 0.5;
-function flipped(strand, name) {
-  const own = name.at(-1);
-  return (strand === "+" || strand === "-") && (own === "+" || own === "-") && strand !== own;
-}
-function xorshift(seed) {
-  let s = Math.imul(seed, 2654435761) >>> 0 || 1;
-  return () => {
-    s ^= s << 13;
-    s >>>= 0;
-    s ^= s >>> 17;
-    s ^= s << 5;
-    s >>>= 0;
-    return s / 4294967296;
-  };
-}
-function num(value, fallback) {
-  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
-}
-function chains(request) {
-  const { nodes, edges } = request.graph;
-  const o = request.options;
-  const perMegabase = num(o.nodeLengthPerMegabase, 1e3);
-  const minimum = num(o.minimumNodeLength, 1);
-  const segment = num(o.nodeSegmentLength, 1);
-  const link = num(o.edgeLength, 1);
-  const ids = nodes.map((n2) => n2.id);
-  const first = new Int32Array(nodes.length);
-  const count = new Int32Array(nodes.length);
-  const per = new Float64Array(nodes.length);
-  let n = 0;
-  nodes.forEach((node, k) => {
-    const drawn = Math.max(perMegabase * node.length / 1e6, minimum);
-    const steps = Math.max(1, Math.ceil(drawn / segment));
-    first[k] = n;
-    count[k] = steps + 1;
-    per[k] = drawn / steps;
-    n += steps + 1;
-  });
-  const chainOf = new Int32Array(n);
-  const indexOf = new Int32Array(n);
-  const seedX = new Float64Array(n).fill(NaN);
-  const seedY = new Float64Array(n).fill(NaN);
-  const backbone = new Uint8Array(n);
-  const adjacent = Array.from({ length: n }, () => []);
-  nodes.forEach((node, k) => {
-    const seeded = typeof node.x === "number" && typeof node.y === "number";
-    const reference = isBackbone(node) ? 1 : 0;
-    for (let i = 0; i < count[k]; i++) {
-      const v = first[k] + i;
-      chainOf[v] = k;
-      indexOf[v] = i;
-      backbone[v] = reference;
-      if (seeded) {
-        seedX[v] = node.x + i * per[k];
-        seedY[v] = node.y;
-      }
-      if (i > 0) {
-        adjacent[v - 1].push([v, per[k]]);
-        adjacent[v].push([v - 1, per[k]]);
-      }
-    }
-  });
-  const index = new Map(ids.map((id, k) => [id, k]));
-  const links = nodes.map(() => [[], []]);
-  for (const edge of edges) {
-    const a = index.get(edge.from);
-    const b = index.get(edge.to);
-    if (a === void 0 || b === void 0) {
-      continue;
-    }
-    if (a === b && count[a] <= 2) {
-      continue;
-    }
-    const fromSide = flipped(edge.fromStrand, edge.from) ? 0 : 1;
-    const toSide = flipped(edge.toStrand, edge.to) ? 1 : 0;
-    const u = first[a] + (fromSide ? count[a] - 1 : 0);
-    const v = first[b] + (toSide ? count[b] - 1 : 0);
-    adjacent[u].push([v, link]);
-    adjacent[v].push([u, link]);
-    links[a][fromSide].push([b, toSide]);
-    links[b][toSide].push([a, fromSide]);
-  }
-  const off = new Int32Array(n + 1);
-  for (let i = 0; i < n; i++) {
-    off[i + 1] = off[i] + adjacent[i].length;
-  }
-  const nb = new Int32Array(off[n]);
-  const wt = new Float64Array(off[n]);
-  for (let i = 0; i < n; i++) {
-    adjacent[i].forEach(([v, w], k) => {
-      nb[off[i] + k] = v;
-      wt[off[i] + k] = w;
-    });
-  }
-  return {
-    ids,
-    first,
-    count,
-    per,
-    links,
-    chainOf,
-    indexOf,
-    seedX,
-    seedY,
-    backbone,
-    off,
-    nb,
-    wt,
-    n,
-    link
-  };
-}
-function components(c) {
-  const { n, off, nb } = c;
-  const comp = new Int32Array(n).fill(-1);
-  const members = [];
-  for (let s = 0; s < n; s++) {
-    if (comp[s] >= 0) {
-      continue;
-    }
-    const queue = [s];
-    comp[s] = members.length;
-    for (const u of queue) {
-      for (let e = off[u]; e < off[u + 1]; e++) {
-        const v = nb[e];
-        if (comp[v] < 0) {
-          comp[v] = members.length;
-          queue.push(v);
-        }
-      }
-    }
-    members.push(queue);
-  }
-  return { comp, members };
-}
-function stressLayout(request, opts = {}) {
-  const c = chains(request);
-  const { n, off, nb, wt, seedX, seedY, backbone, first, count, per, link } = c;
-  const o = request.options;
-  const quality = QUALITY[Math.max(0, Math.min(4, num(opts.quality ?? o.quality, 2)))];
-  const gap = num(opts.componentSeparation ?? o.componentSeparation, 15);
-  const rand = xorshift(num(opts.seed ?? o.seed, 1));
-  const X = new Float64Array(n);
-  const Y = new Float64Array(n);
-  const nodePositions = {};
-  if (n === 0) {
-    return { nodePositions };
-  }
-  const { comp, members } = components(c);
-  let dmin = Infinity;
-  let total = 0;
-  for (let e = 0; e < nb.length; e++) {
-    dmin = Math.min(dmin, wt[e]);
-    total += wt[e];
-  }
-  total /= 2;
-  let anySeed = false;
-  for (let i = 0; i < n; i++) {
-    if (!Number.isNaN(seedX[i])) {
-      anySeed = true;
-      break;
-    }
-  }
-  const placed = anySeed ? stressPlacement(c) : void 0;
-  const side = Math.sqrt(n) * 20;
-  for (let i = 0; i < n; i++) {
-    if (placed && !Number.isNaN(placed.X[i])) {
-      X[i] = placed.X[i];
-      Y[i] = placed.Y[i];
-    } else if (anySeed && !Number.isNaN(seedX[i])) {
-      X[i] = seedX[i] + rand() - 0.5;
-      Y[i] = seedY[i] + rand() - 0.5;
-    } else {
-      X[i] = rand() * side;
-      Y[i] = rand() * side;
-    }
-  }
-  const refIdx = members.map(
-    (points) => Int32Array.from(
-      points.filter((i) => backbone[i] && !Number.isNaN(seedX[i])).sort((a, b) => seedX[a] - seedX[b])
-    )
-  );
-  const refX = refIdx.map((idx) => Float64Array.from(idx, (i) => seedX[i]));
-  let span = 0;
-  for (const xs of refX) {
-    if (xs.length) {
-      span = Math.max(span, xs[xs.length - 1] - xs[0]);
-    }
-  }
-  const dmax = Math.max(span, total / 4, dmin * 10);
-  const etaMax = dmax * dmax;
-  const etaMin = EPS * dmin * dmin;
-  const { walks, iterations } = quality;
-  const lambda = Math.log(etaMax / etaMin) / Math.max(1, iterations - 1);
-  const logMin = Math.log(dmin);
-  const logMax = Math.log(dmax);
-  const move = (i, j, d, eta) => {
-    let mu = eta / (d * d);
-    if (mu > 1) {
-      mu = 1;
-    }
-    const dx = X[i] - X[j];
-    const dy = Y[i] - Y[j];
-    const mag = Math.sqrt(dx * dx + dy * dy) || 1e-9;
-    const r = mu * (mag - d) / (2 * mag);
-    const rx = r * dx;
-    const ry = r * dy;
-    X[i] = X[i] - rx;
-    Y[i] = Y[i] - ry;
-    X[j] = X[j] + rx;
-    Y[j] = Y[j] + ry;
-  };
-  let walked = 0;
-  const walk = (i, length) => {
-    let chain = c.chainOf[i];
-    let idx = c.indexOf[i];
-    let dir = rand() < 0.5 ? -1 : 1;
-    let remaining = length;
-    const maxHops = refIdx[comp[i]].length >= 2 ? REFERENCE_HOPS : MAX_HOPS;
-    for (let hops = 0; hops < maxHops; hops++) {
-      const points = count[chain];
-      const step = per[chain];
-      const toEnd = (dir > 0 ? points - 1 - idx : idx) * step;
-      if (remaining <= toEnd) {
-        const steps = Math.round(remaining / step);
-        walked = length - remaining + steps * step;
-        return first[chain] + idx + dir * steps;
-      }
-      remaining -= toEnd;
-      const out = c.links[chain][dir > 0 ? 1 : 0];
-      if (out.length === 0) {
-        walked = length - remaining;
-        return first[chain] + (dir > 0 ? points - 1 : 0);
-      }
-      const [next, enterSide] = out[Math.floor(rand() * out.length)];
-      remaining -= link;
-      chain = next;
-      dir = enterSide === 0 ? 1 : -1;
-      idx = enterSide === 0 ? 0 : count[next] - 1;
-      if (remaining <= 0) {
-        walked = length - remaining;
-        return first[chain] + idx;
-      }
-    }
-    return -1;
-  };
-  const referenceTerm = (i, eta) => {
-    const idx = refIdx[comp[i]];
-    if (!backbone[i] || idx.length < 2 || Number.isNaN(seedX[i])) {
-      return;
-    }
-    const xs = refX[comp[i]];
-    const target = seedX[i] + Math.exp(logMin + rand() * (logMax - logMin)) * (rand() < 0.5 ? -1 : 1);
-    let lo = 0;
-    let hi = xs.length;
-    while (lo < hi) {
-      const mid = lo + hi >> 1;
-      if (xs[mid] < target) {
-        lo = mid + 1;
-      } else {
-        hi = mid;
-      }
-    }
-    const j = idx[Math.min(lo, idx.length - 1)];
-    const d = seedX[j] - seedX[i];
-    if (j === i || d === 0) {
-      return;
-    }
-    let mu = eta / (d * d);
-    if (mu > 1) {
-      mu = 1;
-    }
-    const r = mu * (X[j] - X[i] - d) / 2;
-    X[i] = X[i] + r;
-    X[j] = X[j] - r;
-  };
-  const adjacentTerms = (i, eta) => {
-    for (let e = off[i]; e < off[i + 1]; e++) {
-      const j = nb[e];
-      if (j > i) {
-        move(i, j, wt[e], eta);
-      }
-    }
-  };
-  const order = new Int32Array(n);
-  for (let i = 0; i < n; i++) {
-    order[i] = i;
-  }
-  const warm = anySeed ? Math.floor(WARM * iterations) : 0;
-  for (let t = warm; t < iterations; t++) {
-    const eta = etaMax * Math.exp(-lambda * t);
-    for (let k = n - 1; k > 0; k--) {
-      const r = Math.floor(rand() * (k + 1));
-      const tmp = order[k];
-      order[k] = order[r];
-      order[r] = tmp;
-    }
-    for (let q = 0; q < n; q++) {
-      const i = order[q];
-      adjacentTerms(i, eta);
-      for (let w = 0; w < walks; w++) {
-        const length = Math.exp(logMin + rand() * (logMax - logMin));
-        const j = walk(i, length);
-        if (j >= 0 && j !== i && walked > 0) {
-          move(i, j, walked, eta);
-        }
-      }
-      referenceTerm(i, eta);
-    }
-  }
-  const radius = UNTANGLE_LINKS * link;
-  const key = (x, y) => Math.floor(x / radius) * 73856093 ^ Math.floor(y / radius) * 19349663;
-  for (let u = 0; u < UNTANGLE_PASSES; u++) {
-    const grid = /* @__PURE__ */ new Map();
-    for (let i = 0; i < n; i++) {
-      const k = key(X[i], Y[i]);
-      const list = grid.get(k);
-      if (list) {
-        list.push(i);
-      } else {
-        grid.set(k, [i]);
-      }
-    }
-    for (let i = 0; i < n; i++) {
-      const cx = Math.floor(X[i] / radius);
-      const cy = Math.floor(Y[i] / radius);
-      for (let gx = cx - 1; gx <= cx + 1; gx++) {
-        for (let gy = cy - 1; gy <= cy + 1; gy++) {
-          const list = grid.get(gx * 73856093 ^ gy * 19349663);
-          if (!list) {
-            continue;
-          }
-          for (const j of list) {
-            if (j <= i) {
-              continue;
-            }
-            let joined = false;
-            for (let e = off[i]; e < off[i + 1]; e++) {
-              if (nb[e] === j) {
-                joined = true;
-                break;
-              }
-            }
-            if (joined) {
-              continue;
-            }
-            const dx = X[i] - X[j];
-            const dy = Y[i] - Y[j];
-            const mag = Math.sqrt(dx * dx + dy * dy);
-            if (mag >= radius) {
-              continue;
-            }
-            let rx;
-            let ry;
-            if (mag > 1e-6) {
-              const r = UNTANGLE_PUSH * (radius - mag) / (2 * mag);
-              rx = r * dx;
-              ry = r * dy;
-            } else {
-              rx = UNTANGLE_PUSH * radius * (rand() - 0.5);
-              ry = UNTANGLE_PUSH * radius * (rand() - 0.5);
-            }
-            X[i] = X[i] + rx;
-            Y[i] = Y[i] + ry;
-            X[j] = X[j] - rx;
-            Y[j] = Y[j] - ry;
-          }
-        }
-      }
-    }
-    for (let i = 0; i < n; i++) {
-      adjacentTerms(i, Infinity);
-      referenceTerm(i, etaMin * 4);
-    }
-  }
-  for (let k = 0; k < count.length; k++) {
-    const a = first[k];
-    const m = count[k];
-    if (m < 3) {
-      continue;
-    }
-    for (let s = 0; s < SMOOTH_PASSES; s++) {
-      const xs = X.slice(a, a + m);
-      const ys = Y.slice(a, a + m);
-      for (let i = 1; i + 1 < m; i++) {
-        X[a + i] = 0.5 * xs[i] + 0.25 * (xs[i - 1] + xs[i + 1]);
-        Y[a + i] = 0.5 * ys[i] + 0.25 * (ys[i - 1] + ys[i + 1]);
-      }
-    }
-    respace(X, Y, a, m, per[k]);
-  }
-  packComponents(comp, members, X, Y, anySeed, gap);
-  for (let k = 0; k < c.ids.length; k++) {
-    const points = [];
-    for (let i = 0; i < count[k]; i++) {
-      points.push({ x: X[first[k] + i], y: Y[first[k] + i] });
-    }
-    nodePositions[c.ids[k]] = points;
-  }
-  return { nodePositions };
-}
-function respace(X, Y, a, m, per) {
-  const arc = new Float64Array(m);
-  for (let i = 1; i < m; i++) {
-    arc[i] = arc[i - 1] + Math.hypot(X[a + i] - X[a + i - 1], Y[a + i] - Y[a + i - 1]);
-  }
-  if (!arc[m - 1]) {
-    return;
-  }
-  const loss = per * (m - 1) - arc[m - 1];
-  if (loss > 0) {
-    extend(X, Y, a, a + 1, loss / 2);
-    extend(X, Y, a + m - 1, a + m - 2, loss / 2);
-    for (let i = 1; i < m; i++) {
-      arc[i] = arc[i - 1] + Math.hypot(X[a + i] - X[a + i - 1], Y[a + i] - Y[a + i - 1]);
-    }
-  }
-  const total = arc[m - 1];
-  const xs = X.slice(a, a + m);
-  const ys = Y.slice(a, a + m);
-  let seg = 1;
-  for (let i = 1; i + 1 < m; i++) {
-    const s = total * i / (m - 1);
-    while (seg < m - 1 && arc[seg] < s) {
-      seg++;
-    }
-    const span = arc[seg] - arc[seg - 1];
-    const t = span > 0 ? (s - arc[seg - 1]) / span : 0;
-    X[a + i] = xs[seg - 1] + (xs[seg] - xs[seg - 1]) * t;
-    Y[a + i] = ys[seg - 1] + (ys[seg] - ys[seg - 1]) * t;
-  }
-}
-function extend(X, Y, end, next, by) {
-  const dx = X[end] - X[next];
-  const dy = Y[end] - Y[next];
-  const mag = Math.hypot(dx, dy);
-  if (mag > 0) {
-    X[end] = X[end] + dx / mag * by;
-    Y[end] = Y[end] + dy / mag * by;
-  }
-}
-function packComponents(comp, members, X, Y, anySeed, gap) {
-  if (!anySeed) {
-    for (const points of members) {
-      rotateToPrincipalAxis(X, Y, points);
-    }
-  }
-  if (members.length < 2) {
-    return;
-  }
-  const minX = new Float64Array(members.length).fill(Infinity);
-  const minY = new Float64Array(members.length).fill(Infinity);
-  const maxY = new Float64Array(members.length).fill(-Infinity);
-  for (let i = 0; i < X.length; i++) {
-    const k = comp[i];
-    minX[k] = Math.min(minX[k], X[i]);
-    minY[k] = Math.min(minY[k], Y[i]);
-    maxY[k] = Math.max(maxY[k], Y[i]);
-  }
-  const shift = new Float64Array(members.length);
-  let y = 0;
-  for (let k = 0; k < members.length; k++) {
-    shift[k] = y - minY[k];
-    y += maxY[k] - minY[k] + gap;
-  }
-  for (let i = 0; i < X.length; i++) {
-    const k = comp[i];
-    X[i] = X[i] - minX[k];
-    Y[i] = Y[i] + shift[k];
-  }
-}
-function rotateToPrincipalAxis(X, Y, points) {
-  if (points.length < 3) {
-    return;
-  }
-  let cx = 0;
-  let cy = 0;
-  for (const i of points) {
-    cx += X[i];
-    cy += Y[i];
-  }
-  cx /= points.length;
-  cy /= points.length;
-  let sxx = 0;
-  let syy = 0;
-  let sxy = 0;
-  for (const i of points) {
-    const dx = X[i] - cx;
-    const dy = Y[i] - cy;
-    sxx += dx * dx;
-    syy += dy * dy;
-    sxy += dx * dy;
-  }
-  const angle = -0.5 * Math.atan2(2 * sxy, sxx - syy);
-  const cos = Math.cos(angle);
-  const sin = Math.sin(angle);
-  for (const i of points) {
-    const dx = X[i] - cx;
-    const dy = Y[i] - cy;
-    X[i] = cx + cos * dx - sin * dy;
-    Y[i] = cy + sin * dx + cos * dy;
-  }
-}
-
-export {
-  chains,
-  stressLayout
-};

package/dist/layout/stressEngine.js

@@ -1,11 +0,0 @@
-import {
-  chains,
-  stressLayout
-} from "../chunks/chunk-Q6FRNVDU.js";
-import "../chunks/chunk-LYJ4US66.js";
-import "../chunks/chunk-JVLURPFW.js";
-import "../chunks/chunk-FYQWPEEY.js";
-export {
-  chains,
-  stressLayout
-};

package/dist/layout/stressPlacement.js

@@ -1,7 +0,0 @@
-import {
-  stressPlacement
-} from "../chunks/chunk-LYJ4US66.js";
-import "../chunks/chunk-JVLURPFW.js";
-export {
-  stressPlacement
-};

package/dist/types/layout/stressEngine.d.ts

@@ -1,27 +0,0 @@
-import type { EngineRequest } from '../pipeline.js';
-import type { LayoutResult } from '../types.js';
-export type Side = 0 | 1;
-export interface Chains {
-    ids: string[];
-    first: Int32Array;
-    count: Int32Array;
-    per: Float64Array;
-    links: [number, Side][][][];
-    chainOf: Int32Array;
-    indexOf: Int32Array;
-    seedX: Float64Array;
-    seedY: Float64Array;
-    backbone: Uint8Array;
-    off: Int32Array;
-    nb: Int32Array;
-    wt: Float64Array;
-    n: number;
-    link: number;
-}
-export declare function chains(request: EngineRequest): Chains;
-export interface StressOptions {
-    quality?: number;
-    seed?: number;
-    componentSeparation?: number;
-}
-export declare function stressLayout(request: EngineRequest, opts?: StressOptions): LayoutResult;

package/dist/types/layout/stressPlacement.d.ts

@@ -1,5 +0,0 @@
-import type { Chains } from './stressEngine.js';
-export declare function stressPlacement(c: Chains): {
-    X: Float64Array<ArrayBuffer>;
-    Y: Float64Array<ArrayBuffer>;
-};

package/dist/chunks/{chunk-EU6FBTQF.js → chunk-HQ2AHRMH.js}

@@ -1,9 +1,9 @@
-import {
-  MAX_GAP_PX
-} from "./chunk-HK5Y2YWV.js";
 import {
   tubeMapMismatches
 } from "./chunk-XXT2JCAC.js";
+import {
+  MAX_GAP_PX
+} from "./chunk-HK5Y2YWV.js";
 import {
   readColor
 } from "./chunk-CWFNEKST.js";