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

package/esm/util/layouts/GranularRectLayout.js

@@ -49,10 +49,13 @@ export default class GranularRectLayout {
         this.maxHeight = Math.ceil(maxHeight / this.pitchY);
     }
     /**
+     * `lower` gives the rows lying wholly at or past `lower.top` px below the
+     * rect's top a span of their own.
+     *
      * @returns top position for the rect, or Null if laying
      *  out the rect would exceed maxHeight
      */
-    addRect(id, left, right, height) {
+    addRect(id, left, right, height, lower) {
         const pitchX = this.pitchX;
         const pitchY = this.pitchY;
         // if we have already laid it out, return its layout
@@ -65,12 +68,19 @@ export default class GranularRectLayout {
         const pLeft = Math.trunc(left / pitchX);
         const pRight = Math.trunc(right / pitchX);
         const pHeight = Math.ceil(height / pitchY);
+        const pLowerTop = lower ? Math.ceil(lower.top / pitchY) : pHeight;
         const rectangle = {
             l: pLeft,
             r: pRight,
             top: null,
             h: pHeight,
         };
+        const lowerSpan = lower
+            ? {
+                l: Math.trunc(lower.left / pitchX),
+                r: Math.trunc(lower.right / pitchX),
+            }
+            : rectangle;
         // Allow features to start at any position up to maxHeight
         // Features starting at maxHeight or beyond are filtered out, but features
         // that start below maxHeight and extend past it are allowed
@@ -84,7 +94,10 @@ export default class GranularRectLayout {
         // between them still spans y, because y < top + pHeight — so nothing between
         // can fit. `top = y` plus the loop's own increment is that jump, and it turns
         // the scan from O(rows * pHeight) into O(rows): without it, a rect pHeight
-        // rows tall re-tests the row that blocked it pHeight times over.
+        // rows tall re-tests the row that blocked it pHeight times over. Moving
+        // the rect down only moves y up within it, so a hit above the lower span
+        // blocks every top to y, and a hit in the lower span blocks just the tops
+        // keeping y there: the jump goes to the first top putting y above it.
         outer: for (; top <= maxTop; top += 1) {
             // Check all rows that this rectangle would occupy
             const maxY = top + pHeight;
@@ -97,13 +110,17 @@ export default class GranularRectLayout {
                 const intervals = row.getIntervals();
                 const len = intervals.length;
                 if (len > 0) {
+                    const inLower = y - top >= pLowerTop;
+                    const l = inLower ? lowerSpan.l : pLeft;
+                    const r = inLower ? lowerSpan.r : pRight;
+                    const blockedTop = inLower ? y - pLowerTop : y;
                     if (len < 40) {
                         // Linear scan for small arrays
                         for (let i = 0; i < len; i += 2) {
                             const start = intervals[i];
                             const end = intervals[i + 1];
-                            if (end > pLeft && start < pRight) {
-                                top = y;
+                            if (end > l && start < r) {
+                                top = blockedTop;
                                 continue outer;
                             }
                         }
@@ -115,7 +132,7 @@ export default class GranularRectLayout {
                         while (low < high) {
                             const mid = (low + high) >>> 1;
                             const midIdx = mid << 1;
-                            if (intervals[midIdx + 1] <= pLeft) {
+                            if (intervals[midIdx + 1] <= l) {
                                 low = mid + 1;
                             }
                             else {
@@ -125,8 +142,8 @@ export default class GranularRectLayout {
                         const idx = low << 1;
                         if (idx < len) {
                             const start = intervals[idx];
-                            if (start < pRight) {
-                                top = y;
+                            if (start < r) {
+                                top = blockedTop;
                                 continue outer;
                             }
                         }
@@ -143,7 +160,7 @@ export default class GranularRectLayout {
         rectangle.top = top;
         const yEnd = top + pHeight;
         for (let y = top; y < yEnd; y += 1) {
-            this.getOrCreateRow(y).addRect(rectangle);
+            this.getOrCreateRow(y).addRect(y - top >= pLowerTop ? lowerSpan : rectangle);
         }
         return top * pitchY;
     }

package/esm/util/lazyAfterAttach.d.ts

@@ -0,0 +1,13 @@
+import type { IStateTreeNode } from '@jbrowse/mobx-state-tree';
+/**
+ * #api core/util
+ * Run a display's `afterAttach` body from a module loaded on demand, so the
+ * autorun installers stay out of the display's eager bundle.
+ *
+ * One policy for the gap the `await` opens: a node torn down before the module
+ * lands installs nothing, and a module that fails to load is reported where the
+ * user can see it rather than onto the display's own error slot — that slot is
+ * what `reload()` clears, and nothing would re-run the install behind it.
+ * Three displays hand-rolled this IIFE and each drew the lines differently.
+ */
+export declare function runLazyAfterAttach<Self extends IStateTreeNode>(self: Self, load: () => Promise<(self: Self) => void>): void;

package/esm/util/lazyAfterAttach.js

@@ -0,0 +1,31 @@
+import { isAlive } from '@jbrowse/mobx-state-tree';
+import { getNotificationSink } from './sessionServices.js';
+/**
+ * #api core/util
+ * Run a display's `afterAttach` body from a module loaded on demand, so the
+ * autorun installers stay out of the display's eager bundle.
+ *
+ * One policy for the gap the `await` opens: a node torn down before the module
+ * lands installs nothing, and a module that fails to load is reported where the
+ * user can see it rather than onto the display's own error slot — that slot is
+ * what `reload()` clears, and nothing would re-run the install behind it.
+ * Three displays hand-rolled this IIFE and each drew the lines differently.
+ */
+export function runLazyAfterAttach(self, load) {
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+    ;
+    (async () => {
+        try {
+            const install = await load();
+            if (isAlive(self)) {
+                install(self);
+            }
+        }
+        catch (e) {
+            if (isAlive(self)) {
+                console.error(e);
+                getNotificationSink(self).notifyError(`${e}`, e);
+            }
+        }
+    })();
+}

package/esm/util/lazyWithPreload.d.ts

@@ -0,0 +1,19 @@
+import type { AnyReactComponentType } from './types/util.ts';
+/**
+ * `React.lazy` that also exposes the import it wraps, so code that knows a
+ * component is about to render (a session naming a view, a track being shown)
+ * can start the download instead of waiting for React to reach it. A failed
+ * load is not kept, so the render that follows tries again.
+ *
+ * Once the import has landed, the first render gets the module synchronously.
+ * React.lazy suspends on any promise, settled or not, and React holds a
+ * suspended boundary's reveal for 300 ms after its fallback commits, so a
+ * preloaded component nested under another cost that 300 ms per level.
+ */
+export declare function lazyWithPreload<T extends AnyReactComponentType>(factory: () => Promise<{
+    default: T;
+}>): import("react").LazyExoticComponent<T> & {
+    preload: () => Promise<{
+        default: T;
+    }>;
+};

package/esm/util/lazyWithPreload.js

@@ -0,0 +1,27 @@
+import { lazy } from 'react';
+/**
+ * `React.lazy` that also exposes the import it wraps, so code that knows a
+ * component is about to render (a session naming a view, a track being shown)
+ * can start the download instead of waiting for React to reach it. A failed
+ * load is not kept, so the render that follows tries again.
+ *
+ * Once the import has landed, the first render gets the module synchronously.
+ * React.lazy suspends on any promise, settled or not, and React holds a
+ * suspended boundary's reveal for 300 ms after its fallback commits, so a
+ * preloaded component nested under another cost that 300 ms per level.
+ */
+export function lazyWithPreload(factory) {
+    let loaded;
+    let loading;
+    const load = () => (loading ??= factory().then(module => (loaded = module), (error) => {
+        loading = undefined;
+        throw error;
+    }));
+    const settled = (module) => ({
+        // eslint-disable-next-line unicorn/no-thenable -- React.lazy takes a module synchronously only from a then that calls back at once
+        then: (resolve) => {
+            resolve(module);
+        },
+    });
+    return Object.assign(lazy(() => (loaded ? settled(loaded) : load())), { preload: load });
+}

package/esm/util/legendCandidates.d.ts

@@ -0,0 +1,72 @@
+import type { CategoricalEntry, CategoricalScale } from '../ui/colorScale.ts';
+import type { LegendSwatch } from '../ui/legendSpec.ts';
+import type { CategoricalField } from './categoricalField.ts';
+export interface LegendCandidate {
+    rowIndex: number;
+    value: string;
+    color: number;
+}
+export interface LegendEntry {
+    values: string[];
+    color: number;
+}
+export declare const MAX_LEGEND_ENTRIES = 30;
+export declare const MAX_LEGEND_CANDIDATES = 1024;
+/**
+ * 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 declare function createLegendCandidateCollector(maxCandidates?: number): {
+    candidates: LegendCandidate[];
+    add(rowIndex: number, value: string, color: number): void;
+};
+export interface LegendCandidateSource {
+    candidates: readonly LegendCandidate[];
+    rowPaintsCandidateColor: (rowIndex: number) => boolean;
+}
+/**
+ * The categorical color key over any number of packed regions: one entry per
+ * 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 there are more than `maxEntries` distinct colors, where the data is
+ * not a categorical vocabulary. `regions` is consumed lazily.
+ */
+export declare function unionLegendCandidates<T>(regions: Iterable<T>, resolve: (region: T) => LegendCandidateSource, maxEntries?: number): LegendEntry[];
+/**
+ * A source whose every entry is a candidate its one row paints: the entries of
+ * a scale table `encodeFeatures` resolved, or any walk that met each value in
+ * one color.
+ */
+export declare function everyRowPaints(entries: readonly {
+    value: string;
+    color: number;
+}[]): LegendCandidateSource;
+/**
+ * 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. `title` heads it in place of the field's name, `''` heading
+ * nothing, and `swatches` draws a row as something other than its color's box.
+ * `besides` are the colors of rows a display lists beside these, which the
+ * one-color test counts and the length test does not.
+ */
+export declare function derivedColorScale<T>(regions: Iterable<T>, resolve: (region: T) => LegendCandidateSource, { id, field, title, maxItems, swatches, besides, }: {
+    id: string;
+    field: CategoricalField;
+    title?: string;
+    maxItems?: number;
+    swatches?: (row: CategoricalEntry & {
+        color: string;
+    }) => LegendSwatch[];
+    besides?: readonly string[];
+}): CategoricalScale[];

package/esm/util/legendCandidates.js

@@ -0,0 +1,138 @@
+import { MAX_LEGEND_ITEMS, 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.
+//
+// A different question from `legendIsReadable`'s lower bar, which asks whether a
+// key a display already has is worth the rows it costs.
+export const MAX_LEGEND_ENTRIES = 30;
+// Bound on the candidate list one region ships. Far above MAX_LEGEND_ENTRIES, so
+// a vocabulary that is categorical at all crosses whole, and a track with a name
+// per feature ships a prefix that reads the same way it would have.
+export const MAX_LEGEND_CANDIDATES = 1024;
+/**
+ * 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 seen = new Set();
+    return {
+        candidates,
+        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 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 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 rows = new Map();
+    const seenValues = new Set();
+    for (const region of regions) {
+        const { candidates, rowPaintsCandidateColor } = resolve(region);
+        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 [...rows.values()];
+}
+/**
+ * A source whose every entry is a candidate its one row paints: the entries of
+ * a scale table `encodeFeatures` resolved, or any walk that met each value in
+ * one color.
+ */
+export function everyRowPaints(entries) {
+    return {
+        candidates: entries.map(({ value, color }) => ({
+            rowIndex: 0,
+            value,
+            color,
+        })),
+        rowPaintsCandidateColor: () => true,
+    };
+}
+/**
+ * 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. `title` heads it in place of the field's name, `''` heading
+ * nothing, and `swatches` draws a row as something other than its color's box.
+ * `besides` are the colors of rows a display lists beside these, which the
+ * one-color test counts and the length test does not.
+ */
+export function derivedColorScale(regions, resolve, { id, field, title = field.field, maxItems, swatches, besides = [], }) {
+    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));
+    const beside = besides.map(color => ({
+        label: '',
+        color: abgrToCssRgba(cssColorToABGR(color)),
+    }));
+    return painted.length > 0 &&
+        legendIsReadable([...entries, ...beside], (maxItems ?? MAX_LEGEND_ITEMS) + beside.length)
+        ? [
+            {
+                kind: 'categorical',
+                id,
+                ...(title ? { title } : {}),
+                ...(field.domain.length > 0 ? { domain: field.domain } : {}),
+                entries: swatches
+                    ? entries.map(row => ({ ...row, swatches: swatches(row) }))
+                    : entries,
+            },
+        ]
+        : [];
+}

package/esm/util/locString.js

@@ -36,12 +36,12 @@ export function parseLocStringOneBased(locString, isValidRefName) {
         throw new Error('no location string provided, could not parse');
     }
     // handle reverse strand notation e.g. "chr1:1-100[rev]"
+    locString = locString.replaceAll(/\s/g, '');
     let reversed = false;
     if (locString.endsWith('[rev]')) {
         reversed = true;
         locString = locString.slice(0, -5);
     }
-    locString = locString.replaceAll(/\s/g, '');
     // extract optional assembly name in braces e.g. "{hg19}chr1:1-100"
     const assemblyMatch = ASSEMBLY_REGEX.exec(locString);
     if (!assemblyMatch) {
@@ -174,7 +174,10 @@ function assembleLocStringWith(region, cb = (n) => n) {
     }
     let endString;
     if (end !== undefined) {
-        endString = start !== undefined && start + 1 === end ? '' : `..${cb(end)}`;
+        endString =
+            start !== undefined && (start + 1 === end || start === end)
+                ? ''
+                : `..${cb(end)}`;
     }
     else {
         endString = start !== undefined ? '..' : '';

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

@@ -0,0 +1,150 @@
+import Flatbush from './flatbush/index.ts';
+import type { FeatureTable } from './featureTable.ts';
+import type { JexlInstance } from './jexlStrings.ts';
+import type { ColorEncoding, ColorScaleTable, ContinuousRef, Encoded, EncodedChannels, FieldRef, LocusRef, ShapeEncoding, SizeEncoding, LaneName } from './markEncodingTypes.ts';
+import type { ProgressReporter } from './progress.ts';
+import type { Feature } from './simpleFeature.ts';
+export type { AggregateOp, AggregateStep, BinStep, CategoricalRef, ColorEncoding, ContinuousRef, CoverageStep, ColorScaleTable, CoreGetEncodedLayersArgs, Encoded, EncodedChannels, EncodedLayersResult, FacetSection, FacetSpec, FieldRef, FilterStep, FormulaStep, LocusRef, MateStep, ShapeEncoding, ShapeName, ShapeScaleTable, SizeEncoding, SizeRef, SizeScaleTable, 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";
+export declare const DEFAULT_SIZE_RANGE_PX: [number, number];
+/**
+ * #api
+ * The misconfiguration grey packed as the encoder paints it: a `jexl:` colour
+ * that answered no string, a ramp value that is no number, text a threshold
+ * cannot read.
+ */
+export declare const MISCONFIGURED_ABGR: number;
+/**
+ * #api
+ * The no-value grey packed as the encoder paints it: a feature with nothing in
+ * the field a threshold reads.
+ */
+export declare const NO_VALUE_ABGR: number;
+/**
+ * #api
+ * A channel read per feature: the compiled form of a {@link FieldRef}, and
+ * what a display's own worker method hands the encoder for a channel no
+ * field name can say — a join against a second adapter, a lookup table, a
+ * rule over two fields.
+ */
+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, 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 | LocusRef | ChannelReader;
+    y?: FieldRef | ChannelReader;
+    row?: FieldRef | ChannelReader | ArrayLike<number>;
+    color?: ColorEncoding | ChannelReader<number>;
+    shape?: ShapeEncoding | ChannelReader<number>;
+    text?: FieldRef | ChannelReader;
+    size?: SizeEncoding;
+}
+/**
+ * #api
+ * What surrounds an encode: the jexl instance a `jexl:` channel compiles
+ * against — a caller whose channels are all readers or field names passes
+ * none — and a progress reporter.
+ */
+export interface EncodeContext {
+    jexl?: JexlInstance;
+    report?: ProgressReporter;
+}
+/**
+ * #api
+ * 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 hitIndexOf(x: Uint32Array, x2: Uint32Array, y: Float32Array | undefined, count?: number): Flatbush;
+/**
+ * #api
+ * An encoded payload as a display stores it: the hit index the worker built
+ * with {@link hitIndexOf}, wrapped once where the payload lands.
+ */
+export type HitIndexed<T extends EncodedChannels> = T & {
+    flatbush?: Flatbush;
+};
+/**
+ * #api
+ * {@link HitIndexed} over what the worker shipped.
+ */
+export declare function withHitIndex<T extends EncodedChannels>(channels: T): HitIndexed<T>;
+/**
+ * #api
+ * Evaluate one encoding over a feature list into dense channel arrays for
+ * the lanes named, the scale table each scaled channel came from, the `y`
+ * extremes and — when `index` is among the lanes — a hit index.
+ *
+ * A feature whose `x`, `x2` or (declared and asked-for) `y` is not finite is
+ * skipped and counted in `skipped`, so every array stays index-aligned with
+ * the Flatbush. Pure: the RPC around it owns the adapter, the filters and the
+ * transferables.
+ *
+ * Columnar: one pass admits the rows over `x`, `x2` and `y` alone, and none
+ * runs where all three are lanes of whole numbers; every other lane is then
+ * filled in its own loop over the admitted rows, a lane straight off a typed
+ * column and a categorical over a `category` column per label.
+ */
+export declare function encodeFeatures<L extends LaneName>(input: readonly Feature[] | FeatureTable, encoding: MarkEncodingInput, lanes: readonly L[], ctx?: EncodeContext): Encoded<L>;
+/**
+ * #api
+ * A continuous colour scale over `extent`, the values it met: the domain its
+ * declared ends and the extent make, the straight table its stops bake to and
+ * where its middle stop sits, and the packed colour a value paints through
+ * them: an infinity the end on its side, as a threshold places it, and NaN,
+ * text that is no number, the misconfiguration grey. The encoder and every
+ * display painting a ramp itself read it, so a value takes one colour whoever
+ * paints it.
+ */
+export declare function continuousColorScale(encoding: ContinuousRef, extent: readonly [number, number]): {
+    domain: [number, number];
+    lut: Uint8Array<ArrayBufferLike>;
+    midNorm: number;
+    colorOf: (value: number) => number;
+};
+/**
+ * #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. The table stays straight and `domainMid` a value, so the middle stop
+ * follows the widened domain with no table baked again.
+ */
+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 —
+ * the unscaled arm of {@link ColorEncoding}, on its own for a display that
+ * carries a plain `color` slot.
+ */
+export declare function colorEvaluator(color: string, jexl: JexlInstance | undefined): (feature: Feature) => number;
+/**
+ * #api
+ * The input feature instance `i` of `channels` was: `featureIndex[i]`, or `i`
+ * itself where the encoder skipped none and so shipped no index.
+ */
+export declare function featureIndexAt(channels: Pick<EncodedChannels, 'featureIndex'>, i: number): number;
+/**
+ * #api
+ * The packed colour instance `i` of `channels` paints: `color[i]`, or `color`
+ * itself where the colour is a constant and so shipped as one number.
+ */
+export declare function colorAt(channels: Pick<EncodedChannels, 'color'>, i: number): number | undefined;
+/**
+ * #api
+ * The buffers an {@link EncodedChannels} owns, for `rpcResult`'s transfer
+ * list.
+ */
+export declare function encodedChannelTransferables(c: EncodedChannels): ArrayBufferLike[];