@fjader/svelte 0.2.3 → 0.2.5

package/dist/components/marks/lifecycle/other-split.js

@@ -0,0 +1,112 @@
+/**
+ * An Other bar's selected share, per row, and when a bar has one: the pure
+ * half of MarkLifecycleV2's `otherSplit`, so it can be tested without a mark.
+ */
+/**
+ * The split channel for the bar renderer, per row: share = Σ values · selected
+ * / Σ values over the row's own member lists. Selection is by value (`decode`
+ * maps an id to its value), so the NULL category needs nothing special. A row
+ * whose members mix signs gets no split (0): a share of a sum that cancels
+ * means nothing.
+ *
+ * `previous`: the last split for the SAME rows (the same result), when only the
+ * selection changed. A flat row then holds its previous position, so going flat
+ * (a selection cleared, or one that no longer reaches into Other) is a fade,
+ * not a slide. Without it (a new result) every row takes its value, and the
+ * split travels with the bar's own morph.
+ *
+ * Cost, measured: about 22 ns per Other member per call (the `selected.has`),
+ * so 0.1 ms at 5 000 members and about 1.2 ms at 50 000. Fine per click. If
+ * selection ever changes continuously (a brush on a band axis) over a very large
+ * Other, test membership against a Uint8Array indexed by id, built once per
+ * change, rather than a Set. The arrays allocated here are sized by rows.
+ */
+export function otherSplit(opts) {
+    const { rows, band, otherId, ids, values, selected, decode } = opts;
+    const previous = opts.previous && opts.previous.split.length === rows ? opts.previous : null;
+    const split = new Float32Array(rows);
+    const flat = new Uint8Array(rows);
+    const pickedSums = new Float64Array(rows);
+    const totals = new Float64Array(rows);
+    const pickedCount = new Int32Array(rows);
+    const memberCount = new Int32Array(rows);
+    let slides = true;
+    for (let row = 0; row < rows; row++) {
+        if (Number(band.at(row)) !== otherId)
+            continue;
+        const memberIds = ids.at(row);
+        const memberValues = values.at(row);
+        if (!memberIds || !memberValues)
+            continue;
+        let total = 0;
+        let picked = 0;
+        let count = 0;
+        let positive = false;
+        let negative = false;
+        for (let k = 0; k < memberIds.length; k++) {
+            const v = memberValues[k];
+            if (v > 0)
+                positive = true;
+            else if (v < 0)
+                negative = true;
+            total += v;
+            if (selected == null || selected.has(decode[memberIds[k]])) {
+                picked += v;
+                count++;
+            }
+        }
+        if (positive && negative)
+            continue;
+        pickedSums[row] = picked;
+        totals[row] = total;
+        pickedCount[row] = count;
+        memberCount[row] = memberIds.length;
+        const share = total === 0 ? (selected == null ? 1 : 0) : Math.min(1, Math.max(0, picked / total));
+        const isFlat = selected == null || share === 0;
+        flat[row] = isFlat ? 1 : 0;
+        if (isFlat && previous) {
+            const held = previous.split[row];
+            split[row] = held > 0.5 ? held : 2;
+        }
+        else {
+            split[row] = 1 + share;
+        }
+        if (previous && previous.flat[row] === 1 && !isFlat)
+            slides = false;
+    }
+    return {
+        split,
+        flat,
+        slides,
+        picked: pickedSums,
+        total: totals,
+        pickedCount,
+        memberCount,
+        active: selected != null
+    };
+}
+/**
+ * Whether a bar's Other bucket can be split: its length must be what Other
+ * sums, and a total. `length` is the bar's length channel, `by` the channel
+ * topN ranks by (null: its default, the length), `expr` the length channel's
+ * select expression.
+ *
+ * Other sums `by`, so a length channel that is not `by` is 0 on the Other row.
+ * A bare COUNT or SUM, or a raw column (an ungrouped mark), is a total; a mean,
+ * a max, a ratio or a distinct count summed into Other is not, and a share of
+ * it would look exact while meaning nothing.
+ */
+export function splittable(length, by, expr) {
+    if (!length || (by ?? length) !== length)
+        return false;
+    if (typeof expr === 'string')
+        return true;
+    const node = expr;
+    if (!node || typeof node !== 'object')
+        return false;
+    if (node.type === 'COLUMN_REF')
+        return true;
+    if (node.type !== 'AGGREGATE' || node.isDistinct)
+        return false;
+    return node.name === 'count' || node.name === 'sum';
+}

