higlass 1.13.6 → 2.0.1

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

@@ -0,0 +1,36 @@
+export default ContextMenuContainer;
+declare class ContextMenuContainer extends React.Component<any, any, any> {
+    constructor(props: any);
+    adjusted: boolean;
+    state: {
+        orientation: any;
+        left: any;
+        top: any;
+        submenuShown: null;
+    };
+    componentDidMount(): void;
+    UNSAFE_componentWillReceiveProps(newProps: any): void;
+    componentDidUpdate(): void;
+    handleItemMouseEnterWithRect(clientRect: any, series: any): void;
+    /**
+     * @param {React.MouseEvent} evt
+     */
+    handleItemMouseEnter(evt: React.MouseEvent, series: any): void;
+    handleMouseLeave(): void;
+    handleOtherMouseEnter(): void;
+    updateOrientation(): void;
+    divDom: Element | Text | null | undefined;
+    render(): React.JSX.Element;
+    div: HTMLDivElement | null | undefined;
+}
+declare namespace ContextMenuContainer {
+    namespace propTypes {
+        let children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        let orientation: PropTypes.Requireable<string>;
+        let parentBbox: PropTypes.Requireable<object>;
+        let position: PropTypes.Requireable<object>;
+        let theme: PropTypes.Validator<symbol>;
+    }
+}
+import React from 'react';
+import PropTypes from 'prop-types';

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

@@ -0,0 +1,34 @@
+export default ContextMenuItem;
+export type ContextMenuItemProps = {
+    className?: string | undefined;
+    onClick: (evt: React.MouseEvent) => void;
+    onMouseEnter: (evt: React.MouseEvent) => void;
+    onMouseLeave: (evt: React.MouseEvent) => void;
+};
+/**
+ * @typedef ContextMenuItemProps
+ * @prop {string} [className]
+ * @prop {(evt: React.MouseEvent) => void} onClick
+ * @prop {(evt: React.MouseEvent) => void} onMouseEnter
+ * @prop {(evt: React.MouseEvent) => void} onMouseLeave
+ */
+/**
+ * @param {React.PropsWithChildren<ContextMenuItemProps>} props
+ */
+declare function ContextMenuItem(props: React.PropsWithChildren<ContextMenuItemProps>): React.JSX.Element;
+declare namespace ContextMenuItem {
+    namespace defaultProps {
+        function onMouseEnter(): undefined;
+        function onMouseLeave(): undefined;
+    }
+    namespace propTypes {
+        export let children: PropTypes.Validator<NonNullable<PropTypes.ReactNodeLike>>;
+        export let onClick: PropTypes.Validator<(...args: any[]) => any>;
+        let onMouseEnter_1: PropTypes.Requireable<(...args: any[]) => any>;
+        export { onMouseEnter_1 as onMouseEnter };
+        let onMouseLeave_1: PropTypes.Requireable<(...args: any[]) => any>;
+        export { onMouseLeave_1 as onMouseLeave };
+    }
+}
+import React from 'react';
+import PropTypes from 'prop-types';

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

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

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

@@ -0,0 +1,24 @@
+export default CrossRule;
+declare class CrossRule {
+    constructor(context: any, options: any);
+    xPosition: any;
+    yPosition: any;
+    strokeWidth: number;
+    strokeOpacity: number;
+    dashLength: number;
+    dashGap: number;
+    draw(): void;
+    mouseMoveHandler(mousePos: any): void;
+    highlighted: any;
+    drawHorizontalRule(graphics: any): void;
+    isMouseOverHorizontalLine(mousePos: any): boolean;
+    /**
+     * Export an SVG representation of this track
+     *
+     * @returns {Array} The two returned DOM nodes are both SVG
+     * elements [base,track]. Base is a parent which contains track as a
+     * child. Track is clipped with a clipping rectangle contained in base.
+     *
+     */
+    exportSVG(): any[];
+}

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

