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

package/esm/util/cellsStep.js

@@ -0,0 +1,437 @@
+// 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 { 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) {
+    return !drawn
+        ? NO_STATE
+        : isGapByte(rowByte)
+            ? GAP
+            : (refByte | LOWER_BIT) === (rowByte | LOWER_BIT)
+                ? MATCH
+                : 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) {
+    let at = table;
+    let toBase;
+    while (at instanceof DerivedTable && !at.madeFrom) {
+        toBase = at.parentRow ? compose(toBase, at.parentRow) : toBase;
+        at = at.parent;
+    }
+    if (!(at instanceof DerivedTable)) {
+        return undefined;
+    }
+    return {
+        made: at,
+        toMade: toBase,
+        table: at.parent,
+        row: at.parentRow ? compose(toBase, at.parentRow) : toBase,
+    };
+}
+function compose(outer, inner) {
+    if (!outer) {
+        return inner;
+    }
+    const out = new Uint32Array(outer.length);
+    for (let i = 0; i < outer.length; i++) {
+        out[i] = inner[outer[i]];
+    }
+    return out;
+}
+// Below this length a character loop copies a string faster than
+// `encodeInto`, as the MAF packer measured.
+const ASCII_COPY_MAX_LENGTH = 64;
+const encoder = new TextEncoder();
+// A column's text as bytes, one per character: an adapter's own, or the
+// strings a feature holds copied into one buffer.
+function textOf(column, n) {
+    if (column.kind === 'text') {
+        return column;
+    }
+    const read = readerOf(column);
+    const texts = new Array(n);
+    let total = 0;
+    for (let i = 0; i < n; i++) {
+        const v = read(i);
+        if (typeof v === 'string') {
+            texts[i] = v;
+            total += v.length;
+        }
+    }
+    const bytes = new Uint8Array(total);
+    const offset = new Uint32Array(n);
+    const length = new Uint32Array(n);
+    let pos = 0;
+    for (let i = 0; i < n; i++) {
+        const text = texts[i];
+        if (text === undefined) {
+            continue;
+        }
+        offset[i] = pos;
+        if (text.length <= ASCII_COPY_MAX_LENGTH) {
+            for (let c = 0; c < text.length; c++) {
+                bytes[pos + c] = text.charCodeAt(c);
+            }
+            length[i] = text.length;
+        }
+        else {
+            length[i] = encoder.encodeInto(text, bytes.subarray(pos, pos + text.length)).written;
+        }
+        pos += text.length;
+    }
+    return { kind: 'text', bytes, offset, length, at: undefined };
+}
+/**
+ * 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
+ * a container reads off the container.
+ */
+class WalkedTexts {
+    row;
+    reference;
+    refRow;
+    constructor(row, ref, refRow) {
+        this.row = row;
+        this.reference = ref;
+        this.refRow = refRow;
+    }
+    rowOf(r) {
+        const { at } = this.row;
+        return at ? at[r] : r;
+    }
+    refOf(r) {
+        const p = this.refRow ? this.refRow[r] : r;
+        const { at } = this.reference;
+        return at ? at[p] : p;
+    }
+}
+export function walkedTexts(table, field) {
+    const row = textOf(table.column(field), table.length);
+    const container = containerOf(table);
+    const made = container?.made;
+    if (container && !(made instanceof FannedTable && made.hasKept)) {
+        const { table: base } = container;
+        return new WalkedTexts(row, textOf(base.column(field), base.length), container.row);
+    }
+    // A container a flatten kept with nothing to fan out is the row itself, so
+    // its reference is its own container's, as its `parent()` says.
+    const byParent = (r) => table.row(r).parent?.()?.get(field);
+    const readContainer = container
+        ? readerOf(container.table.column(field))
+        : undefined;
+    const read = readContainer && made instanceof FannedTable
+        ? (r) => {
+            const { toMade, row: refRow } = container;
+            return made.isKept(toMade ? toMade[r] : r)
+                ? byParent(r)
+                : readContainer(refRow ? refRow[r] : r);
+        }
+        : byParent;
+    return new WalkedTexts(row, textOf({ kind: 'value', read }, table.length));
+}
+/**
+ * The runs a `cells` step answers, one per stretch of one state against the
+ * reference, typed: each run's span, its state and the text column it starts
+ * at, with `base`, `match` and `length` read back out of the texts when asked
+ * for.
+ */
+class CellTable extends DerivedTable {
+    start;
+    end;
+    state;
+    textAt;
+    texts;
+    firstOfRow;
+    derived = new Map();
+    constructor(parent, parentRow, lanes, texts) {
+        super(parent, parentRow);
+        this.start = lanes.start;
+        this.end = lanes.end;
+        this.state = lanes.state;
+        this.textAt = lanes.textAt;
+        this.texts = texts;
+    }
+    get madeFrom() {
+        return true;
+    }
+    laneOf(name, build) {
+        let column = this.derived.get(name);
+        if (!column) {
+            column = build();
+            this.derived.set(name, column);
+        }
+        return column;
+    }
+    own(name) {
+        switch (name) {
+            case 'start': {
+                return { kind: 'number', values: this.start, at: undefined };
+            }
+            case 'end': {
+                return { kind: 'number', values: this.end, at: undefined };
+            }
+            case 'state': {
+                return {
+                    kind: 'category',
+                    codes: this.state,
+                    labels: CELL_STATES,
+                    at: undefined,
+                };
+            }
+            case 'match': {
+                return this.laneOf(name, () => {
+                    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;
+                    }
+                    return { kind: 'number', values, at: undefined, nanIsAbsent: true };
+                });
+            }
+            case 'length': {
+                return this.laneOf(name, () => {
+                    const values = new Float32Array(this.length).fill(Number.NaN);
+                    for (let i = 0; i < this.length; i++) {
+                        if (this.state[i] === INSERTION) {
+                            values[i] = this.inserted(i).length;
+                        }
+                    }
+                    return { kind: 'number', values, at: undefined, nanIsAbsent: true };
+                });
+            }
+            case 'base': {
+                return this.laneOf(name, () => {
+                    const values = new Array(this.length);
+                    for (let i = 0; i < this.length; i++) {
+                        const s = this.state[i];
+                        values[i] =
+                            s === MISMATCH
+                                ? this.mismatched(i)
+                                : s === INSERTION
+                                    ? this.inserted(i)
+                                    : undefined;
+                    }
+                    return { kind: 'value', read: i => values[i] };
+                });
+            }
+            default: {
+                return undefined;
+            }
+        }
+    }
+    mismatched(i) {
+        const { bytes, offset } = this.texts.row;
+        const k = this.texts.rowOf(this.parentOf(i));
+        return String.fromCharCode(bytes[offset[k] + this.textAt[i]]);
+    }
+    // The bases a row holds where the reference has none, from the column the
+    // insertion starts at to the reference's next base.
+    inserted(i) {
+        const { row, reference: ref } = this.texts;
+        const r = this.parentOf(i);
+        const k = this.texts.rowOf(r);
+        const f = this.texts.refOf(r);
+        const rowAt = row.offset[k];
+        const refAt = ref.offset[f];
+        const end = Math.min(row.length[k], ref.length[f]);
+        let out = '';
+        for (let col = this.textAt[i]; col < end && ref.bytes[refAt + col] === DASH; col++) {
+            const b = row.bytes[rowAt + col];
+            if (!isGapByte(b)) {
+                out += String.fromCharCode(b);
+            }
+        }
+        return out;
+    }
+    id(i) {
+        const p = this.parentOf(i);
+        this.firstOfRow ??= firstRowIndex(this.parentRow, this.parent.length);
+        return `${this.parent.row(p).id()}#${i - this.firstOfRow[p]}`;
+    }
+    json(i) {
+        const out = {
+            ...this.parent.row(this.parentOf(i)).toJSON(),
+            start: this.start[i],
+            end: this.end[i],
+            state: CELL_STATES[this.state[i]],
+        };
+        for (const name of ['base', 'match', 'length']) {
+            const v = valueAt(this.column(name), i);
+            if (v !== undefined) {
+                out[name] = v;
+            }
+        }
+        return out;
+    }
+}
+// The lanes a `cells` walk writes, doubled as a row would overrun them.
+class RunLanes {
+    start;
+    end;
+    state;
+    textAt;
+    parentRow;
+    length = 0;
+    constructor(capacity) {
+        this.start = new Uint32Array(capacity);
+        this.end = new Uint32Array(capacity);
+        this.state = new Uint8Array(capacity);
+        this.textAt = new Uint32Array(capacity);
+        this.parentRow = new Uint32Array(capacity);
+    }
+    reserve(more) {
+        const need = this.length + more;
+        if (need <= this.start.length) {
+            return;
+        }
+        const size = Math.max(this.start.length * 2, need);
+        const widen = (a) => {
+            const next = new a.constructor(size);
+            next.set(a);
+            return next;
+        };
+        this.start = widen(this.start);
+        this.end = widen(this.end);
+        this.state = widen(this.state);
+        this.textAt = widen(this.textAt);
+        this.parentRow = widen(this.parentRow);
+    }
+    // One row's runs against its reference: a run per column is the most it
+    // can answer, so the lanes grow once and the walk writes through locals.
+    walk(r, startPos, rowBytes, rowAt, rowLen, refBytes, refAt, refLen) {
+        this.reserve(refLen + 1);
+        const { start, end, state, textAt, parentRow } = this;
+        let n = this.length;
+        let pos = startPos;
+        const first = firstDrawn(rowBytes, rowAt, rowLen);
+        const last = lastDrawn(rowBytes, rowAt, rowLen, first);
+        let runStart = -1;
+        let runState = NO_STATE;
+        let runBase = -1;
+        let runCol = 0;
+        let insertAt = -1;
+        for (let col = 0; col < refLen; col++) {
+            const refByte = refBytes[refAt + col];
+            const rowByte = col < rowLen ? rowBytes[rowAt + col] : SPACE;
+            if (refByte === DASH) {
+                if (insertAt < 0 && col < rowLen && !isGapByte(rowByte)) {
+                    insertAt = col;
+                }
+                continue;
+            }
+            if (insertAt >= 0) {
+                start[n] = pos;
+                end[n] = pos;
+                state[n] = INSERTION;
+                textAt[n] = insertAt;
+                parentRow[n] = r;
+                n++;
+                insertAt = -1;
+            }
+            const st = cellState(refByte, rowByte, col >= first && col <= last && col < rowLen);
+            const base = st === MISMATCH ? rowByte : -1;
+            if (st !== runState || base !== runBase) {
+                if (runStart >= 0) {
+                    start[n] = runStart;
+                    end[n] = pos;
+                    state[n] = runState;
+                    textAt[n] = runCol;
+                    parentRow[n] = r;
+                    n++;
+                }
+                runStart = st === NO_STATE ? -1 : pos;
+                runState = st;
+                runBase = base;
+                runCol = col;
+            }
+            pos++;
+        }
+        if (runStart >= 0) {
+            start[n] = runStart;
+            end[n] = pos;
+            state[n] = runState;
+            textAt[n] = runCol;
+            parentRow[n] = r;
+            n++;
+        }
+        this.length = n;
+    }
+}
+// Where each parent row's children start, for children written parent by
+// parent in order.
+function firstRowIndex(parentRow, parents) {
+    const first = new Uint32Array(parents);
+    for (let i = parentRow.length - 1; i >= 0; i--) {
+        first[parentRow[i]] = i;
+    }
+    return first;
+}
+export function cells({ table, bounds }, step) {
+    const { field = DEFAULT_CELLS_FIELD } = step;
+    const texts = walkedTexts(table, field);
+    const readStart = numberReaderOf(table.column('start'));
+    const { bytes: rowBytes, offset: rowOffset, length: rowLength } = texts.row;
+    const { bytes: refBytes, offset: refOffset, length: refLength, } = texts.reference;
+    // A run per reference base is the most a row can answer and far past what
+    // one does, so the lanes start at an eighth of it.
+    let bound = 0;
+    for (let r = 0; r < table.length; r++) {
+        bound += refLength[texts.refOf(r)] + 1;
+    }
+    const lanes = new RunLanes(Math.max(1024, bound >>> 3));
+    for (let r = 0; r < table.length; r++) {
+        const f = texts.refOf(r);
+        const refLen = refLength[f];
+        const pos = readStart(r);
+        if (refLen > 0 && pos >= 0) {
+            const k = texts.rowOf(r);
+            lanes.walk(r, pos, rowBytes, rowOffset[k], rowLength[k], refBytes, refOffset[f], refLen);
+        }
+    }
+    const n = lanes.length;
+    const rows = lanes.parentRow.subarray(0, n);
+    return {
+        table: new CellTable(table, rows, {
+            start: lanes.start.subarray(0, n),
+            end: lanes.end.subarray(0, n),
+            state: lanes.state.subarray(0, n),
+            textAt: lanes.textAt.subarray(0, n),
+        }, texts),
+        bounds: boundsThrough(bounds, rows),
+    };
+}

