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

package/esm/scoreRuleMarks.d.ts

@@ -1,20 +1,4 @@
-import type { ScoreRuleMark } from '@jbrowse/display-ui';
-/**
- * #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;
-}
+import type { ScoreRuleMark, ValueScaleRule } from '@jbrowse/display-ui';
 export type { ScoreRuleMark } from '@jbrowse/display-ui';
 /**
  * #api
@@ -33,12 +17,12 @@ export type { ScoreRuleMark } from '@jbrowse/display-ui';
  * 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;
@@ -46,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 '@jbrowse/display-ui';
+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 '@jbrowse/display-ui';
  * 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,12 +1,11 @@
-// 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.
@@ -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];

package/esm/valueScaleConfigSchema.d.ts

@@ -0,0 +1,211 @@
+import type { Instance } from '@jbrowse/mobx-state-tree';
+/** The autoscale modes a display offers, and the one it starts on. */
+export interface ValueScaleAutoscale {
+    modes: readonly string[];
+    default: string;
+}
+export interface ValueScaleOptions {
+    /** the scale types this display's renderer places, `linear` first */
+    types: readonly string[];
+    /** omitted where the display's domain consults no mode */
+    autoscale?: ValueScaleAutoscale;
+    /** `symlogConstant`'s default, where `types` holds `symlog` */
+    symlogConstant?: number;
+    /** the display draws `rules` and widens its domain to them */
+    rules?: boolean;
+    /** the display captions its axis with `title` */
+    title?: boolean;
+}
+declare function valueScaleRuleSchema(): import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+    readonly value: {
+        type: "number";
+    } & {
+        defaultValue: number;
+    };
+    readonly color: {
+        type: "maybeColor";
+    };
+    readonly label: {
+        type: "string";
+    } & {
+        defaultValue: string;
+    };
+}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined, undefined, import("@jbrowse/core/configuration").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>>>;
+export type ValueScaleRuleConfig = Instance<ReturnType<typeof valueScaleRuleSchema>>;
+/**
+ * #config ValueScale
+ * #category display
+ * The value scale of a quantitative display, written as `scales.y`: the
+ * wiggle and multi-wiggle plots, the Manhattan plot, the alignments coverage
+ * band and the mark display each carry one. Which members it has follows what
+ * the display draws: Manhattan places a linear axis and consults no autoscale
+ * mode, so it has neither `type` alternatives nor `autoscale`.
+ *
+ * Vega-Lite's spelling: a pinned end is `domainMin` or `domainMax`, and an end
+ * left unset autoscales over the loaded regions.
+ *
+ * Two defaults come from the display rather than from the scale. `autoscale`
+ * starts at `localpercentile` on the wiggle and multi-wiggle plots and at
+ * `local` on the coverage band and the mark display. `symlogConstant` starts
+ * at `0` on the wiggle family and at `1` on the coverage band.
+ *
+ * The wiggle family, the Manhattan plot and the mark display also carry
+ * `rules`, reference lines at chosen values; the mark display adds `title`,
+ * the caption beside the axis. A rule naming no `color` draws in the one
+ * colour the chrome rules every plot in, so a red line is a claim its author
+ * makes rather than a meaning a display assigns.
+ *
+ * #example
+ * A log axis floored at 1:
+ * ```js
+ * {
+ *   type: 'LinearWiggleDisplay',
+ *   scales: { y: { type: 'log', domainMin: 1 } },
+ * }
+ * ```
+ *
+ * #example
+ * The whole visible range, rather than the 99th percentile the wiggle
+ * displays start on:
+ * ```js
+ * {
+ *   type: 'LinearWiggleDisplay',
+ *   scales: { y: { autoscale: 'local' } },
+ * }
+ * ```
+ *
+ * #example
+ * A titled axis with a labelled genome-wide threshold over a plain
+ * suggestive one:
+ * ```js
+ * {
+ *   type: 'LinearMarkDisplay',
+ *   scales: {
+ *     y: {
+ *       title: '-log10 p',
+ *       rules: [{ value: 7.3, color: 'red', label: 'p = 5e-8' }, 5],
+ *     },
+ *   },
+ * }
+ * ```
+ */
+export declare function valueScaleSchema({ types: scaleTypes, autoscale, symlogConstant, rules, title, }: ValueScaleOptions): import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+    readonly type: {
+        type: "stringEnum";
+    } & {
+        model: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+    } & {
+        defaultValue: string;
+    };
+    readonly domainMin: {
+        type: "maybeNumber";
+    };
+    readonly domainMax: {
+        type: "maybeNumber";
+    };
+    readonly symlogConstant?: ({
+        type: "number";
+    } & {
+        defaultValue: number;
+    }) | undefined;
+    readonly autoscale?: ({
+        type: "stringEnum";
+    } & {
+        model: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+    } & {
+        defaultValue: string;
+    }) | undefined;
+    readonly numStdDev?: ({
+        type: "number";
+    } & {
+        defaultValue: number;
+    }) | undefined;
+    readonly numQuantile?: ({
+        type: "number";
+    } & {
+        defaultValue: number;
+    }) | undefined;
+    readonly title?: {
+        type: "maybeString";
+    } | undefined;
+    readonly rules?: import("@jbrowse/mobx-state-tree").IArrayType<import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+        readonly value: {
+            type: "number";
+        } & {
+            defaultValue: number;
+        };
+        readonly color: {
+            type: "maybeColor";
+        };
+        readonly label: {
+            type: "string";
+        } & {
+            defaultValue: string;
+        };
+    }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined, undefined, import("@jbrowse/core/configuration").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>>>> | undefined;
+}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined, undefined, import("@jbrowse/core/configuration").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>>>;
+export type ValueScaleConfigSchema = ReturnType<typeof valueScaleSchema>;
+/**
+ * The `scales` object a display declares, one member per aesthetic the
+ * grammar gives a scale. `y` is the only one so far, and every mark, bar or
+ * bin the display draws is placed through it.
+ */
+export declare function scalesSchema(y: ValueScaleConfigSchema): import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+    readonly y: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+        readonly type: {
+            type: "stringEnum";
+        } & {
+            model: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+        } & {
+            defaultValue: string;
+        };
+        readonly domainMin: {
+            type: "maybeNumber";
+        };
+        readonly domainMax: {
+            type: "maybeNumber";
+        };
+        readonly symlogConstant?: ({
+            type: "number";
+        } & {
+            defaultValue: number;
+        }) | undefined;
+        readonly autoscale?: ({
+            type: "stringEnum";
+        } & {
+            model: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+        } & {
+            defaultValue: string;
+        }) | undefined;
+        readonly numStdDev?: ({
+            type: "number";
+        } & {
+            defaultValue: number;
+        }) | undefined;
+        readonly numQuantile?: ({
+            type: "number";
+        } & {
+            defaultValue: number;
+        }) | undefined;
+        readonly title?: {
+            type: "maybeString";
+        } | undefined;
+        readonly rules?: import("@jbrowse/mobx-state-tree").IArrayType<import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+            readonly value: {
+                type: "number";
+            } & {
+                defaultValue: number;
+            };
+            readonly color: {
+                type: "maybeColor";
+            };
+            readonly label: {
+                type: "string";
+            } & {
+                defaultValue: string;
+            };
+        }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined, undefined, import("@jbrowse/core/configuration").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>>>> | undefined;
+    }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined, undefined, import("@jbrowse/core/configuration").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>>>;
+}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined, undefined, import("@jbrowse/core/configuration").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>>>;
+export type ScalesConfigSchema = ReturnType<typeof scalesSchema>;
+export {};

