@jbrowse/wiggle-core 5.0.0-beta.8 → 5.0.0-beta.9

package/esm/WiggleScoreConfigMixin.d.ts

@@ -0,0 +1,89 @@
+import type { scalesSchema } from './valueScaleConfigSchema.ts';
+import type { ConfigModelForFields } from '@jbrowse/core/configuration';
+/** The slots its composers each declare, with their own defaults. */
+export declare const wiggleScoreConfigExtraSlots: {
+    readonly scatterPointSize: {
+        readonly type: 'number';
+        readonly defaultValue: 2;
+    };
+    readonly displayCrossHatches: {
+        readonly type: 'boolean';
+        readonly defaultValue: false;
+    };
+};
+export interface WiggleScoreConfigHost {
+    configuration: ConfigModelForFields<{
+        scales: ReturnType<typeof scalesSchema>;
+    } & typeof wiggleScoreConfigExtraSlots>;
+}
+/**
+ * #stateModel WiggleScoreConfigMixin
+ * #category display
+ *
+ * The score-plot config every display with a score axis shares: the axis
+ * (`ScoreScaleMixin`), the cross-hatch toggle and the scatter point size. A
+ * display plotting one configured field composes `ScoreFieldConfigMixin`,
+ * which adds `scoreField`.
+ */
+export declare function WiggleScoreConfigMixin(): import("@jbrowse/mobx-state-tree").IModelType<Omit<{}, never>, {
+    readonly scaleType: string;
+    readonly manualMinScore: number | undefined;
+    readonly manualMaxScore: number | undefined;
+    readonly defaultScoreDomain: [number | undefined, number | undefined];
+    readonly valueScales: import("@jbrowse/display-ui").ValueScale[];
+} & {
+    readonly minScoreBound: number | undefined;
+    readonly maxScoreBound: number | undefined;
+    readonly hasManualScoreBounds: boolean;
+    readonly axes: import("@jbrowse/display-ui").YAxis[];
+} & {
+    readonly scaleType: string;
+    readonly scaleTypeChoices: string[];
+    readonly autoscaleType: string | undefined;
+    readonly numStdDev: number;
+    readonly numQuantile: number;
+    readonly symlogConstant: number;
+    readonly manualMinScore: number | undefined;
+    readonly manualMaxScore: number | undefined;
+    readonly scaleTitle: string | undefined;
+    readonly scoreRulesDrawn: boolean;
+    readonly scoreRules: import("@jbrowse/display-ui").ValueScaleRule[];
+} & {
+    setScaleType(scaleType: string): void;
+    setAutoscale(val?: string): void;
+    setMinScore(val?: number): void;
+    setMaxScore(val?: number): void;
+    setScoreRules(rules: (number | import("@jbrowse/display-ui").ValueScaleRule)[]): void;
+} & {
+    /**
+     * #getter
+     */
+    readonly scatterPointSize: number;
+    /**
+     * #getter
+     * The configured cross-hatch setting the menu toggles; `showCrossHatches`
+     * is what draws.
+     */
+    readonly displayCrossHatches: boolean;
+    /**
+     * #getter
+     * Whether score maps to color instead of height; a display overrides it.
+     */
+    readonly isDensityMode: boolean;
+} & {
+    /**
+     * #action
+     */
+    toggleCrossHatches(): void;
+    /**
+     * #action
+     */
+    setScatterPointSize(val?: number): void;
+} & {
+    /**
+     * #getter
+     * Whether the score-axis cross hatches draw: never in density mode, which
+     * has no height axis to rule and no toggle in its menu.
+     */
+    readonly showCrossHatches: boolean;
+}, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;

package/esm/WiggleScoreConfigMixin.js

