@vitessce/vit-s 2.0.0-beta.0

package/dist/export-utils.js

@@ -0,0 +1,70 @@
+import Bowser from 'bowser';
+import { compressToEncodedURIComponent, decompressFromEncodedURIComponent } from 'lz-string';
+const CURRENT_VERSION = '0.0.1';
+const VITESSCE_CONF_QUERY_STRING = 'vitessce_conf';
+const VERSION_QUERY_STRING = 'vitessce_conf_version';
+const LENGTH_QUERY_STRING = 'vitessce_conf_length';
+function sniffBrowser() {
+    const { browser } = Bowser.parse(window.navigator.userAgent);
+    return browser.name;
+}
+// https://stackoverflow.com/questions/417142/what-is-the-maximum-length-of-a-url-in-different-browsers
+const MAX_BROWSER_URL_LENGTHS = {
+    Chrome: 32779,
+    'Internet Explorer': 2047,
+    Edge: 2047,
+    Safari: 65000,
+    Firefox: 65000,
+};
+export default class CompressedConfLengthError {
+    constructor(message) {
+        this.message = message;
+    }
+}
+/**
+ * Encode a configuration as url params with a version and an lz-compressed conf.
+ * @param {Object} params
+ * @param {Object} params.conf Previous scope names.
+ * @param {function} params.onOverMaximumUrlLength Callback for when new url
+ * is over max length for your browser - takes two arguments: { message, willWorkOn }
+ * for the error message and the browsers for which the url will work (optional).
+ * @returns {string} The new params like
+ * vitessce_conf_length=10&vitessce_conf_version=0.0.1&vitessce_conf=fksdfasdfjkl
+ */
+export function encodeConfInUrl({ conf, onOverMaximumUrlLength = () => { }, }) {
+    const compressedConf = compressToEncodedURIComponent(JSON.stringify(conf));
+    const newParams = `${LENGTH_QUERY_STRING}=${compressedConf.length}&${VERSION_QUERY_STRING}=${CURRENT_VERSION}&${VITESSCE_CONF_QUERY_STRING}=${compressedConf}`;
+    const browser = sniffBrowser();
+    const maxLength = MAX_BROWSER_URL_LENGTHS[browser];
+    if (newParams.length > maxLength) {
+        const willWorkOn = Object.entries(MAX_BROWSER_URL_LENGTHS)
+            .filter(entry => entry[1] > newParams.length)
+            .map(entry => entry[0]);
+        const message = `Configuration is ${compressedConf.length} characters; max URL for ${browser} is ${maxLength}: it will work on ${willWorkOn.join(', ') || 'no browser'}.`;
+        console.error(message);
+        onOverMaximumUrlLength({ message, willWorkOn });
+    }
+    return newParams;
+}
+/**
+ * Decode URL params to a Vitessce configuration.
+ * The URL params must have version and vitessce_conf params,
+ * like vitessce_conf_length=10&vitessce_conf_version=0.0.1&vitessce_conf=fksdfasdfjkl.
+ * @param {Object} queryString The URL params,
+ * like vitessce_conf_length=10&vitessce_conf_version=0.0.1&vitessce_conf=fksdfasdfjkl.
+ * @returns {string} A vitessce configuration.
+ */
+export function decodeURLParamsToConf(queryString) {
+    const params = new URLSearchParams(queryString.replace('#', '&'));
+    const compressedConfString = params.get(VITESSCE_CONF_QUERY_STRING);
+    const expectedConfLength = Number(params.get(LENGTH_QUERY_STRING));
+    if (expectedConfLength !== compressedConfString.length) {
+        throw new CompressedConfLengthError(`Compressed conf length (${compressedConfString.length}) != expected (${expectedConfLength}). URL truncated?`);
+    }
+    const version = params.get(VERSION_QUERY_STRING);
+    if (version === CURRENT_VERSION) {
+        const conf = JSON.parse(decompressFromEncodedURIComponent(compressedConfString));
+        return conf;
+    }
+    throw new Error('Unrecognized URL Param Version');
+}

package/dist/export-utils.test.js