@@ -0,0 +1,17 @@
+export default CustomTrackDialog;
+declare class CustomTrackDialog extends React.PureComponent<any, any, any> {
+    constructor(props: any);
+    constructor(props: any, context: any);
+    render(): React.JSX.Element;
+}
+declare namespace CustomTrackDialog {
+    let defaultProps: {};
+    namespace propTypes {
+        let onCancel: PropTypes.Validator<(...args: any[]) => any>;
+        let title: PropTypes.Requireable<string>;
+        let bodyProps: PropTypes.Requireable<any[]>;
+        let children: PropTypes.Requireable<any[]>;
+    }
+}
+import React from 'react';
+import PropTypes from 'prop-types';

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

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

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

@@ -0,0 +1,4 @@
+export default DivergentBarTrack;
+declare class DivergentBarTrack extends BarTrack {
+}
+import BarTrack from './BarTrack';

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

@@ -0,0 +1,32 @@
+declare const _default: typeof DragListeningDiv;
+export default _default;
+declare class DragListeningDiv extends React.Component<any, any, any> {
+    constructor(props: any);
+    state: {
+        dragOnTop: boolean;
+    };
+    render(): React.JSX.Element;
+}
+declare namespace DragListeningDiv {
+    namespace defaultProps {
+        let enabled: boolean;
+        let style: {};
+        let draggingHappening: {};
+        function onTrackDropped(): void;
+    }
+    namespace propTypes {
+        let enabled_1: PropTypes.Requireable<boolean>;
+        export { enabled_1 as enabled };
+        let style_1: PropTypes.Requireable<object>;
+        export { style_1 as style };
+        export let defaultTrackType: PropTypes.Requireable<object>;
+        let draggingHappening_1: PropTypes.Requireable<object>;
+        export { draggingHappening_1 as draggingHappening };
+        let onTrackDropped_1: PropTypes.Requireable<(...args: any[]) => any>;
+        export { onTrackDropped_1 as onTrackDropped };
+        export let position: PropTypes.Validator<string>;
+        export let pubSub: PropTypes.Validator<object>;
+    }
+}
+import React from 'react';
+import PropTypes from 'prop-types';

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

@@ -0,0 +1,63 @@
+declare const _default: typeof DraggableDiv;
+export default _default;
+declare class DraggableDiv extends React.Component<any, any, any> {
+    constructor(props: any);
+    dragTopRight: import("d3-drag").DragBehavior<Element, any, any>;
+    dragTopLeft: import("d3-drag").DragBehavior<Element, any, any>;
+    dragBottomRight: import("d3-drag").DragBehavior<Element, any, any>;
+    dragBottomLeft: import("d3-drag").DragBehavior<Element, any, any>;
+    dragBottom: import("d3-drag").DragBehavior<Element, any, any>;
+    dragTop: import("d3-drag").DragBehavior<Element, any, any>;
+    dragLeft: import("d3-drag").DragBehavior<Element, any, any>;
+    dragRight: import("d3-drag").DragBehavior<Element, any, any>;
+    minWidth: number;
+    minHeight: number;
+    bottomHandleWidth: number;
+    state: {
+        uid: any;
+        width: any;
+        height: any;
+        top: any;
+        left: any;
+    };
+    domBody: import("d3-selection").BaseType;
+    componentDidMount(): void;
+    UNSAFE_componentWillReceiveProps(newProps: any): void;
+    dragBottomFunc(event: any): void;
+    dragLeftFunc(event: any): void;
+    dragTopFunc(event: any): void;
+    dragRightFunc(event: any): void;
+    dragBottomLeftFunc(event: any): void;
+    dragBottomRightFunc(event: any): void;
+    dragTopRightFunc(event: any): void;
+    dragTopLeftFunc(event: any): void;
+    dragStart(event: any): void;
+    dragStartMousePos: [number, number] | undefined;
+    dragStartWidth: any;
+    dragStartHeight: any;
+    dragStartTop: any;
+    dragStartLeft: any;
+    sizeChanged(): void;
+    rotateClicked(): void;
+    closeClicked(): void;
+    render(): React.JSX.Element;
+    divContainer: HTMLDivElement | null | undefined;
+}
+declare namespace DraggableDiv {
+    namespace propTypes {
+        let className: PropTypes.Requireable<string>;
+        let height: PropTypes.Requireable<number>;
+        let left: PropTypes.Requireable<number>;
+        let opacity: PropTypes.Requireable<number>;
+        let resizeHandles: PropTypes.Requireable<object>;
+        let sizeChanged: PropTypes.Requireable<(...args: any[]) => any>;
+        let top: PropTypes.Requireable<number>;
+        let trackClosed: PropTypes.Requireable<(...args: any[]) => any>;
+        let trackRotated: PropTypes.Requireable<(...args: any[]) => any>;
+        let uid: PropTypes.Requireable<string>;
+        let width: PropTypes.Requireable<number>;
+        let theme: PropTypes.Requireable<symbol>;
+    }
+}
+import React from 'react';
+import PropTypes from 'prop-types';

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

