@vitessce/vit-s 3.0.0 → 3.0.1

package/dist-tsc/data-hooks.js

@@ -1,7 +1,8 @@
 import { useState, useEffect, useMemo } from 'react';
 import { CoordinationType, DataType, STATUS } from '@vitessce/constants-internal';
 import { fromEntries } from '@vitessce/utils';
-import { useMatchingLoader, useMultiCoordinationValues, useSetWarning } from './state/hooks.js';
+import { useQuery, useQueries } from '@tanstack/react-query';
+import { getMatchingLoader, useMultiCoordinationValues, useSetWarning, } from './state/hooks.js';
 import { LoaderNotFoundError, } from './errors/index.js';
 import { warn, useDataType, useDataTypeMulti, } from './data-hook-utils.js';
 /**
@@ -38,8 +39,6 @@ export function useDescription(loaders, dataset) {
  * datasets and data types to loader instances.
  * @param {string} dataset The key for a dataset,
  * used to identify which loader to use.
- * @param {function} addUrl A function to call to update
- * the URL list.
  * @param {boolean} isRequired Should a warning be thrown if
  * loading is unsuccessful?
  * @param {object} coordinationSetters Object where
@@ -52,35 +51,35 @@ export function useDescription(loaders, dataset) {
  * cells is an object and cellsCount is the
  * number of items in the cells object.
  */
