@genome-spy/core 0.65.0 → 0.67.0

package/dist/src/data/transforms/regexExtract.test.js

@@ -1,70 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { processData } from "../flowTestUtils.js";
-
-import RegexExtractTransform from "./regexExtract.js";
-
-/**
- * @param {import("../../spec/transform.js").RegexExtractParams} params
- * @param {any[]} data
- */
-function transform(params, data) {
-    return processData(new RegexExtractTransform(params), data);
-}
-
-describe("RegexExtractTransform", () => {
-    /**
-     * @typedef {import("../../spec/transform.js").RegexExtractParams} RegexExtractParams
-     */
-    const rows = [{ a: "12-34" }, { a: "23-45" }];
-
-    /** @type {RegexExtractParams} */
-    const params = {
-        type: "regexExtract",
-        regex: "^(\\d+)-(\\d+)$",
-        field: "a",
-        as: ["b", "c"],
-    };
-
-    test("Valid config and input", () => {
-        expect(transform(params, rows)).toEqual([
-            { a: "12-34", b: "12", c: "34" },
-            { a: "23-45", b: "23", c: "45" },
-        ]);
-    });
-
-    test("Invalid config", () => {
-        /** @type {RegexExtractParams} */
-        const config2 = {
-            type: "regexExtract",
-            regex: "^(\\d+)-(\\d+)$",
-            field: "a",
-            as: ["b", "c", "d"],
-        };
-
-        expect(() => transform(config2, rows)).toThrow();
-    });
-
-    test("Invalid data", () => {
-        const rows2 = [{ a: "12--34" }];
-
-        expect(() => transform(params, rows2)).toThrow();
-    });
-
-    test("Invalid, non-string data", () => {
-        const rows2 = [{ a: 123 }];
-
-        expect(() => transform(params, rows2)).toThrow();
-    });
-
-    test("Skip invalid or non-string data", () => {
-        const rows2 = [{ a: 123 }, { a: "xyzzy" }, { a: "12-34" }];
-
-        expect(transform({ ...params, skipInvalidInput: true }, rows2)).toEqual(
-            [
-                { a: 123, b: undefined, c: undefined },
-                { a: "xyzzy", b: undefined, c: undefined },
-                { a: "12-34", b: "12", c: "34" },
-            ]
-        );
-    });
-});

package/dist/src/data/transforms/regexFold.test.js

