higlass 1.13.5 → 2.0.0

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

@@ -0,0 +1,129 @@
+export default OSMTilesTrack;
+declare class OSMTilesTrack extends PixiTrack<any> {
+    /**
+     * A track that must pull remote tiles
+     *
+     * @param scene: A PIXI.js scene to draw everything to.
+     * @param server: The server to pull tiles from.
+     * @param tilesetUid: The data set to get the tiles from the server
+     */
+    constructor(context: any, options: any);
+    visibleTiles: Set<any>;
+    visibleTileIds: Set<any>;
+    fetching: Set<any>;
+    fetchedTiles: {};
+    tileGraphics: {};
+    minX: number;
+    maxX: number;
+    minY: any;
+    maxY: any;
+    maxZoom: number;
+    maxWidth: number;
+    animate: any;
+    uuid: string;
+    refreshTilesDebounced: {
+        (...args: any[]): void;
+        cancel(): void;
+    };
+    /**
+     * Return the set of ids of all tiles which are both visible and fetched.
+     */
+    visibleAndFetchedIds(): string[];
+    visibleAndFetchedTiles(): 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;
+    removeAllTiles(): void;
+    refreshTiles(): void;
+    /**
+     * Remove obsolete tiles
+     *
+     * @param toRemoveIds: An array of tile ids to remove from the list of fetched tiles.
+     */
+    removeTiles(toRemoveIds: any): void;
+    tileToLocalId(tile: any): any;
+    /**
+     * The tile identifier used on the server.
+     * @param   {array}  tile  Contains `[zoomLevel, xPos, yPos]`.
+     * @return  {string}  Remote ID string
+     */
+    tileToRemoteId(tile: array): string;
+    localToRemoteId(remoteId: any): any;
+    calculateVisibleTiles(): void;
+    zoomLevel: number | undefined;
+    xTiles: number[] | undefined;
+    yTiles: number[] | undefined;
+    zoomed(newXScale: any, newYScale: any, k: any, tx: any, ty: any): void;
+    setPosition(newPosition: any): void;
+    setDimensions(newDimensions: any): 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;
+    minValue(_: any): any;
+    maxValue(_: any): any;
+    minRawValue(): any;
+    maxRawValue(): any;
+    /**
+     * Get the tile's position in its coordinate system.
+     */
+    getTilePosAndDimensions(zoomLevel: any, tilePos: any): {
+        tileX: number;
+        tileY: any;
+        tileWidth: number;
+        tileHeight: number;
+    };
+    setSpriteProperties(sprite: any, zoomLevel: any, tilePos: any): void;
+    initTile(tile: any): void;
+    updateTile(tile: any): void;
+    destroyTile(tile: any): void;
+    /**
+     * Add graphics for tiles that have no graphics
+     */
+    addMissingGraphics(): void;
+    /**
+     * Change the graphics for existing tiles
+     */
+    updateExistingGraphics(): void;
+    /**
+     * Make sure that we have a one to one mapping between tiles
+     * and graphics objects
+     */
+    synchronizeTilesAndGraphics(): void;
+    /**
+     * Extract drawable data from a tile loaded by a generic tile loader
+     *
+     * @param tile: A tile returned by a TiledArea.
+     * @param 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.
+     */
+    loadTileData(tile: any, dataLoader: any): any;
+    /**
+     * Get the url used to fetch the tile data
+     */
+    getTileUrl(tileZxy: any): string;
+    fetchNewTiles(toFetch: any): void;
+    /**
+     * We've gotten a bunch of tiles from the server in
+     * response to a request from fetchTiles.
+     */
+    receivedTiles(loadedTiles: any): void;
+    /**
+     * Draw a tile on some graphics
+     */
+    drawTile(): void;
+    refScalesChanged(refXScale: any, refYScale: any): void;
+}
+import PixiTrack from './PixiTrack';

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

@@ -0,0 +1,13 @@
+export default OverlayTrack;
+declare class OverlayTrack extends PixiTrack<any> {
+    constructor(context: any, options: any);
+    drawnRects: {};
+    drawHorizontalOverlay(graphics: any, position: any, extent: any, minWidth: number | undefined, fill: any, stroke: any, outline: any, options: any): void;
+    drawVerticalOverlay(graphics: any, position: any, extent: any, minHeight: number | undefined, fill: any, stroke: any, outline: any, options?: {}): void;
+    draw(options: any): void;
+    zoomed(newXScale: any, newYScale: any): void;
+    setPosition(newPosition: any): void;
+    setDimensions(newDimensions: any): void;
+    exportSVG(): HTMLElement[];
+}
+import PixiTrack from './PixiTrack';

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

