@vitessce/vit-s 3.1.2 → 3.2.0

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

@@ -0,0 +1,101 @@
+import { describe, it, expect } from 'vitest';
+import { initializeNestedObject, nestFeatureSelectionQueryResults, getFeatureSelectionQueryKeyScopeTuples, nestQueryResults, getQueryKeyScopeTuples, } from './data-hooks-multilevel-utils.js';
+describe('recursive data hook utilities for nesting and un-nesting multi-level queries', () => {
+    describe('initializeNestedObject', () => {
+        it('should initialize an empty nested object', () => {
+            const nestedObject = {};
+            initializeNestedObject(['a', 'b', 'c'], nestedObject, () => true);
+            expect(nestedObject).toEqual({ a: { b: { c: true } } });
+        });
+        it('should initialize a non-empty nested object at the same path', () => {
+            const nestedObject = { a: { b: { c: [1, 2, 3] } } };
+            initializeNestedObject(['a', 'b', 'c'], nestedObject, () => []);
+            expect(nestedObject).toEqual({ a: { b: { c: [1, 2, 3] } } });
+        });
+        it('should initialize a non-empty nested object at a different path', () => {
+            const nestedObject = { a: { b: { c: [1, 2, 3] } } };
+            initializeNestedObject(['a', 'b', 'd'], nestedObject, () => []);
+            expect(nestedObject).toEqual({ a: { b: { c: [1, 2, 3], d: [] } } });
+        });
+        it('should initialize two paths', () => {
+            const nestedObject = {};
+            initializeNestedObject(['a', 'b', 'c'], nestedObject, () => true);
+            initializeNestedObject(['d', 'e', 'f'], nestedObject, () => true);
+            expect(nestedObject).toEqual({
+                a: { b: { c: true } },
+                d: { e: { f: true } },
+            });
+        });
+    });
+    describe('nestFeatureSelectionQueryResults', () => {
+        it('should nest flat query results', () => {
+            const queryKeyScopeTuples = [
+                [['someQueryKey', 'abc'], { levelScopes: ['a', 'b', 'c'], featureIndex: 0, numFeatures: 3 }],
+                [['someQueryKey', 'abc'], { levelScopes: ['a', 'b', 'c'], featureIndex: 1, numFeatures: 3 }],
+                [['someQueryKey', 'abd'], { levelScopes: ['a', 'b', 'd'], featureIndex: 0, numFeatures: 2 }],
+            ];
+            const flatQueryResults = [
+                'abc0',
+                'abc1',
+                'abd0',
+            ];
+            const nestedData = nestFeatureSelectionQueryResults(queryKeyScopeTuples, flatQueryResults);
+            expect(nestedData).toEqual({
+                a: { b: { c: ['abc0', 'abc1', undefined], d: ['abd0', undefined] } },
+            });
+        });
+    });
+    describe('getFeatureSelectionQueryKeyScopeTuples', () => {
+        it('should convert nested selections and matchOn objects to array of tuples', () => {
+            const selections = { a: { b: { c: ['geneA', 'geneB', 'geneC'] } } };
+            const matchOn = { a: { b: { c: { obsType: 'cell', featureType: 'gene' } } } };
+            const queryKeyScopeTuples = getFeatureSelectionQueryKeyScopeTuples(selections, matchOn, 3, 'someDataset', 'someDataType', true);
+            expect(queryKeyScopeTuples).toEqual([
+                [
+                    ['someDataset', 'someDataType', { obsType: 'cell', featureType: 'gene' }, 'geneA', true, 'useFeatureSelectionMultiLevel'],
+                    // scope info (for rolling up later)
+                    { levelScopes: ['a', 'b', 'c'], featureIndex: 0, numFeatures: 3 },
+                ],
+                [
+                    ['someDataset', 'someDataType', { obsType: 'cell', featureType: 'gene' }, 'geneB', true, 'useFeatureSelectionMultiLevel'],
+                    // scope info (for rolling up later)
+                    { levelScopes: ['a', 'b', 'c'], featureIndex: 1, numFeatures: 3 },
+                ],
+                [
+                    ['someDataset', 'someDataType', { obsType: 'cell', featureType: 'gene' }, 'geneC', true, 'useFeatureSelectionMultiLevel'],
+                    // scope info (for rolling up later)
+                    { levelScopes: ['a', 'b', 'c'], featureIndex: 2, numFeatures: 3 },
+                ],
+            ]);
+        });
+    });
+    describe('nestQueryResults', () => {
+        it('should nest flat query results', () => {
+            const queryKeyScopeTuples = [
+                [['someQueryKey', 'abc'], { levelScopes: ['a', 'b', 'c'] }],
+                [['someQueryKey', 'abd'], { levelScopes: ['a', 'b', 'd'] }],
+            ];
+            const flatQueryResults = [
+                { someKey: 'abc0' },
+                { someKey: 'abd0' },
+            ];
+            const nestedData = nestQueryResults(queryKeyScopeTuples, flatQueryResults);
+            expect(nestedData).toEqual({
+                a: { b: { c: { someKey: 'abc0' }, d: { someKey: 'abd0' } } },
+            });
+        });
+    });
+    describe('getQueryKeyScopeTuples', () => {
+        it('should convert nested selections and matchOn objects to array of tuples', () => {
+            const matchOn = { a: { b: { c: { obsType: 'cell', featureType: 'gene' } } } };
+            const queryKeyScopeTuples = getQueryKeyScopeTuples(matchOn, 3, 'someDataset', 'someDataType', true);
+            expect(queryKeyScopeTuples).toEqual([
+                [
+                    ['someDataset', 'someDataType', { obsType: 'cell', featureType: 'gene' }, true, 'useDataType'],
+                    // scope info (for rolling up later)
+                    { levelScopes: ['a', 'b', 'c'] },
+                ],
+            ]);
+        });
+    });
+});

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

