@vitessce/vit-s 2.0.3 → 3.0.0

package/dist-tsc/data/AbstractTwoStepLoader.js

@@ -0,0 +1,7 @@
+import AbstractLoader from './AbstractLoader.js';
+export default class AbstractTwoStepLoader extends AbstractLoader {
+    constructor(dataSource, params) {
+        super(params);
+        this.dataSource = dataSource;
+    }
+}

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

@@ -0,0 +1,7 @@
+export default class LoaderResult {
+    constructor(data: any, url: any, coordinationValues?: null);
+    data: any;
+    url: any;
+    coordinationValues: any;
+}
+//# sourceMappingURL=LoaderResult.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LoaderResult.d.ts","sourceRoot":"","sources":["../../src/data/LoaderResult.js"],"names":[],"mappings":"AACA;IACE,4DAIC;IAHC,UAAgB;IAChB,SAAc;IACd,wBAA4C;CAE/C"}

package/dist-tsc/data/LoaderResult.js

@@ -0,0 +1,7 @@
+export default class LoaderResult {
+    constructor(data, url, coordinationValues = null) {
+        this.data = data;
+        this.url = url;
+        this.coordinationValues = coordinationValues;
+    }
+}

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

@@ -0,0 +1,4 @@
+export { default as AbstractLoader } from "./AbstractLoader.js";
+export { default as AbstractTwoStepLoader } from "./AbstractTwoStepLoader.js";
+export { default as LoaderResult } from "./LoaderResult.js";
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist-tsc/data/index.js

@@ -0,0 +1,3 @@
+export { default as AbstractLoader } from './AbstractLoader.js';
+export { default as AbstractTwoStepLoader } from './AbstractTwoStepLoader.js';
+export { default as LoaderResult } from './LoaderResult.js';

package/dist-tsc/data/loader-registry.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Get the data source and data loader class.
+ * @param {string} type The fileType name.
+ * @param {PluginFileType[]} fileTypes The array of file types.
+ * @returns {array} [dataSourceClass, dataLoaderClass].
+ */
+export function getSourceAndLoaderFromFileType(type: string, fileTypes: PluginFileType[]): array;
+export function getDataTypeFromFileType(type: any, fileTypes: any): any;
+//# sourceMappingURL=loader-registry.d.ts.map

package/dist-tsc/data/loader-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader-registry.d.ts","sourceRoot":"","sources":["../../src/data/loader-registry.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,qDAJW,MAAM,aACN,gBAAgB,SAc1B;AAED,wEAQC"}

package/dist-tsc/data/loader-registry.js

@@ -0,0 +1,27 @@
+/**
+ * Get the data source and data loader class.
+ * @param {string} type The fileType name.
+ * @param {PluginFileType[]} fileTypes The array of file types.
+ * @returns {array} [dataSourceClass, dataLoaderClass].
+ */
+export function getSourceAndLoaderFromFileType(type, fileTypes) {
+    if (Array.isArray(fileTypes)) {
+        const matchingFileType = fileTypes.find(ft => ft.name === type);
+        if (matchingFileType) {
+            return matchingFileType.getSourceAndLoader();
+        }
+    }
+    // Fallback to JSON.
+    // TODO(monorepo)
+    // return [JsonSource, JsonLoader];
+    return [null, null];
+}
+export function getDataTypeFromFileType(type, fileTypes) {
+    if (Array.isArray(fileTypes)) {
+        const matchingFileType = fileTypes.find(ft => ft.name === type);
+        if (matchingFileType) {
+            return matchingFileType.dataType;
+        }
+    }
+    return null;
+}

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