@@ -0,0 +1,69 @@
+import { getConf, setConf } from '@jbrowse/core/configuration';
+import { types } from '@jbrowse/mobx-state-tree';
+import { ScoreScaleMixin } from './ScoreScaleMixin.js';
+/** The slots its composers each declare, with their own defaults. */
+export const wiggleScoreConfigExtraSlots = {
+    scatterPointSize: { type: 'number', defaultValue: 2 },
+    displayCrossHatches: { type: 'boolean', defaultValue: false },
+};
+const confNode = (self) => self;
+/**
+ * #stateModel WiggleScoreConfigMixin
+ * #category display
+ *
+ * The score-plot config every display with a score axis shares: the axis
+ * (`ScoreScaleMixin`), the cross-hatch toggle and the scatter point size. A
+ * display plotting one configured field composes `ScoreFieldConfigMixin`,
+ * which adds `scoreField`.
+ */
+export function WiggleScoreConfigMixin() {
+    return types
+        .compose('WiggleScoreConfigMixin', ScoreScaleMixin(), types.model({}))
+        .views(self => ({
+        /**
+         * #getter
+         */
+        get scatterPointSize() {
+            return getConf(confNode(self), 'scatterPointSize');
+        },
+        /**
+         * #getter
+         * The configured cross-hatch setting the menu toggles; `showCrossHatches`
+         * is what draws.
+         */
+        get displayCrossHatches() {
+            return getConf(confNode(self), 'displayCrossHatches');
+        },
+        /**
+         * #getter
+         * Whether score maps to color instead of height; a display overrides it.
+         */
+        get isDensityMode() {
+            return false;
+        },
+    }))
+        .actions(self => ({
+        /**
+         * #action
+         */
+        toggleCrossHatches() {
+            setConf(confNode(self), 'displayCrossHatches', !self.displayCrossHatches);
+        },
+        /**
+         * #action
+         */
+        setScatterPointSize(val) {
+            setConf(confNode(self), 'scatterPointSize', val);
+        },
+    }))
+        .views(self => ({
+        /**
+         * #getter
+         * Whether the score-axis cross hatches draw: never in density mode, which
+         * has no height axis to rule and no toggle in its menu.
+         */
+        get showCrossHatches() {
+            return self.displayCrossHatches && !self.isDensityMode;
+        },
+    }));
+}

package/esm/autoscale.d.ts

@@ -18,6 +18,29 @@ export interface ScoreStats {
     scoreMean: number;
     scoreStdDev: number;
 }
+/**
+ * #api
+ * One block's worth of values to fold into a domain, whatever packed them: a
+ * wiggle source's interleaved `featurePositions` and its three summary arrays,
+ * or a mark layer's separate `x`/`x2` and its one `y` lane. `starts[i * stride]`
+ * and `ends[i * stride + endOffset]` give instance `i`'s span; `low`, `high` and
+ * `avg` give the two ends of its value and the one the mean is taken over, which
+ * are the same array wherever the packer ships a single scalar.
+ */
+export interface ScoreSpan {
+    count: number;
+    starts: Uint32Array;
+    ends: Uint32Array;
+    stride: number;
+    endOffset: number;
+    low: Float32Array;
+    high: Float32Array;
+    avg: Float32Array;
+    visStart?: number;
+    visEnd?: number;
+}
+/** The wiggle packer's arrays as a span, under a summary mode. */
+export declare function datasetSpan({ data, visStart, visEnd }: Dataset, summaryScoreMode: string): ScoreSpan;
 /**
  * #api
  * Per-feature scalar score array for a summary mode: the min/max summary array
@@ -28,16 +51,33 @@ export declare function getEffectiveScores(data: {
     featureMinScores: Float32Array;
     featureMaxScores: Float32Array;
 }, summaryScoreMode: string): Float32Array<ArrayBufferLike>;
+export declare function computeSpanStats(spans: ScoreSpan[]): ScoreStats | undefined;
+/** `computeSpanStats` over the wiggle packer's datasets. */
 export declare function computeScoreStats(summaryScoreMode: string, datasets: Dataset[]): ScoreStats | undefined;
 /**
  * #api
- * Converts score stats into a `[min, max]` domain, applying std-dev
- * expansion for the `localsd` autoscale type.
+ * Converts score stats into a `[min, max]` domain, applying std-dev expansion
+ * for the `localsd` autoscale type. An `undefined` mode is a display whose
+ * scale declares none, and takes the plain extremes.
  */
