higlass 1.13.5 → 2.0.0

package/dist/app/scripts/plugins/get-data-fetcher.d.ts

@@ -0,0 +1,2 @@
+export default getDataFetcher;
+declare const getDataFetcher: (dataConfig: any, pubSub: any, pluginDataFetchers: any, availableForPlugins?: any) => any;

package/dist/app/scripts/plugins/index.d.ts

@@ -0,0 +1,2 @@
+export { default as getDataFetcher } from "./get-data-fetcher";
+export { default as AVAILABLE_FOR_PLUGINS } from "./available-for-plugins";

package/dist/app/scripts/services/chrom-info.d.ts

@@ -0,0 +1,10 @@
+export default api;
+declare namespace api {
+    export { get };
+}
+/**
+ * @param {string} url
+ * @returns {Promise<ParsedChromsizes | null>}
+ */
+declare function get(url: string): Promise<ParsedChromsizes | null>;
+import type { ParsedChromsizes } from '../utils/parse-chromsizes-rows';

package/dist/app/scripts/services/dom-event.d.ts

@@ -0,0 +1,7 @@
+export default domEvent;
+/**
+ * Public API.
+ *
+ * @type {object}
+ */
+declare const domEvent: object;

package/dist/app/scripts/services/element-resize-listener.d.ts

@@ -0,0 +1,5 @@
+export default ElementResizeListener;
+declare namespace ElementResizeListener {
+    export { listen };
+}
+declare function listen(): void;

package/dist/app/scripts/services/index.d.ts

@@ -0,0 +1,5 @@
+export { default as chromInfo } from "./chrom-info";
+export { default as createDomEvent } from "./dom-event";
+export { default as ElementResizeListener } from "./element-resize-listener";
+export { tileResponseToData } from "./worker";
+export { default as tileProxy, requestsInFlight, setTileProxyAuthHeader, getTileProxyAuthHeader, authHeader } from "./tile-proxy";

package/dist/app/scripts/services/tile-proxy.d.ts

