higlass 1.13.5 → 2.0.0

package/dist/app/scripts/utils/load-chrom-infos.d.ts

@@ -0,0 +1,8 @@
+export default loadChromInfos;
+/**
+ * @param {Record<string, { chromInfoPath: string }>} views
+ * @returns {void}
+ */
+declare function loadChromInfos(views: Record<string, {
+    chromInfoPath: string;
+}>): void;

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

@@ -0,0 +1,13 @@
+export default map;
+/**
+ * Exposed map function. You can do cool stuff with that!
+ *
+ * @description
+ * The pure map function is more powerful because it can be used on data types
+ * other than Array too.
+ *
+ * @template T, B
+ * @param {(item: T, idx?: number) => B} f - Mapping function.
+ * @return {(x: Array<T>) => Array<B>} Mapped array.
+ */
+declare function map<T, B>(f: (item: T, idx?: number) => B): (x: Array<T>) => Array<B>;

package/dist/app/scripts/utils/max-non-zero.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Calculate the maximum non-zero value in the data
+ * @param {ArrayLike<number>} data - An array of values
+ * @returns {number} The maximum non-zero value in the array
+ */
+export default function maxNonZero(data: ArrayLike<number>): number;

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

@@ -0,0 +1,10 @@
+export default max;
+/**
+ * Fast version of `Math.max`. Based on
+ *   https://jsperf.com/math-min-max-vs-ternary-vs-if/24 `Math.max` is not
+ *   very fast
+ * @param {number} a - Value A
+ * @param {number} b - Value B
+ * @return {number} If `true` A is greater than B.
+ */
+declare function max(a: number, b: number): number;

package/dist/app/scripts/utils/min-non-zero.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Calculate the minimum non-zero value in the data
+ * @param {ArrayLike<number>} data - An array of values
+ * @returns {number} The minimum non-zero value in the array
+ */
+export default function minNonZero(data: ArrayLike<number>): number;

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

@@ -0,0 +1,10 @@
+export default min;
+/**
+ * Fast version of `Math.min`. Based on
+ *   https://jsperf.com/math-min-max-vs-ternary-vs-if/24 `Math.max` is not
+ *   very fast
+ * @param {number} a - Value A
+ * @param {number} b - Value B
+ * @return {number} If `true` A is smaller than B.
+ */
+declare function min(a: number, b: number): number;

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

@@ -0,0 +1,9 @@
+export default mod;
+/**
+ * Non-negative modulo function. E.g., `mod(-1, 5) === 4` while `-1 % 5 === -1`.
+ *
+ * @param {number} n - Dividend (integer)
+ * @param {number} m - Divisor (integer)
+ * @return {number} Remainder (integer)
+ */
+declare function mod(n: number, m: number): number;

package/dist/app/scripts/utils/ndarray-assign.d.ts

@@ -0,0 +1,2 @@
+export default ndarrayAssign;
+declare function ndarrayAssign(target: any, source: any): void;

package/dist/app/scripts/utils/ndarray-flatten.d.ts

@@ -0,0 +1,2 @@
+export default ndarrayFlatten;
+declare function ndarrayFlatten(arr: any): any;

package/dist/app/scripts/utils/ndarray-to-list.d.ts

@@ -0,0 +1,2 @@
+export default ndarrayToList;
+declare function ndarrayToList(arr: any): any[];

package/dist/app/scripts/utils/numericify-version.d.ts

@@ -0,0 +1,6 @@
+export default numericifyVersion;
+/**
+ * @param {string} version
+ * @returns {number}
+ */
+declare function numericifyVersion(version: string): number;

package/dist/app/scripts/utils/obj-vals.d.ts

@@ -0,0 +1,8 @@
+export default objVals;
+/**
+ * Convert an object into array which entries are the prop values of the object
+ *
+ * @param {Object} obj - Object to be arrayified
+ * @return {Array} Array of the object.
+ */
+declare function objVals(obj: Object): any[];

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

