@jbrowse/plugin-spreadsheet-view 2.16.1 → 2.18.0

package/esm/SpreadsheetView/ImportWizard.js

@@ -0,0 +1,214 @@
+import { readConfObject } from '@jbrowse/core/configuration';
+import { getEnv, getSession } from '@jbrowse/core/util';
+import { openLocation } from '@jbrowse/core/util/io';
+import { getTrackName } from '@jbrowse/core/util/tracks';
+import { getParent, types } from 'mobx-state-tree';
+const IMPORT_SIZE_LIMIT = 100000000;
+const fileTypes = ['VCF', 'BED', 'BEDPE', 'STAR-Fusion'];
+const fileTypeParsers = {
+    VCF: () => import('./importAdapters/VcfImport').then(r => r.parseVcfBuffer),
+    BED: () => import('./importAdapters/BedImport').then(r => r.parseBedBuffer),
+    BEDPE: () => import('./importAdapters/BedpeImport').then(r => r.parseBedPEBuffer),
+    'STAR-Fusion': () => import('./importAdapters/STARFusionImport').then(r => r.parseSTARFusionBuffer),
+};
+function getType(adapter) {
+    if (adapter.vcfLocation || adapter.vcfGzLocation) {
+        return 'VCF';
+    }
+    else if (adapter.bedLocation || adapter.bedGzLocation) {
+        return 'BED';
+    }
+    else if (adapter.bedpeLocation) {
+        return 'BEDPE';
+    }
+    else {
+        return undefined;
+    }
+}
+function getAdapterLoc(adapter) {
+    return (adapter.vcfLocation ||
+        adapter.vcfGzLocation ||
+        adapter.bedLocation ||
+        adapter.bedGzLocation ||
+        adapter.bedpeLocation);
+}
+const fileTypesRegexp = new RegExp(`\\.(${fileTypes.join('|')})(\\.gz)?$`, 'i');
+function x() { }
+export default function stateModelFactory() {
+    return types
+        .model('SpreadsheetImportWizard', {
+        fileType: types.optional(types.enumeration(fileTypes), 'VCF'),
+        hasColumnNameLine: true,
+        columnNameLineNumber: 1,
+        selectedAssemblyName: types.maybe(types.string),
+        cachedFileLocation: types.frozen(),
+    })
+        .volatile(() => ({
+        fileTypes,
+        fileSource: undefined,
+        error: undefined,
+        loading: false,
+    }))
+        .views(self => ({
+        get isReadyToOpen() {
+            return (self.fileSource &&
+                (self.fileSource.blobId ||
+                    self.fileSource.localPath ||
+                    self.fileSource.uri));
+        },
+        get fileName() {
+            return (self.fileSource.uri ||
+                self.fileSource.localPath ||
+                (self.fileSource.blobId && self.fileSource.name));
+        },
+        get requiresUnzip() {
+            return this.fileName.endsWith('gz');
+        },
+        isValidRefName(refName, assemblyName) {
+            const { assemblyManager } = getSession(self);
+            return !assemblyName
+                ? false
+                : assemblyManager.isValidRefName(refName, assemblyName);
+        },
+        tracksForAssembly(selectedAssembly) {
+            const session = getSession(self);
+            const { tracks = [], sessionTracks = [] } = session;
+            const allTracks = [
+                ...tracks,
+                ...sessionTracks,
+            ];
+            return allTracks
+                .map(track => {
+                const assemblyNames = readConfObject(track, 'assemblyNames');
+                const adapter = readConfObject(track, 'adapter');
+                const category = readConfObject(track, 'category').join(',');
+                const loc = getAdapterLoc(adapter);
+                return assemblyNames.includes(selectedAssembly) && loc
+                    ? {
+                        track,
+                        label: [
+                            category ? `[${category}]` : '',
+                            getTrackName(track, session),
+                        ]
+                            .filter(f => !!f)
+                            .join(' '),
+                        assemblyNames,
+                        type: getType(adapter) || 'UNKNOWN',
+                        loc,
+                    }
+                    : undefined;
+            })
+                .filter(f => !!f)
+                .sort((a, b) => a.label.localeCompare(b.label));
+        },
+    }))
+        .actions(self => ({
+        setSelectedAssemblyName(s) {
+            self.selectedAssemblyName = s;
+        },
+        setFileSource(newSource) {
+            var _a;
+            self.fileSource = newSource;
+            self.error = undefined;
+            if (self.fileSource) {
+                const name = self.fileName;
+                if (name) {
+                    const firstMatch = (_a = fileTypesRegexp.exec(name)) === null || _a === void 0 ? void 0 : _a[1];
+                    if (firstMatch) {
+                        self.fileType =
+                            firstMatch === 'tsv' && name.includes('star-fusion')
+                                ? 'STAR-Fusion'
+                                : firstMatch.toUpperCase();
+                    }
+                }
+            }
+        },
+        setColumnNameLineNumber(newnumber) {
+            if (newnumber > 0) {
+                self.columnNameLineNumber = newnumber;
+            }
+        },
+        setFileType(typeName) {
+            self.fileType = typeName;
+        },
+        setError(error) {
+            self.error = error;
+        },
+        setLoading(arg) {
+            self.loading = arg;
+        },
+        cancelButton() {
+            self.error = undefined;
+            getParent(self).setDisplayMode();
+        },
+        setCachedFileHandle(arg) {
+            self.cachedFileLocation = arg;
+        },
+    }))
+        .actions(self => ({
+        async import(assemblyName) {
+            if (!self.fileSource) {
+                return;
+            }
+            self.selectedAssemblyName = assemblyName;
+            const type = self.fileType;
+            const typeParser = await fileTypeParsers[type]();
+            const { fetchAndMaybeUnzip } = await import('@jbrowse/core/util');
+            const { pluginManager } = getEnv(self);
+            const filehandle = openLocation(self.fileSource, pluginManager);
+            self.setLoading(true);
+            try {
+                const stat = await filehandle.stat();
+                if (stat.size > IMPORT_SIZE_LIMIT) {
+                    self.setError(`File is too big. Tabular files are limited to at most ${(IMPORT_SIZE_LIMIT / 1000).toLocaleString()}kb.`);
+                    return;
+                }
+            }
+            catch (e) {
+                console.warn(e);
+            }
+            finally {
+                self.setLoading(false);
+            }
+            self.setLoading(true);
+            try {
+                if (self.fileSource.uri) {
+                    self.setCachedFileHandle({
+                        uri: self.fileSource.uri,
+                        baseUri: self.fileSource.baseUri,
+                        locationType: 'UriLocation',
+                    });
+                }
+                const data = await fetchAndMaybeUnzip(filehandle);
+                getParent(self).displaySpreadsheet({
+                    ...typeParser(data),
+                    assemblyName,
+                });
+            }
+            catch (e) {
+                console.error(e);
+                self.setError(e);
+            }
+            finally {
+                self.setLoading(false);
+            }
+        },
+    }))
+        .actions(self => ({
+        afterAttach() {
+            ;
+            (async () => {
+                try {
+                    if (self.cachedFileLocation && self.selectedAssemblyName) {
+                        self.setFileSource(self.cachedFileLocation);
+                        await self.import(self.selectedAssemblyName);
+                    }
+                }
+                catch (e) {
+                    console.error(e);
+                    getSession(self).notifyError(`${e}`, e);
+                }
+            })();
+        },
+    }));
+}

