@genome-spy/core 0.36.1 → 0.37.0

package/dist/src/types/flowBatch.d.ts

@@ -0,0 +1,40 @@
+import { Field } from "../spec/transform";
+
+export interface FlowBatchBase {
+    type: string;
+}
+
+/**
+ * Indicates that the contents of a new file will be propagated. The fields of
+ * the file may or may not differ from the previous file. The data items within
+ * a single batch must have homogenous fields.
+ *
+ * FlowNodes can react to FileBatches and, for example, clear their internal
+ * states that expect specific fields in a specific layout.
+ */
+export interface FileBatch {
+    type: "file";
+
+    /**
+     * An absolute or relative url where the file was loaded from.
+     */
+    url?: string;
+}
+
+/**
+ * Indicates that a new group/facet will be propagated. All data items that
+ * belong to a specific facet must be propagated within a single batch.
+ */
+export interface FacetBatch {
+    type: "facet";
+
+    facetId: any | any[];
+
+    /**
+     * The field or fields that were used for partitioning the data.
+     * May be missing if partitioning is not based on the fields.
+     */
+    facetField?: Field | Field[];
+}
+
+export type FlowBatch = FileBatch | FacetBatch;

package/dist/src/types/rendering.d.ts

@@ -0,0 +1,65 @@
+import Mark from "../marks/mark";
+import { LocSize } from "../utils/layout/flexLayout";
+import Rectangle from "../utils/layout/rectangle";
+
+/**
+ * Describes the location of a sample facet. Left is the primary pos, right is for
+ * transitioning between two sets of samples.
+ */
+export interface SampleFacetRenderingOptions {
+    /**
+     * Location and height on unit scale, zero at top
+     */
+    locSize: LocSize;
+
+    /**
+     * Target (during transition)
+     */
+    targetLocSize?: LocSize;
+}
+
+export interface RenderingOptions {
+    /**
+     * Which facet to render (if faceting is being used)
+     */
+    facetId?: any;
+
+    sampleFacetRenderingOptions?: SampleFacetRenderingOptions;
+
+    /**
+     * Clip rendering using the given rectangle.
+     * Mainly intended for clipping scrollable views.
+     */
+    clipRect?: Rectangle;
+}
+
+/**
+ * Options that affect the whole rendering pass.
+ */
+export interface GlobalRenderingOptions {
+    /**
+     * Replace colors with unique ids for picking.
+     * Views that haven't enabled picking can be skipped.
+     */
+    picking?: boolean;
+}
+
+/**
+ * Allows for collecting marks for optimized rendering order.
+ */
+
+export interface BufferedRenderingRequest {
+    mark: Mark;
+    callback: () => void;
+    coords: Rectangle;
+    clipRect?: Rectangle;
+}
+
+/**
+ * Method signature for View.render(). Reduces the amount of JSDoc needed.
+ */
+export type RenderMethod = (
+    context: ViewRenderingContext,
+    coords: Rectangle,
+    options?: RenderingOptions
+) => void;

package/dist/src/types/scaleResolutionApi.d.ts

@@ -0,0 +1,40 @@
+import { ComplexDomain, NumericDomain } from "../spec/scale";
+import ScaleResolution from "../view/scaleResolution";
+
+export interface ScaleResolutionEvent {
+    type: "domain";
+
+    scaleResolution: ScaleResolution;
+}
+
+export type ScaleResolutionListener = (event: ScaleResolutionEvent) => void;
+
+/**
+ * A public API for ScaleResolution
+ */
+export interface ScaleResolutionApi {
+    addEventListener(type: "domain", listener: ScaleResolutionListener): void;
+
+    removeEventListener(
+        type: "domain",
+        listener: ScaleResolutionListener
+    ): void;
+
+    /**
+     * Returns the current, possible zoomed domain.
+     */
+    getDomain(): any[];
+
+    /**
+     * Returns the current, possible zoomed domain converted into complex objects
+     * such as genomic coordinates.
+     */
+    getComplexDomain(): NumericDomain | ComplexDomain;
+
+    isZoomable(): boolean;
+
+    zoomTo(
+        domain: number[] | ComplexDomain,
+        duration?: boolean | number
+    ): Promise<void>;
+}

package/dist/src/types/viewContext.d.ts

