higlass 1.13.6 → 2.0.1

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

@@ -0,0 +1,199 @@
+import type * as configs from './configs';
+import type { ChromsizeRow } from './utils/parse-chromsizes-rows';
+export type Theme = typeof configs.THEME_DARK | typeof configs.THEME_LIGHT;
+export type SizeMode = typeof configs.SIZE_MODE_DEFAULT | typeof configs.SIZE_MODE_BOUNDED | typeof configs.SIZE_MODE_OVERFLOW | typeof configs.SIZE_MODE_BOUNDED_OVERFLOW | typeof configs.SIZE_MODE_SCROLL;
+export type HiGlassViewConfig = Record<string, unknown>;
+/** Additional options for how the {@link HiGlassComponent} is drawn and behaves */
+export interface HiGlassOptions {
+    /** An auth token to be included with every tile request. */
+    authToken?: string;
+    /**
+     * Whether the component should be sized to fit within the enclosing div.
+     *
+     * If `false`, the component will grow as needed to fit the tracks within it.
+     */
+    bounded?: boolean;
+    /**
+     * Whether the layout be changed.
+     *
+     * If `false`, the view headers will be hidden. Overrides the `editable` value in the viewconf if specified.
+     */
+    editable?: boolean;
+    /** A set of default options that will be used for newly added tracks. */
+    defaultTrackOptions?: {
+        /** Options for all tracks types. */
+        all?: Record<string, unknown>;
+        /** Options for specific tracks types. */
+        trackSpecific?: Record<string, Record<string, unknown>>;
+    };
+    viewMarginTop?: number;
+    viewMarginBottom?: number;
+    viewMarginLeft?: number;
+    viewMarginRight?: number;
+    viewPaddingTop?: number;
+    viewPaddingBottom?: number;
+    viewPaddingLeft?: number;
+    viewPaddingRight?: number;
+    theme?: 'dark' | 'light';
+    isDarkTheme?: boolean;
+    moustTool?: 'select' | 'track-select';
+    pluginTracks?: Record<string, unknown>;
+    pluginDataFetchers?: Record<string, unknown>;
+    pixelPreciseMarginPadding?: boolean;
+    sizeMode?: SizeMode;
+    renderer?: 'canvas';
+    onViewConfLoaded?: () => void;
+    cheatCodesEnabled?: boolean;
+    rangeSelectionOnAlt?: boolean;
+    tracksEditable?: boolean;
+    zoomFixed?: boolean;
+    containerPaddingX?: number;
+    containerPaddingY?: number;
+    broadcastMousePositionGlobally?: boolean;
+    showGlobalMousePosition?: boolean;
+    globalMousePosition?: boolean;
+}
+export type Scale = import('d3-scale').ScaleContinuousNumeric<number, number>;
+export type TrackPosition = typeof import('./configs/primitives').TRACK_LOCATIONS[number];
+export type ChromInfo<Name extends string = string> = {
+    cumPositions: {
+        id?: number;
+        pos: number;
+        chr: Name;
+    }[];
+    chrPositions: Record<Name, {
+        pos: number;
+    }>;
+    chromLengths: Record<Name, number>;
+    totalLength: number;
+};
+export type UnknownTrackConfig = {
+    type: string;
+    uid: string;
+    server: string;
+    tilesetUid: string;
+    options?: Record<string, unknown>;
+    position?: TrackPosition;
+    data?: Record<string, unknown>;
+    coordSystem?: unknown;
+    height?: number;
+    width?: number;
+    x?: number;
+    y?: number;
+    chromInfoPath?: string;
+    projectionXDomain?: [number, number];
+    projectionYDomain?: [number, number];
+    registerViewportChanged?: unknown;
+    removeViewportChanged?: unknown;
+    setDomainsCallback?: unknown;
+};
+export type CombinedTrackConfig = {
+    type: 'combined';
+    contents: Array<UnknownTrackConfig>;
+    uid: string;
+    server?: string;
+    height?: number;
+    width?: number;
+    tilesetUid?: string;
+    options?: Record<string, unknown>;
+    position?: TrackPosition;
+    data?: Record<string, unknown>;
+    coordSystem?: unknown;
+    x?: number;
+    y?: number;
+    chromInfoPath?: string;
+    projectionXDomain?: [number, number];
+    projectionYDomain?: [number, number];
+    registerViewportChanged?: unknown;
+    removeViewportChanged?: unknown;
+    setDomainsCallback?: unknown;
+};
+export type TrackConfig = UnknownTrackConfig | CombinedTrackConfig;
+export type TrackVisitor = (track: TrackConfig, position: null | TrackPosition) => void;
+type ZoomedFunction = (xScale: Scale, yScale: Scale, k?: number, x?: number, y?: number, xPosition?: number, yPosition?: number) => void;
+export interface TrackObject {
+    draw(): void;
+    rerender(options: unknown): void;
+    delayDrawing: boolean;
+    flipText?: boolean;
+    originalTrack?: TrackObject;
+    childTracks?: TrackObject[];
+    createdTracks: Record<string, TrackObject>;
+    refScalesChanged(x: Scale, y: Scale): void;
+    position: [number, number];
+    dimensions: [number, number];
+    updateContents(contents: TrackConfig[], x: unknown): TrackObject;
+    zoomed: ZoomedFunction;
+    setPosition(position: [number, number]): void;
+    setDimensions(dimensions: [number, number]): void;
+    remove(): void;
+    movedY(extent: number): void;
+    zoomedY(yPosition: number, wheelDelta: number): void;
+    fetching?: Set<unknown>;
+    tilesetInfo?: TilesetInfo;
+    chromInfo?: unknown;
+}
+/** Minimum information describing a tileset. */
+export type TilesetInfoShared = {
+    name: string;
+    min_pos: number[];
+    max_pos: number[];
+    max_zoom: number;
+    coordSystem?: string;
+    tile_size?: number;
+    max_tile_width?: number;
+    transforms?: {
+        name: string;
+        value: string;
+    }[];
+    chromsizes?: ArrayLike<ChromsizeRow>;
+    error?: string;
+};
+export type LegacyTilesetInfo = TilesetInfoShared & {
+    max_width: number;
+    bins_per_dimension?: number;
+};
+export type ResolutionsTilesetInfo = TilesetInfoShared & {
+    resolutions: number[];
+};
+export type TilesetInfo = LegacyTilesetInfo | ResolutionsTilesetInfo;
+export type DataConfig = {
+    server?: string;
+    url?: string;
+    filetype?: string;
+    coordSystem?: string;
+    children?: DataConfig[];
+    options?: Record<string, any>;
+    type?: string;
+    slicePos?: number;
+};
+export type HandleTilesetInfoFinished = (info: TilesetInfo | null | {
+    error: string;
+}, tilesetUid?: string) => void;
+export interface AbstractDataFetcher<TileType, DataConfig> {
+    tilesetInfo(callback?: HandleTilesetInfoFinished): Promise<TilesetInfo | undefined>;
+    fetchTilesDebounced(receivedTiles: (tiles: Record<string, TileType>) => void, tileIds: string[]): Promise<Record<string, TileType>>;
+    dataConfig: DataConfig;
+}
+export type TilesRequest = {
+    id: string;
+    tileIds: Array<string>;
+    server: string;
+    options?: Record<string, any>;
+};
+export type TilesetInfoRequest = {
+    server: string;
+    tilesetUid: string;
+};
+export type RegisterTilesetRequest = {
+    server: string;
+    url: string;
+    filetype: string;
+    coordSystem?: string;
+};
+export type TileSource<T> = {
+    fetchTiles: (request: TilesRequest) => Promise<Record<string, T>>;
+    fetchTilesetInfo: (request: TilesetInfoRequest) => Promise<Record<string, TilesetInfo>>;
+    registerTileset: (request: RegisterTilesetRequest) => Promise<Response>;
+};
+export {};