@@ -0,0 +1,174 @@
+export default PixiTrack;
+export type PixiTrackOptions = {
+    /**
+     * - If the label is to be drawn, where should it be drawn?
+     */
+    labelPosition: string;
+    /**
+     * - What should be drawn in the label.
+     * If either labelPosition or labelText are false, no label will be drawn.
+     */
+    labelText: string;
+    trackBorderWidth?: number | undefined;
+    trackBorderColor?: string | undefined;
+    backgroundColor?: string | undefined;
+    labelColor?: string | undefined;
+    lineStrokeColor?: string | undefined;
+    barFillColor?: string | undefined;
+    name?: string | undefined;
+    labelTextOpacity?: number | undefined;
+    labelBackgroundColor?: string | undefined;
+    labelLeftMargin?: number | undefined;
+    labelRightMargin?: number | undefined;
+    labelTopMargin?: number | undefined;
+    labelBottomMargin?: number | undefined;
+    labelBackgroundOpacity?: number | undefined;
+    labelShowAssembly?: boolean | undefined;
+    labelShowResolution?: boolean | undefined;
+    dataTransform?: string | undefined;
+};
+export type PixiTrackContext = import("./Track").ExtendedTrackContext<{
+    scene: import("pixi.js").Container;
+}>;
+export type ExtendedPixiContext<T> = T & PixiTrackContext;
+export type ExtendedPixiOptions<T> = T & PixiTrackOptions;
+/**
+ * @typedef PixiTrackOptions
+ * @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.
+ * If either labelPosition or labelText are false, no label will be drawn.
+ * @property {number=} trackBorderWidth
+ * @property {string=} trackBorderColor
+ * @property {string=} backgroundColor
+ * @property {string=} labelColor
+ * @property {string=} lineStrokeColor
+ * @property {string=} barFillColor
+ * @property {string=} name
+ * @property {number=} labelTextOpacity
+ * @property {string=} labelBackgroundColor
+ * @property {number=} labelLeftMargin
+ * @property {number=} labelRightMargin
+ * @property {number=} labelTopMargin
+ * @property {number=} labelBottomMargin
+ * @property {number=} labelBackgroundOpacity
+ * @property {boolean=} labelShowAssembly
+ * @property {boolean=} labelShowResolution
+ * @property {string=} dataTransform
+ */
+/**
+ * @typedef {import('./Track').ExtendedTrackContext<{ scene: import('pixi.js').Container}>} PixiTrackContext
+ */
+/**
+ * @template T
+ * @typedef {T & PixiTrackContext} ExtendedPixiContext
+ */
+/**
+ * @template T
+ * @typedef {T & PixiTrackOptions} ExtendedPixiOptions
+ */
+/**
+ * @template {ExtendedPixiOptions<{[key: string]: any}>} Options
+ * @extends {Track<Options>} */
+declare class PixiTrack<Options extends ExtendedPixiOptions<{
+    [key: string]: any;
+}>> extends Track<Options> {
+    /**
+     * @param {PixiTrackContext} context - Includes the PIXI.js scene to draw to.
+     * @param {Options} options - The options for this track.
+     */
+    constructor(context: PixiTrackContext, options: Options);
+    /** @type {import('pixi.js').Container} */
+    scene: import("pixi.js").Container;
+    /** @type {boolean} */
+    delayDrawing: boolean;
+    /** @type {import('pixi.js').Graphics} */
+    pBase: import("pixi.js").Graphics;
+    /** @type {import('pixi.js').Graphics} */
+    pMasked: import("pixi.js").Graphics;
+    /** @type {import('pixi.js').Graphics} */
+    pMask: import("pixi.js").Graphics;
+    /** @type {import('pixi.js').Graphics} */
+    pMain: import("pixi.js").Graphics;
+    /** @type {import('pixi.js').Graphics} */
+    pBorder: import("pixi.js").Graphics;
+    /** @type {import('pixi.js').Graphics} */
+    pBackground: import("pixi.js").Graphics;
+    /** @type {import('pixi.js').Graphics} */
+    pForeground: import("pixi.js").Graphics;
+    /** @type {import('pixi.js').Graphics} */
+    pLabel: import("pixi.js").Graphics;
+    /** @type {import('pixi.js').Graphics} */
+    pMobile: import("pixi.js").Graphics;
+    /** @type {import('pixi.js').Graphics} */
+    pAxis: import("pixi.js").Graphics;
+    /** @type {import('pixi.js').Graphics} */
+    pMouseOver: import("pixi.js").Graphics;
+    /** @type {string} */
+    prevOptions: string;
+    /** @type {string} */
+    labelTextFontFamily: string;
+    /** @type {number} */
+    labelTextFontSize: number;
+    /**
+     * Used to avoid label/colormap clashes
+     * @type {number}
+     */
+    labelXOffset: number;
+    /** @type {import('pixi.js').Text} */
+    labelText: import("pixi.js").Text;
+    /** @type {import('pixi.js').Text} */
+    errorText: import("pixi.js").Text;
+    /** @type {boolean} */
+    flipText: boolean;
+    /** @type {import('./types').TilesetInfo | undefined} */
+    tilesetInfo: import("./types").TilesetInfo | undefined;
+    /** @type {{ [key: string]: string }} */
+    errorTexts: {
+        [key: string]: string;
+    };
+    setLabelText(): void;
+    /**
+     * @param {[number, number]} position
+     * @param {[number, number]} dimensions
+     */
+    setMask(position: [number, number], dimensions: [number, number]): void;
+    setForeground(): void;
+    /**
+     * Draw a border around each track.
+     */
+    drawBorder(): void;
+    /** Set an error for this track.
+     *
+     * The error can be associated with a source so that multiple
+     * components within the track can set their own independent errors
+     * that will be displayed to the user without overlapping.
+     *
+     * @param {string} error The error text
+     * @param {string} source The source of the error
+     */
+    setError(error: string, source: string): void;
+    drawError(): void;
+    drawBackground(): void;
+    /**
+     * Determine the label color based on the number of options.
+     *
+     * @return {string} The color to use for the label.
+     */
+    getLabelColor(): string;
+    getName(): string;
+    drawLabel(): void;
+    /**
+     * Export an SVG representation of this track
+     *
+     * @returns {[HTMLElement, HTMLElement]} 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(): [HTMLElement, HTMLElement];
+    /**
+     * @returns {number}
+     */
+    calculateZoomLevel(): number;
+}
+import Track from './Track';

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

