higlass 1.13.5 → 2.0.0

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

@@ -1,15 +1,44 @@
-// @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]
+    : // @ts-expect-error - ok with undefined check
+      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 +50,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-default-tracks-for-datatype.ts

@@ -0,0 +1,46 @@
+// @ts-nocheck
+import { DEFAULT_TRACKS_FOR_DATATYPE, TRACKS_INFO_BY_TYPE } from '../configs';
+
+/** Get the default tracks for a datatype. Uses the known track definitions as
+ * well as any extra definitions that may be passed in. */
+export default function getDefaultTracksForDatatype(
+  datatype,
+  otherDefaultTracks,
+) {
+  if (window.higlassTracksByType) {
+    // Extend `TRACKS_INFO_BY_TYPE` with the configs of plugin tracks.
+    Object.keys(window.higlassTracksByType).forEach((pluginTrackType) => {
+      TRACKS_INFO_BY_TYPE[pluginTrackType] =
+        window.higlassTracksByType[pluginTrackType].config;
+    });
+  }
+
+  if (!(datatype in DEFAULT_TRACKS_FOR_DATATYPE) && !otherDefaultTracks) {
+    console.warn('unknown data type:', datatype);
+    return undefined;
+  }
+
+  const orientationToPositions = {
+    '1d-horizontal': ['top', 'bottom', 'left', 'right'],
+    '2d': ['center'],
+    '1d-vertical': ['left', 'right'],
+  };
+
+  const defaultTracks = DEFAULT_TRACKS_FOR_DATATYPE[datatype] || {};
+
+  if (otherDefaultTracks) {
+    for (const trackType of otherDefaultTracks) {
+      if (!TRACKS_INFO_BY_TYPE[trackType]) {
+        console.warn('unknown track type', trackType);
+      } else {
+        for (const position of orientationToPositions[
+          TRACKS_INFO_BY_TYPE[trackType].orientation
+        ]) {
+          defaultTracks[position] = trackType;
+        }
+      }
+    }
+  }
+
+  return defaultTracks;
+}

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/index.js

@@ -83,6 +83,7 @@ export { default as DenseDataExtrema2D } from './DenseDataExtrema2D';
 export { default as getAggregationFunction } from './get-aggregation-function';
 export { default as selectedItemsToSize } from './selected-items-to-size';
 export { default as IS_TRACK_RANGE_SELECTABLE } from './is-track-range-selectable';
+export { default as getDefaultTracksForDatatype } from './default-tracks';
 
 export {
   getTrackObjectFromHGC,