“mid” interval transform

src/marks/dot.js

@@ -1,6 +1,6 @@
 import {create} from "d3";
 import {filter, positive} from "../defined.js";
-import {maybeIntervalX, maybeIntervalY} from "../transforms/interval.js";
+import {maybeIntervalMidX, maybeIntervalMidY} from "../transforms/interval.js";
 import {Mark, identity, maybeNumber, maybeTuple} from "../mark.js";
 import {applyChannelStyles, applyDirectStyles, applyIndirectStyles, applyTransform, offset} from "../style.js";
 
@@ -53,13 +53,13 @@ export class Dot extends Mark {
 
 export function dot(data, {x, y, ...options} = {}) {
   ([x, y] = maybeTuple(x, y));
-  return new Dot(data, maybeIntervalY(maybeIntervalX({...options, x, y})));
+  return new Dot(data, maybeIntervalMidY(maybeIntervalMidX({...options, x, y})));
 }
 
 export function dotX(data, {x = identity, ...options} = {}) {
-  return new Dot(data, maybeIntervalY({...options, x}));
+  return new Dot(data, maybeIntervalMidY({...options, x}));
 }
 
 export function dotY(data, {y = identity, ...options} = {}) {
-  return new Dot(data, maybeIntervalX({...options, y}));
+  return new Dot(data, maybeIntervalMidX({...options, y}));
 }

src/marks/image.js

@@ -1,6 +1,6 @@
 import {create} from "d3";
 import {filter, positive} from "../defined.js";
-import {maybeIntervalX, maybeIntervalY} from "../transforms/interval.js";
+import {maybeIntervalMidX, maybeIntervalMidY} from "../transforms/interval.js";
 import {Mark, maybeNumber, maybeTuple, string} from "../mark.js";
 import {applyChannelStyles, applyDirectStyles, applyIndirectStyles, applyTransform, applyAttr, offset, impliedString} from "../style.js";
 
@@ -90,5 +90,5 @@ export class Image extends Mark {
 
 export function image(data, {x, y, ...options} = {}) {
   ([x, y] = maybeTuple(x, y));
-  return new Image(data, maybeIntervalY(maybeIntervalX({...options, x, y})));
+  return new Image(data, maybeIntervalMidY(maybeIntervalMidX({...options, x, y})));
 }

src/marks/text.js

@@ -2,7 +2,7 @@ import {create} from "d3";
 import {filter, nonempty} from "../defined.js";
 import {Mark, indexOf, identity, string, maybeNumber, maybeTuple, numberChannel} from "../mark.js";
 import {applyChannelStyles, applyDirectStyles, applyIndirectStyles, applyAttr, applyTransform, offset} from "../style.js";
-import {maybeIntervalX, maybeIntervalY} from "../transforms/interval.js";
+import {maybeIntervalMidX, maybeIntervalMidY} from "../transforms/interval.js";
 
 const defaults = {
   strokeLinejoin: "round"
@@ -80,15 +80,15 @@ export class Text extends Mark {
 
 export function text(data, {x, y, ...options} = {}) {
   ([x, y] = maybeTuple(x, y));
-  return new Text(data, maybeIntervalY(maybeIntervalX({...options, x, y})));
+  return new Text(data, maybeIntervalMidY(maybeIntervalMidX({...options, x, y})));
 }
 
 export function textX(data, {x = identity, ...options} = {}) {
-  return new Text(data, maybeIntervalY({...options, x}));
+  return new Text(data, maybeIntervalMidY({...options, x}));
 }
 
 export function textY(data, {y = identity, ...options} = {}) {
-  return new Text(data, maybeIntervalX({...options, y}));
+  return new Text(data, maybeIntervalMidX({...options, y}));
 }
 
 function applyIndirectTextStyles(selection, mark) {

src/transforms/interval.js

@@ -9,9 +9,19 @@ function maybeInterval(interval) {
   if (typeof interval === "number") {
     const n = interval;
     // Note: this offset doesn’t support the optional step argument for simplicity.
-    interval = {floor: d => n * Math.floor(d / n), offset: d => d + n};
+    interval = {
+      floor: d => n * Math.floor(d / n),
+      mid: d => n * (Math.floor(d / n) + 0.5),
+      offset: d => d + n
+    };
   }
   if (typeof interval.floor !== "function" || typeof interval.offset !== "function") throw new Error("invalid interval");
+  if (typeof interval.mid !== "function") {
+    interval = {
+      ...interval,
+      mid: x => (x = interval.floor(x), new Date((+x + +interval.offset(x)) / 2))
+    };
+  }
   return interval;
 }
 
@@ -27,14 +37,30 @@ function maybeIntervalK(k, maybeInsetK, options) {
   const {[k]: v, [`${k}1`]: v1, [`${k}2`]: v2} = options;
   const {value, interval} = maybeIntervalValue(v, options);
   if (value == null || interval == null) return options;
-  let V1;
-  const tv1 = data => V1 || (V1 = valueof(data, value).map(v => interval.floor(v)));
+  let D1, V1;
   const label = labelof(v);
+  function transform(data) {
+    if (V1 !== undefined && data === D1) return V1; // memoize
+    return V1 = valueof(D1 = data, value).map(v => interval.floor(v));
+  }
   return maybeInsetK({
     ...options,
-    [k]: {transform: (data) => tv1(data).map(v => mid(interval.offset(v), v)), label},
-    [`${k}1`]: v1 === undefined ? {transform: tv1, label} : v1,
-    [`${k}2`]: v2 === undefined ? {transform: (data) => tv1(data).map(v => interval.offset(v)), label} : v2
+    [k]: undefined,
+    [`${k}1`]: v1 === undefined ? {transform, label} : v1,
+    [`${k}2`]: v2 === undefined ? {transform: data => transform(data).map(v => interval.offset(v)), label} : v2
+  });
+}
+
+function maybeIntervalMidK(k, maybeInsetK, options) {
+  const {[k]: v} = options;
+  const {value, interval} = maybeIntervalValue(v, options);
+  if (value == null || interval == null) return options;
+  return maybeInsetK({
+    ...options,
+    [k]: {
+      label: labelof(v),
+      transform: data => valueof(data, value).map(interval.mid)
+    }
   });
 }
 
@@ -46,6 +72,10 @@ export function maybeIntervalY(options = {}) {
   return maybeIntervalK("y", maybeInsetY, options);
 }
 
-function mid(a, b) {
-  return a instanceof Date ? new Date((+a + +b) / 2) : (a + b) / 2;
+export function maybeIntervalMidX(options = {}) {
+  return maybeIntervalMidK("x", maybeInsetX, options);
+}
+
+export function maybeIntervalMidY(options = {}) {
+  return maybeIntervalMidK("y", maybeInsetY, options);
 }