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

package/esm/BigBedAdapter/index.js

@@ -1,10 +1,11 @@
 import AdapterType from '@jbrowse/core/pluggableElementTypes/AdapterType';
-import configSchema from "./configSchema.js";
+import configSchema, { normalizeSnapshot } from './configSchema.js';
 export default function BigBedAdapterF(pluginManager) {
     pluginManager.addAdapterType(() => new AdapterType({
         name: 'BigBedAdapter',
         displayName: 'BigBed adapter',
+        normalizeSnapshot,
         configSchema,
-        getAdapterClass: () => import("./BigBedAdapter.js").then(r => r.default),
+        getAdapterClass: () => import('./BigBedAdapter.js').then(r => r.default),
     }));
 }

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

@@ -0,0 +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, Region } from '@jbrowse/core/util';
+export default class StarFusionAdapter extends BaseFeatureDataAdapter<StarFusionAdapterConfig> {
+    private loadData;
+    static capabilities: string[];
+    private loadDataP;
+    getRefNames(opts?: BaseOptions): Promise<string[]>;
+    private featureFromLine;
+    private loadFeatureTreeP;
+    private treeFeatures;
+    getFeatures(query: Region, opts?: BaseOptions): import("rxjs").Observable<Feature>;
+}

package/esm/StarFusionAdapter/StarFusionAdapter.js

@@ -0,0 +1,66 @@
+import { BaseFeatureDataAdapter, cachedSetup, } from '@jbrowse/core/data_adapters/BaseAdapter';
+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';
+export default class StarFusionAdapter extends BaseFeatureDataAdapter {
+    loadData = cachedSetup({ setup: opts => this.loadDataP(opts) });
+    static capabilities = ['getFeatures', 'getRefNames'];
+    async loadDataP(opts) {
+        const buffer = await fetchAndMaybeUnzip(openLocation(this.getConf('starFusionLocation'), this.pluginManager), opts);
+        let columnNames = [];
+        let leftIdx = -1;
+        let rightIdx = -1;
+        const feats1 = {};
+        const feats2 = {};
+        parseLineByLine(buffer, (line, lineIndex) => {
+            if (lineIndex === 0) {
+                columnNames = starFusionColumns(line);
+                leftIdx = columnNames.indexOf('LeftBreakpoint');
+                rightIdx = columnNames.indexOf('RightBreakpoint');
+            }
+            else if (!line.startsWith('#')) {
+                const cols = line.split('\t');
+                const left = cols[leftIdx];
+                const right = cols[rightIdx];
+                if (left && right) {
+                    const leftRef = parseStarFusionBreakpoint(left, true).refName;
+                    const rightRef = parseStarFusionBreakpoint(right, false).refName;
+                    (feats1[leftRef] ??= []).push(line);
+                    (feats2[rightRef] ??= []).push(line);
+                }
+            }
+            return true;
+        }, opts?.statusCallback);
+        return { columnNames, feats1, feats2 };
+    }
+    async getRefNames(opts = {}) {
+        const { feats1, feats2 } = await this.loadData(opts);
+        return [...new Set([...Object.keys(feats1), ...Object.keys(feats2)])];
+    }
+    featureFromLine(line, columnNames, uniqueId, flip) {
+        const cols = line.split('\t');
+        const row = Object.fromEntries(columnNames.map((name, i) => [name, cols[i]]));
+        const donor = parseStarFusionBreakpoint(row.LeftBreakpoint, true);
+        const acceptor = parseStarFusionBreakpoint(row.RightBreakpoint, false);
+        const [primary, mate] = flip ? [acceptor, donor] : [donor, acceptor];
+        return new SimpleFeature({
+            uniqueId,
+            ...primary,
+            name: row.FusionName,
+            score: row.JunctionReadCount ? +row.JunctionReadCount : undefined,
+            type: 'fusion',
+            mate,
+            ...row,
+        });
+    }
+    async loadFeatureTreeP(refName) {
+        const { columnNames, feats1, feats2 } = await this.loadData();
+        return buildPairedIntervalTree(feats1, feats2, refName, this.id, (line, uniqueId, flip) => this.featureFromLine(line, columnNames, uniqueId, flip));
+    }
+    treeFeatures = intervalTreeFeatures(opts => this.loadData(opts), refName => this.loadFeatureTreeP(refName));
+    getFeatures(query, opts) {
+        return this.treeFeatures(query, opts);
+    }
+}

