@uwdata/mosaic-spec 0.7.1 → 0.8.0

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

@@ -0,0 +1,57 @@
+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/dist/types/spec/marks/Contour.d.ts

@@ -0,0 +1,23 @@
+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/dist/types/spec/marks/Delaunay.d.ts

@@ -0,0 +1,86 @@
+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/dist/types/spec/marks/DenseLine.d.ts

@@ -0,0 +1,27 @@
+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/dist/types/spec/marks/Density.d.ts

@@ -0,0 +1,121 @@
+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";
+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';
+}
+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/dist/types/spec/marks/Dot.d.ts

@@ -0,0 +1,129 @@
+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/dist/types/spec/marks/Frame.d.ts

@@ -0,0 +1,21 @@
+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';
+}

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

@@ -0,0 +1,53 @@
+import { ParamRef } from '../Param.js';
+import { ChannelValue, ChannelValueSpec, MarkData, MarkOptions } from './Marks.js';
+/** Options for the geo mark. */
+export interface GeoOptions extends MarkOptions {
+    /**
+     * A required channel for the geometry to render; defaults to identity,
+     * assuming *data* is a GeoJSON object or an iterable of GeoJSON objects.
+     */
+    geometry?: ChannelValue;
+    /**
+     * The size of Point and MultiPoint geometries, defaulting to a constant 3
+     * pixels. If **r** is a number, it is interpreted as a constant radius in
+     * pixels; otherwise it is interpreted as a channel and the effective radius
+     * is controlled by the *r* scale, which defaults to a *sqrt* scale such that
+     * the visual area of a point is proportional to its associated value.
+     *
+     * If **r** is a channel, geometries will be sorted by descending radius by
+     * default, to limit occlusion; use the **sort** transform to control render
+     * order. Geometries with a nonpositive radius are not drawn.
+     */
+    r?: ChannelValueSpec | ParamRef;
+}
+/** The geo mark. */
+export interface Geo extends MarkData, GeoOptions {
+    /**
+     * A geo mark. The **geometry** channel, which defaults to the identity
+     * function assuming that *data* is a GeoJSON object or an iterable of
+     * GeoJSON objects, is projected to the plane using the plot’s top-level
+     * **projection**.
+     *
+     * If *data* is a GeoJSON feature collection, then the mark’s data is
+     * *data*.features; if *data* is a GeoJSON geometry collection, then the
+     * mark’s data is *data*.geometries; if *data* is some other GeoJSON
+     * object, then the mark’s data is the single-element array [*data*].
+     */
+    mark: 'geo';
+}
+/** The sphere mark. */
+export interface Sphere extends MarkOptions {
+    /**
+     * A geo mark whose *data* is the outline of the sphere on the
+     * projection’s plane. (For use with a spherical **projection** only.)
+     */
+    mark: 'sphere';
+}
+/** The graticule mark. */
+export interface Graticule extends MarkOptions {
+    /**
+     * A geo mark whose *data* is a 10° global graticule. (For use with a
+     * spherical **projection** only.)
+     */
+    mark: 'graticule';
+}

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

@@ -0,0 +1,30 @@
+import { ParamRef } from '../Param.js';
+import { DotOptions } from './Dot.js';
+import { ChannelValue, MarkData, TextStyles } from './Marks.js';
+export interface HexbinOptions extends DotOptions, TextStyles {
+    /**
+     * The basic mark type to use for hex-binned values.
+     * Defaults to a hexagon mark; dot and text marks are also supported.
+     */
+    type?: 'dot' | 'circle' | 'hexagon' | 'text' | ParamRef;
+    /**
+     * The distance between centers of neighboring hexagons, in pixels; defaults
+     * to 20. If also using a hexgrid mark, use matching **binWidth** values.
+     */
+    binWidth?: number | ParamRef;
+    /**
+     * How to subdivide bins. If not specified, defaults to the *fill* channel,
+     * if any, or the *stroke* channel, if any. If null, bins will not be
+     * subdivided.
+     */
+    z?: ChannelValue;
+}
+/** The hexbin mark. */
+export interface Hexbin extends MarkData, HexbinOptions {
+    /**
+     * A hexbin mark that bins **x** and **y** data into a hexagonal grid and
+     * visualizes aggregate functions per bin (e.g., count for binned density).
+     * Aggregate functions can be used for fill, stroke, or r (radius) options.
+     */
+    mark: 'hexbin';
+}

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

