@uwdata/mosaic-spec 0.7.0 → 0.8.0

package/src/spec/marks/Bar.ts

@@ -0,0 +1,160 @@
+import { ParamRef } from '../Param.js';
+import { Interval } from '../PlotTypes.js';
+import { ChannelValueIntervalSpec, ChannelValueSpec, InsetOptions, MarkData, MarkOptions, StackOptions } from './Marks.js';
+import { RectCornerOptions } from './Rect.js';
+
+/** Options for the barX and barY marks. */
+interface BarOptions extends MarkOptions, InsetOptions, RectCornerOptions, StackOptions {
+  /**
+   * How to convert a continuous value (**x** for barX, or **y** for barY) into
+   * an interval (**x1** and **x2** for barX, or **y1** and **y2** for barY);
+   * one of:
+   *
+   * - a named time interval such as *day* (for date intervals)
+   * - a number (for number intervals), defining intervals at integer multiples of *n*
+   *
+   * Setting this option disables the implicit stack transform (stackX for barX,
+   * or stackY for barY).
+   */
+  interval?: Interval | ParamRef;
+}
+
+/** Options for the barX mark. */
+export interface BarXOptions extends BarOptions {
+  /**
+   * The horizontal position (or length/width) channel, typically bound to the
+   * *x* scale.
+   *
+   * 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.
+   */
+  x?: ChannelValueIntervalSpec;
+
+  /**
+   * The required primary (starting, often left) horizontal position channel,
+   * typically bound to the *x* scale. Setting this option disables the
+   * implicit stackX transform.
+   *
+   * If *x* represents ordinal values, use a cell mark instead.
+   */
+  x1?: ChannelValueSpec;
+
+  /**
+   * The required secondary (ending, often right) horizontal position channel,
+   * typically bound to the *x* scale. Setting this option disables the
+   * implicit stackX transform.
+   *
+   * If *x* represents ordinal values, use a cell mark instead.
+   */
+  x2?: ChannelValueSpec;
+
+  /**
+   * The optional vertical position of the bar; a ordinal channel typically
+   * bound to the *y* scale. If not specified, the bar spans the vertical
+   * extent of the frame; otherwise the *y* scale must be a *band* scale.
+   *
+   * If *y* represents quantitative or temporal values, use a rectX mark
+   * instead.
+   */
+  y?: ChannelValueSpec;
+}
+
+/** Options for the barY mark. */
+export interface BarYOptions extends BarOptions {
+  /**
+   * The vertical position (or length/height) channel, typically bound to the
+   * *y* scale.
+   *
+   * 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.
+   */
+  y?: ChannelValueIntervalSpec;
+
+  /**
+   * The required primary (starting, often bottom) vertical position channel,
+   * typically bound to the *y* scale. Setting this option disables the
+   * implicit stackY transform.
+   *
+   * If *y* represents ordinal values, use a cell mark instead.
+   */
+  y1?: ChannelValueSpec;
+
+  /**
+   * The required secondary (ending, often top) horizontal position channel,
+   * typically bound to the *y* scale. Setting this option disables the
+   * implicit stackY transform.
+   *
+   * If *y* represents ordinal values, use a cell mark instead.
+   */
+  y2?: ChannelValueSpec;
+
+  /**
+   * The optional horizontal position of the bar; a ordinal channel typically
+   * bound to the *x* scale. If not specified, the bar spans the horizontal
+   * extent of the frame; otherwise the *x* scale must be a *band* scale.
+   *
+   * If *x* represents quantitative or temporal values, use a rectY mark
+   * instead.
+   */
+  x?: ChannelValueSpec;
+}
+
+/** The barX mark. */
+export interface BarX extends MarkData, BarXOptions {
+  /**
+   * A horizontal bar mark. The required *x* values should be quantitative or
+   * temporal, 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.
+   *
+   * If *y* is quantitative, use the rectX mark instead.
+   * If *x* is ordinal, use the cell mark instead.
+   */
+  mark: 'barX';
+}
+
+/** The barY mark. */
+export interface BarY extends MarkData, BarYOptions {
+  /**
+   * A vertical bar mark. The required *y* values should be quantitative or
+   * temporal, 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.
+   *
+   * If *x* is quantitative, use the rectY mark instead.
+   * If *y* is ordinal, use the cell mark instead.
+   */
+  mark: 'barY';
+}