package/esm/SpreadsheetView/SpreadsheetModel.d.ts

@@ -0,0 +1,79 @@
+import React from 'react';
+import type { SimpleFeatureSerialized } from '@jbrowse/core/util';
+import type { Instance } from 'mobx-state-tree';
+export interface Row {
+    feature?: SimpleFeatureSerialized;
+    cellData?: Record<string, unknown>;
+    cells?: {
+        text: unknown;
+    }[];
+}
+export interface RowSet {
+    rows: Row[];
+}
+export default function stateModelFactory(): import("mobx-state-tree").IModelType<{
+    rowSet: import("mobx-state-tree").IType<RowSet | undefined, RowSet | undefined, RowSet | undefined>;
+    columns: import("mobx-state-tree").IType<{
+        name: string;
+    }[], {
+        name: string;
+    }[], {
+        name: string;
+    }[]>;
+    assemblyName: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
+    visibleColumns: import("mobx-state-tree").IType<Record<string, boolean>, Record<string, boolean>, Record<string, boolean>>;
+}, {
+    isLoaded: boolean;
+    visibleRowFlags: Record<number, boolean> | undefined;
+} & {
+    readonly rows: {
+        id: number;
+        feature: SimpleFeatureSerialized | undefined;
+    }[] | undefined;
+    readonly initialized: boolean | undefined;
+} & {
+    readonly dataGridColumns: ({
+        field: string;
+        width: number;
+    } | {
+        field: string;
+        width: number;
+        renderCell: ({ row }: import("@mui/x-data-grid").GridRenderCellParams<{
+            id: number;
+            feature: SimpleFeatureSerialized | undefined;
+        }, any, any, import("@mui/x-data-grid").GridTreeNodeWithRender>) => React.JSX.Element | "N/A";
+        valueGetter?: undefined;
+        valueFormatter?: undefined;
+    } | {
+        field: string;
+        width: number;
+        valueGetter: (_val: unknown, row: {
+            feature?: SimpleFeatureSerialized;
+        }) => number | undefined;
+        valueFormatter: (arg: never) => string;
+        renderCell?: undefined;
+    })[] | undefined;
+} & {
+    readonly visibleRows: {
+        id: number;
+        feature: SimpleFeatureSerialized | undefined;
+    }[] | undefined;
+} & {
+    setVisibleRows(arg?: Record<number, boolean>): void;
+    setVisibleColumns(arg: Record<string, boolean>): void;
+    setLoaded(flag: boolean): void;
+    afterAttach(): void;
+}, import("mobx-state-tree").ModelCreationType<import("mobx-state-tree/dist/internal").ExtractCFromProps<{
+    rowSet: import("mobx-state-tree").IType<RowSet | undefined, RowSet | undefined, RowSet | undefined>;
+    columns: import("mobx-state-tree").IType<{
+        name: string;
+    }[], {
+        name: string;
+    }[], {
+        name: string;
+    }[]>;
+    assemblyName: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
+    visibleColumns: import("mobx-state-tree").IType<Record<string, boolean>, Record<string, boolean>, Record<string, boolean>>;
+}>>, import("mobx-state-tree")._NotCustomized>;
+export type SpreadsheetStateModel = ReturnType<typeof stateModelFactory>;
+export type SpreadsheetModel = Instance<SpreadsheetStateModel>;

