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

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

@@ -0,0 +1 @@
+{"version":3,"file":"view-config-utils.test.fixtures.d.ts","sourceRoot":"","sources":["../src/view-config-utils.test.fixtures.js"],"names":[],"mappings":""}

package/{dist → dist-tsc}/view-config-utils.test.fixtures.js

@@ -763,3 +763,121 @@ export const initializedViewConfig = {
         },
     ],
 };
+export const implicitPerDatasetCoordinations = {
+    version: '1.0.9',
+    name: 'Per-dataset coordinations',
+    description: 'My config description',
+    initStrategy: 'auto',
+    coordinationSpace: {
+        dataset: {
+            A: 'first',
+            B: 'second',
+        },
+        embeddingCellRadius: {
+            small: 2,
+            big: 20,
+        },
+        embeddingCellRadiusMode: {
+            all: 'manual',
+        },
+    },
+    datasets: [
+        {
+            files: [],
+            name: 'First dataset',
+            uid: 'first',
+        },
+        {
+            files: [],
+            name: 'Second dataset',
+            uid: 'second',
+        },
+    ],
+    layout: [
+        {
+            component: 'somePluginView',
+            coordinationScopes: {
+                dataset: ['A', 'B'],
+                embeddingCellRadius: { A: 'small', B: 'big' },
+                embeddingCellRadiusMode: 'all',
+            },
+            h: 4,
+            w: 5,
+            x: 0,
+            y: 2,
+        },
+        {
+            component: 'scatterplot',
+            coordinationScopes: {
+                dataset: 'A',
+                embeddingCellRadius: 'small',
+                embeddingCellRadiusMode: 'all',
+            },
+            h: 4,
+            w: 5,
+            x: 0,
+            y: 2,
+        },
+    ],
+};
+export const explicitPerDatasetCoordinations = {
+    version: '1.0.16',
+    name: 'Per-dataset coordinations',
+    description: 'My config description',
+    initStrategy: 'auto',
+    coordinationSpace: {
+        dataset: {
+            A: 'first',
+            B: 'second',
+        },
+        embeddingCellRadius: {
+            small: 2,
+            big: 20,
+        },
+        embeddingCellRadiusMode: {
+            all: 'manual',
+        },
+    },
+    datasets: [
+        {
+            files: [],
+            name: 'First dataset',
+            uid: 'first',
+        },
+        {
+            files: [],
+            name: 'Second dataset',
+            uid: 'second',
+        },
+    ],
+    layout: [
+        {
+            component: 'somePluginView',
+            coordinationScopes: {
+                dataset: ['A', 'B'],
+                embeddingCellRadiusMode: 'all',
+            },
+            coordinationScopesBy: {
+                dataset: {
+                    embeddingCellRadius: { A: 'small', B: 'big' },
+                },
+            },
+            h: 4,
+            w: 5,
+            x: 0,
+            y: 2,
+        },
+        {
+            component: 'scatterplot',
+            coordinationScopes: {
+                dataset: 'A',
+                embeddingCellRadius: 'small',
+                embeddingCellRadiusMode: 'all',
+            },
+            h: 4,
+            w: 5,
+            x: 0,
+            y: 2,
+        },
+    ],
+};

package/dist-tsc/view-config-utils.test.js

