@genome-spy/core 0.36.1 → 0.37.1

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

@@ -0,0 +1,22 @@
+/**
+ * Finds the top k
+ *
+ * Based on ideas at https://lemire.me/blog/2017/06/21/top-speed-for-top-k-queries/
+ *
+ * @param {T[]} data
+ * @param {number} k
+ * @param {(datum: T) => number} priorityAccessor
+ * @template T
+ */
+export function topK<T>(data: T[], k: number, priorityAccessor: (datum: T) => number): T[];
+/**
+ * Takes an array of priorities and returns the top k indices from the
+ * specified slice
+ *
+ * @param {number[]} priorities An array of priorities
+ * @param {number} k
+ * @param {number} [start] Default: 0
+ * @param {number} [end] Exclusive. Default: priorities.length
+ */
+export function topKSlice(priorities: number[], k: number, start?: number, end?: number): number[];
+//# sourceMappingURL=topK.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"topK.d.ts","sourceRoot":"","sources":["../../../src/utils/topK.js"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,sCAJW,MAAM,kCACQ,MAAM,OA4B9B;AAED;;;;;;;;GAQG;AACH,sCALW,MAAM,EAAE,KACR,MAAM,UACN,MAAM,QACN,MAAM,YA6BhB"}

package/dist/src/utils/topK.js

@@ -0,0 +1,76 @@
+import FlatQueue from "flatqueue";
+
+/**
+ * Finds the top k
+ *
+ * Based on ideas at https://lemire.me/blog/2017/06/21/top-speed-for-top-k-queries/
+ *
+ * @param {T[]} data
+ * @param {number} k
+ * @param {(datum: T) => number} priorityAccessor
+ * @template T
+ */
+export function topK(data, k, priorityAccessor) {
+    /** @type {FlatQueue<number>} */
+    const queue = new FlatQueue();
+
+    let i;
+    for (i = 0; i < k && i < data.length; i++) {
+        queue.push(i, priorityAccessor(data[i]));
+    }
+
+    for (; i < data.length; i++) {
+        const p = priorityAccessor(data[i]);
+        if (p >= queue.peekValue()) {
+            queue.push(i, p);
+            queue.pop();
+        }
+    }
+
+    const result = [];
+
+    let index;
+    while ((index = queue.pop()) !== undefined) {
+        result.push(data[index]);
+    }
+
+    return result.reverse();
+}
+
+/**
+ * Takes an array of priorities and returns the top k indices from the
+ * specified slice
+ *
+ * @param {number[]} priorities An array of priorities
+ * @param {number} k
+ * @param {number} [start] Default: 0
+ * @param {number} [end] Exclusive. Default: priorities.length
+ */
+export function topKSlice(priorities, k, start = 0, end = priorities.length) {
+    /** @type {FlatQueue<number>} */
+    const queue = new FlatQueue();
+
+    const sliceLength = end - start;
+
+    let i;
+    for (i = 0; i < k && i < sliceLength; i++) {
+        queue.push(i, priorities[start + i]);
+    }
+
+    for (; i < sliceLength; i++) {
+        const p = priorities[start + i];
+        if (p >= queue.peekValue()) {
+            queue.push(i, p);
+            queue.pop();
+        }
+    }
+
+    const result = [];
+
+    let index;
+    while ((index = queue.pop()) !== undefined) {
+        result.push(start + index);
+    }
+
+    return result.reverse();
+}

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

