@genome-spy/core 0.29.0 → 0.30.2

package/src/utils/domainArray.js

@@ -1,216 +0,0 @@
-/**
- * @typedef {boolean | number | string} scalar
- */
-
-export class DomainArray /** @type {Array<scalar>} */ extends Array {
-    constructor() {
-        super();
-        /** @type {string} */
-        this.type = undefined;
-    }
-
-    /**
-     *
-     * @param {scalar} value
-     * @returns {DomainArray}
-     */
-    extend(value) {
-        return this;
-    }
-
-    /**
-     *
-     * @param {Iterable<scalar>} values
-     * @returns {DomainArray}
-     */
-    extendAll(values) {
-        if (values instanceof DomainArray && values.type != this.type) {
-            throw new Error(
-                `Cannot combine different types of domains: ${this.type} and ${values.type}`
-            );
-        }
-
-        for (const value of values) {
-            this.extend(value);
-        }
-
-        return this;
-    }
-
-    /**
-     * @param {Iterable<T>} values
-     * @param {function(T):scalar} [accessor]
-     * @returns {DomainArray}
-     * @template T
-     */
-    extendAllWithAccessor(values, accessor) {
-        for (const value of values) {
-            this.extend(accessor(value));
-        }
-
-        return this;
-    }
-}
-
-export class QuantitativeDomain extends DomainArray {
-    constructor() {
-        super();
-        this.type = "quantitative";
-    }
-
-    /**
-     *
-     * @param {scalar} value
-     * @returns {DomainArray}
-     */
-    extend(value) {
-        if (value === null || value === undefined || Number.isNaN(value)) {
-            return this;
-        }
-
-        value = +value;
-
-        if (this.length) {
-            if (value < this[0]) {
-                this[0] = value;
-            } else if (value > this[1]) {
-                this[1] = value;
-            }
-        } else {
-            this.push(value);
-            this.push(value);
-        }
-
-        return this;
-    }
-}
-
-/**
- * Builder that tries to preserve the order
- */
-export class OrdinalDomain extends DomainArray {
-    constructor() {
-        super();
-        this.type = "ordinal";
-
-        /** @type {Set<scalar>} */
-        this.uniqueValues = new Set();
-    }
-
-    /**
-     *
-     * @param {scalar} value
-     * @returns {DomainArray}
-     */
-    extend(value) {
-        if (value === null || value === undefined || Number.isNaN(value)) {
-            return this;
-        }
-
-        if (!this.uniqueValues.has(value)) {
-            this.uniqueValues.add(value);
-            this.push(value);
-        }
-
-        return this;
-    }
-}
-
-export class NominalDomain extends OrdinalDomain {
-    constructor() {
-        super();
-        this.type = "nominal";
-    }
-}
-
-export class PiecewiseDomain extends DomainArray {
-    /**
-     *
-     * @param {number[]} initialDomain
-     */
-    constructor(initialDomain) {
-        super();
-
-        let sum = 0;
-        for (let i = 1; i < initialDomain.length; i++) {
-            sum += Math.sign(initialDomain[i] - initialDomain[i - 1]);
-        }
-        if (Math.abs(sum) != initialDomain.length - 1) {
-            throw new Error(
-                "Piecewise domain must be strictly increasing or decreasing: " +
-                    JSON.stringify(initialDomain)
-            );
-        }
-
-        initialDomain.forEach((x) => this.push(x));
-    }
-
-    /**
-     *
-     * @param {scalar} value
-     * @returns {DomainArray}
-     */
-    extend(value) {
-        if (this.includes(value)) {
-            return this;
-        }
-
-        throw new Error(
-            "Piecewise domains are immutable and cannot be unioned!"
-        );
-    }
-}
-
-/**
- * @type Object.<string, typeof DomainArray>
- */
-const domainTypes = {
-    quantitative: QuantitativeDomain,
-    index: QuantitativeDomain,
-    locus: QuantitativeDomain,
-    nominal: NominalDomain,
-    ordinal: OrdinalDomain,
-};
-
-/**
- *
- * @param {string} type
- * @param {scalar[]} [initialDomain]
- */
-export default function createDomain(type, initialDomain) {
-    if (type == "quantitative" && isPiecewiseArray(initialDomain)) {
-        const b = new PiecewiseDomain(/** @type {number[]} */ (initialDomain));
-        b.type = type;
-        return b;
-    } else if (domainTypes[type]) {
-        const b = new domainTypes[type]();
-        b.type = type;
-        if (initialDomain) {
-            b.extendAll(initialDomain);
-        }
-        return b;
-    }
-
-    throw new Error("Unknown type: " + type);
-}
-
-/**
- * For unit tests
- *
- * @param {DomainArray | any[]} domainArray
- */
-export function toRegularArray(domainArray) {
-    return [...domainArray];
-}
-
-/**
- * @param {scalar[]} array
- */
-function isPiecewiseArray(array) {
-    return (
-        array &&
-        array.length > 0 &&
-        array.length != 2 &&
-        array.every((x) => typeof x === "number")
-    );
-}