package/dist/components/marks/lifecycle/query-builder.d.ts

@@ -1,6 +1,7 @@
 import { sum, Query, WindowNode, type ExprNode } from '@uwdata/mosaic-sql';
 import type { TransformCompiler } from '../../../transforms/TransformCompiler';
 import type { ColumnSchema } from '../../../query-engine/QueryEngine';
+import type { BinPadding } from '../../../types';
 interface OrderConfig {
     seriesChannel: string | null;
     dimensionChannel: string;
@@ -18,6 +19,14 @@ export interface QueryParts {
      * combination, and cannot recover from a query topN has already wrapped.
      */
     groupKeys: string[] | null;
+    /**
+     * The numeric `bin()` channels and their bins, set by the mark from the
+     * same resolution its bin expressions came from. With them `dense()` pads a
+     * histogram to every bin; preagg reads copy them, so both paths pad alike.
+     */
+    bins?: Record<string, BinPadding> | null;
+    /** The query reads a preagg table that already holds its padding rows. */
+    padded?: boolean;
     orderChannels: string[] | null;
     aliasMap: Map<string, string>;
     /** Channels whose raw config value was a column-name passthrough (string
@@ -26,7 +35,31 @@ export interface QueryParts {
      *  CAST for ORDER BY, ordinal CASE for PARTITION BY). Used by preagg to
      *  fold redundant window col refs into channel aliases. */
     passthroughChannels: Map<string, string>;
+    /**
+     * `nulls="drop"`: the categorical channels whose NULL the mark leaves out.
+     * Stated by CHANNEL, not by source column, so every path filters in the
+     * terms of its own select: `assembleQuery` reads each channel's expression
+     * from the `selectDef` it is given — the id column on the base table, the
+     * preagg table's column when preagg rewrote it — and ANDs the predicate
+     * into the base scan, before any transform.
+     */
+    nullDrops?: readonly NullDrop[];
+}
+/**
+ * One channel whose NULL a mark drops. With `nullId`, the channel carries dim
+ * ids and the NULL category is that id: `<channel> <> nullId`. Without (a raw
+ * value, or a dim with no NULL row): `<channel> IS NOT NULL`.
+ */
+export interface NullDrop {
+    channel: string;
+    nullId: number | null;
 }
+/**
+ * The predicates for `drops`, each on its channel's expression in `selectDef`.
+ * A dropped channel must be a row-level group key of the query; one the query
+ * does not select would be left unfiltered, so that is an error, not a skip.
+ */
+export declare function nullDropPredicates(drops: readonly NullDrop[], selectDef: Record<string, unknown>): ExprNode[];
 /** Window functions to apply in an outer CTE over the assembled inner query. */
 export interface WindowWrap {
     /** channel → outer WindowNode (already rewritten to reference channel aliases). */
@@ -38,9 +71,10 @@ export interface AssembleOptions {
     parts: QueryParts;
     /** Per-call filter predicates (crossfilter, bin filters). */
     filter?: unknown[];
-    /** Columns to add IS NOT NULL predicates for. */
     transformCompiler: TransformCompiler;
     limit?: number | null;
+    /** The table already has the mark's row filters (`filter()`) applied: a preagg table. */
+    skipRowFilters?: boolean;
     /** When set, the inner query is wrapped in a CTE and these window
      *  functions are applied in the outer SELECT. ORDER BY / LIMIT move to
      *  the outer query. */
@@ -49,8 +83,8 @@ export interface AssembleOptions {
 /**
  * Wrap an expression so DuckDB returns a Float32-compatible REAL with NULLs
  * mapped to NaN: COALESCE(CAST(expr AS REAL), 'NaN'::REAL). Arrow columns then
- * have nullCount=0 and clean buffers for zero-copy GPU upload; shaders detect
- * NaN and discard.
+ * have nullCount=0 and clean Float32 buffers that upload to the GPU as they are,
+ * with no per-row JS pass; shaders detect NaN and discard.
  */
 export declare function castReal(expr: unknown): ExprNode;
 /**
@@ -134,5 +168,21 @@ export declare function buildQueryParts(select: Record<string, unknown>, orderCo
  * discarded one level up.
  */
 export declare function outerOrder(preference: string[] | null, alignment: string[] | null): string[] | null;
+/**
+ * Assemble a Query from cached parts + per-call filter.
+ *
+ * Order is fixed and shared by the flat, window-CTE, and preagg paths:
+ *
+ *   SELECT parts.selectDef FROM table [GROUP BY dims]
+ *   WHERE filter AND nullDrops      — on the base scan, so transform CTEs
+ *                                     (topN ranking etc.) see filtered rows
+ *   → SQL transforms (CTE wrapping)
+ *   → [window CTE: outer SELECT applies window fns over the inner result]
+ *   → ORDER BY outerOrder(...)      — alignment, then orderChannels; outermost
+ *   → LIMIT
+ *
+ * Callers decide what is CAST-wrapped by preparing parts.selectDef with
+ * castNumeric(); assembly never inspects expression types.
+ */
 export declare function assembleQuery(opts: AssembleOptions): Query;
 export {};

package/dist/components/marks/lifecycle/query-builder.js

@@ -1,13 +1,30 @@
-import { isNode, isAggregateExpression, isColumnRef, isColumnParam, column as sqlColumn, cast, coalesce, collectColumns, rewrite, sql, isNotNull, and, sum, avg, min, max, Query, WindowNode } from '@uwdata/mosaic-sql';
+import { isNode, isAggregateExpression, isColumnRef, isColumnParam, column as sqlColumn, cast, coalesce, collectColumns, rewrite, sql, isNotNull, neq, literal, and, sum, avg, min, max, Query, WindowNode } from '@uwdata/mosaic-sql';
 import { isWindowExpression, isVerbatimWindowExpression } from '../../../sql/expression-utils';
+/**
+ * The predicates for `drops`, each on its channel's expression in `selectDef`.
+ * A dropped channel must be a row-level group key of the query; one the query
+ * does not select would be left unfiltered, so that is an error, not a skip.
+ */
+export function nullDropPredicates(drops, selectDef) {
+    const out = [];
+    for (const { channel, nullId } of drops) {
+        const value = selectDef[channel];
+        if (value === undefined) {
+            throw new Error(`nulls="drop" filters the "${channel}" channel, which this query does not select.`);
+        }
+        const expr = (typeof value === 'string' ? sqlColumn(value) : value);
+        out.push(nullId === null ? isNotNull(expr) : neq(expr, literal(nullId)));
+    }
+    return out;
+}
 // ---------------------------------------------------------------------------
 // Numeric CAST policy (single rule for every assembly path)
 // ---------------------------------------------------------------------------
 /**
  * Wrap an expression so DuckDB returns a Float32-compatible REAL with NULLs
  * mapped to NaN: COALESCE(CAST(expr AS REAL), 'NaN'::REAL). Arrow columns then
- * have nullCount=0 and clean buffers for zero-copy GPU upload; shaders detect
- * NaN and discard.
+ * have nullCount=0 and clean Float32 buffers that upload to the GPU as they are,
+ * with no per-row JS pass; shaders detect NaN and discard.
  */
 export function castReal(expr) {
     return coalesce(cast(expr, 'REAL'), sql `'NaN'::REAL`);
@@ -202,22 +219,6 @@ export function buildQueryParts(select, orderConfig, hasSQLTransforms, passthrou
 // ---------------------------------------------------------------------------
 // Assembly — the one sequence every query path follows
 // ---------------------------------------------------------------------------
-/**
- * Assemble a Query from cached parts + per-call filter.
- *
- * Order is fixed and shared by the flat, window-CTE, and preagg paths:
- *
- *   SELECT parts.selectDef FROM table [GROUP BY dims]
- *   WHERE filter AND nulls          — on the base scan, so transform CTEs
- *                                     (topN ranking etc.) see filtered rows
- *   → SQL transforms (CTE wrapping)
- *   → [window CTE: outer SELECT applies window fns over the inner result]
- *   → ORDER BY outerOrder(...)      — alignment, then orderChannels; outermost
- *   → LIMIT
- *
- * Callers decide what is CAST-wrapped by preparing parts.selectDef with
- * castNumeric(); assembly never inspects expression types.
- */
 /** Output aliases a query exposes to whatever wraps it. */
 function selectAliases(query) {
     const sel = query._select;
@@ -266,20 +267,39 @@ export function outerOrder(preference, alignment) {
         add(channel);
     return order;
 }
+/**
+ * Assemble a Query from cached parts + per-call filter.
+ *
+ * Order is fixed and shared by the flat, window-CTE, and preagg paths:
+ *
+ *   SELECT parts.selectDef FROM table [GROUP BY dims]
+ *   WHERE filter AND nullDrops      — on the base scan, so transform CTEs
+ *                                     (topN ranking etc.) see filtered rows
+ *   → SQL transforms (CTE wrapping)
+ *   → [window CTE: outer SELECT applies window fns over the inner result]
+ *   → ORDER BY outerOrder(...)      — alignment, then orderChannels; outermost
+ *   → LIMIT
+ *
+ * Callers decide what is CAST-wrapped by preparing parts.selectDef with
+ * castNumeric(); assembly never inspects expression types.
+ */
 export function assembleQuery(opts) {
-    const { table, parts, filter = [], transformCompiler, limit, window } = opts;
+    const { table, parts, filter = [], transformCompiler, limit, window, skipRowFilters } = opts;
     const { selectDef, nonAggregateGroupBy, hasAggregates, hasSQLTransforms, orderChannels } = parts;
     const q = Query.from(table).select(selectDef);
     if (hasAggregates && nonAggregateGroupBy.length > 0) {
         q.groupby(nonAggregateGroupBy);
     }
-    const allFilters = [...filter];
+    const allFilters = [
+        ...filter,
+        ...nullDropPredicates(parts.nullDrops ?? [], selectDef)
+    ];
     if (allFilters.length > 0) {
         q.where(and(allFilters));
     }
     let result = q;
     if (hasSQLTransforms) {
-        result = transformCompiler.applyToQuery(q, { groupKeys: parts.groupKeys });
+        result = transformCompiler.applyToQuery(q, { groupKeys: parts.groupKeys, bins: parts.bins ?? null, padded: parts.padded ?? false }, { skipRowFilters });
     }
     if (window) {
         const outerSelect = {};
@@ -307,7 +327,10 @@ export function assembleQuery(opts) {
             .with({ [window.cteName]: result });
     }
     const alignment = hasSQLTransforms
-        ? transformCompiler.alignment(Object.keys(selectDef), { groupKeys: parts.groupKeys })
+        ? transformCompiler.alignment(Object.keys(selectDef), {
+            groupKeys: parts.groupKeys,
+            bins: parts.bins ?? null
+        })
         : null;
     const order = outerOrder(orderChannels, alignment);
     if (order) {

package/dist/components/marks/utils/MarkColor.svelte.d.ts

@@ -1,5 +1,5 @@
 import type { ColorScaleState } from '../../../scales/ColorScaleState.svelte';
-import type { ColorProp, ChartContext } from '../../../types';
+import type { ColorDomainValue, ColorProp, ChartContext } from '../../../types';
 import type { ScaleRegistry } from '../../../scales/ScaleRegistry.svelte';
 import type { MarkSetupState } from './mark-types';
 interface ColorConfig {
@@ -11,6 +11,8 @@ interface ColorConfig {
     explicitType?: string;
     constant?: number;
     exponent?: number;
+    range?: readonly string[];
+    pinnedDomain?: readonly ColorDomainValue[];
 }
 export declare class MarkColor {
     #private;

package/dist/components/marks/utils/MarkColor.svelte.js

@@ -30,6 +30,10 @@ export class MarkColor {
             const mode = this.#mode;
             const field = this.#field;
             const type = this.config.scaleType;
+            // Again when the chart's scales are replaced: the registry dropped
+            // this one with the old ChartScales (its GPU slots may already be
+            // someone else's), and holding it would write to a destroyed scale.
+            void this.#chartContext.scaleGeneration;
             // Only create scale when type is known (not null)
             if (mode === 'field' && field && this.#scaleRegistry && type !== null) {
                 untrack(() => {
@@ -42,7 +46,9 @@ export class MarkColor {
                         type: type,
                         scheme: this.config.scheme,
                         constant: this.config.constant,
-                        exponent: this.config.exponent
+                        exponent: this.config.exponent,
+                        range: this.config.range,
+                        pinnedDomain: this.config.pinnedDomain
                     }, this.#chartContext.chartId);
                 });
             }
@@ -66,6 +72,21 @@ export class MarkColor {
                 this.scaleState.setScheme(scheme);
             }
         });
+        // 2a. Lifecycle: Update explicit colours (Fast Path - no scale recreation)
+        // Like the scheme, a mark without them leaves a shared scale's alone; one
+        // that drops them (an edited prop) clears what it set.
+        let hadRange = false;
+        $effect(() => {
+            const range = this.config.range;
+            const pinned = this.config.pinnedDomain;
+            const scale = this.scaleState;
+            if (!scale?.isOrdinal)
+                return;
+            const has = !!(range?.length || pinned?.length);
+            if (has || hadRange)
+                scale.setRange(range ?? null, pinned ?? null);
+            hadRange = has;
+        });
         // 2b. Lifecycle: Update Transform (Fast Path - no scale recreation)
         $effect(() => {
             const type = this.config.explicitType;
@@ -148,6 +169,8 @@ export class MarkColor {
         let explicitType;
         let constant;
         let exponent;
+        let range;
+        let pinnedDomain;
         // Handle object wrapper format { field: "species", scheme: "dark2", type: "symlog" }
         if (typeof c === 'object' && 'field' in c && !isNode(c)) {
             field = c.field;
@@ -155,10 +178,15 @@ export class MarkColor {
             explicitType = c.type;
             constant = c.constant;
             exponent = c.exponent;
+            range = c.range;
+            pinnedDomain = c.domain;
         }
         // 1. Determine Type from field semantics + schema (may return null if waiting for schema)
         // If an explicit type is given (log/symlog/sqrt/pow), use it directly.
-        const scaleType = explicitType || this.#resolveScaleType(field);
+        // Explicit colours or pinned values mean categories, whatever the column
+        // type: a 0/1 integer column would otherwise read as continuous.
+        const scaleType = explicitType ||
+            (range?.length || pinnedDomain?.length ? 'ordinal' : this.#resolveScaleType(field));
         // 2. Pass explicit scheme if provided, otherwise undefined (registry will apply default)
         return {
             mode: 'field',
@@ -167,7 +195,9 @@ export class MarkColor {
             scheme: explicitScheme, // undefined if not specified
             explicitType,
             constant,
-            exponent
+            exponent,
+            range,
+            pinnedDomain
         };
     });
     // Separate derived for mode (independent of scheme to avoid unnecessary tracking)

package/dist/components/marks/utils/MarkSeries.svelte.d.ts

@@ -12,8 +12,21 @@ import type { MarkSetupState } from './mark-types';
 export declare class MarkSeries {
     #private;
     scaleState: ColorScaleState | null;
-    constructor(getSeries: () => string | object | null, channelName: string, getSetup: () => MarkSetupState, scaleRegistry: ScaleRegistry, chartContext: ChartContext);
+    constructor(getSeries: () => string | object | null, channelName: string, getSetup: () => MarkSetupState, scaleRegistry: ScaleRegistry, chartContext: ChartContext, getColorScale?: () => ColorScaleState | null);
     selectField: string | object | null;
     data: Float32Array | null;
+    /**
+     * Whether the renderer reads selection activity through the series scale:
+     * 1 for a `z` of its own, a field that carries ids, so a selection on it
+     * dims the other series. 0 without `z` (the series is the colour, read
+     * already), for a `z` on the colour field (the registry hands both
+     * channels one scale, and reading it twice is a load for nothing), and
+     * before the scale has an identity, while its values are not ids yet.
+     * Routing (MarkLifecycleV2's reads) lists the same field in the same
+     * cases, so the mark dims rather than filters exactly when this is 1.
+     */
+    activityMode: number;
+    /** The series scale's colour config index, read when `activityMode` is 1. */
+    activityScaleIndex: number;
     ready: boolean;
 }

package/dist/components/marks/utils/MarkSeries.svelte.js

@@ -15,17 +15,23 @@ export class MarkSeries {
     #setupState;
     #scaleRegistry;
     #chartContext;
+    #colorScale;
     scaleState = $state(null);
-    constructor(getSeries, channelName, getSetup, scaleRegistry, chartContext) {
+    constructor(getSeries, channelName, getSetup, scaleRegistry, chartContext, getColorScale = () => null) {
         this.#seriesProp = getSeries;
         this.#channelName = channelName;
         this.#setupState = getSetup;
         this.#scaleRegistry = scaleRegistry;
         this.#chartContext = chartContext;
+        this.#colorScale = getColorScale;
         // Lifecycle: Create/Destroy Scale
         // Series grouping is always ordinal
         $effect(() => {
             const field = this.#field;
+            // Again when the chart's scales are replaced: the registry dropped
+            // this one with the old ChartScales (its GPU slots may already be
+            // someone else's), and holding it would write to a destroyed scale.
+            void this.#chartContext.scaleGeneration;
             if (field && this.#scaleRegistry) {
                 untrack(() => {
                     // Use raw field name - registry deduplicates automatically
@@ -89,6 +95,24 @@ export class MarkSeries {
         }
         return this.scaleState.processDataForGPU(raw);
     });
+    /**
+     * Whether the renderer reads selection activity through the series scale:
+     * 1 for a `z` of its own, a field that carries ids, so a selection on it
+     * dims the other series. 0 without `z` (the series is the colour, read
+     * already), for a `z` on the colour field (the registry hands both
+     * channels one scale, and reading it twice is a load for nothing), and
+     * before the scale has an identity, while its values are not ids yet.
+     * Routing (MarkLifecycleV2's reads) lists the same field in the same
+     * cases, so the mark dims rather than filters exactly when this is 1.
+     */
+    activityMode = $derived.by(() => {
+        const scale = this.scaleState;
+        if (this.#channelName !== 'z' || !scale?.hasIdentity)
+            return 0;
+        return scale === this.#colorScale() ? 0 : 1;
+    });
+    /** The series scale's colour config index, read when `activityMode` is 1. */
+    activityScaleIndex = $derived(this.scaleState?.gpuIndex ?? 0);
     // Ready when: no field (single series) or scale is ready
     ready = $derived(!this.#field || (this.scaleState?.ready ?? false));
 }

package/dist/components/marks/utils/MarkSize.svelte.js

@@ -18,6 +18,10 @@ export class MarkSize {
         $effect(() => {
             const mode = this.#mode;
             const field = this.#field;
+            // Again when the chart's scales are replaced: the registry dropped
+            // this one with the old ChartScales (its GPU slots may already be
+            // someone else's), and holding it would write to a destroyed scale.
+            void this.#chartContext.scaleGeneration;
             if (mode === 'field' && field && this.#scaleRegistry) {
                 untrack(() => {
                     this.scaleState = this.#scaleRegistry.getOrCreateScale(field, 'size', { range: this.#rangeProp() }, this.#chartContext.chartId);

package/dist/components/marks/utils/reactive-config.d.ts

@@ -12,6 +12,6 @@ import type { MarkEntry } from '../../../config/ChartConfig.svelte';
  * @param entry - The mark entry (reactive props from ChartConfig)
  * @param opts.resolveFitDomain - Getter for resolved fitDomain (deferred read)
  */
-export declare function buildReactiveConfig(entry: Partial<Pick<MarkEntry, 'sort' | 'limit' | 'domain' | 'tooltip' | 'tip' | 'fitDomain' | 'selectionResponse'>>, opts?: {
+export declare function buildReactiveConfig(entry: Partial<Pick<MarkEntry, 'sort' | 'limit' | 'domain' | 'tooltip' | 'tip' | 'fitDomain' | 'selectionResponse' | 'nulls' | 'contributeDomain' | 'holdsEntrance'>>, opts?: {
     resolveFitDomain?: () => 'x' | 'y' | boolean | undefined;
 }): ReactiveConfig;

package/dist/components/marks/utils/reactive-config.js

@@ -19,6 +19,9 @@ export function buildReactiveConfig(entry, opts) {
         get limit() {
             return entry.limit;
         },
+        get holdsEntrance() {
+            return entry.holdsEntrance;
+        },
         get domain() {
             return entry.domain ?? null;
         },
@@ -33,6 +36,12 @@ export function buildReactiveConfig(entry, opts) {
         },
         get selectionResponse() {
             return entry.selectionResponse;
+        },
+        get nulls() {
+            return entry.nulls;
+        },
+        get contributeDomain() {
+            return entry.contributeDomain;
         }
     };
 }

package/dist/components/marks/utils/tooltip-helpers.d.ts

@@ -1,3 +1,4 @@
+import type { OtherRowStats } from '../lifecycle/other-rows.svelte';
 import type { ChartContext } from '../../../types';
 import type { ColorScaleState } from '../../../scales/ColorScaleState.svelte';
 import type { DimValue } from '../../../query-engine/categorical-identity';
@@ -34,6 +35,7 @@ interface TooltipConfigParams {
     constantRadius?: number;
     sizeScaleState?: SizeScaleState | null;
     displayFields?: string[] | null;
+    otherStats?: TooltipConfig['otherStats'];
 }
 interface TooltipConfig {
     tempTable: string;
@@ -61,7 +63,8 @@ interface TooltipConfig {
     constantRadius?: number;
     sizeScaleState?: SizeScaleState | null;
     displayFields?: string[] | null;
+    otherStats?: (point: Record<string, unknown>) => OtherRowStats | null;
     enabled: boolean;
 }
-export declare function buildTooltipConfig({ tempTable, markType, chartContext, channelFields, columns, bandAxes, colorColumn, markColor, seriesColumn, markSeries, proximityAxis, constantRadius, sizeScaleState, displayFields }: TooltipConfigParams): TooltipConfig;
+export declare function buildTooltipConfig({ tempTable, markType, chartContext, channelFields, columns, bandAxes, colorColumn, markColor, seriesColumn, markSeries, proximityAxis, constantRadius, sizeScaleState, displayFields, otherStats }: TooltipConfigParams): TooltipConfig;
 export {};

package/dist/components/marks/utils/tooltip-helpers.js

@@ -1,4 +1,4 @@
-export function buildTooltipConfig({ tempTable, markType, chartContext, channelFields, columns, bandAxes, colorColumn, markColor, seriesColumn, markSeries, proximityAxis, constantRadius, sizeScaleState, displayFields }) {
+export function buildTooltipConfig({ tempTable, markType, chartContext, channelFields, columns, bandAxes, colorColumn, markColor, seriesColumn, markSeries, proximityAxis, constantRadius, sizeScaleState, displayFields, otherStats }) {
     const colorScaleState = markColor.scaleState;
     const constantColor = markColor.constantCssColor;
     return {
@@ -33,6 +33,7 @@ export function buildTooltipConfig({ tempTable, markType, chartContext, channelF
         ...(constantRadius != null && { constantRadius }),
         ...(sizeScaleState && { sizeScaleState }),
         ...(displayFields && { displayFields }),
+        ...(otherStats && { otherStats }),
         enabled: true
     };
 }