higlass 1.13.5 → 2.0.0

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

@@ -0,0 +1,724 @@
+/** @typedef {import('./types').Scale} Scale */
+/** @typedef {import('./types').TrackConfig} TrackConfig */
+/** @typedef {import('./types').TrackObject} TrackObject */
+/** @typedef {import('./types').TilesetInfo} TilesetInfo */
+/** @typedef {TrackRenderer["setCenter"]} SetCentersFunction */
+/** @typedef {(x: Scale, y: Scale) => [Scale, Scale]} ProjectorFunction */
+/**
+ * @typedef TrackDefinition
+ * @property {TrackConfig} track
+ * @property {number} width
+ * @property {number} height
+ * @property {number} top
+ * @property {number} left
+ */
+/**
+ * @typedef MetaPluginTrackContext
+ * @property {(trackId: string) => TrackObject | undefined} getTrackObject
+ * @property {() => void} onNewTilesLoaded
+ * @property {TrackConfig} definition
+ */
+/**
+ * @typedef {Object} PluginTrackContext
+ * @property {string} id
+ * @property {string} trackUid
+ * @property {string} trackType
+ * @property {string} viewUid
+ * @property {import('pub-sub-es').PubSub} pubSub
+ * @property {import("pixi.js").Graphics} scene
+ * @property {Record<string, unknown>} dataConfig
+ * @property {unknown} dataFetcher
+ * @property {() => unknown} getLockGroupExtrema
+ * @property {(tilesetInfo: TilesetInfo) => void} handleTilesetInfoReceived
+ * @property {() => void} animate
+ * @property {HTMLElement} svgElement
+ * @property {() => boolean} isValueScaleLocked
+ * @property {() => void} onValueScaleChanged
+ * @property {(newOption: Record<string, unknown>) => void} onTrackOptionsChanged
+ * @property {() => void} onMouseMoveZoom
+ * @property {string=} chromInfoPath
+ * @property {() => boolean} isShowGlobalMousePosition
+ * @property {() => import('./types').Theme} getTheme
+ * @property {unknown=} AVAILABLE_FOR_PLUGINS
+ * @property {(HTMLDivElement | null)=} baseEl
+ * @property {TrackConfig=} definition
+ * @property {number=} x
+ * @property {number=} y
+ * @property {number=} xPosition
+ * @property {number=} yPosition
+ * @property {[number, number]=} projectionXDomain
+ * @property {[number, number]=} projectionYDomain
+ * @property {unknown=} registerViewportChanged
+ * @property {unknown=} removeViewportChanged
+ * @property {unknown=} setDomainsCallback
+ * @property {TrackConfig[]=} tracks
+ * @property {TrackRenderer["createTrackObject"]=} createTrackObject
+ * @property {string=} orientation
+ * @property {boolean=} isOverlay
+ */
+/**
+ * @typedef PluginTrack
+ * @property {{ new (availableForPlugins: unknown, context: PluginTrackContext, options: Record<string, unknown>): TrackObject }} track
+ * @property {false=} isMetaTrack
+ */
+/**
+ * @typedef MetaPluginTrack
+ * @property {{ new (availableForPlugins: unknown, context: MetaPluginTrackContext, options: Record<string, unknown>): TrackObject }} track
+ * @property {true} isMetaTrack
+ */
+/**
+ * @template T
+ * @typedef {T & { __zoom?: import('d3-zoom').ZoomTransform }} WithZoomTransform
+ */
+/**
+ * @typedef TrackRendererProps
+ * @property {HTMLElement} canvasElement
+ * @property {number} centerHeight
+ * @property {number} centerWidth
+ * @property {Array<JSX.Element>} children
+ * @property {number} galleryDim
+ * @property {number} height
+ * @property {[number, number]} initialXDomain
+ * @property {[number, number]} initialYDomain
+ * @property {boolean} isShowGlobalMousePosition
+ * @property {boolean} isRangeSelection
+ * @property {number} leftWidth
+ * @property {number} leftWidthNoGallery
+ * @property {number} paddingLeft
+ * @property {number} paddingTop
+ * @property {Array<TrackConfig>} metaTracks
+ * @property {() => void} onMouseMoveZoom
+ * @property {(trackId?: string) => void} onNewTilesLoaded
+ * @property {(x: Scale, y: Scale) => void} onScalesChanged
+ * @property {import("pixi.js").Renderer} pixiRenderer
+ * @property {import("pixi.js").Container} pixiStage
+ * @property {Record<string, unknown>} pluginDataFetchers
+ * @property {Record<string, PluginTrack | MetaPluginTrack>} pluginTracks
+ * @property {Array<TrackDefinition>} positionedTracks
+ * @property {import('pub-sub-es').PubSub} pubSub
+ * @property {(func: SetCentersFunction) => void} setCentersFunction
+ * @property {HTMLElement} svgElement
+ * @property {import('./types').Theme} theme
+ * @property {number} topHeight
+ * @property {number} topHeightNoGallery
+ * @property {{ backgroundColor?: string }} viewOptions
+ * @property {number} width
+ * @property {[number, number]} xDomainLimits
+ * @property {[number, number]} yDomainLimits
+ * @property {boolean} valueScaleZoom
+ * @property {boolean} zoomable
+ * @property {[number, number]} zoomDomain
+ * @property {[number, number]} zoomLimits
+ * @property {string} uid
+ * @property {boolean} dragging
+ * @property {(func: (draggingStatus: boolean) => void) => void} registerDraggingChangedListener
+ * @property {boolean} disableTrackMenu
+ * @property {(listener: (draggingStatus: boolean) => void) => void} removeDraggingChangedListener
+ * @property {(trackId: string, tilesetInfo: TilesetInfo) => void} onTilesetInfoReceived
+ * @property {(trackId: string) => unknown} getLockGroupExtrema
+ * @property {(trackId: string) => boolean} isValueScaleLocked
+ * @property {(trackId: string) => void} onValueScaleChanged
+ * @property {(trackId: string, newOption: Record<string, unknown>) => void} onTrackOptionsChanged
+ */
+/**
+ * @extends {React.Component<TrackRendererProps>}
+ */
+export class TrackRenderer extends React.Component<TrackRendererProps, any, any> {
+    /**
+     * Maintain a list of tracks, and re-render them whenever either
+     * their size changes or the zoom level changes
+     *
+     * Zooming changes the domain of the scales.
+     *
+     * Resizing changes the range. Both trigger a rerender.
+     *
+     * @param {TrackRendererProps} props
+     */
+    constructor(props: TrackRendererProps);
+    /** @type {boolean} */
+    dragging: boolean;
+    /** @type {WithZoomTransform<HTMLElement> | null} */
+    element: WithZoomTransform<HTMLElement> | null;
+    /** @type {HTMLElement | null} */
+    eventTracker: HTMLElement | null;
+    /** @type {HTMLElement | null} */
+    eventTrackerOld: HTMLElement | null;
+    /** @type {boolean} */
+    closing: boolean;
+    /** @type {number} */
+    yPositionOffset: number;
+    /** @type {number} */
+    xPositionOffset: number;
+    /** @type {number} */
+    scrollTop: number;
+    /** @type {ReturnType<typeof setTimeout> | null} */
+    scrollTimeout: ReturnType<typeof setTimeout> | null;
+    /** @type {number} */
+    activeTransitions: number;
+    /** @type {import('d3-zoom').ZoomTransform} */
+    zoomTransform: import("d3-zoom").ZoomTransform;
+    /** @type {() => void} */
+    windowScrolledBound: () => void;
+    /** @type {(event?: import('d3-zoom').D3ZoomEvent<HTMLElement, unknown>) => void} */
+    zoomStartedBound: (event?: import("d3-zoom").D3ZoomEvent<HTMLElement, unknown>) => void;
+    /** @type {(event: import('d3-zoom').D3ZoomEvent<HTMLElement, unknown> & { shiftKey?: boolean }) => void} */
+    zoomedBound: (event: import("d3-zoom").D3ZoomEvent<HTMLElement, unknown> & {
+        shiftKey?: boolean;
+    }) => void;
+    /** @type {() => void} */
+    zoomEndedBound: () => void;
+    /** @type {string} */
+    uid: string;
+    /** @type {string} */
+    viewUid: string;
+    /** @type {unknown} */
+    availableForPlugins: unknown;
+    /** @type {boolean} */
+    mounted: boolean;
+    /** @type {import("d3-zoom").ZoomBehavior<HTMLElement, unknown>} */
+    emptyZoomBehavior: import("d3-zoom").ZoomBehavior<HTMLElement, unknown>;
+    /** @type {TrackRendererProps} */
+    currentProps: TrackRendererProps;
+    /** @type {string} */
+    prevPropsStr: string;
+    /** @type {import("d3-zoom").ZoomBehavior<HTMLElement, unknown>} */
+    zoomBehavior: import("d3-zoom").ZoomBehavior<HTMLElement, unknown>;
+    /** @type {import('d3-zoom').ZoomTransform} */
+    prevZoomTransform: import("d3-zoom").ZoomTransform;
+    /** @type {[number, number]} */
+    initialXDomain: [number, number];
+    /** @type {[number, number]} */
+    initialYDomain: [number, number];
+    /** @type {[number, number]} */
+    xDomainLimits: [number, number];
+    /** @type {[number, number]} */
+    yDomainLimits: [number, number];
+    /** @type {[number, number]} */
+    zoomLimits: [number, number];
+    /** @type {number} */
+    prevCenterX: number;
+    /** @type {number} */
+    prevCenterY: number;
+    /** @type {number} */
+    cumCenterXOffset: number;
+    /** @type {number} */
+    cumCenterYOffset: number;
+    /** @type {Record<string, { trackObject: TrackObject, trackDef: TrackDefinition }>} */
+    trackDefObjects: Record<string, {
+        trackObject: TrackObject;
+        trackDef: TrackDefinition;
+    }>;
+    /** @type {Record<string, { trackObject: TrackObject | UnknownPixiTrack, trackDef: TrackConfig }>} */
+    metaTracks: Record<string, {
+        trackObject: TrackObject | UnknownPixiTrack;
+        trackDef: TrackConfig;
+    }>;
+    /** @type {Array<import("pub-sub-es").Subscription>} */
+    pubSubs: Array<import("pub-sub-es").Subscription>;
+    /** @type {<T extends Event>(event: T & { sourceUid?: string, forwarded?: boolean }) => void} */
+    boundForwardEvent: <T extends Event>(event: T & {
+        sourceUid?: string;
+        forwarded?: boolean;
+    }) => void;
+    /** @type {() => void} */
+    boundScrollEvent: () => void;
+    /** @type {(event: { altKey: boolean, preventDefault(): void }) => void} */
+    boundForwardContextMenu: (event: {
+        altKey: boolean;
+        preventDefault(): void;
+    }) => void;
+    /** @type {(event: Event & { sourceUid: string, type: string }) => void} */
+    dispatchEventBound: (event: Event & {
+        sourceUid: string;
+        type: string;
+    }) => void;
+    /** @type {(opts: { pos: [number, number, number, number], animateTime: number, isMercator: boolean }) => void} */
+    zoomToDataPosHandlerBound: (opts: {
+        pos: [number, number, number, number];
+        animateTime: number;
+        isMercator: boolean;
+    }) => void;
+    /** @type {(scrollTop: number) => void} */
+    onScrollHandlerBound: (scrollTop: number) => void;
+    /** @type {{ height: number, width: number, left: number, top: number }} */
+    elementPos: {
+        height: number;
+        width: number;
+        left: number;
+        top: number;
+    };
+    /** @type {import('d3-selection').Selection<WithZoomTransform<HTMLElement>, unknown, null, unknown> | null} */
+    elementSelection: import("d3-selection").Selection<WithZoomTransform<HTMLElement>, unknown, null, unknown> | null;
+    get xScale(): import("d3-scale").ScaleLinear<number, number, never>;
+    get yScale(): import("d3-scale").ScaleLinear<number, number, never>;
+    UNSAFE_componentWillMount(): void;
+    componentDidMount(): void;
+    /** @type {import('pixi.js').Graphics} */
+    pStage: import("pixi.js").Graphics | undefined;
+    /** @type {import('pixi.js').Graphics} */
+    pMask: import("pixi.js").Graphics | undefined;
+    /** @type {import('pixi.js').Graphics} */
+    pOutline: import("pixi.js").Graphics | undefined;
+    /** @type {import('pixi.js').Graphics} */
+    pBackground: import("pixi.js").Graphics | undefined;
+    svgElement: HTMLElement | undefined;
+    /** @param {TrackRendererProps} nextProps */
+    UNSAFE_componentWillReceiveProps(nextProps: TrackRendererProps): void;
+    /** @param {TrackRendererProps} prevProps */
+    componentDidUpdate(prevProps: TrackRendererProps): void;
+    componentWillUnmount(): void;
+    /**
+     * Dispatch a forwarded event on the main DOM element
+     *
+     * @param  {Event & { sourceUid: string, type: string }} event Event to be dispatched.
+     */
+    dispatchEvent(event: Event & {
+        sourceUid: string;
+        type: string;
+    }): void;
+    /**
+     * Check of a view position (i.e., pixel coords) is within this view
+     *
+     * @param {number} x - X position to be tested.
+     * @param {number} y - Y position to be tested.
+     * @return {boolean} If `true` position is within this view.
+     */
+    isWithin(x: number, y: number): boolean;
+    /** @param {{ pos: [number, number, number, number], animateTime: number }} opts */
+    zoomToDataPosHandler({ pos, animateTime }: {
+        pos: [number, number, number, number];
+        animateTime: number;
+    }): void;
+    addZoom(): void;
+    removeZoom(): void;
+    setMask(): void;
+    setBackground(): void;
+    windowScrolled(): void;
+    /**
+     * @param {[number, number]} initialXDomain
+     * @param {[number, number]} initialYDomain
+     * @param {[number, number]} xDomainLimits
+     * @param {[number, number]} yDomainLimits
+     * @param {[number, number]} zoomLimits
+     */
+    setUpInitialScales(initialXDomain?: [number, number], initialYDomain?: [number, number], xDomainLimits?: [number, number], yDomainLimits?: [number, number], zoomLimits?: [number, number]): void;
+    drawableToDomainX: import("d3-scale").ScaleLinear<number, number, never> | undefined;
+    drawableToDomainY: import("d3-scale").ScaleLinear<number, number, never> | undefined;
+    /** @param {TrackRendererProps} props */
+    updatablePropsToString(props: TrackRendererProps): string;
+    /** @param {boolean} draggingStatus */
+    draggingChanged(draggingStatus: boolean): void;
+    setUpScales(notify?: boolean): void;
+    _xScale: import("d3-scale").ScaleLinear<number, number, never> | undefined;
+    _yScale: import("d3-scale").ScaleLinear<number, number, never> | undefined;
+    /**
+     * Get a track's viewconf definition by its object
+     *
+     * @param {TrackObject} trackObjectIn
+     */
+    getTrackDef(trackObjectIn: TrackObject): import("./types").TrackConfig | null;
+    /**
+     * Fetch the trackObject for a track with a given ID
+     *
+     * @param {string} trackId
+     * @return {TrackObject | undefined}
+     */
+    getTrackObject(trackId: string): TrackObject | undefined;
+    timedUpdatePositionAndDimensions(): void;
+    /**
+     * @param {Array<TrackConfig>} trackDefinitions
+     */
+    syncMetaTracks(trackDefinitions: Array<TrackConfig>): void;
+    /**
+     * @param {Array<TrackDefinition>} trackDefinitions
+     */
+    syncTrackObjects(trackDefinitions: Array<TrackDefinition>): void;
+    /**
+     * Make sure we have a track object for every passed track definition.
+     *
+     * If we get a track definition for which we have no Track object, we
+     * create a new one.
+     *
+     * If we have a track object for which we have no definition, we remove
+     * the object.
+     *
+     * All the others we ignore.
+     *
+     * Track definitions should be of the following form:
+     *
+     * { height:  100, width: 50, top: 30, left: 40, track: {...}}
+     *
+     * @param trackDefinitions: The definition of the track
+     * @return: Nothing
+     */
+    prevTrackDefinitions: string | undefined;
+    /**
+     * Add new meta tracks
+     *
+     * @param {Array<TrackConfig>} metaTrackDefs  Definitions of meta tracks to be added.
+     */
+    addMetaTracks(metaTrackDefs: Array<TrackConfig>): void;
+    /**
+     * @param {Array<TrackDefinition>} newTrackDefinitions
+     */
+    addNewTracks(newTrackDefinitions: Array<TrackDefinition>): void;
+    /** @param {unknown} _unused */
+    updateMetaTracks(_unused: unknown): void;
+    /** @param {Array<TrackDefinition>} newTrackDefs */
+    updateExistingTrackDefs(newTrackDefs: Array<TrackDefinition>): void;
+    updateTrackPositions(): boolean;
+    /** @param {string[]} trackIds */
+    removeMetaTracks(trackIds: string[]): void;
+    /** @param {string[]} trackUids */
+    removeTracks(trackUids: string[]): void;
+    /**
+     * Set the center of this view to a paticular X and Y coordinate
+     * @param  {number}  centerX  Centeral X data? position.
+     * @param  {number}  centerY  Central Y data? position.
+     * @param  {number}  sourceK  Source zoom level? @Pete what's the source?
+     * @param  {boolean}  notify  If `true` notify listeners that the scales
+     *   have changed. This can be turned off to prevent circular updates when
+     *   scales are locked.
+     * @param  {number}  animateTime  Animation time in milliseconds. Only used
+     *   when `animate` is true.
+     * @param  {Scale}  xScale  The scale to use for the X axis.
+     * @param  {Scale}  yScale  The scale to use for the Y axis.
+     */
+    setCenter(centerX: number, centerY: number, sourceK: number, notify?: boolean, animateTime?: number, xScale?: Scale, yScale?: Scale): [import("d3-scale").ScaleContinuousNumeric<number, number, never>, import("d3-scale").ScaleContinuousNumeric<number, number, never>] | undefined;
+    /** @param {number} movement */
+    valueScaleMove(movement: number): void;
+    /**
+     * @param {{ sourceEvent: Event }} event
+     * @param {string | null} orientation
+     */
+    valueScaleZoom(event: {
+        sourceEvent: Event;
+    }, orientation: string | null): void;
+    /**
+     * Respond to a zoom event.
+     *
+     * We need to update our local record of the zoom transform and apply it
+     * to all the tracks.
+     *
+     * @param {import("d3-zoom").D3ZoomEvent<HTMLElement, unknown> & { shiftKey?: boolean }} event
+     */
+    zoomed(event: import("d3-zoom").D3ZoomEvent<HTMLElement, unknown> & {
+        shiftKey?: boolean;
+    }): void;
+    /**
+     * Return a list of tracks under this position.
+     *
+     * The position should be relative to this.props.canvasElement.
+     *
+     * @param {number} x The query x position
+     * @param {number} y The query y position
+     * @return {Array<TrackObject>}  An array of tracks at this position
+     */
+    getTracksAtPosition(x: number, y: number): Array<TrackObject>;
+    /** @param {import('d3-zoom').D3ZoomEvent<HTMLElement, unknown>=} event */
+    zoomStarted(event?: import("d3-zoom").D3ZoomEvent<HTMLElement, unknown> | undefined): void;
+    zooming: boolean | undefined;
+    zoomStartPos: [number, number] | null | undefined;
+    valueScaleZooming: boolean | undefined;
+    zoomStartTransform: import("d3-zoom").ZoomTransform | undefined;
+    zoomEnded(): void;
+    /**
+     * @param {boolean=} notify
+     * @returns {[Scale, Scale] | undefined}
+     */
+    applyZoomTransform(notify?: boolean | undefined): [Scale, Scale] | undefined;
+    zoomedXScale: import("d3-scale").ScaleLinear<number, number, never> | undefined;
+    zoomedYScale: import("d3-scale").ScaleLinear<number, number, never> | undefined;
+    currentXScale: import("d3-scale").ScaleLinear<number, number, never> | undefined;
+    currentYScale: import("d3-scale").ScaleLinear<number, number, never> | undefined;
+    /** @param {TrackConfig} track */
+    createMetaTrack(track: TrackConfig): import("./types").TrackObject | UnknownPixiTrack;
+    /** @param {TrackConfig} track */
+    createTrackObject(track: TrackConfig): import("./types").TrackObject | CombinedTrack | Annotations1dTrack | BedLikeTrack | Annotations2dTrack | ArrowheadDomainsTrack | HorizontalLine1DPixiTrack | CNVIntervalTrack | Chromosome2DAnnotations | Chromosome2DLabels | ChromosomeGrid | CrossRule | HeatmapTiledPixiTrack | Horizontal2DDomainsTrack | HorizontalChromosomeLabels | HorizontalGeneAnnotationsTrack | HorizontalHeatmapTrack | HorizontalMultivecTrack | HorizontalPoint1DPixiTrack | HorizontalRule | Id2DTiledPixiTrack | IdHorizontal1DTiledPixiTrack | IdVertical1DTiledPixiTrack | SVGTrack | MapboxTilesTrack | OSMTilesTrack | OSMTileIdsTrack | OverlayTrack | RasterTilesTrack | SquareMarkersTrack | VerticalRule | ViewportTracker2D | ViewportTrackerHorizontal | ViewportTrackerVertical | UnknownPixiTrack | LeftTrackModifier | Track<{}>;
+    /** @param {TrackConfig} track */
+    createLocationAgnosticTrackObject(track: TrackConfig): import("./types").TrackObject | CombinedTrack | Annotations1dTrack | BedLikeTrack | Annotations2dTrack | ArrowheadDomainsTrack | HorizontalLine1DPixiTrack | CNVIntervalTrack | Chromosome2DAnnotations | Chromosome2DLabels | ChromosomeGrid | CrossRule | HeatmapTiledPixiTrack | Horizontal2DDomainsTrack | HorizontalChromosomeLabels | HorizontalGeneAnnotationsTrack | HorizontalHeatmapTrack | HorizontalMultivecTrack | HorizontalPoint1DPixiTrack | HorizontalRule | Id2DTiledPixiTrack | IdHorizontal1DTiledPixiTrack | IdVertical1DTiledPixiTrack | SVGTrack | MapboxTilesTrack | OSMTilesTrack | OSMTileIdsTrack | OverlayTrack | RasterTilesTrack | SquareMarkersTrack | VerticalRule | ViewportTracker2D | ViewportTrackerHorizontal | ViewportTrackerVertical | UnknownPixiTrack | Track<{}>;
+    /**
+     * Zoom to a location given the data coordinates
+     * @param   {number}  dataXStart  Data start X coordinate.
+     * @param   {number}  dataXEnd  Data end X coordinate.
+     * @param   {number}  dataYStart  Data start Y coordinate.
+     * @param   {number}  dataYEnd  Data end Y coordinate.
+     * @param   {number}  animateTime  Animation time in milliseconds.
+     * @param   {ProjectorFunction | null}  projector  If not `null` a projector function that
+     *   provides adjusted x and y scales.
+     */
+    zoomToDataPos(dataXStart: number, dataXEnd: number, dataYStart: number, dataYEnd: number, animateTime?: number, projector?: ProjectorFunction | null): void;
+    /**
+     * @param {{ altKey: boolean, preventDefault: () => void }} e
+     */
+    forwardContextMenu(e: {
+        altKey: boolean;
+        preventDefault: () => void;
+    }): void;
+    addEventTracker(): void;
+    removeEventTracker(): void;
+    scrollEvent(): void;
+    /**
+     * Publishes an event to the pubSub channel, first overriding the
+     * sourceUid to be the uid of this track renderer.
+     *
+     * @template {Event} T
+     * @param {T & { sourceUid?: string; forwarded?: boolean }} event
+     */
+    forwardEvent<T extends Event>(event: T & {
+        sourceUid?: string;
+        forwarded?: boolean;
+    }): void;
+    /** @param {number} scrollTop */
+    onScrollHandler(scrollTop: number): void;
+    render(): React.JSX.Element;
+    baseEl: HTMLDivElement | null | undefined;
+}
+export namespace TrackRenderer {
+    namespace defaultProps {
+        let pluginDataFetchers: {};
+        let pluginTracks: {};
+        let canvasElement: null;
+        let centerHeight: number;
+        let centerWidth: number;
+        let children: never[];
+        let galleryDim: number;
+        let height: number;
+        let initialXDomain: never[];
+        let initialYDomain: never[];
+        let isShowGlobalMousePosition: boolean;
+        let isRangeSelection: boolean;
+        let leftWidth: number;
+        let leftWidthNoGallery: number;
+        let paddingLeft: number;
+        let paddingTop: number;
+        let positionedTracks: never[];
+        let topHeight: number;
+        let topHeightNoGallery: number;
+        let width: number;
+        let metaTracks: never[];
+    }
+    namespace propTypes {
+        let canvasElement_1: PropTypes.Requireable<object>;
+        export { canvasElement_1 as canvasElement };
+        let centerHeight_1: PropTypes.Requireable<number>;
+        export { centerHeight_1 as centerHeight };
+        let centerWidth_1: PropTypes.Requireable<number>;
+        export { centerWidth_1 as centerWidth };
+        let children_1: PropTypes.Requireable<any[]>;
+        export { children_1 as children };
+        export let disableTrackMenu: PropTypes.Requireable<boolean>;
+        let galleryDim_1: PropTypes.Requireable<number>;
+        export { galleryDim_1 as galleryDim };
+        let height_1: PropTypes.Requireable<number>;
+        export { height_1 as height };
+        let initialXDomain_1: PropTypes.Requireable<any[]>;
+        export { initialXDomain_1 as initialXDomain };
+        let initialYDomain_1: PropTypes.Requireable<any[]>;
+        export { initialYDomain_1 as initialYDomain };
+        let isShowGlobalMousePosition_1: PropTypes.Requireable<boolean>;
+        export { isShowGlobalMousePosition_1 as isShowGlobalMousePosition };
+        let isRangeSelection_1: PropTypes.Requireable<boolean>;
+        export { isRangeSelection_1 as isRangeSelection };
+        let leftWidth_1: PropTypes.Requireable<number>;
+        export { leftWidth_1 as leftWidth };
+        let leftWidthNoGallery_1: PropTypes.Requireable<number>;
+        export { leftWidthNoGallery_1 as leftWidthNoGallery };
+        let paddingLeft_1: PropTypes.Requireable<number>;
+        export { paddingLeft_1 as paddingLeft };
+        let paddingTop_1: PropTypes.Requireable<number>;
+        export { paddingTop_1 as paddingTop };
+        let metaTracks_1: PropTypes.Requireable<any[]>;
+        export { metaTracks_1 as metaTracks };
+        export let onMouseMoveZoom: PropTypes.Requireable<(...args: any[]) => any>;
+        export let onNewTilesLoaded: PropTypes.Validator<(...args: any[]) => any>;
+        export let onScalesChanged: PropTypes.Validator<(...args: any[]) => any>;
+        export let pixiRenderer: PropTypes.Validator<object>;
+        export let pixiStage: PropTypes.Validator<object>;
+        let pluginDataFetchers_1: PropTypes.Requireable<object>;
+        export { pluginDataFetchers_1 as pluginDataFetchers };
+        let pluginTracks_1: PropTypes.Requireable<object>;
+        export { pluginTracks_1 as pluginTracks };
+        let positionedTracks_1: PropTypes.Requireable<any[]>;
+        export { positionedTracks_1 as positionedTracks };
+        export let pubSub: PropTypes.Validator<object>;
+        export let setCentersFunction: PropTypes.Requireable<(...args: any[]) => any>;
+        export let svgElement: PropTypes.Validator<object>;
+        export let theme: PropTypes.Validator<symbol>;
+        let topHeight_1: PropTypes.Requireable<number>;
+        export { topHeight_1 as topHeight };
+        let topHeightNoGallery_1: PropTypes.Requireable<number>;
+        export { topHeightNoGallery_1 as topHeightNoGallery };
+        export let viewOptions: PropTypes.Requireable<object>;
+        let width_1: PropTypes.Requireable<number>;
+        export { width_1 as width };
+        export let xDomainLimits: PropTypes.Requireable<any[]>;
+        export let yDomainLimits: PropTypes.Requireable<any[]>;
+        export let valueScaleZoom: PropTypes.Requireable<boolean>;
+        export let zoomable: PropTypes.Validator<boolean>;
+        export let zoomDomain: PropTypes.Requireable<any[]>;
+        export let uid: PropTypes.Requireable<string>;
+        export let zoomLimits: PropTypes.Requireable<any[]>;
+    }
+}
+declare const _default: typeof TrackRenderer;
+export default _default;
+export type Scale = import("./types").Scale;
+export type TrackConfig = import("./types").TrackConfig;
+export type TrackObject = import("./types").TrackObject;
+export type TilesetInfo = import("./types").TilesetInfo;
+export type SetCentersFunction = TrackRenderer["setCenter"];
+export type ProjectorFunction = (x: Scale, y: Scale) => [Scale, Scale];
+export type TrackDefinition = {
+    track: TrackConfig;
+    width: number;
+    height: number;
+    top: number;
+    left: number;
+};
+export type MetaPluginTrackContext = {
+    getTrackObject: (trackId: string) => TrackObject | undefined;
+    onNewTilesLoaded: () => void;
+    definition: TrackConfig;
+};
+export type PluginTrackContext = {
+    id: string;
+    trackUid: string;
+    trackType: string;
+    viewUid: string;
+    pubSub: import("pub-sub-es").PubSub;
+    scene: import("pixi.js").Graphics;
+    dataConfig: Record<string, unknown>;
+    dataFetcher: unknown;
+    getLockGroupExtrema: () => unknown;
+    handleTilesetInfoReceived: (tilesetInfo: TilesetInfo) => void;
+    animate: () => void;
+    svgElement: HTMLElement;
+    isValueScaleLocked: () => boolean;
+    onValueScaleChanged: () => void;
+    onTrackOptionsChanged: (newOption: Record<string, unknown>) => void;
+    onMouseMoveZoom: () => void;
+    chromInfoPath?: string | undefined;
+    isShowGlobalMousePosition: () => boolean;
+    getTheme: () => import("./types").Theme;
+    AVAILABLE_FOR_PLUGINS?: unknown | undefined;
+    baseEl?: (HTMLDivElement | null) | undefined;
+    definition?: TrackConfig | undefined;
+    x?: number | undefined;
+    y?: number | undefined;
+    xPosition?: number | undefined;
+    yPosition?: number | undefined;
+    projectionXDomain?: [number, number] | undefined;
+    projectionYDomain?: [number, number] | undefined;
+    registerViewportChanged?: unknown | undefined;
+    removeViewportChanged?: unknown | undefined;
+    setDomainsCallback?: unknown | undefined;
+    tracks?: TrackConfig[] | undefined;
+    createTrackObject?: TrackRenderer["createTrackObject"] | undefined;
+    orientation?: string | undefined;
+    isOverlay?: boolean | undefined;
+};
+export type PluginTrack = {
+    track: {
+        new (availableForPlugins: unknown, context: PluginTrackContext, options: Record<string, unknown>): TrackObject;
+    };
+    isMetaTrack?: false | undefined;
+};
+export type MetaPluginTrack = {
+    track: {
+        new (availableForPlugins: unknown, context: MetaPluginTrackContext, options: Record<string, unknown>): TrackObject;
+    };
+    isMetaTrack: true;
+};
+export type WithZoomTransform<T> = T & {
+    __zoom?: import("d3-zoom").ZoomTransform;
+};
+export type TrackRendererProps = {
+    canvasElement: HTMLElement;
+    centerHeight: number;
+    centerWidth: number;
+    children: Array<JSX.Element>;
+    galleryDim: number;
+    height: number;
+    initialXDomain: [number, number];
+    initialYDomain: [number, number];
+    isShowGlobalMousePosition: boolean;
+    isRangeSelection: boolean;
+    leftWidth: number;
+    leftWidthNoGallery: number;
+    paddingLeft: number;
+    paddingTop: number;
+    metaTracks: Array<TrackConfig>;
+    onMouseMoveZoom: () => void;
+    onNewTilesLoaded: (trackId?: string) => void;
+    onScalesChanged: (x: Scale, y: Scale) => void;
+    pixiRenderer: import("pixi.js").Renderer;
+    pixiStage: import("pixi.js").Container;
+    pluginDataFetchers: Record<string, unknown>;
+    pluginTracks: Record<string, PluginTrack | MetaPluginTrack>;
+    positionedTracks: Array<TrackDefinition>;
+    pubSub: import("pub-sub-es").PubSub;
+    setCentersFunction: (func: SetCentersFunction) => void;
+    svgElement: HTMLElement;
+    theme: import("./types").Theme;
+    topHeight: number;
+    topHeightNoGallery: number;
+    viewOptions: {
+        backgroundColor?: string;
+    };
+    width: number;
+    xDomainLimits: [number, number];
+    yDomainLimits: [number, number];
+    valueScaleZoom: boolean;
+    zoomable: boolean;
+    zoomDomain: [number, number];
+    zoomLimits: [number, number];
+    uid: string;
+    dragging: boolean;
+    registerDraggingChangedListener: (func: (draggingStatus: boolean) => void) => void;
+    disableTrackMenu: boolean;
+    removeDraggingChangedListener: (listener: (draggingStatus: boolean) => void) => void;
+    onTilesetInfoReceived: (trackId: string, tilesetInfo: TilesetInfo) => void;
+    getLockGroupExtrema: (trackId: string) => unknown;
+    isValueScaleLocked: (trackId: string) => boolean;
+    onValueScaleChanged: (trackId: string) => void;
+    onTrackOptionsChanged: (trackId: string, newOption: Record<string, unknown>) => void;
+};
+import React from 'react';
+import UnknownPixiTrack from './UnknownPixiTrack';
+import CombinedTrack from './CombinedTrack';
+import Annotations1dTrack from './Annotations1dTrack';
+import BedLikeTrack from './BedLikeTrack';
+import Annotations2dTrack from './Annotations2dTrack';
+import ArrowheadDomainsTrack from './ArrowheadDomainsTrack';
+import HorizontalLine1DPixiTrack from './HorizontalLine1DPixiTrack';
+import CNVIntervalTrack from './CNVIntervalTrack';
+import Chromosome2DAnnotations from './Chromosome2DAnnotations';
+import Chromosome2DLabels from './Chromosome2DLabels';
+import ChromosomeGrid from './ChromosomeGrid';
+import CrossRule from './CrossRule';
+import HeatmapTiledPixiTrack from './HeatmapTiledPixiTrack';
+import Horizontal2DDomainsTrack from './Horizontal2DDomainsTrack';
+import HorizontalChromosomeLabels from './HorizontalChromosomeLabels';
+import HorizontalGeneAnnotationsTrack from './HorizontalGeneAnnotationsTrack';
+import HorizontalHeatmapTrack from './HorizontalHeatmapTrack';
+import HorizontalMultivecTrack from './HorizontalMultivecTrack';
+import HorizontalPoint1DPixiTrack from './HorizontalPoint1DPixiTrack';
+import HorizontalRule from './HorizontalRule';
+import Id2DTiledPixiTrack from './Id2DTiledPixiTrack';
+import IdHorizontal1DTiledPixiTrack from './IdHorizontal1DTiledPixiTrack';
+import IdVertical1DTiledPixiTrack from './IdVertical1DTiledPixiTrack';
+import SVGTrack from './SVGTrack';
+import MapboxTilesTrack from './MapboxTilesTrack';
+import OSMTilesTrack from './OSMTilesTrack';
+import OSMTileIdsTrack from './OSMTileIdsTrack';
+import OverlayTrack from './OverlayTrack';
+import RasterTilesTrack from './RasterTilesTrack';
+import SquareMarkersTrack from './SquareMarkersTrack';
+import VerticalRule from './VerticalRule';
+import ViewportTracker2D from './ViewportTracker2D';
+import ViewportTrackerHorizontal from './ViewportTrackerHorizontal';
+import ViewportTrackerVertical from './ViewportTrackerVertical';
+import LeftTrackModifier from './LeftTrackModifier';
+import Track from './Track';
+import PropTypes from 'prop-types';