package/src/utils/domainArray.test.js

@@ -1,130 +0,0 @@
-import { describe, expect, test } from "vitest";
-import createDomain, {
-    toRegularArray as r,
-    PiecewiseDomain,
-} from "./domainArray";
-
-describe("Build quantitative domains", () => {
-    test("Empty domain", () => {
-        const b = createDomain("quantitative");
-        expect(r(b)).toEqual([]);
-    });
-
-    test("Extends by one value at a time", () => {
-        const b = createDomain("quantitative");
-        b.extend(2);
-        b.extend(1);
-        b.extend(null);
-        b.extend(undefined);
-        b.extend(NaN);
-        b.extend(5);
-        b.extend(4);
-        expect(r(b)).toEqual([1, 5]);
-    });
-
-    test("Extends with an iterable", () => {
-        const b = createDomain("quantitative");
-        b.extendAll([2, 1, null, undefined, NaN, 5, 4]);
-        expect(r(b)).toEqual([1, 5]);
-    });
-
-    test("Extends with an iterable and an accessor", () => {
-        const b = createDomain("quantitative");
-        b.extendAllWithAccessor(
-            [
-                { x: 2 },
-                { x: 1 },
-                { x: null },
-                { x: undefined },
-                { x: NaN },
-                { x: 5 },
-                { x: 4 },
-            ],
-            (d) => d.x
-        );
-        expect(r(b)).toEqual([1, 5]);
-    });
-
-    test("Coerces to number", () => {
-        const b = createDomain("quantitative");
-        expect(r(b.extend("123"))).toEqual([123, 123]);
-    });
-});
-
-describe("Build ordinal domains", () => {
-    // Note: nominal is an unordered abstraction of ordinal. Testing just ordinal is enough.
-
-    test("Empty domain", () => {
-        const b = createDomain("ordinal");
-        expect(r(b)).toEqual([]);
-    });
-
-    test("Extends by one value at a time, preserves order", () => {
-        const b = createDomain("ordinal");
-        b.extend("a");
-        b.extend("b");
-        b.extend("c");
-        b.extend("b");
-        b.extend(null);
-        b.extend(undefined);
-        b.extend(NaN);
-        b.extend("d");
-        expect(r(b)).toEqual(["a", "b", "c", "d"]);
-    });
-});
-
-describe("Build piecewise domains", () => {
-    test("Creates a piecewise domain", () => {
-        expect(createDomain("quantitative", [1])).toBeInstanceOf(
-            PiecewiseDomain
-        );
-        expect(createDomain("quantitative", [1, 2, 3])).toBeInstanceOf(
-            PiecewiseDomain
-        );
-        expect(createDomain("quantitative", [1, 2, 3, 4])).toBeInstanceOf(
-            PiecewiseDomain
-        );
-        expect(createDomain("quantitative", [3, 2, 1])).toBeInstanceOf(
-            PiecewiseDomain
-        );
-        expect(r(createDomain("quantitative", [3, 2, 1]))).toEqual([3, 2, 1]);
-    });
-
-    test("Throws on domain that is not stricly increasing or decreasing", () => {
-        expect(() => createDomain("quantitative", [2, 1, 3])).toThrow();
-        expect(() => createDomain("quantitative", [2, 3, 1])).toThrow();
-        expect(() => createDomain("quantitative", [3, 0, 2])).toThrow();
-        expect(() => createDomain("quantitative", [0, 3, 2])).toThrow();
-        expect(() => createDomain("quantitative", [1, 2, 2, 3])).toThrow();
-    });
-
-    test("Throws on mutation attempts", () => {
-        expect(() =>
-            createDomain("quantitative", [1, 2, 3]).extend(4)
-        ).toThrow();
-    });
-
-    test("Does not throw when extending with existing value", () => {
-        expect(r(createDomain("quantitative", [1, 2, 3]).extend(2))).toEqual([
-            1, 2, 3,
-        ]);
-    });
-});
-
-describe("Annotations", () => {
-    test("Quantitative domain is annotated", () =>
-        expect(createDomain("quantitative").type).toEqual("quantitative"));
-
-    test("Ordinal domain is annotated", () =>
-        expect(createDomain("ordinal").type).toEqual("ordinal"));
-
-    test("Nominal domain is annotated", () =>
-        expect(createDomain("nominal").type).toEqual("nominal"));
-});
-
-describe("Other stuff", () => {
-    test("Throws on extending by other type of domain array", () =>
-        expect(() =>
-            createDomain("quantitative").extendAll(createDomain("nominal"))
-        ).toThrow());
-});