package/dist/app/scripts/utils/DenseDataExtrema1D.d.ts

@@ -0,0 +1,88 @@
+export default DenseDataExtrema1D;
+/**
+ * @template {ArrayLike<number>} [T=ArrayLike<number>]
+ */
+declare class DenseDataExtrema1D<T extends ArrayLike<number> = ArrayLike<number>> {
+    /**
+     * This module efficiently computes extrema of arbitrary subsets of a given data array.
+     * The array is subdivided into 'numSubsets' subsets where extrema are precomputed.
+     * These values are used to compute extrema given arbitrary start and end indices via
+     * the getMinNonZeroInSubset and getMaxNonZeroInSubset methods.
+     * @param {T}  data
+     */
+    constructor(data: T);
+    /** @type {number} */
+    epsilon: number;
+    /** @type {T} */
+    data: T;
+    /** @type {number} */
+    tileSize: number;
+    /** @type {number} */
+    paddedTileSize: number;
+    /** @type {number} */
+    numSubsets: number;
+    /** @type {number} */
+    subsetSize: number;
+    subsetMinimums: number[];
+    subsetMaximums: number[];
+    minNonZeroInTile: number;
+    maxNonZeroInTile: number;
+    /**
+     * Computes the non-zero minimum in a subset using precomputed values,
+     * if possible. data[end] is not considered.
+     *
+     * @param {[start: number, end: number]} indexBounds
+     * @return {number} non-zero minium of the subset
+     */
+    getMinNonZeroInSubset(indexBounds: [start: number, end: number]): number;
+    /**
+     * Computes the non-zero maximum in a subset using precomputed values, if possible
+     *
+     * @param {[start: number, end: number]}  indexBounds
+     * @return {number} non-zero maxium of the subset
+     */
+    getMaxNonZeroInSubset(indexBounds: [start: number, end: number]): number;
+    /**
+     * Precomputes non-zero minimums of subsets of the given data vector
+     *
+     * @returns {Array<number>} - Minimums of the regularly subdivided data vector
+     */
+    computeSubsetNonZeroMinimums(): Array<number>;
+    /**
+     * Precomputes non-zero maximums of subsets of the given data vector
+     * @return {Array<number>} Maximums of the regularly subdivided data vector
+     */
+    computeSubsetNonZeroMaximums(): Array<number>;
+    /**
+     * Computes the non-zero minimum in the entire data array using precomputed values
+     *
+     * @return {number} Non-zeros maximum of the data
+     */
+    getMinNonZeroInTile(): number;
+    /**
+     * Computes the non-zero maximum in the entire data array using precomputed values
+     *
+     * @return {number} Non-zeros maximum of the data
+     */
+    getMaxNonZeroInTile(): number;
+    /**
+     * Calculate the minimum non-zero value in the data from start
+     * to end. No precomputations are used to compute the min.
+     *
+     * @param {ArrayLike<number>} data
+     * @param {number} start
+     * @param {number} end
+     * @return {number} non-zero min in subset
+     */
+    minNonZero(data: ArrayLike<number>, start: number, end: number): number;
+    /**
+     * Calculate the maximum non-zero value in the data from start
+     * to end. No precomputations are used to compute the max.
+     *
+     * @param {ArrayLike<number>} data
+     * @param {number} start
+     * @param {number} end
+     * @return {number} non-zero max in subset
+     */
+    maxNonZero(data: ArrayLike<number>, start: number, end: number): number;
+}

