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

package/esm/ScoreFieldConfigMixin.d.ts

@@ -0,0 +1,72 @@
+import type { ScoreFieldConfigModel } from './scoreFieldConfigSchemaFields.ts';
+export interface ScoreFieldConfigHost {
+    configuration: ScoreFieldConfigModel;
+}
+/**
+ * #stateModel ScoreFieldConfigMixin
+ * #category display
+ *
+ * `WiggleScoreConfigMixin` plus `scoreField`, for a display that plots one
+ * configured feature field and so declares `scoreFieldConfigSchemaFields`:
+ * the wiggle display. `LinearMarkDisplay` names a field per mark and composes
+ * the base instead.
+ */
+export declare function ScoreFieldConfigMixin(): import("@jbrowse/mobx-state-tree").IModelType<Omit<{}, never>, {
+    readonly scaleType: string;
+    readonly scaleZero: boolean;
+    readonly manualMinScore: number | undefined;
+    readonly manualMaxScore: number | undefined;
+    readonly defaultScoreDomain: [number | undefined, number | undefined];
+    readonly valueScales: import("@jbrowse/display-ui").ValueScale[];
+    readonly autoscaleGroup: string | undefined;
+    readonly autoscaleRange: [number, number] | undefined;
+} & {
+    readonly axisReachesZero: boolean;
+} & {
+    readonly autoscaledDomain: [number, number] | undefined;
+    readonly minScoreBound: number | undefined;
+    readonly maxScoreBound: number | undefined;
+    readonly hasManualScoreBounds: boolean;
+    readonly axes: import("@jbrowse/display-ui").YAxis[];
+} & {
+    unclippedQuantile: number | undefined;
+} & {
+    readonly scaleType: string;
+    readonly scaleZero: boolean;
+    readonly domainQuantile: number;
+    readonly clipQuantile: number;
+    readonly symlogConstant: number;
+    readonly manualMinScore: number | undefined;
+    readonly manualMaxScore: number | undefined;
+    readonly valueScaleNotices: string[];
+    readonly autoscaleGroup: string | undefined;
+    readonly scaleTitle: string;
+    readonly grid: boolean;
+    readonly minimalTicks: boolean;
+    readonly scoreRulesDrawn: boolean;
+    readonly scoreRules: import("@jbrowse/display-ui").ValueScaleRule[];
+} & {
+    setScaleType(scaleType: string): void;
+    setScaleZero(zero: boolean): void;
+    setDomainQuantile(quantile: number): void;
+    setMinScore(val?: number): void;
+    setMaxScore(val?: number): void;
+    setAutoscaleGroup(group?: string): void;
+    setGrid(grid: boolean): void;
+    setScoreRules(rules: (number | import("@jbrowse/display-ui").ValueScaleRule)[]): void;
+} & {
+    readonly size: number;
+    readonly isDensityMode: boolean;
+} & {
+    readonly axisReachesZero: boolean;
+} & {
+    setSize(val?: number): void;
+} & {
+    /**
+     * #getter
+     * The feature field the worker plots on the score axis, `score` by
+     * default. A fetch input: every composing display carries it in its
+     * `rpcProps()`, since the field is read where the features are.
+     */
+    readonly scoreField: string;
+}, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;

package/esm/ScoreFieldConfigMixin.js

@@ -0,0 +1,25 @@
+import { getConf } from '@jbrowse/core/configuration';
+import { WiggleScoreConfigMixin } from './WiggleScoreConfigMixin.js';
+const confNode = (self) => self;
+/**
+ * #stateModel ScoreFieldConfigMixin
+ * #category display
+ *
+ * `WiggleScoreConfigMixin` plus `scoreField`, for a display that plots one
+ * configured feature field and so declares `scoreFieldConfigSchemaFields`:
+ * the wiggle display. `LinearMarkDisplay` names a field per mark and composes
+ * the base instead.
+ */
+export function ScoreFieldConfigMixin() {
+    return WiggleScoreConfigMixin().views(self => ({
+        /**
+         * #getter
+         * The feature field the worker plots on the score axis, `score` by
+         * default. A fetch input: every composing display carries it in its
+         * `rpcProps()`, since the field is read where the features are.
+         */
+        get scoreField() {
+            return getConf(confNode(self), 'scoreField');
+        },
+    }));
+}

package/esm/ScorePlotChrome.d.ts

