@fjader/svelte 0.2.3 → 0.2.4

package/dist/query-engine/preagg/plan.js

@@ -12,7 +12,7 @@
  * License; see NOTICE.
  */
 import { isAggregateExpression, isNode, collectColumns, column, and, isBetween, literal, Query, sql as sqlTag } from '@uwdata/mosaic-sql';
-import { togglePredicate } from '../toggle-predicate';
+import { BITMAP_MIN_IDS, idBitmapPredicate, togglePredicate } from '../toggle-predicate';
 import { rewriteForPreagg, buildBinExpr, binsFineEnough, BIN_WINDOW_MARGIN } from '../sufficient-statistics';
 import { assembleQuery, castNumeric, castReal } from '../../components/marks/lifecycle/query-builder';
 /**
@@ -37,6 +37,11 @@ export function planPreagg(descriptor, dims, identity) {
     const { parts, table, baseTable, schema } = descriptor;
     if (!parts.hasAggregates && !parts.hasWindowAggregates)
         return null;
+    // A having() on a preagg table would count its groups, not the source rows, and
+    // return the wrong rows without an error. The built-in transforms add none; see
+    // TransformCompiler.hasHaving for why, and for what supporting it would take.
+    if (descriptor.transformCompiler.hasHaving())
+        return null;
     // Analyze selectDef for preagg compatibility
     const analysis = rewriteForPreagg(parts.selectDef, parts.passthroughChannels);
     if (!analysis)
@@ -115,6 +120,7 @@ export function planPreagg(descriptor, dims, identity) {
             groupby: [...preaggGroupBy, ...activeGroupBy],
             // Sorted by bin columns for fast range scans
             orderby: binOrder,
+            where: descriptor.transformCompiler.rowFilters(),
             joins
         },
         outputSelect,
@@ -280,8 +286,9 @@ export function preaggQuerySQL(route, descriptor, selection, preagg, params, ide
         }
         if (valueExprs && valueMeta) {
             // A toggle's clause holds tuples in its field order. Id columns
-            // filter by id; a value with no id (NULL, or not in the dim) cannot
-            // be expressed, so this query goes to the base table instead.
+            // filter by id (the NULL category has one); a value with no id (not in
+            // the dim yet) cannot be expressed, so this query goes to the base
+            // table instead.
             const tuples = [];
             for (const tuple of clause.value) {
                 const mapped = [];
@@ -294,7 +301,17 @@ export function preaggQuerySQL(route, descriptor, selection, preagg, params, ide
                 }
                 tuples.push(mapped);
             }
-            filters.push(togglePredicate(valueExprs, tuples));
+            // One field by id, and many of them (a click on a large Other): a
+            // constant-size bitmap rather than a long IN list, which DuckDB spends
+            // most of its time parsing. Measured on a preagg table: 1 ms against
+            // 20 ms for IN of 9 000 ids.
+            const only = valueMeta.length === 1 ? valueMeta[0] : null;
+            if (only?.byId && tuples.length > BITMAP_MIN_IDS) {
+                filters.push(idBitmapPredicate(valueExprs[0], tuples.map((t) => t[0]), identity.identity(only.field).values.length));
+            }
+            else {
+                filters.push(togglePredicate(valueExprs, tuples));
+            }
         }
     }
     // --- Build selectDef: CAST recombined aggregates; dimensions are already
@@ -324,13 +341,19 @@ export function preaggQuerySQL(route, descriptor, selection, preagg, params, ide
         hasSQLTransforms: parts.hasSQLTransforms,
         orderChannels: parts.orderChannels,
         aliasMap: parts.aliasMap,
-        passthroughChannels: parts.passthroughChannels
+        passthroughChannels: parts.passthroughChannels,
+        // nulls="drop", read through this select: each dropped channel is a group
+        // key, so the table keeps NULL as its own group, and dropping that group
+        // here removes exactly what the base scan would have left out.
+        nullDrops: parts.nullDrops
     };
     return assembleQuery({
         table: preagg.table,
         parts: preaggParts,
         filter: filters,
         transformCompiler,
+        // The table was built with them.
+        skipRowFilters: true,
         limit: params.limit,
         window: windowChannels ? { channels: windowChannels, cteName: '__preagg_cte' } : null
     }).toString();
@@ -338,8 +361,9 @@ export function preaggQuerySQL(route, descriptor, selection, preagg, params, ide
 /** A preagg table's SELECT. Build and validity check share it, so equal SQL means an equal table. */
 export function preaggSelectSQL(creation, filters) {
     const query = Query.from(creation.table).select(creation.select).groupby(creation.groupby);
-    if (filters.length > 0)
-        query.where(and(filters));
+    const where = [...creation.where, ...filters];
+    if (where.length > 0)
+        query.where(and(where));
     if (creation.joins.length === 0)
         return query.orderby(creation.orderby).toString();
     // Map fields grouped by value to their ids on the grouped result: a join

package/dist/query-engine/toggle-predicate.d.ts

@@ -8,3 +8,24 @@ import { type ExprNode } from '@uwdata/mosaic-sql';
  * so a predicate is never rewritten after the fact.
  */
 export declare function togglePredicate(exprs: ExprNode[], tuples: unknown[][]): ExprNode;
+/**
+ * Above this many ids, a selection over an id column is a bitmap, not an `IN`
+ * list (see idBitmapPredicate). The crossover measured in DuckDB-WASM 1.30 lies
+ * between 500 values (`IN`, 29 ms on 2 M rows) and the bitmap (26 ms).
+ */
+export declare const BITMAP_MIN_IDS = 256;
+/**
+ * `expr`'s id is one of `ids`, as one constant-size literal:
+ * `get_bit('<bits>'::BIT, <index>) = 1`.
+ *
+ * Never `NOT IN`, whatever the selection's size: DuckDB evaluates it as a chain
+ * of `<>`, 2.8 s on 2 M rows for 1 000 ids. And never a long `IN`, which it
+ * spends most of its time parsing.
+ *
+ * Bit `id + 1` is set for each selected id; bit 0 is id -1 ("not in the dim
+ * yet") and is never set; the last bit, `size + 1`, is a sentinel kept 0. The
+ * index is clamped onto [0, sentinel], so an id appended to the dim after the
+ * selection was made reads the sentinel (it was not selected: a snapshot), and
+ * get_bit never sees an index out of range, which is an error rather than a 0.
+ */
+export declare function idBitmapPredicate(expr: ExprNode, ids: readonly number[], size: number): ExprNode;

package/dist/query-engine/toggle-predicate.js

@@ -1,4 +1,4 @@
-import { and as sqlAnd, isIn, isNotDistinct, literal, or } from '@uwdata/mosaic-sql';
+import { and as sqlAnd, isIn, isNotDistinct, literal, or, sql as sqlTag } from '@uwdata/mosaic-sql';
 /**
  * A toggle's clause over its selected tuples: `IN` for one field, an `OR` of
  * `IS NOT DISTINCT FROM` tuples for several, so a NULL member matches NULL.
@@ -25,3 +25,31 @@ export function togglePredicate(exprs, tuples) {
     const clauses = tuples.map((t) => sqlAnd(t.map((v, i) => isNotDistinct(exprs[i], literal(v)))));
     return clauses.length === 1 ? clauses[0] : or(clauses);
 }
+/**
+ * Above this many ids, a selection over an id column is a bitmap, not an `IN`
+ * list (see idBitmapPredicate). The crossover measured in DuckDB-WASM 1.30 lies
+ * between 500 values (`IN`, 29 ms on 2 M rows) and the bitmap (26 ms).
+ */
+export const BITMAP_MIN_IDS = 256;
+/**
+ * `expr`'s id is one of `ids`, as one constant-size literal:
+ * `get_bit('<bits>'::BIT, <index>) = 1`.
+ *
+ * Never `NOT IN`, whatever the selection's size: DuckDB evaluates it as a chain
+ * of `<>`, 2.8 s on 2 M rows for 1 000 ids. And never a long `IN`, which it
+ * spends most of its time parsing.
+ *
+ * Bit `id + 1` is set for each selected id; bit 0 is id -1 ("not in the dim
+ * yet") and is never set; the last bit, `size + 1`, is a sentinel kept 0. The
+ * index is clamped onto [0, sentinel], so an id appended to the dim after the
+ * selection was made reads the sentinel (it was not selected: a snapshot), and
+ * get_bit never sees an index out of range, which is an error rather than a 0.
+ */
+export function idBitmapPredicate(expr, ids, size) {
+    const bits = new Array(size + 2).fill('0');
+    for (const id of ids)
+        if (id >= 0 && id < size)
+            bits[id + 1] = '1';
+    const sentinel = size + 1;
+    return sqlTag `get_bit(${literal(bits.join(''))}::BIT, CAST(greatest(least(${expr} + 1, ${sentinel}), 0) AS INTEGER)) = 1`;
+}

package/dist/scales/ActivityTable.d.ts

@@ -85,8 +85,12 @@ export declare class ActivityTable {
      * fade down from 1.
      *
      * `resize(0)` drops every id, for ids that stopped meaning their category.
+     *
+     * `trailing`: the last slot is not an id but a slot of its own that stays
+     * last (FieldActivity's free slot). Its fade moves to the new end, and the
+     * slot it leaves is a new id like any other, rather than inheriting it.
      */
-    resize(count: number, active?: readonly number[] | null): void;
+    resize(count: number, active?: readonly number[] | null, trailing?: boolean): void;
     /**
      * Select exactly these ids; every other id fades out. Ids outside the table
      * are ignored. Does nothing when the selection is the one already headed to.

package/dist/scales/ActivityTable.js

@@ -117,11 +117,18 @@ export class ActivityTable {
      * fade down from 1.
      *
      * `resize(0)` drops every id, for ids that stopped meaning their category.
+     *
+     * `trailing`: the last slot is not an id but a slot of its own that stays
+     * last (FieldActivity's free slot). Its fade moves to the new end, and the
+     * slot it leaves is a new id like any other, rather than inheriting it.
      */
-    resize(count, active) {
+    resize(count, active, trailing = false) {
         if (count === this.#to.length)
             return;
-        const keep = Math.min(this.#to.length, count);
+        const oldLength = this.#to.length;
+        const tail = trailing && oldLength > 0 && count > 0;
+        const keep = tail ? Math.min(oldLength - 1, count - 1) : Math.min(oldLength, count);
+        const ids = tail ? count - 1 : count;
         const selecting = active === undefined ? this.#selecting : active !== null;
         const fill = selecting ? 0 : 1;
         const grown = (old) => {
@@ -130,9 +137,11 @@ export class ActivityTable {
             next.set(old.subarray(0, keep), 0);
             if (active) {
                 for (const id of active)
-                    if (id >= keep && id < count)
+                    if (id >= keep && id < ids)
                         next[id] = 1;
             }
+            if (tail)
+                next[count - 1] = old[oldLength - 1];
             return next;
         };
         this.#from = grown(this.#from);

package/dist/scales/BandScaleState.svelte.d.ts

@@ -211,6 +211,8 @@ export declare class BandScaleState {
      * undisplayed Other is ignored.
      */
     setOtherId(id: number | null): void;
+    /** This axis's Other bucket id, while a mark on it has one; null otherwise. */
+    get otherId(): number | null;
     /**
      * This axis's Other bucket, shared by every mark on it that has one.
      *
@@ -331,7 +333,7 @@ export declare class BandScaleState {
     /**
      * Get D3 band scale configured for rendering
      */
-    getBaseScale(axis: string, innerWidthOrHeight: number): ScaleBand<DimValue>;
+    getBaseScale(_axis: string, innerWidthOrHeight: number): ScaleBand<DimValue>;
     /**
      * Update scale domain (for D3 scale)
      */
@@ -403,19 +405,22 @@ export declare class BandScaleState {
     /**
      * Where a tick's label sits now, in pixels along the axis: the centre of its
      * category's current slot, so it travels with the bar. Slot 0 is at the start
-     * of the range on x and at the bottom on y, as in the shader and d3's
-     * reversed range. Per frame, O(1).
+     * of the range on both axes: the left on x, the top on y, as in the shader
+     * and d3's range. Per frame, O(1).
      */
-    tickPosition(key: number, rangeSize: number, axis: 'x' | 'y'): number;
+    tickPosition(key: number, rangeSize: number): number;
     /**
      * The same, for a caller that already has the slot.
      *
      * A consumer that has to test the slot first — an SVG label, which must not
      * draw a category the axis is not displaying — would otherwise ask for it
-     * twice per item per frame. The axis flip lives here rather than being
-     * re-derived by such a caller.
+     * twice per item per frame.
+     *
+     * The same on both axes. A y band axis reads top-down, like a list: slot 0
+     * at the top, so a ranking and an explicit domain need no reversing, and
+     * the exit one past the last slot is the end of the list on either axis.
      */
-    slotPosition(slot: number, rangeSize: number, axis: 'x' | 'y'): number;
+    slotPosition(slot: number, rangeSize: number): number;
     /**
      * Centre of a (possibly fractional) slot, measured from the start of the
      * range — the same layout the shader's computeBandLayout uses, so a label
@@ -452,7 +457,7 @@ export declare class BandScaleState {
      * Returns the 0-based index of the band under the cursor, or null if
      * no bands exist.
      */
-    invertScreenToData(screenVal: number, rangeSize: number, isYAxis?: boolean): number | null;
+    invertScreenToData(screenVal: number, rangeSize: number, _isYAxis?: boolean): number | null;
     /**
      * Get all mark extents (for debugging). Ids when the scale has identity.
      */

package/dist/scales/BandScaleState.svelte.js

@@ -327,6 +327,10 @@ export class BandScaleState {
     setOtherId(id) {
         this.#slots.otherId = id;
     }
+    /** This axis's Other bucket id, while a mark on it has one; null otherwise. */
+    get otherId() {
+        return this.#slots.otherId;
+    }
     /**
      * This axis's Other bucket, shared by every mark on it that has one.
      *
@@ -621,8 +625,10 @@ export class BandScaleState {
     /**
      * Get D3 band scale configured for rendering
      */
-    getBaseScale(axis, innerWidthOrHeight) {
-        this.#sharedScale.range(axis === 'x' ? [0, innerWidthOrHeight] : [innerWidthOrHeight, 0]);
+    getBaseScale(_axis, innerWidthOrHeight) {
+        // The same on both axes, not reversed on y: slot 0 is at the top, as in
+        // the shader (slotPosition).
+        this.#sharedScale.range([0, innerWidthOrHeight]);
         if (this.#paddingInner !== null && this.#paddingOuter !== null) {
             this.#sharedScale.paddingInner(this.#paddingInner).paddingOuter(this.#paddingOuter);
         }
@@ -759,23 +765,25 @@ export class BandScaleState {
     /**
      * Where a tick's label sits now, in pixels along the axis: the centre of its
      * category's current slot, so it travels with the bar. Slot 0 is at the start
-     * of the range on x and at the bottom on y, as in the shader and d3's
-     * reversed range. Per frame, O(1).
+     * of the range on both axes: the left on x, the top on y, as in the shader
+     * and d3's range. Per frame, O(1).
      */
-    tickPosition(key, rangeSize, axis) {
-        return this.slotPosition(this.tickSlot(key), rangeSize, axis);
+    tickPosition(key, rangeSize) {
+        return this.slotPosition(this.tickSlot(key), rangeSize);
     }
     /**
      * The same, for a caller that already has the slot.
      *
      * A consumer that has to test the slot first — an SVG label, which must not
      * draw a category the axis is not displaying — would otherwise ask for it
-     * twice per item per frame. The axis flip lives here rather than being
-     * re-derived by such a caller.
+     * twice per item per frame.
+     *
+     * The same on both axes. A y band axis reads top-down, like a list: slot 0
+     * at the top, so a ranking and an explicit domain need no reversing, and
+     * the exit one past the last slot is the end of the list on either axis.
      */
-    slotPosition(slot, rangeSize, axis) {
-        const centre = this.slotCenter(slot, rangeSize);
-        return axis === 'y' ? rangeSize - centre : centre;
+    slotPosition(slot, rangeSize) {
+        return this.slotCenter(slot, rangeSize);
     }
     /**
      * Centre of a (possibly fractional) slot, measured from the start of the
@@ -854,7 +862,9 @@ export class BandScaleState {
      * Returns the 0-based index of the band under the cursor, or null if
      * no bands exist.
      */
-    invertScreenToData(screenVal, rangeSize, isYAxis = false) {
+    invertScreenToData(screenVal, rangeSize, 
+    // Band slots run from the start of the range on both axes (slotPosition).
+    _isYAxis = false) {
         const config = this.getConfig();
         const n = config.categoryCount;
         if (n === 0)
@@ -863,10 +873,7 @@ export class BandScaleState {
         if (stepSize === 0)
             return null;
         const offset = config.paddingOuter * stepSize;
-        // GPU band scale renders Y categories bottom-to-top (matching D3),
-        // so flip screen coordinate for Y axis inversion.
-        const pos = isYAxis ? rangeSize - screenVal : screenVal;
-        const bandIndex = Math.floor((pos - offset) / stepSize);
+        const bandIndex = Math.floor((screenVal - offset) / stepSize);
         // Clamped to a WHOLE slot. Mid-transition the count is fractional, so a
         // bare `n - 1` hands back a fraction for a pointer past the last band —
         // and a fractional slot indexes nothing, so idAtSlot and the domain both

package/dist/spec/types.d.ts

@@ -135,6 +135,8 @@ interface BaseMarkSpec {
     selection?: string;
     /** How the mark responds to selections in its group; see BaseMarkProps. Default 'auto'. */
     selectionResponse?: 'auto' | 'filter';
+    /** What the mark does with NULL in its categorical channels; see BaseMarkProps. Default 'keep'. */
+    nulls?: 'keep' | 'drop';
     scheme?: ColorScheme;
     limit?: number;
     transforms?: TransformSpec[];

package/dist/theme.css

@@ -7,6 +7,11 @@
  * Or copy and customize the variables below in your own CSS.
  * All variables are optional — Fjader components have sensible
  * inline fallbacks and work without any CSS imports.
+ *
+ * The tooltip is not set here: it follows the color-scheme it inherits (the
+ * one below, or the app's own) by itself, in contrast or follow mode
+ * (data-fjader-tooltip on any ancestor, or ChartContainer's tooltipScheme).
+ * Set --fjader-tooltip-bg and --fjader-tooltip-text to override both modes.
  */
 
 :where(:root) {
@@ -16,8 +21,6 @@
 	--fjader-bg: #ffffff;
 	--fjader-primary: #3b82f6;
 	--fjader-accent: #93c5fd;
-	--fjader-tooltip-bg: rgba(0, 0, 0, 0.88);
-	--fjader-tooltip-text: #ffffff;
 	--fjader-palette-bg: rgba(0, 0, 0, 0.92);
 	--fjader-palette-text: #ffffff;
 	--fjader-palette-text-secondary: rgba(255, 255, 255, 0.5);
@@ -34,8 +37,6 @@
 		--fjader-bg: #111827;
 		--fjader-primary: #60a5fa;
 		--fjader-accent: #3b82f6;
-		--fjader-tooltip-bg: rgba(255, 255, 255, 0.92);
-		--fjader-tooltip-text: #111827;
 		--fjader-palette-bg: rgba(255, 255, 255, 0.95);
 		--fjader-palette-text: #111827;
 		--fjader-palette-text-secondary: rgba(17, 24, 39, 0.5);

package/dist/transforms/TransformCompiler.d.ts

@@ -1,4 +1,4 @@
-import type { SelectQuery } from '@uwdata/mosaic-sql';
+import type { ExprNode, SelectQuery } from '@uwdata/mosaic-sql';
 import type { Transform, SqlTransform, JsTransform, MarkConfig, ScaleMap } from '../types';
 import type { DataAccessor } from '../data/DataAccessor';
 export declare class TransformCompiler {
@@ -19,7 +19,40 @@ export declare class TransformCompiler {
      * than of the mark — its GROUP BY keys, say — merged over the mark config for
      * this call only, so the shared config object is never written per query.
      */
-    applyToQuery(query: SelectQuery, facts?: Partial<MarkConfig>): SelectQuery;
+    applyToQuery(query: SelectQuery, facts?: Partial<MarkConfig>, 
+    /** The row filters are already in the table the query reads (a preagg table). */
+    options?: {
+        skipRowFilters?: boolean;
+    }): SelectQuery;
+    /**
+     * Whether a SQL transform filters on the groups' aggregates (`having`). Its
+     * condition names aggregates over the source rows, which a pre-aggregated table
+     * would recompute over its own groups: `count(*)` counts the table's groups, not
+     * the rows, so it gives a different answer with no error.
+     *
+     * Only the user-facing `having()` does this. The built-ins (topN, rank, stack,
+     * normalize, dense) add no HAVING: each wraps the grouped query in a subquery
+     * (`Query.from({ __topn_base: query })`) and adds window functions or joins, and
+     * those work the same on a preagg table's aggregated result, which is why a topN
+     * mark is served from preagg. The only CTE is assembleQuery's window wrapper for
+     * window aggregates, applied after the transforms. A test in transforms.test.ts
+     * fails if a built-in starts to emit a HAVING; this then has to know it.
+     *
+     * Supporting `having()` on a preagg table would mean rewriting its condition the
+     * way a select channel is rewritten (sufficient-statistics: collectAggregates,
+     * sufficientStats, rewrite; an aggregate not in the select adds a partial
+     * column) and applying it to the inner grouped query BEFORE the transforms wrap
+     * it, so it ends up inside their subquery as it does on the base table.
+     */
+    hasHaving(): boolean;
+    /**
+     * The row predicates of the SQL transforms (`filter`), for a pre-aggregated
+     * table to be built with: its read cannot apply them (see SqlTransform.where).
+     * A row filter applies before grouping, so building the table with it gives the
+     * same rows the base query sees; only `filter()` is one (see hasHaving for the
+     * transforms that are not).
+     */
+    rowFilters(): ExprNode[];
     /**
      * Which channels a query with these aliases comes back aligned on, leading
      * term first, or null. Asked with the same facts as `applyToQuery`, so the
@@ -60,5 +93,7 @@ export declare class TransformCompiler {
      * before the transform can write it.
      */
     hasSyntheticOtherBucket(): boolean;
+    /** The `by` a topN Other bucket ranks by when stated explicitly, else null (its default). */
+    otherBy(): string | null;
     getCategoryTransformKey(): string | null;
 }

package/dist/transforms/TransformCompiler.js

@@ -35,10 +35,14 @@ export class TransformCompiler {
      * than of the mark — its GROUP BY keys, say — merged over the mark config for
      * this call only, so the shared config object is never written per query.
      */
-    applyToQuery(query, facts) {
+    applyToQuery(query, facts, 
+    /** The row filters are already in the table the query reads (a preagg table). */
+    options) {
         let result = query;
         const config = this.#configFor(facts);
         for (const transform of this.sqlTransforms) {
+            if (options?.skipRowFilters && transform.where !== undefined)
+                continue;
             try {
                 result = transform.apply(result, config);
             }
@@ -48,6 +52,39 @@ export class TransformCompiler {
         }
         return result;
     }
+    /**
+     * Whether a SQL transform filters on the groups' aggregates (`having`). Its
+     * condition names aggregates over the source rows, which a pre-aggregated table
+     * would recompute over its own groups: `count(*)` counts the table's groups, not
+     * the rows, so it gives a different answer with no error.
+     *
+     * Only the user-facing `having()` does this. The built-ins (topN, rank, stack,
+     * normalize, dense) add no HAVING: each wraps the grouped query in a subquery
+     * (`Query.from({ __topn_base: query })`) and adds window functions or joins, and
+     * those work the same on a preagg table's aggregated result, which is why a topN
+     * mark is served from preagg. The only CTE is assembleQuery's window wrapper for
+     * window aggregates, applied after the transforms. A test in transforms.test.ts
+     * fails if a built-in starts to emit a HAVING; this then has to know it.
+     *
+     * Supporting `having()` on a preagg table would mean rewriting its condition the
+     * way a select channel is rewritten (sufficient-statistics: collectAggregates,
+     * sufficientStats, rewrite; an aggregate not in the select adds a partial
+     * column) and applying it to the inner grouped query BEFORE the transforms wrap
+     * it, so it ends up inside their subquery as it does on the base table.
+     */
+    hasHaving() {
+        return this.sqlTransforms.some((t) => t.type === 'having');
+    }
+    /**
+     * The row predicates of the SQL transforms (`filter`), for a pre-aggregated
+     * table to be built with: its read cannot apply them (see SqlTransform.where).
+     * A row filter applies before grouping, so building the table with it gives the
+     * same rows the base query sees; only `filter()` is one (see hasHaving for the
+     * transforms that are not).
+     */
+    rowFilters() {
+        return this.sqlTransforms.flatMap((t) => (t.where === undefined ? [] : [t.where]));
+    }
     /**
      * Which channels a query with these aliases comes back aligned on, leading
      * term first, or null. Asked with the same facts as `applyToQuery`, so the
@@ -147,6 +184,12 @@ export class TransformCompiler {
     hasSyntheticOtherBucket() {
         return this.transforms.some((t) => t.type === 'topN' && t.spec?.includeOthers === true);
     }
+    /** The `by` a topN Other bucket ranks by when stated explicitly, else null (its default). */
+    otherBy() {
+        const t = this.transforms.find((t) => t.type === 'topN' && t.spec?.includeOthers === true);
+        const by = t?.spec?.by;
+        return typeof by === 'string' ? by : null;
+    }
     getCategoryTransformKey() {
         const parts = [];
         for (const t of this.transforms) {

package/dist/transforms/index.js

@@ -14,6 +14,7 @@ export function filter(condition) {
         stage: 'sql',
         type: 'filter',
         spec: { transform: 'filter', condition: condition.toString() },
+        where: condition,
         apply(query) {
             return query.where(condition);
         },
@@ -303,9 +304,11 @@ export const DENSE_ROW_LIMIT = 10_000;
  */
 function padIds(id, dim) {
     const present = id?.present;
+    // A mark that drops NULL pads no row for it: its rows were filtered out.
+    const notNull = id?.dropNullId != null ? ` WHERE "id" <> ${id.dropNullId}` : '';
     if (!present)
-        return `(SELECT "id" FROM ${quoteTable(dim)})`;
-    return (`(SELECT "id" FROM ${quoteTable(present)} UNION ALL ` +
+        return `(SELECT "id" FROM ${quoteTable(dim)}${notNull})`;
+    return (`(SELECT "id" FROM ${quoteTable(present)}${notNull} UNION ALL ` +
         `SELECT "id" FROM ${quoteTable(dim)} WHERE "label" IS NOT NULL)`);
 }
 /**
@@ -806,7 +809,9 @@ export function stackX(options = {}) {
     return stackSQL('x', options);
 }
 /** Resolve band (group) / value column aliases for a stack direction, validated against the select list. */
-function resolveStackColumns(aliases, config, direction) {
+function resolveStackColumns(aliases, config, direction, 
+/** Called when there is no series column; the caller decides whether that is worth saying. */
+onNoSeries) {
     const bandAxis = direction === 'y' ? 'x' : 'y';
     const band = config?.[bandAxis];
     const value = config?.[direction];
@@ -820,20 +825,31 @@ function resolveStackColumns(aliases, config, direction) {
     }
     const fill = config?.fill;
     const series = typeof fill === 'string' && aliases.includes(fill) ? fill : null;
-    // With no series column there is one row per band, so the cumulative sum equals
-    // that row's own value and the stack is arithmetically a no-op — the output is
-    // identical to an unstacked mark. That is the correct result, but it is
-    // indistinguishable from a broken stack to anyone looking at the chart, so say
-    // what is missing rather than silently drawing an ordinary bar.
-    if (!series) {
-        console.warn(`stack${direction === 'y' ? 'Y' : 'X'}: no series column, so stacking has no effect ` +
-            `(one row per band). Stacking groups rows within a band by the ordinal ` +
-            `fill channel — add fill="<field>" to the mark. Select list: [${aliases.join(', ')}].`);
-    }
+    if (!series)
+        onNoSeries(aliases);
     return { band, value, series };
 }
-function stackSQL(direction, options) {
+/**
+ * `implicit`: added by the mark (withImplicitStack), not written by the user.
+ *
+ * With no series column there is one row per band, so the cumulative sum equals
+ * that row's own value and the stack is arithmetically a no-op. For a stack the
+ * user wrote, that is indistinguishable from a broken one on screen, so it says
+ * what is missing, once per transform rather than on every query assembled. An
+ * implicit stack says nothing: every bar mark without a fill gets one, and it is
+ * the ordinary bar it draws, not a mistake.
+ */
+function stackSQL(direction, options, implicit = false) {
     const [loName, hiName] = direction === 'y' ? ['y0', 'y1'] : ['x0', 'x1'];
+    let warned = implicit;
+    const onNoSeries = (aliases) => {
+        if (warned)
+            return;
+        warned = true;
+        console.warn(`stack${direction === 'y' ? 'Y' : 'X'}: no series column, so stacking has no effect ` +
+            `(one row per band). Stacking groups rows within a band by the ordinal ` +
+            `fill channel — add fill="<field>" to the mark. Select list: [${aliases.join(', ')}].`);
+    };
     return {
         stage: 'sql',
         type: 'stack',
@@ -844,7 +860,7 @@ function stackSQL(direction, options) {
         channels: [loName, hiName],
         apply(query, config) {
             const aliases = getSelectAliases(query);
-            const { band, value, series } = resolveStackColumns(aliases, config, direction);
+            const { band, value, series } = resolveStackColumns(aliases, config, direction, onNoSeries);
             const valueCol = column(value);
             const bandCol = column(band);
             const notNaN = sqlTag `NOT isnan(${valueCol})`;
@@ -1185,9 +1201,7 @@ export function withImplicitStack(transforms, hasExplicitBounds, direction) {
         ? direction === 'y'
             ? stackY({ engine: 'js' })
             : stackX({ engine: 'js' })
-        : direction === 'y'
-            ? stackY()
-            : stackX();
+        : stackSQL(direction, {}, true);
     return [...transforms, implicitStack];
 }
 export { TransformCompiler } from './TransformCompiler';