@genome-spy/core 0.30.0 → 0.30.3

package/src/data/flowNode.js

@@ -1,283 +0,0 @@
-import { range } from "d3-array";
-
-/**
- * The FlowNode clones the data objects passing through or creates entirely
- * new objects.
- */
-export const BEHAVIOR_CLONES = 1 << 0;
-
-/**
- * FlowNode modifies the objects that pass through. Creating defensive copies
- * (clones) in an upstream node may be appropriate, depending on branching.
- */
-export const BEHAVIOR_MODIFIES = 1 << 1;
-
-const ROOT_CONTEXT_OBJECT = {};
-/**
- * This is heavily inspired by Vega's and Vega-Lite's data flow system.
- *
- * @typedef {import("./flowBatch").FlowBatch} FlowBatch
- *
- * @typedef {Record<string, any>} Datum
- * @typedef {Datum[]} Data
- */
-export default class FlowNode {
-    get behavior() {
-        return 0;
-    }
-
-    constructor() {
-        /** @type {FlowNode[]} */
-        this.children = [];
-
-        /** @type {FlowNode} */
-        this.parent = undefined;
-
-        /** True if all data have been processed */
-        this.completed = false;
-    }
-
-    /**
-     * Resets the node and all its descendants to their initial state, i.e., preparing
-     * for a new batch of data.
-     */
-    reset() {
-        this.completed = false;
-
-        for (const child of this.children) {
-            child.reset();
-        }
-    }
-
-    /**
-     * Allows for doing final initialization after the flow structure has been
-     * built and optimized. Must be called before any data are to be propagated.
-     */
-    initialize() {
-        // override
-    }
-
-    /**
-     * Dynamically updates the propagator method to allow the JavaScript engine
-     * to employ optimizations such as inlining.
-     */
-    _updatePropagator() {
-        this._propagate = Function(
-            "children",
-            range(this.children.length)
-                .map((i) => `const child${i} = children[${i}];`)
-                .join("\n") +
-                `return function propagate(datum) {${range(this.children.length)
-                    .map((i) => `child${i}.handle(datum);`)
-                    .join("\n")}}`
-        )(this.children);
-    }
-
-    /**
-     *
-     * @param {FlowNode} parent
-     */
-    setParent(parent) {
-        this.parent = parent;
-    }
-
-    /**
-     *
-     * @param {FlowNode} child
-     */
-    addChild(child) {
-        if (child.parent) {
-            throw new Error("Cannot add the child! It already has a parent.");
-        }
-        this.children.push(child);
-        child.setParent(this);
-        this._updatePropagator();
-        return this;
-    }
-
-    /**
-     * @param {FlowNode} node
-     */
-    adopt(node) {
-        if (node.parent) {
-            node.parent.removeChild(node);
-        }
-
-        this.addChild(node);
-    }
-
-    /**
-     * @param {FlowNode} otherParent
-     */
-    adoptChildrenOf(otherParent) {
-        for (const child of otherParent.children) {
-            this.adopt(child);
-        }
-    }
-
-    /**
-     * @param {FlowNode} newParent
-     */
-    insertAsParent(newParent) {
-        if (this.isRoot()) {
-            // Root should always be a data source
-            throw new Error("Cannot insert a new parent for a root node!");
-        }
-
-        newParent.parent = this.parent;
-        this.parent.children[this.parent.children.indexOf(this)] = newParent;
-        this.parent._updatePropagator();
-        this.parent = undefined;
-        newParent.addChild(this);
-    }
-
-    /**
-     *
-     * @param {FlowNode} child
-     */
-    removeChild(child) {
-        const index = this.children.indexOf(child);
-        if (index > -1) {
-            this.children.splice(index, 1);
-            child.parent = undefined;
-            this._updatePropagator();
-        } else {
-            throw new Error("Trying to remove an unknown child node!");
-        }
-    }
-
-    /**
-     * Removes this node and ligates (connects) the preceding and succeeding nodes.
-     */
-    excise() {
-        if (this.isRoot()) {
-            // TODO: Implement
-            throw new Error("Cannot excise root node!");
-        } else if (this.isTerminal()) {
-            this.parent.removeChild(this);
-        } else if (this.children.length == 1) {
-            const child = this.children[0];
-            child.setParent(this.parent);
-            this.parent.children[this.parent.children.indexOf(this)] = child;
-            this.parent._updatePropagator();
-            this.setParent(undefined);
-            this.children.length = 0;
-        } else {
-            // TODO: Implement
-            throw new Error("Cannot excise a node that has multiple children!");
-        }
-    }
-
-    isRoot() {
-        return !this.parent;
-    }
-
-    isBranching() {
-        return this.children.length > 1;
-    }
-
-    isTerminal() {
-        return this.children.length == 0;
-    }
-
-    /**
-     * Visits child nodes in depth-first order.
-     *
-     * @param {(function(FlowNode):void) & { afterChildren?: function(FlowNode):void}} visitor
-     */
-    visit(visitor) {
-        // pre-order
-        visitor(this);
-
-        for (const child of this.children) {
-            child.visit(visitor);
-        }
-
-        // post-oder
-        if (visitor.afterChildren) {
-            visitor.afterChildren(this);
-        }
-    }
-
-    /**
-     * @param {number} [depth]
-     * @returns {string}
-     */
-    subtreeToString(depth = 0) {
-        const childTree = this.children
-            .map((child) => child.subtreeToString(depth + 1))
-            .join("");
-        return (
-            " ".repeat(depth * 2) +
-            "* " +
-            /^class ([A-Za-z0-9_]+)/.exec("" + this.constructor)?.[1] +
-            "\n" +
-            childTree
-        );
-    }
-
-    /**
-     * The global object for expressions (in formula and filter transforms).
-     * Nodes in the hierarchy may extend the object using Object.create to
-     * introduce variables that are visible downstream the flow.
-     *
-     * @returns {Record<string, any>}
-     */
-    getGlobalObject() {
-        return this.parent
-            ? this.parent.getGlobalObject()
-            : ROOT_CONTEXT_OBJECT;
-    }
-
-    /**
-     *
-     * @param {Datum} datum
-     */
-    handle(datum) {
-        // Default implementation just passes through
-        this._propagate(datum);
-    }
-
-    complete() {
-        this.completed = true;
-
-        for (const child of this.children) {
-            child.complete();
-        }
-    }
-
-    /**
-     * Signals that a new batch of data will be propagated.
-     *
-     * @param {FlowBatch} flowBatch
-     */
-    beginBatch(flowBatch) {
-        for (const child of this.children) {
-            child.beginBatch(flowBatch);
-        }
-    }
-
-    /**
-     *
-     * @param {any} datum
-     */
-    _propagate(datum) {
-        // Implementation is set dynamically in add/removeChild
-    }
-}
-
-/**
- * @param {FlowBatch} flowBatch
- * @returns {flowBatch is import("./flowBatch").FileBatch}
- */
-export function isFileBatch(flowBatch) {
-    return flowBatch.type == "file";
-}
-
-/**
- * @param {FlowBatch} flowBatch
- * @returns {flowBatch is import("./flowBatch").FacetBatch}
- */
-export function isFacetBatch(flowBatch) {
-    return flowBatch.type == "facet";
-}