@@ -0,0 +1,64 @@
+import { expect, test } from "vitest";
+import { range } from "d3-array";
+import { topK, topKSlice } from "./topK";
+
+test("topK returns top k numbers in priority order", () => {
+    /** @param {number} x */
+    const priorityAccessor = (x) => x;
+
+    expect(topK([1, 2, 3], 3, priorityAccessor)).toEqual([3, 2, 1]);
+    expect(topK([1, 2, 3], 1, priorityAccessor)).toEqual([3]);
+    expect(topK([1, 2, 3], 6, priorityAccessor)).toEqual([3, 2, 1]);
+    expect(topK([1, 2, 3, 4, 5, 6], 3, priorityAccessor)).toEqual([6, 5, 4]);
+    expect(topK([0, 9, 1, 8, 2, 7, 3, 6, 4, 5], 3, priorityAccessor)).toEqual([
+        9, 8, 7,
+    ]);
+    expect(topK([1, 1, 1], 3, priorityAccessor)).toEqual([1, 1, 1]);
+});
+
+test("topK returns top k objects in priority order", () => {
+    /** @param {{priority: number}} d */
+    const priorityAccessor = (d) => d.priority;
+
+    expect(
+        topK(
+            [0, 9, 1, 8, 2, 7, 3, 6, 4, 5].map((x) => ({ priority: x })),
+            3,
+            priorityAccessor
+        )
+    ).toEqual([9, 8, 7].map((x) => ({ priority: x })));
+});
+
+test("topK returns top k objects in priority order with large datasets", () => {
+    /** @param {number} x */
+    const priorityAccessor = (x) => x;
+
+    const n = 10000;
+    const bigArray = range(n).map((x) => Math.floor(Math.random() * 100));
+    const sortedBigArray = bigArray.slice().sort((a, b) => b - a);
+
+    for (let k = 0; k < 13000; k += 1000) {
+        expect(topK(bigArray, k, priorityAccessor)).toEqual(
+            sortedBigArray.slice(0, k)
+        );
+    }
+});
+
+test("topKSlice returns top k indexes in priority order", () => {
+    expect(topKSlice([0, 1, 2], 3)).toEqual([2, 1, 0]);
+    expect(topKSlice([1, 2, 3], 3)).toEqual([2, 1, 0]);
+    expect(topKSlice([0, 1, 2], 1)).toEqual([2]);
+    expect(topKSlice([0, 1, 2], 6)).toEqual([2, 1, 0]);
+    expect(topKSlice([0, 1, 2, 3, 4, 5], 3)).toEqual([5, 4, 3]);
+    expect(topKSlice([0, 9, 1, 8, 2, 7, 3, 6, 4, 5], 3)).toEqual([1, 3, 5]);
+    expect(new Set(topKSlice([1, 1, 1, 2, 2, 2], 3))).toEqual(
+        new Set([3, 4, 5])
+    );
+});
+
+test("topKSlice returns top k indexes from a slice in priority order", () => {
+    expect(topKSlice([0, 1, 2, 3, 4, 5], 2, 1, 5)).toEqual([4, 3]);
+    expect(topKSlice([0, 9, 1, 8, 2, 7, 3, 6, 4, 5], 3, 1, 5)).toEqual([
+        1, 3, 4,
+    ]);
+});

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

@@ -0,0 +1,44 @@
+/**
+ * @param {TransitionOptions} options
+ *
+ * @typedef {Object} TransitionOptions
+ * @prop {number} [from] default: 0
+ * @prop {number} [to] default: 1
+ * @prop {number} [duration] in milliseconds, default: 1000
+ * @prop {number} [delay] milliseconds to wait before the transition starts, default: 0
+ * @prop {function(number):void} onUpdate
+ * @prop {function(number):number} [easingFunction] default: linear
+ * @prop {function(function(number):void):void} [requestAnimationFrame]
+ *      default: window.requestAnimationFrame
+ * @prop {AbortSignal} [signal]
+ */
+export default function transition(options: TransitionOptions): Promise<any>;
+export type TransitionOptions = {
+    /**
+     * default: 0
+     */
+    from?: number;
+    /**
+     * default: 1
+     */
+    to?: number;
+    /**
+     * in milliseconds, default: 1000
+     */
+    duration?: number;
+    /**
+     * milliseconds to wait before the transition starts, default: 0
+     */
+    delay?: number;
+    onUpdate: (arg0: number) => void;
+    /**
+     * default: linear
+     */
+    easingFunction?: (arg0: number) => number;
+    /**
+     * default: window.requestAnimationFrame
+     */
+    requestAnimationFrame?: (arg0: (arg0: number) => void) => void;
+    signal?: AbortSignal;
+};
+//# sourceMappingURL=transition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transition.d.ts","sourceRoot":"","sources":["../../../src/utils/transition.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH,4CAbW,iBAAiB,gBAqE3B;;;;;WAlES,MAAM;;;;SACN,MAAM;;;;eACN,MAAM;;;;YACN,MAAM;qBACG,MAAM,KAAE,IAAI;;;;4BACZ,MAAM,KAAE,MAAM;;;;0CACL,MAAM,KAAE,IAAI,KAAE,IAAI;aAEpC,WAAW"}

package/dist/src/utils/transition.js

