@jbrowse/plugin-alignments 2.10.1 → 2.10.3

package/esm/AlignmentsFeatureDetail/PairLink.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import { AlignmentFeatureWidgetModel } from './stateModelFactory';
+export default function PairLink({ locString, model, }: {
+    locString: string;
+    model: AlignmentFeatureWidgetModel;
+}): React.JSX.Element;

package/esm/AlignmentsFeatureDetail/PairLink.js

@@ -0,0 +1,10 @@
+import React from 'react';
+import { Link } from '@mui/material';
+import { navToLoc } from './util';
+export default function PairLink({ locString, model, }) {
+    return (React.createElement(Link, { onClick: event => {
+            event.preventDefault();
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
+            navToLoc(locString, model);
+        }, href: "#" }, locString));
+}

package/esm/AlignmentsFeatureDetail/SuppAlignments.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { SimpleFeatureSerialized } from '@jbrowse/core/util';
+import { AlignmentFeatureWidgetModel } from './stateModelFactory';
+export default function SuppAlignments(props: {
+    tag: string;
+    model: AlignmentFeatureWidgetModel;
+    feature: SimpleFeatureSerialized;
+}): React.JSX.Element;

package/esm/AlignmentsFeatureDetail/SuppAlignments.js

@@ -0,0 +1,20 @@
+import React from 'react';
+import { BaseCard } from '@jbrowse/core/BaseFeatureWidget/BaseFeatureDetail';
+import { getEnv, getSession } from '@jbrowse/core/util';
+import SuppAlignmentsLocStrings from './SuppAlignmentsLocStrings';
+import LaunchBreakpointSplitViewPanel from './LaunchBreakpointSplitViewPanel';
+export default function SuppAlignments(props) {
+    const { model, tag, feature } = props;
+    const session = getSession(model);
+    const { pluginManager } = getEnv(session);
+    let viewType;
+    try {
+        viewType = pluginManager.getViewType('BreakpointSplitView');
+    }
+    catch (e) {
+        // ignore
+    }
+    return (React.createElement(BaseCard, { ...props, title: "Supplementary alignments" },
+        React.createElement(SuppAlignmentsLocStrings, { model: model, tag: tag }),
+        viewType ? (React.createElement(LaunchBreakpointSplitViewPanel, { viewType: viewType, model: model, feature: feature })) : null));
+}

package/esm/AlignmentsFeatureDetail/SuppAlignmentsLocStrings.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import { AlignmentFeatureWidgetModel } from './stateModelFactory';
+export default function SuppAlignmentsLocStrings({ tag, model, }: {
+    tag: string;
+    model: AlignmentFeatureWidgetModel;
+}): React.JSX.Element;

package/esm/AlignmentsFeatureDetail/{AlignmentsFeatureSuppAligns.js → SuppAlignmentsLocStrings.js}

@@ -1,11 +1,10 @@
 import React from 'react';
 import { Typography, Link } from '@mui/material';
-import { BaseCard } from '@jbrowse/core/BaseFeatureWidget/BaseFeatureDetail';
+// locals
 import { getLengthOnRef } from '../MismatchParser';
 import { navToLoc } from './util';
-export default function SupplementaryAlignments(props) {
-    const { tag, model } = props;
-    return (React.createElement(BaseCard, { ...props, title: "Supplementary alignments" },
+export default function SuppAlignmentsLocStrings({ tag, model, }) {
+    return (React.createElement("div", null,
         React.createElement(Typography, null, "List of supplementary alignment locations"),
         React.createElement("ul", null, tag
             .split(';')
@@ -16,7 +15,9 @@ export default function SupplementaryAlignments(props) {
             const extra = Math.floor(saLength / 5);
             const start = +saStart;
             const end = +saStart + saLength;
-            const locString = `${saRef}:${Math.max(1, start - extra)}-${end + extra}`;
+            const sp = start - extra;
+            const ep = end + extra;
+            const locString = `${saRef}:${Math.max(1, sp)}-${ep}`;
             const displayStart = start.toLocaleString('en-US');
             const displayEnd = end.toLocaleString('en-US');
             const displayString = `${saRef}:${displayStart}-${displayEnd} (${saStrand}) [${saLength}bp]`;
@@ -25,6 +26,6 @@ export default function SupplementaryAlignments(props) {
                         event.preventDefault();
                         // eslint-disable-next-line @typescript-eslint/no-floating-promises
                         navToLoc(locString, model);
-                    }, href: "#" }, displayString)));
+                    } }, displayString)));
         }))));
 }