@@ -0,0 +1,8 @@
+export default or;
+/**
+ * Logical or operator for convenience.
+ * @param {boolean} a - Value A
+ * @param {boolean} b - Value B
+ * @return {boolean} If `true` one of the two or both values are truthy.
+ */
+declare function or(a: boolean, b: boolean): boolean;

package/dist/app/scripts/utils/parse-chromsizes-rows.d.ts

@@ -0,0 +1,34 @@
+export default parseChromsizesRows;
+export type ChromsizeRow = [string, number];
+export type CumulativeChromsizeEntry = {
+    id: number;
+    chr: string;
+    pos: number;
+};
+export type ParsedChromsizes = {
+    cumPositions: CumulativeChromsizeEntry[];
+    chrPositions: Record<string, CumulativeChromsizeEntry>;
+    totalLength: number;
+    chromLengths: Record<string, number>;
+};
+/** @typedef {[string, number]} ChromsizeRow */
+/**
+ * @typedef CumulativeChromsizeEntry
+ * @property {number} id
+ * @property {string} chr
+ * @property {number} pos
+ */
+/**
+ * @typedef ParsedChromsizes
+ * @property {CumulativeChromsizeEntry[]} cumPositions
+ * @property {Record<string, CumulativeChromsizeEntry>} chrPositions
+ * @property {number} totalLength
+ * @property {Record<string, number>} chromLengths
+ */
+/**
+ * Parse an array of chromsizes, for example that result from reading rows of a chromsizes CSV file.
+ *
+ * @param {ArrayLike<ChromsizeRow>} data - Array of [chrName, chrLen] "tuples".
+ * @returns {ParsedChromsizes}
+ */
+declare function parseChromsizesRows(data: ArrayLike<ChromsizeRow>): ParsedChromsizes;

package/dist/app/scripts/utils/pixi-text-to-svg.d.ts

@@ -0,0 +1,2 @@
+export function pixiTextToSvg(pixiText: import("pixi.js").Text): HTMLElement;
+export default pixiTextToSvg;

package/dist/app/scripts/utils/positioned-tracks-to-all-tracks.d.ts

@@ -0,0 +1,26 @@
+export default positionedTracksToAllTracks;
+/**
+ * Convert the position indexed list of tracks.
+ *
+ * If `includeCombinedContents` is `true`, tracks inside
+ * `combined.contents` will also be included in the output.
+ *
+ * @template {{ type: string } | { type: 'combined', contents: Array<T> }} T
+ *
+ * @param {PositionedTracks<T>} positionedTracks
+ * @param {{ includeCombinedContents?: boolean }} options
+ * @returns {Array<T & { position: TrackPosition }>}
+ *
+ */
+declare function positionedTracksToAllTracks<T extends {
+    type: string;
+} | {
+    type: "combined";
+    contents: Array<T>;
+}>(positionedTracks: PositionedTracks<T>, { includeCombinedContents }?: {
+    includeCombinedContents?: boolean;
+}): Array<T & {
+    position: TrackPosition;
+}>;
+import type { PositionedTracks } from './visit-positioned-tracks';
+import type { TrackPosition } from '../types';

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

@@ -0,0 +1,18 @@
+export default q;
+/**
+ * Object query language using dot-notation.
+ *
+ * @description  In order to query an object dynamically do:
+ *   ```
+ *   const myFancyObj = { my: { fancy: { property: 'Sweet!' } } };
+ *   const myNotSoFancyObj = { noSoFancy: 'buh!' };
+ *
+ *   const myFancyQuery = q('my.fancy.property');
+ *
+ *   console.log(myFancyQuery(myFancyObj)) ==> 'Sweet!'
+ *   console.log(myFancyQuery(myNotSoFancyObj)) ==> undefined
+ *   ```
+ * @param {string} queryStr - dot-notation query string
+ * @return {unknown}
+ */
+declare function q(queryStr: string): unknown;

