higlass 1.13.5 → 2.0.0

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

@@ -0,0 +1,369 @@
+/** @import * as t from './types' */
+/**
+ * Get a valueScale for a heatmap.
+ *
+ * If the scalingType isn't specified, then default to the defaultScaling.
+ *
+ * @param {string} scalingType: The type of the (e.g. 'linear', or 'log')
+ * @param {number} minValue: The minimum data value to which this scale will apply
+ * @param {number} pseudocountIn: A value to add to all numbers to prevent taking the log of 0
+ * @param {number} maxValue: The maximum data value to which this scale will apply
+ * @param {string} defaultScaling: The default scaling type to use in case
+ * 'scalingType' is null (e.g. 'linear' or 'log')
+ *
+ * @returns {[string, import('d3-scale').ScaleLogarithmic<number, number> | import('d3-scale').ScaleLinear<number, number>]}
+ * An array of [string, scale] containing the scale type and a scale with an appropriately set domain and range
+ */
+export function getValueScale(scalingType: string, minValue: number, pseudocountIn: number, maxValue: number, defaultScaling: string): [string, import("d3-scale").ScaleLogarithmic<number, number> | import("d3-scale").ScaleLinear<number, number>];
+export default TiledPixiTrack;
+export type Scale = {
+    minValue?: number | null | undefined;
+    maxValue?: number | null | undefined;
+    maxRawValue?: number | null | undefined;
+    minRawValue?: number | null | undefined;
+};
+/**
+ * An alternative to Tile. Perhaps the worst data type. An array of numbers with some extra properties.
+ */
+export type TilePositionArrayObject = Array<number> & Pick<Tile, "mirrored" | "tilePositionId">;
+export type Tile = {
+    tileId: string;
+    tileData: TileData;
+    remoteId: string;
+    mirrored: unknown;
+    tilePositionId: string;
+    graphics: import("pixi.js").Graphics;
+};
+export type TileData = {
+    tilesetUid: string;
+    zoomLevel: number;
+    tilePos: Array<number>;
+    error: string;
+    dense: Float32Array;
+    minNonZero: number;
+    maxNonZero: number;
+    /**
+     * - Optional 1D or 2D array dimensions
+     */
+    shape?: number[] | undefined;
+};
+export type TiledPixiTrackContextBase = {
+    dataFetcher: DataFetcher;
+    dataConfig: t.DataConfig;
+    /**
+     * A function to redraw this track. Typically called when an
+     * asynchronous event occurs (i.e. tiles loaded)
+     */
+    animate: Function;
+    /**
+     * The range of values has changed so we need to inform
+     * the higher ups that the value scale has changed. Only occurs on tracks with ``dense`` data.
+     */
+    onValueScaleChanged: () => void;
+    /**
+     * A callback to do something once once the tileset
+     * info is received. Usually it registers some information about the tileset with its definition
+     */
+    handleTilesetInfoReceived?: ((t: t.TilesetInfo) => void) | undefined;
+};
+export type TiledPixiTrackContext = import("./PixiTrack").ExtendedPixiContext<TiledPixiTrackContextBase>;
+export type TiledPixiTrackOptions = {
+    /**
+     * - If the label is to be drawn, where should it be drawn?
+     */
+    labelPosition: string;
+    /**
+     * - What should be drawn in the label.
+     */
+    labelText: string;
+    maxZoom: number;
+    name: string;
+};
+export type ExtendedTiledPixiTrackOptions<T> = T & TiledPixiTrackOptions;
+/**
+ * @typedef Scale
+ * @property {number | null} [minValue]
+ * @property {number | null} [maxValue]
+ * @property {number | null} [maxRawValue]
+ * @property {number | null} [minRawValue]
+ */
+/**
+ * An alternative to Tile. Perhaps the worst data type. An array of numbers with some extra properties.
+ * @typedef {Array<number> & Pick<Tile, 'mirrored' | 'tilePositionId'>} TilePositionArrayObject
+ */
+/**
+ * @typedef Tile
+ * @property {string} tileId
+ * @property {TileData} tileData
+ * @property {string} remoteId
+ * @property {unknown} mirrored
+ * @property {string} tilePositionId
+ * @property {import("pixi.js").Graphics} graphics
+ */
+/**
+ * @typedef TileData
+ * @property {string} tilesetUid
+ * @property {number} zoomLevel
+ * @property {Array<number>} tilePos
+ * @property {string} error
+ * @property {Float32Array} dense
+ * @property {number} minNonZero
+ * @property {number} maxNonZero
+ * @property {Array<number>} [shape] - Optional 1D or 2D array dimensions
+ */
+/**
+ * @typedef TiledPixiTrackContextBase
+ * @property {DataFetcher} dataFetcher
+ * @property {t.DataConfig} dataConfig
+ * @property {function} animate A function to redraw this track. Typically called when an
+ *  asynchronous event occurs (i.e. tiles loaded)
+ * @property {() => void} onValueScaleChanged The range of values has changed so we need to inform
+ *  the higher ups that the value scale has changed. Only occurs on tracks with ``dense`` data.
+ * @property {(t: t.TilesetInfo) => void} [handleTilesetInfoReceived] A callback to do something once once the tileset
+ *  info is received. Usually it registers some information about the tileset with its definition
+ */
+/**
+ * @typedef {import('./PixiTrack').ExtendedPixiContext<TiledPixiTrackContextBase>} TiledPixiTrackContext
+ */
+/**
+ * @typedef TiledPixiTrackOptions
+ * @property {string} labelPosition - If the label is to be drawn, where should it be drawn?
+ * @property {string} labelText - What should be drawn in the label.
+ * @property {number} maxZoom
+ * @property {string} name
+ */
+/**
+ * @template T
+ * @typedef {T & TiledPixiTrackOptions} ExtendedTiledPixiTrackOptions
+ */
+/**
+ * The TiledPixiTrack requires an options parameter, which should be an object containing properties specified in
+ * TiledPixiTrackOptions. It is capable of accepting any property defined in any of its superclasses.
+ * @template {ExtendedTiledPixiTrackOptions<{[key: string]: any}>} Options
+ * @extends {PixiTrack<Options>}
+ * */
+declare class TiledPixiTrack<Options extends ExtendedTiledPixiTrackOptions<{
+    [key: string]: any;
+}>> extends PixiTrack<Options> {
+    /**
+     *
+     * @param {TiledPixiTrackContext} context
+     * @param {Options} options
+     */
+    constructor(context: TiledPixiTrackContext, options: Options);
+    /** @type {number} */
+    renderVersion: number;
+    /** @type {Array<Pick<Tile, 'tileId' |'remoteId' | 'mirrored'>>} */
+    visibleTiles: Array<Pick<Tile, "tileId" | "remoteId" | "mirrored">>;
+    /** @type {Set<string>} */
+    visibleTileIds: Set<string>;
+    renderingTiles: Set<any>;
+    fetching: Set<any>;
+    /** @type {Scale} */
+    scale: Scale;
+    /** @type {{[id: string]: Tile}} */
+    fetchedTiles: {
+        [id: string]: Tile;
+    };
+    /** @type {Object.<string, import('pixi.js').DisplayObject>} */
+    tileGraphics: {
+        [x: string]: import("pixi.js").DisplayObject;
+    };
+    /** @type {number} */
+    maxZoom: number;
+    medianVisibleValue: number | null | undefined;
+    backgroundTaskScheduler: {
+        taskList: import("./utils/background-task-scheduler").Task[];
+        taskHandle: number | null;
+        requestIdleCallbackTimeout: number;
+        /**
+         * @template T
+         * @overload
+         * @param {(data: T) => void} taskHandler
+         * @param {T} taskData
+         * @param {string | null=} trackId
+         * @return {void}
+         */
+        enqueueTask<T>(taskHandler: (data: T) => void, taskData: T, trackId?: (string | null) | undefined): void;
+        /**
+         * If `taskData` is `null` the `taskHandler` will eventaully be called without any arguments.
+         *
+         * @overload
+         * @param {() => void} taskHandler
+         * @param {null} taskData
+         * @param {string | null=} trackId
+         * @return {void}
+         */
+        enqueueTask(taskHandler: () => void, taskData: null, trackId?: (string | null) | undefined): void;
+        runTaskQueue(deadline: {
+            timeRemaining(): number;
+            didTimeout: boolean;
+        }): void;
+    };
+    continuousScaling: boolean;
+    valueScaleMin: number | null;
+    fixedValueScaleMin: number | null;
+    valueScaleMax: number | null;
+    fixedValueScaleMax: number | null;
+    /** @type {Record<string, Array<Function>>} */
+    listeners: Record<string, Array<Function>>;
+    animate: Function;
+    onValueScaleChanged: () => void;
+    prevValueScale: any;
+    dataFetcher: DataFetcher;
+    /** @type {null | string} */
+    tilesetInfoError: null | string;
+    uuid: string;
+    trackNotFoundText: import("pixi.js").Text;
+    refreshTilesDebounced: (request: unknown) => void;
+    chromInfo: import("./utils/parse-chromsizes-rows.js").ParsedChromsizes;
+    tilesetUid: string | undefined;
+    server: string;
+    /** @param {number | string} value */
+    setFixedValueScaleMin(value: number | string): void;
+    /** @param {number | string} value */
+    setFixedValueScaleMax(value: number | string): void;
+    checkValueScaleLimits(): void;
+    /**
+     * Register an event listener for track events. Currently, the only supported
+     * event is ``dataChanged``.
+     *
+     * @param {string} event The event to listen for
+     * @param {function} callback The callback to call when the event occurs. The
+     *  parameters for the event depend on the event called.
+     *
+     * @example
+     *
+     *  trackObj.on('dataChanged', (newData) => {
+     *   console.log('newData:', newData)
+     *  });
+     */
+    on(event: string, callback: Function): void;
+    /**
+     * @param {string} event The event to listen for
+     * @param {function} callback The callback to call when the event occurs. The
+     *  parameters for the event depend on the event called.
+     */
+    off(event: string, callback: Function): void;
+    /** Called when tileset info is received. The actual tileset info
+     * can be found in this.tilesetInfo.
+     *
+     * Child tracks can implement this method.
+     */
+    tilesetInfoReceived(): void;
+    /**
+     * Return the set of ids of all tiles which are both visible and fetched.
+     */
+    visibleAndFetchedIds(): string[];
+    visibleAndFetchedTiles(): Tile[];
+    /**
+     * Set which tiles are visible right now.
+     *
+     * @param {Array<TilePositionArrayObject>} tilePositions - A set of tiles which will be considered the currently visible tile positions.
+     */
+    setVisibleTiles(tilePositions: Array<TilePositionArrayObject>): void;
+    removeOldTiles(): void;
+    refreshTiles(): void;
+    /** @param {Tile} tile */
+    parentInFetched(tile: Tile): boolean;
+    /** @param {Tile} tile */
+    parentTileId(tile: Tile): string;
+    /**
+     * Remove obsolete tiles
+     *
+     * @param {Array<string>} toRemoveIds: An array of tile ids to remove from the list of fetched tiles.
+     */
+    removeTiles(toRemoveIds: Array<string>): void;
+    /**
+     * @param {t.Scale} newXScale
+     * @param {t.Scale} newYScale
+     */
+    zoomed(newXScale: t.Scale, newYScale: t.Scale, k?: number, tx?: number, ty?: number): void;
+    /**
+     * Check to see if all the visible tiles are loaded.
+     *
+     * If they are, remove all other tiles.
+     */
+    areAllVisibleTilesLoaded(): boolean;
+    /**
+     * Function is called when all tiles that should be visible have
+     * been received.
+     */
+    allTilesLoaded(): void;
+    /** @param {number} [_] - Optional value to set */
+    minValue(_?: number): number | this | null | undefined;
+    /** @param {number} [_] - Optional value to set */
+    maxValue(_?: number): number | this | null | undefined;
+    minRawValue(): number | null | undefined;
+    maxRawValue(): number | null | undefined;
+    /** @param {Tile} tile */
+    initTile(tile: Tile): void;
+    /** @param {Tile} tile */
+    updateTile(tile: Tile): void;
+    /** @param {Tile} tile */
+    destroyTile(tile: Tile): void;
+    addMissingGraphics(): void;
+    /**
+     * Change the graphics for existing tiles
+     */
+    updateExistingGraphics(): void;
+    synchronizeTilesAndGraphics(): void;
+    /**
+     * @typedef TiledAreaTile
+     * @property {string} tileId
+     * @property {string} type
+     * @property {unknown} data
+     */
+    /**
+     *
+     * @param {TiledAreaTile} tile A tile returned by a TiledArea.
+     * @param {function} dataLoader A function for extracting drawable data from a tile. This
+     * usually means differentiating the between dense and sparse tiles and putting the data into an array.
+     * @returns
+     */
+    loadTileData(tile: {
+        tileId: string;
+        type: string;
+        data: unknown;
+    }, dataLoader: Function): any;
+    /** @param {Pick<Tile,'remoteId'>[]} toFetch */
+    fetchNewTiles(toFetch: Pick<Tile, "remoteId">[]): void;
+    /**
+     * We've gotten a bunch of tiles from the server in
+     * response to a request from fetchTiles.
+     * @param {Object<string, import('./data-fetchers/DataFetcher').DividedTile | Tile | TilePositionArrayObject>} loadedTiles
+     */
+    receivedTiles(loadedTiles: {
+        [x: string]: import("./data-fetchers/DataFetcher").DividedTile | Tile | TilePositionArrayObject;
+    }): void;
+    _checkForErrors(): string[];
+    /**
+     * Draw a tile on some graphics
+     * @param {Tile} tile
+     */
+    drawTile(tile: Tile): void;
+    calculateMedianVisibleValue(): number | undefined;
+    allVisibleValues(): number[];
+    minVisibleValue(ignoreFixedScale?: boolean): number | null;
+    minVisibleValueInTiles(ignoreFixedScale?: boolean): number | null;
+    maxVisibleValue(ignoreFixedScale?: boolean): number | null;
+    maxVisibleValueInTiles(ignoreFixedScale?: boolean): number | null;
+    /** @typedef {import('d3-scale').ScaleQuantile<number, never> & { ticks?: (count: number) => number[] }} ScaleQuantile */
+    /**
+     * Create a value scale that will be used to position values
+     * along the y axis.
+     * @param {number} minValue The minimum value of the data
+     * @param {number} medianValue The median value of the data. Potentially used for adding a pseudocount
+     * @param {number} maxValue The maximum value of the data
+     * @param {number} [inMargin] A number of pixels to be left free on the top and bottom
+     *    of the track. For example if the glyphs have a certain
+     *    width and we want all of them to fit into the space
+     * @returns {[t.Scale | ScaleQuantile, number]}
+     */
+    makeValueScale(minValue: number, medianValue: number, maxValue: number, inMargin?: number): [t.Scale | (import("d3-scale").ScaleQuantile<number, never> & {
+        ticks?: (count: number) => number[];
+    }), number];
+}
+import { DataFetcher } from './data-fetchers';
+import type * as t from './types';
+import PixiTrack from './PixiTrack';

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

