@genome-spy/core 0.65.0 → 0.67.0

package/dist/src/data/collector.test.js

@@ -1,138 +0,0 @@
-import { describe, expect, test } from "vitest";
-
-import Collector from "./collector.js";
-import { UNIQUE_ID_KEY } from "./transforms/identifier.js";
-
-const data = [1, 5, 2, 4, 3].map((x) => ({ x }));
-
-test("Collector collects data", () => {
-    const collector = new Collector();
-
-    for (const d of data) {
-        collector.handle(d);
-    }
-    collector.complete();
-
-    expect(collector.getData()).toEqual(data);
-});
-
-test("Collector collects and sorts data", () => {
-    const collector = new Collector({
-        type: "collect",
-        sort: { field: ["x"] },
-    });
-
-    for (const d of data) {
-        collector.handle(d);
-    }
-    collector.complete();
-
-    expect([...collector.getData()]).toEqual(
-        [1, 2, 3, 4, 5].map((x) => ({ x }))
-    );
-});
-
-test("Collector collects, groups, and sorts data", () => {
-    const collector = new Collector({
-        type: "collect",
-        sort: { field: ["x"] },
-        groupby: ["a", "b"],
-    });
-
-    const data = [
-        { a: 1, b: 1, x: 1 },
-        { a: 1, b: 2, x: 2 },
-        { a: 1, b: 2, x: 3 },
-        { a: 2, b: 1, x: 4 },
-        { a: 2, b: 1, x: 5 },
-        { a: 2, b: 2, x: 6 },
-    ];
-
-    for (const d of data) {
-        collector.handle(d);
-    }
-    collector.complete();
-
-    const cd = [...collector.getData()];
-
-    expect(cd.map((d) => ({ x: d.x }))).toEqual(
-        [1, 2, 3, 4, 5, 6].map((x) => ({ x }))
-    );
-
-    /** @param {any[]} group*/
-    const getGroupX = (group) =>
-        collector.facetBatches.get(group).map((d) => d.x);
-
-    expect(getGroupX([1, 1])).toEqual([1]);
-    expect(getGroupX([1, 2])).toEqual([2, 3]);
-    expect(getGroupX([2, 1])).toEqual([4, 5]);
-    expect(getGroupX([2, 2])).toEqual([6]);
-
-    expect(new Set(collector.facetBatches.keys())).toEqual(
-        new Set([
-            [1, 1],
-            [1, 2],
-            [2, 1],
-            [2, 2],
-        ])
-    );
-});
-
-test("Collector throws on incomplete flow", () => {
-    const collector = new Collector();
-
-    expect(() => collector.getData()).toThrow();
-});
-
-describe("Indexing unique ids", () => {
-    test("Collector builds a working index when ids are available", () => {
-        const collector = new Collector({
-            type: "collect",
-            groupby: ["a"],
-        });
-
-        const data = [
-            { a: 1, x: 1, [UNIQUE_ID_KEY]: 8 },
-            { a: 1, x: 2, [UNIQUE_ID_KEY]: 2 },
-            { a: 1, x: 3, [UNIQUE_ID_KEY]: 4 },
-            { a: 1, x: 4, [UNIQUE_ID_KEY]: 6 },
-            { a: 2, x: 5, [UNIQUE_ID_KEY]: 9 },
-            { a: 2, x: 6, [UNIQUE_ID_KEY]: 7 },
-            { a: 2, x: 7, [UNIQUE_ID_KEY]: 3 },
-            { a: 2, x: 8, [UNIQUE_ID_KEY]: 1 },
-        ];
-
-        for (const d of data) {
-            collector.handle(d);
-        }
-        collector.complete();
-
-        expect(collector.findDatumByUniqueId(8)).toEqual(data[0]);
-        expect(collector.findDatumByUniqueId(2)).toEqual(data[1]);
-        expect(collector.findDatumByUniqueId(4)).toEqual(data[2]);
-        expect(collector.findDatumByUniqueId(6)).toEqual(data[3]);
-        expect(collector.findDatumByUniqueId(9)).toEqual(data[4]);
-        expect(collector.findDatumByUniqueId(7)).toEqual(data[5]);
-        expect(collector.findDatumByUniqueId(3)).toEqual(data[6]);
-        expect(collector.findDatumByUniqueId(1)).toEqual(data[7]);
-    });
-
-    test("Collector returns undefined when ids are not available", () => {
-        const collector = new Collector({
-            type: "collect",
-            groupby: ["a"],
-        });
-
-        const data = [
-            { a: 1, x: 1 },
-            { a: 2, x: 5 },
-        ];
-
-        for (const d of data) {
-            collector.handle(d);
-        }
-        collector.complete();
-
-        expect(collector.findDatumByUniqueId(0)).toBeUndefined();
-    });
-});

