@genome-spy/core 0.63.0 → 0.65.0

package/dist/schema.json

@@ -1654,6 +1654,15 @@
         }
       ]
     },
+    "DomEventType": {
+      "enum": [
+        "click",
+        "dblclick",
+        "mouseover",
+        "pointerover"
+      ],
+      "type": "string"
+    },
     "DsvDataFormat": {
       "additionalProperties": false,
       "properties": {
@@ -2107,6 +2116,23 @@
       },
       "type": "object"
     },
+    "EventConfig": {
+      "additionalProperties": false,
+      "properties": {
+        "filter": {
+          "description": "An optional filter expression to further filter events of the specified type. The expression can only refer to the event object as `event`, and should evaluate to a boolean value indicating whether to include the event. No other data or parameters are in scope.",
+          "type": "string"
+        },
+        "type": {
+          "$ref": "#/definitions/DomEventType",
+          "description": "The type of event to listen to. For example, `\"click\"` or `\"mouseover\"`."
+        }
+      },
+      "required": [
+        "type"
+      ],
+      "type": "object"
+    },
     "ExprDef": {
       "additionalProperties": false,
       "properties": {
@@ -3715,6 +3741,23 @@
     "IntervalSelectionConfig": {
       "additionalProperties": false,
       "properties": {
+        "clear": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/DomEventType"
+            },
+            {
+              "$ref": "#/definitions/EventConfig"
+            },
+            {
+              "type": "string"
+            },
+            {
+              "type": "boolean"
+            }
+          ],
+          "description": "A string or object that defines the events that should clear the selection.\n\n__Default value:__ `\"dblclick\"`"
+        },
         "encodings": {
           "description": "An array of encoding channels that define the interval selection.",
           "items": {
@@ -3727,16 +3770,22 @@
           "description": "Interval selections display a rectangle mark to show the selected range. Use the `mark` property to adjust the appearance of this rectangle."
         },
         "on": {
-          "enum": [
-            "click",
-            "mouseover",
-            "pointerover"
+          "anyOf": [
+            {
+              "$ref": "#/definitions/DomEventType"
+            },
+            {
+              "$ref": "#/definitions/EventConfig"
+            },
+            {
+              "type": "string"
+            }
           ],
-          "type": "string"
+          "description": "A string or object that defines the events to which the selection should listen."
         },
         "type": {
           "const": "interval",
-          "description": "Determines the default event processing and data query for the selection. Vega-Lite currently supports two selection types:\n\n- `\"point\"` -- to select multiple discrete data values; the first value is selected on `click` and additional values toggled on shift-click.\n- `\"interval\"` -- to select a continuous range of data values on `drag`.",
+          "description": "The selection type.\n\n- `\"point\"` -- to select multiple discrete data values; the first value is selected on `click` and additional values toggled on shift-click.\n- `\"interval\"` -- to select a continuous range of data values on `drag`.",
           "type": "string"
         }
       },
@@ -4978,13 +5027,36 @@
     "PointSelectionConfig": {
       "additionalProperties": false,
       "properties": {
+        "clear": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/DomEventType"
+            },
+            {
+              "$ref": "#/definitions/EventConfig"
+            },
+            {
+              "type": "string"
+            },
+            {
+              "type": "boolean"
+            }
+          ],
+          "description": "A string or object that defines the events that should clear the selection.\n\n__Default value:__ `\"dblclick\"`"
+        },
         "on": {
-          "enum": [
-            "click",
-            "mouseover",
-            "pointerover"
+          "anyOf": [
+            {
+              "$ref": "#/definitions/DomEventType"
+            },
+            {
+              "$ref": "#/definitions/EventConfig"
+            },
+            {
+              "type": "string"
+            }
           ],
-          "type": "string"
+          "description": "A string or object that defines the events to which the selection should listen."
         },
         "toggle": {
           "description": "Controls whether data values should be toggled (inserted or removed from a point selection) when clicking with the shift key pressed.\n\n- `true` -- additional values can be selected by shift-clicking.\n- `false` -- only a single value can be selected at a time.\n\n__Default value:__ `true`",
@@ -4992,7 +5064,7 @@
         },
         "type": {
           "const": "point",
-          "description": "Determines the default event processing and data query for the selection. Vega-Lite currently supports two selection types:\n\n- `\"point\"` -- to select multiple discrete data values; the first value is selected on `click` and additional values toggled on shift-click.\n- `\"interval\"` -- to select a continuous range of data values on `drag`.",
+          "description": "The selection type.\n\n- `\"point\"` -- to select multiple discrete data values; the first value is selected on `click` and additional values toggled on shift-click.\n- `\"interval\"` -- to select a continuous range of data values on `drag`.",
           "type": "string"
         }
       },
@@ -8111,7 +8183,7 @@
           "type": "string"
         },
         "type": {
-          "$ref": "#/definitions/Type",
+          "$ref": "#/definitions/SampleAttributeType",
           "description": "The attribute type. One of `\"nominal\"`, `\"ordinal\"`, or `\"quantitative\"`."
         },
         "visible": {
@@ -8125,6 +8197,14 @@
       },
       "type": "object"
     },
