plot/test/marks/tick-test.js at 06644440628ebf982041e96d3c9f0c7df7e9582c · observablehq/plot · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
import {assert, it} from "vitest";
import * as Plot from "@observablehq/plot";

it("tickX() has the expected defaults", () => {
  const tick = Plot.tickX();
  assert.strictEqual(tick.data, undefined);
  assert.strictEqual(tick.transform, undefined);
  assert.deepStrictEqual(Object.keys(tick.channels), ["x"]);
  assert.deepStrictEqual(
    Object.values(tick.channels).map((c) => Plot.valueof([1, 2, 3], c.value)),
    [[1, 2, 3]]
  );
  assert.deepStrictEqual(
    Object.values(tick.channels).map((c) => c.scale),
    ["x"]
  );
  assert.strictEqual(tick.fill, undefined);
  assert.strictEqual(tick.fillOpacity, undefined);
  assert.strictEqual(tick.stroke, "currentColor");
  assert.strictEqual(tick.strokeWidth, undefined);
  assert.strictEqual(tick.strokeOpacity, undefined);
  assert.strictEqual(tick.strokeLinejoin, undefined);
  assert.strictEqual(tick.strokeLinecap, undefined);
  assert.strictEqual(tick.strokeMiterlimit, undefined);
  assert.strictEqual(tick.strokeDasharray, undefined);
  assert.strictEqual(tick.strokeDashoffset, undefined);
  assert.strictEqual(tick.mixBlendMode, undefined);
  assert.strictEqual(tick.shapeRendering, undefined);
});

it("tickX(data, {y}) uses a band scale", () => {
  const tick = Plot.tickX(undefined, {y: "x"});
  assert.deepStrictEqual(Object.keys(tick.channels), ["x", "y"]);
  assert.deepStrictEqual(
    Object.values(tick.channels).map((c) => c.scale),
    ["x", "y"]
  );
  assert.strictEqual(tick.channels.y.type, "band");
  assert.strictEqual(tick.channels.y.value, "x");
});

it("tickX(data, {title}) specifies an optional title channel", () => {
  const tick = Plot.tickX(undefined, {title: "x"});
  const {title} = tick.channels;
  assert.strictEqual(title.value, "x");
  assert.strictEqual(title.scale, undefined);
});

it("tickX(data, {stroke}) allows stroke to be a constant color", () => {
  const tick = Plot.tickX(undefined, {stroke: "red"});
  assert.strictEqual(tick.stroke, "red");
});

it("tickX(data, {stroke}) allows stroke to be null", () => {
  const tick = Plot.tickX(undefined, {stroke: null});
  assert.strictEqual(tick.stroke, undefined);
});

it("tickX(data, {stroke}) allows stroke to be a variable color", () => {
  const tick = Plot.tickX(undefined, {stroke: "x"});
  assert.strictEqual(tick.stroke, undefined);
  const {stroke} = tick.channels;
  assert.strictEqual(stroke.value, "x");
  assert.strictEqual(stroke.scale, "auto");
});

it("tickY() has the expected defaults", () => {
  const tick = Plot.tickY();
  assert.strictEqual(tick.data, undefined);
  assert.strictEqual(tick.transform, undefined);
  assert.deepStrictEqual(Object.keys(tick.channels), ["y"]);
  assert.deepStrictEqual(
    Object.values(tick.channels).map((c) => Plot.valueof([1, 2, 3], c.value)),
    [[1, 2, 3]]
  );
  assert.deepStrictEqual(
    Object.values(tick.channels).map((c) => c.scale),
    ["y"]
  );
  assert.strictEqual(tick.fill, undefined);
  assert.strictEqual(tick.fillOpacity, undefined);
  assert.strictEqual(tick.stroke, "currentColor");
  assert.strictEqual(tick.strokeWidth, undefined);
  assert.strictEqual(tick.strokeOpacity, undefined);
  assert.strictEqual(tick.strokeLinejoin, undefined);
  assert.strictEqual(tick.strokeLinecap, undefined);
  assert.strictEqual(tick.strokeMiterlimit, undefined);
  assert.strictEqual(tick.strokeDasharray, undefined);
  assert.strictEqual(tick.strokeDashoffset, undefined);
  assert.strictEqual(tick.mixBlendMode, undefined);
  assert.strictEqual(tick.shapeRendering, undefined);
});

it("tickY(data, {x}) uses a band scale", () => {
  const tick = Plot.tickY(undefined, {x: "y"});
  assert.deepStrictEqual(Object.keys(tick.channels), ["y", "x"]);
  assert.deepStrictEqual(
    Object.values(tick.channels).map((c) => c.scale),
    ["y", "x"]
  );
  assert.strictEqual(tick.channels.x.type, "band");
  assert.strictEqual(tick.channels.x.value, "y");
});

it("tickY(data, {title}) specifies an optional title channel", () => {
  const tick = Plot.tickY(undefined, {title: "x"});
  const {title} = tick.channels;
  assert.strictEqual(title.value, "x");
  assert.strictEqual(title.scale, undefined);
});

it("tickY(data, {stroke}) allows stroke to be a constant color", () => {
  const tick = Plot.tickY(undefined, {stroke: "red"});
  assert.strictEqual(tick.stroke, "red");
});

it("tickY(data, {stroke}) allows stroke to be null", () => {
  const tick = Plot.tickY(undefined, {stroke: null});
  assert.strictEqual(tick.stroke, undefined);
});

it("tickY(data, {stroke}) allows stroke to be a variable color", () => {
  const tick = Plot.tickY(undefined, {stroke: "x"});
  assert.strictEqual(tick.stroke, undefined);
  const {stroke} = tick.channels;
  assert.strictEqual(stroke.value, "x");
  assert.strictEqual(stroke.scale, "auto");
});