higlass 1.13.5 → 2.0.0

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

@@ -0,0 +1,64 @@
+export class AddTrackDialog extends React.Component<any, any, any> {
+    constructor(props: any);
+    options: {};
+    state: {
+        selectedTilesets: {
+            datatype: string;
+        }[];
+        allTracksSameDatatype: boolean;
+    };
+    handleSubmitBound: (evt: any) => void;
+    handleTilesetPickerDoubleClickBound: (tileset: any) => void;
+    selectedTilesetsChangedBound: (selectedTilesetsIn: any) => void;
+    /**
+     * Get the track available track orientations for the given
+     * track position. Generally "top" or "bottom" equal "1d-horizontal",
+     * "left" or "right" correspond to "1d-vertical" and "center" means "2d".
+     *
+     * Arguments
+     * ---------
+     *  position: string
+     *
+     * Returns
+     * -------
+     *
+     *  A string containing the track orientation.
+     */
+    getOrientation(position: any): string;
+    handleSubmit(evt: any): void;
+    /**
+     * The user double clicked a tileset in the tileset finder dialog.
+     * This means that only one is selected.
+     *
+     * Arguments
+     * ---------
+     *  tileset: { uuid: 'CXCX', filetype: 'cooler' ....}
+     */
+    handleTilesetPickerDoubleClick(tileset: any): void;
+    handleOptionsChanged(newOptions: any): void;
+    handlePlotTypeSelected(newPlotType: any): void;
+    selectedPlotType: any;
+    selectedTilesetsChanged(selectedTilesetsIn: any): void;
+    render(): React.JSX.Element;
+    tilesetFinder: import("./TilesetFinder").TilesetFinder | null | undefined;
+    plotTypeChooser: PlotTypeChooser | null | undefined;
+}
+export namespace AddTrackDialog {
+    namespace defaultProps {
+        let position: string;
+    }
+    namespace propTypes {
+        export let datatype: PropTypes.Requireable<string>;
+        export let extent: PropTypes.Requireable<string>;
+        export let host: PropTypes.Requireable<string>;
+        export let onCancel: PropTypes.Validator<(...args: any[]) => any>;
+        export let onTracksChosen: PropTypes.Validator<(...args: any[]) => any>;
+        let position_1: PropTypes.Requireable<string>;
+        export { position_1 as position };
+        export let trackSourceServers: PropTypes.Validator<any[]>;
+    }
+}
+export default AddTrackDialog;
+import React from 'react';
+import PlotTypeChooser from './PlotTypeChooser';
+import PropTypes from 'prop-types';

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

@@ -0,0 +1,5 @@
+declare const _default: typeof React.Component<{
+    theme?: Theme;
+}>;
+export default _default;
+import React from 'react';

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

@@ -0,0 +1,15 @@
+export function rectsAtPoint(track: any, x: any, y: any): [];
+export default Annotations1dTrack;
+declare class Annotations1dTrack extends BedLikeTrack {
+    constructor(context: any, options: any, isVertical: any);
+    /**
+     * @param  {x} x position of the evt relative to the track
+     * @param  {y} y position of the evt relative to the track
+     */
+    click(x: any, y: any): {
+        type: string;
+        event: null;
+        payload: [];
+    };
+}
+import BedLikeTrack from './BedLikeTrack';

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