package/src/spec/marks/Cell.ts

@@ -0,0 +1,62 @@
+import { ChannelValueSpec, InsetOptions, MarkData, MarkOptions } from './Marks.js';
+import { RectCornerOptions } from './Rect.js';
+
+/** Options for the cell mark. */
+export interface CellOptions extends MarkOptions, InsetOptions, RectCornerOptions {
+  /**
+   * The horizontal position of the cell; an optional ordinal channel typically
+   * bound to the *x* scale. If not specified, the cell spans the horizontal
+   * extent of the frame; otherwise the *x* scale must be a *band* scale.
+   *
+   * If *x* represents quantitative or temporal values, use a barX mark instead;
+   * if *y* is also quantitative or temporal, use a rect mark.
+   */
+  x?: ChannelValueSpec;
+
+  /**
+   * The vertical position of the cell; an optional ordinal channel typically
+   * bound to the *y* scale. If not specified, the cell spans the vertical
+   * extent of the frame; otherwise the *y* scale must be a *band* scale.
+   *
+   * If *y* represents quantitative or temporal values, use a barY mark instead;
+   * if *x* is also quantitative or temporal, use a rect mark.
+   */
+  y?: ChannelValueSpec;
+}
+
+/** The cell mark. */
+export interface Cell extends MarkData, CellOptions {
+  /**
+   * A rectangular cell mark. Along with **x** and/or **y**, a **fill** channel
+   * is typically specified to encode value as color.
+   *
+   * If neither **x** nor **y** are specified, *data* is assumed to be an array of
+   * pairs [[*x₀*, *y₀*], [*x₁*, *y₁*], [*x₂*, *y₂*], …] such that **x** = [*x₀*,
+   * *x₁*, *x₂*, …] and **y** = [*y₀*, *y₁*, *y₂*, …].
+   *
+   * Both **x** and **y** should be ordinal; if only **x** is quantitative (or
+   * temporal), use a barX mark; if only **y** is quantitative, use a barY mark;
+   * if both are quantitative, use a rect mark.
+   */
+  mark: 'cell';
+}
+
+/** The cellX mark. */
+export interface CellX extends MarkData, CellOptions {
+  /**
+   * Like cell, but **x** defaults to the zero-based index [0, 1, 2, …], and if
+   * **stroke** is not a channel, **fill** defaults to the identity function,
+   * assuming that *data* = [*x₀*, *x₁*, *x₂*, …].
+   */
+  mark: 'cellX';
+}
+
+/** The cellY mark. */
+export interface CellY extends MarkData, CellOptions {
+  /**
+   * Like cell, but **y** defaults to the zero-based index [0, 1, 2, …], and if
+   * **stroke** is not a channel, **fill** defaults to the identity function,
+   * assuming that *data* = [*y₀*, *y₁*, *y₂*, …].
+   */
+  mark: 'cellY';
+}

package/src/spec/marks/Contour.ts

@@ -0,0 +1,25 @@
+import { ParamRef } from '../Param.js';
+import { MarkData, MarkOptions } from './Marks.js';
+import { Grid2DOptions } from './Raster.js';
+
+export interface ContourOptions extends MarkOptions, Grid2DOptions {
+  /**
+   * The number of contour thresholds to subdivide the domain into discrete
+   * level sets; defaults to 10. One of:
+   *
+   * - a count representing the desired number of bins
+   * - an array of *n* threshold values for *n* - 1 bins
+   */
+  thresholds?: number | number[] | ParamRef;
+}
+
+/** The contour mark. */
+export interface Contour extends MarkData, ContourOptions {
+  /**
+   * A contour mark that draws isolines to delineate regions above and below a
+   * particular continuous value. It is often used to convey densities as a
+   * height field. The special column name "density" can be used to map density
+   * values to the fill or stroke options.
+   */
+  mark: 'contour';
+}

package/src/spec/marks/Delaunay.ts