package/dist/app/scripts/utils/DenseDataExtrema2D.d.ts

@@ -0,0 +1,97 @@
+export default DenseDataExtrema2D;
+export type View2D = {
+    get: (i: number, j: number) => number;
+    set: (i: number, j: number, v: number) => void;
+};
+/**
+ * @typedef View2D
+ * @property {(i: number, j: number) => number} get
+ * @property {(i: number, j: number, v: number) => void} set
+ */
+declare class DenseDataExtrema2D {
+    /**
+     * This module efficiently computes extrema of subsets of a given data matrix.
+     * The matrix is subdivided into 'numSubsets' subsets where extrema are precomputed.
+     * These values are used to efficiently approximate extrema given arbitrary subsets.
+     * Larger values of 'numSubsets' lead to more accurate approximations (more expensive).
+     *
+     * @param {ArrayLike<number>} data array of quadratic length
+     */
+    constructor(data: ArrayLike<number>);
+    /** @type {number} */
+    epsilon: number;
+    /** @type {number} */
+    tileSize: number;
+    /** @type {number} */
+    numSubsets: number;
+    /** @type {number} */
+    subsetSize: number;
+    /** @type {View2D} */
+    subsetMinimums: View2D;
+    /** @type {View2D} */
+    subsetMaximums: View2D;
+    /** @type {number} */
+    minNonZeroInTile: number;
+    /** @type {number} */
+    maxNonZeroInTile: number;
+    /**
+     * Computes an approximation of the non-zero minimum in a subset
+     *
+     * @param {[startX: number, startY: number, endX: number, endY: number]} indexBounds
+     * @return {number} Non-zero minium of the subset
+     */
+    getMinNonZeroInSubset(indexBounds: [startX: number, startY: number, endX: number, endY: number]): number;
+    /**
+     * Computes an approximation of the non-zero maximum in a subset
+     *
+     * @param {[startX: number, startY: number, endX: number, endY: number]} indexBounds
+     * @return {number} Non-zero maxium of the subset
+     */
+    getMaxNonZeroInSubset(indexBounds: [startX: number, startY: number, endX: number, endY: number]): number;
+    /**
+     * Precomputes non-zero minimums of subsets of a given matrix
+     * @param {View2D} dataMatrix
+     * @return {View2D} Matrix containing minimums of the dataMatrix after subdivision using a regular grid
+     */
+    computeSubsetNonZeroMinimums(dataMatrix: View2D): View2D;
+    /**
+     * Precomputes non-zero maximums of subsets of a given matrix
+     *
+     * @param {View2D} dataMatrix
+     * @return {View2D} Matrix containing maximums of the dataMatrix after subdivision using a regular grid
+     */
+    computeSubsetNonZeroMaximums(dataMatrix: View2D): View2D;
+    /**
+     * Computes the non-zero minimum of a subset of a matrix (ndarray)
+     * @param {View2D} arr
+     * @param {number} rowOffset - Starting row of the subset
+     * @param {number} colOffset - Starting column of the subset
+     * @param {number} width - Width (num columns) of the subset
+     * @param {number} height - Height (num rows) of the subset
+     * @return {number} Non-zeros - minimum of the subset
+     */
+    getMinNonZeroInNdarraySubset(arr: View2D, rowOffset: number, colOffset: number, width: number, height: number): number;
+    /**
+     * Computes the non-zero maximum of a subset of a matrix (ndarray)
+     * @param {View2D} arr
+     * @param {number} rowOffset - Starting row of the subset
+     * @param {number} colOffset - Starting column of the subset
+     * @param {number} width - Width (num columns) of the subset
+     * @param {number} height - Height (num rows) of the subset
+     * @return {number} Non-zeros maximum of the subset
+     */
+    getMaxNonZeroInNdarraySubset(arr: View2D, rowOffset: number, colOffset: number, width: number, height: number): number;
+    mirrorPrecomputedExtrema(): void;
+    /**
+     * Computes the non-zero minimum in the entire data array using precomputed values
+     *
+     * @return {number} Non-zeros minimum of the data
+     */
+    getMinNonZeroInTile(): number;
+    /**
+     * Computes the non-zero maximum in the entire data array using precomputed values
+     *
+     * @return {number} Non-zeros maximum of the data
+     */
+    getMaxNonZeroInTile(): number;
+}

