@vitessce/vit-s 2.0.3 → 3.0.1

package/dist-tsc/data-hooks.js

@@ -0,0 +1,254 @@
+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 { 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 {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, isRequired, coordinationSetters, initialCoordinationValues, matchOn) {
+    return useDataType(DataType.OBS_EMBEDDING, 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);
+}
+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, isRequired, coordinationSetters, initialCoordinationValues, matchOn) {
+    return useDataType(DataType.OBS_SEGMENTATIONS, loaders, dataset, 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, isRequired, coordinationSetters, initialCoordinationValues, matchOn) {
+    return useDataType(DataType.OBS_FEATURE_MATRIX, loaders, dataset, 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, isRequired, coordinationSetters, initialCoordinationValues, matchOn) {
+    return useDataType(DataType.IMAGE, loaders, dataset, 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, 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.
+ * 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 setWarning = useSetWarning();
+    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 null;
+                    const { data } = payload;
+                    const { obsIndex, featureIndex, obsFeatureMatrix } = data;
+                    // 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
+    }, [anyError, setWarning]);
+    return [geneData, loadedGeneName, dataStatus];
+}
+/**
+ * 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 {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, isRequired, matchOn) {
+    const setWarning = useSetWarning();
+    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 placeholderObject;
+                    const { data: payloadData, url } = payload;
+                    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,
+                    },
+                    urls: [{ url, name: DataType.OBS_FEATURE_MATRIX }],
+                };
+            }
+            // No loader was found.
+            if (isRequired) {
+                // Status: error
+                throw new LoaderNotFoundError(loaders, dataset, DataType.OBS_FEATURE_MATRIX, matchOn);
+            }
+            else {
+                // 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);
+        }
+    }, [error, setWarning]);
+    return [loadedData, dataStatus, urls];
+}
+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];
+}

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"AbstractLoaderError.d.ts","sourceRoot":"","sources":["../../src/errors/AbstractLoaderError.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH;IACE,0BAEC;IADC,aAAsB;IAIxB,sBAEC;CACF"}

package/dist-tsc/errors/AbstractLoaderError.js

@@ -0,0 +1,13 @@
+/**
+ * A loader error ancestor class containing a default constructor
+ * and a stub for the required warnInConsole() method.
+ */
+export default class AbstractLoaderError {
+    constructor(message) {
+        this.message = message;
+    }
+    // eslint-disable-next-line class-methods-use-this
+    warnInConsole() {
+        throw new Error('The warnInConsole() method has not been implemented.');
+    }
+}

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

@@ -0,0 +1,8 @@
+export default class DataSourceFetchError extends AbstractLoaderError {
+    constructor(source: any, url: any, headers: any);
+    source: any;
+    url: any;
+    headers: any;
+}
+import AbstractLoaderError from "./AbstractLoaderError.js";
+//# sourceMappingURL=DataSourceFetchError.d.ts.map

package/dist-tsc/errors/DataSourceFetchError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DataSourceFetchError.d.ts","sourceRoot":"","sources":["../../src/errors/DataSourceFetchError.js"],"names":[],"mappings":"AAEA;IACE,iDAKC;IAHC,YAAoB;IACpB,SAAc;IACd,aAAsB;CAOzB"}

package/dist-tsc/errors/DataSourceFetchError.js

@@ -0,0 +1,13 @@
+import AbstractLoaderError from './AbstractLoaderError.js';
+export default class DataSourceFetchError extends AbstractLoaderError {
+    constructor(source, url, headers) {
+        super(`${source} Error HTTP Status fetching from ${url}`);
+        this.source = source;
+        this.url = url;
+        this.headers = headers;
+    }
+    warnInConsole() {
+        const { source, url, headers } = this;
+        console.warn(`${source} failed to fetch from ${url} with headers ${JSON.stringify(headers)}`);
+    }
+}

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

@@ -0,0 +1,6 @@
+export default class DatasetNotFoundError extends AbstractLoaderError {
+    name: string;
+    datasetUid: any;
+}
+import AbstractLoaderError from "./AbstractLoaderError.js";
+//# sourceMappingURL=DatasetNotFoundError.d.ts.map

package/dist-tsc/errors/DatasetNotFoundError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DatasetNotFoundError.d.ts","sourceRoot":"","sources":["../../src/errors/DatasetNotFoundError.js"],"names":[],"mappings":"AAEA;IAGI,aAAkC;IAElC,gBAA4B;CAe/B"}

package/dist-tsc/errors/DatasetNotFoundError.js

@@ -0,0 +1,17 @@
+import AbstractLoaderError from './AbstractLoaderError.js';
+export default class DatasetNotFoundError extends AbstractLoaderError {
+    constructor(datasetUid) {
+        super(`Error finding dataset for ${datasetUid}. Please check that at least one dataset exists in the view config.`);
+        this.name = 'DatasetNotFoundError';
+        this.datasetUid = datasetUid;
+    }
+    warnInConsole() {
+        const { datasetUid, } = this;
+        if (datasetUid) {
+            console.warn(`Unable to find dataset for ${datasetUid}`);
+        }
+        else {
+            console.warn('No dataset uid specified.');
+        }
+    }
+}

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

@@ -0,0 +1,10 @@
+export default class LoaderNotFoundError extends AbstractLoaderError {
+    constructor(loaders: any, dataset: any, fileType: any, viewCoordinationValues: any);
+    name: string;
+    loaders: any;
+    dataset: any;
+    fileType: any;
+    viewCoordinationValues: any;
+}
+import AbstractLoaderError from "./AbstractLoaderError.js";
+//# sourceMappingURL=LoaderNotFoundError.d.ts.map

package/dist-tsc/errors/LoaderNotFoundError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LoaderNotFoundError.d.ts","sourceRoot":"","sources":["../../src/errors/LoaderNotFoundError.js"],"names":[],"mappings":"AAEA;IACE,oFAQC;IANC,aAAiC;IAEjC,aAAsB;IACtB,aAAsB;IACtB,cAAwB;IACxB,4BAAoD;CAavD"}

package/dist-tsc/errors/LoaderNotFoundError.js

@@ -0,0 +1,17 @@
+import AbstractLoaderError from './AbstractLoaderError.js';
+export default class LoaderNotFoundError extends AbstractLoaderError {
+    constructor(loaders, dataset, fileType, viewCoordinationValues) {
+        super(`Error: unable to find matching ${fileType} file in dataset ${dataset}.`);
+        this.name = 'LoaderNotFoundError';
+        this.loaders = loaders;
+        this.dataset = dataset;
+        this.fileType = fileType;
+        this.viewCoordinationValues = viewCoordinationValues;
+    }
+    warnInConsole() {
+        const { loaders, viewCoordinationValues, } = this;
+        console.warn(
+        // eslint-disable-next-line prefer-template
+        `Expected to match on { ${Object.entries(viewCoordinationValues).map(([k, v]) => k + ': ' + v).join(', ')} }`, loaders);
+    }
+}

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

@@ -0,0 +1,10 @@
+export default class LoaderValidationError extends AbstractLoaderError {
+    constructor(datasetType: any, datasetFileType: any, datasetUrl: any, reason: any);
+    name: string;
+    datasetType: any;
+    datasetFileType: any;
+    datasetUrl: any;
+    reason: any;
+}
+import AbstractLoaderError from "./AbstractLoaderError.js";
+//# sourceMappingURL=LoaderValidationError.d.ts.map

package/dist-tsc/errors/LoaderValidationError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LoaderValidationError.d.ts","sourceRoot":"","sources":["../../src/errors/LoaderValidationError.js"],"names":[],"mappings":"AAEA;IACE,kFAQC;IANC,aAAmC;IAEnC,iBAA8B;IAC9B,qBAAsC;IACtC,gBAA4B;IAC5B,YAAoB;CAYvB"}

package/dist-tsc/errors/LoaderValidationError.js

@@ -0,0 +1,15 @@
+import AbstractLoaderError from './AbstractLoaderError.js';
+export default class LoaderValidationError extends AbstractLoaderError {
+    constructor(datasetType, datasetFileType, datasetUrl, reason) {
+        super(`Error while validating ${datasetType}.`);
+        this.name = 'LoaderValidationError';
+        this.datasetType = datasetType;
+        this.datasetFileType = datasetFileType;
+        this.datasetUrl = datasetUrl;
+        this.reason = reason;
+    }
+    warnInConsole() {
+        const { datasetType, datasetUrl, reason, } = this;
+        console.warn(`${datasetType} from ${datasetUrl}: validation failed`, JSON.stringify(reason, null, 2));
+    }
+}

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

@@ -0,0 +1,6 @@
+export { default as AbstractLoaderError } from "./AbstractLoaderError.js";
+export { default as LoaderValidationError } from "./LoaderValidationError.js";
+export { default as LoaderNotFoundError } from "./LoaderNotFoundError.js";
+export { default as DatasetNotFoundError } from "./DatasetNotFoundError.js";
+export { default as DataSourceFetchError } from "./DataSourceFetchError.js";
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist-tsc/errors/index.js

@@ -0,0 +1,5 @@
+export { default as AbstractLoaderError } from './AbstractLoaderError.js';
+export { default as LoaderValidationError } from './LoaderValidationError.js';
+export { default as LoaderNotFoundError } from './LoaderNotFoundError.js';
+export { default as DatasetNotFoundError } from './DatasetNotFoundError.js';
+export { default as DataSourceFetchError } from './DataSourceFetchError.js';

package/dist-tsc/hooks.d.ts

@@ -0,0 +1,76 @@
+export function useVitessceContainer(ref: any): any;
+/**
+ * Custom hook, gets the full window dimensions.
+ * @returns {array} `[width, height]` where width and height
+ * are numbers.
+ */
+export function useWindowDimensions(): array;
+/**
+ * Custom hook, subscribes to GRID_RESIZE and window resize events.
+ * @returns {array} `[width, height, containerRef]` where width and height
+ * are numbers and containerRef is a React ref.
+ */
+export function useGridItemSize(): array;
+/**
+ * Custom hook, subscribes to GRID_RESIZE and window resize events.
+ * @returns {array} `[width, height, deckRef]` where width and height
+ * are numbers and deckRef is a React ref to be used with
+ * a <DeckGL/> element (or a forwardRef to one).
+ */
+export function useDeckCanvasSize(): array;
+/**
+ * This hook handles a boolean isReady value,
+ * which only returns true once every item in the
+ * input list has been marked as "ready".
+ * @param {string[]} statusValues The items to wait on.
+ * @returns {boolean} Whether the status values are all success.
+ */
+export function useReady(statusValues: string[]): boolean;
+/**
+ * This hook helps manage a list of URLs.
+ * @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(urls: (null | object[])[]): array;
+/**
+ * Custom hook, subscribes to the width and height of the closest .vitessce-container
+ * element and updates upon window resize events.
+ * @param {Ref} ref A React ref object within the `.vitessce-container`.
+ * @returns {array} `[width, height]` where width and height
+ * are numbers.
+ */
+export function useClosestVitessceContainerSize(ref: Ref): array;
+/**
+ * Normalize an obsFeatureMatrix to a Uint8Array.
+ * @param {object} params
+ * @param {object} params.obsFeatureMatrix The obsFeatureMatrix
+ * returned by the useObsFeatureMatrix hook.
+ * @returns {array} A tuple [obsFeatureMatrix, dataExtent]
+ * where obsFeatureMatrix
+ * is a Uint8Array with the same shape as
+ * params.obsFeatureMatrix.data, and dataExtent is the
+ * [min, max] of the original data.
+ */
+export function useUint8ObsFeatureMatrix({ obsFeatureMatrix }: {
+    obsFeatureMatrix: object;
+}): array;
+/**
+ * Normalize a feature selection (data for selected
+ * columns of an obsFeatureMatrix) to a Uint8Array.
+ * @param {array|null} expressionData The expressionData
+ * returned by the useFeatureSelection hook,
+ * where each element corresponds to an
+ * array of values for a selected feature.
+ * @returns {array} A tuple [normData, extents] where
+ * normData is an array of Uint8Arrays (or null), and extents is
+ * an array of [min, max] values for each feature (or null).
+ */
+export function useUint8FeatureSelection(expressionData: array | null): array;
+export function useExpressionValueGetter({ instanceObsIndex, matrixObsIndex, expressionData }: {
+    instanceObsIndex: any;
+    matrixObsIndex: any;
+    expressionData: any;
+}): any;
+export function useGetObsMembership(obsSetsMembership: any): any;
+export function useGetObsInfo(obsType: any, obsLabelsTypes: any, obsLabelsData: any, obsSetsMembership: any): any;
+//# sourceMappingURL=hooks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../src/hooks.js"],"names":[],"mappings":"AAkBA,oDAOC;AAED;;;;GAIG;AACH,6CAgBC;AAED;;;;GAIG;AACH,yCAiCC;AAED;;;;;GAKG;AACH,2CAiCC;AAED;;;;;;GAMG;AACH,uCAHW,MAAM,EAAE,GACN,OAAO,CAOnB;AAED;;;;GAIG;AACH,8BAHW,CAAC,IAAI,GAAC,MAAM,EAAE,CAAC,EAAE,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"}