package/src/data/flowNode.test.js

@@ -1,50 +0,0 @@
-import { describe, expect, test } from "vitest";
-import FlowNode from "./flowNode";
-import { validateLinks } from "./flowOptimizer";
-
-describe("Flow mutation", () => {
-    test("Excise a terminal node", () => {
-        const a = new FlowNode();
-        const b = new FlowNode();
-
-        a.addChild(b);
-        b.excise();
-
-        expect(a.children[0]).toBeUndefined();
-        expect(b.parent).toBeUndefined();
-
-        expect(validateLinks(a)).toBeTruthy();
-    });
-
-    test("Excise a node in the middle", () => {
-        const a = new FlowNode();
-        const b = new FlowNode();
-        const c = new FlowNode();
-
-        a.addChild(b);
-        b.addChild(c);
-        b.excise();
-
-        expect(a.children[0]).toBe(c);
-        expect(c.parent).toBe(a);
-
-        expect(validateLinks(a)).toBeTruthy();
-    });
-
-    test("Insert as parent", () => {
-        const a = new FlowNode();
-        const b = new FlowNode();
-        const c = new FlowNode();
-        const d = new FlowNode();
-
-        a.addChild(c);
-        a.addChild(d);
-        c.insertAsParent(b);
-
-        expect(a.children[0]).toBe(b);
-        expect(a.children[1]).toBe(d);
-        expect(a.children[0].children[0]).toBe(c);
-
-        expect(validateLinks(a)).toBeTruthy();
-    });
-});