@@ -0,0 +1,21 @@
+export default ExportLinkDialog;
+declare class ExportLinkDialog extends React.Component<any, any, any> {
+    constructor(props: any);
+    constructor(props: any, context: any);
+    render(): React.JSX.Element;
+    input: HTMLInputElement | undefined;
+}
+declare namespace ExportLinkDialog {
+    namespace defaultProps {
+        function onDone(): void;
+        let url: string;
+    }
+    namespace propTypes {
+        let onDone_1: PropTypes.Requireable<(...args: any[]) => any>;
+        export { onDone_1 as onDone };
+        let url_1: PropTypes.Requireable<string>;
+        export { url_1 as url };
+    }
+}
+import React from 'react';
+import PropTypes from 'prop-types';

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

@@ -0,0 +1,5 @@
+export default FilledLine;
+declare class FilledLine extends HorizontalLine1DPixiTrack {
+    drawRange(tile: any, row: any, tileXScale: any, offsetValue: any): void;
+}
+import HorizontalLine1DPixiTrack from './HorizontalLine1DPixiTrack';

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

@@ -0,0 +1,5 @@
+export default class FixedTrack extends TrackArea {
+    render(): React.JSX.Element;
+}
+import TrackArea from './TrackArea';
+import React from 'react';

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

@@ -0,0 +1,20 @@
+export default GalleryTracks;
+declare class GalleryTracks extends React.Component<any, any, any> {
+    constructor(props: any);
+    state: {
+        hovering: boolean;
+    };
+    mouseEnterHandler(): void;
+    mouseLeaveHandler(): void;
+    render(): React.JSX.Element;
+}
+declare namespace GalleryTracks {
+    namespace propTypes {
+        let editable: PropTypes.Requireable<boolean>;
+        let onCloseTrackMenuOpened: PropTypes.Validator<(...args: any[]) => any>;
+        let onConfigTrackMenuOpened: PropTypes.Validator<(...args: any[]) => any>;
+        let tracks: PropTypes.Requireable<any[]>;
+    }
+}
+import React from 'react';
+import PropTypes from 'prop-types';

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

