@jbrowse/plugin-alignments 3.6.5 → 4.0.0

package/esm/BamAdapter/BamSlightlyLazyFeature.js

@@ -1,27 +1,137 @@
-import { getMismatches } from '../MismatchParser';
-import { cacheGetter } from '../shared/util';
-export default class BamSlightlyLazyFeature {
-    constructor(record, adapter, ref) {
-        this.record = record;
-        this.adapter = adapter;
-        this.ref = ref;
-    }
+import { BamRecord } from '@gmod/bam';
+import { forEachMismatchNumeric } from "./forEachMismatchNumeric.js";
+import { CHAR_FROM_CODE, CIGAR_H, CIGAR_S, } from "../PileupRenderer/renderers/cigarUtil.js";
+import { decodeSeq } from "../shared/decodeSeq.js";
+import { HARDCLIP_TYPE, INSERTION_TYPE, MISMATCH_TYPE, SOFTCLIP_TYPE, } from "../shared/forEachMismatchTypes.js";
+import { convertTagsToPlainArrays } from "../shared/util.js";
+export default class BamSlightlyLazyFeature extends BamRecord {
+    adapter;
+    ref;
+    _cachedFields;
     id() {
-        return `${this.adapter.id}-${this.record.id}`;
+        return `${this.adapter.id}-${this.fileOffset}`;
+    }
+    get seq() {
+        return decodeSeq(this.NUMERIC_SEQ, this.seq_length);
     }
     get mismatches() {
-        return getMismatches(this.record.CIGAR, this.record.tags.MD, this.record.seq, this.ref, this.record.qual);
+        const mismatches = [];
+        this.forEachMismatch((type, start, length, base, qual, altbase, cliplen) => {
+            if (type === MISMATCH_TYPE) {
+                mismatches.push({
+                    type: 'mismatch',
+                    start,
+                    length,
+                    base,
+                    qual: qual !== undefined && qual >= 0 ? qual : undefined,
+                    altbase: altbase !== undefined && altbase > 0
+                        ? CHAR_FROM_CODE[altbase]
+                        : undefined,
+                });
+            }
+            else if (type === INSERTION_TYPE) {
+                mismatches.push({
+                    type: 'insertion',
+                    start,
+                    length,
+                    insertlen: cliplen,
+                    insertedBases: base,
+                });
+            }
+            else if (type === SOFTCLIP_TYPE) {
+                mismatches.push({
+                    type: 'softclip',
+                    start,
+                    length,
+                    cliplen: cliplen,
+                });
+            }
+            else if (type === HARDCLIP_TYPE) {
+                mismatches.push({
+                    type: 'hardclip',
+                    start,
+                    length,
+                    cliplen: cliplen,
+                });
+            }
+            else {
+                mismatches.push({
+                    type: type === 2 ? 'deletion' : 'skip',
+                    start,
+                    length,
+                });
+            }
+        });
+        return mismatches;
+    }
+    forEachMismatch(callback) {
+        forEachMismatchNumeric(this.NUMERIC_CIGAR, this.NUMERIC_SEQ, this.seq_length, this.NUMERIC_MD, this.qual, this.ref, callback);
+    }
+    get qualString() {
+        return this.qual?.join(' ');
+    }
+    get clipLengthAtStartOfRead() {
+        const cigar = this.NUMERIC_CIGAR;
+        if (cigar.length === 0) {
+            return 0;
+        }
+        const packed = this.strand === -1 ? cigar[cigar.length - 1] : cigar[0];
+        const op = packed & 0xf;
+        if (op === CIGAR_S || op === CIGAR_H) {
+            return packed >> 4;
+        }
+        return 0;
     }
-    get qual() {
-        var _a;
-        return (_a = this.record.qual) === null || _a === void 0 ? void 0 : _a.join(' ');
+    get refName() {
+        return this.adapter.refIdToName(this.ref_id);
     }
     get(field) {
-        return field === 'mismatches'
-            ? this.mismatches
-            : field === 'qual'
-                ? this.qual
-                : this.fields[field];
+        switch (field) {
+            case 'mismatches':
+                return this.mismatches;
+            case 'name':
+                return this.name;
+            case 'start':
+                return this.start;
+            case 'refName':
+                return this.refName;
+            case 'end':
+                return this.end;
+            case 'strand':
+                return this.strand;
+            case 'qual':
+                return this.qualString;
+            case 'seq':
+                return this.seq;
+            case 'tags':
+                return this.tags;
+            case 'NUMERIC_SEQ':
+                return this.NUMERIC_SEQ;
+            case 'NUMERIC_CIGAR':
+                return this.NUMERIC_CIGAR;
+            case 'CIGAR':
+                return this.CIGAR;
+            case 'NUMERIC_QUAL':
+                return this.qual;
+            case 'NUMERIC_MD':
+                return this.NUMERIC_MD;
+            case 'seq_length':
+                return this.seq_length;
+            case 'flags':
+                return this.flags;
+            case 'pair_orientation':
+                return this.pair_orientation;
+            case 'next_ref':
+                return this.next_ref;
+            case 'next_pos':
+                return this.next_pos;
+            case 'template_length':
+                return this.template_length;
+            case 'clipLengthAtStartOfRead':
+                return this.clipLengthAtStartOfRead;
+            default:
+                return this.fields[field];
+        }
     }
     parent() {
         return undefined;
@@ -30,37 +140,44 @@ export default class BamSlightlyLazyFeature {
         return undefined;
     }
     get fields() {
-        const r = this.record;
-        const a = this.adapter;
-        const p = r.isPaired();
-        return {
-            start: r.start,
-            name: r.name,
-            end: r.end,
-            score: r.score,
-            strand: r.strand,
-            template_length: r.template_length,
-            flags: r.flags,
-            tags: r.tags,
-            refName: a.refIdToName(r.ref_id),
-            CIGAR: r.CIGAR,
-            seq: r.seq,
-            type: 'match',
-            pair_orientation: r.pair_orientation,
-            next_ref: p ? a.refIdToName(r.next_refid) : undefined,
-            next_pos: p ? r.next_pos : undefined,
-            next_segment_position: p
-                ? `${a.refIdToName(r.next_refid)}:${r.next_pos + 1}`
-                : undefined,
-            uniqueId: this.id(),
-        };
+        if (this._cachedFields === undefined) {
+            this._cachedFields = {
+                start: this.start,
+                name: this.name,
+                end: this.end,
+                score: this.score,
+                strand: this.strand,
+                template_length: this.template_length,
+                flags: this.flags,
+                tags: this.tags,
+                refName: this.refName,
+                type: 'match',
+                pair_orientation: this.pair_orientation,
+                next_ref: this.next_ref,
+                next_pos: this.next_pos,
+                next_segment_position: this.next_segment_position,
+                uniqueId: this.id(),
+            };
+        }
+        return this._cachedFields;
+    }
+    get next_ref() {
+        return this.isPaired()
+            ? this.adapter.refIdToName(this.next_refid)
+            : undefined;
+    }
+    get next_segment_position() {
+        return this.isPaired()
+            ? `${this.adapter.refIdToName(this.next_refid)}:${this.next_pos + 1}`
+            : undefined;
     }
     toJSON() {
         return {
             ...this.fields,
-            qual: this.qual,
+            CIGAR: this.CIGAR,
+            seq: this.seq,
+            tags: convertTagsToPlainArrays(this.tags),
+            qual: this.qualString,
         };
     }
 }
-cacheGetter(BamSlightlyLazyFeature, 'fields');
-cacheGetter(BamSlightlyLazyFeature, 'mismatches');

package/esm/BamAdapter/configSchema.d.ts

@@ -1,4 +1,4 @@
-declare const configSchema: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+declare const configSchema: import("node_modules/@jbrowse/core/src/configuration/configurationSchema").ConfigurationSchemaType<{
     bamLocation: {
         type: string;
         defaultValue: {
@@ -6,9 +6,9 @@ declare const configSchema: import("@jbrowse/core/configuration/configurationSch
             locationType: string;
         };
     };
-    index: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+    index: import("node_modules/@jbrowse/core/src/configuration/configurationSchema").ConfigurationSchemaType<{
         indexType: {
-            model: import("mobx-state-tree").ISimpleType<string>;
+            model: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
             type: string;
             defaultValue: string;
         };
@@ -19,16 +19,11 @@ declare const configSchema: import("@jbrowse/core/configuration/configurationSch
                 locationType: string;
             };
         };
-    }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
+    }, import("node_modules/@jbrowse/core/src/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
     fetchSizeLimit: {
         type: string;
         description: string;
         defaultValue: number;
     };
-    sequenceAdapter: {
-        type: string;
-        description: string;
-        defaultValue: null;
-    };
-}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
+}, import("node_modules/@jbrowse/core/src/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
 export default configSchema;

package/esm/BamAdapter/configSchema.js

@@ -1,5 +1,5 @@
 import { ConfigurationSchema } from '@jbrowse/core/configuration';
-import { types } from 'mobx-state-tree';
+import { types } from '@jbrowse/mobx-state-tree';
 function x() { }
 const configSchema = ConfigurationSchema('BamAdapter', {
     bamLocation: {
@@ -26,12 +26,7 @@ const configSchema = ConfigurationSchema('BamAdapter', {
     fetchSizeLimit: {
         type: 'number',
         description: 'size to fetch in bytes over which to display a warning to the user that too much data will be fetched',
-        defaultValue: 5000000,
-    },
-    sequenceAdapter: {
-        type: 'frozen',
-        description: 'sequence data adapter, used to calculate SNPs when BAM reads lacking MD tags',
-        defaultValue: null,
+        defaultValue: 5_000_000,
     },
 }, {
     explicitlyTyped: true,

package/esm/BamAdapter/forEachMismatchNumeric.d.ts

@@ -0,0 +1,2 @@
+import type { MismatchCallback } from '../shared/forEachMismatchTypes.ts';
+export declare function forEachMismatchNumeric(cigar: ArrayLike<number>, numericSeq: ArrayLike<number>, seqLength: number, md: ArrayLike<number> | undefined, qual: ArrayLike<number> | null | undefined, ref: string | undefined, callback: MismatchCallback): void;

package/esm/BamAdapter/forEachMismatchNumeric.js

@@ -0,0 +1,207 @@
+import { CIGAR_D, CIGAR_H, CIGAR_I, CIGAR_M_EQ_MASK, CIGAR_N, CIGAR_S, CIGAR_X, SEQRET, SEQRET_NUMERIC_DECODER, } from "../PileupRenderer/renderers/cigarUtil.js";
+import { DELETION_TYPE, HARDCLIP_TYPE, INSERTION_TYPE, MISMATCH_TYPE, SKIP_TYPE, SOFTCLIP_TYPE, } from "../shared/forEachMismatchTypes.js";
+export function forEachMismatchNumeric(cigar, numericSeq, seqLength, md, qual, ref, callback) {
+    if (seqLength === 0) {
+        let roffset = 0;
+        for (let i = 0, l = cigar.length; i < l; i++) {
+            const packed = cigar[i];
+            const len = packed >> 4;
+            const op = packed & 0xf;
+            if ((1 << op) & CIGAR_M_EQ_MASK) {
+                roffset += len;
+            }
+            else if (op === CIGAR_I) {
+                callback(INSERTION_TYPE, roffset, 0, '*', -1, 0, len);
+            }
+            else if (op === CIGAR_D) {
+                callback(DELETION_TYPE, roffset, len, '*', -1, 0, 0);
+                roffset += len;
+            }
+            else if (op === CIGAR_N) {
+                callback(SKIP_TYPE, roffset, len, 'N', -1, 0, 0);
+                roffset += len;
+            }
+            else if (op === CIGAR_S) {
+                callback(SOFTCLIP_TYPE, roffset, 1, `S${len}`, -1, 0, len);
+            }
+            else if (op === CIGAR_H) {
+                callback(HARDCLIP_TYPE, roffset, 1, `H${len}`, -1, 0, len);
+            }
+        }
+        return;
+    }
+    const mdLength = md?.length ?? 0;
+    const hasQual = !!qual;
+    const hasMD = md && mdLength > 0;
+    let roffset = 0;
+    let soffset = 0;
+    let mdIdx = 0;
+    let mdMatchRemaining = 0;
+    if (hasMD) {
+        while (mdIdx < mdLength) {
+            const c = md[mdIdx];
+            if (c >= 48 && c <= 57) {
+                mdMatchRemaining = mdMatchRemaining * 10 + (c - 48);
+                mdIdx++;
+            }
+            else {
+                break;
+            }
+        }
+    }
+    for (let i = 0, l = cigar.length; i < l; i++) {
+        const packed = cigar[i];
+        const len = packed >> 4;
+        const op = packed & 0xf;
+        if ((1 << op) & CIGAR_M_EQ_MASK) {
+            if (hasMD) {
+                let remaining = len;
+                let localOffset = 0;
+                while (remaining > 0) {
+                    if (mdMatchRemaining >= remaining) {
+                        mdMatchRemaining -= remaining;
+                        localOffset += remaining;
+                        remaining = 0;
+                    }
+                    else {
+                        localOffset += mdMatchRemaining;
+                        remaining -= mdMatchRemaining;
+                        mdMatchRemaining = 0;
+                        if (mdIdx < mdLength && md[mdIdx] >= 65 && md[mdIdx] <= 90) {
+                            const seqIdx = soffset + localOffset;
+                            const sb = numericSeq[seqIdx >> 1];
+                            const nibble = (sb >> ((1 - (seqIdx & 1)) << 2)) & 0xf;
+                            callback(MISMATCH_TYPE, roffset + localOffset, 1, SEQRET[nibble], hasQual ? qual[seqIdx] : -1, md[mdIdx], 0);
+                            mdIdx++;
+                            localOffset++;
+                            remaining--;
+                            mdMatchRemaining = 0;
+                            while (mdIdx < mdLength) {
+                                const c = md[mdIdx];
+                                if (c >= 48 && c <= 57) {
+                                    mdMatchRemaining = mdMatchRemaining * 10 + (c - 48);
+                                    mdIdx++;
+                                }
+                                else {
+                                    break;
+                                }
+                            }
+                        }
+                        else {
+                            break;
+                        }
+                    }
+                }
+            }
+            else if (ref) {
+                for (let j = 0; j < len; j++) {
+                    const seqIdx = soffset + j;
+                    const sb = numericSeq[seqIdx >> 1];
+                    const nibble = (sb >> ((1 - (seqIdx & 1)) << 2)) & 0xf;
+                    const seqBaseCode = SEQRET_NUMERIC_DECODER[nibble];
+                    const refCharCode = ref.charCodeAt(roffset + j);
+                    if (seqBaseCode !== (refCharCode | 0x20)) {
+                        callback(MISMATCH_TYPE, roffset + j, 1, SEQRET[nibble], hasQual ? qual[seqIdx] : -1, refCharCode, 0);
+                    }
+                }
+            }
+            soffset += len;
+            roffset += len;
+        }
+        else if (op === CIGAR_I) {
+            let insertedBases;
+            if (len === 1) {
+                const sb = numericSeq[soffset >> 1];
+                const nibble = (sb >> ((1 - (soffset & 1)) << 2)) & 0xf;
+                insertedBases = SEQRET[nibble];
+            }
+            else if (len === 2) {
+                const seqIdx0 = soffset;
+                const sb0 = numericSeq[seqIdx0 >> 1];
+                const nibble0 = (sb0 >> ((1 - (seqIdx0 & 1)) << 2)) & 0xf;
+                const seqIdx1 = soffset + 1;
+                const sb1 = numericSeq[seqIdx1 >> 1];
+                const nibble1 = (sb1 >> ((1 - (seqIdx1 & 1)) << 2)) & 0xf;
+                insertedBases = SEQRET[nibble0] + SEQRET[nibble1];
+            }
+            else {
+                const bases = new Array(len);
+                for (let j = 0; j < len; j++) {
+                    const seqIdx = soffset + j;
+                    const sb = numericSeq[seqIdx >> 1];
+                    const nibble = (sb >> ((1 - (seqIdx & 1)) << 2)) & 0xf;
+                    bases[j] = SEQRET[nibble];
+                }
+                insertedBases = bases.join('');
+            }
+            callback(INSERTION_TYPE, roffset, 0, insertedBases, -1, 0, len);
+            soffset += len;
+        }
+        else if (op === CIGAR_D) {
+            callback(DELETION_TYPE, roffset, len, '*', -1, 0, 0);
+            if (hasMD && mdIdx < mdLength && md[mdIdx] === 94) {
+                mdIdx++;
+                while (mdIdx < mdLength && md[mdIdx] >= 65) {
+                    mdIdx++;
+                }
+                mdMatchRemaining = 0;
+                while (mdIdx < mdLength) {
+                    const c = md[mdIdx];
+                    if (c >= 48 && c <= 57) {
+                        mdMatchRemaining = mdMatchRemaining * 10 + (c - 48);
+                        mdIdx++;
+                    }
+                    else {
+                        break;
+                    }
+                }
+            }
+            roffset += len;
+        }
+        else if (op === CIGAR_N) {
+            callback(SKIP_TYPE, roffset, len, 'N', -1, 0, 0);
+            roffset += len;
+        }
+        else if (op === CIGAR_X) {
+            for (let j = 0; j < len; j++) {
+                const seqIdx = soffset + j;
+                const sb = numericSeq[seqIdx >> 1];
+                const nibble = (sb >> ((1 - (seqIdx & 1)) << 2)) & 0xf;
+                let altbaseCode = 0;
+                if (hasMD) {
+                    if (mdMatchRemaining === 0 && mdIdx < mdLength && md[mdIdx] >= 65) {
+                        altbaseCode = md[mdIdx];
+                        mdIdx++;
+                        mdMatchRemaining = 0;
+                        while (mdIdx < mdLength) {
+                            const c = md[mdIdx];
+                            if (c >= 48 && c <= 57) {
+                                mdMatchRemaining = mdMatchRemaining * 10 + (c - 48);
+                                mdIdx++;
+                            }
+                            else {
+                                break;
+                            }
+                        }
+                    }
+                    else if (mdMatchRemaining > 0) {
+                        mdMatchRemaining--;
+                    }
+                }
+                else if (ref) {
+                    altbaseCode = ref.charCodeAt(roffset + j);
+                }
+                callback(MISMATCH_TYPE, roffset + j, 1, SEQRET[nibble], hasQual ? qual[seqIdx] : -1, altbaseCode, 0);
+            }
+            soffset += len;
+            roffset += len;
+        }
+        else if (op === CIGAR_S) {
+            callback(SOFTCLIP_TYPE, roffset, 1, `S${len}`, -1, 0, len);
+            soffset += len;
+        }
+        else if (op === CIGAR_H) {
+            callback(HARDCLIP_TYPE, roffset, 1, `H${len}`, -1, 0, len);
+        }
+    }
+}

package/esm/BamAdapter/index.js

@@ -1,12 +1,12 @@
 import AdapterType from '@jbrowse/core/pluggableElementTypes/AdapterType';
-import configSchema from './configSchema';
+import configSchema from "./configSchema.js";
 export default function BamAdapterF(pluginManager) {
     pluginManager.addAdapterType(() => {
         return new AdapterType({
             name: 'BamAdapter',
             displayName: 'BAM adapter',
             configSchema,
-            getAdapterClass: () => import('./BamAdapter').then(r => r.default),
+            getAdapterClass: () => import("./BamAdapter.js").then(r => r.default),
         });
     });
 }

package/esm/CramAdapter/CramAdapter.d.ts

@@ -1,39 +1,19 @@
-import { IndexedCramFile } from '@gmod/cram';
 import { BaseFeatureDataAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
-import CramSlightlyLazyFeature from './CramSlightlyLazyFeature';
-import type { FilterBy } from '../shared/types';
-import type { CramRecord } from '@gmod/cram';
+import type { FilterBy } from '../shared/types.ts';
+import type { ParsedSamHeader } from '../shared/util.ts';
 import type { BaseOptions, BaseSequenceAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
 import type { Feature, Region } from '@jbrowse/core/util';
-interface Header {
-    idToName?: string[];
-    nameToId?: Record<string, number>;
-    readGroups?: (string | undefined)[];
-}
 export default class CramAdapter extends BaseFeatureDataAdapter {
-    samHeader: Header;
+    samHeader?: ParsedSamHeader;
     private setupP?;
-    private configureP?;
+    private configureResult?;
+    private sequenceAdapterP?;
     private ultraLongFeatureCache;
-    private seqIdToRefName;
     private seqIdToOriginalRefName;
-    configurePre(): Promise<{
-        cram: IndexedCramFile;
-        sequenceAdapter: BaseSequenceAdapter;
-    }>;
-    configure(): Promise<{
-        cram: IndexedCramFile;
-        sequenceAdapter: BaseSequenceAdapter;
-    }>;
+    private configure;
+    getSequenceAdapter(): Promise<BaseSequenceAdapter | undefined>;
     getHeader(_opts?: BaseOptions): Promise<string | undefined>;
-    private seqFetch;
-    private setupPre;
-    private setupPre2;
-    setup(opts?: BaseOptions): Promise<{
-        samHeader: Header;
-        cram: IndexedCramFile;
-        sequenceAdapter: BaseSequenceAdapter;
-    }>;
+    private setup;
     getRefNames(opts?: BaseOptions): Promise<string[]>;
     refNameToId(refName: string): number | undefined;
     refIdToName(refId: number): string | undefined;
@@ -41,13 +21,11 @@ export default class CramAdapter extends BaseFeatureDataAdapter {
     getFeatures(region: Region & {
         originalRefName?: string;
     }, opts?: BaseOptions & {
-        filterBy: FilterBy;
+        filterBy?: FilterBy;
     }): import("rxjs").Observable<Feature>;
-    cramRecordToFeature(record: CramRecord): CramSlightlyLazyFeature;
-    getMultiRegionFeatureDensityStats(regions: Region[], opts?: BaseOptions): Promise<{
+    getMultiRegionFeatureDensityStats(regions: Region[]): Promise<{
         bytes: number;
         fetchSizeLimit: any;
     }>;
     private bytesForRegions;
 }
-export {};