package/dist/app/scripts/utils/LruCache.d.ts

@@ -0,0 +1,44 @@
+export default LruCache;
+/**
+ * A doubly linked list-based Least Recently Used (LRU) cache. Will keep most
+ * recently used items while discarding least recently used items when its limit
+ * is reached.
+ *
+ * Licensed under MIT. Copyright (c) 2010 Rasmus Andersson <http://hunch.se/>
+ * See README.md for details.
+ *
+ * Illustration of the design:
+ *
+ *       entry             entry             entry             entry
+ *       ______            ______            ______            ______
+ *      | head |.newer => |      |.newer => |      |.newer => | tail |
+ *      |  A   |          |  B   |          |  C   |          |  D   |
+ *      |______| <= older.|______| <= older.|______| <= older.|______|
+ *
+ *  removed  <--  <--  <--  <--  <--  <--  <--  <--  <--  <--  <--  added
+ */
+declare function LruCache(limit: any): void;
+declare class LruCache {
+    /**
+     * A doubly linked list-based Least Recently Used (LRU) cache. Will keep most
+     * recently used items while discarding least recently used items when its limit
+     * is reached.
+     *
+     * Licensed under MIT. Copyright (c) 2010 Rasmus Andersson <http://hunch.se/>
+     * See README.md for details.
+     *
+     * Illustration of the design:
+     *
+     *       entry             entry             entry             entry
+     *       ______            ______            ______            ______
+     *      | head |.newer => |      |.newer => |      |.newer => | tail |
+     *      |  A   |          |  B   |          |  C   |          |  D   |
+     *      |______| <= older.|______| <= older.|______| <= older.|______|
+     *
+     *  removed  <--  <--  <--  <--  <--  <--  <--  <--  <--  <--  <--  added
+     */
+    constructor(limit: any);
+    size: number;
+    limit: any;
+    _keymap: {};
+}