@@ -0,0 +1,180 @@
+/**
+ * Merges an array of request objects by combining requests
+ * that share the same `id`, reducing the total number of requests.
+ *
+ * If multiple requests have the same `id`, their `tileIds` arrays are merged
+ * into a single request entry in the output array.
+ *
+ * @example
+ * ```js
+ * const requests = [
+ *   { id: "A", tileIds: ["1", "2"] },
+ *   { id: "B", tileIds: ["3"] },
+ *   { id: "A", tileids: ["4", "5"] },
+ * ];
+ *
+ * const bundled = bundleRequests(requests);
+ * console.log(bundled);
+ * // [
+ * //   { id: "A", tileIds: ["1", "2", "4", "5"] },
+ * //   { id: "B", tileIds: ["3"] },
+ * // ]
+ * ```
+ *
+ * @template {{ id: string, tileIds: ReadonlyArray<string> }} T
+ * @param {Array<T>} requests - The list of requests to bundle
+ * @returns {Array<T>} - A new array with merged requests
+ */
+export function bundleRequestsById<T extends {
+    id: string;
+    tileIds: ReadonlyArray<string>;
+}>(requests: Array<T>): Array<T>;
+/**
+ * Groups request objects by `server`, merging their `tileIds` and structuring tileset-related
+ * data into `body`.
+ *
+ * **Note:** The first request for each `server` sets the `options` for all grouped requests.
+ * Each tileset in `body` also inherits these `options`. A tileset is only added to `body`
+ * if the request includes `options`.
+ *
+ * Trevor (2025-02-20): This follows the original "server bundling" logic. It’s unclear if `body` is
+ * actually used in practice. Omitting requests without `options` might be an unintended
+ * behavior, but we're maintaining it for now.
+ *
+ * @example
+ * ```js
+ * const requests = [
+ *   { server: "A", tileIds: ["tileset1.1", "tileset2.2"], options: { foo: "bar" } },
+ *   { server: "B", tileIds: ["tileset3.3"], options: { baz: "qux" } },
+ *   { server: "A", tileIds: ["tileset1.4"] },
+ * ];
+ *
+ * const bundled = bundleRequestsByServer(requests);
+ * console.log(bundled);
+ * // [
+ * //   {
+ * //     server: "A",
+ * //     tileIds: ["tileset1.1", "tileset2.2", "tileset1.4"],
+ * //     options: { foo: "bar" },
+ * //     body: [
+ * //       { tilesetUid: "tileset1", tileIds: ["1"], options: { foo: "bar" } },
+ * //       { tilesetUid: "tileset2", tileIds: ["2"], options: { foo: "bar" } }
+ * //     ]
+ * //   },
+ * //   {
+ * //     server: "B",
+ * //     tileIds: ["tileset3.3"],
+ * //     options: { baz: "qux" },
+ * //     body: [
+ * //       { tilesetUid: "tileset3", tileIds: ["3"], options: { baz: "qux" } }
+ * //     ]
+ * //   }
+ * // ]
+ * ```
+ *
+ * @template {{ tileIds: ReadonlyArray<string>, server: string, options?: Record<string, any> }} T
+ * @param {Array<T>} requests - The list of requests to bundle
+ * @returns {Array<T & { body: ReadonlyArray<ServerTilesetBody> }> }>} - A new array with merged requests per server
+ */
+export function bundleRequestsByServer<T extends {
+    tileIds: ReadonlyArray<string>;
+    server: string;
+    options?: Record<string, any>;
+}>(requests: Array<T>): Array<T & {
+    body: ReadonlyArray<{
+        tilesetUid: string;
+        tileIds: Array<string>;
+        options: Record<string, any>;
+    }>;
+}>;
+/**
+ * Calculate the element within this tile containing the given
+ * position.
+ *
+ * Returns the tile position and position within the tile for
+ * the given element.
+ *
+ * @param {TilesetInfo} tilesetInfo - The information about this tileset
+ * @param {number} maxDim - The maximum width of the dataset (only used for tilesets without resolutions)
+ * @param {number} dataStartPos - The position where the data begins
+ * @param {number} zoomLevel - The (integer) current zoomLevel
+ * @param {number} position -The position (in absolute coordinates) to caculate the tile and position in tile for
+ *
+ * @returns {Array<number>}
+ */
+export function calculateTileAndPosInTile(tilesetInfo: TilesetInfo, maxDim: number, dataStartPos: number, zoomLevel: number, position: number): Array<number>;
+/** @type {number} */
+export let requestsInFlight: number;
+/** @type {string | null} */
+export let authHeader: string | null;
+export function setTileProxyAuthHeader(newHeader: string): void;
+export function getTileProxyAuthHeader(): string | null;
+/**
+ * Retrieve a set of tiles from the server.
+ *
+ * @type {(request: TilesRequest, pubSub: PubSub) => Promise<Record<string, TileData>>}
+ */
+export const fetchTilesDebounced: (request: TilesRequest, pubSub: PubSub) => Promise<Record<string, TileData>>;
+export function calculateZoomLevelFromResolutions(resolutions: Array<string>, scale: Scale): number;
+export function calculateResolution(tilesetInfo: TilesetInfo, zoomLevel: number): number;
+export function calculateZoomLevel(scale: Scale, minX: number, maxX: number, binsPerTile: number): number;
+export function calculateTiles(zoomLevel: number, scale: Scale, minX: number, _maxX: number, maxZoom: number, maxDim: number): Array<number>;
+export function calculateTileWidth(tilesetInfo: TilesetInfo, zoomLevel: number, binsPerTile: number): number;
+export function calculateTilesFromResolution(resolution: number, scale: Scale, minX: number, maxX: number, pixelsPerTile?: number | undefined): number[];
+export function tileDataToPixData(tile: {
+    mirrored?: boolean;
+    isMirrored?: boolean;
+    tileData: {
+        dense: Float32Array;
+        tilePos: readonly [a: number, b?: number];
+        shape: readonly [number, number];
+    };
+}, valueScaleType: "log" | "linear", valueScaleDomain: [min: number, max: number], pseudocount: number, colorScale: ReadonlyArray<readonly [r: number, g: number, b: number, a: number]>, finished: (x: null | {
+    pixData: Uint8ClampedArray;
+}) => void, ignoreUpperRight: boolean | undefined, ignoreLowerLeft: boolean | undefined, zeroValueColor: [r: number, g: number, b: number, a: number], selectedRowsOptions: Partial<SelectedRowsOptions>): void;
+export function trackInfo(server: string, tilesetUid: string, doneCb: (info: Record<string, TilesetInfo>) => void, errorCb: (error: string) => void, pubSub: import("pub-sub-es").PubSub): void;
+export default api;
+export type WithResolvers<T, U> = {
+    value: T;
+    resolve: (value: U) => void;
+    reject: (err: unknown) => void;
+};
+export type TileData = CompletedTileData<TileResponse>;
+import type { TilesetInfo } from '../types';
+import type { TilesRequest } from '../types';
+import type { PubSub } from 'pub-sub-es';
+import type { Scale } from '../types';
+import type { SelectedRowsOptions } from './worker';
+declare namespace api {
+    export { calculateResolution };
+    export { calculateTileAndPosInTile };
+    export { calculateTiles };
+    export { calculateTilesFromResolution };
+    export { calculateTileWidth };
+    export { calculateZoomLevel };
+    export { calculateZoomLevelFromResolutions };
+    export { fetchTilesDebounced };
+    export { json };
+    export { text };
+    export { tileDataToPixData };
+    export { trackInfo };
+}
+import type { TileResponse } from './worker';
+import type { CompletedTileData } from './worker';
+/**
+ * Send a JSON request and mark it so that we can tell how many are in flight
+ *
+ * @template T
+ * @param {string} url
+ * @param {(err: Error | undefined, value: T | undefined) => void} callback
+ * @param {import("pub-sub-es").PubSub} pubSub
+ */
+declare function json<T>(url: string, callback: (err: Error | undefined, value: T | undefined) => void, pubSub: import("pub-sub-es").PubSub): Promise<T>;
+/**
+ * Send a text request and mark it so that we can tell how many are in flight
+ *
+ * @param {string | URL} url
+ * @param {(err: Error | undefined, value: string | undefined) => void} callback
+ * @param {import("pub-sub-es").PubSub} pubSub
+ */
+declare function text(url: string | URL, callback: (err: Error | undefined, value: string | undefined) => void, pubSub: import("pub-sub-es").PubSub): Promise<string>;