package/src/data/flowOptimizer.js

@@ -1,123 +0,0 @@
-import Collector from "./collector";
-import { BEHAVIOR_CLONES } from "./flowNode";
-import CloneTransform from "./transforms/clone";
-
-/**
- * @typedef {import("./flowNode").default} FlowNode
- * @typedef {import("./sources/dataSource").default} DataSource
- * @typedef {import("./dataFlow").default<any>} DataFlow
- */
-
-/**
- * @param {FlowNode} node
- * @param {FlowNode} [parent]
- */
-export function validateLinks(node, parent = undefined) {
-    if (node.parent !== parent) {
-        return false;
-    }
-
-    for (const child of node.children) {
-        if (!validateLinks(child, node)) {
-            return false;
-        }
-    }
-
-    return true;
-}
-
-/**
- * Removes possible redundant CloneTransforms that were added during graph construction.
- *
- * @param {FlowNode} node
- */
-export function removeRedundantCloneTransforms(node, cloneRequired = false) {
-    if (node instanceof Collector) {
-        // If an object is modified downstream of Collector, it must be cloned
-        cloneRequired = true;
-    }
-
-    if (node instanceof CloneTransform) {
-        if (cloneRequired) {
-            cloneRequired = false;
-        } else {
-            const child = node.children[0];
-            node.excise();
-            if (child) {
-                removeRedundantCloneTransforms(child, cloneRequired);
-            }
-            return;
-        }
-    }
-
-    if (node.behavior & BEHAVIOR_CLONES) {
-        cloneRequired = false;
-    }
-
-    for (let i = 0, n = node.children.length; i < n; i++) {
-        // All but the last branch need defensive copies to prevent side effects
-        removeRedundantCloneTransforms(
-            node.children[i],
-            cloneRequired || i < n - 1
-        );
-    }
-}
-
-export function removeRedundantCollectors() {
-    // TODO: Remove chained collectors, e.g., first collect and sort, then just collect
-}
-
-export function combineAndPullCollectorsUp() {
-    // TODO:
-}
-
-/**
- * @param {import("./dataFlow").default<any>} dataFlow
- */
-export function combineIdenticalDataSources(dataFlow) {
-    const dataSourceEntries = [...dataFlow._dataSourcesByHost.entries()];
-
-    /** @type {Map<string, DataSource>} */
-    const sourcesByIdentifiers = new Map();
-    for (const e of dataSourceEntries) {
-        const ds = e[1];
-        if (ds.identifier && !sourcesByIdentifiers.has(ds.identifier)) {
-            sourcesByIdentifiers.set(ds.identifier, ds);
-        }
-    }
-
-    dataFlow._dataSourcesByHost.clear();
-
-    for (let [key, dataSource] of dataSourceEntries) {
-        const target = sourcesByIdentifiers.get(dataSource.identifier);
-        if (target) {
-            target.adoptChildrenOf(dataSource);
-            dataSource = target;
-        }
-        dataFlow.addDataSource(dataSource, key);
-    }
-}
-
-/**
- *
- * @param {FlowNode} root
- */
-export function optimizeFlowGraph(root) {
-    removeRedundantCloneTransforms(root);
-    if (!validateLinks(root)) {
-        throw new Error(
-            "Encountered a bug! There's a problem in the data flow structure."
-        );
-    }
-}
-
-/**
- * @param {import("./dataFlow").default<any>} dataFlow
- */
-export function optimizeDataFlow(dataFlow) {
-    for (const dataSource of dataFlow.dataSources) {
-        optimizeFlowGraph(dataSource);
-    }
-
-    combineIdenticalDataSources(dataFlow);
-}

