@jbrowse/plugin-spreadsheet-view 2.16.1 → 2.18.0

package/dist/LaunchSpreadsheetView/index.d.ts

@@ -1,2 +1,2 @@
-import PluginManager from '@jbrowse/core/PluginManager';
+import type PluginManager from '@jbrowse/core/PluginManager';
 export default function LaunchSpreadsheetViewF(pluginManager: PluginManager): void;

package/dist/LaunchSpreadsheetView/index.js

@@ -2,9 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = LaunchSpreadsheetViewF;
 function LaunchSpreadsheetViewF(pluginManager) {
-    pluginManager.addToExtensionPoint('LaunchView-SpreadsheetView', 
-    // @ts-expect-error
-    async ({ session, assembly, uri, fileType, }) => {
+    pluginManager.addToExtensionPoint('LaunchView-SpreadsheetView', async ({ session, assembly, uri, fileType, }) => {
         var _a, _b;
         const view = session.addView('SpreadsheetView');
         const exts = uri.split('.');

package/dist/SpreadsheetView/ImportWizard.d.ts

@@ -0,0 +1,51 @@
+import type { FileLocation } from '@jbrowse/core/util';
+import type { Instance } from 'mobx-state-tree';
+export default function stateModelFactory(): import("mobx-state-tree").IModelType<{
+    fileType: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
+    hasColumnNameLine: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+    columnNameLineNumber: import("mobx-state-tree").IType<number | undefined, number, number>;
+    selectedAssemblyName: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
+    cachedFileLocation: import("mobx-state-tree").IType<FileLocation | undefined, FileLocation | undefined, FileLocation | undefined>;
+}, {
+    fileTypes: string[];
+    fileSource: any;
+    error: unknown;
+    loading: boolean;
+} & {
+    readonly isReadyToOpen: any;
+    readonly fileName: any;
+    readonly requiresUnzip: any;
+    isValidRefName(refName: string, assemblyName?: string): boolean;
+    tracksForAssembly(selectedAssembly: string): {
+        track: {
+            [x: string]: any;
+        } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
+            setSubschema(slotName: string, data: Record<string, unknown>): Record<string, unknown> | ({
+                [x: string]: any;
+            } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
+                setSubschema(slotName: string, data: Record<string, unknown>): Record<string, unknown> | ({
+                    [x: string]: any;
+                } & import("mobx-state-tree/dist/internal").NonEmptyObject & any & import("mobx-state-tree").IStateTreeNode<import("@jbrowse/core/configuration").AnyConfigurationSchemaType>);
+            } & import("mobx-state-tree").IStateTreeNode<import("@jbrowse/core/configuration").AnyConfigurationSchemaType>);
+        } & import("mobx-state-tree").IStateTreeNode<import("@jbrowse/core/configuration").AnyConfigurationSchemaType>;
+        label: string;
+        assemblyNames: any;
+        type: string;
+        loc: FileLocation;
+    }[];
+} & {
+    setSelectedAssemblyName(s: string): void;
+    setFileSource(newSource: unknown): void;
+    setColumnNameLineNumber(newnumber: number): void;
+    setFileType(typeName: string): void;
+    setError(error: unknown): void;
+    setLoading(arg: boolean): void;
+    cancelButton(): void;
+    setCachedFileHandle(arg: FileLocation): void;
+} & {
+    import(assemblyName: string): Promise<void>;
+} & {
+    afterAttach(): void;
+}, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
+export type ImportWizardStateModel = ReturnType<typeof stateModelFactory>;
+export type ImportWizardModel = Instance<ImportWizardStateModel>;

package/dist/SpreadsheetView/ImportWizard.js

@@ -0,0 +1,240 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = stateModelFactory;
+const configuration_1 = require("@jbrowse/core/configuration");
+const util_1 = require("@jbrowse/core/util");
+const io_1 = require("@jbrowse/core/util/io");
+const tracks_1 = require("@jbrowse/core/util/tracks");
+const mobx_state_tree_1 = require("mobx-state-tree");
+const IMPORT_SIZE_LIMIT = 100000000;
+const fileTypes = ['VCF', 'BED', 'BEDPE', 'STAR-Fusion'];
+const fileTypeParsers = {
+    VCF: () => Promise.resolve().then(() => __importStar(require('./importAdapters/VcfImport'))).then(r => r.parseVcfBuffer),
+    BED: () => Promise.resolve().then(() => __importStar(require('./importAdapters/BedImport'))).then(r => r.parseBedBuffer),
+    BEDPE: () => Promise.resolve().then(() => __importStar(require('./importAdapters/BedpeImport'))).then(r => r.parseBedPEBuffer),
+    'STAR-Fusion': () => Promise.resolve().then(() => __importStar(require('./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() { }
+function stateModelFactory() {
+    return mobx_state_tree_1.types
+        .model('SpreadsheetImportWizard', {
+        fileType: mobx_state_tree_1.types.optional(mobx_state_tree_1.types.enumeration(fileTypes), 'VCF'),
+        hasColumnNameLine: true,
+        columnNameLineNumber: 1,
+        selectedAssemblyName: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.string),
+        cachedFileLocation: mobx_state_tree_1.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 } = (0, util_1.getSession)(self);
+            return !assemblyName
+                ? false
+                : assemblyManager.isValidRefName(refName, assemblyName);
+        },
+        tracksForAssembly(selectedAssembly) {
+            const session = (0, util_1.getSession)(self);
+            const { tracks = [], sessionTracks = [] } = session;
+            const allTracks = [
+                ...tracks,
+                ...sessionTracks,
+            ];
+            return allTracks
+                .map(track => {
+                const assemblyNames = (0, configuration_1.readConfObject)(track, 'assemblyNames');
+                const adapter = (0, configuration_1.readConfObject)(track, 'adapter');
+                const category = (0, configuration_1.readConfObject)(track, 'category').join(',');
+                const loc = getAdapterLoc(adapter);
+                return assemblyNames.includes(selectedAssembly) && loc
+                    ? {
+                        track,
+                        label: [
+                            category ? `[${category}]` : '',
+                            (0, tracks_1.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;
+            (0, mobx_state_tree_1.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 Promise.resolve().then(() => __importStar(require('@jbrowse/core/util')));
+            const { pluginManager } = (0, util_1.getEnv)(self);
+            const filehandle = (0, io_1.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);
+                (0, mobx_state_tree_1.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);
+                    (0, util_1.getSession)(self).notifyError(`${e}`, e);
+                }
+            })();
+        },
+    }));
+}

package/dist/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/dist/SpreadsheetView/SpreadsheetModel.js

@@ -0,0 +1,133 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = stateModelFactory;
+const react_1 = __importDefault(require("react"));
+const util_1 = require("@jbrowse/core/util");
+const mobx_1 = require("mobx");
+const mobx_state_tree_1 = require("mobx-state-tree");
+const LocationCell_1 = __importDefault(require("./components/LocationCell"));
+function stateModelFactory() {
+    return mobx_state_tree_1.types
+        .model('Spreadsheet', {
+        rowSet: mobx_state_tree_1.types.frozen(),
+        columns: mobx_state_tree_1.types.frozen(),
+        assemblyName: mobx_state_tree_1.types.maybe(mobx_state_tree_1.types.string),
+        visibleColumns: mobx_state_tree_1.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 = (0, util_1.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: (0, util_1.measureGridWidth)(rows.map(row => row.feature ? (0, util_1.assembleLocStringFast)(row.feature) : 0)) + 40,
+                        renderCell: ({ row }) => {
+                            const { feature } = row;
+                            return feature ? (react_1.default.createElement(LocationCell_1.default, { model: self, feature: feature })) : ('N/A');
+                        },
+                    },
+                    {
+                        field: 'Length',
+                        width: (0, util_1.measureGridWidth)(rows.map(r => r.feature ? (0, util_1.toLocale)(r.feature.end - r.feature.start) : 0)),
+                        valueGetter: (_val, row) => {
+                            return row.feature
+                                ? row.feature.end - row.feature.start
+                                : undefined;
+                        },
+                        valueFormatter: arg => (0, util_1.toLocale)(arg),
+                    },
+                    ...self.columns.map(f => ({
+                        field: f.name,
+                        width: (0, util_1.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() {
+            (0, mobx_state_tree_1.addDisposer)(self, (0, mobx_1.autorun)(async () => {
+                const session = (0, util_1.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;
+    });
+}