@@ -0,0 +1,74 @@
+/** @param {number} ms */
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+/**
+ * @param {TransitionOptions} options
+ *
+ * @typedef {Object} TransitionOptions
+ * @prop {number} [from] default: 0
+ * @prop {number} [to] default: 1
+ * @prop {number} [duration] in milliseconds, default: 1000
+ * @prop {number} [delay] milliseconds to wait before the transition starts, default: 0
+ * @prop {function(number):void} onUpdate
+ * @prop {function(number):number} [easingFunction] default: linear
+ * @prop {function(function(number):void):void} [requestAnimationFrame]
+ *      default: window.requestAnimationFrame
+ * @prop {AbortSignal} [signal]
+ */
+export default function transition(options) {
+    const requestAnimationFrame =
+        options.requestAnimationFrame || window.requestAnimationFrame;
+
+    const signal = options.signal;
+
+    const makePromise = () =>
+        new Promise((resolve, reject) => {
+            if (signal?.aborted) {
+                return reject("aborted");
+            }
+
+            const beginTimestamp = performance.now();
+            const endTimestamp = beginTimestamp + (options.duration || 1000);
+
+            const from = typeof options.from == "number" ? options.from : 0;
+            const to = typeof options.to == "number" ? options.to : 1;
+            const ease = options.easingFunction || ((x) => x);
+
+            /** @param {number} x */
+            const toUnit = (x) =>
+                (x - beginTimestamp) / (endTimestamp - beginTimestamp);
+
+            /** @param {number} x */
+            const toRange = (x) => x * (to - from) + from;
+
+            /** @param {number} x */
+            const clamp = (x) => Math.max(0, Math.min(1, x));
+
+            /** @param {number} stamp */
+            const step = (stamp) => {
+                if (signal?.aborted) {
+                    reject("aborted");
+                } else {
+                    options.onUpdate(toRange(ease(clamp(toUnit(stamp)))));
+                    if (stamp < endTimestamp) {
+                        requestAnimationFrame(step);
+                    } else {
+                        options.onUpdate(toRange(ease(1)));
+                        resolve();
+                    }
+                }
+            };
+
+            requestAnimationFrame(step);
+        });
+
+    if (options.delay) {
+        if (signal?.aborted) {
+            return Promise.reject("aborted");
+        }
+
+        return wait(options.delay).then(makePromise);
+    } else {
+        return makePromise();
+    }
+}

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

@@ -0,0 +1,56 @@
+/**
+ * Takes an array of nodes that have parent references and turns them into a
+ * tree of nodes. The original nodes are not modified, they are wrapped in a
+ * new object. Uses a custom accessor for parent.
+ *
+ * @param {T[]} nodes
+ * @param {(node: T) => T} parentAccessor
+ * @template T
+ * @returns {NodeWrapper<T>[]}
+ */
+export function nodesToTreesWithAccessor<T>(nodes: T[], parentAccessor: (node: T) => T): {
+    ref: T;
+    children: any[];
+}[];
+/**
+ * Takes an array of nodes that have parent references and turns them into a
+ * tree of nodes. The original nodes are not modified, they are wrapped in a
+ * new object.
+ *
+ * @param {T[]} nodes
+ * @template {{ parent: T}} T
+ */
+export function nodesToTrees<T extends {
+    parent: T;
+}>(nodes: T[]): {
+    ref: T;
+    children: any[];
+}[];
+/**
+ * Visits a tree using depth-first search. Uses a custom accessor for children.
+ *
+ * @param {T} rootNode
+ * @param {{ preOrder?: (node: T) => VisitResult, postOrder?: (node: T) => VisitResult }} visitor
+ * @param {(node: T) => Iterable<T>} childrenAccessor
+ * @returns {VisitResult}
+ * @template T
+ */
+export function visitTreeWithAccessor<T>(rootNode: T, visitor: {
+    preOrder?: (node: T) => void | "stop" | "skip";
+    postOrder?: (node: T) => void | "stop" | "skip";
+}, childrenAccessor: (node: T) => Iterable<T>): void | "stop" | "skip";
+/**
+ * Visits a tree using depth-first search.
+ *
+ * @param {T} rootNode
+ * @param {{ preOrder?: (node: T) => VisitResult, postOrder?: (node: T) => VisitResult }} visitor
+ * @returns {VisitResult}
+ * @template {{ children: T[] }} T
+ */
+export function visitTree<T extends {
+    children: T[];
+}>(rootNode: T, visitor: {
+    preOrder?: (node: T) => void | "stop" | "skip";
+    postOrder?: (node: T) => void | "stop" | "skip";
+}): void | "stop" | "skip";
+//# sourceMappingURL=trees.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"trees.d.ts","sourceRoot":"","sources":["../../../src/utils/trees.js"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH;;;IA0BC;AAED;;;;;;;GAOG;AACH;;;;;IAEC;AAED;;;;;;;;GAQG;AACH;;;uEAmBC;AAED;;;;;;;GAOG;AACH;;;;;2BAGC"}

package/dist/src/utils/trees.js