@@ -0,0 +1,85 @@
+import { TemplateResult } from "lit-html";
+import View, { BroadcastMessage } from "../view/view";
+import DataFlow from "../data/dataFlow";
+import AccessorFactory from "../encoder/accessor";
+import WebGLHelper from "../gl/webGLHelper";
+import Animator from "../utils/animator";
+import GenomeStore from "../genome/genomeStore";
+import BmFontManager from "../fonts/bmFontManager";
+import Mark from "../marks/mark";
+import { Datum } from "../data/flowNode";
+import { ViewSpec } from "../spec/view";
+import ContainerView from "./containerView";
+import { BroadcastEventType } from "../genomeSpy";
+
+export interface Hover {
+    mark: Mark;
+    datum: Datum;
+}
+
+/**
+ * ViewContext provides essential data and interfaces to View classes.
+ */
+export default interface ViewContext {
+    dataFlow: DataFlow<View>;
+    accessorFactory: AccessorFactory;
+    glHelper: WebGLHelper;
+    animator: Animator;
+    genomeStore?: GenomeStore;
+    fontManager: BmFontManager;
+
+    devicePixelRatio: number;
+
+    requestLayoutReflow: () => void;
+
+    updateTooltip: <T>(
+        datum: T,
+        converter?: (datum: T) => Promise<TemplateResult>
+    ) => void;
+
+    getCurrentHover: () => Hover;
+
+    /**
+     * Adds a keyboard event listener to the document. Cleanup is performed automatically
+     * when GenomeSpy is finalized.
+     *
+     * TODO: Listeners should be called only when the mouse pointer is inside the
+     * container or the app covers the full document.
+     */
+    addKeyboardListener: (
+        type: "keydown" | "keyup",
+        listener: (event: KeyboardEvent) => void
+    ) => void;
+
+    /**
+     * Registers a listener for broadcast messages.
+     * Typically broadcast messages are automatically broadcasted to all views.
+     * However, in some cases non-view components may be interested in these messages.
+     */
+    addBroadcastListener: (
+        type: BroadcastEventType,
+        listener: (message: BroadcastMessage) => void
+    ) => void;
+
+    removeBroadcastListener: (
+        type: BroadcastEventType,
+        listener: (message: BroadcastMessage) => void
+    ) => void;
+
+    getNamedDataFromProvider: (name: string) => any[];
+
+    /**
+     * Returns true if the view is configured to be visible.
+     * N.B. This does NOT consider ancestors' visibility.
+     */
+    isViewConfiguredVisible: (view: View) => boolean;
+
+    isViewSpec: (spec: any) => boolean;
+
+    createView: (
+        spec: ViewSpec,
+        layoutParent?: ContainerView,
+        dataParent?: View,
+        defaultName?: string
+    ) => View;
+}

package/dist/src/utils/addBaseUrl.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {string} url
+ * @param {string} baseUrl
+ */
+export default function addBaseUrl(url: string, baseUrl: string): string;
+//# sourceMappingURL=addBaseUrl.d.ts.map

package/dist/src/utils/addBaseUrl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addBaseUrl.d.ts","sourceRoot":"","sources":["../../../src/utils/addBaseUrl.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wCAHW,MAAM,WACN,MAAM,UAgBhB"}

package/dist/src/utils/addBaseUrl.js

@@ -0,0 +1,19 @@
+/**
+ * @param {string} url
+ * @param {string} baseUrl
+ */
+export default function addBaseUrl(url, baseUrl) {
+    // Regex copied from vega-loader
+    if (!baseUrl || /^(data:|([A-Za-z]+:)?\/\/)/.test(url)) {
+        return url;
+    }
+
+    if (!url.startsWith("/")) {
+        if (!baseUrl.endsWith("/")) {
+            baseUrl += "/";
+        }
+        return baseUrl + url;
+    }
+
+    return url;
+}

package/dist/src/utils/addBaseUrl.test.js

@@ -0,0 +1,22 @@
+import { expect, test } from "vitest";
+import addBaseUrl from "./addBaseUrl";
+
+test("addBaseUrl adds baseUrl when needed", () => {
+    expect(addBaseUrl("foo.html", "https://site.com/")).toEqual(
+        "https://site.com/foo.html"
+    );
+    expect(addBaseUrl("foo.html", "https://site.com")).toEqual(
+        "https://site.com/foo.html"
+    );
+    expect(addBaseUrl("bar/foo.html", "https://site.com/")).toEqual(
+        "https://site.com/bar/foo.html"
+    );
+    expect(addBaseUrl("../foo.html", "https://site.com/bar/")).toEqual(
+        "https://site.com/bar/../foo.html"
+    );
+});
+
+test("addBaseUrl doesn't add baseUrl when not needed", () => {
+    expect(addBaseUrl("/foo.html", "https://site.com/")).toEqual("/foo.html");
+    expect(addBaseUrl("foo.html", undefined)).toEqual("foo.html");
+});

package/dist/src/utils/animator.d.ts

