@jbrowse/plugin-blat 5.0.0-beta.1 → 5.0.0-beta.11

package/esm/BlatDialog.js

@@ -7,7 +7,7 @@ import MonospaceTextField from './MonospaceTextField.js';
 import UcscQueryActions from './UcscQueryActions.js';
 import UcscQueryFields from './UcscQueryFields.js';
 import UcscQueryStatus from './UcscQueryStatus.js';
-import { DEFAULT_BLAT_URL, UCSC_BLAT_URL, MAXIMUM_BLAT_LENGTH, MAXIMUM_BLAT_QUERIES, MINIMUM_BLAT_LENGTH, buildBlatBody, fastaRecordCount, parseBlatResponse, pslToFeatures, queryLabel, stripFasta, } from './blatQuery.js';
+import { DEFAULT_BLAT_URL, UCSC_BLAT_URL, MINIMUM_BLAT_LENGTH, blatQueryProblem, blatResidueCount, buildBlatBody, parseBlatResponse, parseFastaRecords, pslToFeatures, queryLabel, } from './blatQuery.js';
 import { parseQuerySequences, pslToSam } from './pslToSam.js';
 import { canRenderAlignments } from './ucscShared.js';
 import { runUcscFetch, useUcscQuery } from './useUcscQuery.js';
@@ -20,20 +20,14 @@ const BlatDialog = observer(function BlatDialog({ session, handleClose, }) {
     });
     const { db, urlBase, fallbackUrl, apiKey } = query;
     const [seq, setSeq] = useState('');
-    const residues = stripFasta(seq);
-    const queryCount = fastaRecordCount(seq);
-    const tooShort = residues.length < MINIMUM_BLAT_LENGTH;
-    const tooLong = residues.length > MAXIMUM_BLAT_LENGTH;
-    const tooMany = queryCount > MAXIMUM_BLAT_QUERIES;
-    const seqError = tooLong
-        ? `Sequence is ${residues.length.toLocaleString()} bp; UCSC BLAT is limited to ${MAXIMUM_BLAT_LENGTH.toLocaleString()} bp`
-        : tooMany
-            ? `${queryCount} sequences; UCSC BLAT is limited to ${MAXIMUM_BLAT_QUERIES} per query`
-            : tooShort && residues
-                ? `Sequence must be at least ${MINIMUM_BLAT_LENGTH} bp`
-                : '';
+    const records = parseFastaRecords(seq);
+    const queryCount = records.length;
+    const seqError = blatQueryProblem(records);
+    // an empty box disables submit without turning the field red, so the minimum
+    // is checked here rather than reported above
+    const submittable = !seqError && blatResidueCount(records) >= MINIMUM_BLAT_LENGTH;
     async function handleSubmit() {
-        const label = queryLabel(seq);
+        const label = queryLabel(records);
         await query.runQuery({
             // PSL states each hit as aligned blocks in query and target coordinates,
             // which is a CIGAR alignment: converting to SAM and showing it in an
@@ -86,7 +80,7 @@ const BlatDialog = observer(function BlatDialog({ session, handleClose, }) {
         }, children: [_jsxs(DialogContent, { style: { display: 'flex', flexDirection: 'column', gap: 12 }, children: [_jsx(MonospaceTextField, { label: "Sequence", value: seq, onChange: event => {
                             setSeq(event.target.value);
                         }, multiline: true, minRows: 6, maxRows: 14, autoFocus: true, placeholder: "Paste a DNA sequence or FASTA to locate it in the genome", error: !!seqError, helperText: seqError ||
-                            'DNA, or FASTA with up to 25 records, 25 kb total. Hits are added as a track, and listed best-first in a panel where each one is a link.' }), _jsx(UcscQueryFields, { session: session, query: query, urlLabel: "BLAT server URL" }), _jsx(UcscQueryStatus, { query: query })] }), _jsx(UcscQueryActions, { query: query, submitDisabled: tooShort || tooLong || tooMany || !db, onSubmit: () => void handleSubmit(), onCancel: () => {
+                            'DNA, or FASTA with up to 25 records, 25 kb each and 50 kb in total. Hits are added as a track, and listed best-first in a panel where each one is a link.' }), _jsx(UcscQueryFields, { session: session, query: query, urlLabel: "BLAT server URL" }), _jsx(UcscQueryStatus, { query: query })] }), _jsx(UcscQueryActions, { query: query, submitDisabled: !submittable || !db, onSubmit: () => void handleSubmit(), onCancel: () => {
                     handleClose();
                 } })] }));
 });

