@jbrowse/plugin-bed 4.3.0 → 5.0.0-beta.2

package/esm/BedAdapter/BedAdapter.d.ts

@@ -1,32 +1,17 @@
-import BED from '@gmod/bed';
 import { BaseFeatureDataAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
 import { IntervalTree } from '@jbrowse/core/util';
+import type { BedAdapterConfig } from './configSchema.ts';
 import type { BaseOptions } from '@jbrowse/core/data_adapters/BaseAdapter';
 import type { Feature, Region } from '@jbrowse/core/util';
-export default class BedAdapter extends BaseFeatureDataAdapter {
-    protected bedFeatures?: Promise<{
+export default class BedAdapter extends BaseFeatureDataAdapter<BedAdapterConfig> {
+    loadData: (opts?: BaseOptions) => Promise<{
         header: string;
         features: Record<string, string[]>;
-        parser: BED;
-        columnNames: string[];
-        scoreColumn: string;
-        colRef: number;
-        colStart: number;
-        colEnd: number;
     }>;
+    private getParser;
     protected intervalTrees: Record<string, Promise<IntervalTree<Feature> | undefined> | undefined>;
     static capabilities: string[];
     private loadDataP;
-    loadData(opts?: BaseOptions): Promise<{
-        header: string;
-        features: Record<string, string[]>;
-        parser: BED;
-        columnNames: string[];
-        scoreColumn: string;
-        colRef: number;
-        colStart: number;
-        colEnd: number;
-    }>;
     getRefNames(opts?: BaseOptions): Promise<string[]>;
     getHeader(opts?: BaseOptions): Promise<string>;
     getNames(): Promise<string[] | undefined>;

package/esm/BedAdapter/BedAdapter.js

@@ -1,60 +1,24 @@
-import BED from '@gmod/bed';
-import { BaseFeatureDataAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
+import { BaseFeatureDataAdapter, cachedSetup, } from '@jbrowse/core/data_adapters/BaseAdapter';
 import { IntervalTree, SimpleFeature, fetchAndMaybeUnzip, } from '@jbrowse/core/util';
 import { openLocation } from '@jbrowse/core/util/io';
-import { parseLineByLine } from '@jbrowse/core/util/parseLineByLine';
-import { ObservableCreate } from '@jbrowse/core/util/rxjs';
-import { featureData } from "../util.js";
+import { intervalTreeFeatures } from '../adapterUtil.js';
+import { bedFeatureLocus, bucketBedLines, featureData, makeParser, resolveColumnNames, } from '../util.js';
 export default class BedAdapter extends BaseFeatureDataAdapter {
-    bedFeatures;
+    // No `label`: `fetchAndMaybeUnzip` narrates the download from inside.
+    loadData = cachedSetup({ setup: opts => this.loadDataP(opts) });
+    // the parser needs the column names, which come from the header, so it can
+    // only be built once the file is loaded
+    getParser = cachedSetup({
+        setup: async () => makeParser({
+            autoSql: this.getConf('autoSql'),
+            columnNames: await this.getNames(),
+        }),
+    });
     intervalTrees = {};
     static capabilities = ['getFeatures', 'getRefNames'];
     async loadDataP(opts) {
-        const bedLoc = this.getConf('bedLocation');
-        const buffer = await fetchAndMaybeUnzip(openLocation(bedLoc, this.pluginManager), opts);
-        const headerLines = [];
-        const features = {};
-        parseLineByLine(buffer, line => {
-            if (line.startsWith('#')) {
-                headerLines.push(line);
-            }
-            else {
-                const tab = line.indexOf('\t');
-                const refName = line.slice(0, tab);
-                if (!features[refName]) {
-                    features[refName] = [];
-                }
-                features[refName].push(line);
-            }
-            return true;
-        }, opts?.statusCallback);
-        const header = headerLines.join('\n');
-        const autoSql = this.getConf('autoSql');
-        const parser = new BED({ autoSql });
-        const columnNames = this.getConf('columnNames');
-        const scoreColumn = this.getConf('scoreColumn');
-        const colRef = this.getConf('colRef');
-        const colStart = this.getConf('colStart');
-        const colEnd = this.getConf('colEnd');
-        return {
-            header,
-            features,
-            parser,
-            columnNames,
-            scoreColumn,
-            colRef,
-            colStart,
-            colEnd,
-        };
-    }
-    async loadData(opts = {}) {
-        if (!this.bedFeatures) {
-            this.bedFeatures = this.loadDataP(opts).catch((e) => {
-                this.bedFeatures = undefined;
-                throw e;
-            });
-        }
-        return this.bedFeatures;
+        const buffer = await fetchAndMaybeUnzip(openLocation(this.getConf('bedLocation'), this.pluginManager), opts);
+        return bucketBedLines(buffer, opts?.statusCallback);
     }
     async getRefNames(opts = {}) {
         const { features } = await this.loadData(opts);
@@ -65,39 +29,30 @@ export default class BedAdapter extends BaseFeatureDataAdapter {
         return header;
     }
     async getNames() {
-        const { header, columnNames } = await this.loadData();
-        if (columnNames.length) {
-            return columnNames;
-        }
-        const defs = header.split(/\n|\r\n|\r/).filter(f => !!f);
-        const defline = defs.at(-1);
-        return defline?.includes('\t')
-            ? defline
-                .slice(1)
-                .split('\t')
-                .map(field => field.trim())
-            : undefined;
+        return resolveColumnNames(this.getConf('columnNames'), async () => (await this.loadData()).header);
     }
     async loadFeatureIntervalTreeHelper(refName) {
-        const { colRef, colStart, colEnd, features, parser, scoreColumn } = await this.loadData();
+        const { features } = await this.loadData();
         const lines = features[refName];
         if (!lines) {
             return undefined;
         }
         const names = await this.getNames();
+        const parser = await this.getParser();
+        const scoreColumn = this.getConf('scoreColumn');
+        const colRef = this.getConf('colRef');
+        const colStart = this.getConf('colStart');
+        const colEnd = this.getConf('colEnd');
         const disableGeneHeuristic = this.getConf('disableGeneHeuristic');
         const intervalTree = new IntervalTree();
         for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            const uniqueId = `${this.id}-${refName}-${i}`;
+            const splitLine = lines[i].split('\t');
             const feat = new SimpleFeature(featureData({
-                line,
-                colRef,
-                colStart,
-                colEnd,
+                splitLine,
+                ...bedFeatureLocus({ splitLine, colRef, colStart, colEnd }),
                 scoreColumn,
                 parser,
-                uniqueId,
+                uniqueId: `${this.id}-${refName}-${i}`,
                 names,
                 disableGeneHeuristic,
             }));
@@ -106,25 +61,13 @@ export default class BedAdapter extends BaseFeatureDataAdapter {
         return intervalTree;
     }
     async loadFeatureIntervalTree(refName) {
-        if (!this.intervalTrees[refName]) {
-            this.intervalTrees[refName] = this.loadFeatureIntervalTreeHelper(refName).catch((e) => {
-                this.intervalTrees[refName] = undefined;
-                throw e;
-            });
-        }
+        this.intervalTrees[refName] ??= this.loadFeatureIntervalTreeHelper(refName).catch((e) => {
+            this.intervalTrees[refName] = undefined;
+            throw e;
+        });
         return this.intervalTrees[refName];
     }
     getFeatures(query, opts = {}) {
-        return ObservableCreate(async (observer) => {
-            const { start, end, refName } = query;
-            const intervalTree = await this.loadFeatureIntervalTree(refName);
-            const features = intervalTree?.search([start, end]);
-            if (features) {
-                for (const f of features) {
-                    observer.next(f);
-                }
-            }
-            observer.complete();
-        }, opts.stopToken);
+        return intervalTreeFeatures(query, opts, refName => this.loadFeatureIntervalTree(refName));
     }
 }

package/esm/BedAdapter/configSchema.d.ts

@@ -1,46 +1,95 @@
+import type { Instance } from '@jbrowse/mobx-state-tree';
+export declare function normalizeSnapshot(snap: Record<string, unknown>): Record<string, unknown>;
+/**
+ * #config BedAdapter
+ * #trackType FeatureTrack
+ * #fileFormat feature | BED (plain) | Loaded entirely into memory; for small files
+ * #gotcha Named BED columns past `name`/`score`/`strand` (`itemRgb`,
+ * `thickStart`, ...) are only guaranteed for BED12 or a track with an
+ * `autoSql`/`columnNames`. For a BED7-BED11 file JBrowse cannot know what the
+ * extra columns mean, so it exposes them generically as `field6`, `field7`,
+ * ... and a jexl callback reading `feature.itemRgb` gets `undefined`. Set
+ * `columnNames` to refer to them by name.
+ *
+ * used to load plain-text BED files. Loads the whole file into memory, so
+ * prefer the BedTabixAdapter for large files.
+ *
+ * #example
+ * ```js
+ * {
+ *   type: 'BedAdapter',
+ *   uri: 'https://example.com/features.bed',
+ * }
+ * ```
+ */
 declare const BedAdapter: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
-    bedLocation: {
-        type: string;
-        description: string;
-        defaultValue: {
-            uri: string;
-            locationType: string;
+    /**
+     * #slot
+     */
+    readonly bedLocation: {
+        readonly type: "fileLocation";
+        readonly description: "path to bed file, also allows gzipped bed";
+        readonly defaultValue: {
+            readonly uri: "/path/to/my.bed.gz";
+            readonly locationType: "UriLocation";
         };
     };
-    columnNames: {
-        type: string;
-        description: string;
-        defaultValue: never[];
-    };
-    scoreColumn: {
-        type: string;
-        description: string;
-        defaultValue: string;
-    };
-    autoSql: {
-        type: string;
-        description: string;
-        defaultValue: string;
-    };
-    colRef: {
-        type: string;
-        description: string;
-        defaultValue: number;
-    };
-    colStart: {
-        type: string;
-        description: string;
-        defaultValue: number;
-    };
-    colEnd: {
-        type: string;
-        description: string;
-        defaultValue: number;
-    };
-    disableGeneHeuristic: {
-        type: string;
-        description: string;
-        defaultValue: boolean;
+    /**
+     * #slot
+     */
+    readonly columnNames: {
+        readonly type: "stringArray";
+        readonly description: "List of column names. A column named like a standard BED column is parsed as that column's type (chromStart numeric, blockSizes a numeric list); any other column is text";
+        readonly defaultValue: readonly [];
+    };
+    /**
+     * #slot
+     */
+    readonly scoreColumn: {
+        readonly type: "string";
+        readonly description: "The column to use as a \"score\" attribute";
+        readonly defaultValue: "";
+    };
+    /**
+     * #slot
+     */
+    readonly autoSql: {
+        readonly type: "string";
+        readonly description: "The autoSql definition for the data fields in the file";
+        readonly defaultValue: "";
+    };
+    /**
+     * #slot
+     */
+    readonly colRef: {
+        readonly type: "number";
+        readonly description: "The column to use as a \"refName\" attribute";
+        readonly defaultValue: 0;
+    };
+    /**
+     * #slot
+     */
+    readonly colStart: {
+        readonly type: "number";
+        readonly description: "The column to use as a \"start\" attribute";
+        readonly defaultValue: 1;
+    };
+    /**
+     * #slot
+     */
+    readonly colEnd: {
+        readonly type: "number";
+        readonly description: "The column to use as a \"end\" attribute";
+        readonly defaultValue: 2;
+    };
+    /**
+     * #slot
+     */
+    readonly disableGeneHeuristic: {
+        readonly type: "boolean";
+        readonly description: "Disable the heuristic that auto-detects BED12 features as gene/transcript structures. Useful for files that have BED12-like structure but are not genes (e.g. tandem duplications)";
+        readonly defaultValue: false;
     };
 }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
+export type BedAdapterConfig = Instance<typeof BedAdapter>;
 export default BedAdapter;

package/esm/BedAdapter/configSchema.js

@@ -1,6 +1,35 @@
 import { ConfigurationSchema } from '@jbrowse/core/configuration';
-function x() { }
+export function normalizeSnapshot(snap) {
+    return snap.uri
+        ? { ...snap, bedLocation: { uri: snap.uri, baseUri: snap.baseUri } }
+        : snap;
+}
+/**
+ * #config BedAdapter
+ * #trackType FeatureTrack
+ * #fileFormat feature | BED (plain) | Loaded entirely into memory; for small files
+ * #gotcha Named BED columns past `name`/`score`/`strand` (`itemRgb`,
+ * `thickStart`, ...) are only guaranteed for BED12 or a track with an
+ * `autoSql`/`columnNames`. For a BED7-BED11 file JBrowse cannot know what the
+ * extra columns mean, so it exposes them generically as `field6`, `field7`,
+ * ... and a jexl callback reading `feature.itemRgb` gets `undefined`. Set
+ * `columnNames` to refer to them by name.
+ *
+ * used to load plain-text BED files. Loads the whole file into memory, so
+ * prefer the BedTabixAdapter for large files.
+ *
+ * #example
+ * ```js
+ * {
+ *   type: 'BedAdapter',
+ *   uri: 'https://example.com/features.bed',
+ * }
+ * ```
+ */
 const BedAdapter = ConfigurationSchema('BedAdapter', {
+    /**
+     * #slot
+     */
     bedLocation: {
         type: 'fileLocation',
         description: 'path to bed file, also allows gzipped bed',
@@ -9,36 +38,57 @@ const BedAdapter = ConfigurationSchema('BedAdapter', {
             locationType: 'UriLocation',
         },
     },
+    /**
+     * #slot
+     */
     columnNames: {
         type: 'stringArray',
-        description: 'List of column names',
+        description: "List of column names. A column named like a standard BED column is parsed as that column's type (chromStart numeric, blockSizes a numeric list); any other column is text",
         defaultValue: [],
     },
+    /**
+     * #slot
+     */
     scoreColumn: {
         type: 'string',
         description: 'The column to use as a "score" attribute',
         defaultValue: '',
     },
+    /**
+     * #slot
+     */
     autoSql: {
         type: 'string',
         description: 'The autoSql definition for the data fields in the file',
         defaultValue: '',
     },
+    /**
+     * #slot
+     */
     colRef: {
         type: 'number',
         description: 'The column to use as a "refName" attribute',
         defaultValue: 0,
     },
+    /**
+     * #slot
+     */
     colStart: {
         type: 'number',
         description: 'The column to use as a "start" attribute',
         defaultValue: 1,
     },
+    /**
+     * #slot
+     */
     colEnd: {
         type: 'number',
         description: 'The column to use as a "end" attribute',
         defaultValue: 2,
     },
+    /**
+     * #slot
+     */
     disableGeneHeuristic: {
         type: 'boolean',
         description: 'Disable the heuristic that auto-detects BED12 features as gene/transcript structures. Useful for files that have BED12-like structure but are not genes (e.g. tandem duplications)',
@@ -46,16 +96,18 @@ const BedAdapter = ConfigurationSchema('BedAdapter', {
     },
 }, {
     explicitlyTyped: true,
-    preProcessSnapshot: snap => {
-        return snap.uri
-            ? {
-                ...snap,
-                bedLocation: {
-                    uri: snap.uri,
-                    baseUri: snap.baseUri,
-                },
-            }
-            : snap;
-    },
+    /**
+     * #preProcessSnapshot
+     *
+     *
+     * preprocessor to allow minimal config:
+     * ```json
+     * {
+     *   "type": "BedAdapter",
+     *   "uri": "yourfile.bed"
+     * }
+     * ```
+     */
+    preProcessSnapshot: normalizeSnapshot,
 });
 export default BedAdapter;

package/esm/BedAdapter/index.js

@@ -1,10 +1,12 @@
 import AdapterType from '@jbrowse/core/pluggableElementTypes/AdapterType';
-import configSchema from "./configSchema.js";
+import configSchema, { normalizeSnapshot } from './configSchema.js';
 export default function BedAdapterF(pluginManager) {
     pluginManager.addAdapterType(() => new AdapterType({
         name: 'BedAdapter',
         displayName: 'BED adapter',
         configSchema,
-        getAdapterClass: () => import("./BedAdapter.js").then(r => r.default),
+        getAdapterClass: () => import('./BedAdapter.js').then(r => r.default),
+        locationKey: 'bedLocation',
+        normalizeSnapshot,
     }));
 }

package/esm/BedGraphAdapter/BedGraphAdapter.d.ts

@@ -1,12 +1,12 @@
 import { BaseFeatureDataAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
 import { IntervalTree } from '@jbrowse/core/util';
+import type { BedGraphAdapterConfig } from './configSchema.ts';
 import type { BaseOptions } from '@jbrowse/core/data_adapters/BaseAdapter';
 import type { Feature, Region } from '@jbrowse/core/util';
-export default class BedGraphAdapter extends BaseFeatureDataAdapter {
-    protected bedFeatures?: Promise<{
+export default class BedGraphAdapter extends BaseFeatureDataAdapter<BedGraphAdapterConfig> {
+    loadData: (opts?: BaseOptions) => Promise<{
         header: string;
         features: Record<string, string[]>;
-        columnNames: string[];
     }>;
     protected intervalTrees: Record<string, Promise<IntervalTree<Feature> | undefined> | undefined>;
     getNames(): Promise<string[] | undefined>;
@@ -14,10 +14,5 @@ export default class BedGraphAdapter extends BaseFeatureDataAdapter {
     getRefNames(opts?: BaseOptions): Promise<string[]>;
     private loadDataP;
     loadFeatureIntervalTree(refName: string): Promise<IntervalTree<Feature> | undefined>;
-    loadData(opts?: BaseOptions): Promise<{
-        header: string;
-        features: Record<string, string[]>;
-        columnNames: string[];
-    }>;
-    getFeatures(query: Region, _opts?: BaseOptions): import("rxjs").Observable<Feature>;
+    getFeatures(query: Region, opts?: BaseOptions): import("rxjs").Observable<Feature>;
 }

package/esm/BedGraphAdapter/BedGraphAdapter.js

@@ -1,24 +1,15 @@
-import { BaseFeatureDataAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
-import { IntervalTree, SimpleFeature, fetchAndMaybeUnzip, } from '@jbrowse/core/util';
+import { BaseFeatureDataAdapter, cachedSetup, } from '@jbrowse/core/data_adapters/BaseAdapter';
+import { IntervalTree, fetchAndMaybeUnzip } from '@jbrowse/core/util';
 import { openLocation } from '@jbrowse/core/util/io';
-import { parseLineByLine } from '@jbrowse/core/util/parseLineByLine';
-import { ObservableCreate } from '@jbrowse/core/util/rxjs';
+import { intervalTreeFeatures } from '../adapterUtil.js';
+import { makeBedGraphFeature } from '../bedGraphUtil.js';
+import { bucketBedLines, resolveColumnNames } from '../util.js';
 export default class BedGraphAdapter extends BaseFeatureDataAdapter {
-    bedFeatures;
+    // No `label`: `fetchAndMaybeUnzip` narrates the download from inside.
+    loadData = cachedSetup({ setup: opts => this.loadDataP(opts) });
     intervalTrees = {};
     async getNames() {
-        const { header, columnNames } = await this.loadData();
-        if (columnNames.length) {
-            return columnNames;
-        }
-        const defs = header.split(/\n|\r\n|\r/).filter(f => !!f);
-        const defline = defs.at(-1);
-        return defline?.includes('\t')
-            ? defline
-                .slice(1)
-                .split('\t')
-                .map(field => field.trim())
-            : undefined;
+        return resolveColumnNames(this.getConf('columnNames'), async () => (await this.loadData()).header);
     }
     async loadFeatureIntervalTreeHelper(refName) {
         const { features } = await this.loadData();
@@ -26,28 +17,24 @@ export default class BedGraphAdapter extends BaseFeatureDataAdapter {
         if (!lines) {
             return undefined;
         }
-        const names = (await this.getNames())?.slice(3) || [];
+        const names = (await this.getNames())?.slice(3) ?? [];
         const intervalTree = new IntervalTree();
         for (let i = 0, l = lines.length; i < l; i++) {
-            const line = lines[i];
-            const [refName, s, e, ...rest] = line.split('\t');
+            const [refName, s, e, ...rest] = lines[i].split('\t');
+            const start = +s;
+            const end = +e;
             for (let j = 0, l2 = rest.length; j < l2; j++) {
-                const uniqueId = `${this.id}-${refName}-${i}-${j}`;
-                const start = +s;
-                const end = +e;
-                const score = +rest[j];
-                const source = names[j] || `col${j}`;
-                if (score) {
-                    intervalTree.insert([start, end], new SimpleFeature({
-                        id: uniqueId,
-                        data: {
-                            refName,
-                            start,
-                            end,
-                            score,
-                            source,
-                        },
-                    }));
+                const feat = makeBedGraphFeature({
+                    uniqueId: `${this.id}-${refName}-${i}-${j}`,
+                    refName: refName,
+                    start,
+                    end,
+                    names,
+                    j,
+                    value: rest[j],
+                });
+                if (feat) {
+                    intervalTree.insert([start, end], feat);
                 }
             }
         }
@@ -58,58 +45,17 @@ export default class BedGraphAdapter extends BaseFeatureDataAdapter {
         return Object.keys(features);
     }
     async loadDataP(opts = {}) {
-        const pm = this.pluginManager;
-        const bedLoc = this.getConf('bedGraphLocation');
-        const buffer = await fetchAndMaybeUnzip(openLocation(bedLoc, pm), opts);
-        const features = {};
-        const headerLines = [];
-        parseLineByLine(buffer, line => {
-            if (line.startsWith('#')) {
-                headerLines.push(line);
-            }
-            else {
-                const tab = line.indexOf('\t');
-                const refName = line.slice(0, tab);
-                if (!features[refName]) {
-                    features[refName] = [];
-                }
-                features[refName].push(line);
-            }
-            return true;
-        }, opts.statusCallback);
-        const columnNames = this.getConf('columnNames');
-        return {
-            header: headerLines.join('\n'),
-            features,
-            columnNames,
-        };
+        const buffer = await fetchAndMaybeUnzip(openLocation(this.getConf('bedGraphLocation'), this.pluginManager), opts);
+        return bucketBedLines(buffer, opts.statusCallback);
     }
     async loadFeatureIntervalTree(refName) {
-        if (!this.intervalTrees[refName]) {
-            this.intervalTrees[refName] = this.loadFeatureIntervalTreeHelper(refName).catch((e) => {
-                this.intervalTrees[refName] = undefined;
-                throw e;
-            });
-        }
+        this.intervalTrees[refName] ??= this.loadFeatureIntervalTreeHelper(refName).catch((e) => {
+            this.intervalTrees[refName] = undefined;
+            throw e;
+        });
         return this.intervalTrees[refName];
     }
-    async loadData(opts = {}) {
-        if (!this.bedFeatures) {
-            this.bedFeatures = this.loadDataP(opts).catch((e) => {
-                this.bedFeatures = undefined;
-                throw e;
-            });
-        }
-        return this.bedFeatures;
-    }
-    getFeatures(query, _opts = {}) {
-        return ObservableCreate(async (observer) => {
-            const { start, end, refName } = query;
-            const intervalTree = await this.loadFeatureIntervalTree(refName);
-            for (const feature of intervalTree?.search([start, end]) || []) {
-                observer.next(feature);
-            }
-            observer.complete();
-        });
+    getFeatures(query, opts = {}) {
+        return intervalTreeFeatures(query, opts, refName => this.loadFeatureIntervalTree(refName));
     }
 }