@@ -0,0 +1,95 @@
+export default Annotations2dTrack;
+declare class Annotations2dTrack extends TiledPixiTrack<any> {
+    constructor(context: any, options: any);
+    drawnAnnotations: {};
+    drawnAnnoGfx: {};
+    selectedAnno: {
+        graphics: any;
+        uid: any;
+    } | null;
+    publish: any;
+    subscribe: any;
+    unsubscribe: any;
+    sT: number;
+    annoSelectedBound: (uid: any) => void;
+    get minX(): number;
+    get maxX(): any;
+    get minY(): number;
+    get maxY(): any;
+    get maxSize(): any;
+    /**
+     * Point projection from the data to the view (pixel) coordinates
+     * @param   {number}  x  Data X coordinate
+     * @param   {number}  y  Data Y coordinate
+     * @return  {array}  Tuple [x,y] containing the translated view coordinates.
+     */
+    projection([x, y]: number): array;
+    /**
+     * The local tile identifier
+     *
+     * @param  {Array}  tile  Array containing [zoomLevel, xPos, yPos]
+     * @return  {String}  Joined ID string
+     */
+    tileToLocalId(tile: any[]): string;
+    /**
+     * The tile identifier used on the server
+     *
+     * @param  {Array}  tile  Array containing [zoomLevel, xPos, yPos]
+     * @return  {String}  Joined ID string
+     */
+    tileToRemoteId(tile: any[]): string;
+    localToRemoteId(remoteId: any): any;
+    /**
+     * Set which tiles are visible right now.
+     *
+     * @param tiles: A set of tiles which will be considered the currently visible
+     * tile positions.
+     */
+    setVisibleTiles(tilePositions: any): void;
+    calculateVisibleTiles(): void;
+    zoomLevel: number | undefined;
+    xTiles: number[] | undefined;
+    yTiles: number[] | undefined;
+    drawTile(tile: any, force?: boolean, silent?: boolean): void;
+    prepAnnotation(graphics: any, uid: any, startX: any, startY: any, width: any, height: any, td: any): {
+        graphics: any;
+        id: any;
+        uid: any;
+        annotation: {
+            x: any;
+            y: any;
+            width: any;
+            height: any;
+        };
+        dataPos: any[];
+        importance: any;
+        info: any;
+    };
+    drawAnnotation({ graphics, id, uid, annotation, dataPos, importance, info }: {
+        graphics: any;
+        id: any;
+        uid: any;
+        annotation: any;
+        dataPos: any;
+        importance: any;
+        info: any;
+    }, silent: any): void;
+    _drawRect(graphics: any, viewPos: any, uid: any): void;
+    context(graphics: any, viewPos: any, uid: any): (proc: any) => any;
+    click(graphics: any, viewPos: any, uid: any, event: any, payload: any): void;
+    mouseDown(): void;
+    mouseUp(graphics: any, viewPos: any, uid: any, event: any, payload: any): void;
+    hover(graphics: any, viewPos: any, uid: any): void;
+    hoveredAnno: any;
+    focus(graphics: any, viewPos: any, uid: any): void;
+    blur(graphics: any, viewPos: any, uid: any): void;
+    select(graphics: any, viewPos: any, uid: any, silent?: boolean): void;
+    unselect(): void;
+    annoSelected(uid: any): void;
+    exportSVG(): HTMLElement[];
+    setBorderStyle(graphics: any, color?: any, width?: any, alpha?: any): void;
+    setFill(graphics: any, color?: any, alpha?: any): void;
+    setPosition(newPosition: any): void;
+    zoomed(newXScale: any, newYScale: any): void;
+}
+import TiledPixiTrack from './TiledPixiTrack';

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

@@ -0,0 +1,36 @@
+export default ArrowheadDomainsTrack;
+declare class ArrowheadDomainsTrack extends TiledPixiTrack<any> {
+    constructor(...args: any[]);
+    drawnRects: {};
+    publish: any;
+    subscribe: any;
+    unsubscribe: any;
+    tileToLocalId(tile: any): string;
+    /**
+     * The tile identifier used on the server
+     */
+    tileToRemoteId(tile: any): string;
+    localToRemoteId(remoteId: any): any;
+    /**
+     * Set which tiles are visible right now.
+     *
+     * @param tiles: A set of tiles which will be considered the currently visible
+     * tile positions.
+     */
+    setVisibleTiles(tilePositions: any): void;
+    calculateVisibleTiles(): void;
+    zoomLevel: number | undefined;
+    xTiles: number[] | undefined;
+    yTiles: number[] | undefined;
+    /**
+     * Create whatever is needed to draw this tile.
+     */
+    initTile(): void;
+    destroyTile(): void;
+    drawTile(tile: any): void;
+    exportSVG(): HTMLElement[];
+    setPosition(newPosition: any): void;
+    zoomed(newXScale: any, newYScale: any): void;
+    leftTrackDraw(): void;
+}
+import TiledPixiTrack from './TiledPixiTrack';

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