package/src/utils/eerp.js

@@ -1,13 +0,0 @@
-/**
- * Exponential interpolation
- *
- * https://twitter.com/FreyaHolmer/status/1068293398073929728
- *
- * @param {number} a
- * @param {number} b
- * @param {number} t
- * @returns
- */
-export default function (a, b, t) {
-    return a * Math.pow(b / a, t);
-}

package/src/utils/expression.js

@@ -1,32 +0,0 @@
-import { parseExpression, codegenExpression } from "vega-expression";
-
-/**
- *
- * @param {string} expr
- */
-export default function createFunction(expr, global = {}) {
-    const cg = codegenExpression({
-        forbidden: [],
-        allowed: ["datum"],
-        globalvar: "global",
-        fieldvar: "datum",
-    });
-
-    try {
-        const parsed = parseExpression(expr);
-        const generatedCode = cg(parsed);
-
-        // eslint-disable-next-line no-new-func
-        const fn = Function(
-            "datum",
-            "global",
-            `"use strict"; return (${generatedCode.code});`
-        );
-
-        const exprFunction = /** @param {object} x */ (x) => fn(x, global);
-        exprFunction.fields = generatedCode.fields;
-        return exprFunction;
-    } catch (e) {
-        throw new Error(`Invalid expression: ${expr}, ${e.message}`);
-    }
-}

package/src/utils/field.js

@@ -1,28 +0,0 @@
-import { field as vegaField, accessor } from "vega-util";
-
-/**
- * Creates an accessor function based on the field expression.
- * This is equivalent to vega-util's field function but generates optimized
- * accessors for trivial cases.
- *
- * Function calls with polymorphic objects spoil the inline caching that
- * virtually all JavaScript engines use. Thus, we generate code and compile
- * always a new function to "guarantee" homomorphims, given that only same
- * type of objects are even passed to the accessor.
- *
- * Read more at: https://mrale.ph/blog/2015/01/11/whats-up-with-monomorphism.html
- *
- * @param {string} fieldExpr
- * @param {string} [name]
- */
-export function field(fieldExpr, name = fieldExpr) {
-    if (/^[A-Za-z0-9_]+$/.test(fieldExpr)) {
-        // eslint-disable-next-line no-new-func
-        const fn = /** @type {import("vega-util").AccessorFn} */ (
-            new Function("datum", `return datum[${JSON.stringify(fieldExpr)}]`)
-        );
-        return accessor(fn, [fieldExpr], name);
-    } else {
-        return vegaField(fieldExpr);
-    }
-}

package/src/utils/formatObject.js