@@ -0,0 +1,45 @@
+import type { ContextMenuAnchor, MenuItem, MouseState } from '@jbrowse/core/ui';
+import type { ChromeModel } from '@jbrowse/display-kit/DisplayChrome';
+import type { Mark } from '@jbrowse/render-core/marks';
+import type { PerRegionRenderingBackend } from '@jbrowse/render-core/perRegionRenderingBackend';
+import type { FrameDimensions } from '@jbrowse/render-core/renderingBackendBase';
+import type { RenderLifecycleModel } from '@jbrowse/render-core/useRenderingBackend';
+import type { ReactNode } from 'react';
+interface PlotBox {
+    yTop: number;
+    plotHeight: number;
+}
+interface ContextMenuView {
+    contextMenuInfo?: ContextMenuAnchor;
+    contextMenuItems: () => MenuItem[];
+    closeContextMenu: () => void;
+}
+export interface ScorePlotContextMenuHost<Hit> extends ContextMenuView {
+    openContextMenu: (info: ContextMenuAnchor & {
+        hit: Hit;
+    }) => void;
+    clearHoveredFeature: () => void;
+}
+export type ScorePlotChromeModel<Hit, TRegion, TState extends FrameDimensions> = ChromeModel & RenderLifecycleModel<PerRegionRenderingBackend<TRegion, TState>> & {
+    canvasWidthPx: number;
+    setHoveredFeature: (hit?: Hit) => void;
+    selectFeature: (hit: Hit) => void;
+};
+/**
+ * The on-screen chrome of a display drawing a mark list on a score axis: the
+ * canvas in the axis plot box, hover and click resolved through `findHit`, the
+ * pointer-following `tooltip`, and the right-click menu where `contextMenu`
+ * names the model that owns it. `findHit` takes y from the plot's own top.
+ */
+export declare const ScorePlotChrome: <Hit, TRegion, TState extends FrameDimensions>({ model, marks, testid, plotGeometry, findHit, tooltip, overlay, indicators, contextMenu, }: {
+    model: ScorePlotChromeModel<Hit, TRegion, TState>;
+    marks: readonly Mark<TRegion, TState>[];
+    testid: string;
+    plotGeometry?: PlotBox;
+    findHit: (x: number, y: number) => Hit | undefined;
+    tooltip: (mouseState: MouseState | undefined) => ReactNode;
+    overlay?: (plotGeometry: PlotBox) => ReactNode;
+    indicators?: () => ReactNode;
+    contextMenu?: ScorePlotContextMenuHost<Hit>;
+}) => import("react").JSX.Element;
+export {};

package/esm/ScorePlotChrome.js

@@ -0,0 +1,47 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import { eventPoint } from '@jbrowse/core/util/eventPoint';
+import BottomRightIndicators from '@jbrowse/display-kit/BottomRightIndicators';
+import DisplayChrome from '@jbrowse/display-kit/DisplayChrome';
+import { DisplayContextMenu, openContextMenuFromEvent, } from '@jbrowse/display-kit/DisplayContextMenu';
+import { PointerLayer, axisPlotBox } from '@jbrowse/display-ui';
+import { createMarkBackend } from '@jbrowse/render-core/marks/backend';
+import { observer } from 'mobx-react';
+/**
+ * The on-screen chrome of a display drawing a mark list on a score axis: the
+ * canvas in the axis plot box, hover and click resolved through `findHit`, the
+ * pointer-following `tooltip`, and the right-click menu where `contextMenu`
+ * names the model that owns it. `findHit` takes y from the plot's own top.
+ */
+export const ScorePlotChrome = observer(function ScorePlotChrome({ model, marks, testid, plotGeometry, findHit, tooltip, overlay, indicators, contextMenu, }) {
+    const { height, canvasWidthPx: width } = model;
+    const box = plotGeometry ?? axisPlotBox(height);
+    const factory = useMemo(() => (canvas) => createMarkBackend(canvas, marks), [marks]);
+    const hitAt = (x, y) => findHit(x, y - box.yTop);
+    return (_jsx(DisplayChrome, { model: model, factory: factory, testid: testid, style: { width, whiteSpace: 'nowrap', textAlign: 'left' }, onPointerPosition: state => {
+            model.setHoveredFeature(state ? hitAt(state.x, state.y) : undefined);
+        }, onClick: event => {
+            const { x, y } = eventPoint(event);
+            const hit = hitAt(x, y);
+            if (hit) {
+                model.selectFeature(hit);
+            }
+        }, onContextMenu: contextMenu
+            ? event => {
+                const { x, y } = eventPoint(event);
+                const hit = hitAt(x, y);
+                openContextMenuFromEvent(contextMenu, event, hit
+                    ? { clientX: event.clientX, clientY: event.clientY, hit }
+                    : undefined);
+            }
+            : undefined, children: ({ canvasRef, mouseTracker }) => (_jsx(ScorePlotBody, { canvasRef: canvasRef, mouseTracker: mouseTracker, width: width, plotGeometry: box, tooltip: tooltip, overlay: overlay, indicators: indicators, contextMenu: contextMenu })) }));
+});
+const ScorePlotBody = observer(function ScorePlotBody({ canvasRef, mouseTracker, width, plotGeometry, tooltip, overlay, indicators, contextMenu, }) {
+    return (_jsxs(_Fragment, { children: [_jsx("canvas", { ref: canvasRef, style: {
+                    width,
+                    height: plotGeometry.plotHeight,
+                    position: 'absolute',
+                    left: 0,
+                    top: plotGeometry.yTop,
+                } }), overlay?.(plotGeometry), _jsx(PointerLayer, { mouseTracker: mouseTracker, children: tooltip }), indicators ? (_jsx(BottomRightIndicators, { children: indicators() })) : null, contextMenu ? _jsx(DisplayContextMenu, { model: contextMenu }) : null] }));
+});