@@ -0,0 +1,313 @@
+export class TiledPlot extends React.Component<any, any, any> {
+    constructor(props: any);
+    closing: boolean;
+    brushX: import("d3-brush").BrushBehavior<any>;
+    canvasElement: any;
+    tracksByUidInit: {};
+    annotationUid: any;
+    annotationCreatedNotified: boolean;
+    xScale: any;
+    yScale: any;
+    trackToReplace: any;
+    trackRenderer: import("./TrackRenderer").TrackRenderer | null;
+    brushSelection: any[] | any[][] | null;
+    configTrackMenu: any;
+    state: {
+        sizeMeasured: boolean;
+        height: number;
+        width: number;
+        tracks: any;
+        init: boolean;
+        addTrackExtent: null;
+        addTrackPosition: null;
+        customDialog: null;
+        mouseOverOverlayUid: null;
+        forceUpdate: number;
+        rangeSelection: null[];
+        rangeSelectionEnd: boolean;
+        chromInfo: null;
+        defaultChromSizes: null;
+        contextMenuCustomItems: null;
+        contextMenuPosition: null;
+        addDivisorDialog: null;
+    };
+    reset: boolean;
+    topHeight: number;
+    bottomHeight: number;
+    leftWidth: number;
+    rightWidth: number;
+    centerHeight: number;
+    centerWidth: number;
+    dragTimeout: any;
+    previousPropsStr: string;
+    brushesCreated: {};
+    appZoomedBound: () => void;
+    handleClickBound: (evt: any) => void;
+    contextMenuHandlerBound: (e: any) => void;
+    handleNoTrackAddedBound: () => void;
+    handleTracksAddedBound: (newTracks: any, position: any, extent: any, host: any) => any;
+    closeMenusBound: () => void;
+    handleAddDivisorBound: (series: any) => void;
+    handleAddSeriesBound: (trackUid: any) => void;
+    handleChangeTrackDataBound: (uid: any, newData: any) => void;
+    handleChangeTrackTypeBound: (uid: any, newType: any) => void;
+    handleCloseTrackBound: (uid: any) => void;
+    handleConfigureTrackBound: (track: any, configComponent: any) => void;
+    handleExportTrackDataBound: (hostTrackUid: any, trackUid: any) => void;
+    handleLockValueScaleBound: (uid: any) => void;
+    handleReplaceTrackBound: (uid: any, orientation: any) => void;
+    handleTrackOptionsChangedBound: (trackUid: any, newOptions: any) => any;
+    handleUnlockValueScaleBound: (uid: any) => void;
+    onAddTrack: (position: any, extent: any) => void;
+    waitForDOMAttachment(callback: any): void;
+    componentDidMount(): void;
+    mounted: boolean | undefined;
+    element: HTMLDivElement | null | undefined;
+    resizeSensor: ResizeSensor | undefined;
+    pubSubs: any[] | undefined;
+    /** Get the data in the selection */
+    getTracksData(positionedTracks: any, extent: any): {
+        name: any;
+        mean: number;
+        trackUid: any;
+    }[];
+    appZoomed(): void;
+    clearOtherBrushes(myBrush: any): void;
+    handleClick(evt: any): void;
+    cancelBrushes(): void;
+    brushEl: any;
+    removeBrushText(): void;
+    enableBrushes(): void;
+    disableBrushes(): void;
+    createBrushes(positionedTracks: any): {};
+    brushCurrent: any;
+    brushType: string | undefined;
+    brushTrack: any;
+    brushSelectionRaw: any;
+    removeBrushes(): void;
+    addBrushes(): void;
+    brushes: {} | undefined;
+    brushEls: {} | undefined;
+    UNSAFE_componentWillReceiveProps(newProps: any): void;
+    shouldComponentUpdate(nextProps: any, nextState: any): boolean;
+    numTracks: number | undefined;
+    componentDidUpdate(prevProps: any, prevState: any): void;
+    componentWillUnmount(): void;
+    addUidsToTracks(positionedTracks: any): void;
+    contextMenuHandler(e: any): void;
+    measureSize(): void;
+    handleTrackOptionsChanged(trackUid: any, newOptions: any): any;
+    handleScalesChanged(x: any, y: any): void;
+    /**
+     * We've received information about a tileset from the server. Register it
+     * with the track definition.
+     * @param trackUid (string): The identifier for the track
+     * @param tilesetInfo (object): Information about the track (hopefully including
+     *                              its name.
+     */
+    handleTilesetInfoReceived(trackUid: any, tilesetInfo: any): void;
+    /**
+     * Check if all track which are expecting a tileset info have been loaded.
+     */
+    checkAllTilesetInfoReceived(): void;
+    handleOverlayMouseEnter(uid: any): void;
+    handleOverlayMouseLeave(uid: any): void;
+    handleTrackPositionChosen(pTrack: any, evt: any): void;
+    handleNoTrackAdded(): void;
+    handleAddDivisor(series: any): void;
+    /**
+     * The user has selected a track that they wish to use to normalize another
+     * track.
+     */
+    handleDivisorChosen(series: any, newTrack: any): void;
+    handleDivideSeries(seriesUid: any): void;
+    handleAddSeries(trackUid: any): void;
+    handleReplaceTrack(uid: any, orientation: any): void;
+    handleAddTrack(position: any, extent: any): void;
+    handleResizeTrack(uid: any, width: any, height: any): void;
+    closeMenus(): void;
+    handleLockValueScale(uid: any): void;
+    handleUnlockValueScale(uid: any): void;
+    handleCloseTrack(uid: any): void;
+    handleChangeTrackType(uid: any, newType: any): void;
+    /**
+     * Change this tracks data section so that it
+     * is either of type "divided" or the "divided"
+     * type is removed
+     */
+    handleChangeTrackData(uid: any, newData: any): void;
+    handleTracksAdded(newTracks: any, position: any, extent: any, host: any): any;
+    handleCloseTrackMenuOpened(uid: any, clickPosition: any): void;
+    handleCloseContextMenu(): void;
+    handleCloseTrackMenuClosed(): void;
+    handleConfigTrackMenuOpened(uid: any, clickPosition: any): void;
+    handleConfigureTrack(track: any, configComponent: any): void;
+    handleSortEnd(sortedTracks: any): void;
+    createTracksAndLocations(): any[];
+    /**
+     * Calculate where a track is absoluately positioned within the drawing area
+     *
+     * @param track: The track object (with members, e.g. track.uid, track.width,
+     *   track.height)
+     * @param location: Where it's being plotted (e.g. 'top', 'bottom')
+     * @return: The position of the track and it's height and width
+     *          (e.g. {left: 10, top: 20, width: 30, height: 40}
+     */
+    calculateTrackPosition(track: any, location: any): {
+        left: any;
+        top: any;
+        width: number;
+        height: any;
+        track: any;
+    };
+    /**
+     * Find a central heatmap track among all displayed tracks
+     *
+     * @param  {Array}  tracks  Tracks to be searched.
+     * @return  {Object}  The first central heatmap track or `undefined`.
+     */
+    findCentralHeatmapTrack(tracks: any[]): Object;
+    trackUuidToOrientation(trackUuid: any): void;
+    overlayTracks(positionedTracks: any): any;
+    positionedTracks(): {
+        left: any;
+        top: any;
+        width: number;
+        height: any;
+        track: any;
+    }[];
+    createTrackPositionTexts(): React.JSX.Element[];
+    handleExportTrackData(hostTrackUid: any, trackUid: any): void;
+    /**
+     * List all the tracks that are under this mouse position
+     */
+    listTracksAtPosition(x: any, y: any, isReturnTrackObj?: boolean): (import("./types").UnknownTrackConfig | import("./types").CombinedTrackConfig | import("./types").TrackObject)[];
+    listAllTrackObjects(): import("./types").TrackObject[];
+    handleZoomToData(): void;
+    resetViewport(): void;
+    updatablePropsToString(props: any): string;
+    getXYScales(): void;
+    /**
+     * Translate view to data location.
+     *
+     * @description
+     * The view location is in pixels relative to the browser window. The data
+     * location is given by the scaling relative to the initial x and y domains.
+     * And the genomic location depends on the chrom sizes.
+     *
+     * @method  rangeViewToDataLoci
+     * @author  Fritz Lekschas
+     * @date    2018-01-14
+     * @param  {Array}  range  Selected view range
+     * @param  {Function}  scale  View to data scaling
+     * @return  {Array}  2D array of data locations
+     */
+    rangeViewToDataLoci(range: any[], scale: Function): any[];
+    rangeSelectionResetHandler(): void;
+    rangeSelection1dEndHandler(axis: any): (range: any) => void;
+    rangeSelection1dHandler(axis: any): (range: any) => void;
+    rangeSelection1dStartHandler(): void;
+    rangeSelection2dHandler(range: any): void;
+    rangeSelection2dStartHandler(): void;
+    rangeSelection2dEndHandler(range: any): void;
+    getContextMenu(): React.JSX.Element | null;
+    /**
+     * Draw an overlay that shows the positions of all the different
+     * track areas
+     */
+    getIdealizedTrackPositionsOverlay(): React.JSX.Element | null;
+    render(): React.JSX.Element;
+    galleryDim: any;
+    topHeightNoGallery: any;
+    bottomHeightNoGallery: any;
+    leftWidthNoGallery: any;
+    rightWidthNoGallery: any;
+    divTiledPlot: HTMLDivElement | null | undefined;
+    addEventListeners(): void;
+    eventListeners: any[] | undefined;
+    removeEventListeners(): void;
+}
+export namespace TiledPlot {
+    namespace defaultProps {
+        let isShowGlobalMousePosition: boolean;
+        let pluginTracks: {};
+        let metaTracks: never[];
+        let zoomable: boolean;
+    }
+    namespace propTypes {
+        export let addTrackExtent: PropTypes.Requireable<string>;
+        export let addTrackPosition: PropTypes.Requireable<string>;
+        export let canvasElement: PropTypes.Requireable<object>;
+        export let chooseTrackHandler: PropTypes.Requireable<(...args: any[]) => any>;
+        export let chromInfoPath: PropTypes.Requireable<string>;
+        export let customDialog: PropTypes.Requireable<any[]>;
+        export let closeCustomDialog: PropTypes.Requireable<(...args: any[]) => any>;
+        export let disableTrackMenu: PropTypes.Requireable<boolean>;
+        export let dragging: PropTypes.Requireable<boolean>;
+        export let draggingHappening: PropTypes.Requireable<boolean>;
+        export let editable: PropTypes.Requireable<boolean>;
+        export let getLockGroupExtrema: PropTypes.Requireable<(...args: any[]) => any>;
+        export let initialXDomain: PropTypes.Requireable<any[]>;
+        export let initialYDomain: PropTypes.Requireable<any[]>;
+        let isShowGlobalMousePosition_1: PropTypes.Requireable<boolean>;
+        export { isShowGlobalMousePosition_1 as isShowGlobalMousePosition };
+        export let isValueScaleLocked: PropTypes.Requireable<(...args: any[]) => any>;
+        export let marginBottom: PropTypes.Validator<number>;
+        export let marginLeft: PropTypes.Validator<number>;
+        export let marginRight: PropTypes.Validator<number>;
+        export let marginTop: PropTypes.Validator<number>;
+        export let paddingBottom: PropTypes.Validator<number>;
+        export let paddingLeft: PropTypes.Validator<number>;
+        export let paddingRight: PropTypes.Validator<number>;
+        export let paddingTop: PropTypes.Validator<number>;
+        let metaTracks_1: PropTypes.Requireable<any[]>;
+        export { metaTracks_1 as metaTracks };
+        export let modal: PropTypes.Requireable<object>;
+        export let mouseTool: PropTypes.Requireable<string>;
+        export let onCloseTrack: PropTypes.Requireable<(...args: any[]) => any>;
+        export let onChangeTrackData: PropTypes.Requireable<(...args: any[]) => any>;
+        export let onChangeTrackType: PropTypes.Requireable<(...args: any[]) => any>;
+        export let onDataDomainChanged: PropTypes.Requireable<(...args: any[]) => any>;
+        export let onLockValueScale: PropTypes.Requireable<(...args: any[]) => any>;
+        export let onMouseMoveZoom: PropTypes.Requireable<(...args: any[]) => any>;
+        export let onNewTilesLoaded: PropTypes.Requireable<(...args: any[]) => any>;
+        export let onNoTrackAdded: PropTypes.Requireable<(...args: any[]) => any>;
+        export let onRangeSelection: PropTypes.Validator<(...args: any[]) => any>;
+        export let onScalesChanged: PropTypes.Requireable<(...args: any[]) => any>;
+        export let onTrackOptionsChanged: PropTypes.Requireable<(...args: any[]) => any>;
+        export let onTrackPositionChosen: PropTypes.Requireable<(...args: any[]) => any>;
+        export let onTracksAdded: PropTypes.Requireable<(...args: any[]) => any>;
+        export let onUnlockValueScale: PropTypes.Requireable<(...args: any[]) => any>;
+        export let onValueScaleChanged: PropTypes.Requireable<(...args: any[]) => any>;
+        export let onResizeTrack: PropTypes.Requireable<(...args: any[]) => any>;
+        export let overlays: PropTypes.Requireable<any[]>;
+        export let openModal: PropTypes.Requireable<(...args: any[]) => any>;
+        export let pixiRenderer: PropTypes.Requireable<object>;
+        export let pixiStage: PropTypes.Requireable<object>;
+        let pluginTracks_1: PropTypes.Requireable<object>;
+        export { pluginTracks_1 as pluginTracks };
+        export let pubSub: PropTypes.Validator<object>;
+        export let rangeSelection1dSize: PropTypes.Requireable<any[]>;
+        export let rangeSelectionToInt: PropTypes.Requireable<boolean>;
+        export let registerDraggingChangedListener: PropTypes.Requireable<(...args: any[]) => any>;
+        export let removeDraggingChangedListener: PropTypes.Requireable<(...args: any[]) => any>;
+        export let setCentersFunction: PropTypes.Requireable<(...args: any[]) => any>;
+        export let svgElement: PropTypes.Requireable<object>;
+        export let theme: PropTypes.Validator<symbol>;
+        export let tracks: PropTypes.Requireable<object>;
+        export let trackSourceServers: PropTypes.Requireable<any[]>;
+        export let uid: PropTypes.Requireable<string>;
+        export let viewOptions: PropTypes.Requireable<object>;
+        export let xDomainLimits: PropTypes.Requireable<any[]>;
+        export let yDomainLimits: PropTypes.Requireable<any[]>;
+        let zoomable_1: PropTypes.Requireable<boolean>;
+        export { zoomable_1 as zoomable };
+        export let zoomLimits: PropTypes.Requireable<any[]>;
+        export let zoomToDataExtentOnInit: PropTypes.Requireable<(...args: any[]) => any>;
+    }
+}
+declare const _default: typeof TiledPlot;
+export default _default;
+import React from 'react';
+import { ResizeSensor } from 'css-element-queries';
+import PropTypes from 'prop-types';