higlass 1.13.4 → 1.13.5

package/app/scripts/data-fetchers/DataFetcher.js

@@ -1,16 +1,16 @@
 import slugid from 'slugid';
 import { scaleLinear } from 'd3-scale';
-import {
-  trimTrailingSlash as tts,
-  dictValues,
-  minNonZero,
-  maxNonZero,
-  DenseDataExtrema1D,
-  DenseDataExtrema2D,
-} from '../utils';
+
+// Utils
+import tts from '../utils/trim-trailing-slash';
+import dictValues from '../utils/dict-values';
+import minNonZero from '../utils/min-non-zero';
+import maxNonZero from '../utils/max-non-zero';
+import DenseDataExtrema1D from '../utils/DenseDataExtrema1D';
+import DenseDataExtrema2D from '../utils/DenseDataExtrema2D';
 
 // Services
-import { tileProxy } from '../services';
+import * as tileProxy from '../services/tile-proxy';
 
 /** @typedef {import('../types').DataConfig} DataConfig */
 /** @typedef {import('../types').TilesetInfo} TilesetInfo */
@@ -18,6 +18,10 @@ import { tileProxy } from '../services';
  * @template T
  * @typedef {import('../types').AbstractDataFetcher<T>} AbstractDataFetcher
  */
+/**
+ * @template T
+ * @typedef {import('../types').TileSource<T>} TileSource
+ */
 
 /**
  * @typedef Tile
@@ -49,13 +53,50 @@ function isTuple(x) {
   return x.length === 2;
 }
 
+/**
+ * @param {import("pub-sub-es").PubSub} pubSub
+ * @returns {TileSource<Tile>}
+ */
+function createDefaultTileSource(pubSub) {
+  return {
+    fetchTiles(request) {
+      const ids = request.tileIds;
+      return new Promise((done, _reject) => {
+        tileProxy.fetchTilesDebounced({ ...request, ids, done }, pubSub, true);
+      });
+    },
+    fetchTilesetInfo({ server, tilesetUid }) {
+      return new Promise((resolve, reject) => {
+        tileProxy.trackInfo(server, tilesetUid, resolve, reject, pubSub);
+      });
+    },
+    registerTileset({ server, url, filetype, coordSystem }) {
+      const serverUrl = `${tts(server)}/register_url/`;
+      const payload = {
+        fileurl: url,
+        filetype,
+        coordSystem,
+      };
+      return fetch(serverUrl, {
+        method: 'POST',
+        body: JSON.stringify(payload),
+        headers: {
+          'Content-Type': 'application/json; charset=utf-8',
+        },
+      });
+    },
+  };
+}
+
 /** @implements {AbstractDataFetcher<Tile | DividedTile>} */
 export default class DataFetcher {
   /**
    * @param {import('../types').DataConfig} dataConfig
    * @param {import('pub-sub-es').PubSub} pubSub
+   * @param {TileSource<Tile>} [tileSource]
    */
-  constructor(dataConfig, pubSub) {
+  constructor(dataConfig, pubSub, tileSource) {
+    this._tileSource = tileSource || createDefaultTileSource(pubSub);
     /** @type {boolean} */
     this.tilesetInfoLoading = true;
 
@@ -95,20 +136,11 @@ export default class DataFetcher {
    * @param {string=} opts.coordSystem - The coordinate system being served (e.g. 'hg38')
    */
   async registerFileUrl({ server, url, filetype, coordSystem }) {
-    const serverUrl = `${tts(server)}/register_url/`;
-
-    const payload = {
-      fileurl: url,
+    return this._tileSource.registerTileset({
+      server,
+      url,
       filetype,
       coordSystem,
-    };
-
-    return fetch(serverUrl, {
-      method: 'POST',
-      body: JSON.stringify(payload),
-      headers: {
-        'Content-Type': 'application/json; charset=utf-8',
-      },
     });
   }
 
@@ -160,22 +192,18 @@ export default class DataFetcher {
         );
         finished(null);
       } else {
-        // pass in the callback
-        tileProxy.trackInfo(
-          server,
-          tilesetUid,
-          (/** @type {Record<string, TilesetInfo>} */ tilesetInfo) => {
+        this._tileSource
+          .fetchTilesetInfo({ server, tilesetUid })
+          .then((tilesetInfo) => {
             // tileset infos are indxed by by tilesetUids, we can just resolve
             // that here before passing it back to the track
             this.dataConfig.tilesetInfo = tilesetInfo[tilesetUid];
             finished(tilesetInfo[tilesetUid], tilesetUid);
-          },
-          (/** @type {string} */ error) => {
+          })
+          .catch((error) => {
             this.tilesetInfoLoading = false;
             finished({ error });
-          },
-          this.pubSub,
-        );
+          });
       }
     } else {
       // this data source has children, so we need to wait to get
@@ -231,35 +259,28 @@ export default class DataFetcher {
 
     if (!this.dataConfig.children && this.dataConfig.tilesetUid) {
       // no children, just return the fetched tiles as is
-      /** @type {Promise<Record<string, Tile>>} */
-      const promise = new Promise((resolve) => {
-        tileProxy.fetchTilesDebounced(
-          {
-            id: slugid.nice(),
-            server: this.dataConfig.server,
-            done: resolve,
-            ids: tileIds.map((x) => `${this.dataConfig.tilesetUid}.${x}`),
-            options: this.dataConfig.options,
-          },
-          this.pubSub,
-          true,
-        );
+      const promise = this._tileSource.fetchTiles({
+        id: slugid.nice(),
+        server: this.dataConfig.server,
+        tileIds: tileIds.map((x) => `${this.dataConfig.tilesetUid}.${x}`),
+        options: this.dataConfig.options,
       });
+      return /** @type {Promise<Record<string, Tile>>} */ (promise).then(
+        (returnedTiles) => {
+          const tilesetUid = dictValues(returnedTiles)[0].tilesetUid;
+          /** @type {Record<string, Tile>} */
+          const newTiles = {};
 
-      return promise.then((returnedTiles) => {
-        const tilesetUid = dictValues(returnedTiles)[0].tilesetUid;
-        /** @type {Record<string, Tile>} */
-        const newTiles = {};
-
-        for (let i = 0; i < tileIds.length; i++) {
-          const fullTileId = this.fullTileId(tilesetUid, tileIds[i]);
+          for (let i = 0; i < tileIds.length; i++) {
+            const fullTileId = this.fullTileId(tilesetUid, tileIds[i]);
 
-          returnedTiles[fullTileId].tilePositionId = tileIds[i];
-          newTiles[tileIds[i]] = returnedTiles[fullTileId];
-        }
-        receivedTiles(newTiles);
-        return newTiles;
-      });
+            returnedTiles[fullTileId].tilePositionId = tileIds[i];
+            newTiles[tileIds[i]] = returnedTiles[fullTileId];
+          }
+          receivedTiles(newTiles);
+          return newTiles;
+        },
+      );
     }
 
     // multiple child tracks, need to wait for all of them to
@@ -325,12 +346,12 @@ export default class DataFetcher {
   /**
    * Extract a slice from a matrix at a given position.
    *
-   * @param {Array<number>} inputData - An array containing a matrix stored row-wise
+   * @param {Array<number> | Float32Array} inputData - An array containing a matrix stored row-wise
    * @param {Array<number>} arrayShape - The shape of the array, should be a
    *  two element array e.g. [256,256].
    * @param {number} sliceIndex - The index across which to take the slice
    * @param {number=} axis - The axis along which to take the slice
-   * @returns {Array<number>} an array corresponding to a slice of this matrix
+   * @returns {Array<number> | Float32Array} an array corresponding to a slice of this matrix
    */
   extractDataSlice(inputData, arrayShape, sliceIndex, axis) {
     if (!axis) {
@@ -419,18 +440,12 @@ export default class DataFetcher {
     }
 
     // actually fetch the new tileIds
-    const promise = new Promise((resolve) => {
-      tileProxy.fetchTilesDebounced(
-        {
-          id: slugid.nice(),
-          server: this.dataConfig.server,
-          done: resolve,
-          ids: newTileIds.map((x) => `${this.dataConfig.tilesetUid}.${x}`),
-        },
-        this.pubSub,
-        true,
-      );
+    const promise = this._tileSource.fetchTiles({
+      id: slugid.nice(),
+      server: this.dataConfig.server,
+      tileIds: newTileIds.map((x) => `${this.dataConfig.tilesetUid}.${x}`),
     });
+
     return promise.then((returnedTiles) => {
       // we've received some new tiles, but they're 2D
       // we need to extract the row corresponding to the data we need
@@ -489,7 +504,9 @@ export default class DataFetcher {
         }
 
         const newTile = {
+          // @ts-expect-error - this is ok because float32 array can be spread as number[]
           min_value: Math.min.apply(null, dataSlice),
+          // @ts-expect-error - this is ok because float32 array can be spread as number[]
           max_value: Math.max.apply(null, dataSlice),
           denseDataExtrema: new DenseDataExtrema1D(dataSlice),
           minNonZero: minNonZero(dataSlice),

package/app/scripts/gosling-exports.js

@@ -0,0 +1,29 @@
+// These are all exports that are used is Gosling.js
+
+/**
+ * Tracks
+ */
+export { default as Track } from './Track';
+export { default as PixiTrack } from './PixiTrack';
+export { default as TiledPixiTrack } from './TiledPixiTrack';
+export { default as SVGTrack } from './SVGTrack';
+export { default as ViewportTrackerHorizontal } from './ViewportTrackerHorizontal';
+export { default as HeatmapTiledPixiTrack } from './HeatmapTiledPixiTrack';
+
+/**
+ * Data Fetcher
+ */
+export { default as DataFetcher } from './data-fetchers/DataFetcher';
+/**
+ * Utils
+ */
+export { default as tileProxy } from './services/tile-proxy';
+export { default as fakePubSub } from './utils/fake-pub-sub';
+export { default as DenseDataExtrema1D } from './utils/DenseDataExtrema1D';
+export { default as absToChr } from './utils/abs-to-chr';
+export { default as chrToAbs } from './utils/chr-to-abs';
+export { default as colorToHex } from './utils/color-to-hex';
+export { default as chromInfoBisector } from './utils/chrom-info-bisector';
+export { default as pixiTextToSvg } from './utils/pixi-text-to-svg';
+export { default as svgLine } from './utils/svg-line';
+export { default as showMousePosition } from './utils/show-mouse-position';

package/app/scripts/hglib.jsx

@@ -114,3 +114,5 @@ export const viewer = (element, viewConfig, options) => {
   const hg = launch(element, viewConfig, options);
   return hg.api;
 };
+
+export * as hggos from './gosling-exports';

package/app/scripts/hocs/with-pub-sub.js

@@ -0,0 +1,19 @@
+// @ts-nocheck
+import React from 'react';
+
+import fakePubSub from '../utils/fake-pub-sub';
+
+const { Provider, Consumer } = React.createContext(fakePubSub);
+
+// Written without JSX to make it so we don't need JSX-transformation to load this file
+function withPubSub(Component) {
+  return React.forwardRef((props, ref) =>
+    React.createElement(Consumer, null, (pubSub) =>
+      React.createElement(Component, { ref, ...props, pubSub }),
+    ),
+  );
+}
+
+export default withPubSub;
+
+export { Provider };

package/app/scripts/services/tile-proxy.js

@@ -4,10 +4,11 @@ import slugid from 'slugid';
 
 import { workerGetTiles, workerSetPix } from './worker';
 
-import { trimTrailingSlash as tts, timeout as sleep } from '../utils';
+import tts from '../utils/trim-trailing-slash';
+import sleep from '../utils/timeout';
 
 // Config
-import { TILE_FETCH_DEBOUNCE } from '../configs';
+import { TILE_FETCH_DEBOUNCE } from '../configs/primitives';
 
 const MAX_FETCH_TILES = 15;
 

package/app/scripts/services/worker.js

@@ -1,10 +1,10 @@
 import { scaleLog, scaleLinear } from 'd3-scale';
-import {
-  DenseDataExtrema1D,
-  DenseDataExtrema2D,
-  getAggregationFunction,
-  selectedItemsToSize,
-} from '../utils';
+
+// utils
+import DenseDataExtrema1D from '../utils/DenseDataExtrema1D';
+import DenseDataExtrema2D from '../utils/DenseDataExtrema2D';
+import getAggregationFunction from '../utils/get-aggregation-function';
+import selectedItemsToSize from '../utils/selected-items-to-size';
 
 /**
  * This function helps to fill in pixData by calling setPixData()

package/app/scripts/types.ts

@@ -140,3 +140,32 @@ export interface AbstractDataFetcher<TileType> {
     tileIds: string[],
   ): Promise<Record<string, TileType>>;
 }
+
+// Tileset API
+
+type TilesRequest = {
+  id: string;
+  server?: string;
+  tileIds: string[];
+  options?: unknown;
+};
+
+type TilesetInfoRequest = {
+  server: string;
+  tilesetUid: string;
+};
+
+type RegisterTilesetRequest = {
+  server: string;
+  url: string;
+  filetype: string;
+  coordSystem?: string;
+};
+
+export type TileSource<T> = {
+  fetchTiles: (request: TilesRequest) => Promise<Record<string, T>>;
+  fetchTilesetInfo: (
+    request: TilesetInfoRequest,
+  ) => Promise<Record<string, TilesetInfo>>;
+  registerTileset: (request: RegisterTilesetRequest) => Promise<Response>;
+};

package/app/scripts/utils/DenseDataExtrema1D.js

@@ -1,4 +1,4 @@
-import { NUM_PRECOMP_SUBSETS_PER_1D_TTILE } from '../configs';
+import { NUM_PRECOMP_SUBSETS_PER_1D_TTILE } from '../configs/dense-data-extrema-config';
 
 /**
  * @template {ArrayLike<number>} [T=ArrayLike<number>]

package/app/scripts/utils/DenseDataExtrema2D.js

@@ -1,5 +1,6 @@
 import ndarray from 'ndarray';
-import { NUM_PRECOMP_SUBSETS_PER_2D_TTILE } from '../configs';
+
+import { NUM_PRECOMP_SUBSETS_PER_2D_TTILE } from '../configs/dense-data-extrema-config';
 
 /**
  * @typedef View2D

package/app/scripts/utils/color-to-hex.js

@@ -1,7 +1,7 @@
 import { color } from 'd3-color';
 
 // Configs
-import { GLOBALS } from '../configs';
+import GLOBALS from '../configs/globals';
 
 /**
  * Convert a regular color value (e.g. 'red', '#FF0000', 'rgb(255,0,0)') to a

package/app/scripts/utils/fake-pub-sub.js

@@ -0,0 +1,12 @@
+const fakePubSub = {
+  __fake__: true,
+  publish: () => {},
+  subscribe: () => ({
+    event: '',
+    handler: () => {},
+  }),
+  unsubscribe: () => {},
+  clear: () => {},
+};
+
+export default fakePubSub;

package/app/scripts/utils/show-mouse-position.js

@@ -3,7 +3,7 @@ import { globalPubSub } from 'pub-sub-es';
 import hexStrToInt from './hex-string-to-int';
 
 // Configs
-import { GLOBALS } from '../configs';
+import GLOBALS from '../configs/globals';
 
 const COLOR = 0xaaaaaa;
 const ALPHA = 1.0;