package/esm/AlignmentsFeatureDetail/configSchema.d.ts

@@ -0,0 +1 @@
+export declare const configSchema: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;

package/esm/AlignmentsFeatureDetail/configSchema.js

@@ -0,0 +1,2 @@
+import { ConfigurationSchema } from '@jbrowse/core/configuration';
+export const configSchema = ConfigurationSchema('AlignmentsFeatureWidget', {});

package/esm/AlignmentsFeatureDetail/getSAFeatures.d.ts

@@ -0,0 +1,23 @@
+import { Feature } from '@jbrowse/core/util';
+import { LinearGenomeViewModel } from '@jbrowse/plugin-linear-genome-view';
+export interface ReducedFeature {
+    refName: string;
+    start: number;
+    clipPos: number;
+    end: number;
+    strand: number;
+    seqLength: number;
+    syntenyId?: number;
+    uniqueId: string;
+    mate: {
+        refName: string;
+        start: number;
+        end: number;
+        syntenyId?: number;
+        uniqueId?: string;
+    };
+}
+export declare function getSAFeatures({ view, feature, }: {
+    view: LinearGenomeViewModel;
+    feature: Feature;
+}): Promise<ReducedFeature[]>;

package/esm/AlignmentsFeatureDetail/getSAFeatures.js

@@ -0,0 +1,37 @@
+import { getSession } from '@jbrowse/core/util';
+// locals
+import { featurizeSA, getClip, getLengthSansClipping } from '../MismatchParser';
+import { getTag } from '../util';
+export async function getSAFeatures({ view, feature, }) {
+    const { assemblyManager } = getSession(view);
+    const cigar = feature.get('CIGAR');
+    const origStrand = feature.get('strand');
+    const SA = getTag(feature, 'SA') || '';
+    const readName = feature.get('name');
+    const clipPos = getClip(cigar, 1);
+    // get the canonical refname for the read because if the
+    // read.get('refName') is chr1 and the actual fasta refName is 1 then no
+    // tracks can be opened on the top panel of the linear read vs ref
+    const assembly = await assemblyManager.waitForAssembly(view.assemblyNames[0]);
+    if (!assembly) {
+        throw new Error('assembly not found');
+    }
+    const suppAlns = featurizeSA(SA, feature.id(), origStrand, readName, true);
+    const feat = feature.toJSON();
+    feat.clipPos = clipPos;
+    feat.strand = 1;
+    feat.mate = {
+        refName: readName,
+        start: clipPos,
+        end: clipPos + getLengthSansClipping(cigar),
+    };
+    const features = [feat, ...suppAlns];
+    features.forEach((f, idx) => {
+        f.refName = (assembly === null || assembly === void 0 ? void 0 : assembly.getCanonicalRefName(f.refName)) || f.refName;
+        f.syntenyId = idx;
+        f.mate.syntenyId = idx;
+        f.mate.uniqueId = `${f.uniqueId}_mate`;
+    });
+    features.sort((a, b) => a.clipPos - b.clipPos);
+    return features;
+}

package/esm/AlignmentsFeatureDetail/index.d.ts

@@ -1,51 +1,2 @@
 import PluginManager from '@jbrowse/core/PluginManager';