@@ -0,0 +1,25 @@
+export default PlotTypeChooser;
+declare class PlotTypeChooser extends React.Component<any, any, any> {
+    constructor(props: any);
+    DATATYPE_TO_TRACK_TYPE: {
+        none: any[];
+    };
+    AVAILABLE_TRACK_TYPES: any[];
+    state: {
+        selectedPlotType: any;
+    };
+    UNSAFE_componentWillReceiveProps(newProps: any): void;
+    handlePlotTypeSelected(key: any): void;
+    render(): React.JSX.Element;
+}
+declare namespace PlotTypeChooser {
+    namespace propTypes {
+        let allTracksSameDatatype: PropTypes.Requireable<boolean>;
+        let datatypes: PropTypes.Requireable<any[]>;
+        let orientation: PropTypes.Requireable<string>;
+        let onPlotTypeSelected: PropTypes.Requireable<(...args: any[]) => any>;
+        let position: PropTypes.Requireable<string>;
+    }
+}
+import React from 'react';
+import PropTypes from 'prop-types';

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

@@ -0,0 +1,28 @@
+export default PopupMenu;
+declare class PopupMenu extends React.Component<any, any, any> {
+    constructor(props: any);
+    clickHandlerBound: (event: any) => void;
+    contextMenuHandlerBound: (event: any) => void;
+    resizeHandlerBound: () => void;
+    componentDidMount(): void;
+    popup: HTMLDivElement | undefined;
+    componentDidUpdate(): void;
+    componentWillUnmount(): void;
+    _renderLayer(): void;
+    clickHandler(event: any): void;
+    contextMenuHandler(event: any): void;
+    resizeHandler(): void;
+    render(): React.JSX.Element;
+}
+declare namespace PopupMenu {
+    namespace defaultProps {
+        export { intoTheVoid as onMenuClosed };
+    }
+    namespace propTypes {
+        let children: PropTypes.Validator<NonNullable<PropTypes.ReactNodeLike>>;
+        let onMenuClosed: PropTypes.Requireable<(...args: any[]) => any>;
+    }
+}
+import React from 'react';
+import intoTheVoid from './utils/into-the-void';
+import PropTypes from 'prop-types';

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