@@ -0,0 +1,8 @@
+export function useSegmentationMultiFeatureSelection(coordinationScopes: any, coordinationScopesBy: any, loaders: any, dataset: any): any[];
+export function useSpotMultiFeatureSelection(coordinationScopes: any, coordinationScopesBy: any, loaders: any, dataset: any): any[];
+export function useSegmentationMultiObsFeatureMatrixIndices(coordinationScopes: any, coordinationScopesBy: any, loaders: any, dataset: any): any[];
+export function useSpotMultiObsFeatureMatrixIndices(coordinationScopes: any, coordinationScopesBy: any, loaders: any, dataset: any): any[];
+export function usePointMultiObsLabels(coordinationScopes: any, coordinationScopesBy: any, loaders: any, dataset: any): any[];
+export function useSegmentationMultiObsLocations(coordinationScopes: any, coordinationScopesBy: any, loaders: any, dataset: any): any[];
+export function useSegmentationMultiObsSets(coordinationScopes: any, coordinationScopesBy: any, loaders: any, dataset: any): any[];
+//# sourceMappingURL=data-hooks-multilevel.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,125 @@
+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) {
+    const obsFeatureMatrixCoordination = useComplexCoordinationSecondary([
+        CoordinationType.OBS_TYPE,
+        CoordinationType.FEATURE_TYPE,
+        CoordinationType.FEATURE_VALUE_TYPE,
+    ], coordinationScopes, coordinationScopesBy, CoordinationType.SEGMENTATION_LAYER, CoordinationType.SEGMENTATION_CHANNEL);
+    const featureSelectionCoordination = useComplexCoordinationSecondary([
+        CoordinationType.FEATURE_SELECTION,
+    ], coordinationScopes, coordinationScopesBy, CoordinationType.SEGMENTATION_LAYER, CoordinationType.SEGMENTATION_CHANNEL);
+    const matchOnObj = useMemo(() => obsFeatureMatrixCoordination[0], 
+    // imageCoordination reference changes each render,
+    // use coordinationScopes and coordinationScopesBy which are
+    // indirect dependencies here.
+    [coordinationScopes, coordinationScopesBy]);
+    const selections = useMemo(() => fromEntries(Object.entries(featureSelectionCoordination[0])
+        .map(([layerScope, layerVal]) => ([
+        layerScope,
+        fromEntries(Object.entries(layerVal)
+            .map(([cScope, cVal]) => ([cScope, cVal.featureSelection]))),
+    ]))), 
+    // 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)),
+    ]);
+    const [featureData, loadedSelections, extents, normData, featureStatus,] = useFeatureSelectionMultiLevel(loaders, dataset, false, matchOnObj, selections, 2);
+    return [featureData, loadedSelections, extents, normData, featureStatus];
+}
+export function useSpotMultiFeatureSelection(coordinationScopes, coordinationScopesBy, loaders, dataset) {
+    const obsFeatureMatrixCoordination = useComplexCoordination([
+        CoordinationType.OBS_TYPE,
+        CoordinationType.FEATURE_TYPE,
+        CoordinationType.FEATURE_VALUE_TYPE,
+    ], coordinationScopes, coordinationScopesBy, CoordinationType.SPOT_LAYER);
+    const featureSelectionCoordination = useComplexCoordination([
+        CoordinationType.FEATURE_SELECTION,
+    ], coordinationScopes, coordinationScopesBy, CoordinationType.SPOT_LAYER);
+    const matchOnObj = useMemo(() => obsFeatureMatrixCoordination[0], 
+    // imageCoordination reference changes each render,
+    // 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,
+    ]))), 
+    // Need to execute this more frequently, whenever the featureSelections update.
+    [coordinationScopes, coordinationScopesBy,
+        ...Object.values(featureSelectionCoordination[0] || {})
+            .flatMap(layerVal => layerVal.featureSelection),
+    ]);
+    const [featureData, loadedSelections, extents, normData, featureStatus,] = useFeatureSelectionMultiLevel(loaders, dataset, false, matchOnObj, selections, 1);
+    return [featureData, loadedSelections, extents, normData, featureStatus];
+}
+export function useSegmentationMultiObsFeatureMatrixIndices(coordinationScopes, coordinationScopesBy, loaders, dataset) {
+    const obsFeatureMatrixCoordination = useComplexCoordinationSecondary([
+        CoordinationType.OBS_TYPE,
+        CoordinationType.FEATURE_TYPE,
+        CoordinationType.FEATURE_VALUE_TYPE,
+    ], coordinationScopes, coordinationScopesBy, CoordinationType.SEGMENTATION_LAYER, CoordinationType.SEGMENTATION_CHANNEL);
+    const matchOnObj = useMemo(() => obsFeatureMatrixCoordination[0], 
+    // imageCoordination reference changes each render,
+    // use coordinationScopes and coordinationScopesBy which are
+    // indirect dependencies here.
+    [coordinationScopes, coordinationScopesBy]);
+    const [indicesData, indicesDataStatus] = useObsFeatureMatrixIndicesMultiLevel(loaders, dataset, false, matchOnObj, 2);
+    return [indicesData, indicesDataStatus];
+}
+export function useSpotMultiObsFeatureMatrixIndices(coordinationScopes, coordinationScopesBy, loaders, dataset) {
+    const obsFeatureMatrixCoordination = useComplexCoordination([
+        CoordinationType.OBS_TYPE,
+        CoordinationType.FEATURE_TYPE,
+        CoordinationType.FEATURE_VALUE_TYPE,
+    ], coordinationScopes, coordinationScopesBy, CoordinationType.SPOT_LAYER);
+    const matchOnObj = useMemo(() => obsFeatureMatrixCoordination[0], 
+    // imageCoordination reference changes each render,
+    // use coordinationScopes and coordinationScopesBy which are
+    // indirect dependencies here.
+    [coordinationScopes, coordinationScopesBy]);
+    const [indicesData, indicesDataStatus] = useObsFeatureMatrixIndicesMultiLevel(loaders, dataset, false, matchOnObj, 1);
+    return [indicesData, indicesDataStatus];
+}
+export function usePointMultiObsLabels(coordinationScopes, coordinationScopesBy, loaders, dataset) {
+    const obsLabelsCoordination = useComplexCoordination([
+        CoordinationType.OBS_TYPE,
+        CoordinationType.OBS_LABELS_TYPE,
+    ], coordinationScopes, coordinationScopesBy, CoordinationType.POINT_LAYER);
+    const matchOnObj = useMemo(() => obsLabelsCoordination[0], 
+    // imageCoordination reference changes each render,
+    // use coordinationScopes and coordinationScopesBy which are
+    // indirect dependencies here.
+    [coordinationScopes, coordinationScopesBy]);
+    const [indicesData, indicesDataStatus] = useObsLabelsMultiLevel(loaders, dataset, false, matchOnObj, 1);
+    return [indicesData, indicesDataStatus];
+}
+export function useSegmentationMultiObsLocations(coordinationScopes, coordinationScopesBy, loaders, dataset) {
+    const obsTypeCoordination = useComplexCoordinationSecondary([
+        CoordinationType.OBS_TYPE,
+    ], coordinationScopes, coordinationScopesBy, CoordinationType.SEGMENTATION_LAYER, CoordinationType.SEGMENTATION_CHANNEL);
+    const matchOnObj = useMemo(() => obsTypeCoordination[0], 
+    // imageCoordination reference changes each render,
+    // use coordinationScopes and coordinationScopesBy which are
+    // indirect dependencies here.
+    [coordinationScopes, coordinationScopesBy]);
+    const [indicesData, indicesDataStatus] = useObsLocationsMultiLevel(loaders, dataset, false, matchOnObj, 2);
+    return [indicesData, indicesDataStatus];
+}
+export function useSegmentationMultiObsSets(coordinationScopes, coordinationScopesBy, loaders, dataset) {
+    const obsTypeCoordination = useComplexCoordinationSecondary([
+        CoordinationType.OBS_TYPE,
+    ], coordinationScopes, coordinationScopesBy, CoordinationType.SEGMENTATION_LAYER, CoordinationType.SEGMENTATION_CHANNEL);
+    const matchOnObj = useMemo(() => obsTypeCoordination[0], 
+    // imageCoordination reference changes each render,
+    // use coordinationScopes and coordinationScopesBy which are
+    // indirect dependencies here.
+    [coordinationScopes, coordinationScopesBy]);
+    const [indicesData, indicesDataStatus] = useObsSetsMultiLevel(loaders, dataset, false, matchOnObj, 2);
+    return [indicesData, indicesDataStatus];
+}

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

