@genome-spy/core 0.64.0 → 0.65.0

package/dist/src/data/flowInit.js

@@ -0,0 +1,238 @@
+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 { reconfigureScales } from "../view/scaleResolution.js";
+
+/** @type {WeakMap<import("./sources/dataSource.js").default, Promise<void>>} */
+const inFlightLoads = new WeakMap();
+
+/**
+ * Deduplicate concurrent loads for shared sources without changing propagation.
+ *
+ * Data sources still propagate rows immediately during `load()`/`loadSynchronously`
+ * and do not retain data. This helper only prevents overlapping `load()` calls
+ * from running twice; collectors remain the sole in-memory cache. Once the load
+ * promise settles, the source may be loaded again later as usual.
+ *
+ * @param {import("./sources/dataSource.js").default} dataSource
+ * @returns {Promise<void>}
+ */
+function loadDataSourceOnce(dataSource) {
+    const existing = inFlightLoads.get(dataSource);
+    if (existing) {
+        return existing;
+    }
+
+    const loadPromise = Promise.resolve()
+        .then(() => dataSource.load())
+        .finally(() => {
+            inFlightLoads.delete(dataSource);
+        });
+
+    inFlightLoads.set(dataSource, loadPromise);
+    return loadPromise;
+}
+
+/**
+ * Synchronize flow handles after data flow optimization.
+ *
+ * @param {import("../view/view.js").default} root
+ * @param {Map<import("./sources/dataSource.js").default, import("./sources/dataSource.js").default>} canonicalBySource
+ */
+export function syncFlowHandles(root, canonicalBySource) {
+    for (const view of root.getDescendants()) {
+        const handle = view.flowHandle;
+        if (!handle) {
+            continue;
+        }
+
+        const dataSource = handle.dataSource;
+        if (dataSource) {
+            handle.dataSource = canonicalBySource.get(dataSource) ?? dataSource;
+        }
+    }
+}
+
+/**
+ * Initializes data flow and mark wiring for a subtree without rebuilding the
+ * entire view hierarchy. This is the primary entry point for dynamic view
+ * insertion: build the subtree fully, call this, then attach the subtree to
+ * the live hierarchy.
+ *
+ * What it does:
+ * - builds/extends the dataflow graph for the subtree
+ * - runs flow optimization and syncs flow handles to canonical data sources
+ * - discovers the nearest data sources for views in the subtree
+ * - initializes dataflow nodes (initialize) for those sources
+ * - initializes mark encoders for unit views
+ * - queues graphics initialization (if a GL context exists)
+ * - wires collector observers so marks update on data arrival
+ *
+ * How to use it:
+ * - call after the subtree is fully constructed (post-order build)
+ * - do not attach the subtree to the live hierarchy until after this call
+ * - dispose the old subtree before replacing it to prevent observer leaks
+ * - follow up with finalizeSubtreeGraphics(...) once graphics promises resolve
+ * - reconfigure scales for the subtree when data loads complete
+ *
+ * Considerations:
+ * - this does not trigger data loading; callers decide when to load
+ * - data sources are derived by walking to the nearest ancestor source; nested
+ *   sources should be treated as boundaries (do not walk past them)
+ * - only call updateGraphicsData when graphics are initialized or a GL context
+ *   is available; headless/test contexts must avoid WebGL usage
+ * - loadViewSubtreeData emits a subtree-scoped "subtreeDataReady" broadcast
+ *
+ * TODO:
+ * - promote in-flight load caching to a persistent load-state per source
+ * - replace global dataLoaded usage with subtree-scoped readiness
+ * - integrate with async font readiness for text marks
+ * - unify observer wiring via a disposable registry across view types
+ *
+ * @param {import("../view/view.js").default} subtreeRoot
+ * @param {import("./dataFlow.js").default} flow
+ * @returns {{
+ *     dataFlow: import("./dataFlow.js").default,
+ *     unitViews: UnitView[],
+ *     dataSources: Set<import("./sources/dataSource.js").default>,
+ *     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);
+
+    // Initialize flow nodes for the sources that belong to this subtree.
+    for (const dataSource of dataSources) {
+        dataSource.visit((node) => node.initialize());
+    }
+
+    /** @type {UnitView[]} */
+    const unitViews = subtreeViews.filter((view) => view instanceof UnitView);
+
+    /** @type {Promise<import("../marks/mark.js").default>[]} */
+    const graphicsPromises = [];
+
+    const canInitializeGraphics = !!subtreeRoot.context.glHelper;
+
+    for (const view of unitViews) {
+        const mark = view.mark;
+        // Encoders can be initialized immediately; graphics need a GL context.
+        mark.initializeEncoders();
+        if (canInitializeGraphics) {
+            graphicsPromises.push(mark.initializeGraphics().then(() => mark));
+        }
+
+        // Wire collector completion to mark data/graphics updates.
+        const observer = (
+            /** @type {import("./collector.js").default} */ _collector
+        ) => {
+            mark.initializeData(); // does faceting
+            if (canInitializeGraphics) {
+                try {
+                    mark.updateGraphicsData();
+                } catch (e) {
+                    e.view = view;
+                    throw e;
+                }
+            }
+            view.context.animator.requestRender();
+        };
+        view.registerDisposer(view.flowHandle.collector.observe(observer));
+    }
+
+    return {
+        dataFlow,
+        unitViews,
+        dataSources,
+        graphicsPromises,
+    };
+}
+
+/**
+ * Collects data sources needed to initialize all views in the subtree.
+ * This includes sources that are overridden deeper in the hierarchy.
+ *
+ * @param {import("../view/view.js").default | import("../view/view.js").default[]} subtreeRoot
+ * @returns {Set<import("./sources/dataSource.js").default>}
+ */
+export function collectViewSubtreeDataSources(subtreeRoot) {
+    const subtreeViews = Array.isArray(subtreeRoot)
+        ? subtreeRoot
+        : subtreeRoot.getDescendants();
+    /** @type {Set<import("./sources/dataSource.js").default>} */
+    const dataSources = new Set();
+    for (const view of subtreeViews) {
+        // Walk up to the nearest view that owns a data source.
+        let current = view;
+        while (current && !current.flowHandle?.dataSource) {
+            current = current.dataParent;
+        }
+        if (current?.flowHandle?.dataSource) {
+            dataSources.add(current.flowHandle.dataSource);
+        }
+    }
+    return dataSources;
+}
+
+/**
+ * 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
+ * @returns {Set<import("./sources/dataSource.js").default>}
+ */
+export function collectNearestViewSubtreeDataSources(subtreeRoot) {
+    /** @type {Set<import("./sources/dataSource.js").default>} */
+    const dataSources = new Set();
+    subtreeRoot.visit((view) => {
+        if (view.flowHandle?.dataSource) {
+            dataSources.add(view.flowHandle.dataSource);
+            return VISIT_SKIP;
+        }
+    });
+    return dataSources;
+}
+
+/**
+ * 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]
+ * @returns {Promise<void[]>}
+ */
+export function loadViewSubtreeData(
+    subtreeRoot,
+    dataSources = collectNearestViewSubtreeDataSources(subtreeRoot)
+) {
+    return Promise.all(
+        Array.from(dataSources).map((dataSource) =>
+            loadDataSourceOnce(dataSource)
+        )
+    ).then((results) => {
+        reconfigureScales(subtreeRoot);
+        broadcastSubtreeDataReady(subtreeRoot);
+        return results;
+    });
+}
+
+/**
+ * Broadcasts a subtree-scoped data-ready event to views within the subtree.
+ *
+ * @param {import("../view/view.js").default} subtreeRoot
+ */
+function broadcastSubtreeDataReady(subtreeRoot) {
+    /** @type {import("../view/view.js").BroadcastMessage} */
+    const message = {
+        type: /** @type {import("../genomeSpy.js").BroadcastEventType} */ (
+            "subtreeDataReady"
+        ),
+        payload: { subtreeRoot },
+    };
+    subtreeRoot.visit((view) => view.handleBroadcast(message));
+}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=flowInit.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flowInit.test.d.ts","sourceRoot":"","sources":["../../../src/data/flowInit.test.js"],"names":[],"mappings":""}

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