@@ -0,0 +1,9 @@
+export default RasterTilesTrack;
+/**
+ * A track that must pull remote tiles
+ */
+declare class RasterTilesTrack extends OSMTilesTrack {
+    style: any;
+    getTileUrl(tileZxy: any): any;
+}
+import OSMTilesTrack from './OSMTilesTrack';

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

@@ -0,0 +1,2 @@
+export default RuleMixin;
+declare const RuleMixin: Function;

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

@@ -0,0 +1,15 @@
+export default SVGTrack;
+declare class SVGTrack extends Track<any> {
+    constructor(context: any, options: any);
+    /**
+     * Create a new SVG track. It will contain a g element
+     * that maintains all of its element.
+     */
+    gMain: import("d3-selection").Selection<SVGGElement, any, null, undefined>;
+    clipUid: string;
+    clipRect: import("d3-selection").Selection<SVGRectElement, any, null, undefined>;
+    setPosition(newPosition: any): void;
+    setDimensions(newDimensions: any): void;
+    draw(): this;
+}
+import Track from './Track';

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

@@ -0,0 +1,13 @@
+export default SearchField;
+declare class SearchField {
+    constructor(chromInfo: any);
+    chromInfo: any;
+    chromInfoBisector: (array: ArrayLike<any>, x: any, lo?: number, hi?: number) => number;
+    scalesToPositionText(xScale: any, yScale: any, twoD?: boolean): string;
+    convertNumberNotation(numStr: any): any;
+    parsePosition(positionText: any, prevChr?: null): any[];
+    matchRangesToLarger(range1: any, range2: any): any[];
+    getSearchRange(term: any): any[] | null;
+    parseOffset(offsetText: any): number[][];
+    searchPosition(text: any): any[];
+}

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

@@ -0,0 +1,2 @@
+export function getAllTracksAndSubtracks(tracks: array): any[];
+export function getSeriesItems(tracks: object, onItemMouseEnter: func, onItemMouseLeave: func, onItemClick: func): array;

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

@@ -0,0 +1,51 @@
+/**
+ * @typedef MenuItem
+ * @property {string} name
+ * @property {string} [value]
+ * @property {Record<string, unknown>} [children]
+ * @property {() => void} [handler]
+ */
+export default class SeriesListMenu extends ContextMenuContainer {
+    /**
+     * @param {unknown} position
+     * @param {unknown} bbox
+     * @param {{ type: string, options: Record<string, unknown>, uid: string, }} track
+     */
+    getConfigureSeriesMenu(position: unknown, bbox: unknown, track: {
+        type: string;
+        options: Record<string, unknown>;
+        uid: string;
+    }): React.JSX.Element | null;
+    /**
+     * Return a list of track types that can be used
+     * with the data for this track
+     *
+     * @param {Object} position The position where to draw ths menu (e.g. {left: 42, top: 88})
+     *
+     * @param {Object} bbox
+     *  The bounding box of the parent menu, used to determine whether
+     *  to draw the child menu on the left or the right
+     *
+     * @param {{ uid: string, type: string, datatype: string }} track The track definition for this series (as in the viewconf)
+     */
+    getTrackTypeItems(position: Object, bbox: Object, track: {
+        uid: string;
+        type: string;
+        datatype: string;
+    }): React.JSX.Element;
+    getSubmenu(): React.JSX.Element | null;
+    getDivideByMenuItem(): React.JSX.Element;
+    componentWillUnmount(): void;
+}
+export type ContextMenuHandler = {
+    label: string;
+    onClick: (evt: unknown, onTrackOptionsChanged: (options: Record<string, unknown>) => void) => void;
+};
+export type MenuItem = {
+    name: string;
+    value?: string | undefined;
+    children?: Record<string, unknown> | undefined;
+    handler?: (() => void) | undefined;
+};
+import ContextMenuContainer from './ContextMenuContainer';
+import React from 'react';

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

@@ -0,0 +1,2 @@
+export default SeriesListSubmenuMixin;
+declare const SeriesListSubmenuMixin: Function;

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

@@ -0,0 +1,25 @@
+export default SketchInlinePicker;
+declare class SketchInlinePicker extends React.Component<any, any, any> {
+    constructor(props: any);
+    state: {
+        displayColorPicker: boolean;
+        color: {
+            r: number;
+            g: number;
+            b: number;
+            a: number;
+        };
+    };
+    handleClick(): void;
+    handleClose(): void;
+    handleChange(color: any): void;
+    render(): React.JSX.Element;
+}
+declare namespace SketchInlinePicker {
+    namespace propTypes {
+        let color: PropTypes.Requireable<string>;
+        let onChange: PropTypes.Requireable<(...args: any[]) => any>;
+    }
+}
+import React from 'react';
+import PropTypes from 'prop-types';

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

