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

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/StarFusionAdapter/StarFusionAdapter.d.ts

@@ -0,0 +1,15 @@
+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';
+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;
+    getFeatures(query: Region, opts?: BaseOptions): import("rxjs").Observable<Feature>;
+}

package/esm/StarFusionAdapter/StarFusionAdapter.js

@@ -0,0 +1,121 @@
+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 { 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);
+        let columnNames = [];
+        let leftIdx = -1;
+        let rightIdx = -1;
+        const feats1 = {};
+        const feats2 = {};
+        parseLineByLine(buffer, line => {
+            if (line.startsWith('#')) {
+                columnNames = line.slice(1).split('\t');
+                leftIdx = columnNames.indexOf('LeftBreakpoint');
+                rightIdx = columnNames.indexOf('RightBreakpoint');
+            }
+            else if (leftIdx >= 0 && rightIdx >= 0) {
+                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) {
+                    ;
+                    (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 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
+        return new SimpleFeature({
+            uniqueId,
+            refName: primaryBp.refName,
+            start: primaryBp.start,
+            end: primaryBp.end,
+            strand: primaryBp.strand,
+            mateDirection: tickDirection(primaryBp.strand, !flip),
+            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),
+            },
+            ...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));
+    }
+    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));
+    }
+}

package/esm/StarFusionAdapter/configSchema.d.ts

@@ -0,0 +1,31 @@
+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<{
+    /**
+     * #slot
+     */
+    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";
+        };
+    };
+}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
+export type StarFusionAdapterConfig = Instance<typeof StarFusionAdapter>;
+export default StarFusionAdapter;

package/esm/StarFusionAdapter/configSchema.js