package/src/data/flowOptimizer.test.js

@@ -1,193 +0,0 @@
-import { describe, expect, test } from "vitest";
-import FlowNode, { BEHAVIOR_CLONES } from "./flowNode";
-import { removeRedundantCloneTransforms, validateLinks } from "./flowOptimizer";
-import CloneTransform from "./transforms/clone";
-import Collector from "./collector";
-import DataFlow from "./dataFlow";
-import { combineIdenticalDataSources } from "./flowOptimizer";
-import InlineSource from "./sources/inlineSource";
-import UrlSource from "./sources/urlSource";
-
-test("validateLinks() detects broken graph", () => {
-    const root = new FlowNode();
-    const a = new FlowNode();
-    const b = new FlowNode();
-    const c = new FlowNode();
-
-    root.addChild(a);
-    root.addChild(b);
-    root.addChild(c);
-
-    expect(validateLinks(root)).toBeTruthy();
-
-    // Break it!
-    b.parent = undefined;
-
-    expect(validateLinks(root)).toBeFalsy();
-
-    // Check handling of root
-
-    const rootWithParent = new FlowNode();
-    // Break it!
-    rootWithParent.parent = new FlowNode();
-
-    expect(validateLinks(rootWithParent)).toBeFalsy();
-});
-
-describe("removeRedundantCloneTransforms", () => {
-    test("Removes redundancy from linear graph #1", () => {
-        const a = new FlowNode();
-        const b = new CloneTransform();
-        const c = new FlowNode();
-        const d = new CloneTransform();
-        const e = new CloneTransform();
-        const f = new FlowNode();
-
-        a.addChild(b);
-        b.addChild(c);
-        c.addChild(d);
-        d.addChild(e);
-        e.addChild(f);
-
-        removeRedundantCloneTransforms(a);
-
-        expect(a.children[0]).toBe(c);
-        expect(c.children[0]).toBe(f);
-    });
-
-    test("Removes redundancy from linear graph #2", () => {
-        const a = new FlowNode();
-        const b = new CloneTransform();
-        const c = new FlowNode();
-        const d = new CloneTransform();
-        const e = new CloneTransform();
-        const f = new FlowNode();
-
-        a.addChild(b);
-        b.addChild(c);
-        c.addChild(d);
-        d.addChild(e);
-        e.addChild(f);
-
-        // First CloneTransform should be retained
-        removeRedundantCloneTransforms(a, true);
-
-        expect(a.children[0]).toBe(b);
-        expect(b.children[0]).toBe(c);
-        expect(c.children[0]).toBe(f);
-    });
-
-    test("Node with cloning behavior satisfies cloning requirement", () => {
-        class CloningFlowNode extends FlowNode {
-            get behavior() {
-                return BEHAVIOR_CLONES;
-            }
-        }
-
-        const a = new FlowNode();
-        const b = new CloningFlowNode();
-        const c = new FlowNode();
-        const d = new CloneTransform();
-        const e = new FlowNode();
-
-        a.addChild(b);
-        b.addChild(c);
-        c.addChild(d);
-        d.addChild(e);
-
-        removeRedundantCloneTransforms(a, true);
-
-        expect(a.children[0]).toBe(b);
-        expect(b.children[0]).toBe(c);
-        expect(c.children[0]).toBe(e);
-    });
-
-    test("Removes redundancy from a branching graph", () => {
-        const root = new FlowNode();
-        const branching = new FlowNode();
-        const a = new CloneTransform();
-        const al = new FlowNode();
-        const b = new CloneTransform();
-        const bl = new FlowNode();
-        const c = new CloneTransform();
-        const cl = new FlowNode();
-
-        root.addChild(branching);
-        branching.addChild(a);
-        branching.addChild(b);
-        branching.addChild(c);
-        a.addChild(al);
-        b.addChild(bl);
-        c.addChild(cl);
-
-        removeRedundantCloneTransforms(root);
-
-        // All but the last branch needs cloning
-        expect(branching.children[0]).toBe(a);
-        expect(branching.children[1]).toBe(b);
-        expect(branching.children[2]).toBe(cl);
-    });
-});
-
-describe("Merge indentical data sources", () => {
-    test("Merges correctly", () => {
-        /** @type {DataFlow<string>} */
-        const dataFlow = new DataFlow();
-
-        const a = new UrlSource({ url: "http://genomespy.app/" });
-        const ac = new Collector();
-        a.addChild(ac);
-
-        const b = new UrlSource({ url: "http://genomespy.app/" });
-        const bc = new Collector();
-        b.addChild(bc);
-
-        const c = new UrlSource({ url: "http://helsinki.fi/" });
-        const cc = new Collector();
-        c.addChild(cc);
-
-        dataFlow.addDataSource(a, "a");
-        dataFlow.addDataSource(b, "b");
-        dataFlow.addDataSource(c, "c");
-
-        dataFlow.addCollector(ac, "a");
-        dataFlow.addCollector(bc, "b");
-        dataFlow.addCollector(cc, "c");
-
-        combineIdenticalDataSources(dataFlow);
-
-        expect(dataFlow.dataSources.length).toEqual(2);
-
-        expect(dataFlow.findDataSourceByKey("a")).toBe(a);
-        expect(dataFlow.findDataSourceByKey("b")).toBe(a); // Merged!
-        expect(dataFlow.findDataSourceByKey("c")).toBe(c);
-
-        expect(new Set(a.children)).toEqual(new Set([ac, bc]));
-        expect(c.children[0]).toBe(cc);
-
-        for (const dataSource of dataFlow.dataSources) {
-            // Cheat that we loaded something
-            dataSource.complete();
-        }
-
-        expect(ac.completed).toBeTruthy();
-        expect(bc.completed).toBeTruthy();
-        expect(cc.completed).toBeTruthy();
-    });
-
-    test("Does not merge those with undefined identifier", () => {
-        /** @type {DataFlow<string>} */
-        const dataFlow = new DataFlow();
-
-        const a = new InlineSource({ values: [1, 2, 3] });
-        const b = new InlineSource({ values: [1, 2, 3] });
-
-        dataFlow.addDataSource(a, "a");
-        dataFlow.addDataSource(b, "b");
-
-        combineIdenticalDataSources(dataFlow);
-
-        expect(dataFlow.findDataSourceByKey("a")).toBe(a);
-        expect(dataFlow.findDataSourceByKey("b")).toBe(b);
-    });
-});