package/dist/app/scripts/utils/rad-to-deg.d.ts

@@ -0,0 +1,7 @@
+export default radToDeg;
+/**
+ * Convert radiance to degree
+ * @param {number} rad - Radiance
+ * @return {number} Degree
+ */
+declare function radToDeg(rad: number): number;

package/dist/app/scripts/utils/range-query-2d.d.ts

@@ -0,0 +1,17 @@
+export default rangeQuery2d;
+/**
+ * Perform a 2D query on a 1D array
+ *
+ * @param  {Array}  src  Data source array.
+ * @param  {Integer}  xDimSrc  X dimension of `src`.
+ * @param  {Integer}  xDimOut  X dimension of `outList`.
+ * @param  {Array}  xRange  X range array, e.g., `[start, end]`.
+ * @param  {Array}  yRange  Y range array, e.g., `[start, end]`.
+ * @param  {Integer}  xOff  X offset in regards to `outList`.
+ * @param  {Integer}  yOff  Y offset in regards to `outList`.
+ * @param  {Boolean}  mirrored  If `true` mirror query.
+ * @param  {Array}  outList  Typed array to be set in place.
+ *        1D representation of a 2D array (e.g. ass = new Uint8ClampedArray(10);)
+ * @return  {Array}  Sub array.
+ */
+declare function rangeQuery2d(src: any[], xDimSrc: Integer, xDimOut: Integer, xRange: any[], yRange: any[], mirrored: boolean, xOff: Integer, yOff: Integer, outList: any[]): any[];

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

@@ -0,0 +1,14 @@
+export default reduce;
+/**
+ * Pure functional reducer. Can be used for currying stuff.
+ *
+ * @see {@link ./flatten.js}
+ *
+ * @template T
+ * @template U
+ *
+ * @param {(previousValue: U, currentValue: T, currentIndex: number, array: Array<T>) => U} callbackfn
+ * @param {U} initialValue
+ * @return {(x: Array<T>) => U}  Curried function that accepts an array to be reduced.
+ */
+declare function reduce<T, U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: Array<T>) => U, initialValue: U): (x: Array<T>) => U;

package/dist/app/scripts/utils/rel-to-abs-chrom-pos.d.ts

@@ -0,0 +1,10 @@
+export default relToAbsChromPos;
+/**
+ * @template {string} Name
+ * @param {Name} chrom
+ * @param {number} x
+ * @param {number} y
+ * @param {import('../types').ChromInfo<Name>} chromInfo
+ * @returns {[number, number]}
+ */
+declare function relToAbsChromPos<Name extends string>(chrom: Name, x: number, y: number, chromInfo: import("../types").ChromInfo<Name>): [number, number];

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

@@ -0,0 +1,7 @@
+export default removeClass;
+/**
+ * Remove a class from an HTML or SVG element.
+ * @param {Element} el - HTML or SVG element.
+ * @param {string} className  Class name to be removed.
+ */
+declare function removeClass(el: Element, className: string): void;

package/dist/app/scripts/utils/reset-d3-brush-style.d.ts

@@ -0,0 +1,10 @@
+export default resetD3BrushStyle;
+export type BaseType = import("d3-selection").BaseType;
+/** @typedef {import('d3-selection').BaseType} BaseType */
+/**
+ * Unsets the automatically set brush style of D3.
+ * @template {import('d3-selection').Selection<BaseType, unknown, BaseType, unknown>} Sel
+ * @param {Sel} el - Element which is brushed on.
+ * @param {string} className  New class name to be set.
+ */
+declare function resetD3BrushStyle<Sel extends import("d3-selection").Selection<BaseType, unknown, BaseType, unknown>>(el: Sel, className: string): void;

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

@@ -0,0 +1,8 @@
+export default rgbToHex;
+/**
+ * @param {number} r
+ * @param {number} g
+ * @param {number} b
+ * @returns {string}
+ */
+declare function rgbToHex(r: number, g: number, b: number): string;