@@ -0,0 +1,102 @@
+export default Autocomplete;
+declare class Autocomplete extends React.Component<any, any, any> {
+    constructor(props: any);
+    state: {
+        highlightedIndex: null;
+        menuTop: number;
+        menuLeft: number;
+        menuWidth: number;
+        isOpen: boolean;
+    };
+    keyDownHandlers: {
+        ArrowDown(event: any): void;
+        ArrowUp(event: any): void;
+        Enter(event: any): void;
+        Escape(): void;
+    };
+    getInitialState(): {
+        isOpen: boolean;
+        highlightedIndex: null;
+    };
+    UNSAFE_componentWillMount(): void;
+    _ignoreBlur: any;
+    _performAutoCompleteOnUpdate: boolean | undefined;
+    _performAutoCompleteOnKeyUp: boolean | undefined;
+    UNSAFE_componentWillReceiveProps(nextProps: any): void;
+    componentDidUpdate(prevProps: any, prevState: any): void;
+    maybeScrollItemIntoView(): void;
+    handleKeyDown(event: any): void;
+    handleChange(event: any): void;
+    handleKeyUp(): void;
+    getFilteredItems(): any;
+    maybeAutoCompleteText(): void;
+    setMenuPositions(): void;
+    highlightItemFromMouse(index: any): void;
+    selectItemFromMouse(item: any): void;
+    setIgnoreBlur(ignore: any): void;
+    renderMenu(): React.FunctionComponentElement<{
+        ref: string;
+    }> | null;
+    handleInputBlur(): void;
+    handleInputFocus(): void;
+    _ignoreClick: boolean | undefined;
+    isInputFocused(): boolean;
+    handleInputClick(): void;
+    composeEventHandlers(internal: any, external: any): any;
+    render(): React.JSX.Element;
+    inputEl: HTMLInputElement | null | undefined;
+}
+declare namespace Autocomplete {
+    namespace defaultProps {
+        let value: string;
+        let wrapperProps: {};
+        namespace wrapperStyle {
+            let display: string;
+        }
+        let inputProps: {};
+        function onChange(): void;
+        function onSelect(): void;
+        function renderMenu(items: any, value: any, style: any): React.JSX.Element;
+        function shouldItemRender(): boolean;
+        namespace menuStyle {
+            let borderRadius: string;
+            let boxShadow: string;
+            let background: string;
+            let padding: string;
+            let fontSize: string;
+            let position: string;
+            let overflow: string;
+            let maxHeight: string;
+        }
+        let autoHighlight: boolean;
+        function onMenuVisibilityChange(): void;
+    }
+    namespace propTypes {
+        let autoHighlight_1: PropTypes.Requireable<boolean>;
+        export { autoHighlight_1 as autoHighlight };
+        export let debug: PropTypes.Requireable<boolean>;
+        export let getItemValue: PropTypes.Validator<(...args: any[]) => any>;
+        let inputProps_1: PropTypes.Requireable<object>;
+        export { inputProps_1 as inputProps };
+        export let items: PropTypes.Requireable<any[]>;
+        let menuStyle_1: PropTypes.Requireable<object>;
+        export { menuStyle_1 as menuStyle };
+        export let onChange: PropTypes.Requireable<(...args: any[]) => any>;
+        export let onFocus: PropTypes.Requireable<(...args: any[]) => any>;
+        export let onMenuVisibilityChange: PropTypes.Requireable<(...args: any[]) => any>;
+        export let onSelect: PropTypes.Requireable<(...args: any[]) => any>;
+        export let open: PropTypes.Requireable<boolean>;
+        export let renderItem: PropTypes.Validator<(...args: any[]) => any>;
+        export let renderMenu: PropTypes.Requireable<(...args: any[]) => any>;
+        export let shouldItemRender: PropTypes.Requireable<(...args: any[]) => any>;
+        export let sortItems: PropTypes.Requireable<(...args: any[]) => any>;
+        let value_1: PropTypes.Requireable<any>;
+        export { value_1 as value };
+        let wrapperProps_1: PropTypes.Requireable<object>;
+        export { wrapperProps_1 as wrapperProps };
+        let wrapperStyle_1: PropTypes.Requireable<object>;
+        export { wrapperStyle_1 as wrapperStyle };
+    }
+}
+import React from 'react';
+import PropTypes from 'prop-types';

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