package/src/data/flowTestUtils.js

@@ -1,63 +0,0 @@
-import Collector from "./collector";
-import FlowNode from "./flowNode";
-
-/**
- *
- * @param {import("./flowNode").default} flowNode
- * @param {any[]} data
- */
-export function processData(flowNode, data) {
-    const collector = new Collector();
-    flowNode.addChild(collector);
-
-    for (const d of data) {
-        flowNode.handle(d);
-    }
-    flowNode.complete();
-
-    flowNode.removeChild(collector);
-
-    return [...collector.getData()];
-}
-
-/**
- * For testing
- */
-export class SynchronousSource extends FlowNode {
-    /**
-     *
-     * @param {any[]} data
-     */
-    constructor(data) {
-        super();
-        this.data = data;
-    }
-
-    dispatch() {
-        for (const d of this.data) {
-            this._propagate(d);
-        }
-
-        this.complete();
-    }
-}
-
-/**
- * For testing
- */
-export class SynchronousSequenceSource extends SynchronousSource {
-    /**
-     *
-     * @param {number} n number of elements
-     */
-    constructor(n) {
-        n = n || 10;
-
-        const data = [];
-        for (let i = 0; i < n; i++) {
-            data.push({ data: i });
-        }
-
-        super(data);
-    }
-}