higlass 1.13.5 → 2.0.0

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

@@ -0,0 +1,65 @@
+export class TilesetFinder extends React.Component<any, any, any> {
+    constructor(props: any);
+    localTracks: {
+        type: string;
+        datatype: string | string[];
+        orientation: string;
+        aliases?: string[] | undefined;
+        local?: boolean | undefined;
+        rotatable?: boolean | undefined;
+        hidden?: boolean | undefined;
+        name?: string | undefined;
+        thumbnail?: (HTMLElement | null | string) | undefined;
+        availableOptions?: string[] | undefined;
+        defaultOptions?: Record<string, unknown> | undefined;
+        exportable?: boolean | undefined;
+        defaultOptionsByTheme?: Record<string, Record<string, unknown>> | undefined;
+        minHeight?: number | undefined;
+        defaultHeight?: number | undefined;
+        defaultWidth?: number | undefined;
+        chromInfoPath?: string | undefined;
+        projection?: boolean | undefined;
+        optionsInfo?: Record<string, unknown> | undefined;
+    }[];
+    augmentedTracksInfo: import("./configs/tracks-info").TrackInfo[];
+    mounted: boolean;
+    state: {
+        selectedUuid: string[] | null;
+        options: any;
+        filter: string;
+        checked: never[];
+        expanded: never[];
+    };
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    prepareNewEntries(sourceServer: any, newEntries: any, existingOptions: any): any;
+    serverUidKey(server: any, uid: any): string;
+    requestTilesetLists(): void;
+    /**
+     * Double clicked on an element. Should be selected
+     * and this window will be closed.
+     */
+    handleOptionDoubleClick(x: any): void;
+    handleSelectedOptions(selectedOptions: any): void;
+    handleSelect(): void;
+    handleSearchChange(): void;
+    partitionByGroup(datasetsDict: any, filter: any): any[];
+    handleChecked(checked: any): void;
+    handleExpanded(expanded: any): void;
+    render(): React.JSX.Element;
+    searchBox: HTMLInputElement | null | undefined;
+}
+export namespace TilesetFinder {
+    namespace propTypes {
+        let datatype: PropTypes.Requireable<string>;
+        let orientation: PropTypes.Requireable<string>;
+        let onDoubleClick: PropTypes.Requireable<(...args: any[]) => any>;
+        let pubSub: PropTypes.Validator<object>;
+        let selectedTilesetChanged: PropTypes.Requireable<(...args: any[]) => any>;
+        let trackSourceServers: PropTypes.Requireable<any[]>;
+    }
+}
+declare const _default: typeof TilesetFinder;
+export default _default;
+import React from 'react';
+import PropTypes from 'prop-types';

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

@@ -0,0 +1,9 @@
+export default TopAxisTrack;
+declare class TopAxisTrack extends SVGTrack {
+    axis: import("d3-axis").Axis<import("d3-scale").NumberValue>;
+    gAxis: import("d3-selection").Selection<SVGGElement, any, null, undefined>;
+    tilesetInfo: boolean;
+    draw(): this;
+    zoomed(newXScale: any, newYScale: any): void;
+}
+import SVGTrack from './SVGTrack';

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

