@genome-spy/core 0.29.0 → 0.30.2

package/src/utils/layout/flexLayout.test.js

@@ -1,311 +0,0 @@
-import { describe, expect, test } from "vitest";
-import {
-    mapToPixelCoords,
-    getMinimumSize,
-    getLargestSize,
-    isStretching,
-    parseSizeDef,
-} from "./flexLayout";
-
-test("parseSize", () => {
-    expect(parseSizeDef(10)).toEqual({ px: 10, grow: 0 });
-    expect(parseSizeDef({ px: 20, grow: 2 })).toEqual({ px: 20, grow: 2 });
-    expect(parseSizeDef(undefined)).toEqual({ px: 0, grow: 1 });
-    expect(parseSizeDef(null)).toEqual({ px: 0, grow: 1 });
-    expect(parseSizeDef("container")).toEqual({ px: 0, grow: 1 });
-    expect(() => parseSizeDef({})).toThrow();
-});
-
-describe("Basic flex functionality", () => {
-    test("Absolute sizes", () => {
-        const items = [10, 30, 20].map((x) => ({ px: x }));
-        const containerSize = 100;
-
-        const mapped = mapToPixelCoords(items, containerSize);
-
-        expect(mapped[0]).toEqual({ location: 0, size: 10 });
-        expect(mapped[1]).toEqual({ location: 10, size: 30 });
-        expect(mapped[2]).toEqual({ location: 40, size: 20 });
-    });
-
-    test("Absolute sizes with spacing", () => {
-        const items = [10, 30, 20].map((x) => ({ px: x }));
-        const containerSize = 100;
-
-        const mapped = mapToPixelCoords(items, containerSize, { spacing: 10 });
-
-        expect(mapped[0]).toEqual({ location: 0, size: 10 });
-        expect(mapped[1]).toEqual({ location: 20, size: 30 });
-        expect(mapped[2]).toEqual({ location: 60, size: 20 });
-    });
-
-    test("Absolute sizes with spacing, reversed", () => {
-        const items = [10, 30, 20].map((x) => ({ px: x }));
-        const containerSize = 100;
-
-        const mapped = mapToPixelCoords(items, containerSize, {
-            spacing: 10,
-            reverse: true,
-        });
-
-        expect(mapped[0]).toEqual({ location: 90, size: 10 });
-        expect(mapped[1]).toEqual({ location: 50, size: 30 });
-        expect(mapped[2]).toEqual({ location: 20, size: 20 });
-    });
-
-    test("Absolute sizes with spacing, reversed and insufficient containerSize", () => {
-        const items = [10, 30, 20].map((x) => ({ px: x }));
-        const containerSize = 0;
-
-        const mapped = mapToPixelCoords(items, containerSize, {
-            spacing: 10,
-            reverse: true,
-        });
-
-        expect(mapped[0]).toEqual({ location: 70, size: 10 });
-        expect(mapped[1]).toEqual({ location: 30, size: 30 });
-        expect(mapped[2]).toEqual({ location: 0, size: 20 });
-    });
-
-    test("Growing sizes", () => {
-        const items = [10, 20, 70].map((x) => ({ grow: x }));
-        const containerSize = 200;
-
-        const mapped = mapToPixelCoords(items, containerSize);
-
-        expect(mapped[0]).toEqual({ location: 0, size: 20 });
-        expect(mapped[1]).toEqual({ location: 20, size: 40 });
-        expect(mapped[2]).toEqual({ location: 60, size: 140 });
-    });
-
-    test("Growing sizes with spacing", () => {
-        const items = [10, 20, 70].map((x) => ({ grow: x }));
-        const containerSize = 220;
-        const mapped = mapToPixelCoords(items, containerSize, { spacing: 10 });
-
-        expect(mapped[0]).toEqual({ location: 0, size: 20 });
-        expect(mapped[1]).toEqual({ location: 30, size: 40 });
-        expect(mapped[2]).toEqual({ location: 80, size: 140 });
-    });
-
-    test("Mixed absolute and relative sizes", () => {
-        const items = [{ px: 100 }, { grow: 1 }, { grow: 9 }, { px: 200 }];
-        const containerSize = 1100;
-        const mapped = mapToPixelCoords(items, containerSize);
-
-        expect(mapped[0]).toEqual({ location: 0, size: 100 });
-        expect(mapped[1]).toEqual({ location: 100, size: 80 });
-        expect(mapped[2]).toEqual({ location: 180, size: 720 });
-        expect(mapped[3]).toEqual({ location: 900, size: 200 });
-    });
-
-    test("Sizes having both absolute and growing components", () => {
-        const items = [
-            { px: 1 },
-            { px: 2 },
-            { px: 3, grow: 2 },
-            { px: 4, grow: 1 },
-        ];
-        const containerSize = 16;
-        const mapped = mapToPixelCoords(items, containerSize);
-
-        expect(mapped[0]).toEqual({ location: 0, size: 1 });
-        expect(mapped[1]).toEqual({ location: 1, size: 2 });
-        expect(mapped[2]).toEqual({ location: 3, size: 7 });
-        expect(mapped[3]).toEqual({ location: 10, size: 6 });
-    });
-
-    test("Zero sizes return zero coords", () => {
-        const items = [{ grow: 0 }, { grow: 0 }];
-
-        const mapped = mapToPixelCoords(items, 0);
-        expect(mapped[0]).toEqual({ location: 0, size: 0 });
-        expect(mapped[1]).toEqual({ location: 0, size: 0 });
-
-        const mapped2 = mapToPixelCoords(items, 1);
-        expect(mapped2[0]).toEqual({ location: 0, size: 0 });
-        expect(mapped2[1]).toEqual({ location: 0, size: 0 });
-    });
-
-    test("Offset is added", () => {
-        const items = [10, 30, 20].map((x) => ({ px: x }));
-        const containerSize = 100;
-
-        const mapped = mapToPixelCoords(items, containerSize, { offset: 5 });
-
-        expect(mapped[0]).toEqual({ location: 5, size: 10 });
-        expect(mapped[1]).toEqual({ location: 15, size: 30 });
-        expect(mapped[2]).toEqual({ location: 45, size: 20 });
-    });
-});
-
-describe("Collapse gaps when items have zero px and grow", () => {
-    test("Zero as first", () => {
-        const items = [0, 30, 20].map((x) => ({ px: x }));
-        const containerSize = 100;
-
-        const mapped = mapToPixelCoords(items, containerSize, { spacing: 10 });
-
-        expect(mapped[0]).toEqual({ location: 0, size: 0 });
-        expect(mapped[1]).toEqual({ location: 0, size: 30 });
-        expect(mapped[2]).toEqual({ location: 40, size: 20 });
-    });
-
-    test("Zero in the middle", () => {
-        const items = [10, 0, 20].map((x) => ({ px: x }));
-        const containerSize = 100;
-
-        const mapped = mapToPixelCoords(items, containerSize, { spacing: 10 });
-
-        expect(mapped[0]).toEqual({ location: 0, size: 10 });
-        expect(mapped[1]).toEqual({ location: 15, size: 0 });
-        expect(mapped[2]).toEqual({ location: 20, size: 20 });
-    });
-
-    test("Multiple zeroes in the middle", () => {
-        const items = [10, 0, 0, 0, 20].map((x) => ({ px: x }));
-        const containerSize = 100;
-
-        const mapped = mapToPixelCoords(items, containerSize, { spacing: 10 });
-
-        expect(mapped[0]).toEqual({ location: 0, size: 10 });
-        expect(mapped[1]).toEqual({ location: 12.5, size: 0 });
-        expect(mapped[2]).toEqual({ location: 15, size: 0 });
-        expect(mapped[3]).toEqual({ location: 17.5, size: 0 });
-        expect(mapped[4]).toEqual({ location: 20, size: 20 });
-    });
-
-    test("Zero as last", () => {
-        const items = [10, 30, 0].map((x) => ({ px: x }));
-        const containerSize = 100;
-
-        const mapped = mapToPixelCoords(items, containerSize, { spacing: 10 });
-
-        expect(mapped[0]).toEqual({ location: 0, size: 10 });
-        expect(mapped[1]).toEqual({ location: 20, size: 30 });
-        expect(mapped[2]).toEqual({ location: 50, size: 0 });
-    });
-
-    test("Only a zero", () => {
-        const items = [0].map((x) => ({ px: x }));
-        const containerSize = 100;
-
-        const mapped = mapToPixelCoords(items, containerSize, { spacing: 10 });
-
-        expect(mapped[0]).toEqual({ location: 0, size: 0 });
-    });
-});
-
-describe("Collapse gaps when items have zero px and grow, reversed", () => {
-    test("Zero as first", () => {
-        const items = [0, 30, 20].map((x) => ({ px: x }));
-        const containerSize = 100;
-
-        const mapped = mapToPixelCoords(items, containerSize, {
-            spacing: 10,
-            reverse: true,
-        });
-
-        expect(mapped[0]).toEqual({ location: 100, size: 0 });
-        expect(mapped[1]).toEqual({ location: 70, size: 30 });
-        expect(mapped[2]).toEqual({ location: 40, size: 20 });
-    });
-
-    test("Zero in the middle", () => {
-        const items = [10, 0, 20].map((x) => ({ px: x }));
-        const containerSize = 100;
-
-        const mapped = mapToPixelCoords(items, containerSize, {
-            spacing: 10,
-            reverse: true,
-        });
-
-        expect(mapped[0]).toEqual({ location: 90, size: 10 });
-        expect(mapped[1]).toEqual({ location: 85, size: 0 });
-        expect(mapped[2]).toEqual({ location: 60, size: 20 });
-    });
-
-    test("Multiple zeroes in the middle", () => {
-        const items = [10, 0, 0, 0, 20].map((x) => ({ px: x }));
-        const containerSize = 100;
-
-        const mapped = mapToPixelCoords(items, containerSize, {
-            spacing: 10,
-            reverse: true,
-        });
-
-        expect(mapped[0]).toEqual({ location: 90, size: 10 });
-        expect(mapped[1]).toEqual({ location: 87.5, size: 0 });
-        expect(mapped[2]).toEqual({ location: 85, size: 0 });
-        expect(mapped[3]).toEqual({ location: 82.5, size: 0 });
-        expect(mapped[4]).toEqual({ location: 60, size: 20 });
-    });
-
-    test("Zero as last", () => {
-        const items = [10, 30, 0].map((x) => ({ px: x }));
-        const containerSize = 100;
-
-        const mapped = mapToPixelCoords(items, containerSize, {
-            spacing: 10,
-            reverse: true,
-        });
-
-        expect(mapped[0]).toEqual({ location: 90, size: 10 });
-        expect(mapped[1]).toEqual({ location: 50, size: 30 });
-        expect(mapped[2]).toEqual({ location: 50, size: 0 });
-    });
-
-    test("Only a zero", () => {
-        const items = [0].map((x) => ({ px: x }));
-        const containerSize = 100;
-
-        const mapped = mapToPixelCoords(items, containerSize, {
-            spacing: 10,
-            reverse: true,
-        });
-
-        expect(mapped[0]).toEqual({ location: 100, size: 0 });
-    });
-});
-
-describe("Utility fuctions", () => {
-    test("getMinimumSize", () => {
-        const items = [{ px: 100 }, { grow: 1 }, { grow: 9 }, { px: 200 }];
-
-        expect(getMinimumSize(items)).toEqual(300);
-
-        expect(getMinimumSize(items, { spacing: 10 })).toEqual(330);
-    });
-
-    test("getMinimumSize, items include zeroes", () => {
-        const items = [
-            { px: 100 },
-            { px: 0, grow: 0 },
-            { grow: 1 },
-            { grow: 9 },
-            { px: 200 },
-        ];
-
-        expect(getMinimumSize(items)).toEqual(300);
-
-        expect(getMinimumSize(items, { spacing: 10 })).toEqual(330);
-    });
-
-    test("getLargestSize", () => {
-        const items = [
-            { px: 100 },
-            { px: 0, grow: 0 },
-            { grow: 1 },
-            { grow: 9 },
-            { px: 200 },
-            { px: 50 },
-        ];
-
-        expect(getLargestSize(items)).toEqual({ px: 200, grow: 9 });
-    });
-
-    test("isStretching", () => {
-        expect(isStretching([{ grow: 1 }])).toBeTruthy();
-        expect(isStretching([{ px: 1 }])).toBeFalsy();
-    });
-});