package/dist/app/scripts/utils/abs-to-chr.d.ts

@@ -0,0 +1,14 @@
+export default absToChr;
+export type ChromosomePosition<Name extends string> = [name: Name, pos: number, offset: number, insertPoint: number];
+/**
+ * @template {string} Name
+ * @typedef {[name: Name, pos: number, offset: number, insertPoint: number ]} ChromosomePosition
+ */
+/**
+ * Convert an absolute genome position to a chromosome position.
+ * @template {string} Name
+ * @param {number} absPosition - Absolute genome position.
+ * @param {import('../types').ChromInfo<Name>} chromInfo - Chromosome info object.
+ * @return {ChromosomePosition<Name> | null} The chromosome position.
+ */
+declare function absToChr<Name extends string>(absPosition: number, chromInfo: import("../types").ChromInfo<Name>): ChromosomePosition<Name> | null;

package/dist/app/scripts/utils/accessor-transposition.d.ts

@@ -0,0 +1,14 @@
+export default accessorTransposition;
+/**
+ * Factory function for a transposition accessor for a 2D matrix in form of a 1D
+ * array.
+ *
+ * @description
+ * i^T = column * i + row
+ * where column: `Math.floor(i / x)` and row: `Math.floor(i / x)`
+ *
+ * @param {number} x - X dimension of the 2D matrix
+ * @param {number} y - Y dimension of the 2D matrix
+ * @return {(index: number) => number} Accessor function converting the orignal 1D index into the transposed index
+ */
+declare function accessorTransposition(x: number, y: number): (index: number) => number;

package/dist/app/scripts/utils/add-arrays.d.ts

@@ -0,0 +1,18 @@
+export default addArrays;
+/**
+ * Add two 1D arrays
+ *
+ * @description
+ * `a2` is added onto `a1`, hence `a2` needs to be at least as long as `a1`.
+ *
+ * @example
+ * ```
+ * addArrays([1,2,3], [2,3,4,5]) === [3,5,7]
+ * ```
+ *
+ * @param {Array<number>} a1 - First array of numbers
+ * @param {Array<number>} a2 - Second array of numbers
+ * @param {(index: number) => number} accessor - Allows to use custom accessors. This can be useful when a2 represents a transformed (e.g., transposed matrix).
+ * @return {Array<number>} - Combination of both arrays.
+ */
+declare function addArrays(a1: Array<number>, a2: Array<number>, accessor?: (index: number) => number): Array<number>;

package/dist/app/scripts/utils/add-class.d.ts

@@ -0,0 +1,8 @@
+export default addClass;
+/**
+ * Method to add a class name to an HTML or SVG element.
+ * @param {Element} el - HTML or SVG element to add a class to.
+ * @param {string} className - The class name to be added.
+ * @returns {void}
+ */
+declare function addClass(el: Element, className: string): void;