@@ -1,201 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { processData } from "../flowTestUtils.js";
-import RegexFoldTransform from "./regexFold.js";
-
-describe("RegexFold", () => {
-    test("Throws error if the number of capture groups in columnRegex != 1", () => {
-        /** @type { import("../../spec/transform.js").RegexFoldParams } */
-        const singleGatherConfig = {
-            type: "regexFold",
-            columnRegex: "^.+_a$",
-            asValue: "a",
-        };
-
-        expect(() => new RegexFoldTransform(singleGatherConfig)).toThrowError(
-            `Regex /^.+_a$/ must have exactly one capturing group!`
-        );
-    });
-
-    test("Transform single variable", () => {
-        const sampleData = [
-            {
-                row: 1,
-                sample1_a: "r1s1a",
-                sample2_a: "r1s2a",
-            },
-            {
-                row: 2,
-                sample1_a: "r2s1a",
-                sample2_a: "r2s2a",
-            },
-        ];
-
-        /** @type { import("../../spec/transform.js").RegexFoldParams } */
-        const singleGatherConfig = {
-            type: "regexFold",
-            columnRegex: "^(.*)_a$",
-            asValue: "a",
-        };
-
-        const result = processData(
-            new RegexFoldTransform(singleGatherConfig),
-            sampleData
-        );
-
-        expect(result).toEqual([
-            {
-                row: 1,
-                sample: "sample1",
-                a: "r1s1a",
-            },
-            {
-                row: 1,
-                sample: "sample2",
-                a: "r1s2a",
-            },
-            {
-                row: 2,
-                sample: "sample1",
-                a: "r2s1a",
-            },
-            {
-                row: 2,
-                sample: "sample2",
-                a: "r2s2a",
-            },
-        ]);
-    });
-
-    test("Transform single variable and skip specific columns", () => {
-        const sampleData = [
-            {
-                row: 1,
-                sample1_a: "r1s1a",
-                sample2_a: "r1s2a",
-            },
-            {
-                row: 2,
-                sample1_a: "r2s1a",
-                sample2_a: "r2s2a",
-            },
-        ];
-
-        /** @type { import("../../spec/transform.js").RegexFoldParams } */
-        const singleGatherConfig = {
-            type: "regexFold",
-            columnRegex: "^(.*)_a$",
-            asValue: "a",
-            skipRegex: "^row$",
-        };
-
-        const result = processData(
-            new RegexFoldTransform(singleGatherConfig),
-            sampleData
-        );
-
-        expect(result).toEqual([
-            {
-                sample: "sample1",
-                a: "r1s1a",
-            },
-            {
-                sample: "sample2",
-                a: "r1s2a",
-            },
-            {
-                sample: "sample1",
-                a: "r2s1a",
-            },
-            {
-                sample: "sample2",
-                a: "r2s2a",
-            },
-        ]);
-    });
-
-    test("Transform multiple variables", () => {
-        const sampleData = [
-            {
-                row: 1,
-                sample1_a: "r1s1a",
-                sample2_a: "r1s2a",
-                sample1_b: "r1s1b",
-                sample2_b: "r1s2b",
-            },
-            {
-                row: 2,
-                sample1_a: "r2s1a",
-                sample2_a: "r2s2a",
-                sample1_b: "r2s1b",
-                sample2_b: "r2s2b",
-            },
-        ];
-
-        /** @type { import("../../spec/transform.js").RegexFoldParams } */
-        const singleGatherConfig = {
-            type: "regexFold",
-            columnRegex: ["^(.*)_a$", "^(.*)_b$"],
-            asValue: ["a", "b"],
-        };
-
-        const result = processData(
-            new RegexFoldTransform(singleGatherConfig),
-            sampleData
-        );
-
-        expect(result).toEqual([
-            {
-                row: 1,
-                sample: "sample1",
-                a: "r1s1a",
-                b: "r1s1b",
-            },
-            {
-                row: 1,
-                sample: "sample2",
-                a: "r1s2a",
-                b: "r1s2b",
-            },
-            {
-                row: 2,
-                sample: "sample1",
-                a: "r2s1a",
-                b: "r2s1b",
-            },
-            {
-                row: 2,
-                sample: "sample2",
-                a: "r2s2a",
-                b: "r2s2b",
-            },
-        ]);
-    });
-
-    test("Throws error if no columns match the regex", () => {
-        const sampleData = [
-            {
-                row: 1,
-                sample1_a: "r1s1a",
-                sample2_a: "r1s2a",
-            },
-            {
-                row: 2,
-                sample1_a: "r2s1a",
-                sample2_a: "r2s2a",
-            },
-        ];
-
-        /** @type { import("../../spec/transform.js").RegexFoldParams } */
-        const singleGatherConfig = {
-            type: "regexFold",
-            columnRegex: "^(.*)_c$",
-            asValue: "a",
-        };
-
-        expect(() =>
-            processData(new RegexFoldTransform(singleGatherConfig), sampleData)
-        ).toThrowError(
-            "No columns matching the regex /^(.*)_c$/ found in the data!"
-        );
-    });
-});

package/dist/src/data/transforms/sample.test.js

@@ -1,38 +0,0 @@
-import { expect, test } from "vitest";
-import SampleTransform from "./sample.js";
-import { extent } from "d3-array";
-import { createChain } from "../../view/flowBuilder.js";
-
-test("SampleTransform produces roughly uniform distributions", () => {
-    const size = 10;
-    const n = 20;
-    const rounds = 10000;
-
-    const freqs = [];
-    for (let i = 0; i < n; i++) {
-        freqs[i] = 0;
-    }
-
-    const { dataSource, collector } = createChain(
-        new SampleTransform({ type: "sample", size })
-    );
-
-    for (let r = 0; r < rounds; r++) {
-        for (let i = 0; i < n; i++) {
-            dataSource.handle({ data: i });
-        }
-        dataSource.complete();
-
-        for (const datum of collector.getData()) {
-            freqs[datum.data] = freqs[datum.data] + 1;
-        }
-
-        dataSource.reset();
-    }
-
-    const e = extent(freqs);
-
-    // Not a deterministic test! TODO: Come up with some sensical testing method
-    expect(e[0]).toBeGreaterThan(4800);
-    expect(e[1]).toBeLessThan(5200);
-});

