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

package/esm/util/analytics.js

@@ -1,6 +1,7 @@
 import { effectiveRenderer, getGraphicsCapabilities, } from '@jbrowse/render-core/graphicsCapabilities';
 import { readConfObject } from '../configuration/index.js';
 import { isElectron, rIC } from '../util/index.js';
+import { getConfAssemblyNamesOrNone } from './tracks.js';
 // Both writers are fire-and-forget from several call sites, so they swallow
 // their own failures rather than rejecting: a floating rejected promise trips
 // the webpack-dev-server overlay (it listens for unhandledrejection), and an
@@ -8,7 +9,7 @@ import { isElectron, rIC } from '../util/index.js';
 export async function writeAWSAnalytics(rootModel, initialTimestamp, sessionQuery) {
     try {
         const url = 'https://analytics.jbrowse.org/api/v1';
-        const multiAssemblyTracks = rootModel.jbrowse.tracks.filter(track => readConfObject(track, 'assemblyNames').length > 1).length;
+        const multiAssemblyTracks = rootModel.jbrowse.tracks.filter(track => getConfAssemblyNamesOrNone(track).length > 1).length;
         // The rung createGpuHal built where a display has built one by idle time,
         // else the ladder's prediction with any page-wide pin applied — so a
         // session that fell back to Canvas2D is counted as Canvas2D rather than as
@@ -138,7 +139,8 @@ export function doAnalytics(rootModel, initialTimestamp, initialSessionQuery) {
 // `[data-app-phase="ready"]`, or a timeout for a page that never shows one
 // (Desktop's start screen)
 function afterAppReady(callback, maxWaitMs = 10_000) {
-    const isReady = () => document.querySelector('[data-app-phase="ready"]') !== null;
+    const doc = document;
+    const isReady = () => doc.querySelector('[data-app-phase="ready"]') !== null;
     if (isReady()) {
         callback();
         return;
@@ -158,7 +160,7 @@ function afterAppReady(callback, maxWaitMs = 10_000) {
         }
     });
     const timer = setTimeout(finish, maxWaitMs);
-    observer.observe(document.body, {
+    observer.observe(doc.body, {
         subtree: true,
         childList: true,
         attributeFilter: ['data-app-phase'],

package/esm/util/bezierConnector.js

@@ -19,6 +19,9 @@ const SPAN_FACTOR = 0.3;
 // its leading end: unbounded, that hook grows with the arc, and a full-width
 // inversion flings a ~500px curl back across unrelated reads.
 const MAX_HANDLE_PX = 200;
+// The handles are horizontal, so a tall vertical gap (stacked split-view
+// panels) only widens the sideways bulge; past this height it earns no more.
+const MAX_VERTICAL_SPAN_PX = 150;
 // A symmetric cubic's extreme sits 3/4 of the way from its baseline to its
 // control points, so an arc asked to reach a given apex puts its controls 4/3
 // past it. Exported because the sashimi overlay solves the same equation in the
@@ -62,7 +65,8 @@ function tangentSign(strand, leading, reversed) {
 // How much shaping (handle length, bow height) this curve may spend: a fraction
 // of the distance it has to cover.
 function shapingBudget(p1, p2) {
-    return Math.hypot(p2.x - p1.x, p2.y - p1.y) * SPAN_FACTOR;
+    const dy = Math.min(Math.abs(p2.y - p1.y), MAX_VERTICAL_SPAN_PX);
+    return Math.hypot(p2.x - p1.x, dy) * SPAN_FACTOR;
 }
 // Fades to zero as the endpoints' rows separate, since a cross-row curve
 // already has vertical extent — and via the budget as they close in

package/esm/util/categoricalField.d.ts

@@ -1,3 +1,4 @@
+import type { HeldSlots } from '../ui/colors.ts';
 /** #api */
 export declare const STRAND_FIELD = "strand";
 /**
@@ -19,7 +20,9 @@ export declare const NO_VALUE_LABEL = "(no value)";
  * orders keys (the `domain` first, the rest by `compareGroupKeys`, `''`
  * after them), `label` names a key in a legend, `sectionLabel` on a chip, and
  * `color` paints it. A key's color depends only on the key and the
- * declaration, so every region agrees on it.
+ * declaration, so every region agrees on it, except that a field dealing its
+ * colors (`categoricalField`'s `held`) also steps a key off the colors of the
+ * keys met before it.
  */
 export interface CategoricalField {
     field: string;
@@ -47,10 +50,27 @@ export declare function keyNames(keys: readonly unknown[], labels?: readonly str
 /**
  * #api
  * `labels` names the `domain`'s values in a key, one each in order, where a
- * config spells them for a reader rather than as the data does.
+ * config spells them for a reader rather than as the data does. `held` deals
+ * each key the domain does not list a color of its own on first sight
+ * (`categoricalScale`); the caller keeps it for as long as the colors should
+ * hold.
  */
-export declare function categoricalField(field: string, { domain, range, labels, }?: {
+export declare function categoricalField(field: string, { domain, range, labels, held, }?: {
     domain?: readonly string[];
     range?: readonly string[];
     labels?: readonly string[];
+    held?: HeldSlots;
 }): CategoricalField;
+/**
+ * #api
+ * Deals `keys` their colours in `field.compare` order, so the colours a set
+ * of keys first seen together takes do not depend on the order they arrive
+ * in. A no-op for a field that deals nothing.
+ */
+export declare function dealKeyColors(field: CategoricalField, keys: Iterable<string>): void;
+/**
+ * #api
+ * The `HeldSlots` `owner` keeps under `key`, made empty on first ask. Lives as
+ * long as `owner` and is never persisted, so a reload deals afresh.
+ */
+export declare function heldSlotsOf(owner: object, key: string): HeldSlots;

package/esm/util/categoricalField.js

@@ -37,9 +37,12 @@ export function keyNames(keys, labels = []) {
 /**
  * #api
  * `labels` names the `domain`'s values in a key, one each in order, where a
- * config spells them for a reader rather than as the data does.
+ * config spells them for a reader rather than as the data does. `held` deals
+ * each key the domain does not list a color of its own on first sight
+ * (`categoricalScale`); the caller keeps it for as long as the colors should
+ * hold.
  */
-export function categoricalField(field, { domain = [], range = [], labels = [], } = {}) {
+export function categoricalField(field, { domain = [], range = [], labels = [], held, } = {}) {
     // a field with a vocabulary of its own reads it on every channel, a facet's
     // sections as well as a colour's key
     const vocabulary = universalPresetOf(field);
@@ -66,8 +69,38 @@ export function categoricalField(field, { domain = [], range = [], labels = [],
             if (key === '') {
                 return NO_CATEGORY_COLOR;
             }
-            colorOf ??= categoricalColorScale(paired, colors);
+            colorOf ??= categoricalColorScale(paired, colors, held);
             return colorOf(key);
         },
     };
 }
+/**
+ * #api
+ * Deals `keys` their colours in `field.compare` order, so the colours a set
+ * of keys first seen together takes do not depend on the order they arrive
+ * in. A no-op for a field that deals nothing.
+ */
+export function dealKeyColors(field, keys) {
+    for (const key of [...new Set(keys)].sort(field.compare)) {
+        field.color(key);
+    }
+}
+const heldByOwner = new WeakMap();
+/**
+ * #api
+ * The `HeldSlots` `owner` keeps under `key`, made empty on first ask. Lives as
+ * long as `owner` and is never persisted, so a reload deals afresh.
+ */
+export function heldSlotsOf(owner, key) {
+    let byKey = heldByOwner.get(owner);
+    if (byKey === undefined) {
+        byKey = new Map();
+        heldByOwner.set(owner, byKey);
+    }
+    let held = byKey.get(key);
+    if (held === undefined) {
+        held = new Map();
+        byKey.set(key, held);
+    }
+    return held;
+}

package/esm/util/cellMatches.js

@@ -1,8 +1,9 @@
 // A `cells` step, the interval `bin` behind it and the `aggregate` of its
 // matches as one walk over the rows' bytes, which `runSteps` in
 // featureTransforms.ts reaches by relative path only.
+import { DASH, SPACE, firstDrawn, isGapByte, lastDrawn, } from './alignedBytes.js';
 import { fusesBinAggregate } from './binnedAggregate.js';
-import { DASH, DEFAULT_CELLS_FIELD, MATCH, MISMATCH, NO_STATE, SPACE, cellState, firstDrawn, isGapByte, lastDrawn, walkedTexts, } from './cellsStep.js';
+import { DEFAULT_CELLS_FIELD, MATCH, NO_STATE, cellState, comparesBase, opensRun, runKey, walkedTexts, } from './cellsStep.js';
 import { numberReaderOf, readerOf } from './featureTable.js';
 import { BIN_OVERLAP_FIELD, DEFAULT_BIN_AS, OpSums, groupKey, madeGroups, } from './stepTables.js';
 const isEdges = (pair) => pair?.length === 2 && pair[0] === 'start' && pair[1] === 'end';
@@ -97,10 +98,10 @@ class SectionBins {
     }
     /**
      * One row's runs as `cells` writes them, each met by its bins as the bin
-     * step cuts it and in the order the lanes hold them: a run when the next
-     * column's state differs, an insertion at the reference base after it,
-     * ahead of the run still open. The bases a run of matches or mismatches
-     * holds are counted in their bins as the walk passes them.
+     * step cuts it and in the order the lanes hold them: a run where the next
+     * column `opensRun`, an insertion at the reference base after it,
+     * ahead of the run still open. The compared bases a run holds are counted
+     * in their bins as the walk passes them.
      */
     walk(r, startPos, size, rowBytes, rowAt, rowLen, refBytes, refAt, refLen) {
         const { matched, compared, low } = this;
@@ -114,7 +115,7 @@ class SectionBins {
         let runOpen = false;
         let runBin = 0;
         let runState = NO_STATE;
-        let runBase = -1;
+        let openKey = -1;
         let inserting = false;
         for (let col = 0; col < refLen; col++) {
             const refByte = refBytes[refAt + col];
@@ -130,22 +131,21 @@ class SectionBins {
                 inserting = false;
             }
             const st = cellState(refByte, rowByte, col >= first && col <= last && col < rowLen);
-            const base = st === MISMATCH ? rowByte : -1;
-            if (st !== runState || base !== runBase) {
+            const key = runKey(st, refByte);
+            if (opensRun(st, key, runState, openKey)) {
                 if (runOpen) {
                     this.touch(runBin, pos > edge - size ? bin : bin - 1, r);
                 }
                 runOpen = st !== NO_STATE;
                 runBin = bin;
                 runState = st;
-                runBase = base;
+                openKey = key;
             }
-            if (st === MATCH) {
-                m++;
-                c++;
-            }
-            else if (st === MISMATCH) {
+            if (comparesBase(st, refByte)) {
                 c++;
+                if (st === MATCH) {
+                    m++;
+                }
             }
             pos++;
             if (pos === edge) {

package/esm/util/cellsStep.d.ts

@@ -2,15 +2,13 @@ import type { FeatureTable, TextColumn } from './featureTable.ts';
 import type { CellsStep } from './markEncodingTypes.ts';
 import type { Staged } from './stepTables.ts';
 export declare const DEFAULT_CELLS_FIELD = "seq";
-export declare const DASH = 45;
-export declare const SPACE = 32;
 export declare const MATCH = 0;
 export declare const MISMATCH = 1;
 export declare const NO_STATE = 255;
-export declare function isGapByte(b: number): b is 32 | 45;
-export declare function firstDrawn(bytes: Uint8Array, at: number, len: number): number;
-export declare function lastDrawn(bytes: Uint8Array, at: number, len: number, first: number): number;
 export declare function cellState(refByte: number, rowByte: number, drawn: boolean): 0 | 1 | 2 | 255;
+export declare function comparesBase(state: number, refByte: number): boolean;
+export declare function runKey(state: number, refByte: number): 0 | 1;
+export declare function opensRun(state: number, key: number, runState: number, openKey: number): boolean;
 /**
  * The texts a `cells` walk reads, by the row of the table it walked: each
  * row's own, and the reference it is read against, which a row fanned out of

package/esm/util/cellsStep.js

@@ -1,38 +1,16 @@
 // The `cells` step: each row's runs against the reference it was fanned out
 // of, and the texts its walk reads, which the fused identity kernel in
 // cellMatches.ts walks too. Imported by relative path only.
+import { DASH, SPACE, firstDrawn, isGapByte, isUnknownBase, lastDrawn, sameBase, } from './alignedBytes.js';
 import { DerivedTable, numberReaderOf, readerOf, valueAt, } from './featureTable.js';
 import { FannedTable, boundsThrough } from './stepTables.js';
 export const DEFAULT_CELLS_FIELD = 'seq';
-export const DASH = 45;
-export const SPACE = 32;
-const LOWER_BIT = 0x20;
 const CELL_STATES = ['match', 'mismatch', 'gap', 'insertion'];
 export const MATCH = 0;
 export const MISMATCH = 1;
 const GAP = 2;
 const INSERTION = 3;
 export const NO_STATE = 255;
-export function isGapByte(b) {
-    return b === DASH || b === SPACE;
-}
-// The columns carrying the row's own sequence: a gap run reaching either end
-// of the row measures where the block was cut, not the alignment, so it is no
-// cell either.
-export function firstDrawn(bytes, at, len) {
-    let first = 0;
-    while (first < len && isGapByte(bytes[at + first])) {
-        first++;
-    }
-    return first;
-}
-export function lastDrawn(bytes, at, len, first) {
-    let last = len - 1;
-    while (last > first && isGapByte(bytes[at + last])) {
-        last--;
-    }
-    return last;
-}
 // A reference base's cell: no state outside the drawn columns, else the row's
 // gap, or its base matched or not regardless of case.
 export function cellState(refByte, rowByte, drawn) {
@@ -40,10 +18,25 @@ export function cellState(refByte, rowByte, drawn) {
         ? NO_STATE
         : isGapByte(rowByte)
             ? GAP
-            : (refByte | LOWER_BIT) === (rowByte | LOWER_BIT)
+            : sameBase(refByte, rowByte)
                 ? MATCH
                 : MISMATCH;
 }
+// Whether a cell counts toward identity: matched or not against a known
+// reference base.
+export function comparesBase(state, refByte) {
+    return state <= MISMATCH && !isUnknownBase(refByte);
+}
+// What the cells of one run share besides their state: whether they are
+// compared, so a run's `match` is one value.
+export function runKey(state, refByte) {
+    return state <= MISMATCH && isUnknownBase(refByte) ? 1 : 0;
+}
+// A mismatch always starts a run of its own, so each differing base is one
+// instance and a text over `base` letters every one.
+export function opensRun(state, key, runState, openKey) {
+    return state !== runState || key !== openKey || state === MISMATCH;
+}
 // The row a cell step reads against: past any table that only reordered or
 // annotated the rows, the one they were fanned out of.
 function containerOf(table) {
@@ -218,7 +211,11 @@ class CellTable extends DerivedTable {
                     const values = new Float32Array(this.length);
                     for (let i = 0; i < this.length; i++) {
                         const s = this.state[i];
-                        values[i] = s === MATCH ? 1 : s === MISMATCH ? 0 : Number.NaN;
+                        values[i] = comparesBase(s, this.refByte(i))
+                            ? s === MATCH
+                                ? 1
+                                : 0
+                            : Number.NaN;
                     }
                     return { kind: 'number', values, at: undefined, nanIsAbsent: true };
                 });
@@ -254,6 +251,11 @@ class CellTable extends DerivedTable {
             }
         }
     }
+    refByte(i) {
+        const { reference: ref } = this.texts;
+        const f = this.texts.refOf(this.parentOf(i));
+        return ref.bytes[ref.offset[f] + this.textAt[i]];
+    }
     mismatched(i) {
         const { bytes, offset } = this.texts.row;
         const k = this.texts.rowOf(this.parentOf(i));
@@ -342,7 +344,7 @@ class RunLanes {
         const last = lastDrawn(rowBytes, rowAt, rowLen, first);
         let runStart = -1;
         let runState = NO_STATE;
-        let runBase = -1;
+        let openKey = -1;
         let runCol = 0;
         let insertAt = -1;
         for (let col = 0; col < refLen; col++) {
@@ -364,8 +366,8 @@ class RunLanes {
                 insertAt = -1;
             }
             const st = cellState(refByte, rowByte, col >= first && col <= last && col < rowLen);
-            const base = st === MISMATCH ? rowByte : -1;
-            if (st !== runState || base !== runBase) {
+            const key = runKey(st, refByte);
+            if (opensRun(st, key, runState, openKey)) {
                 if (runStart >= 0) {
                     start[n] = runStart;
                     end[n] = pos;
@@ -376,7 +378,7 @@ class RunLanes {
                 }
                 runStart = st === NO_STATE ? -1 : pos;
                 runState = st;
-                runBase = base;
+                openKey = key;
                 runCol = col;
             }
             pos++;

package/esm/util/color-bits/parse.js

@@ -239,16 +239,27 @@ export function parseColor(color) {
     }
     throw new Error(`Color.parse(): invalid CSS color: "${color}"`);
 }
+/** A channel's leading number, throwing where it has none, as `rgb(a,b,1)`. */
+function parseNumber(value) {
+    const n = Number.parseFloat(value);
+    if (Number.isNaN(n)) {
+        throw new TypeError(`Color.parse(): invalid CSS color channel: "${value}"`);
+    }
+    return n;
+}
 /**
- * Accepts: "50%", "128"
+ * Accepts: "50%", "128", "none"
  * https://developer.mozilla.org/en-US/docs/Web/CSS/color_value/rgb#values
  * @returns a value in the 0 to 255 range
  */
 function parseColorChannel(channel) {
+    if (channel === 'none') {
+        return 0;
+    }
     if (channel.charCodeAt(channel.length - 1) === PERCENT) {
-        return Math.round((Number.parseFloat(channel) / 100) * 255);
+        return Math.round((parseNumber(channel) / 100) * 255);
     }
-    return Math.round(Number.parseFloat(channel));
+    return Math.round(parseNumber(channel));
 }
 /**
  * Accepts: "50%", ".5", "0.5"
@@ -268,9 +279,9 @@ function parseAlphaValue(channel) {
         return 0;
     }
     if (channel.charCodeAt(channel.length - 1) === PERCENT) {
-        return Number.parseFloat(channel) / 100;
+        return parseNumber(channel) / 100;
     }
-    return Number.parseFloat(channel);
+    return parseNumber(channel);
 }
 /**
  * Accepts: "360", "360deg", "400grad", "6.28rad", "1turn", "none"
@@ -302,7 +313,7 @@ function parseAngle(angle) {
             factor = 360;
         }
     }
-    const turns = Number.parseFloat(angle) / factor;
+    const turns = parseNumber(angle) / factor;
     // Hue is periodic, and every caller of this is a hue. `hueToRGB` corrects its
     // argument by at most one turn, so it reads `hsl(-720deg)` as a hue two turns
     // below the wheel rather than as red — folding here is what makes the three
@@ -317,7 +328,7 @@ function parsePercentage(value) {
     if (value.charCodeAt(0) === N) {
         return 0;
     }
-    return Number.parseFloat(value) / 100;
+    return parseNumber(value) / 100;
 }
 /**
  * Accepts: "1.0", "100%", "none"
@@ -328,9 +339,9 @@ function parsePercentageOrValue(value) {
         return 0;
     }
     if (value.charCodeAt(value.length - 1) === PERCENT) {
-        return Number.parseFloat(value) / 100;
+        return parseNumber(value) / 100;
     }
-    return Number.parseFloat(value);
+    return parseNumber(value);
 }
 /**
  * Accepts: "100", "100%", "none"
@@ -341,9 +352,9 @@ function parsePercentageFor(value, range) {
         return 0;
     }
     if (value.charCodeAt(value.length - 1) === PERCENT) {
-        return (Number.parseFloat(value) / 100) * range;
+        return (parseNumber(value) / 100) * range;
     }
-    return Number.parseFloat(value);
+    return parseNumber(value);
 }
 // HSL functions
 function hueToRGB(p, q, t) {

package/esm/util/colorRamp.js

@@ -90,6 +90,11 @@ const PURPLEORANGE_STOPS = [
     [179, 88, 6, 255],
     [127, 59, 8, 255],
 ];
+const REDGREYBLUE_STOPS = [
+    [199, 67, 56, 255],
+    [140, 140, 140, 255],
+    [47, 102, 176, 255],
+];
 const SCHEME_STOPS = {
     viridis: VIRIDIS_STOPS,
     juicebox: JUICEBOX_STOPS,
@@ -101,6 +106,7 @@ const SCHEME_STOPS = {
     cividis: stopsFromHex(CIVIDIS_HEX_SPEC),
     redblue: REDBLUE_STOPS,
     purpleorange: PURPLEORANGE_STOPS,
+    redgreyblue: REDGREYBLUE_STOPS,
 };
 function luminanceOverWhite([r, g, b, a]) {
     const over = (c) => 255 + (c - 255) * (a / 255);

package/esm/util/colorScale.d.ts

@@ -36,8 +36,8 @@ export interface FieldPreset<S extends string = ColorScaleName> {
 export type FieldPresets<S extends string = ColorScaleName> = Readonly<Record<string, FieldPreset<S>>>;
 /**
  * The fields whose values have names, an order and colours of their own on
- * every display, beneath each display's own presets. Red forward and blue
- * reverse is what the synteny ribbons paint too. The SV classes are
+ * every display, beneath each display's own presets. The synteny ribbons
+ * paint strand from this range too. The SV classes are
  * `svClassOf`'s, deletion red and duplication blue as dbVar and gnomAD-SV
  * paint them, insertion the pileup's purple, and the rest kept apart under
  * deuteranopia and protanopia. A record with no class files under `''`, so
@@ -143,6 +143,13 @@ export interface ColorSlots {
     domainQuantile?: number;
     labels?: readonly unknown[];
 }
+/** A quantitative scale's ends among the members `member` reads, each a number or unset. */
+export declare function scaleEndsOf(member: (name: string) => unknown): ScaleEnds;
+/**
+ * The members `colorProblems` reads among the ones `member` reads, each of the
+ * type it reads or unset, so a config snapshot and a config node answer alike.
+ */
+export declare function colorSlotsOf(member: (name: string) => unknown): ColorSlots;
 /**
  * What a colour object's slots say together that no single slot can refuse,
  * since the config editor writes one slot at a time (ADR-133), read with its

package/esm/util/colorScale.js

@@ -20,8 +20,8 @@ export const IDENTITY_SCALE = 'identity';
 const CATEGORICAL_PRESET = { scale: 'categorical' };
 /**
  * The fields whose values have names, an order and colours of their own on
- * every display, beneath each display's own presets. Red forward and blue
- * reverse is what the synteny ribbons paint too. The SV classes are
+ * every display, beneath each display's own presets. The synteny ribbons
+ * paint strand from this range too. The SV classes are
  * `svClassOf`'s, deletion red and duplication blue as dbVar and gnomAD-SV
  * paint them, insertion the pileup's purple, and the rest kept apart under
  * deuteranopia and protanopia. A record with no class files under `''`, so
@@ -165,6 +165,37 @@ export function scaleEndProblems({ domainMin, domainMax, domainQuantile }, { rev
 export function noticeLines(setting, problems) {
     return problems.map(({ slot, message }) => `${setting}.${slot}: ${message}`);
 }
+function numberOf(value) {
+    return typeof value === 'number' ? value : undefined;
+}
+function stringOf(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function listOf(value) {
+    return Array.isArray(value) ? value : undefined;
+}
+/** A quantitative scale's ends among the members `member` reads, each a number or unset. */
+export function scaleEndsOf(member) {
+    return {
+        domainMin: numberOf(member('domainMin')),
+        domainMax: numberOf(member('domainMax')),
+        domainQuantile: numberOf(member('domainQuantile')),
+    };
+}
+/**
+ * The members `colorProblems` reads among the ones `member` reads, each of the
+ * type it reads or unset, so a config snapshot and a config node answer alike.
+ */
+export function colorSlotsOf(member) {
+    return {
+        ...scaleEndsOf(member),
+        field: stringOf(member('field')) ?? '',
+        scale: stringOf(member('scale')),
+        domain: listOf(member('domain')),
+        range: listOf(member('range')),
+        labels: listOf(member('labels')),
+    };
+}
 function pinned(entry) {
     return entry !== '' && Number.isFinite(Number(entry));
 }

package/esm/util/colorSchemes.d.ts

@@ -7,9 +7,11 @@
  * transparent to red, as Juicebox paints contacts; `fall` runs white through
  * yellow and red to black, as HiGlass does; `reds` and `blues` are
  * ColorBrewer's, from white; `redblue` and `purpleorange` diverge through
- * white, ColorBrewer's RdBu and PuOr.
+ * white, ColorBrewer's RdBu and PuOr; `redgreyblue` diverges through a grey
+ * middle, which stays visible on a white page where a white middle would not,
+ * as the MAF display's identity ramp paints it.
  */
-export declare const COLOR_SCHEMES: readonly ['viridis', 'magma', 'inferno', 'cividis', 'juicebox', 'fall', 'reds', 'blues', 'redblue', 'purpleorange'];
+export declare const COLOR_SCHEMES: readonly ['viridis', 'magma', 'inferno', 'cividis', 'juicebox', 'fall', 'reds', 'blues', 'redblue', 'purpleorange', 'redgreyblue'];
 /** #api */
 export type ColorSchemeName = (typeof COLOR_SCHEMES)[number];
 /**

package/esm/util/colorSchemes.js

@@ -7,7 +7,9 @@
  * transparent to red, as Juicebox paints contacts; `fall` runs white through
  * yellow and red to black, as HiGlass does; `reds` and `blues` are
  * ColorBrewer's, from white; `redblue` and `purpleorange` diverge through
- * white, ColorBrewer's RdBu and PuOr.
+ * white, ColorBrewer's RdBu and PuOr; `redgreyblue` diverges through a grey
+ * middle, which stays visible on a white page where a white middle would not,
+ * as the MAF display's identity ramp paints it.
  */
 export const COLOR_SCHEMES = [
     'viridis',
@@ -20,6 +22,7 @@ export const COLOR_SCHEMES = [
     'blues',
     'redblue',
     'purpleorange',
+    'redgreyblue',
 ];
 /**
  * #api

package/esm/util/isoformRank.d.ts

@@ -0,0 +1,39 @@
+import type { Feature, SimpleFeatureSerializedNoId } from './simpleFeature.ts';
+/**
+ * Which isoform of a gene a display shows first: the canvas gene glyph's
+ * `longestCoding` collapse and the sequence panel's default transcript both
+ * rank with this, so the panel opens on the isoform the track drew. Generic
+ * over the feature shape because the worker ranks live `Feature`s and the
+ * panel ranks their serialized form.
+ */
+export interface IsoformReader<T> {
+    type: (feature: T) => string | undefined;
+    start: (feature: T) => number;
+    end: (feature: T) => number;
+    subfeatures: (feature: T) => readonly T[];
+    attribute: (feature: T, field: string) => unknown;
+}
+export declare const featureIsoformReader: IsoformReader<Feature>;
+export declare const serializedIsoformReader: IsoformReader<SimpleFeatureSerializedNoId>;
+/**
+ * The attribute naming a gene's representative isoform, and the values of it
+ * that do, best first. The canvas display's `canonicalTranscriptField` and
+ * `canonicalTranscriptTags` slots default to these.
+ */
+export interface CanonicalTranscripts {
+    field: string;
+    tags: readonly string[];
+}
+export declare const DEFAULT_CANONICAL_TRANSCRIPTS: CanonicalTranscripts;
+export interface IsoformScore {
+    canonical: number;
+    coding: boolean;
+    size: number;
+}
+export declare function isCodingIsoform<T>(read: IsoformReader<T>, feature: T): boolean;
+export declare function isoformScorer<T>(read: IsoformReader<T>, { field, tags }: CanonicalTranscripts): (feature: T) => IsoformScore;
+export declare function rankIsoforms<T>(isoforms: readonly T[], scoreOf: (feature: T) => IsoformScore): T[];
+export interface CanonicalTranscriptsHost {
+    canonicalTranscripts: CanonicalTranscripts;
+}
+export declare function isCanonicalTranscriptsHost(thing: unknown): thing is CanonicalTranscriptsHost;