-declare const configSchema: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
-export declare function stateModelFactory(pluginManager: PluginManager): import("mobx-state-tree").IModelType<{
-    id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
-    type: import("mobx-state-tree").ISimpleType<"BaseFeatureWidget">;
-    featureData: import("mobx-state-tree").IType<any, any, any>;
-    formattedFields: import("mobx-state-tree").IType<any, any, any>;
-    unformattedFeatureData: import("mobx-state-tree").IType<any, any, any>;
-    view: import("mobx-state-tree").IMaybe<import("mobx-state-tree").IReferenceType<import("mobx-state-tree").IAnyType>>;
-    track: import("mobx-state-tree").IMaybe<import("mobx-state-tree").IReferenceType<import("mobx-state-tree").IAnyType>>;
-    trackId: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
-    trackType: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
-    maxDepth: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<number>>;
-} & {
-    type: import("mobx-state-tree").ISimpleType<"AlignmentsFeatureWidget">;
-}, {
-    error: unknown;
-} & {
-    setFeatureData(featureData: Record<string, unknown>): void;
-    clearFeatureData(): void;
-    setFormattedData(feat: Record<string, unknown>): void;
-    setExtra(type?: string | undefined, trackId?: string | undefined, maxDepth?: number | undefined): void;
-    setError(e: unknown): void;
-} & {
-    afterCreate(): void;
-}, {
-    type: "BaseFeatureWidget";
-} & Partial<import("mobx-state-tree/dist/internal").ExtractCFromProps<{
-    id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
-    type: import("mobx-state-tree").ISimpleType<"BaseFeatureWidget">;
-    featureData: import("mobx-state-tree").IType<any, any, any>;
-    formattedFields: import("mobx-state-tree").IType<any, any, any>;
-    unformattedFeatureData: import("mobx-state-tree").IType<any, any, any>;
-    view: import("mobx-state-tree").IMaybe<import("mobx-state-tree").IReferenceType<import("mobx-state-tree").IAnyType>>;
-    track: import("mobx-state-tree").IMaybe<import("mobx-state-tree").IReferenceType<import("mobx-state-tree").IAnyType>>;
-    trackId: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
-    trackType: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
-    maxDepth: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<number>>;
-}>> & import("mobx-state-tree/dist/internal").NonEmptyObject & import("mobx-state-tree")._NotCustomized, {
-    type: "BaseFeatureWidget";
-    id: string;
-    track: import("mobx-state-tree").ReferenceIdentifier | undefined;
-    view: import("mobx-state-tree").ReferenceIdentifier | undefined;
-    trackId: string | undefined;
-    trackType: string | undefined;
-    maxDepth: number | undefined;
-    formattedFields: any;
-    finalizedFeatureData: any;
-} & import("mobx-state-tree")._NotCustomized>;
-export default function register(pluginManager: PluginManager): void;
-export { configSchema };
+export default function AlignmentFeatureDetailsF(pluginManager: PluginManager): void;

package/esm/AlignmentsFeatureDetail/index.js

@@ -1,22 +1,13 @@
 import { lazy } from 'react';
-import { ConfigurationSchema } from '@jbrowse/core/configuration';
-import { types } from 'mobx-state-tree';
 import WidgetType from '@jbrowse/core/pluggableElementTypes/WidgetType';
