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

package/esm/scoreMenuItems.d.ts

@@ -1,37 +1,56 @@
-import type { MenuItem } from '@jbrowse/core/ui';
+import type { AutoscalePeer } from './autoscaleGroup.ts';
+import type { CheckboxMenuItem, MenuItem } from '@jbrowse/core/ui';
+import type { ValueScaleRule } from '@jbrowse/display-ui';
 import type { IStateTreeNode } from '@jbrowse/mobx-state-tree';
 export interface ScoreScaleModel extends IStateTreeNode {
     scaleType: string;
-    autoscaleType: string;
-    minScore: number;
-    maxScore: number;
+    scaleZero: boolean;
+    domainQuantile: number;
+    clipQuantile: number;
+    manualMinScore: number | undefined;
+    manualMaxScore: number | undefined;
     minScoreBound: number | undefined;
     maxScoreBound: number | undefined;
+    hasManualScoreBounds: boolean;
+    autoscaledDomain: [number, number] | undefined;
     setScaleType: (v: string) => void;
-    setAutoscale: (v?: string) => void;
+    setScaleZero: (zero: boolean) => void;
     setMinScore: (n?: number) => void;
     setMaxScore: (n?: number) => void;
+    setDomainQuantile: (quantile: number) => void;
+}
+export interface ScoreRulesModel {
+    scoreRulesDrawn: boolean;
+    scoreRules: ValueScaleRule[];
+    setScoreRules: (rules: ValueScaleRule[]) => void;
 }
 export declare function makeScaleTypeSubMenu(self: {
     scaleType: string;
     setScaleType: (v: string) => void;
 }): MenuItem;
-export declare function makeAutoscaleTypeSubMenu(self: {
-    autoscaleType: string;
-    setAutoscale: (v?: string) => void;
-}, options?: [string, string][]): MenuItem;
+export declare const CLIP_OUTLIERS_LABEL = "Clip outliers";
+export declare function makeClipOutliersItem(self: {
+    domainQuantile: number;
+    clipQuantile: number;
+    setDomainQuantile: (quantile: number) => void;
+}): CheckboxMenuItem;
+export declare const AXIS_ZERO_LABEL = "Start axis at 0";
+export declare function makeAxisZeroItem(self: {
+    scaleZero: boolean;
+    setScaleZero: (zero: boolean) => void;
+}): CheckboxMenuItem;
 export declare function makeSetMinMaxScoreItem(self: ScoreScaleModel): MenuItem;
 export declare function makeCrossHatchItem(self: {
-    displayCrossHatches: boolean;
-    toggleCrossHatches: () => void;
+    grid: boolean;
+    setGrid: (grid: boolean) => void;
 }): MenuItem;
-export declare function makeScoreSubMenu(self: ScoreScaleModel, opts?: {
+export interface ScoreSubMenuOptions {
     label?: string;
-    scaleType?: boolean;
-    autoscale?: boolean;
-    autoscaleOptions?: [string, string][];
     leadingItems?: MenuItem[];
     trailingItems?: MenuItem[];
     disabled?: boolean;
     disabledHelpText?: string;
-}): MenuItem;
+}
+export declare function makeAutoscaleGroupItem(self: IStateTreeNode & AutoscalePeer): MenuItem;
+export declare function makeSetScoreRulesItem(self: IStateTreeNode & ScoreRulesModel): MenuItem;
+export declare function makeScoreSubMenu(self: ScoreScaleModel & Partial<ScoreRulesModel> & Partial<AutoscalePeer>, opts?: ScoreSubMenuOptions): MenuItem;

package/esm/scoreMenuItems.js

@@ -1,90 +1,123 @@
 import { lazy } from 'react';
-import { checkboxItem, radioItems } from '@jbrowse/core/ui/menuItems';
+import { checkboxItem, radioItems, toggleItem, } from '@jbrowse/core/ui/menuItems';
 import { getDialogHost } from '@jbrowse/core/util';
 import EqualizerIcon from '@mui/icons-material/Equalizer';
-import { DEFAULT_AUTOSCALE_OPTIONS } from './autoscale.js';
+import { autoscaleGroupMembers, autoscalePeers } from './autoscaleGroup.js';
+import { VALUE_SCALE_TYPES } from './valueScaleConfigSchema.js';
+const AutoscaleGroupDialog = lazy(() => import('./AutoscaleGroupDialog.js'));
 const SetMinMaxDialog = lazy(() => import('./SetMinMaxDialog.js'));