@@ -0,0 +1,95 @@
+import {
+  ChannelValue, ChannelValueSpec, CurveOptions,
+  MarkData, MarkOptions, MarkerOptions
+} from './Marks.js';
+
+/** Options for the Delaunay marks. */
+export interface DelaunayOptions extends MarkOptions, MarkerOptions, CurveOptions {
+  /** The horizontal position channel, typically bound to the *x* scale. */
+  x?: ChannelValueSpec;
+  /** The vertical position channel, typically bound to the *y* scale. */
+  y?: ChannelValueSpec;
+  /**
+   * An optional ordinal channel for grouping to produce multiple
+   * (possibly overlapping) triangulations.
+   */
+  z?: ChannelValue;
+}
+
+/** The delaunayLink mark. */
+export interface DelaunayLink extends MarkData, DelaunayOptions {
+  /**
+   * A mark that draws links for each edge of the Delaunay triangulation
+   * of points given by the **x** and **y** channels. Like the link mark,
+   * except that **x1**, **y1**, **x2**, and **y2** are derived automatically
+   * from **x** and **y**. When an aesthetic channel is specified (such as
+   * **stroke** or **strokeWidth**), the link inherits the corresponding
+   * channel value from one of its two endpoints arbitrarily.
+   *
+   * If **z** is specified, the input points are grouped by *z*, producing a
+   * separate Delaunay triangulation for each group.
+   */
+  mark: 'delaunayLink';
+}
+
+/** The delaunayMesh mark. */
+export interface DelaunayMesh extends MarkData, DelaunayOptions {
+  /**
+   * A mark that draws a mesh of the Delaunay triangulation of the points
+   * given by the **x** and **y** channels. The **stroke** option defaults to
+   * _currentColor_, and the **strokeOpacity** defaults to 0.2; the **fill**
+   * option is not supported. When an aesthetic channel is specified (such as
+   * **stroke** or **strokeWidth**), the mesh inherits the corresponding
+   * channel value from one of its constituent points arbitrarily.
+   *
+   * If **z** is specified, the input points are grouped by *z*, producing a
+   * separate Delaunay triangulation for each group.
+   */
+  mark: 'delaunayMesh';
+}
+
+/** The hull mark. */
+export interface Hull extends MarkData, DelaunayOptions {
+  /**
+   * A mark that draws a convex hull around the points given by the **x** and
+   * **y** channels. The **stroke** option defaults to _currentColor_ and the
+   * **fill** option defaults to _none_. When an aesthetic channel is specified
+   * (such as **stroke** or **strokeWidth**), the hull inherits the
+   * corresponding channel value from one of its constituent points
+   * arbitrarily.
+   *
+   * If **z** is specified, the input points are grouped by *z*, producing a
+   * separate hull for each group. If **z** is not specified, it defaults to
+   * the **fill** channel, if any, or the **stroke** channel, if any.
+   */
+  mark: 'hull';
+}
+
+/** The voronoi mark. */
+export interface Voronoi extends MarkData, DelaunayOptions {
+  /**
+   * A mark that draws polygons for each cell of the Voronoi tesselation
+   * of the points given by the **x** and **y** channels.
+   *
+   * If **z** is specified, the input points are grouped by *z*, producing a
+   * separate Voronoi tesselation for each group.
+   */
+  mark: 'voronoi';
+}
+
+/** The voronoiMesh mark. */
+export interface VoronoiMesh extends MarkData, DelaunayOptions {
+  /**
+   * A mark that draws a mesh for the cell boundaries of the Voronoi
+   * tesselation of the points given by the **x** and **y** channels. The
+   * **stroke** option defaults to _currentColor_, and the **strokeOpacity**
+   * defaults to 0.2. The **fill** option is not supported. When an aesthetic
+   * channel is specified (such as **stroke** or **strokeWidth**), the mesh
+   * inherits the corresponding channel value from one of its constituent
+   * points arbitrarily.
+   *
+   * If **z** is specified, the input points are grouped by *z*, producing a
+   * separate Voronoi tesselation for each group.
+   */
+  mark: 'voronoiMesh';
+}

package/src/spec/marks/DenseLine.ts

@@ -0,0 +1,30 @@
+import { ParamRef } from '../Param.js';
+import { ChannelValue, MarkData } from './Marks.js';
+import { RasterOptions } from './Raster.js';
+
+export interface DenseLineOptions extends RasterOptions {
+  /**
+   * Flag to perform approximate arc length normalization of line segments
+   * to prevent artifacts due to overcounting steep lines. Defaults to `true`.
+   */
+  normalize?: boolean | ParamRef;
+
+  /**
+   * A ordinal channel for grouping data into series to be drawn as separate
+   * lines.
+   */
+  z?: ChannelValue;
+}
+
+/** The denseLine mark. */
+export interface DenseLine extends MarkData, DenseLineOptions {
+  /**
+   * A denseLine mark that plots line densities rather than point densities.
+   * The mark forms a binned raster grid and "draws" straight lines into it.
+   * To avoid over-weighting steep lines, by default each drawn series is
+   * normalized on a per-column basis to approximate arc length normalization.
+   * The values for each series are aggregated to form the line density, which
+   * is then drawn as an image similar to the raster mark.
+   */
+  mark: 'denseLine';
+}