package/esm/StarFusionAdapter/configSchema.d.ts

@@ -0,0 +1,30 @@
+import type { Instance } from '@jbrowse/mobx-state-tree';
+export declare function normalizeSnapshot(snap: Record<string, unknown>): Record<string, unknown>;
+/**
+ * #config StarFusionAdapter
+ * #trackType VariantTrack
+ * #fileFormat variants | STAR-Fusion
+ * used to load STAR-Fusion `star-fusion.fusion_predictions.tsv` output
+ *
+ * #example
+ * ```js
+ * {
+ *   type: 'StarFusionAdapter',
+ *   uri: 'https://example.com/star-fusion.fusion_predictions.tsv',
+ * }
+ * ```
+ */
+declare const StarFusionAdapter: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+    type: {
+        type: "string";
+    } & {
+        defaultValue: string;
+    };
+    readonly starFusionLocation: {
+        type: "fileLocation";
+    } & {
+        defaultValue: unknown;
+    };
+}, 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

@@ -0,0 +1,43 @@
+import { ConfigurationSchema, expandUriShorthand, } from '@jbrowse/core/configuration';
+export function normalizeSnapshot(snap) {
+    return expandUriShorthand(snap, 'starFusionLocation');
+}
+/**
+ * #config StarFusionAdapter
+ * #trackType VariantTrack
+ * #fileFormat variants | STAR-Fusion
+ * used to load STAR-Fusion `star-fusion.fusion_predictions.tsv` output
+ *
+ * #example
+ * ```js
+ * {
+ *   type: 'StarFusionAdapter',
+ *   uri: 'https://example.com/star-fusion.fusion_predictions.tsv',
+ * }
+ * ```
+ */
+const StarFusionAdapter = ConfigurationSchema('StarFusionAdapter', {
+    /**
+     * #slot
+     */
+    starFusionLocation: {
+        type: 'fileLocation',
+        description: 'STAR-Fusion TSV output file (plain text or gzipped)',
+        defaultValue: {
+            uri: '/path/to/star-fusion.fusion_predictions.tsv',
+            locationType: 'UriLocation',
+        },
+    },
+}, {
+    explicitlyTyped: true,
+    /**
+     * #preProcessSnapshot
+     *
+     * Allows minimal config:
+     * ```json
+     * { "type": "StarFusionAdapter", "uri": "star-fusion.tsv" }
+     * ```
+     */
+    preProcessSnapshot: normalizeSnapshot,
+});
+export default StarFusionAdapter;

package/esm/StarFusionAdapter/index.d.ts

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

package/esm/StarFusionAdapter/index.js

@@ -0,0 +1,12 @@
+import AdapterType from '@jbrowse/core/pluggableElementTypes/AdapterType';
+import configSchema, { normalizeSnapshot } from './configSchema.js';
+export default function StarFusionAdapterF(pluginManager) {
+    pluginManager.addAdapterType(() => new AdapterType({
+        name: 'StarFusionAdapter',
+        displayName: 'STAR-Fusion adapter',
+        configSchema,
+        getAdapterClass: () => import('./StarFusionAdapter.js').then(r => r.default),
+        locationKey: 'starFusionLocation',
+        normalizeSnapshot,
+    }));
+}

package/esm/adapterUtil.d.ts

