@jbrowse/wiggle-core 4.3.0 → 5.0.0-beta.10

package/esm/autoscale.js

@@ -1,19 +1,20 @@
-// Default autoscale modes shared by wiggle / multi-wiggle. The alignments
-// coverage band exposes only a subset and a dynamic σ value, so it passes its
-// own option list.
-//
-// Here rather than beside the menu that renders it because a `[value, label]`
-// table is the one thing a menu holds that something outside the app needs to
-// read: the website's figure recipes name these labels in a click path, and a
-// module importing React or a lazy .tsx cannot be loaded by the node script
-// that builds them. A leaf module makes the recipe import the label instead of
-// retyping it, which is the difference between a copy that drifts and one that
-// cannot.
-export const DEFAULT_AUTOSCALE_OPTIONS = [
-    ['local', 'Local'],
-    ['localpercentile', 'Local (99th percentile)'],
-    ['localsd', 'Local ± 3σ'],
-];
+import { quantileExtent } from '@jbrowse/core/util/quantileExtent';
+/** The wiggle packer's arrays as a span, under a summary mode. */
+export function datasetSpan({ data, visStart, visEnd }, summaryScoreMode) {
+    const { low, high } = boundArrays(summaryScoreMode);
+    return {
+        count: data.numFeatures,
+        starts: data.featurePositions,
+        ends: data.featurePositions,
+        stride: 2,
+        endOffset: 1,
+        low: low(data),
+        high: high(data),
+        visStart,
+        visEnd,
+        sortedBins: true,
+    };
+}
 /**
  * #api
  * Per-feature scalar score array for a summary mode: the min/max summary array
@@ -32,9 +33,8 @@ function overlaps(fStart, fEnd, visStart, visEnd) {
 }
 // Which per-feature array each end of the domain comes from. Whiskers spreads
 // the two ends across the min/max summary arrays; every other mode draws both
-// from a single scalar. One table because `computeScoreStats` and the
-// percentile histogram have to agree — a domain whose extent and whose clipped
-// bound were measured off different arrays is a domain that clips its own data.
+// from a single scalar. One table because the extent and the clipped bound have
+// to read the same arrays, or a domain clips its own data.
 function boundArrays(summaryScoreMode) {
     const useWhiskers = summaryScoreMode === 'whiskers';
     return {
@@ -46,18 +46,15 @@ function boundArrays(summaryScoreMode) {
             : getEffectiveScores(data, summaryScoreMode),
     };
 }
-// Bin count for the approximate percentile histogram. 1024 bins gives ~0.1%
-// resolution on the domain, which is finer than any autoscale needs and keeps
-// the second pass O(n) with a fixed, trivial allocation.
-const NUM_HISTOGRAM_BINS = 1024;
-// First index whose feature STARTS at or after `bp`. `featurePositions` is
-// sorted by start — the same property `findFeatureAtBp` binary-searches on.
-function lowerBoundByStart(featurePositions, numFeatures, bp) {
+// First index whose instance STARTS at or after `bp`. `starts` is sorted by
+// start — the same property `findFeatureAtBp` binary-searches on.
+function lowerBoundByStart(span, bp) {
+    const { starts, stride } = span;
     let lo = 0;
-    let hi = numFeatures;
+    let hi = span.count;
     while (lo < hi) {
         const mid = (lo + hi) >> 1;
-        if (featurePositions[mid * 2] >= bp) {
+        if (starts[mid * stride] >= bp) {
             hi = mid;
         }
         else {
@@ -67,186 +64,114 @@ function lowerBoundByStart(featurePositions, numFeatures, bp) {
     return lo;
 }
 /**
- * The half-open index range that can overlap `[visStart, visEnd)`.
- *
- * A fetch covers `bufferedVisibleRegions` — the viewport plus half a screen on
- * each side — so roughly half of what these passes walk is off-screen, and
- * `localpercentile` (the default) walks it two or three times over. Both bounds
- * come from a binary search on the sorted starts instead.
- *
- * The upper bound needs nothing but that sortedness: a feature starting at or
- * after `visEnd` cannot reach back into the window. The lower bound also leans
- * on wiggle features being non-overlapping bins — bigWig summary levels and
- * bedGraph both are — walking back over any run that does reach in. The callers
- * still test `overlaps` per feature inside the range, so a dataset that broke
- * that assumption could only lose a long early feature, never gain one.
+ * The half-open index range that can overlap `[visStart, visEnd)`. Over
+ * `sortedBins` a binary search bounds it, walking back over any bin that
+ * reaches into the window; any other span is walked whole, and every caller
+ * tests `overlaps` per instance inside the range.
  */