@@ -0,0 +1,66 @@
+import expect from 'expect';
+import { encodeConfInUrl, decodeURLParamsToConf, } from './export-utils';
+const fakeConfig = {
+    version: '0.1.0',
+    public: false,
+    layers: [
+        {
+            name: 'cells',
+            type: 'CELLS',
+            fileType: 'cells.json',
+            url: 'http://example.com/cells.json',
+        },
+    ],
+    name: 'Just scatterplot',
+    staticLayout: [
+        {
+            component: 'scatterplot',
+            props: {
+                mapping: 't-SNE',
+                view: {
+                    zoom: 0.75,
+                    target: [0, 0, 0],
+                },
+            },
+            x: 0,
+            y: 0,
+            w: 12,
+            h: 2,
+        },
+    ],
+};
+function makeLongString(length) {
+    let result = '';
+    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    const charactersLength = characters.length;
+    // eslint-disable-next-line no-plusplus
+    for (let i = 0; i < length; i++) {
+        result += characters.charAt(Math.floor(Math.random() * charactersLength));
+    }
+    return result;
+}
+describe('src/app/export-utils.js', () => {
+    describe('encodeConfInUrl', () => {
+        it('encodes a view config for a URL', () => {
+            const urlParams1 = encodeConfInUrl({ conf: {} });
+            expect(urlParams1).toEqual('vitessce_conf_length=5&vitessce_conf_version=0.0.1&vitessce_conf=N4XyA');
+            const urlParams2 = encodeConfInUrl({ conf: fakeConfig });
+            expect(urlParams2).toEqual('vitessce_conf_length=327&vitessce_conf_version=0.0.1&vitessce_conf=N4IgbgpgTgzglgewHYgFwgAwDoCMWMgA0IADgK4BGANnAMZoBmAhlTBMVUwJ7QxoDaoJEwC2ENCFoQqrIiAAuXEuPQBhAKIAZTQGU5DOFQgAVJSsnTWWAFYxkcslCoSAFvPklUAei8QAHqIkRli0CCJeUjIwNnYoAL4AusTCYhIAUmQw8gAEMLRM7tBBCPJyWQV0mtwIZKWogpJhJMgQSHUgeQXyRVQlciRQCCR8qKAiTCQkcEgA5hLyALQ6AHLqcmBwEADuaKAAXghhaNgA7ACsxPJMUDMQdfwYhI8YCXFxxH7HxFxfIDuoOAATMQXGhAYk4kA');
+        });
+        it('Calls onOverMaximumUrlLength for conf too long', () => {
+            let browsers;
+            // eslint-disable-next-line no-return-assign
+            const onOverMaximumUrlLength = ({ willWorkOn }) => browsers = willWorkOn;
+            encodeConfInUrl({ conf: { foo: makeLongString(69000) }, onOverMaximumUrlLength });
+            expect(browsers).toEqual([]);
+            encodeConfInUrl({ conf: { foo: makeLongString(37000) }, onOverMaximumUrlLength });
+            expect(browsers).toEqual(['Safari', 'Firefox']);
+        });
+        it('decodes a view config for a URL', () => {
+            const viewConfig1 = decodeURLParamsToConf('vitessce_conf_length=5&vitessce_conf_version=0.0.1&vitessce_conf=N4XyA');
+            expect(viewConfig1).toEqual({});
+            const viewConfig2 = decodeURLParamsToConf('vitessce_conf_length=327&vitessce_conf_version=0.0.1&vitessce_conf=N4IgbgpgTgzglgewHYgFwgAwDoCMWMgA0IADgK4BGANnAMZoBmAhlTBMVUwJ7QxoDaoJEwC2ENCFoQqrIiAAuXEuPQBhAKIAZTQGU5DOFQgAVJSsnTWWAFYxkcslCoSAFvPklUAei8QAHqIkRli0CCJeUjIwNnYoAL4AusTCYhIAUmQw8gAEMLRM7tBBCPJyWQV0mtwIZKWogpJhJMgQSHUgeQXyRVQlciRQCCR8qKAiTCQkcEgA5hLyALQ6AHLqcmBwEADuaKAAXghhaNgA7ACsxPJMUDMQdfwYhI8YCXFxxH7HxFxfIDuoOAATMQXGhAYk4kA');
+            expect(viewConfig2).toEqual(fakeConfig);
+        });
+    });
+});

package/dist/file-options-schemas-legacy.js

