@vitessce/vit-s 3.3.4 → 3.3.5

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":"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"}
+{"version":3,"file":"data-hook-utils.d.ts","sourceRoot":"","sources":["../src/data-hook-utils.js"],"names":[],"mappings":"AAiBA;;;;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, getInitialCoordinationScopePrefix, } from '@vitessce/utils';
+import { capitalize, 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';
@@ -195,9 +195,9 @@ export function useDataTypeMulti(dataType, loaders, dataset, isRequired, coordin
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [anyError, setWarning]);
     // Convert data to object keyed by scopeKey.
-    const data = useMemo(() => fromEntries(matchOnEntries.map(([scopeKey], i) => ([scopeKey, dataQueries[i].data?.data]))), [matchOnObj, dataStatus]);
+    const data = useMemo(() => Object.fromEntries(matchOnEntries.map(([scopeKey], i) => ([scopeKey, dataQueries[i].data?.data]))), [matchOnObj, dataStatus]);
     // Convert data to object keyed by scopeKey.
-    const urls = useMemo(() => fromEntries(matchOnEntries.map(([scopeKey], i) => ([scopeKey, dataQueries[i].data?.urls]))), [dataQueries]);
+    const urls = useMemo(() => Object.fromEntries(matchOnEntries.map(([scopeKey], i) => ([scopeKey, dataQueries[i].data?.urls]))), [dataQueries]);
     return [data, dataStatus, urls];
 }
 export function useHasLoader(loaders, dataset, dataType, matchOn) {

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,4IAkDC;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":"AAeA,4IAoDC;AAED,oIA4CC;AAED,mJAuBC;AAED,2IAsBC;AAED,8HAqBC;AAED,wIAqBC;AAED,mIAqBC"}

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

@@ -1,6 +1,5 @@
 import { useMemo } from 'react';
 import { CoordinationType } from '@vitessce/constants-internal';
-import { fromEntries } from '@vitessce/utils';
 import { useComplexCoordination, useComplexCoordinationSecondary, } from './state/hooks.js';
 import { useFeatureSelectionMultiLevel, useObsFeatureMatrixIndicesMultiLevel, useObsLocationsMultiLevel, useObsSetsMultiLevel, useObsLabelsMultiLevel, } from './data-hooks-multilevel-utils.js';
 export function useSegmentationMultiFeatureSelection(coordinationScopes, coordinationScopesBy, loaders, dataset) {
@@ -19,10 +18,10 @@ export function useSegmentationMultiFeatureSelection(coordinationScopes, coordin
     [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])
+    const selections = useMemo(() => Object.fromEntries(Object.entries(featureSelectionCoordination[0])
         .map(([layerScope, layerVal]) => ([
         layerScope,
-        fromEntries(Object.entries(layerVal)
+        Object.fromEntries(Object.entries(layerVal)
             .map(([cScope, cVal]) => ([cScope, cVal.featureSelection]))),
     ]))), 
     // Need to execute this more frequently, whenever the featureSelections update.
@@ -48,7 +47,7 @@ export function useSpotMultiFeatureSelection(coordinationScopes, coordinationSco
     // use coordinationScopes and coordinationScopesBy which are
     // indirect dependencies here.
     [coordinationScopes, coordinationScopesBy]);
-    const selections = useMemo(() => fromEntries(Object.entries(featureSelectionCoordination[0])
+    const selections = useMemo(() => Object.fromEntries(Object.entries(featureSelectionCoordination[0])
         .map(([layerScope, layerVal]) => ([
         layerScope,
         layerVal.featureSelection,

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,+JAuBC;AAED,8JAuBC;AAED,2HAsBC;AAED,4GAmBC;AAED,sKA2BC;AAED,4JAyBC"}
+{"version":3,"file":"data-hooks.d.ts","sourceRoot":"","sources":["../src/data-hooks.js"],"names":[],"mappings":"AAkBA;;;;;;;;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

@@ -1,6 +1,5 @@
 import { useState, useEffect, useMemo } from 'react';
 import { CoordinationType, DataType, STATUS } from '@vitessce/constants-internal';
-import { fromEntries } from '@vitessce/utils';
 import { useQuery, useQueries } from '@tanstack/react-query';
 import { useMultiCoordinationValues, useComplexCoordination, useSetWarning, getMatchingLoader, } from './state/hooks.js';
 import { LoaderNotFoundError, } from './errors/index.js';
@@ -288,7 +287,7 @@ export function useSpotMultiObsSets(coordinationScopes, coordinationScopesBy, lo
 }
 export function useMultiObsLabels(coordinationScopes, obsType, loaders, dataset) {
     const obsLabelsTypes = useMultiCoordinationValues(CoordinationType.OBS_LABELS_TYPE, coordinationScopes);
-    const obsLabelsMatchOnObj = useMemo(() => fromEntries(Object.entries(obsLabelsTypes).map(([scope, obsLabelsType]) => ([
+    const obsLabelsMatchOnObj = useMemo(() => Object.fromEntries(Object.entries(obsLabelsTypes).map(([scope, obsLabelsType]) => ([
         scope,
         { obsLabelsType, obsType },
     ]))), [obsLabelsTypes, obsType]);

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

@@ -1 +1 @@
-{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../src/hooks.js"],"names":[],"mappings":"AAkBA,oDAOC;AAED;;;;GAIG;AACH,6CAgBC;AAED;;;;GAIG;AACH,yCAiCC;AAED;;;;;GAKG;AACH,2CAiCC;AAED;;;;;;GAMG;AACH,uCAHW,MAAM,EAAE,GACN,OAAO,CAOnB;AAED;;;;GAIG;AACH,8BAHW,CAAC,IAAI,GAAC,MAAM,EAAE,CAAC,EAAE,SAa3B;AAED;;;;;;GAMG;AACH,iEAuBC;AAED;;;;;;;;;;GAUG;AACH;IAR0B,gBAAgB,EAA/B,MAAM;UAqBhB;AAED;;;;;;;;;;GAUG;AACH,yDARW,QAAM,IAAI,SAuBpB;AAED;;;;QA2BC;AAED,iEAOC;AAED,kHAuBC"}
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../src/hooks.js"],"names":[],"mappings":"AAkBA,oDAOC;AAED;;;;GAIG;AACH,6CAgBC;AAED;;;;GAIG;AACH,yCAiCC;AAED;;;;;GAKG;AACH,2CAiCC;AAED;;;;;;GAMG;AACH,uCAHW,MAAM,EAAE,GACN,OAAO,CAOnB;AAED;;;;GAIG;AACH,8BAHW,CAAC,IAAI,GAAC,MAAM,EAAE,CAAC,EAAE,SAa3B;AAED;;;;;;GAMG;AACH,iEAuBC;AAED;;;;;;;;;;GAUG;AACH;IAR0B,gBAAgB,EAA/B,MAAM;UAqBhB;AAED;;;;;;;;;;GAUG;AACH,yDARW,QAAM,IAAI,SAuBpB;AAED;;;;QA2BC;AAED,iEAOC;AAED,kHA4BC"}

package/dist-tsc/hooks.js

@@ -1,7 +1,7 @@
 import { useRef, useState, useEffect, useCallback, useMemo, } from 'react';
 import { debounce, every } from 'lodash-es';
 import { extent } from 'd3-array';
-import { capitalize, fromEntries } from '@vitessce/utils';
+import { capitalize } from '@vitessce/utils';
 import { STATUS } from '@vitessce/constants-internal';
 import { useGridResize, useEmitGridResize } from './state/hooks.js';
 import { VITESSCE_CONTAINER } from './classNames.js';
@@ -246,11 +246,12 @@ export function useGetObsInfo(obsType, obsLabelsTypes, obsLabelsData, obsSetsMem
             const obsMembership = obsSetsMembership?.get(obsId) || [];
             return {
                 [`${capitalize(obsType)} ID`]: obsId,
-                ...fromEntries(obsMembership.flatMap(path => path.slice(1).map((pathEl, elLevel) => ([
+                ...Object.fromEntries(obsMembership
+                    .flatMap(path => path.slice(1).map((pathEl, elLevel) => ([
                     `${path[0]}${path.length > 2 ? ` L${elLevel + 1}` : ''}`,
                     pathEl,
                 ])))),
-                ...fromEntries(Object.entries(obsLabelsTypes).map(([scopeKey, obsLabelsType]) => ([
+                ...Object.fromEntries(Object.entries(obsLabelsTypes).map(([scopeKey, obsLabelsType]) => ([
                     obsLabelsType,
                     obsLabelsData?.[scopeKey]?.obsLabels?.[
                     // TODO: Maybe all loaders that return obsIndex should also return an obsIndexMap

package/dist-tsc/shared-mui/styles.d.ts

@@ -1,5 +1,6 @@
 export namespace muiTheme {
     const dark: import("@material-ui/core").Theme;
     const light: import("@material-ui/core").Theme;
+    const light2: import("@material-ui/core").Theme;
 }
 //# sourceMappingURL=styles.d.ts.map

package/dist-tsc/shared-mui/styles.js

@@ -53,6 +53,28 @@ const sharedThemeOptions = {
         },
     },
 };
+const lightPalette = {
+    type: 'light',
+    primary: grey,
+    secondary: grey,
+    primaryBackground: '#F1F1F1',
+    primaryBackgroundHighlight: '#FFFFFF',
+    primaryBackgroundInput: '#FFFFFF',
+    primaryBackgroundDim: '#8A8A8A',
+    primaryBackgroundLight: '#e0e0e0',
+    primaryForeground: '#333333',
+    primaryForegroundL5: 'rgb(64, 64, 64)',
+    primaryForegroundL10: 'rgb(77, 77, 77)',
+    primaryForegroundD15: 'rgb(13, 13, 13)',
+    primaryForegroundDim: '#808080',
+    primaryForegroundActive: '#0074D9',
+    secondaryBackground: '#F1F1F1',
+    secondaryBackgroundDim: '#C0C0C0',
+    secondaryForeground: '#222222',
+    gridLayoutBackground: '#FFFFFF',
+    cardBorder: 'rgba(241, 241, 241, 0.125)',
+    tooltipText: 'rgba(0, 0, 0, 0.87)',
+};
 export const muiTheme = {
     dark: createTheme({
         palette: {
@@ -79,31 +101,28 @@ export const muiTheme = {
             ...globalColors,
         },
         ...sharedThemeOptions,
+        cardBorderSize: '1px',
     }),
     light: createTheme({
         palette: {
-            type: 'light',
-            primary: grey,
-            secondary: grey,
-            primaryBackground: '#F1F1F1',
-            primaryBackgroundHighlight: '#FFFFFF',
-            primaryBackgroundInput: '#FFFFFF',
-            primaryBackgroundDim: '#8A8A8A',
-            primaryBackgroundLight: '#e0e0e0',
-            primaryForeground: '#333333',
-            primaryForegroundL5: 'rgb(64, 64, 64)',
-            primaryForegroundL10: 'rgb(77, 77, 77)',
-            primaryForegroundD15: 'rgb(13, 13, 13)',
-            primaryForegroundDim: '#808080',
-            primaryForegroundActive: '#0074D9',
-            secondaryBackground: '#F1F1F1',
-            secondaryBackgroundDim: '#C0C0C0',
-            secondaryForeground: '#222222',
+            ...lightPalette,
+            ...globalColors,
+        },
+        ...sharedThemeOptions,
+        cardBorderSize: '1px',
+    }),
+    light2: createTheme({
+        palette: {
+            ...lightPalette,
+            primaryBackground: '#FFFFFF',
+            primaryBackgroundHighlight: '#F1F1F1',
+            primaryBackgroundInput: '#F1F1F1',
+            secondaryBackground: '#FFFFFF',
             gridLayoutBackground: '#FFFFFF',
-            cardBorder: 'rgba(241, 241, 241, 0.125)',
-            tooltipText: 'rgba(0, 0, 0, 0.87)',
+            cardBorder: '#ccc',
             ...globalColors,
         },
         ...sharedThemeOptions,
+        cardBorderSize: '2px',
     }),
 };

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

@@ -62,9 +62,7 @@ export function useMultiCoordinationScopes(parameter: any, coordinationScopes: a
 export function useMultiCoordinationScopesNonNull(parameter: any, coordinationScopes: any): any;
 export function useMultiCoordinationScopesSecondary(parameter: any, byType: any, coordinationScopes: any, coordinationScopesBy: any): any;
 export function useMultiCoordinationScopesSecondaryNonNull(parameter: any, byType: any, coordinationScopes: any, coordinationScopesBy: any): any;
-export function useMultiCoordinationValues(parameter: any, coordinationScopes: any): {
-    [key: string]: any;
-};
+export function useMultiCoordinationValues(parameter: any, coordinationScopes: any): any;
 /**
  * Get a mapping from dataset coordination scopes to dataset UIDs.
  * @param {object} coordinationScopes The coordination scope mapping object for a view.

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

@@ -1 +1 @@
-{"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"}
+{"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,yFAmBC;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

@@ -6,7 +6,7 @@ import createContext from 'zustand/context';
 import shallow from 'zustand/shallow';
 import { isMatch, cloneDeep } from 'lodash-es';
 import { CoordinationType } from '@vitessce/constants-internal';
-import { fromEntries, capitalize } from '@vitessce/utils';
+import { capitalize } from '@vitessce/utils';
 import { getCoordinationSpaceAndScopes } from '@vitessce/config';
 import { removeImageChannelInMetaCoordinationScopesHelper, addImageChannelInMetaCoordinationScopesHelper, } from './spatial-reducers.js';
 // Reference: https://github.com/pmndrs/zustand#react-context
@@ -395,7 +395,7 @@ const useGridSizeStore = create(set => ({
 export function useInitialCoordination(parameters, coordinationScopes) {
     const values = useViewConfigStore((state) => {
         const { coordinationSpace } = state.initialViewConfig;
-        return fromEntries(parameters.map((parameter) => {
+        return Object.fromEntries(parameters.map((parameter) => {
             if (coordinationSpace && coordinationSpace[parameter]) {
                 const value = coordinationSpace[parameter][coordinationScopes[parameter]];
                 return [parameter, value];
@@ -425,7 +425,7 @@ export function useCoordination(parameters, coordinationScopes) {
     const setCoordinationValue = useViewConfigStore(state => state.setCoordinationValue);
     const values = useViewConfigStore((state) => {
         const { coordinationSpace } = state.viewConfig;
-        return fromEntries(parameters.map((parameter) => {
+        return Object.fromEntries(parameters.map((parameter) => {
             if (coordinationSpace) {
                 const parameterScope = getParameterScope(parameter, coordinationScopes);
                 if (coordinationSpace && coordinationSpace[parameter]) {
@@ -436,7 +436,7 @@ export function useCoordination(parameters, coordinationScopes) {
             return [parameter, undefined];
         }));
     }, shallow);
-    const setters = useMemo(() => fromEntries(parameters.map((parameter) => {
+    const setters = useMemo(() => Object.fromEntries(parameters.map((parameter) => {
         const setterName = `set${capitalize(parameter)}`;
         const setterFunc = value => setCoordinationValue({
             parameter,
@@ -480,7 +480,7 @@ export function useMultiCoordinationScopesSecondary(parameter, byType, coordinat
         const scopes = getParameterScope(byType, coordinationScopes);
         if (scopes && coordinationScopesBy?.[byType]?.[parameter]) {
             const scopesArr = Array.isArray(scopes) ? scopes : [scopes];
-            return [scopesArr, fromEntries(scopesArr.map((scope) => {
+            return [scopesArr, Object.fromEntries(scopesArr.map((scope) => {
                     const secondaryScopes = coordinationScopesBy[byType][parameter][scope];
                     const secondaryScopesArr = Array.isArray(secondaryScopes)
                         ? secondaryScopes
@@ -491,7 +491,7 @@ export function useMultiCoordinationScopesSecondary(parameter, byType, coordinat
         // Fallback from fine-grained to coarse-grained.
         if (scopes && !coordinationScopesBy?.[byType]?.[parameter] && coordinationScopes?.[parameter]) {
             const scopesArr = Array.isArray(scopes) ? scopes : [scopes];
-            return [scopesArr, fromEntries(scopesArr.map((scope) => {
+            return [scopesArr, Object.fromEntries(scopesArr.map((scope) => {
                     const secondaryScopes = coordinationScopes?.[parameter];
                     const secondaryScopesArr = Array.isArray(secondaryScopes)
                         ? secondaryScopes
@@ -522,7 +522,7 @@ export function useMultiCoordinationScopesSecondaryNonNull(parameter, byType, co
                 }
                 return false;
             });
-            return [scopesNonNull, fromEntries(scopesNonNull.map((scope) => {
+            return [scopesNonNull, Object.fromEntries(scopesNonNull.map((scope) => {
                     const secondaryScopes = coordinationScopesBy[byType][parameter][scope];
                     const secondaryScopesArr = Array.isArray(secondaryScopes)
                         ? secondaryScopes
@@ -547,7 +547,7 @@ export function useMultiCoordinationScopesSecondaryNonNull(parameter, byType, co
                 }
                 return false;
             });
-            return [scopesNonNull, fromEntries(scopesNonNull.map((scope) => {
+            return [scopesNonNull, Object.fromEntries(scopesNonNull.map((scope) => {
                     const secondaryScopes = coordinationScopes?.[parameter];
                     const secondaryScopesArr = Array.isArray(secondaryScopes)
                         ? secondaryScopes
@@ -572,7 +572,7 @@ export function useMultiCoordinationValues(parameter, coordinationScopes) {
         const { coordinationSpace } = state.viewConfig;
         // Convert a single scope to an array of scopes to be consistent.
         const scopesArr = Array.isArray(scopes) ? scopes : [scopes];
-        return fromEntries(scopesArr.map((scope) => {
+        return Object.fromEntries(scopesArr.map((scope) => {
             if (coordinationSpace && coordinationSpace[parameter]) {
                 const value = coordinationSpace[parameter][scope];
                 return [scope, value];
@@ -616,8 +616,8 @@ export function useComplexCoordination(parameters, coordinationScopes, coordinat
         if (typeScopes) {
             // Convert a single scope to an array of scopes to be consistent.
             const typeScopesArr = Array.isArray(typeScopes) ? typeScopes : [typeScopes];
-            return fromEntries(typeScopesArr.map((datasetScope) => {
-                const datasetValues = fromEntries(parameters.map((parameter, i) => {
+            return Object.fromEntries(typeScopesArr.map((datasetScope) => {
+                const datasetValues = Object.fromEntries(parameters.map((parameter, i) => {
                     if (parameterSpaces[i]) {
                         const parameterSpace = parameterSpaces[i];
                         const parameterScope = getParameterScopeBy(parameter, byType, datasetScope, coordinationScopes, coordinationScopesBy);
@@ -642,8 +642,8 @@ export function useComplexCoordination(parameters, coordinationScopes, coordinat
         if (typeScopes) {
             // Convert a single scope to an array of scopes to be consistent.
             const typeScopesArr = Array.isArray(typeScopes) ? typeScopes : [typeScopes];
-            return fromEntries(typeScopesArr.map((datasetScope) => {
-                const datasetSetters = fromEntries(parameters.map((parameter) => {
+            return Object.fromEntries(typeScopesArr.map((datasetScope) => {
+                const datasetSetters = Object.fromEntries(parameters.map((parameter) => {
                     const setterName = `set${capitalize(parameter)}`;
                     const setterFunc = value => setCoordinationValue({
                         parameter,
@@ -836,7 +836,7 @@ export function useAuxiliaryCoordination(parameters, coordinationScopes) {
     const mappedParameters = mapParameters(parameters);
     const values = useAuxiliaryStore((state) => {
         const { auxiliaryStore } = state;
-        return fromEntries(mappedParameters.map((parameter) => {
+        return Object.fromEntries(mappedParameters.map((parameter) => {
             if (auxiliaryStore && auxiliaryStore[parameter]) {
                 const value = auxiliaryStore[parameter][mappedCoordinationScopes[parameter]];
                 return [parameter, value];
@@ -844,7 +844,7 @@ export function useAuxiliaryCoordination(parameters, coordinationScopes) {
             return [parameter, undefined];
         }));
     }, shallow);
-    const setters = useMemo(() => fromEntries(mappedParameters.map((parameter) => {
+    const setters = useMemo(() => Object.fromEntries(mappedParameters.map((parameter) => {
         const setterName = `set${capitalize(parameter)}`;
         const setterFunc = value => setCoordinationValue({
             parameter,

package/dist-tsc/title-styles.js

@@ -36,7 +36,7 @@ export const useTitleStyles = makeStyles(theme => ({
         },
     },
     card: {
-        border: `1px solid ${theme.palette.cardBorder}`,
+        border: `${theme.cardBorderSize} solid ${theme.palette.cardBorder}`,
         flex: '1 1 auto',
         minHeight: '1px',
         padding: '12px',

package/dist-tsc/view-config-utils.js

@@ -1,7 +1,7 @@
 /* eslint-disable no-plusplus */
 /* eslint-disable camelcase */
 import { cloneDeep } from 'lodash-es';
-import { fromEntries, getNextScope } from '@vitessce/utils';
+import { getNextScope } from '@vitessce/utils';
 import { AUTO_INDEPENDENT_COORDINATION_TYPES, META_VERSION, } from '@vitessce/constants-internal';
 export function logConfig(config, name) {
     console.groupCollapsed(`🚄 VitS (${META_VERSION.version}) ${name}`);
@@ -33,7 +33,7 @@ export function getExistingScopesForCoordinationType(config, coordinationType) {
  * @returns {object} The new view config.
  */
 function coordinateComponentsTogether(config, coordinationType, scopeValue, viewTypes) {
-    const componentCoordinationTypes = fromEntries(viewTypes.map(vt => ([vt.name, vt.coordinationTypes])));
+    const componentCoordinationTypes = Object.fromEntries(viewTypes.map(vt => ([vt.name, vt.coordinationTypes])));
     const scopeName = getNextScope(getExistingScopesForCoordinationType(config, coordinationType));
     const newConfig = {
         ...config,
@@ -72,7 +72,7 @@ function coordinateComponentsTogether(config, coordinationType, scopeValue, view
  * @returns {object} The new view config.
  */
 function coordinateComponentsIndependent(config, coordinationType, scopeValue, viewTypes) {
-    const componentCoordinationTypes = fromEntries(viewTypes.map(vt => ([vt.name, vt.coordinationTypes])));
+    const componentCoordinationTypes = Object.fromEntries(viewTypes.map(vt => ([vt.name, vt.coordinationTypes])));
     const newConfig = {
         ...config,
         layout: [...config.layout],
@@ -117,8 +117,8 @@ function coordinateComponentsIndependent(config, coordinationType, scopeValue, v
 function initializeAuto(config, coordinationTypeObjs, viewTypeObjs) {
     let newConfig = config;
     const { layout, datasets } = newConfig;
-    const componentCoordinationTypes = fromEntries(viewTypeObjs.map(vt => ([vt.name, vt.coordinationTypes])));
-    const defaultCoordinationValues = fromEntries(coordinationTypeObjs.map(ct => ([ct.name, ct.defaultValue])));
+    const componentCoordinationTypes = Object.fromEntries(viewTypeObjs.map(vt => ([vt.name, vt.coordinationTypes])));
+    const defaultCoordinationValues = Object.fromEntries(coordinationTypeObjs.map(ct => ([ct.name, ct.defaultValue])));
     const coordinationTypes = coordinationTypeObjs.map(ct => ct.name);
     // For each coordination type, check whether it requires initialization.
     coordinationTypes.forEach((coordinationType) => {
@@ -186,7 +186,7 @@ function assignViewUids(config) {
  * @returns The view config containing expanded minimal file types.
  */
 function expandConvenienceFileDefs(config, jointFileTypes) {
-    const convenienceFileTypes = fromEntries(jointFileTypes.map(ft => ([ft.name, ft.expandFunction])));
+    const convenienceFileTypes = Object.fromEntries(jointFileTypes.map(ft => ([ft.name, ft.expandFunction])));
     const { datasets: currDatasets } = config;
     const datasets = cloneDeep(currDatasets);
     currDatasets.forEach((dataset, i) => {

package/dist-tsc/vitessce-grid-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vitessce-grid-utils.d.ts","sourceRoot":"","sources":["../src/vitessce-grid-utils.js"],"names":[],"mappings":"AA0CA,gHA6CC;AA4BD;;;;;;;;;;GAUG;AACH,wCATW,MAAM,EAAE,qBACR,MAAM,aAEN,gBAAgB,qBAChB,wBAAwB,UACxB,MAAM,GACJ,MAAM,CA4DlB"}
+{"version":3,"file":"vitessce-grid-utils.d.ts","sourceRoot":"","sources":["../src/vitessce-grid-utils.js"],"names":[],"mappings":"AAyCA,gHA6CC;AA4BD;;;;;;;;;;GAUG;AACH,wCATW,MAAM,EAAE,qBACR,MAAM,aAEN,gBAAgB,qBAChB,wBAAwB,UACxB,MAAM,GACJ,MAAM,CA4DlB"}

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

@@ -1,7 +1,6 @@
 import { useState, useEffect, useRef, } from 'react';
 import { InternMap } from 'internmap';
 import { isEqual, pick } from 'lodash-es';
-import { fromEntries } from '@vitessce/utils';
 import { DATA_TYPE_COORDINATION_VALUE_USAGE } from '@vitessce/constants-internal';
 import { getSourceAndLoaderFromFileType, getDataTypeFromFileType } from './data/loader-registry.js';
 /**
@@ -109,7 +108,7 @@ function withDefaults(coordinationValues, dataType, fileType, datasetUid, defaul
 export function createLoaders(datasets, configDescription, fileTypes, coordinationTypes, stores) {
     const result = {};
     const dataSources = new InternMap([], JSON.stringify);
-    const defaultCoordinationValues = fromEntries(coordinationTypes.map(ct => ([ct.name, ct.defaultValue])));
+    const defaultCoordinationValues = Object.fromEntries(coordinationTypes.map(ct => ([ct.name, ct.defaultValue])));
     datasets.forEach((dataset) => {
         const datasetLoaders = {
             name: dataset.name,

package/package.json

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

package/src/data-hook-utils.js

@@ -2,7 +2,6 @@ import { useEffect, useMemo } from 'react';
 import { useQuery, useQueries } from '@tanstack/react-query';
 import {
   capitalize,
-  fromEntries,
   getInitialCoordinationScopePrefix,
 } from '@vitessce/utils';
 import { STATUS } from '@vitessce/constants-internal';
@@ -236,7 +235,7 @@ export function useDataTypeMulti(
   }, [anyError, setWarning]);
 
   // Convert data to object keyed by scopeKey.
-  const data = useMemo(() => fromEntries(
+  const data = useMemo(() => Object.fromEntries(
     matchOnEntries.map(([scopeKey], i) => ([scopeKey, dataQueries[i].data?.data])),
   // Deliberate dependency omissions: dataQueries and matchOnEntries,
   // since dataQueries changes every re-render. We use the in-direct
@@ -245,7 +244,7 @@ export function useDataTypeMulti(
   ), [matchOnObj, dataStatus]);
 
   // Convert data to object keyed by scopeKey.
-  const urls = useMemo(() => fromEntries(
+  const urls = useMemo(() => Object.fromEntries(
     matchOnEntries.map(([scopeKey], i) => ([scopeKey, dataQueries[i].data?.urls])),
   // Deliberate dependency omissions: matchOnEntries, since dataQueries depends on it.
   // eslint-disable-next-line react-hooks/exhaustive-deps

package/src/data-hooks-multilevel.js

@@ -1,6 +1,5 @@
 import { useMemo } from 'react';
 import { CoordinationType } from '@vitessce/constants-internal';
-import { fromEntries } from '@vitessce/utils';
 import {
   useComplexCoordination,
   useComplexCoordinationSecondary,
@@ -44,14 +43,16 @@ export function useSegmentationMultiFeatureSelection(
     [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,
-      fromEntries(
-        Object.entries(layerVal)
-          .map(([cScope, cVal]) => ([cScope, cVal.featureSelection])),
-      ),
-    ]))),
+  const selections = useMemo(() => Object.fromEntries(
+    Object.entries(featureSelectionCoordination[0])
+      .map(([layerScope, layerVal]) => ([
+        layerScope,
+        Object.fromEntries(
+          Object.entries(layerVal)
+            .map(([cScope, cVal]) => ([cScope, cVal.featureSelection])),
+        ),
+      ])),
+  ),
   // Need to execute this more frequently, whenever the featureSelections update.
   [coordinationScopes, coordinationScopesBy,
     // We need to ensure there are always the same number of
@@ -92,11 +93,13 @@ export function useSpotMultiFeatureSelection(
     // use coordinationScopes and coordinationScopesBy which are
     // indirect dependencies here.
     [coordinationScopes, coordinationScopesBy]);
-  const selections = useMemo(() => fromEntries(Object.entries(featureSelectionCoordination[0])
-    .map(([layerScope, layerVal]) => ([
-      layerScope,
-      layerVal.featureSelection,
-    ]))),
+  const selections = useMemo(() => Object.fromEntries(
+    Object.entries(featureSelectionCoordination[0])
+      .map(([layerScope, layerVal]) => ([
+        layerScope,
+        layerVal.featureSelection,
+      ])),
+  ),
   // Need to execute this more frequently, whenever the featureSelections update.
   [coordinationScopes, coordinationScopesBy,
     ...Object.values(featureSelectionCoordination[0] || {})

package/src/data-hooks.js

@@ -1,6 +1,5 @@
 import { useState, useEffect, useMemo } from 'react';
 import { CoordinationType, DataType, STATUS } from '@vitessce/constants-internal';
-import { fromEntries } from '@vitessce/utils';
 import { useQuery, useQueries } from '@tanstack/react-query';
 import {
   useMultiCoordinationValues,
@@ -456,7 +455,7 @@ export function useMultiObsLabels(
     CoordinationType.OBS_LABELS_TYPE,
     coordinationScopes,
   );
-  const obsLabelsMatchOnObj = useMemo(() => fromEntries(
+  const obsLabelsMatchOnObj = useMemo(() => Object.fromEntries(
     Object.entries(obsLabelsTypes).map(([scope, obsLabelsType]) => ([
       scope,
       { obsLabelsType, obsType },

package/src/hooks.js

@@ -3,7 +3,7 @@ import {
 } from 'react';
 import { debounce, every } from 'lodash-es';
 import { extent } from 'd3-array';
-import { capitalize, fromEntries } from '@vitessce/utils';
+import { capitalize } from '@vitessce/utils';
 import { STATUS } from '@vitessce/constants-internal';
 import { useGridResize, useEmitGridResize } from './state/hooks.js';
 import { VITESSCE_CONTAINER } from './classNames.js';
@@ -290,19 +290,24 @@ export function useGetObsInfo(obsType, obsLabelsTypes, obsLabelsData, obsSetsMem
       const obsMembership = obsSetsMembership?.get(obsId) || [];
       return {
         [`${capitalize(obsType)} ID`]: obsId,
-        ...fromEntries(obsMembership.flatMap(path => path.slice(1).map((pathEl, elLevel) => ([
-          `${path[0]}${path.length > 2 ? ` L${elLevel + 1}` : ''}`,
-          pathEl,
-        ])))),
-        ...fromEntries(Object.entries(obsLabelsTypes).map(([scopeKey, obsLabelsType]) => ([
-          obsLabelsType,
-          obsLabelsData?.[scopeKey]?.obsLabels?.[
-            // TODO: Maybe all loaders that return obsIndex should also return an obsIndexMap
-            // with keys: obsId, values: obsIdx
-            // which would avoid the indexOf calls.
-            obsLabelsData?.[scopeKey]?.obsIndex?.indexOf(obsId)
-          ],
-        ])).filter(([obsLabelsType]) => Boolean(obsLabelsType))),
+        ...Object.fromEntries(
+          obsMembership
+            .flatMap(path => path.slice(1).map((pathEl, elLevel) => ([
+              `${path[0]}${path.length > 2 ? ` L${elLevel + 1}` : ''}`,
+              pathEl,
+            ]))),
+        ),
+        ...Object.fromEntries(
+          Object.entries(obsLabelsTypes).map(([scopeKey, obsLabelsType]) => ([
+            obsLabelsType,
+            obsLabelsData?.[scopeKey]?.obsLabels?.[
+              // TODO: Maybe all loaders that return obsIndex should also return an obsIndexMap
+              // with keys: obsId, values: obsIdx
+              // which would avoid the indexOf calls.
+              obsLabelsData?.[scopeKey]?.obsIndex?.indexOf(obsId)
+            ],
+          ])).filter(([obsLabelsType]) => Boolean(obsLabelsType)),
+        ),
       };
     }
     return null;