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

package/dist/schemas/config-1.0.16.schema.test.js

@@ -0,0 +1,22 @@
+import { CoordinationType } from '@vitessce/constants-internal';
+import viewConfigSchema from './config-1.0.16.schema.json';
+describe('view config schema', () => {
+    describe('coordination types', () => {
+        it('defines schema for all valid coordination types', () => {
+            const allCoordinationTypes = Object.values(CoordinationType);
+            const inCoordinationSpace = Object.keys(viewConfigSchema.properties.coordinationSpace.properties);
+            const inCoordinationScopes = Object.keys(viewConfigSchema.definitions.components.items.properties
+                .coordinationScopes.properties);
+            expect(inCoordinationSpace).toEqual(expect.arrayContaining(allCoordinationTypes));
+            expect(inCoordinationScopes).toEqual(expect.arrayContaining(allCoordinationTypes));
+        });
+        it('defines schema for only valid coordination types (does not have extra)', () => {
+            const allCoordinationTypes = Object.values(CoordinationType);
+            const inCoordinationSpace = Object.keys(viewConfigSchema.properties.coordinationSpace.properties);
+            const inCoordinationScopes = Object.keys(viewConfigSchema.definitions.components.items.properties
+                .coordinationScopes.properties);
+            expect(allCoordinationTypes).toEqual(expect.arrayContaining(inCoordinationSpace));
+            expect(allCoordinationTypes).toEqual(expect.arrayContaining(inCoordinationScopes));
+        });
+    });
+});

package/dist/schemas/obs-sets-tabular.schema.js

@@ -0,0 +1,37 @@
+export const obsSetsTabularSchema = {
+    $schema: 'http://json-schema.org/draft-07/schema#',
+    $id: 'https://github.com/vitessce/vitessce/#obsSetsTabular',
+    title: 'Vitessce obs sets data, tabular format',
+    definitions: {
+        colorArray: {
+            type: 'array',
+            items: { type: 'integer', minimum: 0, maximum: 255 },
+            minItems: 3,
+            maxItems: 3,
+        },
+    },
+    type: 'array',
+    items: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['groupName', 'setName', 'obsId'],
+        properties: {
+            groupName: { type: 'string' },
+            setName: { type: 'string' },
+            setColor: { $ref: '#/definitions/colorArray' },
+            obsId: { type: 'string' },
+            predictionScore: {
+                oneOf: [
+                    {
+                        type: 'number',
+                        minimum: 0.0,
+                        maximum: 1.0,
+                    },
+                    {
+                        type: 'null',
+                    },
+                ],
+            },
+        },
+    },
+};

package/dist/schemas/obs-sets.schema.js