package/src/utils/layout/grid.js

@@ -1,95 +0,0 @@
-/**
- * An utility class for indexing cells in a wrapping grid layout
- */
-export default class Grid {
-    /**
-     *
-     * @param {number} nChildren
-     * @param {number} [maxCols]
-     */
-    constructor(nChildren, maxCols) {
-        this.n = nChildren;
-        this.maxCols = maxCols ?? Infinity;
-    }
-
-    get nRows() {
-        return this.maxCols == Infinity ? 1 : Math.ceil(this.n / this.maxCols);
-    }
-
-    get nCols() {
-        return Math.min(this.n, this.maxCols);
-    }
-
-    get rowIndices() {
-        /** @type {number[][]} */
-        const rows = [];
-
-        const nCols = this.nCols;
-        const nRows = this.nRows;
-
-        for (let row = 0; row < nRows; row++) {
-            /** @type {number[]} */
-            const arr = [];
-            rows.push(arr);
-            for (let col = 0; col < nCols; col++) {
-                const i = row * nCols + col;
-                if (i < this.n) {
-                    arr.push(i);
-                }
-            }
-        }
-        return rows;
-    }
-
-    get colIndices() {
-        /** @type {number[][]} */
-        const cols = [];
-
-        const nCols = this.nCols;
-        const nRows = this.nRows;
-
-        for (let col = 0; col < nCols; col++) {
-            /** @type {number[]} */
-            const arr = [];
-            cols.push(arr);
-            for (let row = 0; row < nRows; row++) {
-                const i = row * nCols + col;
-                if (i < this.n) {
-                    arr.push(i);
-                }
-            }
-        }
-        return cols;
-    }
-
-    /**
-     * @param {number} col
-     * @param {number} row
-     */
-    getCellIndex(col, row) {
-        let i = 0;
-
-        if (this.maxCols == Infinity) {
-            i = row == 0 ? col : undefined;
-        } else if (col >= this.maxCols) {
-            return undefined;
-        } else {
-            i = row * this.nCols + col;
-        }
-
-        return i < this.n ? i : undefined;
-    }
-
-    /**
-     *
-     * @param {number} index
-     * @returns {[number, number]}
-     */
-    getCellCoords(index) {
-        if (index < 0 || index >= this.n) {
-            return undefined;
-        }
-
-        return [index % this.nCols, Math.floor(index / this.nCols)];
-    }
-}