@@ -0,0 +1,95 @@
+declare const _default: typeof GenomePositionSearchBox;
+export default _default;
+declare class GenomePositionSearchBox extends React.Component<any, any, any> {
+    constructor(props: any);
+    mounted: boolean;
+    uid: string;
+    chromInfo: any;
+    searchField: SearchField | null;
+    autocompleteMenu: Autocomplete | null;
+    xScale: any;
+    yScale: any;
+    prevParts: any[];
+    menuPosition: {
+        left: number;
+        top: number;
+    };
+    currentChromInfoServer: any;
+    currentChromInfoId: any;
+    positionText: any;
+    state: {
+        value: any;
+        loading: boolean;
+        menuPosition: number[];
+        genes: never[];
+        isFocused: boolean;
+        menuOpened: boolean;
+        availableAssemblies: never[];
+        selectedAssembly: null;
+    };
+    styles: {
+        item: {
+            padding: string;
+            cursor: string;
+        };
+        highlightedItem: {
+            color: string;
+            background: string;
+            padding: string;
+            cursor: string;
+        };
+        menu: {
+            border: string;
+        };
+    };
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    /**
+     * The user has selected an assembly to use for the coordinate search box
+     *
+     * @param {string} chromInfoServer
+     * @param {string} chromInfoId - The name of the chromosome info set to use
+     *
+     * @returns {void} Once the appropriate ChromInfo file is fetched, it is stored locally
+     */
+    fetchChromInfo(chromInfoServer: string, chromInfoId: string): void;
+    scalesChanged(xScale: any, yScale: any): void;
+    setPositionText(): void;
+    autocompleteKeyPress(event: any): void;
+    replaceGenesWithLoadedPositions(genePositions: any): any;
+    replaceGenesWithPositions(finished: any): void;
+    buttonClick(): void;
+    searchFieldSubmit(): void;
+    pathJoin(parts: any, sep: any): any;
+    onAutocompleteChange(event: any, value: any): void;
+    changedPart: number | null | undefined;
+    geneSelected(value: any, objct: any): void;
+    handleMenuVisibilityChange(isOpen: any, inputEl: any): void;
+    handleRenderMenu(items: any): React.JSX.Element;
+    handleAssemblySelect(evt: any): void;
+    focusHandler(isFocused: any): void;
+    UNSAFE_componentWillReceiveProps(nextProps: any): void;
+    render(): React.JSX.Element;
+    gpsbForm: HTMLDivElement | null | undefined;
+}
+declare namespace GenomePositionSearchBox {
+    namespace propTypes {
+        let autocompleteId: PropTypes.Requireable<string>;
+        let autocompleteServer: PropTypes.Requireable<string>;
+        let chromInfoId: PropTypes.Requireable<string>;
+        let chromInfoServer: PropTypes.Requireable<string>;
+        let isFocused: PropTypes.Requireable<boolean>;
+        let onFocus: PropTypes.Requireable<(...args: any[]) => any>;
+        let onSelectedAssemblyChanged: PropTypes.Requireable<(...args: any[]) => any>;
+        let registerViewportChangedListener: PropTypes.Requireable<(...args: any[]) => any>;
+        let removeViewportChangedListener: PropTypes.Requireable<(...args: any[]) => any>;
+        let setCenters: PropTypes.Requireable<(...args: any[]) => any>;
+        let theme: PropTypes.Requireable<string>;
+        let trackSourceServers: PropTypes.Requireable<any[]>;
+        let twoD: PropTypes.Requireable<boolean>;
+    }
+}
+import React from 'react';
+import SearchField from './SearchField';
+import Autocomplete from './Autocomplete';
+import PropTypes from 'prop-types';

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

@@ -0,0 +1,30 @@
+export default HeatmapOptions;
+declare class HeatmapOptions extends React.Component<any, any, any> {
+    constructor(props: any);
+    state: {
+        colors: any;
+    };
+    handleColorsChanged(newColors: any): void;
+    handleSubmit(): void;
+    /**
+     * Add a color to the end
+     */
+    handleAddColor(): void;
+    /**
+     * Remove one of the colors from the color map
+     */
+    handleRemoveColor(i: any): void;
+    render(): React.JSX.Element;
+}
+declare namespace HeatmapOptions {
+    namespace propTypes {
+        let handleCancel: PropTypes.Requireable<(...args: any[]) => any>;
+        let onCancel: PropTypes.Requireable<(...args: any[]) => any>;
+        let onSubmit: PropTypes.Requireable<(...args: any[]) => any>;
+        let track: PropTypes.Requireable<object>;
+        let xScale: PropTypes.Requireable<object>;
+        let yScale: PropTypes.Requireable<object>;
+    }
+}
+import React from 'react';
+import PropTypes from 'prop-types';

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

