jbrowse-plugin-msaview 3.3.0 → 3.4.1

package/dist/MsaViewPanel/doLaunchBlast.js

@@ -2,29 +2,68 @@ import { makeId, strip } from '../LaunchMsaView/components/util';
 import { cleanProteinSequence } from '../LaunchMsaView/util';
 import { saveBlastResult } from '../utils/blastCache';
 import { queryEbiBlast } from '../utils/ebiBlast';
-import { launchMSA } from '../utils/msa';
+import { launchMSA, launchTree } from '../utils/msa';
+import { buildPhmmerMsa, buildRowMetadata } from '../utils/msaRows';
+import { queryPhmmer } from '../utils/phmmer';
 import { fetchTaxonomyInfo } from '../utils/taxonomyNames';
-export async function doLaunchBlast({ self, }) {
-    const { blastDatabase, msaAlgorithm, proteinSequence, selectedTranscript } = self.blastParams;
-    const cleanedSeq = cleanProteinSequence(proteinSequence);
-    const onProgress = (arg) => {
-        self.setProgress(arg);
-    };
+export async function doLaunchBlast({ self, scope, }) {
+    // kept whole rather than destructured: the database's type depends on
+    // searchProgram, and pulling the two apart loses the link between them
+    const params = self.blastParams;
+    const { selectedTranscript } = params;
+    const cleanedSeq = cleanProteinSequence(params.proteinSequence);
+    const { onProgress, onRid, signal } = scope;
+    const { msa, tree, treeMetadata, rid } = params.searchProgram === 'phmmer'
+        ? await runPhmmer({
+            query: cleanedSeq,
+            database: params.blastDatabase,
+            onProgress,
+            onRid,
+            signal,
+        })
+        : await runBlast({
+            query: cleanedSeq,
+            blastDatabase: params.blastDatabase,
+            msaAlgorithm: params.msaAlgorithm,
+            onProgress,
+            onRid,
+            signal,
+        });
+    const treeMetadataJson = JSON.stringify(treeMetadata);
+    await saveBlastResult({
+        proteinSequence: cleanedSeq,
+        blastDatabase: params.blastDatabase,
+        msaAlgorithm: params.msaAlgorithm,
+        searchProgram: params.searchProgram,
+        msa,
+        tree,
+        treeMetadata: treeMetadataJson,
+        rid,
+        geneId: selectedTranscript?.get('parentId'),
+        transcriptId: selectedTranscript?.id(),
+        transcriptName: selectedTranscript?.get('name') ?? selectedTranscript?.get('id'),
+        geneName: selectedTranscript?.get('gene_name') ??
+            selectedTranscript?.get('parentId'),
+    });
+    return { msa, tree, treeMetadata: treeMetadataJson };
+}
+/**
+ * BLAST returns each hit already aligned to the query, but pairwise and one hit
+ * at a time, so the alignments are stripped back off and every hit is realigned
+ * together by a dedicated aligner.
+ */
+async function runBlast({ query, blastDatabase, msaAlgorithm, onProgress, onRid, signal, }) {
     const { hits, rid } = await queryEbiBlast({
-        query: cleanedSeq,
+        query,
         blastDatabase,
         onProgress,
-        // publish the job id before the first poll so the view can link out while
-        // the job is still running
-        onRid: r => {
-            self.setRid(r);
-        },
+        onRid,
+        signal,
     });
-    self.setProgress('Fetching species taxonomy info...');
-    const taxids = hits
+    onProgress('Fetching species taxonomy info...');
+    const taxonomyInfo = await fetchTaxonomyInfo(hits
         .map(h => h.description[0]?.taxid)
-        .filter((t) => t !== undefined);
-    const taxonomyInfo = await fetchTaxonomyInfo(taxids);
+        .filter((t) => t !== undefined));
     const treeMetadata = {};
     const sequences = hits.map(h => {
         const desc = h.description[0] ?? {
@@ -33,52 +72,43 @@ export async function doLaunchBlast({ self, }) {
             sciname: 'unknown',
         };
         const rowName = makeId(desc, taxonomyInfo);
-        const seq = strip(h.hsps[0]?.hseq ?? '');
         treeMetadata[rowName] = buildRowMetadata(desc, taxonomyInfo);
-        return `>${rowName}\n${seq}`;
+        return `>${rowName}\n${strip(h.hsps[0]?.hseq ?? '')}`;
     });
     const result = await launchMSA({
         algorithm: msaAlgorithm,
-        sequence: [`>QUERY\n${cleanedSeq}`, ...sequences].join('\n'),
+        sequence: [`>QUERY\n${query}`, ...sequences].join('\n'),
         onProgress,
+        signal,
     });
-    const treeMetadataJson = JSON.stringify(treeMetadata);
-    await saveBlastResult({
-        proteinSequence: cleanedSeq,
-        blastDatabase,
-        msaAlgorithm,
-        msa: result.msa,
-        tree: result.tree,
-        treeMetadata: treeMetadataJson,
-        rid,
-        geneId: selectedTranscript?.get('parentId'),
-        transcriptId: selectedTranscript?.id(),
-        transcriptName: selectedTranscript?.get('name') ?? selectedTranscript?.get('id'),
-        geneName: selectedTranscript?.get('gene_name') ??
-            selectedTranscript?.get('parentId'),
+    return { ...result, treeMetadata, rid };
+}
+/**
+ * phmmer aligns every hit to a profile of the query as it searches, so its own
+ * output is the MSA and there is no realignment step — the hits keep the
+ * placement HMMER gave them, and the query row is derived from the alignment's
+ * match columns rather than being aligned back in afterwards. That leaves no
+ * aligner run to take a tree from, so the tree is built from this alignment.
+ */
+async function runPhmmer({ query, database, onProgress, onRid, signal, }) {
+    const { rows, queryRow, rid } = await queryPhmmer({
+        query,
+        database,
+        onProgress,
+        onRid,
+        signal,
+    });
+    onProgress('Fetching species taxonomy info...');
+    const taxonomyInfo = await fetchTaxonomyInfo(rows.map(r => r.taxid).filter((t) => t !== undefined));
+    const { msa, treeMetadata } = buildPhmmerMsa({
+        rows,
+        queryRow,
+        taxonomyInfo,
     });
     return {
-        ...result,
-        treeMetadata: treeMetadataJson,
+        msa,
+        tree: await launchTree({ alignment: msa, onProgress, signal }),
+        treeMetadata,
+        rid,
     };
 }
-function buildRowMetadata(desc, taxonomyInfo) {
-    const metadata = {};
-    const taxInfo = desc.taxid ? taxonomyInfo.get(desc.taxid) : undefined;
-    if (taxInfo?.sciname) {
-        metadata['Scientific name'] = taxInfo.sciname;
-    }
-    if (taxInfo?.commonName) {
-        metadata['Common name'] = taxInfo.commonName;
-    }
-    if (desc.accession) {
-        metadata.Accession = desc.accession;
-    }
-    if (desc.id) {
-        metadata.ID = desc.id;
-    }
-    if (desc.title) {
-        metadata.Description = desc.title;
-    }
-    return metadata;
-}

package/dist/MsaViewPanel/doLaunchOrthologs.d.ts

@@ -1,4 +1,5 @@
 import type { JBrowsePluginMsaViewModel } from './model';
+import type { LaunchScope } from './runLaunch';
 /**
  * The no-search-job alternative to doLaunchBlast.
  *
@@ -16,8 +17,9 @@ import type { JBrowsePluginMsaViewModel } from './model';
  * would silently break the genome<->MSA linkage. The query species is therefore
  * excluded from the ortholog set rather than appearing twice.
  */
-export declare function doLaunchOrthologs({ self, }: {
+export declare function doLaunchOrthologs({ self, scope, }: {
     self: JBrowsePluginMsaViewModel;
+    scope: LaunchScope;
 }): Promise<{
     treeMetadata: string;
     msa: string;

package/dist/MsaViewPanel/doLaunchOrthologs.js

@@ -20,11 +20,9 @@ import { fetchTaxonomyInfo } from '../utils/taxonomyNames';
  * would silently break the genome<->MSA linkage. The query species is therefore
  * excluded from the ortholog set rather than appearing twice.
  */
-export async function doLaunchOrthologs({ self, }) {
+export async function doLaunchOrthologs({ self, scope, }) {
     const { taxId, taxa, maxSpecies, geneCandidates, msaAlgorithm, proteinSequence, source = 'ncbi', } = self.orthologParams;
-    const onProgress = (arg) => {
-        self.setProgress(arg);
-    };
+    const { onProgress, act, signal } = scope;
     const request = {
         taxId,
         geneCandidates,
@@ -62,7 +60,9 @@ export async function doLaunchOrthologs({ self, }) {
     // token, and a collision would silently point the coordinate mapping at
     // another animal's row.
     const queryLabel = await queryRowLabel(taxId, rows);
-    self.setQuerySeqName(queryLabel);
+    act(() => {
+        self.setQuerySeqName(queryLabel);
+    });
     const treeMetadata = {
         [queryLabel]: buildQueryMetadata(self, geneId, cleanedSeq, representative),
     };
@@ -76,6 +76,7 @@ export async function doLaunchOrthologs({ self, }) {
             ...rows.map(r => `>${r.label}\n${r.sequence}`),
         ].join('\n'),
         onProgress,
+        signal,
     });
     return {
         ...result,

package/dist/MsaViewPanel/doLaunchOrthologs.test.js

@@ -1,9 +1,9 @@
 import { beforeEach, describe, expect, test, vi } from 'vitest';
-import { doLaunchOrthologs } from './doLaunchOrthologs';
 import { launchMSA } from '../utils/msa';
 import { defaultMaxSpecies, fetchOrthologRows, fetchProteinForGene, resolveGeneId, } from '../utils/ncbiOrthologs';
 import { fetchPantherOrthologs } from '../utils/pantherOrthologs';
 import { fetchTaxonomyInfo } from '../utils/taxonomyNames';
+import { doLaunchOrthologs } from './doLaunchOrthologs';
 // Every network call is mocked and nothing else is. What is under test is the
 // argument shaping either side of those calls -- which species get asked for,
 // what becomes the QUERY row, and whether the row earns the Accession that
@@ -33,10 +33,24 @@ const setQuerySeqName = vi.fn();
 function makeModel(orthologParams) {
     return {
         orthologParams,
-        setProgress: () => { },
         setQuerySeqName,
     };
 }
+// a scope that never cancels, so these tests see the launch's own behaviour --
+// what the scope does when it IS cancelled is runLaunch.test.ts's subject
+function launch({ self }) {
+    return doLaunchOrthologs({
+        self,
+        scope: {
+            signal: new AbortController().signal,
+            act: fn => {
+                fn();
+            },
+            onProgress: () => { },
+            onRid: () => { },
+        },
+    });
+}
 function params(extra = {}) {
     return {
         taxId: HUMAN,
@@ -79,11 +93,11 @@ beforeEach(() => {
 });
 describe('which species become rows', () => {
     test('omitted taxa asks for no restriction at all, which is every ortholog NCBI has', async () => {
-        await doLaunchOrthologs({ self: makeModel(params()) });
+        await launch({ self: makeModel(params()) });
         expect(rowRequest().taxa).toBeUndefined();
     });
     test('given taxa is taken as written', async () => {
-        await doLaunchOrthologs({
+        await launch({
             self: makeModel(params({ taxa: [HUMAN, 10090, 9615] })),
         });
         expect(rowRequest().taxa).toEqual([9606, 9615, 10090]);
@@ -92,20 +106,20 @@ describe('which species become rows', () => {
     // and "the query row already covers this one" stay separable -- an unrestricted
     // launch still has to drop the query species.
     test('the query species is excluded whether or not taxa was given', async () => {
-        await doLaunchOrthologs({ self: makeModel(params()) });
+        await launch({ self: makeModel(params()) });
         expect(rowRequest().exclude).toBe(HUMAN);
         vi.clearAllMocks();
         mockResolveGeneId.mockResolvedValue({ geneId: GENE_ID, matched: 'NLRP1' });
         mockFetchProtein.mockResolvedValue(REPRESENTATIVE);
         mockFetchRows.mockResolvedValue([]);
         mockLaunchMSA.mockResolvedValue({ msa: '', tree: '' });
-        await doLaunchOrthologs({
+        await launch({
             self: makeModel(params({ taxa: [HUMAN, 10090] })),
         });
         expect(rowRequest().exclude).toBe(HUMAN);
     });
     test('an empty list is a request for no rows, not a request for all of them', async () => {
-        await doLaunchOrthologs({ self: makeModel(params({ taxa: [] })) });
+        await launch({ self: makeModel(params({ taxa: [] })) });
         expect(rowRequest().taxa).toEqual([]);
     });
 });
@@ -114,11 +128,11 @@ describe('which species become rows', () => {
 // second a row.
 describe('the row cap', () => {
     test('is passed through when given', async () => {
-        await doLaunchOrthologs({ self: makeModel(params({ maxSpecies: 12 })) });
+        await launch({ self: makeModel(params({ maxSpecies: 12 })) });
         expect(rowRequest().limit).toBe(12);
     });
     test('omitted leaves the default to fetchOrthologGenes rather than sending Infinity', async () => {
-        await doLaunchOrthologs({ self: makeModel(params()) });
+        await launch({ self: makeModel(params()) });
         expect(rowRequest().limit).toBeUndefined();
         expect(defaultMaxSpecies).toBeGreaterThan(2);
     });
@@ -129,7 +143,7 @@ describe('the row cap', () => {
 // model's querySeqName and the header have to be the same string.
 describe('the query row name', () => {
     test('is the species, marked, rather than a bare QUERY among named rows', async () => {
-        await doLaunchOrthologs({ self: makeModel(params()) });
+        await launch({ self: makeModel(params()) });
         expect(queryRowName()).toBe('human_query');
         expect(setQuerySeqName).toHaveBeenCalledWith('human_query');
     });
@@ -137,41 +151,41 @@ describe('the query row name', () => {
         mockFetchRows.mockResolvedValue([
             { label: 'human_query', sequence: 'MM' },
         ]);
-        await doLaunchOrthologs({ self: makeModel(params()) });
+        await launch({ self: makeModel(params()) });
         expect(queryRowName()).toBe('human_query_2');
         expect(setQuerySeqName).toHaveBeenCalledWith('human_query_2');
     });
     test('falls back rather than throwing when NCBI cannot name the taxon', async () => {
         vi.spyOn(console, 'warn').mockImplementation(() => { });
         mockFetchTaxonomy.mockRejectedValue(new Error('429'));
-        await doLaunchOrthologs({ self: makeModel(params()) });
+        await launch({ self: makeModel(params()) });
         expect(queryRowName()).toBe('query_query');
     });
     test('the metadata that drives the domain overlay is keyed to that same name', async () => {
-        const result = await doLaunchOrthologs({ self: makeModel(params()) });
+        const result = await launch({ self: makeModel(params()) });
         expect(Object.keys(JSON.parse(result.treeMetadata))).toContain('human_query');
     });
 });
 describe('the query row sequence', () => {
     test('omitted proteinSequence falls back to the representative protein', async () => {
-        await doLaunchOrthologs({ self: makeModel(params()) });
+        await launch({ self: makeModel(params()) });
         expect(queryRowSent()).toBe(REPRESENTATIVE.sequence);
     });
     test('a supplied sequence is used, and is cleaned first', async () => {
-        await doLaunchOrthologs({
+        await launch({
             self: makeModel(params({ proteinSequence: 'MAGG*AWGR&' })),
         });
         expect(queryRowSent()).toBe('MAGGAWGR');
     });
     test('throws when neither a sequence nor a representative is available', async () => {
         mockFetchProtein.mockResolvedValue(undefined);
-        await expect(doLaunchOrthologs({ self: makeModel(params()) })).rejects.toThrow(/No query protein/);
+        await expect(launch({ self: makeModel(params()) })).rejects.toThrow(/No query protein/);
         expect(mockLaunchMSA).not.toHaveBeenCalled();
     });
     test('a failed representative lookup does not take down a launch that brought its own sequence', async () => {
         vi.spyOn(console, 'warn').mockImplementation(() => { });
         mockFetchProtein.mockRejectedValue(new Error('429'));
-        await doLaunchOrthologs({
+        await launch({
             self: makeModel(params({ proteinSequence: REPRESENTATIVE.sequence })),
         });
         expect(queryRowSent()).toBe(REPRESENTATIVE.sequence);
@@ -183,14 +197,14 @@ describe('the query row sequence', () => {
 // here, in both directions.
 describe('the Accession that drives the domain overlay', () => {
     test('is attached when the query row IS the representative protein', async () => {
-        const result = await doLaunchOrthologs({ self: makeModel(params()) });
+        const result = await launch({ self: makeModel(params()) });
         expect(queryMetadata(result)).toMatchObject({
             'Gene ID': GENE_ID,
             Accession: REPRESENTATIVE.accession,
         });
     });
     test('is withheld from a non-representative isoform', async () => {
-        const result = await doLaunchOrthologs({
+        const result = await launch({
             self: makeModel(params({ proteinSequence: 'MDIFFERENTISOFORM' })),
         });
         expect(queryMetadata(result).Accession).toBeUndefined();
@@ -198,7 +212,7 @@ describe('the Accession that drives the domain overlay', () => {
     test('is withheld when the representative lookup failed', async () => {
         vi.spyOn(console, 'warn').mockImplementation(() => { });
         mockFetchProtein.mockRejectedValue(new Error('429'));
-        const result = await doLaunchOrthologs({
+        const result = await launch({
             self: makeModel(params({ proteinSequence: REPRESENTATIVE.sequence })),
         });
         expect(queryMetadata(result).Accession).toBeUndefined();
@@ -235,12 +249,12 @@ describe('the PANTHER source', () => {
         mockFetchTaxonomy.mockResolvedValue(new Map([[YEAST, { sciname: 'Saccharomyces cerevisiae' }]]));
     });
     test('source omitted is NCBI, so an old launch never reaches PANTHER', async () => {
-        await doLaunchOrthologs({ self: makeModel(params()) });
+        await launch({ self: makeModel(params()) });
         expect(mockFetchPanther).not.toHaveBeenCalled();
         expect(mockResolveGeneId).toHaveBeenCalled();
     });
     test('source panther asks PANTHER with the same species semantics, and skips NCBI', async () => {
-        await doLaunchOrthologs({
+        await launch({
             self: makeModel({
                 taxId: YEAST,
                 source: 'panther',
@@ -260,7 +274,7 @@ describe('the PANTHER source', () => {
         expect(limit).toBe(7);
     });
     test("the query row is PANTHER's own entry for the gene when no sequence was supplied, and carries its UniProt accession for the domain overlay", async () => {
-        const result = await doLaunchOrthologs({
+        const result = await launch({
             self: makeModel({
                 taxId: YEAST,
                 source: 'panther',
@@ -280,7 +294,7 @@ describe('the PANTHER source', () => {
         });
     });
     test('a supplied sequence still wins, and a different isoform earns no Accession', async () => {
-        const result = await doLaunchOrthologs({
+        const result = await launch({
             self: makeModel({
                 taxId: YEAST,
                 source: 'panther',
@@ -294,7 +308,7 @@ describe('the PANTHER source', () => {
     });
     test('names PANTHER when it has no protein for the query row', async () => {
         mockFetchPanther.mockResolvedValue({ ...found, query: undefined });
-        await expect(doLaunchOrthologs({
+        await expect(launch({
             self: makeModel({
                 taxId: YEAST,
                 source: 'panther',

package/dist/MsaViewPanel/genomeToMSA.js

@@ -1,9 +1,11 @@
 import { getSession } from '@jbrowse/core/util';
-import { hasHoverPosition } from './util';
+import { hasHoverPosition, hasQueryRow } from './util';
 export function genomeToMSA({ model }) {
     const { hovered } = getSession(model);
     const { querySeqName, transcriptToMsaMap, connectedView, mafRegion } = model;
-    if (!connectedView?.initialized || !hasHoverPosition(hovered)) {
+    if (!connectedView?.initialized ||
+        !hasHoverPosition(hovered) ||
+        !hasQueryRow(model)) {
         return undefined;
     }
     const { coord, refName } = hovered.hoverPosition;

package/dist/MsaViewPanel/genomeToMSA.test.js

@@ -19,6 +19,7 @@ describe('genomeToMSA', () => {
         });
         const model = {
             querySeqName: 'hg38.chr1',
+            rows: [['hg38.chr1', 'ACGTACGTAC']],
             transcriptToMsaMap: undefined,
             mafRegion: {
                 refName: 'chr1',
@@ -38,6 +39,7 @@ describe('genomeToMSA', () => {
         });
         const model = {
             querySeqName: 'hg38.chr1',
+            rows: [['hg38.chr1', 'ACGTACGTAC']],
             transcriptToMsaMap: undefined,
             mafRegion: {
                 refName: 'chr1',
@@ -62,6 +64,7 @@ describe('genomeToMSA', () => {
             const mockSeqPosToVisibleCol = vi.fn().mockReturnValue(5);
             const model = {
                 querySeqName: 'hg38.chr1',
+                rows: [['hg38.chr1', 'ACGTACGTAC']],
                 transcriptToMsaMap: undefined,
                 mafRegion: {
                     refName: 'chr1',
@@ -90,6 +93,7 @@ describe('genomeToMSA', () => {
             });
             const model = {
                 querySeqName: 'hg38.chr1',
+                rows: [['hg38.chr1', 'ACGTACGTAC']],
                 transcriptToMsaMap: undefined,
                 mafRegion: {
                     refName: 'chr1',
@@ -116,6 +120,7 @@ describe('genomeToMSA', () => {
             });
             const model = {
                 querySeqName: 'hg38.chr1',
+                rows: [['hg38.chr1', 'ACGTACGTAC']],
                 transcriptToMsaMap: undefined,
                 mafRegion: {
                     refName: 'chr1',
@@ -142,6 +147,7 @@ describe('genomeToMSA', () => {
             });
             const model = {
                 querySeqName: 'hg38.chr1',
+                rows: [['hg38.chr1', 'ACGTACGTAC']],
                 transcriptToMsaMap: undefined,
                 mafRegion: {
                     refName: 'chr1',
@@ -167,6 +173,7 @@ describe('genomeToMSA', () => {
             });
             const model = {
                 querySeqName: 'hg38.chr1',
+                rows: [['hg38.chr1', 'ACGTACGTAC']],
                 transcriptToMsaMap: undefined,
                 mafRegion: {
                     refName: 'chr1',
@@ -195,6 +202,7 @@ describe('genomeToMSA', () => {
             const mockSeqPosToVisibleCol = vi.fn().mockReturnValue(10);
             const model = {
                 querySeqName: 'QUERY',
+                rows: [['QUERY', 'MKVLTAEEK']],
                 transcriptToMsaMap: {
                     refName: 'chr1',
                     // g2p is keyed by 0-based genome position, the hover coord is 1-based
@@ -220,6 +228,7 @@ describe('genomeToMSA', () => {
             const mockSeqPosToVisibleCol = vi.fn();
             const model = {
                 querySeqName: 'QUERY',
+                rows: [['QUERY', 'MKVLTAEEK']],
                 transcriptToMsaMap: {
                     refName: 'chr1',
                     g2p: { 1004: 10 },
@@ -240,6 +249,7 @@ describe('genomeToMSA', () => {
             });
             const model = {
                 querySeqName: 'QUERY',
+                rows: [['QUERY', 'MKVLTAEEK']],
                 transcriptToMsaMap: {
                     refName: 'chr1',
                     g2p: { 1000: 0 }, // No entry for 1004
@@ -261,6 +271,7 @@ describe('genomeToMSA', () => {
         });
         const model = {
             querySeqName: 'QUERY',
+            rows: [['QUERY', 'MKVLTAEEK']],
             transcriptToMsaMap: undefined,
             mafRegion: undefined,
             connectedView: { initialized: true },
@@ -269,4 +280,27 @@ describe('genomeToMSA', () => {
         const result = genomeToMSA({ model });
         expect(result).toBeUndefined();
     });
+    // seqPosToVisibleCol answers 0 for a row name it does not know, so without a
+    // guard an alignment whose query row is missing -- the default 'QUERY' on an
+    // uploaded file, or the empty name the manual panel leaves when it matches
+    // nothing -- lights column 0 on every genome hover
+    test('returns undefined when querySeqName names no row here', () => {
+        mockGetSession.mockReturnValue({
+            hovered: {
+                hoverFeature: {},
+                hoverPosition: { coord: 1005, refName: 'chr1' },
+            },
+        });
+        const seqPosToVisibleCol = vi.fn(() => 0);
+        const model = {
+            querySeqName: 'QUERY',
+            rows: [['some_other_row', 'MKVLTAEEK']],
+            transcriptToMsaMap: { refName: 'chr1', g2p: { 1004: 3 } },
+            mafRegion: undefined,
+            connectedView: { initialized: true },
+            seqPosToVisibleCol,
+        };
+        expect(genomeToMSA({ model })).toBeUndefined();
+        expect(seqPosToVisibleCol).not.toHaveBeenCalled();
+    });
 });