@@ -0,0 +1,25 @@
+export default AxisPixi;
+declare class AxisPixi {
+    constructor(track: any);
+    pAxis: import("pixi.js").Graphics;
+    track: any;
+    axisTexts: any[];
+    axisTextFontFamily: string;
+    axisTextFontSize: number;
+    startAxis(axisHeight: any): void;
+    createAxisTexts(valueScale: any, axisHeight: any): void;
+    tickValues: any;
+    tickFormat: ((n: number | {
+        valueOf(): number;
+    }) => string) | ((x: any) => any) | undefined;
+    calculateAxisTickValues(valueScale: any, axisHeight: any): any;
+    drawAxisLeft(valueScale: any, axisHeight: any): void;
+    drawAxisRight(valueScale: any, axisHeight: any): void;
+    hideOverlappingAxisLabels(): void;
+    exportVerticalAxis(axisHeight: any): HTMLElement;
+    createAxisSVGLine(): HTMLElement;
+    createAxisSVGText(text: any): HTMLElement;
+    exportAxisLeftSVG(valueScale: any, axisHeight: any): HTMLElement;
+    exportAxisRightSVG(valueScale: any, axisHeight: any): HTMLElement;
+    clearAxis(): void;
+}

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

@@ -0,0 +1,28 @@
+export default BarTrack;
+declare class BarTrack extends HorizontalLine1DPixiTrack {
+    constructor(...args: any[]);
+    zeroLine: import("pixi.js").Graphics;
+    valueScaleTransform: import("d3-zoom").ZoomTransform;
+    initialized: boolean;
+    setColorScale(colorRange: any): void;
+    colorScale: any;
+    setColorGradient(colorGradient: any): void;
+    colorGradientColors: any;
+    drawZeroLine(): void;
+    drawZeroLineSvg(output: any): void;
+    getXScaleAndOffset(drawnAtScale: any): number[];
+    movedY(dY: any): void;
+    zoomedY(yPos: any, kMultiplier: any): void;
+    /**
+     * Adds information to recreate the track in SVG to the tile
+     *
+     * @param tile
+     * @param x x value of bar
+     * @param y y value of bar
+     * @param width width of bar
+     * @param height height of bar
+     * @param color color of bar (not converted to hex)
+     */
+    addSVGInfo(tile: any, x: any, y: any, width: any, height: any, color: any): void;
+}
+import HorizontalLine1DPixiTrack from './HorizontalLine1DPixiTrack';

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

