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

package/esm/ui/colors.js

@@ -98,11 +98,9 @@ export const paletteColors = {
  * The wide qualitative palette: every scheme above, in order, deduped and with
  * the neutrals dropped. ~40 entries.
  *
- * One list, because "give each row a distinct color" is one question this repo
- * answers in two places — the multi-row painter handing colors out by row
- * index, and the arrangement dialog's palette-by-attribute — and two lists
- * would mean a track's automatic colors and the colors it takes when a user
- * palettes it by hand were different palettes for no reason a reader could see.
+ * A feature's categorical colour deals from it; a row's deals from
+ * `rowPaletteColorAt`, which re-lights tableau10 rather than reaching for
+ * another scheme's hues.
  *
  * `tableau10` leads because its hues are the most evenly separated, so a track
  * with a handful of rows spends only that. The tail is what makes the 26
@@ -114,21 +112,16 @@ export const paletteColors = {
  * re-palettes), while a by-position painter has no value to hash and wraps.
  *
  * **It holds 14 pairs `similarColors` calls the same** — five schemes' blues,
- * oranges, greens, reds and pinks — and deduping it at construction is the
- * wrong reading of that, measured on the 38 GENCODE gene biotypes. Hashed,
- * which is what a track with no `colorDomain` does, 30 of them land on 22
- * colors and 38 on 26; the loss is the birthday collision on 40 slots, not the
- * near-twins, and only 3 of the pairs they land on read alike. Pruning to the
- * 30 distinct entries makes that 23 and 24, so it costs ten colors and buys
- * nothing.
+ * oranges, greens, reds and pinks. A dealt scale (`categoricalScale`'s `held`)
+ * steps over a twin of a color already dealt, so they cost a track only once
+ * it has more values than the 30 distinct entries.
  *
- * The near-twins bite the PINNED case instead, where a `domain` spends the
- * list in order: 30 listed values take 30 colors today and 7 of those pairs
- * read alike. Ordering the distinct 30 first and the twins behind them fixes
- * that outright (0 pairs at 30 listed values, 11 at 38 where the twins are
- * reached anyway) and costs no colors — but it moves every hashed color in
- * marks, GWAS, canvas, multi-row and the arrangement dialog, so it is a pass
- * with a figure refresh in it.
+ * The near-twins bite a `domain` instead, which spends the list in order: 30
+ * listed values take 30 colors and 7 of those pairs read alike. Ordering the
+ * distinct 30 first and the twins behind them fixes that outright (0 pairs at
+ * 30 listed values, 11 at 38 where the twins are reached anyway) and costs no
+ * colors — but it moves every hashed color in marks, GWAS, canvas, multi-row
+ * and the arrangement dialog, so it is a pass with a figure refresh in it.
  */
 export const categoricalPalette = [
     ...new Set([...tableau10, ...set1, ...dark2, ...set2, ...category10].filter(hex => !NEUTRALS.has(hex.toLowerCase()))),
@@ -159,19 +152,24 @@ function freeSlot(value, size, taken) {
     return slot;
 }
 /**
- * The categorical rule every scaled channel resolves through. With no
- * `domain` a value takes `categoricalValueColor`'s slot in `range`. With one,
- * the listed values take `range` in order, continuing into the `fallback`
- * entries `range` lacks past its end, and any other value takes a slot of the
- * whole list derived from itself that no listed value holds, nor one
- * `isNear` calls the same. A value's entry depends only on the value and the
- * declaration, so every region agrees on it, and adding a listed value moves
- * only the unlisted values on the slots it takes.
+ * The categorical rule every scaled channel resolves through. The values
+ * `domain` lists take `range` in order, continuing into the `fallback`
+ * entries `range` lacks past its end. Any other value takes the slot derived
+ * from itself (`categoricalValueColor`'s, with no `domain`) unless a listed
+ * value holds it or one `isNear` calls the same, and then another slot derived
+ * from itself.
+ *
+ * With `held`, a value is dealt once, on first sight: its slot avoids every
+ * slot `held` already records and their near twins as well, so values met
+ * together never share an entry while the list has room, and the slot is
+ * recorded so the value keeps it as others arrive. A value nothing else
+ * collides with keeps the entry it takes without `held`. With no `domain`, the
+ * deal spends `range` before spilling into the `fallback` entries it lacks.
  */
-export function categoricalScale(domain, range, { fallback = [], isNear, } = {}) {
+export function categoricalScale(domain, range, { fallback = [], isNear, held, } = {}) {
     const base = range.length ? range : fallback;
     const listed = [...new Set((domain ?? []).map(String))].filter(v => v !== '');
-    if (listed.length === 0) {
+    if (listed.length === 0 && !held) {
         return value => base[valueSlot(value, base.length)];
     }
     const seen = new Set(base.map(entryKey));
@@ -183,19 +181,44 @@ export function categoricalScale(domain, range, { fallback = [], isNear, } = {})
         }),
     ];
     const size = entries.length;
+    const twins = [];
+    const twinsOf = (slot) => (twins[slot] ??= entries.flatMap((entry, i) => i === slot || isNear?.(entries[slot], entry) ? [i] : []));
     const rank = new Map(listed.map((value, i) => [value, i]));
-    const listedSlots = new Set(listed.map((_, i) => i % size));
-    const taken = new Set(entries.flatMap((entry, i) => listedSlots.has(i) ||
-        (isNear && [...listedSlots].some(j => isNear(entries[j], entry)))
-        ? [i]
-        : []));
+    const listedTaken = new Set(listed.flatMap((_, i) => twinsOf(i % size)));
+    const tiers = listed.length > 0
+        ? [[0, size]]
+        : [[0, base.length], [base.length, size]];
+    const deal = (value, taken) => {
+        for (const [from, to] of tiers) {
+            const inTier = from === 0 && to === size
+                ? taken
+                : new Set([...taken].filter(s => s >= from && s < to).map(s => s - from));
+            if (inTier.size < to - from) {
+                return from + freeSlot(value, to - from, inTier);
+            }
+        }
+        return valueSlot(value, tiers[0][1]);
+    };
     return value => {
         const i = rank.get(value);
-        return entries[i !== undefined
-            ? i % size
-            : taken.size < size
-                ? freeSlot(value, size, taken)
-                : valueSlot(value, size)];
+        if (i !== undefined) {
+            return entries[i % size];
+        }
+        if (!held) {
+            return entries[deal(value, listedTaken)];
+        }
+        let slot = held.get(value);
+        if (slot === undefined) {
+            const taken = new Set(listedTaken);
+            for (const s of held.values()) {
+                for (const twin of twinsOf(s)) {
+                    taken.add(twin);
+                }
+            }
+            slot = deal(value, taken);
+            held.set(value, slot);
+        }
+        return entries[slot];
     };
 }
 const oklabByColor = new Map();
@@ -219,12 +242,14 @@ export function similarColors(a, b) {
 /**
  * `categoricalScale` for a color channel: `palette` (the wide palette when
  * empty) spent in `domain` order and continued into the wide palette, and an
- * unlisted value never on a listed value's color or one that reads the same.
+ * unlisted value never on a listed value's color or one that reads the same,
+ * nor, with `held`, on the color of a value met before it.
  */
-export function categoricalColorScale(domain, palette = []) {
+export function categoricalColorScale(domain, palette = [], held) {
     return categoricalScale(domain, palette, {
         fallback: categoricalPalette,
         isNear: similarColors,
+        held,
     });
 }
 const MAX_CACHED_SCALES = 16;
@@ -316,11 +341,23 @@ const PALETTE_LAP_TONES = [
     // and pinks all pin against the top of the sRGB gamut and converge there.
     { lightnessShift: 0.18, chromaScale: 0.8 },
 ];
+// The colour at `position` in `hexes`, each lap past the end re-lit.
+function lapColorAt(hexes, position) {
+    const hex = hexes[position % hexes.length];
+    const lap = PALETTE_LAP_TONES[Math.floor(position / hexes.length) % PALETTE_LAP_TONES.length];
+    return lap ? relight(hex, lap.lightnessShift, lap.chromaScale) : hex;
+}
 /** The palette color for a chromosome at `position` in its assembly. */
 export function refNamePaletteColorAt(position) {
-    const hex = refNameColorHexes[position % refNameColorHexes.length];
-    const lap = PALETTE_LAP_TONES[Math.floor(position / refNameColorHexes.length) % PALETTE_LAP_TONES.length];
-    return lap ? relight(hex, lap.lightnessShift, lap.chromaScale) : hex;
+    return lapColorAt(refNameColorHexes, position);
+}
+const rowColorHexes = tableau10.filter(hex => !NEUTRALS.has(hex));
+/**
+ * The colour the row palette deals the row or value at `position`: tableau10
+ * less its grey, then re-lit laps of it, as a karyotype's are.
+ */
+export function rowPaletteColorAt(position) {
+    return lapColorAt(rowColorHexes, position);
 }
 /**
  * The color a refName paints, BY POSITION IN THE ASSEMBLY where the caller

package/esm/ui/multiTrackMenuItems.d.ts

@@ -1,10 +1,10 @@
 import type PluginManager from '../PluginManager.ts';
-import type { AnyConfigurationModel } from '../configuration/index.ts';
+import type { AnyTrackConfig } from '../configuration/index.ts';
 import type { AbstractSessionModel } from '../util/types/index.ts';
 import type { MenuItem } from './MenuTypes.ts';
 import type { IStateTreeNode } from '@jbrowse/mobx-state-tree';
 export interface MultiTrackSelection extends IStateTreeNode {
-    selection: AnyConfigurationModel[];
+    selection: AnyTrackConfig[];
 }
 export interface MultiTrackMenuItemsProps {
     session: AbstractSessionModel;

package/esm/util/TimeTraveller.d.ts

@@ -9,10 +9,13 @@ declare const TimeTraveller: import("@jbrowse/mobx-state-tree").IModelType<{
 }, {
     history: unknown[];
     notTrackingUndo: boolean;
+    hasPendingRecord: boolean;
 } & {
     readonly canUndo: boolean;
     readonly canRedo: boolean;
 } & {
+    setHasPendingRecord(value: boolean): void;
+    flushPendingRecord(): void;
     stopTrackingUndo(): void;
     resumeTrackingUndo(): void;
     addUndoState(snapshot: unknown): void;

package/esm/util/TimeTraveller.js

@@ -14,13 +14,16 @@ const TimeTraveller = types
     .volatile(() => ({
     history: [],
     notTrackingUndo: false,
+    hasPendingRecord: false,
 }))
     .views(self => ({
     get canUndo() {
-        return self.undoIdx > 0 && !self.notTrackingUndo;
+        return ((self.undoIdx > 0 || self.hasPendingRecord) && !self.notTrackingUndo);
     },
     get canRedo() {
-        return self.undoIdx < self.history.length - 1 && !self.notTrackingUndo;
+        return (self.undoIdx < self.history.length - 1 &&
+            !self.hasPendingRecord &&
+            !self.notTrackingUndo);
     },
 }))
     .actions(self => {
@@ -93,7 +96,21 @@ const TimeTraveller = types
             skipNextUndoState = false;
         }
     }
+    let recordPending;
     return {
+        setHasPendingRecord(value) {
+            self.hasPendingRecord = value;
+        },
+        flushPendingRecord() {
+            if (debounceTimer) {
+                clearTimeout(debounceTimer);
+                debounceTimer = undefined;
+            }
+            if (self.hasPendingRecord) {
+                self.hasPendingRecord = false;
+                recordPending?.();
+            }
+        },
         stopTrackingUndo() {
             self.notTrackingUndo = true;
         },
@@ -141,14 +158,17 @@ const TimeTraveller = types
             skipNextUndoState = false;
             self.history = [];
             self.undoIdx = -1;
+            self.hasPendingRecord = false;
             // read the target's current state rather than a snapshot captured per
             // change: any change inside the debounce window re-times it, so when it
             // does fire the two agree
             const record = () => {
+                this.setHasPendingRecord(false);
                 if (targetStore) {
                     this.addUndoState(getSnapshot(targetStore));
                 }
             };
+            recordPending = record;
             // onPatch, not onSnapshot: this only needs to know *that* the target
             // changed, and the snapshot is taken once per debounce window below.
             // onSnapshot would serialize the whole target on every single change to
@@ -178,17 +198,29 @@ const TimeTraveller = types
                         clearTimeout(debounceTimer);
                         debounceTimer = undefined;
                     }
+                    this.setHasPendingRecord(false);
                     return;
                 }
+                if (!self.hasPendingRecord) {
+                    this.setHasPendingRecord(true);
+                }
                 armRecording(record);
             });
             this.addUndoState(getSnapshot(targetStore));
         },
         undo() {
+            this.flushPendingRecord();
+            if (self.undoIdx <= 0) {
+                return;
+            }
             self.undoIdx--;
             applyHistoryState(self.undoIdx);
         },
         redo() {
+            this.flushPendingRecord();
+            if (self.undoIdx >= self.history.length - 1) {
+                return;
+            }
             self.undoIdx++;
             applyHistoryState(self.undoIdx);
         },

package/esm/util/alignedBytes.d.ts

@@ -0,0 +1,19 @@
+export declare const DASH = 45;
+export declare const SPACE = 32;
+export declare const LOWER_BIT = 32;
+export declare const N_UPPER = 78;
+/** No base at this column of a row: a gap, or the padding of a short row. */
+export declare function isGapByte(b: number): b is 32 | 45;
+export declare function sameBase(a: number, b: number): boolean;
+/**
+ * An `N` reference base, which a row neither matches nor mismatches, so
+ * identity leaves it uncounted.
+ */
+export declare function isUnknownBase(b: number): boolean;
+/**
+ * The first column carrying the row's own sequence. A gap run reaching either
+ * end of a row measures where the block was cut, not the alignment.
+ */
+export declare function firstDrawn(bytes: Uint8Array, at: number, len: number): number;
+/** The last column carrying the row's own sequence, from `firstDrawn`'s answer. */
+export declare function lastDrawn(bytes: Uint8Array, at: number, len: number, first: number): number;

package/esm/util/alignedBytes.js

@@ -0,0 +1,37 @@
+export const DASH = 45;
+export const SPACE = 32;
+export const LOWER_BIT = 0x20;
+export const N_UPPER = 78;
+/** No base at this column of a row: a gap, or the padding of a short row. */
+export function isGapByte(b) {
+    return b === DASH || b === SPACE;
+}
+export function sameBase(a, b) {
+    return (a | LOWER_BIT) === (b | LOWER_BIT);
+}
+/**
+ * An `N` reference base, which a row neither matches nor mismatches, so
+ * identity leaves it uncounted.
+ */
+export function isUnknownBase(b) {
+    return (b & ~LOWER_BIT) === N_UPPER;
+}
+/**
+ * The first column carrying the row's own sequence. A gap run reaching either
+ * end of a row measures where the block was cut, not the alignment.
+ */
+export function firstDrawn(bytes, at, len) {
+    let first = 0;
+    while (first < len && isGapByte(bytes[at + first])) {
+        first++;
+    }
+    return first;
+}
+/** The last column carrying the row's own sequence, from `firstDrawn`'s answer. */
+export function lastDrawn(bytes, at, len, first) {
+    let last = len - 1;
+    while (last > first && isGapByte(bytes[at + last])) {
+        last--;
+    }
+    return last;
+}

package/esm/util/analytics.d.ts

@@ -1,22 +1,21 @@
-import type { AnyConfigurationModel } from '../configuration/index.ts';
+import type { AnyConfigurationModel, TrackConfigEntry } from '../configuration/index.ts';
 declare global {
     interface Window {
         ga?: (...args: unknown[]) => void;
     }
 }
-type TrackConfig = AnyConfigurationModel & {
-    type: string;
-};
 interface AnalyticsRootModel {
     jbrowse: {
-        tracks: TrackConfig[];
+        tracks: TrackConfigEntry[];
         assemblies: unknown[];
         plugins?: {
             name?: string;
         }[];
     };
     session?: {
-        sessionTracks: TrackConfig[];
+        sessionTracks: {
+            type: string;
+        }[];
         views: unknown[];
     };
     version: string;

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/baseDisplayConfig.d.ts

@@ -0,0 +1,8 @@
+/**
+ * #api core/util
+ * The base's entry for this display, hydrated, which a reset returns to and
+ * "is this the reader's" compares against: the config.json's, or the one a
+ * track the session owns was added with; empty in a session that keeps no
+ * base.
+ */
+export declare function baseDisplayConfig(self: object): Record<string, unknown>;

package/esm/util/baseDisplayConfig.js

@@ -0,0 +1,27 @@
+import { hasParent } from '@jbrowse/mobx-state-tree';
+import { getConf } from '../configuration/getConf.js';
+import { getContainingTrack, getSession } from './mstUtils.js';
+import { isSessionWithBaseTrackConfig } from './types/index.js';
+/**
+ * #api core/util
+ * The base's entry for this display, hydrated, which a reset returns to and
+ * "is this the reader's" compares against: the config.json's, or the one a
+ * track the session owns was added with; empty in a session that keeps no
+ * base.
+ */
+export function baseDisplayConfig(self) {
+    if (!hasParent(self)) {
+        return {};
+    }
+    const session = getSession(self);
+    if (!isSessionWithBaseTrackConfig(session)) {
+        return {};
+    }
+    const base = session.baseTrackConfig(getConf(getContainingTrack(self), 'trackId'));
+    const { displayId } = self
+        .configuration;
+    const displays = base?.displays;
+    return ((Array.isArray(displays)
+        ? displays.find(d => d.displayId === displayId)
+        : undefined) ?? {});
+}

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/cachedSetup.d.ts

@@ -1,6 +1,12 @@
 import type { BaseOptions } from '../data_adapters/BaseAdapter/types.ts';
 /** byte-granularity progress reporter to hand an index reader's `onProgress` */
 type OnProgress = (current: number, total?: number) => void;
+/**
+ * How long a setup with no live waiter keeps running before its signal aborts:
+ * `createAbortRotation.begin()` aborts the superseded call before it posts the
+ * replacement, which joins within this window instead of restarting from byte 0.
+ */
+export declare const ABANDONED_SETUP_GRACE_MS = 100;
 /**
  * Memoize an adapter's one-time setup (open the file, read the header, build a
  * parser, download and parse a whole file) into a loader every method can
@@ -17,11 +23,13 @@ type OnProgress = (current: number, total?: number) => void;
  *   moment that fetch was superseded — the display's latest-wins guard gates the
  *   old callback off — so the fetch replacing it awaited a multi-GB parse behind
  *   a blank loading overlay.
- * - **`signal` is withheld from the shared work.** Honoring one caller's
- *   cancel would abort a parse the caller replacing it is already waiting on,
- *   and reject them both. A superseded fetch just stops listening. Cancellation
- *   stays with the per-call work (indexed range queries), which no one else is
- *   waiting on.
+ * - **Cancellation is shared, not per caller.** The setup gets one signal that
+ *   aborts once its last live waiter has aborted and nobody rejoins within
+ *   {@link ABANDONED_SETUP_GRACE_MS}, so a superseded fetch cannot cancel a
+ *   parse its replacement is waiting on, yet a download nobody awaits stops.
+ *   Each caller's own await rejects the moment its own signal aborts. An
+ *   abandoned setup leaves the memo first, so the next call starts afresh and
+ *   an abandoned run's late statuses reach no one.
  * - **`label` is shown only while the *first* attempt is in flight.** Re-entry
  *   on pan/zoom (every getFeatures and byte estimate awaits the loader) would
  *   otherwise re-flash "Downloading index" over an index that is already
@@ -32,7 +40,9 @@ type OnProgress = (current: number, total?: number) => void;
  * a whole-file fetch driving its own download bar — since two labels for one
  * download is worse than one, and phases nest (see `openPhase` in progress.ts).
  * `onProgress` is for handing to an index reader that can upgrade the label to a
- * determinate bar.
+ * determinate bar; like the status, it fans out to every live waiter. It is
+ * undefined without a `label`, so a setup that narrates itself never opts its
+ * reads into streamed progress.
  */
 export declare function cachedSetup<T>({ setup, label, }: {
     setup: (opts: BaseOptions, onProgress?: OnProgress) => Promise<T>;