package/src/spec/marks/Density.ts

@@ -0,0 +1,145 @@
+import { ParamRef } from "../Param.js";
+import { AreaXOptions, AreaYOptions } from "./Area.js";
+import { DotOptions } from "./Dot.js";
+import { LineXOptions, LineYOptions } from "./Line.js";
+import { MarkData, MarkOptions, TextStyles } from "./Marks.js";
+import { Grid2DOptions } from "./Raster.js";
+import { TextOptions } from "./Text.js";
+
+// Density2D
+
+export interface Density2DOptions extends MarkOptions, Omit<DotOptions, 'x' | 'y'>, TextStyles, Grid2DOptions {
+  /**
+   * The basic mark type to use to render 2D density values.
+   * Defaults to a dot mark; cell and text marks are also supported.
+   */
+  type?: 'dot' | 'circle' | 'hexagon' | 'cell' | 'text' | ParamRef;
+}
+
+/** The density mark for 2D densities. */
+export interface Density extends MarkData, Density2DOptions {
+  /**
+   * A 2D density mark that shows smoothed point cloud densities along two
+   * dimensions. The mark bins the data, counts the number of records that fall
+   * into each bin, and smooths the resulting counts, then plots the smoothed
+   * distribution, by default using a circular dot mark. The density mark
+   * calculates density values that can be mapped to encoding channels such as
+   * fill or r using the special field name "density".
+   *
+   * Set the *type* property to use a different base mark type.
+   */
+  mark: 'density';
+}
+
+// Density1D
+
+export interface Density1DOptions {
+  /**
+   * The kernel density bandwidth for smoothing, in pixels. Defaults to 20.
+   */
+  bandwidth?: number | ParamRef;
+
+  /**
+   * The number of bins over which to discretize the data prior to smoothing.
+   * Defaults to 1024.
+   */
+  bins?: number | ParamRef;
+}
+
+export interface DensityAreaXOptions extends Omit<AreaXOptions, 'x' | 'x1' | 'x2'> {
+  /**
+   * The basic mark type to use to render 1D density values. Defaults to an
+   * areaX mark; lineX, dotX, and textX marks are also supported.
+   */
+  type: 'areaX';
+}
+
+export interface DensityAreaYOptions extends Omit<AreaYOptions, 'y' | 'y1' | 'y2'> {
+  /**
+   * The basic mark type to use to render 1D density values. Defaults to an
+   * areaY mark; lineY, dot, and text marks are also supported.
+   */
+  type?: 'areaY';
+}
+
+export interface DensityLineXOptions extends Omit<LineXOptions, 'x' | 'x1' | 'x2'> {
+  /**
+   * The basic mark type to use to render 1D density values. Defaults to an
+   * areaX mark; lineX, dotX, and textX marks are also supported.
+   */
+  type: 'lineX';
+}
+
+export interface DensityLineYOptions extends Omit<LineYOptions, 'y' | 'y1' | 'y2'> {
+  /**
+   * The basic mark type to use to render 1D density values. Defaults to an
+   * areaY mark; lineY, dot, and text marks are also supported.
+   */
+  type: 'lineY';
+}
+
+export interface DensityDotXOptions extends Omit<DotOptions, 'x'> {
+  /**
+   * The basic mark type to use to render 1D density values. Defaults to an
+   * areaX mark; lineX, dotX, and textX marks are also supported.
+   */
+  type: 'dotX';
+}
+
+export interface DensityDotYOptions extends Omit<DotOptions, 'y'> {
+  /**
+   * The basic mark type to use to render 1D density values. Defaults to an
+   * areaY mark; lineY, dot, and text marks are also supported.
+   */
+  type: 'dot' | 'dotY' | 'circle' | 'hexagon';
+}
+
+export interface DensityTextXOptions extends Omit<TextOptions, 'x'> {
+  /**
+   * The basic mark type to use to render 1D density values. Defaults to an
+   * areaX mark; lineX, dotX, and textX marks are also supported.
+   */
+  type: 'textX';
+}
+
+export interface DensityTextYOptions extends Omit<TextOptions, 'y'> {
+  /**
+   * The basic mark type to use to render 1D density values. Defaults to an
+   * areaY mark; lineY, dot, and text marks are also supported.
+   */
+  type: 'text' | 'textY';
+}
+
+export interface DensityXBase extends MarkData, Density1DOptions {
+  /**
+   * A densityX mark that visualizes smoothed point cloud densities along the
+   * **x** dimension. The mark bins the data, counts the number of records that
+   * fall into each bin, smooths the resulting counts, and then plots the
+   * smoothed distribution, by default using an areaX mark.
+   *
+   * Set the *type* property to use a different base mark type.
+   */
+  mark: 'densityX';
+}
+
+export interface DensityYBase extends MarkData, Density1DOptions {
+  /**
+   * A densityY mark that visualizes smoothed point cloud densities along the
+   * **y** dimension. The mark bins the data, counts the number of records that
+   * fall into each bin, smooths the resulting counts, and then plots the
+   * smoothed distribution, by default using an areaY mark.
+   *
+   * Set the *type* property to use a different base mark type.
+   */
+  mark: 'densityY';
+}
+
+/** The densityX mark. */
+export type DensityX = DensityXBase & (
+  DensityAreaXOptions | DensityLineXOptions | DensityDotXOptions | DensityTextXOptions
+);
+
+/** The densityY mark. */
+export type DensityY = DensityYBase & (
+  DensityAreaYOptions | DensityLineYOptions | DensityDotYOptions | DensityTextYOptions
+);