package/src/utils/layout/grid.test.js

@@ -1,71 +0,0 @@
-import { expect, test, describe } from "vitest";
-
-import Grid from "./grid";
-
-describe("Grid indexing", () => {
-    test("Single row", () => {
-        const g = new Grid(3);
-
-        expect(g.maxCols).toEqual(Infinity);
-        expect(g.nCols).toEqual(3);
-        expect(g.nRows).toEqual(1);
-        expect(g.colIndices).toEqual([[0], [1], [2]]);
-        expect(g.rowIndices).toEqual([[0, 1, 2]]);
-        expect(g.getCellIndex(1, 0)).toEqual(1);
-        expect(g.getCellIndex(1, 1)).toBeUndefined();
-        expect(g.getCellCoords(1)).toEqual([1, 0]);
-        expect(g.getCellCoords(-1)).toBeUndefined();
-        expect(g.getCellCoords(3)).toBeUndefined();
-    });
-
-    test("Single column", () => {
-        const g = new Grid(3, 1);
-
-        expect(g.maxCols).toEqual(1);
-        expect(g.nCols).toEqual(1);
-        expect(g.nRows).toEqual(3);
-        expect(g.colIndices).toEqual([[0, 1, 2]]);
-        expect(g.rowIndices).toEqual([[0], [1], [2]]);
-        expect(g.getCellIndex(0, 1)).toEqual(1);
-        expect(g.getCellIndex(1, 1)).toBeUndefined();
-        expect(g.getCellCoords(1)).toEqual([0, 1]);
-    });
-
-    test("Two columns", () => {
-        const g = new Grid(6, 2);
-
-        expect(g.maxCols).toEqual(2);
-        expect(g.nCols).toEqual(2);
-        expect(g.nRows).toEqual(3);
-        expect(g.colIndices).toEqual([
-            [0, 2, 4],
-            [1, 3, 5],
-        ]);
-        expect(g.rowIndices).toEqual([
-            [0, 1],
-            [2, 3],
-            [4, 5],
-        ]);
-        expect(g.getCellIndex(1, 0)).toEqual(1);
-        expect(g.getCellIndex(0, 1)).toEqual(2);
-        expect(g.getCellIndex(1, 1)).toEqual(3);
-        expect(g.getCellCoords(3)).toEqual([1, 1]);
-    });
-
-    test("Two columns, second is partial", () => {
-        const g = new Grid(5, 2);
-
-        expect(g.maxCols).toEqual(2);
-        expect(g.nCols).toEqual(2);
-        expect(g.nRows).toEqual(3);
-        expect(g.colIndices).toEqual([
-            [0, 2, 4],
-            [1, 3],
-        ]);
-        expect(g.rowIndices).toEqual([[0, 1], [2, 3], [4]]);
-        expect(g.getCellIndex(1, 0)).toEqual(1);
-        expect(g.getCellIndex(0, 1)).toEqual(2);
-        expect(g.getCellIndex(1, 2)).toBeUndefined();
-        expect(g.getCellCoords(3)).toEqual([1, 1]);
-    });
-});