package/dist/app/scripts/utils/add-event-listener-once.d.ts

@@ -0,0 +1,11 @@
+export default addEventListenerOnce;
+/**
+ * Add an event listener that fires only once and auto-removes itself
+ *
+ * @template {keyof HTMLElementEventMap} K
+ *
+ * @param {HTMLElement} element - DOM element to assign listener to.
+ * @param {K} eventName - Event name to listen to.
+ * @param {(event: HTMLElementEventMap[K]) => void} f - Event callback function.
+ */
+declare function addEventListenerOnce<K extends keyof HTMLElementEventMap>(element: HTMLElement, eventName: K, f: (event: HTMLElementEventMap[K]) => void): void;

package/dist/app/scripts/utils/assert.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Make an assertion.
+ *
+ * Usage
+ * @example
+ * ```ts
+ * const value: boolean = Math.random() <= 0.5;
+ * assert(value, "value is greater than than 0.5!");
+ * value // true
+ * ```
+ *
+ * @param {unknown} expression - The expression to test.
+ * @param {string=} msg - The optional message to display if the assertion fails.
+ * @returns {asserts expression}
+ * @throws an {@link Error} if `expression` is not truthy.
+ */
+export default function assert(expression: unknown, msg?: string | undefined): asserts expression;

package/dist/app/scripts/utils/background-task-scheduler.d.ts

@@ -0,0 +1,47 @@
+export default backgroundTaskScheduler;
+export type DataTask<T> = {
+    data: T;
+    handler: (data: T) => void;
+    trackId?: string | undefined;
+};
+export type NullDataTask = {
+    data: null;
+    handler: () => void;
+    trackId?: string | undefined;
+};
+export type Task = DataTask<any> | NullDataTask;
+declare const backgroundTaskScheduler: BackgroundTaskScheduler;
+/**
+ */
+declare class BackgroundTaskScheduler {
+    /** @type {Task[]} */
+    taskList: Task[];
+    taskHandle: number | null;
+    requestIdleCallbackTimeout: number;
+    /**
+     * @template T
+     * @overload
+     * @param {(data: T) => void} taskHandler
+     * @param {T} taskData
+     * @param {string | null=} trackId
+     * @return {void}
+     */
+    enqueueTask<T>(taskHandler: (data: T) => void, taskData: T, trackId?: (string | null) | undefined): void;
+    /**
+     * If `taskData` is `null` the `taskHandler` will eventaully be called without any arguments.
+     *
+     * @overload
+     * @param {() => void} taskHandler
+     * @param {null} taskData
+     * @param {string | null=} trackId
+     * @return {void}
+     */
+    enqueueTask(taskHandler: () => void, taskData: null, trackId?: (string | null) | undefined): void;
+    /**
+     * @param {{ timeRemaining(): number, didTimeout: boolean }} deadline
+     */
+    runTaskQueue(deadline: {
+        timeRemaining(): number;
+        didTimeout: boolean;
+    }): void;
+}

package/dist/app/scripts/utils/base64-to-canvas.d.ts

@@ -0,0 +1,9 @@
+export default base64ToCanvas;
+/**
+ * Convert a base64 encoded image into a canvas object.
+ * @param {string} base64 - Base64 string encoding the image.
+ * @param {number} width - Custom width for the canvas object.
+ * @param {number} height - Custom height for the canvas object.
+ * @return {Promise<HTMLCanvasElement>} The converted canvas object
+ */
+declare function base64ToCanvas(base64: string, width: number, height: number): Promise<HTMLCanvasElement>;

package/dist/app/scripts/utils/chr-to-abs.d.ts

@@ -0,0 +1,10 @@
+export default chrToAbs;
+/**
+ * Convert a chromosome position to an absolute genome position.
+ *
+ * @template {string} Name
+ * @param {Name} chrom - Chromosome name
+ * @param {number} chromPos - Chromosome position
+ * @param {import('../types').ChromInfo<Name>} chromInfo - Chromosome info object
+ */
+declare function chrToAbs<Name extends string>(chrom: Name, chromPos: number, chromInfo: import("../types").ChromInfo<Name>): number;

