jbrowse-plugin-msaview 2.9.0 → 2.10.0

package/dist/utils/ebiJobDispatcher.js

@@ -31,14 +31,39 @@ export async function submitEbiJob({ tool, params, }) {
     });
     return jobId.trim();
 }
+/**
+ * A status check that could not reach EBI at all says nothing about the job, so
+ * it is not a reason to abandon one. A job the server has accepted keeps running
+ * whatever happens to the poller's connection, and the poll is the long part: an
+ * alignment of a hundred sequences runs for minutes and is checked every ten
+ * seconds, so a single blip anywhere in that window used to throw away a job
+ * that went on to finish.
+ *
+ * Consecutive failures still end it, because an endpoint that has genuinely gone
+ * away must not be polled forever.
+ */
+const MAX_CONSECUTIVE_STATUS_FAILURES = 5;
 export async function waitForEbiJob({ tool, jobId, intervalSeconds = 10, onCountdown, }) {
+    let consecutiveFailures = 0;
     await pollLoop({
         intervalSeconds,
         onCountdown,
         check: async () => {
+            let status;
+            try {
+                status = (await textfetch(`${EBI_BASE}/${tool}/status/${jobId}`)).trim();
+            }
+            catch (e) {
+                consecutiveFailures += 1;
+                if (consecutiveFailures >= MAX_CONSECUTIVE_STATUS_FAILURES) {
+                    throw new Error(`Could not reach EBI to check ${tool} job ${jobId} after ${consecutiveFailures} tries`, { cause: e });
+                }
+                console.warn(`[msaview] EBI status check ${consecutiveFailures} failed, retrying:`, e);
+                return false;
+            }
+            consecutiveFailures = 0;
             // exact match, not includes(): a job whose status is ERROR must not be
             // able to poll forever waiting for a FINISHED that will never arrive
-            const status = (await textfetch(`${EBI_BASE}/${tool}/status/${jobId}`)).trim();
             if (status === 'FINISHED') {
                 return true;
             }

package/dist/utils/ebiJobDispatcher.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/ebiJobDispatcher.test.js

@@ -0,0 +1,46 @@
+import { afterEach, describe, expect, test, vi } from 'vitest';
+import { waitForEbiJob } from './ebiJobDispatcher';
+// A long alignment is polled every ten seconds for minutes, so the chance of one
+// failed status check somewhere in that window is not small -- and the job is
+// running at EBI regardless of what happens to the poller's connection.
+describe('waitForEbiJob', () => {
+    afterEach(() => {
+        vi.unstubAllGlobals();
+    });
+    const statuses = (seq) => {
+        let i = 0;
+        vi.stubGlobal('fetch', () => {
+            const next = seq[Math.min(i++, seq.length - 1)];
+            return next instanceof Error
+                ? Promise.reject(next)
+                : Promise.resolve({
+                    ok: true,
+                    status: 200,
+                    text: () => Promise.resolve(next),
+                });
+        });
+    };
+    const wait = () => waitForEbiJob({
+        tool: 'clustalo',
+        jobId: 'job1',
+        intervalSeconds: 0,
+        onCountdown: () => { },
+    });
+    test('a transient failure mid-poll does not abandon a job that then finishes', async () => {
+        statuses(['RUNNING', new TypeError('Failed to fetch'), 'FINISHED']);
+        await expect(wait()).resolves.toBeUndefined();
+    });
+    test('failures that do not persist never accumulate to the limit', async () => {
+        const blip = new TypeError('Failed to fetch');
+        statuses([blip, 'RUNNING', blip, 'RUNNING', blip, 'RUNNING', blip, 'FINISHED']);
+        await expect(wait()).resolves.toBeUndefined();
+    });
+    test('an endpoint that has genuinely gone away is not polled forever', async () => {
+        statuses([new TypeError('Failed to fetch')]);
+        await expect(wait()).rejects.toThrow(/Could not reach EBI/);
+    });
+    test('a job EBI reports as failed still ends the poll immediately', async () => {
+        statuses(['ERROR']);
+        await expect(wait()).rejects.toThrow(/returned status ERROR/);
+    });
+});

package/dist/utils/eutils.d.ts

@@ -1,3 +1,12 @@
 export declare const NCBI_TOOL = "jbrowse-plugin-msaview";
 export declare const NCBI_EMAIL = "colin.diesh@gmail.com";
 export declare function efetchUrl(params: Record<string, string>): string;
+/**
+ * The same request as a POST body. An `id` list of a few hundred accessions
+ * exceeds what a URL carries — 865 of them is ~13KB — and NCBI documents POST
+ * as the route above about 200 ids. eutils sends `ACAO: *` on both verbs.
+ */
+export declare function efetchPost(params: Record<string, string>): readonly ["https://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi", {
+    readonly method: "POST";
+    readonly body: URLSearchParams;
+}];

package/dist/utils/eutils.js

@@ -12,3 +12,21 @@ export function efetchUrl(params) {
     });
     return `${EUTILS}/efetch.fcgi?${search.toString()}`;
 }
+/**
+ * The same request as a POST body. An `id` list of a few hundred accessions
+ * exceeds what a URL carries — 865 of them is ~13KB — and NCBI documents POST
+ * as the route above about 200 ids. eutils sends `ACAO: *` on both verbs.
+ */
+export function efetchPost(params) {
+    return [
+        `${EUTILS}/efetch.fcgi`,
+        {
+            method: 'POST',
+            body: new URLSearchParams({
+                ...params,
+                tool: NCBI_TOOL,
+                email: NCBI_EMAIL,
+            }),
+        },
+    ];
+}

package/dist/utils/ncbiOrthologs.d.ts

@@ -1,74 +1,4 @@
-export declare const COMMON_SPECIES: readonly [{
-    readonly label: "Human";
-    readonly taxId: 9606;
-}, {
-    readonly label: "Chimpanzee";
-    readonly taxId: 9598;
-}, {
-    readonly label: "Gorilla";
-    readonly taxId: 9595;
-}, {
-    readonly label: "Rhesus macaque";
-    readonly taxId: 9544;
-}, {
-    readonly label: "Marmoset";
-    readonly taxId: 9483;
-}, {
-    readonly label: "Mouse";
-    readonly taxId: 10090;
-}, {
-    readonly label: "Rat";
-    readonly taxId: 10116;
-}, {
-    readonly label: "Guinea pig";
-    readonly taxId: 10141;
-}, {
-    readonly label: "Rabbit";
-    readonly taxId: 9986;
-}, {
-    readonly label: "Cat";
-    readonly taxId: 9685;
-}, {
-    readonly label: "Dog";
-    readonly taxId: 9615;
-}, {
-    readonly label: "Horse";
-    readonly taxId: 9796;
-}, {
-    readonly label: "Pig";
-    readonly taxId: 9823;
-}, {
-    readonly label: "Cow";
-    readonly taxId: 9913;
-}, {
-    readonly label: "Sheep";
-    readonly taxId: 9940;
-}, {
-    readonly label: "Opossum";
-    readonly taxId: 13616;
-}, {
-    readonly label: "Chicken";
-    readonly taxId: 9031;
-}, {
-    readonly label: "Frog";
-    readonly taxId: 8364;
-}, {
-    readonly label: "Zebrafish";
-    readonly taxId: 7955;
-}, {
-    readonly label: "Fruitfly";
-    readonly taxId: 7227;
-}, {
-    readonly label: "C. elegans";
-    readonly taxId: 6239;
-}, {
-    readonly label: "Yeast";
-    readonly taxId: 4932;
-}, {
-    readonly label: "Arabidopsis";
-    readonly taxId: 3702;
-}];
-export declare const COMMON_TAX_RANK: Map<number, number>;
+export declare const defaultMaxSpecies = 100;
 export interface OrthologRow {
     taxId: number;
     /** single-token id used identically in the FASTA, the tree and the domain GFF */
@@ -91,8 +21,18 @@ export declare function resolveGeneId(candidates: string[], taxId: number): Prom
     geneId: string;
     matched: string;
 } | undefined>;
-/** One ortholog gene per species, restricted to the requested taxa. */
-export declare function fetchOrthologGenes(geneId: string, taxa: Set<number>): Promise<{
+/**
+ * One ortholog gene per species, in NCBI's report order, capped at `limit`.
+ *
+ * `taxa` narrows the set when a caller wants specific species; omitted, every
+ * species NCBI has an ortholog for is a candidate. `exclude` drops the query
+ * taxon, which the QUERY row already represents.
+ */
+export declare function fetchOrthologGenes(geneId: string, { taxa, exclude, limit, }?: {
+    taxa?: Set<number>;
+    exclude?: number;
+    limit?: number;
+}): Promise<{
     taxId: number;
     geneId: string;
     scientificName: string;
@@ -128,8 +68,10 @@ export declare function fetchProteinForGene(geneId: string): Promise<{
  * accessions and sequences. Everything here is a precomputed lookup, so this
  * returns in seconds rather than the 10+ minutes a BLAST submission costs.
  */
-export declare function fetchOrthologRows({ geneId, taxa, onProgress, }: {
+export declare function fetchOrthologRows({ geneId, taxa, exclude, limit, onProgress, }: {
     geneId: string;
-    taxa: Set<number>;
+    taxa?: Set<number>;
+    exclude?: number;
+    limit?: number;
     onProgress: (arg: string) => void;
 }): Promise<OrthologRow[]>;

package/dist/utils/ncbiOrthologs.js

@@ -14,68 +14,41 @@
 //
 // Mirrors jb2hubs' website/src/components/proteinMsa.ts assembler, trimmed to
 // what the launch dialog needs and using this plugin's fetch/eutils helpers.
-import { NCBI_EMAIL, NCBI_TOOL } from './eutils';
+import { NCBI_EMAIL, NCBI_TOOL, efetchPost } from './eutils';
 import { jsonfetch, textfetch } from './fetch';
 // v2, not v2alpha: the alpha path still answers /orthologs but 404s
 // /product_report, so an assembler pointed at it silently resolves zero
 // representative proteins and reports "no orthologs" for every gene.
 const DATASETS = 'https://api.ncbi.nlm.nih.gov/datasets/v2';
 const EUTILS = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils';
-// The species panel offered in the launch dialog, ordered from the reference
-// outward so a run that finds only close relatives still reads as a ladder.
-// Orthologs absent for a given gene are skipped rather than erroring.
+// NCBI's ortholog report IS the species panel. There is no list here to keep in
+// step with what NCBI knows, and the panel widens by itself as NCBI annotates
+// more genomes.
 //
-// The index order is the order the sequences are SUBMITTED in
-// (`COMMON_TAX_RANK` below sorts `fetchOrthologGenes`' return), not the order the
-// rows are drawn in: the view lays rows out by the guide tree the aligner returns,
-// so a run on this list comes out grouped by relatedness rather than by this
-// list's own sequence. Reordering here changes what Clustal is handed, not the
-// picture.
+// It used to be a hand-written 23-species list intersected with the report, and
+// the intersection is what made the alignment thin: NCBI publishes 165 orthologs
+// for human NLRP1 and 865 for CFTR, so the list kept 12 of the first and 19 of
+// the second. It also carried four species -- fruitfly, yeast, C. elegans and
+// arabidopsis -- that the endpoint has never once returned for a human gene:
+// checked against NLRP1, TP53, ACTB, BRCA1, PIK3CA, APOE and NOTCH1, whose fly
+// ortholog is famous and still absent. NCBI's ortholog sets are vertebrate
+// scoped.
 //
-// THE MAMMALS EARN THEIR PLACE, and the reason is measured rather than aesthetic.
-// The thirteen this list used to hold were one per major clade, which reads well
-// on a gene conserved to yeast and produces almost nothing on a gene that is not:
-// NCBI publishes 165 orthologs for human NLRP1 and every one of them is a mammal,
-// so of the old thirteen only Human, Mouse, Cow, Pig and Dog returned a row --
-// five, and Rat not among them, since NLRP1 is absent in Rattus norvegicus. The
-// same query against this list returns twelve. An inflammasome gene is not an
-// unusual case; anything immune, reproductive or lineage-specific behaves the
-// same way, and those are the genes a person opens an ortholog alignment on.
+// The report's OWN order is the ladder the list was hand-built to approximate,
+// and it is per gene. CFTR opens human, mouse, rat, zebrafish, pig, sheep,
+// rabbit, chicken, cattle, ferret, dog, rhesus; NLRP1, which has no ortholog
+// outside placental mammals, opens human, mouse, rhesus, shrew mouse, chimp,
+// dog, cattle, horse. So `limit` takes a prefix and never needs a rank table.
 //
-// Cat, rabbit and opossum are here despite contributing nothing to that gene.
-// They are the three that most often separate "absent in this clade" from
-// "absent in this species", which is the question a gap in the alignment raises.
+// The rows are SUBMITTED in that order, not drawn in it -- the view lays rows out
+// by the guide tree the aligner returns.
 //
-// The cost is the run, and it is roughly linear: one NCBI protein fetch per
-// species and a Clustal Omega job over what comes back, so ~23 rows is about
-// twice the ~13-row wait. Still seconds rather than the minutes BLAST takes,
-// which is the comparison the panel's own text makes.
-export const COMMON_SPECIES = [
-    { label: 'Human', taxId: 9606 },
-    { label: 'Chimpanzee', taxId: 9598 },
-    { label: 'Gorilla', taxId: 9595 },
-    { label: 'Rhesus macaque', taxId: 9544 },
-    { label: 'Marmoset', taxId: 9483 },
-    { label: 'Mouse', taxId: 10090 },
-    { label: 'Rat', taxId: 10116 },
-    { label: 'Guinea pig', taxId: 10141 },
-    { label: 'Rabbit', taxId: 9986 },
-    { label: 'Cat', taxId: 9685 },
-    { label: 'Dog', taxId: 9615 },
-    { label: 'Horse', taxId: 9796 },
-    { label: 'Pig', taxId: 9823 },
-    { label: 'Cow', taxId: 9913 },
-    { label: 'Sheep', taxId: 9940 },
-    { label: 'Opossum', taxId: 13616 },
-    { label: 'Chicken', taxId: 9031 },
-    { label: 'Frog', taxId: 8364 },
-    { label: 'Zebrafish', taxId: 7955 },
-    { label: 'Fruitfly', taxId: 7227 },
-    { label: 'C. elegans', taxId: 6239 },
-    { label: 'Yeast', taxId: 4932 },
-    { label: 'Arabidopsis', taxId: 3702 },
-];
-export const COMMON_TAX_RANK = new Map(COMMON_SPECIES.map((s, i) => [s.taxId, i]));
+// What limits the row count is the aligner, and it is linear in rows at roughly
+// half a second each for a ~1400aa protein: 165 NLRP1 orthologs align at EBI in
+// 88s, 865 CFTR orthologs in 407s. `defaultMaxSpecies` keeps a default run under
+// a minute; EBI's own ceiling is 4000 sequences and 4MB, which even CFTR's full
+// set (1.3MB) sits inside.
+export const defaultMaxSpecies = 100;
 function ncbiUrl(url) {
     const sep = url.includes('?') ? '&' : '?';
     return `${url}${sep}tool=${NCBI_TOOL}&email=${encodeURIComponent(NCBI_EMAIL)}`;
@@ -107,13 +80,22 @@ export async function resolveGeneId(candidates, taxId) {
     }
     return undefined;
 }
-/** One ortholog gene per species, restricted to the requested taxa. */
-export async function fetchOrthologGenes(geneId, taxa) {
+/**
+ * One ortholog gene per species, in NCBI's report order, capped at `limit`.
+ *
+ * `taxa` narrows the set when a caller wants specific species; omitted, every
+ * species NCBI has an ortholog for is a candidate. `exclude` drops the query
+ * taxon, which the QUERY row already represents.
+ */
+export async function fetchOrthologGenes(geneId, { taxa, exclude, limit = defaultMaxSpecies, } = {}) {
     const json = await jsonfetch(ncbiUrl(`${DATASETS}/gene/id/${geneId}/orthologs?returned_content=COMPLETE`));
     const byTaxon = new Map();
     for (const { gene } of json.reports ?? []) {
         const taxId = Number(gene?.tax_id);
-        if (gene?.gene_id && taxa.has(taxId) && !byTaxon.has(taxId)) {
+        if (gene?.gene_id &&
+            taxId !== exclude &&
+            (taxa?.has(taxId) ?? true) &&
+            !byTaxon.has(taxId)) {
             byTaxon.set(taxId, {
                 taxId,
                 geneId: gene.gene_id,
@@ -121,10 +103,26 @@ export async function fetchOrthologGenes(geneId, taxa) {
                 commonName: gene.common_name,
             });
         }
+        if (byTaxon.size >= limit) {
+            break;
+        }
     }
-    return [...byTaxon.values()].sort((a, b) => (COMMON_TAX_RANK.get(a.taxId) ?? Infinity) -
-        (COMMON_TAX_RANK.get(b.taxId) ?? Infinity));
+    return [...byTaxon.values()];
 }
+// Two ceilings sit between a gene id list and its product report, and both fail
+// by returning less rather than by erroring, so a caller that ignores them just
+// draws a thinner alignment.
+//
+// The ids go in the URL PATH, and NCBI answers HTTP 414 above roughly 8KB of
+// them -- CFTR's 865 orthologs join to 8609 characters and 414 on the nose.
+// `PRODUCT_REPORT_CHUNK` keeps a request well inside that.
+//
+// Then the endpoint paginates at 20 with the count in `total_count` and the rest
+// behind `next_page_token`, which is invisible to a caller reading `reports`.
+// `page_size` covers a chunk in one request. The old 23-species panel never
+// reached this: the query taxon is excluded and NCBI has no ortholog for the
+// four invertebrate entries, so its ceiling was 19.
+const PRODUCT_REPORT_CHUNK = 150;
 /**
  * geneId -> representative protein accession: MANE Select where flagged, else
  * the longest isoform. A stable, comparable choice across species — picking
@@ -132,8 +130,9 @@ export async function fetchOrthologGenes(geneId, taxa) {
  */
 export async function fetchRepresentativeProteins(geneIds) {
     const byGene = new Map();
-    if (geneIds.length > 0) {
-        const json = await jsonfetch(ncbiUrl(`${DATASETS}/gene/id/${geneIds.join(',')}/product_report`));
+    for (let i = 0; i < geneIds.length; i += PRODUCT_REPORT_CHUNK) {
+        const chunk = geneIds.slice(i, i + PRODUCT_REPORT_CHUNK);
+        const json = await jsonfetch(ncbiUrl(`${DATASETS}/gene/id/${chunk.join(',')}/product_report?page_size=${chunk.length}`));
         for (const { product } of json.reports ?? []) {
             const candidates = (product?.transcripts ?? [])
                 .map(t => ({
@@ -210,11 +209,11 @@ export async function fetchProteinForGene(geneId) {
  * accessions and sequences. Everything here is a precomputed lookup, so this
  * returns in seconds rather than the 10+ minutes a BLAST submission costs.
  */
-export async function fetchOrthologRows({ geneId, taxa, onProgress, }) {
+export async function fetchOrthologRows({ geneId, taxa, exclude, limit, onProgress, }) {
     onProgress('Finding orthologs across species...');
-    const genes = await fetchOrthologGenes(geneId, taxa);
+    const genes = await fetchOrthologGenes(geneId, { taxa, exclude, limit });
     if (genes.length < 2) {
-        throw new Error(`Only ${genes.length} ortholog(s) found among the selected species — not enough to align`);
+        throw new Error(`Only ${genes.length} ortholog(s) found for this gene — not enough to align`);
     }
     onProgress('Selecting a representative protein per species...');
     const proteinByGene = await fetchRepresentativeProteins(genes.map(g => g.geneId));
@@ -224,7 +223,12 @@ export async function fetchOrthologRows({ geneId, taxa, onProgress, }) {
     }
     onProgress(`Fetching ${withProtein.length} protein sequences...`);
     const accessions = withProtein.map(g => proteinByGene.get(g.geneId));
-    const seqByAcc = parseFasta(await textfetch(ncbiUrl(`${EUTILS}/efetch.fcgi?db=protein&id=${accessions.join(',')}&rettype=fasta&retmode=text`)));
+    const seqByAcc = parseFasta(await textfetch(...efetchPost({
+        db: 'protein',
+        id: accessions.join(','),
+        rettype: 'fasta',
+        retmode: 'text',
+    })));
     const labels = dedupeLabels(withProtein.map(g => g.commonName ?? g.scientificName));
     const rows = withProtein
         .map((g, i) => {

package/dist/utils/ncbiOrthologs.test.js

@@ -1,5 +1,5 @@
-import { describe, expect, test } from 'vitest';
-import { dedupeLabels, parseFasta } from './ncbiOrthologs';
+import { afterEach, describe, expect, test, vi } from 'vitest';
+import { dedupeLabels, fetchOrthologGenes, fetchRepresentativeProteins, parseFasta, } from './ncbiOrthologs';
 describe('dedupeLabels', () => {
     test('sanitizes to single tokens', () => {
         // labels are used identically as FASTA headers, Newick leaf names and GFF
@@ -39,3 +39,83 @@ describe('parseFasta', () => {
         expect(parseFasta('Error: CEFetchPApplication::proxy_stream()').size).toBe(0);
     });
 });
+// The two ceilings that make a widened species set silently return fewer rows.
+// Both are shaped like a successful response, so only a test that counts what
+// came back sees them.
+describe('the NCBI request ceilings', () => {
+    const stubFetch = (handler) => {
+        const seen = [];
+        vi.stubGlobal('fetch', (url) => {
+            seen.push(url);
+            return Promise.resolve({
+                ok: true,
+                status: 200,
+                json: () => Promise.resolve(handler(url)),
+                text: () => Promise.resolve(JSON.stringify(handler(url))),
+            });
+        });
+        return seen;
+    };
+    afterEach(() => {
+        vi.unstubAllGlobals();
+    });
+    const orthologReport = (n) => ({
+        total_count: n,
+        reports: Array.from({ length: n }, (_, i) => ({
+            gene: {
+                gene_id: String(1000 + i),
+                tax_id: String(2000 + i),
+                taxname: `Species ${i}`,
+            },
+        })),
+    });
+    test('fetchOrthologGenes takes a prefix of NCBI report order, not a filtered intersection', async () => {
+        stubFetch(() => orthologReport(165));
+        const genes = await fetchOrthologGenes('22861', { limit: 10 });
+        expect(genes.length).toBe(10);
+        // the report's own order, which leads with the reference organisms
+        expect(genes.map(g => g.geneId)).toEqual(Array.from({ length: 10 }, (_, i) => String(1000 + i)));
+    });
+    test('fetchOrthologGenes drops the query taxon without spending a row on it', async () => {
+        stubFetch(() => orthologReport(165));
+        const genes = await fetchOrthologGenes('22861', { exclude: 2000, limit: 3 });
+        expect(genes.map(g => g.taxId)).toEqual([2001, 2002, 2003]);
+    });
+    test('fetchRepresentativeProteins chunks the gene ids below the URI length NCBI 414s at', async () => {
+        // 865 CFTR ortholog gene ids join to 8609 characters, which NCBI answers
+        // with HTTP 414 rather than a short result
+        const ids = Array.from({ length: 400 }, (_, i) => String(100000 + i));
+        const seen = stubFetch(url => ({
+            reports: (/id\/([^/]+)\//.exec(url)?.[1] ?? '').split(',').map(id => ({
+                product: {
+                    gene_id: id,
+                    transcripts: [{ protein: { accession_version: `NP_${id}.1` } }],
+                },
+            })),
+        }));
+        const byGene = await fetchRepresentativeProteins(ids);
+        expect(byGene.size).toBe(400);
+        expect(seen.length).toBeGreaterThan(1);
+        expect(Math.max(...seen.map(u => u.length))).toBeLessThan(8000);
+    });
+    test('fetchRepresentativeProteins asks for a page big enough to hold its chunk', async () => {
+        // the endpoint paginates at 20 by default and hides the rest behind
+        // next_page_token, so a caller reading only `reports` loses everything past
+        // the first page and reports no protein for those genes
+        const ids = Array.from({ length: 50 }, (_, i) => String(100000 + i));
+        const seen = stubFetch(url => ({
+            reports: (/id\/([^/]+)\//.exec(url)?.[1] ?? '')
+                .split(',')
+                .slice(0, Number(/page_size=(\d+)/.exec(url)?.[1] ?? 20))
+                .map(id => ({
+                product: {
+                    gene_id: id,
+                    transcripts: [{ protein: { accession_version: `NP_${id}.1` } }],
+                },
+            })),
+        }));
+        const byGene = await fetchRepresentativeProteins(ids);
+        expect(byGene.size).toBe(50);
+        expect(seen.every(u => /page_size=\d+/.test(u))).toBe(true);
+    });
+});

package/dist/utils/ncbiTaxonomy.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Free text -> NCBI taxon id. A bare number is taken as the id itself; anything
+ * else is searched against db=taxonomy, which resolves a scientific name
+ * (`Danio rerio`), a common name (`zebrafish`) and a genus alike.
+ *
+ * This replaces a fixed list of species the dialog used to offer. The query
+ * taxon has to match the assembly the user is browsing -- `resolveGeneId`
+ * searches `SYMBOL[Gene Name] AND <taxid>[taxid]` -- so a list that stops at 23
+ * species silently resolves the wrong organism's gene for anyone outside it.
+ */
+export declare function resolveTaxId(query: string): Promise<number | undefined>;

package/dist/utils/ncbiTaxonomy.js

@@ -0,0 +1,33 @@
+import { NCBI_EMAIL, NCBI_TOOL } from './eutils';
+import { jsonfetch } from './fetch';
+const EUTILS = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils';
+/**
+ * Free text -> NCBI taxon id. A bare number is taken as the id itself; anything
+ * else is searched against db=taxonomy, which resolves a scientific name
+ * (`Danio rerio`), a common name (`zebrafish`) and a genus alike.
+ *
+ * This replaces a fixed list of species the dialog used to offer. The query
+ * taxon has to match the assembly the user is browsing -- `resolveGeneId`
+ * searches `SYMBOL[Gene Name] AND <taxid>[taxid]` -- so a list that stops at 23
+ * species silently resolves the wrong organism's gene for anyone outside it.
+ */
+export async function resolveTaxId(query) {
+    const term = query.trim();
+    if (!term) {
+        return undefined;
+    }
+    if (/^\d+$/.test(term)) {
+        return Number(term);
+    }
+    const search = new URLSearchParams({
+        db: 'taxonomy',
+        term,
+        retmode: 'json',
+        retmax: '1',
+        tool: NCBI_TOOL,
+        email: NCBI_EMAIL,
+    });
+    const json = await jsonfetch(`${EUTILS}/esearch.fcgi?${search.toString()}`);
+    const id = json.esearchresult?.idlist?.[0];
+    return id ? Number(id) : undefined;
+}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "2.9.0";
+export declare const version = "2.10.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '2.9.0';
+export const version = '2.10.0';

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.9.0",
+  "version": "2.10.0",
   "license": "MIT",
   "name": "jbrowse-plugin-msaview",
   "repository": {
@@ -43,7 +43,7 @@
     "eslint-plugin-unicorn": "^72.0.0",
     "mobx": "^6.16.1",
     "mobx-react": "^9.2.2",
-    "msa-parsers": "^5.7.1",
+    "msa-parsers": "^5.9.0",
     "pixelmatch": "^7.2.0",
     "pngjs": "^7.0.0",
     "prettier": "^3.9.6",
@@ -51,7 +51,7 @@
     "puppeteer": "^25.3.0",
     "react": "^19.2.8",
     "react-dom": "^19.2.8",
-    "react-msaview": "^5.7.2",
+    "react-msaview": "^5.9.0",
     "rimraf": "^6.1.3",
     "rxjs": "^7.8.2",
     "serve": "^14.2.6",