@@ -0,0 +1,69 @@
+/**
+ * Warn via publishing to the console
+ * and to the global warning store.
+ * @param {AbstractLoaderError} error An error instance.
+ */
+export function warn(error: AbstractLoaderError, setWarning: any): void;
+/**
+ * Initialize values in the coordination space.
+ * @param {object} values Object where
+ * keys are coordination type names,
+ * values are initial coordination values.
+ * @param {object} setters Object where
+ * keys are coordination type names with the prefix 'set',
+ * values are coordination setter functions.
+ * @param {object} initialValues Object where
+ * keys are coordination type names and keys are values.
+ */
+export function initCoordinationSpace(values: object, setters: object, initialValues: object): void;
+/**
+ * Get data from a cells data type loader,
+ * updating "ready" and URL state appropriately.
+ * Throw warnings if the data is marked as required.
+ * Subscribe to loader updates.
+ * @param {object} loaders The object mapping
+ * 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
+ * keys are coordination type names with the prefix 'set',
+ * values are coordination setter functions.
+ * @param {object} initialCoordinationValues Object where
+ * keys are coordination type names with the prefix 'initialize',
+ * values are initialization preferences as boolean values.
+ * @returns {array} [cells, cellsCount] where
+ * cells is an object and cellsCount is the
+ * number of items in the cells object.
+ */
+export function useDataType(dataType: any, loaders: object, dataset: string, addUrl: Function, isRequired: boolean, coordinationSetters: object, initialCoordinationValues: object, matchOn: any): array;
+/**
+ * Get data from a cells data type loader,
+ * updating "ready" and URL state appropriately.
+ * Throw warnings if the data is marked as required.
+ * Subscribe to loader updates.
+ * @param {object} loaders The object mapping
+ * 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
+ * keys are coordination type names with the prefix 'set',
+ * values are coordination setter functions.
+ * @param {object} initialCoordinationValues Object where
+ * keys are coordination type names with the prefix 'initialize',
+ * values are initialization preferences as boolean values.
+ * @returns {array} [cells, cellsCount] where
+ * cells is an object and cellsCount is the
+ * number of items in the cells object.
+ */
+export function useDataTypeMulti(dataType: any, loaders: object, dataset: string, addUrl: Function, isRequired: boolean, coordinationSetters: object, initialCoordinationValues: object, matchOnObj: any): array;
+export function useHasLoader(loaders: any, dataset: any, dataType: any, matchOn: any): boolean;
+import { AbstractLoaderError } from "./errors/index.js";
+//# sourceMappingURL=data-hook-utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"data-hook-utils.d.ts","sourceRoot":"","sources":["../src/data-hook-utils.js"],"names":[],"mappings":"AASA;;;;GAIG;AACH,4BAFW,mBAAmB,yBAS7B;AAED;;;;;;;;;;GAUG;AACH,8CATW,MAAM,WAGN,MAAM,iBAGN,MAAM,QAiBhB;AAGD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,oDAlBW,MAAM,WAEN,MAAM,gCAIN,OAAO,uBAEP,MAAM,6BAGN,MAAM,uBAmDhB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,yDAlBW,MAAM,WAEN,MAAM,gCAIN,OAAO,uBAEP,MAAM,6BAGN,MAAM,0BAqDhB;AAED,+FAGC"}

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

