@vitessce/vit-s 3.3.2 → 3.3.4

package/dist-tsc/VitS.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VitS.d.ts","sourceRoot":"","sources":["../src/VitS.js"],"names":[],"mappings":"AA8BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH;IA7ByB,MAAM,EAApB,MAAM;IAGkB,SAAS,EAAjC,SAAS,GAAC,MAAM;IACF,MAAM,EAApB,MAAM;IACQ,KAAK,EAAnB,MAAM;IAEU,MAAM;IACN,cAAc;IAEd,cAAc;IAEf,cAAc,EAA7B,OAAO;IAIQ,sBAAsB,EAArC,OAAO;IAGY,GAAG,EAAtB,IAAI,GAAC,MAAM;IAGE,SAAS;IACT,SAAS;IACT,cAAc;IACd,iBAAiB;IACX,OAAO,EAA1B,IAAI,GAAC,MAAM;gBA2LrB"}
+{"version":3,"file":"VitS.d.ts","sourceRoot":"","sources":["../src/VitS.js"],"names":[],"mappings":"AA8BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH;IA7ByB,MAAM,EAApB,MAAM;IAGkB,SAAS,EAAjC,SAAS,GAAC,MAAM;IACF,MAAM,EAApB,MAAM;IACQ,KAAK,EAAnB,MAAM;IAEU,MAAM;IACN,cAAc;IAEd,cAAc;IAEf,cAAc,EAA7B,OAAO;IAIQ,sBAAsB,EAArC,OAAO;IAGY,GAAG,EAAtB,IAAI,GAAC,MAAM;IAGE,SAAS;IACT,SAAS;IACT,cAAc;IACd,iBAAiB;IACX,OAAO,EAA1B,IAAI,GAAC,MAAM;gBA4LrB"}

package/dist-tsc/VitS.js

@@ -142,5 +142,5 @@ export function VitS(props) {
         return createViewConfigStore(null, null);
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [success, configKey]);
-    return success ? (_jsx(StylesProvider, { generateClassName: generateClassName, children: _jsx(ThemeProvider, { theme: muiTheme[theme], children: _jsx(QueryClientProvider, { client: queryClient, children: _jsx(ViewConfigProvider, { createStore: createViewConfigStoreClosure, children: _jsxs(AuxiliaryProvider, { createStore: createAuxiliaryStore, children: [_jsx(VitessceGrid, { success: success, configKey: configKey, viewTypes: viewTypes, fileTypes: fileTypes, coordinationTypes: coordinationTypes, config: configOrWarning, rowHeight: rowHeight, height: height, theme: theme, isBounded: isBounded }), _jsx(CallbackPublisher, { onWarn: onWarn, onConfigChange: onConfigChange, onLoaderChange: onLoaderChange, validateOnConfigChange: validateOnConfigChange, pluginSpecificConfigSchema: pluginSpecificConfigSchema })] }) }, configKey) }) }) })) : (_jsx(StylesProvider, { generateClassName: generateClassName, children: _jsx(ThemeProvider, { theme: muiTheme[theme], children: _jsx(Warning, { ...configOrWarning }) }) }));
+    return success ? (_jsx(StylesProvider, { generateClassName: generateClassName, children: _jsx(ThemeProvider, { theme: muiTheme[theme], children: _jsx(QueryClientProvider, { client: queryClient, children: _jsx(ViewConfigProvider, { createStore: createViewConfigStoreClosure, children: _jsxs(AuxiliaryProvider, { createStore: createAuxiliaryStore, children: [_jsx(VitessceGrid, { success: success, configKey: configKey, viewTypes: viewTypes, fileTypes: fileTypes, coordinationTypes: coordinationTypes, config: configOrWarning, rowHeight: rowHeight, height: height, theme: theme, isBounded: isBounded, stores: stores }), _jsx(CallbackPublisher, { onWarn: onWarn, onConfigChange: onConfigChange, onLoaderChange: onLoaderChange, validateOnConfigChange: validateOnConfigChange, pluginSpecificConfigSchema: pluginSpecificConfigSchema })] }) }, configKey) }) }) })) : (_jsx(StylesProvider, { generateClassName: generateClassName, children: _jsx(ThemeProvider, { theme: muiTheme[theme], children: _jsx(Warning, { ...configOrWarning }) }) }));
 }

package/dist-tsc/VitessceGrid.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VitessceGrid.d.ts","sourceRoot":"","sources":["../src/VitessceGrid.js"],"names":[],"mappings":"AA4BA;;;;;;;;;;;GAWG;AACH;IATyB,SAAS,EAAvB,MAAM;IACQ,MAAM,EAApB,MAAM;IACQ,KAAK,EAAnB,MAAM;IACQ,MAAM,EAApB,MAAM;IACU,MAAM;IACE,SAAS,EAAjC,gBAAgB;IACQ,SAAS,EAAjC,gBAAgB;IACgB,iBAAiB,EAAjD,wBAAwB;gBA4FlC"}
+{"version":3,"file":"VitessceGrid.d.ts","sourceRoot":"","sources":["../src/VitessceGrid.js"],"names":[],"mappings":"AA4BA;;;;;;;;;;;GAWG;AACH;IATyB,SAAS,EAAvB,MAAM;IACQ,MAAM,EAApB,MAAM;IACQ,KAAK,EAAnB,MAAM;IACQ,MAAM,EAApB,MAAM;IACU,MAAM;IACE,SAAS,EAAjC,gBAAgB;IACQ,SAAS,EAAjC,gBAAgB;IACgB,iBAAiB,EAAjD,wBAAwB;gBA8FlC"}

package/dist-tsc/VitessceGrid.js