package/dist/src/data/dataFlow.test.js

@@ -1,38 +0,0 @@
-import { describe, expect, test } from "vitest";
-import DataFlow from "./dataFlow.js";
-import DataSource from "./sources/dataSource.js";
-import Collector from "./collector.js";
-
-describe("DataFlow", () => {
-    test("removes sources and collectors and clears observers", () => {
-        const flow = new DataFlow();
-
-        const sourceA = new DataSource(/** @type {any} */ ({}));
-        const sourceB = new DataSource(/** @type {any} */ ({}));
-
-        flow.addDataSource(sourceA);
-        flow.addDataSource(sourceB);
-
-        const collector = new Collector();
-        flow.addCollector(collector);
-
-        let called = false;
-        collector.observe(() => {
-            called = true;
-        });
-
-        expect(flow.dataSources).toContain(sourceA);
-        expect(flow.collectors).toContain(collector);
-        expect(collector.observers.size).toBe(1);
-
-        flow.removeDataSource(sourceA);
-        flow.removeCollector(collector);
-
-        expect(flow.dataSources).not.toContain(sourceA);
-        expect(flow.collectors).not.toContain(collector);
-
-        expect(collector.observers.size).toBe(0);
-        expect(called).toBe(false);
-        expect(flow.dataSources).toContain(sourceB);
-    });
-});

package/dist/src/data/flow.test.js

@@ -1,81 +0,0 @@
-import { describe, expect, test } from "vitest";
-import FilterTransform from "./transforms/filter.js";
-import FormulaTransform from "./transforms/formula.js";
-import Collector from "./collector.js";
-import {
-    SynchronousSequenceSource,
-    makeParamMediatorProvider,
-} from "./flowTestUtils.js";
-
-describe("Test flow graphs", () => {
-    test("Trivial graph: sequence to collector", () => {
-        const source = new SynchronousSequenceSource(5);
-        const collector = new Collector();
-        source.addChild(collector);
-
-        source.dispatch();
-
-        expect(collector.getData()).toEqual(
-            [0, 1, 2, 3, 4].map((d) => ({
-                data: d,
-            }))
-        );
-    });
-
-    test("Trivial branching: sequence to two collectors", () => {
-        const source = new SynchronousSequenceSource(5);
-        const collector1 = new Collector();
-        source.addChild(collector1);
-        const collector2 = new Collector();
-        source.addChild(collector2);
-
-        source.dispatch();
-
-        expect(collector1.getData()).toEqual(
-            [0, 1, 2, 3, 4].map((d) => ({
-                data: d,
-            }))
-        );
-
-        expect(collector2.getData()).toEqual(
-            [0, 1, 2, 3, 4].map((d) => ({
-                data: d,
-            }))
-        );
-    });
-
-    test.skip("Implement stub for ParamMediator");
-
-    test("Longer chain of nodes", () => {
-        const source = new SynchronousSequenceSource(10);
-        const filter = new FilterTransform(
-            {
-                type: "filter",
-                expr: "datum.data < 5",
-            },
-            makeParamMediatorProvider()
-        );
-        const formula = new FormulaTransform(
-            {
-                type: "formula",
-                expr: "datum.data * 2",
-                as: "data",
-            },
-            makeParamMediatorProvider()
-        );
-        const collector = new Collector();
-
-        source.addChild(filter);
-        filter.addChild(formula);
-        formula.addChild(collector);
-
-        source.visit((node) => node.initialize());
-        source.dispatch();
-
-        expect(collector.getData()).toEqual(
-            [0, 2, 4, 6, 8].map((d) => ({
-                data: d,
-            }))
-        );
-    });
-});

package/dist/src/data/flowInit.test.js

