@jbrowse/core 4.3.0 → 5.0.0-beta.10

package/esm/util/colord.js

@@ -1,231 +1,83 @@
-import { namedColorToHex } from "./color/cssColorsLevel4.js";
-function clamp(value, min, max) {
-    return Math.max(min, Math.min(max, value));
-}
+import { blend, alpha as cbAlpha, formatHEX, formatHEXA, getAlpha, getBlue, getGreen, getRed, newColor, parse, toGLrgb, toHSLA, toRGBA, } from './color-bits/index.js';
+import { parseCssColorOr } from './colorBits.js';
+import { clamp } from './numericUtils.js';
 function round(value, precision = 0) {
     const mult = 10 ** precision;
     return Math.round(value * mult) / mult;
 }
-function parseHex(hex) {
-    const match = /^#([0-9a-f]{3,8})$/i.exec(hex);
-    if (!match) {
-        return null;
-    }
-    const hexStr = match[1];
-    if (hexStr.length === 3) {
-        return {
-            r: parseInt(hexStr[0] + hexStr[0], 16),
-            g: parseInt(hexStr[1] + hexStr[1], 16),
-            b: parseInt(hexStr[2] + hexStr[2], 16),
-            a: 1,
-        };
-    }
-    if (hexStr.length === 4) {
-        return {
-            r: parseInt(hexStr[0] + hexStr[0], 16),
-            g: parseInt(hexStr[1] + hexStr[1], 16),
-            b: parseInt(hexStr[2] + hexStr[2], 16),
-            a: parseInt(hexStr[3] + hexStr[3], 16) / 255,
-        };
-    }
-    if (hexStr.length === 6) {
-        return {
-            r: parseInt(hexStr.slice(0, 2), 16),
-            g: parseInt(hexStr.slice(2, 4), 16),
-            b: parseInt(hexStr.slice(4, 6), 16),
-            a: 1,
-        };
-    }
-    if (hexStr.length === 8) {
-        return {
-            r: parseInt(hexStr.slice(0, 2), 16),
-            g: parseInt(hexStr.slice(2, 4), 16),
-            b: parseInt(hexStr.slice(4, 6), 16),
-            a: parseInt(hexStr.slice(6, 8), 16) / 255,
-        };
-    }
-    return null;
-}
-function parseRgb(str) {
-    const match = /^rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*([\d.]+)\s*)?\)$/i.exec(str);
-    if (match) {
-        return {
-            r: parseInt(match[1], 10),
-            g: parseInt(match[2], 10),
-            b: parseInt(match[3], 10),
-            a: match[4] ? parseFloat(match[4]) : 1,
-        };
-    }
-    return null;
+function hslShiftLightness(c, amount) {
+    const hsla = toHSLA(c);
+    const newL = clamp(hsla.l + amount, 0, 100);
+    const parsed = parse(`hsl(${hsla.h}, ${hsla.s}%, ${newL}%)`);
+    return cbAlpha(parsed, getAlpha(c) / 255);
 }