@@ -0,0 +1,41 @@
+export default class Animator {
+    /**
+     *
+     * @param {function(number):void} renderCallback
+     */
+    constructor(renderCallback: (arg0: number) => void);
+    _renderCallback: (arg0: number) => void;
+    _renderRequested: boolean;
+    _warn: boolean;
+    /** @type {(function(number):void)[]} */
+    transitions: ((arg0: number) => void)[];
+    /**
+     * Schedules a "transition" to be called before the actual rendering
+     * is preformed. The transition could adjust the layout, for example.
+     * This method also requests rendering to be performed.
+     *
+     * If the callback has already been requested (compared by identity),
+     * it is removed from the queue and added to the end.
+     *
+     * @param {function(number):void} callback
+     */
+    requestTransition(callback: (arg0: number) => void): void;
+    /**
+     * @param {function(number):void} callback
+     */
+    cancelTransition(callback: (arg0: number) => void): void;
+    /**
+     * Requests the request transitions and rendering callback to be called
+     * during the next animation frame. Redundant calls to this method are safe,
+     * they have no effect.
+     */
+    requestRender(): void;
+    /**
+     * Initiates a transition with a `requestAnimationFrame` that is synced
+     * with this Animator instance.
+     *
+     * @param {import("./transition").TransitionOptions} options
+     */
+    transition(options: import("./transition").TransitionOptions): Promise<any>;
+}
+//# sourceMappingURL=animator.d.ts.map

package/dist/src/utils/animator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animator.d.ts","sourceRoot":"","sources":["../../../src/utils/animator.js"],"names":[],"mappings":"AAEA;IACI;;;OAGG;IACH,mCAFoB,MAAM,KAAE,IAAI,EAS/B;IANG,wBAHgB,MAAM,KAAE,IAAI,CAGS;IACrC,0BAA6B;IAC7B,eAAkB;IAElB,wCAAwC;IACxC,qBADqB,MAAM,KAAE,IAAI,IACZ;IAGzB;;;;;;;;;OASG;IACH,mCAFoB,MAAM,KAAE,IAAI,QAM/B;IAED;;OAEG;IACH,kCAFoB,MAAM,KAAE,IAAI,QAO/B;IAED;;;;OAIG;IACH,sBAoBC;IAED;;;;;OAKG;IACH,oBAFW,OAAO,cAAc,EAAE,iBAAiB,gBAQlD;CACJ"}

package/dist/src/utils/animator.js

@@ -0,0 +1,83 @@
+import doTransition from "./transition";
+
+export default class Animator {
+    /**
+     *
+     * @param {function(number):void} renderCallback
+     */
+    constructor(renderCallback) {
+        this._renderCallback = renderCallback;
+        this._renderRequested = false;
+        this._warn = false;
+
+        /** @type {(function(number):void)[]} */
+        this.transitions = [];
+    }
+
+    /**
+     * Schedules a "transition" to be called before the actual rendering
+     * is preformed. The transition could adjust the layout, for example.
+     * This method also requests rendering to be performed.
+     *
+     * If the callback has already been requested (compared by identity),
+     * it is removed from the queue and added to the end.
+     *
+     * @param {function(number):void} callback
+     */
+    requestTransition(callback) {
+        this.cancelTransition(callback);
+        this.transitions.push(callback);
+        this.requestRender();
+    }
+
+    /**
+     * @param {function(number):void} callback
+     */
+    cancelTransition(callback) {
+        const existingIndex = this.transitions.indexOf(callback);
+        if (existingIndex >= 0) {
+            this.transitions.splice(existingIndex, 1);
+        }
+    }
+
+    /**
+     * Requests the request transitions and rendering callback to be called
+     * during the next animation frame. Redundant calls to this method are safe,
+     * they have no effect.
+     */
+    requestRender() {
+        if (!this._renderRequested) {
+            this._renderRequested = true;
+            window.requestAnimationFrame((timestamp) => {
+                this._renderRequested = false;
+
+                const transitions = this.transitions;
+                this.transitions = [];
+
+                /** @type {function} */
+                let transitionCallback;
+                while ((transitionCallback = transitions.shift())) {
+                    transitionCallback(timestamp);
+                }
+
+                this._renderCallback(timestamp);
+            });
+        } else if (this._warn) {
+            console.warn("Render already requested!");
+        }
+    }
+
+    /**
+     * Initiates a transition with a `requestAnimationFrame` that is synced
+     * with this Animator instance.
+     *
+     * @param {import("./transition").TransitionOptions} options
+     */
+    transition(options) {
+        return doTransition({
+            requestAnimationFrame: (callback) =>
+                this.requestTransition(callback),
+            ...options,
+        });
+    }
+}

