@jbrowse/core 5.0.0-beta.7 → 5.0.0-beta.9

package/esm/util/legendCandidates.js

@@ -1,3 +1,5 @@
+import { legendIsReadable } from '../ui/legendSpec.js';
+import { abgrToCssRgba, cssColorToABGR } from './colorBits.js';
 // How many distinct colors a derived key may name and still BE a key. Past this
 // the data is not a categorical vocabulary (a track keyed by unique per-feature
 // names), and a list of every feature is the thing a key exists instead of.
@@ -10,78 +12,102 @@ export const MAX_LEGEND_ENTRIES = 30;
 // per feature ships a prefix that reads the same way it would have.
 export const MAX_LEGEND_CANDIDATES = 1024;
 /**
- * Accumulator for the distinct (row, name, color) combinations a packer walks
- * past, in first-seen order and bounded — the small list `unionLegendCandidates`
- * derives a key from, so the main thread never re-walks the features. Fed scalar
- * by scalar, from the loop that already holds the three values.
- *
- * Deduped on the whole triple rather than on (row, color): the union takes the
- * first NAME it sees for a color, so where that name is already spoken for, the
- * second name on that color has to still be in the list to carry it.
- *
- * A nameless feature contributes nothing, which is the union's rule too — so a
- * track whose features have no names ships an empty list rather than one entry
- * per feature.
+ * Accumulator for the distinct (row, value, color) combinations a packer walks
+ * past, in first-seen order and bounded, so the main thread never re-walks the
+ * features. Deduped on the whole triple: a row of the union lists every value
+ * painted in its color, so a second value on that color has to still be in the
+ * list to reach it.
  */
 export function createLegendCandidateCollector(maxCandidates = MAX_LEGEND_CANDIDATES) {
     const candidates = [];
-    const colorsSeen = new Map();
+    const seen = new Set();
     return {
         candidates,
-        add(rowIndex, label, color) {
-            if (label !== '' && candidates.length < maxCandidates) {
-                let byLabel = colorsSeen.get(rowIndex);
-                if (byLabel === undefined) {
-                    byLabel = new Map();
-                    colorsSeen.set(rowIndex, byLabel);
-                }
-                let colors = byLabel.get(label);
-                if (colors === undefined) {
-                    colors = new Set();
-                    byLabel.set(label, colors);
-                }
-                if (!colors.has(color)) {
-                    colors.add(color);
-                    candidates.push({ rowIndex, label, color });
-                }
+        add(rowIndex, value, color) {
+            const id = `${rowIndex}\u0000${color}\u0000${value}`;
+            if (candidates.length < maxCandidates && !seen.has(id)) {
+                seen.add(id);
+                candidates.push({ rowIndex, value, color });
             }
         },
     };
 }
 /**
  * The categorical color key over any number of packed regions: one entry per
- * distinct color, labeled by the first name seen in that color, in first-seen
- * order.
- *
- * Keyed by color rather than by name, so each key row is 1:1 with a color — a
- * row is normally a toggle and hiding a category hides features BY color, so two
- * names sharing one color must collapse to a single row. A name reused across
- * two colors keeps its first-seen color.
+ * distinct color listing every value painted in it, colors in first-seen
+ * order. Keyed by color rather than by value because hiding a category hides
+ * features BY color, so two values sharing one color are one row that names
+ * both; a value met in two colors stays with the first.
  *
- * `[]` when the data carries no categorical signal: nothing named, or more than
- * `maxEntries` distinct colors.
- *
- * `regions` is consumed lazily, so a caller able to answer without reading any
- * of them can pass a generator and have none of them touched.
+ * `[]` when there are more than `maxEntries` distinct colors, where the data is
+ * not a categorical vocabulary. `regions` is consumed lazily.
  */
 export function unionLegendCandidates(regions, resolve, maxEntries = MAX_LEGEND_ENTRIES) {
-    const entries = [];
-    const seenColors = new Set();
-    const seenLabels = new Set();
+    const rows = new Map();
+    const seenValues = new Set();
     for (const region of regions) {
         const { candidates, rowPaintsCandidateColor } = resolve(region);
-        for (const { rowIndex, label, color } of candidates) {
-            if (rowPaintsCandidateColor(rowIndex) &&
-                !seenLabels.has(label) &&
-                !seenColors.has(color)) {
-                seenLabels.add(label);
-                seenColors.add(color);
-                entries.push({ label, color });
-                if (entries.length > maxEntries) {
+        for (const { rowIndex, value, color } of candidates) {
+            if (!rowPaintsCandidateColor(rowIndex) || seenValues.has(value)) {
+                continue;
+            }
+            seenValues.add(value);
+            const row = rows.get(color);
+            if (row) {
+                row.values.push(value);
+            }
+            else {
+                rows.set(color, { values: [value], color });
+                if (rows.size > maxEntries) {
                     return [];
                 }
             }
         }
     }
-    return entries;
+    return [...rows.values()];
+}
+/**
+ * The one categorical key a color channel derives from what a worker painted:
+ * the union above over the loaded regions, each row a painted color naming
+ * every value in it through `field` and ordered by it, and nothing where the
+ * rows would say nothing (`legendIsReadable`). A display resolving its own colors hands the
+ * candidates its packer recorded; one resolved by `encodeFeatures` hands the
+ * entries of the scale tables that came back. Either way the key lists what
+ * the painting holds, and a `closed` field's domain besides once anything
+ * painted.
+ */
+export function derivedColorScale(regions, resolve, { id, field, maxItems, }) {
+    const painted = unionLegendCandidates(regions, resolve).map(({ values, color }) => {
+        const sorted = values.toSorted(field.compare);
+        const value = sorted[0];
+        return {
+            value,
+            values: sorted,
+            label: sorted.map(v => field.label(v)).join(', '),
+            color: abgrToCssRgba(color),
+            ...(value === '' ? { missing: true } : {}),
+        };
+    });
+    const named = new Set(painted.flatMap(e => e.values));
+    const unpainted = field.closed && painted.length > 0
+        ? field.domain
+            .filter(value => !named.has(value))
+            .map(value => ({
+            value,
+            label: field.label(value),
+            color: abgrToCssRgba(cssColorToABGR(field.color(value))),
+        }))
+        : [];
+    const entries = [...painted, ...unpainted].sort((a, b) => field.compare(a.value, b.value));
+    return legendIsReadable(entries, maxItems)
+        ? [
+            {
+                kind: 'categorical',
+                id,
+                title: field.field,
+                ...(field.domain.length > 0 ? { domain: field.domain } : {}),
+                entries,
+            },
+        ]
+        : [];
 }

package/esm/util/localStorage.js

@@ -12,10 +12,10 @@ export const { available: localStorageAvailable, getItem: localStorageGetItem, s
 // and has to be announced by hand. Missing that half is what let two components
 // on one key show different values until one of them remounted.
 //
-// Announcing is deliberately not folded into localStorageSetItem. The
-// grid-bookmark widget persists its list from an autorun over the list, so a
-// write that called its own subscriber back would re-enter that autorun and
-// write again, forever. A writer says when its write is news.
+// Announcing is deliberately not folded into localStorageSetItem. A writer
+// that persists from an autorun over its own state would, if its write called
+// its own subscriber back, re-enter that autorun and write again, forever. A
+// writer says when its write is news.
 const listeners = new Map();
 // Installed on the first subscription rather than at module scope, so importing
 // this file from a worker or a test never touches `window`.

package/esm/util/markEncoding.d.ts

@@ -1,16 +1,13 @@
+import Flatbush from './flatbush/index.ts';
 import type { JexlInstance } from './jexlStrings.ts';
-import type { ColorEncoding, Encoded, EncodedChannels, FieldRef, GlyphEncoding, LaneName, ValueEncoding } from './markEncodingTypes.ts';
+import type { ColorEncoding, ColorScaleTable, Encoded, EncodedChannels, FieldRef, GlyphEncoding, LaneName } from './markEncodingTypes.ts';
 import type { ProgressReporter } from './progress.ts';
 import type { Feature } from './simpleFeature.ts';
-export type { AggregateOp, AggregateStep, BinStep, CategoricalRef, ColorEncoding, CoverageStep, ColorScaleTable, CoreEncodeFeaturesArgs, Encoded, EncodedChannels, EncodedFeaturesResult, FieldRef, FilterStep, FormulaStep, GlyphEncoding, GlyphName, GlyphScaleTable, LaneName, LayerRequest, MarkEncoding, RampRef, ScaleTable, TransformStep, ValueEncoding, } from './markEncodingTypes.ts';
+export type { AggregateOp, AggregateStep, BinStep, CategoricalRef, ColorEncoding, ContinuousRef, CoverageStep, ColorScaleTable, CoreEncodeFeaturesArgs, Encoded, EncodedChannels, EncodedFeaturesResult, FacetSection, FacetSpec, FieldRef, FilterStep, FormulaStep, GlyphEncoding, GlyphName, GlyphScaleTable, LaneName, LayerRequest, MarkEncoding, ScaleTable, ThresholdRef, TransformStep, } from './markEncodingTypes.ts';
+export type { ColorSchemeName } from './colorSchemes.ts';
+export { COLOR_SCHEMES } from './colorSchemes.ts';
+export { NO_VALUE_LABEL } from './categoricalField.ts';
 export declare const DEFAULT_MARK_COLOR = "#0068d1";
-/**
- * #api
- * The key row a feature with nothing in a categorical field lands on, so the
- * legend says why a mark is grey, or a disc, rather than listing a blank
- * value.
- */
-export declare const NO_VALUE_LABEL = "(no value)";
 /**
  * #api
  * A channel read per feature: the compiled form of a {@link FieldRef}, and
@@ -22,14 +19,16 @@ export type ChannelReader<T = unknown> = (feature: Feature) => T;
 /**
  * #api
  * What `encodeFeatures` takes: a {@link MarkEncoding}, any channel of which
- * may be a {@link ChannelReader} in place of its declared form. The declared
- * form is what crosses the wire; a reader is built in the worker.
+ * may be a {@link ChannelReader} in place of its declared form, and `row` the
+ * values themselves, one per input feature, where the caller computed them —
+ * a facet's stacked rows. The declared form is what crosses the wire; a
+ * reader or a value list is built in the worker.
  */
 export interface MarkEncodingInput {
     x?: FieldRef | ChannelReader;
     x2?: FieldRef | ChannelReader;
-    y?: ValueEncoding | ChannelReader;
-    row?: FieldRef | ChannelReader;
+    y?: FieldRef | ChannelReader;
+    row?: FieldRef | ChannelReader | ArrayLike<number>;
     color?: ColorEncoding | ChannelReader<number>;
     glyph?: GlyphEncoding | ChannelReader<number>;
 }
@@ -45,10 +44,10 @@ export interface EncodeContext {
 }
 /**
  * #api
- * The field a `y` declaration reads, whichever of its two forms it is
- * written in.
+ * The hit index over `count` instances: each a box from `x` to `x2` at its
+ * `y`, or at 0 for a mark with no value.
  */
-export declare function valueField(y: ValueEncoding): FieldRef;
+export declare function hitIndexOf(x: Uint32Array, x2: Uint32Array, y: Float32Array | undefined, count?: number): Flatbush;
 /**
  * #api
  * Evaluate one encoding over a feature list into dense channel arrays for
@@ -61,6 +60,23 @@ export declare function valueField(y: ValueEncoding): FieldRef;
  * transferables.
  */
 export declare function encodeFeatures<L extends LaneName>(features: readonly Feature[], encoding: MarkEncodingInput, lanes: readonly L[], ctx?: EncodeContext): Encoded<L>;
+/**
+ * #api
+ * A ramp table over `extent`, the union a display took across the regions it
+ * loaded: each open end of the domain moved to the union's, the pinned ends
+ * kept, and the table baked again where a `domainMid` places its middle stop
+ * by that domain. Each region baked its own, so keeping the first region's
+ * put the middle colour at a value none of them declared.
+ *
+ * One table per stop list and middle position, so a display asking again over
+ * an extent that has not moved gets the bytes it already uploaded: a backend
+ * re-uploads a ramp on identity.
+ */
+export declare function rampOverExtent(table: Extract<ColorScaleTable, {
+    kind: 'ramp';
+}>, extent: [number, number]): Extract<ColorScaleTable, {
+    kind: 'ramp';
+}>;
 /**
  * #api
  * A CSS colour or `jexl:` colour expression as a per-feature packed ABGR —