ggaction 0.0.4 → 0.0.5

package/src/actions/guides/applicability.js

@@ -7,9 +7,21 @@ import {
   POLAR_POSITION_CHANNELS
 } from "../../core/vocabulary.js";
 import { findSemanticScale } from "../../selectors/scales.js";
+import { findDataset } from "../../selectors/datasets.js";
+import { findUpstreamTransform } from
+  "../../materialization/dataProvenance.js";
+
+function isHorizonLayer(program, layer) {
+  return findUpstreamTransform(
+    program,
+    findDataset(program, layer.data),
+    "horizon"
+  ) !== undefined;
+}
 
 function hasEncoding(program, channel, { scaled = false, grid = false } = {}) {
   return program.semanticSpec.layers.some(layer => {
+    if (isHorizonLayer(program, layer) && channel !== "x") return false;
     const encoding = layer.encoding?.[channel];
     if (!scaled && !grid) return encoding !== undefined;
     if (encoding?.scale === undefined) return false;
@@ -33,22 +45,24 @@ function positionalApplicability(program, channels) {
 
 export function hasInferableLegend(program) {
   return program.semanticSpec.layers.some(layer =>
-    (layer.mark?.type === "point" &&
-      layer.encoding?.opacity?.scale !== undefined) ||
-    (layer.mark?.type === "point" &&
-      layer.encoding?.size?.scale !== undefined) ||
-    (layer.mark?.type === "point" &&
-      layer.encoding?.color?.scale !== undefined &&
-      (layer.encoding?.shape?.scale !== undefined ||
-        ["sequential", "quantize", "quantile", "threshold"].includes(
-          findSemanticScale(program, layer.encoding.color.scale)?.type
-        ))) ||
-    (layer.mark?.type === "line" &&
-      ["color", "strokeDash"].some(
-        channel => layer.encoding?.[channel]?.scale !== undefined
-      )) ||
-    (["bar", "area", "arc", "rect"].includes(layer.mark?.type) &&
-      layer.encoding?.color?.scale !== undefined)
+    !isHorizonLayer(program, layer) && (
+      (layer.mark?.type === "point" &&
+        layer.encoding?.opacity?.scale !== undefined) ||
+      (layer.mark?.type === "point" &&
+        layer.encoding?.size?.scale !== undefined) ||
+      (layer.mark?.type === "point" &&
+        layer.encoding?.color?.scale !== undefined &&
+        (layer.encoding?.shape?.scale !== undefined ||
+          ["sequential", "quantize", "quantile", "threshold"].includes(
+            findSemanticScale(program, layer.encoding.color.scale)?.type
+          ))) ||
+      (layer.mark?.type === "line" &&
+        ["color", "strokeDash"].some(
+          channel => layer.encoding?.[channel]?.scale !== undefined
+        )) ||
+      (["bar", "area", "arc", "rect"].includes(layer.mark?.type) &&
+        layer.encoding?.color?.scale !== undefined)
+    )
   );
 }
 
@@ -58,12 +72,22 @@ export function resolveGuideApplicability(program) {
     CARTESIAN_POSITION_CHANNELS
   );
   const polar = positionalApplicability(program, POLAR_POSITION_CHANNELS);
+  const parallel = program.semanticSpec.layers.some(layer =>
+    layer.encoding?.parallel?.dimensions?.length >= 2
+  );
   return Object.freeze({
     axes: Object.freeze({
       cartesian: CARTESIAN_POSITION_CHANNELS.some(
         channel => cartesian[channel].axis
       ),
-      polar: POLAR_POSITION_CHANNELS.some(channel => polar[channel].axis)
+      polar: POLAR_POSITION_CHANNELS.some(channel => polar[channel].axis),
+      parallel,
+      directions: Object.freeze({
+        x: cartesian.x.axis,
+        y: cartesian.y.axis,
+        theta: polar.theta.axis,
+        radius: polar.radius.axis
+      })
     }),
     grid: Object.freeze({
       cartesian: CARTESIAN_POSITION_CHANNELS.some(
@@ -90,6 +114,9 @@ export function resolveAutomaticGridOptions(program) {
       ...(directions.radial ? { radial: {} } : {})
     });
   }
+  if (directions.vertical && !directions.horizontal) {
+    return Object.freeze({ horizontal: false, vertical: {} });
+  }
 
   const barOrientations = program.semanticSpec.layers
     .map(resolveBarOrientation)

package/src/actions/guides/axes/axes.js

@@ -9,7 +9,9 @@ const TOP_OPTIONS = Object.freeze([
   "coordinate", "x", "y", "theta", "radius"
 ]);
 const COORDINATE_OPTIONS = Object.freeze(["id", "type"]);
-const COORDINATE_API_TYPES = new Set(["auto", "cartesian", "polar"]);
+const COORDINATE_API_TYPES = new Set([
+  "auto", "cartesian", "polar", "parallel"
+]);
 
 function validateAxisOption(value, channel) {
   if (value !== undefined && value !== false && !isPlainObject(value)) {
@@ -47,6 +49,9 @@ function inspectChannels(layers) {
     layer =>
       layer.encoding?.theta !== undefined || layer.encoding?.radius !== undefined
   );
+  const parallelLayers = layers.filter(
+    layer => layer.encoding?.parallel !== undefined
+  );
   const hasMixedLayer = layers.some(layer => {
     const hasCartesian =
       layer.encoding?.x !== undefined || layer.encoding?.y !== undefined;
@@ -61,7 +66,7 @@ function inspectChannels(layers) {
     );
   }
 
-  return { cartesianLayers, polarLayers };
+  return { cartesianLayers, polarLayers, parallelLayers };
 }
 
 function resolveCoordinate(program, descriptor, cartesianLayers) {
@@ -185,7 +190,7 @@ const createAxes = action(
   },
   function (args = {}) {
     const coordinateDescriptor = validateArgs(args);
-    const { cartesianLayers, polarLayers } = inspectChannels(
+    const { cartesianLayers, polarLayers, parallelLayers } = inspectChannels(
       this.semanticSpec.layers
     );
     const requestedCoordinateType = coordinateDescriptor.id === undefined
@@ -194,6 +199,35 @@ const createAxes = action(
     const explicitlyPolar = coordinateDescriptor.type === "polar" ||
       requestedCoordinateType === "polar" ||
       args.theta !== undefined || args.radius !== undefined;
+    const explicitlyParallel = coordinateDescriptor.type === "parallel" ||
+      requestedCoordinateType === "parallel";
+    if (parallelLayers.length > 0 && (
+      (cartesianLayers.length === 0 && polarLayers.length === 0) ||
+      explicitlyParallel
+    )) {
+      if (
+        args.x !== undefined || args.y !== undefined ||
+        args.theta !== undefined || args.radius !== undefined
+      ) {
+        throw new Error(
+          "createAxes channel options are not supported for Parallel axes."
+        );
+      }
+      const candidates = coordinateDescriptor.id === undefined
+        ? parallelLayers
+        : parallelLayers.filter(layer =>
+            layer.coordinate === coordinateDescriptor.id
+          );
+      if (candidates.length !== 1) {
+        throw new Error(
+          "createAxes requires coordinate.id when one Parallel layer cannot be inferred."
+        );
+      }
+      return this.createParallelAxes({
+        target: candidates[0].id,
+        coordinate: candidates[0].coordinate
+      });
+    }
     if (polarLayers.length > 0 &&
         (cartesianLayers.length === 0 || explicitlyPolar)) {
       if (coordinateDescriptor.type === "cartesian") {

package/src/actions/guides/axes/index.js

@@ -12,6 +12,7 @@ import {
   removeXAxis,
   removeYAxis
 } from "./remove.js";
+import { registerParallelAxisActions } from "./parallel.js";
 
 export function registerGuideAxisActions(ProgramClass) {
   registerAxisLineActions(ProgramClass);
@@ -22,6 +23,7 @@ export function registerGuideAxisActions(ProgramClass) {
   registerAxisActions(ProgramClass);
   registerAxisCollectionActions(ProgramClass);
   registerCompleteAxisEditActions(ProgramClass);
+  registerParallelAxisActions(ProgramClass);
   ProgramClass.prototype.removeXAxis = removeXAxis;
   ProgramClass.prototype.removeYAxis = removeYAxis;
   ProgramClass.prototype.removeThetaAxis = removeThetaAxis;

package/src/actions/guides/axes/labels.js

@@ -27,6 +27,7 @@ import {
 } from "./policy.js";
 import { findCanvasGraphic, resolvePlotGraphicPlacement } from
   "../../../materialization/graphicHierarchy.js";
+import { resolveTextBounds } from "../../../core/textMetrics.js";
 
 const OPTIONS = Object.freeze([
   "scale", "position", "count", "values", "offset", "format", "color",
@@ -122,14 +123,18 @@ function resolve(program, channel, config) {
     })
   };
   const canvas = findCanvasGraphic(program)?.properties;
-  const maximumTextWidth = Math.max(
-    0,
-    ...text.map(value => [...value].length * config.fontSize * 0.6)
-  );
+  const labelBounds = text.map((value, index) => resolveTextBounds({
+    x: Array.isArray(resolved.x) ? resolved.x[index] : resolved.x,
+    y: Array.isArray(resolved.y) ? resolved.y[index] : resolved.y,
+    text: value,
+    fontSize: config.fontSize,
+    textAlign: resolved.textAlign,
+    textBaseline: resolved.textBaseline
+  }));
   const fits = config.position === "top"
-    ? resolved.y - config.fontSize >= 0
+    ? labelBounds.every(item => item.top >= 0)
     : config.position === "right"
-      ? resolved.x + maximumTextWidth <= canvas?.width
+      ? labelBounds.every(item => item.right <= canvas?.width)
       : true;
   if (!canvas || !fits) {
     throw new Error(`The ${channel}-axis labels do not fit the Canvas margin.`);

package/src/actions/guides/axes/parallel/resolve.js

@@ -0,0 +1,86 @@
+import { validateUserId } from "../../../../core/identifiers.js";
+import {
+  isTransformedScaleType,
+  mapContinuousScaleValues,
+  mapOrdinalPositionValues,
+  transformedTicks
+} from "../../../../grammar/scales/index.js";
+import { niceTicks } from "../../../../grammar/ticks.js";
+import { resolveGraphicBounds } from "../../../../layout/canvas.js";
+import { findCoordinate } from "../../../../selectors/coordinates.js";
+import { findLayer } from "../../../../selectors/layers.js";
+
+export function requireParallelAxisLayer(program, target) {
+  const layer = findLayer(program, target);
+  const coordinate = layer === undefined
+    ? undefined
+    : findCoordinate(program, layer.coordinate);
+  if (
+    layer?.mark?.type !== "line" ||
+    coordinate?.type !== "parallel" ||
+    layer.encoding?.parallel?.dimensions?.length < 2
+  ) {
+    throw new Error(`Parallel axes require an encoded Parallel line "${target}".`);
+  }
+  return { coordinate, dimensions: layer.encoding.parallel.dimensions, layer };
+}
+
+export function resolveParallelAxisTarget(program, requested) {
+  if (requested !== undefined) {
+    const target = validateUserId(requested, "Parallel axes target");
+    requireParallelAxisLayer(program, target);
+    return target;
+  }
+  const candidates = program.semanticSpec.layers.filter(layer => {
+    const coordinate = findCoordinate(program, layer.coordinate);
+    return layer.encoding?.parallel !== undefined && coordinate?.type === "parallel";
+  });
+  if (candidates.length !== 1) {
+    throw new Error(
+      "Parallel axes require target when one Parallel layer cannot be inferred."
+    );
+  }
+  return candidates[0].id;
+}
+
+function ticksForScale(scale) {
+  if (["ordinal", "band", "point"].includes(scale.type)) return scale.domain;
+  if (isTransformedScaleType(scale.type)) {
+    return transformedTicks(scale.type, scale.domain, 5, {
+      ...(scale.base === undefined ? {} : { base: scale.base }),
+      ...(scale.exponent === undefined ? {} : { exponent: scale.exponent }),
+      ...(scale.constant === undefined ? {} : { constant: scale.constant })
+    });
+  }
+  return niceTicks(scale.domain, 5);
+}
+
+function formatValue(value) {
+  if (Number.isFinite(value) && Math.abs(value) >= 1000 && value % 1000 === 0) {
+    return `${value / 1000}k`;
+  }
+  return String(value);
+}
+
+export function resolveParallelAxisValues(program, dimensions) {
+  const bounds = resolveGraphicBounds(program);
+  const step = bounds.width / (dimensions.length - 1);
+  const axes = dimensions.map((dimension, index) => {
+    const scale = program.resolvedScales[dimension.scale];
+    if (scale === undefined) {
+      throw new Error(`Parallel axis requires resolved scale "${dimension.scale}".`);
+    }
+    const values = ticksForScale(scale);
+    const y = ["ordinal", "band", "point"].includes(scale.type)
+      ? mapOrdinalPositionValues(values, scale)
+      : mapContinuousScaleValues(values, scale);
+    return {
+      ...dimension,
+      x: bounds.x + step * index,
+      values,
+      y,
+      labels: values.map(formatValue)
+    };
+  });
+  return { axes, bounds };
+}

package/src/actions/guides/axes/parallel.js

@@ -0,0 +1,228 @@
+import { action } from "../../../core/action.js";
+import { validateOptionObject } from "../../../core/validation.js";
+import { resolvePlotGraphicPlacement } from
+  "../../../materialization/graphicHierarchy.js";
+import { DEFAULT_COLORS, DEFAULT_FONT_FAMILY } from
+  "../../../theme/defaults.js";
+import {
+  requireParallelAxisLayer,
+  resolveParallelAxisTarget,
+  resolveParallelAxisValues
+} from "./parallel/resolve.js";
+
+const CREATE_OPTIONS = Object.freeze(["target", "coordinate"]);
+const REMATERIALIZE_OPTIONS = Object.freeze(["target"]);
+
+export const rematerializeParallelAxes = action(
+  {
+    op: "rematerializeParallelAxes",
+    description: "Recompute concrete Parallel dimension axes."
+  },
+  function (args = {}) {
+    validateOptionObject(
+      args,
+      REMATERIALIZE_OPTIONS,
+      "rematerializeParallelAxes"
+    );
+    const target = resolveParallelAxisTarget(
+      this,
+      args.target ?? this.guideConfigs.axis?.parallel?.axes?.target
+    );
+    const { dimensions } = requireParallelAxisLayer(this, target);
+    const { axes, bounds } = resolveParallelAxisValues(this, dimensions);
+    const ticks = axes.flatMap(axis => axis.values.map((value, index) => ({
+      x: axis.x,
+      y: axis.y[index],
+      value,
+      text: axis.labels[index]
+    })));
+    let next = this
+      .editGraphics({
+        target: "parallelAxisLines",
+        property: "length",
+        value: axes.length
+      })
+      .editGraphics({
+        target: "parallelAxisLines",
+        property: "x1",
+        value: axes.map(axis => axis.x)
+      })
+      .editGraphics({ target: "parallelAxisLines", property: "y1", value: bounds.y })
+      .editGraphics({
+        target: "parallelAxisLines",
+        property: "x2",
+        value: axes.map(axis => axis.x)
+      })
+      .editGraphics({
+        target: "parallelAxisLines",
+        property: "y2",
+        value: bounds.y + bounds.height
+      })
+      .editGraphics({
+        target: "parallelAxisLines",
+        property: "stroke",
+        value: DEFAULT_COLORS.axis
+      })
+      .editGraphics({
+        target: "parallelAxisLines",
+        property: "strokeWidth",
+        value: 1.25
+      })
+      .editGraphics({
+        target: "parallelAxisTicks",
+        property: "length",
+        value: ticks.length
+      })
+      .editGraphics({
+        target: "parallelAxisTicks",
+        property: "x1",
+        value: ticks.map(tick => tick.x - 4)
+      })
+      .editGraphics({
+        target: "parallelAxisTicks",
+        property: "y1",
+        value: ticks.map(tick => tick.y)
+      })
+      .editGraphics({
+        target: "parallelAxisTicks",
+        property: "x2",
+        value: ticks.map(tick => tick.x + 4)
+      })
+      .editGraphics({
+        target: "parallelAxisTicks",
+        property: "y2",
+        value: ticks.map(tick => tick.y)
+      })
+      .editGraphics({
+        target: "parallelAxisTicks",
+        property: "stroke",
+        value: DEFAULT_COLORS.mutedText
+      })
+      .editGraphics({
+        target: "parallelAxisTicks",
+        property: "strokeWidth",
+        value: 1
+      })
+      .editGraphics({
+        target: "parallelAxisLabels",
+        property: "length",
+        value: ticks.length
+      })
+      .editGraphics({
+        target: "parallelAxisLabels",
+        property: "x",
+        value: ticks.map(tick => tick.x - 9)
+      })
+      .editGraphics({
+        target: "parallelAxisLabels",
+        property: "y",
+        value: ticks.map(tick => tick.y)
+      })
+      .editGraphics({
+        target: "parallelAxisLabels",
+        property: "text",
+        value: ticks.map(tick => tick.text)
+      })
+      .editGraphics({ target: "parallelAxisLabels", property: "fill", value: DEFAULT_COLORS.axis })
+      .editGraphics({ target: "parallelAxisLabels", property: "fontSize", value: 11 })
+      .editGraphics({ target: "parallelAxisLabels", property: "fontFamily", value: DEFAULT_FONT_FAMILY })
+      .editGraphics({ target: "parallelAxisLabels", property: "fontWeight", value: "normal" })
+      .editGraphics({ target: "parallelAxisLabels", property: "textAlign", value: "right" })
+      .editGraphics({ target: "parallelAxisLabels", property: "textBaseline", value: "middle" })
+      .editGraphics({
+        target: "parallelAxisTitles",
+        property: "length",
+        value: axes.length
+      })
+      .editGraphics({
+        target: "parallelAxisTitles",
+        property: "x",
+        value: axes.map(axis => axis.x)
+      })
+      .editGraphics({
+        target: "parallelAxisTitles",
+        property: "y",
+        value: bounds.y - 20
+      })
+      .editGraphics({
+        target: "parallelAxisTitles",
+        property: "text",
+        value: axes.map(axis => axis.title)
+      })
+      .editGraphics({ target: "parallelAxisTitles", property: "fill", value: DEFAULT_COLORS.axisTitle })
+      .editGraphics({ target: "parallelAxisTitles", property: "fontSize", value: 13 })
+      .editGraphics({ target: "parallelAxisTitles", property: "fontFamily", value: DEFAULT_FONT_FAMILY })
+      .editGraphics({ target: "parallelAxisTitles", property: "fontWeight", value: 600 })
+      .editGraphics({ target: "parallelAxisTitles", property: "textAlign", value: "center" })
+      .editGraphics({ target: "parallelAxisTitles", property: "textBaseline", value: "middle" });
+    return next._withGuideConfig("parallel", "axes", {
+      target,
+      scales: dimensions.map(dimension => dimension.scale)
+    });
+  }
+);
+
+export const createParallelAxes = action(
+  {
+    op: "createParallelAxes",
+    description: "Create ordinary line and text graphics for Parallel dimensions."
+  },
+  function (args = {}) {
+    validateOptionObject(args, CREATE_OPTIONS, "createParallelAxes");
+    const target = resolveParallelAxisTarget(this, args.target);
+    const { coordinate, dimensions } = requireParallelAxisLayer(this, target);
+    if (args.coordinate !== undefined && args.coordinate !== coordinate.id) {
+      throw new Error(
+        `Parallel layer "${target}" uses coordinate "${coordinate.id}".`
+      );
+    }
+    for (const id of [
+      "parallelAxisLines", "parallelAxisTicks", "parallelAxisLabels",
+      "parallelAxisTitles"
+    ]) {
+      if (this.graphicSpec.objects[id] !== undefined) {
+        throw new Error("createParallelAxes requires missing Parallel axes.");
+      }
+    }
+    const placement = resolvePlotGraphicPlacement(this);
+    let next = this
+      .editSemantic({
+        property: "guide.axis.parallel.target",
+        value: target
+      })
+      .editSemantic({
+        property: "guide.axis.parallel.coordinate",
+        value: coordinate.id
+      })
+      .editSemantic({
+        property: "guide.axis.parallel.scales",
+        value: dimensions.map(dimension => dimension.scale)
+      })
+      .createGraphics({ id: "parallelAxisLines", type: "line", length: 0, ...placement })
+      .editGraphics({ target: "parallelAxisLines", property: "stroke", value: DEFAULT_COLORS.axis })
+      .editGraphics({ target: "parallelAxisLines", property: "strokeWidth", value: 1.25 })
+      .createGraphics({ id: "parallelAxisTicks", type: "line", length: 0, ...placement })
+      .editGraphics({ target: "parallelAxisTicks", property: "stroke", value: DEFAULT_COLORS.mutedText })
+      .editGraphics({ target: "parallelAxisTicks", property: "strokeWidth", value: 1 })
+      .createGraphics({ id: "parallelAxisLabels", type: "text", length: 0, ...placement })
+      .editGraphics({ target: "parallelAxisLabels", property: "fill", value: DEFAULT_COLORS.axis })
+      .editGraphics({ target: "parallelAxisLabels", property: "fontSize", value: 11 })
+      .editGraphics({ target: "parallelAxisLabels", property: "fontFamily", value: DEFAULT_FONT_FAMILY })
+      .editGraphics({ target: "parallelAxisLabels", property: "fontWeight", value: "normal" })
+      .editGraphics({ target: "parallelAxisLabels", property: "textAlign", value: "right" })
+      .editGraphics({ target: "parallelAxisLabels", property: "textBaseline", value: "middle" })
+      .createGraphics({ id: "parallelAxisTitles", type: "text", length: 0, ...placement })
+      .editGraphics({ target: "parallelAxisTitles", property: "fill", value: DEFAULT_COLORS.axisTitle })
+      .editGraphics({ target: "parallelAxisTitles", property: "fontSize", value: 13 })
+      .editGraphics({ target: "parallelAxisTitles", property: "fontFamily", value: DEFAULT_FONT_FAMILY })
+      .editGraphics({ target: "parallelAxisTitles", property: "fontWeight", value: 600 })
+      .editGraphics({ target: "parallelAxisTitles", property: "textAlign", value: "center" })
+      .editGraphics({ target: "parallelAxisTitles", property: "textBaseline", value: "middle" });
+    return next.rematerializeParallelAxes({ target });
+  }
+);
+
+export function registerParallelAxisActions(ProgramClass) {
+  ProgramClass.prototype.createParallelAxes = createParallelAxes;
+  ProgramClass.prototype.rematerializeParallelAxes = rematerializeParallelAxes;
+}

package/src/actions/guides/axes/titles.js

@@ -24,6 +24,7 @@ import {
 } from "./policy.js";
 import { findCanvasGraphic, resolvePlotGraphicPlacement } from
   "../../../materialization/graphicHierarchy.js";
+import { resolveTextBounds } from "../../../core/textMetrics.js";
 
 const CREATE_OPTIONS = Object.freeze([
   "text", "scale", "position", "at", "offset", "rotation", "color",
@@ -132,17 +133,19 @@ function resolveGeometry(program, channel, config) {
     offset: config.offset
   });
   const text = program.semanticSpec.guides.axis?.[channel]?.title ?? "";
-  const width = [...text].length * config.fontSize * 0.6;
-  const height = config.fontSize;
-  const cosine = Math.cos(config.rotation);
-  const sine = Math.sin(config.rotation);
-  const extentX = Math.abs(cosine) * width / 2 + Math.abs(sine) * height / 2;
-  const extentY = Math.abs(sine) * width / 2 + Math.abs(cosine) * height / 2;
+  const titleBounds = resolveTextBounds({
+    ...geometry,
+    text,
+    fontSize: config.fontSize,
+    textAlign: "center",
+    textBaseline: "middle",
+    rotation: config.rotation
+  });
   const canvas = findCanvasGraphic(program)?.properties;
   const newEdgeFits = config.position === "top"
-    ? geometry.y - extentY >= 0
+    ? titleBounds.top >= 0
     : config.position === "right"
-      ? geometry.x + extentX <= canvas?.width
+      ? titleBounds.right <= canvas?.width
       : true;
   if (!canvas || !newEdgeFits) {
     throw new Error(`The ${channel}-axis title does not fit the Canvas margin.`);

package/src/actions/guides/guides.js

@@ -5,6 +5,9 @@ import {
   resolveAutomaticGridOptions,
   resolveGuideApplicability
 } from "./applicability.js";
+import { findDataset } from "../../selectors/datasets.js";
+import { findUpstreamTransform } from
+  "../../materialization/dataProvenance.js";
 
 const OPTIONS = Object.freeze(["axes", "grid", "legend"]);
 
@@ -21,16 +24,51 @@ function validateOptions(args) {
   validateGuideOption(args.legend, "createGuides legend");
 }
 
-function inferAxesOptions(program) {
+function inferAxesOptions(program, applicability) {
   const horizontalInterval = program.semanticSpec.layers.some(layer =>
     layer.mark?.type === "rule" &&
     layer.encoding?.x?.fieldType === "quantitative" &&
     layer.encoding?.x2?.fieldType === "quantitative" &&
     ["nominal", "ordinal", "temporal"].includes(layer.encoding?.y?.fieldType)
   );
-  return horizontalInterval
+  const inferred = horizontalInterval
     ? { x: { ticksAndLabels: { count: 7 } } }
     : {};
+  const directions = applicability.axes.directions;
+  const hasStoredY = program.semanticSpec.layers.some(
+    layer => layer.encoding?.y !== undefined
+  );
+  if (!directions.y && hasStoredY) inferred.y = false;
+  const horizonLayers = program.semanticSpec.layers.filter(layer =>
+    findUpstreamTransform(
+      program,
+      findDataset(program, layer.data),
+      "horizon"
+    ) !== undefined
+  );
+  if (horizonLayers.length === 1 && directions.x && !directions.y) {
+    const scaleId = horizonLayers[0].encoding?.x?.scale;
+    const domain = program.resolvedScales?.[scaleId]?.domain;
+    if (
+      Array.isArray(domain) &&
+      domain.length === 2 &&
+      domain.every(Number.isFinite) &&
+      domain[0] !== domain[1]
+    ) {
+      const low = Math.min(...domain);
+      const high = Math.max(...domain);
+      inferred.x = {
+        ...(inferred.x ?? {}),
+        ticksAndLabels: {
+          values: Array.from(
+            { length: 6 },
+            (_, index) => low + (high - low) * index / 5
+          )
+        }
+      };
+    }
+  }
+  return inferred;
 }
 
 function selectOption(explicit, applicable) {
@@ -39,6 +77,17 @@ function selectOption(explicit, applicable) {
   return applicable ? {} : undefined;
 }
 
+function mergeInferredOptions(inferred, explicit) {
+  if (!isPlainObject(inferred) || !isPlainObject(explicit)) return explicit;
+  const merged = { ...inferred };
+  for (const [key, value] of Object.entries(explicit)) {
+    merged[key] = isPlainObject(value) && isPlainObject(inferred[key])
+      ? mergeInferredOptions(inferred[key], value)
+      : value;
+  }
+  return merged;
+}
+
 const createGuides = action(
   {
     op: "createGuides",
@@ -47,10 +96,16 @@ const createGuides = action(
   function (args = {}) {
     validateOptions(args);
     const applicability = resolveGuideApplicability(this);
-    const hasAxes = applicability.axes.cartesian || applicability.axes.polar;
+    const hasAxes = applicability.axes.cartesian || applicability.axes.polar ||
+      applicability.axes.parallel;
+    const inferredAxes = applicability.axes.cartesian
+      ? inferAxesOptions(this, applicability)
+      : {};
     const axes = args.axes === undefined && applicability.axes.cartesian
-      ? inferAxesOptions(this)
-      : selectOption(args.axes, hasAxes);
+      ? inferredAxes
+      : args.axes !== undefined && args.axes !== false && hasAxes
+        ? mergeInferredOptions(inferredAxes, args.axes)
+        : selectOption(args.axes, hasAxes);
     const grid = args.grid === undefined &&
         (applicability.grid.cartesian || applicability.grid.polar)
       ? resolveAutomaticGridOptions(this)