package/dist/src/data/transforms/stack.test.js

@@ -1,91 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { processData } from "../flowTestUtils.js";
-import StackTransform from "./stack.js";
-
-const sampleData = [
-    { group: "a", choice: "q", value: 1 },
-    { group: "b", choice: "x", value: 1 },
-    { group: "b", choice: "y", value: 3 },
-];
-
-/** @type {import("../../spec/transform.js").StackParams} */
-const baseParams = {
-    type: "stack",
-    field: "value",
-    groupby: ["group"],
-    sort: {
-        field: "value",
-        order: "ascending",
-    },
-    offset: "zero",
-    as: ["z0", "z1"],
-};
-
-/**
- *
- * @param {import("../../spec/transform.js").StackParams} params
- * @param {any[]} data
- */
-function transform(params, data) {
-    return processData(new StackTransform(params), data);
-}
-
-describe("Stack transform", () => {
-    test("No field", () => {
-        const conf = Object.assign({}, baseParams, {
-            field: undefined,
-        });
-
-        expect(transform(conf, sampleData)).toEqual([
-            { group: "a", choice: "q", value: 1, z0: 0, z1: 1 },
-            { group: "b", choice: "x", value: 1, z0: 0, z1: 1 },
-            { group: "b", choice: "y", value: 3, z0: 1, z1: 2 },
-        ]);
-    });
-
-    test("Zero offset", () => {
-        expect(transform(baseParams, sampleData)).toEqual([
-            { group: "a", choice: "q", value: 1, z0: 0, z1: 1 },
-            { group: "b", choice: "x", value: 1, z0: 0, z1: 1 },
-            { group: "b", choice: "y", value: 3, z0: 1, z1: 4 },
-        ]);
-    });
-
-    test("Normalize offset", () => {
-        const conf = Object.assign({}, baseParams, {
-            offset: "normalize",
-        });
-
-        expect(transform(conf, sampleData)).toEqual([
-            { group: "a", choice: "q", value: 1, z0: 0, z1: 1 },
-            { group: "b", choice: "x", value: 1, z0: 0, z1: 0.25 },
-            { group: "b", choice: "y", value: 3, z0: 0.25, z1: 1 },
-        ]);
-    });
-
-    test("Center offset", () => {
-        const conf = Object.assign({}, baseParams, {
-            offset: "center",
-        });
-
-        expect(transform(conf, sampleData)).toEqual([
-            { group: "a", choice: "q", value: 1, z0: -0.5, z1: 0.5 },
-            { group: "b", choice: "x", value: 1, z0: -2, z1: -1 },
-            { group: "b", choice: "y", value: 3, z0: -1, z1: 2 },
-        ]);
-    });
-
-    test("Descending sort", () => {
-        const conf = Object.assign({}, baseParams, {
-            sort: {
-                field: "value",
-                order: "descending",
-            },
-        });
-        expect(transform(conf, sampleData)).toEqual([
-            { group: "a", choice: "q", value: 1, z0: 0, z1: 1 },
-            { group: "b", choice: "y", value: 3, z0: 0, z1: 3 },
-            { group: "b", choice: "x", value: 1, z0: 3, z1: 4 },
-        ]);
-    });
-});

package/dist/src/encoder/accessor.test.js