-function parseHsl(str) {
-    const match = /^hsla?\(\s*([\d.]+)\s*,\s*([\d.]+)%\s*,\s*([\d.]+)%\s*(?:,\s*([\d.]+)\s*)?\)$/i.exec(str);
-    if (match) {
-        const h = parseFloat(match[1]);
-        const s = parseFloat(match[2]) / 100;
-        const l = parseFloat(match[3]) / 100;
-        const a = match[4] ? parseFloat(match[4]) : 1;
-        return { ...hslToRgb(h, s, l), a };
-    }
-    return null;
-}
-function hslToRgb(h, s, l) {
-    h = ((h % 360) + 360) % 360;
-    const c = (1 - Math.abs(2 * l - 1)) * s;
-    const x = c * (1 - Math.abs(((h / 60) % 2) - 1));
-    const m = l - c / 2;
-    let r = 0;
-    let g = 0;
-    let b = 0;
-    if (h < 60) {
-        r = c;
-        g = x;
-    }
-    else if (h < 120) {
-        r = x;
-        g = c;
-    }
-    else if (h < 180) {
-        g = c;
-        b = x;
-    }
-    else if (h < 240) {
-        g = x;
-        b = c;
-    }
-    else if (h < 300) {
-        r = x;
-        b = c;
-    }
-    else {
-        r = c;
-        b = x;
-    }
-    return {
-        r: Math.round((r + m) * 255),
-        g: Math.round((g + m) * 255),
-        b: Math.round((b + m) * 255),
-    };
-}
-function rgbToHsl(r, g, b) {
-    r /= 255;
-    g /= 255;
-    b /= 255;
-    const max = Math.max(r, g, b);
-    const min = Math.min(r, g, b);
-    const l = (max + min) / 2;
-    if (max === min) {
-        return { h: 0, s: 0, l };
-    }
-    const d = max - min;
-    const s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
-    let h = 0;
-    if (max === r) {
-        h = ((g - b) / d + (g < b ? 6 : 0)) / 6;
-    }
-    else if (max === g) {
-        h = ((b - r) / d + 2) / 6;
-    }
-    else {
-        h = ((r - g) / d + 4) / 6;
-    }
-    return { h: h * 360, s, l };
-}
-function parseColor(input) {
+function parseInput(input) {
     if (typeof input === 'object') {
         const { h, s, l } = input;
-        return { ...hslToRgb(h, s / 100, l / 100), a: 1 };
-    }
-    const str = input.trim().toLowerCase();
-    const namedHex = namedColorToHex(str);
-    if (namedHex) {
-        return parseHex(namedHex);
-    }
-    if (str === 'transparent') {
-        return { r: 0, g: 0, b: 0, a: 0 };
+        return parse(`hsl(${h}, ${s}%, ${l}%)`);
     }
-    const hex = parseHex(str);
-    if (hex) {
-        return hex;
-    }
-    const rgb = parseRgb(str);
-    if (rgb) {
-        return rgb;
-    }
-    const hsl = parseHsl(str);
-    if (hsl) {
-        return hsl;
-    }
-    return { r: 0, g: 0, b: 0, a: 1 };
-}
-function toHex2(n) {
-    return Math.round(clamp(n, 0, 255))
-        .toString(16)
-        .padStart(2, '0');
+    return parseCssColorOr(input, newColor(0, 0, 0, 255));
 }
-function createColord(rgba) {
+function createColord(c) {
     const obj = {
         alpha(value) {
             if (value === undefined) {
-                return rgba.a;
+                return getAlpha(c) / 255;
             }
-            return createColord({ ...rgba, a: clamp(value, 0, 1) });
+            return createColord(cbAlpha(c, value));
         },
         toHex() {
-            const { r, g, b, a } = rgba;
-            if (a < 1) {
-                return `#${toHex2(r)}${toHex2(g)}${toHex2(b)}${toHex2(a * 255)}`;
+            if (getAlpha(c) < 255) {
+                return formatHEXA(c);
             }
-            return `#${toHex2(r)}${toHex2(g)}${toHex2(b)}`;
+            return formatHEX(c);
+        },
+        toRgb() {
+            const rgba = toRGBA(c);
+            return { r: rgba.r, g: rgba.g, b: rgba.b, a: rgba.a / 255 };
         },
         toRgbString() {
-            const { r, g, b, a } = rgba;
+            const a = getAlpha(c) / 255;
             if (a < 1) {
-                return `rgba(${Math.round(r)}, ${Math.round(g)}, ${Math.round(b)}, ${round(a, 3)})`;
+                return `rgba(${getRed(c)}, ${getGreen(c)}, ${getBlue(c)}, ${round(a, 3)})`;
             }
-            return `rgb(${Math.round(r)}, ${Math.round(g)}, ${Math.round(b)})`;
+            return `rgb(${getRed(c)}, ${getGreen(c)}, ${getBlue(c)})`;
         },
         toHsl() {
-            const { h, s, l } = rgbToHsl(rgba.r, rgba.g, rgba.b);
+            const hsla = toHSLA(c);
             return {
-                h: round(h, 1),
-                s: round(s * 100, 1),
-                l: round(l * 100, 1),
-                a: rgba.a,
+                h: round(hsla.h, 1),
+                s: round(hsla.s, 1),
+                l: round(hsla.l, 1),
+                a: getAlpha(c) / 255,
             };
         },
         toHslString() {
-            const { h, s, l } = rgbToHsl(rgba.r, rgba.g, rgba.b);
-            if (rgba.a < 1) {
-                return `hsla(${round(h, 1)}, ${round(s * 100, 1)}%, ${round(l * 100, 1)}%, ${round(rgba.a, 3)})`;
+            const hsla = toHSLA(c);
+            const a = getAlpha(c) / 255;
+            if (a < 1) {
+                return `hsla(${round(hsla.h, 1)}, ${round(hsla.s, 1)}%, ${round(hsla.l, 1)}%, ${round(a, 3)})`;
             }
-            return `hsl(${round(h, 1)}, ${round(s * 100, 1)}%, ${round(l * 100, 1)}%)`;
+            return `hsl(${round(hsla.h, 1)}, ${round(hsla.s, 1)}%, ${round(hsla.l, 1)}%)`;
         },
         mix(color2, ratio = 0.5) {
             const c2 = typeof color2 === 'string'
-                ? parseColor(color2)
-                : parseColor(color2.toHex());
-            const r = rgba.r + (c2.r - rgba.r) * ratio;
-            const g = rgba.g + (c2.g - rgba.g) * ratio;
-            const b = rgba.b + (c2.b - rgba.b) * ratio;
-            const a = rgba.a + (c2.a - rgba.a) * ratio;
-            return createColord({ r, g, b, a });
+                ? parseInput(color2)
+                : parseInput(color2.toHex());
+            return createColord(blend(c, c2, ratio));
         },
         darken(amount = 0.1) {
-            const { h, s, l } = rgbToHsl(rgba.r, rgba.g, rgba.b);
-            const newL = clamp(l - amount, 0, 1);
-            const rgb = hslToRgb(h, s, newL);
-            return createColord({ ...rgb, a: rgba.a });
+            return createColord(hslShiftLightness(c, -amount * 100));
         },
         lighten(amount = 0.1) {
-            const { h, s, l } = rgbToHsl(rgba.r, rgba.g, rgba.b);
-            const newL = clamp(l + amount, 0, 1);
-            const rgb = hslToRgb(h, s, newL);
-            return createColord({ ...rgb, a: rgba.a });
+            return createColord(hslShiftLightness(c, amount * 100));
         },
     };
     return obj;
 }
 export function colord(input) {
-    return createColord(parseColor(input));
+    return createColord(parseInput(input));
+}
+export function hexToGLrgb(hex) {
+    return toGLrgb(parse(hex));
 }

package/esm/util/convertCodingSequenceToPeptides.d.ts

@@ -1,6 +1,20 @@
-import type { Feat } from '../BaseFeatureWidget/util.tsx';
-export declare function convertCodingSequenceToPeptides({ cds, sequence, codonTable, }: {
-    cds: Feat[];
+import type { TranslExcept } from './geneticCodes.ts';
+export declare function translExceptProteinPositions({ cds, translExcept, }: {
+    cds: {
+        start: number;
+        end: number;
+        phase?: number;
+    }[];
+    translExcept?: TranslExcept[];
+}): Set<number>;
+export declare function convertCodingSequenceToPeptides({ cds, sequence, codonTable, starts, translExcept, }: {
+    cds: {
+        start: number;
+        end: number;
+        phase?: number;
+    }[];
     sequence: string;
     codonTable: Record<string, string>;
+    starts?: string[];
+    translExcept?: TranslExcept[];
 }): string;

package/esm/util/convertCodingSequenceToPeptides.js

@@ -1,10 +1,57 @@
-import { stitch } from "../BaseFeatureWidget/util.js";
-export function convertCodingSequenceToPeptides({ cds, sequence, codonTable, }) {
+import { stitch } from './seqUtils.js';
+// Maps a single position (in the same coordinate system as the cds array) to its
+// codon index within the stitched CDS string. Returns undefined if the position
+// falls outside all CDS segments or before the phase offset.
+function posToCodonIndex(pos, cds, phase) {
+    let offset = 0;
+    for (const seg of cds) {
+        if (pos >= seg.start && pos < seg.end) {
+            const stitchedPos = offset + (pos - seg.start);
+            if (stitchedPos < phase) {
+                return undefined;
+            }
+            return Math.floor((stitchedPos - phase) / 3);
+        }
+        offset += seg.end - seg.start;
+    }
+    return undefined;
+}
+// phase > 0 prepends a leading '&' to the protein, shifting every codon's index
+// in the protein string by one.
+function proteinIndexShift(phase) {
+    return phase > 0 ? 1 : 0;
+}
+// Maps each in-range transl_except to its codon index within the stitched CDS.
+function translExceptCodonOverrides(cds, translExcept, phase) {
+    const overrides = new Map();
+    for (const ex of translExcept) {
+        const idx = posToCodonIndex(ex.start, cds, phase);
+        if (idx !== undefined) {
+            overrides.set(idx, ex.aa);
+        }
+    }
+    return overrides;
+}
+// Returns the 0-indexed positions in the final protein string where translExcept
+// overrides were applied. Position 0 = first character of the returned protein string
+// (which may be '&' if phase > 0). Callers use this to highlight those characters.
+export function translExceptProteinPositions({ cds, translExcept = [], }) {
+    const phase = cds[0]?.phase ?? 0;
+    const shift = proteinIndexShift(phase);
+    const codonIndexes = translExceptCodonOverrides(cds, translExcept, phase).keys();
+    return new Set([...codonIndexes].map(idx => idx + shift));
+}
+export function convertCodingSequenceToPeptides({ cds, sequence, codonTable, starts, translExcept = [], }) {
     const phase = cds[0]?.phase ?? 0;
     const str = stitch(cds, sequence);
+    const overrides = translExceptCodonOverrides(cds, translExcept, phase);
     let protein = phase > 0 ? '&' : '';
-    for (let i = phase; i < str.length; i += 3) {
-        protein += codonTable[str.slice(i, i + 3)] || '&';
+    let codonIdx = 0;
+    for (let i = phase; i < str.length; i += 3, codonIdx++) {
+        const codon = str.slice(i, i + 3);
+        const isStart = codonIdx === 0 && phase === 0 && starts?.includes(codon.toUpperCase());
+        protein +=
+            overrides.get(codonIdx) ?? (isStart ? 'M' : codonTable[codon]) ?? '&';
     }
     return protein;
 }

package/esm/util/copyText.d.ts

@@ -0,0 +1,18 @@
+import type { CopyOptions } from './copyToClipboard.ts';
+import type { AbstractSessionModel } from './types/index.ts';
+import type { IAnyStateTreeNode } from '@jbrowse/mobx-state-tree';
+/**
+ * Copy `text` to the clipboard, confirming it in a snackbar (`what` names what
+ * landed — "read name", "EDEN.1:c.93+1", "feature info") and surfacing a failure
+ * rather than silently doing nothing.
+ *
+ * Every display that offered a copy item had grown its own copy of this wrapper,
+ * and they had drifted on both the wording and whether an error reached the user
+ * at all. Take this when you hold a session; `copyText` when you hold a model.
+ */
+export declare function copyTextWithSession(session: Pick<AbstractSessionModel, 'notify' | 'notifyError'>, text: string, what: string, options?: CopyOptions): Promise<void>;
+/**
+ * `copyTextWithSession` for a menu item on a model, which is what a display has
+ * in hand.
+ */
+export declare function copyText(node: IAnyStateTreeNode, text: string, what: string, options?: CopyOptions): Promise<void>;

package/esm/util/copyText.js

@@ -0,0 +1,30 @@
+import copyToClipboard from './copyToClipboard.js';
+import { getSession } from './mstUtils.js';
+/**
+ * Copy `text` to the clipboard, confirming it in a snackbar (`what` names what
+ * landed — "read name", "EDEN.1:c.93+1", "feature info") and surfacing a failure
+ * rather than silently doing nothing.
+ *
+ * Every display that offered a copy item had grown its own copy of this wrapper,
+ * and they had drifted on both the wording and whether an error reached the user
+ * at all. Take this when you hold a session; `copyText` when you hold a model.
+ */
+export async function copyTextWithSession(session, text, what, options) {
+    try {
+        // awaited: copyToClipboard reports a rejected write by throwing, so without
+        // this the snackbar confirms a copy that never landed
+        await copyToClipboard(text, options);
+        session.notify(`Copied ${what} to clipboard`, 'success');
+    }
+    catch (e) {
+        console.error(e);
+        session.notifyError(`${e}`, e);
+    }
+}
+/**
+ * `copyTextWithSession` for a menu item on a model, which is what a display has
+ * in hand.
+ */
+export async function copyText(node, text, what, options) {
+    return copyTextWithSession(getSession(node), text, what, options);
+}

package/esm/util/copyToClipboard.d.ts

@@ -0,0 +1,4 @@
+export interface CopyOptions {
+    format?: string;
+}
+export default function copyToClipboard(text: string, options?: CopyOptions): Promise<void>;

package/esm/util/copyToClipboard.js

@@ -0,0 +1,58 @@
+// Throws when the write did not happen, which is the only signal the async API
+// gives (it reports a denied permission or an unfocused document by rejecting).
+// A caller that reports success must therefore await this, or it confirms a copy
+// that never landed.
+export default async function copyToClipboard(text, options = {}) {
+    const format = options.format ?? 'text/plain';
+    // navigator.clipboard is only present in secure contexts; isSecureContext is
+    // the real gate, so insecure http:// falls through to execCommand below
+    if (format === 'text/plain' && window.isSecureContext) {
+        await navigator.clipboard.writeText(text);
+    }
+    else if (!execCommandCopy(text, format)) {
+        throw new Error('the browser rejected the clipboard write');
+    }
+}
+function execCommandCopy(text, format) {
+    const selection = document.getSelection();
+    const previousRange = selection && selection.rangeCount > 0 ? selection.getRangeAt(0) : undefined;
+    // offscreen span carrying the text, with whitespace preserved
+    const span = document.createElement('span');
+    span.textContent = text;
+    span.style.whiteSpace = 'pre';
+    span.style.position = 'fixed';
+    span.style.top = '0';
+    span.style.left = '0';
+    span.style.opacity = '0';
+    document.body.append(span);
+    const listener = (e) => {
+        if (e.clipboardData) {
+            e.clipboardData.clearData();
+            e.clipboardData.setData(format, text);
+        }
+        e.preventDefault();
+    };
+    document.addEventListener('copy', listener);
+    let success = false;
+    try {
+        const range = document.createRange();
+        range.selectNodeContents(span);
+        selection?.removeAllRanges();
+        selection?.addRange(range);
+        // execCommand is deprecated but is the only clipboard write available in
+        // non-secure (http://) contexts, which JBrowse must support
+        success = document.execCommand('copy');
+    }
+    catch (e) {
+        console.error(e);
+    }
+    finally {
+        document.removeEventListener('copy', listener);
+        selection?.removeAllRanges();
+        if (previousRange) {
+            selection?.addRange(previousRange);
+        }
+        span.remove();
+    }
+    return success;
+}

package/esm/util/createAbortRotation.d.ts

@@ -0,0 +1,115 @@
+import type { RpcStatus, StatusWindow } from './progress.ts';
+import type { IStateTreeNode } from '@jbrowse/mobx-state-tree';
+/**
+ * Where a rotation reports, in the one of two modes the host is actually in.
+ *
+ * A union rather than one shape with an optional window, because the two modes
+ * do not use the same member and the optional version required the one that is
+ * dead in the lending mode: when a host lends its `statusWindow` the rotation
+ * writes through the window and never calls `setStatusMessage`, so a caller
+ * supplying both got silence from the half it thought it was wiring up.
+ * `FetchMixin` was that caller.
+ */
+export type StatusReporter = {
+    /**
+     * The host's own window, present on any display composing `FetchMixin`.
+     * The rotation reports through it rather than opening a SECOND on the
+     * same status field — which is what one-window-per-owner exists to
+     * prevent.
+     */
+    statusWindow: StatusWindow;
+    setStatusMessage?: never;
+} | {
+    /**
+     * The sink for the window the rotation opens for itself: the mode of a
+     * fetch on a host with no window of its own — the prerequisite reads,
+     * chord, the breakpoint overlay — along with every
+     * {@link createStatusChannel} holder. The comparative displays this
+     * helper was written for lend a window now (ADR-105).
+     */
+    setStatusMessage: (status?: RpcStatus) => void;
+    statusWindow?: never;
+};
+/**
+ * A {@link StatusReporter} a model can hold in **one** volatile, for something
+ * that has one operation to narrate and no reason to grow a status vocabulary
+ * of its own. `ProgressChip` takes `message`/`fraction` straight off it.
+ *
+ * The alternative is what every display does: two volatiles and an action
+ * calling {@link statusMessageText} and {@link statusFraction}. That is the
+ * right shape where the fields are part of the model's own surface —
+ * `BaseDisplay` and `FetchMixin` declare them because half the display API reads
+ * them — and a lot of declaration for a view that wants a corner chip while one
+ * fetch runs. A plain function rather than a mixin because a compose layer is
+ * what the model chains here cannot afford (ADR-041).
+ */
+export interface StatusChannel {
+    setStatusMessage: (status?: RpcStatus) => void;
+    readonly message: string | undefined;
+    readonly fraction: number | undefined;
+}
+export declare function createStatusChannel(): StatusChannel;
+export interface ActiveFetch {
+    signal: AbortSignal;
+    /**
+     * True only while this is still the most recent fetch AND `self` is alive.
+     * Gate every post-await write — result commit, error set — on it so a
+     * superseded or torn-down fetch never writes back.
+     */
+    isCurrent: () => boolean;
+    /**
+     * RPC `statusCallback` pre-gated by `isCurrent`: forwards progress to
+     * `setStatusMessage` only while this is still the latest fetch, so a
+     * superseded fetch's late status update can't flicker the overlay, and
+     * throttled to the same leading edge as `FetchMixin`'s callbacks. Pass it
+     * straight as the RPC `statusCallback` arg.
+     */
+    statusCallback: (status: RpcStatus) => void;
+    /**
+     * Call in the `finally` of the run that owns this fetch: closes `isCurrent`
+     * and retires this fetch's status slot, which blanks the field only if no
+     * other operation on the host is still reporting.
+     *
+     * Both together, because a caller doing it by hand gets a subset.
+     * `isCurrent` is `signal === current && isAlive`, and a run that *completes*
+     * never rotates its own signal — so without this the guard stays open past the
+     * work and a trailing write lands on top of a hand-written
+     * `setStatusMessage(undefined)` up to a window later.
+     *
+     * A superseded run's slot is already retired by the `begin()` that replaced
+     * it, so its `end()` only closes the guard.
+     */
+    end: () => void;
+}
+/**
+ * Latest-wins abort rotation for a fetch that runs in a bare `autorun`
+ * rather than through `FetchMixin.runFetch` (which welds the same mechanics to
+ * `fetchGeneration`, so it's only for viewport-driven LGV fetches). Each
+ * `begin()` aborts the prior fetch and returns a fresh signal plus an
+ * `isCurrent()` guard that captures this run — gate every post-await write on
+ * it and a superseded or torn-down fetch can never clobber fresher data. The
+ * guard is the return value, so a caller can't forget to compare by hand.
+ *
+ * `end()` in the run's `finally` is the other half, and for the same reason —
+ * see {@link ActiveFetch.end} for the two things it does together.
+ *
+ * Owns the controller and the status channel; the caller keeps its own
+ * loading/error/commit side-effects. Three holders: `FetchMixin` as a member
+ * (so `cancelFetch` can reach it), `installFetch` one per installation (every
+ * other fetch in the tree runs on that skeleton), and the synteny diagonalize
+ * progress wrapper (`withDiagonalizeProgress`) directly.
+ *
+ * `report` is passed rather than read off `self`, so where the status lands is
+ * the caller's decision and not a shape this imposes. A display passes itself —
+ * its status fields are part of its own API, and one composing `FetchMixin`
+ * passes the model-wide window along with them (see `StatusReporter`).
+ * Anything with one operation to narrate and no status vocabulary of its own
+ * passes a {@link createStatusChannel}, which is one volatile instead of two
+ * fields and an action.
+ */
+export type AbortRotation = ReturnType<typeof createAbortRotation>;
+export declare function createAbortRotation(self: IStateTreeNode, report: StatusReporter): {
+    begin(): ActiveFetch;
+    cancel: () => void;
+    dispose(): void;
+};