package/dist/app/scripts/services/worker.d.ts

@@ -0,0 +1,157 @@
+/**
+ * @typedef SelectedRowsOptions
+ * @property {Array<number | Array<number>>} selectedRows - Row indices, for ordering and filtering rows. Used by the HorizontalMultivecTrack.
+ * @property {'mean' | 'sum' | 'variance' | 'deviation'} selectedRowsAggregationMode - The aggregation function to use ("mean", "sum", etc).
+ * @property {boolean} selectedRowsAggregationWithRelativeHeight - Whether the height of row groups should be relative to the size of the group.
+ * @property {'client' | 'server'} selectedRowsAggregationMethod - Where will the aggregation be performed? Possible values: "client", "server".
+ */
+/**
+ * This function takes in tile data and other rendering parameters,
+ * and generates an array of pixel data that can be passed to a canvas
+ * (and subsequently passed to a PIXI sprite).
+ *
+ * @param {number} size - `data` parameter length. Often set to a tile's `tile.tileData.dense.length` value.
+ * @param {Array<number> | Float32Array} data - The tile data array.
+ * @param {'log' | 'linear'} valueScaleType 'log' or 'linear'.
+ * @param {[number, number]} valueScaleDomain
+ * @param {number} pseudocount - The pseudocount is generally the minimum non-zero value and is
+ * used so that our log scaling doesn't lead to NaN values.
+ * @param {ReadonlyArray<readonly [r: number, g: number, b: number, a: number]>} colorScale
+ * @param {boolean} ignoreUpperRight
+ * @param {boolean} ignoreLowerLeft
+ * @param {readonly [numRows: number, numCols: number] | null} shape - Array `[numRows, numCols]`, used when iterating over a subset of rows,
+ * when one needs to know the width of each column.
+ * @param {[r: number, g: number, b: number, a: number] | null} zeroValueColor - The color to use for rendering zero data values, [r, g, b, a].
+ * @param {Partial<SelectedRowsOptions> | null} selectedRowsOptions - Rendering options when using a `selectRows` track option.
+ *
+ * @returns {Uint8ClampedArray} A flattened array of pixel values.
+ */
+export function workerSetPix(size: number, data: Array<number> | Float32Array, valueScaleType: "log" | "linear", valueScaleDomain: [number, number], pseudocount: number, colorScale: ReadonlyArray<readonly [r: number, g: number, b: number, a: number]>, ignoreUpperRight?: boolean, ignoreLowerLeft?: boolean, shape?: readonly [numRows: number, numCols: number] | null, zeroValueColor?: [r: number, g: number, b: number, a: number] | null, selectedRowsOptions?: Partial<SelectedRowsOptions> | null): Uint8ClampedArray;
+/**
+ * @typedef TileData<Server>
+ * @property {string} server
+ * @property {string} tileId
+ * @property {number} zoomLevel
+ * @property {[number] | [number, number]} tilePos
+ * @property {string} tilesetUid
+ */
+/**
+ * @typedef DenseTileData
+ * @property {string} server
+ * @property {string} tileId
+ * @property {number} zoomLevel
+ * @property {[number] | [number, number]} tilePos
+ * @property {string} tilesetUid
+ * @property {Float32Array} dense
+ * @property {string} dtype
+ * @property {DenseDataExtrema1D | DenseDataExtrema2D} denseDataExtrema
+ * @property {number} minNonZero
+ * @property {number} maxNonZero
+ */
+/**
+ * @template T
+ * @typedef {Omit<T, keyof DenseTileData> & (TileData | DenseTileData)} CompletedTileData
+ */
+/**
+ * @typedef TileResponse
+ * @property {string} [dense] - a base64 encoded string
+ * @property {string} [tilePositionId] - The position of the tile
+ */
+/**
+ * Convert a response from the tile server to data that can be used by higlass.
+ *
+ * WARNING: Mutates the data object.
+ *
+ * @template {TileResponse} T
+ * @param {Record<string, T>} inputData
+ * @param {string} server
+ * @param {ReadonlyArray<string>} theseTileIds
+ *
+ * @returns {Record<string, CompletedTileData<T>>}
+ *
+ * Trevor: This function is littered with ts-expect-error comments because
+ * the type of mutation happening to the input object is very tricky to type.
+ * The type signature of the function tries to adequately describe the mutation,
+ * to outside users.
+ */
+export function tileResponseToData<T extends TileResponse>(inputData: Record<string, T>, server: string, theseTileIds: ReadonlyArray<string>): Record<string, CompletedTileData<T>>;
+/**
+ * Fetch tiles from the server.
+ *
+ * @template {TileResponse} T
+ *
+ * @param {Object} request
+ * @param {string} request.server
+ * @param {ReadonlyArray<string>} request.tileIds
+ * @param {ReadonlyArray<{ tilesetUid: string, tileIds: Array<string>, options?: Record<string, unknown> }>} request.body
+ * @param {Object} options
+ * @param {string | null} [options.authHeader]
+ * @param {import("pub-sub-es").PubSub} [options.pubSub]
+ * @param {string} options.sessionId
+ */
+export function workerFetchTiles<T extends TileResponse>(request: {
+    server: string;
+    tileIds: ReadonlyArray<string>;
+    body: ReadonlyArray<{
+        tilesetUid: string;
+        tileIds: Array<string>;
+        options?: Record<string, unknown>;
+    }>;
+}, options: {
+    authHeader?: string | null | undefined;
+    pubSub?: import("pub-sub-es").PubSub | undefined;
+    sessionId: string;
+}): Promise<void | Record<string, CompletedTileData<TileResponse>>>;
+export type SelectedRowsOptions = {
+    /**
+     * - Row indices, for ordering and filtering rows. Used by the HorizontalMultivecTrack.
+     */
+    selectedRows: Array<number | Array<number>>;
+    /**
+     * - The aggregation function to use ("mean", "sum", etc).
+     */
+    selectedRowsAggregationMode: "mean" | "sum" | "variance" | "deviation";
+    /**
+     * - Whether the height of row groups should be relative to the size of the group.
+     */
+    selectedRowsAggregationWithRelativeHeight: boolean;
+    /**
+     * - Where will the aggregation be performed? Possible values: "client", "server".
+     */
+    selectedRowsAggregationMethod: "client" | "server";
+};
+/**
+ * <Server>
+ */
+export type TileData = {
+    server: string;
+    tileId: string;
+    zoomLevel: number;
+    tilePos: [number] | [number, number];
+    tilesetUid: string;
+};
+export type DenseTileData = {
+    server: string;
+    tileId: string;
+    zoomLevel: number;
+    tilePos: [number] | [number, number];
+    tilesetUid: string;
+    dense: Float32Array;
+    dtype: string;
+    denseDataExtrema: DenseDataExtrema1D | DenseDataExtrema2D;
+    minNonZero: number;
+    maxNonZero: number;
+};
+export type CompletedTileData<T> = Omit<T, keyof DenseTileData> & (TileData | DenseTileData);
+export type TileResponse = {
+    /**
+     * - a base64 encoded string
+     */
+    dense?: string | undefined;
+    /**
+     * - The position of the tile
+     */
+    tilePositionId?: string | undefined;
+};
+import DenseDataExtrema1D from '../utils/DenseDataExtrema1D';
+import DenseDataExtrema2D from '../utils/DenseDataExtrema2D';

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