-export declare function domainFromStats(stats: ScoreStats, autoscaleType: string, numStdDev: number): [number, number];
+export declare function domainFromStats(stats: ScoreStats, autoscaleType: string | undefined, numStdDev: number): [number, number];
+/**
+ * #api
+ * Already-computed stats to the displayed domain, for the `local` / `localsd` /
+ * `localpercentile` autoscale modes. `localpercentile` re-walks the spans to
+ * build its histogram; the other modes read the stats alone.
+ */
+export declare function autoscaleDomainFromSpans({ stats, autoscaleType, numStdDev, numQuantile, spans, }: {
+    stats: ScoreStats;
+    autoscaleType: string | undefined;
+    numStdDev: number;
+    numQuantile?: number;
+    spans: ScoreSpan[];
+}): [number, number];
+/** `autoscaleDomainFromSpans` over the wiggle packer's datasets. */
 export declare function autoscaleDomainFromStats({ stats, autoscaleType, summaryScoreMode, numStdDev, numQuantile, visibleEntries, }: {
     stats: ScoreStats;
-    autoscaleType: string;
+    autoscaleType: string | undefined;
     summaryScoreMode: string;
     numStdDev: number;
     numQuantile?: number;
@@ -48,7 +88,7 @@ export declare function autoscaleDomainFromStats({ stats, autoscaleType, summary
  * Computes a score domain from the visible feature arrays for the `local` /
  * `localsd` / `localpercentile` autoscale types.
  */
-export declare function computeAutoscaleDomain(autoscaleType: string, summaryScoreMode: string, numStdDev: number, visibleEntries: {
+export declare function computeAutoscaleDomain(autoscaleType: string | undefined, summaryScoreMode: string, numStdDev: number, visibleEntries: {
     data: FeatureArrays;
     visStart: number;
     visEnd: number;

package/esm/autoscale.js

@@ -14,6 +14,22 @@ export const DEFAULT_AUTOSCALE_OPTIONS = [
     ['localpercentile', 'Local (99th percentile)'],
     ['localsd', 'Local ± 3σ'],
 ];
+/** 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),
+        avg: data.featureScores,
+        visStart,
+        visEnd,
+    };
+}
 /**
  * #api
  * Per-feature scalar score array for a summary mode: the min/max summary array
@@ -50,14 +66,15 @@ function boundArrays(summaryScoreMode) {
 // 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 {
@@ -81,60 +98,62 @@ function lowerBoundByStart(featurePositions, numFeatures, bp) {
  * 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.
  */
-function visibleIndexRange(featurePositions, numFeatures, visStart, visEnd) {
+function visibleIndexRange(span) {
+    const { visStart, visEnd, ends, stride, endOffset } = span;
     if (visStart === undefined || visEnd === undefined) {
-        return { from: 0, to: numFeatures };
+        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 instances the
+// index range admits.
+function spanOverlaps(span, i) {
+    const { visStart, visEnd, starts, ends, stride, endOffset } = span;
+    return (visStart === undefined ||
+        visEnd === undefined ||
+        overlaps(starts[i * stride], ends[i * stride + endOffset], visStart, visEnd));
+}
+// Min/max/mean/stddev 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 the stats 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, avg } = 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;
             }
-            // Non-finite scores are skipped rather than folded in: a wig file may
+            // Non-finite values are skipped rather than folded in: a wig file may
             // carry a NaN, and one of them poisons min/max and mean alike, collapsing
             // the whole domain to the [0, 1] stub the callers fall back to.
-            const lo = minScores[i];
+            const lo = low[i];
             if (Number.isFinite(lo)) {
                 min = Math.min(min, lo);
             }
-            const hi = maxScores[i];
+            const hi = high[i];
             if (Number.isFinite(hi)) {
                 max = Math.max(max, hi);
             }
-            // 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];
-            if (Number.isFinite(avg)) {
-                sum += avg;
-                sumSq += avg * avg;
+            // Mean/stddev always come from `avg` — the average score on the wiggle
+            // side — while min/max come from the mode-selected pair. Intentional:
+            // sd-based autoscale centers on the average-value distribution even in
+            // whiskers/min/max summary modes.
+            const mid = avg[i];
+            if (Number.isFinite(mid)) {
+                sum += mid;
+                sumSq += mid * mid;
                 count++;
             }
         }
@@ -146,10 +165,15 @@ export function computeScoreStats(summaryScoreMode, datasets) {
     const stdDev = Math.sqrt(Math.max(0, sumSq / count - mean * mean));
     return { scoreMin: min, scoreMax: max, scoreMean: mean, scoreStdDev: stdDev };
 }
+/** `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.
+ * Converts score stats into a `[min, max]` domain, applying std-dev expansion
+ * for the `localsd` autoscale type. An `undefined` mode is a display whose
+ * scale declares none, and takes the plain extremes.
  */
 export function domainFromStats(stats, autoscaleType, numStdDev) {
     if (autoscaleType === 'localsd') {
@@ -161,31 +185,28 @@ export function domainFromStats(stats, autoscaleType, numStdDev) {
     }
     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
+// The `quantile`-th percentile magnitude of one signed side of the value
+// distribution: instances 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) {
+function sideMagnitudePercentile(spans, valuesFor, 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);
+    for (const span of spans) {
+        const values = valuesFor(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];
+            const mag = positiveSide ? values[i] : -values[i];
             if (mag > 0) {
                 const bin = Math.min(NUM_HISTOGRAM_BINS - 1, Math.floor(mag * scale));
                 bins[bin]++;
@@ -207,10 +228,10 @@ function sideMagnitudePercentile(datasets, scoresFor, positiveSide, maxMag, quan
     }
     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
+// Builds a `[low, high]` domain by clipping each side of the value 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 heavily skewed 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
@@ -218,46 +239,57 @@ function sideMagnitudePercentile(datasets, scoresFor, positiveSide, maxMag, quan
 // 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) {
+function percentileDomainFromSpans(stats, quantile, spans) {
     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)
+        ? sideMagnitudePercentile(spans, span => span.high, true, scoreMax, quantile)
         : 0;
     const negExtent = scoreMin < 0
-        ? sideMagnitudePercentile(datasets, arrays.low, false, -scoreMin, quantile)
+        ? sideMagnitudePercentile(spans, span => span.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];
 }
-// 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, }) {
+/**
+ * #api
+ * Already-computed stats to the displayed domain, for the `local` / `localsd` /
+ * `localpercentile` autoscale modes. `localpercentile` re-walks the spans to
+ * build its histogram; the other modes read the stats alone.
+ */
+export function autoscaleDomainFromSpans({ stats, autoscaleType, numStdDev, numQuantile = 0.99, spans, }) {
     return autoscaleType === 'localpercentile'
-        ? percentileDomainFromHistogram(stats, summaryScoreMode, numQuantile, visibleEntries)
+        ? percentileDomainFromSpans(stats, numQuantile, spans)
         : domainFromStats(stats, autoscaleType, numStdDev);
 }
+/** `autoscaleDomainFromSpans` over the wiggle packer's datasets. */
+export function autoscaleDomainFromStats({ stats, autoscaleType, summaryScoreMode, numStdDev, numQuantile = 0.99, visibleEntries, }) {
+    return autoscaleDomainFromSpans({
+        stats,
+        autoscaleType,
+        numStdDev,
+        numQuantile,
+        spans: visibleEntries.map(d => datasetSpan(d, summaryScoreMode)),
+    });
+}
 /**
  * #api
  * Computes a score domain from the visible feature arrays for the `local` /
  * `localsd` / `localpercentile` autoscale types.
  */
 export function computeAutoscaleDomain(autoscaleType, summaryScoreMode, numStdDev, visibleEntries, numQuantile = 0.99) {
-    const stats = computeScoreStats(summaryScoreMode, visibleEntries);
+    const spans = visibleEntries.map(d => datasetSpan(d, summaryScoreMode));
+    const stats = computeSpanStats(spans);
     return stats
-        ? autoscaleDomainFromStats({
+        ? autoscaleDomainFromSpans({
             stats,
             autoscaleType,
-            summaryScoreMode,
             numStdDev,
             numQuantile,
-            visibleEntries,
+            spans,
         })
         : undefined;
 }

package/esm/chrome.d.ts

@@ -0,0 +1,4 @@
+export { AxisGutter, CrossHatchLines, CrossHatches, ScoreDomainCaption, ScoreRuleLines, ScoreRules, YScaleBar, YScaleBarOverlay, } from '@jbrowse/display-ui';
+export { makeResolutionSubMenuItem } from './ResolutionStepper.tsx';
+export { makePointSizeSubMenu, makeScatterPointSizeMenuItem, } 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, makeScatterPointSizeMenuItem, } from './pointSizeMenu.js';
+export { default as SetMinMaxDialog } from './SetMinMaxDialog.js';

package/esm/computeYTicks.d.ts

@@ -1,4 +1,4 @@
-import type { YScaleTicks } from '@jbrowse/display-ui';
+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,4 +1,5 @@
-import { YSCALEBAR_LABEL_OFFSET, axisPlotBox } from '@jbrowse/display-ui';
+import { YSCALEBAR_LABEL_OFFSET } from '@jbrowse/display-ui/yAxisConstants';
+import { axisPlotBox } from '@jbrowse/display-ui/yScaleTicks';
 import { getScale } from './scale.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
@@ -17,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/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,9 @@ 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;
 }

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.