@@ -0,0 +1,25 @@
+import { ParamRef } from '../Param.js';
+import { MarkOptions } from './Marks.js';
+/** Options for the hexgrid mark. */
+export interface HexgridOptions extends MarkOptions {
+    /**
+     * The distance between centers of neighboring hexagons, in pixels; defaults
+     * to 20. Should match the **binWidth** of the hexbin mark.
+     */
+    binWidth?: number | ParamRef;
+}
+/** The hexgrid mark. */
+export interface Hexgrid extends HexgridOptions {
+    /**
+     * The hexgrid decoration mark complements the hexbin mark, showing the
+     * outlines of all hexagons spanning the frame with a default **stroke** of
+     * *currentColor* and a default **strokeOpacity** of 0.1, similar to the
+     * default axis grids.
+     *
+     * Note that the **binWidth** option of the hexgrid mark should match that of
+     * the hexbin transform. The grid is clipped by the frame. This is a
+     * stroke-only mark, and **fill** is not supported; to fill the frame,
+     * use the frame mark.
+     */
+    mark: 'hexgrid';
+}

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

@@ -0,0 +1,89 @@
+import { ParamRef } from '../Param.js';
+import { FrameAnchor } from '../PlotTypes.js';
+import { ChannelValue, ChannelValueSpec, MarkData, MarkOptions } from './Marks.js';
+/** Options for the image mark. */
+export interface ImageOptions extends MarkOptions {
+    /**
+     * The horizontal position channel specifying the image’s center; typically
+     * bound to the *x* scale.
+     */
+    x?: ChannelValueSpec;
+    /**
+     * The vertical position channel specifying the image’s center; typically
+     * bound to the *y* scale.
+     */
+    y?: ChannelValueSpec;
+    /**
+     * The image width in pixels. When a number, it is interpreted as a constant
+     * radius in pixels; otherwise it is interpreted as a channel. Also sets the
+     * default **height**; if neither are set, defaults to 16. Images with a
+     * nonpositive width are not drawn.
+     */
+    width?: ChannelValue | ParamRef;
+    /**
+     * The image height in pixels. When a number, it is interpreted as a constant
+     * radius in pixels; otherwise it is interpreted as a channel. Also sets the
+     * default **height**; if neither are set, defaults to 16. Images with a
+     * nonpositive height are not drawn.
+     */
+    height?: ChannelValue | ParamRef;
+    /**
+     * The image clip radius, for circular images. If null (default), images are
+     * not clipped; when a number, it is interpreted as a constant in pixels;
+     * otherwise it is interpreted as a channel, typically bound to the *r* scale.
+     * Also defaults **height** and **width** to twice its value.
+     */
+    r?: ChannelValue | ParamRef;
+    /**
+     * The rotation angle, in degrees clockwise. When a number, it is interpreted
+     * as a constant; otherwise it is interpreted as a channel.
+     */
+    rotate?: ChannelValue | ParamRef;
+    /**
+     * The required image URL (or relative path). If a string that starts with a
+     * dot, slash, or URL protocol (*e.g.*, “https:”) it is assumed to be a
+     * constant; otherwise it is interpreted as a channel.
+     */
+    src?: ChannelValue | ParamRef;
+    /**
+     * The image [aspect ratio][1]; defaults to *xMidYMid meet*. To crop the image
+     * instead of scaling it to fit, use *xMidYMid slice*.
+     *
+     * [1]: https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/preserveAspectRatio
+     */
+    preserveAspectRatio?: string | ParamRef;
+    /**
+     * The [cross-origin][1] behavior. See the [Plot.image notebook][2] for details.
+     *
+     * [1]: https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/crossorigin
+     * [2]: https://observablehq.com/@observablehq/plot-image
+     */
+    crossOrigin?: string | 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.
+     */
+    frameAnchor?: FrameAnchor | ParamRef;
+    /**
+     * The [image-rendering attribute][1]; defaults to *auto* (bilinear). The
+     * option may be set to *pixelated* to disable bilinear interpolation for a
+     * sharper image; however, note that this is not supported in WebKit.
+     *
+     * [1]: https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/image-rendering
+     */
+    imageRendering?: string | ParamRef;
+}
+export interface Image extends MarkData, ImageOptions {
+    /**
+     * An image mark that draws images 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₂*, …].
+     */
+    mark: 'image';
+}