@@ -0,0 +1,22 @@
+export default SortableList;
+declare const SortableList: React.ComponentClass<{
+    className: any;
+    items: any;
+    itemClass: any;
+    itemControlAlignLeft: any;
+    sortingIndex: any;
+    useDragHandle: any;
+    sortableHandlers: any;
+    height: any;
+    width: any;
+    onCloseTrack: any;
+    onCloseTrackMenuOpened: any;
+    onConfigTrackMenuOpened: any;
+    onAddSeries: any;
+    handleConfigTrack: any;
+    editable: any;
+    itemReactClass: any;
+    handleResizeTrack: any;
+    resizeHandles: any;
+} & import("react-sortable-hoc").SortableContainerProps, any>;
+import React from 'react';

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

@@ -0,0 +1,22 @@
+export default SquareMarkersTrack;
+declare class SquareMarkersTrack extends TiledPixiTrack<any> {
+    constructor(context: any, options: any);
+    drawnRects: Set<any>;
+    tileToLocalId(tile: any): string;
+    /**
+     * The tile identifier used on the server
+     */
+    tileToRemoteId(tile: any): string;
+    localToRemoteId(remoteId: any): any;
+    setVisibleTiles(tilePositions: any): void;
+    calculateVisibleTiles(mirrorTiles?: boolean): void;
+    zoomLevel: number | undefined;
+    xTiles: number[] | undefined;
+    yTiles: number[] | undefined;
+    initTile(tile: any): void;
+    destroyTile(tile: any, graphics: any): void;
+    drawTile(tile: any): void;
+    setPosition(newPosition: any): void;
+    zoomed(newXScale: any, newYScale: any): void;
+}
+import TiledPixiTrack from './TiledPixiTrack';

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

@@ -0,0 +1,60 @@
+export default Tiled1DPixiTrack;
+declare class Tiled1DPixiTrack extends TiledPixiTrack<any> {
+    constructor(context: any, options: any);
+    onMouseMoveZoom: any;
+    isValueScaleLocked: any;
+    getLockGroupExtrema: any;
+    initTile(tile: any): void;
+    tileToLocalId(tile: any): string;
+    tileToRemoteId(tile: any): string;
+    relevantScale(): null;
+    setVisibleTiles(tilePositions: any): void;
+    calculateVisibleTiles(): void;
+    zoomLevel: number | undefined;
+    getTilePosAndDimensions(zoomLevel: any, tilePos: any, binsPerTileIn: any): {
+        tileX: number;
+        tileY: number;
+        tileWidth: number;
+        tileHeight: number;
+    };
+    updateTile(tile: any): void;
+    scheduleRerender(): void;
+    handleRerender(): void;
+    getIndicesOfVisibleDataInTile(tile: any): number[] | null[];
+    /**
+     * Returns the minimum in the visible area (not visible tiles)
+     */
+    minVisibleValue(ignoreFixedScale?: boolean): number;
+    /**
+     * Returns the maximum in the visible area (not visible tiles)
+     */
+    maxVisibleValue(ignoreFixedScale?: boolean): number;
+    /**
+     * Return an aggregated visible value. For example, the minimum or maximum.
+     *
+     * @description
+     *   The difference to `minVisibleValueInTiles`
+     *   is that the truly visible min or max value is returned instead of the
+     *   min or max value of the tile. The latter is not necessarily visible.
+     *
+     *   For 'min' and 'max' this is identical to minVisibleValue and maxVisibleValue
+     *
+     * @param  {string} aggregator Aggregation method. Currently supports `min`
+     *   and `max` only.
+     * @return {number} The aggregated value.
+     */
+    getAggregatedVisibleValue(aggregator?: string): number;
+    /**
+     * Get the data value at a relative pixel position
+     * @param   {number}  relPos  Relative pixel position, where 0 indicates the
+     *   start of the track
+     * @return  {number}  The data value at `relPos`
+     */
+    getDataAtPos(relPos: number): number;
+    mouseMoveHandler({ x, y }?: {}): void;
+    mouseX: any;
+    mouseY: any;
+    mouseMoveZoomHandler(): void;
+    zoomed(...args: any[]): void;
+}
+import TiledPixiTrack from './TiledPixiTrack';