@@ -0,0 +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(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

@@ -0,0 +1,43 @@
+import { IntervalTree } from '@jbrowse/core/util';
+import { ObservableCreate } from '@jbrowse/core/util/rxjs';
+// `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.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
+// starts here (feats2, flip=true). Shared by BedpeAdapter and StarFusionAdapter.
+export function buildPairedIntervalTree(feats1, feats2, refName, idPrefix, makeFeature) {
+    const tree = new IntervalTree();
+    for (const [i, line] of (feats1[refName] ?? []).entries()) {
+        const f = makeFeature(line, `${idPrefix}-${refName}-${i}-r1`, false);
+        tree.insert([f.get('start'), f.get('end')], f);
+    }
+    for (const [i, line] of (feats2[refName] ?? []).entries()) {
+        const f = makeFeature(line, `${idPrefix}-${refName}-${i}-r2`, true);
+        tree.insert([f.get('start'), f.get('end')], f);
+    }
+    return tree;
+}

package/esm/bedGraphUtil.d.ts

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

package/esm/bedGraphUtil.js

@@ -0,0 +1,20 @@
+import { SimpleFeature } from '@jbrowse/core/util';
+// Build a single-score bedGraph feature for value column j, or undefined when
+// 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
+        : new SimpleFeature({
+            id: uniqueId,
+            data: {
+                refName,
+                start,
+                end,
+                score,
+                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.d.ts

@@ -16,7 +16,7 @@ export declare function generateBedMethylFeature({ splitLine, uniqueId, refName,
     end: number;
     code: string | undefined;
     score: number;
-    strand: string | undefined;
+    strand: number;
     color: string | undefined;
     source: string | undefined;
     n_valid_cov: string | undefined;

package/esm/generateBedMethylFeature.js

@@ -1,19 +1,37 @@
+import { parseStrand } from './util.js';
+// this uses modkit bedMethyl. unclear how to reliably detect minimal 9+2 bedMethyl
 export function isBedMethylFeature({ splitLine, start, end, }) {
-    return (+(splitLine[6] || 0) === start &&
-        +(splitLine[7] || 0) === end &&
-        [9, 10, 11, 12, 13, 14, 15, 16, 17].every(r => splitLine[r] && !Number.isNaN(+splitLine[r])));
+    if (splitLine.length < 18 ||
+        +splitLine[6] !== start ||
+        +splitLine[7] !== end) {
+        return false;
+    }
+    // columns 9-17 are the nine numeric methylation stats
+    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, }) {
-    const [, , , code, , strand, , , color, n_valid_cov, fraction_modified, n_mod, n_canonical, n_other_mod, n_delete, n_fail, n_diff, n_nocall,] = splitLine;
+    // see
+    // https://github.com/nanoporetech/modkit?tab=readme-ov-file#description-of-bedmethyl-output
+    const code = splitLine[3];
+    const strandRaw = splitLine[5];
+    const color = splitLine[8];
+    const [n_valid_cov, fraction_modified, n_mod, n_canonical, n_other_mod, n_delete, n_fail, n_diff, n_nocall,] = splitLine.slice(9);
     return {
         uniqueId,
         refName,
         start,
         end,
         code,
-        score: +fraction_modified || 0,
-        strand,
+        score: +fraction_modified,
+        strand: parseStrand(strandRaw),
         color,
+        // source mirrors code so MultiQuantitativeTrack groups by modification code
         source: code,
         n_valid_cov,
         fraction_modified,

package/esm/generateRastairMethylFeature.d.ts

@@ -0,0 +1,28 @@
+export declare function isRastairMethylFeature(names: string[]): boolean;
+export declare function generateRastairMethylFeature({ splitLine, names, uniqueId, refName, start, end, }: {
+    splitLine: string[];
+    names: string[];
+    uniqueId: string;
+    refName: string;
+    start: number;
+    end: number;
+}): {
+    uniqueId: string;
+    refName: string;
+    start: number;
+    end: number;
+    code: string;
+    source: string;
+    score: number;
+    fraction_modified: number;
+    strand: number;
+    n_valid_cov: string | undefined;
+    n_mod: string | undefined;
+    n_canonical: string | undefined;
+    beta_est: string | undefined;
+    no_snp: string | undefined;
+    snp: string | undefined;
+    coverage: string | undefined;
+    genotype: string | undefined;
+    gt_conf_score: string | undefined;
+};