@@ -0,0 +1,184 @@
+export default HeatmapTiledPixiTrack;
+declare class HeatmapTiledPixiTrack extends TiledPixiTrack<any> {
+    constructor(context: any, options: any);
+    pubSub: any;
+    is2d: boolean;
+    animate: any;
+    uid: string;
+    scaleBrush: import("d3-brush").BrushBehavior<any>;
+    onTrackOptionsChanged: any;
+    isShowGlobalMousePosition: any;
+    isValueScaleLocked: any;
+    pColorbarArea: import("pixi.js").Graphics;
+    pColorbar: import("pixi.js").Graphics;
+    axis: AxisPixi;
+    colorScale: number[][];
+    gBase: import("d3-selection").Selection<SVGGElement, any, null, undefined>;
+    gMain: import("d3-selection").Selection<SVGGElement, any, null, undefined>;
+    gColorscaleBrush: import("d3-selection").Selection<SVGGElement, any, null, undefined>;
+    brushing: boolean;
+    prevIndUpperLeftTile: string;
+    onMouseMoveZoom: any;
+    dataLens: Float32Array<ArrayBuffer>;
+    mouseMoveHandlerBound: (e: Object) => void;
+    hideMousePosition: Function | undefined;
+    /**
+     * Mouse move handler
+     *
+     * @param  {Object}  e  Event object.
+     */
+    mouseMoveHandler(e: Object): void;
+    mouseX: any;
+    mouseY: any;
+    /**
+     * Mouse move and zoom handler. Is triggered on both events.
+     *
+     * @param  {Number}  absX  Absolute X coordinate.
+     * @param  {Number}  absY  Absolute Y coordinate
+     */
+    mouseMoveZoomHandler(absX?: number, absY?: number): void;
+    scheduleRerender(): void;
+    handleRerender(): void;
+    /**
+     * Get absolute (i.e., display) tile dimension and position.
+     *
+     * @param {Number}  zoomLevel  Current zoom level.
+     * @param {Array}  tilePos  Tile position.
+     * @return {Object}  Object holding the absolute x, y, width, and height.
+     */
+    getAbsTileDim(zoomLevel: number, tilePos: any[], mirrored: any): Object;
+    updateValueScale(): (string | import("d3-scale").ScaleLinear<number, number, never>)[];
+    valueScale: import("d3-scale").ScaleLinear<number, number, never> | import("d3-scale").ScaleLogarithmic<number, number, never> | undefined;
+    limitedValueScale: import("d3-scale").ScaleLinear<number, number, never> | undefined;
+    rerender(options: any, force: any): void;
+    tileDataToCanvas(pixData: any): HTMLCanvasElement;
+    exportData(): void;
+    /**
+     * Position sprite (the rendered tile)
+     *
+     * @param  {Object}  sprite  PIXI sprite object.
+     * @param  {Number}  zoomLevel  Current zoom level.
+     * @param  {Array}  tilePos  X,Y position of tile.
+     * @param  {Boolean}  mirrored  If `true` tile is mirrored.
+     */
+    setSpriteProperties(sprite: Object, zoomLevel: number, tilePos: any[], mirrored: boolean): void;
+    refXScale(_: any): void;
+    refYScale(_: any): void;
+    newBrushOptions(selection: any): any;
+    brushStart(): void;
+    brushMoved(event: any): void;
+    brushEnd(): void;
+    setPosition(newPosition: any): void;
+    setDimensions(newDimensions: any): void;
+    removeColorbar(): void;
+    drawColorbar(): void;
+    colorbarHeight: number | undefined;
+    northHandle: import("d3-selection").Selection<SVGRectElement, {
+        type: string;
+    }, SVGGElement, any> | undefined;
+    exportColorBarSVG(): HTMLElement;
+    /**
+     * Set data lens size
+     *
+     * @param  {Integer}  newDataLensSize  New data lens size. Needs to be an odd
+     *   integer.
+     */
+    setDataLensSize(newDataLensSize: Integer): void;
+    dataLensPadding: number | undefined;
+    dataLensSize: number | undefined;
+    binsPerTile(): any;
+    /**
+     * Get the data in the visible rectangle
+     *
+     * The parameter coordinates are in pixel coordinates
+     *
+     * @param {int} x: The upper left corner of the rectangle in pixel coordinates
+     * @param {int} y: The upper left corner of the rectangle in pixel coordinates
+     * @param {int} width: The width of the rectangle (pixels)
+     * @param {int} height: The height of the rectangle (pixels)
+     *
+     * @returns {Array} A numjs array containing the data in the visible region
+     *
+     */
+    getVisibleRectangleData(x: int, y: int, width: int, height: int): any[];
+    /**
+     * Convert the raw tile data to a rendered array of values which can be represented as a sprite.
+     *
+     * @param tile: The data structure containing all the tile information. Relevant to
+     *              this function are tile.tileData = \{'dense': [...], ...\}
+     *              and tile.graphics
+     */
+    initTile(tile: any): void;
+    updateTile(tile: any): void;
+    destroyTile(tile: any): void;
+    pixDataFunction(tile: any, pixData: any): void;
+    /**
+     * Render / draw a tile.
+     *
+     * @param {Object}  tile  Tile data to be rendered.
+     */
+    renderTile(tile: Object): void;
+    refScalesChanged(refXScale: any, refYScale: any): void;
+    /**
+     * Bypass this track's exportSVG function
+     */
+    superSVG(): [HTMLElement, HTMLElement];
+    exportSVG(): HTMLElement[];
+    getVisiblePartOfUppLeftTile(): (string | number)[] | null;
+    getIndicesOfVisibleDataInTile(tile: any): number[];
+    zoomed(newXScale: any, newYScale: any, k: any, tx: any, ty: any): void;
+    /**
+     * Helper method for adding a tile ID in place. Used by `tilesToId()`.
+     *
+     * @param  {Array}  tiles  Array tile ID should be added to.
+     * @param  {Integer}  zoomLevel  Zoom level.
+     * @param  {Integer}  row  Column ID, i.e., y.
+     * @param  {Integer}  column  Column ID, i.e., x.
+     * @param  {Objwect}  dataTransform  ??
+     * @param  {Boolean}  mirrored  If `true` tile is mirrored.
+     */
+    addTileId(tiles: any[], zoomLevel: Integer, row: Integer, column: Integer, dataTransform: Objwect, mirrored?: boolean): void;
+    /**
+     * Convert tile positions to tile IDs
+     *
+     * @param  {Array}  xTiles  X positions of tiles
+     * @param  {Array}  yTiles  Y positions of tiles
+     * @param  {Array}  zoomLevel  Current zoom level
+     * @return  {Array}  List of tile IDs
+     */
+    tilesToId(xTiles: any[], yTiles: any[], zoomLevel: any[]): any[];
+    calculateVisibleTiles(): void;
+    zoomLevel: number | undefined;
+    xTiles: number[] | undefined;
+    yTiles: number[] | undefined;
+    mirrorTiles(): boolean;
+    contextMenuItems(trackX: any, trackY: any): never[];
+    getMouseOverHtml(trackX: any, trackY: any): string;
+    /**
+     * Get the tile's position in its coordinate system.
+     *
+     * @description
+     * Normally the absolute coordinate system are the genome basepair positions
+     */
+    getTilePosAndDimensions(zoomLevel: any, tilePos: any, binsPerTileIn: any): {
+        tileX: number;
+        tileY: number;
+        tileWidth: number;
+        tileHeight: number;
+    };
+    /**
+     * The local tile identifier
+     *
+     * @param {array}  tile  Tile definition array to be converted to id. Tile
+     *   array must contain `[zoomLevel, xPos, yPos]` and two props `mirrored` and
+     *   `dataTransform`.
+     */
+    tileToLocalId(tile: array): string;
+    /**
+     * The tile identifier used on the server
+     */
+    tileToRemoteId(tile: any): string;
+    localToRemoteId(remoteId: any): any;
+}
+import TiledPixiTrack from './TiledPixiTrack';
+import AxisPixi from './AxisPixi';