package/esm/UcscResultsWidget/configSchema.d.ts

@@ -1 +1 @@
-export declare const configSchema: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
+export declare const configSchema: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined, undefined, import("@jbrowse/core/configuration").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>, any>>;

package/esm/UcscResultsWidget/index.js

@@ -1,13 +1,14 @@
-import { lazy } from 'react';
 import WidgetType from '@jbrowse/core/pluggableElementTypes/WidgetType';
+import { lazyWithPreload } from '@jbrowse/core/util/lazyWithPreload';
 import { configSchema } from './configSchema.js';
 import { stateModelFactory } from './stateModel.js';
 export default function UcscResultsWidgetF(pluginManager) {
     pluginManager.addWidgetType(() => new WidgetType({
         name: 'UcscResultsWidget',
+        discardOnClose: true,
         heading: 'Search results',
         configSchema,
         stateModel: stateModelFactory(),
-        ReactComponent: lazy(() => import('./UcscResultsWidget.js')),
+        ReactComponent: lazyWithPreload(() => import('./UcscResultsWidget.js')),
     }));
 }

package/esm/UcscResultsWidget/stateModel.d.ts

@@ -36,7 +36,7 @@ export declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").
      * product, which is a band on a gel — the word a bench scientist reasons in,
      * and "2 hits" understates what two of them mean for a PCR run
      */
-    resultNoun: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
+    resultNoun: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<"hit" | "product">, [undefined]>;
 }, {}, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;
 export type UcscResultsWidgetStateModel = ReturnType<typeof stateModelFactory>;
 export type UcscResultsWidgetModel = Instance<UcscResultsWidgetStateModel>;

package/esm/blatQuery.d.ts

