@genome-spy/core 0.66.1 → 0.68.0

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

@@ -19,6 +19,19 @@ export default class Collector extends FlowNode {
      * @returns {() => void}
      */
     observe(listener: (arg0: Collector) => void): () => void;
+    /**
+     * @param {string} domainKey
+     * @param {import("../spec/channel.js").Type} type
+     * @param {import("../types/encoder.js").Accessor} accessor
+     * @returns {import("../utils/domainArray.js").DomainArray}
+     */
+    getDomain(domainKey: string, type: import("../spec/channel.js").Type, accessor: import("../types/encoder.js").Accessor): import("../utils/domainArray.js").DomainArray;
+    /**
+     * @param {string} domainKey
+     * @param {() => void} listener
+     * @returns {() => void}
+     */
+    subscribeDomainChanges(domainKey: string, listener: () => void): () => void;
     /**
      * @returns {Iterable<Datum>}
      */
@@ -38,6 +51,13 @@ export default class Collector extends FlowNode {
      * @param {number} uniqueId
      */
     findDatumByUniqueId(uniqueId: number): import("./flowNode.js").Datum;
+    /**
+     * Uses a lazy index to find a datum by its key fields.
+     *
+     * @param {string[]} keyFields
+     * @param {import("../spec/channel.js").Scalar[]} keyTuple
+     */
+    findDatumByKey(keyFields: string[], keyTuple: import("../spec/channel.js").Scalar[]): import("./flowNode.js").Datum;
     #private;
 }
 import FlowNode from "./flowNode.js";

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,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"}
+{"version":3,"file":"collector.d.ts","sourceRoot":"","sources":["../../../src/data/collector.js"],"names":[],"mappings":"AAYA;;;;;GAKG;AACH;IA6CI;;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;IAwFzD;;;OAGG;IACH,kBAHW,CAAS,IAAS,EAAT,SAAS,KAAE,IAAI,GACtB,MAAM,IAAI,CAOtB;IAiCD;;;;;OAKG;IACH,qBALW,MAAM,QACN,OAAO,oBAAoB,EAAE,IAAI,YACjC,OAAO,qBAAqB,EAAE,QAAQ,GACpC,OAAO,yBAAyB,EAAE,WAAW,CAkBzD;IAED;;;;OAIG;IACH,kCAJW,MAAM,YACN,MAAM,IAAI,GACR,MAAM,IAAI,CAItB;IAED;;OAEG;IACH,WAFa,QAAQ,+BAAO,CAqB3B;IAED;;;OAGG;IACH,mBAFW,CAAC,KAAK,+BAAO,KAAK,IAAI,QAUhC;IAED;;OAEG;IACH,uBAMC;IAqDD;;;;OAIG;IACH,8BAFW,MAAM,iCA4BhB;IAED;;;;;OAKG;IACH,0BAHW,MAAM,EAAE,YACR,OAAO,oBAAoB,EAAE,MAAM,EAAE,iCAS/C;;CACJ;qBA9XyD,eAAe"}

package/dist/src/data/collector.js

@@ -7,6 +7,8 @@ import { field } from "../utils/field.js";
 import { asArray } from "../utils/arrayUtils.js";
 import { radixSortIntoLookupArray } from "../utils/radixSort.js";
 import { UNIQUE_ID_KEY } from "./transforms/identifier.js";
+import createDomain from "../utils/domainArray.js";
+import KeyIndex from "./keyIndex.js";
 
 /**
  * Collects (materializes) the data that flows through this node.
@@ -33,6 +35,9 @@ export default class Collector extends FlowNode {
      */
     #uniqueIdIndex = [];
 
+    /** @type {KeyIndex} */
+    #keyIndex = new KeyIndex();
+
     /**
      * Start and end indices of all facets if they are concatenated into a single array.
      * Used together with the uniqueIdIndex for looking up data items by their unique id.
@@ -45,6 +50,9 @@ export default class Collector extends FlowNode {
      */
     #comparator;
 
+    /** @type {DomainCache} */
+    #domainCache = new DomainCache();
+
     get behavior() {
         return BEHAVIOR_COLLECTS;
     }
@@ -76,6 +84,7 @@ export default class Collector extends FlowNode {
     #init() {
         this.#buffer = [];
         this.#uniqueIdIndex = [];
+        this.#keyIndex.invalidate();
 
         this.facetBatches.clear();
         this.facetBatches.set(undefined, this.#buffer);
@@ -97,6 +106,8 @@ export default class Collector extends FlowNode {
      * @param {import("../types/flowBatch.js").FlowBatch} flowBatch
      */
     beginBatch(flowBatch) {
+        this.#keyIndex.invalidate();
+
         if (isFacetBatch(flowBatch)) {
             this.#buffer = [];
             this.facetBatches.set(asArray(flowBatch.facetId), this.#buffer);
@@ -144,6 +155,8 @@ export default class Collector extends FlowNode {
 
         super.complete();
 
+        this.#invalidateDomains();
+
         for (const observer of this.observers) {
             observer(this);
         }
@@ -187,6 +200,41 @@ export default class Collector extends FlowNode {
         for (const child of this.children) {
             child.complete();
         }
+
+        this.#invalidateDomains();
+    }
+
+    /**
+     * @param {string} domainKey
+     * @param {import("../spec/channel.js").Type} type
+     * @param {import("../types/encoder.js").Accessor} accessor
+     * @returns {import("../utils/domainArray.js").DomainArray}
+     */
+    getDomain(domainKey, type, accessor) {
+        return this.#domainCache.getDomain(domainKey, () => {
+            const domain = createDomain(type);
+
+            if (accessor.constant) {
+                domain.extend(accessor({}));
+            } else if (this.completed) {
+                for (const data of this.facetBatches.values()) {
+                    for (let i = 0, n = data.length; i < n; i++) {
+                        domain.extend(accessor(data[i]));
+                    }
+                }
+            }
+
+            return domain;
+        });
+    }
+
+    /**
+     * @param {string} domainKey
+     * @param {() => void} listener
+     * @returns {() => void}
+     */
+    subscribeDomainChanges(domainKey, listener) {
+        return this.#domainCache.subscribe(domainKey, listener);
     }
 
     /**
@@ -246,6 +294,13 @@ export default class Collector extends FlowNode {
         }
     }
 
+    #invalidateDomains() {
+        if (this.#domainCache.hasCachedDomains()) {
+            this.#domainCache.clear();
+        }
+        this.#domainCache.notify();
+    }
+
     /**
      * Builds an index for looking up data items by their unique id.
      * Using a sorted index and binary search for O(log n) complexity.
@@ -314,6 +369,99 @@ export default class Collector extends FlowNode {
             }
         }
     }
+
+    /**
+     * Uses a lazy index to find a datum by its key fields.
+     *
+     * @param {string[]} keyFields
+     * @param {import("../spec/channel.js").Scalar[]} keyTuple
+     */
+    findDatumByKey(keyFields, keyTuple) {
+        this.#checkStatus();
+        return this.#keyIndex.findDatum(
+            keyFields,
+            keyTuple,
+            this.facetBatches.values()
+        );
+    }
+}
+
+/**
+ * Manages cached domains and subscriptions for invalidation.
+ */
+class DomainCache {
+    /** @type {Map<string, import("../utils/domainArray.js").DomainArray>} */
+    #cache = new Map();
+
+    /** @type {Map<string, Set<() => void>>} */
+    #observers = new Map();
+
+    hasCachedDomains() {
+        return this.#cache.size > 0;
+    }
+
+    clear() {
+        this.#cache.clear();
+    }
+
+    /**
+     * @param {string} domainKey
+     * @param {() => import("../utils/domainArray.js").DomainArray} build
+     * @returns {import("../utils/domainArray.js").DomainArray}
+     */
+    getDomain(domainKey, build) {
+        const cached = this.#cache.get(domainKey);
+        if (cached) {
+            return cached;
+        } else {
+            const domain = build();
+            this.#cache.set(domainKey, domain);
+            return domain;
+        }
+    }
+
+    /**
+     * @param {string} domainKey
+     * @param {() => void} listener
+     * @returns {() => void}
+     */
+    subscribe(domainKey, listener) {
+        let listeners = this.#observers.get(domainKey);
+        if (!listeners) {
+            listeners = new Set();
+            this.#observers.set(domainKey, listeners);
+        }
+        listeners.add(listener);
+
+        return () => {
+            const entry = this.#observers.get(domainKey);
+            if (!entry) {
+                return;
+            }
+            entry.delete(listener);
+            if (entry.size === 0) {
+                this.#observers.delete(domainKey);
+            }
+        };
+    }
+
+    notify() {
+        if (this.#observers.size === 0) {
+            return;
+        }
+
+        /** @type {Set<() => void>} */
+        const listeners = new Set();
+        for (const observers of this.#observers.values()) {
+            for (const observer of observers) {
+                listeners.add(observer);
+            }
+        }
+
+        for (const listener of listeners) {
+            listener();
+        }
+    }
 }
 
 /**

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

@@ -2,6 +2,12 @@
  * DataFlow holds data sources and collectors for optimization and initialization.
  */
 export default class DataFlow {
+    /**
+     * Registry for per-view loading status. The host may replace this.
+     *
+     * @type {import("../genomeSpy/loadingStatusRegistry.js").default}
+     */
+    loadingStatusRegistry: import("../genomeSpy/loadingStatusRegistry.js").default;
     get dataSources(): DataSource[];
     get collectors(): import("./collector.js").default[];
     /**

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"dataFlow.d.ts","sourceRoot":"","sources":["../../../src/data/dataFlow.js"],"names":[],"mappings":"AAIA;;GAEG;AACH;IAOI;;;;OAIG;IACH,uBAFU,OAAO,uCAAuC,EAAE,OAAO,CAE3C;IAYtB,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;uBA/HsB,yBAAyB;wBACxB,0BAA0B"}

package/dist/src/data/dataFlow.js

@@ -1,3 +1,4 @@
+import LoadingStatusRegistry from "../genomeSpy/loadingStatusRegistry.js";
 import DataSource from "./sources/dataSource.js";
 import NamedSource from "./sources/namedSource.js";
 
@@ -11,12 +12,21 @@ export default class DataFlow {
     /** @type {Set<import("./collector.js").default>} */
     #collectors;
 
+    /**
+     * Registry for per-view loading status. The host may replace this.
+     *
+     * @type {import("../genomeSpy/loadingStatusRegistry.js").default}
+     */
+    loadingStatusRegistry;
+
     constructor() {
         /** @type {Set<import("./sources/dataSource.js").default>} */
         this.#dataSources = new Set();
 
         /** @type {Set<import("./collector.js").default>} */
         this.#collectors = new Set();
+
+        this.loadingStatusRegistry = new LoadingStatusRegistry();
     }
 
     get dataSources() {

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

@@ -2,6 +2,7 @@
  * @typedef {object} FlowHandle
  * @prop {import("./sources/dataSource.js").default} [dataSource]
  * @prop {import("./collector.js").default} [collector]
+ * @prop {import("./flowNode.js").default} [node]
  */
 /**
  * @param {FlowHandle} [handle]
@@ -11,5 +12,6 @@ export function createFlowHandle(handle?: FlowHandle): FlowHandle;
 export type FlowHandle = {
     dataSource?: import("./sources/dataSource.js").default;
     collector?: import("./collector.js").default;
+    node?: import("./flowNode.js").default;
 };
 //# sourceMappingURL=flowHandle.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"flowHandle.d.ts","sourceRoot":"","sources":["../../../src/data/flowHandle.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;GAGG;AACH,0CAHW,UAAU,GACR,UAAU,CAItB;;iBAXS,OAAO,yBAAyB,EAAE,OAAO;gBACzC,OAAO,gBAAgB,EAAE,OAAO;WAChC,OAAO,eAAe,EAAE,OAAO"}

package/dist/src/data/flowHandle.js

@@ -2,6 +2,7 @@
  * @typedef {object} FlowHandle
  * @prop {import("./sources/dataSource.js").default} [dataSource]
  * @prop {import("./collector.js").default} [collector]
+ * @prop {import("./flowNode.js").default} [node]
  */
 
 /**

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

@@ -43,6 +43,8 @@ export function syncFlowHandles(root: import("../view/view.js").default, canonic
  *
  * @param {import("../view/view.js").default} subtreeRoot
  * @param {import("./dataFlow.js").default} flow
+ * @param {(view: import("../view/view.js").default) => boolean} [viewFilter]
+ * @param {(view: import("../view/view.js").default) => boolean} [viewInitializationPredicate]
  * @returns {{
  *     dataFlow: import("./dataFlow.js").default,
  *     unitViews: UnitView[],
@@ -50,7 +52,7 @@ export function syncFlowHandles(root: import("../view/view.js").default, canonic
  *     graphicsPromises: Promise<import("../marks/mark.js").default>[]
  * }}
  */
-export function initializeViewSubtree(subtreeRoot: import("../view/view.js").default, flow: import("./dataFlow.js").default): {
+export function initializeViewSubtree(subtreeRoot: import("../view/view.js").default, flow: import("./dataFlow.js").default, viewFilter?: (view: import("../view/view.js").default) => boolean, viewInitializationPredicate?: (view: import("../view/view.js").default) => boolean): {
     dataFlow: import("./dataFlow.js").default;
     unitViews: UnitView[];
     dataSources: Set<import("./sources/dataSource.js").default>;
@@ -61,25 +63,31 @@ export function initializeViewSubtree(subtreeRoot: import("../view/view.js").def
  * This includes sources that are overridden deeper in the hierarchy.
  *
  * @param {import("../view/view.js").default | import("../view/view.js").default[]} subtreeRoot
+ * @param {(view: import("../view/view.js").default) => boolean} [viewFilter]
  * @returns {Set<import("./sources/dataSource.js").default>}
  */
-export function collectViewSubtreeDataSources(subtreeRoot: import("../view/view.js").default | import("../view/view.js").default[]): Set<import("./sources/dataSource.js").default>;
+export function collectViewSubtreeDataSources(subtreeRoot: import("../view/view.js").default | import("../view/view.js").default[], viewFilter?: (view: import("../view/view.js").default) => boolean): Set<import("./sources/dataSource.js").default>;
 /**
  * Collects the nearest data sources under a subtree root.
  * These sources define data-ready boundaries for subtree-level loading.
  *
  * @param {import("../view/view.js").default} subtreeRoot
+ * @param {(view: import("../view/view.js").default) => boolean} [viewFilter]
  * @returns {Set<import("./sources/dataSource.js").default>}
  */
-export function collectNearestViewSubtreeDataSources(subtreeRoot: import("../view/view.js").default): Set<import("./sources/dataSource.js").default>;
+export function collectNearestViewSubtreeDataSources(subtreeRoot: import("../view/view.js").default, viewFilter?: (view: import("../view/view.js").default) => boolean): Set<import("./sources/dataSource.js").default>;
 /**
  * Loads the nearest data sources for a subtree.
  * Use the returned promise as a subtree-level "data ready" signal.
  *
  * @param {import("../view/view.js").default} subtreeRoot
  * @param {Set<import("./sources/dataSource.js").default>} [dataSources]
+ * @param {(view: import("../view/view.js").default) => boolean} [viewFilter]
+ * @param {{ queueReload?: boolean }} [loadOptions]
  * @returns {Promise<void[]>}
  */
-export function loadViewSubtreeData(subtreeRoot: import("../view/view.js").default, dataSources?: Set<import("./sources/dataSource.js").default>): Promise<void[]>;
+export function loadViewSubtreeData(subtreeRoot: import("../view/view.js").default, dataSources?: Set<import("./sources/dataSource.js").default>, viewFilter?: (view: import("../view/view.js").default) => boolean, loadOptions?: {
+    queueReload?: boolean;
+}): Promise<void[]>;
 import UnitView from "../view/unitView.js";
 //# sourceMappingURL=flowInit.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"flowInit.d.ts","sourceRoot":"","sources":["../../../src/data/flowInit.js"],"names":[],"mappings":"AAoCA;;;;;GAKG;AACH,sCAHW,OAAO,iBAAiB,EAAE,OAAO,qBACjC,GAAG,CAAC,OAAO,yBAAyB,EAAE,OAAO,EAAE,OAAO,yBAAyB,EAAE,OAAO,CAAC,QAcnG;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,mDATW,OAAO,iBAAiB,EAAE,OAAO,QACjC,OAAO,eAAe,EAAE,OAAO,GAC7B;IACN,QAAQ,EAAE,OAAO,eAAe,EAAE,OAAO,CAAC;IAC1C,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,WAAW,EAAE,GAAG,CAAC,OAAO,yBAAyB,EAAE,OAAO,CAAC,CAAC;IAC5D,gBAAgB,EAAE,OAAO,CAAC,OAAO,kBAAkB,EAAE,OAAO,CAAC,EAAE,CAAA;CAClE,CAsDH;AAED;;;;;;GAMG;AACH,2DAHW,OAAO,iBAAiB,EAAE,OAAO,GAAG,OAAO,iBAAiB,EAAE,OAAO,EAAE,GACrE,GAAG,CAAC,OAAO,yBAAyB,EAAE,OAAO,CAAC,CAmB1D;AAED;;;;;;GAMG;AACH,kEAHW,OAAO,iBAAiB,EAAE,OAAO,GAC/B,GAAG,CAAC,OAAO,yBAAyB,EAAE,OAAO,CAAC,CAY1D;AAED;;;;;;;GAOG;AACH,iDAJW,OAAO,iBAAiB,EAAE,OAAO,gBACjC,GAAG,CAAC,OAAO,yBAAyB,EAAE,OAAO,CAAC,GAC5C,OAAO,CAAC,IAAI,EAAE,CAAC,CAe3B;qBA7NoB,qBAAqB"}
+{"version":3,"file":"flowInit.d.ts","sourceRoot":"","sources":["../../../src/data/flowInit.js"],"names":[],"mappings":"AAwDA;;;;;GAKG;AACH,sCAHW,OAAO,iBAAiB,EAAE,OAAO,qBACjC,GAAG,CAAC,OAAO,yBAAyB,EAAE,OAAO,EAAE,OAAO,yBAAyB,EAAE,OAAO,CAAC,QAcnG;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,mDAXW,OAAO,iBAAiB,EAAE,OAAO,QACjC,OAAO,eAAe,EAAE,OAAO,eAC/B,CAAC,IAAI,EAAE,OAAO,iBAAiB,EAAE,OAAO,KAAK,OAAO,gCACpD,CAAC,IAAI,EAAE,OAAO,iBAAiB,EAAE,OAAO,KAAK,OAAO,GAClD;IACN,QAAQ,EAAE,OAAO,eAAe,EAAE,OAAO,CAAC;IAC1C,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,WAAW,EAAE,GAAG,CAAC,OAAO,yBAAyB,EAAE,OAAO,CAAC,CAAC;IAC5D,gBAAgB,EAAE,OAAO,CAAC,OAAO,kBAAkB,EAAE,OAAO,CAAC,EAAE,CAAA;CAClE,CA6FH;AAED;;;;;;;GAOG;AACH,2DAJW,OAAO,iBAAiB,EAAE,OAAO,GAAG,OAAO,iBAAiB,EAAE,OAAO,EAAE,eACvE,CAAC,IAAI,EAAE,OAAO,iBAAiB,EAAE,OAAO,KAAK,OAAO,GAClD,GAAG,CAAC,OAAO,yBAAyB,EAAE,OAAO,CAAC,CAsB1D;AAED;;;;;;;GAOG;AACH,kEAJW,OAAO,iBAAiB,EAAE,OAAO,eACjC,CAAC,IAAI,EAAE,OAAO,iBAAiB,EAAE,OAAO,KAAK,OAAO,GAClD,GAAG,CAAC,OAAO,yBAAyB,EAAE,OAAO,CAAC,CAe1D;AAED;;;;;;;;;GASG;AACH,iDANW,OAAO,iBAAiB,EAAE,OAAO,gBACjC,GAAG,CAAC,OAAO,yBAAyB,EAAE,OAAO,CAAC,eAC9C,CAAC,IAAI,EAAE,OAAO,iBAAiB,EAAE,OAAO,KAAK,OAAO,gBACpD;IAAE,WAAW,CAAC,EAAE,OAAO,CAAA;CAAE,GACvB,OAAO,CAAC,IAAI,EAAE,CAAC,CAsB3B;qBA3SoB,qBAAqB"}

package/dist/src/data/flowInit.js

@@ -2,10 +2,11 @@ import UnitView from "../view/unitView.js";
 import { buildDataFlow } from "../view/flowBuilder.js";
 import { optimizeDataFlow } from "./flowOptimizer.js";
 import { VISIT_SKIP } from "../view/view.js";
-import { reconfigureScaleDomains } from "../scales/scaleResolution.js";
 
 /** @type {WeakMap<import("./sources/dataSource.js").default, Promise<void>>} */
 const inFlightLoads = new WeakMap();
+/** @type {WeakMap<import("./sources/dataSource.js").default, Promise<void>>} */
+const queuedReloads = new WeakMap();
 
 /**
  * Deduplicate concurrent loads for shared sources without changing propagation.
@@ -16,12 +17,31 @@ const inFlightLoads = new WeakMap();
  * promise settles, the source may be loaded again later as usual.
  *
  * @param {import("./sources/dataSource.js").default} dataSource
+ * @param {{ queueReload?: boolean }} [options]
  * @returns {Promise<void>}
  */
-function loadDataSourceOnce(dataSource) {
+function loadDataSourceOnce(dataSource, options) {
     const existing = inFlightLoads.get(dataSource);
     if (existing) {
-        return existing;
+        if (!options?.queueReload) {
+            return existing;
+        }
+        const queued = queuedReloads.get(dataSource);
+        if (queued) {
+            return queued;
+        }
+        const reload = existing
+            .catch(
+                /** @returns {void} */ () => {
+                    // Nop: ensure a queued reload can proceed after a failure.
+                }
+            )
+            .then(() => loadDataSourceOnce(dataSource))
+            .finally(() => {
+                queuedReloads.delete(dataSource);
+            });
+        queuedReloads.set(dataSource, reload);
+        return reload;
     }
 
     const loadPromise = Promise.resolve()
@@ -92,6 +112,8 @@ export function syncFlowHandles(root, canonicalBySource) {
  *
  * @param {import("../view/view.js").default} subtreeRoot
  * @param {import("./dataFlow.js").default} flow
+ * @param {(view: import("../view/view.js").default) => boolean} [viewFilter]
+ * @param {(view: import("../view/view.js").default) => boolean} [viewInitializationPredicate]
  * @returns {{
  *     dataFlow: import("./dataFlow.js").default,
  *     unitViews: UnitView[],
@@ -99,20 +121,54 @@ export function syncFlowHandles(root, canonicalBySource) {
  *     graphicsPromises: Promise<import("../marks/mark.js").default>[]
  * }}
  */
-export function initializeViewSubtree(subtreeRoot, flow) {
-    const dataFlow = buildDataFlow(subtreeRoot, flow);
-    const canonicalBySource = optimizeDataFlow(dataFlow);
-    syncFlowHandles(subtreeRoot, canonicalBySource);
-    const subtreeViews = subtreeRoot.getDescendants();
-    const dataSources = collectViewSubtreeDataSources(subtreeViews);
+export function initializeViewSubtree(
+    subtreeRoot,
+    flow,
+    viewFilter,
+    viewInitializationPredicate
+) {
+    const shouldInitializeView = viewInitializationPredicate ?? (() => true);
+    const subtreeViews = collectSubtreeViews(subtreeRoot, viewFilter);
+    const viewsToInitialize = subtreeViews.filter(shouldInitializeView);
+    if (viewsToInitialize.length === 0) {
+        return {
+            dataFlow: flow,
+            unitViews: [],
+            dataSources: new Set(),
+            graphicsPromises: [],
+        };
+    }
+
+    const viewsToInitializeSet = new Set(viewsToInitialize);
+    for (const view of viewsToInitialize) {
+        view._setDataInitializationState("pending");
+    }
+
+    let dataFlow;
+    try {
+        dataFlow = buildDataFlow(subtreeRoot, flow, viewFilter, (view) =>
+            viewsToInitializeSet.has(view)
+        );
+        const canonicalBySource = optimizeDataFlow(dataFlow);
+        syncFlowHandles(subtreeRoot, canonicalBySource);
+    } catch (error) {
+        for (const view of viewsToInitialize) {
+            view._setDataInitializationState("none");
+        }
+        throw error;
+    }
+
+    const dataSources = collectViewSubtreeDataSources(viewsToInitialize);
 
     // Initialize flow nodes for the sources that belong to this subtree.
     for (const dataSource of dataSources) {
-        dataSource.visit((node) => node.initialize());
+        dataSource.visit((node) => node.initializeOnce());
     }
 
     /** @type {UnitView[]} */
-    const unitViews = subtreeViews.filter((view) => view instanceof UnitView);
+    const unitViews = viewsToInitialize.filter(
+        (view) => view instanceof UnitView
+    );
 
     /** @type {Promise<import("../marks/mark.js").default>[]} */
     const graphicsPromises = [];
@@ -123,6 +179,7 @@ export function initializeViewSubtree(subtreeRoot, flow) {
         const mark = view.mark;
         // Encoders can be initialized immediately; graphics need a GL context.
         mark.initializeEncoders();
+        view.registerDomainSubscriptions();
         if (canInitializeGraphics) {
             graphicsPromises.push(mark.initializeGraphics().then(() => mark));
         }
@@ -145,6 +202,10 @@ export function initializeViewSubtree(subtreeRoot, flow) {
         view.registerDisposer(view.flowHandle.collector.observe(observer));
     }
 
+    for (const view of viewsToInitialize) {
+        view._setDataInitializationState("ready");
+    }
+
     return {
         dataFlow,
         unitViews,
@@ -158,15 +219,19 @@ export function initializeViewSubtree(subtreeRoot, flow) {
  * This includes sources that are overridden deeper in the hierarchy.
  *
  * @param {import("../view/view.js").default | import("../view/view.js").default[]} subtreeRoot
+ * @param {(view: import("../view/view.js").default) => boolean} [viewFilter]
  * @returns {Set<import("./sources/dataSource.js").default>}
  */
-export function collectViewSubtreeDataSources(subtreeRoot) {
+export function collectViewSubtreeDataSources(subtreeRoot, viewFilter) {
     const subtreeViews = Array.isArray(subtreeRoot)
         ? subtreeRoot
-        : subtreeRoot.getDescendants();
+        : collectSubtreeViews(subtreeRoot, viewFilter);
     /** @type {Set<import("./sources/dataSource.js").default>} */
     const dataSources = new Set();
     for (const view of subtreeViews) {
+        if (viewFilter && !viewFilter(view)) {
+            continue;
+        }
         // Walk up to the nearest view that owns a data source.
         let current = view;
         while (current && !current.flowHandle?.dataSource) {
@@ -184,12 +249,16 @@ export function collectViewSubtreeDataSources(subtreeRoot) {
  * These sources define data-ready boundaries for subtree-level loading.
  *
  * @param {import("../view/view.js").default} subtreeRoot
+ * @param {(view: import("../view/view.js").default) => boolean} [viewFilter]
  * @returns {Set<import("./sources/dataSource.js").default>}
  */
-export function collectNearestViewSubtreeDataSources(subtreeRoot) {
+export function collectNearestViewSubtreeDataSources(subtreeRoot, viewFilter) {
     /** @type {Set<import("./sources/dataSource.js").default>} */
     const dataSources = new Set();
     subtreeRoot.visit((view) => {
+        if (viewFilter && !viewFilter(view)) {
+            return VISIT_SKIP;
+        }
         if (view.flowHandle?.dataSource) {
             dataSources.add(view.flowHandle.dataSource);
             return VISIT_SKIP;
@@ -204,23 +273,52 @@ export function collectNearestViewSubtreeDataSources(subtreeRoot) {
  *
  * @param {import("../view/view.js").default} subtreeRoot
  * @param {Set<import("./sources/dataSource.js").default>} [dataSources]
+ * @param {(view: import("../view/view.js").default) => boolean} [viewFilter]
+ * @param {{ queueReload?: boolean }} [loadOptions]
  * @returns {Promise<void[]>}
  */
 export function loadViewSubtreeData(
     subtreeRoot,
-    dataSources = collectNearestViewSubtreeDataSources(subtreeRoot)
+    dataSources,
+    viewFilter,
+    loadOptions
 ) {
+    if (!dataSources) {
+        dataSources = collectNearestViewSubtreeDataSources(
+            subtreeRoot,
+            viewFilter
+        );
+    }
     return Promise.all(
         Array.from(dataSources).map((dataSource) =>
-            loadDataSourceOnce(dataSource)
+            loadDataSourceOnce(dataSource, loadOptions)
         )
     ).then((results) => {
-        reconfigureScaleDomains(subtreeRoot);
         broadcastSubtreeDataReady(subtreeRoot);
         return results;
     });
 }
 
+/**
+ * @param {import("../view/view.js").default} subtreeRoot
+ * @param {(view: import("../view/view.js").default) => boolean} [viewFilter]
+ * @returns {import("../view/view.js").default[]}
+ */
+function collectSubtreeViews(subtreeRoot, viewFilter) {
+    /** @type {import("../view/view.js").default[]} */
+    const views = [];
+    if (!viewFilter) {
+        return subtreeRoot.getDescendants();
+    }
+    subtreeRoot.visit((view) => {
+        if (!viewFilter(view)) {
+            return VISIT_SKIP;
+        }
+        views.push(view);
+    });
+    return views;
+}
+
 /**
  * Broadcasts a subtree-scoped data-ready event to views within the subtree.
  *

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

@@ -69,8 +69,16 @@ export default class FlowNode {
     /**
      * Allows for doing final initialization after the flow structure has been
      * built and optimized. Must be called before any data are to be propagated.
+     * Note: Some transforms call initialize() from reset() to rebuild internal
+     * fast paths per batch. Use initializeOnce() for graph-level init to avoid
+     * double-initialization issues.
      */
     initialize(): void;
+    /**
+     * Calls initialize() once per node instance. Intended for graph-level init
+     * passes that should not rerun when reusing existing branches.
+     */
+    initializeOnce(): void;
     /**
      * @param {Datum} datum
      * @protected

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

@@ -1 +1 @@
-{"version":3,"file":"flowNode.d.ts","sourceRoot":"","sources":["../../../src/data/flowNode.js"],"names":[],"mappings":"AAuUA;;;GAGG;AACH,uCAHW,OAAO,uBAAuB,EAAE,SAAS,GACvC,SAAS,IAAI,OAAO,uBAAuB,EAAE,SAAS,CAIlE;AAED;;;GAGG;AACH,wCAHW,OAAO,uBAAuB,EAAE,SAAS,GACvC,SAAS,IAAI,OAAO,uBAAuB,EAAE,UAAU,CAInE;AAnVD;;;GAGG;AACH,qCAAsC;AAEtC;;;GAGG;AACH,uCAAwC;AAExC;;;GAGG;AACH,uCAAwC;AAExC;;GAEG;AAEH;;;;;GAKG;AACH;IA2BI;;OAEG;IACH,oCAFW,qBAAqB,EAa/B;IAxCD;;QAEI,oBAAoB;eAAT,KAAK;MAElB;IAEF;;;;OAIG;IACH,uBAFU,qBAAqB,CAEF;IAE7B,uBAEC;IAED;;;;OAIG;IACH,aAFa,MAAM,CAIlB;IAQG,yBAAyB;IACzB,UADW,QAAQ,EAAE,CACH;IAElB,uBAAuB;IACvB,QADW,QAAQ,CACI;IAEvB,2CAA2C;IAC3C,mBAAsB;IAG1B;;;OAGG;IACH,cASC;IAED;;;OAGG;IACH,mBAEC;IAgOD;;;OAGG;IACH,4BAHW,KAAK,QAKf;IA7MD;;;OAGG;IACH,kBAFW,QAAQ,QAIlB;IAED;;;OAGG;IACH,gBAFW,QAAQ,QAUlB;IAED;;OAEG;IACH,YAFW,QAAQ,QAQlB;IAED;;OAEG;IACH,6BAFW,QAAQ,QAMlB;IAED;;OAEG;IACH,0BAFW,QAAQ,QAalB;IAED;;;OAGG;IACH,mBAFW,QAAQ,QAWlB;IAED;;OAEG;IACH,eAiBC;IAED,kBAEC;IAED,uBAEC;IAED,sBAEC;IAED;;;;OAIG;IACH,eAFW,CAAC,CAAS,IAAQ,EAAR,QAAQ,KAAE,IAAI,CAAC,GAAG;QAAE,aAAa,CAAC,EAAE,CAAS,IAAQ,EAAR,QAAQ,KAAE,IAAI,CAAA;KAAC,QAchF;IAED;;;OAGG;IACH,wBAHW,MAAM,GACJ,MAAM,CAWlB;IAED;;;OAGG;IACH,cAFW,KAAK,QAKf;IAED,iBAMC;IAED;;;;OAIG;IACH,sBAFW,OAAO,uBAAuB,EAAE,SAAS,QAMnD;IAED;;;OAGG;IACH,+BAHa,OAAO,0BAA0B,EAAE,OAAO,CAYtD;IAED;;;;OAIG;IACH,8BAQC;;CASJ;oCAhTY;IAAC,aAAa,EAAE,OAAO,0BAA0B,EAAE,OAAO,CAAA;CAAC;;;;oBAM3D,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;;;;mBACnB,KAAK,EAAE"}
+{"version":3,"file":"flowNode.d.ts","sourceRoot":"","sources":["../../../src/data/flowNode.js"],"names":[],"mappings":"AAyVA;;;GAGG;AACH,uCAHW,OAAO,uBAAuB,EAAE,SAAS,GACvC,SAAS,IAAI,OAAO,uBAAuB,EAAE,SAAS,CAIlE;AAED;;;GAGG;AACH,wCAHW,OAAO,uBAAuB,EAAE,SAAS,GACvC,SAAS,IAAI,OAAO,uBAAuB,EAAE,UAAU,CAInE;AArWD;;;GAGG;AACH,qCAAsC;AAEtC;;;GAGG;AACH,uCAAwC;AAExC;;;GAGG;AACH,uCAAwC;AAExC;;GAEG;AAEH;;;;;GAKG;AACH;IA8BI;;OAEG;IACH,oCAFW,qBAAqB,EAa/B;IA3CD;;QAEI,oBAAoB;eAAT,KAAK;MAElB;IAKF;;;;OAIG;IACH,uBAFU,qBAAqB,CAEF;IAE7B,uBAEC;IAED;;;;OAIG;IACH,aAFa,MAAM,CAIlB;IAQG,yBAAyB;IACzB,UADW,QAAQ,EAAE,CACH;IAElB,uBAAuB;IACvB,QADW,QAAQ,CACI;IAEvB,2CAA2C;IAC3C,mBAAsB;IAG1B;;;OAGG;IACH,cASC;IAED;;;;;;OAMG;IACH,mBAEC;IAED;;;OAGG;IACH,uBAMC;IAgOD;;;OAGG;IACH,4BAHW,KAAK,QAKf;IA7MD;;;OAGG;IACH,kBAFW,QAAQ,QAIlB;IAED;;;OAGG;IACH,gBAFW,QAAQ,QAUlB;IAED;;OAEG;IACH,YAFW,QAAQ,QAQlB;IAED;;OAEG;IACH,6BAFW,QAAQ,QAMlB;IAED;;OAEG;IACH,0BAFW,QAAQ,QAalB;IAED;;;OAGG;IACH,mBAFW,QAAQ,QAWlB;IAED;;OAEG;IACH,eAiBC;IAED,kBAEC;IAED,uBAEC;IAED,sBAEC;IAED;;;;OAIG;IACH,eAFW,CAAC,CAAS,IAAQ,EAAR,QAAQ,KAAE,IAAI,CAAC,GAAG;QAAE,aAAa,CAAC,EAAE,CAAS,IAAQ,EAAR,QAAQ,KAAE,IAAI,CAAA;KAAC,QAchF;IAED;;;OAGG;IACH,wBAHW,MAAM,GACJ,MAAM,CAWlB;IAED;;;OAGG;IACH,cAFW,KAAK,QAKf;IAED,iBAMC;IAED;;;;OAIG;IACH,sBAFW,OAAO,uBAAuB,EAAE,SAAS,QAMnD;IAED;;;OAGG;IACH,+BAHa,OAAO,0BAA0B,EAAE,OAAO,CAYtD;IAED;;;;OAIG;IACH,8BAQC;;CASJ;oCAlUY;IAAC,aAAa,EAAE,OAAO,0BAA0B,EAAE,OAAO,CAAA;CAAC;;;;oBAM3D,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;;;;mBACnB,KAAK,EAAE"}