@@ -1,31 +0,0 @@
-import { isNumber, isString, isBoolean } from "vega-util";
-import { format as d3format } from "d3-format";
-import { html } from "lit-html";
-
-const numberFormat = d3format(".4~r");
-const exponentNumberFormat = d3format(".4~e");
-
-/**
- *
- * @param {any} object Object to format
- */
-export default function formatObject(object) {
-    if (object === null) {
-        return html` <span class="na">NA</span> `;
-    }
-
-    if (isString(object)) {
-        return object.substring(0, 30);
-    } else if (Number.isInteger(object)) {
-        return "" + object;
-    } else if (isNumber(object)) {
-        return Math.abs(object) > Math.pow(10, 8) ||
-            Math.abs(object) < Math.pow(10, -8)
-            ? exponentNumberFormat(object)
-            : numberFormat(object);
-    } else if (isBoolean(object)) {
-        return object ? "True" : "False";
-    } else {
-        return "?" + typeof object + " " + object;
-    }
-}

package/src/utils/indexer.js

@@ -1,43 +0,0 @@
-/**
- * Assigns unique values an index number in the order they are encountered.
- *
- * TODO: What about undefined?
- *
- * @template T
- */
-export default function createIndexer() {
-    let counter = 0;
-
-    /** @type {Map<T, number>} */
-    const values = new Map();
-
-    /** @param {T} value */
-    const indexer = (value) => {
-        let index = values.get(value);
-        if (index === undefined) {
-            index = counter++;
-            values.set(value, index);
-        }
-        return index;
-    };
-
-    /** @param {Iterable<T>} iterable */
-    indexer.addAll = (iterable) => {
-        for (const value of iterable) {
-            indexer(value);
-        }
-    };
-
-    /** @param {number} value */
-    indexer.invert = (value) => {
-        for (const entry of values.entries()) {
-            if (entry[1] == value) {
-                return entry[0];
-            }
-        }
-    };
-
-    indexer.domain = () => [...values.keys()];
-
-    return indexer;
-}

package/src/utils/indexer.test.js

@@ -1,47 +0,0 @@
-import { expect, test } from "vitest";
-import createIndexer from "./indexer";
-
-test("Index values one by one", () => {
-    const indexer = createIndexer();
-
-    expect(indexer("a")).toEqual(0);
-    expect(indexer("b")).toEqual(1);
-    expect(indexer("c")).toEqual(2);
-    expect(indexer("a")).toEqual(0);
-    expect(indexer("c")).toEqual(2);
-});
-
-test("Index multiple values (predefined domain)", () => {
-    const indexer = createIndexer();
-
-    indexer.addAll(["a", "b", "c"]);
-
-    expect(indexer("d")).toEqual(3);
-    expect(indexer("a")).toEqual(0);
-    expect(indexer("b")).toEqual(1);
-    expect(indexer("c")).toEqual(2);
-    expect(indexer("d")).toEqual(3);
-});
-
-test("Indexer inverts index numbers", () => {
-    const indexer = createIndexer();
-
-    indexer.addAll(["a", "b", "c"]);
-
-    expect(indexer.invert(0)).toEqual("a");
-    expect(indexer.invert(1)).toEqual("b");
-    expect(indexer.invert(2)).toEqual("c");
-    expect(indexer.invert(3)).toBeUndefined();
-});
-
-test("Indexer return correct domain", () => {
-    const indexer = createIndexer();
-
-    expect(indexer("a")).toEqual(0);
-    expect(indexer("b")).toEqual(1);
-    expect(indexer("c")).toEqual(2);
-    expect(indexer("a")).toEqual(0);
-    expect(indexer("c")).toEqual(2);
-
-    expect(indexer.domain()).toEqual(["a", "b", "c"]);
-});

package/src/utils/inertia.js

