higlass 1.13.5 → 1.13.6

package/app/scripts/utils/get-default-track-for-datatype.js

@@ -1,15 +1,43 @@
-// @ts-nocheck
 // Configs
 import { DEFAULT_TRACKS_FOR_DATATYPE } from '../configs';
 
+/** @typedef {typeof DEFAULT_TRACKS_FOR_DATATYPE} DataTypeMapping */
+/** @typedef {keyof DataTypeMapping} DataType */
+/** @typedef {"top" | "bottom" | "left" | "right" | "center"} TrackPosition */
+
+/**
+ * @template {string} D
+ * @template {string} P
+ * @typedef {D extends DataType ? P extends keyof DataTypeMapping[D] ? DataTypeMapping[D][P] : undefined : undefined} ExtractDataType
+ */
+
+/**
+ * @template {DataType | string & {}} D
+ * @template {TrackPosition} P
+ *
+ * @param {D} datatype
+ * @param {P} position
+ * @returns {ExtractDataType<D, P>}
+ */
+function findDefaultTrackType(datatype, position) {
+  // @ts-expect-error - ok with undefined check
+  return DEFAULT_TRACKS_FOR_DATATYPE[datatype] !== undefined
+    ? // @ts-expect-error - ok with undefined check
+      DEFAULT_TRACKS_FOR_DATATYPE[datatype][position]
+    : undefined;
+}
+
 /**
  * Gets the default track as defined in utils/default-tracks-for-datatype.js
  *
- * @param  {string} datatype The datatype to get the default track for
- * @param  {string} position   top, bottom, left, right, center
- * @param  {array} availableTracks   list of tracks to choose from,
- * typically obtained from AVAILABLE_TRACK_TYPES(...)
- * @return {object}  an element of availableTracks or undefined
+ * @template {DataType | string & {}} D
+ * @template {TrackPosition} P
+ * @template {ReadonlyArray<{ type: string }>} ATracks
+ *
+ * @param  {D} datatype - The datatype to get the default track for
+ * @param  {P} position - top, bottom, left, right, center
+ * @param  {ATracks} availableTracks - List of tracks to choose from, typically obtained from AVAILABLE_TRACK_TYPES(...)
+ * @return {ATracks[number] | undefined} An element of availableTracks or undefined
  */
 const getDefaultTrackForDatatype = (datatype, position, availableTracks) => {
   if (availableTracks.length === 0) {
@@ -21,10 +49,8 @@ const getDefaultTrackForDatatype = (datatype, position, availableTracks) => {
   }
 
   let usedTrack = availableTracks[0];
-  const defaultTrackType =
-    DEFAULT_TRACKS_FOR_DATATYPE[datatype] !== undefined
-      ? DEFAULT_TRACKS_FOR_DATATYPE[datatype][position]
-      : undefined;
+
+  const defaultTrackType = findDefaultTrackType(datatype, position);
 
   if (defaultTrackType !== undefined) {
     // If we found a default track type for this datatype,

package/app/scripts/utils/get-higlass-components.js

@@ -1,19 +1,43 @@
-// @ts-nocheck
+/** @import * as t from '../types' */
+/** @import HiGlassComponent from '../HiGlassComponent' */
+/** @import { TrackRenderer } from '../TrackRenderer' */
+/** @import { TiledPlot } from '../TiledPlot' */
+
+/**
+ * @param {HiGlassComponent} hgc
+ * @param {string} viewUid
+ * @param {string | undefined} trackUid
+ * @returns {t.TrackObject | undefined}
+ */
 export const getTrackObjectFromHGC = (hgc, viewUid, trackUid) => {
+  /** @type {string} */
   let newViewUid = viewUid;
-  let newTrackUid = trackUid;
+  /** @type {string} */
+  let newTrackUid;
 
   if (!trackUid) {
     // didn't specify a trackUid so use the viewUid as the trackUid
     // and use the first plot
     newTrackUid = viewUid;
     newViewUid = Object.values(hgc.state.views)[0].uid;
+  } else {
+    newTrackUid = trackUid;
   }
 
-  return hgc.tiledPlots[newViewUid].trackRenderer.getTrackObject(newTrackUid);
+  return hgc.tiledPlots[newViewUid].trackRenderer?.getTrackObject(newTrackUid);
 };
 
+/**
+ * @param {HiGlassComponent} hgc
+ * @param {string} viewUid
+ * @returns {TrackRenderer | null}
+ */
 export const getTrackRenderer = (hgc, viewUid) =>
   hgc.tiledPlots[viewUid].trackRenderer;
 
+/**
+ * @param {HiGlassComponent} hgc
+ * @param {string} viewUid
+ * @returns {TiledPlot}
+ */
 export const getTiledPlot = (hgc, viewUid) => hgc.tiledPlots[viewUid];

package/app/scripts/utils/get-track-position-by-uid.js

@@ -1,10 +1,17 @@
-// @ts-nocheck
 import visitPositionedTracks from './visit-positioned-tracks';
 
+/** @import { TrackPosition } from '../types' */
+/** @import { PositionedTracks } from './visit-positioned-tracks' */
+
 /**
  * Get a track's orientation by its UID.
+ *
+ * @param {PositionedTracks} positionedTracks
+ * @param {string} uid
+ * @returns {TrackPosition | null}
  */
 const getTrackPositionByUid = (positionedTracks, uid) => {
+  /** @type {TrackPosition | null} */
   let position = null;
 
   visitPositionedTracks(positionedTracks, (track, trackPosition) => {

package/app/scripts/utils/get-xylofon.js

@@ -1,13 +1,16 @@
-// @ts-nocheck
-/* global XYLOPHON:false */
-
 import map from './map';
 
-const getXylofon = () => [
-  window,
-  map((c) => c.charCodeAt(0))(XYLOPHON)
-    .map((number) => (number <= 999 ? `00${number}`.slice(-3) : number))
-    .join(''),
-];
+// Trevor(2025-02-18): Really not sure what the purpose of this module is.
+
+const getXylofon = () =>
+  /** @type {const} */ ([
+    window,
+    map((c) => c.charCodeAt(0))(
+      // @ts-expect-error - A global added by `vite.config.js`.
+      XYLOPHON,
+    )
+      .map((number) => (number <= 999 ? `00${number}`.slice(-3) : number))
+      .join(''),
+  ]);
 
 export default getXylofon;

package/app/scripts/utils/has-parent.js

@@ -1,16 +1,16 @@
-// @ts-nocheck
 /**
  * Test whether a DOM element is the parent of another DOM element.
  *
- * @param {object} el - Potential child element.
- * @param {object} target - Target parent element which is tested to have `el`
- *   as a child.
- * @return  {Boolean}  If `true` `el` has `target` as a parent.
+ * @param {HTMLElement} el - Potential child element.
+ * @param {HTMLElement} target - Target parent element which is tested to have `el` as a child.
+ * @return {boolean}  If `true` `el` has `target` as a parent.
  */
 const hasParent = (el, target) => {
+  /** @type {HTMLElement | null} */
   let _el = el;
 
   while (_el && _el !== target && _el.tagName !== 'HTML') {
+    // @ts-expect-error - we know ParentElement is also DOM or null
     _el = _el.parentNode;
   }
 

package/app/scripts/utils/hex-string-to-int.js

@@ -10,6 +10,6 @@
  * @param {string} str - HEX string
  * @return {number} An (integer) HEX number
  */
-const hexStrToInt = (str) => parseInt(str.replace(/^#/, ''), 16);
+const hexStrToInt = (str) => Number.parseInt(str.replace(/^#/, ''), 16);
 
 export default hexStrToInt;

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)