@@ -30,6 +30,8 @@ export function useDescription(loaders: object, dataset: string): array;
  * number of items in the cells object.
  */
 export function useObsEmbeddingData(loaders: object, dataset: string, isRequired: boolean, coordinationSetters: object, initialCoordinationValues: object, matchOn: any): array;
+export function useObsSpotsData(loaders: any, dataset: any, isRequired: any, coordinationSetters: any, initialCoordinationValues: any, matchOn: any): array;
+export function useObsPointsData(loaders: any, dataset: any, isRequired: any, coordinationSetters: any, initialCoordinationValues: any, matchOn: any): array;
 export function useObsLocationsData(loaders: any, dataset: any, isRequired: any, coordinationSetters: any, initialCoordinationValues: any, matchOn: any): array;
 export function useObsLabelsData(loaders: any, dataset: any, isRequired: any, coordinationSetters: any, initialCoordinationValues: any, matchOn: any): array;
 export function useObsSegmentationsData(loaders: any, dataset: any, isRequired: any, coordinationSetters: any, initialCoordinationValues: any, matchOn: any): array;
@@ -69,5 +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 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[];
 //# 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":"AAkBA;;;;;;;;GAQG;AACH,wCAPW,MAAM,WAEN,MAAM,SAsBhB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,6CAhBW,MAAM,WAEN,MAAM,cAEN,OAAO,uBAEP,MAAM,6BAGN,MAAM,uBAgBhB;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,CAyElB;AAED,4GAoBC"}
