@genome-spy/core 0.64.0 → 0.66.1

package/dist/src/view/layout/flexLayout.test.js

@@ -1,323 +0,0 @@
-import { describe, expect, test } from "vitest";
-import {
-    mapToPixelCoords,
-    getMinimumSize,
-    getLargestSize,
-    isStretching,
-    parseSizeDef,
-    sumSizeDefs,
-} from "./flexLayout.js";
-
-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("sumSizeDefs", () => {
-        const items = [
-            { px: 100 },
-            { px: 10, grow: 1 },
-            { grow: 9 },
-            { px: 200 },
-        ];
-
-        expect(sumSizeDefs(items)).toEqual({ px: 310, grow: 10 });
-    });
-
-    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/dist/src/view/layout/grid.test.js

@@ -1,71 +0,0 @@
-import { expect, test, describe } from "vitest";
-
-import Grid from "./grid.js";
-
-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/dist/src/view/layout/rectangle.test.js

@@ -1,192 +0,0 @@
-import { expect, test } from "vitest";
-import Rectangle from "./rectangle.js";
-import Padding from "./padding.js";
-
-test("Rectangle creation", () => {
-    const r = Rectangle.create(1, 2, 3, 4);
-    expect(r.x).toEqual(1);
-    expect(r.y).toEqual(2);
-    expect(r.width).toEqual(3);
-    expect(r.height).toEqual(4);
-});
-
-test("equals", () => {
-    const r = Rectangle.create(1, 2, 3, 4);
-    expect(r.equals(r)).toBeTruthy();
-    expect(r.equals(Rectangle.create(1, 2, 3, 4))).toBeTruthy();
-    expect(r.equals(undefined)).toBeFalsy();
-});
-
-test("x2 and y2 calculation", () => {
-    const r = Rectangle.create(1, 2, 3, 4);
-    expect(r.x2).toEqual(4);
-    expect(r.y2).toEqual(6);
-});
-
-test("translate", () => {
-    const r = Rectangle.create(1, 2, 3, 4).translate(2, 3);
-    expect(r.x).toEqual(3);
-    expect(r.y).toEqual(5);
-    expect(r.width).toEqual(3);
-    expect(r.height).toEqual(4);
-});
-
-test("Dynamic translate", () => {
-    let tx = 0;
-    let ty = 0;
-
-    const r = Rectangle.create(1, 2, 3, 4)
-        .translate(
-            () => tx,
-            () => ty
-        )
-        .translate(2, 3);
-
-    expect(r.x).toEqual(3);
-    expect(r.y).toEqual(5);
-    expect(r.width).toEqual(3);
-    expect(r.height).toEqual(4);
-
-    tx = 1;
-    ty = 2;
-
-    expect(r.x).toEqual(4);
-    expect(r.y).toEqual(7);
-    expect(r.width).toEqual(3);
-    expect(r.height).toEqual(4);
-});
-
-test("expand", () => {
-    const r = Rectangle.create(1, 2, 3, 4).expand(
-        Padding.createFromRecord({ top: 2, right: 3, bottom: 4, left: 5 })
-    );
-
-    expect(r.x).toEqual(-4);
-    expect(r.width).toEqual(11);
-    expect(r.y).toEqual(0);
-    expect(r.height).toEqual(10);
-});
-
-test("shrink", () => {
-    const r = Rectangle.create(1, 2, 3, 4).shrink(
-        Padding.createUniformPadding(1)
-    );
-
-    expect(r.x).toEqual(2);
-    expect(r.width).toEqual(1);
-    expect(r.y).toEqual(3);
-    expect(r.height).toEqual(2);
-});
-
-test("modify", () => {
-    const r = Rectangle.create(1, 2, 3, 4);
-    const m = r.modify({ x: 5 });
-
-    expect(m.equals(r)).toBeFalsy();
-    expect(m.equals(Rectangle.create(5, 2, 3, 4))).toBeTruthy();
-});
-
-test("Dynamic modify", () => {
-    let x = 1;
-    const r = Rectangle.create(1, 2, 3, 4);
-    const m = r.modify({ x: () => x });
-
-    expect(m.equals(r)).toBeTruthy();
-    expect(m.equals(Rectangle.create(1, 2, 3, 4))).toBeTruthy();
-
-    x = 5;
-
-    expect(m.equals(r)).toBeFalsy();
-    expect(m.equals(Rectangle.create(5, 2, 3, 4))).toBeTruthy();
-});
-
-test("intersect", () => {
-    const a = Rectangle.create(1, 1, 6, 3);
-    const b = Rectangle.create(5, 2, 3, 4);
-    const c = Rectangle.create(5, 2, 2, 2);
-
-    expect(a.intersect(b).equals(c)).toBeTruthy();
-    expect(a.intersect(b).isDefined()).toBeTruthy();
-
-    const x = Rectangle.create(1, 1, 1, 1);
-    const y = Rectangle.create(3, 3, 1, 1);
-
-    expect(x.intersect(y).isDefined()).toBeFalsy();
-});
-
-test("union", () => {
-    const a = Rectangle.create(1, 1, 6, 3);
-    const b = Rectangle.create(5, 2, 3, 4);
-    const c = Rectangle.create(1, 1, 7, 5);
-
-    expect(a.union(b).equals(c)).toBeTruthy();
-});
-
-test("isDefined", () => {
-    expect(Rectangle.create(0, 0, 1, 1).isDefined()).toBeTruthy();
-    expect(Rectangle.create(0, 0, 0, 0).isDefined()).toBeTruthy();
-
-    expect(Rectangle.create(0, 0, -1, 0).isDefined()).toBeFalsy();
-    expect(Rectangle.create(0, 0, 0, -1).isDefined()).toBeFalsy();
-});
-
-test("flatten", () => {
-    let tx = 0;
-    let ty = 0;
-
-    const r = Rectangle.create(1, 2, 3, 4).translate(
-        () => tx,
-        () => ty
-    );
-
-    const flattened = r.flatten();
-
-    tx = -1;
-    ty = -2;
-
-    expect(r.equals(Rectangle.create(0, 0, 3, 4)));
-    expect(flattened.equals(Rectangle.create(1, 2, 3, 4)));
-});
-
-test("containsPoint", () => {
-    const r = Rectangle.create(1, 2, 3, 4);
-
-    expect(r.containsPoint(0, 0)).toBeFalsy();
-    expect(r.containsPoint(0, 10)).toBeFalsy();
-    expect(r.containsPoint(10, 0)).toBeFalsy();
-    expect(r.containsPoint(10, 10)).toBeFalsy();
-
-    expect(r.containsPoint(2, 0)).toBeFalsy();
-    expect(r.containsPoint(2, 10)).toBeFalsy();
-    expect(r.containsPoint(0, 3)).toBeFalsy();
-    expect(r.containsPoint(10, 3)).toBeFalsy();
-
-    // Inclusive corner
-    expect(r.containsPoint(1, 2)).toBeTruthy();
-
-    // Inside
-    expect(r.containsPoint(2, 3)).toBeTruthy();
-
-    // Exclusive corner
-    expect(r.containsPoint(4, 6)).toBeFalsy();
-});
-
-test("normalizePoint", () => {
-    const r = Rectangle.create(1, 2, 6, 4);
-
-    expect(r.normalizePoint(1, 2)).toEqual({ x: 0, y: 0 });
-    expect(r.normalizePoint(7, 2)).toEqual({ x: 1, y: 0 });
-    expect(r.normalizePoint(4, 4)).toEqual({ x: 0.5, y: 0.5 });
-
-    expect(r.normalizePoint(1, 6, true)).toEqual({ x: 0, y: 0 });
-});
-
-test("denormalizePoint", () => {
-    const r = Rectangle.create(1, 2, 6, 4);
-
-    expect(r.denormalizePoint(0, 0)).toEqual({ x: 1, y: 2 });
-    expect(r.denormalizePoint(1, 0)).toEqual({ x: 7, y: 2 });
-    expect(r.denormalizePoint(0.5, 0.5)).toEqual({ x: 4, y: 4 });
-
-    expect(r.denormalizePoint(0, 0, true)).toEqual({ x: 1, y: 6 });
-});