package/src/utils/layout/padding.js

@@ -1,120 +0,0 @@
-/**
- * A class for handing paddings, borders, margins, etc.
- *
- * @typedef {import("../../spec/view").Paddings} Paddings
- * @typedef {import("../../spec/view").PaddingConfig} PaddingConfig
- */
-export default class Padding {
-    /**
-     * @param {number} top
-     * @param {number} right
-     * @param {number} bottom
-     * @param {number} left
-     */
-    constructor(top, right, bottom, left) {
-        /** @readonly */ this.top = top || 0;
-        /** @readonly */ this.right = right || 0;
-        /** @readonly */ this.bottom = bottom || 0;
-        /** @readonly */ this.left = left || 0;
-    }
-
-    /**
-     * Returns the sum of left and right
-     */
-    get width() {
-        return this.left + this.right;
-    }
-
-    /**
-     * Returns the sum of top and bottom
-     */
-    get height() {
-        return this.top + this.bottom;
-    }
-
-    /**
-     * @param {number} amount In pixels
-     */
-    expand(amount) {
-        if (amount <= 0) {
-            return this;
-        }
-
-        return new Padding(
-            this.top + amount,
-            this.right + amount,
-            this.bottom + amount,
-            this.left + amount
-        );
-    }
-
-    /**
-     *
-     * @param {Padding} padding padding to add
-     */
-    add(padding) {
-        return new Padding(
-            this.top + padding.top,
-            this.right + padding.right,
-            this.bottom + padding.bottom,
-            this.left + padding.left
-        );
-    }
-
-    /**
-     *
-     * @param {Padding} padding padding to subtract
-     */
-    subtract(padding) {
-        return new Padding(
-            this.top - padding.top,
-            this.right - padding.right,
-            this.bottom - padding.bottom,
-            this.left - padding.left
-        );
-    }
-
-    /**
-     *
-     * @param {PaddingConfig} config
-     */
-    static createFromConfig(config) {
-        if (typeof config == "number") {
-            return this.createUniformPadding(config);
-        } else if (config) {
-            return this.createFromRecord(config);
-        } else {
-            return zeroPadding;
-        }
-    }
-
-    /**
-     * @param {Paddings} paddings
-     */
-    static createFromRecord(paddings) {
-        return new Padding(
-            paddings.top,
-            paddings.right,
-            paddings.bottom,
-            paddings.left
-        );
-    }
-
-    /**
-     * Returns a zeroed padding.
-     */
-    static zero() {
-        return zeroPadding;
-    }
-
-    /**
-     *
-     * @param {number} value
-     */
-    static createUniformPadding(value) {
-        return new Padding(value, value, value, value);
-    }
-}
-
-const zeroPadding = Padding.createUniformPadding(0);
-Object.freeze(zeroPadding);

package/src/utils/layout/point.js

@@ -1,23 +0,0 @@
-export default class Point {
-    /**
-     *
-     * @param {number} x
-     * @param {number} y
-     */
-    constructor(x, y) {
-        /** @readonly */ this.x = x;
-        /** @readonly */ this.y = y;
-    }
-
-    /**
-     *
-     * @param {Point} point
-     */
-    equals(point) {
-        if (!point) {
-            return false;
-        }
-
-        return point === this || (point.x === this.x && point.y === this.y);
-    }
-}