@@ -0,0 +1,92 @@
+/**
+ * Takes an array of nodes that have parent references and turns them into a
+ * tree of nodes. The original nodes are not modified, they are wrapped in a
+ * new object. Uses a custom accessor for parent.
+ *
+ * @param {T[]} nodes
+ * @param {(node: T) => T} parentAccessor
+ * @template T
+ * @returns {NodeWrapper<T>[]}
+ */
+export function nodesToTreesWithAccessor(nodes, parentAccessor) {
+    /**
+     * @typedef {object} NodeWrapper
+     * @prop {T} ref
+     * @prop {NodeWrapper<T>[]} children
+     * @template T
+     */
+
+    /** @type {Map<T, NodeWrapper<T>>} */
+    const nodeMap = new Map();
+    const rootNodes = [];
+
+    for (const node of nodes) {
+        nodeMap.set(node, { ref: node, children: [] });
+    }
+
+    for (const nodeWrapper of nodeMap.values()) {
+        const parent = nodeMap.get(parentAccessor(nodeWrapper.ref));
+        if (parent) {
+            parent.children.push(nodeWrapper);
+        } else {
+            rootNodes.push(nodeWrapper);
+        }
+    }
+
+    return rootNodes;
+}
+
+/**
+ * Takes an array of nodes that have parent references and turns them into a
+ * tree of nodes. The original nodes are not modified, they are wrapped in a
+ * new object.
+ *
+ * @param {T[]} nodes
+ * @template {{ parent: T}} T
+ */
+export function nodesToTrees(nodes) {
+    return nodesToTreesWithAccessor(nodes, (node) => node.parent);
+}
+
+/**
+ * Visits a tree using depth-first search. Uses a custom accessor for children.
+ *
+ * @param {T} rootNode
+ * @param {{ preOrder?: (node: T) => VisitResult, postOrder?: (node: T) => VisitResult }} visitor
+ * @param {(node: T) => Iterable<T>} childrenAccessor
+ * @returns {VisitResult}
+ * @template T
+ */
+export function visitTreeWithAccessor(rootNode, visitor, childrenAccessor) {
+    /** @typedef {"skip" | "stop" | void} VisitResult */
+    const preResult = visitor.preOrder?.(rootNode);
+    if (preResult) {
+        return preResult;
+    }
+
+    for (const child of childrenAccessor(rootNode)) {
+        const childResult = visitTreeWithAccessor(
+            child,
+            visitor,
+            childrenAccessor
+        );
+        if (childResult === "stop") {
+            return childResult;
+        }
+    }
+
+    return visitor.postOrder?.(rootNode);
+}
+
+/**
+ * Visits a tree using depth-first search.
+ *
+ * @param {T} rootNode
+ * @param {{ preOrder?: (node: T) => VisitResult, postOrder?: (node: T) => VisitResult }} visitor
+ * @returns {VisitResult}
+ * @template {{ children: T[] }} T
+ */
+export function visitTree(rootNode, visitor) {
+    /** @typedef {"skip" | "stop" | void} VisitResult */
+    return visitTreeWithAccessor(rootNode, visitor, (node) => node.children);
+}

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

@@ -0,0 +1,130 @@
+import { expect, test } from "vitest";
+import { nodesToTrees, visitTree } from "./trees";
+import { describe } from "vitest";
+
+describe("NodesToTrees", () => {
+    test("NodesToTrees converts an array of nodes to a tree", () => {
+        const a = { parent: null };
+        const b = { parent: a };
+        const c = { parent: a };
+        const d = { parent: b };
+        const e = { parent: b };
+
+        const nodes = [a, b, c, d, e];
+
+        const trees = nodesToTrees(nodes);
+
+        expect(trees).toEqual([
+            {
+                ref: a,
+                children: [
+                    {
+                        ref: b,
+                        children: [
+                            {
+                                ref: d,
+                                children: [],
+                            },
+                            {
+                                ref: e,
+                                children: [],
+                            },
+                        ],
+                    },
+                    {
+                        ref: c,
+                        children: [],
+                    },
+                ],
+            },
+        ]);
+    });
+
+    test("NodesToTrees converts two disjoint node arrays to two trees", () => {
+        const a = { parent: null };
+        const b = { parent: a };
+
+        const c = { parent: null };
+        const d = { parent: c };
+
+        const nodes = [a, b, c, d];
+
+        const trees = nodesToTrees(nodes);
+
+        expect(trees).toEqual([
+            {
+                ref: a,
+                children: [
+                    {
+                        ref: b,
+                        children: [],
+                    },
+                ],
+            },
+            {
+                ref: c,
+                children: [
+                    {
+                        ref: d,
+                        children: [],
+                    },
+                ],
+            },
+        ]);
+    });
+});
+
+describe("VisitTree", () => {
+    test("VisitTree visits all nodes in a tree in correct order", () => {
+        const tree = {
+            id: "a",
+            children: [
+                {
+                    id: "b",
+                    children: [
+                        {
+                            id: "d",
+                            children: [],
+                        },
+                        {
+                            id: "e",
+                            children: [],
+                        },
+                    ],
+                },
+                {
+                    id: "c",
+                    children: [],
+                },
+            ],
+        };
+
+        const visitedPre = [];
+        const visitedPost = [];
+
+        visitTree(tree, {
+            preOrder: (node) => {
+                visitedPre.push(node);
+            },
+            postOrder: (node) => {
+                visitedPost.push(node);
+            },
+        });
+
+        expect(visitedPre.map((node) => node.id)).toEqual([
+            "a",
+            "b",
+            "d",
+            "e",
+            "c",
+        ]);
+
+        expect(visitedPost.map((node) => node.id)).toEqual([
+            "d",
+            "e",
+            "b",
+            "c",
+            "a",
+        ]);
+    });
+});

