@jbrowse/core 5.0.0-beta.10 → 5.0.0-beta.13

package/esm/BaseFeatureWidget/SequenceFeatureDetails/featureTypeUtil.d.ts

@@ -1,10 +1,11 @@
 import type { SimpleFeatureSerialized, SimpleFeatureSerializedNoId } from '../../util/index.ts';
+import type { CanonicalTranscripts } from '../../util/isoformRank.ts';
 import type { SequenceDisplayMode, ShowCoordinatesMode } from './model.ts';
 export declare function featureHasCDS(feature: SimpleFeatureSerializedNoId): boolean;
 export declare function featureHasExon(feature: SimpleFeatureSerializedNoId): boolean;
 export declare function featureHasExonOrCDS(feature: SimpleFeatureSerializedNoId): boolean;
 export declare function getTranscripts(feature: SimpleFeatureSerialized): SimpleFeatureSerialized[];
-export declare function pickDefaultTranscriptIndex(transcripts: SimpleFeatureSerialized[]): number;
+export declare function pickDefaultTranscriptIndex(transcripts: SimpleFeatureSerialized[], canonical?: CanonicalTranscripts): number;
 export declare function getDefaultMode(feature: SimpleFeatureSerializedNoId): SequenceDisplayMode;
 export declare function modeHasUpDownstream(mode: SequenceDisplayMode): boolean;
 export declare function modeSupportsRevcomp(mode: SequenceDisplayMode): boolean;

package/esm/BaseFeatureWidget/SequenceFeatureDetails/featureTypeUtil.js

@@ -1,3 +1,4 @@
+import { DEFAULT_CANONICAL_TRANSCRIPTS, isoformScorer, rankIsoforms, serializedIsoformReader, } from '../../util/isoformRank.js';
 // these predicates only ever read type/subfeatures, so they accept a bare
 // subfeature (no guaranteed uniqueId) as readily as a full feature
 export function featureHasCDS(feature) {
@@ -30,20 +31,12 @@ export function getTranscripts(feature) {
         uniqueId: `${feature.uniqueId}_${idx}`,
     })) ?? []);
 }