+{"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"}

package/dist-tsc/data-hooks.js

@@ -2,7 +2,7 @@ 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 { getMatchingLoader, useMultiCoordinationValues, useSetWarning, } from './state/hooks.js';
+import { useMultiCoordinationValues, useComplexCoordination, useSetWarning, getMatchingLoader, } from './state/hooks.js';
 import { LoaderNotFoundError, } from './errors/index.js';
 import { warn, useDataType, useDataTypeMulti, } from './data-hook-utils.js';
 /**
@@ -54,6 +54,12 @@ export function useDescription(loaders, dataset) {
 export function useObsEmbeddingData(loaders, dataset, isRequired, coordinationSetters, initialCoordinationValues, matchOn) {
     return useDataType(DataType.OBS_EMBEDDING, loaders, dataset, isRequired, coordinationSetters, initialCoordinationValues, matchOn);
 }
+export function useObsSpotsData(loaders, dataset, isRequired, coordinationSetters, initialCoordinationValues, matchOn) {
+    return useDataType(DataType.OBS_SPOTS, loaders, dataset, isRequired, coordinationSetters, initialCoordinationValues, matchOn);
+}
+export function useObsPointsData(loaders, dataset, isRequired, coordinationSetters, initialCoordinationValues, matchOn) {
+    return useDataType(DataType.OBS_POINTS, loaders, dataset, isRequired, coordinationSetters, initialCoordinationValues, matchOn);
+}
 export function useObsLocationsData(loaders, dataset, isRequired, coordinationSetters, initialCoordinationValues, matchOn) {
     return useDataType(DataType.OBS_LOCATIONS, loaders, dataset, isRequired, coordinationSetters, initialCoordinationValues, matchOn);
 }
@@ -113,7 +119,7 @@ export function useFeatureSelection(loaders, dataset, isRequired, selection, mat
                         if (!payload)
                             return null;
                         const { data } = payload;
-                        return { data: data[0], dataKey: selection };
+                        return { data: data[0], dataKey: featureId };
                     }
                     // Loader does not implement loadGeneSelection.
                     const payload = await loader.load();
@@ -184,7 +190,9 @@ export function useObsFeatureMatrixIndices(loaders, dataset, isRequired, matchOn
         placeholderData: placeholderObject,
         // Include the hook name in the queryKey to prevent the case in which an identical queryKey
         // in a different hook would cause an accidental cache hit.
-        queryKey: [dataset, DataType.OBS_FEATURE_MATRIX, matchOn, 'useObsFeatureMatrixIndices'],
+        // Note: this uses the same key structure/suffix as
+        // getMatrixIndicesQueryKeyScopeTuplesAux for shared caching.
+        queryKey: [dataset, DataType.OBS_FEATURE_MATRIX, matchOn, isRequired, 'useObsFeatureMatrixIndices'],
         // Query function should return an object
         // { data, dataKey } where dataKey is the loaded gene selection.
         // TODO: use TypeScript to type the return value?
@@ -242,13 +250,74 @@ export function useObsFeatureMatrixIndices(loaders, dataset, isRequired, matchOn
     }, [error, setWarning]);
     return [loadedData, dataStatus, urls];
 }
+export function useMultiObsPoints(coordinationScopes, coordinationScopesBy, loaders, dataset) {
+    const obsTypeCoordination = useComplexCoordination([
+        CoordinationType.OBS_TYPE,
+    ], coordinationScopes, coordinationScopesBy, CoordinationType.POINT_LAYER);
+    const matchOnObj = useMemo(() => obsTypeCoordination[0], 
+    // imageCoordination reference changes each render,
+    // use coordinationScopes and coordinationScopesBy which are
+    // indirect dependencies here.
+    [coordinationScopes, coordinationScopesBy]);
+    const [obsPointsData, obsPointsDataStatus, obsPointsUrls] = useDataTypeMulti(DataType.OBS_POINTS, loaders, dataset, false, {}, {}, matchOnObj);
+    return [obsPointsData, obsPointsDataStatus, obsPointsUrls];
+}
+export function useMultiObsSpots(coordinationScopes, coordinationScopesBy, loaders, dataset) {
+    const obsTypeCoordination = useComplexCoordination([
+        CoordinationType.OBS_TYPE,
+    ], coordinationScopes, coordinationScopesBy, CoordinationType.SPOT_LAYER);
+    const matchOnObj = useMemo(() => obsTypeCoordination[0], 
+    // imageCoordination reference changes each render,
+    // use coordinationScopes and coordinationScopesBy which are
+    // indirect dependencies here.
+    [coordinationScopes, coordinationScopesBy]);
+    const [obsSpotsData, obsSpotsDataStatus, obsSpotsUrls] = useDataTypeMulti(DataType.OBS_SPOTS, loaders, dataset, false, {}, {}, matchOnObj);
+    return [obsSpotsData, obsSpotsDataStatus, obsSpotsUrls];
+}
+export function useSpotMultiObsSets(coordinationScopes, coordinationScopesBy, loaders, dataset) {
+    const obsTypeCoordination = useComplexCoordination([
+        CoordinationType.OBS_TYPE,
+    ], coordinationScopes, coordinationScopesBy, CoordinationType.SPOT_LAYER);
+    const matchOnObj = useMemo(() => obsTypeCoordination[0], 
+    // imageCoordination reference changes each render,
+    // use coordinationScopes and coordinationScopesBy which are
+    // indirect dependencies here.
+    [coordinationScopes, coordinationScopesBy]);
+    const [obsSetsData, obsSetsDataStatus, obsSetsUrls] = useDataTypeMulti(DataType.OBS_SETS, loaders, dataset, false, {}, {}, matchOnObj);
+    return [obsSetsData, obsSetsDataStatus, obsSetsUrls];
+}
 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]) => ([
         scope,
         { obsLabelsType, obsType },
     ]))), [obsLabelsTypes, obsType]);
-    const [obsLabelsData, obsLabelsDataStatus] = useDataTypeMulti(DataType.OBS_LABELS, loaders, dataset, false, {}, {}, obsLabelsMatchOnObj);
-    const urls = null; // TODO?
-    return [obsLabelsTypes, obsLabelsData, obsLabelsDataStatus, urls];
+    const [obsLabelsData, obsLabelsDataStatus, obsLabelsUrls] = useDataTypeMulti(DataType.OBS_LABELS, loaders, dataset, false, {}, {}, obsLabelsMatchOnObj);
+    return [obsLabelsTypes, obsLabelsData, obsLabelsDataStatus, obsLabelsUrls];
+}
+export function useMultiObsSegmentations(coordinationScopes, coordinationScopesBy, loaders, dataset) {
+    const imageCoordination = useComplexCoordination([
+        CoordinationType.FILE_UID,
+    ], coordinationScopes, coordinationScopesBy, CoordinationType.SEGMENTATION_LAYER);
+    const matchOnObj = useMemo(() => imageCoordination[0], 
+    // imageCoordination reference changes each render,
+    // use coordinationScopes and coordinationScopesBy which are
+    // indirect dependencies here.
+    [coordinationScopes, coordinationScopesBy]);
+    const [obsSegmentationsData, obsSegmentationsDataStatus, obsSegmentationsUrls,] = useDataTypeMulti(DataType.OBS_SEGMENTATIONS, loaders, dataset, false, {}, {}, matchOnObj);
+    return [obsSegmentationsData, obsSegmentationsDataStatus, obsSegmentationsUrls];
+}
+export function useMultiImages(coordinationScopes, coordinationScopesBy, loaders, dataset) {
+    // 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([
+        CoordinationType.FILE_UID,
+    ], coordinationScopes, coordinationScopesBy, CoordinationType.IMAGE_LAYER);
+    const matchOnObj = useMemo(() => imageCoordination[0], 
+    // imageCoordination reference changes each render,
+    // use coordinationScopes and coordinationScopesBy which are
+    // indirect dependencies here.
+    [coordinationScopes, coordinationScopesBy]);
+    const [imageData, imageDataStatus, imageUrls] = useDataTypeMulti(DataType.IMAGE, loaders, dataset, false, {}, {}, matchOnObj);
+    return [imageData, imageDataStatus, imageUrls];
 }

package/dist-tsc/hooks.js

@@ -125,7 +125,7 @@ export function useReady(statusValues) {
  */
 export function useUrls(urls) {
     const mergedUrls = useMemo(() => urls.filter(a => Array.isArray(a)).flat().filter((url, index, array) => {
-        const firstIndex = array.findIndex(u => u.name === url.name);
+        const firstIndex = array.findIndex(u => u && url && u.name === url.name);
         return index === firstIndex;
     }), 
     // eslint-disable-next-line react-hooks/exhaustive-deps

package/dist-tsc/index.d.ts

@@ -4,8 +4,9 @@ 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 { useInitialCoordination, useCoordination, useComplexCoordination, useMultiCoordinationValues, useMultiDatasetCoordination, useDatasetUids, useLoaders, useMatchingLoader, useViewConfigStore, useViewConfigStoreApi, useComponentHover, useSetComponentHover, useComponentViewInfo, useSetComponentViewInfo, useWarning, useSetWarning, useAuxiliaryCoordination, useComponentLayout } from "./state/hooks.js";
-export { useDescription, useImageData, useObsSetsData, useObsEmbeddingData, useFeatureSelection, useObsFeatureMatrixIndices, useMultiObsLabels, useObsLocationsData, useObsSegmentationsData, useNeighborhoodsData, useObsLabelsData, useObsFeatureMatrixData, useFeatureLabelsData, useGenomicProfilesData } from "./data-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 { 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";
 export { AbstractLoaderError, DatasetNotFoundError, LoaderNotFoundError, LoaderValidationError, DataSourceFetchError } from "./errors/index.js";
 export { CellColorEncodingOption, OptionsContainer, OptionSelect, usePlotOptionsStyles } from "./shared-plot-options/index.js";

package/dist-tsc/index.js

@@ -3,8 +3,9 @@ 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 { useInitialCoordination, useCoordination, useComplexCoordination, useMultiCoordinationValues, useMultiDatasetCoordination, useDatasetUids, useLoaders, useMatchingLoader, useViewConfigStore, useViewConfigStoreApi, useComponentHover, useSetComponentHover, useComponentViewInfo, useSetComponentViewInfo, useWarning, useSetWarning, useAuxiliaryCoordination, useComponentLayout, } from './state/hooks.js';
-export { useDescription, useImageData, useObsSetsData, useObsEmbeddingData, useFeatureSelection, useObsFeatureMatrixIndices, useMultiObsLabels, useObsLocationsData, useObsSegmentationsData, useNeighborhoodsData, useObsLabelsData, useObsFeatureMatrixData, useFeatureLabelsData, useGenomicProfilesData, } from './data-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 { 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';
 export { AbstractLoader, AbstractTwoStepLoader, LoaderResult, } from './data/index.js';
 export { AbstractLoaderError, DatasetNotFoundError, LoaderNotFoundError, LoaderValidationError, DataSourceFetchError, } from './errors/index.js';

package/dist-tsc/shared-mui/components.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"components.d.ts","sourceRoot":"","sources":["../../src/shared-mui/components.js"],"names":[],"mappings":"AAwBA,oDA2DC"}
+{"version":3,"file":"components.d.ts","sourceRoot":"","sources":["../../src/shared-mui/components.js"],"names":[],"mappings":"AAyBA,oDA+DC"}

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

@@ -1,6 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import React, { useRef } from 'react';
 import { makeStyles, Paper, Popper, IconButton, MenuList, ClickAwayListener, Fade, } from '@material-ui/core';
+import clsx from 'clsx';
 import { useVitessceContainer } from '../hooks.js';
 const useStyles = makeStyles(() => ({
     paper: {
@@ -14,7 +15,7 @@ const useStyles = makeStyles(() => ({
     },
 }));
 export function PopperMenu(props) {
-    const { buttonIcon, open, setOpen, children, buttonClassName, placement = 'bottom-end', 'aria-label': ariaLabel, } = props;
+    const { buttonIcon, open, setOpen, children, buttonClassName, placement = 'bottom-end', withPaper = true, containerClassName, 'aria-label': ariaLabel, } = props;
     const classes = useStyles();
     const anchorRef = useRef();
     const handleClick = () => {
@@ -25,5 +26,5 @@ export function PopperMenu(props) {
     };
     const id = open ? 'v-popover-menu' : undefined;
     const getTooltipContainer = useVitessceContainer(anchorRef);
-    return (_jsxs("div", { ref: anchorRef, className: classes.container, children: [_jsx(IconButton, { "aria-describedby": id, onClick: handleClick, onTouchEnd: handleClick, size: "small", className: buttonClassName, "aria-label": ariaLabel, children: buttonIcon }), _jsx(Popper, { id: id, open: open, anchorEl: anchorRef && anchorRef.current, container: getTooltipContainer, onClose: handleClose, placement: placement, transition: true, children: ({ TransitionProps }) => (_jsx(ClickAwayListener, { onClickAway: handleClose, children: _jsx(Fade, { ...TransitionProps, timeout: 100, children: _jsx(Paper, { elevation: 4, className: classes.paper, children: _jsx(MenuList, { children: children }) }) }) })) })] }));
+    return (_jsxs("div", { ref: anchorRef, className: clsx(classes.container, containerClassName), children: [_jsx(IconButton, { "aria-describedby": id, onClick: handleClick, onTouchEnd: handleClick, size: "small", className: buttonClassName, "aria-label": ariaLabel, children: buttonIcon }), _jsx(Popper, { id: id, open: open, anchorEl: anchorRef && anchorRef.current, container: getTooltipContainer, onClose: handleClose, placement: placement, transition: true, children: ({ TransitionProps }) => (_jsx(ClickAwayListener, { onClickAway: handleClose, children: _jsx(Fade, { ...TransitionProps, timeout: 100, children: withPaper ? (_jsx(Paper, { elevation: 4, className: classes.paper, children: _jsx(MenuList, { children: children }) })) : children }) })) })] }));
 }

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

@@ -1,3 +1,35 @@
+/**
+ * Get the "computed" coordinationScopes after accounting for
+ * meta-coordination.
+ * @param {*} coordinationScopes The coordinationScopes for a view.
+ * @param {*} coordinationSpace The coordinationSpace for a config.
+ * @returns {string|undefined} The coordinationScopesBy after meta-coordination.
+ */
+export function getScopes(coordinationScopes: any, metaSpace: any): string | undefined;
+/**
+ * Get the "computed" coordinationScopesBy after accounting for
+ * meta-coordination.
+ * @param {*} coordinationScopes The coordinationScopes for a view.
+ * @param {*} coordinationScopesBy The coordinationScopesBy for a view.
+ * @param {*} coordinationSpace The coordinationSpace for a config.
+ * @returns {string|undefined} The coordinationScopesBy after meta-coordination.
+ */
+export function getScopesBy(coordinationScopes: any, coordinationScopesBy: any, metaSpaceBy: any): string | undefined;
+/**
+ * Get the matching parameter scope.
+ * @param {string} parameter A coordination type.
+ * @param {*} coordinationScopes The coordinationScopes for a view.
+ * @returns {string|undefined} The coordination scope that matches.
+ */
+export function getParameterScope(parameter: string, coordinationScopes: any): string | undefined;
+/**
+ * Get the matching parameter scope.
+ * @param {string} parameter A coordination type.
+ * @param {*} coordinationScopes The coordinationScopes for a view.
+ * @param {*} coordinationScopesBy The coordinationScopesBy for a view.
+ * @returns {string|undefined} The coordination scope that matches.
+ */
+export function getParameterScopeBy(parameter: string, byType: any, typeScope: any, coordinationScopes: any, coordinationScopesBy: any): string | undefined;
 /**
  * This hook uses the same logic as for the `values` part of
  * the useCoordination hook, with the difference that it
@@ -26,6 +58,10 @@ export function useInitialCoordination(parameters: string[], coordinationScopes:
  * prefix.
  */
 export function useCoordination(parameters: string[], coordinationScopes: object): array;
+export function useMultiCoordinationScopes(parameter: any, coordinationScopes: any): any;
+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): any;
 /**
  * Get a mapping from dataset coordination scopes to dataset UIDs.
@@ -48,6 +84,30 @@ export function useDatasetUids(coordinationScopes: object): object;
  * setter functions.
  */
 export function useComplexCoordination(parameters: string[], coordinationScopes: object, coordinationScopesBy: object, byType: string): array;
+/**
+ * Get the "computed" (i.e., after accounting for meta-coordination)
+ * value for coordinationScopes.
+ * @param {object} coordinationScopes The original coordinationScopes passed to the view.
+ * @returns {object} The coordinationScopes after filling in with meta-coordinationScopes.
+ */
+export function useCoordinationScopes(coordinationScopes: object): object;
+/**
+ * Get the "computed" (i.e., after accounting for meta-coordination)
+ * value for coordinationScopesBy.
+ * @param {object} coordinationScopes The original coordinationScopes passed to the view.
+ * @param {object} coordinationScopesBy The original coordinationScopesBy passed to the view.
+ * @returns {object} The coordinationScopesBy after filling in with meta-coordinationScopesBy.
+ */
+export function useCoordinationScopesBy(coordinationScopes: object, coordinationScopesBy: object): object;
+/**
+ * Use a second level of complex coordination.
+ * @param {string[]} parameters Array of coordination types.
+ * @param {object} coordinationScopesBy The coordinationScopesBy object from the view definition.
+ * @param {string} primaryType The first-level coordination type, such as spatialImageLayer.
+ * @param {string} secondaryType The second-level coordination type, such as spatialImageChannel.
+ * @returns The results of useComplexCoordination.
+ */
+export function useComplexCoordinationSecondary(parameters: string[], coordinationScopes: any, coordinationScopesBy: object, primaryType: string, secondaryType: string): any[];
 /**
  * Use coordination values and coordination setter functions corresponding to
  * dataset-specific coordination scopes for each coordination type.
@@ -113,21 +173,6 @@ export function getMatchingLoader(loaders: object, dataset: string, dataType: st
  * @returns The matching loader instance or `null`.
  */
 export function useMatchingLoader(loaders: object, dataset: string, dataType: string, viewCoordinationValues: object): any;
-/**
- * Find a specific loader instance for a particular dataset, data type, and view
- * coordination values (mapping from coordination types to coordination values).
- * Uses lodash/isMatch to perform matching against the file definition's
- * coordination value mapping.
- * TODO: can this function be removed?
- * @param {object} loaders The value returned by useLoaders.
- * @param {string} dataset The dataset UID.
- * @param {string} dataType The data type for the matching file.
- * @param {object} viewCoordinationValues Current coordination values
- * from the view. Match these against a subset of file definition coordination
- * values.
- * @returns The matching loader instance or `null`.
- */
-export function useMatchingLoaders(loaders: object, dataset: string, dataType: string, viewCoordinationValuesObj: any): any;
 /**
  * Obtain the view config layout array from
  * the global app state.
@@ -142,6 +187,20 @@ export function useLayout(): object[];
  * in the `useViewInfoStore` store.
  */
 export function useRemoveComponent(): Function;
+/**
+ * Obtain the component removal function from
+ * the global app state.
+ * @returns {function} The remove component function
+ * in the `useViewInfoStore` store.
+ */
+export function useRemoveImageChannelInMetaCoordinationScopes(): Function;
+/**
+ * Obtain the component removal function from
+ * the global app state.
+ * @returns {function} The remove component function
+ * in the `useViewInfoStore` store.
+ */
+export function useAddImageChannelInMetaCoordinationScopes(): Function;
 /**
  * Obtain the component prop setter function from
  * the global app state.
@@ -221,9 +280,9 @@ export function useEmitGridResize(): Function;
 export const ViewConfigProvider: ({ initialStore, createStore, children, }: {
     initialStore?: import("zustand").UseBoundStore<object, import("zustand").StoreApi<object>> | undefined;
     createStore: () => import("zustand").UseBoundStore<object, import("zustand").StoreApi<object>>;
-    children: import("../../../plugins/node_modules/@types/react/ts5.0").ReactNode;
-}) => import("../../../plugins/node_modules/@types/react/ts5.0").FunctionComponentElement<import("../../../plugins/node_modules/@types/react/ts5.0").ProviderProps<import("zustand").UseBoundStore<object, import("zustand").StoreApi<object>> | undefined>>;
-export const useViewConfigStore: import("zustand/context").UseContextStore<object>;
+    children: import("../../../plugins/node_modules/@types/react/ts5.0/index.js").ReactNode;
+}) => import("../../../plugins/node_modules/@types/react/ts5.0/index.js").FunctionComponentElement<import("../../../plugins/node_modules/@types/react/ts5.0/index.js").ProviderProps<import("zustand").UseBoundStore<object, import("zustand").StoreApi<object>> | undefined>>;
+export const useViewConfigStore: import("zustand/context.js").UseContextStore<object>;
 export const useViewConfigStoreApi: () => {
     getState: import("zustand").GetState<object>;
     setState: import("zustand").SetState<object>;
@@ -233,9 +292,9 @@ export const useViewConfigStoreApi: () => {
 export const AuxiliaryProvider: ({ initialStore, createStore, children, }: {
     initialStore?: import("zustand").UseBoundStore<object, import("zustand").StoreApi<object>> | undefined;
     createStore: () => import("zustand").UseBoundStore<object, import("zustand").StoreApi<object>>;
-    children: import("../../../plugins/node_modules/@types/react/ts5.0").ReactNode;
-}) => import("../../../plugins/node_modules/@types/react/ts5.0").FunctionComponentElement<import("../../../plugins/node_modules/@types/react/ts5.0").ProviderProps<import("zustand").UseBoundStore<object, import("zustand").StoreApi<object>> | undefined>>;
-export const useAuxiliaryStore: import("zustand/context").UseContextStore<object>;
+    children: import("../../../plugins/node_modules/@types/react/ts5.0/index.js").ReactNode;
+}) => import("../../../plugins/node_modules/@types/react/ts5.0/index.js").FunctionComponentElement<import("../../../plugins/node_modules/@types/react/ts5.0/index.js").ProviderProps<import("zustand").UseBoundStore<object, import("zustand").StoreApi<object>> | undefined>>;
+export const useAuxiliaryStore: import("zustand/context.js").UseContextStore<object>;
 export function createViewConfigStore(initialLoaders: any, initialConfig: any): Function;
 export function useComponentLayout(component: any, scopes: any, coordinationScopes: any): Object;
 export function createAuxiliaryStore(): Function;

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

@@ -1 +1 @@
-{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../src/state/hooks.js"],"names":[],"mappings":"AAyLA;;;;;;;;;GASG;AACH,mDALW,MAAM,EAAE,sBACR,MAAM,GAEJ,MAAM,CAclB;AAED;;;;;;;;;;;;;;;GAeG;AACH,4CATW,MAAM,EAAE,sBACR,MAAM,SAkChB;AAED,yFAmBC;AAED;;;;GAIG;AACH,mDAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;;;;;;;;GAaG;AACH,mDAXW,MAAM,EAAE,sBACR,MAAM,wBACN,MAAM,UAEN,MAAM,SAsEhB;AAED;;;;;;;;;;;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;;;;;;;;;;;;;GAaG;AACH,4CARW,MAAM,WACN,MAAM,YACN,MAAM,uCA4BhB;AAED;;;;;GAKG;AACH,6BAHa,MAAM,EAAE,CAKpB;AAED;;;;;GAKG;AACH,+CAEC;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;AA3pBD;;;;6PAA0D;AAC1D,mFAA0D;AAC1D;;;;;EAAgE;AAOhE;;;;6PAAwD;AACxD,kFAAwD;AAajD,yFAiDJ;AAOI,0FAFM,MAAM,CAOlB;AAcM,iDAUJ"}
+{"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,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,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"}