@@ -0,0 +1,194 @@
+export const obsSetsSchema = {
+    $schema: 'http://json-schema.org/draft-07/schema#',
+    $id: 'https://github.com/vitessce/vitessce/#cell-sets',
+    title: 'Vitessce obs sets data',
+    type: 'object',
+    definitions: {
+        stringArray: {
+            type: 'array',
+            items: {
+                type: 'string',
+            },
+        },
+        stringProbabilityTupleArray: {
+            type: 'array',
+            items: {
+                type: 'array',
+                additionalItems: false,
+                items: [
+                    {
+                        type: 'string',
+                    },
+                    {
+                        oneOf: [
+                            {
+                                type: 'number',
+                                minimum: 0.0,
+                                maximum: 1.0,
+                            },
+                            {
+                                type: 'null',
+                            },
+                        ],
+                    },
+                ],
+            },
+        },
+        colorArray: {
+            type: 'array',
+            items: {
+                type: 'integer',
+                minimum: 0,
+                maximum: 255,
+            },
+            minItems: 3,
+            maxItems: 3,
+        },
+        treeNodeLeaf: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['name'],
+            properties: {
+                name: {
+                    type: 'string',
+                },
+                color: {
+                    $ref: '#/definitions/colorArray',
+                },
+                set: {
+                    $ref: '#/definitions/stringArray',
+                },
+            },
+        },
+        treeNodeNonLeaf: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['name'],
+            properties: {
+                name: {
+                    type: 'string',
+                },
+                color: {
+                    $ref: '#/definitions/colorArray',
+                },
+                children: {
+                    type: 'array',
+                    items: {
+                        $ref: '#/definitions/treeNode',
+                    },
+                },
+            },
+        },
+        treeNode: {
+            oneOf: [
+                {
+                    $ref: '#/definitions/treeNodeNonLeaf',
+                },
+                {
+                    $ref: '#/definitions/treeNodeLeaf',
+                },
+            ],
+        },
+        'version0.1.2': {
+            type: 'object',
+            additionalProperties: false,
+            required: ['version', 'datatype', 'tree'],
+            properties: {
+                dataset: {
+                    type: 'string',
+                },
+                version: {
+                    type: 'string',
+                    enum: ['0.1.2'],
+                },
+                datatype: {
+                    type: 'string',
+                    enum: ['cell', 'obs'],
+                },
+                tree: {
+                    type: 'array',
+                    items: {
+                        $ref: '#/definitions/treeNodeNonLeaf',
+                    },
+                },
+            },
+        },
+        treeNodeLeafProbabilistic: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['name'],
+            properties: {
+                name: {
+                    type: 'string',
+                },
+                color: {
+                    $ref: '#/definitions/colorArray',
+                },
+                set: {
+                    $ref: '#/definitions/stringProbabilityTupleArray',
+                },
+            },
+        },
+        treeNodeNonLeafProbabilistic: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['name'],
+            properties: {
+                name: {
+                    type: 'string',
+                },
+                color: {
+                    $ref: '#/definitions/colorArray',
+                },
+                children: {
+                    type: 'array',
+                    items: {
+                        $ref: '#/definitions/treeNodeProbabilistic',
+                    },
+                },
+            },
+        },
+        treeNodeProbabilistic: {
+            oneOf: [
+                {
+                    $ref: '#/definitions/treeNodeNonLeafProbabilistic',
+                },
+                {
+                    $ref: '#/definitions/treeNodeLeafProbabilistic',
+                },
+            ],
+        },
+        'version0.1.3': {
+            type: 'object',
+            additionalProperties: false,
+            required: ['version', 'datatype', 'tree'],
+            properties: {
+                dataset: {
+                    type: 'string',
+                },
+                version: {
+                    type: 'string',
+                    enum: ['0.1.3'],
+                },
+                datatype: {
+                    type: 'string',
+                    enum: ['cell', 'obs'],
+                },
+                tree: {
+                    type: 'array',
+                    items: {
+                        $ref: '#/definitions/treeNodeNonLeafProbabilistic',
+                    },
+                },
+            },
+        },
+    },
+    oneOf: [
+        {
+            $ref: '#/definitions/version0.1.2',
+        },
+        {
+            $ref: '#/definitions/version0.1.3',
+        },
+    ],
+};

package/dist/schemas/schema.test.js

@@ -0,0 +1,46 @@
+import Ajv from 'ajv';
+/* eslint-disable import/no-dynamic-require */
+/* eslint-disable global-require */
+describe('schemas', () => {
+    [
+        'config-1.0.1',
+        'obsSets',
+        'obsSetsTabular',
+        'raster',
+    ].forEach((type) => {
+        const schemaFile = `${type}.schema.json`;
+        describe(schemaFile, () => {
+            const schema = require(`./${schemaFile}`);
+            let validate;
+            if (type === 'config-1.0.1') {
+                const obsSets = require('./obsSets.schema.json');
+                const raster = require('./raster.schema.json');
+                validate = new Ajv()
+                    .addSchema(obsSets)
+                    .addSchema(raster)
+                    .compile(schema);
+            }
+            else {
+                validate = new Ajv().compile(schema);
+            }
+            const [goodFixture, badFixture, badMessage] = [
+                'good', 'bad', 'bad.message',
+            ].map(stem => `${type}.${stem}.json`);
+            it(`passes ${goodFixture}`, () => {
+                const data = require(`./fixtures/${goodFixture}`);
+                const valid = validate(data);
+                if (!valid) {
+                    console.warn(validate.errors);
+                }
+                expect(valid).toEqual(true);
+            });
+            it(`fails ${badFixture}`, () => {
+                const data = require(`./fixtures/${badFixture}`);
+                const message = require(`./fixtures/${badMessage}`);
+                const valid = validate(data);
+                expect(valid).toEqual(false);
+                expect(validate.errors).toEqual(message);
+            });
+        });
+    });
+});