@@ -1,413 +0,0 @@
-import { describe, expect, test, vi } from "vitest";
-
-import { createTestViewContext } from "../view/testUtils.js";
-import { buildDataFlow } from "../view/flowBuilder.js";
-import { optimizeDataFlow } from "./flowOptimizer.js";
-import {
-    collectNearestViewSubtreeDataSources,
-    collectViewSubtreeDataSources,
-    initializeViewSubtree,
-    loadViewSubtreeData,
-    syncFlowHandles,
-} from "./flowInit.js";
-
-describe("flowInit", () => {
-    test("syncs handles to canonical data sources after merge", async () => {
-        const context = createTestViewContext();
-        context.getNamedDataFromProvider = () => [];
-        context.addBroadcastListener = () => undefined;
-        context.removeBroadcastListener = () => undefined;
-
-        /** @type {import("../spec/view.js").HConcatSpec} */
-        const spec = {
-            hconcat: [
-                {
-                    data: { name: "shared" },
-                    mark: "point",
-                    encoding: {
-                        x: { field: "x", type: "quantitative" },
-                    },
-                },
-                {
-                    data: { name: "shared" },
-                    mark: "point",
-                    encoding: {
-                        x: { field: "x", type: "quantitative" },
-                    },
-                },
-            ],
-        };
-
-        const root = await context.createOrImportView(spec, null, null, "root");
-
-        const flow = buildDataFlow(root, context.dataFlow);
-        const canonicalBySource = optimizeDataFlow(flow);
-        syncFlowHandles(root, canonicalBySource);
-
-        const concatRoot =
-            /** @type {import("../view/concatView.js").default} */ (root);
-        const left = concatRoot.children[0];
-        const right = concatRoot.children[1];
-
-        expect(left.flowHandle.dataSource).toBeDefined();
-        expect(right.flowHandle.dataSource).toBeDefined();
-        expect(left.flowHandle.dataSource).toBe(right.flowHandle.dataSource);
-
-        const sharedSources = flow.dataSources.filter(
-            (/** @type {import("./sources/dataSource.js").default} */ source) =>
-                source.identifier === "shared"
-        );
-        expect(sharedSources).toEqual([left.flowHandle.dataSource]);
-    });
-
-    test("initializeViewSubtree wires collector updates for subtree loads", async () => {
-        const context = createTestViewContext();
-        context.getNamedDataFromProvider = () => [];
-        context.addBroadcastListener = () => undefined;
-        context.removeBroadcastListener = () => undefined;
-
-        /** @type {import("../spec/view.js").UnitSpec} */
-        const spec = {
-            data: { values: [{ x: 1 }, { x: 2 }] },
-            mark: "point",
-            encoding: {
-                x: { field: "x", type: "quantitative" },
-            },
-        };
-
-        const root = await context.createOrImportView(spec, null, null, "root");
-        const { dataSources } = initializeViewSubtree(root, context.dataFlow);
-
-        // This guards subtree-only initialization: dynamic view rebuilds should still
-        // trigger mark updates when their local collectors complete.
-        const unitView = /** @type {import("../view/unitView.js").default} */ (
-            root
-        );
-        const initializeSpy = vi.spyOn(unitView.mark, "initializeData");
-
-        await Promise.all(
-            Array.from(dataSources).map((dataSource) => dataSource.load())
-        );
-
-        expect(initializeSpy).toHaveBeenCalledTimes(1);
-        initializeSpy.mockRestore();
-    });
-
-    test("disposeSubtree removes observers before rebuilding subtree", async () => {
-        const context = createTestViewContext();
-        context.getNamedDataFromProvider = () => [{ x: 1 }];
-        context.addBroadcastListener = () => undefined;
-        context.removeBroadcastListener = () => undefined;
-
-        /** @type {import("../spec/view.js").UnitSpec} */
-        const spec = {
-            data: { name: "shared" },
-            mark: "point",
-            encoding: {
-                x: { field: "x", type: "quantitative" },
-            },
-        };
-
-        const firstRoot = await context.createOrImportView(
-            spec,
-            null,
-            null,
-            "first"
-        );
-        const { dataSources: firstSources } = initializeViewSubtree(
-            firstRoot,
-            context.dataFlow
-        );
-
-        const firstUnit = /** @type {import("../view/unitView.js").default} */ (
-            firstRoot
-        );
-        const firstCollector = firstUnit.flowHandle.collector;
-        const firstInitializeSpy = vi.spyOn(firstUnit.mark, "initializeData");
-
-        await Promise.all(
-            Array.from(firstSources).map((dataSource) => dataSource.load())
-        );
-
-        expect(firstInitializeSpy).toHaveBeenCalledTimes(1);
-        firstInitializeSpy.mockRestore();
-
-        firstRoot.disposeSubtree();
-
-        // This prevents stale observers from firing after a subtree is rebuilt.
-        expect(firstCollector.observers.size).toBe(0);
-
-        const secondRoot = await context.createOrImportView(
-            spec,
-            null,
-            null,
-            "second"
-        );
-        const { dataSources: secondSources } = initializeViewSubtree(
-            secondRoot,
-            context.dataFlow
-        );
-
-        const secondUnit =
-            /** @type {import("../view/unitView.js").default} */ (secondRoot);
-        const secondInitializeSpy = vi.spyOn(secondUnit.mark, "initializeData");
-
-        await Promise.all(
-            Array.from(secondSources).map((dataSource) => dataSource.load())
-        );
-
-        expect(secondInitializeSpy).toHaveBeenCalledTimes(1);
-        secondInitializeSpy.mockRestore();
-    });
-
-    test("disposeSubtree prunes named source branches", async () => {
-        const context = createTestViewContext();
-        context.getNamedDataFromProvider = () => [{ x: 1 }];
-        context.addBroadcastListener = () => undefined;
-        context.removeBroadcastListener = () => undefined;
-
-        /** @type {import("../spec/view.js").UnitSpec} */
-        const spec = {
-            data: { name: "shared" },
-            mark: "point",
-            encoding: {
-                x: { field: "x", type: "quantitative" },
-            },
-        };
-
-        const root = await context.createOrImportView(spec, null, null, "root");
-        initializeViewSubtree(root, context.dataFlow);
-
-        const unitView = /** @type {import("../view/unitView.js").default} */ (
-            root
-        );
-        const dataSource = unitView.flowHandle.dataSource;
-
-        // This guards against stale flow branches when a subtree is disposed.
-        expect(context.dataFlow.dataSources).toContain(dataSource);
-        expect(dataSource.children.length).toBeGreaterThan(0);
-
-        root.disposeSubtree();
-
-        expect(dataSource.children.length).toBe(0);
-        expect(context.dataFlow.dataSources).not.toContain(dataSource);
-    });
-
-    test("collectNearestViewSubtreeDataSources stops at nested sources", async () => {
-        const context = createTestViewContext();
-        context.addBroadcastListener = () => undefined;
-        context.removeBroadcastListener = () => undefined;
-
-        /** @type {import("../spec/view.js").LayerSpec} */
-        const spec = {
-            data: { values: [{ x: 0 }] },
-            layer: [
-                {
-                    data: { values: [{ x: 1 }] },
-                    mark: "point",
-                    encoding: {
-                        x: { field: "x", type: "quantitative" },
-                    },
-                },
-                {
-                    mark: "point",
-                    encoding: {
-                        x: { field: "x", type: "quantitative" },
-                    },
-                },
-            ],
-        };
-
-        const root = await context.createOrImportView(spec, null, null, "root");
-        initializeViewSubtree(root, context.dataFlow);
-
-        // Nearest-source semantics: a top-level source hides deeper sources.
-        const sources = collectNearestViewSubtreeDataSources(root);
-        expect(sources.size).toBe(1);
-
-        const [rootSource] = Array.from(sources);
-        const layerRoot =
-            /** @type {import("../view/layerView.js").default} */ (root);
-        const childWithSource = layerRoot.children[0];
-
-        expect(rootSource).toBe(layerRoot.flowHandle.dataSource);
-        expect(childWithSource.flowHandle.dataSource).not.toBe(rootSource);
-    });
-
-    test("loadViewSubtreeData only loads nearest sources", async () => {
-        const context = createTestViewContext();
-        context.addBroadcastListener = () => undefined;
-        context.removeBroadcastListener = () => undefined;
-
-        /** @type {import("../spec/view.js").LayerSpec} */
-        const spec = {
-            data: { values: [{ x: 0 }] },
-            layer: [
-                {
-                    data: { values: [{ x: 1 }] },
-                    mark: "point",
-                    encoding: {
-                        x: { field: "x", type: "quantitative" },
-                    },
-                },
-            ],
-        };
-
-        const root = await context.createOrImportView(spec, null, null, "root");
-        initializeViewSubtree(root, context.dataFlow);
-
-        const layerRoot =
-            /** @type {import("../view/layerView.js").default} */ (root);
-        const rootSource = layerRoot.flowHandle.dataSource;
-        const childSource = layerRoot.children[0].flowHandle.dataSource;
-
-        const rootLoadSpy = vi.spyOn(rootSource, "load");
-        const childLoadSpy = vi.spyOn(childSource, "load");
-
-        // Data-ready should ignore nested sources.
-        await loadViewSubtreeData(root);
-
-        expect(rootLoadSpy).toHaveBeenCalledTimes(1);
-        expect(childLoadSpy).toHaveBeenCalledTimes(0);
-
-        rootLoadSpy.mockRestore();
-        childLoadSpy.mockRestore();
-    });
-
-    test("collectViewSubtreeDataSources includes nested sources", async () => {
-        const context = createTestViewContext();
-        context.addBroadcastListener = () => undefined;
-        context.removeBroadcastListener = () => undefined;
-
-        /** @type {import("../spec/view.js").LayerSpec} */
-        const spec = {
-            data: { values: [{ x: 0 }] },
-            layer: [
-                {
-                    data: { values: [{ x: 1 }] },
-                    mark: "point",
-                    encoding: {
-                        x: { field: "x", type: "quantitative" },
-                    },
-                },
-            ],
-        };
-
-        const root = await context.createOrImportView(spec, null, null, "root");
-        initializeViewSubtree(root, context.dataFlow);
-
-        // Initialization needs the full set of sources, including nested ones.
-        const sources = collectViewSubtreeDataSources(root);
-        expect(sources.size).toBe(2);
-    });
-
-    test("collectNearestViewSubtreeDataSources returns child sources when root has none", async () => {
-        const context = createTestViewContext();
-        context.addBroadcastListener = () => undefined;
-        context.removeBroadcastListener = () => undefined;
-
-        /** @type {import("../spec/view.js").HConcatSpec} */
-        const spec = {
-            hconcat: [
-                {
-                    data: { values: [{ x: 1 }] },
-                    mark: "point",
-                    encoding: {
-                        x: { field: "x", type: "quantitative" },
-                    },
-                },
-                {
-                    data: { values: [{ x: 2 }] },
-                    mark: "point",
-                    encoding: {
-                        x: { field: "x", type: "quantitative" },
-                    },
-                },
-            ],
-        };
-
-        const root = await context.createOrImportView(spec, null, null, "root");
-        initializeViewSubtree(root, context.dataFlow);
-
-        // Without a root source, the nearest sources include the child sources.
-        // Layout decorations may add additional sources.
-        const sources = collectNearestViewSubtreeDataSources(root);
-        const concatRoot =
-            /** @type {import("../view/concatView.js").default} */ (root);
-        expect(sources.has(concatRoot.children[0].flowHandle.dataSource)).toBe(
-            true
-        );
-        expect(sources.has(concatRoot.children[1].flowHandle.dataSource)).toBe(
-            true
-        );
-    });
-
-    test("loadViewSubtreeData emits subtree data ready broadcast", async () => {
-        const context = createTestViewContext();
-        context.addBroadcastListener = () => undefined;
-        context.removeBroadcastListener = () => undefined;
-
-        /** @type {import("../spec/view.js").UnitSpec} */
-        const spec = {
-            data: { values: [{ x: 1 }] },
-            mark: "point",
-            encoding: {
-                x: { field: "x", type: "quantitative" },
-            },
-        };
-
-        const root = await context.createOrImportView(spec, null, null, "root");
-        initializeViewSubtree(root, context.dataFlow);
-
-        let calls = 0;
-        root._addBroadcastHandler("subtreeDataReady", (message) => {
-            calls += 1;
-            expect(message.payload.subtreeRoot).toBe(root);
-        });
-
-        await loadViewSubtreeData(root);
-
-        expect(calls).toBe(1);
-    });
-
-    test("loadViewSubtreeData deduplicates concurrent loads", async () => {
-        const context = createTestViewContext();
-        context.getNamedDataFromProvider = () => [{ x: 1 }];
-        context.addBroadcastListener = () => undefined;
-        context.removeBroadcastListener = () => undefined;
-
-        /** @type {import("../spec/view.js").HConcatSpec} */
-        const spec = {
-            data: { name: "shared" },
-            hconcat: [
-                {
-                    mark: "point",
-                    encoding: {
-                        x: { field: "x", type: "quantitative" },
-                    },
-                },
-                {
-                    mark: "point",
-                    encoding: {
-                        x: { field: "x", type: "quantitative" },
-                    },
-                },
-            ],
-        };
-
-        const root = await context.createOrImportView(spec, null, null, "root");
-        initializeViewSubtree(root, context.dataFlow);
-
-        const dataSource = root.flowHandle.dataSource;
-        const loadSpy = vi.spyOn(dataSource, "load");
-
-        // Prevent duplicate fetches when concurrent subtrees share a source.
-        await Promise.all([
-            loadViewSubtreeData(root, new Set([dataSource])),
-            loadViewSubtreeData(root, new Set([dataSource])),
-        ]);
-
-        expect(loadSpy).toHaveBeenCalledTimes(1);
-        loadSpy.mockRestore();
-    });
-});