-export function useObsEmbeddingData(loaders, dataset, addUrl, isRequired, coordinationSetters, initialCoordinationValues, matchOn) {
-    return useDataType(DataType.OBS_EMBEDDING, loaders, dataset, addUrl, isRequired, coordinationSetters, initialCoordinationValues, matchOn);
+export function useObsEmbeddingData(loaders, dataset, isRequired, coordinationSetters, initialCoordinationValues, matchOn) {
+    return useDataType(DataType.OBS_EMBEDDING, loaders, dataset, isRequired, coordinationSetters, initialCoordinationValues, matchOn);
 }
-export function useObsLocationsData(loaders, dataset, addUrl, isRequired, coordinationSetters, initialCoordinationValues, matchOn) {
-    return useDataType(DataType.OBS_LOCATIONS, loaders, dataset, addUrl, isRequired, coordinationSetters, initialCoordinationValues, matchOn);
+export function useObsLocationsData(loaders, dataset, isRequired, coordinationSetters, initialCoordinationValues, matchOn) {
+    return useDataType(DataType.OBS_LOCATIONS, loaders, dataset, isRequired, coordinationSetters, initialCoordinationValues, matchOn);
 }
-export function useObsLabelsData(loaders, dataset, addUrl, isRequired, coordinationSetters, initialCoordinationValues, matchOn) {
-    return useDataType(DataType.OBS_LABELS, loaders, dataset, addUrl, isRequired, coordinationSetters, initialCoordinationValues, matchOn);
+export function useObsLabelsData(loaders, dataset, isRequired, coordinationSetters, initialCoordinationValues, matchOn) {
+    return useDataType(DataType.OBS_LABELS, loaders, dataset, isRequired, coordinationSetters, initialCoordinationValues, matchOn);
 }
-export function useObsSegmentationsData(loaders, dataset, addUrl, isRequired, coordinationSetters, initialCoordinationValues, matchOn) {
-    return useDataType(DataType.OBS_SEGMENTATIONS, loaders, dataset, addUrl, isRequired, coordinationSetters, initialCoordinationValues, matchOn);
+export function useObsSegmentationsData(loaders, dataset, isRequired, coordinationSetters, initialCoordinationValues, matchOn) {
+    return useDataType(DataType.OBS_SEGMENTATIONS, loaders, dataset, isRequired, coordinationSetters, initialCoordinationValues, matchOn);
 }
-export function useObsSetsData(loaders, dataset, addUrl, isRequired, coordinationSetters, initialCoordinationValues, matchOn) {
-    return useDataType(DataType.OBS_SETS, loaders, dataset, addUrl, isRequired, coordinationSetters, initialCoordinationValues, matchOn);
+export function useObsSetsData(loaders, dataset, isRequired, coordinationSetters, initialCoordinationValues, matchOn) {
+    return useDataType(DataType.OBS_SETS, loaders, dataset, isRequired, coordinationSetters, initialCoordinationValues, matchOn);
 }
-export function useObsFeatureMatrixData(loaders, dataset, addUrl, isRequired, coordinationSetters, initialCoordinationValues, matchOn) {
-    return useDataType(DataType.OBS_FEATURE_MATRIX, loaders, dataset, addUrl, isRequired, coordinationSetters, initialCoordinationValues, matchOn);
+export function useObsFeatureMatrixData(loaders, dataset, isRequired, coordinationSetters, initialCoordinationValues, matchOn) {
+    return useDataType(DataType.OBS_FEATURE_MATRIX, loaders, dataset, isRequired, coordinationSetters, initialCoordinationValues, matchOn);
 }
-export function useFeatureLabelsData(loaders, dataset, addUrl, isRequired, coordinationSetters, initialCoordinationValues, matchOn) {
-    return useDataType(DataType.FEATURE_LABELS, loaders, dataset, addUrl, isRequired, coordinationSetters, initialCoordinationValues, matchOn);
+export function useFeatureLabelsData(loaders, dataset, isRequired, coordinationSetters, initialCoordinationValues, matchOn) {
+    return useDataType(DataType.FEATURE_LABELS, loaders, dataset, isRequired, coordinationSetters, initialCoordinationValues, matchOn);
 }
-export function useImageData(loaders, dataset, addUrl, isRequired, coordinationSetters, initialCoordinationValues, matchOn) {
-    return useDataType(DataType.IMAGE, loaders, dataset, addUrl, isRequired, coordinationSetters, initialCoordinationValues, matchOn);
+export function useImageData(loaders, dataset, isRequired, coordinationSetters, initialCoordinationValues, matchOn) {
+    return useDataType(DataType.IMAGE, loaders, dataset, isRequired, coordinationSetters, initialCoordinationValues, matchOn);
 }
-export function useGenomicProfilesData(loaders, dataset, addUrl, isRequired, coordinationSetters, initialCoordinationValues, matchOn) {
-    return useDataType(DataType.GENOMIC_PROFILES, loaders, dataset, addUrl, isRequired, coordinationSetters, initialCoordinationValues, matchOn);
+export function useGenomicProfilesData(loaders, dataset, isRequired, coordinationSetters, initialCoordinationValues, matchOn) {
+    return useDataType(DataType.GENOMIC_PROFILES, loaders, dataset, isRequired, coordinationSetters, initialCoordinationValues, matchOn);
 }
-export function useNeighborhoodsData(loaders, dataset, addUrl, isRequired, coordinationSetters, initialCoordinationValues, matchOn) {
-    return useDataType(DataType.NEIGHBORHOODS, loaders, dataset, addUrl, isRequired, coordinationSetters, initialCoordinationValues, matchOn);
+export function useNeighborhoodsData(loaders, dataset, isRequired, coordinationSetters, initialCoordinationValues, matchOn) {
+    return useDataType(DataType.NEIGHBORHOODS, loaders, dataset, isRequired, coordinationSetters, initialCoordinationValues, matchOn);
 }
 /**
  * Get data from the expression matrix data type loader for a given gene selection.
@@ -97,72 +96,70 @@ export function useNeighborhoodsData(loaders, dataset, addUrl, isRequired, coord
  * for however many genes are in the selection.
  */
 export function useFeatureSelection(loaders, dataset, isRequired, selection, matchOn) {
-    const [geneData, setGeneData] = useState();
-    const [status, setStatus] = useState(STATUS.LOADING);
-    const [loadedGeneName, setLoadedGeneName] = useState(null);
     const setWarning = useSetWarning();
-    const loader = useMatchingLoader(loaders, dataset, DataType.OBS_FEATURE_MATRIX, matchOn);
-    useEffect(() => {
-        if (!selection) {
-            setGeneData(null);
-            setLoadedGeneName(null);
-            setStatus(STATUS.SUCCESS);
-            return;
-        }
-        if (loader) {
-            setGeneData(null);
-            setLoadedGeneName(null);
-            setStatus(STATUS.LOADING);
-            const implementsGeneSelection = typeof loader.loadGeneSelection === 'function';
-            if (implementsGeneSelection) {
-                loader
-                    .loadGeneSelection({ selection })
-                    .catch(e => warn(e, setWarning))
-                    .then((payload) => {
-                    if (!payload)
-                        return;
-                    const { data } = payload;
-                    setGeneData(data);
-                    setStatus(STATUS.SUCCESS);
-                    setLoadedGeneName(selection);
-                });
-            }
-            else {
-                loader.load().catch(e => warn(e, setWarning)).then((payload) => {
+    const featureQueries = useQueries({
+        queries: selection?.map(featureId => ({
+            structuralSharing: false,
+            placeholderData: null,
+            queryKey: [dataset, DataType.OBS_FEATURE_MATRIX, matchOn, featureId, 'useFeatureSelection'],
+            // Query function should return an object
+            // { data, dataKey } where dataKey is the loaded gene selection.
+            queryFn: async (ctx) => {
+                const loader = getMatchingLoader(ctx.meta.loaders, ctx.queryKey[0], ctx.queryKey[1], ctx.queryKey[2]);
+                if (loader) {
+                    const implementsGeneSelection = typeof loader.loadGeneSelection === 'function';
+                    if (implementsGeneSelection) {
+                        const payload = await loader.loadGeneSelection({ selection: [featureId] });
+                        if (!payload)
+                            return null;
+                        const { data } = payload;
+                        return { data: data[0], dataKey: selection };
+                    }
+                    // Loader does not implement loadGeneSelection.
+                    const payload = await loader.load();
                     if (!payload)
-                        return;
+                        return null;
                     const { data } = payload;
                     const { obsIndex, featureIndex, obsFeatureMatrix } = data;
-                    const expressionDataForSelection = selection.map((sel) => {
-                        const geneIndex = featureIndex.indexOf(sel);
-                        const numGenes = featureIndex.length;
-                        const numCells = obsIndex.length;
-                        const expressionData = new Float32Array(numCells);
-                        for (let cellIndex = 0; cellIndex < numCells; cellIndex += 1) {
-                            expressionData[cellIndex] = obsFeatureMatrix.data[cellIndex * numGenes + geneIndex];
-                        }
-                        return expressionData;
-                    });
-                    setGeneData(expressionDataForSelection);
-                    setStatus(STATUS.SUCCESS);
-                    setLoadedGeneName(selection);
-                });
-            }
-        }
-        else {
-            setGeneData(null);
-            setLoadedGeneName(null);
-            if (isRequired) {
-                warn(new LoaderNotFoundError(loaders, dataset, DataType.OBS_FEATURE_MATRIX, matchOn), setWarning);
-                setStatus(STATUS.ERROR);
-            }
-            else {
-                setStatus(STATUS.SUCCESS);
-            }
-        }
+                    // Compute expressionData
+                    const geneIndex = featureIndex.indexOf(featureId);
+                    const numGenes = featureIndex.length;
+                    const numCells = obsIndex.length;
+                    const expressionData = new Float32Array(numCells);
+                    for (let cellIndex = 0; cellIndex < numCells; cellIndex += 1) {
+                        expressionData[cellIndex] = obsFeatureMatrix.data[cellIndex * numGenes + geneIndex];
+                    }
+                    return { data: expressionData, dataKey: featureId };
+                }
+                // No loader was found.
+                if (isRequired) {
+                    throw new LoaderNotFoundError(loaders, dataset, DataType.OBS_FEATURE_MATRIX, matchOn);
+                }
+                else {
+                    return { data: null, dataKey: null };
+                }
+            },
+            meta: { loaders },
+        })) || [],
+    });
+    const anyLoading = featureQueries.some(q => q.isFetching);
+    const anyError = featureQueries.some(q => q.isError);
+    // eslint-disable-next-line no-nested-ternary
+    const dataStatus = anyLoading ? STATUS.LOADING : (anyError ? STATUS.ERROR : STATUS.SUCCESS);
+    const isSuccess = dataStatus === STATUS.SUCCESS;
+    const geneData = isSuccess ? featureQueries.map(q => q.data?.data || null) : null;
+    const loadedGeneName = isSuccess ? featureQueries.map(q => q.data?.dataKey || null) : null;
+    useEffect(() => {
+        featureQueries
+            .map(q => q.error)
+            .filter(e => Boolean(e))
+            .forEach((error) => {
+            warn(error, setWarning);
+        });
+        // Deliberate dependency omissions: use indirect dependencies for efficiency.
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [loader, selection]);
-    return [geneData, loadedGeneName, status];
+    }, [anyError, setWarning]);
+    return [geneData, loadedGeneName, dataStatus];
 }
 /**
  * Get the attributes for the expression matrix data type loader,
@@ -174,68 +171,84 @@ export function useFeatureSelection(loaders, dataset, isRequired, selection, mat
  * datasets and data types to loader instances.
  * @param {string} dataset The key for a dataset,
  * used to identify which loader to use.
- * @param {function} addUrl A function to call to update
- * the URL list.
  * @param {boolean} isRequired Should a warning be thrown if
  * loading is unsuccessful?
  * @returns {object} [attrs] { rows, cols } object containing cell and gene names.
  */
-export function useObsFeatureMatrixIndices(loaders, dataset, addUrl, isRequired, matchOn) {
-    const [data, setData] = useState({});
-    const [status, setStatus] = useState(STATUS.LOADING);
+export function useObsFeatureMatrixIndices(loaders, dataset, isRequired, matchOn) {
     const setWarning = useSetWarning();
-    const loader = useMatchingLoader(loaders, dataset, DataType.OBS_FEATURE_MATRIX, matchOn);
-    useEffect(() => {
-        if (loader) {
-            setStatus(STATUS.LOADING);
-            const implementsLoadAttrs = typeof loader.loadAttrs === 'function';
-            if (implementsLoadAttrs) {
-                loader.loadAttrs().catch(e => warn(e, setWarning)).then((payload) => {
-                    if (!payload)
-                        return;
-                    const { data: payloadData, url } = payload;
-                    setData({
-                        obsIndex: payloadData.rows,
-                        featureIndex: payloadData.cols,
-                    });
-                    addUrl(url, DataType.OBS_FEATURE_MATRIX);
-                    setStatus(STATUS.SUCCESS);
-                });
-            }
-            else {
-                loader.load().catch(e => warn(e, setWarning)).then((payload) => {
+    const placeholderObject = useMemo(() => ({}), []);
+    const indicesQuery = useQuery({
+        // TODO: only enable once `loaders` is available?
+        structuralSharing: false,
+        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'],
+        // Query function should return an object
+        // { data, dataKey } where dataKey is the loaded gene selection.
+        // TODO: use TypeScript to type the return value?
+        queryFn: async (ctx) => {
+            const loader = getMatchingLoader(ctx.meta.loaders, ctx.queryKey[0], ctx.queryKey[1], ctx.queryKey[2]);
+            if (loader) {
+                const implementsLoadAttrs = typeof loader.loadAttrs === 'function';
+                if (implementsLoadAttrs) {
+                    // Has loadAttrs function.
+                    const payload = await loader.loadAttrs();
                     if (!payload)
-                        return;
+                        return placeholderObject;
                     const { data: payloadData, url } = payload;
-                    setData({
+                    return {
+                        data: {
+                            obsIndex: payloadData.rows,
+                            featureIndex: payloadData.cols,
+                        },
+                        urls: [{ url, name: DataType.OBS_FEATURE_MATRIX }],
+                    };
+                }
+                // No loadAttrs function.
+                const payload = await loader.load();
+                if (!payload)
+                    return placeholderObject;
+                const { data: payloadData, url } = payload;
+                return {
+                    data: {
                         obsIndex: payloadData.obsIndex,
                         featureIndex: payloadData.featureIndex,
-                    });
-                    addUrl(url, DataType.OBS_FEATURE_MATRIX);
-                    setStatus(STATUS.SUCCESS);
-                });
+                    },
+                    urls: [{ url, name: DataType.OBS_FEATURE_MATRIX }],
+                };
             }
-        }
-        else {
-            setData({});
+            // No loader was found.
             if (isRequired) {
-                warn(new LoaderNotFoundError(loaders, dataset, DataType.OBS_FEATURE_MATRIX, matchOn), setWarning);
-                setStatus(STATUS.ERROR);
+                // Status: error
+                throw new LoaderNotFoundError(loaders, dataset, DataType.OBS_FEATURE_MATRIX, matchOn);
             }
             else {
-                setStatus(STATUS.SUCCESS);
+                // Status: success
+                return { data: placeholderObject, dataKey: null };
             }
+        },
+        meta: { loaders },
+    });
+    const { data, status, isFetching, error } = indicesQuery;
+    const loadedData = data?.data || placeholderObject;
+    const dataStatus = isFetching ? STATUS.LOADING : status;
+    const urls = data?.urls;
+    useEffect(() => {
+        if (error) {
+            setWarning(error.message);
         }
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [loader]);
-    return [data, status];
+    }, [error, setWarning]);
+    return [loadedData, dataStatus, urls];
 }
-export function useMultiObsLabels(coordinationScopes, obsType, loaders, dataset, addUrl) {
+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, addUrl, false, {}, {}, obsLabelsMatchOnObj);
-    return [obsLabelsTypes, obsLabelsData, obsLabelsDataStatus];
+    const [obsLabelsData, obsLabelsDataStatus] = useDataTypeMulti(DataType.OBS_LABELS, loaders, dataset, false, {}, {}, obsLabelsMatchOnObj);
+    const urls = null; // TODO?
+    return [obsLabelsTypes, obsLabelsData, obsLabelsDataStatus, urls];
 }

package/dist-tsc/errors/DataSourceFetchError.js

@@ -8,6 +8,6 @@ export default class DataSourceFetchError extends AbstractLoaderError {
     }
     warnInConsole() {
         const { source, url, headers } = this;
-        console.warn(`${source} failed to fetch from ${url} with headers ${headers}`);
+        console.warn(`${source} failed to fetch from ${url} with headers ${JSON.stringify(headers)}`);
     }
 }

package/dist-tsc/hooks.d.ts

@@ -28,14 +28,10 @@ export function useDeckCanvasSize(): array;
 export function useReady(statusValues: string[]): boolean;
 /**
  * This hook helps manage a list of URLs.
- * @param {object} loaders The loaders dependency.
- * @param {string} dataset The dataset UID dependency.
- * @returns {array} An array
- * [urls, addUrl]
- * where urls is the array of URL objects,
- * and addUrl is a function for adding a URL to the array.
+ * @param {(null|object[])[]} urls Array of (null or array of { url, name }).
+ * @returns {array} An array of { url, name } objects (flattened from the input).
  */
-export function useUrls(loaders: object, dataset: string): array;
+export function useUrls(urls: (null | object[])[]): array;
 /**
  * Custom hook, subscribes to the width and height of the closest .vitessce-container
  * element and updates upon window resize events.

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

@@ -1 +1 @@
-{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../src/hooks.js"],"names":[],"mappings":"AAiBA,oDAOC;AAED;;;;GAIG;AACH,6CAgBC;AAED;;;;GAIG;AACH,yCAiCC;AAED;;;;;GAKG;AACH,2CAiCC;AAED;;;;;;GAMG;AACH,uCAHW,MAAM,EAAE,GACN,OAAO,CAOnB;AAED;;;;;;;;GAQG;AACH,iCAPW,MAAM,WACN,MAAM,SAoBhB;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,SAU3B;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"}

package/dist-tsc/hooks.js

@@ -2,6 +2,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 { STATUS } from '@vitessce/constants-internal';
 import { useGridResize, useEmitGridResize } from './state/hooks.js';
 import { VITESSCE_CONTAINER } from './classNames.js';
 function getWindowDimensions() {
@@ -115,28 +116,18 @@ export function useDeckCanvasSize() {
  * @returns {boolean} Whether the status values are all success.
  */
 export function useReady(statusValues) {
-    return useMemo(() => every(statusValues, val => val === 'success'), statusValues);
+    return useMemo(() => every(statusValues, val => val !== STATUS.LOADING), statusValues);
 }
 /**
  * This hook helps manage a list of URLs.
- * @param {object} loaders The loaders dependency.
- * @param {string} dataset The dataset UID dependency.
- * @returns {array} An array
- * [urls, addUrl]
- * where urls is the array of URL objects,
- * and addUrl is a function for adding a URL to the array.
+ * @param {(null|object[])[]} urls Array of (null or array of { url, name }).
+ * @returns {array} An array of { url, name } objects (flattened from the input).
  */
-export function useUrls(loaders, dataset) {
-    const [urls, setUrls] = useState([]);
-    const addUrl = useCallback((url, name) => {
-        if (url) {
-            setUrls(prev => ([...prev, { url, name }]));
-        }
-    }, [setUrls]);
-    useEffect(() => {
-        setUrls([]);
-    }, [loaders, dataset]);
-    return [urls, addUrl];
+export function useUrls(urls) {
+    const mergedUrls = useMemo(() => urls.filter(a => Array.isArray(a)).flat(), 
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    urls);
+    return mergedUrls;
 }
 /**
  * Custom hook, subscribes to the width and height of the closest .vitessce-container

package/dist-tsc/index.d.ts

@@ -2,8 +2,9 @@ export { VitS } from "./VitS.js";
 export { TitleInfo } from "./TitleInfo.js";
 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 { useCoordination, useComplexCoordination, useMultiCoordinationValues, useMultiDatasetCoordination, useDatasetUids, useLoaders, useMatchingLoader, useViewConfigStore, useViewConfigStoreApi, useComponentHover, useSetComponentHover, useComponentViewInfo, useSetComponentViewInfo, useWarning, useSetWarning, useAuxiliaryCoordination, useComponentLayout } from "./state/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 { AbstractLoader, AbstractTwoStepLoader, LoaderResult } from "./data/index.js";
 export { AbstractLoaderError, DatasetNotFoundError, LoaderNotFoundError, LoaderValidationError, DataSourceFetchError } from "./errors/index.js";

package/dist-tsc/index.js

@@ -3,9 +3,10 @@ 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 { useCoordination, useComplexCoordination, useMultiCoordinationValues, useMultiDatasetCoordination, useDatasetUids, useLoaders, useMatchingLoader, useViewConfigStore, useViewConfigStoreApi, useComponentHover, useSetComponentHover, useComponentViewInfo, useSetComponentViewInfo, useWarning, useSetWarning, useAuxiliaryCoordination, useComponentLayout, } from './state/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 { useHasLoader, } from './data-hook-utils.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';
+export { logConfig } from './view-config-utils.js';

package/dist-tsc/mui-utils.d.ts

@@ -0,0 +1,2 @@
+export function createGenerateClassName(customPrefix: any): (rule: any, styleSheet: any) => string;
+//# sourceMappingURL=mui-utils.d.ts.map

package/dist-tsc/mui-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mui-utils.d.ts","sourceRoot":"","sources":["../src/mui-utils.js"],"names":[],"mappings":"AAyBA,mGA0BC"}

package/dist-tsc/mui-utils.js

@@ -0,0 +1,44 @@
+// This function has been copied from MUI v4
+// with logic related to randomness / random numbers removed.
+// Reference: https://github.com/mui/material-ui/blob/0adada09/packages/mui-styles/src/createGenerateClassName/createGenerateClassName.js#L29
+/**
+ * This is the list of the style rule name we use as drop in replacement for the built-in
+ * pseudo classes (:checked, :disabled, :focused, etc.).
+ *
+ * Why do they exist in the first place?
+ * These classes are used at a specificity of 2.
+ * It allows them to override previously defined styles as well as
+ * being untouched by simple user overrides.
+ */
+const stateClasses = [
+    'checked',
+    'disabled',
+    'error',
+    'focused',
+    'focusVisible',
+    'required',
+    'expanded',
+    'selected',
+];
+const defaultPrefix = 'vit-';
+export function createGenerateClassName(customPrefix) {
+    return (rule, styleSheet) => {
+        const { name: styleSheetName, link: styleSheetLink, classNamePrefix, } = styleSheet.options;
+        const { key: ruleKey } = rule;
+        const seedPrefix = customPrefix ? `${customPrefix}-` : defaultPrefix;
+        // Is a global static MUI style?
+        if (styleSheetName && styleSheetName.indexOf('Mui') === 0 && !styleSheetLink) {
+            // We can use a shorthand class name, we never use the keys to style the components.
+            if (stateClasses.indexOf(ruleKey) !== -1) {
+                return `Mui-${ruleKey}`;
+            }
+            const prefix = `${seedPrefix}${styleSheetName}-${ruleKey}`;
+            return prefix;
+        }
+        // Help with debuggability.
+        if (classNamePrefix) {
+            return `${seedPrefix}${classNamePrefix}-${ruleKey}`;
+        }
+        return `${seedPrefix}${ruleKey}`;
+    };
+}

package/dist-tsc/shared-plot-options/OptionSelect.js

@@ -6,7 +6,7 @@ export default function OptionSelect(props) {
     const { classes: classesProp = {} } = props;
     const classes = useStyles();
     return (_jsx(Select, { native: true, disableUnderline: true, ...props, classes: {
-            root: classes.selectRoot,
+            root: classes.optionSelectRoot,
             ...classesProp,
         } }));
 }

package/dist-tsc/shared-plot-options/styles.js

@@ -41,7 +41,7 @@ export const useStyles = makeStyles(theme => ({
             fontSize: '14px',
         },
     },
-    selectRoot: {
+    optionSelectRoot: {
         padding: 0,
         height: 'auto',
     },

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

@@ -1,3 +1,14 @@
+/**
+ * This hook uses the same logic as for the `values` part of
+ * the useCoordination hook, with the difference that it
+ * gets its values from the _initial_ view config rather
+ * than the current view config.
+ * @param {string[]} parameters Array of coordination types.
+ * @param {object} coordinationScopes Mapping of coordination types
+ * to scope names.
+ * @returns {object} Object containing all coordination values.
+ */
+export function useInitialCoordination(parameters: string[], coordinationScopes: object): object;
 /**
  * The useCoordination hook returns both the
  * values and setter functions for the coordination objects
@@ -74,6 +85,20 @@ export function useAuxiliaryCoordination(parameters: string[], coordinationScope
  * in the `useViewConfigStore` store.
  */
 export function useLoaders(): object;
+/**
+ * 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.
+ * @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 getMatchingLoader(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).
@@ -93,6 +118,7 @@ export function useMatchingLoader(loaders: object, dataset: string, dataType: st
  * 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.
@@ -210,7 +236,7 @@ export const AuxiliaryProvider: ({ initialStore, createStore, children, }: {
     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>;
-export function createViewConfigStore(): Function;
+export function createViewConfigStore(initialLoaders: any, initialConfig: any): Function;
 export function useComponentLayout(component: any, scopes: any, coordinationScopes: any): Object;
 export function createAuxiliaryStore(): Function;
 //# sourceMappingURL=hooks.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../src/state/hooks.js"],"names":[],"mappings":"AAuLA;;;;;;;;;;;;;;;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;AAED;;;;;;;;;;;;GAYG;AACH,2CARW,MAAM,WACN,MAAM,YACN,MAAM,0BACN,MAAM,OAsBhB;AAED;;;;;;;;;;;;GAYG;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;AA9mBD;;;;6PAA0D;AAC1D,mFAA0D;AAC1D;;;;;EAAgE;AAOhE;;;;6PAAwD;AACxD,kFAAwD;AAajD,kDA+CJ;AAOI,0FAFM,MAAM,CAOlB;AAcM,iDAUJ"}
+{"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"}