package/dist/app/scripts/utils/scales-center-and-k.d.ts

@@ -0,0 +1,12 @@
+export default scalesCenterAndK;
+/**
+ * Calculate the center of the scale as well as its scale
+ * factor
+ *
+ * Assumes the two scales have the same k
+ *
+ * @param {import('../types').Scale} xScale - A d3 scale.
+ * @param {import('../types').Scale} yScale - A d3 scale.
+ * @return {[xCenter: number, yCenter: number, k: number]}
+ */
+declare function scalesCenterAndK(xScale: import("../types").Scale, yScale: import("../types").Scale): [xCenter: number, yCenter: number, k: number];

package/dist/app/scripts/utils/scales-to-genome-loci.d.ts

@@ -0,0 +1,3 @@
+export function scalesToGenomeLoci(xScale: import("../types").Scale, yScale: import("../types").Scale, chromInfo: import("../types").ChromInfo): [...GenomicLoci, ...GenomicLoci] | undefined;
+export default scalesToGenomeLoci;
+export type GenomicLoci = import("./data-to-genomic-loci").GenomicLoci;

package/dist/app/scripts/utils/segments-to-rows.d.ts

@@ -0,0 +1,15 @@
+export default segmentsToRows;
+export type Segment = {
+    from: number;
+    to: number;
+};
+/** @typedef {{ from:number, to: number }} Segment */
+/**
+ * Partition a list of segments into an array of rows containing the segments.
+ *
+ * WARNING: Sorts the `segments` array input _inplace_.
+ *
+ * @param {Array<Segment>} segments An array of segments (e.g. [{from: 10, to: 20}, {from: 18, to: 30}])
+ * @return: {Array<Array<Segment>>} non-overlapping rows of segments
+ */
+declare function segmentsToRows(segments: Array<Segment>): Segment[][];

package/dist/app/scripts/utils/selected-items-to-cum-weights.d.ts

@@ -0,0 +1,12 @@
+export default selectedItemsToCumWeights;
+/**
+ * Compute the cumulative normalized weights associated with a
+ * potentially 2d array of selected item indices.
+ *
+ * @param {Array<unknown>} selectedItems - The 1d or 2d array of items or groups of items.
+ * @param {boolean} withRelativeSize - Does a group of indices count as 1 unit size or is its size relative to the group size?
+ * @returns {Float64Array} The array of cumulative weights, one for each item.
+ *
+ * Sums to 1 before the cumulative sum step (i.e. the final array element will be 1).
+ */
+declare function selectedItemsToCumWeights(selectedItems: Array<unknown>, withRelativeSize: boolean): Float64Array;

package/dist/app/scripts/utils/selected-items-to-size.d.ts

@@ -0,0 +1,13 @@
+export default selectedItemsToSize;
+/**
+ * Compute the size associated with a potentially 2d array of selected item indices.
+ * For example, this can be used to compute the total height of a `horizontal-multivec` track
+ * where rows are selected individually or in aggregation groups.
+ *
+ * @param {Array<unknown>} selectedItems The 1d or 2d array of items or groups of items.
+ * @param {boolean} withRelativeSize Does a group of indices count as 1 unit size
+ * or is its size relative to the group size?
+ * @returns {number} The computed size value.
+ * Between 0 and the total number of items in the (flattened) input array.
+ */
+declare function selectedItemsToSize(selectedItems: Array<unknown>, withRelativeSize: boolean): number;

package/dist/app/scripts/utils/show-mouse-position.d.ts