@@ -0,0 +1,84 @@
+export function polyToPoly(poly: any, kx: any, px: any, ky: any, py: any): any[][];
+export function uniqueify(elements: any): any[];
+export class TextManager {
+    constructor(track: any);
+    track: any;
+    texts: {};
+    textsList: any[];
+    textWidths: {};
+    textHeights: {};
+    textGraphics: import("pixi.js").Graphics;
+    fontSize: number;
+    hideOverlaps(): void;
+    startDraw(): void;
+    allBoxes: any[] | undefined;
+    allTexts: any[] | undefined;
+    lightUpdateSingleText(td: any, xMiddle: any, yMiddle: any, textInfo: any): void;
+    updateSingleText(td: any, xMiddle: any, yMiddle: any, textText: any): void;
+    updateTexts(): void;
+}
+export default BedLikeTrack;
+declare class BedLikeTrack extends HorizontalTiled1DPixiTrack {
+    valueScaleTransform: import("d3-zoom").ZoomTransform;
+    textManager: TextManager;
+    vertY: number;
+    vertK: number;
+    prevY: number;
+    prevK: number;
+    minRawValue: any;
+    maxRawValue: any;
+    rectGraphics: import("pixi.js").Graphics;
+    selectedRect: any;
+    uniqueSegments: any[];
+    /** Factor out some initialization code for the track. This is
+     necessary because we can now load tiles synchronously and so
+     we have to check if the track is initialized in renderTiles
+     and not in the constructor */
+    initialize(): void;
+    drawnRects: {} | undefined;
+    colorScale: import("./utils/color-domain-to-rgba-array").Color[] | number[][] | undefined;
+    initialized: boolean | undefined;
+    plusStrandRows: import("./utils/segments-to-rows").Segment[][] | {
+        value: any;
+    }[][] | undefined;
+    minusStrandRows: any[] | undefined;
+    selectRect(uid: any): void;
+    /**
+     * Remove the tile's rectangles from the list of drawnRects so that they
+     * can be drawn again.
+     */
+    destroyTile(tile: any): void;
+    removeTiles(toRemoveIds: any): void;
+    drawTile(tile: any): void;
+    valueScale: any;
+    /**
+     * Use this only when there's one row
+     *
+     * @return {[type]} [description]
+     */
+    allVisibleRects(): [type];
+    drawSegmentStyle(xStartPos: any, xEndPos: any, rectY: any, rectHeight: any, strand: any): any[];
+    drawPoly(xStartPos: any, xEndPos: any, rectY: any, rectHeight: any, strand: any): any[];
+    /** The value scale is used to arrange annotations vertically
+        based on a value */
+    setValueScale(): void;
+    /** The color value scale is used to map some value to a coloring */
+    setColorValueScale(): void;
+    colorValueScale: import("d3-scale").ScaleLinear<number, number, never> | null | undefined;
+    renderRows(rows: any, maxRows: any, startY: any, endY: any, fill: any): void;
+    render(): void;
+    prevVertY: number | undefined;
+    drawnAtScale: import("d3-scale").ScaleContinuousNumeric<number, number, never> | undefined;
+    minVisibleValueInTiles(valueColumn: any): number;
+    maxVisibleValueInTiles(valueColumn: any): number;
+    calculateMedianVisibleValue(valueColumn: any): void;
+    setPosition(newPosition: any): void;
+    setDimensions(newDimensions: any): void;
+    zoomed(newXScale: any, newYScale: any): void;
+    /** Move event for the y-axis */
+    movedY(dY: any): void;
+    /** Zoomed along the y-axis */
+    zoomedY(yPos: any, kMultiplier: any): void;
+    getMouseOverHtml(trackX: any, trackY: any): any;
+}
+import HorizontalTiled1DPixiTrack from './HorizontalTiled1DPixiTrack';

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

@@ -0,0 +1,3 @@
+export default Button;
+declare const Button: React.ForwardRefExoticComponent<React.RefAttributes<any>>;
+import React from 'react';

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

@@ -0,0 +1,12 @@
+export default CNVIntervalTrack;
+declare class CNVIntervalTrack extends HorizontalTiled1DPixiTrack {
+    seen: Set<any>;
+    rows: any[];
+    uid(item: any): any;
+    segmentOverlap(segment1: any, segment2: any): void;
+    drawAll(allTileData: any): void;
+    maxRows(): number;
+    destroyTile(tile: any): void;
+    drawTile(tile: any): void;
+}
+import HorizontalTiled1DPixiTrack from './HorizontalTiled1DPixiTrack';

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

@@ -0,0 +1,3 @@
+export default CenterTiledPlot;
+declare function CenterTiledPlot(): React.JSX.Element;
+import React from 'react';

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

