higlass 1.13.6 → 2.0.1

package/dist/app/scripts/api.d.ts

@@ -0,0 +1,640 @@
+export default createApi;
+export type HiGlassApi = ReturnType<typeof createApi>;
+/** @typedef {ReturnType<typeof createApi>} HiGlassApi */
+declare function createApi(context: any, pubSub: any): {
+    destroy: () => void;
+    publish: any;
+    stack: any;
+    public: {
+        /**
+         * HiGlass version
+         * @return {string} Version number
+         */
+        readonly version: string;
+        /**
+         * Enable or disable broadcasting the mouse position globally
+         * @param {boolean} isBroadcastMousePositionGlobally - If `true` the mouse
+         *   position will be broadcasted globally.
+         */
+        setBroadcastMousePositionGlobally(isBroadcastMousePositionGlobally?: boolean): void;
+        /**
+         * Enable or disable showing the global mouse position
+         * @param {boolean} isShowGlobalMousePosition - If `true` the global mouse
+         *   position will be shown for any track that has
+         *   `options.showMousePosition = true`.
+         */
+        setShowGlobalMousePosition(isShowGlobalMousePosition?: boolean): void;
+        /**
+         * Convenience function to enable / disable the global mouse position
+         * @description This function is equivalent to calling
+         *   `setBroadcastMousePositionGlobally()` and
+         *   `setShowGlobalMousePosition()`.
+         * @param {boolean} isGlobalMousePosition - If `true` the global mouse
+         *   position will be shown and broadcasted.
+         */
+        setGlobalMousePosition(isGlobalMousePosition?: boolean): void;
+        /**
+         * Set an auth header to be included with all tile requests.
+         *
+         * @param {string} newHeader The contensts of the header to be included.
+         * Example: ``hgapi.setAuthHeader('JWT xyz')``
+         */
+        setAuthHeader(newHeader: string): void;
+        /**
+         * Get the currently set auth header
+         */
+        getAuthHeader(): string | null;
+        /**
+         * Get a reference to the React HiGlassComponent
+         *
+         * @returns {HiGlassComponent}
+         */
+        getComponent(): HiGlassComponent;
+        /**
+         * Reload all or specific tiles for viewId/trackId
+         *
+         * @param {array} target Should be an array of type
+         *                       ({ viewId: string, trackId: string } | string).
+         *                       If the array is just strings, it's interpreted
+         *                       as a list of views whose tracks to reload.
+         */
+        reload(target: array): void;
+        /**
+         * Destroy HiGlass instance
+         */
+        destroy(): void;
+        /**
+         * Force integer range selections.
+         *
+         * @example
+         *
+         * hgv.activateTool('select'); // Activate select tool
+         * hgv.setRangeSelectionToFloat(); // Allow float range selections
+         */
+        setRangeSelectionToInt(): void;
+        /**
+         * Force float range selections.
+         *
+         * @example
+         *
+         * hgv.activateTool('select'); // Activate select tool
+         * hgv.setRangeSelectionToFloat(); // Allow float range selections
+         */
+        setRangeSelectionToFloat(): void;
+        /**
+         *
+         *  The following enpoint restricts the size of range selection equally for 1D or
+         *  2D tracks to a certain length (specified in absolute coordinates).
+         *
+         * @param {Number} [minSize = 0]  Minimum range selection.
+         *   ``undefined`` unsets the value.
+         * @param {Number} [maxSize = Infinity] Maximum range selection.
+         *   ``undefined`` unsets the value.
+         * @example
+         *
+         * hgv.activateTool('select'); // Activate select tool
+         * hgv.setRangeSelection1dSize(5000, 10000); // Force selections to be between 5 and 10 Kb
+         */
+        setRangeSelection1dSize(minSize?: number, maxSize?: number): void;
+        /**
+         * Set a new view config to define the layout and data
+         * of this component
+         *
+         * @param {obj} newViewConfig A JSON object that defines
+         *    the state of the HiGlassComponent
+         * @param {boolean} resolveImmediately If true, the returned promise resolves immediately
+         *    even if not all data has loaded. This should be set to true, if the new viewconf does not request new data. Default: false.
+         * @example
+         *
+         * const p = hgv.setViewConfig(newViewConfig);
+         * p.then(() => {
+         *   // the initial set of tiles has been loaded
+         * });
+         *
+         * @return {Promise} dataLoaded A promise that resolves when
+         *   all of the data for this viewconfig is loaded. If `resolveImmediately` is set to true,
+         * the promise resolves without waiting for the data to be loaded.
+         */
+        setViewConfig(newViewConfig: obj, resolveImmediately?: boolean): Promise<any>;
+        /**
+         * Retrieve the visible viewconf.
+         *
+         * @returns (Object) A JSON object describing the visible views
+         */
+        getViewConfig(): any;
+        /**
+         * Validate a viewconf.
+         *
+         * @returns (Boolean) A JSON object describing the visible views
+         */
+        validateViewConfig(viewConfig: any, { verbose }?: {
+            verbose?: boolean | undefined;
+        }): boolean | PromiseLike<any>;
+        /**
+         * Get the minimum and maximum visible values for a given track.
+         *
+         * @param {string} viewId The id of the view containing the track.
+         * @param {string} trackId The id of the track to query.
+         * @param {bool} [ignoreOffScreenValues=false] If ``true`` only truly visible values
+         *  are considered. Otherwise the values of visible tiles are used. Not that
+         *  considering only the truly visible
+         *  values results in a roughly 10x slowdown (from 0.1 to 1 millisecond).
+         * @param {bool} [ignoreFixedScale=false]  If ``true`` potentially fixed scaled values are
+         *  ignored. I.e., if the
+         *  absolute range is ``[1, 18]`` but you have fixed the output range to
+         *  ``[4, 5]`` you would normally retrieve ``[4, 5]``. Having this option set to
+         *  ``true`` retrieves the absolute ``[1, 18]`` range.
+         * @example
+         * const [minVal, maxVal] = hgv.getMinMaxValue('myView', 'myTrack');
+         * @returns {Array} The minimum and maximum value
+         */
+        getMinMaxValue(viewId: string, trackId: string, ignoreOffScreenValues?: bool, ignoreFixedScale?: bool): any[];
+        /**
+         * Generate a sharable link to the current view config. The `url` parameter should contain
+         * the API endpoint used to export the view link (e.g. 'http://localhost:8989/api/v1/viewconfs').
+         * If it is not provided, the value is taken from the `exportViewUrl` value of the viewconf.
+         *
+         * @param {string}  url  Custom URL that should point to a higlass server's
+         *   view config endpoint, i.e.,
+         *   `http://my-higlass-server.com/api/v1/viewconfs/`.
+         * @returns {Object}  Promise resolving to the link ID and URL.
+         * @example
+         * hgv.shareViewConfigAsLink('http://localhost:8989/api/v1/viewconfs')
+         * .then((sharedViewConfig) => {
+         *   const { id, url } = sharedViewConfig;
+         *   console.log(`Shared view config (ID: ${id}) is available at ${url}`)
+         * })
+         * .catch((err) => { console.error('Something did not work. Sorry', err); })
+         */
+        shareViewConfigAsLink(url: string): Object;
+        /**
+         * Show overlays where this track can be positioned. This
+         * function will take a track definition and display red,
+         * blue or green overlays highlighting where the track can
+         * be placed on the view. Blue indicates that a track can
+         * be placed in that region, red that it can't and green that
+         * the mouse is currently over the given region.
+         *
+         * @param {obj} track { server, tilesetUid, datatype }
+         *
+         * @example
+         *
+         *  let lineTrack = {
+         *   "server": "http://higlass.io/api/v1",
+         *   "tilesetUid": "WtBJUYawQzS9M2WVIIHnlA",
+         *   "datatype": "multivec",
+         *   "defaultTracks": ['horizontal-stacked-bar']
+         * }
+         *
+         * window.hgApi.showAvailableTrackPositions(lineTrack);
+         */
+        showAvailableTrackPositions(track: obj): void;
+        /**
+         * Hide the overlay showing where a track can be positioned
+         */
+        hideAvailableTrackPositions(): void;
+        measureSize(): void;
+        /**
+         * Show the track chooser which highlights tracks
+         * when the mouse is over them.
+         *
+         * @param  {Function} callback (toViewUid, toTrackUid) =>: A function
+         *                             to be called when a track is chosen.
+         * @return {[type]}            [description]
+         */
+        showTrackChooser(callback: Function): [type];
+        /**
+         * Hide the track chooser.
+         */
+        hideTrackChooser(): void;
+        /**
+         *
+         * When comparing different 1D tracks it can be desirable to fix their y or value
+         * scale
+         *
+         * @param {string} [viewId=''] The view identifier. If you only have one view this
+         * parameter can be omitted.
+         *
+         * @param {string} [trackId=null] The track identifier.
+         * @param [Number] [minValue=null] Minimum value used for scaling the track.
+         * @param [Number] [maxValue=null] Maximum value used for scaling the track.
+         *
+         * @example
+         *
+         * hgv.setTrackValueScale(myView, myTrack, 0, 100); // Sets the scaling to [0, 100]
+         * hgv.setTrackValueScale(myView, myTrack); // Unsets the fixed scaling, i.e., enables
+         * dynamic scaling again.
+         */
+        setTrackValueScaleLimits(viewId?: string, trackId?: string, minValue: any, maxValue: any): void;
+        /**
+         * Choose a theme.
+         * @deprecated since version 1.6.6. Use `setTheme()` instead.
+         */
+        setDarkTheme(darkTheme: any): void;
+        /**
+         * Choose a theme.
+         */
+        setTheme(theme: any): void;
+        /**
+         * Change the current view port to a certain data location.
+         * When ``animateTime`` is greater than 0, animate the transition.
+  
+         * If working with genomic data, a chromosome info file will need to be used in
+         * order to calculate "data" coordinates from chromosome coordinates. "Data"
+         * coordinates are simply the coordinates as if the chromosomes were placed next
+         * to each other.
+         *
+         * @param {string} viewUid The identifier of the view to zoom
+         * @param {Number} start1Abs The x start position
+         * @param {Number} end1Abs The x end position
+         * @param {Number} start2Abs (optional) The y start position. If not specified
+         *    start1Abs will be used.
+         * @param {Number} end2Abs (optional) The y end position. If not specified
+         *    end1Abs will be used
+         * @param {Number} animateTime The time to spend zooming to the specified location
+         * @example
+         *    // Absolute coordinates
+         * hgApi.zoomTo('view1', 1000000, 1100000, 2000000, 2100000, 500);
+         * // Chromosomal coordinates
+         * hglib
+         *   // Pass in the URL of your chrom sizes
+         *   .ChromosomeInfo('//s3.amazonaws.com/pkerp/data/hg19/chromSizes.tsv')
+         *   // Now we can use the chromInfo object to convert
+         *   .then((chromInfo) => {
+         *     // Go to PTEN
+         *     hgApi.zoomTo(
+         *       viewConfig.views[0].uid,
+         *       chromInfo.chrToAbs(['chr10', 89596071]),
+         *       chromInfo.chrToAbs(['chr10', 89758810]),
+         *       chromInfo.chrToAbs(['chr10', 89596071]),
+         *       chromInfo.chrToAbs(['chr10', 89758810]),
+         *       2500  // Animation time
+         *     );
+         *   });
+         *   // Just in case, let us catch errors
+         *   .catch(error => console.error('Oh boy...', error))
+         * // Using getLocation() for coordinates
+         * let firstViewLoc = hgApi.getLocation(oldViewUid);
+         * hgApi.zoomTo(
+         *  viewUid,
+         *  firstViewLoc["xDomain"][0],
+         *  firstViewLoc["xDomain"][1],
+         *  firstViewLoc["yDomain"][0],
+         *  firstViewLoc["yDomain"][1]
+         * );
+         */
+        zoomTo(viewUid: string, start1Abs: number, end1Abs: number, start2Abs: number, end2Abs: number, animateTime?: number): void;
+        /**
+         * Change the current view port to a location near the gene of interest.
+         * When ``animateTime`` is greater than 0, animate the transition.
+         *
+         * @param {string} viewUid The identifier of the view to zoom
+         * @param {string} geneName The name of gene symbol to search
+         * @param {string} padding The padding (base pairs) around a given gene for the navigation
+         * @param {Number} animateTime The time to spend zooming to the specified location
+         * @example
+         * // Zoom to the location near 'MYC'
+         * hgApi.zoomToGene('view1', 'MYC', 100, 2000);
+         */
+        zoomToGene(viewUid: string, geneName: string, padding?: string, animateTime?: number): void;
+        /**
+         * Get the list of genes of top match for a given keyword.
+         *
+         * @param {string} viewUid The id of the view containing the track.
+         * @param {string} keyword The substring of gene name to search.
+         * @param {function} callback A function to be called upon gene list search.
+         * @example
+         * hgv.suggestGene('view1', 'MY', (suggestions) => {
+         *    if(suggestions && suggestions.length > 0) {
+         *      console.log('Gene suggested', suggestions[0].geneName);
+         *      console.log('Chromosome', suggestions[0].chr);
+         *      console.log('Start position', suggestions[0].txStart);
+         *      console.log('End position', suggestions[0].txEnd);
+         *    }
+         * });
+         */
+        suggestGene(viewUid: string, keyword: string, callback: Function): void;
+        /**
+         * Zoom so that the entirety of all the datasets in a view
+         * are visible.
+         * The passed in ``viewUid`` should refer to a view which is present. If it
+         * doesn't, an exception will be thrown. Note that if this function is invoked
+         * directly after a HiGlass component is created, the information about the
+         * visible tilesets will not have been retrieved from the server and
+         * ``zoomToDataExtent`` will not work as expected. To ensure that the
+         * visible data has been loaded from the server, use the ``setViewConfig``
+         * function and place ``zoomToDataExtent`` in the promise resolution.
+         *
+         * @param {string} viewUid The view uid of the view to zoom
+         * @example
+         *
+         * const p = hgv.setViewConfig(newViewConfig);
+         * p.then(() => {
+         *     hgv.zoomToDataExtent('viewUid');
+         * });
+         */
+        zoomToDataExtent(viewUid: string): void;
+        /**
+         * The endpoint allows you to reset the viewport to the initially defined X and Y
+         * domains of your view config.
+         *
+         * @param {string} viewId The view identifier. If you have only one view you can
+         * omit this parameter.
+         *
+         * @example
+         *
+         * hgv.resetViewport(); // Resets the first view
+         */
+        resetViewport(viewId: string): void;
+        /**
+         * Some tools needs conflicting mouse events such as mousedown or mousemove. To
+         * avoid complicated triggers for certain actions HiGlass supports different mouse
+         * tools for different interactions. The default mouse tool enables pan&zoom. The
+         * only other mouse tool available right now is ``select``, which lets you brush
+         * on to a track to select a range for annotating regions.
+         *
+         * @param {string} [mouseTool='']  Select a mouse tool to use. Currently there
+         * only 'default' and 'select' are available.
+         *
+         * @example
+         *
+         * hgv.activateTool('select'); // Select tool is active
+         * hgv.activateTool(); // Default pan&zoom tool is active
+         */
+        activateTool(tool: any): void;
+        /**
+         * Set the size mode for the higlass container
+         *
+         * @param {string sizeMode The size mode for the container.
+         *                         The vailable options are 'default',
+         *                         'bounded', 'overflow' and 'scroll'
+         */
+        setSizeMode(sizeMode: string): void;
+        /**
+         * Get a Promise which returns a Blob containing a PNG for the current view.
+         * It's possible to get string of the PNG bytes from that:
+         *
+         * @example
+         * hgApi.exportAsPngBlobPromise().then(function(blob) {
+         *   var reader = new FileReader();
+         *   reader.addEventListener("loadend", function() {
+         *     var array = new Uint8Array(reader.result.slice(0,8));
+         *     console.log(array);
+         *     console.log(new TextDecoder("iso-8859-2").decode(array));
+         *   });
+         *   reader.readAsArrayBuffer(blob);
+         * });
+         *
+         * @returns {promise}
+         */
+        exportAsPngBlobPromise(): promise;
+        /**
+         * Get the current view as an SVG. Relies on all the tracks implementing
+         * their respective exportAsSVG methods.
+         *
+         * @returns {string} An SVG string of the current view.
+         */
+        exportAsSvg(): string;
+        /**
+         * Export the current view as a Viewconf.
+         *
+         * @returns {string} A stringified version of the current viewconf
+         */
+        exportAsViewConfString(): string;
+        /**
+         * Get the current range selection
+         *
+         * @return {Array} The current range selection
+         */
+        getRangeSelection(): any[];
+        /**
+         * Get the current location for a view.
+         *
+         * @param {string} [viewId=null] The id of the view to get the location for
+         * @returns {obj} A an object containing four arrays representing the domains and ranges of
+         *  the x and y scales of the view.
+         * @example
+         *
+         * const {xDomain, yDomain, xRange, yRange} = hgv.getLocation('viewId');
+         */
+        getLocation(viewId?: string): obj;
+        /**
+         * Return the track's javascript object. This is useful for subscribing to
+         * data events (dataChanged)
+         *
+         * @param {string} viewId The id of the view containing the track
+         * @param {string} trackId The id of the track within the view
+         * @return {obj} The HiGlass track object for this track
+         */
+        getTrackObject(viewId: string, trackId: string): obj;
+        /**
+         * Set or get an option.
+         * @param   {string}  key  The name of the option you want get or set
+         * @param   {*}  value  If not `undefined`, `key` will be set to `value`
+         * @return  {obj}  When `value` is `undefined` the current value of
+         *   `key` will be returned.
+         */
+        option(key: string, value: any): obj;
+        /**
+         * Cancel a subscription.
+         *
+         * @param {string} event One of the available events
+         * @param {function} listener The function to unsubscribe
+         * @param {string} viewId The viewId to unsubscribe it from (not strictly necessary)
+         * The variables used in the following examples are coming from the examples of ``on()``.
+         *
+         * @example
+         *
+         * hgv.off('location', listener, 'viewId1');
+         * hgv.off('rangeSelection', rangeListener);
+         * hgv.off('viewConfig', viewConfigListener);
+         * hgv.off('mouseMoveZoom', mmz);
+         * hgv.off('wheel', wheelListener);
+         * hgv.off('createSVG');
+         * hgv.off('click');
+         * hgv.off('geneSearch', geneSearchListener);
+         */
+        off(event: string, listenerId: any, viewId: string): void;
+        /**
+         * Subscribe to events
+         *
+         *
+         * HiGlass exposes the following event, which one can subscribe to via this method:
+         *
+         * - location
+         * - rangeSelection
+         * - viewConfig
+         * - mouseMoveZoom
+         *
+         * **Event types**
+         *
+         * ``click``: Returns clicked objects. (Currently only clicks on 1D annotations are captured.)
+         *
+         * .. code-block:: javascript
+         *
+         *     [
+         *      {
+         *       event: {
+         *          type: 'annotation',
+         *          event: { ... },
+         *          payload: [230000000, 561000000]
+         *        },
+         *       trackType: '1d-annotation',
+         *       trackUid: 'xyz',
+         *       viewUid: 'abc'
+         *      }
+         *     ]
+         *
+         * ``cursorLocation:`` Returns an object describing the location under the cursor
+         *
+         * .. code-block:: javascript
+         *
+         *    {
+         *        absX: 100,
+         *        absY: 200,
+         *        relX: 50,
+         *        relY: 150,
+         *        relTrackX: 50,
+         *        relTrackY: 100,
+         *        dataX: 10000,
+         *        dataY: 123456,
+         *        isFrom2dTrack: false,
+         *        isFromVerticalTrack: false,
+         *    }
+         *
+         * ``location:`` Returns an object describing the visible region
+         *
+         * .. code-block:: javascript
+         *
+         *    {
+         *        xDomain: [1347750580.3773856, 1948723324.787681],
+         *        xRange: [0, 346],
+         *        yDomain: [1856870481.5391564, 2407472678.0075483],
+         *        yRange: [0, 317]
+         *    }
+         *
+         * ``rangeSelection:`` Returns a BED- (1D) or BEDPE (1d) array of the selected data and
+         * genomic range (if chrom-sizes are available)
+         *
+         * .. code-block:: javascript
+         *
+         *  // Global output
+         *  {
+         *    dataRange: [...]
+         *    genomicRange: [...]
+         *  }
+         *
+         *  // 1D data range
+         *  [[1218210862, 1528541001], null]
+         *
+         *  // 2D data range
+         *  [[1218210862, 1528541001], [1218210862, 1528541001]]
+         *
+         *  // 1D or BED-like array
+         *  [["chr1", 249200621, "chrM", 50000], null]
+         *
+         *  // 2D or BEDPE-like array
+         *  [["chr1", 249200621, "chr2", 50000], ["chr3", 197972430, "chr4", 50000]]
+         *
+         * ``viewConfig:`` Returns the current view config (as a string).
+         *  This event is published upon interactions including:
+         *  - Saving in the view config editor modal.
+         *  - Panning and zooming in views, which update view object ``initialXDomain`` and ``initialYDomain`` values.
+         *  - Brushing in ``viewport-projection-`` tracks containing null ``fromViewUid`` fields, which update track object ``projectionXDomain`` and ``projectionYDomain`` values.
+         *
+         * ``mouseMoveZoom:`` Returns the location and data at the mouse cursor's
+         * screen location.
+         *
+         * .. code-block:: javascript
+         *
+         *  {
+         *    // Float value of the hovering track
+         *    data,
+         *    // Absolute x screen position of the cursor in px
+         *    absX,
+         *    // Absolute y screen position of the cursor in px
+         *    absY,
+         *    // X screen position of the cursor in px relative to the track extent.
+         *    relX,
+         *    // Y screen position of the cursor in px relative to the track extent.
+         *    relY,
+         *    // Data x position of the cursor relative to the track's data.
+         *    dataX,
+         *    // Data y position of the cursor relative to the track's data.
+         *    dataY,
+         *    // Track orientation, i.e., '1d-horizontal', '1d-vertical', or '2d'
+         *    orientation: '1d-horizontal',
+         *
+         *    // The following properties are only returned when hovering 2D tracks:
+         *    // Raw Float32Array
+         *    dataLens,
+         *    // Dimension of the lens, e.g., 3 (the lens is squared so `3` corresponds
+         *    // to a 3x3 matrix represented by an array of length 9)
+         *    dim,
+         *    // Function for converting the raw data values to rgb values
+         *    toRgb,
+         *    // Center position of the data or genomic position (as a BED array)
+         *    center,
+         *    // Range of the x data or genomic position (as a BEDPE array)
+         *    xRange,
+         *    // Range of the y data or genomic position (as a BEDPE array)
+         *    yRange,
+         *    // If `true` `center`, `xRange`, and `yRange` are given in genomic positions
+         *    isGenomicCoords
+         *  }
+         *
+         * ``createSVG:`` Set a callback to obtain the current exported SVG DOM node,
+         *                and potentially return a manipulated SVG DOM node.
+         *
+         * @param {string} event One of the events described below
+         *
+         * @param {function} callback A callback to be called when the event occurs
+         *
+         * @param {string} viewId The view ID to listen to events
+         *
+         * @example
+         *
+         * let locationListenerId;
+         * hgv.on(
+         *   'location',
+         *   location => console.log('Here we are:', location),
+         *   'viewId1',
+         *   listenerId => locationListenerId = listenerId
+         * );
+         *
+         * const rangeListenerId = hgv.on(
+         *   'rangeSelection',
+         *   range => console.log('Selected', range)
+         * );
+         *
+         * const viewConfigListenerId = hgv.on(
+         *   'viewConfig',
+         *   range => console.log('Selected', range)
+         * );
+         *
+         * const mmz = event => console.log('Moved', event);
+         * hgv.on('mouseMoveZoom', mmz);
+         *
+         * const wheelListener = event => console.log('Wheel', event);
+         * hgv.on('wheel', wheelListener);
+         *
+         * hgv.on('createSVG', (svg) => {
+         *    const circle = document.createElement('circle');
+         *    circle.setAttribute('cx', 100);
+         *    circle.setAttribute('cy', 100);
+         *    circle.setAttribute('r', 50);
+         *    circle.setAttribute('fill', 'green');
+         *    svg.appendChild(circle);
+         *    return svg;
+         * });
+         *
+         * const geneSearchListener = event => {
+         *    console.log('Gene searched', event.geneSymbol);
+         *    console.log('Range of the gene', event.range);
+         *    console.log('Center of the gene', event.centerX);
+         * }
+         * hgv.on('geneSearch', geneSearchListener);
+         */
+        on(event: string, callback: Function, viewId: string, callbackId: any): any;
+    };
+};