-function visibleIndexRange(featurePositions, numFeatures, visStart, visEnd) {
-    if (visStart === undefined || visEnd === undefined) {
-        return { from: 0, to: numFeatures };
+function visibleIndexRange(span) {
+    const { visStart, visEnd, ends, stride, endOffset, sortedBins } = span;
+    if (!sortedBins || visStart === undefined || visEnd === undefined) {
+        return { from: 0, to: span.count };
     }
-    const to = lowerBoundByStart(featurePositions, numFeatures, visEnd);
-    let from = lowerBoundByStart(featurePositions, numFeatures, visStart);
-    while (from > 0 && featurePositions[(from - 1) * 2 + 1] > visStart) {
+    const to = lowerBoundByStart(span, visEnd);
+    let from = lowerBoundByStart(span, visStart);
+    while (from > 0 && ends[(from - 1) * stride + endOffset] > visStart) {
         from--;
     }
     return { from, to };
 }
-// Min/max/mean/stddev of the visible features for a summary mode, in one pass.
-// Exported (not #api — internal plumbing shared with the wiggle displays) so a
-// caller needing both a domain and the raw extent computes the stats once and
-// feeds them to autoscaleDomainFromStats instead of walking the arrays twice.
-export function computeScoreStats(summaryScoreMode, datasets) {
-    const { low, high } = boundArrays(summaryScoreMode);
+// Half-open overlap test against the span's own window, for the drawn
+// instances the index range admits.
+function spanOverlaps(span, i) {
+    const { visStart, visEnd, starts, ends, stride, endOffset, drawnKeys } = span;
+    return ((drawnKeys === undefined || drawnKeys[span.row?.[i] ?? 0] === 1) &&
+        (visStart === undefined ||
+            visEnd === undefined ||
+            overlaps(starts[i * stride], ends[i * stride + endOffset], visStart, visEnd)));
+}
+// The extremes of the visible instances, in one pass. Exported (not #api —
+// internal plumbing shared with the quantitative displays) so a caller needing
+// both a domain and the raw extent computes them once and feeds them to
+// `autoscaleDomainFromSpans` instead of walking the arrays twice.
+export function computeSpanStats(spans) {
     let min = Infinity;
     let max = -Infinity;
-    let sum = 0;
-    let sumSq = 0;
-    let count = 0;
-    for (const { data, visStart, visEnd } of datasets) {
-        const { featureScores, featurePositions, numFeatures } = data;
-        // Selecting the arrays once per dataset keeps the mode check out of the
-        // per-feature loop.
-        const minScores = low(data);
-        const maxScores = high(data);
-        const { from, to } = visibleIndexRange(featurePositions, numFeatures, visStart, visEnd);
+    for (const span of spans) {
+        const { low, high } = span;
+        const { from, to } = visibleIndexRange(span);
         for (let i = from; i < to; i++) {
-            if (visStart !== undefined &&
-                visEnd !== undefined &&
-                !overlaps(featurePositions[i * 2], featurePositions[i * 2 + 1], visStart, visEnd)) {
+            if (!spanOverlaps(span, i)) {
                 continue;
             }
-            min = Math.min(min, minScores[i]);
-            max = Math.max(max, maxScores[i]);
-            // Mean/stddev always use featureScores (the average) regardless of
-            // summaryScoreMode; min/max for the domain bounds come from the mode-
-            // selected arrays above. Intentional: sd-based autoscale centers on the
-            // average-value distribution even in whiskers/min/max summary modes.
-            const avg = featureScores[i];
-            sum += avg;
-            sumSq += avg * avg;
-            count++;
+            // Non-finite values are skipped rather than folded in: a wig file may
+            // carry a NaN, and one of them poisons min/max, collapsing the whole
+            // domain to the [0, 1] stub the callers fall back to.
+            const lo = low[i];
+            if (Number.isFinite(lo)) {
+                min = Math.min(min, lo);
+            }
+            const hi = high[i];
+            if (Number.isFinite(hi)) {
+                max = Math.max(max, hi);
+            }
         }
     }
-    if (count === 0 || !Number.isFinite(min) || !Number.isFinite(max)) {
-        return undefined;
-    }
-    const mean = sum / count;
-    const stdDev = Math.sqrt(Math.max(0, sumSq / count - mean * mean));
-    return { scoreMin: min, scoreMax: max, scoreMean: mean, scoreStdDev: stdDev };
+    return Number.isFinite(min) && Number.isFinite(max)
+        ? { scoreMin: min, scoreMax: max }
+        : undefined;
+}
+/** `computeSpanStats` over the wiggle packer's datasets. */
+export function computeScoreStats(summaryScoreMode, datasets) {
+    return computeSpanStats(datasets.map(d => datasetSpan(d, summaryScoreMode)));
 }
 /**
  * #api
- * Converts score stats into a `[min, max]` domain, applying std-dev
- * expansion for the `localsd` autoscale type.
+ * The domain the visible instances autoscale to: at a `quantile` of 1 their
+ * extremes, `stats`; below it `quantileExtent`'s ends, the bottom read off
+ * the `low`s and the top off the `high`s less the zeros where any is
+ * positive, so whiskers open to their spread, a sparse window's empty bins
+ * lower no top, and a window of nothing above 0 keeps the top it has.
  */
-export function domainFromStats(stats, autoscaleType, numStdDev) {
-    if (autoscaleType === 'localsd') {
-        const { scoreMean, scoreStdDev, scoreMin } = stats;
-        return [
-            scoreMin >= 0 ? 0 : scoreMean - numStdDev * scoreStdDev,
-            scoreMean + numStdDev * scoreStdDev,
-        ];
+export function autoscaleDomainFromSpans({ stats, quantile, spans, }) {
+    if (quantile >= 1) {
+        return [stats.scoreMin, stats.scoreMax];
     }
-    return [stats.scoreMin, stats.scoreMax];
-}
-// The `quantile`-th percentile magnitude of one signed side of the score
-// distribution: features are filtered to a single sign (`positiveSide`), their
-// magnitudes binned over `[0, maxMag]`, and the magnitude below which `quantile`
-// of that side's mass falls is returned — clipping the outermost `1 - quantile`
-// as outliers. Returns 0 when the side is empty. A fixed histogram keeps this an
-// O(n) pass with no sort, approximate to ~1/NUM_HISTOGRAM_BINS of maxMag, far
-// finer than the display needs.
-function sideMagnitudePercentile(datasets, scoresFor, positiveSide, maxMag, quantile) {
-    if (maxMag <= 0) {
-        return 0;
-    }
-    const bins = new Int32Array(NUM_HISTOGRAM_BINS);
-    const scale = NUM_HISTOGRAM_BINS / maxMag;
-    let count = 0;
-    for (const { data, visStart, visEnd } of datasets) {
-        const { featurePositions, numFeatures } = data;
-        const scores = scoresFor(data);
-        const { from, to } = visibleIndexRange(featurePositions, numFeatures, visStart, visEnd);
+    const lows = [];
+    const highs = [];
+    for (const span of spans) {
+        const { low, high } = span;
+        const { from, to } = visibleIndexRange(span);
         for (let i = from; i < to; i++) {
-            if (visStart !== undefined &&
-                visEnd !== undefined &&
-                !overlaps(featurePositions[i * 2], featurePositions[i * 2 + 1], visStart, visEnd)) {
+            if (!spanOverlaps(span, i)) {
                 continue;
             }
-            const mag = positiveSide ? scores[i] : -scores[i];
-            if (mag > 0) {
-                const bin = Math.min(NUM_HISTOGRAM_BINS - 1, Math.floor(mag * scale));
-                bins[bin]++;
-                count++;
-            }
+            lows.push(low[i]);
+            highs.push(high[i]);
         }
     }
-    if (count === 0) {
-        return 0;
-    }
-    const target = quantile * count;
-    let cumulative = 0;
-    for (let bin = 0; bin < NUM_HISTOGRAM_BINS; bin++) {
-        cumulative += bins[bin];
-        // +1 so the target bin is included rather than clipped.
-        if (cumulative >= target) {
-            return ((bin + 1) / NUM_HISTOGRAM_BINS) * maxMag;
-        }
-    }
-    return maxMag;
-}
-// Builds a `[low, high]` domain by clipping each side of the score distribution
-// to its central `quantile` fraction (e.g. 0.99 → clip the outermost 1% of each
-// sign). Unlike localsd it makes no normality assumption, so it stays robust on
-// the heavily skewed score distributions typical of coverage/wiggle data.
-//
-// The two signs are clipped INDEPENDENTLY, anchored at 0. A single combined
-// percentile spends its whole budget on the dominant side, so on strongly
-// one-sided signed data (e.g. phyloP: mostly-positive conservation with a
-// sparse, small negative tail) the minority tail's 1st percentile lands at or
-// above 0 and the negative extent collapses to a flat band. Measuring each
-// side's percentile from 0 outward keeps a small-but-real opposite tail visible.
-function percentileDomainFromHistogram(stats, summaryScoreMode, quantile, datasets) {
-    const { scoreMin, scoreMax } = stats;
-    if (scoreMax - scoreMin <= 0) {
-        return [scoreMin, scoreMax];
-    }
-    const arrays = boundArrays(summaryScoreMode);
-    const high = scoreMax > 0
-        ? sideMagnitudePercentile(datasets, arrays.high, true, scoreMax, quantile)
-        : 0;
-    const negExtent = scoreMin < 0
-        ? sideMagnitudePercentile(datasets, arrays.low, false, -scoreMin, quantile)
-        : 0;
-    // Anchor the low bound at 0 for all-positive data (matching localsd's origin
-    // convention); otherwise extend it to the negative side's clipped extent.
-    return [scoreMin < 0 ? -negExtent : 0, high];
+    const tops = highs.some(v => v > 0) ? highs.filter(v => v !== 0) : highs;
+    const min = quantileExtent(lows, lows.length, quantile)[0];
+    const max = quantileExtent(tops, tops.length, quantile)[1];
+    return [Number.isFinite(min) ? min : 0, Number.isFinite(max) ? max : 0];
 }
-// Turns already-computed stats into the displayed domain for the `local` /
-// `localsd` / `localpercentile` autoscale types. `localpercentile` re-walks the
-// entries to build its histogram; the other types read the stats alone.
-// computeAutoscaleDomain (#api) is the one-shot form.
-export function autoscaleDomainFromStats({ stats, autoscaleType, summaryScoreMode, numStdDev, numQuantile = 0.99, visibleEntries, }) {
-    return autoscaleType === 'localpercentile'
-        ? percentileDomainFromHistogram(stats, summaryScoreMode, numQuantile, visibleEntries)
-        : domainFromStats(stats, autoscaleType, numStdDev);
+/** `autoscaleDomainFromSpans` over the wiggle packer's datasets. */
+export function autoscaleDomainFromStats({ stats, quantile, summaryScoreMode, visibleEntries, }) {
+    return autoscaleDomainFromSpans({
+        stats,
+        quantile,
+        spans: visibleEntries.map(d => datasetSpan(d, summaryScoreMode)),
+    });
 }
 /**
  * #api
- * Computes a score domain from the visible feature arrays for the `local` /
- * `localsd` / `localpercentile` autoscale types.
+ * The score domain of the visible feature arrays, following `quantile` as
+ * `scales.y.domainQuantile` says.
  */
-export function computeAutoscaleDomain(autoscaleType, summaryScoreMode, numStdDev, visibleEntries, numQuantile = 0.99) {
-    const stats = computeScoreStats(summaryScoreMode, visibleEntries);
+export function computeAutoscaleDomain(quantile, summaryScoreMode, visibleEntries) {
+    const spans = visibleEntries.map(d => datasetSpan(d, summaryScoreMode));
+    const stats = computeSpanStats(spans);
     return stats
-        ? autoscaleDomainFromStats({
-            stats,
-            autoscaleType,
-            summaryScoreMode,
-            numStdDev,
-            numQuantile,
-            visibleEntries,
-        })
+        ? autoscaleDomainFromSpans({ stats, quantile, spans })
         : undefined;
 }

package/esm/autoscaleGroup.d.ts

@@ -0,0 +1,30 @@
+import type { IAnyStateTreeNode } from '@jbrowse/mobx-state-tree';
+/** A display whose value scale can autoscale beside others. */
+export interface AutoscaleGroupMember {
+    autoscaleGroup: string | undefined;
+    autoscaleRange: [number, number] | undefined;
+}
+/** A member the score menu can move into or out of a group. */
+export interface AutoscalePeer extends AutoscaleGroupMember {
+    setAutoscaleGroup: (group?: string) => void;
+}
+/**
+ * Every display in `node`'s view whose value scale names `group`, `node`
+ * among them.
+ */
+export declare function autoscaleGroupMembers(node: IAnyStateTreeNode, group: string): AutoscaleGroupMember[];
+/** The span every defined range covers; undefined where none is. */
+export declare function unionRanges(ranges: readonly ([number, number] | undefined)[]): [number, number] | undefined;
+/** The other displays in `node`'s view with a value scale, by track name. */
+export declare function autoscalePeers(node: IAnyStateTreeNode): {
+    display: AutoscalePeer;
+    key: string;
+    name: string;
+}[];
+/**
+ * Put `self` and `chosen` in one group, and take the group off every peer that
+ * held it and is not chosen. The group keeps `self`'s name, or a chosen
+ * peer's, and is named afresh where neither has one; choosing nobody takes
+ * `self` out of its group.
+ */
+export declare function autoscaleWith(self: AutoscalePeer, peers: readonly AutoscalePeer[], chosen: ReadonlySet<AutoscalePeer>): void;

package/esm/autoscaleGroup.js

@@ -0,0 +1,97 @@
+import { getConf } from '@jbrowse/core/configuration';
+import { getContainingTrack, getContainingView, } from '@jbrowse/core/util/mstUtils';
+import { hasParent, isStateTreeNode } from '@jbrowse/mobx-state-tree';
+function isMember(thing) {
+    return (typeof thing === 'object' &&
+        thing !== null &&
+        'autoscaleGroup' in thing &&
+        'autoscaleRange' in thing);
+}
+function isPeer(thing) {
+    return isMember(thing) && 'setAutoscaleGroup' in thing;
+}
+function displaysOf(track) {
+    return typeof track === 'object' &&
+        track !== null &&
+        'displays' in track &&
+        Array.isArray(track.displays)
+        ? track.displays
+        : [];
+}
+function containingView(node) {
+    if (!isStateTreeNode(node) || !hasParent(node)) {
+        return undefined;
+    }
+    try {
+        return getContainingView(node);
+    }
+    catch {
+        return undefined;
+    }
+}
+// A display standing outside any view, as a unit test builds one, shares its
+// axis with nothing.
+function viewDisplays(node) {
+    const view = containingView(node);
+    const tracks = view && 'tracks' in view && Array.isArray(view.tracks) ? view.tracks : [];
+    return tracks.flatMap(displaysOf);
+}
+/**
+ * Every display in `node`'s view whose value scale names `group`, `node`
+ * among them.
+ */
+export function autoscaleGroupMembers(node, group) {
+    return viewDisplays(node).filter((display) => isMember(display) && display.autoscaleGroup === group);
+}
+/** The span every defined range covers; undefined where none is. */
+export function unionRanges(ranges) {
+    let union;
+    for (const range of ranges) {
+        if (range) {
+            union = union
+                ? [Math.min(union[0], range[0]), Math.max(union[1], range[1])]
+                : [range[0], range[1]];
+        }
+    }
+    return union;
+}
+/** The other displays in `node`'s view with a value scale, by track name. */
+export function autoscalePeers(node) {
+    return viewDisplays(node).flatMap(display => {
+        if (!isPeer(display) || display === node) {
+            return [];
+        }
+        const track = getContainingTrack(display);
+        return [{ display, key: track.id, name: String(getConf(track, 'name')) }];
+    });
+}
+function freeGroupName(taken) {
+    let n = 1;
+    while (taken.has(`group${n}`)) {
+        n++;
+    }
+    return `group${n}`;
+}
+/**
+ * Put `self` and `chosen` in one group, and take the group off every peer that
+ * held it and is not chosen. The group keeps `self`'s name, or a chosen
+ * peer's, and is named afresh where neither has one; choosing nobody takes
+ * `self` out of its group.
+ */
+export function autoscaleWith(self, peers, chosen) {
+    const previous = self.autoscaleGroup;
+    const group = chosen.size === 0
+        ? undefined
+        : (previous ??
+            [...chosen].find(p => p.autoscaleGroup)?.autoscaleGroup ??
+            freeGroupName(new Set(peers.map(p => p.autoscaleGroup))));
+    self.setAutoscaleGroup(group);
+    for (const peer of peers) {
+        if (chosen.has(peer)) {
+            peer.setAutoscaleGroup(group);
+        }
+        else if (group !== undefined && peer.autoscaleGroup === previous) {
+            peer.setAutoscaleGroup(undefined);
+        }
+    }
+}

package/esm/chrome.d.ts

@@ -0,0 +1,5 @@
+export { AxisGutter, CrossHatchLines, CrossHatches, ScoreDomainCaption, ScoreRuleLines, ScoreRules, YScaleBar, YScaleBarOverlay, } from '@jbrowse/display-ui';
+export { makeResolutionSubMenuItem } from './ResolutionStepper.tsx';
+export { makePointSizeSubMenu, pointSizeAccess } from './pointSizeMenu.tsx';
+export type { PointSizeAccess } from './pointSizeMenu.tsx';
+export { default as SetMinMaxDialog } from './SetMinMaxDialog.tsx';

package/esm/chrome.js

@@ -0,0 +1,7 @@
+// What draws a score plot, kept out of the package entry so the entry's score
+// math and config mixins stay real in the RPC worker. A display imports these;
+// an adapter or an RPC method never does.
+export { AxisGutter, CrossHatchLines, CrossHatches, ScoreDomainCaption, ScoreRuleLines, ScoreRules, YScaleBar, YScaleBarOverlay, } from '@jbrowse/display-ui';
+export { makeResolutionSubMenuItem } from './ResolutionStepper.js';
+export { makePointSizeSubMenu, pointSizeAccess } from './pointSizeMenu.js';
+export { default as SetMinMaxDialog } from './SetMinMaxDialog.js';

package/esm/computeYTicks.d.ts

@@ -1,4 +1,4 @@
-import type { YScaleTicks } from './yScaleTicks.ts';
+import type { YScaleTicks } from '@jbrowse/display-ui/yScaleTicks';
 export declare function computeYTicks(opts: {
     height: number;
     domain: [number, number] | number[] | undefined;

package/esm/computeYTicks.js

@@ -1,6 +1,6 @@
-import { YSCALEBAR_LABEL_OFFSET } from './constants.js';
+import { YSCALEBAR_LABEL_OFFSET } from '@jbrowse/display-ui/yAxisConstants';
+import { axisPlotBox } from '@jbrowse/display-ui/yScaleTicks';
 import { getScale } from './scale.js';
-import { axisPlotBox } from './yScaleTicks.js';
 // Builds Y-axis tick positions for a wiggle-family display: tick values come
 // from d3's scale.ticks(4) at normal heights, or fall back to the domain
 // endpoints for short tracks / when the user opts into minimal ticks.
@@ -18,7 +18,8 @@ export function computeYTicks(opts) {
     const { yTop, yBottom } = axisPlotBox(height, offset);
     // A window whose scores are all one value (an all-zero coverage stretch) has
     // a domain of no width. d3 answers the midpoint for every input there while
-    // `makeScoreNormalizer` answers 0, and the renderer is the one to agree with.
+    // `makeScoreNormalizer` puts that value on the baseline, and the renderer is
+    // the one to agree with.
     if (domainMin === domainMax) {
         return { items: [{ value: domainMin, y: yBottom }], yTop, yBottom };
     }

package/esm/constants.d.ts

@@ -1,2 +1 @@
-export declare const YSCALEBAR_LABEL_OFFSET = 5;
-export declare const ONSCREEN_AXIS_LEFT_PX = 50;
+export { YSCALEBAR_LABEL_OFFSET } from '@jbrowse/display-ui/yAxisConstants';

package/esm/constants.js

@@ -1,10 +1 @@
-// Vertical inset the single-wiggle family reserves above and below the plot so
-// the top/bottom y-axis labels aren't clipped. Lives in its own module because
-// both index.ts (which re-exports computeYTicks) and computeYTicks.ts need it —
-// importing it from index.ts would close a cycle.
-export const YSCALEBAR_LABEL_OFFSET = 5;
-// Left indent of the on-screen y-axis overlay (single-wiggle / manhattan) and of
-// multi-wiggle's per-row scalebars. The axis is right-oriented on screen, so its
-// labels grow into the plot from here; the indent keeps them clear of the track
-// label. Export uses its own anchor (the content left edge).
-export const ONSCREEN_AXIS_LEFT_PX = 50;
+export { YSCALEBAR_LABEL_OFFSET } from '@jbrowse/display-ui/yAxisConstants';

package/esm/dataTypes.d.ts

@@ -1,3 +1,4 @@
+import type { ZoomRange } from '@jbrowse/core/data_adapters/BaseAdapter/zoomRange';
 export interface SourceInfo {
     name: string;
     color?: string;
@@ -13,14 +14,11 @@ export interface WiggleFeatureArrays {
     featureMaxScores: Float32Array;
     numFeatures: number;
     hasSummaryScores: boolean;
-    posFeaturePositions: Uint32Array;
-    posFeatureScores: Float32Array;
-    posNumFeatures: number;
-    negFeaturePositions: Uint32Array;
-    negFeatureScores: Float32Array;
-    negNumFeatures: number;
 }
 export type WiggleSourceData = SourceInfo & WiggleFeatureArrays;
 export interface WiggleDataResult {
     sources: WiggleSourceData[];
+    zoomRange?: ZoomRange;
+    /** The bounds the adapter's values lie in by definition (`getValueDomain`). */
+    valueDomain?: [number, number];
 }

package/esm/displayModel.d.ts

@@ -1,7 +1,7 @@
 import type { WiggleDataResult } from './dataTypes.ts';
 import type { WiggleRenderingBackend } from './renderingBackendTypes.ts';
-import type { YScaleTicks } from './yScaleTicks.ts';
 import type { RegionHost } from '@jbrowse/display-kit/regionHost';
+import type { YScaleTicks } from '@jbrowse/display-ui';
 import type { DisplayPhase } from '@jbrowse/render-core/displayPhase';
 import type { RenderLifecycleModel } from '@jbrowse/render-core/useRenderingBackend';
 export interface WiggleGpuDisplayModel<TRenderingBackend = WiggleRenderingBackend, TData = WiggleDataResult> extends RenderLifecycleModel<TRenderingBackend> {
@@ -20,5 +20,4 @@ export interface WiggleGpuDisplayModel<TRenderingBackend = WiggleRenderingBacken
     regionTooLargeReason: string;
     zoomCanReleaseGate: boolean;
     forceLoad: () => void;
-    showCrossHatches: boolean;
 }

package/esm/gapBreak.d.ts

@@ -5,9 +5,8 @@
  * draw. Returns `Infinity` when there is nothing to decide, so a caller can
  * always compare against it unguarded.
  *
- * The limit is a multiple of the series' own *mean* spacing rather than an
- * absolute distance, which is what makes one number work across zoom levels and
- * data types: reduced BigWig bins get wider as you zoom out, so any fixed bp
+ * The limit is a multiple of the series' *mean* spacing rather than an
+ * absolute distance, so one number works across zoom levels and data types: reduced BigWig bins get wider as you zoom out, so any fixed bp
  * threshold would be either useless at one end or destructive at the other. It
  * also lets the same rule serve a bp axis (wiggle's linecenter) and a px one —
  * the caller picks the space, this only cares that the units are consistent.

package/esm/gapBreak.js

@@ -5,9 +5,8 @@
  * draw. Returns `Infinity` when there is nothing to decide, so a caller can
  * always compare against it unguarded.
  *
- * The limit is a multiple of the series' own *mean* spacing rather than an
- * absolute distance, which is what makes one number work across zoom levels and
- * data types: reduced BigWig bins get wider as you zoom out, so any fixed bp
+ * The limit is a multiple of the series' *mean* spacing rather than an
+ * absolute distance, so one number works across zoom levels and data types: reduced BigWig bins get wider as you zoom out, so any fixed bp
  * threshold would be either useless at one end or destructive at the other. It
  * also lets the same rule serve a bp axis (wiggle's linecenter) and a px one —
  * the caller picks the space, this only cares that the units are consistent.