@@ -0,0 +1,136 @@
+export const cellsJsonSchema = {
+    $schema: 'http://json-schema.org/draft-07/schema#',
+    $id: 'https://github.com/vitessce/vitessce/#cells-json-options',
+    title: 'cells.json options',
+    oneOf: [
+        { type: 'null' },
+        {
+            type: 'object',
+            additionalProperties: false,
+            required: [],
+            properties: {
+                obsLabelsTypes: {
+                    type: 'array',
+                    items: { type: 'string' },
+                },
+                embeddingTypes: {
+                    type: 'array',
+                    items: { type: 'string' },
+                },
+            },
+        },
+    ],
+};
+export const anndataCellsZarrSchema = {
+    $schema: 'http://json-schema.org/draft-07/schema#',
+    $id: 'https://github.com/vitessce/vitessce/#anndata-cells-zarr-options',
+    title: 'anndata-cells.zarr options',
+    type: 'object',
+    minProperties: 1,
+    additionalProperties: false,
+    required: [],
+    properties: {
+        xy: {
+            type: 'string',
+            description: "The location in the AnnData store of cell centroids, like 'obsm/X_centroids.'",
+        },
+        poly: {
+            type: 'string',
+            description: "The location in the AnnData store of cell polygon outlines, like 'obsm/X_polygons.'",
+        },
+        factors: {
+            type: 'array',
+            description: "List of locations in the AnnData store of cell sets, like 'obs/louvain'",
+            items: {
+                type: 'string',
+            },
+        },
+        mappings: {
+            patternProperties: {
+                '.': {
+                    type: 'object',
+                    description: "An object containing key-values for mappings like { UMAP: { key: 'obsm/X_umap', dims: [0, 1] } }.",
+                    additionalProperties: false,
+                    required: ['key'],
+                    properties: {
+                        key: {
+                            type: 'string',
+                            description: "Where to look in the AnnData store for this mapping, like 'obsm/X_umap.'",
+                        },
+                        dims: {
+                            type: 'array',
+                            description: 'Which indices of the obsm object to take for a scatterplot, allowing for, for example, different PCs from obsm/X_pca',
+                            minItems: 2,
+                            maxItems: 2,
+                            items: { type: 'number' },
+                        },
+                    },
+                },
+            },
+        },
+    },
+};
+export const anndataCellSetsZarrSchema = {
+    $schema: 'http://json-schema.org/draft-07/schema#',
+    $id: 'https://github.com/vitessce/vitessce/#anndata-cell-sets-zarr-options',
+    title: 'anndata-cell-sets.zarr options',
+    type: 'array',
+    items: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['groupName', 'setName'],
+        properties: {
+            groupName: {
+                type: 'string',
+                description: "The display name for the set, like 'Cell Type' or 'Louvain.'",
+            },
+            setName: {
+                oneOf: [
+                    {
+                        type: 'string',
+                        description: "The location in the AnnData store for the set, like 'obs/louvain' or 'obs/celltype.'",
+                    },
+                    {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'An array of locations in the AnnData store for a hierarchy of set names, from coarse to fine levels.',
+                    },
+                ],
+            },
+            scoreName: {
+                oneOf: [
+                    {
+                        type: 'string',
+                        description: "The location in the AnnData store for the set confidence scores, like 'obs/celltype_prediction_score.'",
+                    },
+                ],
+            },
+        },
+    },
+};
+export const anndataExpressionMatrixZarrSchema = {
+    $schema: 'http://json-schema.org/draft-07/schema#',
+    $id: 'https://github.com/vitessce/vitessce/#anndata-expression-matrix-zarr-options',
+    title: 'anndata-expression-matrix.zarr options',
+    type: 'object',
+    additionalProperties: false,
+    required: ['matrix'],
+    properties: {
+        matrix: {
+            type: 'string',
+            description: "The location in the AnnData store of the cell x gene matrix, like 'obsm/hvg_subset.' or 'X'",
+        },
+        geneFilter: {
+            type: 'string',
+            description: "The location in the AnnData store of a filter for the genes if using a subset of the data, like 'var.highly_variable.' if the matrix comes from 'obsm/hvg_subset.'",
+        },
+        matrixGeneFilter: {
+            type: 'string',
+            description: "The location in the AnnData store of a filter for the matrix data (used in heatmap and histogram), like 'var.highly_variable.''",
+        },
+        geneAlias: {
+            type: 'string',
+            description: 'The location in the AnnData store of a different list of names for gene list component, other than the `var` index',
+        },
+    },
+};

package/dist/file-options-schemas-legacy.test.js

