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

package/esm/BedTabixAdapter/configSchema.js

@@ -1,4 +1,5 @@
-import { ConfigurationSchema, expandTabixShorthand, tabixIndexFields, } from '@jbrowse/core/configuration';
+import { ConfigurationSchema, expandTabixShorthand, tabixIndexSchema, } from '@jbrowse/core/configuration';
+import { densityAdapterConfigSchemaFields } from '@jbrowse/core/data_adapters/BaseAdapter';
 export function normalizeSnapshot(snap) {
     return expandTabixShorthand(snap, 'bedGzLocation');
 }
@@ -30,7 +31,12 @@ const BedTabixAdapter = ConfigurationSchema('BedTabixAdapter', {
             locationType: 'UriLocation',
         },
     },
-    index: ConfigurationSchema('TabixIndex', { ...tabixIndexFields }),
+    /**
+     * #slot
+     * where the tabix index is and which kind it is. The `uri` shorthand derives
+     * both, so a config using it states neither.
+     */
+    index: tabixIndexSchema(),
     /**
      * #slot
      */
@@ -63,6 +69,7 @@ const BedTabixAdapter = ConfigurationSchema('BedTabixAdapter', {
         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)',
         defaultValue: false,
     },
+    ...densityAdapterConfigSchemaFields,
 }, {
     explicitlyTyped: true,
     /**

package/esm/BedpeAdapter/BedpeAdapter.d.ts

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

package/esm/BedpeAdapter/BedpeAdapter.js

@@ -8,7 +8,6 @@ import { featureData } from './util.js';
 export default class BedpeAdapter 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('bedpeLocation'), this.pluginManager), opts);
@@ -50,14 +49,8 @@ export default class BedpeAdapter extends BaseFeatureDataAdapter {
         const names = await this.getNames();
         return buildPairedIntervalTree(feats1, feats2, refName, this.id, (line, uniqueId, flip) => featureData(line, uniqueId, flip, names));
     }
-    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/BedpeAdapter/configSchema.d.ts

@@ -15,25 +15,21 @@ export declare function normalizeSnapshot(snap: Record<string, unknown>): Record
  * ```
  */
 declare const BedpeAdapter: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
-    /**
-     * #slot
-     */
+    type: {
+        type: "string";
+    } & {
+        defaultValue: string;
+    };
     readonly bedpeLocation: {
-        readonly type: "fileLocation";
-        readonly description: "can be plaintext or gzipped, not indexed so loaded into memory on startup";
-        readonly defaultValue: {
-            readonly uri: "/path/to/my.bedpe.gz";
-            readonly locationType: "UriLocation";
-        };
+        type: "fileLocation";
+    } & {
+        defaultValue: unknown;
     };
-    /**
-     * #slot
-     */
     readonly columnNames: {
-        readonly type: "stringArray";
-        readonly description: "List of column names";
-        readonly defaultValue: readonly [];
+        type: "stringArray";
+    } & {
+        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 BedpeAdapterConfig = Instance<typeof BedpeAdapter>;
 export default BedpeAdapter;

package/esm/BedpeAdapter/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,
-            bedpeLocation: {
-                uri: snap.uri,
-                baseUri: snap.baseUri,
-                locationType: 'UriLocation',
-            },
-        }
-        : snap;
+    return expandUriShorthand(snap, 'bedpeLocation');
 }
 /**
  * #config BedpeAdapter

package/esm/BedpeAdapter/util.js

@@ -1,4 +1,5 @@
 import { SimpleFeature } from '@jbrowse/core/util';
+import { svClassOfToken } from '@jbrowse/core/util/svAlt';
 import { parseStrand } from '../util.js';
 const svTypes = new Set(['DUP', 'TRA', 'INV', 'CNV', 'DEL']);
 export function featureData(line, uniqueId, flip, names) {
@@ -24,7 +25,7 @@ export function featureData(line, uniqueId, flip, names) {
     const rest = names
         ? Object.fromEntries(names.slice(10).map((n, idx) => [n, extra[idx]]))
         : {};
-    const ALT = svTypes.has(extra[0]) ? `<${extra[0]}>` : undefined;
+    const token = svTypes.has(extra[0]) ? extra[0] : undefined;
     // `name` and `score` are spread only when the file actually sets them, which
     // is what lets a column past 10 of the same name through. juicer's bedpe is
     // the case that needs it: Arrowhead writes '.' in both standard columns and
@@ -46,6 +47,6 @@ export function featureData(line, uniqueId, flip, names) {
             end: end2,
             strand: strand2,
         },
-        ...(ALT ? { ALT: [ALT] } : {}),
+        ...(token ? { ALT: [`<${token}>`], svType: svClassOfToken(token) } : {}),
     });
 }

package/esm/BigBedAdapter/BigBedAdapter.js

@@ -4,7 +4,6 @@ import { BaseFeatureDataAdapter, cachedSetup, } from '@jbrowse/core/data_adapter
 import { SimpleFeature, doesIntersect2, downloadStatus, max, min, updateStatus, } from '@jbrowse/core/util';
 import { openLocation } from '@jbrowse/core/util/io';
 import { ObservableCreate } from '@jbrowse/core/util/rxjs';
-import { withStopTokenSignal } from '@jbrowse/core/util/stopToken';
 import { firstValueFrom, toArray } from 'rxjs';
 import { featureData } from '../util.js';
 export default class BigBedAdapter extends BaseFeatureDataAdapter {
@@ -97,11 +96,11 @@ export default class BigBedAdapter extends BaseFeatureDataAdapter {
         // (they come from the R-tree index) so this reports a determinate fraction
         // rather than an indeterminate spinner. Matters most here — BigBed is a
         // full-feature download, which is why getRegionByteSize gates it above.
-        const feats = await withStopTokenSignal(opts.stopToken, signal => downloadStatus('Downloading features', statusCallback, onProgress => bigbed.getFeatures(query.refName, query.start, query.end, {
+        const feats = await downloadStatus('Downloading features', statusCallback, onProgress => bigbed.getFeatures(query.refName, query.start, query.end, {
             basesPerSpan: query.end - query.start,
             onProgress,
-            signal,
-        })));
+            signal: opts.signal,
+        }));
         await updateStatus('Processing features', statusCallback, async () => {
             const parentAggregation = {};
             const singletons = [];
@@ -214,6 +213,6 @@ export default class BigBedAdapter extends BaseFeatureDataAdapter {
             catch (e) {
                 observer.error(e);
             }
-        }, opts.stopToken);
+        }, opts.signal);
     }
 }

package/esm/BigBedAdapter/configSchema.d.ts

@@ -14,42 +14,34 @@ export declare function normalizeSnapshot(snap: Record<string, unknown>): Record
  * ```
  */
 declare const BigBedAdapter: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