@@ -1,162 +0,0 @@
-import { describe, expect, test } from "vitest";
-import ParamMediator from "../view/paramMediator.js";
-import { createAccessor, createConditionalAccessors } from "./accessor.js";
-import { UNIQUE_ID_KEY } from "../data/transforms/identifier.js";
-import { createSinglePointSelection } from "../selection/selection.js";
-
-const datum = {
-    a: 1,
-    b: 2,
-    "x.c": 3,
-};
-
-describe("Accessors for different encoding types", () => {
-    test("Creates a field accessor", () => {
-        const a = createAccessor("x", { field: "a" }, new ParamMediator());
-        expect(a(datum)).toEqual(1);
-        expect(a.constant).toBeFalsy();
-        expect(a.fields).toEqual(["a"]);
-    });
-
-    test("Creates an expression accessor", () => {
-        const a = createAccessor(
-            "x",
-            { expr: `datum.b + datum['x\.c']` },
-            new ParamMediator()
-        );
-        expect(a(datum)).toEqual(5);
-        expect(a.constant).toBeFalsy();
-        expect(a.fields.sort()).toEqual(["b", "x.c"].sort());
-    });
-
-    test("Creates a constant accessor", () => {
-        const a = createAccessor("x", { datum: 0 }, new ParamMediator());
-        expect(a(datum)).toEqual(0);
-        expect(a.constant).toBeTruthy();
-        expect(a.fields).toEqual([]);
-    });
-
-    test("Creates a value accessor", () => {
-        const a = createAccessor("x", { value: 123 }, new ParamMediator());
-        expect(a(datum)).toEqual(123);
-        expect(a.constant).toBeTruthy();
-        expect(a.fields).toEqual([]);
-    });
-});
-
-test("Throws on incomplete encoding spec", () => {
-    expect(() => createAccessor("x", {}, new ParamMediator())).toThrow();
-});
-
-// TODO: Refactor and fix conditional accessors
-describe.skip("createConditionalAccessors", () => {
-    const data = [
-        { a: 1, b: 2, [UNIQUE_ID_KEY]: 0 },
-        { a: 3, b: 4, [UNIQUE_ID_KEY]: 1 },
-    ];
-
-    const paramMediator = new ParamMediator();
-    paramMediator.allocateSetter("p", createSinglePointSelection(data[0]));
-
-    const a = createConditionalAccessors(
-        "x",
-        {
-            field: "a",
-            type: "quantitative",
-            condition: { param: "p", value: 123 },
-        },
-        paramMediator
-    );
-
-    const b = createConditionalAccessors(
-        "x",
-        {
-            field: "a",
-            type: "quantitative",
-            condition: [
-                { param: "p", value: 123 },
-                { param: "p", value: 234 },
-            ],
-        },
-        paramMediator
-    );
-
-    const c = createConditionalAccessors(
-        "x",
-        {
-            value: 123,
-            condition: {
-                param: "p",
-                field: "a",
-                type: "quantitative",
-            },
-        },
-        paramMediator
-    );
-
-    // TODO: Add more combinations of datum, field, expr, etc
-
-    test("Creates a correct number of accessors", () => {
-        expect(a.length).toBe(2);
-        expect(b.length).toBe(3);
-        expect(c.length).toBe(2);
-    });
-
-    // Conditional accessor
-    test("Conditional accessor accesses the correct field", () => {
-        expect(a[0](data[0])).toEqual(123);
-        expect(a[0].predicate.param).toEqual("p");
-    });
-
-    test("Conditional predicate is true only for the selected datum", () => {
-        expect(a[0].predicate(data[0])).toBeTruthy();
-        expect(a[0].predicate(data[1])).toBeFalsy();
-    });
-
-    // Default accessor
-    test("Default accessor accesses the correct field", () => {
-        expect(a[1](data[0])).toEqual(1);
-        expect(a[1].predicate.param).toBeFalsy();
-    });
-
-    test("Default predicate is true for all data", () => {
-        expect(a[1].predicate(data[0])).toBeTruthy();
-        expect(a[1].predicate(data[1])).toBeTruthy();
-    });
-
-    test("Throws if multiple non-constant accessors are used", () => {
-        expect(() =>
-            createConditionalAccessors(
-                "x",
-                {
-                    field: "a",
-                    type: "quantitative",
-                    condition: {
-                        param: "p",
-                        // @ts-expect-error
-                        field: "b",
-                        type: "quantitative",
-                    },
-                },
-                paramMediator
-            )
-        ).toThrow();
-
-        expect(() =>
-            createConditionalAccessors(
-                "x",
-                {
-                    field: "a",
-                    type: "quantitative",
-                    condition: {
-                        param: "p",
-                        // @ts-expect-error
-                        expr: "datum.b",
-                        type: "quantitative",
-                    },
-                },
-                paramMediator
-            )
-        ).toThrow();
-    });
-});