@@ -0,0 +1,54 @@
+export default setupShowMousePosition;
+export type MouseTrackOptions = {
+    /**
+     * - Color of the mouse position.
+     */
+    mousePositionColor?: string | undefined;
+    /**
+     * - Alpha of the mouse position.
+     */
+    mousePositionAlpha?: number | undefined;
+};
+export type ClassContext = {
+    pForeground?: import("pixi.js").Container | undefined;
+    pMasked?: import("pixi.js").Container | undefined;
+    pMain?: import("pixi.js").Container | undefined;
+    xScale: () => import("../types").Scale;
+    yScale: () => import("../types").Scale;
+    getPosition: () => [number, number];
+    getDimensions: () => [number, number];
+    pubSub: import("pub-sub-es").PubSub;
+    pubSubs: Array<import("pub-sub-es").Subscription>;
+    getProp: (prop: "flipText") => () => boolean;
+    options: {};
+};
+/**
+ * @typedef ClassContext
+ * @property {import('pixi.js').Container=} pForeground
+ * @property {import('pixi.js').Container=} pMasked
+ * @property {import('pixi.js').Container=} pMain
+ * @property {() => import('../types').Scale} xScale
+ * @property {() => import('../types').Scale} yScale
+ * @property {() => [number, number]} getPosition
+ * @property {() => [number, number]} getDimensions
+ * @property {import('pub-sub-es').PubSub} pubSub
+ * @property {Array<import('pub-sub-es').Subscription>} pubSubs
+ * @property {(prop: 'flipText') => () => boolean} getProp
+ * @property {{}} options
+ */
+/**
+ * Public API for showing the mouse location.
+ *
+ * @description
+ * This is just a convenience wrapper to avoid code duplication.
+ * `showMousePosition` is the actual function and could be called from within
+ * each class as well.
+ *
+ * @param {ClassContext} context - Class context, i.e., `this`.
+ * @param {Boolean} is2d - If `true` both dimensions of the mouse location
+ *   should be shown. E.g., on a central track.
+ * @param {Boolean} isGlobal - If `true` local and global events will trigger
+ *   the mouse position drawing.
+ * @return {Function} - Method to remove graphics showing the mouse location.
+ */
+declare function setupShowMousePosition(context: ClassContext, is2d?: boolean, isGlobal?: boolean): Function;

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

@@ -0,0 +1,10 @@
+export default some;
+/**
+ * Functional version of `Array.forEach`. More flexible and applicable to
+ * other array-like data types like `NodeList`.
+ *
+ * @template T
+ * @param {(item: T, i: number) => boolean} f - Modifier function applied on every item of the array.
+ * @return {(arr: Array<T>) => boolean}  Modified array-like variable.
+ */
+declare function some<T>(f: (item: T, i: number) => boolean): (arr: Array<T>) => boolean;

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

@@ -0,0 +1,8 @@
+export default sum;
+/**
+ * Convenience function for a reducer to sum up a numerical array.
+ * @param {number} a - Value A
+ * @param {number} b - Value B
+ * @return {number} Sum of A + B
+ */
+declare function sum(a: number, b: number): number;

package/dist/app/scripts/utils/svg-line.d.ts

@@ -0,0 +1,2 @@
+export function svgLine(x1: number, y1: number, x2: number, y2: number, strokeWidth: number, strokeColor: string): HTMLElement;
+export default svgLine;

package/dist/app/scripts/utils/throttle-and-debounce.d.ts