@@ -24,7 +24,7 @@ const margin = 5;
  * @param {PluginCoordinationType[]} props.coordinationTypes
  */
 export default function VitessceGrid(props) {
-    const { success, configKey, rowHeight: initialRowHeight, config, theme, height, isBounded, viewTypes, fileTypes, coordinationTypes, } = props;
+    const { success, configKey, rowHeight: initialRowHeight, config, theme, height, isBounded, viewTypes, fileTypes, coordinationTypes, stores, } = props;
     const [rowHeight, containerRef] = useRowHeight(config, initialRowHeight, height, margin, padding);
     const onResize = useEmitGridResize();
     const [componentWidth] = useClosestVitessceContainerSize(containerRef);
@@ -54,7 +54,7 @@ export default function VitessceGrid(props) {
         let newLoaders = null;
         let newConfig = null;
         if (success) {
-            newLoaders = createLoaders(config.datasets, config.description, fileTypes, coordinationTypes);
+            newLoaders = createLoaders(config.datasets, config.description, fileTypes, coordinationTypes, stores);
             newConfig = config;
         }
         setViewConfig(newConfig);

package/dist-tsc/data-hook-utils.d.ts

@@ -60,7 +60,7 @@ export function useDataType(dataType: any, loaders: object, dataset: string, isR
  * cells is an object and cellsCount is the
  * number of items in the cells object.
  */
-export function useDataTypeMulti(dataType: any, loaders: object, dataset: string, isRequired: boolean, coordinationSetters: object, initialCoordinationValues: object, matchOnObj: any): array;
+export function useDataTypeMulti(dataType: any, loaders: object, dataset: string, isRequired: boolean, coordinationSetters: object, initialCoordinationValues: object, matchOnObj: any, mergeCoordination: any, viewUid: any): array;
 export function useHasLoader(loaders: any, dataset: any, dataType: any, matchOn: any): boolean;
 import { AbstractLoaderError } from "./errors/index.js";
 //# sourceMappingURL=data-hook-utils.d.ts.map

package/dist-tsc/data-hook-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"data-hook-utils.d.ts","sourceRoot":"","sources":["../src/data-hook-utils.js"],"names":[],"mappings":"AAcA;;;;GAIG;AACH,4BAFW,mBAAmB,yBAS7B;AAED;;;;;;;;;;GAUG;AACH,8CATW,MAAM,WAGN,MAAM,iBAGN,MAAM,QAiBhB;AAGD,oDAuBC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,oDAhBW,MAAM,WAEN,MAAM,cAEN,OAAO,uBAEP,MAAM,6BAGN,MAAM,uBAkDhB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,yDAhBW,MAAM,WAEN,MAAM,cAEN,OAAO,uBAEP,MAAM,6BAGN,MAAM,0BA+EhB;AAED,+FAGC"}
+{"version":3,"file":"data-hook-utils.d.ts","sourceRoot":"","sources":["../src/data-hook-utils.js"],"names":[],"mappings":"AAkBA;;;;GAIG;AACH,4BAFW,mBAAmB,yBAS7B;AAED;;;;;;;;;;GAUG;AACH,8CATW,MAAM,WAGN,MAAM,iBAGN,MAAM,QAiBhB;AAGD,oDAuBC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,oDAhBW,MAAM,WAEN,MAAM,cAEN,OAAO,uBAEP,MAAM,6BAGN,MAAM,uBAkDhB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,yDAhBW,MAAM,WAEN,MAAM,cAEN,OAAO,uBAEP,MAAM,6BAGN,MAAM,gEAyFhB;AAED,+FAGC"}

package/dist-tsc/data-hook-utils.js

@@ -1,6 +1,6 @@
 import { useEffect, useMemo } from 'react';
 import { useQuery, useQueries } from '@tanstack/react-query';
-import { capitalize, fromEntries } from '@vitessce/utils';
+import { capitalize, fromEntries, getInitialCoordinationScopePrefix, } from '@vitessce/utils';
 import { STATUS } from '@vitessce/constants-internal';
 import { getMatchingLoader, useMatchingLoader, useSetWarning, } from './state/hooks.js';
 import { AbstractLoaderError, LoaderNotFoundError, } from './errors/index.js';
@@ -56,7 +56,7 @@ export async function dataQueryFn(ctx) {
         const { data, url, coordinationValues } = payload;
         // Status: success
         // Array of objects like  { url, name }.
-        const urls = Array.isArray(url) ? url : [{ url, name: dataType }];
+        const urls = (Array.isArray(url) ? url : [{ url, name: dataType }]).filter(d => d.url);
         return { data, coordinationValues, urls };
     }
     // No loader was found.
@@ -144,7 +144,7 @@ export function useDataType(dataType, loaders, dataset, isRequired, coordination
  * cells is an object and cellsCount is the
  * number of items in the cells object.
  */
-export function useDataTypeMulti(dataType, loaders, dataset, isRequired, coordinationSetters, initialCoordinationValues, matchOnObj) {
+export function useDataTypeMulti(dataType, loaders, dataset, isRequired, coordinationSetters, initialCoordinationValues, matchOnObj, mergeCoordination, viewUid) {
     const placeholderObject = useMemo(() => ({}), []);
     const setWarning = useSetWarning();
     const matchOnEntries = matchOnObj ? Object.entries(matchOnObj) : [];
@@ -172,10 +172,17 @@ export function useDataTypeMulti(dataType, loaders, dataset, isRequired, coordin
     const isSuccess = dataStatus === STATUS.SUCCESS;
     useEffect(() => {
         dataQueries
-            .map(q => q.data?.coordinationValues)
-            .filter(v => Boolean(v))
-            .forEach((coordinationValues) => {
-            initCoordinationSpace(coordinationValues, coordinationSetters, initialCoordinationValues);
+            .filter(q => Boolean(q.data?.coordinationValues))
+            .forEach((q) => {
+            const { coordinationValues } = q.data;
+            if (mergeCoordination) {
+                mergeCoordination(coordinationValues, 
+                // Auto-generate based on the dataset and data type.
+                getInitialCoordinationScopePrefix(dataset, dataType), viewUid);
+            }
+            else {
+                initCoordinationSpace(coordinationValues, coordinationSetters, initialCoordinationValues);
+            }
         });
         // Deliberate dependency omissions: use indirect dependencies for efficiency.
         // eslint-disable-next-line react-hooks/exhaustive-deps

package/dist-tsc/data-hooks-multilevel-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"data-hooks-multilevel-utils.d.ts","sourceRoot":"","sources":["../src/data-hooks-multilevel-utils.js"],"names":[],"mappings":"AA+CA;;;;;;;;;;;;;GAaG;AACH,mEAPW,MAAM,cACN,MAAM,SACN,MAAM,WACN,MAAM,YACN,MAAM,wBAmBhB;AA8BD;;;;;;;;;;;;GAYG;AACH,gEANW,MAAM,SACN,MAAM,WACN,MAAM,YACN,MAAM,wBAiBhB;AA+BD;;;;;;;;;;;;GAYG;AACH,mDANW,MAAM,SACN,MAAM,WACN,MAAM,YACN,MAAM,wBAiBhB;AAuBD;;;;;;;;;;GAUG;AACH,oDALW,MAAM,EAAE,WACR,MAAM,+BAOhB;AAED;;;;;;GAMG;AACH,0GAUC;AAED;;;;;;GAMG;AACH,0FAYC;AA+DD,gJA6DC;AAuCD,sIAqDC;AAyDD,2HAQC;AAED,sHAQC;AAED,wHAQC"}
+{"version":3,"file":"data-hooks-multilevel-utils.d.ts","sourceRoot":"","sources":["../src/data-hooks-multilevel-utils.js"],"names":[],"mappings":"AA+CA;;;;;;;;;;;;;GAaG;AACH,mEAPW,MAAM,cACN,MAAM,SACN,MAAM,WACN,MAAM,YACN,MAAM,wBAmBhB;AA8BD;;;;;;;;;;;;GAYG;AACH,gEANW,MAAM,SACN,MAAM,WACN,MAAM,YACN,MAAM,wBAiBhB;AA+BD;;;;;;;;;;;;GAYG;AACH,mDANW,MAAM,SACN,MAAM,WACN,MAAM,YACN,MAAM,wBAiBhB;AAuBD;;;;;;;;;;GAUG;AACH,oDALW,MAAM,EAAE,WACR,MAAM,+BAOhB;AAED;;;;;;GAMG;AACH,0GAUC;AAED;;;;;;GAMG;AACH,0FAYC;AA+DD,gJA6DC;AAuCD,sIAuDC;AAyDD,2HAQC;AAED,sHAQC;AAED,wHAQC"}

package/dist-tsc/data-hooks-multilevel-utils.js

@@ -281,7 +281,7 @@ export function useFeatureSelectionMultiLevel(loaders, dataset, isRequired, matc
         // (i.e., a single number, despite possibly different numbers of queries).
         // Reference: https://github.com/TanStack/query/issues/3049#issuecomment-1253201068
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [featureQueries.reduce((a, h) => a + h.dataUpdatedAt, 0)]);
+    }, [featureQueries.reduce((a, h) => a + h.dataUpdatedAt, 0), queryKeyScopeTuples]);
     return [geneData, loadedGeneName, extents, normData, dataStatus];
 }
 async function matrixIndicesQueryFn(ctx) {
@@ -361,8 +361,10 @@ export function useObsFeatureMatrixIndicesMultiLevel(loaders, dataset, isRequire
         // We use .reduce to ensure the number of dependencies is stable
         // (i.e., a single number, despite possibly different numbers of queries).
         // Reference: https://github.com/TanStack/query/issues/3049#issuecomment-1253201068
+        // We also want to re-compute if any of the keys within the matchOnObj change,
+        // so we also use queryKeyScopeTuples as a dependency.
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [indicesQueries.reduce((a, h) => a + h.dataUpdatedAt, 0)]);
+    }, [indicesQueries.reduce((a, h) => a + h.dataUpdatedAt, 0), queryKeyScopeTuples]);
     return [indicesData, dataStatus];
 }
 function useDataTypeMultiLevel(loaders, dataset, isRequired, matchOnObj, depth, dataType) {
@@ -404,7 +406,7 @@ function useDataTypeMultiLevel(loaders, dataset, isRequired, matchOnObj, depth,
         // (i.e., a single number, despite possibly different numbers of queries).
         // Reference: https://github.com/TanStack/query/issues/3049#issuecomment-1253201068
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [locationsQueries.reduce((a, h) => a + h.dataUpdatedAt, 0)]);
+    }, [locationsQueries.reduce((a, h) => a + h.dataUpdatedAt, 0), queryKeyScopeTuples]);
     return [locationsData, dataStatus];
 }
 export function useObsLocationsMultiLevel(loaders, dataset, isRequired, matchOnObj, depth) {

package/dist-tsc/data-hooks-multilevel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"data-hooks-multilevel.d.ts","sourceRoot":"","sources":["../src/data-hooks-multilevel.js"],"names":[],"mappings":"AAgBA,4IA+CC;AAED,oIA0CC;AAED,mJAuBC;AAED,2IAsBC;AAED,8HAqBC;AAED,wIAqBC;AAED,mIAqBC"}
+{"version":3,"file":"data-hooks-multilevel.d.ts","sourceRoot":"","sources":["../src/data-hooks-multilevel.js"],"names":[],"mappings":"AAgBA,4IAkDC;AAED,oIA0CC;AAED,mJAuBC;AAED,2IAsBC;AAED,8HAqBC;AAED,wIAqBC;AAED,mIAqBC"}

package/dist-tsc/data-hooks-multilevel.js

@@ -17,6 +17,8 @@ export function useSegmentationMultiFeatureSelection(coordinationScopes, coordin
     // use coordinationScopes and coordinationScopesBy which are
     // indirect dependencies here.
     [coordinationScopes, coordinationScopesBy]);
+    const useMemoDependency = Object.values(featureSelectionCoordination[0] || {})
+        .flatMap(layerVal => Object.values(layerVal).map(cVal => cVal.featureSelection));
     const selections = useMemo(() => fromEntries(Object.entries(featureSelectionCoordination[0])
         .map(([layerScope, layerVal]) => ([
         layerScope,
@@ -25,8 +27,9 @@ export function useSegmentationMultiFeatureSelection(coordinationScopes, coordin
     ]))), 
     // Need to execute this more frequently, whenever the featureSelections update.
     [coordinationScopes, coordinationScopesBy,
-        ...Object.values(featureSelectionCoordination[0] || {})
-            .flatMap(layerVal => Object.values(layerVal).map(cVal => cVal.featureSelection)),
+        // We need to ensure there are always the same number of
+        // entries in the full dependency array.
+        JSON.stringify(useMemoDependency.length > 0 ? useMemoDependency : [null]),
     ]);
     const [featureData, loadedSelections, extents, normData, featureStatus,] = useFeatureSelectionMultiLevel(loaders, dataset, false, matchOnObj, selections, 2);
     return [featureData, loadedSelections, extents, normData, featureStatus];

package/dist-tsc/data-hooks.d.ts

@@ -71,10 +71,10 @@ export function useFeatureSelection(loaders: object, dataset: string, isRequired
  * @returns {object} [attrs] { rows, cols } object containing cell and gene names.
  */
 export function useObsFeatureMatrixIndices(loaders: object, dataset: string, isRequired: boolean, matchOn: any): object;
-export function useMultiObsPoints(coordinationScopes: any, coordinationScopesBy: any, loaders: any, dataset: any): any[];
-export function useMultiObsSpots(coordinationScopes: any, coordinationScopesBy: any, loaders: any, dataset: any): any[];
+export function useMultiObsPoints(coordinationScopes: any, coordinationScopesBy: any, loaders: any, dataset: any, mergeCoordination: any, viewUid: any): any[];
+export function useMultiObsSpots(coordinationScopes: any, coordinationScopesBy: any, loaders: any, dataset: any, mergeCoordination: any, viewUid: any): any[];
 export function useSpotMultiObsSets(coordinationScopes: any, coordinationScopesBy: any, loaders: any, dataset: any): any[];
 export function useMultiObsLabels(coordinationScopes: any, obsType: any, loaders: any, dataset: any): any[];
-export function useMultiObsSegmentations(coordinationScopes: any, coordinationScopesBy: any, loaders: any, dataset: any): any[];
-export function useMultiImages(coordinationScopes: any, coordinationScopesBy: any, loaders: any, dataset: any): any[];
+export function useMultiObsSegmentations(coordinationScopes: any, coordinationScopesBy: any, loaders: any, dataset: any, mergeCoordination: any, viewUid: any): any[];
+export function useMultiImages(coordinationScopes: any, coordinationScopesBy: any, loaders: any, dataset: any, mergeCoordination: any, viewUid: any): any[];
 //# sourceMappingURL=data-hooks.d.ts.map

package/dist-tsc/data-hooks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"data-hooks.d.ts","sourceRoot":"","sources":["../src/data-hooks.js"],"names":[],"mappings":"AAmBA;;;;;;;;GAQG;AACH,wCAPW,MAAM,WAEN,MAAM,SAsBhB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,6CAhBW,MAAM,WAEN,MAAM,cAEN,OAAO,uBAEP,MAAM,6BAGN,MAAM,uBAgBhB;AAED,4JASC;AAED,6JASC;AAED,gKASC;AAED,6JASC;AAED,oKASC;AAED,2JASC;AAED,oKASC;AAED,iKASC;AAED,yJASC;AAED,mKASC;AAED,iKASC;AAED;;;;;;;;;;;;;GAaG;AACH,6CAVW,MAAM,WAEN,MAAM,cAEN,OAAO,aAEP,OAAO,uBA4EjB;AAED;;;;;;;;;;;;;GAaG;AACH,oDARW,MAAM,WAEN,MAAM,cAEN,OAAO,iBAEL,MAAM,CA2ElB;AAED,yHAsBC;AAED,wHAsBC;AAED,2HAsBC;AAED,4GAmBC;AAED,gIA0BC;AAED,sHAwBC"}
+{"version":3,"file":"data-hooks.d.ts","sourceRoot":"","sources":["../src/data-hooks.js"],"names":[],"mappings":"AAmBA;;;;;;;;GAQG;AACH,wCAPW,MAAM,WAEN,MAAM,SAsBhB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,6CAhBW,MAAM,WAEN,MAAM,cAEN,OAAO,uBAEP,MAAM,6BAGN,MAAM,uBAgBhB;AAED,4JASC;AAED,6JASC;AAED,gKASC;AAED,6JASC;AAED,oKASC;AAED,2JASC;AAED,oKASC;AAED,iKASC;AAED,yJASC;AAED,mKASC;AAED,iKASC;AAED;;;;;;;;;;;;;GAaG;AACH,6CAVW,MAAM,WAEN,MAAM,cAEN,OAAO,aAEP,OAAO,uBA4EjB;AAED;;;;;;;;;;;;;GAaG;AACH,oDARW,MAAM,WAEN,MAAM,cAEN,OAAO,iBAEL,MAAM,CA2ElB;AAED,+JAuBC;AAED,8JAuBC;AAED,2HAsBC;AAED,4GAmBC;AAED,sKA2BC;AAED,4JAyBC"}

package/dist-tsc/data-hooks.js

@@ -211,7 +211,7 @@ export function useObsFeatureMatrixIndices(loaders, dataset, isRequired, matchOn
                             obsIndex: payloadData.rows,
                             featureIndex: payloadData.cols,
                         },
-                        urls: [{ url, name: DataType.OBS_FEATURE_MATRIX }],
+                        urls: (url ? [{ url, name: DataType.OBS_FEATURE_MATRIX }] : null),
                     };
                 }
                 // No loadAttrs function.
@@ -250,7 +250,7 @@ export function useObsFeatureMatrixIndices(loaders, dataset, isRequired, matchOn
     }, [error, setWarning]);
     return [loadedData, dataStatus, urls];
 }
