@jbrowse/plugin-alignments 3.7.0 → 4.0.1

package/esm/CramAdapter/CramAdapter.js

@@ -1,152 +1,92 @@
 import { CraiIndex, IndexedCramFile } from '@gmod/cram';
 import { BaseFeatureDataAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
-import { toLocale, updateStatus } from '@jbrowse/core/util';
+import { sum, updateStatus } from '@jbrowse/core/util';
 import QuickLRU from '@jbrowse/core/util/QuickLRU';
 import { openLocation } from '@jbrowse/core/util/io';
 import { ObservableCreate } from '@jbrowse/core/util/rxjs';
 import { checkStopToken } from '@jbrowse/core/util/stopToken';
-import { firstValueFrom } from 'rxjs';
-import { toArray } from 'rxjs/operators';
-import CramSlightlyLazyFeature from './CramSlightlyLazyFeature';
-import { filterReadFlag, filterTagValue } from '../shared/util';
+import CramSlightlyLazyFeature from "./CramSlightlyLazyFeature.js";
+import { filterReadFlag, filterTagValue, parseSamHeader, } from "../shared/util.js";
 export default class CramAdapter extends BaseFeatureDataAdapter {
-    constructor() {
-        super(...arguments);
-        this.samHeader = {};
-        this.ultraLongFeatureCache = new QuickLRU({
-            maxSize: 500,
-        });
-        this.seqIdToOriginalRefName = [];
-    }
-    async configurePre() {
-        const cramLocation = this.getConf('cramLocation');
-        const craiLocation = this.getConf('craiLocation');
-        const pm = this.pluginManager;
-        const cram = new IndexedCramFile({
-            cramFilehandle: openLocation(cramLocation, pm),
-            index: new CraiIndex({
-                filehandle: openLocation(craiLocation, pm),
-            }),
-            seqFetch: (...args) => this.seqFetch(...args),
-            checkSequenceMD5: false,
-        });
-        if (!this.getSubAdapter) {
-            throw new Error('Error getting subadapter');
-        }
-        const seqConf = this.getConf('sequenceAdapter');
-        if (!seqConf) {
-            throw new Error('no sequenceAdapter supplied to CramAdapter config');
+    samHeader;
+    setupP;
+    configureResult;
+    sequenceAdapterP;
+    ultraLongFeatureCache = new QuickLRU({
+        maxSize: 500,
+    });
+    seqIdToOriginalRefName = [];
+    configure() {
+        if (!this.configureResult) {
+            const cramLocation = this.getConf('cramLocation');
+            const craiLocation = this.getConf('craiLocation');
+            this.configureResult = {
+                cram: new IndexedCramFile({
+                    cramFilehandle: openLocation(cramLocation, this.pluginManager),
+                    index: new CraiIndex({
+                        filehandle: openLocation(craiLocation, this.pluginManager),
+                    }),
+                    seqFetch: async (seqId, start, end) => {
+                        const sequenceAdapter = await this.getSequenceAdapter();
+                        if (!sequenceAdapter) {
+                            throw new Error('no sequenceAdapter available');
+                        }
+                        const refName = this.refIdToOriginalName(seqId) || this.refIdToName(seqId);
+                        if (!refName) {
+                            throw new Error('unknown refName');
+                        }
+                        return ((await sequenceAdapter.getSequence({
+                            refName,
+                            start: start - 1,
+                            end,
+                        })) ?? '');
+                    },
+                    checkSequenceMD5: false,
+                }),
+            };
         }
-        const subadapter = await this.getSubAdapter(seqConf);
-        return {
-            cram,
-            sequenceAdapter: subadapter.dataAdapter,
-        };
+        return this.configureResult;
     }
-    async configure() {
-        if (!this.configureP) {
-            this.configureP = this.configurePre().catch((e) => {
-                this.configureP = undefined;
-                throw e;
-            });
+    async getSequenceAdapter() {
+        const config = this.sequenceAdapterConfig;
+        if (!config || !this.getSubAdapter) {
+            return undefined;
         }
-        return this.configureP;
+        this.sequenceAdapterP ??= this.getSubAdapter(config)
+            .then(r => r.dataAdapter)
+            .catch((e) => {
+            this.sequenceAdapterP = undefined;
+            throw e;
+        });
+        return this.sequenceAdapterP;
     }
     async getHeader(_opts) {
-        const { cram } = await this.configure();
+        const { cram } = this.configure();
         return cram.cram.getHeaderText();
     }
-    async seqFetch(seqId, start, end) {
-        start -= 1;
-        const { sequenceAdapter } = await this.configure();
-        const refName = this.refIdToOriginalName(seqId) || this.refIdToName(seqId);
-        if (!refName) {
-            throw new Error('unknown');
-        }
-        const seqChunks = await firstValueFrom(sequenceAdapter
-            .getFeatures({
-            refName,
-            start,
-            end,
-            assemblyName: '',
-        })
-            .pipe(toArray()));
-        const sequence = seqChunks
-            .sort((a, b) => a.get('start') - b.get('start'))
-            .map(chunk => {
-            const chunkStart = chunk.get('start');
-            const chunkEnd = chunk.get('end');
-            const trimStart = Math.max(start - chunkStart, 0);
-            const trimEnd = Math.min(end - chunkStart, chunkEnd - chunkStart);
-            const trimLength = trimEnd - trimStart;
-            const chunkSeq = chunk.get('seq') || chunk.get('residues');
-            return chunkSeq.slice(trimStart, trimStart + trimLength);
-        })
-            .join('');
-        const qlen = end - start;
-        if (sequence.length !== qlen) {
-            throw new Error(`fetching ${refName}:${toLocale(start - 1)}-${toLocale(end)} returned ${toLocale(sequence.length)} bases, should have returned ${toLocale(qlen)}`);
-        }
-        return sequence;
-    }
-    async setupPre(_opts) {
-        const conf = await this.configure();
-        const { cram } = conf;
-        const samHeader = await cram.cram.getSamHeader();
-        const idToName = [];
-        const nameToId = {};
-        for (const [refId, sqLine] of samHeader
-            .filter(l => l.tag === 'SQ')
-            .entries()) {
-            const SN = sqLine.data.find(item => item.tag === 'SN');
-            if (SN) {
-                const refName = SN.value;
-                nameToId[refName] = refId;
-                idToName[refId] = refName;
-            }
-        }
-        const readGroups = samHeader
-            .filter(l => l.tag === 'RG')
-            .map(rgLine => { var _a; return (_a = rgLine.data.find(item => item.tag === 'ID')) === null || _a === void 0 ? void 0 : _a.value; });
-        const data = { idToName, nameToId, readGroups };
-        this.samHeader = data;
-        return {
-            samHeader: data,
-            ...conf,
-        };
-    }
-    async setupPre2(opts) {
-        if (!this.setupP) {
-            this.setupP = this.setupPre(opts).catch((e) => {
-                this.setupP = undefined;
-                throw e;
-            });
-        }
+    async setup(_opts) {
+        this.setupP ??= (async () => {
+            const { cram } = this.configure();
+            const rawHeader = await cram.cram.getSamHeader();
+            const samHeader = parseSamHeader(rawHeader);
+            this.samHeader = samHeader;
+            return { samHeader, cram };
+        })().catch((e) => {
+            this.setupP = undefined;
+            this.configureResult = undefined;
+            throw e;
+        });
         return this.setupP;
     }
-    async setup(opts) {
-        const { statusCallback = () => { } } = opts || {};
-        return updateStatus('Downloading index', statusCallback, () => this.setupPre2(opts));
-    }
     async getRefNames(opts) {
         const { samHeader } = await this.setup(opts);
-        if (!samHeader.idToName) {
-            throw new Error('CRAM file has no header lines');
-        }
         return samHeader.idToName;
     }
     refNameToId(refName) {
-        if (this.samHeader.nameToId) {
-            return this.samHeader.nameToId[refName];
-        }
-        if (this.seqIdToRefName) {
-            return this.seqIdToRefName.indexOf(refName);
-        }
-        return undefined;
+        return this.samHeader?.nameToId[refName];
     }
     refIdToName(refId) {
-        var _a, _b;
-        return ((_a = this.samHeader.idToName) === null || _a === void 0 ? void 0 : _a[refId]) || ((_b = this.seqIdToRefName) === null || _b === void 0 ? void 0 : _b[refId]);
+        return this.samHeader?.idToName[refId];
     }
     refIdToOriginalName(refId) {
         return this.seqIdToOriginalRefName[refId];
@@ -165,10 +105,17 @@ export default class CramAdapter extends BaseFeatureDataAdapter {
             if (originalRefName) {
                 this.seqIdToOriginalRefName[refId] = originalRefName;
             }
-            const records = await updateStatus('Downloading alignments', statusCallback, () => cram.getRecordsForRange(refId, start, end));
+            let records;
+            try {
+                records = await updateStatus('Downloading alignments', statusCallback, () => cram.getRecordsForRange(refId, start, end));
+            }
+            catch (e) {
+                this.setupP = undefined;
+                this.configureResult = undefined;
+                throw e;
+            }
             checkStopToken(stopToken);
             await updateStatus('Processing alignments', statusCallback, () => {
-                var _a;
                 const { flagInclude = 0, flagExclude = 0, tagFilter, readName, } = filterBy || {};
                 for (const record of records) {
                     if (filterReadFlag(record.flags, flagInclude, flagExclude)) {
@@ -176,40 +123,42 @@ export default class CramAdapter extends BaseFeatureDataAdapter {
                     }
                     if (tagFilter &&
                         filterTagValue(tagFilter.tag === 'RG'
-                            ? (_a = samHeader.readGroups) === null || _a === void 0 ? void 0 : _a[record.readGroupId]
+                            ? samHeader.readGroups[record.readGroupId]
                             : record.tags[tagFilter.tag], tagFilter.value)) {
                         continue;
                     }
                     if (readName && record.readName !== readName) {
                         continue;
                     }
-                    const ret = this.ultraLongFeatureCache.get(`${record.uniqueId}`);
-                    if (!ret) {
-                        const elt = this.cramRecordToFeature(record);
-                        this.ultraLongFeatureCache.set(`${record.uniqueId}`, elt);
-                        observer.next(elt);
+                    if (record.readLength > 5_000) {
+                        const ret = this.ultraLongFeatureCache.get(record.uniqueId);
+                        if (ret) {
+                            observer.next(ret);
+                        }
+                        else {
+                            const elt = new CramSlightlyLazyFeature(record, this);
+                            this.ultraLongFeatureCache.set(record.uniqueId, elt);
+                            observer.next(elt);
+                        }
                     }
                     else {
-                        observer.next(ret);
+                        observer.next(new CramSlightlyLazyFeature(record, this));
                     }
                 }
                 observer.complete();
             });
         }, stopToken);
     }
-    cramRecordToFeature(record) {
-        return new CramSlightlyLazyFeature(record, this);
-    }
-    async getMultiRegionFeatureDensityStats(regions, opts) {
-        const bytes = await this.bytesForRegions(regions, opts);
+    async getMultiRegionFeatureDensityStats(regions) {
+        const bytes = await this.bytesForRegions(regions);
         const fetchSizeLimit = this.getConf('fetchSizeLimit');
         return {
             bytes,
             fetchSizeLimit,
         };
     }
-    async bytesForRegions(regions, _opts) {
-        const { cram } = await this.configure();
+    async bytesForRegions(regions) {
+        const { cram } = this.configure();
         const blockResults = await Promise.all(regions.map(region => {
             const { refName, start, end } = region;
             const chrId = this.refNameToId(refName);
@@ -217,6 +166,6 @@ export default class CramAdapter extends BaseFeatureDataAdapter {
                 ? cram.index.getEntriesForRange(chrId, start, end)
                 : Promise.resolve([{ sliceBytes: 0 }]);
         }));
-        return blockResults.flat().reduce((a, b) => a + b.sliceBytes, 0);
+        return sum(blockResults.flat().map(a => a.sliceBytes));
     }
 }

package/esm/CramAdapter/CramSlightlyLazyFeature.d.ts

@@ -1,4 +1,6 @@
-import type CramAdapter from './CramAdapter';
+import type CramAdapter from './CramAdapter.ts';
+import type { MismatchCallback } from '../shared/forEachMismatchTypes.ts';
+import type { Mismatch } from '../shared/types.ts';
 import type { CramRecord } from '@gmod/cram';
 import type { Feature, SimpleFeatureSerialized } from '@jbrowse/core/util';
 export default class CramSlightlyLazyFeature implements Feature {
@@ -22,12 +24,14 @@ export default class CramSlightlyLazyFeature implements Feature {
     get next_pos(): number | undefined;
     get tags(): Record<string, string>;
     get seq(): string | null | undefined;
+    get NUMERIC_CIGAR(): ArrayLike<number>;
     get CIGAR(): string;
     id(): string;
     get(field: string): any;
     parent(): undefined;
     children(): undefined;
-    get mismatches(): import("../shared/types").Mismatch[];
+    get mismatches(): Mismatch[];
+    forEachMismatch(callback: MismatchCallback): void;
     get fields(): SimpleFeatureSerialized;
     toJSON(): SimpleFeatureSerialized;
 }

package/esm/CramAdapter/CramSlightlyLazyFeature.js

@@ -1,7 +1,14 @@
-import { readFeaturesToCIGAR } from './readFeaturesToCIGAR';
-import { readFeaturesToMismatches } from './readFeaturesToMismatches';
-import { cacheGetter } from '../shared/util';
+import { CODE_D, CODE_H, CODE_I, CODE_N, CODE_S, CODE_X, CODE_i, } from "./const.js";
+import { readFeaturesToNumericCIGAR } from "./readFeaturesToNumericCIGAR.js";
+import { CHAR_FROM_CODE } from "../PileupRenderer/renderers/cigarUtil.js";
+import { DELETION_TYPE, HARDCLIP_TYPE, INSERTION_TYPE, MISMATCH_TYPE, SKIP_TYPE, SOFTCLIP_TYPE, } from "../shared/forEachMismatchTypes.js";
+import { cacheGetter, convertTagsToPlainArrays } from "../shared/util.js";
+const NUMERIC_CIGAR_CODES = new Uint8Array([
+    77, 73, 68, 78, 83, 72, 80, 61, 88, 63, 63, 63, 63, 63, 63, 63,
+]);
 export default class CramSlightlyLazyFeature {
+    record;
+    _store;
     constructor(record, _store) {
         this.record = record;
         this._store = _store;
@@ -13,8 +20,7 @@ export default class CramSlightlyLazyFeature {
         return this.record.alignmentStart - 1;
     }
     get end() {
-        var _a;
-        return this.start + ((_a = this.record.lengthOnRef) !== null && _a !== void 0 ? _a : 1);
+        return this.start + (this.record.lengthOnRef ?? 1);
     }
     get score() {
         return this.record.mappingQuality;
@@ -54,31 +60,45 @@ export default class CramSlightlyLazyFeature {
         return !!this.record.mate;
     }
     get next_pos() {
-        var _a;
-        return (_a = this.record.mate) === null || _a === void 0 ? void 0 : _a.alignmentStart;
+        return this.record.mate?.alignmentStart;
     }
     get tags() {
-        var _a;
-        const RG = (_a = this._store.samHeader.readGroups) === null || _a === void 0 ? void 0 : _a[this.record.readGroupId];
+        const RG = this._store.samHeader?.readGroups[this.record.readGroupId];
         return RG !== undefined ? { ...this.record.tags, RG } : this.record.tags;
     }
     get seq() {
         return this.record.getReadBases();
     }
+    get NUMERIC_CIGAR() {
+        return readFeaturesToNumericCIGAR(this.record.readFeatures, this.record.alignmentStart, this.record.readLength);
+    }
     get CIGAR() {
-        return readFeaturesToCIGAR(this.record.readFeatures, this.record.alignmentStart, this.record.readLength, this.record._refRegion);
+        const numeric = this.NUMERIC_CIGAR;
+        let result = '';
+        for (let i = 0, l = numeric.length; i < l; i++) {
+            const packed = numeric[i];
+            const length = packed >> 4;
+            const opCode = NUMERIC_CIGAR_CODES[packed & 0xf];
+            result += length + CHAR_FROM_CODE[opCode];
+        }
+        return result;
     }
     id() {
         return `${this._store.id}-${this.record.uniqueId}`;
     }
     get(field) {
-        return field === 'mismatches'
-            ? this.mismatches
-            : field === 'qual'
-                ? this.qual
-                : field === 'CIGAR'
-                    ? this.CIGAR
-                    : this.fields[field];
+        switch (field) {
+            case 'mismatches':
+                return this.mismatches;
+            case 'qual':
+                return this.qual;
+            case 'CIGAR':
+                return this.CIGAR;
+            case 'NUMERIC_CIGAR':
+                return this.NUMERIC_CIGAR;
+            default:
+                return this.fields[field];
+        }
     }
     parent() {
         return undefined;
@@ -87,7 +107,107 @@ export default class CramSlightlyLazyFeature {
         return undefined;
     }
     get mismatches() {
-        return readFeaturesToMismatches(this.record.readFeatures, this.start, this.qualRaw);
+        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) {
+        const readFeatures = this.record.readFeatures;
+        if (!readFeatures) {
+            return;
+        }
+        const featStart = this.start;
+        const qual = this.qualRaw;
+        const hasQual = !!qual;
+        const len = readFeatures.length;
+        let refPos = 0;
+        let lastPos = featStart;
+        let insertedBases = '';
+        let insertedBasesLen = 0;
+        for (let i = 0; i < len; i++) {
+            const rf = readFeatures[i];
+            const sublen = refPos - lastPos;
+            lastPos = refPos;
+            if (sublen && insertedBasesLen > 0) {
+                callback(INSERTION_TYPE, refPos, 0, insertedBases, -1, 0, insertedBasesLen);
+                insertedBases = '';
+                insertedBasesLen = 0;
+            }
+            refPos = rf.refPos - 1 - featStart;
+            const codeChar = rf.code.charCodeAt(0);
+            if (codeChar === CODE_X) {
+                const refCharCode = rf.ref ? rf.ref.charCodeAt(0) & ~0x20 : 0;
+                callback(MISMATCH_TYPE, refPos, 1, rf.sub, hasQual ? qual[rf.pos - 1] : -1, refCharCode, 0);
+            }
+            else if (codeChar === CODE_I) {
+                callback(INSERTION_TYPE, refPos, 0, rf.data, -1, 0, rf.data.length);
+            }
+            else if (codeChar === CODE_N) {
+                callback(SKIP_TYPE, refPos, rf.data, 'N', -1, 0, 0);
+            }
+            else if (codeChar === CODE_S) {
+                const dataLen = rf.data.length;
+                callback(SOFTCLIP_TYPE, refPos, 1, `S${dataLen}`, -1, 0, dataLen);
+            }
+            else if (codeChar === CODE_H) {
+                callback(HARDCLIP_TYPE, refPos, 1, `H${rf.data}`, -1, 0, rf.data);
+            }
+            else if (codeChar === CODE_D) {
+                callback(DELETION_TYPE, refPos, rf.data, '*', -1, 0, 0);
+            }
+            else if (codeChar === CODE_i) {
+                insertedBases += rf.data;
+                insertedBasesLen++;
+            }
+        }
+        if (insertedBasesLen > 0) {
+            callback(INSERTION_TYPE, refPos, 0, insertedBases, -1, 0, insertedBasesLen);
+        }
     }
     get fields() {
         return {
@@ -98,7 +218,7 @@ export default class CramSlightlyLazyFeature {
             strand: this.strand,
             template_length: this.template_length,
             flags: this.flags,
-            tags: this.tags,
+            tags: convertTagsToPlainArrays(this.tags),
             refName: this.refName,
             seq: this.seq,
             type: 'match',
@@ -119,4 +239,5 @@ export default class CramSlightlyLazyFeature {
 }
 cacheGetter(CramSlightlyLazyFeature, 'fields');
 cacheGetter(CramSlightlyLazyFeature, 'CIGAR');
+cacheGetter(CramSlightlyLazyFeature, 'NUMERIC_CIGAR');
 cacheGetter(CramSlightlyLazyFeature, 'mismatches');

package/esm/CramAdapter/CramTestAdapters.d.ts

@@ -1,4 +1,4 @@
-import { BaseFeatureDataAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
+import { BaseSequenceAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
 import SimpleFeature from '@jbrowse/core/util/simpleFeature';
 import { Observable } from 'rxjs';
 import type { GenericFilehandle } from 'generic-filehandle2';
@@ -14,11 +14,12 @@ export declare class FetchableSmallFasta {
     fetch(id: number, start: number, end: number): Promise<string>;
     getSequenceList(): Promise<string[]>;
 }
-export declare class SequenceAdapter extends BaseFeatureDataAdapter {
+export declare class SequenceAdapter extends BaseSequenceAdapter {
     fasta: FetchableSmallFasta;
     refNames: string[];
     constructor(filehandle: FileHandle);
     getRefNames(): Promise<string[]>;
+    getRegions(): Promise<never[]>;
     getFeatures({ refName, start, end, }: {
         refName: string;
         start: number;

package/esm/CramAdapter/CramTestAdapters.js

@@ -1,5 +1,5 @@
 import { ConfigurationSchema } from '@jbrowse/core/configuration';
-import { BaseFeatureDataAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
+import { BaseSequenceAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
 import SimpleFeature from '@jbrowse/core/util/simpleFeature';
 import { Observable } from 'rxjs';
 export function parseSmallFasta(text) {
@@ -19,6 +19,7 @@ export function parseSmallFasta(text) {
     });
 }
 export class FetchableSmallFasta {
+    data;
     constructor(filehandle) {
         this.data = filehandle.readFile().then(buffer => {
             const decoder = new TextDecoder('utf8');
@@ -40,15 +41,19 @@ export class FetchableSmallFasta {
         return data.map(entry => entry.id);
     }
 }
-export class SequenceAdapter extends BaseFeatureDataAdapter {
+export class SequenceAdapter extends BaseSequenceAdapter {
+    fasta;
+    refNames = [];
     constructor(filehandle) {
         super(ConfigurationSchema('empty', {}).create());
-        this.refNames = [];
         this.fasta = new FetchableSmallFasta(filehandle);
     }
     async getRefNames() {
         return this.refNames;
     }
+    async getRegions() {
+        return [];
+    }
     getFeatures({ refName, start, end, }) {
         return new Observable(observer => {
             this.fasta

package/esm/CramAdapter/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<{
     fetchSizeLimit: {
         type: string;
         description: string;
@@ -18,10 +18,5 @@ declare const configSchema: import("@jbrowse/core/configuration/configurationSch
             locationType: string;
         };
     };
-    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/CramAdapter/configSchema.js

@@ -4,7 +4,7 @@ const configSchema = ConfigurationSchema('CramAdapter', {
     fetchSizeLimit: {
         type: 'number',
         description: 'size in bytes over which to display a warning to the user that too much data will be fetched',
-        defaultValue: 3000000,
+        defaultValue: 3_000_000,
     },
     cramLocation: {
         type: 'fileLocation',
@@ -20,11 +20,6 @@ const configSchema = ConfigurationSchema('CramAdapter', {
             locationType: 'UriLocation',
         },
     },
-    sequenceAdapter: {
-        type: 'frozen',
-        description: 'sequence data adapter',
-        defaultValue: null,
-    },
 }, {
     explicitlyTyped: true,
     preProcessSnapshot: snap => {

package/esm/CramAdapter/const.d.ts

@@ -0,0 +1,12 @@
+export declare const CODE_X = 88;
+export declare const CODE_I = 73;
+export declare const CODE_N = 78;
+export declare const CODE_S = 83;
+export declare const CODE_P = 80;
+export declare const CODE_H = 72;
+export declare const CODE_D = 68;
+export declare const CODE_b = 98;
+export declare const CODE_q = 113;
+export declare const CODE_B = 66;
+export declare const CODE_i = 105;
+export declare const CODE_Q = 81;

package/esm/CramAdapter/const.js

@@ -0,0 +1,12 @@
+export const CODE_X = 88;
+export const CODE_I = 73;
+export const CODE_N = 78;
+export const CODE_S = 83;
+export const CODE_P = 80;
+export const CODE_H = 72;
+export const CODE_D = 68;
+export const CODE_b = 98;
+export const CODE_q = 113;
+export const CODE_B = 66;
+export const CODE_i = 105;
+export const CODE_Q = 81;