package/esm/ScorePlotSvgFrame.d.ts

@@ -0,0 +1,27 @@
+import type { SvgExportable } from '@jbrowse/core/svg/svgReady';
+import type { LgvSvgBodyProps } from '@jbrowse/display-kit/renderDisplaySvg';
+import type { Mark, MarkFrame } from '@jbrowse/render-core/marks';
+import type React from 'react';
+export interface ScorePlotSvgModel extends SvgExportable {
+    id: string;
+    height: number;
+}
+/**
+ * The SVG-export body of a display with a score axis, mounted through
+ * `renderDisplaySvg`, which draws the axis and cross-hatches. Paints `marks`
+ * over `regions` inside the plot box, at the export's width and the box's
+ * height — the two fields of `renderState` the on-screen canvas sizes
+ * differently. `plotGeometry` defaults to the single-plot box `ScorePlotChrome`
+ * draws in; multi-wiggle stacks its rows over the full height instead.
+ * `children` draw over the plot, in the same untranslated space as the axis.
+ */
+export declare function ScorePlotSvgFrame<TRegion, TState extends MarkFrame>({ height, canvasWidth, renderBlocks, opts, plotGeometry, marks, regions, renderState, children, }: LgvSvgBodyProps<ScorePlotSvgModel> & {
+    plotGeometry?: {
+        yTop: number;
+        plotHeight: number;
+    };
+    marks: readonly Mark<TRegion, TState>[];
+    regions: ReadonlyMap<number, TRegion>;
+    renderState: TState;
+    children?: React.ReactNode;
+}): React.JSX.Element;

package/esm/ScorePlotSvgFrame.js

@@ -0,0 +1,23 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { PaintLayer } from '@jbrowse/core/util/paintLayer';
+import { axisPlotBox } from '@jbrowse/display-ui';
+import { paintMarkBlocks } from '@jbrowse/render-core/marks';
+/**
+ * The SVG-export body of a display with a score axis, mounted through
+ * `renderDisplaySvg`, which draws the axis and cross-hatches. Paints `marks`
+ * over `regions` inside the plot box, at the export's width and the box's
+ * height — the two fields of `renderState` the on-screen canvas sizes
+ * differently. `plotGeometry` defaults to the single-plot box `ScorePlotChrome`
+ * draws in; multi-wiggle stacks its rows over the full height instead.
+ * `children` draw over the plot, in the same untranslated space as the axis.
+ */
+export function ScorePlotSvgFrame({ height, canvasWidth, renderBlocks, opts, plotGeometry = axisPlotBox(height), marks, regions, renderState, children, }) {
+    const { yTop, plotHeight } = plotGeometry;
+    return (_jsxs(_Fragment, { children: [_jsx("g", { transform: `translate(0,${yTop})`, children: _jsx(PaintLayer, { width: canvasWidth, height: plotHeight, opts: opts, paint: ctx => {
+                        paintMarkBlocks(ctx, marks, regions, renderBlocks, {
+                            ...renderState,
+                            canvasWidth,
+                            canvasHeight: plotHeight,
+                        });
+                    } }) }), children] }));
+}

package/esm/ScoreScaleMixin.d.ts

