@genome-spy/core 0.36.1 → 0.37.0

package/dist/src/utils/domainArray.js

@@ -0,0 +1,216 @@
+/**
+ * @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/dist/src/utils/domainArray.test.js

@@ -0,0 +1,130 @@
+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/dist/src/utils/eerp.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Exponential interpolation
+ *
+ * https://twitter.com/FreyaHolmer/status/1068293398073929728
+ *
+ * @param {number} a
+ * @param {number} b
+ * @param {number} t
+ * @returns
+ */
+export default function _default(a: number, b: number, t: number): number;
+//# sourceMappingURL=eerp.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"eerp.d.ts","sourceRoot":"","sources":["../../../src/utils/eerp.js"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,oCALW,MAAM,KACN,MAAM,KACN,MAAM,UAKhB"}

package/dist/src/utils/eerp.js

@@ -0,0 +1,13 @@
+/**
+ * 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/dist/src/utils/expression.d.ts

@@ -0,0 +1,9 @@
+/**
+ *
+ * @param {string} expr
+ */
+export default function createFunction(expr: string, global?: {}): {
+    (x: object): any;
+    fields: string[];
+};
+//# sourceMappingURL=expression.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"expression.d.ts","sourceRoot":"","sources":["../../../src/utils/expression.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,6CAFW,MAAM;QAqBwB,MAAM;;EAM9C"}

package/dist/src/utils/expression.js

@@ -0,0 +1,32 @@
+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/dist/src/utils/field.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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: string, name?: string): import("vega-util").AccessorFn<any>;
+//# sourceMappingURL=field.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"field.d.ts","sourceRoot":"","sources":["../../../src/utils/field.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,iCAHW,MAAM,SACN,MAAM,uCAYhB"}

package/dist/src/utils/field.js

@@ -0,0 +1,28 @@
+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/dist/src/utils/formatObject.d.ts

@@ -0,0 +1,7 @@
+/**
+ *
+ * @param {any} object Object to format
+ * @returns {string | import("lit-html").TemplateResult}
+ */
+export default function formatObject(object: any): string | import("lit-html").TemplateResult;
+//# sourceMappingURL=formatObject.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"formatObject.d.ts","sourceRoot":"","sources":["../../../src/utils/formatObject.js"],"names":[],"mappings":"AAOA;;;;GAIG;AACH,6CAHW,GAAG,GACD,MAAM,GAAG,OAAO,UAAU,EAAE,cAAc,CA0BtD"}

package/dist/src/utils/formatObject.js

@@ -0,0 +1,37 @@
+import { isNumber, isString, isBoolean, isArray } from "vega-util";
+import { format as d3format } from "d3-format";
+import { html, nothing } from "lit-html";
+
+const numberFormat = d3format(".4~r");
+const exponentNumberFormat = d3format(".4~e");
+
+/**
+ *
+ * @param {any} object Object to format
+ * @returns {string | import("lit-html").TemplateResult}
+ */
+export default function formatObject(object) {
+    if (object === null || object === undefined) {
+        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 if (isArray(object)) {
+        return html`${object.map((param, i) => [
+            formatObject(param),
+            i < object.length - 1 ? ", " : nothing,
+        ])}`;
+    } else {
+        return "?" + typeof object + " " + object;
+    }
+}

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

@@ -0,0 +1,16 @@
+/**
+ * Assigns unique values an index number in the order they are encountered.
+ *
+ * TODO: What about undefined?
+ *
+ * @template T
+ */
+export default function createIndexer<T>(): {
+    (value: T): number;
+    /** @param {Iterable<T>} iterable */
+    addAll(iterable: Iterable<T>): void;
+    /** @param {number} value */
+    invert(value: number): T;
+    domain(): T[];
+};
+//# sourceMappingURL=indexer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"indexer.d.ts","sourceRoot":"","sources":["../../../src/utils/indexer.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH;;IAgBI,oCAAoC;;IAOpC,4BAA4B;kBAAhB,MAAM;;EAYrB"}

package/dist/src/utils/indexer.js

@@ -0,0 +1,43 @@
+/**
+ * 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/dist/src/utils/indexer.test.js

@@ -0,0 +1,47 @@
+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/dist/src/utils/inertia.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @param {T} event
+ * @template T
+ */
+export function makeEventTemplate<T>(event: T): Partial<Record<keyof T, any>>;
+/**
+ * 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: import("./animator").default, disabled?: boolean);
+    animator: import("./animator").default;
+    disabled: boolean;
+    damping: number;
+    acceleration: number;
+    /** Use acceleration if the momentum step is greater than X */
+    accelerationThreshold: number;
+    lowerLimit: number;
+    loop: boolean;
+    momentum: number;
+    timestamp: number;
+    /** @type {function(number):void} */
+    callback: (arg0: number) => void;
+    _transitionCallback: any;
+    clear(): void;
+    cancel(): void;
+    /**
+     *
+     * @param {number} value
+     * @param {function(number):void} callback
+     */
+    setMomentum(value: number, callback: (arg0: number) => void): void;
+    /**
+     *
+     * @param {number} [timestamp]
+     */
+    animate(timestamp?: number): void;
+}
+//# sourceMappingURL=inertia.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inertia.d.ts","sourceRoot":"","sources":["../../../src/utils/inertia.js"],"names":[],"mappings":"AAsGA;;;GAGG;AACH,8EAiBC;AAzHD;;GAEG;AACH;IACI;;;OAGG;IACH,sBAHW,OAAO,YAAY,EAAE,OAAO,aAC5B,OAAO,EAmBjB;IAhBG,uCAAwB;IACxB,kBAA0B;IAC1B,gBAAoB;IACpB,qBAAuB;IACvB,8DAA8D;IAC9D,8BAAgC;IAChC,mBAAqB;IACrB,cAAiB;IAEjB,UAUW,MAAM,CAVA;IACjB,kBAAkB;IAClB,oCAAoC;IACpC,iBADoB,MAAM,KAAE,IAAI,CACZ;IAEpB,yBAAkD;IAItD,cAMC;IAED,eAKC;IAED;;;;OAIG;IACH,mBAHW,MAAM,mBACG,MAAM,KAAE,IAAI,QAyB/B;IAED;;;OAGG;IACH,oBAFW,MAAM,QAuBhB;CACJ"}