@@ -0,0 +1,209 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/* eslint-disable camelcase */
+import React from 'react';
+import { z } from '@vitessce/schemas';
+import { PluginViewType, PluginCoordinationType } from '@vitessce/plugins';
+import { getExistingScopesForCoordinationType, initialize, } from './view-config-utils.js';
+function FakeComponent(props) {
+    const { text } = props;
+    return _jsx("span", { children: text });
+}
+const jointFileTypes = [];
+const coordinationTypes = [
+    new PluginCoordinationType('dataset', null, z.string().nullable()),
+    new PluginCoordinationType('embeddingTargetX', 0, z.number()),
+    new PluginCoordinationType('embeddingTargetY', 0, z.number()),
+    new PluginCoordinationType('embeddingZoom', 3, z.number()),
+    new PluginCoordinationType('embeddingType', null, z.string().nullable()),
+];
+const viewTypes = [
+    new PluginViewType('description', FakeComponent, ['dataset']),
+    new PluginViewType('scatterplot', FakeComponent, ['dataset', 'embeddingType', 'embeddingZoom', 'embeddingTargetX', 'embeddingTargetY']),
+];
+describe('src/app/view-config-utils.js', () => {
+    describe('getExistingScopesForCoordinationType', () => {
+        it('gets all scope names for a particular coordination type', () => {
+            const config = {
+                coordinationSpace: {
+                    dataset: {
+                        A: 'my-dataset-1',
+                        B: 'my-dataset-2',
+                    },
+                },
+                layout: [
+                    {
+                        coordinationScopes: {
+                            dataset: 'A',
+                        },
+                    },
+                    {
+                        coordinationScopes: {
+                            dataset: 'C',
+                        },
+                    },
+                ],
+            };
+            expect(getExistingScopesForCoordinationType(config, 'dataset')).toEqual(['A', 'B', 'C']);
+        });
+    });
+    describe('initialize', () => {
+        it('initializes coordination space and component coordination scopes when initStrategy is auto', () => {
+            const preInitializationConfig = {
+                version: '1.0.16',
+                name: 'My config name',
+                description: 'My config description',
+                initStrategy: 'auto',
+                coordinationSpace: {
+                    embeddingTargetX: {
+                        A: 0,
+                    },
+                    embeddingTargetY: {
+                        A: 0,
+                    },
+                    embeddingType: {
+                        't-SNE': 't-SNE',
+                    },
+                },
+                datasets: [
+                    {
+                        files: [],
+                        name: 'A',
+                        uid: 'A',
+                    },
+                ],
+                layout: [
+                    {
+                        component: 'description',
+                        coordinationScopes: {},
+                        h: 2,
+                        w: 3,
+                        x: 9,
+                        y: 0,
+                    },
+                    {
+                        component: 'scatterplot',
+                        coordinationScopes: {
+                            embeddingTargetX: 'A',
+                            embeddingTargetY: 'A',
+                            embeddingType: 't-SNE',
+                        },
+                        h: 4,
+                        w: 5,
+                        x: 0,
+                        y: 2,
+                    },
+                ],
+            };
+            const initializedViewConfig = {
+                version: '1.0.16',
+                uid: 'A',
+                name: 'My config name',
+                description: 'My config description',
+                initStrategy: 'auto',
+                coordinationSpace: {
+                    dataset: {
+                        A: 'A',
+                    },
+                    embeddingTargetX: {
+                        A: 0,
+                    },
+                    embeddingTargetY: {
+                        A: 0,
+                    },
+                    embeddingType: {
+                        't-SNE': 't-SNE',
+                    },
+                    embeddingZoom: {
+                        A: 3,
+                    },
+                },
+                datasets: [
+                    {
+                        files: [],
+                        name: 'A',
+                        uid: 'A',
+                    },
+                ],
+                layout: [
+                    {
+                        component: 'description',
+                        coordinationScopes: {
+                            dataset: 'A',
+                        },
+                        h: 2,
+                        uid: 'A',
+                        w: 3,
+                        x: 9,
+                        y: 0,
+                    },
+                    {
+                        component: 'scatterplot',
+                        coordinationScopes: {
+                            dataset: 'A',
+                            embeddingTargetX: 'A',
+                            embeddingTargetY: 'A',
+                            embeddingType: 't-SNE',
+                            embeddingZoom: 'A',
+                        },
+                        h: 4,
+                        uid: 'B',
+                        w: 5,
+                        x: 0,
+                        y: 2,
+                    },
+                ],
+            };
+            expect(initialize(preInitializationConfig, jointFileTypes, coordinationTypes, viewTypes))
+                .toEqual(initializedViewConfig);
+        });
+        it('does not initialize when initStrategy is none', () => {
+            const preInitializationConfig = {
+                version: '1.0.16',
+                name: 'My config name',
+                description: 'My config description',
+                initStrategy: 'none',
+                coordinationSpace: {
+                    embeddingTargetX: {
+                        A: 0,
+                    },
+                    embeddingTargetY: {
+                        A: 0,
+                    },
+                    embeddingType: {
+                        't-SNE': 't-SNE',
+                    },
+                },
+                datasets: [
+                    {
+                        files: [],
+                        name: 'A',
+                        uid: 'A',
+                    },
+                ],
+                layout: [
+                    {
+                        component: 'description',
+                        coordinationScopes: {},
+                        h: 2,
+                        w: 3,
+                        x: 9,
+                        y: 0,
+                    },
+                    {
+                        component: 'scatterplot',
+                        coordinationScopes: {
+                            embeddingTargetX: 'A',
+                            embeddingTargetY: 'A',
+                            embeddingType: 't-SNE',
+                        },
+                        h: 4,
+                        w: 5,
+                        x: 0,
+                        y: 2,
+                    },
+                ],
+            };
+            expect(initialize(preInitializationConfig, jointFileTypes, coordinationTypes, viewTypes).coordinationSpace).toEqual(preInitializationConfig.coordinationSpace);
+        });
+    });
+});