@@ -1,90 +1,135 @@
-import type { ScoreAxisConfigModel } from './scoreAxisConfigSchemaFields.ts';
+import type { scalesSchema } from './valueScaleConfigSchema.ts';
+import type { ConfigModelForFields } from '@jbrowse/core/configuration';
+import type { ValueScaleRule } from '@jbrowse/display-ui';
 /**
- * The whole of what `ScoreScaleMixin` needs a composing display to be. Exported
+ * The whole of what `ScoreScaleMixin` needs a composing display to be: a
+ * `scales` object holding the `y` the value-scale factory built. Exported
  * because it is the mixin's contract and `ScoreScaleMixin.test.ts` pins it:
  * widen it and the `@ts-expect-error`s there go unused.
  */
 export interface ScoreScaleHost {
-    configuration: ScoreAxisConfigModel;
+    configuration: ConfigModelForFields<{
+        scales: ReturnType<typeof scalesSchema>;
+    }>;
 }
 /**
  * #stateModel ScoreScaleMixin
  * #category display
- * #crossCuttingMixin Score axis. Nothing — the config slots. Brings `scaleType` / `autoscaleType` / `minScore` / `maxScore` / `*Bound` / `numStdDev` and their setters, i.e. the whole `ScoreScaleModel` interface the shared score menu and `SetMinMaxDialog` consume
+ * #crossCuttingMixin Value scale, written in `scales.y`. `valueScaleSchema` / `scalesSchema`. Brings `ScoreAxisMixin` plus `scaleType` / `scaleZero` / `domainQuantile` / `clipQuantile` / `symlogConstant` / `manual*` and their setters, i.e. the whole `ScoreScaleModel` interface the shared score menu and `SetMinMaxDialog` consume
  *
- * The score axis every quantitative display shares: which scale, how to
- * autoscale it, and the manual min/max bounds. This is the runtime half of
- * {@link ScoreScaleModel} in `scoreMenuItems.ts` — that interface is what the
- * shared Score menu, the autoscale/scale submenus and `SetMinMaxDialog` consume,
- * and it was already the canonical contract while two displays hand-wrote
- * identical implementations of it (`WiggleScoreConfigMixin`, and the alignments
- * coverage band). Composing this is now how a display satisfies it, so a new
- * score display cannot satisfy it *partially*.
+ * The value scale of every quantitative display: wiggle, the alignments
+ * coverage band and the mark display, Manhattan among them, each declare
+ * `scales.y` through {@link valueScaleSchema} and compose this. It backs
+ * {@link ScoreAxisMixin}'s three overridable members off that object and adds
+ * the setters that write it, so composing this is how a display satisfies
+ * {@link ScoreScaleModel} in `scoreMenuItems.ts` — the interface the shared
+ * Score menu, the scale and autoscale submenus and `SetMinMaxDialog` consume.
  *
- * Deliberately just the axis. Colors, `resolution`, cross-hatches and the
- * autoscale *computation* stay in `WiggleScoreConfigMixin` / `WiggleCommonMixin`
- * — the alignments coverage band shares this axis but none of the rest.
- *
- * `minScore`/`maxScore` are the **raw** slot values with their
- * `Number.MIN_VALUE`/`Number.MAX_VALUE` "unset" sentinels intact, because that
- * is what the dialog round-trips; `minScoreBound`/`maxScoreBound` are the
- * resolved bounds, where `undefined` means "autoscale this end". Every consumer
- * that computes a domain reads the `*Bound` pair.
+ * Deliberately just the scale and the guides it owns. Colors, `resolution`
+ * and the autoscale *computation* stay in `WiggleScoreConfigMixin` /
+ * `WiggleCommonMixin` — the alignments coverage band shares this scale but
+ * none of the rest.
  */
 export declare function ScoreScaleMixin(): import("@jbrowse/mobx-state-tree").IModelType<{}, {
+    readonly scaleType: string;
+    readonly scaleZero: boolean;
+    readonly manualMinScore: number | undefined;
+    readonly manualMaxScore: number | undefined;
+    readonly defaultScoreDomain: [number | undefined, number | undefined];
+    readonly valueScales: import("@jbrowse/display-ui").ValueScale[];
+    readonly autoscaleGroup: string | undefined;
+    readonly autoscaleRange: [number, number] | undefined;
+} & {
+    readonly axisReachesZero: boolean;
+} & {
+    readonly autoscaledDomain: [number, number] | undefined;
+    readonly minScoreBound: number | undefined;
+    readonly maxScoreBound: number | undefined;
+    readonly hasManualScoreBounds: boolean;
+    readonly axes: import("@jbrowse/display-ui").YAxis[];
+} & {
+    unclippedQuantile: number | undefined;
+} & {
     /**
      * #getter
      */
     readonly scaleType: string;
     /**
      * #getter
+     * `scales.y.zero`: whether an autoscaled linear or symlog axis reaches
+     * 0.
      */
-    readonly autoscaleType: string;
+    readonly scaleZero: boolean;
     /**
      * #getter
+     * `scales.y.domainQuantile`: what an unpinned end follows, 1 the
+     * extremes and below it that quantile of each sign.
      */
-    readonly numStdDev: number;
+    readonly domainQuantile: number;
     /**
      * #getter
-     * Raw slot value, sentinel intact — see the class comment.
+     * The quantile "Clip outliers" clips at: the one an untick this session
+     * wrote over, else the scale's own default where that is below 1, else
+     * 0.99.
      */
-    readonly minScore: number;
+    readonly clipQuantile: number;
     /**
      * #getter
-     * Raw slot value, sentinel intact — see the class comment.
+     * Raw slot; `0` means "derive from the domain". Resolve it with
+     * `resolveSymlogConstant` once the domain is known.
      */
-    readonly maxScore: number;
+    readonly symlogConstant: number;
     /**
      * #getter
-     * Overridable hook: what each end of the domain falls back to where the
-     * config leaves its bound unset. `[undefined, undefined]` — the default —
-     * means autoscale both ends, which is right for a track whose scores have
-     * no absolute meaning (a bigwig's units are its own).
-     *
-     * A display whose scores are bounded *by construction* overrides it, so
-     * the axis stops being a function of what happens to be on screen: GC
-     * content is a fraction, so 0 and 1 are its real limits and mean the same
-     * thing at every locus. Autoscaled, the same GC value drew at different
-     * heights depending on where the user had panned, and the track could not
-     * be read across loci.
-     *
-     * A hook rather than a config default because the answer can depend on
-     * display state — GC's does, on `gcMode` — and rather than each display
-     * re-resolving the sentinels below, which is the one thing that must not
-     * be duplicated: config bounds still win, precisely because they are
-     * checked before this is consulted.
+     * The lower bound the config pins, `undefined` where it pins none.
      */
-    readonly defaultScoreDomain: [number | undefined, number | undefined];
+    readonly manualMinScore: number | undefined;
     /**
      * #getter
-     * Resolved lower bound; `undefined` means autoscale this end.
+     * The upper bound the config pins, `undefined` where it pins none.
      */
-    readonly minScoreBound: number | undefined;
+    readonly manualMaxScore: number | undefined;
     /**
      * #getter
-     * Resolved upper bound; `undefined` means autoscale this end.
+     * What `scales.y`'s ends say together that the axis cannot draw as
+     * written, as corner-notice lines, by the rule a colour ramp's ends
+     * answer to. The mark display reports them through its rule list.
      */
-    readonly maxScoreBound: number | undefined;
+    readonly valueScaleNotices: string[];
+    /**
+     * #getter
+     * `scales.y.autoscaleGroup`, `undefined` while it names none.
+     */
+    readonly autoscaleGroup: string | undefined;
+    /**
+     * #getter
+     * `scales.y.title`, `''` while unset
+     */
+    readonly scaleTitle: string;
+    /**
+     * #getter
+     * `scales.y.grid`
+     */
+    readonly grid: boolean;
+    /**
+     * #getter
+     * `scales.y.minimalTicks`
+     */
+    readonly minimalTicks: boolean;
+    /**
+     * #getter
+     * Whether this display draws `scales.y.rules`, which is whether the
+     * score menu offers the reference lines: a scale it places y through
+     * rules a band for them to cross, which a density plot's colour-mapped
+     * rows and a colour ramp do not.
+     */
+    readonly scoreRulesDrawn: boolean;
+    /**
+     * #getter
+     * `scales.y.rules`, read off the live nodes: a snapshot strips a slot at
+     * its default, and a rule at 0 is one.
+     */
+    readonly scoreRules: ValueScaleRule[];
 } & {
     /**
      * #action
@@ -93,7 +138,11 @@ export declare function ScoreScaleMixin(): import("@jbrowse/mobx-state-tree").IM
     /**
      * #action
      */
-    setAutoscale(val?: string): void;
+    setScaleZero(zero: boolean): void;
+    /**
+     * #action
+     */
+    setDomainQuantile(quantile: number): void;
     /**
      * #action
      */
@@ -102,4 +151,18 @@ export declare function ScoreScaleMixin(): import("@jbrowse/mobx-state-tree").IM
      * #action
      */
     setMaxScore(val?: number): void;
+    /**
+     * #action
+     */
+    setAutoscaleGroup(group?: string): void;
+    /**
+     * #action
+     */
+    setGrid(grid: boolean): void;
+    /**
+     * #action
+     * Replaces `scales.y.rules` whole, each entry in a form the config
+     * takes: a number, or `{ value, color, label }`.
+     */
+    setScoreRules(rules: (number | ValueScaleRule)[]): void;
 }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;