-    /**
-     * #slot
-     * location of the BigBed file. It carries its own index and summary zoom
-     * levels, so there is no separate index to configure.
-     */
+    readonly densityAdapter: {
+        type: "maybeFrozen";
+    };
+    type: {
+        type: "string";
+    } & {
+        defaultValue: string;
+    };
     readonly bigBedLocation: {
-        readonly type: "fileLocation";
-        readonly defaultValue: {
-            readonly uri: "/path/to/my.bb";
-            readonly locationType: "UriLocation";
-        };
+        type: "fileLocation";
+    } & {
+        defaultValue: unknown;
     };
-    /**
-     * #slot
-     */
     readonly scoreColumn: {
-        readonly type: "string";
-        readonly description: "The column to use as a \"score\" attribute";
-        readonly defaultValue: "";
+        type: "string";
+    } & {
+        defaultValue: string;
     };
-    /**
-     * #slot
-     */
     readonly aggregateField: {
-        readonly type: "string";
-        readonly description: "An attribute to aggregate features with";
-        readonly defaultValue: "geneName2";
+        type: "string";
+    } & {
+        defaultValue: string;
     };
-    /**
-     * #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;
+        type: "boolean";
+    } & {
+        defaultValue: boolean;
     };
-}, 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 BigBedAdapterConfig = Instance<typeof BigBedAdapter>;
 export default BigBedAdapter;

package/esm/BigBedAdapter/configSchema.js

@@ -1,14 +1,7 @@
-import { ConfigurationSchema } from '@jbrowse/core/configuration';
+import { ConfigurationSchema, expandUriShorthand, } from '@jbrowse/core/configuration';
+import { densityAdapterConfigSchemaFields } from '@jbrowse/core/data_adapters/BaseAdapter';
 export function normalizeSnapshot(snap) {
-    return snap.uri
-        ? {
-            ...snap,
-            bigBedLocation: {
-                uri: snap.uri,
-                baseUri: snap.baseUri,
-            },
-        }
-        : snap;
+    return expandUriShorthand(snap, 'bigBedLocation');
 }
 /**
  * #config BigBedAdapter
@@ -60,6 +53,7 @@ const BigBedAdapter = ConfigurationSchema('BigBedAdapter', {
         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)',
         defaultValue: false,
     },
+    ...densityAdapterConfigSchemaFields,
 }, {
     explicitlyTyped: true,
     /**

package/esm/BigBedTextSearchAdapter/BigBedTextSearchAdapter.d.ts

@@ -0,0 +1,27 @@
+import { BigBed } from '@gmod/bbi';
+import Trix from '@gmod/trix';
+import BaseResult from '@jbrowse/core/TextSearch/BaseResults';
+import { BaseAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
+import type { BigBedTextSearchAdapterConfig } from './configSchema.ts';
+import type PluginManager from '@jbrowse/core/PluginManager';
+import type { BaseTextSearchAdapter, BaseTextSearchArgs } from '@jbrowse/core/data_adapters/BaseAdapter';
+import type { getSubAdapterType } from '@jbrowse/core/data_adapters/dataAdapterCache';
+interface Hit {
+    label: string;
+    refName: string;
+    start: number;
+    end: number;
+}
+export declare function mergeTranscripts(hits: Hit[]): Hit[];
+export default class BigBedTextSearchAdapter extends BaseAdapter<BigBedTextSearchAdapterConfig> implements BaseTextSearchAdapter {
+    bigbed: BigBed;
+    trix?: Trix;
+    constructor(config: BigBedTextSearchAdapterConfig, getSubAdapter?: getSubAdapterType, pluginManager?: PluginManager);
+    names(query: string, exactOnly: boolean, signal?: AbortSignal): Promise<{
+        exact: string[];
+        prefixed: (readonly [string, string])[];
+    }>;
+    lookUp(name: string, word: string, signal?: AbortSignal): Promise<Hit[]>;
+    searchIndex({ queryString, searchType, signal }: BaseTextSearchArgs): Promise<BaseResult[]>;
+}
+export {};

package/esm/BigBedTextSearchAdapter/BigBedTextSearchAdapter.js

@@ -0,0 +1,128 @@
+import { BigBed } from '@gmod/bbi';
+import Trix from '@gmod/trix';
+import BaseResult from '@jbrowse/core/TextSearch/BaseResults';
+import { BaseAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
+import { checkAbortSignal } from '@jbrowse/core/util/aborting';
+import { openLocation } from '@jbrowse/core/util/io';
+// each name a query resolves costs a walk of the BigBed's B+ tree, so a query
+// resolves every name its exact word carries up to one cap, and the words it
+// only prefixes, each whole, while their names fit the other
+const MAX_EXACT_NAMES = 50;
+const MAX_PREFIX_NAMES = 50;
+const MAX_TRIX_HITS = 500;
+function isSet(location) {
+    return 'uri' in location
+        ? !!location.uri
+        : 'localPath' in location
+            ? !!location.localPath
+            : true;
+}
+// the column that matched is the name the hit goes by: a gene symbol for a
+// search by symbol, the accession for a search by accession
+function hitFor({ refName, start, end, rest = '', }, word) {
+    const fields = rest.split('\t');
+    const label = fields.find(f => f.toLowerCase() === word) ?? fields[0];
+    return refName && label ? { label, refName, start, end } : undefined;
+}
+// Transcripts sharing the name that matched and overlapping on one sequence
+// are one gene, the rule BigBedAdapter draws them by, so a search for a gene
+// lands on the gene rather than asking which of its transcripts
+export function mergeTranscripts(hits) {
+    const merged = [];
+    const sorted = hits.toSorted((a, b) => a.label.localeCompare(b.label) ||
+        a.refName.localeCompare(b.refName) ||
+        a.start - b.start);
+    for (const hit of sorted) {
+        const last = merged.at(-1);
+        if (last?.label === hit.label &&
+            last.refName === hit.refName &&
+            hit.start <= last.end) {
+            last.end = Math.max(last.end, hit.end);
+        }
+        else {
+            merged.push({ ...hit });
+        }
+    }
+    return merged;
+}
+// A word is resolved whole or not at all, since a word missing some of its
+// names would land on part of its gene
+function prefixedNames(byWord, word) {
+    const pairs = [];
+    for (const [term, names] of byWord) {
+        if (term !== word && term.startsWith(word)) {
+            if (pairs.length + names.length > MAX_PREFIX_NAMES) {
+                break;
+            }
+            pairs.push(...names.map(name => [term, name]));
+        }
+    }
+    return pairs;
+}
+export default class BigBedTextSearchAdapter extends BaseAdapter {
+    bigbed;
+    trix;
+    constructor(config, getSubAdapter, pluginManager) {
+        super(config, getSubAdapter, pluginManager);
+        this.bigbed = new BigBed({
+            filehandle: openLocation(this.getConf('bigBedLocation'), pluginManager),
+        });
+        const ix = this.getConf('ixFilePath');
+        const ixx = this.getConf('ixxFilePath');
+        if (isSet(ix) && isSet(ixx)) {
+            this.trix = new Trix(openLocation(ixx, pluginManager), openLocation(ix, pluginManager), MAX_TRIX_HITS);
+        }
+    }
+    // The names to look up: the query as spelled, which the extra index answers
+    // however the trix split it into words, then the names the trix finds for
+    // its word. GenArk's trix drops an accession's version, so a versioned query
+    // asks for the bare word and keeps the names spelling the query
+    async names(query, exactOnly, signal) {
+        const word = query.toLowerCase();
+        if (!this.trix) {
+            return { exact: [query], prefixed: [] };
+        }
+        const trixWord = word.replace(/\.\d+$/, '');
+        const byWord = new Map();
+        for (const [term, name] of await this.trix.search(trixWord, { signal })) {
+            const names = byWord.get(term);
+            if (names) {
+                names.push(name);
+            }
+            else {
+                byWord.set(term, [name]);
+            }
+        }
+        const exact = trixWord === word
+            ? (byWord.get(word) ?? [])
+            : (byWord.get(trixWord) ?? []).filter(n => n.toLowerCase() === word);
+        return {
+            exact: [...new Set([query, ...exact])].slice(0, MAX_EXACT_NAMES),
+            prefixed: exactOnly ? [] : prefixedNames(byWord, word),
+        };
+    }
+    async lookUp(name, word, signal) {
+        return (await this.bigbed.searchExtraIndex(name, { signal }))
+            .map(f => hitFor(f, word))
+            .filter(h => h !== undefined);
+    }
+    async searchIndex({ queryString, searchType, signal }) {
+        const query = queryString.trim();
+        const word = query.toLowerCase();
+        const { exact, prefixed } = await this.names(query, searchType === 'exact', signal);
+        const [exactHits, prefixHits] = await Promise.all([
+            Promise.all(exact.map(name => this.lookUp(name, word, signal))),
+            Promise.all(prefixed.map(([term, name]) => this.lookUp(name, term, signal))),
+        ]);
+        checkAbortSignal(signal);
+        const results = (hits, exact) => mergeTranscripts(hits).map(({ label, refName, start, end }) => new BaseResult({
+            label,
+            locString: `${refName}:${start + 1}..${end}`,
+            exact,
+        }));
+        return [
+            ...results(exactHits.flat(), true),
+            ...results(prefixHits.flat(), false),
+        ];
+    }
+}

package/esm/BigBedTextSearchAdapter/configSchema.d.ts

@@ -0,0 +1,51 @@
+import type { Instance } from '@jbrowse/mobx-state-tree';
+/**
+ * #config BigBedTextSearchAdapter
+ * #trackType TextSearchAdapter
+ *
+ * Finds features by the names a BigBed was built to look up, its
+ * `bedToBigBed -extraIndex` columns, which a UCSC hub declares with
+ * `searchIndex`. The hub's `searchTrix` index, when given, adds prefix and
+ * case-insensitive matching. A UCSC track hub connection configures one for
+ * its first gene track declaring a `searchIndex`, GenArk's `ncbiRefSeq`.
+ *
+ * #example
+ * ```js
+ * {
+ *   type: 'BigBedTextSearchAdapter',
+ *   bigBedLocation: { uri: 'bbi/ncbiRefSeq.bb' },
+ *   ixFilePath: { uri: 'ixIxx/ncbiRefSeq.ix' },
+ *   ixxFilePath: { uri: 'ixIxx/ncbiRefSeq.ixx' },
+ * }
+ * ```
+ */
+declare const BigBedTextSearchAdapter: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+    type: {
+        type: "string";
+    } & {
+        defaultValue: string;
+    };
+    readonly bigBedLocation: {
+        type: "fileLocation";
+    } & {
+        defaultValue: unknown;
+    };
+    readonly ixFilePath: {
+        type: "fileLocation";
+    } & {
+        defaultValue: unknown;
+    };
+    readonly ixxFilePath: {
+        type: "fileLocation";
+    } & {
+        defaultValue: unknown;
+    };
+    readonly assemblyNames: {
+        type: "stringArray";
+    } & {
+        defaultValue: unknown;
+    };
+}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined, true, import("@jbrowse/core/configuration").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>, any>>;
+export interface BigBedTextSearchAdapterConfig extends Instance<typeof BigBedTextSearchAdapter> {
+}
+export default BigBedTextSearchAdapter;