+    "SampleAttributeType": {
+      "enum": [
+        "nominal",
+        "ordinal",
+        "quantitative"
+      ],
+      "type": "string"
+    },
     "SampleDef": {
       "additionalProperties": false,
       "properties": {

package/dist/src/data/collector.d.ts

@@ -10,10 +10,15 @@ export default class Collector extends FlowNode {
      */
     constructor(params?: import("../spec/transform.js").CollectParams);
     params: import("../spec/transform.js").CollectParams;
-    /** @type {(function(Collector):void)[]} */
-    observers: ((arg0: Collector) => void)[];
+    /** @type {Set<function(Collector):void>} */
+    observers: Set<(arg0: Collector) => void>;
     /** @type {Map<import("../spec/channel.js").Scalar[], Data>} TODO: proper type for key */
     facetBatches: Map<import("../spec/channel.js").Scalar[], import("./flowNode.js").Data>;
+    /**
+     * @param {function(Collector):void} listener
+     * @returns {() => void}
+     */
+    observe(listener: (arg0: Collector) => void): () => void;
     /**
      * @returns {Iterable<Datum>}
      */

package/dist/src/data/collector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"collector.d.ts","sourceRoot":"","sources":["../../../src/data/collector.js"],"names":[],"mappings":"AAUA;;;;;GAKG;AACH;IAuCI;;OAEG;IACH,qBAFW,OAAO,sBAAsB,EAAE,aAAa,EAiBtD;IAZG,qDAA2C;IAE3C,2CAA2C;IAC3C,WADW,CAAC,CAAS,IAAS,EAAT,SAAS,KAAE,IAAI,CAAC,EAAE,CACpB;IAGnB,yFAAyF;IACzF,cADW,GAAG,CAAC,OAAO,oBAAoB,EAAE,MAAM,EAAE,+BAAO,CACN;IAgHzD;;OAEG;IACH,WAFa,QAAQ,+BAAO,CAqB3B;IAED;;;OAGG;IACH,mBAFW,CAAC,KAAK,+BAAO,KAAK,IAAI,QAUhC;IAED;;OAEG;IACH,uBAMC;IA8CD;;;;OAIG;IACH,8BAFW,MAAM,iCA4BhB;;CACJ;qBA7SyD,eAAe"}
+{"version":3,"file":"collector.d.ts","sourceRoot":"","sources":["../../../src/data/collector.js"],"names":[],"mappings":"AAUA;;;;;GAKG;AACH;IAuCI;;OAEG;IACH,qBAFW,OAAO,sBAAsB,EAAE,aAAa,EAiBtD;IAZG,qDAA2C;IAE3C,4CAA4C;IAC5C,WADW,GAAG,CAAC,CAAS,IAAS,EAAT,SAAS,KAAE,IAAI,CAAC,CACd;IAG1B,yFAAyF;IACzF,cADW,GAAG,CAAC,OAAO,oBAAoB,EAAE,MAAM,EAAE,+BAAO,CACN;IAmFzD;;;OAGG;IACH,kBAHW,CAAS,IAAS,EAAT,SAAS,KAAE,IAAI,GACtB,MAAM,IAAI,CAOtB;IA+BD;;OAEG;IACH,WAFa,QAAQ,+BAAO,CAqB3B;IAED;;;OAGG;IACH,mBAFW,CAAC,KAAK,+BAAO,KAAK,IAAI,QAUhC;IAED;;OAEG;IACH,uBAMC;IA8CD;;;;OAIG;IACH,8BAFW,MAAM,iCA4BhB;;CACJ;qBAxTyD,eAAe"}

package/dist/src/data/collector.js

@@ -61,8 +61,8 @@ export default class Collector extends FlowNode {
 
         this.params = params ?? { type: "collect" };
 
-        /** @type {(function(Collector):void)[]} */
-        this.observers = [];
+        /** @type {Set<function(Collector):void>} */
+        this.observers = new Set();
 
         // TODO: Consider nested maps instead of InternMap
         /** @type {Map<import("../spec/channel.js").Scalar[], Data>} TODO: proper type for key */
@@ -149,6 +149,17 @@ export default class Collector extends FlowNode {
         }
     }
 
+    /**
+     * @param {function(Collector):void} listener
+     * @returns {() => void}
+     */
+    observe(listener) {
+        this.observers.add(listener);
+        return () => {
+            this.observers.delete(listener);
+        };
+    }
+
     #propagateToChildren() {
         if (this.children.length) {
             for (const [facetId, data] of this.facetBatches.entries()) {

package/dist/src/data/dataFlow.d.ts

@@ -1,65 +1,43 @@
 /**
- * @template H A key (string, object, whatever) that is used to retrieve
- *      data sources and collectors.
+ * DataFlow holds data sources and collectors for optimization and initialization.
  */
-export default class DataFlow<H> {
-    /** @type {Map<H, import("./sources/dataSource.js").default>} */
-    _dataSourcesByHost: Map<H, import("./sources/dataSource.js").default>;
-    /** @type {Map<H, import("./collector.js").default>} */
-    _collectorsByHost: Map<H, import("./collector.js").default>;
-    /** @type {Map<H, (function(import("./collector.js").default):void)[]>} */
-    _observers: Map<H, ((arg0: import("./collector.js").default) => void)[]>;
-    get dataSources(): import("./sources/dataSource.js").default[];
+export default class DataFlow {
+    get dataSources(): DataSource[];
     get collectors(): import("./collector.js").default[];
     /**
-     * Adds a callback function that will be called when a collector has completed.
-     *
-     * @param {function(import("./collector.js").default):void} callback
-     * @param {H} key
-     */
-    addObserver(callback: (arg0: import("./collector.js").default) => void, key: H): void;
-    /**
-     *
-     * @param {import("./collector.js").default} collector
-     * @param {H} key
+     * @param {Iterable<import("./sources/dataSource.js").default>} dataSources
      */
-    _relayObserverCallback(collector: import("./collector.js").default, key: H): void;
+    replaceDataSources(dataSources: Iterable<import("./sources/dataSource.js").default>): void;
     /**
-     *
      * @param {import("./sources/dataSource.js").default} dataSource
-     * @param {H} key
      */
-    addDataSource(dataSource: import("./sources/dataSource.js").default, key: H): void;
+    addDataSource(dataSource: import("./sources/dataSource.js").default): void;
     /**
-     *
-     * @param {H} key
+     * @param {import("./sources/dataSource.js").default} dataSource
      */
-    findDataSourceByKey(key: H): import("./sources/dataSource.js").default;
+    removeDataSource(dataSource: import("./sources/dataSource.js").default): void;
     /**
-     *
-     * @param {string} name
+     * @param {import("./collector.js").default} collector
      */
-    findNamedDataSource(name: string): {
-        dataSource: NamedSource;
-        hosts: H[];
-    };
+    addCollector(collector: import("./collector.js").default): void;
     /**
-     *
      * @param {import("./collector.js").default} collector
-     * @param {H} key
      */
-    addCollector(collector: import("./collector.js").default, key: H): void;
+    removeCollector(collector: import("./collector.js").default): void;
     /**
+     * Prune a collector branch from the flow graph, removing empty ancestors.
      *
-     * @param {H} key
+     * @param {import("./collector.js").default} collector
      */
-    findCollectorByKey(key: H): import("./collector.js").default;
+    pruneCollectorBranch(collector: import("./collector.js").default): void;
     /**
-     * Allows the flow nodes to perform final initialization after the flow
-     * structure has been built and optimized.
-     * Must be called before any data are to be propagated.
+     * @param {string} name
      */
-    initialize(): void;
+    findNamedDataSource(name: string): {
+        dataSource: NamedSource;
+    };
+    #private;
 }
+import DataSource from "./sources/dataSource.js";
 import NamedSource from "./sources/namedSource.js";
 //# sourceMappingURL=dataFlow.d.ts.map

package/dist/src/data/dataFlow.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dataFlow.d.ts","sourceRoot":"","sources":["../../../src/data/dataFlow.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,8BAHa,CAAC;IAKN,gEAAgE;IAChE,oBADW,GAAG,CAAC,CAAC,EAAE,OAAO,yBAAyB,EAAE,OAAO,CAAC,CACzB;IAEnC,uDAAuD;IACvD,mBADW,GAAG,CAAC,CAAC,EAAE,OAAO,gBAAgB,EAAE,OAAO,CAAC,CACjB;IAElC,0EAA0E;IAC1E,YADW,GAAG,CAAC,CAAC,EAAE,CAAC,CAAS,IAAgC,EAAhC,OAAO,gBAAgB,EAAE,OAAO,KAAE,IAAI,CAAC,EAAE,CAAC,CAC3C;IAG/B,+DAEC;IAED,qDAEC;IAED;;;;;OAKG;IACH,sBAHW,CAAS,IAAgC,EAAhC,OAAO,gBAAgB,EAAE,OAAO,KAAE,IAAI,OAC/C,CAAC,QAUX;IAED;;;;OAIG;IACH,kCAHW,OAAO,gBAAgB,EAAE,OAAO,OAChC,CAAC,QAUX;IAED;;;;OAIG;IACH,0BAHW,OAAO,yBAAyB,EAAE,OAAO,OACzC,CAAC,QAIX;IAED;;;OAGG;IACH,yBAFW,CAAC,6CAIX;IAED;;;OAGG;IACH,0BAFW,MAAM;;;MAiChB;IAED;;;;OAIG;IACH,wBAHW,OAAO,gBAAgB,EAAE,OAAO,OAChC,CAAC,QAOX;IAED;;;OAGG;IACH,wBAFW,CAAC,oCAIX;IAED;;;;OAIG;IACH,mBAIC;CACJ;wBA7IuB,0BAA0B"}
+{"version":3,"file":"dataFlow.d.ts","sourceRoot":"","sources":["../../../src/data/dataFlow.js"],"names":[],"mappings":"AAGA;;GAEG;AACH;IAeI,gCAEC;IAED,qDAEC;IAED;;OAEG;IACH,gCAFW,QAAQ,CAAC,OAAO,yBAAyB,EAAE,OAAO,CAAC,QAI7D;IAED;;OAEG;IACH,0BAFW,OAAO,yBAAyB,EAAE,OAAO,QAInD;IAED;;OAEG;IACH,6BAFW,OAAO,yBAAyB,EAAE,OAAO,QAInD;IAED;;OAEG;IACH,wBAFW,OAAO,gBAAgB,EAAE,OAAO,QAI1C;IAED;;OAEG;IACH,2BAFW,OAAO,gBAAgB,EAAE,OAAO,QAK1C;IAED;;;;OAIG;IACH,gCAFW,OAAO,gBAAgB,EAAE,OAAO,QAiB1C;IAED;;OAEG;IACH,0BAFW,MAAM;;MA2BhB;;CAGJ;uBAtHsB,yBAAyB;wBACxB,0BAA0B"}

package/dist/src/data/dataFlow.js

@@ -1,92 +1,100 @@
+import DataSource from "./sources/dataSource.js";
 import NamedSource from "./sources/namedSource.js";
 
 /**
- * @template H A key (string, object, whatever) that is used to retrieve
- *      data sources and collectors.
+ * DataFlow holds data sources and collectors for optimization and initialization.
  */
 export default class DataFlow {
-    constructor() {
-        /** @type {Map<H, import("./sources/dataSource.js").default>} */
-        this._dataSourcesByHost = new Map();
+    /** @type {Set<import("./sources/dataSource.js").default>} */
+    #dataSources;
+
+    /** @type {Set<import("./collector.js").default>} */
+    #collectors;
 
-        /** @type {Map<H, import("./collector.js").default>} */
-        this._collectorsByHost = new Map();
+    constructor() {
+        /** @type {Set<import("./sources/dataSource.js").default>} */
+        this.#dataSources = new Set();
 
-        /** @type {Map<H, (function(import("./collector.js").default):void)[]>} */
-        this._observers = new Map();
+        /** @type {Set<import("./collector.js").default>} */
+        this.#collectors = new Set();
     }
 
     get dataSources() {
-        return [...new Set(this._dataSourcesByHost.values()).values()];
+        return [...this.#dataSources];
     }
 
     get collectors() {
-        return [...this._collectorsByHost.values()];
+        return [...this.#collectors];
     }
 
     /**
-     * Adds a callback function that will be called when a collector has completed.
-     *
-     * @param {function(import("./collector.js").default):void} callback
-     * @param {H} key
+     * @param {Iterable<import("./sources/dataSource.js").default>} dataSources
      */
-    addObserver(callback, key) {
-        let arr = this._observers.get(key);
-        if (!arr) {
-            arr = [];
-            this._observers.set(key, arr);
-        }
+    replaceDataSources(dataSources) {
+        this.#dataSources = new Set(dataSources);
+    }
 
-        arr.push(callback);
+    /**
+     * @param {import("./sources/dataSource.js").default} dataSource
+     */
+    addDataSource(dataSource) {
+        this.#dataSources.add(dataSource);
+    }
+
+    /**
+     * @param {import("./sources/dataSource.js").default} dataSource
+     */
+    removeDataSource(dataSource) {
+        this.#dataSources.delete(dataSource);
     }
 
     /**
-     *
      * @param {import("./collector.js").default} collector
-     * @param {H} key
      */
-    _relayObserverCallback(collector, key) {
-        const arr = this._observers.get(key);
-        if (arr) {
-            for (const callback of arr) {
-                // eslint-disable-next-line callback-return
-                callback(collector);
-            }
-        }
+    addCollector(collector) {
+        this.#collectors.add(collector);
     }
 
     /**
-     *
-     * @param {import("./sources/dataSource.js").default} dataSource
-     * @param {H} key
+     * @param {import("./collector.js").default} collector
      */
-    addDataSource(dataSource, key) {
-        this._dataSourcesByHost.set(key, dataSource);
+    removeCollector(collector) {
+        collector.observers.clear();
+        this.#collectors.delete(collector);
     }
 
     /**
+     * Prune a collector branch from the flow graph, removing empty ancestors.
      *
-     * @param {H} key
+     * @param {import("./collector.js").default} collector
      */
-    findDataSourceByKey(key) {
-        return this._dataSourcesByHost.get(key);
+    pruneCollectorBranch(collector) {
+        let parent = collector.parent;
+        if (parent) {
+            parent.removeChild(collector);
+        }
+
+        while (parent && parent.children.length === 0) {
+            const current = parent;
+            parent = current.parent;
+            if (parent) {
+                parent.removeChild(current);
+            } else if (current instanceof DataSource) {
+                this.removeDataSource(current);
+            }
+        }
     }
 
     /**
-     *
      * @param {string} name
      */
     findNamedDataSource(name) {
         /** @type {NamedSource} */
         let namedSource;
-        /** @type {H[]} */
-        let hosts = [];
-
-        // Note: If a named sources with the same name are present at multiple locations in the
-        // view hierarchy, the should actually be exactly the same instance. It's arranged that
-        // way in the data flow optimization phase.
 
-        for (const [host, dataSource] of this._dataSourcesByHost.entries()) {
+        // Note: If named sources with the same name are present at multiple locations in the
+        // view hierarchy, they should actually be exactly the same instance.
+        for (const dataSource of this.#dataSources.values()) {
             if (dataSource instanceof NamedSource) {
                 if (name == dataSource.identifier) {
                     if (namedSource && namedSource !== dataSource) {
@@ -96,7 +104,6 @@ export default class DataFlow {
                         );
                     }
                     namedSource = dataSource;
-                    hosts.push(host);
                 }
             }
         }
@@ -104,39 +111,9 @@ export default class DataFlow {
         if (namedSource) {
             return {
                 dataSource: namedSource,
-                hosts,
             };
         }
     }
 
-    /**
-     *
-     * @param {import("./collector.js").default} collector
-     * @param {H} key
-     */
-    addCollector(collector, key) {
-        this._collectorsByHost.set(key, collector);
-        collector.observers.push((collector) =>
-            this._relayObserverCallback(collector, key)
-        );
-    }
-
-    /**
-     *
-     * @param {H} key
-     */
-    findCollectorByKey(key) {
-        return this._collectorsByHost.get(key);
-    }
-
-    /**
-     * Allows the flow nodes to perform final initialization after the flow
-     * structure has been built and optimized.
-     * Must be called before any data are to be propagated.
-     */
-    initialize() {
-        for (const ds of this.dataSources) {
-            ds.visit((node) => node.initialize());
-        }
-    }
+    // Initialization is handled by subtree helpers to avoid global init order.
 }

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

@@ -1,5 +1,38 @@
-import { describe, test } from "vitest";
+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.todo("TODO");
+    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/flowHandle.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @typedef {object} FlowHandle
+ * @prop {import("./sources/dataSource.js").default} [dataSource]
+ * @prop {import("./collector.js").default} [collector]
+ */
+/**
+ * @param {FlowHandle} [handle]
+ * @returns {FlowHandle}
+ */
+export function createFlowHandle(handle?: FlowHandle): FlowHandle;
+export type FlowHandle = {
+    dataSource?: import("./sources/dataSource.js").default;
+    collector?: import("./collector.js").default;
+};
+//# sourceMappingURL=flowHandle.d.ts.map

package/dist/src/data/flowHandle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flowHandle.d.ts","sourceRoot":"","sources":["../../../src/data/flowHandle.js"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;GAGG;AACH,0CAHW,UAAU,GACR,UAAU,CAItB;;iBAVS,OAAO,yBAAyB,EAAE,OAAO;gBACzC,OAAO,gBAAgB,EAAE,OAAO"}

package/dist/src/data/flowHandle.js

@@ -0,0 +1,13 @@
+/**
+ * @typedef {object} FlowHandle
+ * @prop {import("./sources/dataSource.js").default} [dataSource]
+ * @prop {import("./collector.js").default} [collector]
+ */
+
+/**
+ * @param {FlowHandle} [handle]
+ * @returns {FlowHandle}
+ */
+export function createFlowHandle(handle = {}) {
+    return handle;
+}