@@ -1,124 +0,0 @@
-import { lerp } from "vega-util";
-
-/**
- * Creates some inertia, mainly for zooming with a mechanical mouse wheel
- */
-export default class Inertia {
-    /**
-     * @param {import("./animator").default} animator
-     * @param {boolean} [disabled] Just call the callback directly
-     */
-    constructor(animator, disabled) {
-        this.animator = animator;
-        this.disabled = !!disabled;
-        this.damping = 0.015;
-        this.acceleration = 0.3; // per event
-        /** Use acceleration if the momentum step is greater than X */
-        this.accelerationThreshold = 100;
-        this.lowerLimit = 0.5; // When to stop updating
-        this.loop = false;
-
-        this.momentum = 0;
-        this.timestamp = 0;
-        /** @type {function(number):void} */
-        this.callback = null;
-
-        this._transitionCallback = this.animate.bind(this);
-        this.clear();
-    }
-
-    clear() {
-        /** @type {number} */
-        this.momentum = 0;
-        this.timestamp = null;
-        this.loop = null;
-        this.callback = null;
-    }
-
-    cancel() {
-        if (this.loop) {
-            this.animator.cancelTransition(this._transitionCallback);
-            this.clear();
-        }
-    }
-
-    /**
-     *
-     * @param {number} value
-     * @param {function(number):void} callback
-     */
-    setMomentum(value, callback) {
-        if (this.disabled) {
-            callback(value);
-            return;
-        }
-
-        // This may have some use in the future to improve the behavior of
-        // a mechanical mouse wheel:
-        // https://github.com/w3c/uievents/issues/181
-
-        if (value * this.momentum < 0) {
-            this.momentum = 0; // Stop if the direction changes
-        } else if (Math.abs(value) > this.accelerationThreshold) {
-            this.momentum = lerp([this.momentum, value], this.acceleration);
-        } else {
-            this.momentum = value;
-        }
-
-        this.callback = callback;
-
-        if (!this.loop) {
-            this.animate();
-        }
-    }
-
-    /**
-     *
-     * @param {number} [timestamp]
-     */
-    animate(timestamp) {
-        this.callback(this.momentum); // TODO: This is actually a delta, should take the elapsed time into account
-
-        const timeDelta = timestamp - this.timestamp || 0;
-        this.timestamp = timestamp;
-
-        const velocity = Math.abs(this.momentum);
-
-        this.momentum =
-            Math.sign(this.momentum) *
-            Math.max(
-                0,
-                velocity - ((velocity * this.damping) ** 1.5 + 0.04) * timeDelta
-            );
-
-        if (Math.abs(this.momentum) > this.lowerLimit) {
-            this.loop = true;
-            this.animator.requestTransition(this._transitionCallback);
-        } else {
-            this.clear();
-        }
-    }
-}
-
-/**
- * @param {T} event
- * @template T
- */
-export function makeEventTemplate(event) {
-    /** @type {Partial<Record<keyof T, any>>} */
-    const template = {};
-    const acceptedTypes = ["string", "number", "boolean"];
-    const rejectedProps = ["wheelDelta", "wheelDeltaX", "wheelDeltaY"];
-
-    // eslint-disable-next-line guard-for-in
-    for (const key in event) {
-        const k = /** @type {keyof T} */ (key);
-        if (
-            !rejectedProps.includes(key) &&
-            acceptedTypes.includes(typeof event[k])
-        ) {
-            template[k] = /** @type {any} */ (event[k]);
-        }
-    }
-    return template;
-}

package/src/utils/interactionEvent.js

@@ -1,33 +0,0 @@
-/**
- * This class wraps a MouseEvent (or similar) and allows for
- * its propagation through the view hierarchy in a similar manner
- * as in the DOM.
- */
-export default class InteractionEvent {
-    /**
-     *
-     * @param {import("./layout/point").default} point Event coordinates
-     *      inside the visualization canvas.
-     * @param {UIEvent} uiEvent The event to be wrapped
-     */
-    constructor(point, uiEvent) {
-        this.point = point;
-        this.uiEvent = uiEvent;
-        this.stopped = false;
-
-        /**
-         * The target is known only in the bubbling phase
-         *
-         * @type {import("../view/view").default}
-         */
-        this.target = undefined;
-    }
-
-    stopPropagation() {
-        this.stopped = true;
-    }
-
-    get type() {
-        return this.uiEvent.type;
-    }
-}