package/esm/BigBedTextSearchAdapter/configSchema.js

@@ -0,0 +1,57 @@
+import { ConfigurationSchema } from '@jbrowse/core/configuration';
+/**
+ * #config BigBedTextSearchAdapter
+ * #trackType TextSearchAdapter
+ *
+ * Finds features by the names a BigBed was built to look up, its
+ * `bedToBigBed -extraIndex` columns, which a UCSC hub declares with
+ * `searchIndex`. The hub's `searchTrix` index, when given, adds prefix and
+ * case-insensitive matching. A UCSC track hub connection configures one for
+ * its first gene track declaring a `searchIndex`, GenArk's `ncbiRefSeq`.
+ *
+ * #example
+ * ```js
+ * {
+ *   type: 'BigBedTextSearchAdapter',
+ *   bigBedLocation: { uri: 'bbi/ncbiRefSeq.bb' },
+ *   ixFilePath: { uri: 'ixIxx/ncbiRefSeq.ix' },
+ *   ixxFilePath: { uri: 'ixIxx/ncbiRefSeq.ixx' },
+ * }
+ * ```
+ */
+const BigBedTextSearchAdapter = ConfigurationSchema('BigBedTextSearchAdapter', {
+    /**
+     * #slot
+     * the BigBed whose extra indexes resolve a name to its features
+     */
+    bigBedLocation: {
+        type: 'fileLocation',
+        defaultValue: { uri: '/path/to/my.bb', locationType: 'UriLocation' },
+    },
+    /**
+     * #slot
+     * a UCSC `searchTrix` `.ix`, whose records are the names the extra
+     * indexes hold. Unset, a search matches a name exactly as typed
+     */
+    ixFilePath: {
+        type: 'fileLocation',
+        defaultValue: { uri: '', locationType: 'UriLocation' },
+    },
+    /**
+     * #slot
+     * the `.ixx` beside `ixFilePath`
+     */
+    ixxFilePath: {
+        type: 'fileLocation',
+        defaultValue: { uri: '', locationType: 'UriLocation' },
+    },
+    /**
+     * #slot
+     */
+    assemblyNames: {
+        type: 'stringArray',
+        defaultValue: [],
+        description: 'List of assemblies covered by text search adapter',
+    },
+}, { explicitlyTyped: true });
+export default BigBedTextSearchAdapter;

package/esm/BigBedTextSearchAdapter/index.d.ts

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

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>;
 }