@@ -0,0 +1,92 @@
+export default CenterTrack;
+declare class CenterTrack extends React.Component<any, any, any> {
+    constructor(props: any);
+    state: {
+        isVisible: boolean;
+    };
+    brushBehaviorX: import("d3-brush").BrushBehavior<any>;
+    brushBehaviorY: import("d3-brush").BrushBehavior<any>;
+    brushBehaviorXY: import("d3-brush").BrushBehavior<any>;
+    componentDidMount(): void;
+    shouldComponentUpdate(nextProps: any, nextState: any): any;
+    rangeSelectionTriggeredXY: boolean | undefined;
+    rangeSelectionTriggeredXYEnd: boolean | undefined;
+    rangeSelectionTriggeredX: boolean | undefined;
+    rangeSelectionTriggeredXEnd: boolean | undefined;
+    rangeSelectionTriggeredY: boolean | undefined;
+    rangeSelectionTriggeredYEnd: boolean | undefined;
+    componentDidUpdate(): void;
+    addBrush1d(): void;
+    brushElXOld: any;
+    brushElYOld: any;
+    brushIs1dBound: boolean | undefined;
+    addBrush2d(): void;
+    brushElXYOld: any;
+    brushIs2dBound: boolean | undefined;
+    brushedX(event: any): void;
+    rangeSelectionMoved: boolean | undefined;
+    brushedXEnded(event: any): void;
+    rangeSelectionMovedEnd: boolean | undefined;
+    brushedY(event: any): void;
+    brushedYEnded(event: any): void;
+    brushedXY(event: any): void;
+    brushedXYEnded(event: any): void;
+    brushStarted(event: any): void;
+    moveBrushX(rangeSelection: any, animate?: boolean): void;
+    moveBrushY(rangeSelection: any, animate?: boolean): void;
+    moveBrushXY(rangeSelection: any, animate?: boolean): void;
+    mouseEnterHandler(): void;
+    mouseLeaveHandler(): void;
+    removeBrush1d(): void;
+    removeBrush2d(): void;
+    render(): React.JSX.Element;
+    brushElX: import("d3-selection").Selection<SVGGElement | null, any, null, undefined> | undefined;
+    brushElY: import("d3-selection").Selection<SVGGElement | null, any, null, undefined> | undefined;
+    brushElXY: import("d3-selection").Selection<SVGGElement | null, any, null, undefined> | undefined;
+}
+declare namespace CenterTrack {
+    namespace defaultProps {
+        let className: string;
+        let configTrackMenuId: null;
+        let is1dRangeSelection: boolean;
+        let rangeSelectionEnd: PropTypes.Requireable<boolean>;
+        let isRangeSelectionActive: boolean;
+        function scaleX(x: any): any;
+        function scaleY(x: any): any;
+    }
+    namespace propTypes {
+        let className_1: PropTypes.Requireable<string>;
+        export { className_1 as className };
+        let configTrackMenuId_1: PropTypes.Requireable<string>;
+        export { configTrackMenuId_1 as configTrackMenuId };
+        export let editable: PropTypes.Requireable<boolean>;
+        export let height: PropTypes.Validator<number>;
+        let is1dRangeSelection_1: PropTypes.Requireable<boolean>;
+        export { is1dRangeSelection_1 as is1dRangeSelection };
+        let isRangeSelectionActive_1: PropTypes.Requireable<boolean>;
+        export { isRangeSelectionActive_1 as isRangeSelectionActive };
+        export let onAddSeries: PropTypes.Validator<(...args: any[]) => any>;
+        export let onCloseTrackMenuOpened: PropTypes.Validator<(...args: any[]) => any>;
+        export let onConfigTrackMenuOpened: PropTypes.Validator<(...args: any[]) => any>;
+        export let onRangeSelectionX: PropTypes.Validator<(...args: any[]) => any>;
+        export let onRangeSelectionXEnd: PropTypes.Validator<(...args: any[]) => any>;
+        export let onRangeSelectionY: PropTypes.Validator<(...args: any[]) => any>;
+        export let onRangeSelectionYEnd: PropTypes.Validator<(...args: any[]) => any>;
+        export let onRangeSelectionXY: PropTypes.Validator<(...args: any[]) => any>;
+        export let onRangeSelectionXYEnd: PropTypes.Validator<(...args: any[]) => any>;
+        export let onRangeSelectionReset: PropTypes.Validator<(...args: any[]) => any>;
+        export let onRangeSelectionStart: PropTypes.Validator<(...args: any[]) => any>;
+        export let rangeSelection: PropTypes.Validator<any[]>;
+        let rangeSelectionEnd_1: PropTypes.Requireable<boolean>;
+        export { rangeSelectionEnd_1 as rangeSelectionEnd };
+        let scaleX_1: PropTypes.Requireable<(...args: any[]) => any>;
+        export { scaleX_1 as scaleX };
+        let scaleY_1: PropTypes.Requireable<(...args: any[]) => any>;
+        export { scaleY_1 as scaleY };
+        export let tracks: PropTypes.Validator<any[]>;
+        export let uid: PropTypes.Validator<string>;
+        export let width: PropTypes.Validator<number>;
+    }
+}
+import React from 'react';
+import PropTypes from 'prop-types';

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