package/esm/valueScaleConfigSchema.js

@@ -0,0 +1,240 @@
+import { ConfigurationSchema } from '@jbrowse/core/configuration';
+import { types } from '@jbrowse/mobx-state-tree';
+function valueScaleRuleSchema() {
+    return ConfigurationSchema('ValueScaleRule', {
+        /**
+         * #slot scales.y.rules.value
+         * Where the rule sits on the axis, in the units the axis plots: a
+         * `-log10(p)` over a Manhattan plot, a depth over coverage.
+         */
+        value: {
+            type: 'number',
+            defaultValue: 0,
+            description: 'the value the rule is drawn at',
+        },
+        /**
+         * #slot scales.y.rules.color
+         * The line's colour, and its label's. Unset draws every rule in the one
+         * colour the chrome rules plots in, so a threshold that means something
+         * particular — genome-wide significance, a diploid depth — is one an
+         * author paints, on the plot where it means it.
+         */
+        color: {
+            type: 'maybeColor',
+            description: 'line and label colour; unset is the chrome’s own',
+        },
+        /**
+         * #slot scales.y.rules.label
+         * Free text drawn at the rule's right-hand end. JBrowse assigns it no
+         * meaning: "2 copies" over a coverage plot is a claim only the author
+         * can make, since no ploidy can be assumed.
+         */
+        label: {
+            type: 'string',
+            defaultValue: '',
+            description: "text at the rule's right-hand end",
+        },
+    }, { shorthand: 'value', closed: true });
+}
+/**
+ * #config ValueScale
+ * #category display
+ * The value scale of a quantitative display, written as `scales.y`: the
+ * wiggle and multi-wiggle plots, the Manhattan plot, the alignments coverage
+ * band and the mark display each carry one. Which members it has follows what
+ * the display draws: Manhattan places a linear axis and consults no autoscale
+ * mode, so it has neither `type` alternatives nor `autoscale`.
+ *
+ * Vega-Lite's spelling: a pinned end is `domainMin` or `domainMax`, and an end
+ * left unset autoscales over the loaded regions.
+ *
+ * Two defaults come from the display rather than from the scale. `autoscale`
+ * starts at `localpercentile` on the wiggle and multi-wiggle plots and at
+ * `local` on the coverage band and the mark display. `symlogConstant` starts
+ * at `0` on the wiggle family and at `1` on the coverage band.
+ *
+ * The wiggle family, the Manhattan plot and the mark display also carry
+ * `rules`, reference lines at chosen values; the mark display adds `title`,
+ * the caption beside the axis. A rule naming no `color` draws in the one
+ * colour the chrome rules every plot in, so a red line is a claim its author
+ * makes rather than a meaning a display assigns.
+ *
+ * #example
+ * A log axis floored at 1:
+ * ```js
+ * {
+ *   type: 'LinearWiggleDisplay',
+ *   scales: { y: { type: 'log', domainMin: 1 } },
+ * }
+ * ```
+ *
+ * #example
+ * The whole visible range, rather than the 99th percentile the wiggle
+ * displays start on:
+ * ```js
+ * {
+ *   type: 'LinearWiggleDisplay',
+ *   scales: { y: { autoscale: 'local' } },
+ * }
+ * ```
+ *
+ * #example
+ * A titled axis with a labelled genome-wide threshold over a plain
+ * suggestive one:
+ * ```js
+ * {
+ *   type: 'LinearMarkDisplay',
+ *   scales: {
+ *     y: {
+ *       title: '-log10 p',
+ *       rules: [{ value: 7.3, color: 'red', label: 'p = 5e-8' }, 5],
+ *     },
+ *   },
+ * }
+ * ```
+ */
+export function valueScaleSchema({ types: scaleTypes, autoscale, symlogConstant = 0, rules, title = false, }) {
+    return ConfigurationSchema('ValueScale', {
+        /**
+         * #slot scales.y.type
+         * How the axis reads its domain — the ticks, the cross-hatches and the
+         * renderer's placement all come from it. `log` cannot represent 0 or
+         * negative values and floors the domain above them; `symlog` is log-like
+         * away from zero and linear through it, so a track whose values touch or
+         * cross 0 keeps them. Which of the three a display offers is which of
+         * them its renderer places.
+         */
+        // #region stringEnumSlot
+        type: {
+            type: 'stringEnum',
+            model: types.enumeration('ValueScaleType', [...scaleTypes]),
+            defaultValue: 'linear',
+            description: scaleTypes.join(' or '),
+        },
+        // #endregion
+        /**
+         * #slot scales.y.domainMin
+         * The bottom of the axis, pinning what would otherwise autoscale to the
+         * loaded regions. Unset autoscales that end. The score menu's "Set
+         * min/max" writes here.
+         */
+        domainMin: {
+            type: 'maybeNumber',
+            description: 'pinned bottom of the axis; unset autoscales',
+        },
+        /**
+         * #slot scales.y.domainMax
+         * The top of the axis. Unset autoscales that end.
+         */
+        domainMax: {
+            type: 'maybeNumber',
+            description: 'pinned top of the axis; unset autoscales',
+        },
+        ...(scaleTypes.includes('symlog')
+            ? {
+                /**
+                 * #slot scales.y.symlogConstant
+                 * Width of symlog's linear region around zero. `0` derives it from
+                 * the domain, a thousandth of its largest magnitude — right for a
+                 * wiggle track, whose units are its own. The coverage band starts
+                 * at `1` instead, which makes symlog exactly `log(depth+1)` and
+                 * puts the knee at one read.
+                 */
+                symlogConstant: {
+                    type: 'number',
+                    defaultValue: symlogConstant,
+                    description: "width of symlog's linear region around zero",
+                    advanced: true,
+                },
+            }
+            : {}),
+        ...(autoscale
+            ? {
+                /**
+                 * #slot scales.y.autoscale
+                 * What an unpinned end scales to: `local` takes the extremes of
+                 * the visible region, `localsd` the mean ± `numStdDev` standard
+                 * deviations, `localpercentile` the `numQuantile`-th percentile of
+                 * each sign, which is robust to a peaky distribution.
+                 */
+                autoscale: {
+                    type: 'stringEnum',
+                    model: types.enumeration('ValueScaleAutoscale', [
+                        ...autoscale.modes,
+                    ]),
+                    defaultValue: autoscale.default,
+                    description: autoscale.modes.join(' or '),
+                },
+            }
+            : {}),
+        ...(autoscale?.modes.includes('localsd')
+            ? {
+                /**
+                 * #slot scales.y.numStdDev
+                 * Standard deviations either side of the mean the `localsd`
+                 * autoscale reaches.
+                 */
+                numStdDev: {
+                    type: 'number',
+                    defaultValue: 3,
+                    description: 'standard deviations for the localsd autoscale',
+                    advanced: true,
+                },
+            }
+            : {}),
+        ...(autoscale?.modes.includes('localpercentile')
+            ? {
+                /**
+                 * #slot scales.y.numQuantile
+                 * The percentile `localpercentile` clips outliers at — 0.99 drops
+                 * the outermost 1% of each sign. The two signs are measured
+                 * independently and anchored at 0, so a sparse minority tail
+                 * stays visible and all-positive data pins its bottom at 0.
+                 */
+                numQuantile: {
+                    type: 'number',
+                    defaultValue: 0.99,
+                    description: 'percentile the localpercentile autoscale clips at',
+                    advanced: true,
+                },
+            }
+            : {}),
+        ...(title
+            ? {
+                /**
+                 * #slot scales.y.title
+                 * The caption beside the axis, naming what it measures, drawn
+                 * once however many bands the scale rules and at every zoom.
+                 * Optional, as JBrowse's other captions are: unset, `""` or
+                 * `null`, the axis has none; some text is that text.
+                 */
+                title: {
+                    type: 'maybeString',
+                    description: 'axis caption; unset draws none',
+                },
+            }
+            : {}),
+        ...(rules
+            ? {
+                /**
+                 * #slot scales.y.rules
+                 * Horizontal reference lines at chosen values, across every band
+                 * the scale rules: a significance threshold, a zero line, an
+                 * allele-frequency cut. Each is `{ value, color, label }`, or a
+                 * bare number for a plain line. An autoscaled end widens to keep
+                 * every rule on the axis; a pinned `domainMin` or `domainMax`
+                 * that excludes a rule drops it.
+                 */
+                rules: types.array(valueScaleRuleSchema()),
+            }
+            : {}),
+    }, { closed: true });
+}
+/**
+ * The `scales` object a display declares, one member per aesthetic the
+ * grammar gives a scale. `y` is the only one so far, and every mark, bar or
+ * bin the display draws is placed through it.
+ */
+export function scalesSchema(y) {
+    return ConfigurationSchema('Scales', { y }, { closed: true });
+}

package/esm/wiggleRenderModes.generated.d.ts

@@ -3,7 +3,6 @@ export declare const RENDERING_TYPE_DENSITY = 1;
 export declare const RENDERING_TYPE_LINE = 2;
 export declare const RENDERING_TYPE_SCATTER = 3;
 export declare const RENDERING_TYPE_LINE_CENTER = 4;
-export declare const SCALE_TYPE_LOG = 1;
-export declare const SCALE_TYPE_SYMLOG = 2;
 export declare const NO_PREV_START = 4294967295;
 export declare const MIN_FILL_WIDTH_PX = 1.5;
+export declare const MAX_WIGGLE_CUTS = 8;

package/esm/wiggleRenderModes.generated.js

@@ -5,7 +5,6 @@ export const RENDERING_TYPE_DENSITY = 1;
 export const RENDERING_TYPE_LINE = 2;
 export const RENDERING_TYPE_SCATTER = 3;
 export const RENDERING_TYPE_LINE_CENTER = 4;
-export const SCALE_TYPE_LOG = 1;
-export const SCALE_TYPE_SYMLOG = 2;
 export const NO_PREV_START = 4294967295;
 export const MIN_FILL_WIDTH_PX = 1.5;
+export const MAX_WIGGLE_CUTS = 8;