@jbrowse/plugin-spreadsheet-view 2.17.0 → 3.0.0

package/dist/SpreadsheetView/importAdapters/BedImport.js

@@ -1,144 +1,58 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.removeBedHeaders = removeBedHeaders;
 exports.parseBedBuffer = parseBedBuffer;
-exports.parseBedPEBuffer = parseBedPEBuffer;
-const ImportUtils_1 = require("./ImportUtils");
-const browserBytes = 'browser '.split('').map(c => c.charCodeAt(0));
-const trackBytes = 'track '.split('').map(c => c.charCodeAt(0));
-const commentBytes = '#'.split('').map(c => c.charCodeAt(0));
-function bytesAreFoundAt(position, buffer, bytes) {
-    let i = 0;
-    for (; i < bytes.length; i += 1) {
-        if (buffer[position + i] !== bytes[i]) {
-            return false;
-        }
-    }
-    return true;
-}
-function removeBedHeaders(buffer) {
-    // slice off the first lines of the buffer if it starts with one or more
-    // header lines
-    let i = 0;
-    for (; i < buffer.length; i += 1) {
-        if (bytesAreFoundAt(i, buffer, browserBytes) ||
-            bytesAreFoundAt(i, buffer, trackBytes) ||
-            bytesAreFoundAt(i, buffer, commentBytes)) {
-            // consume up to the next newline
-            do {
-                i += 1;
-            } while (buffer[i] !== 10);
-        }
-        else {
-            // end of headers, return
-            break;
-        }
-    }
-    if (i) {
-        return buffer.subarray(i);
-    }
-    return buffer;
-}
-async function parseBedBuffer(buffer, options) {
-    const b = removeBedHeaders(buffer);
-    const data = await (0, ImportUtils_1.parseTsvBuffer)(b);
-    const bedColumns = [
-        { name: 'chrom', dataType: { type: 'LocRef' } },
-        { name: 'chromStart', dataType: { type: 'LocStart' } },
-        { name: 'chromEnd', dataType: { type: 'LocEnd' } },
-        { name: 'name', dataType: { type: 'Text' } },
-        { name: 'score', dataType: { type: 'Number' } },
-        { name: 'strand', dataType: { type: 'Text' } },
-    ];
-    data.columns.forEach((col, colNumber) => {
-        const bedColumn = bedColumns[colNumber];
-        if (bedColumn) {
-            col.name = bedColumn.name;
-            col.dataType = bedColumn.dataType;
-        }
-    });
-    data.hasColumnNames = true;
-    data.assemblyName = options.selectedAssemblyName;
-    data.columnDisplayOrder.push(data.columnDisplayOrder.length);
-    data.columns.unshift({
-        name: 'Location',
-        dataType: { type: 'LocString' },
-        isDerived: true,
-        derivationFunctionText: `jexl:{text:row.cells[0].text+':'+row.cells[1].text+'..'+row.cells[2].text,\n
-    extendedData: {refName: row.cells.ref.text, start: parseInt(row.cells.start.text,10), end: parseInt(row.cells.end.text,10)}}`,
-    });
-    return data;
-}
-async function parseBedPEBuffer(buffer, options) {
-    const b = removeBedHeaders(buffer);
-    const data = await (0, ImportUtils_1.parseTsvBuffer)(b);
-    const bedColumns = [
-        { name: 'chrom1', dataType: { type: 'Text' }, featureField: ['refName'] },
-        { name: 'start1', dataType: { type: 'Number' }, featureField: ['start'] },
-        { name: 'end1', dataType: { type: 'Number' }, featureField: ['end'] },
-        {
-            name: 'chrom2',
-            dataType: { type: 'Text' },
-            featureField: ['mate', 'refName'],
-        },
-        {
-            name: 'start2',
-            dataType: { type: 'Number' },
-            featureField: ['mate', 'start'],
-        },
-        {
-            name: 'end2',
-            dataType: { type: 'Number' },
-            featureField: ['mate', 'end'],
-        },
-        { name: 'name', dataType: { type: 'Text' }, featureField: ['name'] },
-        { name: 'score', dataType: { type: 'Number' }, featureField: ['score'] },
-        { name: 'strand1', dataType: { type: 'Text' }, featureField: ['strand'] },
-        {
-            name: 'strand2',
-            dataType: { type: 'Text' },
-            featureField: ['mate', 'strand'],
+const isNumber_1 = require("./isNumber");
+const util_1 = require("./util");
+function parseBedBuffer(buffer) {
+    var _a, _b;
+    const lines = (0, util_1.bufferToLines)(buffer);
+    const rest = lines.filter(line => !(line.startsWith('#') ||
+        line.startsWith('browser') ||
+        line.startsWith('track')));
+    const lastHeaderLine = lines.findLast(line => line.startsWith('#'));
+    const coreColumns = ['refName', 'start', 'end'];
+    const numExtraColumns = Math.max(0, (((_b = (_a = rest[0]) === null || _a === void 0 ? void 0 : _a.split('\t')) === null || _b === void 0 ? void 0 : _b.length) || 0) - coreColumns.length);
+    const extraNames = (lastHeaderLine === null || lastHeaderLine === void 0 ? void 0 : lastHeaderLine.includes('\t'))
+        ? lastHeaderLine
+            .slice(1)
+            .split('\t')
+            .slice(coreColumns.length)
+            .map(t => t.trim())
+        : Array.from({ length: numExtraColumns }, (_v, i) => `field_${i}`);
+    const colNames = [...coreColumns, ...extraNames];
+    return {
+        columns: colNames.map(c => ({ name: c })),
+        rowSet: {
+            rows: rest.map((line, idx) => {
+                const cols = line.split('\t');
+                return {
+                    cellData: {
+                        refName: cols[0],
+                        start: +cols[1],
+                        end: +cols[2],
+                        name: cols[3],
+                        score: cols[4],
+                        strand: cols[5],
+                        ...Object.fromEntries(extraNames.map((n, idx) => {
+                            const r = cols[idx + coreColumns.length];
+                            return [n, (0, isNumber_1.isNumber)(r) ? +r : r];
+                        })),
+                    },
+                    feature: {
+                        uniqueId: `bed-${idx}`,
+                        refName: cols[0],
+                        start: +cols[1],
+                        end: +cols[2],
+                        name: cols[3],
+                        score: cols[4],
+                        strand: (0, util_1.parseStrand)(cols[5]),
+                        ...Object.fromEntries(extraNames.map((n, idx) => {
+                            const r = cols[idx + coreColumns.length];
+                            return [n, (0, isNumber_1.isNumber)(r) ? +r : r];
+                        })),
+                    },
+                };
+            }),
         },
-    ];
-    data.columns.forEach((col, colNumber) => {
-        const bedColumn = bedColumns[colNumber];
-        if (bedColumn) {
-            col.name = bedColumn.name;
-            col.dataType = bedColumn.dataType;
-        }
-    });
-    data.hasColumnNames = true;
-    // decorate each row with a feature object in its extendedData
-    data.rowSet.rows.forEach((row, rowNumber) => {
-        const featureData = {};
-        row.cells.forEach(({ text }, columnNumber) => {
-            const bedColumn = bedColumns[columnNumber];
-            const val = bedColumn && bedColumn.dataType.type === 'Number' && text
-                ? Number.parseFloat(text)
-                : text;
-            if (bedColumn) {
-                // a predefined column
-                if (bedColumn.featureField.length === 2) {
-                    if (!featureData[bedColumn.featureField[0]]) {
-                        featureData[bedColumn.featureField[0]] = {};
-                    }
-                    featureData[bedColumn.featureField[0]][bedColumn.featureField[1]] =
-                        val;
-                }
-                else {
-                    featureData[bedColumn.featureField[0]] = val;
-                }
-            }
-            else {
-                // some other column
-                featureData[`column${columnNumber + 1}`] = val;
-            }
-        });
-        featureData.uniqueId = `bedpe-${rowNumber}`;
-        row.extendedData = {
-            feature: featureData,
-        };
-    });
-    data.assemblyName = options.selectedAssemblyName;
-    return data;
+    };
 }

package/dist/SpreadsheetView/importAdapters/BedpeImport.d.ts

@@ -0,0 +1,36 @@
+export declare function parseBedPEBuffer(buffer: Uint8Array): {
+    columns: {
+        name: string;
+    }[];
+    rowSet: {
+        rows: {
+            cellData: {
+                refName: string | undefined;
+                start: string | undefined;
+                end: string | undefined;
+                mateRefName: string | undefined;
+                mateStart: string | undefined;
+                mateEnd: string | undefined;
+                name: string | undefined;
+                score: string | number | undefined;
+                strand: string | undefined;
+                mateStrand: string | undefined;
+            };
+            feature: {
+                uniqueId: string;
+                refName: string | undefined;
+                start: number;
+                end: number;
+                strand: number | undefined;
+                mate: {
+                    refName: string | undefined;
+                    start: number;
+                    end: number;
+                    strand: number | undefined;
+                };
+                name: string | undefined;
+                score: string | undefined;
+            };
+        }[];
+    };
+};

package/dist/SpreadsheetView/importAdapters/BedpeImport.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBedPEBuffer = parseBedPEBuffer;
+const internals_1 = require("@mui/x-data-grid/internals");
+const util_1 = require("./util");
+function parseBedPEBuffer(buffer) {
+    var _a, _b;
+    const lines = (0, util_1.bufferToLines)(buffer);
+    const rest = lines.filter(line => !(line.startsWith('#') ||
+        line.startsWith('browser') ||
+        line.startsWith('track')));
+    const lastHeaderLine = lines.findLast(line => line.startsWith('#'));
+    const coreColumns = [
+        'refName',
+        'start',
+        'end',
+        'mateRef',
+        'mateStart',
+        'mateEnd',
+        'name',
+        'score',
+        'strand',
+        'mateStrand',
+    ];
+    const numExtraColumns = Math.max(0, (((_b = (_a = rest[0]) === null || _a === void 0 ? void 0 : _a.split('\t')) === null || _b === void 0 ? void 0 : _b.length) || 0) - coreColumns.length);
+    const extraNames = (lastHeaderLine === null || lastHeaderLine === void 0 ? void 0 : lastHeaderLine.includes('\t'))
+        ? lastHeaderLine
+            .slice(1)
+            .split('\t')
+            .slice(coreColumns.length)
+            .map(t => t.trim())
+        : Array.from({ length: numExtraColumns }, (_v, i) => `field_${i}`);
+    const colNames = [...coreColumns, ...extraNames];
+    return {
+        columns: colNames.map(c => ({ name: c })),
+        rowSet: {
+            rows: rest.map((line, idx) => {
+                const cols = line.split('\t');
+                return {
+                    cellData: {
+                        refName: cols[0],
+                        start: cols[1],
+                        end: cols[2],
+                        mateRefName: cols[3],
+                        mateStart: cols[4],
+                        mateEnd: cols[5],
+                        name: cols[6],
+                        score: +cols[7] || cols[7],
+                        strand: cols[8],
+                        mateStrand: cols[9],
+                        ...Object.fromEntries(extraNames.map((n, idx) => {
+                            const r = cols[idx + coreColumns.length];
+                            return [n, (0, internals_1.isNumber)(r) ? +r : r];
+                        })),
+                    },
+                    feature: {
+                        uniqueId: `bedpe-${idx}`,
+                        refName: cols[0],
+                        start: +cols[1],
+                        end: +cols[2],
+                        strand: (0, util_1.parseStrand)(cols[8]),
+                        mate: {
+                            refName: cols[3],
+                            start: +cols[4],
+                            end: +cols[5],
+                            strand: (0, util_1.parseStrand)(cols[9]),
+                        },
+                        name: cols[6],
+                        score: cols[7],
+                        ...Object.fromEntries(extraNames.map((n, idx) => {
+                            const r = cols[idx + coreColumns.length];
+                            return [n, (0, internals_1.isNumber)(r) ? +r : r];
+                        })),
+                    },
+                };
+            }),
+        },
+    };
+}

package/dist/SpreadsheetView/importAdapters/STARFusionImport.d.ts

@@ -1,9 +1,25 @@
-import { ParseOptions } from './ImportUtils';
-import type { Buffer } from 'buffer';
-export declare function parseSTARFusionBuffer(buffer: Buffer, options: ParseOptions): Promise<{
-    rowSet: import("./ImportUtils").RowSet;
-    columnDisplayOrder: number[];
-    hasColumnNames: boolean;
-    columns: import("./ImportUtils").Column[];
-    assemblyName: string | undefined;
-}>;
+export declare function parseSTARFusionBuffer(buffer: Uint8Array): {
+    columns: {
+        name: string;
+    }[];
+    rowSet: {
+        rows: {
+            cellData: {
+                [k: string]: string | number;
+            };
+            feature: {
+                mate: {
+                    refName: string | undefined;
+                    start: number;
+                    end: number;
+                    strand: number | undefined;
+                };
+                refName: string | undefined;
+                start: number;
+                end: number;
+                strand: number | undefined;
+                uniqueId: string;
+            };
+        }[];
+    };
+};

package/dist/SpreadsheetView/importAdapters/STARFusionImport.js

@@ -1,70 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseSTARFusionBuffer = parseSTARFusionBuffer;
-const ImportUtils_1 = require("./ImportUtils");
+const isNumber_1 = require("./isNumber");
+const util_1 = require("./util");
 function parseSTARFusionBreakpointString(str) {
     const fields = str.split(':');
-    const refName = fields[0];
-    const pos = Number.parseInt(fields[1], 10);
-    const strand = fields[2] === '-' ? -1 : 1;
-    return { refName, pos, strand };
+    return {
+        refName: fields[0],
+        start: +fields[1],
+        end: +fields[1] + 1,
+        strand: (0, util_1.parseStrand)(fields[2]),
+    };
 }
-const numericColumns = {
-    SpanningFragCount: true,
-    FFPM: true,
-    LeftBreakEntropy: true,
-    RightBreakEntropy: true,
-    JunctionReadCount: true,
-};
-async function parseSTARFusionBuffer(buffer, options) {
-    const data = await (0, ImportUtils_1.parseTsvBuffer)(buffer, {
-        hasColumnNameLine: true,
-        columnNameLineNumber: 1,
-        selectedAssemblyName: options.selectedAssemblyName,
-        isValidRefName: () => false,
-    });
-    // remove the # in #FusionName
-    data.columns[0].name = data.columns[0].name.replace('#', '');
-    // set some columns to be numeric
-    data.columns.forEach(col => {
-        if (numericColumns[col.name]) {
-            col.dataType = { type: 'Number' };
-        }
-    });
-    // decorate each row with a feature object in its extendedData
-    data.rowSet.rows.forEach((row, rowNumber) => {
-        const featureData = {};
-        row.cells.forEach(({ text }, columnNumber) => {
-            const column = data.columns[columnNumber];
-            if (column.name === 'LeftBreakpoint' && text) {
-                const { refName, pos, strand } = parseSTARFusionBreakpointString(text);
-                featureData.refName = refName;
-                featureData.start = pos;
-                featureData.end = pos;
-                featureData.strand = strand;
-            }
-            else if (column.name === 'RightBreakpoint' && text) {
-                const { refName, pos, strand } = parseSTARFusionBreakpointString(text);
-                featureData.mate = {
-                    refName,
-                    start: pos,
-                    end: pos,
-                    strand,
+function parseSTARFusionBuffer(buffer) {
+    const lines = (0, util_1.bufferToLines)(buffer);
+    const columns = lines[0].slice(1).split('\t');
+    return {
+        columns: columns.map(c => ({ name: c })),
+        rowSet: {
+            rows: lines.slice(1).map((line, rowNumber) => {
+                const cols = line.split('\t');
+                const row = Object.fromEntries(columns.map((h, i) => [h, (0, isNumber_1.isNumber)(cols[i]) ? +cols[i] : cols[i]]));
+                return {
+                    cellData: row,
+                    feature: {
+                        uniqueId: `sf-${rowNumber}`,
+                        ...parseSTARFusionBreakpointString(row.LeftBreakpoint),
+                        mate: parseSTARFusionBreakpointString(row.RightBreakpoint),
+                    },
                 };
-            }
-            else if (text && numericColumns[column.name]) {
-                // some other column, numeric
-                featureData[column.name] = Number.parseFloat(text);
-            }
-            else {
-                // some other column, text
-                featureData[column.name] = text;
-            }
-        });
-        featureData.uniqueId = `sf-${rowNumber + 1}`;
-        row.extendedData = {
-            feature: featureData,
-        };
-    });
-    return data;
+            }),
+        },
+    };
 }

package/dist/SpreadsheetView/importAdapters/VcfImport.d.ts

@@ -1,13 +1,20 @@
-import { RowSet, Column, ParseOptions } from './ImportUtils';
-import type { Buffer } from 'buffer';
-export declare function parseVcfBuffer(buffer: Buffer, options?: ParseOptions): {
-    rowSet: RowSet;
-    columnDisplayOrder: number[];
-    hasColumnNames: boolean;
-    columns: Column[];
-    assemblyName: string | undefined;
-};
-export declare function splitVcfFileHeaderAndBody(wholeFile: string): {
-    header: string;
-    body: string;
+export declare function parseVcfBuffer(buffer: Uint8Array): {
+    columns: {
+        name: string;
+    }[];
+    rowSet: {
+        rows: {
+            cellData: {
+                CHROM: string | undefined;
+                POS: number;
+                ID: string | undefined;
+                REF: string | undefined;
+                ALT: string | undefined;
+                QUAL: string | number | undefined;
+                FILTER: string | undefined;
+                FORMAT: string | undefined;
+            };
+            feature: any;
+        }[];
+    };
 };

package/dist/SpreadsheetView/importAdapters/VcfImport.js

@@ -4,108 +4,63 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseVcfBuffer = parseVcfBuffer;
-exports.splitVcfFileHeaderAndBody = splitVcfFileHeaderAndBody;
 const vcf_1 = __importDefault(require("@gmod/vcf"));
 const plugin_variants_1 = require("@jbrowse/plugin-variants");
-const ImportUtils_1 = require("./ImportUtils");
-const vcfCoreColumns = [
-    { name: 'CHROM', type: 'Text' }, // 0
-    { name: 'POS', type: 'Number' }, // 1
-    { name: 'ID', type: 'Text' }, // 2
-    { name: 'REF', type: 'Text' }, // 3
-    { name: 'ALT', type: 'Text' }, // 4
-    { name: 'QUAL', type: 'Number' }, // 5
-    { name: 'FILTER', type: 'Text' }, // 6
-    { name: 'INFO', type: 'Text' }, // 7
-    { name: 'FORMAT', type: 'Text' }, // 8
-];
-function vcfRecordToRow(vcfParser, line, lineNumber) {
-    const vcfVariant = vcfParser.parseLine(line);
-    const vcfFeature = new plugin_variants_1.VcfFeature({
-        variant: vcfVariant,
-        parser: vcfParser,
-        id: `vcf-${lineNumber}`,
-    });
-    const data = line.split('\t').map(d => (d === '.' ? '' : d));
-    // no format column, add blank
-    if (data.length === 8) {
-        data.push('');
-    }
-    const row = {
-        id: String(lineNumber + 1),
-        extendedData: { vcfFeature: vcfFeature.toJSON() },
-        cells: data.map((text, columnNumber) => {
-            return {
-                columnNumber,
-                text,
-            };
-        }),
-    };
-    return row;
-}
-function parseVcfBuffer(buffer, options = {}) {
-    const { selectedAssemblyName } = options;
-    let { header, body } = splitVcfFileHeaderAndBody((0, ImportUtils_1.bufferToString)(buffer));
-    const rows = [];
+const isNumber_1 = require("./isNumber");
+const util_1 = require("./util");
+function parseVcfBuffer(buffer) {
+    const lines = (0, util_1.bufferToLines)(buffer);
+    const header = lines.filter(l => l.startsWith('#')).join('\n');
+    const body = lines.filter(l => !l.startsWith('#'));
     const vcfParser = new vcf_1.default({ header });
-    header = ''; // garbage collect
-    body.split(/\n|\r\n|\r/).forEach((line, lineNumber) => {
-        if (/\S/.test(line)) {
-            rows.push(vcfRecordToRow(vcfParser, line, lineNumber));
-        }
-    });
-    body = ''; // garbage collect
-    const rowSet = {
-        isLoaded: true,
-        rows,
-    };
-    const columnDisplayOrder = [];
-    const columns = [];
-    for (let i = 0; i < vcfCoreColumns.length; i += 1) {
-        columnDisplayOrder.push(i);
-        columns[i] = {
-            name: vcfCoreColumns[i].name,
-            dataType: { type: vcfCoreColumns[i].type },
-        };
-    }
-    for (let i = 0; i < vcfParser.samples.length; i += 1) {
-        const oi = vcfCoreColumns.length + i;
-        columnDisplayOrder.push(oi);
-        columns[oi] = {
-            name: vcfParser.samples[i],
-            dataType: { type: 'Text' },
-        };
-    }
-    columnDisplayOrder.push(columnDisplayOrder.length);
-    columns.unshift({
-        name: 'Location',
-        dataType: { type: 'LocString' },
-        isDerived: true,
-        derivationFunctionText: `jexl:{text:row.extendedData.vcfFeature.refName+':'\n
-    +row.extendedData.vcfFeature.start+'..'+row.extendedData.vcfFeature.end, extendedData:\n
-    {refName:row.extendedData.vcfFeature.refName,start:row.extendedData.vcfFeature.start,end:row.extendedData.vcfFeature.end}}`,
-    });
-    return {
-        rowSet,
-        columnDisplayOrder,
-        hasColumnNames: true,
-        columns,
-        assemblyName: selectedAssemblyName,
-    };
-}
-function splitVcfFileHeaderAndBody(wholeFile) {
-    // split into header and the rest of the file
-    let headerEndIndex = 0;
-    let prevChar;
-    for (; headerEndIndex < wholeFile.length; headerEndIndex += 1) {
-        const c = wholeFile[headerEndIndex];
-        if (prevChar === '\n' && c !== '#') {
-            break;
-        }
-        prevChar = c;
+    const keys = new Set();
+    const rows = [];
+    let i = 0;
+    for (const line of body) {
+        const [CHROM, POS, ID, REF, ALT, QUAL, FILTER, INFO, FORMAT, ...rest] = line.split('\t');
+        const ret = Object.fromEntries((INFO === null || INFO === void 0 ? void 0 : INFO.split(';').map(f => f.trim()).map(e => {
+            const [key, val = 'true'] = e.split('=');
+            const k = `INFO.${key.trim()}`;
+            keys.add(k);
+            const v = val.trim();
+            return [k, (0, isNumber_1.isNumber)(v) ? +v : v];
+        })) || []);
+        rows.push({
+            cellData: {
+                CHROM,
+                POS: +POS,
+                ID,
+                REF,
+                ALT,
+                QUAL: (0, isNumber_1.isNumber)(QUAL) ? +QUAL : QUAL,
+                FILTER,
+                FORMAT,
+                ...ret,
+                ...Object.fromEntries(vcfParser.samples.map((s, idx) => [s, rest[idx]])),
+            },
+            feature: new plugin_variants_1.VcfFeature({
+                parser: vcfParser,
+                variant: vcfParser.parseLine(line),
+                id: `vcf-${i}`,
+            }).toJSON(),
+        });
+        i++;
     }
     return {
-        header: wholeFile.slice(0, Math.max(0, headerEndIndex)),
-        body: wholeFile.slice(headerEndIndex),
+        columns: [
+            'CHROM',
+            'POS',
+            'ID',
+            'REF',
+            'ALT',
+            'QUAL',
+            'FILTER',
+            ...keys,
+            'FORMAT',
+            ...vcfParser.samples,
+        ].map(c => ({ name: c })),
+        rowSet: {
+            rows,
+        },
     };
 }

package/dist/SpreadsheetView/importAdapters/isNumber.d.ts

@@ -0,0 +1 @@
+export declare function isNumber(num: unknown): num is number;