@@ -0,0 +1,196 @@
+export default Track;
+export type TrackContext = {
+    /**
+     * - The track ID.
+     */
+    id: string;
+    /**
+     * - The pub-sub channel.
+     */
+    pubSub?: (import("pub-sub-es").PubSub & {
+        __fake__?: boolean;
+    }) | undefined;
+    /**
+     * - A function that returns the current theme.
+     */
+    getTheme?: (() => import("./types").Theme) | undefined;
+};
+export type ExtendedTrackContext<T> = T & TrackContext;
+/**
+ * @typedef TrackContext
+ * @property {string} id - The track ID.
+ * @property {import('pub-sub-es').PubSub & { __fake__?: boolean }} [pubSub] - The pub-sub channel.
+ * @property {() => import('./types').Theme} [getTheme] - A function that returns the current theme.
+ */
+/**
+ * @template T
+ * @typedef {T & TrackContext} ExtendedTrackContext
+ */
+/** @template Options */
+declare class Track<Options> {
+    /**
+     * @param {TrackContext} context
+     * @param {Options} options
+     */
+    constructor(context: TrackContext, options: Options);
+    context: TrackContext;
+    /** @type {import('pub-sub-es').PubSub} */
+    pubSub: import("pub-sub-es").PubSub;
+    /** @type {string} */
+    id: string;
+    /** @type {import('./types').Scale} */
+    _xScale: import("./types").Scale;
+    /** @type {import('./types').Scale} */
+    _yScale: import("./types").Scale;
+    /** @type {import('./types').Scale} */
+    _refXScale: import("./types").Scale;
+    /** @type {import('./types').Scale} */
+    _refYScale: import("./types").Scale;
+    /** @type {[number, number]} */
+    position: [number, number];
+    /** @type {[number, number]} */
+    dimensions: [number, number];
+    /** @type {Options} */
+    options: Options;
+    /** @type {Array<import('pub-sub-es').Subscription>} */
+    pubSubs: Array<import("pub-sub-es").Subscription>;
+    /** @type {() => (import('./types').Theme | undefined)} */
+    getTheme: () => (import("./types").Theme | undefined);
+    isLeftModified: boolean;
+    /**
+     * Check if a 2d location (x, y) is within the bounds of this track.
+     *
+     * @param {number} x - X position to be tested.
+     * @param {number} y - Y position to be tested.
+     * @return {boolean}  If `true` location is within the track.
+     */
+    isWithin(x: number, y: number): boolean;
+    /**
+     * Get a property from the track.
+     * @template {keyof this} T
+     * @param {T} prop - The property to get.
+     * @return {() => this[T]}
+     */
+    getProp<T extends keyof this>(prop: T): () => this[T];
+    getData(): void;
+    /**
+     * Capture click events. x and y are relative to the track position
+     * @template T
+     * @param {number} x - X position of the click event.
+     * @param {number} y - Y position of the click event.
+     * @param {T} evt - The event.
+     * @return {{ type: 'generic', event: T, payload: null }}
+     */
+    click<T>(x: number, y: number, evt: T): {
+        type: "generic";
+        event: T;
+        payload: null;
+    };
+    /** There was a click event outside the track * */
+    clickOutside(): void;
+    /** @returns {[number, number]} */
+    getDimensions(): [number, number];
+    /** @param {[number, number]} newDimensions */
+    setDimensions(newDimensions: [number, number]): void;
+    /**
+     * @overload
+     * @return {import('./types').Scale}
+     */
+    refXScale(): import("./types").Scale;
+    /**
+     * @overload
+     * @param {import('./types').Scale} scale
+     * @return {this}
+     */
+    refXScale(scale: import("./types").Scale): this;
+    /**
+     * @overload
+     * @return {import('./types').Scale}
+     */
+    refYScale(): import("./types").Scale;
+    /**
+     * @overload
+     * @param {import('./types').Scale} scale
+     * @return {this}
+     */
+    refYScale(scale: import("./types").Scale): this;
+    /**
+     * @overload
+     * @return {import('./types').Scale}
+     */
+    xScale(): import("./types").Scale;
+    /**
+     * @overload
+     * @param {import('./types').Scale} scale
+     * @return {this}
+     */
+    xScale(scale: import("./types").Scale): this;
+    /**
+     * @overload
+     * @return {import('./types').Scale}
+     */
+    yScale(): import("./types").Scale;
+    /**
+     * @overload
+     * @param {import('./types').Scale} scale
+     * @return {this}
+     */
+    yScale(scale: import("./types").Scale): this;
+    /**
+     * @param {import('./types').Scale} newXScale
+     * @param {import('./types').Scale} newYScale
+     * @returns {void}
+     */
+    zoomed(newXScale: import("./types").Scale, newYScale: import("./types").Scale): void;
+    /**
+     * @param {import('./types').Scale} refXScale
+     * @param {import('./types').Scale} refYScale
+     * @returns {void}
+     */
+    refScalesChanged(refXScale: import("./types").Scale, refYScale: import("./types").Scale): void;
+    /** @returns {void} */
+    draw(): void;
+    /** @returns {[number, number]} */
+    getPosition(): [number, number];
+    /**
+     * @param {[number, number]} newPosition
+     * @returns {void}
+     */
+    setPosition(newPosition: [number, number]): void;
+    /**
+     * A blank handler for MouseMove / Zoom events. Should be overriden
+     * by individual tracks to provide
+     *
+     * @param {{}} evt
+     * @returns {void}
+     */
+    defaultMouseMoveHandler(evt: {}): void;
+    /** @returns {void} */
+    remove(): void;
+    /**
+     * @param {Options} options
+     * @returns {void}
+     */
+    rerender(options: Options): void;
+    /**
+     * This function is for seeing whether this track should respond
+     * to events at this mouse position. The difference to `isWithin()` is that it
+     * can be overwritten if a track is inactive for example.
+     *
+     * @param {number} x - X position to be tested.
+     * @param {number} y - Y position to be tested.
+     * @returns {boolean}
+     */
+    respondsToPosition(x: number, y: number): boolean;
+    /**
+     * @param {number} trackY
+     * @param {number} kMultiplier
+     * @returns {void}
+     */
+    zoomedY(trackY: number, kMultiplier: number): void;
+    /**
+     * @param {number} dY
+     * @returns {void}
+     */
+    movedY(dY: number): void;
+}

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

@@ -0,0 +1,26 @@
+export default TrackArea;
+declare class TrackArea extends React.Component<any, any, any> {
+    constructor(props: any);
+    state: {
+        controlsVisible: boolean;
+    };
+    shouldComponentUpdate(): boolean;
+    handleMouseEnter(): void;
+    handleMouseLeave(): void;
+    handleMouseMove(): void;
+    getControls(): React.JSX.Element;
+    imgConfig: SVGSVGElement | null | undefined;
+    imgAdd: SVGSVGElement | null | undefined;
+    imgClose: SVGSVGElement | null | undefined;
+}
+declare namespace TrackArea {
+    namespace propTypes {
+        let configMenuOpen: PropTypes.Requireable<boolean>;
+        let onConfigTrackMenuOpened: PropTypes.Requireable<(...args: any[]) => any>;
+        let onCloseTrackMenuOpened: PropTypes.Requireable<(...args: any[]) => any>;
+        let onAddSeries: PropTypes.Requireable<(...args: any[]) => any>;
+        let uid: PropTypes.Requireable<string>;
+    }
+}
+import React from 'react';
+import PropTypes from 'prop-types';

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

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