-import { stateModelFactory as baseModelFactory } from '@jbrowse/core/BaseFeatureWidget';
-const configSchema = ConfigurationSchema('AlignmentsFeatureWidget', {});
-export function stateModelFactory(pluginManager) {
-    const baseModel = baseModelFactory(pluginManager);
-    return types.compose(baseModel, types.model('AlignmentsFeatureWidget', {
-        type: types.literal('AlignmentsFeatureWidget'),
-    }));
-}
-export default function register(pluginManager) {
+import { configSchema } from './configSchema';
+import { stateModelFactory } from './stateModelFactory';
+export default function AlignmentFeatureDetailsF(pluginManager) {
     pluginManager.addWidgetType(() => new WidgetType({
         name: 'AlignmentsFeatureWidget',
         heading: 'Feature details',
-        configSchema,
+        configSchema: configSchema,
         stateModel: stateModelFactory(pluginManager),
         ReactComponent: lazy(() => import('./AlignmentsFeatureDetail')),
     }));
 }
-export { configSchema };

package/esm/AlignmentsFeatureDetail/launchBreakpointSplitView.d.ts

@@ -0,0 +1,22 @@
+import { LinearGenomeViewModel } from '@jbrowse/plugin-linear-genome-view';
+import { ReducedFeature } from './getSAFeatures';
+export declare function getBreakpointSplitView({ f1, f2, view, }: {
+    f1: ReducedFeature;
+    f2: ReducedFeature;
+    view: LinearGenomeViewModel;
+}): {
+    type: string;
+    views: {
+        type: string;
+        displayedRegions: {
+            start: number;
+            end: number;
+            refName: string;
+            assemblyName: string;
+        }[];
+        hideHeader: boolean;
+        bpPerPx: number;
+        offsetPx: number;
+    }[];
+    displayName: string;
+};

package/esm/AlignmentsFeatureDetail/launchBreakpointSplitView.js

@@ -0,0 +1,46 @@
+import { getSession } from '@jbrowse/core/util';
+export function getBreakpointSplitView({ f1, f2, view, }) {
+    const { assemblyName } = view.displayedRegions[0];
+    const { assemblyManager } = getSession(view);
+    const assembly = assemblyManager.get(assemblyName);
+    if (!assembly) {
+        throw new Error(`assembly ${assemblyName} not found`);
+    }
+    if (!assembly.regions) {
+        throw new Error(`assembly ${assemblyName} regions not loaded`);
+    }
+    const topRegion = assembly.regions.find(f => f.refName === f1.refName);
+    const bottomRegion = assembly.regions.find(f => f.refName === f2.refName);
+    if (!topRegion || !bottomRegion) {
+        throw new Error(`unable to find the refName for the top or bottom of the breakpoint view`);
+    }
+    const topMarkedRegion = [{ ...topRegion }, { ...topRegion }];
+    const bottomMarkedRegion = [{ ...bottomRegion }, { ...bottomRegion }];
+    const s = f1.strand === 1 ? f1.end : f1.start;
+    const e = f2.strand === 1 ? f2.start : f2.end;
+    topMarkedRegion[0].end = s;
+    topMarkedRegion[1].start = s + 1;
+    bottomMarkedRegion[0].end = e;
+    bottomMarkedRegion[1].start = e + 1;
+    const bpPerPx = 10;
+    return {
+        type: 'BreakpointSplitView',
+        views: [
+            {
+                type: 'LinearGenomeView',
+                displayedRegions: topMarkedRegion,
+                hideHeader: true,
+                bpPerPx,
+                offsetPx: (topRegion.start + s) / bpPerPx,
+            },
+            {
+                type: 'LinearGenomeView',
+                displayedRegions: bottomMarkedRegion,
+                hideHeader: true,
+                bpPerPx,
+                offsetPx: (bottomRegion.start + e) / bpPerPx,
+            },
+        ],
+        displayName: `breakend split detail`,
+    };
+}

package/esm/AlignmentsFeatureDetail/stateModelFactory.d.ts

@@ -0,0 +1,51 @@
+import PluginManager from '@jbrowse/core/PluginManager';
+import { Instance } from 'mobx-state-tree';
+export declare function stateModelFactory(pluginManager: PluginManager): import("mobx-state-tree").IModelType<{
+    id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
+    type: import("mobx-state-tree").ISimpleType<"BaseFeatureWidget">;
+    featureData: import("mobx-state-tree").IType<any, any, any>;
+    formattedFields: import("mobx-state-tree").IType<any, any, any>;
+    unformattedFeatureData: import("mobx-state-tree").IType<any, any, any>;
+    view: import("mobx-state-tree").IMaybe<import("mobx-state-tree").IReferenceType<import("mobx-state-tree").IAnyType>>;
+    track: import("mobx-state-tree").IMaybe<import("mobx-state-tree").IReferenceType<import("mobx-state-tree").IAnyType>>;
+    trackId: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
+    trackType: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
+    maxDepth: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<number>>;
+} & {
+    type: import("mobx-state-tree").ISimpleType<"AlignmentsFeatureWidget">;
+}, {
+    error: unknown;
+} & {
+    setFeatureData(featureData: Record<string, unknown>): void;
+    clearFeatureData(): void;
+    setFormattedData(feat: Record<string, unknown>): void;
+    setExtra(type?: string | undefined, trackId?: string | undefined, maxDepth?: number | undefined): void;
+    setError(e: unknown): void;
+} & {
+    afterCreate(): void;
+}, {
+    type: "BaseFeatureWidget";
+} & Partial<import("mobx-state-tree/dist/internal").ExtractCFromProps<{
+    id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
+    type: import("mobx-state-tree").ISimpleType<"BaseFeatureWidget">;
+    featureData: import("mobx-state-tree").IType<any, any, any>;
+    formattedFields: import("mobx-state-tree").IType<any, any, any>;
+    unformattedFeatureData: import("mobx-state-tree").IType<any, any, any>;
+    view: import("mobx-state-tree").IMaybe<import("mobx-state-tree").IReferenceType<import("mobx-state-tree").IAnyType>>;
+    track: import("mobx-state-tree").IMaybe<import("mobx-state-tree").IReferenceType<import("mobx-state-tree").IAnyType>>;
+    trackId: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
+    trackType: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
+    maxDepth: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<number>>;
+}>> & import("mobx-state-tree/dist/internal").NonEmptyObject & import("mobx-state-tree")._NotCustomized, {
+    id: string;
+    type: "BaseFeatureWidget";
+    track: import("mobx-state-tree").ReferenceIdentifier | undefined;
+    view: import("mobx-state-tree").ReferenceIdentifier | undefined;
+    trackId: string | undefined;
+    trackType: string | undefined;
+    maxDepth: number | undefined;
+    formattedFields: any;
+    finalizedFeatureData: any;
+} & import("mobx-state-tree")._NotCustomized>;
+export type AlignmentFeatureWidgetStateModel = ReturnType<typeof stateModelFactory>;
+export type AlignmentFeatureWidgetModel = Instance<AlignmentFeatureWidgetStateModel>;

package/esm/AlignmentsFeatureDetail/stateModelFactory.js

@@ -0,0 +1,8 @@
+import { types } from 'mobx-state-tree';
+import { stateModelFactory as baseModelFactory } from '@jbrowse/core/BaseFeatureWidget';
+export function stateModelFactory(pluginManager) {
+    const baseModel = baseModelFactory(pluginManager);
+    return types.compose(baseModel, types.model('AlignmentsFeatureWidget', {
+        type: types.literal('AlignmentsFeatureWidget'),
+    }));
+}

package/esm/AlignmentsFeatureDetail/tagInfo.d.ts

@@ -0,0 +1,63 @@
+export declare const tags: {
+    AM: string;
+    AS: string;
+    BC: string;
+    BQ: string;
+    BZ: string;
+    CB: string;
+    CC: string;
+    CM: string;
+    CO: string;
+    CP: string;
+    CQ: string;
+    CR: string;
+    CS: string;
+    CT: string;
+    CY: string;
+    E2: string;
+    FI: string;
+    FS: string;
+    FZ: string;
+    GC: string;
+    GQ: string;
+    GS: string;
+    H0: string;
+    H1: string;
+    H2: string;
+    HI: string;
+    IH: string;
+    LB: string;
+    MC: string;
+    MD: string;
+    MF: string;
+    MI: string;
+    ML: string;
+    MM: string;
+    MQ: string;
+    NH: string;
+    NM: string;
+    OA: string;
+    OC: string;
+    OP: string;
+    OQ: string;
+    OX: string;
+    PG: string;
+    PQ: string;
+    PT: string;
+    PU: string;
+    Q2: string;
+    QT: string;
+    QX: string;
+    R2: string;
+    RG: string;
+    RT: string;
+    RX: string;
+    S2: string;
+    SA: string;
+    SM: string;
+    SQ: string;
+    TC: string;
+    TS: string;
+    U2: string;
+    UQ: string;
+};

package/esm/AlignmentsFeatureDetail/tagInfo.js

@@ -0,0 +1,63 @@
+export const tags = {
+    AM: 'The smallest template-independent mapping quality in the template',
+    AS: 'Alignment score generated by aligner',
+    BC: 'Barcode sequence identifying the sample',
+    BQ: 'Offset to base alignment quality (BAQ)',
+    BZ: 'Phred quality of the unique molecular barcode bases in the {OX} tag',
+    CB: 'Cell identifier',
+    CC: 'Reference name of the next hit',
+    CM: 'Edit distance between the color sequence and the color reference (see also {NM})',
+    CO: 'Free-text comments',
+    CP: 'Leftmost coordinate of the next hit',
+    CQ: 'Color read base qualities',
+    CR: 'Cellular barcode sequence bases (uncorrected)',
+    CS: 'Color read sequence',
+    CT: 'Complete read annotation tag, used for consensus annotation dummy features',
+    CY: 'Phred quality of the cellular barcode sequence in the {CR} tag',
+    E2: 'The 2nd most likely base calls',
+    FI: 'The index of segment in the template',
+    FS: 'Segment suffix',
+    FZ: 'Flow signal intensities',
+    GC: 'Reserved for backwards compatibility reasons',
+    GQ: 'Reserved for backwards compatibility reasons',
+    GS: 'Reserved for backwards compatibility reasons',
+    H0: 'Number of perfect hits',
+    H1: 'Number of 1-difference hits (see also {NM})',
+    H2: 'Number of 2-difference hits',
+    HI: 'Query hit index',
+    IH: 'Query hit total count',
+    LB: 'Library',
+    MC: 'CIGAR string for mate/next segment',
+    MD: 'String encoding mismatched and deleted reference bases',
+    MF: 'Reserved for backwards compatibility reasons',
+    MI: 'Molecular identifier; a string that uniquely identifies the molecule from which the record was derived',
+    ML: 'Base modification probabilities',
+    MM: 'Base modifications / methylation ',
+    MQ: 'Mapping quality of the mate/next segment',
+    NH: 'Number of reported alignments that contain the query in the current record',
+    NM: 'Edit distance to the reference',
+    OA: 'Original alignment',
+    OC: 'Original CIGAR (deprecated; use {OA} instead)',
+    OP: 'Original mapping position (deprecated; use {OA} instead)',
+    OQ: 'Original base quality',
+    OX: 'Original unique molecular barcode bases',
+    PG: 'Program',
+    PQ: 'Phred likelihood of the template',
+    PT: 'Read annotations for parts of the padded read sequence',
+    PU: 'Platform unit',
+    Q2: 'Phred quality of the mate/next segment sequence in the {R2} tag',
+    QT: 'Phred quality of the sample barcode sequence in the {BC} tag',
+    QX: 'Quality score of the unique molecular identifier in the {RX} tag',
+    R2: 'Sequence of the mate/next segment in the template',
+    RG: 'Read group',
+    RT: 'Reserved for backwards compatibility reasons',
+    RX: 'Sequence bases of the (possibly corrected) unique molecular identifier',
+    S2: 'Reserved for backwards compatibility reasons',
+    SA: 'Other canonical alignments in a chimeric alignment',
+    SM: 'Template-independent mapping quality',
+    SQ: 'Reserved for backwards compatibility reasons',
+    TC: 'The number of segments in the template',
+    TS: 'Transcript strand',
+    U2: 'Phred probability of the 2nd call being wrong conditional on the best being wrong',
+    UQ: 'Phred likelihood of the segment, conditional on the mapping being correct',
+};

package/esm/BamAdapter/BamAdapter.js

@@ -60,14 +60,13 @@ export default class BamAdapter extends BaseFeatureDataAdapter {
             const idToName = [];
             const nameToId = {};
             samHeader === null || samHeader === void 0 ? void 0 : samHeader.filter(l => l.tag === 'SQ').forEach((sqLine, refId) => {
-                sqLine.data.forEach(item => {
-                    if (item.tag === 'SN') {
-                        // this is the ref name
-                        const refName = item.value;
-                        nameToId[refName] = refId;
-                        idToName[refId] = refName;
-                    }
-                });
+                const SN = sqLine.data.find(item => item.tag === 'SN');
+                if (SN) {
+                    // this is the ref name
+                    const refName = SN.value;
+                    nameToId[refName] = refId;
+                    idToName[refId] = refName;
+                }
             });
             return { idToName, nameToId };
         });
