@jbrowse/plugin-bed 5.0.0-beta.1 → 5.0.0-beta.11

package/esm/BigBedTextSearchAdapter/index.js

@@ -0,0 +1,11 @@
+import TextSearchAdapterType from '@jbrowse/core/pluggableElementTypes/TextSearchAdapterType';
+import configSchema from './configSchema.js';
+export default function BigBedTextSearchAdapterF(pluginManager) {
+    pluginManager.addTextSearchAdapterType(() => new TextSearchAdapterType({
+        name: 'BigBedTextSearchAdapter',
+        displayName: 'BigBed text search adapter',
+        description: 'Searches a BigBed by its extra-indexed names',
+        configSchema,
+        getAdapterClass: () => import('./BigBedTextSearchAdapter.js').then(r => r.default),
+    }));
+}

package/esm/StarFusionAdapter/StarFusionAdapter.d.ts

@@ -1,15 +1,14 @@
 import { BaseFeatureDataAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
 import type { StarFusionAdapterConfig } from './configSchema.ts';
 import type { BaseOptions } from '@jbrowse/core/data_adapters/BaseAdapter';
-import type { Feature, IntervalTree, Region } from '@jbrowse/core/util';
+import type { Feature, Region } from '@jbrowse/core/util';
 export default class StarFusionAdapter extends BaseFeatureDataAdapter<StarFusionAdapterConfig> {
     private loadData;
-    protected intervalTrees: Record<string, Promise<IntervalTree<Feature> | undefined> | undefined>;
     static capabilities: string[];
     private loadDataP;
     getRefNames(opts?: BaseOptions): Promise<string[]>;
     private featureFromLine;
     private loadFeatureTreeP;
-    private loadFeatureTree;
+    private treeFeatures;
     getFeatures(query: Region, opts?: BaseOptions): import("rxjs").Observable<Feature>;
 }

package/esm/StarFusionAdapter/StarFusionAdapter.js

@@ -2,44 +2,10 @@ import { BaseFeatureDataAdapter, cachedSetup, } from '@jbrowse/core/data_adapter
 import { SimpleFeature, fetchAndMaybeUnzip } from '@jbrowse/core/util';
 import { openLocation } from '@jbrowse/core/util/io';
 import { parseLineByLine } from '@jbrowse/core/util/parseLineByLine';
+import { parseStarFusionBreakpoint, starFusionColumns, } from '@jbrowse/core/util/starFusion';
 import { buildPairedIntervalTree, intervalTreeFeatures, } from '../adapterUtil.js';
-/**
- * A STAR-Fusion `refName:pos:strand` breakpoint, read from the RIGHT: a refName
- * may contain colons. GRCh38's full analysis set names its HLA contigs
- * `HLA-A*01:01:01:01`, so a breakpoint on one arrives as
- * `HLA-A*01:01:01:01:5000:+` and splitting at the first colon read the contig as
- * `HLA-A*01`, the position as 1 and the strand as absent. Same rule
- * `parseSvAlt` applies to a BND mate locstring, one field further along.
- *
- * A string with fewer than three fields keeps what it always parsed to, so a
- * truncated or strandless row is no worse off than before.
- */
-function parseBreakpoint(str) {
-    const parts = str.split(':');
-    const strandStr = parts.length >= 3 ? parts.pop() : undefined;
-    const pos = parts.length >= 2 ? +parts.pop() : Number.NaN;
-    return {
-        refName: parts.join(':'),
-        start: pos,
-        end: pos + 1,
-        strand: strandStr === '+' ? 1 : strandStr === '-' ? -1 : undefined,
-    };
-}
-/**
- * Which way the sequence a breakpoint keeps runs from it, as the paired-arc
- * display's mate-direction tick (1 = right, -1 = left, 0 = unknown). A
- * breakpoint's strand in STAR-Fusion is its gene's transcription strand, and the
- * fusion transcript keeps the donor's sequence 5' of the junction and the
- * acceptor's 3' of it: so on a + strand donor the retained side is at lower
- * coordinates and on a + strand acceptor it is at higher ones.
- */
-function tickDirection(strand, isDonor) {
-    return strand === undefined ? 0 : isDonor ? -strand : strand;
-}
 export default class StarFusionAdapter extends BaseFeatureDataAdapter {
-    // No `label`: `fetchAndMaybeUnzip` narrates the download from inside.
     loadData = cachedSetup({ setup: opts => this.loadDataP(opts) });
-    intervalTrees = {};
     static capabilities = ['getFeatures', 'getRefNames'];
     async loadDataP(opts) {
         const buffer = await fetchAndMaybeUnzip(openLocation(this.getConf('starFusionLocation'), this.pluginManager), opts);
@@ -48,23 +14,19 @@ export default class StarFusionAdapter extends BaseFeatureDataAdapter {
         let rightIdx = -1;
         const feats1 = {};
         const feats2 = {};
-        parseLineByLine(buffer, line => {
-            if (line.startsWith('#')) {
-                columnNames = line.slice(1).split('\t');
+        parseLineByLine(buffer, (line, lineIndex) => {
+            if (lineIndex === 0) {
+                columnNames = starFusionColumns(line);
                 leftIdx = columnNames.indexOf('LeftBreakpoint');
                 rightIdx = columnNames.indexOf('RightBreakpoint');
             }
-            else if (leftIdx >= 0 && rightIdx >= 0) {
+            else if (!line.startsWith('#')) {
                 const cols = line.split('\t');
                 const left = cols[leftIdx];
                 const right = cols[rightIdx];
-                // through parseBreakpoint, so the bucket a row is filed under is the
-                // refName its feature will report -- a colon-bearing contig split two
-                // ways puts the row in a bucket no query can reach
-                const leftRef = left ? parseBreakpoint(left).refName : undefined;
-                const rightRef = right ? parseBreakpoint(right).refName : undefined;
-                if (leftRef && rightRef) {
-                    ;
+                if (left && right) {
+                    const leftRef = parseStarFusionBreakpoint(left, true).refName;
+                    const rightRef = parseStarFusionBreakpoint(right, false).refName;
                     (feats1[leftRef] ??= []).push(line);
                     (feats2[rightRef] ??= []).push(line);
                 }
@@ -80,27 +42,16 @@ export default class StarFusionAdapter extends BaseFeatureDataAdapter {
     featureFromLine(line, columnNames, uniqueId, flip) {
         const cols = line.split('\t');
         const row = Object.fromEntries(columnNames.map((name, i) => [name, cols[i]]));
-        const primaryBp = parseBreakpoint((flip ? row.RightBreakpoint : row.LeftBreakpoint));
-        const mateBp = parseBreakpoint((flip ? row.LeftBreakpoint : row.RightBreakpoint));
-        // the LeftBreakpoint is the donor, so this feature is the donor end of the
-        // junction whenever it is not flipped, and the mate is the other end
+        const donor = parseStarFusionBreakpoint(row.LeftBreakpoint, true);
+        const acceptor = parseStarFusionBreakpoint(row.RightBreakpoint, false);
+        const [primary, mate] = flip ? [acceptor, donor] : [donor, acceptor];
         return new SimpleFeature({
             uniqueId,
-            refName: primaryBp.refName,
-            start: primaryBp.start,
-            end: primaryBp.end,
-            strand: primaryBp.strand,
-            mateDirection: tickDirection(primaryBp.strand, !flip),
+            ...primary,
             name: row.FusionName,
             score: row.JunctionReadCount ? +row.JunctionReadCount : undefined,
             type: 'fusion',
-            mate: {
-                refName: mateBp.refName,
-                start: mateBp.start,
-                end: mateBp.end,
-                strand: mateBp.strand,
-                mateDirection: tickDirection(mateBp.strand, flip),
-            },
+            mate,
             ...row,
         });
     }
@@ -108,14 +59,8 @@ export default class StarFusionAdapter extends BaseFeatureDataAdapter {
         const { columnNames, feats1, feats2 } = await this.loadData();
         return buildPairedIntervalTree(feats1, feats2, refName, this.id, (line, uniqueId, flip) => this.featureFromLine(line, columnNames, uniqueId, flip));
     }
-    async loadFeatureTree(refName) {
-        this.intervalTrees[refName] ??= this.loadFeatureTreeP(refName).catch((e) => {
-            this.intervalTrees[refName] = undefined;
-            throw e;
-        });
-        return this.intervalTrees[refName];
-    }
-    getFeatures(query, opts = {}) {
-        return intervalTreeFeatures(query, opts, refName => this.loadFeatureTree(refName));
+    treeFeatures = intervalTreeFeatures(opts => this.loadData(opts), refName => this.loadFeatureTreeP(refName));
+    getFeatures(query, opts) {
+        return this.treeFeatures(query, opts);
     }
 }

package/esm/StarFusionAdapter/configSchema.d.ts

@@ -15,17 +15,16 @@ export declare function normalizeSnapshot(snap: Record<string, unknown>): Record
  * ```
  */
 declare const StarFusionAdapter: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
-    /**
-     * #slot
-     */
+    type: {
+        type: "string";
+    } & {
+        defaultValue: string;
+    };
     readonly starFusionLocation: {
-        readonly type: "fileLocation";
-        readonly description: "STAR-Fusion TSV output file (plain text or gzipped)";
-        readonly defaultValue: {
-            readonly uri: "/path/to/star-fusion.fusion_predictions.tsv";
-            readonly locationType: "UriLocation";
-        };
+        type: "fileLocation";
+    } & {
+        defaultValue: unknown;
     };
-}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
+}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined, true, import("@jbrowse/core/configuration").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>, any>>;
 export type StarFusionAdapterConfig = Instance<typeof StarFusionAdapter>;
 export default StarFusionAdapter;

package/esm/StarFusionAdapter/configSchema.js

@@ -1,15 +1,6 @@
-import { ConfigurationSchema } from '@jbrowse/core/configuration';
+import { ConfigurationSchema, expandUriShorthand, } from '@jbrowse/core/configuration';
 export function normalizeSnapshot(snap) {
-    return snap.uri
-        ? {
-            ...snap,
-            starFusionLocation: {
-                uri: snap.uri,
-                baseUri: snap.baseUri,
-                locationType: 'UriLocation',
-            },
-        }
-        : snap;
+    return expandUriShorthand(snap, 'starFusionLocation');
 }
 /**
  * #config StarFusionAdapter

package/esm/adapterUtil.d.ts

@@ -1,5 +1,5 @@
 import { IntervalTree } from '@jbrowse/core/util';
 import type { BaseOptions } from '@jbrowse/core/data_adapters/BaseAdapter';
 import type { Feature, Region } from '@jbrowse/core/util';
-export declare function intervalTreeFeatures(query: Region, opts: BaseOptions, loadTree: (refName: string) => Promise<IntervalTree<Feature> | undefined>): import("rxjs").Observable<Feature>;
+export declare function intervalTreeFeatures(loadData: (opts: BaseOptions) => Promise<unknown>, buildTree: (refName: string) => Promise<IntervalTree<Feature> | undefined>): (query: Region, opts?: BaseOptions) => import("rxjs").Observable<Feature>;
 export declare function buildPairedIntervalTree(feats1: Record<string, string[]>, feats2: Record<string, string[]>, refName: string, idPrefix: string, makeFeature: (line: string, uniqueId: string, flip: boolean) => Feature): IntervalTree<Feature>;

package/esm/adapterUtil.js

@@ -1,15 +1,30 @@
 import { IntervalTree } from '@jbrowse/core/util';
 import { ObservableCreate } from '@jbrowse/core/util/rxjs';
-// Emit the features of a per-refName interval tree that intersect the query.
-// Shared by the in-memory interval-tree adapters.
-export function intervalTreeFeatures(query, opts, loadTree) {
-    return ObservableCreate(async (observer) => {
+// `getFeatures` for an in-memory interval-tree adapter: one tree per refName,
+// built once and rebuilt after a failure. `loadData` is awaited with each
+// caller's opts ahead of the tree, so every fetch joins the whole-file load's
+// progress rather than only the one that started it.
+export function intervalTreeFeatures(loadData, buildTree) {
+    const trees = new Map();
+    const loadTree = (refName) => {
+        let tree = trees.get(refName);
+        if (tree === undefined) {
+            tree = buildTree(refName).catch((e) => {
+                trees.delete(refName);
+                throw e;
+            });
+            trees.set(refName, tree);
+        }
+        return tree;
+    };
+    return (query, opts = {}) => ObservableCreate(async (observer) => {
+        await loadData(opts);
         const tree = await loadTree(query.refName);
         for (const f of tree?.search([query.start, query.end]) ?? []) {
             observer.next(f);
         }
         observer.complete();
-    }, opts.stopToken);
+    }, opts.signal);
 }
 // Build one interval tree for a refName from paired-feature buckets, inserting
 // the records that start on this ref (feats1, flip=false) and those whose mate

package/esm/bedGraphUtil.d.ts

@@ -1,5 +1,5 @@
 import type { Feature } from '@jbrowse/core/util';
-export declare function makeBedGraphFeature({ uniqueId, refName, start, end, names, j, value, }: {
+export declare function makeBedGraphFeature({ uniqueId, refName, start, end, names, j, value, rowSource, }: {
     uniqueId: string;
     refName: string;
     start: number;
@@ -7,4 +7,5 @@ export declare function makeBedGraphFeature({ uniqueId, refName, start, end, nam
     names: string[];
     j: number;
     value: string;
+    rowSource?: string;
 }): Feature | undefined;

package/esm/bedGraphUtil.js

@@ -1,7 +1,9 @@
 import { SimpleFeature } from '@jbrowse/core/util';
 // Build a single-score bedGraph feature for value column j, or undefined when
-// the value is not numeric. Shared by BedGraphAdapter and BedGraphTabixAdapter.
-export function makeBedGraphFeature({ uniqueId, refName, start, end, names, j, value, }) {
+// the value is not numeric. A wide file names each value column's source in
+// its header; a tidy one has a `source` column naming each row's instead.
+// Shared by BedGraphAdapter and BedGraphTabixAdapter.
+export function makeBedGraphFeature({ uniqueId, refName, start, end, names, j, value, rowSource, }) {
     const score = +value;
     return Number.isNaN(score)
         ? undefined
@@ -12,7 +14,7 @@ export function makeBedGraphFeature({ uniqueId, refName, start, end, names, j, v
                 start,
                 end,
                 score,
-                source: names[j] || `col${j}`,
+                source: rowSource ?? (names[j] || `col${j}`),
             },
         });
 }

package/esm/copyExcept.d.ts

@@ -0,0 +1 @@
+export declare function copyExcept(data: Record<string, unknown>, excluded: ReadonlySet<string>): Record<string, unknown>;

package/esm/copyExcept.js

@@ -0,0 +1,11 @@
+// `const { a, b, ...rest } = data` in the same key order, which measured
+// slower on every BED line shape (benches/featureData.bench.ts)
+export function copyExcept(data, excluded) {
+    const out = {};
+    for (const key in data) {
+        if (!excluded.has(key)) {
+            out[key] = data[key];
+        }
+    }
+    return out;
+}

package/esm/generateBedMethylFeature.js

@@ -1,14 +1,19 @@
 import { parseStrand } from './util.js';
 // this uses modkit bedMethyl. unclear how to reliably detect minimal 9+2 bedMethyl
 export function isBedMethylFeature({ splitLine, start, end, }) {
+    if (splitLine.length < 18 ||
+        +splitLine[6] !== start ||
+        +splitLine[7] !== end) {
+        return false;
+    }
     // columns 9-17 are the nine numeric methylation stats
-    const nums = splitLine.slice(9, 18);
-    return (splitLine[6] !== undefined &&
-        +splitLine[6] === start &&
-        splitLine[7] !== undefined &&
-        +splitLine[7] === end &&
-        nums.length === 9 &&
-        nums.every(x => x && !Number.isNaN(+x)));
+    for (let i = 9; i < 18; i++) {
+        const x = splitLine[i];
+        if (!x || Number.isNaN(+x)) {
+            return false;
+        }
+    }
+    return true;
 }
 export function generateBedMethylFeature({ splitLine, uniqueId, refName, start, end, }) {
     // see

package/esm/generateRepeatMaskerFeature.d.ts

@@ -1,4 +1,17 @@
-declare const FIELDS: readonly ['bitsw_score', 'percent_div', 'percent_del', 'percent_ins', 'query_chr', 'query_begin', 'query_end', 'query_remaining', 'orientation', 'matching_repeat_name', 'matching_repeat_class', 'matching_repeat_begin', 'matching_repeat_end', 'matching_repeat_remaining', 'repeat_id'];
-export type RepeatMaskerFields = Record<(typeof FIELDS)[number], string>;
-export declare function parseRepeatMaskerDescription(desc: unknown): RepeatMaskerFields | undefined;
-export {};
+export declare function parseRepeatMaskerDescription(desc: unknown): {
+    bitsw_score: string;
+    percent_div: string;
+    percent_del: string;
+    percent_ins: string;
+    query_chr: string;
+    query_begin: string;
+    query_end: string;
+    query_remaining: string;
+    orientation: string;
+    matching_repeat_name: string;
+    matching_repeat_class: string;
+    matching_repeat_begin: string;
+    matching_repeat_end: string;
+    matching_repeat_remaining: string;
+    repeat_id: string;
+} | undefined;

package/esm/generateRepeatMaskerFeature.js

@@ -1,30 +1,33 @@
-const FIELDS = [
-    'bitsw_score',
-    'percent_div',
-    'percent_del',
-    'percent_ins',
-    'query_chr',
-    'query_begin',
-    'query_end',
-    'query_remaining',
-    'orientation',
-    'matching_repeat_name',
-    'matching_repeat_class',
-    'matching_repeat_begin',
-    'matching_repeat_end',
-    'matching_repeat_remaining',
-    'repeat_id',
-];
-// RepeatMasker .out-derived description: 15 space-separated fields with numeric
-// values at positions 0,1,2,3,5,6. Returns parsed fields or undefined if the
-// description doesn't match the format.
+const NUMERIC_PARTS = [0, 1, 2, 3, 5, 6];
+// RepeatMasker .out-derived description: 15 space-separated fields, numeric at
+// positions 0,1,2,3,5,6. A literal rather than an object built from the field
+// list, since this runs on every line of a RepeatMasker track.
 export function parseRepeatMaskerDescription(desc) {
-    if (typeof desc === 'string') {
-        const parts = desc.trim().split(' ');
-        const looksRight = [0, 1, 2, 3, 5, 6].every(i => parts[i] !== undefined && !Number.isNaN(+parts[i]));
-        if (looksRight) {
-            return Object.fromEntries(FIELDS.map((f, i) => [f, parts[i] ?? '']));
+    if (typeof desc !== 'string') {
+        return undefined;
+    }
+    const p = desc.trim().split(' ');
+    for (const i of NUMERIC_PARTS) {
+        const v = p[i];
+        if (v === undefined || Number.isNaN(+v)) {
+            return undefined;
         }
     }
-    return undefined;
+    return {
+        bitsw_score: p[0] ?? '',
+        percent_div: p[1] ?? '',
+        percent_del: p[2] ?? '',
+        percent_ins: p[3] ?? '',
+        query_chr: p[4] ?? '',
+        query_begin: p[5] ?? '',
+        query_end: p[6] ?? '',
+        query_remaining: p[7] ?? '',
+        orientation: p[8] ?? '',
+        matching_repeat_name: p[9] ?? '',
+        matching_repeat_class: p[10] ?? '',
+        matching_repeat_begin: p[11] ?? '',
+        matching_repeat_end: p[12] ?? '',
+        matching_repeat_remaining: p[13] ?? '',
+        repeat_id: p[14] ?? '',
+    };
 }

package/esm/generateUcscTranscript.js

@@ -1,9 +1,24 @@
-// type guard: narrows input fields to required + non-zero when true
+import { copyExcept } from './copyExcept.js';
+// type guard: narrows input fields to required when true
 // strand===0 means unstranded — likely not a gene
+//
+// Blocks are what make a transcript, and UCSC's own format definition calls
+// them exons. Thickness says whether the transcript CODES, which is a separate
+// axis: an lncRNA, a spliced EST and any other 12-column feature with
+// thickStart===thickEnd is a transcript by every structural measure, so it is
+// not tested here. `generateUcscTranscript` reads the same equality to emit
+// exons and no CDS.
+//
+// This does conflate a spliced alignment with a transcript, deliberately: a
+// bigPsl track (`est`, `intronEst`, `mrna`, `xenoMrna`, IsoSeq) has an empty
+// thick range too, so it promotes where the same alignment as GFF3
+// `cDNA_match` does not. BED12 carries no column that separates one from an
+// lncRNA, and the promotion stays honest without one — no CDS children, so the
+// sequence panel withholds CDS and protein and HGVS stays `n.`, and the type
+// is `transcript` rather than `mRNA`.
 export function isUcscTranscript(input) {
     return (input.thickStart !== undefined &&
         input.thickEnd !== undefined &&
-        input.thickStart !== input.thickEnd &&
         input.blockCount !== undefined &&
         input.blockCount > 0 &&
         input.strand !== undefined &&
@@ -32,8 +47,26 @@ function parseFrames(frames) {
         ? frames.replace(/,$/, '').split(',').map(Number)
         : frames;
 }
+const TRANSCRIPT_OWN = new Set([
+    'strand',
+    'uniqueId',
+    'start',
+    'end',
+    'thickStart',
+    'thickEnd',
+    'refName',
+    'subfeatures',
+    'chrom',
+    'chromStart',
+    'chromEnd',
+    'chromStarts',
+    'blockStarts',
+    'blockSizes',
+    'blockCount',
+]);
 export function generateUcscTranscript(data) {
-    const { strand, uniqueId, start, end, thickStart, thickEnd, refName, subfeatures: oldSubfeatures, chrom, chromStart, chromEnd, chromStarts, blockStarts, blockSizes, blockCount, ...rest } = data;
+    const { strand, uniqueId, start, end, thickStart, thickEnd, refName, subfeatures: oldSubfeatures, } = data;
+    const rest = copyExcept(data, TRANSCRIPT_OWN);
     // exonFrames from bigGenePred - the @gmod/bed parser returns it in genomic order.
     // _exonFrames fallback supports BED files that use the underscore-prefixed column
     // name, which the parser leaves as raw text because it is not a standard column.
@@ -43,8 +76,22 @@ export function generateUcscTranscript(data) {
         .sort((a, b) => a.start - b.start);
     const fiveUTR = strand > 0 ? 'five_prime_UTR' : 'three_prime_UTR';
     const threeUTR = strand > 0 ? 'three_prime_UTR' : 'five_prime_UTR';
+    // thickStart===thickEnd is UCSC for no coding region, and the block walk
+    // below cannot express that: a thick point inside a block would emit a
+    // zero-length CDS carrying a phase, and one outside every block would make
+    // the whole transcript UTR.
+    //
+    // cdsStartStat and cdsEndStat `none` alone do not mean non-coding: UCSC's
+    // GENCODE bigGenePred (gencodeV44.bb through V50) writes `none` on every
+    // transcript, and reading it as non-coding stripped the CDS from all 370,886
+    // of V50's coding ones, TP53 included. exonFrames tells them apart there:
+    // every coding transcript has a block with a frame, every other one has -1
+    // throughout.
     const { cdsEndStat, cdsStartStat } = rest;
-    if (cdsStartStat === 'none' && cdsEndStat === 'none') {
+    if (thickStart === thickEnd ||
+        (cdsStartStat === 'none' &&
+            cdsEndStat === 'none' &&
+            !exonFrames?.some(frame => frame >= 0))) {
         return {
             ...rest,
             uniqueId,

package/esm/index.js

@@ -5,6 +5,7 @@ import BedGraphTabixAdapterF from './BedGraphTabixAdapter/index.js';
 import BedTabixAdapterF from './BedTabixAdapter/index.js';
 import BedpeAdapterF from './BedpeAdapter/index.js';
 import BigBedAdapterF from './BigBedAdapter/index.js';
+import BigBedTextSearchAdapterF from './BigBedTextSearchAdapter/index.js';
 import StarFusionAdapterF from './StarFusionAdapter/index.js';
 export { default as BedTabixAdapter } from './BedTabixAdapter/BedTabixAdapter.js';
 export { default as bedTabixConfigSchema } from './BedTabixAdapter/configSchema.js';
@@ -12,6 +13,7 @@ export default class BedPlugin extends Plugin {
     name = 'BedPlugin';
     install(pluginManager) {
         BigBedAdapterF(pluginManager);
+        BigBedTextSearchAdapterF(pluginManager);
         BedAdapterF(pluginManager);
         BedpeAdapterF(pluginManager);
         StarFusionAdapterF(pluginManager);

package/esm/util.js

@@ -1,5 +1,6 @@
 import BED from '@gmod/bed';
 import { parseLineByLine } from '@jbrowse/core/util/parseLineByLine';
+import { copyExcept } from './copyExcept.js';
 import { generateBedMethylFeature, isBedMethylFeature, } from './generateBedMethylFeature.js';
 import { generateRastairMethylFeature, isRastairMethylFeature, } from './generateRastairMethylFeature.js';
 import { parseRepeatMaskerDescription } from './generateRepeatMaskerFeature.js';
@@ -99,6 +100,17 @@ export function parseStrand(strand) {
     }
     return 0;
 }
+const BED_OWN = new Set(['strand', 'score', 'chrom', 'chromStart', 'chromEnd']);
+const REPEAT_OWN = new Set([
+    ...BED_OWN,
+    'description',
+    'chromStarts',
+    'blockSizes',
+    'blockStarts',
+    'blockCount',
+    'thickStart',
+    'thickEnd',
+]);
 export function featureData({ splitLine, refName, start, end, parser, uniqueId, scoreColumn, names, disableGeneHeuristic, }) {
     // bedMethyl detection runs on raw splitLine before parsing
     if (isBedMethylFeature({ splitLine, start, end })) {
@@ -122,15 +134,13 @@ export function featureData({ splitLine, refName, start, end, parser, uniqueId,
         });
     }
     const data = parser.parseLine(splitLine, { uniqueId });
-    const { strand: strandRaw, score: scoreRaw, chrom, chromStart, chromEnd, ...rest } = data;
-    const strand = parseStrand(strandRaw);
-    const rawScore = scoreColumn ? data[scoreColumn] : scoreRaw;
+    const strand = parseStrand(data.strand);
+    const rawScore = scoreColumn ? data[scoreColumn] : data.score;
     const score = rawScore === undefined ? undefined : Number(rawScore);
-    const repeat = parseRepeatMaskerDescription(rest.description);
+    const repeat = parseRepeatMaskerDescription(data.description);
     if (repeat) {
-        const { description, chromStarts, blockSizes, blockStarts, blockCount, thickStart, thickEnd, ...rest2 } = rest;
         return {
-            ...rest2,
+            ...copyExcept(data, REPEAT_OWN),
             ...repeat,
             uniqueId,
             score,
@@ -140,22 +150,23 @@ export function featureData({ splitLine, refName, start, end, parser, uniqueId,
             refName,
         };
     }
-    const subfeatures = rest.blockCount
+    const rest = copyExcept(data, BED_OWN);
+    const subfeatures = data.blockCount
         ? makeBlocks({
             start,
             uniqueId,
             refName,
-            chromStarts: rest.chromStarts,
-            blockCount: rest.blockCount,
-            blockSizes: rest.blockSizes,
-            blockStarts: rest.blockStarts,
+            chromStarts: data.chromStarts,
+            blockCount: data.blockCount,
+            blockSizes: data.blockSizes,
+            blockStarts: data.blockStarts,
         })
         : undefined;
     const transcriptCheck = {
         strand,
-        blockCount: rest.blockCount,
-        thickStart: rest.thickStart,
-        thickEnd: rest.thickEnd,
+        blockCount: data.blockCount,
+        thickStart: data.thickStart,
+        thickEnd: data.thickEnd,
     };
     if (!disableGeneHeuristic &&
         subfeatures &&

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbrowse/plugin-bed",
-  "version": "5.0.0-beta.1",
+  "version": "5.0.0-beta.11",
   "type": "module",
   "description": "JBrowse 2 bed adapters, tracks, etc.",
   "keywords": [
@@ -21,13 +21,18 @@
     "esm"
   ],
   "dependencies": {
-    "@gmod/bbi": "^11.2.3",
-    "@gmod/bed": "^2.3.0",
-    "@gmod/tabix": "^3.8.2",
-    "@jbrowse/mobx-state-tree": "^6.5.1",
-    "mobx": "^7.0.3",
+    "@gmod/bbi": "^11.3.0",
+    "@gmod/bed": "^2.3.1",
+    "@gmod/tabix": "^3.9.1",
+    "@gmod/trix": "^3.0.22",
+    "@jbrowse/mobx-state-tree": "^6.7.0",
+    "mobx": "^7.0.5",
     "rxjs": "^7.8.2",
-    "@jbrowse/core": "^5.0.0-beta.1"
+    "@jbrowse/core": "^5.0.0-beta.11"
+  },
+  "peerDependencies": {
+    "react": ">=19.0.0",
+    "react-dom": ">=19.0.0"
   },
   "publishConfig": {
     "access": "public"