package/dist/src/utils/ui/tooltip.d.ts

@@ -0,0 +1,50 @@
+export const SUPPRESS_TOOLTIP_CLASS_NAME: "gs-suppress-tooltip";
+export default class Tooltip {
+    /**
+     * @param {HTMLElement} container
+     */
+    constructor(container: HTMLElement);
+    container: HTMLElement;
+    element: HTMLDivElement;
+    _visible: boolean;
+    /** @type {any} */
+    _previousTooltipDatum: any;
+    enabledStack: boolean[];
+    _penaltyUntil: number;
+    /** @type {[number, number]} */
+    _lastCoords: [number, number];
+    _previousMove: number;
+    /**
+     * @param {boolean} visible
+     */
+    set visible(arg: boolean);
+    get visible(): boolean;
+    get enabled(): boolean;
+    /**
+     * @param {boolean} enabled True if tooltip is enabled (allowed to be shown)
+     */
+    pushEnabledState(enabled: boolean): void;
+    popEnabledState(): void;
+    /**
+     * @param {MouseEvent} mouseEvent
+     */
+    handleMouseMove(mouseEvent: MouseEvent): void;
+    mouseCoords: [number, number];
+    updatePlacement(): void;
+    /**
+     * @param {string | import("lit").TemplateResult | HTMLElement} content
+     */
+    setContent(content: string | import("lit").TemplateResult | HTMLElement): void;
+    clear(): void;
+    /**
+     * Updates the tooltip if the provided datum differs from the previous one.
+     * Otherwise this is nop.
+     *
+     * @param {T} datum
+     * @param {function(T):Promise<string | HTMLElement | import("lit").TemplateResult>} [converter]
+     * @template T
+     */
+    updateWithDatum<T>(datum: T, converter?: (arg0: T) => Promise<string | HTMLElement | import("lit").TemplateResult>): void;
+    _isPenalty(): boolean;
+}
+//# sourceMappingURL=tooltip.d.ts.map

package/dist/src/utils/ui/tooltip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tooltip.d.ts","sourceRoot":"","sources":["../../../../src/utils/ui/tooltip.js"],"names":[],"mappings":"AAIA,gEAAiE;AAEjE;IACI;;OAEG;IACH,uBAFW,WAAW,EAsBrB;IAnBG,uBAA0B;IAE1B,wBAA4C;IAE5C,kBAAoB;IAGpB,kBAAkB;IAClB,uBADW,GAAG,CACwB;IAEtC,wBAA0B;IAE1B,sBAAsB;IACtB,+BAA+B;IAC/B,aADW,CAAC,MAAM,EAAE,MAAM,CAAC,CACC;IAE5B,sBAAsB;IAK1B;;OAEG;IACH,0BAKC;IAED,uBAEC;IAED,uBAEC;IAED;;OAEG;IACH,0BAFW,OAAO,QAOjB;IAED,wBAEC;IAED;;OAEG;IACH,4BAFW,UAAU,QAkCpB;IA/BG,8BAA0D;IAiC9D,wBAiBC;IAED;;OAEG;IACH,oBAFW,MAAM,GAAG,OAAO,KAAK,EAAE,cAAc,GAAG,WAAW,QAiB7D;IAED,cAGC;IAED;;;;;;;OAOG;IACH,sDAHuB,QAAQ,MAAM,GAAG,WAAW,GAAG,OAAO,KAAK,EAAE,cAAc,CAAC,QAmBlF;IAED,sBAEC;CACJ"}