@@ -0,0 +1,173 @@
+import { useState, useEffect } from 'react';
+import { capitalize } from '@vitessce/utils';
+import { STATUS } from '@vitessce/constants-internal';
+import { useMatchingLoader, useMatchingLoaders, useSetWarning } from './state/hooks.js';
+import { AbstractLoaderError, LoaderNotFoundError, } from './errors/index.js';
+/**
+ * Warn via publishing to the console
+ * and to the global warning store.
+ * @param {AbstractLoaderError} error An error instance.
+ */
+export function warn(error, setWarning) {
+    setWarning(error.message);
+    console.warn(error.message);
+    console.error(error.stack);
+    if (error instanceof AbstractLoaderError) {
+        error.warnInConsole();
+    }
+}
+/**
+ * Initialize values in the coordination space.
+ * @param {object} values Object where
+ * keys are coordination type names,
+ * values are initial coordination values.
+ * @param {object} setters Object where
+ * keys are coordination type names with the prefix 'set',
+ * values are coordination setter functions.
+ * @param {object} initialValues Object where
+ * keys are coordination type names and keys are values.
+ */
+export function initCoordinationSpace(values, setters, initialValues) {
+    if (!values || !setters) {
+        return;
+    }
+    Object.entries(values).forEach(([coordinationType, value]) => {
+        const setterName = `set${capitalize(coordinationType)}`;
+        const setterFunc = setters[setterName];
+        const initialValue = initialValues && initialValues[coordinationType];
+        // Interpret null as "uninitialized" and therefore needing initialization.
+        const shouldInit = initialValue === null;
+        if (shouldInit && setterFunc) {
+            setterFunc(value);
+        }
+    });
+}
+/**
+ * Get data from a cells data type loader,
+ * updating "ready" and URL state appropriately.
+ * Throw warnings if the data is marked as required.
+ * Subscribe to loader updates.
+ * @param {object} loaders The object mapping
+ * 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
+ * keys are coordination type names with the prefix 'set',
+ * values are coordination setter functions.
+ * @param {object} initialCoordinationValues Object where
+ * keys are coordination type names with the prefix 'initialize',
+ * values are initialization preferences as boolean values.
+ * @returns {array} [cells, cellsCount] where
+ * cells is an object and cellsCount is the
+ * number of items in the cells object.
+ */
+export function useDataType(dataType, loaders, dataset, addUrl, isRequired, coordinationSetters, initialCoordinationValues, matchOn) {
+    const [data, setData] = useState({});
+    const [status, setStatus] = useState(STATUS.LOADING);
+    const setWarning = useSetWarning();
+    const loader = useMatchingLoader(loaders, dataset, dataType, matchOn);
+    useEffect(() => {
+        if (loader) {
+            setStatus(STATUS.LOADING);
+            loader.load().catch(e => warn(e, setWarning)).then((payload) => {
+                if (!payload)
+                    return;
+                const { data: payloadData, url, coordinationValues } = payload;
+                setData(payloadData);
+                if (Array.isArray(url)) {
+                    url.forEach(([val, name]) => {
+                        addUrl(val, name);
+                    });
+                }
+                else if (url) {
+                    addUrl(url, dataType);
+                }
+                initCoordinationSpace(coordinationValues, coordinationSetters, initialCoordinationValues);
+                setStatus(STATUS.SUCCESS);
+            });
+        }
+        else {
+            setData({});
+            if (isRequired) {
+                warn(new LoaderNotFoundError(loaders, dataset, dataType, matchOn), setWarning);
+                setStatus(STATUS.ERROR);
+            }
+            else {
+                setStatus(STATUS.SUCCESS);
+            }
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [loader]);
+    return [data, status];
+}
+/**
+ * Get data from a cells data type loader,
+ * updating "ready" and URL state appropriately.
+ * Throw warnings if the data is marked as required.
+ * Subscribe to loader updates.
+ * @param {object} loaders The object mapping
+ * 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
+ * keys are coordination type names with the prefix 'set',
+ * values are coordination setter functions.
+ * @param {object} initialCoordinationValues Object where
+ * keys are coordination type names with the prefix 'initialize',
+ * values are initialization preferences as boolean values.
+ * @returns {array} [cells, cellsCount] where
+ * cells is an object and cellsCount is the
+ * number of items in the cells object.
+ */
+export function useDataTypeMulti(dataType, loaders, dataset, addUrl, isRequired, coordinationSetters, initialCoordinationValues, matchOnObj) {
+    const [data, setData] = useState({});
+    const [status, setStatus] = useState(STATUS.LOADING);
+    const setWarning = useSetWarning();
+    const matchingLoaders = useMatchingLoaders(loaders, dataset, dataType, matchOnObj);
+    useEffect(() => {
+        if (matchingLoaders) {
+            setStatus(STATUS.LOADING);
+            Object.entries(matchingLoaders).forEach(([scopeKey, loader]) => {
+                if (loader) {
+                    loader.load().catch(e => warn(e, setWarning)).then((payload) => {
+                        if (!payload)
+                            return;
+                        const { data: payloadData, url, coordinationValues } = payload;
+                        setData((prev) => {
+                            // eslint-disable-next-line no-param-reassign
+                            prev[scopeKey] = payloadData;
+                            return prev;
+                        });
+                        addUrl(url, dataType);
+                        initCoordinationSpace(coordinationValues, coordinationSetters, initialCoordinationValues);
+                        setStatus(STATUS.SUCCESS);
+                    });
+                }
+            });
+        }
+        else {
+            setData({});
+            if (isRequired) {
+                warn(new LoaderNotFoundError(loaders, dataset, dataType, matchOnObj), setWarning);
+                setStatus(STATUS.ERROR);
+            }
+            else {
+                setStatus(STATUS.SUCCESS);
+            }
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [matchingLoaders]);
+    return [data, status];
+}
+export function useHasLoader(loaders, dataset, dataType, matchOn) {
+    const loader = useMatchingLoader(loaders, dataset, dataType, matchOn);
+    return loader !== null;
+}

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

@@ -0,0 +1,77 @@
+/**
+ * Get the dataset description string.
+ * @param {object} loaders The object mapping
+ * datasets and data types to loader instances.
+ * @param {string} dataset The key for a dataset,
+ * used to identify which loader to use.
+ * @returns {array} [description] where
+ * description is a string.
+ */
+export function useDescription(loaders: object, dataset: string): array;
+/**
+ * Get data from a cells data type loader,
+ * updating "ready" and URL state appropriately.
+ * Throw warnings if the data is marked as required.
+ * Subscribe to loader updates.
+ * @param {object} loaders The object mapping
+ * 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
+ * keys are coordination type names with the prefix 'set',
+ * values are coordination setter functions.
+ * @param {object} initialCoordinationValues Object where
+ * keys are coordination type names with the prefix 'initialize',
+ * values are initialization preferences as boolean values.
+ * @returns {array} [cells, cellsCount] where
+ * cells is an object and cellsCount is the
+ * number of items in the cells object.
+ */
+export function useObsEmbeddingData(loaders: object, dataset: string, addUrl: Function, isRequired: boolean, coordinationSetters: object, initialCoordinationValues: object, matchOn: any): array;
+export function useObsLocationsData(loaders: any, dataset: any, addUrl: any, isRequired: any, coordinationSetters: any, initialCoordinationValues: any, matchOn: any): array;
+export function useObsLabelsData(loaders: any, dataset: any, addUrl: any, isRequired: any, coordinationSetters: any, initialCoordinationValues: any, matchOn: any): array;
+export function useObsSegmentationsData(loaders: any, dataset: any, addUrl: any, isRequired: any, coordinationSetters: any, initialCoordinationValues: any, matchOn: any): array;
+export function useObsSetsData(loaders: any, dataset: any, addUrl: any, isRequired: any, coordinationSetters: any, initialCoordinationValues: any, matchOn: any): array;
+export function useObsFeatureMatrixData(loaders: any, dataset: any, addUrl: any, isRequired: any, coordinationSetters: any, initialCoordinationValues: any, matchOn: any): array;
+export function useFeatureLabelsData(loaders: any, dataset: any, addUrl: any, isRequired: any, coordinationSetters: any, initialCoordinationValues: any, matchOn: any): array;
+export function useImageData(loaders: any, dataset: any, addUrl: any, isRequired: any, coordinationSetters: any, initialCoordinationValues: any, matchOn: any): array;
+export function useGenomicProfilesData(loaders: any, dataset: any, addUrl: any, isRequired: any, coordinationSetters: any, initialCoordinationValues: any, matchOn: any): array;
+export function useNeighborhoodsData(loaders: any, dataset: any, addUrl: any, isRequired: any, coordinationSetters: any, initialCoordinationValues: any, matchOn: any): array;
+/**
+ * Get data from the expression matrix data type loader for a given gene selection.
+ * Throw warnings if the data is marked as required.
+ * Subscribe to loader updates.
+ * @param {object} loaders The object mapping
+ * datasets and data types to loader instances.
+ * @param {string} dataset The key for a dataset,
+ * used to identify which loader to use.
+ * @param {boolean} isRequired Should a warning be thrown if
+ * loading is unsuccessful?
+ * @param {boolean} selection A list of gene names to get expression data for.
+ * @returns {array} [geneData] where geneData is an array [Uint8Array, ..., Uint8Array]
+ * for however many genes are in the selection.
+ */
+export function useFeatureSelection(loaders: object, dataset: string, isRequired: boolean, selection: boolean, matchOn: any): array;
+/**
+ * Get the attributes for the expression matrix data type loader,
+ * i.e names of cells and genes.
+ * Throw warnings if the data is marked as required.
+ * Subscribe to loader updates.  Should not be used in conjunction (called in the same component)
+ * with useExpressionMatrixData.
+ * @param {object} loaders The object mapping
+ * 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: object, dataset: string, addUrl: Function, isRequired: boolean, matchOn: any): object;
+export function useMultiObsLabels(coordinationScopes: any, obsType: any, loaders: any, dataset: any, addUrl: any): any[];
+//# sourceMappingURL=data-hooks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"data-hooks.d.ts","sourceRoot":"","sources":["../src/data-hooks.js"],"names":[],"mappings":"AAaA;;;;;;;;GAQG;AACH,wCAPW,MAAM,WAEN,MAAM,SAsBhB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,6CAlBW,MAAM,WAEN,MAAM,gCAIN,OAAO,uBAEP,MAAM,6BAGN,MAAM,uBAgBhB;AAED,6KASC;AAED,0KASC;AAED,iLASC;AAED,wKASC;AAED,iLASC;AAED,8KASC;AAED,sKASC;AAED,gLASC;AAED,8KASC;AAED;;;;;;;;;;;;;GAaG;AACH,6CAVW,MAAM,WAEN,MAAM,cAEN,OAAO,aAEP,OAAO,uBA8EjB;AAED;;;;;;;;;;;;;;;GAeG;AACH,oDAVW,MAAM,WAEN,MAAM,gCAIN,OAAO,iBAEL,MAAM,CAsDlB;AAED,yHAmBC"}

package/dist-tsc/data-hooks.js

@@ -0,0 +1,241 @@
+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 { LoaderNotFoundError, } from './errors/index.js';
+import { warn, useDataType, useDataTypeMulti, } from './data-hook-utils.js';
+/**
+ * Get the dataset description string.
+ * @param {object} loaders The object mapping
+ * datasets and data types to loader instances.
+ * @param {string} dataset The key for a dataset,
+ * used to identify which loader to use.
+ * @returns {array} [description] where
+ * description is a string.
+ */
+export function useDescription(loaders, dataset) {
+    const [description, setDescription] = useState();
+    useEffect(() => {
+        if (!loaders[dataset]) {
+            return;
+        }
+        if (loaders[dataset].description) {
+            setDescription(loaders[dataset].description);
+        }
+        else {
+            setDescription(null);
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [loaders, dataset]);
+    return [description];
+}
+/**
+ * Get data from a cells data type loader,
+ * updating "ready" and URL state appropriately.
+ * Throw warnings if the data is marked as required.
+ * Subscribe to loader updates.
+ * @param {object} loaders The object mapping
+ * 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
+ * keys are coordination type names with the prefix 'set',
+ * values are coordination setter functions.
+ * @param {object} initialCoordinationValues Object where
+ * keys are coordination type names with the prefix 'initialize',
+ * values are initialization preferences as boolean values.
+ * @returns {array} [cells, cellsCount] where
+ * 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 useObsLocationsData(loaders, dataset, addUrl, isRequired, coordinationSetters, initialCoordinationValues, matchOn) {
+    return useDataType(DataType.OBS_LOCATIONS, loaders, dataset, addUrl, 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 useObsSegmentationsData(loaders, dataset, addUrl, isRequired, coordinationSetters, initialCoordinationValues, matchOn) {
+    return useDataType(DataType.OBS_SEGMENTATIONS, loaders, dataset, addUrl, 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 useObsFeatureMatrixData(loaders, dataset, addUrl, isRequired, coordinationSetters, initialCoordinationValues, matchOn) {
+    return useDataType(DataType.OBS_FEATURE_MATRIX, loaders, dataset, addUrl, 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 useImageData(loaders, dataset, addUrl, isRequired, coordinationSetters, initialCoordinationValues, matchOn) {
+    return useDataType(DataType.IMAGE, loaders, dataset, addUrl, 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 useNeighborhoodsData(loaders, dataset, addUrl, isRequired, coordinationSetters, initialCoordinationValues, matchOn) {
+    return useDataType(DataType.NEIGHBORHOODS, loaders, dataset, addUrl, isRequired, coordinationSetters, initialCoordinationValues, matchOn);
+}
+/**
+ * Get data from the expression matrix data type loader for a given gene selection.
+ * Throw warnings if the data is marked as required.
+ * Subscribe to loader updates.
+ * @param {object} loaders The object mapping
+ * datasets and data types to loader instances.
+ * @param {string} dataset The key for a dataset,
+ * used to identify which loader to use.
+ * @param {boolean} isRequired Should a warning be thrown if
+ * loading is unsuccessful?
+ * @param {boolean} selection A list of gene names to get expression data for.
+ * @returns {array} [geneData] where geneData is an array [Uint8Array, ..., Uint8Array]
+ * 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) => {
+                    if (!payload)
+                        return;
+                    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);
+            }
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [loader, selection]);
+    return [geneData, loadedGeneName, status];
+}
+/**
+ * Get the attributes for the expression matrix data type loader,
+ * i.e names of cells and genes.
+ * Throw warnings if the data is marked as required.
+ * Subscribe to loader updates.  Should not be used in conjunction (called in the same component)
+ * with useExpressionMatrixData.
+ * @param {object} loaders The object mapping
+ * 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);
+    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) => {
+                    if (!payload)
+                        return;
+                    const { data: payloadData, url } = payload;
+                    setData({
+                        obsIndex: payloadData.obsIndex,
+                        featureIndex: payloadData.featureIndex,
+                    });
+                    addUrl(url, DataType.OBS_FEATURE_MATRIX);
+                    setStatus(STATUS.SUCCESS);
+                });
+            }
+        }
+        else {
+            setData({});
+            if (isRequired) {
+                warn(new LoaderNotFoundError(loaders, dataset, DataType.OBS_FEATURE_MATRIX, matchOn), setWarning);
+                setStatus(STATUS.ERROR);
+            }
+            else {
+                setStatus(STATUS.SUCCESS);
+            }
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [loader]);
+    return [data, status];
+}
+export function useMultiObsLabels(coordinationScopes, obsType, loaders, dataset, addUrl) {
+    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];
+}

package/dist-tsc/errors/AbstractLoaderError.d.ts

@@ -0,0 +1,10 @@
+/**
+ * A loader error ancestor class containing a default constructor
+ * and a stub for the required warnInConsole() method.
+ */
+export default class AbstractLoaderError {
+    constructor(message: any);
+    message: any;
+    warnInConsole(): void;
+}
+//# sourceMappingURL=AbstractLoaderError.d.ts.map