package/dist/app/scripts/utils/chrom-info-bisector.d.ts

@@ -0,0 +1,4 @@
+export default chromInfoBisector;
+declare const chromInfoBisector: (array: ArrayLike<{
+    pos: number;
+}>, x: any, lo?: number, hi?: number) => number;

package/dist/app/scripts/utils/clone-event.d.ts

@@ -0,0 +1,12 @@
+export default cloneEvent;
+/**
+ * Clone an event by invoking the source event's constructor and passing in the source event.
+ *
+ * @template {Event & { sourceUid?: string, forwarded?: boolean }} TEvent
+ * @param {TEvent} event - Source event to be cloned.
+ * @return {TEvent} Cloned event
+ */
+declare function cloneEvent<TEvent extends Event & {
+    sourceUid?: string;
+    forwarded?: boolean;
+}>(event: TEvent): TEvent;

package/dist/app/scripts/utils/color-domain-to-rgba-array.d.ts

@@ -0,0 +1,13 @@
+export default colorDomainToRgbaArray;
+export type Color = [r: number, g: number, b: number, a: number];
+/** @typedef {[r: number, g: number, b: number, a: number]} Color */
+/**
+ * Convert a color domain to a 255 element array of [r,g,b,a]
+ * values (all from 0 to 255). The last color (255) will always be
+ * transparent
+ *
+ * @param {readonly [start: string, end: string]} colorRange
+ * @param {boolean} noTansparent
+ * @returns {Array<Color>}
+ */
+declare function colorDomainToRgbaArray(colorRange: readonly [start: string, end: string], noTansparent?: boolean): Array<Color>;

package/dist/app/scripts/utils/color-to-hex.d.ts

@@ -0,0 +1,9 @@
+export default colorToHex;
+/**
+ * Convert a regular color value (e.g. 'red', '#FF0000', 'rgb(255,0,0)') to a
+ * hex value which is legible by PIXI
+ *
+ * @param {string} colorValue - Color value to convert
+ * @return {number} Hex value
+ */
+declare function colorToHex(colorValue: string): number;

package/dist/app/scripts/utils/color-to-rgba.d.ts

@@ -0,0 +1,9 @@
+export default colorToRgba;
+/**
+ * Convert a regular color value (e.g. 'red', '#FF0000', 'rgb(255,0,0)') to a
+ * RGBA array, with support for the value "transparent".
+ *
+ * @param {string} colorValue - An RGB(A) color value to convert.
+ * @return {[r: number, g: number, b: number, a: number]} An RGBA array.
+ */
+declare function colorToRgba(colorValue: string): [r: number, g: number, b: number, a: number];

package/dist/app/scripts/utils/copy-text-to-clipboard.d.ts

@@ -0,0 +1,2 @@
+/** @param {string} text */
+export default function copyTextToClipboard(text: string): void;

package/dist/app/scripts/utils/data-to-genomic-loci.d.ts

@@ -0,0 +1,11 @@
+export default dataToGenomicLoci;
+export type GenomicLoci = [startChromName: string, startChromPos: number, endChromName: string, endChromPos: number];
+/** @typedef {[startChromName: string, startChromPos: number, endChromName: string, endChromPos: number]} GenomicLoci */
+/**
+ * Convert a pair of data coordinates to genomic coordinates.
+ * @param {number} x0 - The first data coordinate.
+ * @param {number} x1 - The second data coordinate.
+ * @param {import('../types').ChromInfo} chromInfo - The chromosome info object.
+ * @returns {GenomicLoci} The genomic coordinates.
+ */
+declare function dataToGenomicLoci(x0: number, x1: number, chromInfo: import("../types").ChromInfo): GenomicLoci;

package/dist/app/scripts/utils/debounce.d.ts

@@ -0,0 +1,5 @@
+export function debounce<Args extends any[]>(func: (...args: Args) => void, wait: number, immediate: boolean): {
+    (...args: Args): void;
+    cancel(): void;
+};
+export default debounce;