package/dist/app/scripts/configs/available-track-types.d.ts

@@ -0,0 +1,2 @@
+export function AVAILABLE_TRACK_TYPES(datatypes: any, orientation: any): any[];
+export default AVAILABLE_TRACK_TYPES;

package/dist/app/scripts/configs/colormaps.d.ts

@@ -0,0 +1,2 @@
+export const HEATED_OBJECT_MAP: number[][];
+export default HEATED_OBJECT_MAP;

package/dist/app/scripts/configs/datatype-to-track-type.d.ts

@@ -0,0 +1,4 @@
+export function DATATYPE_TO_TRACK_TYPE(orientation: any): {
+    none: any[];
+};
+export default DATATYPE_TO_TRACK_TYPE;

package/dist/app/scripts/configs/default-tracks-for-datatype.d.ts

@@ -0,0 +1,38 @@
+export const DEFAULT_TRACKS_FOR_DATATYPE: {
+    readonly chromsizes: {
+        readonly center: "2d-chromosome-grid";
+        readonly top: "chromosome-labels";
+        readonly left: "chromosome-labels";
+        readonly bottom: "chromosome-labels";
+        readonly right: "chromosome-labels";
+    };
+    readonly matrix: {
+        readonly center: "heatmap";
+        readonly top: "linear-heatmap";
+        readonly left: "linear-heatmap";
+        readonly right: "linear-heatmap";
+        readonly bottom: "linear-heatmap";
+    };
+    readonly vector: {
+        readonly top: "bar";
+        readonly bottom: "bar";
+        readonly left: "bar";
+        readonly right: "bar";
+    };
+    readonly 'geo-json': {
+        readonly center: "geo-json";
+    };
+    readonly 'gene-annotation': {
+        readonly top: "gene-annotations";
+        readonly bottom: "gene-annotations";
+        readonly left: "gene-annotations";
+        readonly right: "gene-annotations";
+    };
+    readonly bedlike: {
+        readonly top: "bedlike";
+        readonly bottom: "bedlike";
+        readonly left: "vertical-bedlike";
+        readonly right: "vertical-bedlike";
+    };
+};
+export default DEFAULT_TRACKS_FOR_DATATYPE;