package/dist/schemas-extra.js

@@ -0,0 +1,3 @@
+export { schema as rasterSchema } from './schemas/raster.schema';
+export { schema as obsSetsSchema } from './schemas/obs-sets.schema';
+export { schema as obsSetsTabularSchema } from './schemas/obs-sets-tabular.schema';

package/dist/shared-mui/container.js

@@ -7,14 +7,14 @@ export const useVitessceContainerStyles = makeStyles(theme => ({
         backgroundColor: theme.palette.gridLayoutBackground,
         '& div': {
             fontFamily: '-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Arial,"Noto Sans",sans-serif,"Apple Color Emoji","Segoe UI Emoji","Segoe UI Symbol","Noto Color Emoji"',
-            fontSize: '1rem',
+            fontSize: '16px',
             fontWeight: '400',
             lineHeight: '1.5',
             textAlign: 'left',
         },
         '& p': {
             marginTop: '0',
-            marginBottom: '1rem',
+            marginBottom: '16px',
         },
         '& *, ::after, ::before': {
             boxSizing: 'border-box',

package/dist/shared-mui/styles.js

@@ -11,6 +11,48 @@ const globalColors = {
     grayMidL10: 'rgb(154, 154, 154)',
     grayLightL10: 'rgb(237, 237, 237)', // lighten(map-get($global-colors, "gray-light"), 10%);
 };
+const sharedThemeOptions = {
+    // Use px instead of rem, so that sizing is consistent despite the root element font-size.
+    // Reference: https://github.com/mui/material-ui/blob/627c08fc/src/styles/createTypography.js
+    typography: {
+        pxToRem: size => `${size}px`,
+        display4: {
+            fontSize: '112px',
+        },
+        display3: {
+            fontSize: '56px',
+        },
+        display2: {
+            fontSize: '45px',
+        },
+        display1: {
+            fontSize: '34px',
+        },
+        headline: {
+            fontSize: '24px',
+        },
+        title: {
+            fontSize: '21px',
+        },
+        subheading: {
+            fontSize: '16px',
+        },
+        body2: {
+            fontSize: '14px',
+        },
+        body1: {
+            fontSize: '14px',
+        },
+        caption: {
+            fontSize: '12px',
+        },
+    },
+    props: {
+        MuiButtonBase: {
+            disableRipple: true,
+        },
+    },
+};
 export const muiTheme = {
     dark: createTheme({
         palette: {
@@ -35,11 +77,7 @@ export const muiTheme = {
             cardBorder: 'rgba(0, 0, 0, 0.125)',
             ...globalColors,
         },
-        props: {
-            MuiButtonBase: {
-                disableRipple: true,
-            },
-        },
+        ...sharedThemeOptions,
     }),
     light: createTheme({
         palette: {
@@ -64,10 +102,6 @@ export const muiTheme = {
             cardBorder: 'rgba(241, 241, 241, 0.125)',
             ...globalColors,
         },
-        props: {
-            MuiButtonBase: {
-                disableRipple: true,
-            },
-        },
+        ...sharedThemeOptions,
     }),
 };

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

@@ -38,7 +38,7 @@ export const useStyles = makeStyles(theme => ({
     },
     select: {
         '& select': {
-            fontSize: '.875rem',
+            fontSize: '14px',
         },
     },
     selectRoot: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vitessce/vit-s",
-  "version": "2.0.1",
+  "version": "2.0.3-beta.0",
   "author": "Gehlenborg Lab",
   "homepage": "http://vitessce.io",
   "repository": {
@@ -24,8 +24,8 @@
     "react-grid-layout-with-lodash": "^1.3.5",
     "uuid": "^3.3.2",
     "zustand": "^3.5.10",
-    "@vitessce/constants-internal": "2.0.1",
-    "@vitessce/utils": "2.0.1"
+    "@vitessce/constants-internal": "2.0.3-beta.0",
+    "@vitessce/utils": "2.0.3-beta.0"
   },
   "devDependencies": {
     "react": "^18.0.0",