package/dist-tsc/vitessce-grid-layout/VitessceGridLayout.d.ts

@@ -0,0 +1,8 @@
+export function VitessceGridLayout(props: any): any;
+export namespace VitessceGridLayout {
+    namespace defaultProps {
+        const padding: number;
+        const margin: number;
+    }
+}
+//# sourceMappingURL=VitessceGridLayout.d.ts.map

package/dist-tsc/vitessce-grid-layout/VitessceGridLayout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VitessceGridLayout.d.ts","sourceRoot":"","sources":["../../src/vitessce-grid-layout/VitessceGridLayout.js"],"names":[],"mappings":"AAeA,oDA8JC"}

package/{dist → dist-tsc}/vitessce-grid-layout/VitessceGridLayout.js

@@ -1,8 +1,8 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import React, { useState } from 'react';
+import React, { useState, useMemo, useCallback } from 'react';
 import { Responsive, WidthProvider } from 'react-grid-layout-with-lodash';
-import isEqual from 'lodash/isEqual';
-import { getMaxRows, resolveLayout } from './layout-utils';
+import { isEqual } from 'lodash-es';
+import { getMaxRows, resolveLayout } from './layout-utils.js';
 const ResponsiveGridLayout = WidthProvider(Responsive);
 class ResponsiveHeightGridLayout extends ResponsiveGridLayout {
     componentDidUpdate(prevProps) {
@@ -12,10 +12,21 @@ class ResponsiveHeightGridLayout extends ResponsiveGridLayout {
     }
 }
 export function VitessceGridLayout(props) {
-    const { layout, getComponent, padding, margin, draggableHandle: draggableHandleClass, onResize, onResizeStop, rowHeight, theme, height, onRemoveComponent, onLayoutChange: onLayoutChangeProp, isBounded, } = props;
+    const { layout, viewTypes, padding, margin: marginProp, draggableHandle: draggableHandleClass, onResize, onResizeStop, rowHeight, theme, height, onRemoveComponent, onLayoutChange: onLayoutChangeProp, isBounded, } = props;
+    const getComponent = useCallback((viewType) => {
+        if (Array.isArray(viewTypes)) {
+            const matchingViewType = viewTypes.find(v => v.name === viewType);
+            if (matchingViewType) {
+                return matchingViewType.component;
+            }
+        }
+        return () => null;
+    }, [viewTypes]);
     const draggableHandle = `.${draggableHandleClass}`;
     // If layout changes, update grid components.
-    const { cols: gridCols, layouts: gridLayouts, breakpoints: gridBreakpoints, components: gridComponents, } = resolveLayout(layout);
+    const { cols: gridCols, layouts: gridLayouts, breakpoints: gridBreakpoints, components: gridComponents, } = useMemo(() => resolveLayout(layout), [layout]);
+    const containerPadding = useMemo(() => ([padding, padding]), [padding]);
+    const margin = useMemo(() => ([marginProp, marginProp]), [marginProp]);
     const maxRows = getMaxRows(gridLayouts);
     // Inline CSS is generally avoided, but this saves the end-user a little work,
     // and prevents class names from getting out of sync.
@@ -34,15 +45,15 @@ export function VitessceGridLayout(props) {
     //
     // Additionally, react-grid-layout doesn't revert if you don't save a new/changed layouts. If you
     // wish to do this, first you have to save the new layouts and render the grid with it, and then
-    // you can revert to the original layouts. Thus, we need one state for the current grid layouts,
+    // you can revert to the original layouts. Thus, we need one state for a temporary grid layout,
     // which gets called on every onLayoutChange. If the grid height is still valid, we then call
-    // onValidLayoutChange, otherwise we reset currentGridLayouts to lastValidGridLayouts.
+    // onValidLayoutChange, otherwise we call onValidLayoutChange with lastValidGridLayouts.
     //
     // See the following GitHub issue for more information.
     // https://github.com/react-grid-layout/react-grid-layout/issues/1104#issuecomment-827785217
-    const [currentGridLayouts, setCurrentGridLayouts] = useState(gridLayouts);
+    const [tempGridLayouts, setTempGridLayouts] = useState(null);
     const [lastValidGridLayouts, setLastValidGridLayouts] = useState(gridLayouts);
-    const onValidLayoutChange = (newLayout) => {
+    const onValidLayoutChange = useCallback((newLayout) => {
         if (newLayout.length === Object.entries(gridComponents).length) {
             const newComponentProps = {};
             newLayout.forEach((nextC) => {
@@ -64,30 +75,38 @@ export function VitessceGridLayout(props) {
                 onLayoutChangeProp(newComponentProps);
             }
         }
-    };
-    const onLayoutChange = (newLayout, allLayouts) => {
-        setCurrentGridLayouts(allLayouts);
-        if (!isBounded || getMaxRows({ ID: newLayout }) <= maxRows) {
-            onValidLayoutChange(newLayout);
-            setLastValidGridLayouts(allLayouts);
-        }
-        else {
-            setCurrentGridLayouts(lastValidGridLayouts);
-        }
-    };
-    const saveCurrentLayouts = () => {
-        setLastValidGridLayouts(currentGridLayouts);
-    };
-    const layoutChildren = Object.values(gridComponents).map((v) => {
+    }, [gridComponents, onLayoutChangeProp]);
+    const onLayoutChange = useCallback((newLayout, allLayouts) => {
+        // We first need to set the new layout to the potentially-invalid allLayouts
+        // (see comments above about react-grid-layout limitations).
+        setTempGridLayouts(allLayouts);
+        // Then we wait 50ms and validate/set the new layout.
+        setTimeout(() => {
+            if (!isBounded || getMaxRows({ ID: newLayout }) <= maxRows) {
+                // Good, new layout was valid with respect to isBounded, so set in parent.
+                onValidLayoutChange(newLayout);
+                setLastValidGridLayouts(allLayouts);
+            }
+            else {
+                // Bad, new layout was not valid with respect to isBounded.
+                onValidLayoutChange(lastValidGridLayouts);
+            }
+            setTempGridLayouts(null);
+        }, 50);
+    }, [isBounded, lastValidGridLayouts, maxRows, onValidLayoutChange]);
+    const saveCurrentLayouts = useCallback(() => {
+        setLastValidGridLayouts(gridLayouts);
+    }, [gridLayouts]);
+    const layoutChildren = useMemo(() => Object.values(gridComponents).map((v) => {
         const Component = getComponent(v.component);
         const removeGridComponent = () => {
             onRemoveComponent(v.uid);
         };
-        return (_jsx("div", { children: _jsx(Component, { ...v.props, uuid: v.uid, coordinationScopes: v.coordinationScopes, theme: theme, removeGridComponent: removeGridComponent }) }, v.uid));
-    });
-    return (currentGridLayouts && gridComponents && gridBreakpoints && gridCols) && (_jsxs(_Fragment, { children: [style, _jsx(ResponsiveHeightGridLayout, { className: "layout", cols: gridCols, layouts: currentGridLayouts, breakpoints: gridBreakpoints, height: height, rowHeight: rowHeight
+        return (_jsx("div", { children: _jsx(Component, { ...v.props, uuid: v.uid, coordinationScopes: v.coordinationScopes, coordinationScopesBy: v.coordinationScopesBy, theme: theme, removeGridComponent: removeGridComponent }) }, v.uid));
+    }), [gridComponents, getComponent, onRemoveComponent, theme]);
+    return (gridLayouts && gridComponents && gridBreakpoints && gridCols) && (_jsxs(_Fragment, { children: [style, _jsx(ResponsiveHeightGridLayout, { className: "layout", cols: gridCols, layouts: tempGridLayouts || gridLayouts, breakpoints: gridBreakpoints, height: height, rowHeight: rowHeight
                     || ((window.innerHeight - 2 * padding - (maxRows - 1) * margin)
-                        / maxRows), containerPadding: [padding, padding], margin: [margin, margin], draggableHandle: draggableHandle, onLayoutChange: onLayoutChange, isBounded: isBounded, onResizeStart: saveCurrentLayouts, onDragStart: saveCurrentLayouts, onResize: onResize, onResizeStop: onResizeStop, children: layoutChildren })] }));
+                        / maxRows), containerPadding: containerPadding, margin: margin, draggableHandle: draggableHandle, onLayoutChange: onLayoutChange, isBounded: isBounded, onResizeStart: saveCurrentLayouts, onDragStart: saveCurrentLayouts, onResize: onResize, onResizeStop: onResizeStop, children: layoutChildren })] }));
 }
 VitessceGridLayout.defaultProps = {
     padding: 10,

package/dist-tsc/vitessce-grid-layout/VitessceGridLayout.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=VitessceGridLayout.test.d.ts.map

package/dist-tsc/vitessce-grid-layout/VitessceGridLayout.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VitessceGridLayout.test.d.ts","sourceRoot":"","sources":["../../src/vitessce-grid-layout/VitessceGridLayout.test.jsx"],"names":[],"mappings":""}

package/{dist → dist-tsc}/vitessce-grid-layout/VitessceGridLayout.test.js

@@ -2,7 +2,9 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import '@testing-library/jest-dom';
 import { cleanup, render, screen } from '@testing-library/react';
 import { afterEach } from 'vitest';
-import { VitessceGridLayout } from './VitessceGridLayout';
+import React from 'react';
+import { PluginViewType } from '@vitessce/plugins';
+import { VitessceGridLayout } from './VitessceGridLayout.js';
 afterEach(() => {
     cleanup();
 });
@@ -15,16 +17,21 @@ const layoutJson = {
         600: [0, 2, 4, 8],
     },
     components: [
-        { component: 'FakeComponent',
+        {
+            component: 'FakeComponent',
             uid: 'fake',
             props: { text: 'Hello World' },
-            x: 0, y: 0, w: 2 },
+            x: 0,
+            y: 0,
+            w: 2,
+        },
     ],
 };
 describe('VitessceGridLayout.js', () => {
     describe('<VitessceGridLayout />', () => {
         it('mount() works', async () => {
-            const { container } = render(_jsx(VitessceGridLayout, { layout: layoutJson, getComponent: () => FakeComponent, draggableHandle: ".my-handle" }));
+            const viewTypes = [new PluginViewType('FakeComponent', FakeComponent, [])];
+            const { container } = render(_jsx(VitessceGridLayout, { layout: layoutJson, viewTypes: viewTypes, draggableHandle: ".my-handle" }));
             expect(await screen.findByText('Hello World'));
             expect(container.querySelectorAll('.react-grid-item span:not(.react-resizable-handle)').length).toEqual(1);
             const style = container.querySelectorAll('style');
@@ -33,7 +40,8 @@ describe('VitessceGridLayout.js', () => {
             expect(style[0].textContent).toContain('.my-handle:active {');
         });
         it('rowHeight works', () => {
-            const { container } = render(_jsx(VitessceGridLayout, { layout: layoutJson, getComponent: () => FakeComponent, draggableHandle: ".my-handle", rowHeight: 123 }));
+            const viewTypes = [new PluginViewType('FakeComponent', FakeComponent, [])];
+            const { container } = render(_jsx(VitessceGridLayout, { layout: layoutJson, viewTypes: viewTypes, draggableHandle: ".my-handle", rowHeight: 123 }));
             expect(container.querySelector('.react-grid-item').style.height).toEqual('123px');
         });
     });

package/dist-tsc/vitessce-grid-layout/index.d.ts

@@ -0,0 +1,2 @@
+export { VitessceGridLayout } from "./VitessceGridLayout.js";
+//# sourceMappingURL=index.d.ts.map

package/dist-tsc/vitessce-grid-layout/index.d.ts.map

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

package/dist-tsc/vitessce-grid-layout/index.js

@@ -0,0 +1 @@
+export { VitessceGridLayout } from './VitessceGridLayout.js';

package/dist-tsc/vitessce-grid-layout/layout-utils.d.ts

@@ -0,0 +1,15 @@
+export function makeGridLayout(colXs: any, colLayout: any): {
+    i: string;
+    y: any;
+    h: any;
+    x: any;
+    w: any;
+}[];
+export function getMaxRows(layouts: any): number;
+export function resolveLayout(layout: any): {
+    cols: {};
+    layouts: {};
+    breakpoints: {};
+    components: {};
+};
+//# sourceMappingURL=layout-utils.d.ts.map

package/dist-tsc/vitessce-grid-layout/layout-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout-utils.d.ts","sourceRoot":"","sources":["../../src/vitessce-grid-layout/layout-utils.js"],"names":[],"mappings":"AAMA;;;;;;IAYC;AAED,iDAQC;AAED;;;;;EA6CC"}

package/{dist → dist-tsc}/vitessce-grid-layout/layout-utils.js

@@ -1,4 +1,4 @@
-import range from 'lodash/range';
+import { range } from 'lodash-es';
 function sum(a) {
     return a.reduce((x, y) => x + y, 0);
 }
@@ -31,6 +31,7 @@ export function resolveLayout(layout) {
             component: def.component,
             props: def.props || {},
             coordinationScopes: def.coordinationScopes || {},
+            coordinationScopesBy: def.coordinationScopesBy || {},
         };
         positions[id] = {
             id, x: def.x, y: def.y, w: def.w, h: def.h,

package/dist-tsc/vitessce-grid-layout/layout-utils.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=layout-utils.test.d.ts.map

package/dist-tsc/vitessce-grid-layout/layout-utils.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout-utils.test.d.ts","sourceRoot":"","sources":["../../src/vitessce-grid-layout/layout-utils.test.js"],"names":[],"mappings":""}

package/{dist → dist-tsc}/vitessce-grid-layout/layout-utils.test.js

@@ -1,4 +1,4 @@
-import { makeGridLayout, getMaxRows, resolveLayout, } from './layout-utils';
+import { makeGridLayout, getMaxRows, resolveLayout, } from './layout-utils.js';
 describe('layout-utils.js', () => {
     describe('makeGridLayout', () => {
         it('applies columnXs and makes list from object', () => {
@@ -82,12 +82,14 @@ describe('layout-utils.js', () => {
                 uid: 'i0',
                 component: 'NoProps',
                 coordinationScopes: {},
+                coordinationScopesBy: {},
                 props: {},
             },
             i1: {
                 uid: 'i1',
                 component: 'HasProps',
                 coordinationScopes: {},
+                coordinationScopesBy: {},
                 props: {
                     foo: 'bar',
                 },

package/dist-tsc/vitessce-grid-utils.d.ts

@@ -0,0 +1,13 @@
+export function useRowHeight(config: any, initialRowHeight: any, height: any, margin: any, padding: any): any[];
+/**
+ * Create a mapping from dataset ID to loader objects by data type.
+ * @param {object[]} datasets The datasets array from the view config.
+ * @param {string} configDescription The top-level description in the
+ * @param {PluginFileType[]} fileTypes
+ * @param {PluginCoordinationType[]} coordinationTypes
+ * view config.
+ * @returns {object} Mapping from dataset ID to data type to loader
+ * instance.
+ */
+export function createLoaders(datasets: object[], configDescription: string, fileTypes: PluginFileType[], coordinationTypes: PluginCoordinationType[]): object;
+//# sourceMappingURL=vitessce-grid-utils.d.ts.map

package/dist-tsc/vitessce-grid-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vitessce-grid-utils.d.ts","sourceRoot":"","sources":["../src/vitessce-grid-utils.js"],"names":[],"mappings":"AA0CA,gHA6CC;AA4BD;;;;;;;;;GASG;AACH,wCARW,MAAM,EAAE,qBACR,MAAM,aACN,gBAAgB,qBAChB,wBAAwB,GAEtB,MAAM,CAiDlB"}