ggaction 0.0.13 → 0.0.15

package/src/actions/encodings/color/index.js

@@ -150,7 +150,8 @@ const encodeColor = action(
       });
     }
     next = applyEncodingScale(next, scale, requestedScale, {
-      reassignment: layer.encoding?.color?.scale === scale.id
+      reassignment: layer.encoding?.color?.scale === scale.id,
+      allowTypeChange: true
     });
     next = applyColorLayoutCompanion(next, {
       target,

package/src/actions/encodings/density.js

@@ -28,12 +28,12 @@ import {
 
 const OPTIONS = Object.freeze([
   "field", "target", "source", "groupBy", "bandwidth", "extent", "steps",
-  "kernel", "normalization", "as", "densityChannel", "coordinate",
+  "kernel", "normalization", "weight", "as", "densityChannel", "coordinate",
   "valueScale", "densityScale", "placement"
 ]);
 const EDIT_OPTIONS = Object.freeze([
   "target", "source", "field", "groupBy", "bandwidth", "extent", "steps",
-  "kernel", "normalization", "densityChannel", "valueScale", "placement"
+  "kernel", "normalization", "weight", "densityChannel", "valueScale", "placement"
 ]);
 const EDITABLE = Object.freeze(EDIT_OPTIONS.filter(option => option !== "target"));
 const SCALE_PROPERTIES = Object.freeze([
@@ -193,6 +193,7 @@ const encodeDensity = action(
       ...(args.normalization === undefined
         ? {}
         : { normalization: args.normalization }),
+      ...(args.weight === undefined ? {} : { weight: args.weight }),
       ...(args.as === undefined ? {} : { as: args.as }),
       ...(placement === undefined ? {} : { placement })
     };
@@ -350,6 +351,7 @@ const editDensity = action(
     const option = property => Object.hasOwn(args, property)
       ? args[property]
       : transform[property];
+    const weight = option("weight");
 
     const dataArgs = {
       id: revision.id,
@@ -364,6 +366,7 @@ const editDensity = action(
       kernel: option("kernel") ?? "gaussian",
       normalization: option("normalization") ?? "unit",
       as: transform.as,
+      ...(weight === undefined || weight === false ? {} : { weight }),
       ...(requestedPlacement === undefined
         ? {}
         : { placement: requestedPlacement })

package/src/actions/encodings/histogram.js

@@ -3,7 +3,7 @@ import { validateOptions } from "./shared.js";
 
 const HISTOGRAM_OPTIONS = Object.freeze([
   "field", "target", "coordinate", "maxBins", "binStep", "binBoundaries",
-  "stack", "xScale", "yScale"
+  "stack", "xScale", "yScale", "weight"
 ]);
 
 const encodeHistogram = action(
@@ -28,7 +28,8 @@ const encodeHistogram = action(
         : { maxBins: args.maxBins ?? 10 };
     const x = {
       field: args.field,
-      bin
+      bin,
+      ...(args.weight === undefined ? {} : { weight: args.weight })
     };
     const y = {
       stack: Object.hasOwn(args, "stack") ? args.stack : "zero"

package/src/actions/encodings/index.js

@@ -13,8 +13,10 @@ import { registerTextEncodingAction } from "./text.js";
 import { registerAppearanceEncodingAction } from "./appearance.js";
 import { registerStrokeDashEncodingActions } from "./strokeDash.js";
 import { registerRuleAppearanceEncodingActions } from "./ruleAppearance.js";
+import { registerStrokeEncodingAction } from "./stroke.js";
 import { registerBarWidthEncodingAction } from "./barWidth.js";
 import { registerEncodingRemovalAction } from "./remove.js";
+import { registerAtomicEncodingAction } from "./channels.js";
 
 export function registerEncodingActions(ProgramClass) {
   registerSeriesLayoutAction(ProgramClass);
@@ -31,7 +33,9 @@ export function registerEncodingActions(ProgramClass) {
   registerAppearanceEncodingAction(ProgramClass);
   registerAngleEncodingAction(ProgramClass);
   registerRuleAppearanceEncodingActions(ProgramClass);
+  registerStrokeEncodingAction(ProgramClass);
   registerTextEncodingAction(ProgramClass);
   registerParallelEncodingAction(ProgramClass);
   registerEncodingRemovalAction(ProgramClass);
+  registerAtomicEncodingAction(ProgramClass);
 }

package/src/actions/encodings/offset.js

@@ -18,7 +18,6 @@ import {
   resolveBarChannels,
   resolveBarGrain
 } from "../../grammar/bars/policy.js";
-import { normalizeOffsetPadding } from "../../grammar/bars/geometry.js";
 
 const ENCODING_OPTIONS = Object.freeze([
   "field", "target", "fieldType", "scale", "paddingInner", "paddingOuter"
@@ -69,30 +68,38 @@ function createOffsetEncoding(channel) {
         layer.encoding?.[channel],
         args.scale ?? {}
       );
-      const scale = resolveOffsetScaleDefinition(this, requestedScale, channel);
+      const scaleOptions = {
+        ...requestedScale,
+        ...Object.fromEntries(
+          ["paddingInner", "paddingOuter"]
+            .filter(property => Object.hasOwn(args, property))
+            .map(property => [property, args[property]])
+        )
+      };
+      const scale = resolveOffsetScaleDefinition(this, scaleOptions, channel);
       if (Object.hasOwn(scale, "unknown")) {
         throw new Error(
           `${channel} scale unknown is not supported for offset positions.`
         );
       }
-      const padding = normalizeOffsetPadding(
-        args,
-        this.markConfigs[target]?.[channel],
-        channel
-      );
 
       const grouped = layer.mark.type === "bar" ? inferSeriesGroup(this, layer, args.field, "offset") : this;
       let next = setEncodingProperties(grouped, target, channel, {
         field: args.field,
         fieldType,
         scale: scale.id
-      })._withMarkConfig(target, {
-          ...this.markConfigs[target],
-          [channel]: padding
-        });
-      next = applyEncodingScale(next, scale, requestedScale, {
-        reassignment: layer.encoding?.[channel]?.scale === scale.id
       });
+      next = applyEncodingScale(next, scale, {
+        ...Object.fromEntries(Object.entries(scaleOptions).filter(
+          ([property]) => property !== "range"
+        )),
+        paddingInner: scale.paddingInner,
+        paddingOuter: scale.paddingOuter,
+        align: scale.align
+      }, {
+        reassignment: findSemanticScale(this, scale.id) !== undefined
+      });
+      next = next._withoutMaterializationConfig(["marks", target, channel]);
       if (layer.mark.type === "bar") {
         if (findSemanticScale(this, scale.id) === undefined && args.scale?.id === undefined) next = next._withMarkConfig(target, { ...next.markConfigs[target], seriesOffsetScale: scale.id });
         if (layer.layout?.mode !== "group" || layer.encoding?.group?.field !== args.field) return next.layoutSeries({ target, mode: "group" });

package/src/actions/encodings/position/apply.js

@@ -66,18 +66,35 @@ function applyBin(program, target, channel, previous, bin) {
   });
 }
 
-function applyArcThetaWeight(program, target, channel, previous, aggregate, weight) {
-  if (channel !== "theta") return program;
-  if (aggregate !== "sum") {
+function applyPositionWeight(
+  program,
+  target,
+  channel,
+  previous,
+  bin,
+  aggregate,
+  weight
+) {
+  const histogram = channel === "x" && bin !== undefined;
+  const arcSum = channel === "theta" && aggregate === "sum";
+  if (!histogram && !arcSum) {
+    return previous?.weight === undefined
+      ? program
+      : program.editSemantic({
+          property: `layer[${target}].encoding.${channel}.weight`,
+          remove: true
+        });
+  }
+  if (weight === undefined) {
     return previous?.weight === undefined
       ? program
       : program.editSemantic({
-          property: `layer[${target}].encoding.theta.weight`,
+          property: `layer[${target}].encoding.${channel}.weight`,
           remove: true
         });
   }
   return program.editSemantic({
-    property: `layer[${target}].encoding.theta.weight`,
+    property: `layer[${target}].encoding.${channel}.weight`,
     value: weight
   });
 }
@@ -104,6 +121,26 @@ function removeStaleArcThetaAggregate(
   });
 }
 
+function removeMeasuredRadiusAggregate(
+  program,
+  target,
+  channel,
+  previous,
+  clearRadialMapping
+) {
+  if (
+    channel !== "radius" ||
+    !clearRadialMapping ||
+    previous?.aggregate === undefined
+  ) {
+    return program;
+  }
+  return program.editSemantic({
+    property: `layer[${target}].encoding.radius.aggregate`,
+    remove: true
+  });
+}
+
 export function applyPositionSemantics(program, {
   target,
   channel,
@@ -117,7 +154,8 @@ export function applyPositionSemantics(program, {
   bin,
   aggregate,
   stack,
-  weight
+  weight,
+  clearRadialMapping
 }) {
   let next = reconcileInheritedRulePosition(program, {
     target,
@@ -160,11 +198,19 @@ export function applyPositionSemantics(program, {
     fieldType,
     aggregate
   );
-  return applyArcThetaWeight(
+  next = removeMeasuredRadiusAggregate(
+    next,
+    target,
+    channel,
+    previous,
+    clearRadialMapping
+  );
+  return applyPositionWeight(
     next,
     target,
     channel,
     previous,
+    bin,
     aggregate,
     weight
   );

package/src/actions/encodings/position/index.js

@@ -31,7 +31,8 @@ function encodePosition(program, channel, args, operation) {
     aggregate,
     stack,
     weight,
-    companion
+    companion,
+    clearRadialMapping
   } = resolvePositionEncoding(program, channel, args, operation);
 
   let next = program
@@ -53,13 +54,20 @@ function encodePosition(program, channel, args, operation) {
     bin,
     aggregate,
     stack,
-    weight
+    weight,
+    clearRadialMapping
   });
 
   next = next.editSemantic({
       property: `layer[${target}].encoding.${channel}.scale`,
       value: scale.id
     });
+  if (
+    clearRadialMapping &&
+    findSemanticScale(next, scale.id)?.radialMapping !== undefined
+  ) {
+    next = next.editScale({ id: scale.id, radialMapping: undefined });
+  }
   next = applyEncodingScale(next, scale, requestedScale, {
     reassignment: previous?.scale === scale.id,
     allowTypeChange: layer.mark.type === "area"

package/src/actions/encodings/position/policies/bar.js

@@ -10,6 +10,8 @@ import {
   resolveBarOrientation
 } from "../../../../grammar/bars/policy.js";
 import { resolveBin, validateStack } from "./common.js";
+import { normalizeStatisticalWeight } from
+  "../../../../grammar/weightedStatistics.js";
 
 function resolveBarChannelPolicy({
   program,
@@ -37,6 +39,10 @@ function resolveBarChannelPolicy({
       throw new Error("Binned bar x encoding does not support aggregate or stack.");
     }
     bin = resolveBin(args.bin);
+    const weight = args.weight === undefined
+      ? undefined
+      : normalizeStatisticalWeight(args.weight, "Histogram weight");
+    return { bin, aggregate, stack, weight };
   } else if (
     fieldType === "quantitative" &&
     channel === "y" &&
@@ -89,6 +95,9 @@ function resolveBarChannelPolicy({
     );
   }
 
+  if (args.weight !== undefined) {
+    throw new Error("Bar weight is supported only for a binned x encoding.");
+  }
   return { bin, aggregate, stack };
 }
 

package/src/actions/encodings/position/resolve.js

@@ -97,19 +97,26 @@ export function resolvePositionEncoding(program, channel, args, operation) {
     args.target,
     getPositionChannelDefinition(channel).markTypes
   );
+  const previous = layer.encoding?.[channel];
   if (isSourceOwnedText(layer)) {
     throw new Error(`${operation} cannot replace source-owned Text positions; edit the source, use dx/dy, or create independent Text with data.`);
   }
   if (
     Object.hasOwn(args, "weight") &&
-    !(layer.mark.type === "arc" && channel === "theta")
+    !(layer.mark.type === "arc" && channel === "theta") &&
+    !(layer.mark.type === "bar" && channel === "x" &&
+      (args.bin !== undefined || previous?.bin !== undefined))
   ) {
-    throw new Error(`${operation} weight is supported only for arc theta encoding.`);
+      throw new Error(
+        `${operation} weight is supported only for arc theta encoding or histogram x encoding.`
+      );
   }
   if (Object.hasOwn(args, "mapping") && (layer.mark.type !== "arc" || channel !== "radius")) {
     throw new Error(`${operation} mapping requires Arc radius.`);
   }
   validateCoordinateFamily(layer, channel, operation);
+  const clearRadialMapping =
+    layer.mark.type === "arc" && channel === "radius" && args.mapping === false;
   const hasField = Object.hasOwn(args, "field");
   const hasDatum = Object.hasOwn(args, "datum");
   if (["rule", "rect", "text", "point", "tick"].includes(layer.mark.type)) {
@@ -128,9 +135,10 @@ export function resolvePositionEncoding(program, channel, args, operation) {
   } else if (hasDatum) {
     throw new Error(`${operation} does not support datum for a ${layer.mark.type} mark.`);
   }
-  const previous = layer.encoding?.[channel];
   const mapping = channel === "radius" && layer.mark.type === "arc"
-    ? args.mapping ?? findSemanticScale(program, previous?.scale)?.radialMapping
+    ? clearRadialMapping
+      ? undefined
+      : args.mapping ?? findSemanticScale(program, previous?.scale)?.radialMapping
     : undefined;
   const countRadius = mapping !== undefined && (args.aggregate ?? previous?.aggregate) === "count";
   const requestedFieldType = args.fieldType ?? previous?.fieldType ?? (
@@ -165,7 +173,9 @@ export function resolvePositionEncoding(program, channel, args, operation) {
       validateAggregateFieldValues(dataset.values, field, fieldType);
     } else readScaleField(dataset.values, field, fieldType, { temporalUnit });
   }
-  const effectiveArgs = { ...args, ...(mapping === undefined ? {} : { mapping }) };
+  const effectiveArgs = { ...args };
+  if (clearRadialMapping) delete effectiveArgs.mapping;
+  else if (mapping !== undefined) effectiveArgs.mapping = mapping;
   const directQuantitativeArcTheta =
     layer.mark.type === "arc" &&
     channel === "theta" &&
@@ -173,7 +183,8 @@ export function resolvePositionEncoding(program, channel, args, operation) {
   for (const property of ["aggregate", "bin", "stack"]) {
     if (!Object.hasOwn(effectiveArgs, property) && previous !== undefined &&
       Object.hasOwn(previous, property) &&
-      !(directQuantitativeArcTheta && property === "aggregate")) {
+      !(directQuantitativeArcTheta && property === "aggregate") &&
+      !(clearRadialMapping && property === "aggregate")) {
       effectiveArgs[property] = previous[property];
     }
   }
@@ -201,7 +212,7 @@ export function resolvePositionEncoding(program, channel, args, operation) {
     previous,
     Object.hasOwn(args, "scale") ? args.scale : {}
   );
-  const scale = resolvePositionScaleDefinition(
+  const resolvedScale = resolvePositionScaleDefinition(
     program,
     channel,
     aggregateOutput ? "quantitative" : fieldType,
@@ -229,6 +240,11 @@ export function resolvePositionEncoding(program, channel, args, operation) {
           }
         : {}
   );
+  const scale = clearRadialMapping
+    ? Object.fromEntries(
+        Object.entries(resolvedScale).filter(([property]) => property !== "radialMapping")
+      )
+    : resolvedScale;
   if (
     layer.mark.type === "bar" &&
     program.markConfigs[target]?.boxPlot === undefined &&
@@ -310,6 +326,7 @@ export function resolvePositionEncoding(program, channel, args, operation) {
     temporalUnit,
     scale,
     coordinate: resolveCoordinate(program, channel, layer, args.coordinate),
+    clearRadialMapping,
     ...policy
   };
 }

package/src/actions/encodings/remove.js

@@ -25,11 +25,12 @@ import { applyDetachedScaleRematerialization } from "../../materialization/depen
 import { findDataset } from "../../selectors/datasets.js";
 import { assertPathGroupCompatible, validatePathGroupAppearance } from "../../materialization/marks/grouping.js";
 import { assertEncodingSelectionCompatibility } from "../../materialization/selection/compatibility.js";
+import { planLegendBlockTransitions } from "../guides/legends/transition.js";
 
 const OPTIONS = Object.freeze(["target", "channel"]);
 const REMOVABLE_CHANNELS = Object.freeze([
   "x", "y", "x2", "y2", "xOffset", "yOffset", "theta", "radius",
-  "color", "strokeDash", "strokeWidth", "size", "shape", "group",
+  "color", "stroke", "strokeDash", "strokeWidth", "size", "shape", "group",
   "angle", "opacity", "text"
 ]);
 const REMOVE_AXIS = Object.freeze({
@@ -40,6 +41,7 @@ const REMOVE_AXIS = Object.freeze({
 });
 const SPECIALIZED_LEGEND_KIND = Object.freeze({
   color: Object.freeze(["gradient", "interval"]),
+  stroke: Object.freeze(["strokeGradient", "strokeInterval"]),
   size: Object.freeze(["size"]),
   opacity: Object.freeze(["opacity"]),
   strokeWidth: Object.freeze(["strokeWidth"])
@@ -157,7 +159,7 @@ function cleanupPositionGuides(program, removed) {
 }
 
 function reconcileCategoricalLegend(program, target, channels) {
-  const entry = ["series", "color"]
+  const entry = ["series", "color", "stroke"]
     .map(kind => [kind, program.guideConfigs.legend?.[kind]])
     .find(([, config]) =>
       config?.target === target &&
@@ -172,7 +174,10 @@ function reconcileCategoricalLegend(program, target, channels) {
   if (remaining.length === 0) {
     return removeLegendKinds(program, [kind]);
   }
-  const revision = resolveCategoricalLegendRevision(program, kind, config, remaining);
+  const resolved = resolveCategoricalLegendRevision(program, kind, config, remaining);
+  const revision = planLegendBlockTransitions(program, target, [
+    { ...resolved, kind: resolved.config.kind }
+  ])[0];
   const next = removeLegendKinds(program, [kind]);
   return createCategoricalLegendFromConfig(next, revision.config, revision.order);
 }
@@ -218,7 +223,7 @@ export const removeEncoding = action(
     }
     const channels = activeCascade(layer, args.channel);
     assertEncodingSelectionCompatibility(this, layer.id, channels);
-    for (const kind of ["series", "color"]) {
+    for (const kind of ["series", "color", "stroke"]) {
       const config = this.guideConfigs.legend?.[kind];
       const order = this.semanticSpec.guides.legend?.[kind]?.order;
       if (config?.target === layer.id && channels.includes(order?.channel) &&

package/src/actions/encodings/ruleAppearance.js

@@ -1,8 +1,5 @@
 import { action } from "../../core/action.js";
-import {
-  validateRuleStroke,
-  validateRuleStrokeWidth
-} from "../../grammar/ruleAppearance.js";
+import { validateRuleStrokeWidth } from "../../grammar/ruleAppearance.js";
 import { readQuantitativeField } from "../../grammar/scales/index.js";
 import { resolveStrokeWidthScaleDefinition } from "../scales/definitions.js";
 import {
@@ -18,28 +15,10 @@ import { findLayer } from "../../selectors/layers.js";
 import { validatePathSeriesAppearance } from "../../grammar/pathSeries.js";
 import { assertEncodingSelectionCompatibility } from "../../materialization/selection/compatibility.js";
 
-const STROKE_OPTIONS = Object.freeze(["target", "value"]);
 const WIDTH_OPTIONS = Object.freeze([
   "target", "value", "field", "fieldType", "scale"
 ]);
 
-const encodeStroke = action(
-  {
-    op: "encodeStroke",
-    description: "Set a constant graphical stroke on a rule mark."
-  },
-  function (args = {}) {
-    validateOptions(args, STROKE_OPTIONS, "encodeStroke");
-    const { id } = resolveTarget(this, args.target, ["rule"], "rule mark");
-    return this
-      ._withMarkConfig(id, {
-        ...this.markConfigs[id],
-        stroke: validateRuleStroke(args.value)
-      })
-      .rematerializeRuleMark({ id });
-  }
-);
-
 const encodeStrokeWidth = action(
   {
     op: "encodeStrokeWidth",
@@ -119,6 +98,5 @@ const encodeStrokeWidth = action(
 );
 
 export function registerRuleAppearanceEncodingActions(ProgramClass) {
-  ProgramClass.prototype.encodeStroke = encodeStroke;
   ProgramClass.prototype.encodeStrokeWidth = encodeStrokeWidth;
 }

package/src/actions/encodings/seriesLayout.js

@@ -85,6 +85,7 @@ export const layoutSeries = action({ op: "layoutSeries", description: "Assign se
       next = offset.field === undefined
         ? setEncodingProperties(next, target, offsetChannel, offset).createScale(offsetScale)
         : next[offsetChannel === "xOffset" ? "encodeXOffset" : "encodeYOffset"]({ target, field: offset.field, fieldType: offset.fieldType, scale: offsetScale });
+      next = next._withoutMaterializationConfig(["marks", target, offsetChannel]);
       if (findSemanticScale(this, offsetScale.id) === undefined) next = next._withMarkConfig(target, { ...next.markConfigs[target], seriesOffsetScale: offsetScale.id });
     } else {
       const owned = next.markConfigs[target]?.seriesOffsetScale;

package/src/actions/encodings/shared.js

@@ -8,6 +8,7 @@ import { planEncodingRematerialization } from "../../materialization/encodings.j
 import { findSemanticScale } from "../../selectors/scales.js";
 import { validateOptionObject } from "../../core/validation.js";
 import { getMarkGraphicTypes, getPositionChannelDefinition } from "../../core/vocabulary.js";
+import { DEFAULT_TICK_COUNT } from "../guides/tickValues.js";
 
 export function validateOptions(args, supported, operation) {
   validateOptionObject(args, supported, operation);
@@ -105,33 +106,100 @@ export function rebindPositionGuides(
   const direction = definition.gridDirection;
   const grid = program.semanticSpec.guides.grid?.[direction];
   const ownsAxis = axis?.scale === previousScale;
+  const refreshesReboundAxis = axis?.scale === nextScale;
   const ownsGrid = grid?.scale === previousScale;
-  if (!ownsAxis && !ownsGrid) return program;
+  if (!ownsAxis && !ownsGrid && !refreshesReboundAxis) return program;
 
   const remaining = program.semanticSpec.layers.some(layer =>
     layer.id !== target && !isSourceOwnedText(layer) && layer.encoding?.[channel]?.scale === previousScale
   );
-  if (remaining) {
+  if ((ownsAxis || ownsGrid) && remaining) {
     throw new Error(
       `Cannot rebind ${channel} guides from shared scale "${previousScale}" while it has other consumers.`
     );
   }
 
   let next = program;
-  if (ownsAxis) {
-    next = next.editSemantic({
-      property: `guide.axis.${definition.guideChannel}.scale`,
-      value: nextScale
-    });
-    for (const component of ["line", "ticks", "labels", "title"]) {
-      const config = next.guideConfigs.axis?.[definition.guideChannel]?.[component];
-      if (config?.scale === previousScale) {
-        next = next._withGuideConfig(definition.guideChannel, component, {
-          ...config,
-          scale: nextScale
-        });
+  if (ownsAxis || refreshesReboundAxis) {
+    const previousAxisConfig = next.guideConfigs.axis?.[definition.guideChannel];
+    const previousTicks = previousAxisConfig?.ticks;
+    const previousLabels = previousAxisConfig?.labels;
+    const labelsFollowTicks = previousTicks !== undefined &&
+      previousLabels !== undefined &&
+      previousTicks.mode === previousLabels.mode &&
+      (previousTicks.mode === "count"
+        ? previousTicks.count === previousLabels.count
+        : previousTicks.values?.length === previousLabels.values?.length &&
+          previousTicks.values.every(
+            (value, index) => Object.is(value, previousLabels.values[index])
+          ));
+    if (ownsAxis) {
+      next = next.editSemantic({
+        property: `guide.axis.${definition.guideChannel}.scale`,
+        value: nextScale
+      });
+      for (const component of ["line", "ticks", "labels", "title"]) {
+        const config = next.guideConfigs.axis?.[definition.guideChannel]?.[component];
+        if (config?.scale === previousScale) {
+          next = next._withGuideConfig(definition.guideChannel, component, {
+            ...config,
+            scale: nextScale
+          });
+        }
       }
     }
+    const resolved = next.resolvedScales[nextScale] ??
+      findSemanticScale(next, nextScale);
+    const discrete = ["ordinal", "band", "point"].includes(resolved?.type);
+    let ticks = next.guideConfigs.axis?.[definition.guideChannel]?.ticks;
+    if (ticks !== undefined && discrete && ticks.mode !== "values") {
+      ticks = {
+        ...ticks,
+        mode: "values",
+        values: resolved.domain,
+        inferredValues: true
+      };
+      delete ticks.count;
+      next = next._withGuideConfig(definition.guideChannel, "ticks", ticks);
+    } else if (
+      ticks !== undefined &&
+      !discrete &&
+      ticks.mode === "values" &&
+      ticks.inferredValues === true
+    ) {
+      ticks = {
+        ...ticks,
+        mode: "count",
+        count: DEFAULT_TICK_COUNT,
+        inferredValues: true
+      };
+      delete ticks.values;
+      next = next._withGuideConfig(definition.guideChannel, "ticks", ticks);
+    } else if (
+      ticks !== undefined &&
+      discrete &&
+      ticks.inferredValues === true
+    ) {
+      ticks = { ...ticks, values: resolved.domain };
+      next = next._withGuideConfig(definition.guideChannel, "ticks", ticks);
+    }
+    if (previousLabels !== undefined && labelsFollowTicks && ticks !== undefined) {
+      const labels = {
+        ...next.guideConfigs.axis[definition.guideChannel].labels,
+        mode: ticks.mode,
+        inferredValues: ticks.inferredValues === true,
+        ...(ticks.mode === "values"
+          ? { values: ticks.values }
+          : { count: ticks.count })
+      };
+      if (ticks.mode === "values") delete labels.count;
+      else delete labels.values;
+      next = next._withGuideConfig(
+        definition.guideChannel,
+        "labels",
+        labels
+      );
+    }
   }
   if (ownsGrid) {
     next = next