package/esm/util/copyToClipboard.js

@@ -7,7 +7,14 @@ export default async function copyToClipboard(text, options = {}) {
     // 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);
+        try {
+            await navigator.clipboard.writeText(text);
+        }
+        catch (e) {
+            if (!execCommandCopy(text, format)) {
+                throw e;
+            }
+        }
     }
     else if (!execCommandCopy(text, format)) {
         throw new Error('the browser rejected the clipboard write');

package/esm/util/createAbortRotation.js

@@ -81,9 +81,9 @@ export function createAbortRotation(self, report) {
             // Opened before the superseded slot retires, so the window is never idle
             // across the handover and the label on screen survives it (ADR-080).
             // Retired here rather than left to the superseded run's `finally`, which
-            // comes only when its work settles — and a CRAM record read or a shared
-            // parse the signal is withheld from runs on past the abort, its last
-            // reading summed into this fetch's bar the whole time.
+            // comes only when its work settles — and a CRAM record read, or a shared
+            // `cachedSetup` parse the replacement rejoins, runs on past the abort,
+            // its last reading summed into this fetch's bar the whole time.
             const stream = statusWindow.open({ isCurrent });
             openStream?.clear();
             openStream = stream;

package/esm/util/featureTransforms.d.ts

@@ -5,19 +5,20 @@ import type { Feature } from './simpleFeature.ts';
 export { BIN_OVERLAP_FIELD, DEFAULT_BIN_AS } from './stepTables.ts';
 export declare const DEFAULT_BIN_FIELD = "start";
 export declare const DEFAULT_FLATTEN_FIELD = "subfeatures";
-export declare const DEFAULT_CELLS_FIELD = "seq";
+export { DEFAULT_CELLS_FIELD } from './cellsStep.ts';
 export declare const DEFAULT_COVERAGE_AS = "coverage";
 export declare const DEFAULT_PILEUP_AS = "row";
 export declare const DEFAULT_PILEUP_FIELDS: [string, string];
 /**
  * #api
  * How a record states its other end, or undefined where it states none: the
- * `mate` a paired adapter fills (BEDPE, STAR-Fusion), or an `ALT` the breakend
- * and symbolic-SV readers resolve. The `mate` step admits exactly the features
- * this names one for, so a caller deciding whether links are the picture a
- * track wants asks here rather than re-reading the fields.
+ * `mate` a paired adapter fills (BEDPE, STAR-Fusion), an `ALT` the breakend
+ * and symbolic-SV readers resolve, or a read's `next_ref` and `next_pos`. The
+ * `mate` step admits exactly the features this names one for, so a caller
+ * deciding whether links are the picture a track wants asks here rather than
+ * re-reading the fields.
  */
-export declare function matedBy(f: Feature): "alt" | "mate" | undefined;
+export declare function matedBy(f: Feature): "alt" | "mate" | "pair" | undefined;
 /**
  * #api
  * One layer of a faceted request: its rows in section order, and the stacked