package/src/spec/marks/Dot.ts

@@ -0,0 +1,147 @@
+import { ParamRef } from '../Param.js';
+import { FrameAnchor, Interval, SymbolType } from '../PlotTypes.js';
+import {
+  ChannelValue, ChannelValueIntervalSpec,
+  ChannelValueSpec, MarkData, MarkOptions
+} from './Marks.js';
+
+/** Options for the dot mark. */
+export interface DotOptions extends MarkOptions {
+  /**
+   * The horizontal position channel specifying the dot’s center, typically
+   * bound to the *x* scale.
+   */
+  x?: ChannelValueSpec;
+
+  /**
+   * The vertical position channel specifying the dot’s center, typically bound
+   * to the *y* scale.
+   */
+  y?: ChannelValueSpec;
+
+  /**
+   * The radius of dots; either a channel or constant. When a number, it is
+   * interpreted as a constant radius in pixels. Otherwise it is interpreted as
+   * a channel, typically bound to the *r* channel, which defaults to the *sqrt*
+   * type for proportional symbols. The radius defaults to 4.5 pixels when using
+   * the **symbol** channel, and otherwise 3 pixels. Dots with a nonpositive
+   * radius are not drawn.
+   */
+  r?: ChannelValueSpec | number | ParamRef;
+
+  /**
+   * The rotation angle of dots in degrees clockwise; either a channel or a
+   * constant. When a number, it is interpreted as a constant; otherwise it is
+   * interpreted as a channel. Defaults to 0°, pointing up.
+   */
+  rotate?: ChannelValue | number | ParamRef;
+
+  /**
+   * The categorical symbol; either a channel or a constant. A constant symbol
+   * can be specified by a valid symbol name such as *star*, or a symbol object
+   * (implementing the draw method); otherwise it is interpreted as a channel.
+   * Defaults to *circle* for the **dot** mark, and *hexagon* for the
+   * **hexagon** mark.
+   *
+   * If the **symbol** channel’s values are all symbols, symbol names, or
+   * nullish, the channel is unscaled (values are interpreted literally);
+   * otherwise, the channel is bound to the *symbol* scale.
+   */
+  symbol?: ChannelValueSpec | SymbolType | ParamRef;
+
+  /**
+   * The frame anchor specifies defaults for **x** and **y** based on the plot’s
+   * frame; it may be one of the four sides (*top*, *right*, *bottom*, *left*),
+   * one of the four corners (*top-left*, *top-right*, *bottom-right*,
+   * *bottom-left*), or the *middle* of the frame. For example, for dots
+   * distributed horizontally at the top of the frame:
+   *
+   * ```js
+   * Plot.dot(data, {x: "date", frameAnchor: "top"})
+   * ```
+   */
+  frameAnchor?: FrameAnchor | ParamRef;
+}
+
+/** Options for the dotX mark. */
+export interface DotXOptions extends Omit<DotOptions, "y"> {
+  /**
+   * The vertical position of the dot’s center, typically bound to the *y*
+   * scale.
+   */
+  y?: ChannelValueIntervalSpec;
+
+  /**
+   * An interval (such as *day* or a number), to transform **y** values to the
+   * middle of the interval.
+   */
+  interval?: Interval | ParamRef;
+}
+
+/** Options for the dotY mark. */
+export interface DotYOptions extends Omit<DotOptions, "x"> {
+  /**
+   * The horizontal position of the dot’s center, typically bound to the *x*
+   * scale.
+   */
+  x?: ChannelValueIntervalSpec;
+
+  /**
+   * An interval (such as *day* or a number), to transform **x** values to the
+   * middle of the interval.
+   */
+  interval?: Interval | ParamRef;
+}
+
+/** The dot mark. */
+export interface Dot extends MarkData, DotOptions {
+  /**
+   * A dot mark that draws circles, or other symbols, as in a scatterplot.
+   *
+   * If either **x** or **y** is not specified, the default is determined by the
+   * **frameAnchor** option. If none of **x**, **y**, and **frameAnchor** are
+   * specified, *data* is assumed to be an array of pairs [[*x₀*, *y₀*], [*x₁*,
+   * *y₁*], [*x₂*, *y₂*], …] such that **x** = [*x₀*, *x₁*, *x₂*, …] and **y** =
+   * [*y₀*, *y₁*, *y₂*, …].
+   *
+   * Dots are sorted by descending radius **r** by default to mitigate
+   * overplotting; set the **sort** option to null to draw them in input order.
+   */
+  mark: 'dot';
+}
+
+/** The dotX mark. */
+export interface DotX extends MarkData, DotXOptions {
+  /**
+   * Like dot, except that **x** defaults to the identity function, assuming that
+   * *data* = [*x₀*, *x₁*, *x₂*, …].
+   *
+   * If an **interval** is specified, such as *day*, **y** is transformed to the
+   * middle of the interval.
+   */
+  mark: 'dotX';
+}
+
+/** The dotY mark. */
+export interface DotY extends MarkData, DotYOptions {
+  /**
+   * Like dot, except that **y** defaults to the identity function, assuming that
+   * *data* = [*y₀*, *y₁*, *y₂*, …].
+   *
+   * If an **interval** is specified, such as *day*, **x** is transformed to the
+   * middle of the interval.
+   */
+  mark: 'dotY';
+}
+
+/** The circle mark. */
+export interface Circle extends MarkData, Exclude<DotOptions, 'symbol'> {
+  /** Like dot, except that the **symbol** option is set to *circle*. */
+  mark: 'circle';
+}
+
+/** The hexagon mark. */
+export interface Hexagon extends MarkData, Exclude<DotOptions, 'symbol'> {
+  /** Like dot, except that the **symbol** option is set to *hexagon*. */
+  mark: 'hexagon';
+}

package/src/spec/marks/Frame.ts

@@ -0,0 +1,23 @@
+import { ParamRef } from '../Param.js';
+import { InsetOptions, MarkOptions } from './Marks.js';
+import { RectCornerOptions } from './Rect.js';
+
+/** Options for the frame decoration mark. */
+export interface FrameOptions extends MarkOptions, InsetOptions, RectCornerOptions {
+  /**
+   * If null (default), the rectangular outline of the frame is drawn;
+   * otherwise the frame is drawn as a line only on the given side, and the
+   * **rx**, **ry**, **fill**, and **fillOpacity** options are ignored.
+   */
+  anchor?: 'top' | 'right' | 'bottom' | 'left' | null | ParamRef;
+}
+
+/** The frame mark. */
+export interface Frame extends FrameOptions {
+  /**
+   * Draws a rectangle around the plot’s frame, or if an **anchor** is given,
+   * a line on the given side. Useful for visual separation of facets, or in
+   * conjunction with axes and grids to fill the frame’s background.
+   */
+  mark: 'frame';
+}