@@ -139,7 +138,9 @@ export default class BamAdapter extends BaseFeatureDataAdapter {
                     }
                     if (tagFilter) {
                         const v = record.get(tagFilter.tag);
-                        if (!(v === '*' ? v !== undefined : `${v}` === tagFilter.value)) {
+                        if (!(tagFilter.value === '*'
+                            ? v !== undefined
+                            : `${v}` === tagFilter.value)) {
                             continue;
                         }
                     }

package/esm/CramAdapter/CramAdapter.js

@@ -1,6 +1,6 @@
 import { CraiIndex, IndexedCramFile } from '@gmod/cram';
 import { BaseFeatureDataAdapter, } from '@jbrowse/core/data_adapters/BaseAdapter';
-import { checkAbortSignal, updateStatus, } from '@jbrowse/core/util';
+import { checkAbortSignal, updateStatus, toLocale, } from '@jbrowse/core/util';
 import { openLocation } from '@jbrowse/core/util/io';
 import { ObservableCreate } from '@jbrowse/core/util/rxjs';
 import { toArray } from 'rxjs/operators';
@@ -17,12 +17,6 @@ export default class CramAdapter extends BaseFeatureDataAdapter {
     async configurePre() {
         const cramLocation = this.getConf('cramLocation');
         const craiLocation = this.getConf('craiLocation');
-        if (!cramLocation) {
-            throw new Error('missing cramLocation argument');
-        }
-        if (!craiLocation) {
-            throw new Error('missing craiLocation argument');
-        }
         const pm = this.pluginManager;
         const cram = new IndexedCramFile({
             cramFilehandle: openLocation(cramLocation, pm),
@@ -35,6 +29,9 @@ export default class CramAdapter extends BaseFeatureDataAdapter {
             throw new Error('Error getting subadapter');
         }
         const seqConf = this.getConf('sequenceAdapter');
+        if (!seqConf) {
+            throw new Error('no sequenceAdapter supplied to CramAdapter config');
+        }
         const subadapter = await this.getSubAdapter(seqConf);
         return {
             cram,
@@ -81,8 +78,9 @@ export default class CramAdapter extends BaseFeatureDataAdapter {
             return chunkSeq.slice(trimStart, trimStart + trimLength);
         })
             .join('');
-        if (sequence.length !== end - start) {
-            throw new Error(`sequence fetch failed: fetching ${refName}:${(start - 1).toLocaleString()}-${end.toLocaleString()} returned ${sequence.length.toLocaleString()} bases, but should have returned ${(end - start).toLocaleString()}`);
+        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;
     }
@@ -99,14 +97,12 @@ export default class CramAdapter extends BaseFeatureDataAdapter {
             samHeader
                 .filter(l => l.tag === 'SQ')
                 .forEach((sqLine, refId) => {
-                sqLine.data.forEach(item => {
-                    if (item.tag === 'SN') {
-                        // this is the ref name
-                        const refName = item.value;
-                        nameToId[refName] = refId;
-                        idToName[refId] = refName;
-                    }
-                });
+                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')
@@ -156,7 +152,7 @@ export default class CramAdapter extends BaseFeatureDataAdapter {
         const { signal, filterBy, statusCallback = () => { } } = opts || {};
         const { refName, start, end, originalRefName } = region;
         return ObservableCreate(async (observer) => {
-            const { cram } = await this.setup(opts);
+            const { cram, samHeader } = await this.setup(opts);
             const refId = this.refNameToId(refName);
             if (refId === undefined) {
                 console.warn('Unknown refName', refName);
@@ -178,9 +174,11 @@ export default class CramAdapter extends BaseFeatureDataAdapter {
                     }
                     if (tagFilter) {
                         const v = tagFilter.tag === 'RG'
-                            ? (_a = this.samHeader.readGroups) === null || _a === void 0 ? void 0 : _a[record.readGroupId]
+                            ? (_a = samHeader.readGroups) === null || _a === void 0 ? void 0 : _a[record.readGroupId]
                             : record.tags[tagFilter.tag];
-                        if (!(v === '*' ? v !== undefined : `${v}` === tagFilter.value)) {
+                        if (!(tagFilter.value === '*'
+                            ? v !== undefined
+                            : `${v}` === tagFilter.value)) {
                             continue;
                         }
                     }