-// All three scales, so a display offering this menu at all must hold all three
-// in its own `scaleType` enum. `scoreAxisConfigSchemaFields` deliberately does
-// not — symlog is widened in by whoever implements it — so a display that spreads
-// the shared axis fields unchanged has to opt out with `scaleType: false` the way
-// manhattan does, or the radio writes a value its enumeration rejects.
+const SetScoreRulesDialog = lazy(() => import('./SetScoreRulesDialog.js'));
+const SCALE_TYPE_LABELS = {
+    linear: 'Linear scale',
+    log: 'Log scale',
+    symlog: 'Symlog scale (allows zero)',
+};
 export function makeScaleTypeSubMenu(self) {
     return {
         label: 'Scale type',
-        subMenu: radioItems([
-            { value: 'linear', label: 'Linear scale' },
-            { value: 'log', label: 'Log scale' },
-            { value: 'symlog', label: 'Symlog scale (allows zero)' },
-        ], self.scaleType, v => {
+        subMenu: radioItems(VALUE_SCALE_TYPES.map(value => ({
+            value,
+            label: SCALE_TYPE_LABELS[value],
+        })), self.scaleType, v => {
             self.setScaleType(v);
         }),
     };
 }
-export function makeAutoscaleTypeSubMenu(self, options = DEFAULT_AUTOSCALE_OPTIONS) {
-    return {
-        label: 'Autoscale type',
-        subMenu: radioItems(options.map(([value, label]) => ({ value, label })), self.autoscaleType, v => {
-            self.setAutoscale(v);
-        }),
-    };
+// Quoted by the docs' click paths, so one literal string.
+export const CLIP_OUTLIERS_LABEL = 'Clip outliers';
+// One checkbox rather than a radio over modes: what a reader decides is whether
+// a spike may take the axis, and the quantile it clips at is the config's.
+export function makeClipOutliersItem(self) {
+    const clipsAt = self.domainQuantile < 1 ? self.domainQuantile : self.clipQuantile;
+    const percent = Math.round(clipsAt * 100);
+    return toggleItem(CLIP_OUTLIERS_LABEL, self.domainQuantile < 1, on => {
+        self.setDomainQuantile(on ? self.clipQuantile : 1);
+    }, {
+        helpText: `An unpinned end follows the ${percent}th percentile of each sign rather than the extremes, so one spike no longer flattens the rest.`,
+    });
 }
-// The model resolves the Number.MIN_VALUE / MAX_VALUE "unset, fall back to
-// autoscale" sentinel into minScoreBound/maxScoreBound (undefined = autoscale).
-// Surfacing them lets the menu show that a manual range is in force — otherwise
-// an autoscale-type radio still reads as checked while a fixed bound silently
-// overrides it.
-function resolveScoreBounds(self) {
-    const min = self.minScoreBound;
-    const max = self.maxScoreBound;
-    return { min, max, hasManual: min !== undefined || max !== undefined };
+// Quoted by the docs' click paths, so one literal string.
+export const AXIS_ZERO_LABEL = 'Start axis at 0';
+export function makeAxisZeroItem(self) {
+    return toggleItem(AXIS_ZERO_LABEL, self.scaleZero, zero => {
+        self.setScaleZero(zero);
+    }, {
+        helpText: 'A linear or symlog axis reaches 0 whatever the values in view span. Off, it spans those values alone.',
+    });
 }
+// The label shows the PINNED pair, `auto` for an end nobody pinned: the
+// resolved pair captioned every GC content track "(0 – 1)" off its default
+// domain. "Use current range" copies `autoscaledDomain`, undefined while the
+// alignments density tier's features per bin stand in for depth.
 export function makeSetMinMaxScoreItem(self) {
-    const { min, max, hasManual } = resolveScoreBounds(self);
+    const { manualMinScore, manualMaxScore, autoscaledDomain: domain } = self;
     return {
-        label: hasManual
-            ? `Set min/max score (${min ?? 'auto'} – ${max ?? 'auto'})...`
+        label: self.hasManualScoreBounds
+            ? `Set min/max score (${manualMinScore ?? 'auto'} – ${manualMaxScore ?? 'auto'})...`
             : 'Set min/max score...',
         onClick: () => {
             getDialogHost(self).queueDialog(handleClose => [
                 SetMinMaxDialog,
-                { model: self, handleClose },
+                { model: self, domain, handleClose },
             ]);
         },
     };
 }
-// Only offered when a manual bound is set; resets both to the sentinel (same
-// path the dialog takes when its fields are cleared) so autoscale resumes.
-function makeClearMinMaxScoreItem(self) {
+export function makeCrossHatchItem(self) {
+    return checkboxItem('Show cross hatches', self.grid, () => {
+        self.setGrid(!self.grid);
+    });
+}
+// The count of the other tracks in the group is in the label, as the min/max
+// row carries its bounds: an axis that moves when another track pans is
+// something the reader has to be able to find the cause of.
+export function makeAutoscaleGroupItem(self) {
+    const { autoscaleGroup } = self;
+    const others = autoscaleGroup === undefined
+        ? 0
+        : autoscaleGroupMembers(self, autoscaleGroup).length - 1;
     return {
-        label: 'Clear manual min/max',
+        label: others > 0
+            ? `Autoscale with other tracks (${others})...`
+            : 'Autoscale with other tracks...',
         onClick: () => {
-            self.setMinScore(undefined);
-            self.setMaxScore(undefined);
+            getDialogHost(self).queueDialog(handleClose => [
+                AutoscaleGroupDialog,
+                { model: self, handleClose },
+            ]);
         },
     };
 }
-export function makeCrossHatchItem(self) {
-    return checkboxItem('Show cross hatches', self.displayCrossHatches, () => {
-        self.toggleCrossHatches();
-    });
+// Offered once the view holds another track with a value axis to share.
+function autoscalesInGroups(self) {
+    return self.setAutoscaleGroup !== undefined && autoscalePeers(self).length > 0;
+}
+function drawsScoreRules(self) {
+    return (self.scoreRulesDrawn === true &&
+        self.scoreRules !== undefined &&
+        self.setScoreRules !== undefined);
+}
+// A density plot maps its score to colour and rules no band, so its domain
+// spans the values whatever `zero` says; the row is offered with the axis.
+function rulesABand(self) {
+    return self.scoreRulesDrawn === true;
+}
+// The count is in the label, as the min/max row carries its bounds: a dashed
+// line across a plot means nothing until the reader knows it was put there.
+export function makeSetScoreRulesItem(self) {
+    const count = self.scoreRules.length;
+    return {
+        label: count > 0 ? `Reference lines (${count})...` : 'Reference lines...',
+        onClick: () => {
+            getDialogHost(self).queueDialog(handleClose => [
+                SetScoreRulesDialog,
+                { model: self, handleClose },
+            ]);
+        },
+    };
 }
-// The single Score submenu used by every wiggle-family display. Composition is
-// capability-driven: `leadingItems` lets wiggle prepend its Resolution/Summary
-// submenus, `trailingItems` appends what belongs after the range controls rather
-// than before them (the alignments band's allele-fraction floor); `scaleType` is
-// dropped by manhattan (linear-only); `autoscaleOptions` is overridden by
-// coverage's reduced + dynamic-σ list.
-//
-// `autoscale` is the same kind of opt-out as `scaleType`, and exists for the
-// same reason: a display whose domain doesn't consult `autoscaleType` must not
-// offer radios for it. Manhattan takes plain min/max over the loaded regions and
-// applies only the manual bounds, so its Autoscale-type radios wrote the config
-// slot and changed nothing on screen — a control that lies is worse than a
-// missing one. Opt-out rather than opt-in so a display that grows a domain
-// without wiring autoscale keeps the menu it already had.
 export function makeScoreSubMenu(self, opts = {}) {
-    const { label = 'Score', scaleType = true, autoscale = true, autoscaleOptions, leadingItems = [], trailingItems = [], disabled, disabledHelpText, } = opts;
+    const { label = 'Score', leadingItems = [], trailingItems = [], disabled, disabledHelpText, } = opts;
     return {
         label,
         icon: EqualizerIcon,
@@ -92,12 +125,12 @@ export function makeScoreSubMenu(self, opts = {}) {
         disabledHelpText,
         subMenu: [
             ...leadingItems,
-            ...(scaleType ? [makeScaleTypeSubMenu(self)] : []),
-            ...(autoscale ? [makeAutoscaleTypeSubMenu(self, autoscaleOptions)] : []),
+            makeScaleTypeSubMenu(self),
+            makeClipOutliersItem(self),
+            ...(rulesABand(self) ? [makeAxisZeroItem(self)] : []),
             makeSetMinMaxScoreItem(self),
-            ...(resolveScoreBounds(self).hasManual
-                ? [makeClearMinMaxScoreItem(self)]
-                : []),
+            ...(autoscalesInGroups(self) ? [makeAutoscaleGroupItem(self)] : []),
+            ...(drawsScoreRules(self) ? [makeSetScoreRulesItem(self)] : []),
             ...trailingItems,
         ],
     };

package/esm/scoreRuleMarks.d.ts

@@ -1,22 +1,5 @@
-/**
- * #api
- * One horizontal rule across a score plot, at a score the user chose.
- *
- * `label` is free text and carries no meaning this package assigns. That is
- * deliberate: the obvious use is reading a coverage or CNV track against copy
- * number, and there is no ploidy JBrowse could assume on the user's behalf. A
- * whole-genome triplication is not diploid, plenty of genomes are not diploid to
- * begin with, and a cancer sample can be neither — so "2 copies" is a claim only
- * the person looking at the track can make.
- */
-export interface ScoreRule {
-    value: number;
-    label?: string;
-    color?: string;
-}
-export interface ScoreRuleMark extends ScoreRule {
-    y: number;
-}
+import type { ScoreRuleMark, ValueScaleRule } from '@jbrowse/display-ui';
+export type { ScoreRuleMark } from '@jbrowse/display-ui';
 /**
  * #api
  * Screen y for each rule that falls inside the plotted domain, dropping the
@@ -34,12 +17,12 @@ export interface ScoreRuleMark extends ScoreRule {
  * to be read against is not.
  *
  * `box` is likewise the caller's own — hand it the same `{yTop, yBottom}` the
- * display's ticks were built with (a `YScaleTicks` satisfies it). Recomputing a
- * box here would silently disagree with any band that lays its axis out
- * differently, and the alignments coverage band does.
+ * display's ticks were built with (a `YScaleTicks` satisfies it). A box
+ * recomputed here would place rules off the ticks of any band that lays its
+ * axis out differently, and the alignments coverage band does.
  */
 export declare function scoreRuleMarks({ rules, domain, box, normalize, }: {
-    rules: readonly ScoreRule[];
+    rules: readonly ValueScaleRule[];
     domain: [number, number] | undefined;
     box: {
         yTop: number;
@@ -47,27 +30,19 @@ export declare function scoreRuleMarks({ rules, domain, box, normalize, }: {
     };
     normalize: (score: number) => number;
 }): ScoreRuleMark[];
-/**
- * #api
- * Normalizes whatever a `scoreRules` config slot holds into `ScoreRule`s,
- * dropping entries that are not usable. Config is user-authored JSON, so a bare
- * number, a missing value or a non-numeric one all have to survive being read.
- */
-export declare function parseScoreRules(value: unknown): ScoreRule[];
 /**
  * #api
  * Widens an autoscaled range so every configured rule stays on the axis.
  *
- * Without this a rule silently disappears in exactly the window that makes it
- * worth having. Autoscale follows the visible data, so over a homozygous
- * deletion a coverage domain collapses to about `[0, 1]` and a rule at the
- * diploid depth falls outside it — and "2 copies would be up there" is the most
- * informative thing that view can say. The reader has no menu to check either:
- * `scoreRules` is set by whoever wrote the config, so a rule that vanishes
- * leaves nothing behind to notice.
+ * Without this a rule is dropped from the plot in the views where it is most
+ * useful. Autoscale follows the visible data, so over a homozygous deletion a
+ * coverage domain collapses to about `[0, 1]` and a rule at the diploid depth
+ * falls outside it, though the rule's position above the data is the most
+ * informative mark in that view, and a rule that vanishes leaves nothing
+ * behind to notice.
  *
- * Applied to the raw range, before `getNiceDomain` takes the `minScore` /
- * `maxScore` bounds. Those still win: a rule outside an explicitly bounded axis
+ * Applied to the raw range, before `getNiceDomain` takes the `scales.y`
+ * domain bounds. Those still win: a rule outside an explicitly bounded axis
  * is one the config asked not to be shown, and it drops as before.
  */
 export declare function widenRangeToRules(range: [number, number], ruleValues: readonly number[]): [number, number];

package/esm/scoreRuleMarks.js

@@ -1,4 +1,4 @@
-import { clampStrokeInsideAxis, scoreToAxisY } from './yScaleTicks.js';
+import { clampStrokeInsideAxis, scoreToAxisY, } from '@jbrowse/display-ui/yScaleTicks';
 /**
  * #api
  * Screen y for each rule that falls inside the plotted domain, dropping the
@@ -16,9 +16,9 @@ import { clampStrokeInsideAxis, scoreToAxisY } from './yScaleTicks.js';
  * to be read against is not.
  *
  * `box` is likewise the caller's own — hand it the same `{yTop, yBottom}` the
- * display's ticks were built with (a `YScaleTicks` satisfies it). Recomputing a
- * box here would silently disagree with any band that lays its axis out
- * differently, and the alignments coverage band does.
+ * display's ticks were built with (a `YScaleTicks` satisfies it). A box
+ * recomputed here would place rules off the ticks of any band that lays its
+ * axis out differently, and the alignments coverage band does.
  */
 export function scoreRuleMarks({ rules, domain, box, normalize, }) {
     if (!domain) {
@@ -38,52 +38,19 @@ export function scoreRuleMarks({ rules, domain, box, normalize, }) {
         }), box.yBottom),
     }));
 }
-/**
- * #api
- * Normalizes whatever a `scoreRules` config slot holds into `ScoreRule`s,
- * dropping entries that are not usable. Config is user-authored JSON, so a bare
- * number, a missing value or a non-numeric one all have to survive being read.
- */
-export function parseScoreRules(value) {
-    if (!Array.isArray(value)) {
-        return [];
-    }
-    const out = [];
-    for (const entry of value) {
-        if (typeof entry === 'number') {
-            if (Number.isFinite(entry)) {
-                out.push({ value: entry });
-            }
-            continue;
-        }
-        if (entry && typeof entry === 'object') {
-            const { value: v, label, color } = entry;
-            const n = typeof v === 'string' ? Number(v) : v;
-            if (typeof n === 'number' && Number.isFinite(n)) {
-                out.push({
-                    value: n,
-                    ...(typeof label === 'string' && label ? { label } : {}),
-                    ...(typeof color === 'string' && color ? { color } : {}),
-                });
-            }
-        }
-    }
-    return out;
-}
 /**
  * #api
  * Widens an autoscaled range so every configured rule stays on the axis.
  *
- * Without this a rule silently disappears in exactly the window that makes it
- * worth having. Autoscale follows the visible data, so over a homozygous
- * deletion a coverage domain collapses to about `[0, 1]` and a rule at the
- * diploid depth falls outside it — and "2 copies would be up there" is the most
- * informative thing that view can say. The reader has no menu to check either:
- * `scoreRules` is set by whoever wrote the config, so a rule that vanishes
- * leaves nothing behind to notice.
+ * Without this a rule is dropped from the plot in the views where it is most
+ * useful. Autoscale follows the visible data, so over a homozygous deletion a
+ * coverage domain collapses to about `[0, 1]` and a rule at the diploid depth
+ * falls outside it, though the rule's position above the data is the most
+ * informative mark in that view, and a rule that vanishes leaves nothing
+ * behind to notice.
  *
- * Applied to the raw range, before `getNiceDomain` takes the `minScore` /
- * `maxScore` bounds. Those still win: a rule outside an explicitly bounded axis
+ * Applied to the raw range, before `getNiceDomain` takes the `scales.y`
+ * domain bounds. Those still win: a rule outside an explicitly bounded axis
  * is one the config asked not to be shown, and it drops as before.
  */
 export function widenRangeToRules(range, ruleValues) {

package/esm/transferables.js

@@ -1,18 +1,17 @@
-// Walks every result's sources once and returns each source's eight per-feature
+// Walks every result's sources once and returns each source's four per-feature
 // TypedArray buffers as one flat list for postMessage transfer. Field set
 // matches WiggleFeatureArrays — when fields change there, update here so the
 // buffers actually transfer instead of being structured-cloned.
 //
 // The Set dedupe is load-bearing, not insurance: processFeaturesFromArrays
-// aliases fields onto one buffer whenever a copy would be identical (no summary
-// data → min/max are the scores; an all-one-sided window → the pos or neg
-// arrays are the full arrays). postMessage throws on a repeated transferable.
+// aliases min/max onto the scores where no feature is a summary, and
+// postMessage throws on a repeated transferable.
 //
 // Takes ALL the results rather than one, so the dedupe spans regions too — a
 // per-result Set would list a shared buffer twice.
 //
 // Aliasing the adapter's own arrays here as well, rather than copying them, is
-// costed and declined in agent-docs/reference/REJECTED_IDEAS.md: it retains 20
+// costed and declined in agent-docs/architecture-decision-records/: it retains 20
 // bytes a feature on the main thread where copying retains 12.
 export function collectWiggleTransferables(results) {
     const buffers = new Set();
@@ -22,10 +21,6 @@ export function collectWiggleTransferables(results) {
             buffers.add(s.featureScores.buffer);
             buffers.add(s.featureMinScores.buffer);
             buffers.add(s.featureMaxScores.buffer);
-            buffers.add(s.posFeaturePositions.buffer);
-            buffers.add(s.posFeatureScores.buffer);
-            buffers.add(s.negFeaturePositions.buffer);
-            buffers.add(s.negFeatureScores.buffer);
         }
     }
     return [...buffers];