@@ -0,0 +1,52 @@
+import { ConfigurationSchema } from '@jbrowse/core/configuration';
+export function normalizeSnapshot(snap) {
+    return snap.uri
+        ? {
+            ...snap,
+            starFusionLocation: {
+                uri: snap.uri,
+                baseUri: snap.baseUri,
+                locationType: 'UriLocation',
+            },
+        }
+        : snap;
+}
+/**
+ * #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(query: Region, opts: BaseOptions, loadTree: (refName: string) => Promise<IntervalTree<Feature> | undefined>): 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,28 @@
+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) => {
+        const tree = await loadTree(query.refName);
+        for (const f of tree?.search([query.start, query.end]) ?? []) {
+            observer.next(f);
+        }
+        observer.complete();
+    }, opts.stopToken);
+}
+// 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,10 @@
+import type { Feature } from '@jbrowse/core/util';
+export declare function makeBedGraphFeature({ uniqueId, refName, start, end, names, j, value, }: {
+    uniqueId: string;
+    refName: string;
+    start: number;
+    end: number;
+    names: string[];
+    j: number;
+    value: string;
+}): Feature | undefined;

package/esm/bedGraphUtil.js

@@ -0,0 +1,18 @@
+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, }) {
+    const score = +value;
+    return Number.isNaN(score)
+        ? undefined
+        : new SimpleFeature({
+            id: uniqueId,
+            data: {
+                refName,
+                start,
+                end,
+                score,
+                source: names[j] || `col${j}`,
+            },
+        });
+}

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,32 @@
+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])));
+    // 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)));
 }
 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;
+};

package/esm/generateRastairMethylFeature.js

@@ -0,0 +1,38 @@
+import { parseStrand } from './util.js';
+// Rastair (https://www.rastair.com) emits a headered BED/TSV of per-CpG
+// methylation calls from TAPS / mod-C→T data. Its layout differs from modkit
+// bedMethyl, so it's identified by the header column names rather than
+// positionally: #chr start end name beta_est strand unmod mod no_snp snp
+// coverage genotype gt_p_score gt_conf_score
+const RASTAIR_COLUMNS = ['beta_est', 'unmod', 'mod', 'coverage'];
+export function isRastairMethylFeature(names) {
+    return RASTAIR_COLUMNS.every(col => names.includes(col));
+}
+export function generateRastairMethylFeature({ splitLine, names, uniqueId, refName, start, end, }) {
+    const col = (name) => splitLine[names.indexOf(name)];
+    // beta_est is a 0-1 fraction; the shared bedMethyl display path expects a
+    // 0-100 percentage (modkit fraction_modified), so scale to match
+    const fraction_modified = Number(col('beta_est')) * 100;
+    return {
+        uniqueId,
+        refName,
+        start,
+        end,
+        // rastair reports modified C (5mC); use modkit's 'm' code so it groups and
+        // colors as 5mC methylation in the shared bedMethyl display path
+        code: 'm',
+        source: 'm',
+        score: fraction_modified,
+        fraction_modified,
+        strand: parseStrand(col('strand')),
+        n_valid_cov: col('coverage'),
+        n_mod: col('mod'),
+        n_canonical: col('unmod'),
+        beta_est: col('beta_est'),
+        no_snp: col('no_snp'),
+        snp: col('snp'),
+        coverage: col('coverage'),
+        genotype: col('genotype'),
+        gt_conf_score: col('gt_conf_score'),
+    };
+}

package/esm/generateRepeatMaskerFeature.d.ts

@@ -1,51 +1,4 @@
-export declare function isRepeatMaskerDescriptionField(desc?: unknown): desc is string;
-export declare function generateRepeatMaskerFeature({ uniqueId, refName, start, end, description, ...rest }: {
-    uniqueId: string;
-    refName: string;
-    start: number;
-    end: number;
-    description: string;
-    [key: string]: unknown;
-}): {
-    uniqueId: string;
-    refName: string;
-    start: number;
-    end: number;
-    bitsw_score: string | undefined;
-    percent_div: string | undefined;
-    percent_del: string | undefined;
-    percent_ins: string | undefined;
-    query_chr: string | undefined;
-    query_begin: string | undefined;
-    query_end: string | undefined;
-    query_remaining: string | undefined;
-    orientation: string | undefined;
-    matching_repeat_name: string | undefined;
-    matching_repeat_class: string | undefined;
-    matching_repeat_begin: string | undefined;
-    matching_repeat_end: string | undefined;
-    matching_repeat_remaining: string | undefined;
-    repeat_id: string | undefined;
-    description?: undefined;
-} | {
-    uniqueId: string;
-    refName: string;
-    start: number;
-    end: number;
-    description: undefined;
-    bitsw_score?: undefined;
-    percent_div?: undefined;
-    percent_del?: undefined;
-    percent_ins?: undefined;
-    query_chr?: undefined;
-    query_begin?: undefined;
-    query_end?: undefined;
-    query_remaining?: undefined;
-    orientation?: undefined;
-    matching_repeat_name?: undefined;
-    matching_repeat_class?: undefined;
-    matching_repeat_begin?: undefined;
-    matching_repeat_end?: undefined;
-    matching_repeat_remaining?: undefined;
-    repeat_id?: undefined;
-};
+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 {};

package/esm/generateRepeatMaskerFeature.js

@@ -1,43 +1,30 @@
-export function isRepeatMaskerDescriptionField(desc) {
-    if (typeof desc !== 'string') {
-        return false;
+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.
+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] ?? '']));
+        }
     }
-    else {
-        const ret = desc.trim().split(' ');
-        return [0, 1, 2, 3, 5, 6].every(s => ret[s] !== undefined ? !Number.isNaN(+ret[s]) : false);
-    }
-}
-function makeRepeatTrackDescription(description) {
-    if (isRepeatMaskerDescriptionField(description)) {
-        const [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,] = description.trim().split(' ');
-        return {
-            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,
-        };
-    }
-    return { description };
-}
-export function generateRepeatMaskerFeature({ uniqueId, refName, start, end, description, ...rest }) {
-    const { subfeatures, ...rest2 } = rest;
-    return {
-        ...rest2,
-        ...makeRepeatTrackDescription(description),
-        uniqueId,
-        refName,
-        start,
-        end,
-    };
+    return undefined;
 }

package/esm/generateUcscTranscript.d.ts

@@ -1,12 +1,20 @@
 import type { MinimalFeature } from './types.ts';
-export declare function isUcscTranscript({ thickStart, blockCount, strand, }: {
-    thickStart?: unknown;
-    blockCount?: unknown;
+interface UcscTranscriptCheck {
+    thickStart?: number;
+    thickEnd?: number;
+    blockCount?: number;
     strand?: number;
-}): boolean;
+}
+interface ValidUcscTranscriptCheck {
+    thickStart: number;
+    thickEnd: number;
+    blockCount: number;
+    strand: number;
+}
+export declare function isUcscTranscript(input: UcscTranscriptCheck): input is ValidUcscTranscriptCheck;
 interface UcscTranscriptInput {
     uniqueId: string;
-    strand?: number;
+    strand: number;
     thickStart: number;
     thickEnd: number;
     refName: string;
@@ -15,10 +23,10 @@ interface UcscTranscriptInput {
     subfeatures: MinimalFeature[];
     [key: string]: unknown;
 }
-interface UcscTranscriptOutput {
+interface UcscTranscriptOutput extends MinimalFeature {
     uniqueId: string;
     strand: number;
-    type: string;
+    type: 'mRNA' | 'transcript';
     refName: string;
     start: number;
     end: number;