-// index of the transcript the gene glyph itself would collapse to in
-// 'longestCoding' mode (RenderFeatureDataRPC/glyphs/subfeatures.ts): prefer a
-// coding transcript, then the longest span — so the sequence panel's default
-// matches what the track already drew. A feature that is itself a transcript
-// (clicked directly, not via its container gene) has no nested transcripts to
-// autopick from.
-export function pickDefaultTranscriptIndex(transcripts) {
-    if (transcripts.length === 0) {
-        return 0;
-    }
-    const coding = transcripts.filter(t => featureHasCDS(t));
-    const candidates = coding.length > 0 ? coding : transcripts;
-    const longest = candidates.reduce((a, b) => b.end - b.start > a.end - a.start ? b : a);
-    return transcripts.indexOf(longest);
+// The isoform the canvas gene glyph draws first, so the panel opens on the
+// transcript the track showed. A feature that is itself a transcript has no
+// nested transcripts to pick from.
+export function pickDefaultTranscriptIndex(transcripts, canonical = DEFAULT_CANONICAL_TRANSCRIPTS) {
+    const [best] = rankIsoforms(transcripts, isoformScorer(serializedIsoformReader, canonical));
+    return best ? transcripts.indexOf(best) : 0;
 }
 export function getDefaultMode(feature) {
     return featureHasCDS(feature)

package/esm/BaseFeatureWidget/SequenceFeatureDetails/seqtypes/CDNASequence.js

@@ -51,9 +51,9 @@ const CDNASequence = observer(function CDNASequence({ cds, exons, sequence, upst
     }
     // The stretches of the feature its own exons do not reach. Real annotations
     // produce them: CAT/liftoff emits a transcript spanning the source alignment
-    // with exons only where the CDS is supported, so KCNT2 in
-    // `hprc_cfhr_HG00099.1.genes.gff3.gz` runs 10,207 bp past its first exon and
-    // 28 of that corpus's 438 transcripts do the same.
+    // with exons only where the CDS is supported, so KCNT2 in HG00099.1's HPRC CAT
+    // annotation runs 10,207 bp past its first exon, and 28 of the 438 transcripts
+    // around CFH do the same.
     //
     // Uncolored, like the inter-exon gaps they are — the annotation does not call
     // them exonic, so stretching the first and last exon over them (which is what

package/esm/BaseFeatureWidget/SequenceFeatureDetails/useSequenceData.js

@@ -18,13 +18,16 @@ function processFeatureData(children, feature) {
     // translations if included)
     const featureType = feature.type?.toLowerCase();
     const isMatureProteinRegion = featureType === 'mature_protein_region_of_cds';
+    const ofType = (type) => children.filter(sub => sub.type?.toLowerCase() === type);
+    // A frameshift polyprotein's CDS carries its reading frames as CDS rows beside
+    // its cleavage products; a single-frame one has only the products.
+    const codingRows = ofType('cds');
     const cds = isMatureProteinRegion
         ? [{ start: 0, end: feature.end - feature.start, type: 'CDS' }]
-        : filterSuccessiveElementsWithSameStartAndEndCoord(children.filter(sub => {
-            const type = sub.type?.toLowerCase();
-            return type === 'cds' || type === 'mature_protein_region_of_cds';
-        }));
-    const exons = filterSuccessiveElementsWithSameStartAndEndCoord(children.filter(sub => sub.type?.toLowerCase() === 'exon'));
+        : filterSuccessiveElementsWithSameStartAndEndCoord(codingRows.length > 0
+            ? codingRows
+            : ofType('mature_protein_region_of_cds'));
+    const exons = filterSuccessiveElementsWithSameStartAndEndCoord(ofType('exon'));
     // annotated UTRs are deliberately not read: a UTR is just the exonic sequence
     // outside the CDS, so the renderer derives the split from cds+exons. Trusting
     // the annotation meant a transcript that named only one of its UTRs lost the

package/esm/BaseFeatureWidget/stateModelFactory.d.ts

@@ -1,6 +1,7 @@
 import type PluginManager from '../PluginManager.ts';
 import type { AnyConfigurationModel } from '../configuration/index.ts';
 import type { ParentFeatureSummary, SimpleFeatureSerialized } from '../util/index.ts';
+import type { CanonicalTranscripts } from '../util/isoformRank.ts';
 import type { SequenceHoverPosition } from './SequenceFeatureDetails/model.ts';
 import type { FormatDetailsTiers } from './formatDetails.ts';
 import type { Descriptors, MaybeSerializedFeat } from './types.tsx';
@@ -88,6 +89,12 @@ export declare function stateModelFactory(pluginManager: PluginManager): import(
         feature?: SimpleFeatureSerialized;
         error?: Error;
     };
+    /**
+     * #getter
+     * the isoform tags the open track's display ranks by, so the sequence
+     * panel opens on the transcript the track draws first
+     */
+    readonly canonicalTranscripts: CanonicalTranscripts;
     /**
      * #getter
      * levels of subfeature card the panel renders; unset means no limit

package/esm/BaseFeatureWidget/stateModelFactory.js

@@ -1,6 +1,7 @@
 import { getEnv, isStateTreeNode, types } from '@jbrowse/mobx-state-tree';
 import { hydrateTrackConfig } from '../configuration/index.js';
 import { getSession } from '../util/index.js';
+import { DEFAULT_CANONICAL_TRANSCRIPTS, isCanonicalTranscriptsHost, } from '../util/isoformRank.js';
 import { ElementId } from '../util/types/mst.js';
 import { SequenceFeatureDetailsF } from './SequenceFeatureDetails/model.js';
 import { applyFormatDetails, formatDetailsNumber } from './formatDetails.js';
@@ -116,6 +117,16 @@ export function stateModelFactory(pluginManager) {
                 return { error };
             }
         },
+        /**
+         * #getter
+         * the isoform tags the open track's display ranks by, so the sequence
+         * panel opens on the transcript the track draws first
+         */
+        get canonicalTranscripts() {
+            const track = self.track;
+            return (track?.displays.find(isCanonicalTranscriptsHost)
+                ?.canonicalTranscripts ?? DEFAULT_CANONICAL_TRANSCRIPTS);
+        },
         /**
          * #getter
          * levels of subfeature card the panel renders; unset means no limit

package/esm/BaseFeatureWidget/types.d.ts

@@ -1,4 +1,5 @@
 import type { MenuItem } from '../ui/MenuTypes.ts';
+import type { CanonicalTranscripts } from '../util/isoformRank.ts';
 import type { SimpleFeatureSerialized } from '../util/simpleFeature.ts';
 import type { SequenceFeatureDetailsModel, SequenceHoverTarget } from './SequenceFeatureDetails/model.ts';
 import type { IStateTreeNode } from '@jbrowse/mobx-state-tree';
@@ -9,6 +10,7 @@ export interface FeatureDetailsModel extends IStateTreeNode, SequenceHoverTarget
     view: {
         assemblyNames: string[];
     } | undefined;
+    canonicalTranscripts?: CanonicalTranscripts;
 }
 export interface Descriptors {
     [key: string]: React.ReactNode | Descriptors;

package/esm/CorePlugin.js

@@ -1,10 +1,40 @@
+import { trackTypeForAdapter } from '@jbrowse/add-track-core';
 import { configSchema, stateModelFactory } from './BaseFeatureWidget/index.js';
 import Plugin from './Plugin.js';
 import CytobandAdapterF from './data_adapters/CytobandAdapter/index.js';
 import WidgetType from './pluggableElementTypes/WidgetType.js';
 import * as coreRpcMethods from './rpc/coreRpcMethods.js';
-import { installFormatGuessers } from './util/formatGuessers.js';
+import { guessTrackConfFromTable } from './util/formatGuessers.js';
+import { getFileName } from './util/getFileName.js';
 import { lazyWithPreload } from './util/lazyWithPreload.js';
+import { addAdapterGuesser, addTrackTypeGuesser } from './util/tracks.js';
+/**
+ * Guess every format `@jbrowse/add-track-core`'s table describes — the same
+ * table `@jbrowse/cli`'s `add-track` reads, so a file resolves to the same
+ * adapter config in the app and on the command line.
+ *
+ * Whether a build can open a format is decided by `hasAdapterType`, not by the
+ * table: guessing `BamAdapter` in a build with no alignments plugin writes a
+ * track config that fails at render. A plugin therefore registers its adapters
+ * and nothing else — there is no format list to keep in step. ADR-077.
+ *
+ * `CorePlugin` installs this first, so any `addAdapterGuesser` a plugin
+ * registers is later in the chain and wins over the table. That is how a format
+ * the table cannot express is added, and how a third-party plugin claims one.
+ */
+// #region installFormatGuessers
+function installFormatGuessers(pluginManager) {
+    addAdapterGuesser(pluginManager, (file, index, adapterHint) => {
+        const adapter = guessTrackConfFromTable(file, index, adapterHint)?.adapter;
+        return adapter && pluginManager.hasAdapterType(adapter.type)
+            ? adapter
+            : undefined;
+    });
+    addTrackTypeGuesser(pluginManager, (adapterName, file) => pluginManager.hasAdapterType(adapterName)
+        ? trackTypeForAdapter(adapterName, file && getFileName(file))
+        : undefined);
+}
+// #endregion
 // the core plugin, which registers types that ALL JBrowse applications are
 // expected to need.
 export default class CorePlugin extends Plugin {
@@ -19,6 +49,7 @@ export default class CorePlugin extends Plugin {
         pluginManager.addWidgetType(() => {
             return new WidgetType({
                 name: 'BaseFeatureWidget',
+                discardOnClose: true,
                 heading: 'Feature details',
                 configSchema,
                 stateModel: stateModelFactory(pluginManager),

package/esm/PluginManager.d.ts

@@ -375,9 +375,12 @@ export default class PluginManager {
      * frozen object, so a hit can only ever come from this same instance and this
      * same track type. See ADR-031.
      *
-     * The node is never mutated: admin edits replace the frozen entry (new
-     * identity drops the WeakMap entry), and a non-admin's edits go to a private
-     * session working copy, not here (ADR-032). Both levels are `WeakMap`s so
+     * The node is never mutated: every edit goes to a private session working
+     * copy, not here, and is stored as a delta whose merged config is a new
+     * object (ADR-032). In a session composing `SessionTracksManagerSessionMixin`,
+     * which every product does, `track.configuration` resolves to that working
+     * copy, so this memo serves `hydrateTrackConfig` and sessions without the
+     * mixin. Both levels are `WeakMap`s so
      * entries collect normally — no manual invalidation needed, which is why this
      * is a memo and not a cache with a lifecycle to expose.
      */

package/esm/PluginManager.js

@@ -155,9 +155,12 @@ export default class PluginManager {
      * frozen object, so a hit can only ever come from this same instance and this
      * same track type. See ADR-031.
      *
-     * The node is never mutated: admin edits replace the frozen entry (new
-     * identity drops the WeakMap entry), and a non-admin's edits go to a private
-     * session working copy, not here (ADR-032). Both levels are `WeakMap`s so
+     * The node is never mutated: every edit goes to a private session working
+     * copy, not here, and is stored as a delta whose merged config is a new
+     * object (ADR-032). In a session composing `SessionTracksManagerSessionMixin`,
+     * which every product does, `track.configuration` resolves to that working
+     * copy, so this memo serves `hydrateTrackConfig` and sessions without the
+     * mixin. Both levels are `WeakMap`s so
      * entries collect normally — no manual invalidation needed, which is why this
      * is a memo and not a cache with a lifecycle to expose.
      */