@@ -0,0 +1,413 @@
+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();
+    });
+});

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

@@ -12,16 +12,18 @@ export function removeRedundantCloneTransforms(node: import("./flowNode.js").def
 export function removeRedundantCollectors(): void;
 export function combineAndPullCollectorsUp(): void;
 /**
- * @param {import("./dataFlow.js").default<any>} dataFlow
+ * @param {import("./dataFlow.js").default} dataFlow
+ * @returns {Map<import("./sources/dataSource.js").default, import("./sources/dataSource.js").default>}
  */
-export function combineIdenticalDataSources(dataFlow: import("./dataFlow.js").default<any>): void;
+export function combineIdenticalDataSources(dataFlow: import("./dataFlow.js").default): Map<import("./sources/dataSource.js").default, import("./sources/dataSource.js").default>;
 /**
  *
  * @param {import("./flowNode.js").default} root
  */
 export function optimizeFlowGraph(root: import("./flowNode.js").default): void;
 /**
- * @param {import("./dataFlow.js").default<any>} dataFlow
+ * @param {import("./dataFlow.js").default} dataFlow
+ * @returns {Map<import("./sources/dataSource.js").default, import("./sources/dataSource.js").default>}
  */
-export function optimizeDataFlow(dataFlow: import("./dataFlow.js").default<any>): void;
+export function optimizeDataFlow(dataFlow: import("./dataFlow.js").default): Map<import("./sources/dataSource.js").default, import("./sources/dataSource.js").default>;
 //# sourceMappingURL=flowOptimizer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"flowOptimizer.d.ts","sourceRoot":"","sources":["../../../src/data/flowOptimizer.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH,oCAHW,OAAO,eAAe,EAAE,OAAO,WAC/B,OAAO,eAAe,EAAE,OAAO,WAczC;AAED;;;;GAIG;AACH,qDAFW,OAAO,eAAe,EAAE,OAAO,iCAgCzC;AAED,kDAEC;AAED,mDAEC;AAmBD;;GAEG;AACH,sDAFW,OAAO,eAAe,EAAE,OAAO,CAAC,GAAG,CAAC,QAwB9C;AAED;;;GAGG;AACH,wCAFW,OAAO,eAAe,EAAE,OAAO,QASzC;AAED;;GAEG;AACH,2CAFW,OAAO,eAAe,EAAE,OAAO,CAAC,GAAG,CAAC,QAO9C"}
+{"version":3,"file":"flowOptimizer.d.ts","sourceRoot":"","sources":["../../../src/data/flowOptimizer.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH,oCAHW,OAAO,eAAe,EAAE,OAAO,WAC/B,OAAO,eAAe,EAAE,OAAO,WAczC;AAED;;;;GAIG;AACH,qDAFW,OAAO,eAAe,EAAE,OAAO,iCAgCzC;AAED,kDAEC;AAED,mDAEC;AAmBD;;;GAGG;AACH,sDAHW,OAAO,eAAe,EAAE,OAAO,GAC7B,GAAG,CAAC,OAAO,yBAAyB,EAAE,OAAO,EAAE,OAAO,yBAAyB,EAAE,OAAO,CAAC,CAoCrG;AAED;;;GAGG;AACH,wCAFW,OAAO,eAAe,EAAE,OAAO,QASzC;AAED;;;GAGG;AACH,2CAHW,OAAO,eAAe,EAAE,OAAO,GAC7B,GAAG,CAAC,OAAO,yBAAyB,EAAE,OAAO,EAAE,OAAO,yBAAyB,EAAE,OAAO,CAAC,CAQrG"}