@vitessce/vit-s 2.0.3-beta.0 → 3.0.0

package/{dist → dist-tsc}/shared-plot-options/CellColorEncodingOption.js

@@ -1,10 +1,9 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import React from 'react';
-import TableCell from '@material-ui/core/TableCell';
-import TableRow from '@material-ui/core/TableRow';
+import { TableCell, TableRow } from '@material-ui/core';
 import { capitalize } from '@vitessce/utils';
-import OptionSelect from './OptionSelect';
-import { useStyles } from './styles';
+import OptionSelect from './OptionSelect.js';
+import { useStyles } from './styles.js';
 export default function CellColorEncodingOption(props) {
     const { observationsLabel, cellColorEncoding, setCellColorEncoding, } = props;
     const classes = useStyles();

package/dist-tsc/shared-plot-options/OptionSelect.d.ts

@@ -0,0 +1,2 @@
+export default function OptionSelect(props: any): JSX.Element;
+//# sourceMappingURL=OptionSelect.d.ts.map

package/dist-tsc/shared-plot-options/OptionSelect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OptionSelect.d.ts","sourceRoot":"","sources":["../../src/shared-plot-options/OptionSelect.js"],"names":[],"mappings":"AAIA,8DAcC"}

package/{dist → dist-tsc}/shared-plot-options/OptionSelect.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import React from 'react';
-import Select from '@material-ui/core/Select';
-import { useStyles } from './styles';
+import { Select } from '@material-ui/core';
+import { useStyles } from './styles.js';
 export default function OptionSelect(props) {
     const { classes: classesProp = {} } = props;
     const classes = useStyles();

package/dist-tsc/shared-plot-options/OptionsContainer.d.ts

@@ -0,0 +1,2 @@
+export default function OptionsContainer(props: any): JSX.Element;
+//# sourceMappingURL=OptionsContainer.d.ts.map

package/dist-tsc/shared-plot-options/OptionsContainer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OptionsContainer.d.ts","sourceRoot":"","sources":["../../src/shared-plot-options/OptionsContainer.js"],"names":[],"mappings":"AAIA,kEAkBC"}

package/{dist → dist-tsc}/shared-plot-options/OptionsContainer.js

@@ -1,10 +1,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import React from 'react';
-import Box from '@material-ui/core/Box';
-import Table from '@material-ui/core/Table';
-import TableBody from '@material-ui/core/TableBody';
-import TableContainer from '@material-ui/core/TableContainer';
-import { useStyles } from './styles';
+import { Box, Table, TableBody, TableContainer } from '@material-ui/core';
+import { useStyles } from './styles.js';
 export default function OptionsContainer(props) {
     const { children, } = props;
     const classes = useStyles();

package/dist-tsc/shared-plot-options/index.d.ts

@@ -0,0 +1,5 @@
+export { default as CellColorEncodingOption } from "./CellColorEncodingOption.js";
+export { default as OptionsContainer } from "./OptionsContainer.js";
+export { default as OptionSelect } from "./OptionSelect.js";
+export { useStyles as usePlotOptionsStyles } from "./styles.js";
+//# sourceMappingURL=index.d.ts.map

package/dist-tsc/shared-plot-options/index.d.ts.map

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

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

@@ -0,0 +1,4 @@
+export { default as CellColorEncodingOption } from './CellColorEncodingOption.js';
+export { default as OptionsContainer } from './OptionsContainer.js';
+export { default as OptionSelect } from './OptionSelect.js';
+export { useStyles as usePlotOptionsStyles } from './styles.js';

package/dist-tsc/shared-plot-options/styles.d.ts

@@ -0,0 +1,2 @@
+export const useStyles: (props?: any) => import("@material-ui/core/styles/withStyles").ClassNameMap<never>;
+//# sourceMappingURL=styles.d.ts.map

package/dist-tsc/shared-plot-options/styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"styles.d.ts","sourceRoot":"","sources":["../../src/shared-plot-options/styles.js"],"names":[],"mappings":"AAEA,2GA8CI"}

package/{dist → dist-tsc}/shared-plot-options/styles.js

@@ -1,4 +1,4 @@
-import { makeStyles } from '@material-ui/core/styles';
+import { makeStyles } from '@material-ui/core';
 export const useStyles = makeStyles(theme => ({
     box: {
         boxSizing: 'border-box',

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

@@ -0,0 +1,216 @@
+/**
+ * The useCoordination hook returns both the
+ * values and setter functions for the coordination objects
+ * in a particular coordination scope mapping.
+ * This hook is intended to be used within the ___Subscriber
+ * components to allow them to "hook into" only those coordination
+ * objects and setter functions of relevance.
+ * @param {string[]} parameters Array of coordination types.
+ * @param {object} coordinationScopes Mapping of coordination types
+ * to scope names.
+ * @returns {array} Returns a tuple [values, setters]
+ * where values is an object containing all coordination values,
+ * and setters is an object containing all coordination setter
+ * functions for the values in `values`, named with a "set"
+ * prefix.
+ */
+export function useCoordination(parameters: string[], coordinationScopes: object): array;
+export function useMultiCoordinationValues(parameter: any, coordinationScopes: any): any;
+/**
+ * Get a mapping from dataset coordination scopes to dataset UIDs.
+ * @param {object} coordinationScopes The coordination scope mapping object for a view.
+ * @returns {object} Mapping from dataset coordination scope names to dataset UIDs.
+ */
+export function useDatasetUids(coordinationScopes: object): object;
+/**
+ * Use coordination values and coordination setter functions corresponding to
+ * {coordinationType}-specific coordination scopes for each coordination type.
+ * @param {string[]} parameters An array of coordination types supported by a view.
+ * @param {object} coordinationScopes The coordination scope mapping object for a view.
+ * @param {object} coordinationScopesBy The per-coordinationType coordination scope
+ * mapping object for a view.
+ * @param {string} byType The {coordinationType} to use for per-{coordinationType} coordination
+ * scope mappings.
+ * @returns {array} [cValues, cSetters] where
+ * cValues is a mapping from coordination scope name to { coordinationType: coordinationValue },
+ * and cSetters is a mapping from coordination scope name to { setCoordinationType }
+ * setter functions.
+ */
+export function useComplexCoordination(parameters: string[], coordinationScopes: object, coordinationScopesBy: object, byType: string): array;
+/**
+ * Use coordination values and coordination setter functions corresponding to
+ * dataset-specific coordination scopes for each coordination type.
+ * @param {string[]} parameters An array of coordination types supported by a view.
+ * @param {object} coordinationScopes The coordination scope mapping object for a view.
+ * @param {object} coordinationScopesBy The per-coordinationType coordination scope
+ * mapping object for a view.
+ * @returns {array} [cValues, cSetters] where
+ * cValues is a mapping from coordination scope name to { coordinationType: coordinationValue },
+ * and cSetters is a mapping from coordination scope name to { setCoordinationType }
+ * setter functions.
+ */
+export function useMultiDatasetCoordination(parameters: string[], coordinationScopes: object, coordinationScopesBy: object): array;
+/**
+ * The useAuxiliaryCoordination hook returns both the
+ * values and setter functions for the auxiliary coordination objects
+ * in a particular coordination scope mapping.
+ * This hook is intended to be used within the ___Subscriber
+ * components to allow them to "hook into" only those auxiliary coordination
+ * objects and setter functions of relevance, for example "on load" callbacks.
+ * @param {string[]} parameters Array of coordination types.
+ * @param {object} coordinationScopes Mapping of coordination types
+ * to scope names.
+ * @returns {array} Returns a tuple [values, setters]
+ * where values is an object containing all coordination values,
+ * and setters is an object containing all coordination setter
+ * functions for the values in `values`, named with a "set"
+ * prefix.
+ */
+export function useAuxiliaryCoordination(parameters: string[], coordinationScopes: object): array;
+/**
+ * Obtain the loaders object from
+ * the global app state.
+ * @returns {object} The loaders object
+ * 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 useMatchingLoader(loaders: object, dataset: string, dataType: string, viewCoordinationValues: object): any;
+/**
+ * Find a specific loader instance for a particular dataset, data type, and view
+ * coordination values (mapping from coordination types to coordination values).
+ * Uses lodash/isMatch to perform matching against the file definition's
+ * coordination value mapping.
+ * @param {object} loaders The value returned by useLoaders.
+ * @param {string} dataset The dataset UID.
+ * @param {string} dataType The data type for the matching file.
+ * @param {object} viewCoordinationValues Current coordination values
+ * from the view. Match these against a subset of file definition coordination
+ * values.
+ * @returns The matching loader instance or `null`.
+ */
+export function useMatchingLoaders(loaders: object, dataset: string, dataType: string, viewCoordinationValuesObj: any): any;
+/**
+ * Obtain the view config layout array from
+ * the global app state.
+ * @returns {object[]} The layout array
+ * in the `useViewConfigStore` store.
+ */
+export function useLayout(): object[];
+/**
+ * Obtain the component removal function from
+ * the global app state.
+ * @returns {function} The remove component function
+ * in the `useViewInfoStore` store.
+ */
+export function useRemoveComponent(): Function;
+/**
+ * Obtain the component prop setter function from
+ * the global app state.
+ * @returns {function} The set component props function
+ * in the `useViewInfoStore` store.
+ */
+export function useChangeLayout(): Function;
+/**
+ * Obtain the loaders setter function from
+ * the global app state.
+ * @returns {function} The loaders setter function
+ * in the `useViewConfigStore` store.
+ */
+export function useSetLoaders(): Function;
+/**
+ * Obtain the view config setter function from
+ * the global app state.
+ * @returns {function} The view config setter function
+ * in the `useViewConfigStore` store.
+ */
+export function useSetViewConfig(viewConfigStoreApi: any): Function;
+/**
+ * Obtain the component hover value from
+ * the global app state.
+ * @returns {number} The hovered component ID
+ * in the `useHoverStore` store.
+ */
+export function useComponentHover(): number;
+/**
+ * Obtain the component hover setter function from
+ * the global app state.
+ * @returns {function} The component hover setter function
+ * in the `useHoverStore` store.
+ */
+export function useSetComponentHover(): Function;
+/**
+ * Obtain the warning message from
+ * the global app state.
+ * @returns {string} The warning message
+ * in the `useWarnStore` store.
+ */
+export function useWarning(): string;
+/**
+ * Obtain the warning setter function from
+ * the global app state.
+ * @returns {function} The warning setter function
+ * in the `useWarnStore` store.
+ */
+export function useSetWarning(): Function;
+/**
+ * Obtain the component view info value from
+ * the global app state.
+ * @returns {object} The view info object for the component
+ * in the `useViewInfoStore` store.
+ */
+export function useComponentViewInfo(uuid: any): object;
+/**
+ * Obtain the component view info setter function from
+ * the global app state.
+ * @returns {function} The component view info setter function
+ * in the `useViewInfoStore` store.
+ */
+export function useSetComponentViewInfo(uuid: any): Function;
+/**
+ * Obtain the grid resize count value
+ * from the global app state.
+ * @returns {number} The grid resize increment value.
+ */
+export function useGridResize(): number;
+/**
+ * Obtain the grid resize count increment function
+ * from the global app state.
+ * @returns {function} The grid resize count increment
+ * function.
+ */
+export function useEmitGridResize(): Function;
+export const ViewConfigProvider: ({ initialStore, createStore, children, }: {
+    initialStore?: import("zustand").UseBoundStore<object, import("zustand").StoreApi<object>> | undefined;
+    createStore: () => import("zustand").UseBoundStore<object, import("zustand").StoreApi<object>>;
+    children: import("../../../plugins/node_modules/@types/react/ts5.0").ReactNode;
+}) => import("../../../plugins/node_modules/@types/react/ts5.0").FunctionComponentElement<import("../../../plugins/node_modules/@types/react/ts5.0").ProviderProps<import("zustand").UseBoundStore<object, import("zustand").StoreApi<object>> | undefined>>;
+export const useViewConfigStore: import("zustand/context").UseContextStore<object>;
+export const useViewConfigStoreApi: () => {
+    getState: import("zustand").GetState<object>;
+    setState: import("zustand").SetState<object>;
+    subscribe: import("zustand").Subscribe<object>;
+    destroy: import("zustand").Destroy;
+};
+export const AuxiliaryProvider: ({ initialStore, createStore, children, }: {
+    initialStore?: import("zustand").UseBoundStore<object, import("zustand").StoreApi<object>> | undefined;
+    createStore: () => import("zustand").UseBoundStore<object, import("zustand").StoreApi<object>>;
+    children: import("../../../plugins/node_modules/@types/react/ts5.0").ReactNode;
+}) => import("../../../plugins/node_modules/@types/react/ts5.0").FunctionComponentElement<import("../../../plugins/node_modules/@types/react/ts5.0").ProviderProps<import("zustand").UseBoundStore<object, import("zustand").StoreApi<object>> | undefined>>;
+export const useAuxiliaryStore: import("zustand/context").UseContextStore<object>;
+export function createViewConfigStore(): 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

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

package/{dist → dist-tsc}/state/hooks.js

@@ -1,8 +1,9 @@
+/* eslint-disable react-refresh/only-export-components */
 import { useRef, useCallback, useMemo } from 'react';
 import create from 'zustand';
 import createContext from 'zustand/context';
 import shallow from 'zustand/shallow';
-import isMatch from 'lodash/isMatch';
+import { isMatch } from 'lodash-es';
 import { CoordinationType } from '@vitessce/constants-internal';
 import { fromEntries, capitalize } from '@vitessce/utils';
 // Reference: https://github.com/pmndrs/zustand#react-context
@@ -18,7 +19,10 @@ export const useAuxiliaryStore = useAuxiliaryStoreLocal;
  * The useViewConfigStore hook is initialized via the zustand
  * create() function, which sets up both the state variables
  * and the reducer-type functions.
- * Reference: https://github.com/react-spring/zustand
+ * References:
+ * - https://github.com/react-spring/zustand
+ * - https://github.com/pmndrs/zustand/releases/tag/v3.6.0
+ * - https://github.com/pmndrs/zustand#using-subscribe-with-selector
  * @returns {function} The useStore hook.
  */
 export const createViewConfigStore = () => create(set => ({
@@ -221,35 +225,41 @@ export function useDatasetUids(coordinationScopes) {
 }
 /**
  * Use coordination values and coordination setter functions corresponding to
- * dataset-specific coordination scopes for each coordination type.
+ * {coordinationType}-specific coordination scopes for each coordination type.
  * @param {string[]} parameters An array of coordination types supported by a view.
  * @param {object} coordinationScopes The coordination scope mapping object for a view.
+ * @param {object} coordinationScopesBy The per-coordinationType coordination scope
+ * mapping object for a view.
+ * @param {string} byType The {coordinationType} to use for per-{coordinationType} coordination
+ * scope mappings.
  * @returns {array} [cValues, cSetters] where
  * cValues is a mapping from coordination scope name to { coordinationType: coordinationValue },
  * and cSetters is a mapping from coordination scope name to { setCoordinationType }
  * setter functions.
  */
-export function useMultiDatasetCoordination(parameters, coordinationScopes) {
+export function useComplexCoordination(parameters, coordinationScopes, coordinationScopesBy, byType) {
     const setCoordinationValue = useViewConfigStore(state => state.setCoordinationValue);
-    const datasetScopes = coordinationScopes[CoordinationType.DATASET];
+    const typeScopes = coordinationScopes[byType];
+    const byTypeScopes = coordinationScopesBy[byType];
     // Convert a single scope to an array of scopes to be consistent.
-    const datasetScopesArr = Array.isArray(datasetScopes) ? datasetScopes : [datasetScopes];
+    const typeScopesArr = Array.isArray(typeScopes) ? typeScopes : [typeScopes];
     const values = useViewConfigStore((state) => {
         const { coordinationSpace } = state.viewConfig;
-        return fromEntries(datasetScopesArr.map((datasetScope) => {
+        return fromEntries(typeScopesArr.map((datasetScope) => {
             const datasetValues = fromEntries(parameters.map((parameter) => {
                 if (coordinationSpace && coordinationSpace[parameter]) {
                     let value;
                     const parameterSpace = coordinationSpace[parameter];
-                    const parameterScope = coordinationScopes[parameter];
-                    if (typeof parameterScope === 'object') {
-                        value = parameterSpace[parameterScope[datasetScope]];
+                    const parameterScopeGlobal = coordinationScopes[parameter];
+                    const parameterScopeByDataset = byTypeScopes?.[parameter];
+                    if (parameterScopeByDataset && parameterScopeByDataset[datasetScope]) {
+                        value = parameterSpace[parameterScopeByDataset[datasetScope]];
                     }
-                    else if (typeof parameterScope === 'string') {
-                        value = parameterSpace[parameterScope];
+                    else if (parameterScopeGlobal) {
+                        value = parameterSpace[parameterScopeGlobal];
                     }
                     else {
-                        console.error(`coordination scope for ${parameter} must be of type string or object.`);
+                        console.error(`coordination scope for ${parameter} was not found.`);
                     }
                     return [parameter, value];
                 }
@@ -258,27 +268,28 @@ export function useMultiDatasetCoordination(parameters, coordinationScopes) {
             return [datasetScope, datasetValues];
         }));
     }, shallow);
-    const setters = useMemo(() => fromEntries(datasetScopesArr.map((datasetScope) => {
+    const setters = useMemo(() => fromEntries(typeScopesArr.map((datasetScope) => {
         const datasetSetters = fromEntries(parameters.map((parameter) => {
             const setterName = `set${capitalize(parameter)}`;
             let setterFunc;
-            const parameterScope = coordinationScopes[parameter];
-            if (typeof parameterScope === 'object') {
+            const parameterScopeGlobal = coordinationScopes[parameter];
+            const parameterScopeByDataset = byTypeScopes?.[parameter];
+            if (parameterScopeByDataset && parameterScopeByDataset[datasetScope]) {
                 setterFunc = value => setCoordinationValue({
                     parameter,
-                    scope: parameterScope[datasetScope],
+                    scope: parameterScopeByDataset[datasetScope],
                     value,
                 });
             }
-            else if (typeof parameterScope === 'string') {
+            else if (parameterScopeGlobal) {
                 setterFunc = value => setCoordinationValue({
                     parameter,
-                    scope: parameterScope,
+                    scope: parameterScopeGlobal,
                     value,
                 });
             }
             else {
-                console.error(`coordination scope for ${parameter} must be of type string or object.`);
+                console.error(`coordination scope for ${parameter} was not found.`);
             }
             return [setterName, setterFunc];
         }));
@@ -287,6 +298,21 @@ export function useMultiDatasetCoordination(parameters, coordinationScopes) {
     })), [parameters, coordinationScopes]);
     return [values, setters];
 }
+/**
+ * Use coordination values and coordination setter functions corresponding to
+ * dataset-specific coordination scopes for each coordination type.
+ * @param {string[]} parameters An array of coordination types supported by a view.
+ * @param {object} coordinationScopes The coordination scope mapping object for a view.
+ * @param {object} coordinationScopesBy The per-coordinationType coordination scope
+ * mapping object for a view.
+ * @returns {array} [cValues, cSetters] where
+ * cValues is a mapping from coordination scope name to { coordinationType: coordinationValue },
+ * and cSetters is a mapping from coordination scope name to { setCoordinationType }
+ * setter functions.
+ */
+export function useMultiDatasetCoordination(parameters, coordinationScopes, coordinationScopesBy) {
+    return useComplexCoordination(parameters, coordinationScopes, coordinationScopesBy, CoordinationType.DATASET);
+}
 const AUXILIARY_COORDINATION_TYPES_MAP = {
     spatialImageLayer: ['imageLayerCallbacks', 'areLoadingImageChannels'],
     spatialSegmentationLayer: ['segmentationLayerCallbacks', 'areLoadingSegmentationChannels'],
@@ -527,7 +553,7 @@ export function useComponentViewInfo(uuid) {
  */
 export function useSetComponentViewInfo(uuid) {
     const setViewInfoRef = useRef(useViewInfoStore.getState().setComponentViewInfo);
-    const setComponentViewInfo = viewInfo => setViewInfoRef.current(uuid, viewInfo);
+    const setComponentViewInfo = useCallback(viewInfo => setViewInfoRef.current(uuid, viewInfo), [uuid]);
     return setComponentViewInfo;
 }
 /**

package/dist-tsc/title-styles.d.ts

@@ -0,0 +1,2 @@
+export const useTitleStyles: (props?: any) => import("@material-ui/core/styles/withStyles").ClassNameMap<never>;
+//# sourceMappingURL=title-styles.d.ts.map

package/dist-tsc/title-styles.d.ts.map

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

package/dist-tsc/title-styles.js

@@ -0,0 +1,72 @@
+import { makeStyles } from '@material-ui/core';
+export const useTitleStyles = makeStyles(theme => ({
+    title: {
+        color: theme.palette.primaryForeground,
+        overflowX: 'hidden',
+        display: 'flex',
+        flexDirection: 'row',
+        flexShrink: '0',
+    },
+    titleLeft: {
+        flexShrink: '1',
+        textOverflow: 'ellipsis',
+        whiteSpace: 'nowrap',
+    },
+    titleInfo: {
+        width: '100%',
+        textOverflow: 'ellipsis',
+        whiteSpace: 'nowrap',
+        overflow: 'hidden',
+        fontSize: '80% !important',
+        opacity: '.8',
+        padding: '0 4px',
+        justifyContent: 'center',
+        lineHeight: '25px !important',
+        flexShrink: '1',
+        textAlign: 'right !important',
+    },
+    titleButtons: {
+        display: 'flex',
+        flexDirection: 'row',
+        flexGrow: '1',
+        flexShrink: '0',
+        justifyContent: 'right',
+        '& div': {
+            display: 'inline-block',
+        },
+    },
+    card: {
+        border: `1px solid ${theme.palette.cardBorder}`,
+        flex: '1 1 auto',
+        minHeight: '1px',
+        padding: '12px',
+        marginTop: '8px',
+        marginBottom: '8px',
+        position: 'relative',
+        display: 'flex',
+        flexDirection: 'column',
+        minWidth: '0',
+        wordWrap: 'break-word',
+        backgroundClip: 'border-box',
+        borderRadius: '4px',
+    },
+    noScrollCard: {
+        backgroundColor: theme.palette.secondaryBackground,
+        color: theme.palette.secondaryForeground,
+    },
+    scrollCard: {
+        backgroundColor: theme.palette.primaryBackground,
+        color: theme.palette.primaryForeground,
+        '& a': {
+            color: theme.palette.primaryForegroundActive,
+        },
+        overflowY: 'auto',
+    },
+    spatialCard: {
+        backgroundColor: theme.palette.black,
+        color: theme.palette.white,
+        '& a': {
+            color: theme.palette.white,
+        },
+    },
+}));

package/dist-tsc/view-config-utils.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Get a list of all unique scope names for a
+ * particular coordination type, which exist in
+ * a particular view config.
+ * @param {object} config A view config object.
+ * @param {string} coordinationType A coordination type,
+ * for example 'spatialZoom' or 'dataset'.
+ * @returns {string[]} Array of existing coordination scope names.
+ */
+export function getExistingScopesForCoordinationType(config: object, coordinationType: string): string[];
+/**
+ * Initialize the view config:
+ * - Fill in missing coordination objects with default values.
+ * - Fill in missing component coordination scope mappings.
+ *   based on the `initStrategy` specified in the view config.
+ * - Fill in missing view uid values.
+ * - Expand convenience file types.
+ * Should be "stable": if run on the same view config twice, the return value the second
+ * time should be identical to the return value the first time.
+ * @param {object} config The view config prop.
+ * @param {PluginJointFileType[]} jointFileTypes
+ * @param {PluginCoordinationType[]} coordinationTypes
+ * @param {PluginViewType[]} viewTypes
+ * @returns The initialized view config.
+ */
+export function initialize(config: object, jointFileTypes: PluginJointFileType[], coordinationTypes: PluginCoordinationType[], viewTypes: PluginViewType[]): {
+    uid: any;
+    layout: any;
+};
+//# sourceMappingURL=view-config-utils.d.ts.map

package/dist-tsc/view-config-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"view-config-utils.d.ts","sourceRoot":"","sources":["../src/view-config-utils.js"],"names":[],"mappings":"AAQA;;;;;;;;GAQG;AACH,6DALW,MAAM,oBACN,MAAM,GAEJ,MAAM,EAAE,CAMpB;AAyND;;;;;;;;;;;;;;GAcG;AACH,mCANW,MAAM,kBACN,qBAAqB,qBACrB,wBAAwB,aACxB,gBAAgB;;;EAY1B"}