@@ -0,0 +1,33 @@
+export default throttleAndDebounce;
+/**
+ * Throttle and debounce a function call
+ *
+ * Throttling a function call means that the function is called at most every
+ * `interval` milliseconds no matter how frequently you trigger a call.
+ * Debouncing a function call means that the function is called the earliest
+ * after `finalWait` milliseconds wait time where the function was not called.
+ * Combining the two ensures that the function is called at most every
+ * `interval` milliseconds and is ensured to be called with the very latest
+ * arguments after after `finalWait` milliseconds wait time at the end.
+ *
+ * The following imaginary scenario describes the behavior:
+ *
+ * MS | interval=2 and finalWait=2
+ * 01. y(f, 2, 2)(args_01) => f(args_01) call
+ * 02. y(f, 2, 2)(args_02) => throttled call
+ * 03. y(f, 2, 2)(args_03) => f(args_03) call
+ * 04. y(f, 2, 2)(args_04) => throttled call
+ * 05. y(f, 2, 2)(args_05) => f(args_05) call
+ * 06. y(f, 2, 2)(args_06) => throttled call
+ * 07. y(f, 2, 2)(args_07) => f(args_03) call
+ * 08. y(f, 2, 2)(args_08) => throttled call
+ * 09. nothing
+ * 10. y(f, 2, 2)(args_10) => f(args_10) call from debouncing
+ *
+ * @template {any[]} Args
+ * @param {(...args: Args) => void} func - Function to be throttled and debounced
+ * @param {number} interval - Throttle intevals in milliseconds
+ * @param {number} finalWait - Debounce wait time in milliseconds
+ * @return {(request: unknown, ...args: Args) => void} - Throttled and debounced function
+ */
+declare function throttleAndDebounce<Args extends any[]>(func: (...args: Args) => void, interval: number, finalWait: number): (request: unknown, ...args: Args) => void;

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

@@ -0,0 +1,9 @@
+export default tileToCanvas;
+/**
+ * Convert a 1D numerical array into a canvas image
+ * @param {Uint8ClampedArray} pixData - 1D data array
+ * @param {number} w - Width
+ * @param {number} h - Height
+ * @return {object} Canvas object
+ */
+declare function tileToCanvas(pixData: Uint8ClampedArray, w?: number, h?: number): object;

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

@@ -0,0 +1,3 @@
+export default timeout;
+/** @param {number} ms */
+declare function timeout(ms: number): Promise<any>;

package/dist/app/scripts/utils/to-void.d.ts

@@ -0,0 +1,3 @@
+export default toVoid;
+/** @type {(...args: any[]) => void}  */
+declare const toVoid: (...args: any[]) => void;

package/dist/app/scripts/utils/total-track-pixel-height.d.ts

@@ -0,0 +1,27 @@
+export default totalTrackPixelHeight;
+export type Tracks = {
+    top?: {
+        height: number;
+    }[] | undefined;
+    center?: {
+        height: number;
+    }[] | undefined;
+    bottom?: {
+        height: number;
+    }[] | undefined;
+};
+/**
+ * @typedef Tracks
+ * @prop {{ height: number }[]=} top
+ * @prop {{ height: number }[]=} center
+ * @prop {{ height: number }[]=} bottom
+ */
+/**
+ * Calculate the total height of the horizontal and center tracks in pixels
+ *
+ * @param {{ tracks?: Tracks }} view - A typical view configuration containing a list of tracks
+ * @returns {number} - The total height of the top, center and bottom tracks
+ */
+declare function totalTrackPixelHeight(view: {
+    tracks?: Tracks;
+}): number;

package/dist/app/scripts/utils/trim-trailing-slash.d.ts

@@ -0,0 +1,7 @@
+export default trimTrailingSlash;
+/**
+ * Trim trailing slash of an URL.
+ * @param {string} url - URL to be trimmed.
+ * @return {string} Trimmed URL.
+ */
+declare function trimTrailingSlash(url: string): string;

package/dist/app/scripts/utils/type-guards.d.ts

