higlass 1.13.6 → 2.0.1

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

@@ -24,7 +24,8 @@ function findDefaultTrackType(datatype, position) {
   return DEFAULT_TRACKS_FOR_DATATYPE[datatype] !== undefined
     ? // @ts-expect-error - ok with undefined check
       DEFAULT_TRACKS_FOR_DATATYPE[datatype][position]
-    : undefined;
+    : // @ts-expect-error - ok with undefined check
+      undefined;
 }
 
 /**

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/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,

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/show-mouse-position.js

@@ -119,22 +119,6 @@ const showMousePosition = (
       y = event.isFrom2dTrack ? event.dataY : event.dataX;
     }
 
-    // If a track is not 2d and is horizontal, the event.dataY
-    // value of the mouse pointer location should not be allowed
-    // to impact how other tracks globally render their mouse
-    // position (see https://github.com/higlass/higlass/issues/814).
-    // Likewise, if a track is not 2d and is vertical, the
-    // event.dataX value should not be used by other tracks for
-    // position reporting.
-
-    if (!event.isFrom2dTrack) {
-      if (!event.isFromVerticalTrack) {
-        y = Number.MIN_SAFE_INTEGER;
-      } else {
-        x = Number.MIN_SAFE_INTEGER;
-      }
-    }
-
     // 2d or central tracks are not offset and rather rely on a mask, i.e., the
     // top left *visible* position is *not* [0,0] but given by `getPosition()`.
     const offset = is2d ? getPosition() : [0, 0];

package/app/scripts/utils/visit-positioned-tracks.js

@@ -2,7 +2,10 @@ import visitTracks from './visit-tracks';
 
 /** @import { TrackConfig, TrackPosition, TrackVisitor } from '../types' */
 
-/** @typedef {{ [Key in TrackPosition]?: Array<TrackConfig> }} PositionedTracks */
+/**
+ * @template [T=TrackConfig]
+ * @typedef {{ [Key in TrackPosition]?: Array<T> }} PositionedTracks
+ */
 
 /**
  * Track visitor for positioned tracks, i.e., tracks with a position.

package/app/styles/AddTrackPositionMenu.module.scss

@@ -65,6 +65,7 @@
   text-align: center;
   outline: none;
   border: 1px solid $gray;
+  position: relative;
 }
 
 .add-track-position-middle-middle:hover {
@@ -72,6 +73,42 @@
   color: $white;
 }
 
+.add-track-position-middle-middle-full {
+  height: 80px;
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  align-items: center;
+}
+
+.add-track-position-middle-middle-upper-right {
+  width: 0;
+  height: 0;
+  border-top: 30px solid $gray;
+  border-left: 30px solid transparent;
+  position: absolute;
+  top: 0;
+  right: 0;
+}
+
+.add-track-position-middle-middle-upper-right:hover {
+  border-top: 30px solid $active;
+}
+
+.add-track-position-middle-middle-lower-left {
+  width: 0;
+  height: 0;
+  border-bottom: 30px solid $gray;
+  border-right: 30px solid transparent;
+  position: absolute;
+  bottom: 0;
+  left: 0;
+}
+
+.add-track-position-middle-middle-lower-left:hover {
+  border-bottom: 30px solid $active;
+}
+
 .add-track-position-bottom-middle {
   min-height: 20px;
   text-align: center;

package/app/styles/HiGlass.module.scss

@@ -28,11 +28,11 @@
 .higlass-canvas {
   position: absolute;
   width: 100%;
-  height: 100%;
 }
 
 .higlass-drawing-surface {
   position: relative;
+  width: 100%
 }
 
 .higlass-svg {
@@ -47,6 +47,8 @@
 .tiled-area {
   display: flex;
   flex-direction: column;
+  width: 100%;
+  height: 100%;
 }
 
 .track-mouseover-menu {

package/app/styles/TiledPlot.module.scss

@@ -63,3 +63,23 @@
 path.domain {
   stroke-width: 0px;
 }
+
+.tiled-plot-track-overlay-plain {
+  background: transparent;
+  z-index: 1;
+}
+
+.tiled-plot-track-overlay-animate {
+  background: yellow;
+  opacity: 0.3;
+  outline: 2px solid rgba(255, 0, 0, 0.8);
+  z-index: 1;
+  animation: appear 1s;
+}
+
+.tiled-plot-track-overlay-selected {
+  border: 5px solid black;
+  background: yellow;
+  opacity: 0.4;
+  z-index: 1;
+}