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

package/esm/util/diagonalizeRegions.js

@@ -18,7 +18,11 @@ const decisiveStrandFraction = 0.6;
 // float addition is non-associative, so a varying order would perturb these sums
 // in their low bits and could flip the query-chromosome ordering on a near-tie.
 // Only intra-pair order matters, since every sum here is over one pair.
-function anchorStats({ alignments, bases, strandWeightedSum }) {
+//
+// A reversed reference chromosome is drawn right to left, so its positions,
+// strand vote and covariance all change sign: the query is ordered and oriented
+// against the reference as drawn.
+function anchorStats({ alignments, bases, strandWeightedSum, refReversed, }) {
     alignments.sort((a, b) => a.refStart - b.refStart ||
         a.queryStart - b.queryStart ||
         a.refEnd - b.refEnd ||
@@ -45,12 +49,13 @@ function anchorStats({ alignments, bases, strandWeightedSum }) {
                 ((aln.refStart + aln.refEnd) / 2 - refMean) *
                 ((aln.queryStart + aln.queryEnd) / 2 - queryMean);
     }
-    const strandFraction = strandWeightedSum / bases;
+    const sign = refReversed ? -1 : 1;
+    const strandFraction = (sign * strandWeightedSum) / bases;
     return {
-        bestRefPos: refMean,
+        bestRefPos: sign * refMean,
         shouldReverse: Math.abs(strandFraction) > decisiveStrandFraction || covariance === 0
             ? strandFraction < 0
-            : covariance < 0,
+            : sign * covariance < 0,
     };
 }
 // Groups alignments by vertical-axis (query) chromosome, accumulates total
@@ -73,9 +78,12 @@ export async function diagonalizeRegions(alignments, referenceRegions, currentRe
     // first appearance wins: a refName can appear in more than one reference
     // region, and the ordering key is where that chromosome starts on the axis
     const refOrder = new Map();
-    for (const [i, region] of referenceRegions.entries()) {
+    for (const [index, region] of referenceRegions.entries()) {
         if (!refOrder.has(region.refName)) {
-            refOrder.set(region.refName, i);
+            refOrder.set(region.refName, {
+                index,
+                reversed: region.reversed ?? false,
+            });
         }
     }
     // outer key: vertical chrom; inner key: horizontal chrom. Alignments to a
@@ -84,8 +92,8 @@ export async function diagonalizeRegions(alignments, referenceRegions, currentRe
     const queryGroups = new Map();
     for (const aln of alignments) {
         reportGrouping();
-        const refIndex = refOrder.get(aln.refRefName);
-        if (refIndex !== undefined) {
+        const ref = refOrder.get(aln.refRefName);
+        if (ref !== undefined) {
             let group = queryGroups.get(aln.queryRefName);
             if (!group) {
                 group = new Map();
@@ -95,7 +103,8 @@ export async function diagonalizeRegions(alignments, referenceRegions, currentRe
             if (!data) {
                 data = {
                     refName: aln.refRefName,
-                    refIndex,
+                    refIndex: ref.index,
+                    refReversed: ref.reversed,
                     bases: 0,
                     strandWeightedSum: 0,
                     alignments: [],

package/esm/util/featureTransforms.d.ts

@@ -6,8 +6,8 @@ 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 { DEFAULT_CELLS_FIELD } from './cellsStep.ts';
-export declare const DEFAULT_COVERAGE_AS = "coverage";
-export declare const DEFAULT_PILEUP_AS = "row";
+export { DEFAULT_WINDOW_FRAME } from './windowStep.ts';
+export { DEFAULT_COVERAGE_AS, DEFAULT_PILEUP_AS } from './stepOutputs.ts';
 export declare const DEFAULT_PILEUP_FIELDS: [string, string];
 /**
  * #api

package/esm/util/featureTransforms.js

@@ -6,14 +6,16 @@ import { DerivedTable, NO_COLUMN, WithTable, asTable, numberReaderOf, readerOf,
 import { fieldReader, isPlainFieldRef } from './fieldReader.js';
 import { isJexl, stringToJexlExpression } from './jexlStrings.js';
 import SimpleFeature, { buildJexlContext } from './simpleFeature.js';
-import { BIN_OVERLAP_FIELD, DEFAULT_BIN_AS, FannedTable, MadeTable, OpSums, binSize, boundsThrough, groupKey, intervalsOf, isWeighted, madeGroups, stepNumberReader, stepReader, } from './stepTables.js';
+import { DEFAULT_COVERAGE_AS, DEFAULT_PILEUP_AS, isRowwise, stepWrites, } from './stepOutputs.js';
+import { BIN_OVERLAP_FIELD, DEFAULT_BIN_AS, FannedTable, MadeTable, OpSums, binSize, boundsThrough, groupKey, groupRows, intervalsOf, isWeighted, madeGroups, sortByStart, stepNumberReader, stepReader, } from './stepTables.js';
 import { junctionEnds, svClassOfAlt, svClassOfToken } from './svAlt.js';
+import { windowStep } from './windowStep.js';
 export { BIN_OVERLAP_FIELD, DEFAULT_BIN_AS } from './stepTables.js';
 export const DEFAULT_BIN_FIELD = 'start';
 export const DEFAULT_FLATTEN_FIELD = 'subfeatures';
 export { DEFAULT_CELLS_FIELD } from './cellsStep.js';
-export const DEFAULT_COVERAGE_AS = 'coverage';
-export const DEFAULT_PILEUP_AS = 'row';
+export { DEFAULT_WINDOW_FRAME } from './windowStep.js';
+export { DEFAULT_COVERAGE_AS, DEFAULT_PILEUP_AS } from './stepOutputs.js';
 export const DEFAULT_PILEUP_FIELDS = ['start', 'end'];
 function oneSection(n) {
     return Uint32Array.of(0, n);
@@ -596,58 +598,6 @@ function binIntervals({ table, bounds }, step, fields) {
         bounds: boundsThrough(bounds, parentRow),
     };
 }
-// Each row's group, numbered in the order groups are first met, a section
-// being the outermost level: the groups keyed by their raw values, one Map
-// level per groupby field, where a string key built per row was the
-// aggregate's whole cost.
-function groupRows(n, bounds, reads, normalize) {
-    const groupOf = new Uint32Array(n);
-    const firstRow = [];
-    const sectionOf = [];
-    const last = reads.length - 1;
-    for (let s = 0; s + 1 < bounds.length; s++) {
-        const root = new Map();
-        for (let i = bounds[s]; i < bounds[s + 1]; i++) {
-            let g;
-            if (reads.length === 0) {
-                g =
-                    firstRow.length > 0 && sectionOf.at(-1) === s
-                        ? firstRow.length - 1
-                        : -1;
-                if (g < 0) {
-                    g = firstRow.length;
-                    firstRow.push(i);
-                    sectionOf.push(s);
-                }
-            }
-            else {
-                let node = root;
-                for (let l = 0; l < last; l++) {
-                    const raw = reads[l](i);
-                    const v = normalize && typeof raw !== 'object' ? raw : groupKey(raw);
-                    let next = node.get(v);
-                    if (!next) {
-                        next = new Map();
-                        node.set(v, next);
-                    }
-                    node = next;
-                }
-                const raw = reads[last](i);
-                const v = normalize && typeof raw !== 'object' ? raw : groupKey(raw);
-                let at = node.get(v);
-                if (at === undefined) {
-                    at = firstRow.length;
-                    node.set(v, at);
-                    firstRow.push(i);
-                    sectionOf.push(s);
-                }
-                g = at;
-            }
-            groupOf[i] = g;
-        }
-    }
-    return { groupOf, firstRow, sectionOf };
-}
 function aggregate({ table, bounds }, step) {
     const { groupby = [], ops } = step;
     const n = table.length;
@@ -697,39 +647,6 @@ function aggregateColumn(table, agg, groupOf, groups) {
     }
     return sums.column(groups);
 }
-// Rows in start order, ties in the order they came: a start and a row packed
-// into one double and sorted without a comparator, which leaves the typed
-// sort's fast path only where the packing could not be exact.
-function sortByStart(rows, starts) {
-    const n = rows.length;
-    let lo = Infinity;
-    let hi = -Infinity;
-    let whole = true;
-    for (let k = 0; k < n; k++) {
-        const v = starts[rows[k]];
-        if (v < lo) {
-            lo = v;
-        }
-        if (v > hi) {
-            hi = v;
-        }
-        whole &&= Number.isInteger(v);
-    }
-    if (whole && (hi - lo + 1) * n < Number.MAX_SAFE_INTEGER) {
-        const keys = new Float64Array(n);
-        for (let k = 0; k < n; k++) {
-            keys[k] = (starts[rows[k]] - lo) * n + k;
-        }
-        keys.sort();
-        const placed = Uint32Array.from(rows);
-        for (let k = 0; k < n; k++) {
-            rows[k] = placed[keys[k] % n];
-        }
-    }
-    else {
-        rows.sort((a, b) => starts[a] - starts[b] || a - b);
-    }
-}
 /**
  * The lowest row each row fits on, greedy first fit in start order within its
  * section, as a step in front of the encoder rather than a packer behind it.
@@ -900,6 +817,9 @@ function runStep(staged, step, jexl) {
         case 'aggregate': {
             return aggregate(staged, step);
         }
+        case 'window': {
+            return windowStep(staged, step);
+        }
         case 'coverage': {
             return coverage(staged, step);
         }
@@ -1021,6 +941,15 @@ function keepingSection(staged, steps, field, labels) {
         }
         : staged;
 }
+// The counting sort's row order: each section's rows in arrival order.
+function sectionOrder(keyOfRow, sectionOf, bounds) {
+    const next = bounds.slice(0, sectionOf.length);
+    const order = new Uint32Array(keyOfRow.length);
+    for (let i = 0; i < keyOfRow.length; i++) {
+        order[next[sectionOf[keyOfRow[i]]]++] = i;
+    }
+    return order;
+}
 /**
  * #api
  * A faceted request's layers: the rows split on the facet's field, the
@@ -1042,31 +971,54 @@ export function facetLayers(input, facet, layers, jexl) {
     const categories = categoricalField(field);
     const n = table.length;
     const sectionOfKey = new Map();
-    const keyOfRow = new Uint32Array(n);
     const keys = [];
+    const countOfKey = [];
     const keyIndex = (key) => {
         let k = sectionOfKey.get(key);
         if (k === undefined) {
             k = keys.length;
             sectionOfKey.set(key, k);
             keys.push(key);
+            countOfKey.push(0);
         }
         return k;
     };
+    // Runs of one key down the rows: as many as the keys exactly when each
+    // key's rows arrive together, as a multi-source adapter's do.
+    let runs = 0;
+    let keyOfRow;
     const column = isPlainFieldRef(field) ? table.column(field) : undefined;
     if (column?.kind === 'category') {
-        // A label's key is filed once, and each row looks its code up.
+        // Counted per code, and a label's key filed once, in arrival order; the
+        // row-by-row keys are read only for a table that needs reordering.
         const { codes, labels, at } = column;
-        const ofCode = new Int32Array(labels.length).fill(-1);
+        const countOfCode = new Uint32Array(labels.length);
+        const arrived = [];
+        let prev = -1;
         for (let i = 0; i < n; i++) {
             const code = codes[at ? at[i] : i];
-            let k = ofCode[code];
-            if (k < 0) {
-                k = keyIndex(categories.key(labels[code]));
-                ofCode[code] = k;
+            if (code !== prev) {
+                if (countOfCode[code] === 0) {
+                    arrived.push(code);
+                }
+                runs++;
+                prev = code;
             }
-            keyOfRow[i] = k;
-        }
+            countOfCode[code]++;
+        }
+        const keyOfCode = new Uint32Array(labels.length);
+        for (const code of arrived) {
+            const k = keyIndex(categories.key(labels[code]));
+            keyOfCode[code] = k;
+            countOfKey[k] += countOfCode[code];
+        }
+        keyOfRow = () => {
+            const keyOf = new Uint32Array(n);
+            for (let i = 0; i < n; i++) {
+                keyOf[i] = keyOfCode[codes[at ? at[i] : i]];
+            }
+            return keyOf;
+        };
     }
     else {
         const read = column
@@ -1075,9 +1027,16 @@ export function facetLayers(input, facet, layers, jexl) {
                 const r = fieldReader(field, jexl);
                 return (i) => r(table.row(i));
             })();
+        const keyOf = new Uint32Array(n);
         for (let i = 0; i < n; i++) {
-            keyOfRow[i] = keyIndex(categories.key(read(i)));
+            const k = keyIndex(categories.key(read(i)));
+            keyOf[i] = k;
+            countOfKey[k]++;
+            if (i === 0 || k !== keyOf[i - 1]) {
+                runs++;
+            }
         }
+        keyOfRow = () => keyOf;
     }
     const ordered = [...keys.keys()].sort((a, b) => categories.compare(keys[a], keys[b]));
     const sectionOf = new Uint32Array(keys.length);
@@ -1085,19 +1044,19 @@ export function facetLayers(input, facet, layers, jexl) {
         sectionOf[k] = s;
     }
     const bounds = new Uint32Array(keys.length + 1);
-    for (let i = 0; i < n; i++) {
-        bounds[sectionOf[keyOfRow[i]] + 1]++;
-    }
-    for (let s = 0; s < keys.length; s++) {
-        bounds[s + 1] = bounds[s + 1] + bounds[s];
-    }
-    const next = bounds.slice(0, keys.length);
-    const order = new Uint32Array(n);
-    for (let i = 0; i < n; i++) {
-        order[next[sectionOf[keyOfRow[i]]]++] = i;
+    for (const [s, k] of ordered.entries()) {
+        bounds[s + 1] = bounds[s] + countOfKey[k];
     }
+    // Rows arriving grouped, in section order, reach the steps as the table
+    // they came in rather than through a row view.
+    const inSectionOrder = runs === keys.length && ordered.every((k, s) => k === s);
     const labels = ordered.map(k => keys[k]);
-    const layered = runLayers({ table: selectRows(table, order), bounds }, sectionSteps, layers.map(({ transform }) => transform), jexl, (staged, steps) => keepingSection(staged, steps, field, labels));
+    const layered = runLayers({
+        table: inSectionOrder
+            ? table
+            : selectRows(table, sectionOrder(keyOfRow(), sectionOf, bounds)),
+        bounds,
+    }, sectionSteps, layers.map(({ transform }) => transform), jexl, (staged, steps) => keepingSection(staged, steps, field, labels));
     const placed = layers.map(({ row }, l) => {
         const out = layered[l];
         const readRow = row === undefined
@@ -1108,8 +1067,9 @@ export function facetLayers(input, facet, layers, jexl) {
                     const r = fieldReader(row, jexl);
                     return (i) => r(out.table.row(i));
                 })();
-        const local = new Uint32Array(out.table.length);
+        let local;
         if (readRow) {
+            local = new Uint32Array(out.table.length);
             for (let i = 0; i < local.length; i++) {
                 local[i] = rowOf(readRow(i));
             }
@@ -1118,6 +1078,9 @@ export function facetLayers(input, facet, layers, jexl) {
     });
     const rowCount = new Uint32Array(keys.length).fill(1);
     for (const { bounds: b, local } of placed) {
+        if (!local) {
+            continue;
+        }
         for (let s = 0; s < keys.length; s++) {
             for (let i = b[s]; i < b[s + 1]; i++) {
                 if (local[i] + 1 > rowCount[s]) {
@@ -1138,8 +1101,13 @@ export function facetLayers(input, facet, layers, jexl) {
         layers: placed.map(({ table: t, bounds: b, local }) => {
             const rows = new Uint32Array(t.length);
             for (let s = 0; s < keys.length; s++) {
-                for (let i = b[s]; i < b[s + 1]; i++) {
-                    rows[i] = firstRow[s] + local[i];
+                if (local) {
+                    for (let i = b[s]; i < b[s + 1]; i++) {
+                        rows[i] = firstRow[s] + local[i];
+                    }
+                }
+                else {
+                    rows.fill(firstRow[s], b[s], b[s + 1]);
                 }
             }
             return { table: t, rows };
@@ -1158,28 +1126,6 @@ export function runTransforms(input, steps, jexl) {
     return runSteps({ table, bounds: oneSection(table.length) }, steps, jexl)
         .table;
 }
-// The fields a step writes onto its rows, which a partition on one of them
-// has to wait for; none for a step that must see every row at once.
-function writes(step) {
-    switch (step.type) {
-        case 'filter': {
-            return [];
-        }
-        case 'formula': {
-            return [step.as];
-        }
-        case 'bin': {
-            const as = step.as ?? DEFAULT_BIN_AS;
-            return step.fields ? [...as, BIN_OVERLAP_FIELD] : as;
-        }
-        case 'cells': {
-            return ['start', 'end', 'state', 'base', 'match', 'length'];
-        }
-        default: {
-            return undefined;
-        }
-    }
-}
 /**
  * How many of `steps` must run before rows can be split on `field`: the rest
  * each read a row and answer rows of it in order without writing `field`, so
@@ -1193,7 +1139,11 @@ function partitionPoint(steps, field) {
         return steps.length;
     }
     let at = steps.length;
-    while (at > 0 && writes(steps[at - 1])?.includes(field) === false) {
+    while (at > 0) {
+        const step = steps[at - 1];
+        if (!isRowwise(step) || stepWrites(step).some(w => w.field === field)) {
+            break;
+        }
         at--;
     }
     return at;

package/esm/util/fileHandleStore.js

@@ -8,6 +8,11 @@ function getDB() {
         upgrade(db) {
             db.createObjectStore(STORE_NAME);
         },
+        // the browser closed the connection (site data cleared while the page was
+        // open); without this every later pick reuses the dead handle and throws
+        terminated() {
+            dbPromise = undefined;
+        },
     }).catch((error) => {
         // drop the rejected promise, so a transient open failure (a blocked
         // upgrade, a storage prompt the user has since answered) doesn't make every

package/esm/util/groupKeys.d.ts

@@ -29,14 +29,15 @@ export declare function compareGroupKeys(a: string, b: string): number;
  */
 export declare function groupKeyComparator(domain?: readonly string[]): typeof compareGroupKeys;
 /**
- * The domain a re-pick keeps: a facet set from a menu or dialog names no
- * domain, so one naming the field the current facet already reads carries
- * the current order along. A reorder names its own domain and passes
- * through, an empty one included.
+ * The order and hidden sections a re-pick keeps: a facet set from a menu or
+ * dialog names neither, so one naming the field the current facet already
+ * reads carries the current `domain` and `hidden` along. A member the next
+ * facet names passes through, an empty one included.
  */
 export declare function carryGroupDomain<T extends {
     field: string;
     domain?: readonly string[];
+    hidden?: readonly string[];
 }>(next: T | undefined, current: T | undefined): T | undefined;
 /**
  * The overflow bucket's chip. Says MERGED because that lane is the one entry

package/esm/util/groupKeys.js

@@ -102,17 +102,23 @@ export function groupKeyComparator(domain) {
     };
 }
 /**
- * The domain a re-pick keeps: a facet set from a menu or dialog names no
- * domain, so one naming the field the current facet already reads carries
- * the current order along. A reorder names its own domain and passes
- * through, an empty one included.
+ * The order and hidden sections a re-pick keeps: a facet set from a menu or
+ * dialog names neither, so one naming the field the current facet already
+ * reads carries the current `domain` and `hidden` along. A member the next
+ * facet names passes through, an empty one included.
  */
 export function carryGroupDomain(next, current) {
-    return next !== undefined &&
-        next.domain === undefined &&
-        current?.domain !== undefined &&
-        next.field === current.field
-        ? { ...next, domain: current.domain }
+    if (next === undefined || next.field !== current?.field) {
+        return next;
+    }
+    const domain = next.domain === undefined && current.domain !== undefined
+        ? { domain: current.domain }
+        : {};
+    const hidden = next.hidden === undefined && current.hidden?.length
+        ? { hidden: current.hidden }
+        : {};
+    return Object.keys(domain).length || Object.keys(hidden).length
+        ? { ...next, ...domain, ...hidden }
         : next;
 }
 /**

package/esm/util/index.js

@@ -116,7 +116,7 @@ export function isSupportedIndexingAdapter(type = '') {
 // Still an object rather than a Map because this is on the plugin ABI — a Map
 // would leave `Object.entries` on a published plugin returning [] and silently
 // doing nothing. So integer-like keys still hoist ahead of the rest; anything
-// needing insertion order builds its own Map (see tree-sidebar's CLAUDE.md).
+// needing insertion order builds its own Map (reference/TREE_SIDEBAR.md).
 export function groupBy(array, predicate) {
     const result = Object.create(null);
     // eslint-disable-next-line unicorn/prefer-group-by -- Object.groupBy types its result Partial, which would widen every caller's Object.values to `T[] | undefined`

package/esm/util/installFetch.d.ts

@@ -163,8 +163,8 @@ interface InstallFetchOptionsBase<TArgs, TResult> extends FetchPhases<TArgs, TRe
     loadedKey?: () => unknown;
     /**
      * The predicate form of the freshness gate, for a fetch whose "I have exactly
-     * this already" is not key equality: the density tier holds bins over a
-     * buffered read and answers a viewport those bins *contain*, which no key can
+     * this already" is not key equality: `CoarseTierMixin` holds payloads over a
+     * buffered read and answers a viewport that read *contains*, which no key can
      * spell. Same rules as `fetchKey` — declined runs report `declined`, and a
      * `reloadCounter` advanced since the last issued fetch overrides it — so the
      * comparison lives here and not in `prepare`, where a reload could not reach

package/esm/util/installPrerequisiteFetch.d.ts

@@ -25,12 +25,17 @@ export interface AdapterRead<T> {
     adapterConfig: Record<string, unknown>;
     value: T;
 }
+/**
+ * Whether `read` answers the adapter config `host` holds. Equal by value, as
+ * the fetch key is: an undo rebuilds the track's config, handing back an equal
+ * adapter config the fetch declines to read again.
+ */
+export declare function isCurrentRead<T>(host: {
+    adapterConfig: Record<string, unknown>;
+}, read: AdapterRead<T> | undefined): read is AdapterRead<T>;
 /**
  * `read`'s value while it answers the adapter config `host` holds; undefined
  * until a read of that config commits, which a failed read never does.
- *
- * Equal by value, as the fetch key is: an undo rebuilds the track's config,
- * handing back an equal adapter config the fetch declines to read again.
  */
 export declare function readFor<T>(host: {
     adapterConfig: Record<string, unknown>;

package/esm/util/installPrerequisiteFetch.js

@@ -1,18 +1,20 @@
 import { isAlive } from '@jbrowse/mobx-state-tree';
 import { installFetch } from './installFetch.js';
 import { isDataCurrent } from './isDataCurrent.js';
+/**
+ * Whether `read` answers the adapter config `host` holds. Equal by value, as
+ * the fetch key is: an undo rebuilds the track's config, handing back an equal
+ * adapter config the fetch declines to read again.
+ */
+export function isCurrentRead(host, read) {
+    return (read !== undefined && isDataCurrent(read.adapterConfig, host.adapterConfig));
+}
 /**
  * `read`'s value while it answers the adapter config `host` holds; undefined
  * until a read of that config commits, which a failed read never does.
- *
- * Equal by value, as the fetch key is: an undo rebuilds the track's config,
- * handing back an equal adapter config the fetch declines to read again.
  */
 export function readFor(host, read) {
-    return read !== undefined &&
-        isDataCurrent(read.adapterConfig, host.adapterConfig)
-        ? read.value
-        : undefined;
+    return isCurrentRead(host, read) ? read.value : undefined;
 }
 /**
  * A **prerequisite read**: one RPC about the adapter itself, beside the

package/esm/util/io/RemoteFileWithRangeCache.d.ts

@@ -7,4 +7,4 @@
  * imports `clearCache` from this path directly, and `@jbrowse/core/util/io`
  * re-exports the two classes from here.
  */
-export { CachedFilehandle, RemoteFileWithRangeCache, clearCache, sweepIdleCache, } from '@gmod/range-cache-filehandle';
+export { CachedFilehandle, RemoteFileWithRangeCache, clearCache, clearCacheFor, sweepIdleCache, } from '@gmod/range-cache-filehandle';

package/esm/util/io/RemoteFileWithRangeCache.js

@@ -7,4 +7,4 @@
  * imports `clearCache` from this path directly, and `@jbrowse/core/util/io`
  * re-exports the two classes from here.
  */
-export { CachedFilehandle, RemoteFileWithRangeCache, clearCache, sweepIdleCache, } from '@gmod/range-cache-filehandle';
+export { CachedFilehandle, RemoteFileWithRangeCache, clearCache, clearCacheFor, sweepIdleCache, } from '@gmod/range-cache-filehandle';

package/esm/util/jexl.js

@@ -131,7 +131,7 @@ export default function JexlF( /* config?: any*/) {
         // BAM features expose a targeted `getTag` that walks the tag block and
         // decodes only the requested tag; `get('tags')` decodes every tag on the
         // read (a Record allocation plus NM/AS/ms/de/… — often ~10 per read) to
-        // answer one, and this runs per feature on colour/label callbacks like
+        // answer one, and this runs per feature on color/label callbacks like
         // `jexl:getTag(feature,'HP')`. Same duck-typing as
         // `@jbrowse/modifications-utils`' getTag(), which core cannot import (that
         // package depends on core). Unwrap first: on a jexlFeatureProxy every

package/esm/util/layouts/GranularRectLayout.d.ts

@@ -1,3 +1,8 @@
+interface LowerSpan {
+    top: number;
+    left: number;
+    right: number;
+}
 export default class GranularRectLayout {
     private pitchX;
     private pitchY;
@@ -23,10 +28,21 @@ export default class GranularRectLayout {
      * @returns top position for the rect, or Null if laying
      *  out the rect would exceed maxHeight
      */
-    addRect(id: string, left: number, right: number, height: number, lower?: {
-        top: number;
+    addRect(id: string, left: number, right: number, height: number, lower?: LowerSpan): number | null;
+    /**
+     * Lays out rects, none of them placed yet, at one shared top: the lowest
+     * where every one fits. For the pieces of one feature drawn apart.
+     */
+    addRectsAtOneTop(rects: readonly {
+        id: string;
         left: number;
         right: number;
-    }): number | null;
+        height: number;
+        lower?: LowerSpan;
+    }[]): number | null;
+    private placement;
+    private firstFit;
+    private commit;
     private getOrCreateRow;
 }
+export {};