@uwdata/mosaic-spec 0.11.0 → 0.12.1

package/dist/types/ast/ColumnParamRefNode.d.ts

@@ -0,0 +1,8 @@
+export class ColumnParamRefNode extends ASTNode {
+    constructor(param: any);
+    param: any;
+    instantiate(ctx: any): any;
+    codegen(ctx: any): string;
+    toJSON(): string;
+}
+import { ASTNode } from './ASTNode.js';

package/dist/types/ast/ExpressionNode.d.ts

@@ -1,15 +1,13 @@
 export function parseExpression(spec: any, ctx: any): ExpressionNode;
 export class ExpressionNode extends ASTNode {
-    constructor(value: any, spans: any, params: any, label: any, aggregate: any);
+    constructor(value: any, spans: any, params: any);
     value: any;
     spans: any;
     params: any;
-    label: any;
-    aggregate: any;
     instantiate(ctx: any): any;
     codegen(ctx: any): string;
     toJSON(): {
-        [x: string]: any;
+        sql: any;
     };
 }
 import { ASTNode } from './ASTNode.js';

package/dist/types/constants.d.ts

@@ -4,6 +4,7 @@ export const DATAREF: "dataref";
 export const OPTIONS: "options";
 export const SELECTION: "selection";
 export const PARAMREF: "paramref";
+export const COLUMPARAMREF: "columnparamref";
 export const PARAM: "param";
 export const INCLUDE: "include";
 export const SELECT: "select";
@@ -15,7 +16,6 @@ export const SINGLE: "single";
 export const DATA: "data";
 export const EXPRESSION: "expression";
 export const SQL: "sql";
-export const AGG: "agg";
 export const INPUT: "input";
 export const HCONCAT: "hconcat";
 export const VCONCAT: "vconcat";

package/dist/types/spec/Input.d.ts

