@genome-spy/core 0.66.1 → 0.68.0

package/dist/src/view/dataReadiness.js

@@ -0,0 +1,267 @@
+import DataSource from "../data/sources/dataSource.js";
+import UnitView from "./unitView.js";
+
+/**
+ * @typedef {import("../view/view.js").default} View
+ * @typedef {import("../data/sources/lazy/singleAxisLazySource.js").DataReadinessRequest} DataReadinessRequest
+ */
+
+/**
+ * Builds a readiness request for the provided channels.
+ *
+ * @param {View} view
+ * @param {import("../spec/channel.js").PrimaryPositionalChannel[]} channels
+ * @returns {DataReadinessRequest | undefined}
+ */
+export function buildReadinessRequest(view, channels) {
+    /** @type {DataReadinessRequest} */
+    const request = {};
+
+    for (const channel of channels) {
+        const resolution = view.getScaleResolution(channel);
+        if (!resolution) {
+            continue;
+        }
+        request[channel] = Array.from(resolution.getDomain());
+    }
+
+    return Object.keys(request).length ? request : undefined;
+}
+
+/**
+ * Checks whether all data sources under the subtree report readiness.
+ *
+ * @param {View} subtreeRoot
+ * @param {DataReadinessRequest} readinessRequest
+ * @param {(view: View) => boolean} [viewFilter]
+ * @returns {boolean}
+ */
+export function isSubtreeReady(subtreeRoot, readinessRequest, viewFilter) {
+    const shouldConsiderView =
+        viewFilter ??
+        ((/** @type {View} */ view) => view.isConfiguredVisible());
+
+    const unitViews = subtreeRoot
+        .getDescendants()
+        .filter((view) => view instanceof UnitView && shouldConsiderView(view));
+
+    if (unitViews.length === 0) {
+        return subtreeRoot.isDataInitialized();
+    }
+
+    for (const view of unitViews) {
+        /** @type {import("../data/collector.js").default | undefined} */
+        const collector = view.flowHandle?.collector;
+        if (!collector || !collector.completed) {
+            return false;
+        }
+
+        /** @type {import("../data/flowNode.js").default | undefined} */
+        let node = collector;
+        while (node && !(node instanceof DataSource)) {
+            node = node.parent;
+        }
+
+        const dataSource = /** @type {DataSource | undefined} */ (node);
+        if (!dataSource) {
+            return false;
+        }
+
+        if ("isDataReadyForDomain" in dataSource) {
+            // It's available in SingleAxisLazySource and its subclasses
+            const checkableSource =
+                /** @type {import("../data/sources/lazy/singleAxisLazySource.js").DataReadinessCheckable} */ (
+                    dataSource
+                );
+            if (
+                !readinessRequest ||
+                !checkableSource.isDataReadyForDomain(readinessRequest)
+            ) {
+                return false;
+            }
+        }
+    }
+
+    return true;
+}
+
+/**
+ * Checks readiness for lazy data sources under the subtree. Non-lazy sources
+ * are ignored so they do not block readiness checks.
+ *
+ * @param {View} subtreeRoot
+ * @param {DataReadinessRequest | undefined} readinessRequest
+ * @param {(view: View) => boolean} [viewFilter]
+ * @returns {boolean}
+ */
+export function isSubtreeLazyReady(subtreeRoot, readinessRequest, viewFilter) {
+    const shouldConsiderView =
+        viewFilter ??
+        ((/** @type {View} */ view) => view.isConfiguredVisible());
+
+    /** @type {Set<DataSource>} */
+    const dataSources = new Set();
+
+    subtreeRoot.visit((view) => {
+        if (!(view instanceof UnitView)) {
+            return;
+        }
+        if (!shouldConsiderView(view)) {
+            return;
+        }
+
+        /** @type {View | null} */
+        let current = view;
+        while (current) {
+            if (current.flowHandle && current.flowHandle.dataSource) {
+                break;
+            }
+            current = current.dataParent;
+        }
+
+        if (!current || !current.flowHandle) {
+            return;
+        }
+        const dataSource = current.flowHandle.dataSource;
+        if (!("isDataReadyForDomain" in dataSource)) {
+            return;
+        }
+        dataSources.add(dataSource);
+    });
+
+    if (!dataSources.size) {
+        return true;
+    }
+
+    if (!readinessRequest) {
+        return false;
+    }
+
+    for (const dataSource of dataSources) {
+        const checkReady =
+            /** @type {import("../data/sources/lazy/singleAxisLazySource.js").DataReadinessCheckable["isDataReadyForDomain"]} */ (
+                /** @type {any} */ (dataSource).isDataReadyForDomain
+            );
+        if (!checkReady.call(dataSource, readinessRequest)) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+/**
+ * Waits until lazy data sources under the subtree satisfy the readiness request.
+ * Non-lazy sources are ignored so they do not block readiness checks.
+ *
+ * @param {import("../types/viewContext.js").default} context
+ * @param {View} subtreeRoot
+ * @param {DataReadinessRequest} readinessRequest
+ * @param {AbortSignal} [signal]
+ * @param {(view: View) => boolean} [viewFilter]
+ * @returns {Promise<void>}
+ */
+export function awaitSubtreeLazyReady(
+    context,
+    subtreeRoot,
+    readinessRequest,
+    signal,
+    viewFilter
+) {
+    const shouldConsiderView =
+        viewFilter ??
+        ((/** @type {View} */ view) => view.isConfiguredVisible());
+
+    if (!readinessRequest) {
+        if (
+            isSubtreeLazyReady(
+                subtreeRoot,
+                readinessRequest,
+                shouldConsiderView
+            )
+        ) {
+            return Promise.resolve();
+        }
+        return Promise.reject(
+            new Error("Lazy subtree readiness requires a readiness request.")
+        );
+    }
+
+    return new Promise((resolve, reject) => {
+        /** @type {Set<() => void>} */
+        const unregisters = new Set();
+        /** @type {Set<import("../data/collector.js").default>} */
+        const observedCollectors = new Set();
+
+        /** @type {(message: import("./view.js").BroadcastMessage) => void} */
+        const broadcastListener = () => {
+            attachCollectors();
+            checkReady();
+        };
+
+        const cleanup = () => {
+            for (const unregister of unregisters) {
+                unregister();
+            }
+            unregisters.clear();
+            context.removeBroadcastListener(
+                "subtreeDataReady",
+                broadcastListener
+            );
+            if (signal) {
+                signal.removeEventListener("abort", abortHandler);
+            }
+        };
+
+        const checkReady = () => {
+            if (
+                isSubtreeLazyReady(
+                    subtreeRoot,
+                    readinessRequest,
+                    shouldConsiderView
+                )
+            ) {
+                cleanup();
+                resolve();
+            }
+        };
+
+        const attachCollectors = () => {
+            subtreeRoot.visit((view) => {
+                if (!(view instanceof UnitView)) {
+                    return;
+                }
+                if (!shouldConsiderView(view)) {
+                    return;
+                }
+                const collector = view.flowHandle?.collector;
+                if (!collector) {
+                    return;
+                }
+                if (observedCollectors.has(collector)) {
+                    return;
+                }
+                observedCollectors.add(collector);
+                unregisters.add(collector.observe(checkReady));
+            });
+        };
+
+        const abortHandler = () => {
+            cleanup();
+            reject(new Error("Lazy subtree readiness was aborted."));
+        };
+
+        attachCollectors();
+        checkReady();
+
+        context.addBroadcastListener("subtreeDataReady", broadcastListener);
+
+        if (signal) {
+            if (signal.aborted) {
+                abortHandler();
+                return;
+            }
+            signal.addEventListener("abort", abortHandler, { once: true });
+        }
+    });
+}

package/dist/src/view/dataReadiness.test.d.ts

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

package/dist/src/view/dataReadiness.test.d.ts.map

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

package/dist/src/view/facetView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"facetView.d.ts","sourceRoot":"","sources":["../../../src/view/facetView.js"],"names":[],"mappings":"AAmDA;;;;;;;;;;;;;;GAcG;AACH;IACI;;;;;;;OAOG;IACH;;;;;;OAMG;IACH,kBALW,OAAO,gBAAgB,EAAE,SAAS,WAClC,OAAO,gBAAgB,EAAE,WAAW,UACpC,aAAa,QACb,MAAM,EA8BhB;IAzBG,UAAgB;IAEhB,WAEC;IAED;;;;OAIG;IACH,aAFU,MAAM,CAAC,YAAY,EAAE,QAAQ,CAAC,CAYvC;IAED,oDAAoD;IACpD,kBADY,MAAM,CAAC,YAAY,EAAE,cAAc,CAAC,CACa;IAajE,sBAIC;IAED;;;OAGG;IACH,qBAFW,KAAK,GAAG,QAAQ,OAwB1B;IAED,qBAyCC;IAED,qBASC;IA6BD,kDAgBC;IAOD;;;;OAIG;IACH,gBAJW,OAAO,4CAA4C,EAAE,OAAO,UAC5D,OAAO,uBAAuB,EAAE,OAAO,YACvC,OAAO,WAAW,EAAE,gBAAgB,QA2L9C;IA3KO,wBAA0B;CA4KrC;2BAjbY,QAAQ,GAAG,KAAK;;;;;;aA4CnB,OAAO,EAAE,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE;;;0BA1Df,oBAAoB;qBACzB,eAAe"}
+{"version":3,"file":"facetView.d.ts","sourceRoot":"","sources":["../../../src/view/facetView.js"],"names":[],"mappings":"AAoDA;;;;;;;;;;;;;;GAcG;AACH;IACI;;;;;;;OAOG;IACH;;;;;;OAMG;IACH,kBALW,OAAO,gBAAgB,EAAE,SAAS,WAClC,OAAO,gBAAgB,EAAE,WAAW,UACpC,aAAa,QACb,MAAM,EA+BhB;IA1BG,UAAgB;IAEhB,WAEC;IAED;;;;OAIG;IACH,aAFU,MAAM,CAAC,YAAY,EAAE,QAAQ,CAAC,CAavC;IAED,oDAAoD;IACpD,kBADY,MAAM,CAAC,YAAY,EAAE,cAAc,CAAC,CACa;IAajE,sBAIC;IAED;;;OAGG;IACH,qBAFW,KAAK,GAAG,QAAQ,OAwB1B;IAED,qBAyCC;IAED,qBASC;IA6BD,kDAgBC;IAOD;;;;OAIG;IACH,gBAJW,OAAO,4CAA4C,EAAE,OAAO,UAC5D,OAAO,uBAAuB,EAAE,OAAO,YACvC,OAAO,WAAW,EAAE,gBAAgB,QA2L9C;IA3KO,wBAA0B;CA4KrC;2BAlbY,QAAQ,GAAG,KAAK;;;;;;aA4CnB,OAAO,EAAE,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE;;;0BA3Df,oBAAoB;qBACzB,eAAe"}

package/dist/src/view/facetView.js

@@ -12,6 +12,7 @@ import coalesce from "../utils/coalesce.js";
 import { field as vegaField } from "vega-util";
 import DecoratorView from "./decoratorView.js";
 import Padding from "./layout/padding.js";
+import { markViewAsNonAddressable } from "./viewSelectors.js";
 
 const DEFAULT_SPACING = 20;
 
@@ -95,15 +96,16 @@ export default class FacetView extends ContainerView {
          * @type {Record<FacetChannel, UnitView>}
          */
         this._labelViews = Object.fromEntries(
-            FACET_CHANNELS.map((channel) => [
-                channel,
-                new UnitView(
+            FACET_CHANNELS.map((channel) => {
+                const labelView = new UnitView(
                     createLabelViewSpec(headerConfigs[channel]),
                     this.context,
                     this,
                     `facetLabel-${channel}`
-                ),
-            ])
+                );
+                markViewAsNonAddressable(labelView, { skipSubtree: true });
+                return [channel, labelView];
+            })
         );
 
         /**  @type {Record<FacetChannel, FacetDimension>} */

package/dist/src/view/flowBuilder.d.ts

@@ -2,16 +2,18 @@
  * @param {View} root
  * @param {DataFlow} [existingFlow] Add data flow
  *      graphs to an existing DataFlow object.
+ * @param {(view: View) => boolean} [viewFilter]
+ * @param {(view: View) => boolean} [viewInitializationPredicate]
  */
-export function buildDataFlow(root: import("./view.js").default, existingFlow?: DataFlow): DataFlow;
+export function buildDataFlow(root: import("./view.js").default, existingFlow?: DataFlow, viewFilter?: (view: import("./view.js").default) => boolean, viewInitializationPredicate?: (view: import("./view.js").default) => boolean): DataFlow;
 /**
  * Changes the ChromPos channelDefs into FieldDefs and returns
  * LinearizeGenomicCoordinate transform(s) that should be inserted into
  * the data flow.
  *
- * @param {View} view
+ * @param {import("./unitView.js").default} view
  */
-export function linearizeLocusAccess(view: import("./view.js").default): {
+export function linearizeLocusAccess(view: import("./unitView.js").default): {
     transforms: import("../data/flowNode.js").default[];
     rewrittenEncoding: import("../spec/channel.js").Encoding;
     /**

package/dist/src/view/flowBuilder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"flowBuilder.d.ts","sourceRoot":"","sources":["../../../src/view/flowBuilder.js"],"names":[],"mappings":"AAwBA;;;;GAIG;AACH,gFAHW,QAAQ,YAmNlB;AAED;;;;;;GAMG;AACH;;;IAgGc;;;OAGG;;EAYhB;AAgCD;;;;;;GAMG;AACH,4BAFwB,CAAC,SAAZ,qCAAU,cAFZ,CAAC,iBACA,uCAAW;;;0BAwBG,OAAO,CAAC,QAAQ,CAAC,OAAO,qBAAqB,EAAE,KAAK,CAAC,CAAC;EAkB/E;qBA7aoB,qBAAqB;sBANpB,sBAAsB"}
+{"version":3,"file":"flowBuilder.d.ts","sourceRoot":"","sources":["../../../src/view/flowBuilder.js"],"names":[],"mappings":"AAyBA;;;;;;GAMG;AACH,gFALW,QAAQ,eAER,CAAC,IAAI,6BAAM,KAAK,OAAO,gCACvB,CAAC,IAAI,6BAAM,KAAK,OAAO,YAoPjC;AAuBD;;;;;;GAMG;AACH,2CAFW,OAAO,eAAe,EAAE,OAAO;;;IA2G5B;;;OAGG;;EAYhB;AAgCD;;;;;;GAMG;AACH,4BAFwB,CAAC,SAAZ,qCAAU,cAFZ,CAAC,iBACA,uCAAW;;;0BAwBG,OAAO,CAAC,QAAQ,CAAC,OAAO,qBAAqB,EAAE,KAAK,CAAC,CAAC;EAkB/E;qBA/eoB,qBAAqB;sBAPpB,sBAAsB"}

package/dist/src/view/flowBuilder.js

@@ -2,6 +2,7 @@ import Collector from "../data/collector.js";
 import createTransform from "../data/transforms/transformFactory.js";
 import createDataSource from "../data/sources/dataSourceFactory.js";
 import UnitView from "./unitView.js";
+import { VISIT_SKIP } from "./view.js";
 import { BEHAVIOR_MODIFIES } from "../data/flowNode.js";
 import CloneTransform from "../data/transforms/clone.js";
 import DataFlow from "../data/dataFlow.js";
@@ -26,8 +27,15 @@ import { nodesToTreesWithAccessor, visitTree } from "../utils/trees.js";
  * @param {View} root
  * @param {DataFlow} [existingFlow] Add data flow
  *      graphs to an existing DataFlow object.
+ * @param {(view: View) => boolean} [viewFilter]
+ * @param {(view: View) => boolean} [viewInitializationPredicate]
  */
-export function buildDataFlow(root, existingFlow) {
+export function buildDataFlow(
+    root,
+    existingFlow,
+    viewFilter,
+    viewInitializationPredicate
+) {
     /**
      * @typedef {import("./view.js").default} View
      * @typedef {import("../data/flowNode.js").default} FlowNode
@@ -47,6 +55,8 @@ export function buildDataFlow(root, existingFlow) {
     /** @type {(function():void)[]} */
     const postProcessOps = [];
 
+    const shouldInitializeView = viewInitializationPredicate ?? (() => true);
+
     /**
      * @param {FlowNode} node
      * @param {function():Error} [onMissingParent]
@@ -121,6 +131,27 @@ export function buildDataFlow(root, existingFlow) {
 
     /** @param {View} view */
     const processView = (view) => {
+        if (!shouldInitializeView(view)) {
+            const flowNode = view.flowHandle?.node;
+            if (flowNode) {
+                if (flowNode !== currentNode) {
+                    currentNode = flowNode;
+                    nodeStack.push(flowNode);
+                }
+                return;
+            }
+            if (
+                view.spec.data ||
+                view.spec.transform ||
+                view instanceof UnitView
+            ) {
+                throw new Error(
+                    "Cannot reuse missing flow nodes for " +
+                        view.getPathString()
+                );
+            }
+            return;
+        }
         if (view.spec.data) {
             const previousDataSource = view.flowHandle?.dataSource;
             if (
@@ -205,12 +236,18 @@ export function buildDataFlow(root, existingFlow) {
             view.flowHandle ??= {};
             view.flowHandle.collector = collector;
         }
+
+        if (currentNode) {
+            view.flowHandle ??= {};
+            view.flowHandle.node = currentNode;
+        }
     };
 
     // Views only keep track of their children based on the layout hierachy.
     // Thus, let's get traversable hierarchies using dataParents.
+    const views = collectSubtreeViews(root, viewFilter);
     const dataTrees = nodesToTreesWithAccessor(
-        root.getDescendants(),
+        views,
         (view) => view.dataParent
     );
 
@@ -237,16 +274,36 @@ export function buildDataFlow(root, existingFlow) {
     return dataFlow;
 }
 
+/**
+ * @param {import("./view.js").default} root
+ * @param {(view: import("./view.js").default) => boolean} [viewFilter]
+ * @returns {import("./view.js").default[]}
+ */
+function collectSubtreeViews(root, viewFilter) {
+    if (!viewFilter) {
+        return root.getDescendants();
+    }
+
+    /** @type {import("./view.js").default[]} */
+    const views = [];
+    root.visit((view) => {
+        if (!viewFilter(view)) {
+            return VISIT_SKIP;
+        }
+        views.push(view);
+    });
+    return views;
+}
+
 /**
  * Changes the ChromPos channelDefs into FieldDefs and returns
  * LinearizeGenomicCoordinate transform(s) that should be inserted into
  * the data flow.
  *
- * @param {View} view
+ * @param {import("./unitView.js").default} view
  */
 export function linearizeLocusAccess(view) {
     /**
-     * @typedef {import("./view.js").default} View
      * @typedef {import("../data/flowNode.js").default} FlowNode
      * @typedef {import("../spec/channel.js").Channel} Channel
      * @typedef {import("../spec/channel.js").Encoding} Encoding
@@ -258,14 +315,24 @@ export function linearizeLocusAccess(view) {
     /** @type {Encoding} */
     const rewrittenEncoding = {};
 
+    // Use mark.encoding so we see the same channel defs that encoders consume,
+    // including inherited channels and mark defaults. getEncoding() only returns
+    // spec/inherited encodings and can omit channels during lazy init (e.g.,
+    // summary views that inherit chrom/pos), which would skip chrom/pos rewrites.
+    const encoding = view.mark.encoding;
+
     /** @type {{ channel: Channel, chromPosDef: import("../spec/channel.js").ChromPosDef}[]} */
     const channelsAndChromPosDefs = [];
 
     // Optimize the number of transforms. Use only a single transform for positions
     // that share the chromosome field and channel.
-    for (const [c, channelDef] of Object.entries(view.getEncoding())) {
+    for (const [c, channelDef] of Object.entries(encoding)) {
         const channel = /** @type {Channel} */ (c);
-        if (isPositionalChannel(channel) && isChromPosDef(channelDef)) {
+        if (
+            isPositionalChannel(channel) &&
+            !Array.isArray(channelDef) &&
+            isChromPosDef(channelDef)
+        ) {
             channelsAndChromPosDefs.push({ channel, chromPosDef: channelDef });
         }
     }
@@ -302,7 +369,7 @@ export function linearizeLocusAccess(view) {
                 /** @type {any} */
                 const newFieldDef = {
                     ...(view.spec.encoding?.[channel] ??
-                        view.getEncoding()[channel] ??
+                        encoding[channel] ??
                         {}),
                     field: linearizedField,
                 };

package/dist/src/view/gridView/gridChild.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gridChild.d.ts","sourceRoot":"","sources":["../../../../src/view/gridView/gridChild.js"],"names":[],"mappings":"AA4rBA;;;GAGG;AACH,iDAHW,OAAO,oBAAoB,EAAE,cAAc,GACzC,OAAO,oBAAoB,EAAE,QAAQ,CA8BjD;AAED;;;GAGG;AACH,uDAHW,OAAO,oBAAoB,EAAE,cAAc,GACzC,OAAO,oBAAoB,EAAE,QAAQ,CA6CjD;AA1vBD;IACI;;;;;;OAMG;IAEH;;;;OAIG;IACH,kBAJW,OAAO,YAAY,EAAE,OAAO,gBAC5B,OAAO,qBAAqB,EAAE,OAAO,UACrC,MAAM,EAyFhB;IAtFG,oDAAgC;IAChC,mCAAgB;IAChB,eAAoB;IAEpB,uBAAuB;IACvB,YADW,QAAQ,CACQ;IAE3B,uBAAuB;IACvB,kBADW,QAAQ,CACc;IAEjC,sFAAsF;IACtF,MADW,OAAO,CAAC,MAAM,CAAC,OAAO,oBAAoB,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC,CAC/D;IAEd,+FAA+F;IAC/F,WADW,OAAO,CAAC,MAAM,CAAC,OAAO,oBAAoB,EAAE,UAAU,EAAE,YAAY,CAAC,CAAC,CAC9D;IAEnB,mFAAmF;IACnF,YADW,OAAO,CAAC,MAAM,CAAC,OAAO,gBAAgB,EAAE,eAAe,EAAE,SAAS,CAAC,CAAC,CAC3D;IAEpB,4BAA4B;IAC5B,eADW,aAAa,CACM;IAE9B,uBAAuB;IACvB,OADW,QAAQ,CACG;IAEtB,wBAAwB;IACxB,QADW,SAAS,CACQ;IAoZhC,sEAiBC;IAED;;OAEG;IACH,4BAwKC;IAED;;OAEG;IACH,yBAWC;IAED,uBAqBC;IAED,iCAEC;;CACJ;qBA3qBoB,gBAAgB;qBANK,gBAAgB;yBADjC,oBAAoB;sBAQvB,gBAAgB;0BACZ,oBAAoB;sBAJxB,wBAAwB;oBAF1B,sBAAsB"}
+{"version":3,"file":"gridChild.d.ts","sourceRoot":"","sources":["../../../../src/view/gridView/gridChild.js"],"names":[],"mappings":"AAosBA;;;GAGG;AACH,iDAHW,OAAO,oBAAoB,EAAE,cAAc,GACzC,OAAO,oBAAoB,EAAE,QAAQ,CA8BjD;AAED;;;GAGG;AACH,uDAHW,OAAO,oBAAoB,EAAE,cAAc,GACzC,OAAO,oBAAoB,EAAE,QAAQ,CA6CjD;AAjwBD;IACI;;;;;;OAMG;IAEH;;;;OAIG;IACH,kBAJW,OAAO,YAAY,EAAE,OAAO,gBAC5B,OAAO,qBAAqB,EAAE,OAAO,UACrC,MAAM,EAgGhB;IA7FG,oDAAgC;IAChC,mCAAgB;IAChB,eAAoB;IAEpB,uBAAuB;IACvB,YADW,QAAQ,CACQ;IAE3B,uBAAuB;IACvB,kBADW,QAAQ,CACc;IAEjC,sFAAsF;IACtF,MADW,OAAO,CAAC,MAAM,CAAC,OAAO,oBAAoB,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC,CAC/D;IAEd,+FAA+F;IAC/F,WADW,OAAO,CAAC,MAAM,CAAC,OAAO,oBAAoB,EAAE,UAAU,EAAE,YAAY,CAAC,CAAC,CAC9D;IAEnB,mFAAmF;IACnF,YADW,OAAO,CAAC,MAAM,CAAC,OAAO,gBAAgB,EAAE,eAAe,EAAE,SAAS,CAAC,CAAC,CAC3D;IAEpB,4BAA4B;IAC5B,eADW,aAAa,CACM;IAE9B,uBAAuB;IACvB,OADW,QAAQ,CACG;IAEtB,wBAAwB;IACxB,QADW,SAAS,CACQ;IA2ZhC,sEAiBC;IAED;;OAEG;IACH,4BAwKC;IAED;;OAEG;IACH,yBAWC;IAED,uBAqBC;IAED,iCAEC;;CACJ;qBAnrBoB,gBAAgB;qBANK,gBAAgB;yBADjC,oBAAoB;sBASvB,gBAAgB;0BACZ,oBAAoB;sBALxB,wBAAwB;oBAF1B,sBAAsB"}

package/dist/src/view/gridView/gridChild.js

@@ -14,6 +14,7 @@ import Point from "../layout/point.js";
 import Rectangle from "../layout/rectangle.js";
 import createTitle from "../title.js";
 import UnitView from "../unitView.js";
+import { markViewAsNonAddressable } from "../viewSelectors.js";
 import Scrollbar from "./scrollbar.js";
 import SelectionRect from "./selectionRect.js";
 
@@ -76,6 +77,9 @@ export default class GridChild {
                         blockEncodingInheritance: true,
                     }
                 );
+                markViewAsNonAddressable(this.background, {
+                    skipSubtree: true,
+                });
             }
 
             const backgroundStrokeSpec = createBackgroundStroke(viewBackground);
@@ -90,6 +94,9 @@ export default class GridChild {
                         blockEncodingInheritance: true,
                     }
                 );
+                markViewAsNonAddressable(this.backgroundStroke, {
+                    skipSubtree: true,
+                });
             }
 
             const title = createTitle(view.spec.title);
@@ -105,6 +112,7 @@ export default class GridChild {
                     }
                 );
                 this.title = unitView;
+                markViewAsNonAddressable(this.title, { skipSubtree: true });
             }
         }
 

package/dist/src/view/gridView/gridView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gridView.d.ts","sourceRoot":"","sources":["../../../../src/view/gridView/gridView.js"],"names":[],"mappings":"AA42BA;;GAEG;AACH,+EAUC;AAED;;;;;GAKG;AACH,4CAJW,OAAO,wBAAwB,EAAE,OAAO,UACxC,OAAO,oBAAoB,EAAE,UAAU,YACvC,QAAQ,aAmBlB;AA/3BD;;;;;;;;;;;;;;;GAeG;AACH;IAoCI;;;;;;;;;OASG;IACH,kBARW,OAAO,oBAAoB,EAAE,aAAa,WAC1C,OAAO,4BAA4B,EAAE,OAAO,gBAC5C,aAAa,kDAEb,MAAM,WACN,MAAM,YACN,OAAO,YAAY,EAAE,WAAW,EAoB1C;IARG,iDAAgB;IAOhB,uBAA0B;IAG9B;;OAEG;IACH,sDAEC;IAED;;;;;;OAMG;IACH,qDAFa,SAAS,CAIrB;IAED;;;;;;;OAOG;IACH,6DAHW,MAAM,GACJ,SAAS,CAQrB;IAED;;;;;OAKG;IACH,0DAQC;IAED;;;;;OAKG;IACH,qBAFW,MAAM,QAShB;IAeD;;OAEG;IACH,mBAFW,8BAAM,QAUhB;IAYD;;OAEG;IACH,+CAEC;IAED,yBAEC;IAED;;OAEG;IACH,sCAKC;IAED;;;;OAIG;IACH,gCAqCC;;CAwkBJ;qBAr0B0D,gBAAgB;sBADrD,wBAAwB;0BAEpB,qBAAqB;sBAIzB,gBAAgB"}
+{"version":3,"file":"gridView.d.ts","sourceRoot":"","sources":["../../../../src/view/gridView/gridView.js"],"names":[],"mappings":"AAg9BA;;GAEG;AACH,+EAUC;AAmBD;;;;;GAKG;AACH,4CAJW,OAAO,wBAAwB,EAAE,OAAO,UACxC,OAAO,oBAAoB,EAAE,UAAU,YACvC,QAAQ,aAmBlB;AAn/BD;;;;;;;;;;;;;;;GAeG;AACH;IAuCI;;;;;;;;;OASG;IACH,kBARW,OAAO,oBAAoB,EAAE,aAAa,WAC1C,OAAO,4BAA4B,EAAE,OAAO,gBAC5C,aAAa,kDAEb,MAAM,WACN,MAAM,YACN,OAAO,YAAY,EAAE,WAAW,EAkC1C;IAtBG,iDAAgB;IAOhB,uBAA0B;IAiB9B;;OAEG;IACH,sDAEC;IAED;;;;;;OAMG;IACH,qDAFa,SAAS,CAIrB;IAED;;;;;;;OAOG;IACH,6DAHW,MAAM,GACJ,SAAS,CASrB;IAED;;;;;OAKG;IACH,0DAQC;IAED;;;;;OAKG;IACH,qBAFW,MAAM,QAUhB;IAeD;;OAEG;IACH,mBAFW,8BAAM,QAWhB;IAYD;;OAEG;IACH,+CAEC;IAED,yBAEC;IAED;;OAEG;IACH,sCAKC;IAED;;;;OAIG;IACH,gCAqCC;;CAupBJ;qBAz6B0D,gBAAgB;sBADrD,wBAAwB;0BAEpB,qBAAqB;sBAIzB,gBAAgB"}