From 3a686aee58ee3757e7ed9b6b303cd3f34237a6cb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Philippe=20Rivi=C3=A8re?= Date: Fri, 24 Mar 2023 19:14:46 +0100 Subject: [PATCH 1/4] document recct --- src/marks/rect.d.ts | 119 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 119 insertions(+) diff --git a/src/marks/rect.d.ts b/src/marks/rect.d.ts index 9cd4a2099d..0ea7840247 100644 --- a/src/marks/rect.d.ts +++ b/src/marks/rect.d.ts @@ -4,30 +4,149 @@ import type {Interval} from "../interval.js"; import type {Data, MarkOptions, RenderableMark} from "../mark.js"; import type {StackOptions} from "../transforms/stack.js"; +/** Options for the rect mark. */ export interface RectOptions extends MarkOptions, InsetOptions, StackOptions { + /** + * A {value, interval} channel defining derived **x1** and **x2** channels; + * for example, to make timestamps extend from the start to the end of the + * day: + * + * ```js + * Plot.rect(sales, {x: {value: "date", interval: "day"}, y1: 0, y2: "items"}) + * ``` + */ x?: ChannelValueIntervalSpec; + + /** + * The **x1** channel or constant describes the left edge of the rect. Note + * that if x2 < x1 the positions are swapped, so that the rect is always + * defined. + */ x1?: ChannelValueSpec; + + /** + * The **x2** channel or constant describes the right edge of the rect. + */ x2?: ChannelValueSpec; + + /** + * A {value, interval} channel defining derived **y1** and **y2** channels; + * for example, to represent values as bars of height 1 rounded to the closest + * integer: + * + * ```js + * Plot.rect(sales, {x: "date", y: {value: "items", interval: 1}}) + * ``` + */ y?: ChannelValueIntervalSpec; + + /** + * The **y1** channel or constant describes the bottom edge of the rect. Note + * that if y2 < y1 the positions are swapped, so that the rect is always + * defined. + */ y1?: ChannelValueSpec; + + /** + * The **y2** channel or constant describes the top edge of the rect. + */ y2?: ChannelValueSpec; + + /** + * An interval used to derive the **x1** and **x2** channels from **x**, and + * the **y1** and **y2** channels from **y**. If both **x** and **y** are + * defined this way, and you want a different interval on each axis, use the + * {value, interval} channel syntax. + * + * For example, to display a continuous checkerboard pattern: + * + * ```js + * Plot.rect(d3.cross("12345678", "12345678"), { + * x: ([i, j]) => i, + * y: ([i, j]) => j, + * interval: 1, + * fill: ([i, j]) => i % 2 ^ j % 2 + * }) + * ``` + */ interval?: Interval; + + /** + * The [*x* + * radius](https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/rx) for + * rounded corners. + */ rx?: number | string; + + /** + * The [*y* + * radius](https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/ry) for + * rounded corners. + */ ry?: number | string; } +/** Options for the rectX mark. */ export interface RectXOptions extends RectOptions { x?: ChannelValueSpec; // disallow x interval } +/** Options for the rectY mark. */ export interface RectYOptions extends RectOptions { y?: ChannelValueSpec; // disallow y interval } +/** + * Returns a rect mark for the given *data* and *options*. The shape extends + * horizontally from **x1** to **x2**, and vertically from **y1** to **y2**. The + * position channels can be specified directly, but they are often derived with + * a transform, or with an interval. For example, to create a heatmap of + * athletes, binned by weight and height: + * + * ```js + * Plot.rect(athletes, Plot.bin({fill: "proportion"}, {x: "weight", y: "height"})) + * ``` + * + * When a dimension extends from zero, for example for a histogram where the + * height of each bin reflects a count of values, prefer the rectY mark, which + * includes a stack transform; similarly, prefer the rectX mark if the width + * extends from zero. + */ export function rect(data?: Data, options?: RectOptions): Rect; +/** + * Like rect, but if neither the **x1** nor **x2** option is specified, the + * **x** option may be specified as shorthand to apply an implicit **stackX** + * transform; this is the typical configuration for a histogram with rects + * aligned at *x* = 0. + * + * For example, to create a vertical histogram of athletes by height: + * + * ```js + * Plot.rectX(olympians, Plot.binY({ x: "count" }, { y: "height" })) + * ``` + * + * If the **x** option is not specified, it defaults to the identity function, + * assuming that *data* is an array of numbers [*x₀*, *x₁*, *x₂*, …]. + */ export function rectX(data?: Data, options?: RectXOptions): Rect; +/** + * Like rect, but if neither the **y1** nor **y2** option is specified, the + * **y** option may be specified as shorthand to apply an implicit **stackY** + * transform; this is the typical configuration for a histogram with rects + * aligned at *y* = 0. + * + * For example, to create a horizontal histogram of athletes by weight: + * + * ```js + * Plot.rectY(olympians, Plot.binX({ y: "count" }, { x: "weight" })) + * ``` + * + * If the **y** option is not specified, it defaults to the identity function, + * assuming that *data* is an array of numbers [*y₀*, *y₁*, *y₂*, …]. + */ export function rectY(data?: Data, options?: RectYOptions): Rect; +/** The rect mark. */ export class Rect extends RenderableMark {} From f7b948487ee0e95fad7fa5bb45b78a7e7d840d8f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Philippe=20Rivi=C3=A8re?= Date: Mon, 27 Mar 2023 12:27:30 +0200 Subject: [PATCH 2/4] link style --- src/marks/rect.d.ts | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/src/marks/rect.d.ts b/src/marks/rect.d.ts index 0ea7840247..5e39a60042 100644 --- a/src/marks/rect.d.ts +++ b/src/marks/rect.d.ts @@ -72,18 +72,17 @@ export interface RectOptions extends MarkOptions, InsetOptions, StackOptions { interval?: Interval; /** - * The [*x* - * radius](https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/rx) for - * rounded corners. + * The [*x* radius][1] for rounded corners. + * + * [1]: https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/rx */ rx?: number | string; /** - * The [*y* - * radius](https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/ry) for - * rounded corners. + * The [*y* radius][1] for rounded corners. + * + * [1]: https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/ry */ - ry?: number | string; } /** Options for the rectX mark. */ From c713c3c2a5caadc9153088cd0b87094501efce9c Mon Sep 17 00:00:00 2001 From: Mike Bostock Date: Thu, 30 Mar 2023 11:03:13 -0700 Subject: [PATCH 3/4] edits --- src/marks/area.d.ts | 28 ++++++++++++------------- src/marks/bar.d.ts | 40 ++++++++++++++++++++++------------- src/marks/rect.d.ts | 51 +++++++++++++++++++++++++++------------------ src/marks/rule.d.ts | 16 +++++++------- 4 files changed, 78 insertions(+), 57 deletions(-) diff --git a/src/marks/area.d.ts b/src/marks/area.d.ts index c457913ebd..28ec52f4fb 100644 --- a/src/marks/area.d.ts +++ b/src/marks/area.d.ts @@ -7,32 +7,32 @@ import type {StackOptions} from "../transforms/stack.js"; /** Options for the area, areaX, and areaY marks. */ export interface AreaOptions extends MarkOptions, StackOptions, CurveOptions { /** - * The required primary horizontal position channel, representing the area’s - * baseline, typically bound to the *x* scale. For areaX, setting this option - * disables the implicit stackX transform. + * The required primary (starting, often left) horizontal position channel, + * representing the area’s baseline, typically bound to the *x* scale. For + * areaX, setting this option disables the implicit stackX transform. */ x1?: ChannelValueSpec; /** - * The optional secondary horizontal position channel, representing the area’s - * topline, typically bound to the *x* scale; if not specified, **x1** is - * used. For areaX, setting this option disables the implicit stackX - * transform. + * The optional secondary (ending, often right) horizontal position channel, + * representing the area’s topline, typically bound to the *x* scale; if not + * specified, **x1** is used. For areaX, setting this option disables the + * implicit stackX transform. */ x2?: ChannelValueSpec; /** - * The required primary vertical position channel, representing the area’s - * baseline, typically bound to the *y* scale. For areaY, setting this option - * disables the implicit stackY transform. + * The required primary (starting, often bottom) vertical position channel, + * representing the area’s baseline, typically bound to the *y* scale. For + * areaY, setting this option disables the implicit stackY transform. */ y1?: ChannelValueSpec; /** - * The optional secondary vertical position channel, representing the area’s - * topline, typically bound to the *y* scale; if not specified, **y1** is - * used. For areaY, setting this option disables the implicit stackY - * transform. + * The optional secondary (ending, often top) vertical position channel, + * representing the area’s topline, typically bound to the *y* scale; if not + * specified, **y1** is used. For areaY, setting this option disables the + * implicit stackY transform. */ y2?: ChannelValueSpec; diff --git a/src/marks/bar.d.ts b/src/marks/bar.d.ts index 60b2a727be..f6a6fbbaf4 100644 --- a/src/marks/bar.d.ts +++ b/src/marks/bar.d.ts @@ -41,7 +41,7 @@ interface BarOptions extends MarkOptions, InsetOptions, StackOptions { * Plot.barY(alphabet, {x: "letter", y: "frequency", interval: 0.01}) * ``` * - * Setting this option disables the implicit stack transform (stackX or barX, + * Setting this option disables the implicit stack transform (stackX for barX, * or stackY for barY). */ interval?: Interval; @@ -64,16 +64,20 @@ export interface BarXOptions extends BarOptions { x?: ChannelValueIntervalSpec; /** - * The required primary (starting) horizontal position channel, typically - * bound to the *x* scale. Setting this option disables the implicit stackX - * transform. + * 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) horizontal position channel, typically - * bound to the *x* scale. Setting this option disables the implicit stackX - * transform. + * 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; @@ -105,16 +109,20 @@ export interface BarYOptions extends BarOptions { y?: ChannelValueIntervalSpec; /** - * The required primary (starting) vertical position channel, typically bound - * to the *y* scale. Setting this option disables the implicit stackY - * transform. + * 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) horizontal position channel, typically - * bound to the *y* scale. Setting this option disables the implicit stackY - * transform. + * 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; @@ -158,7 +166,8 @@ export interface BarYOptions extends BarOptions { * ``` * * If *y* is quantitative, use the rectX mark instead, possibly with a binY - * transform. + * transform. If *x* is ordinal, use the cell mark instead, possibly with a + * group transform. * * If *options* is undefined, then **y** defaults to the zero-based index of * *data* [0, 1, 2, …], allowing a quick bar chart from an array of numbers: @@ -196,7 +205,8 @@ export function barX(data?: Data, options?: BarXOptions): BarX; * ``` * * If *x* is quantitative, use the rectY mark instead, possibly with a binX - * transform. + * transform. If *y* is ordinal, use the cell mark instead, possibly with a + * group transform. * * If *options* is undefined, then **x** defaults to the zero-based index of * *data* [0, 1, 2, …], allowing a quick bar chart from an array of numbers: diff --git a/src/marks/rect.d.ts b/src/marks/rect.d.ts index 5e39a60042..c74fec164e 100644 --- a/src/marks/rect.d.ts +++ b/src/marks/rect.d.ts @@ -18,14 +18,20 @@ export interface RectOptions extends MarkOptions, InsetOptions, StackOptions { x?: ChannelValueIntervalSpec; /** - * The **x1** channel or constant describes the left edge of the rect. Note - * that if x2 < x1 the positions are swapped, so that the rect is always - * defined. + * The required primary (starting, often left) horizontal position channel, + * typically bound to the *x* scale. Setting this option disables the rectX + * mark’s implicit stackX transform. + * + * If *x* represents ordinal values, use a bar or cell mark instead. */ x1?: ChannelValueSpec; /** - * The **x2** channel or constant describes the right edge of the rect. + * The required secondary (ending, often right) horizontal position channel, + * typically bound to the *x* scale. Setting this option disables the rectX + * mark’s implicit stackX transform. + * + * If *x* represents ordinal values, use a bar or cell mark instead. */ x2?: ChannelValueSpec; @@ -41,9 +47,7 @@ export interface RectOptions extends MarkOptions, InsetOptions, StackOptions { y?: ChannelValueIntervalSpec; /** - * The **y1** channel or constant describes the bottom edge of the rect. Note - * that if y2 < y1 the positions are swapped, so that the rect is always - * defined. + * The **y1** channel or constant describes the bottom edge of the rect. */ y1?: ChannelValueSpec; @@ -53,36 +57,43 @@ export interface RectOptions extends MarkOptions, InsetOptions, StackOptions { y2?: ChannelValueSpec; /** - * An interval used to derive the **x1** and **x2** channels from **x**, and - * the **y1** and **y2** channels from **y**. If both **x** and **y** are - * defined this way, and you want a different interval on each axis, use the - * {value, interval} channel syntax. + * How to convert a continuous value (**x** for rectY, **y** for rectX, or + * both for rect) into an interval (**x1** and **x2** for rectY, or **y1** and + * **y2** for rectX, or both for rect); one of: * - * For example, to display a continuous checkerboard pattern: + * - an object that implements *floor*, *offset*, and *range* methods + * - a named time interval such as *day* (for date intervals) + * - a number (for number intervals), defining intervals at integer multiples of *n* + * + * For example, for a scatterplot of penguin culmen length *vs.* depth, using + * rects of half-millimeter width and height: * * ```js - * Plot.rect(d3.cross("12345678", "12345678"), { - * x: ([i, j]) => i, - * y: ([i, j]) => j, - * interval: 1, - * fill: ([i, j]) => i % 2 ^ j % 2 - * }) + * Plot.rect(penguins, {x: "culmen_length_mm", y: "culmen_depth_mm", interval: 0.5}) * ``` + * + * Setting this option disables the implicit stack transform (stackX for rectX, + * or stackY for rectY). */ interval?: Interval; /** - * The [*x* radius][1] for rounded corners. + * The rounded corner [*x*-radius][1], either in pixels or as a percentage of + * the bar width. If **rx** is not specified, it defaults to **ry** if + * present, and otherwise draws square corners. * * [1]: https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/rx */ rx?: number | string; /** - * The [*y* radius][1] for rounded corners. + * The rounded corner [*y*-radius][1], either in pixels or as a percentage of + * the bar height. If **ry** is not specified, it defaults to **rx** if + * present, and otherwise draws square corners. * * [1]: https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/ry */ + ry?: number | string; } /** Options for the rectX mark. */ diff --git a/src/marks/rule.d.ts b/src/marks/rule.d.ts index 0eb7d4e33f..3b9fcc41dc 100644 --- a/src/marks/rule.d.ts +++ b/src/marks/rule.d.ts @@ -41,16 +41,16 @@ export interface RuleXOptions extends RuleOptions, Omit Date: Thu, 30 Mar 2023 12:28:46 -0700 Subject: [PATCH 4/4] more edits --- src/marks/bar.d.ts | 10 ++-- src/marks/rect.d.ts | 110 +++++++++++++++++++++++++++++--------------- src/marks/tick.d.ts | 15 +++--- 3 files changed, 85 insertions(+), 50 deletions(-) diff --git a/src/marks/bar.d.ts b/src/marks/bar.d.ts index f6a6fbbaf4..9796ac483a 100644 --- a/src/marks/bar.d.ts +++ b/src/marks/bar.d.ts @@ -140,8 +140,9 @@ export interface BarYOptions extends BarOptions { /** * Returns a new horizontal bar mark for the given *data* and *options*; the - * required *x* values must be quantitative, and the optional *y* values must be - * ordinal. For example, for a horizontal bar chart of English letter frequency: + * required *x* values should be quantitative or temporal, and the optional *y* + * values should be ordinal. For example, for a horizontal bar chart of English + * letter frequency: * * ```js * Plot.barX(alphabet, {x: "frequency", y: "letter"}) @@ -180,8 +181,9 @@ export function barX(data?: Data, options?: BarXOptions): BarX; /** * Returns a new vertical bar mark for the given *data* and *options*; the - * required *y* values must be quantitative, and the optional *x* values must be - * ordinal. For example, for a vertical bar chart of English letter frequency: + * required *y* values should be quantitative or temporal, and the optional *x* + * values should be ordinal. For example, for a vertical bar chart of English + * letter frequency: * * ```js * Plot.barY(alphabet, {y: "frequency", x: "letter"}) diff --git a/src/marks/rect.d.ts b/src/marks/rect.d.ts index c74fec164e..f063755eeb 100644 --- a/src/marks/rect.d.ts +++ b/src/marks/rect.d.ts @@ -7,13 +7,18 @@ import type {StackOptions} from "../transforms/stack.js"; /** Options for the rect mark. */ export interface RectOptions extends MarkOptions, InsetOptions, StackOptions { /** - * A {value, interval} channel defining derived **x1** and **x2** channels; - * for example, to make timestamps extend from the start to the end of the - * day: + * The horizontal position (or length/width) channel, typically bound to the + * *x* scale. + * + * If an **interval** is specified, then **x1** and **x2** are derived from + * **x**, representing the lower and upper bound of the containing interval, + * respectively. For example, for a vertical bar chart of items sold by day: * * ```js - * Plot.rect(sales, {x: {value: "date", interval: "day"}, y1: 0, y2: "items"}) + * Plot.rectY(sales, {x: "date", interval: "day", y2: "items"}) * ``` + * + * If *x* represents ordinal values, use a bar or cell mark instead. */ x?: ChannelValueIntervalSpec; @@ -36,23 +41,36 @@ export interface RectOptions extends MarkOptions, InsetOptions, StackOptions { x2?: ChannelValueSpec; /** - * A {value, interval} channel defining derived **y1** and **y2** channels; - * for example, to represent values as bars of height 1 rounded to the closest - * integer: + * The vertical position (or length/height) channel, typically bound to the + * *y* scale. + * + * If an **interval** is specified, then **y1** and **y2** are derived from + * **y**, representing the lower and upper bound of the containing interval, + * respectively. For example, for a horizontal bar chart of items sold by day: * * ```js - * Plot.rect(sales, {x: "date", y: {value: "items", interval: 1}}) + * Plot.rectX(sales, {y: "date", interval: "day", x2: "items"}) * ``` + * + * If *y* represents ordinal values, use a bar or cell mark instead. */ y?: ChannelValueIntervalSpec; /** - * The **y1** channel or constant describes the bottom edge of the rect. + * The required primary (starting, often bottom) vertical position channel, + * typically bound to the *y* scale. Setting this option disables the rectY + * mark’s implicit stackY transform. + * + * If *y* represents ordinal values, use a bar or cell mark instead. */ y1?: ChannelValueSpec; /** - * The **y2** channel or constant describes the top edge of the rect. + * The required secondary (ending, often top) vertical position channel, + * typically bound to the *y* scale. Setting this option disables the rectY + * mark’s implicit stackY transform. + * + * If *y* represents ordinal values, use a bar or cell mark instead. */ y2?: ChannelValueSpec; @@ -98,63 +116,79 @@ export interface RectOptions extends MarkOptions, InsetOptions, StackOptions { /** Options for the rectX mark. */ export interface RectXOptions extends RectOptions { + /** + * The horizontal position (or length/width) channel, typically bound to the + * *x* scale. + * + * If neither **x1** nor **x2** is specified, an implicit stackX transform is + * applied and **x** defaults to the identity function, assuming that *data* = + * [*x₀*, *x₁*, *x₂*, …]. Otherwise, if only one of **x1** or **x2** is + * specified, the other defaults to **x**, which defaults to zero. + */ x?: ChannelValueSpec; // disallow x interval } /** Options for the rectY mark. */ export interface RectYOptions extends RectOptions { + /** + * The vertical position (or length/height) channel, typically bound to the + * *y* scale. + * + * If neither **y1** nor **y2** is specified, an implicit stackY transform is + * applied and **y** defaults to the identity function, assuming that *data* = + * [*y₀*, *y₁*, *y₂*, …]. Otherwise, if only one of **y1** or **y2** is + * specified, the other defaults to **y**, which defaults to zero. + */ y?: ChannelValueSpec; // disallow y interval } /** - * Returns a rect mark for the given *data* and *options*. The shape extends + * Returns a rect mark for the given *data* and *options*. The rectangle extends * horizontally from **x1** to **x2**, and vertically from **y1** to **y2**. The - * position channels can be specified directly, but they are often derived with - * a transform, or with an interval. For example, to create a heatmap of - * athletes, binned by weight and height: + * position channels are often derived with a transform. For example, to create + * a heatmap of athletes, binned by weight and height: * * ```js * Plot.rect(athletes, Plot.bin({fill: "proportion"}, {x: "weight", y: "height"})) * ``` * - * When a dimension extends from zero, for example for a histogram where the - * height of each bin reflects a count of values, prefer the rectY mark, which - * includes a stack transform; similarly, prefer the rectX mark if the width - * extends from zero. + * When **y** extends from zero, for example for a histogram where the height of + * each rect reflects a count of values, use the rectY mark for an implicit + * stackY transform; similarly, if **x** extends from zero, use the rectX mark + * for an implicit stackX transform. + * + * If an **interval** is specified, then **x1** and **x2** are derived from + * **x**, and **y1** and **y2** are derived from **y**, each representing the + * lower and upper bound of the containing interval, respectively. + * + * Both *x* and *y* should be quantitative or temporal; otherwise, use a bar or + * cell mark. */ export function rect(data?: Data, options?: RectOptions): Rect; /** - * Like rect, but if neither the **x1** nor **x2** option is specified, the - * **x** option may be specified as shorthand to apply an implicit **stackX** - * transform; this is the typical configuration for a histogram with rects - * aligned at *x* = 0. - * - * For example, to create a vertical histogram of athletes by height: + * Like rect, but if neither **x1** nor **x2** is specified, an implicit stackX + * transform is applied to **x**, and if **x** is not specified, it defaults to + * the identity function, assuming that *data* is an array of numbers [*x₀*, + * *x₁*, *x₂*, …]. For example, for a vertical histogram of athletes by height + * with rects aligned at *x* = 0: * * ```js - * Plot.rectX(olympians, Plot.binY({ x: "count" }, { y: "height" })) + * Plot.rectX(olympians, Plot.binY({x: "count"}, {y: "height"})) * ``` - * - * If the **x** option is not specified, it defaults to the identity function, - * assuming that *data* is an array of numbers [*x₀*, *x₁*, *x₂*, …]. */ export function rectX(data?: Data, options?: RectXOptions): Rect; /** - * Like rect, but if neither the **y1** nor **y2** option is specified, the - * **y** option may be specified as shorthand to apply an implicit **stackY** - * transform; this is the typical configuration for a histogram with rects - * aligned at *y* = 0. - * - * For example, to create a horizontal histogram of athletes by weight: + * Like rect, but if neither **y1** nor **y2** is specified, apply an implicit + * stackY transform is applied to **y**, and if **y** is not specified, it + * defaults to the identity function, assuming that *data* is an array of + * numbers [*y₀*, *y₁*, *y₂*, …]. For example, for a horizontal histogram of + * athletes by weight with rects aligned at *y* = 0: * * ```js - * Plot.rectY(olympians, Plot.binX({ y: "count" }, { x: "weight" })) + * Plot.rectY(olympians, Plot.binX({y: "count"}, {x: "weight"})) * ``` - * - * If the **y** option is not specified, it defaults to the identity function, - * assuming that *data* is an array of numbers [*y₀*, *y₁*, *y₂*, …]. */ export function rectY(data?: Data, options?: RectYOptions): Rect; diff --git a/src/marks/tick.d.ts b/src/marks/tick.d.ts index 4c6ceccb69..8536b3cab0 100644 --- a/src/marks/tick.d.ts +++ b/src/marks/tick.d.ts @@ -11,7 +11,7 @@ export interface TickXOptions extends MarkOptions, Omit