@@ -0,0 +1,126 @@
+import { expandExpressionMatrixZarr, expandRasterOmeZarr, expandGenesJson, expandCellsJson, expandCellSetsJson, expandMoleculesJson, expandAnndataCellsZarr, expandAnndataCellSetsZarr, expandAnndataExpressionMatrixZarr, expandClustersJson, } from './joint-file-types-legacy';
+describe('src/app/file-options-schemas-legacy.js', () => {
+    describe('Options validation for joint file type expansion functions', () => {
+        it('cells.json with extra options fails validation', () => {
+            expect(() => expandCellsJson({
+                fileType: 'cells.json',
+                url: 'http://localhost:8000/cells.json',
+                options: {
+                    badKey: 'test',
+                    embeddingTypes: ['UMAP', 't-SNE'],
+                    obsLabelsTypes: ['cluster', 'subcluster'],
+                },
+            })).toThrow();
+        });
+        it('molecules.json with any options fails validation', () => {
+            expect(() => expandMoleculesJson({
+                fileType: 'molecules.json',
+                url: 'http://localhost:8000/molecules.json',
+                options: {},
+            })).toThrow();
+        });
+        it('expression-matrix.zarr with any options fails validation', () => {
+            expect(() => expandExpressionMatrixZarr({
+                fileType: 'expression-matrix.zarr',
+                url: 'http://localhost:8000/expression-matrix.zarr',
+                options: {},
+            })).toThrow();
+        });
+        it('raster.ome-zarr with any options fails validation', () => {
+            expect(() => expandRasterOmeZarr({
+                fileType: 'raster.ome-zarr',
+                url: 'http://localhost:8000/raster.ome-zarr',
+                options: {},
+            })).toThrow();
+        });
+        it('cell-sets.json with any options fails validation', () => {
+            expect(() => expandCellSetsJson({
+                fileType: 'cell-sets.json',
+                url: 'http://localhost:8000/cell-sets.json',
+                options: {},
+            })).toThrow();
+        });
+        it('clusters.json with any options fails validation', () => {
+            expect(() => expandClustersJson({
+                fileType: 'clusters.json',
+                url: 'http://localhost:8000/clusters.json',
+                options: {},
+            })).toThrow();
+        });
+        it('genes.json with any options fails validation', () => {
+            expect(() => expandGenesJson({
+                fileType: 'genes.json',
+                url: 'http://localhost:8000/genes.json',
+                options: {},
+            })).toThrow();
+        });
+        it('anndata-cells.zarr with extra options fails validation', () => {
+            expect(() => expandAnndataCellsZarr({
+                fileType: 'anndata-cells.zarr',
+                url: 'http://localhost:8000/anndata-cells.zarr',
+                options: {
+                    poly: 'obsm/poly',
+                    xy: 'obsm/xy',
+                    bad: 'bad',
+                },
+            })).toThrow();
+        });
+        it('anndata-cells.zarr with invalid options fails validation', () => {
+            expect(() => expandAnndataCellsZarr({
+                fileType: 'anndata-cells.zarr',
+                url: 'http://localhost:8000/anndata-cells.zarr',
+                options: {
+                    poly: 'obsm/poly',
+                    xy: 'obsm/xy',
+                    mappings: {
+                        UMAP: ['bad'],
+                    },
+                },
+            })).toThrow();
+        });
+        it('anndata-cell-sets.zarr with invalid options fails validation', () => {
+            expect(() => expandAnndataCellSetsZarr({
+                fileType: 'anndata-cell-sets.zarr',
+                url: 'http://localhost:8000/anndata-cell-sets.zarr',
+                options: {},
+            })).toThrow();
+        });
+        it('anndata-cell-sets.zarr with extra options fails validation', () => {
+            expect(() => expandAnndataCellSetsZarr({
+                fileType: 'anndata-cell-sets.zarr',
+                url: 'http://localhost:8000/anndata-cell-sets.zarr',
+                options: [
+                    {
+                        groupName: 'Cell Type Annotations',
+                        setName: 'obs/cell_type',
+                        scoreName: 'obs/score',
+                        bad: 'bad',
+                    },
+                ],
+            })).toThrow();
+        });
+        it('anndata-expression-matrix.zarr with invalid options fails validation', () => {
+            expect(() => expandAnndataExpressionMatrixZarr({
+                fileType: 'anndata-expression-matrix.zarr',
+                url: 'http://localhost:8000/anndata-expression-matrix.zarr',
+                options: {
+                    matrix: 'good',
+                    geneAlias: 1,
+                },
+            })).toThrow();
+        });
+        it('anndata-expression-matrix.zarr with extra options fails validation', () => {
+            expect(() => expandAnndataExpressionMatrixZarr({
+                fileType: 'anndata-expression-matrix.zarr',
+                url: 'http://localhost:8000/anndata-expression-matrix.zarr',
+                options: {
+                    matrix: 'good',
+                    geneAlias: 'good',
+                    geneFilter: 'good',
+                    matrixGeneFilter: 'good',
+                    bad: 'bad',
+                },
+            })).toThrow();
+        });
+    });
+});