@@ -0,0 +1,13 @@
+/**
+ * Create a path-based symbol icon
+ *
+ * @method  createSymbolIcon
+ * @author  Fritz Lekschas
+ * @date    2016-10-09
+ * @param   {Object}  el       D3 selected base element to where the symbols
+ *   should be appended to.
+ * @param   {String}  id       ID of the icon to be created.
+ * @param   {Array}   paths    Array of path strings.
+ * @param   {String}  viewBox  View box string.
+ */
+export default function createSymbolIcon(el: Object, id: string, paths: any[], viewBox: string): void;

package/dist/app/scripts/test-helpers/index.d.ts

@@ -0,0 +1 @@
+export { changeOptions, waitForJsonComplete, waitForTilesLoaded, waitForTransitionsFinished, waitForScalesStabilized, waitForComponentReady, mountHGComponent, mountHGComponentAsync, removeHGComponent } from "./test-helpers";

package/dist/app/scripts/test-helpers/test-helpers.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @param {HTMLDivElement | null} prevDiv
+ * @param {import("enzyme").ReactWrapper<{}, {}, HiGlassComponent> | null} prevHgc
+ * @param {Record<string, unknown>} viewConf
+ * @param {{ style?: string, bounded?: boolean, extendedDelay?: boolean }} [options]
+ * @returns {Promise<[HTMLDivElement, { instance: () => HiGlassComponent }]>}
+ */
+export function mountHGComponentAsync(prevDiv: HTMLDivElement | null, prevHgc: import("enzyme").ReactWrapper<{}, {}, HiGlassComponent> | null, viewConf: Record<string, unknown>, options?: {
+    style?: string;
+    bounded?: boolean;
+    extendedDelay?: boolean;
+}): Promise<[HTMLDivElement, {
+    instance: () => HiGlassComponent;
+}]>;
+export function changeOptions(hgc: import("enzyme").ReactWrapper<{}, {}, HiGlassComponent>, viewUid: string, trackUid: string, options: Record<string, unknown>): void;
+export function areTransitionsActive(hgc: HiGlassComponent): boolean;
+export function waitForTransitionsFinished(hgc: HiGlassComponent, callback: () => void): void;
+export function waitForJsonComplete(finished: () => void): void;
+export function isWaitingOnTiles(hgc: HiGlassComponent): boolean;
+export function waitForTilesLoaded(hgc: HiGlassComponent, tilesLoadedCallback: (value?: unknown) => void): void;
+export function mountHGComponent(prevDiv: HTMLDivElement | null, prevHgc: import("enzyme").ReactWrapper<{}, {}, HiGlassComponent> | null, viewConf: Record<string, unknown>, done: (value?: unknown) => void, options?: {
+    style?: string;
+    bounded?: boolean;
+    extendedDelay?: boolean;
+}): readonly [HTMLDivElement, import("enzyme").ReactWrapper<{}, {}, HiGlassComponent>];
+export function waitForScalesStabilized(hgc: HiGlassComponent, viewUid: string, options: {
+    initialWait?: number | undefined;
+    timeInterval?: number | undefined;
+    maxTime?: number | undefined;
+}): Promise<void>;
+export function waitForComponentReady(div: HTMLElement): Promise<void>;
+export function removeHGComponent(div: HTMLDivElement): void;
+import HiGlassComponent from '../HiGlassComponent';