package/dist/src/encoder/encoder.test.js

@@ -1,105 +0,0 @@
-import { describe, expect, test } from "vitest";
-
-import { createAccessor, createConditionalAccessors } from "./accessor.js";
-import ParamMediator from "../view/paramMediator.js";
-import { createEncoder, createSimpleOrConditionalEncoder } from "./encoder.js";
-import { UNIQUE_ID_KEY } from "../data/transforms/identifier.js";
-import { createSinglePointSelection } from "../selection/selection.js";
-import { isArray } from "vega-util";
-import { scaleLinear } from "d3-scale";
-
-/** @type {import("../spec/channel.js").Encoding} */
-const encoding = {
-    x: { value: 42 },
-    y: {
-        field: "a",
-        type: "quantitative",
-        scale: { domain: [0, 100], range: [0, 1] },
-    },
-    size: {
-        field: "a",
-        type: "quantitative",
-        scale: { domain: [0, 100], range: [0, 10] },
-        condition: {
-            param: "p",
-            empty: false,
-            value: 5000,
-        },
-    },
-};
-
-const scaleSource = (
-    /** @type {import("../spec/channel.js").ChannelWithScale} */ channel
-) => {
-    // @ts-ignore
-    const props = encoding[channel].scale ?? encoding[channel].condition?.scale;
-
-    return Object.assign(
-        scaleLinear().domain(props.domain).range(props.range),
-        {
-            type: "linear",
-        }
-    );
-};
-
-const datum = {
-    a: 100,
-    b: 6,
-    c: "Pink Floyd",
-    [UNIQUE_ID_KEY]: 1234,
-};
-
-describe("Encoder", () => {
-    const pm = new ParamMediator();
-    /** @type {Partial<Record<import("../spec/channel.js").Channel, import("../types/encoder.js").Encoder>>} */
-    const e = Object.fromEntries(
-        Object.entries(encoding).map(([channel, channelDef]) => {
-            const accessor = createAccessor(channel, channelDef, pm);
-            return [channel, createEncoder(accessor, scaleSource)];
-        })
-    );
-
-    test("has a single accessors", () => {
-        expect(e.x.accessors?.length).toBe(1);
-    });
-
-    test("provides a data accessor for a FieldDef", () =>
-        expect(e.y.dataAccessor.fields).toContain("a"));
-
-    test("doesn't provide a data accessor for a ValueDef", () =>
-        expect(e.x.dataAccessor).toBeUndefined());
-
-    test("returns a value", () => expect(e.x(datum)).toEqual(42));
-
-    test("accesses a field and uses a scale", () => expect(e.y(datum)).toBe(1));
-
-    // TODO: Text ExprRef
-});
-
-// TODO: Refactor and fix conditional encoders
-describe.skip("Conditional encoder with a field and a conditional value", () => {
-    const pm = new ParamMediator();
-    const setter = pm.allocateSetter("p", createSinglePointSelection(null));
-
-    const e = createSimpleOrConditionalEncoder(
-        createConditionalAccessors("size", encoding.size, pm),
-        scaleSource
-    );
-
-    test("has multiple accessors", () => {
-        expect(e.accessors.length).toBe(2);
-    });
-
-    test("accesses the field using the dataAccessor", () =>
-        expect(e.dataAccessor(datum)).toBe(100));
-
-    test("encodes the default when a predicate is false", () => {
-        setter(createSinglePointSelection(null));
-        expect(e(datum)).toBe(10);
-    });
-
-    test("encodes the conditional value when a predicate is true", () => {
-        setter(createSinglePointSelection(datum));
-        expect(e(datum)).toBe(5000);
-    });
-});