package/esm/SpreadsheetView/SpreadsheetModel.js

@@ -0,0 +1,127 @@
+import React from 'react';
+import { assembleLocStringFast, getSession, measureGridWidth, toLocale, } from '@jbrowse/core/util';
+import { autorun } from 'mobx';
+import { addDisposer, types } from 'mobx-state-tree';
+import LocationCell from './components/LocationCell';
+export default function stateModelFactory() {
+    return types
+        .model('Spreadsheet', {
+        rowSet: types.frozen(),
+        columns: types.frozen(),
+        assemblyName: types.maybe(types.string),
+        visibleColumns: types.frozen(),
+    })
+        .volatile(() => ({
+        isLoaded: false,
+        visibleRowFlags: undefined,
+    }))
+        .views(self => ({
+        get rows() {
+            var _a;
+            return (_a = self.rowSet) === null || _a === void 0 ? void 0 : _a.rows.map((row, i) => ({
+                id: i,
+                feature: row.feature,
+                ...Object.fromEntries(self.columns.map((c, idx) => {
+                    var _a, _b, _c, _d;
+                    return [
+                        c.name,
+                        (_b = (_a = row.cellData) === null || _a === void 0 ? void 0 : _a[c.name]) !== null && _b !== void 0 ? _b : (_d = (_c = row.cells) === null || _c === void 0 ? void 0 : _c[idx]) === null || _d === void 0 ? void 0 : _d.text,
+                    ];
+                })),
+            }));
+        },
+        get initialized() {
+            var _a;
+            const session = getSession(self);
+            const name = self.assemblyName;
+            return name ? (_a = session.assemblyManager.get(name)) === null || _a === void 0 ? void 0 : _a.initialized : false;
+        },
+    }))
+        .views(self => ({
+        get dataGridColumns() {
+            const { rows } = self;
+            return rows
+                ? [
+                    {
+                        field: 'Location',
+                        width: measureGridWidth(rows.map(row => row.feature ? assembleLocStringFast(row.feature) : 0)) + 40,
+                        renderCell: ({ row }) => {
+                            const { feature } = row;
+                            return feature ? (React.createElement(LocationCell, { model: self, feature: feature })) : ('N/A');
+                        },
+                    },
+                    {
+                        field: 'Length',
+                        width: measureGridWidth(rows.map(r => r.feature ? toLocale(r.feature.end - r.feature.start) : 0)),
+                        valueGetter: (_val, row) => {
+                            return row.feature
+                                ? row.feature.end - row.feature.start
+                                : undefined;
+                        },
+                        valueFormatter: arg => toLocale(arg),
+                    },
+                    ...self.columns.map(f => ({
+                        field: f.name,
+                        width: measureGridWidth([...rows.map(r => r[f.name]), f.name], { minWidth: 20 }),
+                    })),
+                ]
+                : undefined;
+        },
+    }))
+        .views(self => ({
+        get visibleRows() {
+            var _a;
+            const { visibleRowFlags } = self;
+            return visibleRowFlags
+                ? (_a = self.rows) === null || _a === void 0 ? void 0 : _a.filter((f, idx) => !!visibleRowFlags[idx])
+                : self.rows;
+        },
+    }))
+        .actions(self => ({
+        setVisibleRows(arg) {
+            self.visibleRowFlags = arg;
+        },
+        setVisibleColumns(arg) {
+            self.visibleColumns = arg;
+        },
+        setLoaded(flag) {
+            self.isLoaded = flag;
+        },
+        afterAttach() {
+            addDisposer(self, autorun(async () => {
+                const session = getSession(self);
+                const { assemblyManager } = session;
+                try {
+                    if (self.assemblyName) {
+                        await assemblyManager.waitForAssembly(self.assemblyName);
+                        this.setLoaded(true);
+                    }
+                }
+                catch (e) {
+                    console.error(e);
+                    session.notifyError(`Failed to load assembly ${self.assemblyName} ${e}`, e);
+                }
+            }));
+        },
+    }))
+        .preProcessSnapshot(snap => {
+        return snap
+            ? {
+                ...snap,
+                columns: snap.columns.filter(f => !f.isDerived),
+                rowSet: snap.rowSet
+                    ? {
+                        ...snap.rowSet,
+                        rows: snap.rowSet.rows.map(r => {
+                            var _a, _b;
+                            return ({
+                                ...r,
+                                feature: (_a = r.feature) !== null && _a !== void 0 ? _a : (_b = r.extendedData) === null || _b === void 0 ? void 0 : _b.vcfFeature,
+                            });
+                        }),
+                    }
+                    : undefined,
+            }
+            : snap;
+    });
+}