package/dist/app/scripts/track-utils.d.ts

@@ -0,0 +1,73 @@
+export default trackUtils;
+declare namespace trackUtils {
+    export { calculate1DVisibleTiles };
+    export { calculate1DZoomLevel };
+    export { drawAxis };
+    export { movedY };
+    export { getTilePosAndDimensions };
+    export { stretchRects };
+    export { zoomedY };
+}
+/**
+ * Calculate which tiles should be visible given a track's
+ * scale.
+ *
+ * @param  {object} tilesetInfo The track's tileset info, containing either the `resolutions`
+ *                              list or min_pos and max_pos arrays
+ * @param  {function} scale     The track's D3 scale function.
+ * @return {array}             A list of visible tiles (e.g. [[1,0],[1,1]])
+ */
+declare function calculate1DVisibleTiles(tilesetInfo: object, scale: Function): array;
+/**
+ * Calculate the current zoom level for a 1D track
+ *
+ * @param  {object} tilesetInfo The tileset info for the track. Should contain
+ *                              min_pos and max_pos arrays, each of which has one
+ *                              value which stores the minimum and maximum data
+ *                              positions respectively.
+ * @param  {function} xScale      The current D3 scale function for the track.
+ * @param  {number} maxZoom     The maximum zoom level allowed by the track.
+ * @return {number}                The current zoom level of the track.
+ */
+declare function calculate1DZoomLevel(tilesetInfo: object, xScale: Function, maxZoom: number): number;
+/**
+ * Draw an axis on a track. Where on the track the axis will be drawn
+ * is taken from the track's options.
+ *
+ * @param  {PixiTrack} track   The track to decorate with an axis.
+ * @param  {d3.scale} valueScale The scale that the axis should draw.
+ */
+declare function drawAxis(track: PixiTrack, valueScale: d3.scale): void;
+/**
+ * A track is being dragged along it's value scale axis.
+ *
+ * @param {object} Track The track instance being dragged.
+ * @param  {number} dY The change in y position.
+ */
+declare function movedY(track: any, dY: number): void;
+/**
+ * Get the tile's position in its coordinate system.
+ *
+ * See Tiled1DPIXITrack.js
+ */
+declare function getTilePosAndDimensions(tilesetInfo: any, tileId: any): {
+    tileX: any;
+    tileWidth: number;
+};
+/** When zooming, we want to do fast scaling rather than re-rendering
+ * but if we do this too much, shapes (particularly arrowheads) get
+ * distorted. This function keeps track of how stretched the track is
+ * and redraws it if it becomes too distorted (tileK < 0.5 or tileK > 2) */
+declare function stretchRects(track: any, graphicsAccessors: any): void;
+/**
+ * A track has received an event telling it to zoom along its
+ * vertical axis. Update the transform describing the position
+ * of its graphics.
+ *
+ * @param  {number} yPos        The position the zoom event took place
+ * @param  {number} kMultiplier How much the zoom level should be adjusted by
+ * @param  {d3.transform} transform   The track's current graphics transform.
+ * @param  {number} height      The height of the track
+ * @return {d3.transform}            The track's new graphics transform.
+ */
+declare function zoomedY(yPos: number, kMultiplier: number, transform: d3.transform, height: number): d3.transform;