@@ -0,0 +1,10 @@
+export default Chromosome2DAnnotations;
+declare class Chromosome2DAnnotations extends PixiTrack<any> {
+    constructor(context: any, options: any);
+    pubSub: any;
+    rects: {};
+    chromInfo: any;
+    setPosition(newPosition: any): void;
+    zoomed(newXScale: any, newYScale: any): void;
+}
+import PixiTrack from './PixiTrack';

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

@@ -0,0 +1,13 @@
+export default Chromosome2DLabels;
+declare class Chromosome2DLabels extends PixiTrack<any> {
+    constructor(context: any, options: any);
+    searchField: SearchField | null;
+    chromInfo: any;
+    animate: any;
+    texts: any[];
+    hideOverlaps(allTexts: any): void;
+    setPosition(newPosition: any): void;
+    zoomed(newXScale: any, newYScale: any): void;
+}
+import PixiTrack from './PixiTrack';
+import SearchField from './SearchField';

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

@@ -0,0 +1,24 @@
+export default ChromosomeGrid;
+declare class ChromosomeGrid extends TiledPixiTrack<any> {
+    constructor(context: any, options: any);
+    chromInfo: any;
+    animate: any;
+    orientation: any;
+    isOverlay: any;
+    texts: any[] | undefined;
+    lineGraphics: import("pixi.js").Graphics | undefined;
+    lineGraphics1dH: import("pixi.js").Graphics | undefined;
+    lineGraphics1dV: import("pixi.js").Graphics | undefined;
+    lineGraphics2d: import("pixi.js").Graphics | undefined;
+    mask1dH: import("pixi.js").Graphics | undefined;
+    mask1dV: import("pixi.js").Graphics | undefined;
+    mask2d: import("pixi.js").Graphics | undefined;
+    calculateVisibleTiles(): never[];
+    drawLines(orientation?: any, left?: number, top?: number): void;
+    setPosition(newPosition: any): void;
+    zoomed(newXScale: any, newYScale: any): void;
+    createSvgLine(x1: any, x2: any, y1: any, y2: any, stroke: any, strokeWidth: any): HTMLElement;
+    drawLinesSvg(output: any, orientation: any, width: any, height: any, left?: number, top?: number): void;
+    exportSVG(): HTMLElement[];
+}
+import TiledPixiTrack from './TiledPixiTrack';

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

@@ -0,0 +1,14 @@
+export default ChromosomeInfo;
+declare function ChromosomeInfo(filepath: any, success: any, pubSub?: {
+    __fake__: boolean;
+    publish: () => void;
+    subscribe: () => {
+        event: string;
+        handler: () => void;
+    };
+    unsubscribe: () => void;
+    clear: () => void;
+}): Promise<{
+    absToChr(absPos: any): import("./utils/abs-to-chr").ChromosomePosition<string> | null;
+    chrToAbs([chrName, chrPos]?: [any?, any?]): number | null;
+}>;

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

@@ -0,0 +1,10 @@
+export default CloseTrackMenu;
+declare function CloseTrackMenu(props: any): React.JSX.Element;
+declare namespace CloseTrackMenu {
+    namespace propTypes {
+        let onCloseTrack: PropTypes.Validator<(...args: any[]) => any>;
+        let tracks: PropTypes.Validator<any[]>;
+    }
+}
+import React from 'react';
+import PropTypes from 'prop-types';