higlass 1.13.5 → 2.0.0

package/app/scripts/utils/interval-tree.js

@@ -1,47 +1,221 @@
-// @ts-nocheck
-function IntervalTreeNode(start, end, left, right) {
+/** @typedef {[start: number, end: number]} Interval */
+
+class IntervalTreeNode {
   /**
-   * Node interval.
-   * @member {Array}
+   * @param {number} start
+   * @param {number} end
+   * @param {IntervalTreeNode} [left]
+   * @param {IntervalTreeNode} [right]
    */
-  this.interval = [start, end];
+  constructor(start, end, left, right) {
+    /**
+     * Node interval.
+     * @type {Interval}
+     */
+    this.interval = [start, end];
+    /**
+     * Max endpoint in subtree which starts from this node.
+     * @type {number}
+     */
+    this.max = Number.NEGATIVE_INFINITY;
+    /**
+     * Parent node.
+     * @type {IntervalTreeNode | null}
+     */
+    this.parentNode = null;
+    /**
+     * Left child node.
+     * @type {IntervalTreeNode | null}
+     */
+    this.left = left ?? null;
+    /**
+     * Right child node.
+     * @type {IntervalTreeNode | null}
+     */
+    this.right = right ?? null;
+  }
+}
+
+/**
+ * Interval tree.
+ *
+ * @public
+ * @constructor
+ */
+export class IntervalTree {
+  constructor() {
+    /**
+     * Root node of the tree.
+     * @type {IntervalTreeNode | null}
+     */
+    this.root = null;
+  }
   /**
-   * Max endpoint in subtree which starts from this node.
-   * @member {Number}
+   * Add new interval to the tree.
+   *
+   * @public
+   * @param {Interval} interval - Array with start and end points of the interval.
    */
-  this.max = -Infinity;
+  add(interval) {
+    if (!this.root) {
+      this.root = new IntervalTreeNode(interval[0], interval[1]);
+      this.root.max = interval[1];
+      return;
+    }
+    addHelper(this.root, interval);
+  }
   /**
-   * Parent node.
-   * @member {IntervalTreeNode}
+   * Checks or point belongs to at least one intarval from the tree.<br><br>
+   * Complexity: O(log N).
+   *
+   * @public
+   * @method
+   * @param {Number} point Point which should be checked.
+   * @return {Boolean} True if point belongs to one of the intervals.
    */
-  this.parentNode = null;
+  contains(point) {
+    return contains(point, this.root);
+  }
   /**
-   * Left child node.
-   * @member {IntervalTreeNode}
+   * Checks or interval belongs to at least one intarval from the tree.<br><br>
+   * Complexity: O(log N).
+   *
+   * @public
+   * @method
+   * @param {Interval} interval Interval which should be checked.
+   * @return {boolean} True if interval intersects with one of the intervals.
    */
-  this.left = left;
+  intersects(interval) {
+    return intersectsHelper(interval, this.root);
+  }
   /**
-   * Right child node.
-   * @member {IntervalTreeNode}
+   * Returns height of the tree.
+   *
+   * @public
+   * @method
+   * @return {Number} Height of the tree.
    */
-  this.right = right;
-}
+  height() {
+    return heightHelper(this.root);
+  }
+  /**
+   * Returns node with the max endpoint in subtree.
+   *
+   * @public
+   * @method
+   * @param {IntervalTreeNode} node Root node of subtree.
+   * @return {IntervalTreeNode | null} IntervalTreeNode with the largest endpoint.
+   */
+  findMax(node) {
+    const stack = [node];
+    let current;
+    let max = Number.NEGATIVE_INFINITY;
+    let maxNode;
+    while (stack.length) {
+      current = stack.pop();
+      if (current?.left) {
+        stack.push(current.left);
+      }
+      if (current?.right) {
+        stack.push(current.right);
+      }
+      // @ts-expect-error - ok assertion
+      if (current?.interval[1] > max) {
+        // @ts-expect-error - only ok if above assertion succeeds
+        max = current.interval[1];
+        maxNode = current;
+      }
+    }
+    return maxNode ?? null;
+  }
 
-/**
- * Interval tree.
- *
- * @public
- * @constructor
- */
-export default function IntervalTree() {
   /**
-   * Root node of the tree.
-   * @member {IntervalTreeNode}
+   * Adjust the max value.
+   *
+   * @param {Interval} interval
+   * @param {IntervalTreeNode | null} node
    */
-  this.root = null;
+  _removeHelper(interval, node) {
+    if (!node) {
+      return;
+    }
+    if (node.interval[0] === interval[0] && node.interval[1] === interval[1]) {
+      // When left and right children exists
+      if (node.left && node.right) {
+        let replacement = node.left;
+        while (replacement.left) {
+          replacement = replacement.left;
+        }
+        const temp = replacement.interval;
+        replacement.interval = node.interval;
+        node.interval = temp;
+        this._removeHelper(replacement.interval, node);
+      } else {
+        // When only left or right child exists
+        /** @type {"left" | "right"} */
+        let side = 'left';
+        if (node.right) {
+          side = 'right';
+        }
+        const parentNode = node.parentNode;
+        if (parentNode) {
+          if (parentNode.left === node) {
+            parentNode.left = node[side];
+          } else {
+            parentNode.right = node[side];
+          }
+          if (node[side]) {
+            // @ts-expect-error - ok to set to a node
+            node[side].parentNode = parentNode;
+          }
+        } else {
+          this.root = node[side];
+          // last node removed
+          if (this.root) {
+            this.root.parentNode = null;
+          }
+        }
+      }
+      // Adjust the max value
+      const p = node.parentNode;
+      if (p) {
+        let maxNode = this.findMax(p);
+        const max = maxNode?.interval[1] ?? Number.NEGATIVE_INFINITY;
+        while (maxNode) {
+          if (maxNode.max === node.interval[1]) {
+            maxNode.max = max;
+            maxNode = maxNode.parentNode;
+          } else {
+            maxNode = null;
+          }
+        }
+      }
+    } else {
+      // could be optimized
+      this._removeHelper(interval, node.left);
+      this._removeHelper(interval, node.right);
+    }
+  }
+  /**
+   * Remove interval from the tree.
+   *
+   * @public
+   * @method
+   * @param {Interval} interval - Array with start and end of the interval.
+   */
+  remove(interval) {
+    return this._removeHelper(interval, this.root);
+  }
 }
 
+/**
+ * @param {IntervalTreeNode} node
+ * @param {"left"| "right"} side
+ * @param {Interval} interval
+ * @returns {void}
+ */
 function addNode(node, side, interval) {
+  /** @type {IntervalTreeNode | null} */
   let child = new IntervalTreeNode(interval[0], interval[1]);
   child.max = interval[1];
   child.parentNode = node;
@@ -56,6 +230,11 @@ function addNode(node, side, interval) {
   }
 }
 
+/**
+ * @param {IntervalTreeNode} node
+ * @param {Interval} interval
+ * @returns {void}
+ */
 function addHelper(node, interval) {
   if (node.interval[0] > interval[0]) {
     if (node.left) {
@@ -71,20 +250,10 @@ function addHelper(node, interval) {
 }
 
 /**
- * Add new interval to the tree.
- *
- * @public
- * @param {Array} intreval Array with start and end points of the interval.
+ * @param {number} point
+ * @param {IntervalTreeNode | null} node
+ * @returns {boolean}
  */
-IntervalTree.prototype.add = function add(interval) {
-  if (!this.root) {
-    this.root = new IntervalTreeNode(interval[0], interval[1]);
-    this.root.max = interval[1];
-    return;
-  }
-  addHelper(this.root, interval);
-};
-
 function contains(point, node) {
   if (!node) {
     return false;
@@ -94,7 +263,7 @@ function contains(point, node) {
   }
   let result = false;
   let temp;
-  ['left', 'right'].forEach((key) => {
+  /** @type {const} */ (['left', 'right']).forEach((key) => {
     temp = node[key];
     if (temp) {
       if (temp.max > point) {
@@ -106,18 +275,10 @@ function contains(point, node) {
 }
 
 /**
- * Checks or point belongs to at least one intarval from the tree.<br><br>
- * Complexity: O(log N).
- *
- * @public
- * @method
- * @param {Number} point Point which should be checked.
- * @return {Boolean} True if point belongs to one of the intervals.
+ * @param {Interval} a
+ * @param {Interval} b
+ * @returns {boolean}
  */
-IntervalTree.prototype.contains = function _contains(point) {
-  return contains(point, this.root);
-};
-
 function intersects(a, b) {
   return (
     // The first case checks for completely overlapping
@@ -132,6 +293,11 @@ function intersects(a, b) {
   );
 }
 
+/**
+ * @param {Interval} interval
+ * @param {IntervalTreeNode | null} node
+ * @returns {boolean}
+ */
 function intersectsHelper(interval, node) {
   if (!node) {
     return false;
@@ -141,7 +307,7 @@ function intersectsHelper(interval, node) {
   }
   let result = false;
   let temp;
-  ['left', 'right'].forEach((side) => {
+  /** @type {const} */ (['left', 'right']).forEach((side) => {
     temp = node[side];
     if (temp && temp.max >= interval[0]) {
       result = result || intersectsHelper(interval, temp);
@@ -151,133 +317,12 @@ function intersectsHelper(interval, node) {
 }
 
 /**
- * Checks or interval belongs to at least one intarval from the tree.<br><br>
- * Complexity: O(log N).
- *
- * @public
- * @method
- * @param {Array} interval Interval which should be checked.
- * @return {Boolean} True if interval intersects with one of the intervals.
+ * @param {IntervalTreeNode | null} node
+ * @returns {number}
  */
-IntervalTree.prototype.intersects = function _intersects(interval) {
-  return intersectsHelper(interval, this.root);
-};
-
 function heightHelper(node) {
   if (!node) {
     return 0;
   }
   return 1 + Math.max(heightHelper(node.left), heightHelper(node.right));
 }
-
-/**
- * Returns height of the tree.
- *
- * @public
- * @method
- * @return {Number} Height of the tree.
- */
-IntervalTree.prototype.height = function height() {
-  return heightHelper(this.root);
-};
-
-/**
- * Returns node with the max endpoint in subtree.
- *
- * @public
- * @method
- * @param {IntervalTreeNode} node Root node of subtree.
- * @return {IntervalTreeNode} IntervalTreeNode with the largest endpoint.
- */
-IntervalTree.prototype.findMax = function findMax(node) {
-  const stack = [node];
-  let current;
-  let max = -Infinity;
-  let maxNode;
-  while (stack.length) {
-    current = stack.pop();
-    if (current.left) {
-      stack.push(current.left);
-    }
-    if (current.right) {
-      stack.push(current.right);
-    }
-    if (current.interval[1] > max) {
-      max = current.interval[1];
-      maxNode = current;
-    }
-  }
-  return maxNode;
-};
-
-// adjust the max value
-IntervalTree.prototype._removeHelper = function _removeHelper(interval, node) {
-  if (!node) {
-    return;
-  }
-  if (node.interval[0] === interval[0] && node.interval[1] === interval[1]) {
-    // When left and right children exists
-    if (node.left && node.right) {
-      let replacement = node.left;
-      while (replacement.left) {
-        replacement = replacement.left;
-      }
-      const temp = replacement.interval;
-      replacement.interval = node.interval;
-      node.interval = temp;
-      this._removeHelper(replacement.interval, node);
-    } else {
-      // When only left or right child exists
-      let side = 'left';
-      if (node.right) {
-        side = 'right';
-      }
-      const parentNode = node.parentNode;
-      if (parentNode) {
-        if (parentNode.left === node) {
-          parentNode.left = node[side];
-        } else {
-          parentNode.right = node[side];
-        }
-        if (node[side]) {
-          node[side].parentNode = parentNode;
-        }
-      } else {
-        this.root = node[side];
-        // last node removed
-        if (this.root) {
-          this.root.parentNode = null;
-        }
-      }
-    }
-    // Adjust the max value
-    const p = node.parentNode;
-    if (p) {
-      let maxNode = this.findMax(p);
-      const max = maxNode.interval[1];
-      while (maxNode) {
-        if (maxNode.max === node.interval[1]) {
-          maxNode.max = max;
-          maxNode = maxNode.parentNode;
-        } else {
-          maxNode = false;
-        }
-      }
-    }
-  } else {
-    // could be optimized
-    this._removeHelper(interval, node.left);
-    this._removeHelper(interval, node.right);
-  }
-};
-
-/**
- * Remove interval from the tree.
- *
- * @public
- * @method
- * @param {Array} intreval Array with start and end of the interval.
- */
-IntervalTree.prototype.remove = function remove(interval) {
-  return this._removeHelper(interval, this.root);
-};

package/app/scripts/utils/load-chrom-infos.js

@@ -1,8 +1,11 @@
-// @ts-nocheck
 import { chromInfo } from '../services';
 
 import objVals from './obj-vals';
 
+/**
+ * @param {Record<string, { chromInfoPath: string }>} views
+ * @returns {void}
+ */
 const loadChromInfos = (views) =>
   objVals(views)
     .map((view) => view.chromInfoPath)

package/app/scripts/utils/pixi-text-to-svg.js

@@ -1,10 +1,7 @@
-// @ts-nocheck
 /**
  * Export a PIXI text to an SVG element
- *
- * param {PIXI.Text} pixiText A PIXI.Text object that we want to create an SVG element for
- * returns {Element} A DOM SVG Element with all of the attributes set as to display
- * the given text.
+ * @param {import('pixi.js').Text} pixiText A PIXI.Text object that we want to create an SVG element for
+ * @returns { HTMLElement } A DOM SVG Element with all of the attributes set as to display the given text.
  */
 export const pixiTextToSvg = (pixiText) => {
   const g = document.createElement('g');
@@ -18,11 +15,10 @@ export const pixiTextToSvg = (pixiText) => {
     t.setAttribute('text-anchor', 'middle');
   }
 
-  t.setAttribute('font-family', pixiText.style.fontFamily);
-  t.setAttribute('font-size', pixiText.style.fontSize);
+  t.setAttribute('font-family', pixiText.style.fontFamily?.toString() ?? '');
+  t.setAttribute('font-size', pixiText.style.fontSize?.toString() ?? '');
   g.setAttribute('transform', `scale(${pixiText.scale.x},1)`);
-
-  t.setAttribute('fill', pixiText.style.fill);
+  t.setAttribute('fill', pixiText.style.fill?.toString() ?? '');
   t.innerHTML = pixiText.text;
 
   g.appendChild(t);

package/app/scripts/utils/positioned-tracks-to-all-tracks.js

@@ -0,0 +1,55 @@
+/** @import { PositionedTracks } from './visit-positioned-tracks' */
+/** @import { TrackConfig, TrackPosition } from '../types' */
+
+import { TRACK_LOCATIONS } from '../configs';
+
+/**
+ * Convert the position indexed list of tracks.
+ *
+ * If `includeCombinedContents` is `true`, tracks inside
+ * `combined.contents` will also be included in the output.
+ *
+ * @template {{ type: string } | { type: 'combined', contents: Array<T> }} T
+ *
+ * @param {PositionedTracks<T>} positionedTracks
+ * @param {{ includeCombinedContents?: boolean }} options
+ * @returns {Array<T & { position: TrackPosition }>}
+ *
+ */
+const positionedTracksToAllTracks = (
+  positionedTracks,
+  { includeCombinedContents = true } = {},
+) => {
+  /** @type {Array<T & { position: keyof PositionedTracks }>} */
+  const allTracks = [];
+
+  for (const trackType of TRACK_LOCATIONS) {
+    const theseTracks = positionedTracks[trackType];
+
+    theseTracks?.forEach((x) => {
+      if ('contents' in x) {
+        // we don't really deal with nested combined tracks here,
+        // but those shouldn't really be used anyway
+        if (includeCombinedContents) {
+          x.contents.forEach((y) => {
+            allTracks.push(
+              Object.assign({}, y, {
+                position: trackType,
+              }),
+            );
+          });
+        }
+      }
+
+      allTracks.push(
+        Object.assign({}, x, {
+          position: trackType,
+        }),
+      );
+    });
+  }
+
+  return allTracks;
+};
+
+export default positionedTracksToAllTracks;

package/app/scripts/utils/range-query-2d.js

@@ -1,6 +1,6 @@
 // @ts-nocheck
-import addArrays from './add-arrays';
 import accessorTransposition from './accessor-transposition';
+import addArrays from './add-arrays';
 
 /**
  * Perform a 2D query on a 1D array
@@ -24,9 +24,9 @@ const rangeQuery2d = (
   xRange,
   yRange,
   mirrored,
-  /* eslint-disable-next-line default-param-last */
+  // biome-ignore lint/style/useDefaultParameterLast:
   xOff = 0,
-  /* eslint-disable-next-line default-param-last */
+  // biome-ignore lint/style/useDefaultParameterLast:
   yOff = 0,
   outList,
 ) => {

package/app/scripts/utils/reduce.js

@@ -1,10 +1,17 @@
-// @ts-nocheck
 /**
- * Pure functional reducer. Can be used for currying stuff. Check out `flatten.js`.
- * @param   {function}  f  Reducer function.
- * @return  {array}  Curried function that accepts an array to be reduced.
+ * Pure functional reducer. Can be used for currying stuff.
+ *
+ * @see {@link ./flatten.js}
+ *
+ * @template T
+ * @template U
+ *
+ * @param {(previousValue: U, currentValue: T, currentIndex: number, array: Array<T>) => U} callbackfn
+ * @param {U} initialValue
+ * @return {(x: Array<T>) => U}  Curried function that accepts an array to be reduced.
  */
-const reduce = (f) => (x) => Array.prototype.reduce.call(x, f);
+const reduce = (callbackfn, initialValue) => (x) =>
+  x.reduce(callbackfn, initialValue);
 
 // TODO(Trevor): Not referenced anywhere. Remove?
 export default reduce;

package/app/scripts/utils/segments-to-rows.js

@@ -1,18 +1,20 @@
-// @ts-nocheck
-import IntervalTree from './interval-tree';
-
+import { IntervalTree } from './interval-tree';
+
+/** @typedef {{ from:number, to: number }} Segment */
+
+/**
+ * Partition a list of segments into an array of rows containing the segments.
+ *
+ * WARNING: Sorts the `segments` array input _inplace_.
+ *
+ * @param {Array<Segment>} segments An array of segments (e.g. [{from: 10, to: 20}, {from: 18, to: 30}])
+ * @return: {Array<Array<Segment>>} non-overlapping rows of segments
+ */
 function segmentsToRows(segments) {
-  /**
-   * Partition a list of segments into an array of
-   * rows containing the segments.
-   *
-   * @param segments: An array of segments (e.g. [{from: 10, to: 20}, {from: 18, to: 30}])
-   * @return: An array of arrays of segments, representing
-   *          non-overlapping rows of segments
-   */
   // sort by the length of each segment
   segments.sort((a, b) => b.to - b.from - (a.to - a.from));
 
+  /** @type {Array<Array<Segment>>} */
   const rows = [[]];
   const rowIts = [new IntervalTree()];
 
@@ -23,6 +25,7 @@ function segmentsToRows(segments) {
     for (let j = 0; j < rows.length; j++) {
       const it = rowIts[j]; // an interval tree
 
+      /** @type {[number, number]} */
       const toCheck = [+segments[i].from, +segments[i].to];
       const occluded = it.intersects(toCheck);
 

package/app/scripts/utils/svg-line.js

@@ -1,4 +1,3 @@
-// @ts-nocheck
 /**
  * Generate a SVG line
  * @param   {number}  x1  Start X
@@ -6,19 +5,19 @@
  * @param   {number}  x2  End X
  * @param   {number}  y2  End Y
  * @param   {number}  strokeWidth  Line width
- * @param   {number}  strokeColor  Color HEX string
- * @return  {object}  SVG line object
+ * @param   {string}  strokeColor  Color HEX string
+ * @return  {HTMLElement}  SVG line object
  */
 export const svgLine = (x1, y1, x2, y2, strokeWidth, strokeColor) => {
   const line = document.createElement('line');
 
-  line.setAttribute('x1', x1);
-  line.setAttribute('x2', x2);
-  line.setAttribute('y1', y1);
-  line.setAttribute('y2', y2);
+  line.setAttribute('x1', String(x1));
+  line.setAttribute('x2', String(x2));
+  line.setAttribute('y1', String(y1));
+  line.setAttribute('y2', String(y2));
 
   if (strokeWidth) {
-    line.setAttribute('stroke-width', strokeWidth);
+    line.setAttribute('stroke-width', String(strokeWidth));
   }
   if (strokeColor) {
     line.setAttribute('stroke', strokeColor);