@@ -37,11 +37,36 @@ export interface PslRow {
 export declare function parsePslRows(data: BlatJsonResponse): PslRow[];
 export declare function pslToFeatures(rows: PslRow[]): SimpleFeatureSerialized[];
 export declare const MINIMUM_BLAT_LENGTH = 20;
-export declare const MAXIMUM_BLAT_LENGTH = 25000;
+export declare const MAXIMUM_BLAT_SEQUENCE_LENGTH = 25000;
+export declare const MAXIMUM_BLAT_TOTAL_LENGTH = 50000;
 export declare const MAXIMUM_BLAT_QUERIES = 25;
-export declare function stripFasta(seq: string): string;
-export declare function fastaRecordCount(seq: string): number;
-export declare function queryLabel(seq: string): string;
+/**
+ * One submitted FASTA record. `name` is the header's first token and is absent
+ * for a bare sequence, which hgBlat labels `YourSeq`.
+ *
+ * `residues` keeps letters only, which is what kent's FASTA reader counts and
+ * therefore what both the limits and `qSize` are stated in: a sequence pasted
+ * with line numbers or alignment-gap dashes is fewer bases to BLAT than it has
+ * characters.
+ */
+export interface FastaRecord {
+    name?: string;
+    residues: string;
+}
+/**
+ * The submitted text split the way hgBlat splits it: each record is placed
+ * separately and its hits are labelled with its name. The length limits, the
+ * track label and the name-to-bases map the SAM conversion needs all come off
+ * this one reader, so none of them can disagree about where a record starts.
+ *
+ * The text itself still goes to the server verbatim — stripping the headers here
+ * would fuse a multi-record paste into one chimeric query and throw away the
+ * names that tell the hits apart.
+ */
+export declare function parseFastaRecords(text: string): FastaRecord[];
+export declare function blatResidueCount(records: FastaRecord[]): number;
+export declare function blatQueryProblem(records: FastaRecord[]): string;
+export declare function queryLabel(records: FastaRecord[]): string;
 export declare function buildBlatBody({ db, seq, apiKey, }: {
     db: string;
     seq: string;

package/esm/blatQuery.js

@@ -113,43 +113,86 @@ function pslRowToFeature(row, featureIndex) {
     };
 }
 export function pslToFeatures(rows) {
-    return rows.map((row, i) => pslRowToFeature(row, i));
+    return rows.map(pslRowToFeature);
 }
 export const MINIMUM_BLAT_LENGTH = 20;
-// UCSC rejects queries over 25kb server-side; enforce locally for a clear message
-export const MAXIMUM_BLAT_LENGTH = 25000;
-// hgBlat's per-submission cap on FASTA records
+// hgBlat's own three caps, which its submission page states: 25,000 bases in one
+// DNA sequence, 50,000 across a multi-record submission, 25 records. The
+// per-sequence and combined numbers are separate limits — holding the total to
+// 25,000 refused a three-record FASTA the server would have taken.
+export const MAXIMUM_BLAT_SEQUENCE_LENGTH = 25000;
+export const MAXIMUM_BLAT_TOTAL_LENGTH = 50000;
 export const MAXIMUM_BLAT_QUERIES = 25;
-// residues only, for the length limits. The query itself goes to the server
-// verbatim: hgBlat parses FASTA and labels each hit with its record's name, so
-// stripping headers here would fuse a multi-record paste into one chimeric
-// query and throw away the names that tell the hits apart.
-//
-// Letters only, which is what kent's FASTA reader counts and therefore what the
-// limits are stated in — a sequence pasted with line numbers or alignment-gap
-// dashes is fewer bases to BLAT than it has characters. Counting whitespace out
-// but digits in measured a 25kb-limited query against a number the server does
-// not use. Same rule as parseQuerySequences, which has to agree with `qSize`.
-export function stripFasta(seq) {
-    return seq
-        .split('\n')
-        .filter(line => !line.startsWith('>'))
-        .join('')
-        .replaceAll(/[^A-Za-z]/g, '');
-}
-// hgBlat places each FASTA record separately, so records are queries
-export function fastaRecordCount(seq) {
-    const headers = seq.match(/^>/gm);
-    return headers ? headers.length : 1;
-}
-// names the result track after what was searched: the first FASTA header, or
+/**
+ * The submitted text split the way hgBlat splits it: each record is placed
+ * separately and its hits are labelled with its name. The length limits, the
+ * track label and the name-to-bases map the SAM conversion needs all come off
+ * this one reader, so none of them can disagree about where a record starts.
+ *
+ * The text itself still goes to the server verbatim — stripping the headers here
+ * would fuse a multi-record paste into one chimeric query and throw away the
+ * names that tell the hits apart.
+ */
+export function parseFastaRecords(text) {
+    const records = [];
+    let name;
+    let residues = [];
+    const flush = () => {
+        const joined = residues.join('');
+        if (joined) {
+            records.push({ name, residues: joined });
+        }
+    };
+    for (const line of text.split('\n')) {
+        if (line.startsWith('>')) {
+            flush();
+            name = /^>\s*(\S+)/.exec(line)?.[1];
+            residues = [];
+        }
+        else {
+            residues.push(line.replaceAll(/[^A-Za-z]/g, ''));
+        }
+    }
+    flush();
+    return records;
+}
+export function blatResidueCount(records) {
+    return records.reduce((sum, record) => sum + record.residues.length, 0);
+}
+// Why this query cannot be sent, in the terms hgBlat states its limits in, or
+// '' when it can. Checked here rather than left to the server so an over-long
+// paste says which cap it broke instead of coming back as a kent error page.
+export function blatQueryProblem(records) {
+    const total = blatResidueCount(records);
+    // reduced rather than spread into Math.max: the record cap is checked below
+    // this, so the list reaching here is whatever was pasted
+    const longest = records.reduce((max, record) => Math.max(max, record.residues.length), 0);
+    const subject = records.length > 1 ? 'Longest sequence' : 'Sequence';
+    if (longest > MAXIMUM_BLAT_SEQUENCE_LENGTH) {
+        return `${subject} is ${longest.toLocaleString()} bp; UCSC BLAT is limited to ${MAXIMUM_BLAT_SEQUENCE_LENGTH.toLocaleString()} bp per sequence`;
+    }
+    else if (total > MAXIMUM_BLAT_TOTAL_LENGTH) {
+        return `${total.toLocaleString()} bp in total; UCSC BLAT is limited to ${MAXIMUM_BLAT_TOTAL_LENGTH.toLocaleString()} bp per query`;
+    }
+    else if (records.length > MAXIMUM_BLAT_QUERIES) {
+        return `${records.length} sequences; UCSC BLAT is limited to ${MAXIMUM_BLAT_QUERIES} per query`;
+    }
+    else if (total > 0 && total < MINIMUM_BLAT_LENGTH) {
+        return `Sequence must be at least ${MINIMUM_BLAT_LENGTH} bp`;
+    }
+    else {
+        return '';
+    }
+}
+// names the result track after what was searched: the first record's header, or
 // the leading bases of a bare sequence
-export function queryLabel(seq) {
-    const header = /^>\s*(\S+)/m.exec(seq);
-    const residues = stripFasta(seq);
-    return header
-        ? header[1]
-        : residues.slice(0, 12) + (residues.length > 12 ? '…' : '');
+export function queryLabel(records) {
+    const first = records[0];
+    if (!first) {
+        return '';
+    }
+    const { name, residues } = first;
+    return name ?? residues.slice(0, 12) + (residues.length > 12 ? '…' : '');
 }
 export function buildBlatBody({ db, seq, apiKey, }) {
     const params = new URLSearchParams({
@@ -172,17 +215,21 @@ export function buildBlatBody({ db, seq, apiKey, }) {
 export class BlatChallengeError extends Error {
     name = 'BlatChallengeError';
 }
-// Markers on a Cloudflare Turnstile challenge page. Every marker has to be
-// specific to the challenge itself: a bare `cf-`, `captcha` or `challenge` also
-// matches an ordinary UCSC page, whose standard nav links to
-// FAQdownloads.html#CAPTCHA and whose scripts load from challenges.cloudflare.com.
-// Those two words made a failed parse of a perfectly good result page report
-// itself as a CAPTCHA, sending the user off to solve one that wasn't there.
+// Markers on a Cloudflare Turnstile challenge page. Every marker has to name
+// the widget being MOUNTED, never a page that merely mentions it: a bare `cf-`,
+// `captcha` or `challenge` matches an ordinary UCSC page, whose nav links to
+// FAQdownloads.html#CAPTCHA, and a bare `turnstile` matches one too, because
+// UCSC's Content-Security-Policy whitelists
+// `challenges.cloudflare.com/turnstile/v0/api.js` on every page it serves —
+// including the honest "No matches" that hgPcr answers a primer pair with.
+// Each of those words in turn sent a user off to solve a CAPTCHA that was not
+// there. `turnstile.render(` is the call that puts one on screen, and the
+// challenge page is the only page that makes it.
 //
 // Duplicated in `products/aws/blat-proxy/src/routes.ts`, which decides the same thing
 // about the same pages server-side. The proxy is a standalone package and cannot
 // import this one, so the copies are deliberate: narrow one and narrow both.
-const CHALLENGE_MARKERS = /turnstile|cf[-_]chl/i;
+const CHALLENGE_MARKERS = /turnstile\s*\.\s*render|cf[-_](?:chl|turnstile)/i;
 export function isChallengePage(text) {
     return CHALLENGE_MARKERS.test(text);
 }

package/esm/pslToSam.d.ts

@@ -41,14 +41,8 @@ export declare function pslQuerySeq(row: PslRow, querySequences: Map<string, str
  */
 export declare function pslToSam(rows: PslRow[], querySequences: Map<string, string>): string;
 /**
- * The submitted query text as name -> residues. hgBlat places each FASTA record
- * separately and labels its hits with that record's name, so this is the map
- * from a hit back to the bases it was made of.
- *
- * Keeps only letters, which is what Kent's FASTA reader counts: a pasted
- * sequence carrying line numbers, or alignment-gap dashes, is those bases to
- * BLAT and so `qSize` excludes them. Stripping only whitespace left our text
- * longer than the hit it describes, which is exactly the off-by-N that puts
- * every base out of register.
+ * The submitted query text as name -> residues, which is the map from a hit back
+ * to the bases it was made of. `YourSeq` is what hgBlat calls a record with no
+ * header, so that is the name its hits arrive under.
  */
 export declare function parseQuerySequences(text: string): Map<string, string>;

package/esm/pslToSam.js

@@ -1,4 +1,5 @@
 import { revcom } from '@jbrowse/core/util';
+import { parseFastaRecords } from './blatQuery.js';
 /**
  * PSL states a hit as a list of aligned blocks in both query and target
  * coordinates, which is exactly the information a CIGAR encodes: each block is
@@ -119,35 +120,13 @@ export function pslToSam(rows, querySequences) {
     ].join('\n');
 }
 /**
- * The submitted query text as name -> residues. hgBlat places each FASTA record
- * separately and labels its hits with that record's name, so this is the map
- * from a hit back to the bases it was made of.
- *
- * Keeps only letters, which is what Kent's FASTA reader counts: a pasted
- * sequence carrying line numbers, or alignment-gap dashes, is those bases to
- * BLAT and so `qSize` excludes them. Stripping only whitespace left our text
- * longer than the hit it describes, which is exactly the off-by-N that puts
- * every base out of register.
+ * The submitted query text as name -> residues, which is the map from a hit back
+ * to the bases it was made of. `YourSeq` is what hgBlat calls a record with no
+ * header, so that is the name its hits arrive under.
  */
 export function parseQuerySequences(text) {
-    const sequences = new Map();
-    let name = 'YourSeq';
-    let residues = [];
-    const flush = () => {
-        if (residues.length) {
-            sequences.set(name, residues.join(''));
-        }
-    };
-    for (const line of text.split('\n')) {
-        if (line.startsWith('>')) {
-            flush();
-            name = /^>\s*(\S+)/.exec(line)?.[1] ?? 'YourSeq';
-            residues = [];
-        }
-        else {
-            residues.push(line.replaceAll(/[^A-Za-z]/g, ''));
-        }
-    }
-    flush();
-    return sequences;
+    return new Map(parseFastaRecords(text).map(({ name, residues }) => [
+        name ?? 'YourSeq',
+        residues,
+    ]));
 }

package/esm/ucscShared.js

@@ -1,27 +1,29 @@
 import { getConf } from '@jbrowse/core/configuration';
 import { getEnv, isSessionModelWithWidgets, isSessionWithAddSessionTrack, } from '@jbrowse/core/util';
+import { isSameAssemblyName } from '@jbrowse/core/util/tracks';
 import { assemblyToUcscDb } from './ucscDbMap.js';
 function isNavigableView(view) {
-    return ('showTrack' in view &&
-        typeof view.showTrack === 'function' &&
+    return ('launchTrack' in view &&
+        typeof view.launchTrack === 'function' &&
         'navToLocString' in view &&
         typeof view.navToLocString === 'function');
 }
 // jb2hubs stamps the UCSC db on the assembly's sequence.metadata. Its presence
 // is also the one positive proof that UCSC can search the assembly, so the
 // dialogs read it directly to decide whether to warn.
+// Annotated rather than inferred: the path runs past `metadata`, a `frozen`
+// slot, so the read is into arbitrary JSON and the path type stops deriving
+// anything at that segment.
 export function ucscDbStamp(session, name) {
     const assembly = session.assemblyManager.get(name);
-    const stamped = assembly
+    return assembly
         ? getConf(assembly, ['sequence', 'metadata', 'blatDb'])
         : undefined;
-    return stamped;
 }
 // Prefers the stamp, falling back to the static alias map for assemblies whose
 // configs predate it. Shared by the BLAT and in-silico PCR dialogs.
 export function resolveUcscDb(session, name) {
-    const stamped = ucscDbStamp(session, name);
-    return stamped ? stamped : assemblyToUcscDb(name);
+    return ucscDbStamp(session, name) || assemblyToUcscDb(name);
 }
 /**
  * Whether this host can draw a hit as an alignment rather than as plain blocks.
@@ -45,7 +47,8 @@ export function featureLocString(feature) {
     return `${feature.refName}:${feature.start + 1}-${feature.end}`;
 }
 function findNavigableView(session, assembly) {
-    const view = session.views.find(v => v.type === 'LinearGenomeView' && !!v.assemblyNames?.includes(assembly));
+    const view = session.views.find(v => v.type === 'LinearGenomeView' &&
+        !!v.assemblyNames?.some(n => isSameAssemblyName(n, assembly, session.assemblyManager)));
     return view && isNavigableView(view) ? view : undefined;
 }
 // Navigates an open view to a hit, growing the window so it lands with flanking
@@ -93,24 +96,24 @@ export async function addResultTrack({ session, assembly, features, trackIdPrefi
     });
     const view = findNavigableView(session, assembly);
     if (view) {
-        view.showTrack(trackId);
+        await view.launchTrack(trackId);
     }
     else {
         session.notify(`Added track "${trackId}" but no open view displays ${assembly}`, 'warning');
     }
     // #region showWidget
-    // addWidget constructs the widget and returns it; showWidget is what puts it
-    // in the drawer. The third argument is the initial state, so its keys are the
-    // properties UcscResultsWidget's state model declares. Not every session has
-    // a drawer — an embedded component may be built without one — so the guard is
-    // not optional.
+    // openWidget constructs the widget and puts it in the drawer, which is
+    // addWidget followed by showWidget. The third argument is the initial state,
+    // so its keys are the properties UcscResultsWidget's state model declares. Not
+    // every session has a drawer — an embedded component may be built without one
+    // — so the guard is not optional.
     if (isSessionModelWithWidgets(session)) {
-        session.showWidget(session.addWidget('UcscResultsWidget', 'ucscResults', {
+        session.openWidget('UcscResultsWidget', 'ucscResults', {
             features,
             assembly,
             trackName,
             resultNoun,
-        }));
+        });
     }
     // #endregion
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbrowse/plugin-blat",
-  "version": "5.0.0-beta.1",
+  "version": "5.0.0-beta.11",
   "type": "module",
   "description": "JBrowse 2 UCSC BLAT client",
   "keywords": [
@@ -24,15 +24,16 @@
     "esbuild": "^0.28.2"
   },
   "dependencies": {
-    "@jbrowse/mobx-state-tree": "^6.5.1",
-    "@mui/icons-material": "^9.3.1",
-    "@mui/material": "^9.3.1",
-    "mobx": "^7.0.3",
+    "@jbrowse/mobx-state-tree": "^6.7.0",
+    "@mui/icons-material": "^9.4.0",
+    "@mui/material": "^9.4.0",
+    "mobx": "^7.0.5",
     "mobx-react": "^10.0.2",
-    "@jbrowse/core": "^5.0.0-beta.1"
+    "@jbrowse/core": "^5.0.0-beta.11"
   },
   "peerDependencies": {
-    "react": ">=19.0.0"
+    "react": ">=19.0.0",
+    "react-dom": ">=19.0.0"
   },
   "publishConfig": {
     "access": "public"