@@ -0,0 +1,36 @@
+/** @import * as t from '../types' */
+/**
+ * @param {t.TrackConfig} trackConfig
+ * @return {trackConfig is t.CombinedTrackConfig}
+ */
+export function isCombinedTrackConfig(trackConfig: t.TrackConfig): trackConfig is t.CombinedTrackConfig;
+/**
+ * @param {Event} event
+ * @returns {event is WheelEvent}
+ */
+export function isWheelEvent(event: Event): event is WheelEvent;
+/**
+ * @param {unknown} obj
+ * @returns {obj is {}}
+ */
+export function isObject(obj: unknown): obj is {};
+/**
+ * @param {t.TilesetInfo | undefined} info
+ * @returns {info is t.LegacyTilesetInfo}
+ */
+export function isLegacyTilesetInfo(info: t.TilesetInfo | undefined): info is t.LegacyTilesetInfo;
+/**
+ * @param {t.TilesetInfo | undefined | { error: string }} info
+ * @returns {info is t.ResolutionsTilesetInfo}
+ */
+export function isResolutionsTilesetInfo(info: t.TilesetInfo | undefined | {
+    error: string;
+}): info is t.ResolutionsTilesetInfo;
+/**
+ * @param {t.TilesetInfo | undefined | { error: string }} info
+ * @returns {info is t.TilesetInfo}
+ */
+export function isTilesetInfo(info: t.TilesetInfo | undefined | {
+    error: string;
+}): info is t.TilesetInfo;
+import type * as t from '../types';

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

@@ -0,0 +1,12 @@
+export default valueToColor;
+/**
+ * Factory function for a value to RGB color converter
+ *
+ * @template T
+ * @param {(value: number) => number} valueScale - Value scaling function.
+ * @param {Array<T>} colorScale - Color scale array.
+ * @param {number} pseudoCounts - Pseudo counts used as a pseudocount to prevent taking the log of 0.
+ * @param {number} eps - Epsilon.
+ * @return {(value: number) => T} RGB color array.
+ */
+declare function valueToColor<T>(valueScale: (value: number) => number, colorScale: Array<T>, pseudoCounts?: number, eps?: number): (value: number) => T;

package/dist/app/scripts/utils/visit-positioned-tracks.d.ts

@@ -0,0 +1,18 @@
+export default visitPositionedTracks;
+export type PositionedTracks<T = TrackConfig> = { [Key in TrackPosition]?: Array<T>; };
+/** @import { TrackConfig, TrackPosition, TrackVisitor } from '../types' */
+/**
+ * @template [T=TrackConfig]
+ * @typedef {{ [Key in TrackPosition]?: Array<T> }} PositionedTracks
+ */
+/**
+ * Track visitor for positioned tracks, i.e., tracks with a position.
+ *
+ * @param {PositionedTracks} positionedTracks - List of all positioned tracks from the view definition.
+ * @param {TrackVisitor} visitor - Callback function receiving individual tracks.
+ * @param {boolean} inclCombinedTracks - If `true` recursively visit combined tracks.
+ */
+declare function visitPositionedTracks(positionedTracks: PositionedTracks, visitor: TrackVisitor, inclCombinedTracks?: boolean): TrackConfig[];
+import type { TrackConfig } from '../types';
+import type { TrackPosition } from '../types';
+import type { TrackVisitor } from '../types';

package/dist/app/scripts/utils/visit-tracks.d.ts

@@ -0,0 +1,9 @@
+export default visitTracks;
+/**
+ * Track visitor to run code on individual tracks.
+ * @param {import('../types').TrackConfig[]} tracks - List of all tracks from the view definition.
+ * @param {import('../types').TrackVisitor} visit - Callback function receiving individual tracks.
+ * @param {boolean} includeCombinedTracks - If `true` recursively visit combined tracks.
+ * @param {import('../types').TrackPosition | null} position - Can be used to limit the tracks to be visit to a certain position.
+ */
+declare function visitTracks(tracks: import("../types").TrackConfig[], visit: import("../types").TrackVisitor, includeCombinedTracks?: boolean, position?: import("../types").TrackPosition | null): void;

package/dist/esm.html

@@ -266,14 +266,12 @@
       }
     };
 
-    const hgApi = window.hgApi = hglib.viewer(
+    const hgApi = window.hgApi = await hglib.viewer(
       document.getElementById('demo'),
       viewConfig,
       { bounded: true },
     );
 
-    hgApi.setBroadcastMousePositionGlobally(true);
-
     hgApi.on('viewConfig', () => {
       console.log('View Config changed');
     });