package/dist/src/utils/arrayUtils.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @param {T[]} a
+ * @param {T[]} b
+ * @template T
+ */
+export function shallowArrayEquals<T>(a: T[], b: T[]): boolean;
+/**
+ * @param {A[]} a
+ * @param {B[]} b
+ * @param {function(A):T} aAccessor
+ * @param {function(B):T} bAccessor
+ * @template A, B, T
+ */
+export function shallowArrayEqualsWithAccessors<A, B, T>(a: A[], b: B[], aAccessor: (arg0: A) => T, bAccessor: (arg0: B) => T): boolean;
+/**
+ *
+ * @param {any[]} a
+ */
+export function isHomogeneous(a: any[]): boolean;
+/**
+ * @param {T[] | T} obj
+ * @returns {T[]}
+ * @template T
+ */
+export function asArray<T>(obj: T | T[]): T[];
+/**
+ * Returns the last element of an array.
+ * Like vega-util's peek but with stricter typings
+ *
+ * @param {T[]} arr
+ * @template T
+ */
+export function peek<T>(arr: T[]): T;
+//# sourceMappingURL=arrayUtils.d.ts.map

package/dist/src/utils/arrayUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrayUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/arrayUtils.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,+DAEC;AAED;;;;;;GAMG;AACH,wIAKC;AAED;;;GAGG;AACH,iCAFW,GAAG,EAAE,WASf;AAED;;;;GAIG;AACH,8CAQC;AAED;;;;;;GAMG;AACH,qCAEC"}

package/dist/src/utils/arrayUtils.js

@@ -0,0 +1,61 @@
+/**
+ * @param {T[]} a
+ * @param {T[]} b
+ * @template T
+ */
+export function shallowArrayEquals(a, b) {
+    return a.length == b.length && a.every((s, i) => a[i] === b[i]);
+}
+
+/**
+ * @param {A[]} a
+ * @param {B[]} b
+ * @param {function(A):T} aAccessor
+ * @param {function(B):T} bAccessor
+ * @template A, B, T
+ */
+export function shallowArrayEqualsWithAccessors(a, b, aAccessor, bAccessor) {
+    return (
+        a.length == b.length &&
+        a.every((s, i) => aAccessor(a[i]) === bAccessor(b[i]))
+    );
+}
+
+/**
+ *
+ * @param {any[]} a
+ */
+export function isHomogeneous(a) {
+    if (a.length <= 1) {
+        return true;
+    }
+
+    const first = a[0];
+    return a.every((x) => x === first);
+}
+
+/**
+ * @param {T[] | T} obj
+ * @returns {T[]}
+ * @template T
+ */
+export function asArray(obj) {
+    if (Array.isArray(obj)) {
+        return obj;
+    } else if (typeof obj != "undefined") {
+        return [obj];
+    } else {
+        return [];
+    }
+}
+
+/**
+ * Returns the last element of an array.
+ * Like vega-util's peek but with stricter typings
+ *
+ * @param {T[]} arr
+ * @template T
+ */
+export function peek(arr) {
+    return arr[arr.length - 1];
+}

package/dist/src/utils/binnedIndex.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @callback Lookup
+ * @param {number} start
+ * @param {number} end
+ * @param {[number, number]} [arr] Store the result into this array (and return it)
+ * @returns {[number, number]}
+ */
+/**
+ * A binned index for (overlapping) ranges that are sorted by their start position.
+ * Each indexed range is associated with respective vertex indices.
+ *
+ * @param {number} size Number of bins
+ * @param {[number, number]} domain Domain of positions
+ * @param {(datum: T) => number} accessor Accessor for range's start position
+ * @param {(datum: T) => number} [accessor2] Accessor for range's end position
+ * @template T
+ */
+export function createBinningRangeIndexer<T>(size: number, domain: [number, number], accessor: (datum: T) => number, accessor2?: (datum: T) => number): {
+    (datum: T, startVertexIndex: number, endVertexIndex: number): void;
+    getIndex: () => Lookup;
+};
+export type Lookup = (start: number, end: number, arr?: [number, number]) => [number, number];
+//# sourceMappingURL=binnedIndex.d.ts.map

package/dist/src/utils/binnedIndex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binnedIndex.d.ts","sourceRoot":"","sources":["../../../src/utils/binnedIndex.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AAEH;;;;;;;;;GASG;AACH,mDANW,MAAM,UACN,CAAC,MAAM,EAAE,MAAM,CAAC,0BACF,MAAM,4BACN,MAAM;iCAyChB,MAAM,kBACN,MAAM;;EAwGpB;6BA/JU,MAAM,OACN,MAAM,QACN,CAAC,MAAM,EAAE,MAAM,CAAC,KACd,CAAC,MAAM,EAAE,MAAM,CAAC"}