-export function useMultiObsPoints(coordinationScopes, coordinationScopesBy, loaders, dataset) {
+export function useMultiObsPoints(coordinationScopes, coordinationScopesBy, loaders, dataset, mergeCoordination, viewUid) {
     const obsTypeCoordination = useComplexCoordination([
         CoordinationType.OBS_TYPE,
     ], coordinationScopes, coordinationScopesBy, CoordinationType.POINT_LAYER);
@@ -259,10 +259,10 @@ export function useMultiObsPoints(coordinationScopes, coordinationScopesBy, load
     // use coordinationScopes and coordinationScopesBy which are
     // indirect dependencies here.
     [coordinationScopes, coordinationScopesBy]);
-    const [obsPointsData, obsPointsDataStatus, obsPointsUrls] = useDataTypeMulti(DataType.OBS_POINTS, loaders, dataset, false, {}, {}, matchOnObj);
+    const [obsPointsData, obsPointsDataStatus, obsPointsUrls] = useDataTypeMulti(DataType.OBS_POINTS, loaders, dataset, false, {}, {}, matchOnObj, mergeCoordination, viewUid);
     return [obsPointsData, obsPointsDataStatus, obsPointsUrls];
 }
-export function useMultiObsSpots(coordinationScopes, coordinationScopesBy, loaders, dataset) {
+export function useMultiObsSpots(coordinationScopes, coordinationScopesBy, loaders, dataset, mergeCoordination, viewUid) {
     const obsTypeCoordination = useComplexCoordination([
         CoordinationType.OBS_TYPE,
     ], coordinationScopes, coordinationScopesBy, CoordinationType.SPOT_LAYER);
@@ -271,7 +271,7 @@ export function useMultiObsSpots(coordinationScopes, coordinationScopesBy, loade
     // use coordinationScopes and coordinationScopesBy which are
     // indirect dependencies here.
     [coordinationScopes, coordinationScopesBy]);
-    const [obsSpotsData, obsSpotsDataStatus, obsSpotsUrls] = useDataTypeMulti(DataType.OBS_SPOTS, loaders, dataset, false, {}, {}, matchOnObj);
+    const [obsSpotsData, obsSpotsDataStatus, obsSpotsUrls] = useDataTypeMulti(DataType.OBS_SPOTS, loaders, dataset, false, {}, {}, matchOnObj, mergeCoordination, viewUid);
     return [obsSpotsData, obsSpotsDataStatus, obsSpotsUrls];
 }
 export function useSpotMultiObsSets(coordinationScopes, coordinationScopesBy, loaders, dataset) {
@@ -295,7 +295,7 @@ export function useMultiObsLabels(coordinationScopes, obsType, loaders, dataset)
     const [obsLabelsData, obsLabelsDataStatus, obsLabelsUrls] = useDataTypeMulti(DataType.OBS_LABELS, loaders, dataset, false, {}, {}, obsLabelsMatchOnObj);
     return [obsLabelsTypes, obsLabelsData, obsLabelsDataStatus, obsLabelsUrls];
 }
-export function useMultiObsSegmentations(coordinationScopes, coordinationScopesBy, loaders, dataset) {
+export function useMultiObsSegmentations(coordinationScopes, coordinationScopesBy, loaders, dataset, mergeCoordination, viewUid) {
     const imageCoordination = useComplexCoordination([
         CoordinationType.FILE_UID,
     ], coordinationScopes, coordinationScopesBy, CoordinationType.SEGMENTATION_LAYER);
@@ -304,10 +304,10 @@ export function useMultiObsSegmentations(coordinationScopes, coordinationScopesB
     // use coordinationScopes and coordinationScopesBy which are
     // indirect dependencies here.
     [coordinationScopes, coordinationScopesBy]);
-    const [obsSegmentationsData, obsSegmentationsDataStatus, obsSegmentationsUrls,] = useDataTypeMulti(DataType.OBS_SEGMENTATIONS, loaders, dataset, false, {}, {}, matchOnObj);
+    const [obsSegmentationsData, obsSegmentationsDataStatus, obsSegmentationsUrls,] = useDataTypeMulti(DataType.OBS_SEGMENTATIONS, loaders, dataset, false, {}, {}, matchOnObj, mergeCoordination, viewUid);
     return [obsSegmentationsData, obsSegmentationsDataStatus, obsSegmentationsUrls];
 }
-export function useMultiImages(coordinationScopes, coordinationScopesBy, loaders, dataset) {
+export function useMultiImages(coordinationScopes, coordinationScopesBy, loaders, dataset, mergeCoordination, viewUid) {
     // TODO: delegate the generation of matchOnObj to a different hoook and pass as a parameter?
     // (in all of the useMulti data hooks)?
     const imageCoordination = useComplexCoordination([
@@ -318,6 +318,6 @@ export function useMultiImages(coordinationScopes, coordinationScopesBy, loaders
     // use coordinationScopes and coordinationScopesBy which are
     // indirect dependencies here.
     [coordinationScopes, coordinationScopesBy]);
-    const [imageData, imageDataStatus, imageUrls] = useDataTypeMulti(DataType.IMAGE, loaders, dataset, false, {}, {}, matchOnObj);
+    const [imageData, imageDataStatus, imageUrls] = useDataTypeMulti(DataType.IMAGE, loaders, dataset, false, {}, {}, matchOnObj, mergeCoordination, viewUid);
     return [imageData, imageDataStatus, imageUrls];
 }

package/dist-tsc/index.d.ts

@@ -4,7 +4,7 @@ export { PopperMenu } from "./shared-mui/components.js";
 export { useHasLoader } from "./data-hook-utils.js";
 export { logConfig } from "./view-config-utils.js";
 export { useReady, useUrls, useVitessceContainer, useDeckCanvasSize, useUint8ObsFeatureMatrix, useUint8FeatureSelection, useExpressionValueGetter, useGetObsMembership, useGetObsInfo, useClosestVitessceContainerSize, useWindowDimensions, useGridItemSize } from "./hooks.js";
-export { useCoordinationScopes, useCoordinationScopesBy, useInitialCoordination, useCoordination, useComplexCoordination, useComplexCoordinationSecondary, useMultiCoordinationScopes, useMultiCoordinationScopesNonNull, useMultiCoordinationScopesSecondary, useMultiCoordinationScopesSecondaryNonNull, useMultiCoordinationValues, useMultiDatasetCoordination, useDatasetUids, useLoaders, useMatchingLoader, useViewConfigStore, useViewConfigStoreApi, useComponentHover, useSetComponentHover, useComponentViewInfo, useSetComponentViewInfo, useWarning, useSetWarning, useAuxiliaryCoordination, useComponentLayout, useRemoveImageChannelInMetaCoordinationScopes, useAddImageChannelInMetaCoordinationScopes } from "./state/hooks.js";
+export { useCoordinationScopes, useCoordinationScopesBy, useInitialCoordination, useCoordination, useComplexCoordination, useComplexCoordinationSecondary, useMultiCoordinationScopes, useMultiCoordinationScopesNonNull, useMultiCoordinationScopesSecondary, useMultiCoordinationScopesSecondaryNonNull, useMultiCoordinationValues, useMultiDatasetCoordination, useDatasetUids, useLoaders, useMergeCoordination, useMatchingLoader, useViewConfigStore, useViewConfigStoreApi, useComponentHover, useSetComponentHover, useComponentViewInfo, useSetComponentViewInfo, useWarning, useSetWarning, useAuxiliaryCoordination, useComponentLayout, useRemoveImageChannelInMetaCoordinationScopes, useAddImageChannelInMetaCoordinationScopes } from "./state/hooks.js";
 export { useDescription, useImageData, useObsSetsData, useObsEmbeddingData, useFeatureSelection, useObsFeatureMatrixIndices, useMultiObsLabels, useMultiObsSpots, useMultiObsPoints, useSpotMultiObsSets, useMultiObsSegmentations, useMultiImages, useObsSpotsData, useObsPointsData, useObsLocationsData, useObsSegmentationsData, useNeighborhoodsData, useObsLabelsData, useObsFeatureMatrixData, useFeatureLabelsData, useGenomicProfilesData } from "./data-hooks.js";
 export { usePointMultiObsLabels, useSpotMultiFeatureSelection, useSpotMultiObsFeatureMatrixIndices, useSegmentationMultiFeatureSelection, useSegmentationMultiObsFeatureMatrixIndices, useSegmentationMultiObsLocations, useSegmentationMultiObsSets } from "./data-hooks-multilevel.js";
 export { AbstractLoader, AbstractTwoStepLoader, LoaderResult } from "./data/index.js";

package/dist-tsc/index.js

@@ -3,7 +3,7 @@ export { TitleInfo } from './TitleInfo.js';
 export { PopperMenu } from './shared-mui/components.js';
 // For plugin view types:
 export { useReady, useUrls, useVitessceContainer, useDeckCanvasSize, useUint8ObsFeatureMatrix, useUint8FeatureSelection, useExpressionValueGetter, useGetObsMembership, useGetObsInfo, useClosestVitessceContainerSize, useWindowDimensions, useGridItemSize, } from './hooks.js';
-export { useCoordinationScopes, useCoordinationScopesBy, useInitialCoordination, useCoordination, useComplexCoordination, useComplexCoordinationSecondary, useMultiCoordinationScopes, useMultiCoordinationScopesNonNull, useMultiCoordinationScopesSecondary, useMultiCoordinationScopesSecondaryNonNull, useMultiCoordinationValues, useMultiDatasetCoordination, useDatasetUids, useLoaders, useMatchingLoader, useViewConfigStore, useViewConfigStoreApi, useComponentHover, useSetComponentHover, useComponentViewInfo, useSetComponentViewInfo, useWarning, useSetWarning, useAuxiliaryCoordination, useComponentLayout, useRemoveImageChannelInMetaCoordinationScopes, useAddImageChannelInMetaCoordinationScopes, } from './state/hooks.js';
+export { useCoordinationScopes, useCoordinationScopesBy, useInitialCoordination, useCoordination, useComplexCoordination, useComplexCoordinationSecondary, useMultiCoordinationScopes, useMultiCoordinationScopesNonNull, useMultiCoordinationScopesSecondary, useMultiCoordinationScopesSecondaryNonNull, useMultiCoordinationValues, useMultiDatasetCoordination, useDatasetUids, useLoaders, useMergeCoordination, useMatchingLoader, useViewConfigStore, useViewConfigStoreApi, useComponentHover, useSetComponentHover, useComponentViewInfo, useSetComponentViewInfo, useWarning, useSetWarning, useAuxiliaryCoordination, useComponentLayout, useRemoveImageChannelInMetaCoordinationScopes, useAddImageChannelInMetaCoordinationScopes, } from './state/hooks.js';
 export { useDescription, useImageData, useObsSetsData, useObsEmbeddingData, useFeatureSelection, useObsFeatureMatrixIndices, useMultiObsLabels, useMultiObsSpots, useMultiObsPoints, useSpotMultiObsSets, useMultiObsSegmentations, useMultiImages, useObsSpotsData, useObsPointsData, useObsLocationsData, useObsSegmentationsData, useNeighborhoodsData, useObsLabelsData, useObsFeatureMatrixData, useFeatureLabelsData, useGenomicProfilesData, } from './data-hooks.js';
 export { usePointMultiObsLabels, useSpotMultiFeatureSelection, useSpotMultiObsFeatureMatrixIndices, useSegmentationMultiFeatureSelection, useSegmentationMultiObsFeatureMatrixIndices, useSegmentationMultiObsLocations, useSegmentationMultiObsSets, } from './data-hooks-multilevel.js';
 export { useHasLoader, } from './data-hook-utils.js';

package/dist-tsc/state/hooks.d.ts

@@ -217,6 +217,13 @@ export function useChangeLayout(): Function;
  * in the `useViewConfigStore` store.
  */
 export function useSetLoaders(): Function;
+/**
+ * Obtain the loaders setter function from
+ * the global app state.
+ * @returns {function} The loaders setter function
+ * in the `useViewConfigStore` store.
+ */
+export function useMergeCoordination(): Function;
 /**
  * Obtain the view config setter function from
  * the global app state.

package/dist-tsc/state/hooks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../src/state/hooks.js"],"names":[],"mappings":"AAkCA;;;;;;GAMG;AACH,oEAFa,MAAM,GAAC,SAAS,CAoB5B;AAED;;;;;;;GAOG;AACH,mGAFa,MAAM,GAAC,SAAS,CAoB5B;AAED;;;;;GAKG;AACH,6CAJW,MAAM,4BAEJ,MAAM,GAAC,SAAS,CAI5B;AAED;;;;;;GAMG;AACH,+CALW,MAAM,oFAGJ,MAAM,GAAC,SAAS,CAc5B;AA2MD;;;;;;;;;GASG;AACH,mDALW,MAAM,EAAE,sBACR,MAAM,GAEJ,MAAM,CAclB;AAED;;;;;;;;;;;;;;;GAeG;AACH,4CATW,MAAM,EAAE,sBACR,MAAM,SAqChB;AAED,yFAKC;AAED,gGAqBC;AAED,0IA4BC;AAED,iJAkEC;AAED;;EAmBC;AAED;;;;GAIG;AACH,mDAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;;;;;;;;GAaG;AACH,mDAXW,MAAM,EAAE,sBACR,MAAM,wBACN,MAAM,UAEN,MAAM,SA6EhB;AAED;;;;;GAKG;AACH,0DAHW,MAAM,GACJ,MAAM,CAiBlB;AAED;;;;;;GAMG;AACH,4DAJW,MAAM,wBACN,MAAM,GACJ,MAAM,CAgBlB;AAED;;;;;;;GAOG;AACH,4DANW,MAAM,EAAE,iDACR,MAAM,eACN,MAAM,iBACN,MAAM,SAuEhB;AAGD;;;;;;;;;;;GAWG;AACH,wDATW,MAAM,EAAE,sBACR,MAAM,wBACN,MAAM,SAYhB;AA6BD;;;;;;;;;;;;;;;GAeG;AACH,qDATW,MAAM,EAAE,sBACR,MAAM,SAkChB;AAED;;;;;GAKG;AACH,8BAHa,MAAM,CAKlB;AAGD;;;;;;;;;;;;GAYG;AACH,2CARW,MAAM,WACN,MAAM,YACN,MAAM,0BACN,MAAM,OAoBhB;AAED;;;;;;;;;;;;GAYG;AACH,2CARW,MAAM,WACN,MAAM,YACN,MAAM,0BACN,MAAM,OAShB;AAED;;;;;GAKG;AACH,6BAHa,MAAM,EAAE,CAKpB;AAED;;;;;GAKG;AACH,+CAEC;AAED;;;;;GAKG;AACH,0EAEC;AAED;;;;;GAKG;AACH,uEAEC;AAED;;;;;GAKG;AACH,4CAEC;AAED;;;;;GAKG;AACH,0CAEC;AAED;;;;;GAKG;AACH,oEAIC;AAED;;;;;GAKG;AACH,qCAHa,MAAM,CAKlB;AAED;;;;;GAKG;AACH,iDAEC;AAED;;;;;GAKG;AACH,8BAHa,MAAM,CAKlB;AAED;;;;;GAKG;AACH,0CAEC;AAED;;;;;GAKG;AACH,iDAHa,MAAM,CAKlB;AAED;;;;;GAKG;AACH,6DAOC;AAED;;;;GAIG;AACH,iCAFa,MAAM,CAIlB;AAED;;;;;GAKG;AACH,8CAEC;AAnhCD;;;;+QAA0D;AAC1D,sFAA0D;AAC1D;;;;;EAAgE;AAOhE;;;;+QAAwD;AACxD,qFAAwD;AAmGjD,yFA8FJ;AAOI,0FAFM,MAAM,CAOlB;AAcM,iDAUJ"}
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../src/state/hooks.js"],"names":[],"mappings":"AAmCA;;;;;;GAMG;AACH,oEAFa,MAAM,GAAC,SAAS,CA4B5B;AAED;;;;;;;GAOG;AACH,mGAFa,MAAM,GAAC,SAAS,CA0C5B;AAED;;;;;GAKG;AACH,6CAJW,MAAM,4BAEJ,MAAM,GAAC,SAAS,CAI5B;AAED;;;;;;GAMG;AACH,+CALW,MAAM,oFAGJ,MAAM,GAAC,SAAS,CAc5B;AA4RD;;;;;;;;;GASG;AACH,mDALW,MAAM,EAAE,sBACR,MAAM,GAEJ,MAAM,CAclB;AAED;;;;;;;;;;;;;;;GAeG;AACH,4CATW,MAAM,EAAE,sBACR,MAAM,SAqChB;AAED,yFAKC;AAED,gGAqBC;AAED,0IA4BC;AAED,iJAkEC;AAED;;EAmBC;AAED;;;;GAIG;AACH,mDAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;;;;;;;;GAaG;AACH,mDAXW,MAAM,EAAE,sBACR,MAAM,wBACN,MAAM,UAEN,MAAM,SA6EhB;AAED;;;;;GAKG;AACH,0DAHW,MAAM,GACJ,MAAM,CAiBlB;AAED;;;;;;GAMG;AACH,4DAJW,MAAM,wBACN,MAAM,GACJ,MAAM,CAgBlB;AAED;;;;;;;GAOG;AACH,4DANW,MAAM,EAAE,iDACR,MAAM,eACN,MAAM,iBACN,MAAM,SAuEhB;AAGD;;;;;;;;;;;GAWG;AACH,wDATW,MAAM,EAAE,sBACR,MAAM,wBACN,MAAM,SAYhB;AA6BD;;;;;;;;;;;;;;;GAeG;AACH,qDATW,MAAM,EAAE,sBACR,MAAM,SAkChB;AAED;;;;;GAKG;AACH,8BAHa,MAAM,CAKlB;AAGD;;;;;;;;;;;;GAYG;AACH,2CARW,MAAM,WACN,MAAM,YACN,MAAM,0BACN,MAAM,OAoBhB;AAED;;;;;;;;;;;;GAYG;AACH,2CARW,MAAM,WACN,MAAM,YACN,MAAM,0BACN,MAAM,OAShB;AAED;;;;;GAKG;AACH,6BAHa,MAAM,EAAE,CAKpB;AAED;;;;;GAKG;AACH,+CAEC;AAED;;;;;GAKG;AACH,0EAEC;AAED;;;;;GAKG;AACH,uEAEC;AAED;;;;;GAKG;AACH,4CAEC;AAED;;;;;GAKG;AACH,0CAEC;AAED;;;;;GAKG;AACH,iDAEC;AAED;;;;;GAKG;AACH,oEAIC;AAED;;;;;GAKG;AACH,qCAHa,MAAM,CAKlB;AAED;;;;;GAKG;AACH,iDAEC;AAED;;;;;GAKG;AACH,8BAHa,MAAM,CAKlB;AAED;;;;;GAKG;AACH,0CAEC;AAED;;;;;GAKG;AACH,iDAHa,MAAM,CAKlB;AAED;;;;;GAKG;AACH,6DAOC;AAED;;;;GAIG;AACH,iCAFa,MAAM,CAIlB;AAED;;;;;GAKG;AACH,8CAEC;AA5oCD;;;;+QAA0D;AAC1D,sFAA0D;AAC1D;;;;;EAAgE;AAOhE;;;;+QAAwD;AACxD,qFAAwD;AAiIjD,yFA+KJ;AAOI,0FAFM,MAAM,CAOlB;AAcM,iDAUJ"}

package/dist-tsc/state/hooks.js

@@ -4,9 +4,10 @@ import { useRef, useCallback, useMemo } from 'react';
 import create from 'zustand';
 import createContext from 'zustand/context';
 import shallow from 'zustand/shallow';
-import { isMatch, merge, cloneDeep } from 'lodash-es';
+import { isMatch, cloneDeep } from 'lodash-es';
 import { CoordinationType } from '@vitessce/constants-internal';
 import { fromEntries, capitalize } from '@vitessce/utils';
+import { getCoordinationSpaceAndScopes } from '@vitessce/config';
 import { removeImageChannelInMetaCoordinationScopesHelper, addImageChannelInMetaCoordinationScopesHelper, } from './spatial-reducers.js';
 // Reference: https://github.com/pmndrs/zustand#react-context
 // Reference: https://github.com/pmndrs/zustand/blob/e47ea03/tests/context.test.tsx#L60
@@ -37,7 +38,15 @@ export function getScopes(coordinationScopes, metaSpace) {
             metaScopesArr.forEach((metaScope) => {
                 // Merge the original coordinationScopes with the matching meta-coordinationScopes
                 // from the coordinationSpace.
-                result = merge(result, metaSpace[metaScope]);
+                let o1 = result;
+                const o2 = metaSpace[metaScope] || {};
+                Object.entries(o2).forEach(([cType, cScope]) => {
+                    o1 = {
+                        ...o1,
+                        [cType]: cScope,
+                    };
+                });
+                result = o1;
             });
         }
     }
@@ -64,7 +73,29 @@ export function getScopesBy(coordinationScopes, coordinationScopesBy, metaSpaceB
             metaScopesArr.forEach((metaScope) => {
                 // Merge the original coordinationScopesBy with the matching meta-coordinationScopesBy
                 // from the coordinationSpace.
-                result = merge(result, metaSpaceBy[metaScope]);
+                let o1 = result;
+                const o2 = metaSpaceBy[metaScope] || {};
+                // Cannot simply use lodash merge(o1, o2)
+                // because we do not want to merge (objects/arrays) at the leaf
+                // (i.e., secondaryScopeVal) level.
+                // We want the values in o2 to take precedence over the values in o1.
+                Object.entries(o2).forEach(([primaryType, primaryObj]) => {
+                    Object.entries(primaryObj).forEach(([secondaryType, secondaryObj]) => {
+                        Object.entries(secondaryObj).forEach(([primaryScope, secondaryScopeVal]) => {
+                            o1 = {
+                                ...o1,
+                                [primaryType]: {
+                                    ...(o1?.[primaryType] || {}),
+                                    [secondaryType]: {
+                                        ...(o1?.[primaryType]?.[secondaryType] || {}),
+                                        [primaryScope]: secondaryScopeVal,
+                                    },
+                                },
+                            };
+                        });
+                    });
+                });
+                result = o1;
             });
         }
     }
@@ -146,6 +177,85 @@ export const createViewConfigStore = (initialLoaders, initialConfig) => create(s
             },
         };
     }),
+    mergeCoordination: (newCoordinationValues, scopePrefix, viewUid) => set((state) => {
+        const { coordinationSpace, layout } = state.viewConfig;
+        const { coordinationSpace: newCoordinationSpace, coordinationScopes, } = getCoordinationSpaceAndScopes(newCoordinationValues, scopePrefix);
+        // Merge coordination objects in coordination space
+        Object.entries(newCoordinationSpace).forEach(([coordinationType, coordinationObj]) => {
+            if (coordinationType === CoordinationType.META_COORDINATION_SCOPES) {
+                // Perform an extra level of merging for meta-coordination scopes.
+                Object.entries(coordinationObj).forEach(([coordinationScope, coordinationValue]) => {
+                    coordinationSpace[coordinationType] = {
+                        ...coordinationSpace[coordinationType],
+                        [coordinationScope]: {
+                            ...coordinationValue,
+                            ...(coordinationSpace[coordinationType]?.[coordinationScope] || {}),
+                        },
+                    };
+                });
+            }
+            else if (coordinationType === CoordinationType.META_COORDINATION_SCOPES_BY) {
+                // Perform two extra levels of merging for meta-coordination scopesBy.
+                Object.entries(coordinationObj).forEach(([coordinationScope, coordinationValue]) => {
+                    Object.entries(coordinationValue).forEach(([primaryType, primaryObj]) => {
+                        Object.entries(primaryObj).forEach(([secondaryType, secondaryObj]) => {
+                            coordinationSpace[coordinationType] = {
+                                ...coordinationSpace[coordinationType],
+                                [coordinationScope]: {
+                                    ...(coordinationSpace[coordinationType]?.[coordinationScope] || {}),
+                                    [primaryType]: {
+                                        ...(coordinationSpace[coordinationType]?.[coordinationScope]?.[primaryType] || {}),
+                                        [secondaryType]: {
+                                            ...secondaryObj,
+                                            ...(coordinationSpace[coordinationType]?.[coordinationScope]?.[primaryType]?.[secondaryType] || {}),
+                                        },
+                                    },
+                                },
+                            };
+                        });
+                    });
+                });
+            }
+            else {
+                coordinationSpace[coordinationType] = {
+                    ...coordinationObj,
+                    // Existing coordination values should be preserved,
+                    // so that user-defined values take precedence over auto-initialization values.
+                    ...(coordinationSpace[coordinationType] || {}),
+                };
+            }
+        });
+        const newViewConfig = {
+            ...state.viewConfig,
+            coordinationSpace: {
+                ...coordinationSpace,
+            },
+            layout: layout.map((viewObj) => {
+                if (viewObj.uid === viewUid) {
+                    // Merge coordination scopes for views
+                    return {
+                        ...viewObj,
+                        coordinationScopes: {
+                            ...viewObj.coordinationScopes,
+                            [CoordinationType.META_COORDINATION_SCOPES]: [
+                                ...(coordinationScopes[CoordinationType.META_COORDINATION_SCOPES] || []),
+                                ...(viewObj.coordinationScopes[CoordinationType.META_COORDINATION_SCOPES] || []),
+                            ],
+                            [CoordinationType.META_COORDINATION_SCOPES_BY]: [
+                                ...(coordinationScopes[CoordinationType.META_COORDINATION_SCOPES_BY] || []),
+                                ...(viewObj.coordinationScopes[CoordinationType.META_COORDINATION_SCOPES_BY] || []),
+                            ],
+                        },
+                    };
+                }
+                return viewObj;
+            }),
+        };
+        // console.log('newViewConfig', newViewConfig);
+        return {
+            viewConfig: newViewConfig,
+        };
+    }),
     removeImageChannelInMetaCoordinationScopes: (coordinationScopesRaw, layerScope, channelScope) => set((state) => {
         const { coordinationSpace } = state.viewConfig;
         return {
@@ -854,6 +964,15 @@ export function useChangeLayout() {
 export function useSetLoaders() {
     return useViewConfigStore(state => state.setLoaders);
 }
+/**
+ * Obtain the loaders setter function from
+ * the global app state.
+ * @returns {function} The loaders setter function
+ * in the `useViewConfigStore` store.
+ */
+export function useMergeCoordination() {
+    return useViewConfigStore(state => state.mergeCoordination);
+}
 /**
  * Obtain the view config setter function from
  * the global app state.

package/dist-tsc/state/spatial-reducers.js

@@ -24,7 +24,7 @@ export function getMetaScope(coordinationScopes, coordinationSpace, parameter) {
             metaScopesArr.forEach((metaScope) => {
                 // Merge the original coordinationScopes with the matching meta-coordinationScopes
                 // from the coordinationSpace.
-                if (metaSpace[metaScope][parameter]) {
+                if (metaSpace[metaScope]?.[parameter]) {
                     latestMetaScope = metaScope;
                 }
             });

package/dist-tsc/vitessce-grid-utils.js

@@ -81,7 +81,7 @@ export function useRowHeight(config, initialRowHeight, height, margin, padding)
 function withDefaults(coordinationValues, dataType, fileType, datasetUid, defaultCoordinationValues) {
     const defaultKeys = DATA_TYPE_COORDINATION_VALUE_USAGE[dataType]
         .filter(k => (Object.keys(defaultCoordinationValues).includes(k)
-        && defaultCoordinationValues[k]
+        // && defaultCoordinationValues[k]
         && !Object.keys(coordinationValues).includes(k)));
     const defaultValues = pick(defaultCoordinationValues, defaultKeys);
     const coordinationValuesWithDefaults = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vitessce/vit-s",
-  "version": "3.3.2",
+  "version": "3.3.4",
   "author": "Gehlenborg Lab",
   "homepage": "http://vitessce.io",
   "repository": {
@@ -29,10 +29,11 @@
     "uuid": "^9.0.0",
     "zustand": "^3.5.10",
     "react-aria": "^3.28.0",
-    "@vitessce/constants-internal": "3.3.2",
-    "@vitessce/plugins": "3.3.2",
-    "@vitessce/schemas": "3.3.2",
-    "@vitessce/utils": "3.3.2"
+    "@vitessce/constants-internal": "3.3.4",
+    "@vitessce/plugins": "3.3.4",
+    "@vitessce/schemas": "3.3.4",
+    "@vitessce/utils": "3.3.4",
+    "@vitessce/config": "3.3.4"
   },
   "devDependencies": {
     "@testing-library/jest-dom": "^5.16.4",

package/src/VitS.js

@@ -224,6 +224,7 @@ export function VitS(props) {
                 height={height}
                 theme={theme}
                 isBounded={isBounded}
+                stores={stores}
               />
               <CallbackPublisher
                 onWarn={onWarn}

package/src/VitessceGrid.js

@@ -50,6 +50,7 @@ export default function VitessceGrid(props) {
     viewTypes,
     fileTypes,
     coordinationTypes,
+    stores,
   } = props;
 
   const [rowHeight, containerRef] = useRowHeight(config, initialRowHeight, height, margin, padding);
@@ -93,6 +94,7 @@ export default function VitessceGrid(props) {
         config.description,
         fileTypes,
         coordinationTypes,
+        stores,
       );
       newConfig = config;
     }

package/src/data-hook-utils.js

@@ -1,6 +1,10 @@
 import { useEffect, useMemo } from 'react';
 import { useQuery, useQueries } from '@tanstack/react-query';
-import { capitalize, fromEntries } from '@vitessce/utils';
+import {
+  capitalize,
+  fromEntries,
+  getInitialCoordinationScopePrefix,
+} from '@vitessce/utils';
 import { STATUS } from '@vitessce/constants-internal';
 import {
   getMatchingLoader,
@@ -66,7 +70,7 @@ export async function dataQueryFn(ctx) {
     const { data, url, coordinationValues } = payload;
     // Status: success
     // Array of objects like  { url, name }.
-    const urls = Array.isArray(url) ? url : [{ url, name: dataType }];
+    const urls = (Array.isArray(url) ? url : [{ url, name: dataType }]).filter(d => d.url);
     return { data, coordinationValues, urls };
   }
   // No loader was found.
@@ -169,6 +173,7 @@ export function useDataType(
 export function useDataTypeMulti(
   dataType, loaders, dataset, isRequired,
   coordinationSetters, initialCoordinationValues, matchOnObj,
+  mergeCoordination, viewUid,
 ) {
   const placeholderObject = useMemo(() => ({}), []);
   const setWarning = useSetWarning();
@@ -200,14 +205,23 @@ export function useDataTypeMulti(
 
   useEffect(() => {
     dataQueries
-      .map(q => q.data?.coordinationValues)
-      .filter(v => Boolean(v))
-      .forEach((coordinationValues) => {
-        initCoordinationSpace(
-          coordinationValues,
-          coordinationSetters,
-          initialCoordinationValues,
-        );
+      .filter(q => Boolean(q.data?.coordinationValues))
+      .forEach((q) => {
+        const { coordinationValues } = q.data;
+        if (mergeCoordination) {
+          mergeCoordination(
+            coordinationValues,
+            // Auto-generate based on the dataset and data type.
+            getInitialCoordinationScopePrefix(dataset, dataType),
+            viewUid,
+          );
+        } else {
+          initCoordinationSpace(
+            coordinationValues,
+            coordinationSetters,
+            initialCoordinationValues,
+          );
+        }
       });
   // Deliberate dependency omissions: use indirect dependencies for efficiency.
   // eslint-disable-next-line react-hooks/exhaustive-deps