@jbrowse/core 5.0.0-beta.11 → 5.0.0-beta.14

package/esm/util/colorScale.d.ts

@@ -1,21 +1,21 @@
 /**
- * The scales a colour object paints through, in a module that imports
+ * The scales a color object paints through, in a module that imports
  * nothing: `jbrowse validate` carries a copy of it, so the validator and the
  * displays read one statement.
  */
-/** How a colour object maps its `field`; `none` paints `value`. */
+/** How a color object maps its `field`; `none` paints `value`. */
 export declare const COLOR_SCALES: readonly ['none', 'categorical', 'linear', 'log', 'threshold'];
 /**
- * The scale that maps no field: each feature paints the colour it carries, and
- * the key names the colours `domain` lists. Only a display whose features
- * carry colours of their own declares it.
+ * The scale that maps no field: each feature paints the color it carries, and
+ * the key names the colors `domain` lists. Only a display whose features
+ * carry colors of their own declares it.
  */
 export declare const IDENTITY_SCALE = "identity";
 export type ColorScaleName = (typeof COLOR_SCALES)[number] | typeof IDENTITY_SCALE;
 /**
  * A field's defaults on a display: the scale it paints through while `scale`
  * is unset, and the members that scale reads while the config leaves them
- * unwritten, so a field with a vocabulary or ramp of its own is the colour
+ * unwritten, so a field with a vocabulary or ramp of its own is the color
  * object's defaults rather than a painter beside it.
  */
 export interface FieldPreset<S extends string = ColorScaleName> {
@@ -31,17 +31,22 @@ export interface FieldPreset<S extends string = ColorScaleName> {
     domainMid?: number;
     scheme?: string;
     reverse?: boolean;
+    /** A threshold key's direction: its highest interval first. */
+    descending?: boolean;
 }
 /** Each field's preset, `*` for any other field. */
 export type FieldPresets<S extends string = ColorScaleName> = Readonly<Record<string, FieldPreset<S>>>;
 /**
- * The fields whose values have names, an order and colours of their own on
- * every display, beneath each display's own presets. Red forward and blue
- * reverse is what the synteny ribbons paint too. The SV classes are
+ * The fields whose values have names, an order and colors of their own on
+ * every display, beneath each display's own presets. The synteny ribbons
+ * paint strand from this range too. The SV classes are
  * `svClassOf`'s, deletion red and duplication blue as dbVar and gnomAD-SV
  * paint them, insertion the pileup's purple, and the rest kept apart under
  * deuteranopia and protanopia. A record with no class files under `''`, so
- * each display keeps its own no-value colour for it.
+ * each display keeps its own no-value color for it. The impact tiers are a
+ * variant's most severe SnpEff (ANN) or VEP (CSQ) consequence, and a record
+ * with neither files under Unannotated, its own color: "nobody looked" is
+ * not MODIFIER's "we looked and it is harmless".
  */
 export declare const UNIVERSAL_FIELD_PRESETS: {
     readonly strand: {
@@ -58,6 +63,13 @@ export declare const UNIVERSAL_FIELD_PRESETS: {
         readonly labels: readonly ["Deletion", "Duplication", "Insertion", "Inversion", "Copy-number variable", "Tandem repeat", "Breakend / translocation", "Complex", "Other / mixed"];
         readonly title: 'SV type';
     };
+    readonly impact: {
+        readonly scale: 'categorical';
+        readonly missing: 'Unannotated';
+        readonly domain: readonly ["HIGH", "MODERATE", "LOW", "MODIFIER", "Unannotated"];
+        readonly range: readonly ["#d32f2f", "#f57c00", "#fbc02d", "#9e9e9e", "#607d8b"];
+        readonly title: 'Consequence impact';
+    };
 };
 /** The universal preset of `field`, if it has one. */
 export declare function universalPresetOf(field: string): FieldPreset<'categorical'> | undefined;
@@ -75,6 +87,73 @@ export declare const FEATURE_FIELD_PRESETS: {
     };
     readonly '*': FieldPreset<"categorical">;
 };
+/**
+ * Mapping quality's bins, each keyed by its lowest score and confident reads
+ * first: real MAPQ is bimodal at the aligner's ceiling and at 0, and these
+ * are the cuts people filter on (`samtools view -q 10` / `-q 30`).
+ */
+export declare const MAPQ_BINS: readonly [{
+    readonly key: '30';
+    readonly min: 30;
+    readonly label: 'MAPQ 30+ (high confidence)';
+}, {
+    readonly key: '10';
+    readonly min: 10;
+    readonly label: 'MAPQ 10-29';
+}, {
+    readonly key: '1';
+    readonly min: 1;
+    readonly label: 'MAPQ 1-9 (low)';
+}, {
+    readonly key: '0';
+    readonly min: 0;
+    readonly label: 'MAPQ 0 (multi-mapping)';
+}];
+/**
+ * The measurements whose scale is part of what they mean, for a display
+ * whose features carry them to spread into its own presets: `mapq` in the
+ * bins above; `identity` a fraction from 0 to 1, red where it diverges and
+ * blue where it is conserved, as conservation tracks paint it, through a grey
+ * middle that stays visible on a white page and under a faint ribbon, where
+ * viridis's bright top washed out; and `dnds` read against 1, its ramp's pale
+ * middle, up to 2, past which a few fast-evolving genes would flatten the
+ * rest into one blue; and `syntenicDepth` grey where a gene pair is
+ * one-to-one, so genes sharing one ortholog are what takes color. Opt-in rather
+ * than universal, since a column another file names `identity` need not be a
+ * fraction.
+ */
+export declare const MEASURE_FIELD_PRESETS: {
+    readonly mapq: {
+        readonly scale: 'threshold';
+        readonly domain: ("0" | "1" | "10" | "30")[];
+        readonly scheme: 'cividis';
+        readonly labels: ("MAPQ 0 (multi-mapping)" | "MAPQ 1-9 (low)" | "MAPQ 10-29" | "MAPQ 30+ (high confidence)")[];
+        readonly title: 'Mapping quality';
+        readonly descending: true;
+    };
+    readonly identity: {
+        readonly scale: 'linear';
+        readonly domainMin: 0;
+        readonly domainMax: 1;
+        readonly scheme: 'redgreyblue';
+        readonly title: 'Identity';
+    };
+    readonly dnds: {
+        readonly scale: 'linear';
+        readonly domainMin: 0;
+        readonly domainMax: 2;
+        readonly domainMid: 1;
+        readonly scheme: 'blueyellowred';
+        readonly title: 'dN/dS';
+    };
+    readonly syntenicDepth: {
+        readonly scale: 'threshold';
+        readonly domain: readonly ["2", "3"];
+        readonly range: readonly ["#bdbdbd", "#fdae6b", "#e6550d"];
+        readonly labels: readonly ["One-to-one", "Shared by 2 genes", "Shared by 3 or more"];
+        readonly title: 'Syntenic depth';
+    };
+};
 /**
  * A field's preset under `presets`: its own, else a universal one, else
  * `*`'s, else categorical.
@@ -83,20 +162,31 @@ export declare function presetOf<S extends string>(presets: FieldPresets<S>, fie
 /** What a field paints through under `presets` while `scale` is unset. */
 export declare function fieldScaleOf<S extends string>(presets: FieldPresets<S>, field: string): S | 'categorical';
 /**
- * A colour object with its field's preset under it: each member the preset
+ * A color object with its field's preset under it: each member the preset
  * names and the config leaves unwritten, an empty list counting as unwritten.
- * Only while the colour paints through the preset's own scale, so the cuts of
+ * Only while the color paints through the preset's own scale, so the cuts of
  * a threshold preset never reach a field read through a ramp. A categorical
- * preset's `range` and `labels` name its `domain`'s values in order, so they
- * fill only while `domain` does too: a written order keeps each value's own
- * colour and name.
+ * preset's `range` and `labels` name its `domain`'s values in order, and a
+ * threshold preset's `labels` its intervals, so they fill only while `domain`
+ * does too: a written order keeps each value's own color and name, and written
+ * cuts keep the preset's palette and lose its interval names.
  */
 export declare function withPreset<C extends {
     field?: string;
     scale?: string;
 }>(color: C, presets: FieldPresets<string>): C;
 /**
- * The scale a colour object paints through: `none` while no `field` is
+ * A color object with `implied` as its field while it names neither a field
+ * nor a constant, for a display whose bare color object still maps one (a
+ * quantitative display's `score`), so the display and `jbrowse validate`
+ * read it alike. A written `value` keeps the object a constant.
+ */
+export declare function withImpliedField<C extends {
+    value?: unknown;
+    field?: string;
+}>(color: C, implied: string | undefined): C;
+/**
+ * The scale a color object paints through: `none` while no `field` is
  * named, else its own `scale`, or `fieldScale` where that is unset.
  */
 export declare function paintedScale<S extends string, F extends string>({ scale, field }: {
@@ -105,28 +195,32 @@ export declare function paintedScale<S extends string, F extends string>({ scale
 }, fieldScale: F): S | F | 'none';
 /** A combination of a scale's slots the display cannot draw as written. */
 export interface ScaleProblem {
-    rule: 'threshold-cuts' | 'threshold-range' | 'ramp-domain' | 'domain-ends' | 'domain-quantile' | 'labels-domain';
+    rule: 'threshold-cuts' | 'threshold-range' | 'ramp-domain' | 'ramp-range' | 'domain-ends' | 'domain-quantile' | 'log-floor' | 'labels-domain';
     /** the slot to look at, relative to the scale's own object */
     slot: string;
     message: string;
 }
 /**
- * The members a quantitative scale's ends are read by, as a colour ramp,
+ * The members a quantitative scale's ends are read by, as a color ramp,
  * `scales.y` and a mark's width spell them alike.
  */
 export interface ScaleEnds {
     domainMin?: number;
     domainMax?: number;
     domainQuantile?: number;
+    /** the scale's kind, `scales.y.type` or a color's `scale`, where it bears on the ends */
+    type?: string;
 }
 /**
  * What a quantitative scale's ends say together that neither can refuse
  * alone: a `domainMax` below its `domainMin`, which every such scale draws in
  * order either way, and a `domainQuantile` outside 0.5 to 1, where the quantile
- * an open end follows is clamped. `reverse` is whether the scale turns round by
- * a member of its own, which is then the spelling to point at.
+ * an open end follows is clamped; and a log scale's `domainMin` at or below 0,
+ * which no log scale can hold, so the end floors above it. `reverse` is whether
+ * the scale turns round by a member of its own, which is then the spelling to
+ * point at.
  */
-export declare function scaleEndProblems({ domainMin, domainMax, domainQuantile }: ScaleEnds, { reverse }?: {
+export declare function scaleEndProblems({ domainMin, domainMax, domainQuantile, type }: ScaleEnds, { reverse }?: {
     reverse?: boolean;
 }): ScaleProblem[];
 /** Problems as the lines a display's corner notice lists, under the setting that holds the scale. */
@@ -143,8 +237,15 @@ export interface ColorSlots {
     domainQuantile?: number;
     labels?: readonly unknown[];
 }
+/** A quantitative scale's ends among the members `member` reads, each a number or unset. */
+export declare function scaleEndsOf(member: (name: string) => unknown): ScaleEnds;
+/**
+ * The members `colorProblems` reads among the ones `member` reads, each of the
+ * type it reads or unset, so a config snapshot and a config node answer alike.
+ */
+export declare function colorSlotsOf(member: (name: string) => unknown): ColorSlots;
 /**
- * What a colour object's slots say together that no single slot can refuse,
+ * What a color object's slots say together that no single slot can refuse,
  * since the config editor writes one slot at a time (ADR-133), read with its
  * field's preset under it. A display shows these as a notice and draws what
  * it can. A threshold naming no cuts leaves its intervals to the display —

package/esm/util/colorScale.js

@@ -1,9 +1,9 @@
 /**
- * The scales a colour object paints through, in a module that imports
+ * The scales a color object paints through, in a module that imports
  * nothing: `jbrowse validate` carries a copy of it, so the validator and the
  * displays read one statement.
  */
-/** How a colour object maps its `field`; `none` paints `value`. */
+/** How a color object maps its `field`; `none` paints `value`. */
 export const COLOR_SCALES = [
     'none',
     'categorical',
@@ -12,20 +12,23 @@ export const COLOR_SCALES = [
     'threshold',
 ];
 /**
- * The scale that maps no field: each feature paints the colour it carries, and
- * the key names the colours `domain` lists. Only a display whose features
- * carry colours of their own declares it.
+ * The scale that maps no field: each feature paints the color it carries, and
+ * the key names the colors `domain` lists. Only a display whose features
+ * carry colors of their own declares it.
  */
 export const IDENTITY_SCALE = 'identity';
 const CATEGORICAL_PRESET = { scale: 'categorical' };
 /**
- * The fields whose values have names, an order and colours of their own on
- * every display, beneath each display's own presets. Red forward and blue
- * reverse is what the synteny ribbons paint too. The SV classes are
+ * The fields whose values have names, an order and colors of their own on
+ * every display, beneath each display's own presets. The synteny ribbons
+ * paint strand from this range too. The SV classes are
  * `svClassOf`'s, deletion red and duplication blue as dbVar and gnomAD-SV
  * paint them, insertion the pileup's purple, and the rest kept apart under
  * deuteranopia and protanopia. A record with no class files under `''`, so
- * each display keeps its own no-value colour for it.
+ * each display keeps its own no-value color for it. The impact tiers are a
+ * variant's most severe SnpEff (ANN) or VEP (CSQ) consequence, and a record
+ * with neither files under Unannotated, its own color: "nobody looked" is
+ * not MODIFIER's "we looked and it is harmless".
  */
 export const UNIVERSAL_FIELD_PRESETS = {
     strand: {
@@ -62,6 +65,13 @@ export const UNIVERSAL_FIELD_PRESETS = {
         ],
         title: 'SV type',
     },
+    impact: {
+        scale: 'categorical',
+        missing: 'Unannotated',
+        domain: ['HIGH', 'MODERATE', 'LOW', 'MODIFIER', 'Unannotated'],
+        range: ['#d32f2f', '#f57c00', '#fbc02d', '#9e9e9e', '#607d8b'],
+        title: 'Consequence impact',
+    },
 };
 /** The universal preset of `field`, if it has one. */
 export function universalPresetOf(field) {
@@ -81,6 +91,63 @@ export const FEATURE_FIELD_PRESETS = {
     score: { scale: 'linear' },
     '*': CATEGORICAL_PRESET,
 };
+/**
+ * Mapping quality's bins, each keyed by its lowest score and confident reads
+ * first: real MAPQ is bimodal at the aligner's ceiling and at 0, and these
+ * are the cuts people filter on (`samtools view -q 10` / `-q 30`).
+ */
+export const MAPQ_BINS = [
+    { key: '30', min: 30, label: 'MAPQ 30+ (high confidence)' },
+    { key: '10', min: 10, label: 'MAPQ 10-29' },
+    { key: '1', min: 1, label: 'MAPQ 1-9 (low)' },
+    { key: '0', min: 0, label: 'MAPQ 0 (multi-mapping)' },
+];
+const MAPQ_BINS_ASCENDING = [...MAPQ_BINS].reverse();
+/**
+ * The measurements whose scale is part of what they mean, for a display
+ * whose features carry them to spread into its own presets: `mapq` in the
+ * bins above; `identity` a fraction from 0 to 1, red where it diverges and
+ * blue where it is conserved, as conservation tracks paint it, through a grey
+ * middle that stays visible on a white page and under a faint ribbon, where
+ * viridis's bright top washed out; and `dnds` read against 1, its ramp's pale
+ * middle, up to 2, past which a few fast-evolving genes would flatten the
+ * rest into one blue; and `syntenicDepth` grey where a gene pair is
+ * one-to-one, so genes sharing one ortholog are what takes color. Opt-in rather
+ * than universal, since a column another file names `identity` need not be a
+ * fraction.
+ */
+export const MEASURE_FIELD_PRESETS = {
+    mapq: {
+        scale: 'threshold',
+        domain: MAPQ_BINS_ASCENDING.slice(1).map(bin => bin.key),
+        scheme: 'cividis',
+        labels: MAPQ_BINS_ASCENDING.map(bin => bin.label),
+        title: 'Mapping quality',
+        descending: true,
+    },
+    identity: {
+        scale: 'linear',
+        domainMin: 0,
+        domainMax: 1,
+        scheme: 'redgreyblue',
+        title: 'Identity',
+    },
+    dnds: {
+        scale: 'linear',
+        domainMin: 0,
+        domainMax: 2,
+        domainMid: 1,
+        scheme: 'blueyellowred',
+        title: 'dN/dS',
+    },
+    syntenicDepth: {
+        scale: 'threshold',
+        domain: ['2', '3'],
+        range: ['#bdbdbd', '#fdae6b', '#e6550d'],
+        labels: ['One-to-one', 'Shared by 2 genes', 'Shared by 3 or more'],
+        title: 'Syntenic depth',
+    },
+};
 /**
  * A field's preset under `presets`: its own, else a universal one, else
  * `*`'s, else categorical.
@@ -98,13 +165,14 @@ function unwritten(value) {
     return value === undefined || (Array.isArray(value) && value.length === 0);
 }
 /**
- * A colour object with its field's preset under it: each member the preset
+ * A color object with its field's preset under it: each member the preset
  * names and the config leaves unwritten, an empty list counting as unwritten.
- * Only while the colour paints through the preset's own scale, so the cuts of
+ * Only while the color paints through the preset's own scale, so the cuts of
  * a threshold preset never reach a field read through a ramp. A categorical
- * preset's `range` and `labels` name its `domain`'s values in order, so they
- * fill only while `domain` does too: a written order keeps each value's own
- * colour and name.
+ * preset's `range` and `labels` name its `domain`'s values in order, and a
+ * threshold preset's `labels` its intervals, so they fill only while `domain`
+ * does too: a written order keeps each value's own color and name, and written
+ * cuts keep the preset's palette and lose its interval names.
  */
 export function withPreset(color, presets) {
     const field = color.field ?? '';
@@ -113,17 +181,27 @@ export function withPreset(color, presets) {
         return color;
     }
     const written = new Map(Object.entries(color));
-    const ordered = preset.scale !== 'categorical' ||
-        !preset.domain ||
-        unwritten(written.get('domain'));
+    const ownDomain = !preset.domain || unwritten(written.get('domain'));
+    const named = preset.scale === 'categorical' ? ['range', 'labels'] : ['labels'];
     const filled = Object.entries(preset).filter(([key]) => key !== 'scale' &&
         key !== 'missing' &&
-        (ordered || (key !== 'range' && key !== 'labels')) &&
+        (ownDomain || !named.includes(key)) &&
         unwritten(written.get(key)));
     return filled.length > 0 ? { ...color, ...Object.fromEntries(filled) } : color;
 }
 /**
- * The scale a colour object paints through: `none` while no `field` is
+ * A color object with `implied` as its field while it names neither a field
+ * nor a constant, for a display whose bare color object still maps one (a
+ * quantitative display's `score`), so the display and `jbrowse validate`
+ * read it alike. A written `value` keeps the object a constant.
+ */
+export function withImpliedField(color, implied) {
+    return implied && !color.field && color.value === undefined
+        ? { ...color, field: implied }
+        : color;
+}
+/**
+ * The scale a color object paints through: `none` while no `field` is
  * named, else its own `scale`, or `fieldScale` where that is unset.
  */
 export function paintedScale({ scale, field }, fieldScale) {
@@ -133,11 +211,22 @@ export function paintedScale({ scale, field }, fieldScale) {
  * What a quantitative scale's ends say together that neither can refuse
  * alone: a `domainMax` below its `domainMin`, which every such scale draws in
  * order either way, and a `domainQuantile` outside 0.5 to 1, where the quantile
- * an open end follows is clamped. `reverse` is whether the scale turns round by
- * a member of its own, which is then the spelling to point at.
+ * an open end follows is clamped; and a log scale's `domainMin` at or below 0,
+ * which no log scale can hold, so the end floors above it. `reverse` is whether
+ * the scale turns round by a member of its own, which is then the spelling to
+ * point at.
  */
-export function scaleEndProblems({ domainMin, domainMax, domainQuantile }, { reverse = false } = {}) {
+export function scaleEndProblems({ domainMin, domainMax, domainQuantile, type }, { reverse = false } = {}) {
     return [
+        ...(type === 'log' && domainMin !== undefined && domainMin <= 0
+            ? [
+                {
+                    rule: 'log-floor',
+                    slot: 'domainMin',
+                    message: `a log scale has no ${domainMin}: the end floors to a positive value, so leave domainMin unset to follow the data or pin it above 0`,
+                },
+            ]
+            : []),
         ...(domainMin !== undefined &&
             domainMax !== undefined &&
             domainMin > domainMax
@@ -165,11 +254,44 @@ export function scaleEndProblems({ domainMin, domainMax, domainQuantile }, { rev
 export function noticeLines(setting, problems) {
     return problems.map(({ slot, message }) => `${setting}.${slot}: ${message}`);
 }
+function numberOf(value) {
+    return typeof value === 'number' ? value : undefined;
+}
+function stringOf(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function listOf(value) {
+    return Array.isArray(value) ? value : undefined;
+}
+/** A quantitative scale's ends among the members `member` reads, each a number or unset. */
+export function scaleEndsOf(member) {
+    return {
+        domainMin: numberOf(member('domainMin')),
+        domainMax: numberOf(member('domainMax')),
+        domainQuantile: numberOf(member('domainQuantile')),
+        type: stringOf(member('type')),
+    };
+}
+/**
+ * The members `colorProblems` reads among the ones `member` reads, each of the
+ * type it reads or unset, so a config snapshot and a config node answer alike.
+ */
+export function colorSlotsOf(member) {
+    return {
+        ...scaleEndsOf(member),
+        value: stringOf(member('value')),
+        field: stringOf(member('field')) ?? '',
+        scale: stringOf(member('scale')),
+        domain: listOf(member('domain')),
+        range: listOf(member('range')),
+        labels: listOf(member('labels')),
+    };
+}
 function pinned(entry) {
     return entry !== '' && Number.isFinite(Number(entry));
 }
 /**
- * What a colour object's slots say together that no single slot can refuse,
+ * What a color object's slots say together that no single slot can refuse,
  * since the config editor writes one slot at a time (ADR-133), read with its
  * field's preset under it. A display shows these as a notice and draws what
  * it can. A threshold naming no cuts leaves its intervals to the display —
@@ -198,7 +320,7 @@ export function colorProblems(written, presets) {
             problems.push({
                 rule: 'threshold-range',
                 slot: 'range',
-                message: `${domain.length} threshold ${domain.length === 1 ? 'cut makes' : 'cuts make'} ${domain.length + 1} intervals, one colour each, and range lists ${range.length}: a missing colour comes from the default palette and an extra one is never read`,
+                message: `${domain.length} threshold ${domain.length === 1 ? 'cut makes' : 'cuts make'} ${domain.length + 1} intervals, one color each, and range lists ${range.length}: a missing color comes from the default palette and an extra one is never read`,
             });
         }
     }
@@ -207,10 +329,17 @@ export function colorProblems(written, presets) {
             problems.push({
                 rule: 'ramp-domain',
                 slot: 'domain',
-                message: "a linear or log scale reads no domain, which is a categorical scale's order and a threshold scale's cuts; a ramp's ends are domainMin and domainMax where the colour has them",
+                message: "a linear or log scale reads no domain, which is a categorical scale's order and a threshold scale's cuts; a ramp's ends are domainMin and domainMax where the color has them",
+            });
+        }
+        if (range.length === 1) {
+            problems.push({
+                rule: 'ramp-range',
+                slot: 'range',
+                message: 'a linear or log ramp runs between at least two colors, and one paints every value alike; a single color is value',
             });
         }
-        problems.push(...scaleEndProblems(color, { reverse: true }));
+        problems.push(...scaleEndProblems({ ...color, type: scale }, { reverse: true }));
     }
     const { labels = [] } = color;
     const named = scale === 'categorical' || scale === IDENTITY_SCALE
@@ -225,13 +354,13 @@ export function colorProblems(written, presets) {
         const what = scale === 'categorical'
             ? 'value'
             : scale === IDENTITY_SCALE
-                ? 'colour'
+                ? 'color'
                 : 'interval';
         problems.push({
             rule: 'labels-domain',
             slot: 'labels',
             message: named === undefined
-                ? "labels names a categorical scale's values, a threshold scale's intervals or an identity scale's colours, and this colour paints none of them"
+                ? "labels names a categorical scale's values, a threshold scale's intervals or an identity scale's colors, and this color paints none of them"
                 : `labels names one ${what} each, and ${labels.length} ${labels.length === 1 ? 'label names' : 'labels name'} ${named} ${named === 1 ? what : `${what}s`}: a label past them names nothing`,
         });
     }

package/esm/util/colorSchemes.d.ts

@@ -1,15 +1,19 @@
 /**
  * #api
- * The named ramps a continuous colour scale's `scheme` takes, each one a stop
+ * The named ramps a continuous color scale's `scheme` takes, each one a stop
  * table in `colorRamp.ts` that every ramp baker reads, so no display can name
  * a scheme nothing bakes. `viridis`, `magma`, `inferno` and `cividis` are
  * matplotlib's perceptual ramps, dark at the low end; `juicebox` fades from
  * transparent to red, as Juicebox paints contacts; `fall` runs white through
  * yellow and red to black, as HiGlass does; `reds` and `blues` are
  * ColorBrewer's, from white; `redblue` and `purpleorange` diverge through
- * white, ColorBrewer's RdBu and PuOr.
+ * white, ColorBrewer's RdBu and PuOr; `redgreyblue` diverges through a grey
+ * middle, which stays visible on a white page where a white middle would
+ * not, as `identity` paints;
+ * `blueyellowred` is ColorBrewer's RdYlBu turned round, so low reads cool and
+ * high hot through a pale yellow middle, as `dnds` paints.
  */
-export declare const COLOR_SCHEMES: readonly ['viridis', 'magma', 'inferno', 'cividis', 'juicebox', 'fall', 'reds', 'blues', 'redblue', 'purpleorange'];
+export declare const COLOR_SCHEMES: readonly ['viridis', 'magma', 'inferno', 'cividis', 'juicebox', 'fall', 'reds', 'blues', 'redblue', 'purpleorange', 'redgreyblue', 'blueyellowred'];
 /** #api */
 export type ColorSchemeName = (typeof COLOR_SCHEMES)[number];
 /**

package/esm/util/colorSchemes.js

@@ -1,13 +1,17 @@
 /**
  * #api
- * The named ramps a continuous colour scale's `scheme` takes, each one a stop
+ * The named ramps a continuous color scale's `scheme` takes, each one a stop
  * table in `colorRamp.ts` that every ramp baker reads, so no display can name
  * a scheme nothing bakes. `viridis`, `magma`, `inferno` and `cividis` are
  * matplotlib's perceptual ramps, dark at the low end; `juicebox` fades from
  * transparent to red, as Juicebox paints contacts; `fall` runs white through
  * yellow and red to black, as HiGlass does; `reds` and `blues` are
  * ColorBrewer's, from white; `redblue` and `purpleorange` diverge through
- * white, ColorBrewer's RdBu and PuOr.
+ * white, ColorBrewer's RdBu and PuOr; `redgreyblue` diverges through a grey
+ * middle, which stays visible on a white page where a white middle would
+ * not, as `identity` paints;
+ * `blueyellowred` is ColorBrewer's RdYlBu turned round, so low reads cool and
+ * high hot through a pale yellow middle, as `dnds` paints.
  */
 export const COLOR_SCHEMES = [
     'viridis',
@@ -20,6 +24,8 @@ export const COLOR_SCHEMES = [
     'blues',
     'redblue',
     'purpleorange',
+    'redgreyblue',
+    'blueyellowred',
 ];
 /**
  * #api

package/esm/util/createSvgRasterCanvas.d.ts

@@ -1,3 +1,4 @@
+export declare const MAX_SVG_RASTER_AREA_PX: number;
 export interface SvgRasterCanvasOpts {
     /**
      * headless canvas factory for `rasterizeLayers` (jbrowse-img passes one);
@@ -11,7 +12,19 @@ export interface SvgRasterCanvasOpts {
      */
     decodeSvg?: (markup: string) => Promise<CanvasImageSource>;
 }
-export declare function createSvgRasterCanvas(width: number, height: number, opts: SvgRasterCanvasOpts | undefined): {
+/**
+ * A canvas for one rasterized export layer of `width`x`height` CSS px, drawn in
+ * CSS px. Its backing store is 2× where that fits under `maxAreaPx` and the
+ * per-axis limit, and smaller where it does not, so read `canvas.width` for the
+ * scale it got.
+ */
+export declare function createSvgRasterCanvas(width: number, height: number, opts: SvgRasterCanvasOpts | undefined, maxAreaPx?: number): {
     canvas: HTMLCanvasElement;
     ctx: CanvasRenderingContext2D;
 };
+/**
+ * The PNG data URL of an export raster. A canvas the browser could not
+ * allocate encodes to `data:,`, an image of nothing, so this throws and the
+ * export dialog shows the error.
+ */
+export declare function svgRasterDataUrl(canvas: HTMLCanvasElement): string;