@@ -170,7 +170,7 @@ export interface Table {
     /**
      * The name of a database table to use as a data source for this widget.
      */
-    from: string;
+    from: string | ParamRef;
     /**
      * A list of column names to include in the table grid.
      * If unspecified, all table columns are included.

package/dist/types/spec/PlotAttribute.d.ts

@@ -148,13 +148,19 @@ export interface PlotAttributes {
      */
     grid?: boolean | string | ParamRef;
     /**
-     * A textual label to show on the axis or legend; if null, show no label. By
-     * default the scale label is inferred from channel definitions, possibly with
-     * an arrow (↑, →, ↓, or ←) to indicate the direction of increasing value.
+     * The [aria-label attribute][1] on the SVG root.
      *
-     * For axes and legends only.
+     * [1]: https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-label
+     */
+    ariaLabel?: string | null;
+    /**
+     * The [aria-description attribute][1] on the SVG root.
+     *
+     * [1]: https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-description
      */
-    label?: string | null | ParamRef;
+    ariaDescription?: string | null;
+    /** The default clip for all marks. */
+    clip?: 'frame' | 'sphere' | boolean | null | ParamRef;
     /**
      * The *x* scale type, affecting how the scale encodes abstract data, say by
      * applying a mathematical transformation. If null, the scale is disabled.

package/dist/types/spec/PlotFrom.d.ts

@@ -7,7 +7,7 @@ export type PlotDataInline = any[];
 /** Input data specification for a plot mark. */
 export interface PlotFrom {
     /** The name of the backing data table. */
-    from: string;
+    from: string | ParamRef;
     /** A selection that filters the mark data. */
     filterBy?: ParamRef;
     /**

package/dist/types/spec/PlotInteractor.d.ts

@@ -3,6 +3,7 @@ import { IntervalX, IntervalY } from './interactors/Interval1D.js';
 import { IntervalXY } from './interactors/Interval2D.js';
 import { NearestX, NearestY } from './interactors/Nearest.js';
 import { Pan, PanX, PanY, PanZoom, PanZoomX, PanZoomY } from './interactors/PanZoom.js';
+import { Region } from './interactors/Region.js';
 import { Toggle, ToggleColor, ToggleX, ToggleY } from './interactors/Toggle.js';
 /** A plot interactor entry. */
-export type PlotInteractor = Highlight | IntervalX | IntervalY | IntervalXY | NearestX | NearestY | Toggle | ToggleX | ToggleY | ToggleColor | Pan | PanX | PanY | PanZoom | PanZoomX | PanZoomY;
+export type PlotInteractor = Highlight | IntervalX | IntervalY | IntervalXY | NearestX | NearestY | Pan | PanX | PanY | PanZoom | PanZoomX | PanZoomY | Region | Toggle | ToggleX | ToggleY | ToggleColor;

package/dist/types/spec/PlotMark.d.ts

@@ -23,5 +23,6 @@ import { RuleX, RuleY } from './marks/Rule.js';
 import { Text, TextX, TextY } from './marks/Text.js';
 import { TickX, TickY } from './marks/Tick.js';
 import { Spike, Vector, VectorX, VectorY } from './marks/Vector.js';
+import { WaffleX, WaffleY } from './marks/Waffle.js';
 /** A plot mark entry. */
-export type PlotMark = Area | AreaX | AreaY | Arrow | AxisX | AxisY | AxisFx | AxisFy | GridX | GridY | GridFx | GridFy | BarX | BarY | Cell | CellX | CellY | Contour | DelaunayLink | DelaunayMesh | Hull | Voronoi | VoronoiMesh | DenseLine | Density | DensityX | DensityY | Dot | DotX | DotY | Circle | Hexagon | ErrorBarX | ErrorBarY | Frame | Geo | Graticule | Sphere | Hexbin | Hexgrid | Image | Line | LineX | LineY | Link | Raster | Heatmap | RasterTile | Rect | RectX | RectY | RegressionY | RuleX | RuleY | Text | TextX | TextY | TickX | TickY | Vector | VectorX | VectorY | Spike;
+export type PlotMark = Area | AreaX | AreaY | Arrow | AxisX | AxisY | AxisFx | AxisFy | GridX | GridY | GridFx | GridFy | BarX | BarY | Cell | CellX | CellY | Contour | DelaunayLink | DelaunayMesh | Hull | Voronoi | VoronoiMesh | DenseLine | Density | DensityX | DensityY | Dot | DotX | DotY | Circle | Hexagon | ErrorBarX | ErrorBarY | Frame | Geo | Graticule | Sphere | Hexbin | Hexgrid | Image | Line | LineX | LineY | Link | Raster | Heatmap | RasterTile | Rect | RectX | RectY | RegressionY | RuleX | RuleY | Text | TextX | TextY | TickX | TickY | Vector | VectorX | VectorY | Spike | WaffleX | WaffleY;

package/dist/types/spec/Transform.d.ts

@@ -13,7 +13,7 @@ export interface AggregateOptions {
     distinct?: boolean;
 }
 /** A transform argument. */
-type Arg = string | number | boolean;
+type Arg = string | number | boolean | ParamRef;
 /** A zero argument transform signature. */
 type Arg0 = null | [];
 /** A single argument transform signature. */
@@ -80,6 +80,12 @@ export interface Bin {
      */
     offset?: number;
 }
+export interface Column {
+    /**
+     * Intpret a string or param-value as a column reference.
+     */
+    column: Arg1;
+}
 export interface DateMonth {
     /**
      * Transform a Date value to a month boundary for cyclic comparison.
@@ -325,7 +331,7 @@ export interface NthValue extends WindowOptions {
     nth_value: Arg2Opt;
 }
 /** A data transform that maps one column value to another. */
-export type ColumnTransform = Bin | DateMonth | DateMonthDay | DateDay | Centroid | CentroidX | CentroidY | GeoJSON;
+export type ColumnTransform = Bin | Column | DateMonth | DateMonthDay | DateDay | Centroid | CentroidX | CentroidY | GeoJSON;
 /** An aggregate transform that combines multiple values. */
 export type AggregateTransform = Argmax | Argmin | Avg | Count | Max | Min | First | Last | Max | Min | Median | Mode | Product | Quantile | Stddev | StddevPop | Sum | Variance | VarPop;
 export type WindowTransform = RowNumber | Rank | DenseRank | PercentRank | CumeDist | NTile | Rank | Lag | Lead | FirstValue | LastValue | NthValue;

package/dist/types/spec/interactors/BrushStyles.d.ts

@@ -0,0 +1,27 @@
+/** Styles for rectangular selection brushes. */
+export interface BrushStyles {
+    /**
+     * The overall opacity of the brush rectangle.
+     */
+    opacity?: number;
+    /**
+     * The fill opacity of the brush rectangle.
+     */
+    fillOpacity?: number;
+    /**
+     * The stroke opacity of the brush rectangle.
+     */
+    strokeOpacity?: number;
+    /**
+     * The fill color of the brush rectangle.
+     */
+    fill?: string;
+    /**
+     * The stroke color of the brush rectangle.
+     */
+    stroke?: string;
+    /**
+     * The stroke dash array of the brush rectangle.
+     */
+    strokeDasharray?: string;
+}

package/dist/types/spec/interactors/Interval1D.d.ts

@@ -1,27 +1,5 @@
 import { ParamRef } from '../Param.js';
-/** Styles for rectangular selection brushes. */
-export interface BrushStyles {
-    /**
-     * The overall opacity of the brush rectangle.
-     */
-    opacity?: number;
-    /**
-     * The fill opacity of the brush rectangle.
-     */
-    fillOpacity?: number;
-    /**
-     * The stroke opacity of the brush rectangle.
-     */
-    strokeOpacity?: number;
-    /**
-     * The fill color of the brush rectangle.
-     */
-    fill?: string;
-    /**
-     * The stroke color of the brush rectangle.
-     */
-    stroke?: string;
-}
+import { BrushStyles } from './BrushStyles.js';
 /** Options for 1D interval interactors. */
 export interface Interval1DOptions {
     /**
@@ -37,13 +15,14 @@ export interface Interval1DOptions {
     field?: string;
     /**
      * The size of an interative pixel (default `1`). Larger pixel sizes reduce
-     * the brush resolution, which can reduce the size of data cube indexes.
+     * the brush resolution, which can reduce the size of pre-aggregated
+     * materialized views.
      */
     pixelSize?: number;
     /**
-     * A flag indicating if peer (sibling) marks are when cross-filtering
-     * (default `true`). If set, peer marks will not be filtered by this
-     * interactor's selection in cross-filtering setups.
+     * A flag indicating if peer (sibling) marks are excluded when
+     * cross-filtering (default `true`). If set, peer marks will not be
+     * filtered by this interactor's selection in cross-filtering setups.
      */
     peers?: boolean;
     /**

package/dist/types/spec/interactors/Interval2D.d.ts

@@ -1,5 +1,5 @@
 import { ParamRef } from '../Param.js';
-import { BrushStyles } from './Interval1D.js';
+import { BrushStyles } from './BrushStyles.js';
 /** Options for 2D interval interactors. */
 export interface Interval2DOptions {
     /**
@@ -22,13 +22,14 @@ export interface Interval2DOptions {
     yfield?: string;
     /**
      * The size of an interative pixel (default `1`). Larger pixel sizes reduce
-     * the brush resolution, which can reduce the size of data cube indexes.
+     * the brush resolution, which can reduce the size of pre-aggregated
+     * materialized views.
      */
     pixelSize?: number;
     /**
-     * A flag indicating if peer (sibling) marks are when cross-filtering
-     * (default `true`). If set, peer marks will not be filtered by this
-     * interactor's selection in cross-filtering setups.
+     * A flag indicating if peer (sibling) marks are excluded when
+     * cross-filtering (default `true`). If set, peer marks will not be
+     * filtered by this interactor's selection in cross-filtering setups.
      */
     peers?: boolean;
     /**

package/dist/types/spec/interactors/Region.d.ts

@@ -0,0 +1,32 @@
+import { ParamRef } from '../Param.js';
+import { BrushStyles } from './BrushStyles.js';
+/** Options for region interactors. */
+export interface RegionOptions {
+    /**
+     * The output selection. A clause of the form
+     * `(field = value1) OR (field = value2) ...`
+     * is added for the currently selected values.
+     */
+    as: ParamRef;
+    /**
+     * The encoding channels over which to select values.
+     * For a selected mark, selection clauses will cover
+     * the backing data fields for each channel.
+     */
+    channels: string[];
+    /**
+     * A flag indicating if peer (sibling) marks are excluded when
+     * cross-filtering (default `true`). If set, peer marks will not be
+     * filtered by this interactor's selection in cross-filtering setups.
+     */
+    peers?: boolean;
+    /**
+     * CSS styles for the brush (SVG `rect`) element.
+     */
+    brush?: BrushStyles;
+}
+/** A rectangular region interactor. */
+export interface Region extends RegionOptions {
+    /** Select aspects of individual marks within a 2D range. */
+    select: 'region';
+}

package/dist/types/spec/interactors/Toggle.d.ts

@@ -8,9 +8,9 @@ export interface ToggleOptions {
      */
     as: ParamRef;
     /**
-     * A flag indicating if peer (sibling) marks are when cross-filtering
-     * (default `true`). If set, peer marks will not be filtered by this
-     * interactor's selection in cross-filtering setups.
+     * A flag indicating if peer (sibling) marks are excluded when
+     * cross-filtering (default `true`). If set, peer marks will not be
+     * filtered by this interactor's selection in cross-filtering setups.
      */
     peers?: boolean;
 }

package/dist/types/spec/marks/Marks.d.ts

@@ -337,6 +337,11 @@ export interface MarkOptions {
     tip?: boolean | TipPointer | (TipOptions & {
         pointer?: TipPointer;
     }) | ParamRef;
+    /**
+     * Additional named channels, for example to include in a tooltip.
+     * Consists of (channel name, data field name) key-value pairs.
+     */
+    channels?: Record<string, string>;
     /**
      * How to clip the mark; one of:
      *

package/dist/types/spec/marks/Waffle.d.ts

@@ -0,0 +1,58 @@
+import { ParamRef } from '../Param.js';
+import { BarXOptions, BarYOptions } from './Bar.js';
+import { MarkData } from './Marks.js';
+/** Options for the waffleX and waffleY mark. */
+export interface WaffleOptions {
+    /** The number of cells per row or column; defaults to undefined for automatic. */
+    multiple?: number | ParamRef;
+    /** The quantity each cell represents; defaults to 1. */
+    unit?: number | ParamRef;
+    /** The gap in pixels between cells; defaults to 1. */
+    gap?: number | ParamRef;
+    /** If true, round to integers to avoid partial cells. */
+    round?: boolean | ParamRef;
+}
+/** The waffleX mark. */
+export interface WaffleX extends MarkData, BarXOptions, WaffleOptions {
+    /**
+     * A horizontal waffle mark. The required *x* values should be quantitative,
+     * and the optional *y* values should be ordinal.
+     *
+     * If neither **x1** nor **x2** nor **interval** is specified, an implicit
+     * stackX transform is applied and **x** defaults to the identity function,
+     * assuming that *data* = [*x₀*, *x₁*, *x₂*, …]. Otherwise if an **interval**
+     * is specified, then **x1** and **x2** are derived from **x**, representing
+     * the lower and upper bound of the containing interval, respectively.
+     * Otherwise, if only one of **x1** or **x2** is specified, the other
+     * defaults to **x**, which defaults to zero.
+     *
+     * The optional **y** ordinal channel specifies the vertical position; it is
+     * typically bound to the *y* scale, which must be a *band* scale. If the
+     * **y** channel is not specified, the bar will span the vertical extent of
+     * the plot’s frame. Because a waffle represents a discrete number of square
+     * cells, it may not use all of the available bandwidth.
+     */
+    mark: 'waffleX';
+}
+/** The waffleY mark. */
+export interface WaffleY extends MarkData, BarYOptions, WaffleOptions {
+    /**
+     * A vertical waffle mark. The required *y* values should be quantitative,
+     * and the optional *x* values should be ordinal.
+     *
+     * If neither **y1** nor **y2** nor **interval** is specified, an implicit
+     * stackY transform is applied and **y** defaults to the identity function,
+     * assuming that *data* = [*y₀*, *y₁*, *y₂*, …]. Otherwise if an **interval**
+     * is specified, then **y1** and **y2** are derived from **y**, representing
+     * the lower and upper bound of the containing interval, respectively.
+     * Otherwise, if only one of **y1** or **y2** is specified, the other
+     * defaults to **y**, which defaults to zero.
+     *
+     * The optional **x** ordinal channel specifies the horizontal position; it
+     * is typically bound to the *x* scale, which must be a *band* scale. If the
+     * **x** channel is not specified, the bar will span the horizontal extent of
+     * the plot’s frame. Because a waffle represents a discrete number of square
+     * cells, it may not use all of the available bandwidth.
+     */
+    mark: 'waffleY';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uwdata/mosaic-spec",
-  "version": "0.11.0",
+  "version": "0.12.1",
   "description": "Declarative specification of Mosaic-powered applications.",
   "keywords": [
     "mosaic",
@@ -25,7 +25,7 @@
     "prebuild": "rimraf dist && mkdir dist",
     "build": "npm run types && node ../../esbuild.js mosaic-spec",
     "lint": "eslint src test",
-    "types": "tsc -p tsconfig.json && npm run schema",
+    "types": "tsc && npm run schema",
     "schema": "ts-json-schema-generator -f tsconfig.json -p src/spec/Spec.ts -t Spec --no-type-check --no-ref-encode --functions hide > dist/mosaic-schema.json",
     "pretest": "npm run prebuild && npm run types",
     "test": "vitest run && tsc -p jsconfig.json",
@@ -33,10 +33,10 @@
     "prepublishOnly": "npm run test && npm run lint && npm run build"
   },
   "dependencies": {
-    "@uwdata/mosaic-core": "^0.11.0",
-    "@uwdata/mosaic-sql": "^0.11.0",
-    "@uwdata/vgplot": "^0.11.0",
+    "@uwdata/mosaic-core": "^0.12.1",
+    "@uwdata/mosaic-sql": "^0.12.1",
+    "@uwdata/vgplot": "^0.12.1",
     "ts-json-schema-generator": "^2.3.0"
   },
-  "gitHead": "861d616f39926a1d2aee83b59dbdd70b0b3caf12"
+  "gitHead": "fe3a7c34352da54ec36a1ebf557846f46a649782"
 }

package/src/ast/ColumnParamRefNode.js

@@ -0,0 +1,21 @@
+import { ASTNode } from './ASTNode.js';
+import { COLUMPARAMREF } from '../constants.js';
+
+export class ColumnParamRefNode extends ASTNode {
+  constructor(param) {
+    super(COLUMPARAMREF);
+    this.param = param;
+  }
+
+  instantiate(ctx) {
+    return ctx.api.column(this.param.instantiate(ctx));
+  }
+
+  codegen(ctx) {
+    return `${ctx.ns()}column(${this.param.codegen(ctx)})`;
+  }
+
+  toJSON() {
+    return `$${this.param.toJSON}`;
+  }
+}

package/src/ast/DataNode.js

@@ -1,4 +1,4 @@
-import { create } from '@uwdata/mosaic-sql';
+import { createTable } from '@uwdata/mosaic-sql';
 import { DATA } from '../constants.js';
 import { isArray, isString } from '../util.js';
 import { ASTNode } from './ASTNode.js';
@@ -162,7 +162,7 @@ export class TableDataNode extends QueryDataNode {
   instantiateQuery(ctx) {
     const { name, query, options } = this;
     if (query) {
-      return ctx.api.create(name, query, options.instantiate(ctx));
+      return ctx.api.createTable(name, query, options.instantiate(ctx));
     }
   }
 
@@ -174,7 +174,7 @@ export class TableDataNode extends QueryDataNode {
   codegenQuery(ctx) {
     const { name, query, options } = this;
     if (query) {
-      return `\`${create(name, query, options.instantiate(ctx))}\``;
+      return `\`${createTable(name, query, options.instantiate(ctx))}\``;
     }
   }
 

package/src/ast/ExpressionNode.js

@@ -1,50 +1,47 @@
-import { AGG, EXPRESSION, SQL } from '../constants.js';
+import { EXPRESSION, SQL } from '../constants.js';
 import { ASTNode } from './ASTNode.js';
+import { ColumnParamRefNode } from './ColumnParamRefNode.js';
 
-export function parseExpression(spec, ctx) {
-  const { label } = spec;
-  const key = spec[SQL] ? SQL
-    : spec[AGG] ? AGG
-    : ctx.error('Unrecognized expression type', spec);
+const tokenRegExp = /(\\'|\\"|"(?:\\"|[^"])*"|'(?:\\'|[^'])*'|\${1,2}\w+)/g;
 
-  const expr = spec[key];
-  const tokens = expr.split(/(\\'|\\"|"(?:\\"|[^"])*"|'(?:\\'|[^'])*'|\$\w+)/g);
+export function parseExpression(spec, ctx) {
+  const expr = spec[SQL];
+  const tokens = expr.split(tokenRegExp);
   const spans = [''];
   const params = [];
 
   for (let i = 0, k = 0; i < tokens.length; ++i) {
     const tok = tokens[i];
     if (tok.startsWith('$')) {
-      params[k] = ctx.maybeParam(tok);
+      params[k] = tok.startsWith('$$')
+        ? new ColumnParamRefNode(ctx.paramRef(tok.slice(2)))
+        : ctx.maybeParam(tok);
       spans[++k] = '';
     } else {
       spans[k] += tok;
     }
   }
 
-  return new ExpressionNode(expr, spans, params, label, key === AGG);
+  return new ExpressionNode(expr, spans, params);
 }
 
 export class ExpressionNode extends ASTNode {
-  constructor(value, spans, params, label, aggregate) {
+  constructor(value, spans, params) {
     super(EXPRESSION);
     this.value = value;
     this.spans = spans;
     this.params = params;
-    this.label = label;
-    this.aggregate = aggregate;
   }
 
   instantiate(ctx) {
-    const { spans, params, label, aggregate } = this;
-    const tag = ctx.api[aggregate ? AGG : SQL];
+    const { spans, params } = this;
+    const tag = ctx.api[SQL];
     const args = params.map(e => e.instantiate(ctx));
-    return tag(spans, ...args).annotate({ label });
+    return tag(spans, ...args);
   }
 
   codegen(ctx) {
-    const { spans, params, label, aggregate } = this;
-    const method = aggregate ? AGG : SQL;
+    const { spans, params } = this;
 
     // reconstitute expression string
     let str = '';
@@ -54,12 +51,10 @@ export class ExpressionNode extends ASTNode {
     }
     str += spans[n];
 
-    return `${ctx.ns()}${method}\`${str}\``
-      + (label ? `.annotate({ label: ${JSON.stringify(label)} })` : '');
+    return `${ctx.ns()}${SQL}\`${str}\``;
   }
 
   toJSON() {
-    const key = this.aggregate ? AGG : SQL;
-    return { [key]: this.value };
+    return { [SQL]: this.value };
   }
 }

package/src/ast/PlotFromNode.js

@@ -16,7 +16,7 @@ export function parseMarkData(spec, ctx) {
   }
 
   const { from: table, ...options } = spec;
-  return new PlotFromNode(table, parseOptions(options, ctx));
+  return new PlotFromNode(ctx.maybeParam(table), parseOptions(options, ctx));
 }
 
 export class PlotFromNode extends ASTNode {
@@ -28,17 +28,17 @@ export class PlotFromNode extends ASTNode {
 
   instantiate(ctx) {
     const { table, options } = this;
-    return ctx.api[FROM](table, options.instantiate(ctx));
+    return ctx.api[FROM](table.instantiate(ctx), options.instantiate(ctx));
   }
 
   codegen(ctx) {
-    const { type, table, options } = this;
-    const opt = options.codegen(ctx);
-    return `${ctx.ns()}${type}("${table}"${opt ? ', ' + opt : ''})`;
+    const table = this.table.codegen(ctx);
+    const opt = this.options.codegen(ctx);
+    return `${ctx.ns()}${this.type}(${table}${opt ? ', ' + opt : ''})`;
   }
 
   toJSON() {
     const { type, table, options } = this;
-    return { [type]: table, ...options.toJSON() };
+    return { [type]: table.toJSON(), ...options.toJSON() };
   }
 }

package/src/ast/PlotMarkNode.js

@@ -1,4 +1,4 @@
-import { AGG, MARK, SQL } from '../constants.js';
+import { MARK, SQL } from '../constants.js';
 import { isObject } from '../util.js';
 import { ASTNode } from './ASTNode.js';
 import { parseExpression } from './ExpressionNode.js';
@@ -8,7 +8,7 @@ import { parseTransform } from './TransformNode.js';
 
 function maybeTransform(value, ctx) {
   if (isObject(value)) {
-    return (value[SQL] || value[AGG])
+    return value[SQL]
       ? parseExpression(value, ctx)
       : parseTransform(value, ctx);
   }

package/src/ast/TransformNode.js

@@ -2,8 +2,10 @@ import { ASTNode } from './ASTNode.js';
 import { TRANSFORM } from '../constants.js';
 import { parseOptions } from './OptionsNode.js';
 
-function toArray(value) {
-  return value == null ? [] : [value].flat();
+function toArray(value, ctx) {
+  return value == null
+    ? []
+    : [value].flat().map(v => ctx.maybeParam(v));
 }
 
 export function parseTransform(spec, ctx) {
@@ -20,14 +22,14 @@ export function parseTransform(spec, ctx) {
 
   if (name === 'bin') {
     const { bin, ...options } = spec;
-    const [arg] = toArray(bin);
+    const [arg] = toArray(bin, ctx);
     return new BinTransformNode(name, arg, parseOptions(options, ctx));
   } else {
-    const args = name === 'count' && !spec[name] ? [] : toArray(spec[name]);
+    const args = name === 'count' && !spec[name] ? [] : toArray(spec[name], ctx);
     const options = {
       distinct: spec.distinct,
-      orderby: toArray(spec.orderby).map(v => ctx.maybeParam(v)),
-      partitionby: toArray(spec.partitionby).map(v => ctx.maybeParam(v)),
+      orderby: toArray(spec.orderby, ctx),
+      partitionby: toArray(spec.partitionby, ctx),
       rows: spec.rows ? ctx.maybeParam(spec.rows) : null,
       range: spec.range ? ctx.maybeParam(spec.range) : null
     };
@@ -47,7 +49,7 @@ export class TransformNode extends ASTNode {
     const { name, args, options } = this;
     const { distinct, orderby, partitionby, rows, range } = options;
 
-    let expr = ctx.api[name](...args);
+    let expr = ctx.api[name](...args.map(a => a.instantiate(ctx)));
     if (distinct) {
       expr = expr.distinct();
     }
@@ -70,7 +72,7 @@ export class TransformNode extends ASTNode {
     const { distinct, orderby, partitionby, rows, range } = options;
 
     let str = `${ctx.ns()}${name}(`
-      + args.map(v => JSON.stringify(v)).join(', ')
+      + args.map(v => v.codegen(ctx)).join(', ')
       + ')';
 
     if (distinct) {
@@ -97,7 +99,7 @@ export class TransformNode extends ASTNode {
     const { name, args, options } = this;
     const { distinct, orderby, partitionby, rows, range } = options;
 
-    const json = { [name]: simplify(args) };
+    const json = { [name]: simplify(args.map(v => v.toJSON())) };
 
     if (distinct) {
       json.distinct = true;
@@ -128,21 +130,21 @@ export class BinTransformNode extends ASTNode {
 
   instantiate(ctx) {
     const { name, arg, options } = this;
-    return ctx.api[name](arg, options.instantiate(ctx));
+    return ctx.api[name](arg.instantiate(ctx), options.instantiate(ctx));
   }
 
   codegen(ctx) {
     const { name, arg, options } = this;
     const opt = options.codegen(ctx);
     return `${ctx.ns()}${name}(`
-        + JSON.stringify(arg)
+        + arg.codegen(ctx)
         + (opt ? `, ${opt}` : '')
         + ')';
   }
 
   toJSON() {
     const { name, arg, options } = this;
-    return { [name]: arg, ...options.toJSON() };
+    return { [name]: arg.toJSON(), ...options.toJSON() };
   }
 }