ggaction 0.0.12 → 0.0.15

package/src/actions/encodings/remove.js

@@ -15,13 +15,22 @@ import {
   getSourceDependentMarkSteps
 } from "../../materialization/marks/index.js";
 import { findLayer } from "../../selectors/layers.js";
-import { removeLegendKinds } from "../guides/legends/remove.js";
+import {
+  removeLegendKinds,
+  resolveCategoricalLegendRevision,
+  createCategoricalLegendFromConfig
+} from "../guides/legends/lifecycle.js";
 import { clearMarkGraphic } from "./shared.js";
+import { applyDetachedScaleRematerialization } from "../../materialization/dependencies.js";
+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({
@@ -32,14 +41,11 @@ 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"])
 });
-const LEGEND_OPTION_KEYS = Object.freeze([
-  "position", "align", "direction", "columns", "offset", "titlePosition",
-  "title", "symbol", "labels", "titleStyle", "itemGap", "border"
-]);
 
 function resolveTarget(program, requested, channel) {
   const candidates = program.semanticSpec.layers.filter(
@@ -77,7 +83,7 @@ function activeCascade(layer, channel) {
     channels.add("y2");
     channels.add("yOffset");
   }
-  if (channel === "color" && layer.mark?.type === "bar") {
+  if (channel === "color" && layer.mark?.type === "bar" && layer.layout === undefined) {
     if (resolveBarColorLayout(layer) === "group") {
       channels.add(resolveBarOffsetChannel(layer));
     }
@@ -85,6 +91,7 @@ function activeCascade(layer, channel) {
   if (
     channel === "group" &&
     layer.mark?.type === "area" &&
+    layer.layout === undefined &&
     layer.encoding?.color?.field !== undefined &&
     layer.encoding.color.field === layer.encoding.group?.field
   ) {
@@ -93,21 +100,6 @@ function activeCascade(layer, channel) {
   return [...channels].filter(active => layer.encoding?.[active] !== undefined);
 }
 
-function assertSelectionCompatibility(program, target, channels) {
-  for (const [id, selection] of Object.entries(
-    program.materializationConfigs.selections ?? {}
-  )) {
-    if (
-      selection.target === target &&
-      channels.includes(selection.selector?.channel)
-    ) {
-      throw new Error(
-        `Cannot remove ${selection.selector.channel} encoding while selection "${id}" references that channel.`
-      );
-    }
-  }
-}
-
 function removeChannelConfigs(program, target, channels) {
   let next = program;
   for (const channel of channels) {
@@ -167,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 &&
@@ -182,16 +174,12 @@ function reconcileCategoricalLegend(program, target, channels) {
   if (remaining.length === 0) {
     return removeLegendKinds(program, [kind]);
   }
+  const resolved = resolveCategoricalLegendRevision(program, kind, config, remaining);
+  const revision = planLegendBlockTransitions(program, target, [
+    { ...resolved, kind: resolved.config.kind }
+  ])[0];
   const next = removeLegendKinds(program, [kind]);
-  const options = { target, channels: remaining };
-  for (const property of LEGEND_OPTION_KEYS) {
-    if (
-      (property === "columns" && config[property] === undefined) ||
-      (property === "title" && config.inferredTitle)
-    ) continue;
-    options[property] = config[property];
-  }
-  return next.createLegend(options);
+  return createCategoricalLegendFromConfig(next, revision.config, revision.order);
 }
 
 function cleanupLegends(program, target, channels) {
@@ -228,8 +216,30 @@ export const removeEncoding = action(
       );
     }
     const layer = resolveTarget(this, args.target, args.channel);
+    if (args.channel === "group" && layer.layout?.mode !== undefined && layer.layout.mode !== "overlay") throw new Error("Remove active series layout before removing its group.");
+    if (args.channel === "theta" && layer.mark.type === "arc" &&
+      ["count", "sum"].includes(layer.encoding?.radius?.aggregate)) {
+      throw new Error("Remove measured radius before removing its category theta encoding.");
+    }
     const channels = activeCascade(layer, args.channel);
-    assertSelectionCompatibility(this, layer.id, channels);
+    assertEncodingSelectionCompatibility(this, layer.id, channels);
+    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) &&
+        config.channels.some(channel => !channels.includes(channel))) {
+        throw new Error('Reset linked legend order to "scale" before removing its position encoding.');
+      }
+    }
+    if (["line", "area"].includes(layer.mark?.type)) {
+      const dataset = findDataset(this, layer.data);
+      if (args.channel === "group") {
+        assertPathGroupCompatible(this, layer, dataset, undefined);
+      }
+      const encoding = { ...layer.encoding };
+      for (const channel of channels) delete encoding[channel];
+      validatePathGroupAppearance(this, { ...layer, encoding }, dataset);
+    }
     const removedPositions = channels
       .filter(channel => POSITION_ENCODING_CHANNELS.includes(channel))
       .map(channel => ({
@@ -249,7 +259,7 @@ export const removeEncoding = action(
     next = restoreBarBaseline(next, layer, channels);
     next = cleanupLegends(next, layer.id, channels);
     next = cleanupPositionGuides(next, removedPositions);
-    return rematerializeTarget(next, layer.id);
+    return applyDetachedScaleRematerialization(rematerializeTarget(next, layer.id), [layer]);
   }
 );
 

package/src/actions/encodings/ruleAppearance.js

@@ -1,12 +1,10 @@
 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 {
   applyEncodingScale,
+  applyDetachedScaleRematerialization,
   rematerializeEncoding,
   resolveReassignmentScaleOptions,
   resolveTarget,
@@ -14,33 +12,17 @@ import {
   validateOptions
 } from "./shared.js";
 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",
-    description: "Set a constant graphical stroke width on a rule mark."
+    description: "Assign constant or field-driven line or rule stroke width."
   },
   function (args = {}) {
     validateOptions(args, WIDTH_OPTIONS, "encodeStrokeWidth");
@@ -50,9 +32,14 @@ const encodeStrokeWidth = action(
       throw new Error("encodeStrokeWidth requires exactly one of value or field.");
     }
     if (hasValue) {
-      const { id } = resolveTarget(this, args.target, ["rule"], "rule mark");
+      if (args.fieldType !== undefined || args.scale !== undefined) {
+        throw new Error("Constant stroke width does not accept fieldType or scale.");
+      }
+      validateRuleStrokeWidth(args.value);
+      const { id, layer } = resolveTarget(this, args.target, ["rule", "line"], "rule or line mark");
+      assertEncodingSelectionCompatibility(this, id, ["strokeWidth"]);
       let next = this.guideConfigs.legend?.strokeWidth?.target === id
-        ? this.removeLegend({ target: id })
+        ? this.removeLegend({ target: id, channels: ["strokeWidth"] })
         : this;
       if (findLayer(next, id)?.encoding?.strokeWidth !== undefined) {
         next = next.editSemantic({
@@ -60,12 +47,15 @@ const encodeStrokeWidth = action(
           remove: true
         });
       }
-      return next
-        ._withMarkConfig(id, {
+      next = next._withMarkConfig(id, {
           ...next.markConfigs[id],
-          strokeWidth: validateRuleStrokeWidth(args.value)
-        })
-        .rematerializeRuleMark({ id });
+          strokeWidth: args.value
+        });
+      if (layer.mark.type === "line") {
+        return rematerializeEncoding(next, id, "strokeWidth", undefined, layer);
+      }
+      next = next.rematerializeRuleMark({ id });
+      return applyDetachedScaleRematerialization(next, [layer]);
     }
     const { id, dataset, layer } = resolveTarget(
       this,
@@ -83,6 +73,9 @@ const encodeStrokeWidth = action(
         `encodeStrokeWidth field "${args.field}" cannot contain negative values.`
       );
     }
+    validatePathSeriesAppearance(dataset.values, {
+      ...layer, encoding: { ...layer.encoding, strokeWidth: { field: args.field, fieldType } }
+    });
     const previous = layer.encoding?.strokeWidth;
     const requestedScale = resolveReassignmentScaleOptions(
       previous,
@@ -100,11 +93,10 @@ const encodeStrokeWidth = action(
     next = applyEncodingScale(next, scale, requestedScale, {
       reassignment: previous?.scale === scale.id
     });
-    return rematerializeEncoding(next, id, "strokeWidth", scale.id);
+    return rematerializeEncoding(next, id, "strokeWidth", scale.id, layer);
   }
 );
 
 export function registerRuleAppearanceEncodingActions(ProgramClass) {
-  ProgramClass.prototype.encodeStroke = encodeStroke;
   ProgramClass.prototype.encodeStrokeWidth = encodeStrokeWidth;
 }

package/src/actions/encodings/seriesLayout.js

@@ -0,0 +1,105 @@
+import { action } from "../../core/action.js";
+import { validateColorLayout } from "../../grammar/seriesLayout.js";
+import { deriveAreaSeries, deriveDensityAreaSeries, layoutDensityAreaSeries } from "../../grammar/areaSeries.js";
+import { readSeriesIdentity } from "../../grammar/pathSeries.js";
+import { BAR_GRAINS, resolveBarChannels, resolveBarGrain } from "../../grammar/bars/policy.js";
+import { deriveBarAggregates } from "../../grammar/bars/aggregate.js";
+import { findSemanticScale, hasSemanticScaleReferences } from "../../selectors/scales.js";
+import { findUpstreamTransform } from "../../materialization/dataProvenance.js";
+import { resolveOffsetScaleDefinition } from "../scales/definitions.js";
+import { resolveScalePreview } from "../scales/preview.js";
+import { getPositionEncodingMaterializationSteps } from "../../materialization/marks/index.js";
+import { resolveTarget, setEncodingProperties, validateOptions } from "./shared.js";
+
+export function stackLayoutMode(stack) {
+  return stack === "normalize" ? "fill" : stack === "center" ? "center" : stack === null ? "overlay" : "stack";
+}
+
+export const layoutSeries = action({ op: "layoutSeries", description: "Assign series placement independently of color." }, function (args = {}) {
+  validateOptions(args, ["target", "mode"], "layoutSeries");
+  const mode = validateColorLayout(args.mode);
+  const { id: target, layer, dataset } = resolveTarget(this, args.target, ["bar", "area"], "series mark");
+  const encoding = Object.fromEntries(Object.entries(layer.encoding ?? {}).map(([key, value]) => [key, { ...value }]));
+  const group = encoding.group;
+  const color = encoding.color;
+  if (group === undefined && color?.field !== undefined && ["nominal", "ordinal"].includes(color.fieldType)) {
+    encoding.group = { field: color.field, fieldType: "nominal", inferredFrom: "color" };
+  }
+  for (const channel of ["x", "y"]) if (encoding[channel]) delete encoding[channel].stack;
+  if (color) delete color.layout;
+  const updated = { ...layer, layout: { mode }, encoding };
+  const density = findUpstreamTransform(this, dataset, "density");
+  const horizon = findUpstreamTransform(this, dataset, "horizon");
+  let endpoint, offset, offsetScale, offsetChannel;
+  if (layer.mark.type === "area") {
+    if (horizon !== undefined) throw new Error("Horizon owns its layout; layoutSeries is not supported.");
+    if (mode === "group") throw new Error("Area does not support group layout.");
+    if (density !== undefined) layoutDensityAreaSeries(deriveDensityAreaSeries(dataset.values, updated, density), mode);
+    else {
+      if (mode !== "overlay" && encoding.x2 === undefined && encoding.y2 === undefined && encoding.y?.fieldType === "quantitative") {
+        endpoint = { channel: "y2", datum: 0, fieldType: "quantitative", scale: encoding.y.scale };
+        encoding.y2 = { datum: 0, fieldType: "quantitative", scale: encoding.y.scale };
+      }
+      if (encoding.x?.scale === undefined || encoding.y?.scale === undefined) throw new Error("Area layout requires complete positions.");
+      deriveAreaSeries(dataset.values, updated);
+    }
+  } else {
+    const channels = resolveBarChannels(updated), grain = resolveBarGrain(updated);
+    if (grain === undefined || encoding.x?.scale === undefined || encoding.y?.scale === undefined) throw new Error("Series layout requires a complete bar.");
+    if (mode === "center") throw new Error("Centered bars are not supported.");
+    if (grain === BAR_GRAINS.ranged && mode !== "overlay") throw new Error("Ranged bars support only overlay layout.");
+    if (grain === BAR_GRAINS.aggregate) deriveBarAggregates(dataset.values, updated);
+    if (mode === "group" && grain === BAR_GRAINS.aggregate) {
+      if (encoding.group === undefined) throw new Error("Grouped bars require a group encoding.");
+      readSeriesIdentity(dataset.values, updated);
+      offsetChannel = `${channels.category}Offset`;
+      offsetScale = resolveOffsetScaleDefinition(this, { id: encoding[offsetChannel]?.scale ?? offsetChannel }, offsetChannel);
+      offset = { ...(encoding.group.field === undefined ? {} : { field: encoding.group.field }), fieldType: encoding[offsetChannel]?.fieldType ?? "nominal", scale: offsetScale.id };
+      encoding[offsetChannel] = offset;
+    } else for (const channel of ["xOffset", "yOffset"]) delete encoding[channel];
+  }
+  const scales = offsetScale === undefined ? this.semanticSpec.scales
+    : [...this.semanticSpec.scales.filter(scale => scale.id !== offsetScale.id), offsetScale];
+  const preview = { ...this, markConfigs: this.markConfigs, canvasConfig: this.canvasConfig,
+    resolvedScales: { ...this.resolvedScales },
+    semanticSpec: { ...this.semanticSpec, scales,
+      layers: this.semanticSpec.layers.map(item => item.id === target ? updated : item) } };
+  for (const id of new Set([encoding.x?.scale, encoding.y?.scale, offset?.scale].filter(Boolean))) {
+    preview.resolvedScales[id] = resolveScalePreview(preview, id).resolvedScale;
+  }
+  let next = this.editSemantic({ property: `layer[${target}].layout.mode`, value: mode });
+  if (group === undefined && encoding.group !== undefined) next = setEncodingProperties(next, target, "group", encoding.group);
+  for (const channel of ["x", "y"]) if (Object.hasOwn(layer.encoding?.[channel] ?? {}, "stack")) {
+    next = next.editSemantic({ property: `layer[${target}].encoding.${channel}.stack`, remove: true });
+  }
+  if (color && Object.hasOwn(layer.encoding.color, "layout")) next = next.editSemantic({ property: `layer[${target}].encoding.color.layout`, remove: true });
+  if (endpoint !== undefined) {
+    next = next[endpoint.channel === "y2" ? "encodeY2" : "encodeX2"]({ target, datum: 0 });
+  }
+  if (layer.mark.type === "bar") {
+    for (const channel of ["xOffset", "yOffset"]) {
+      if (layer.encoding?.[channel] !== undefined) next = next.editSemantic({ property: `layer[${target}].encoding.${channel}`, remove: true });
+      if (channel !== offsetChannel) next = next._withoutMaterializationConfig(["marks", target, channel]);
+    }
+    if (offset !== undefined) {
+      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;
+      if (owned !== undefined) {
+        const referenced = hasSemanticScaleReferences(next.semanticSpec, owned);
+        if (!referenced) next = next.editSemantic({ property: `scale[${owned}]`, remove: true });
+        next = next._withoutMaterializationConfig(["marks", target, "seriesOffsetScale"]);
+      }
+    }
+  }
+  for (const step of getPositionEncodingMaterializationSteps(next, updated, encoding.y.scale)) next = next[step.op](step.args);
+  return next;
+});
+
+export function registerSeriesLayoutAction(ProgramClass) {
+  ProgramClass.prototype.layoutSeries = layoutSeries;
+}

package/src/actions/encodings/shared.js

@@ -1,15 +1,14 @@
+import { isSourceOwnedText } from "../../grammar/text.js";
 import { validateUserId } from "../../core/identifiers.js";
 import { findDataset } from "../../selectors/datasets.js";
 import { resolveEligibleLayer } from "../../selectors/layers.js";
 import { hasMaterializedLegend } from "../../materialization/legends.js";
-import { applyMaterializationPlan } from "../../materialization/dependencies.js";
+import { applyDetachedScaleRematerialization, applyMaterializationPlan } from "../../materialization/dependencies.js";
 import { planEncodingRematerialization } from "../../materialization/encodings.js";
 import { findSemanticScale } from "../../selectors/scales.js";
 import { validateOptionObject } from "../../core/validation.js";
-import {
-  getMarkGraphicTypes,
-  getPositionChannelDefinition
-} from "../../core/vocabulary.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);
@@ -31,11 +30,16 @@ export function setEncodingProperties(
   return next;
 }
 
-export function rematerializeEncoding(program, target, channel, scale) {
-  return applyMaterializationPlan(
+export { applyDetachedScaleRematerialization };
+
+export function rematerializeEncoding(program, target, channel, scale, previousLayer) {
+  const next = applyMaterializationPlan(
     program,
     planEncodingRematerialization(program, { target, channel, scale })
   );
+  return previousLayer === undefined
+    ? next
+    : applyDetachedScaleRematerialization(next, [previousLayer]);
 }
 
 export function clearMarkGraphic(program, target) {
@@ -50,19 +54,6 @@ export function clearMarkGraphic(program, target) {
 }
 
 
-export function validateLineSeriesCompatibility(layer, channel, field) {
-  if (layer.mark?.type !== "line") return;
-  for (const companion of ["group", "color", "strokeDash"]) {
-    if (companion === channel) continue;
-    const companionField = layer.encoding?.[companion]?.field;
-    if (companionField !== undefined && companionField !== field) {
-      throw new Error(
-        `Line ${channel} field "${field}" must match ${companion} field "${companionField}".`
-      );
-    }
-  }
-}
-
 export function resolveReassignmentScaleOptions(encoding, options) {
   if (encoding?.scale === undefined || options?.id !== undefined) return options;
   return { ...options, id: encoding.scale };
@@ -72,13 +63,14 @@ export function applyEncodingScale(
   program,
   definition,
   options = {},
-  { reassignment = false } = {}
+  { reassignment = false, allowTypeChange = false } = {}
 ) {
   const existing = findSemanticScale(program, definition.id);
   if (existing === undefined) {
     return program.createScale(definition);
   }
   if (existing.type !== definition.type) {
+    if (reassignment && allowTypeChange) return program.editScale({ ...definition });
     throw new Error(
       `Scale "${definition.id}" cannot change type from "${existing.type}" to "${definition.type}".`
     );
@@ -88,7 +80,7 @@ export function applyEncodingScale(
   for (const property of [
     "domain", "range", "nice", "zero", "clamp", "reverse",
     "base", "exponent", "constant", "paddingInner", "paddingOuter",
-    "padding", "align", "unknown", "interpolate"
+    "padding", "align", "unknown", "interpolate", "radialMapping"
   ]) {
     if (Object.hasOwn(options, property)) patch[property] = definition[property];
   }
@@ -114,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 && layer.encoding?.[channel]?.scale === previousScale
+    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
@@ -195,3 +254,14 @@ export function resolveTarget(
 
   return { id, dataset, layer };
 }
+
+export function inferSeriesGroup(program, layer, field, origin) {
+  const group = layer.encoding?.group;
+  if (group !== undefined && group.inferredFrom !== origin) {
+    if (origin === "offset" && (group.fields !== undefined || group.field !== field)) {
+      throw new Error("Offset field conflicts with the stored series group.");
+    }
+    return program;
+  }
+  return setEncodingProperties(program, layer.id, "group", { field, fieldType: "nominal", inferredFrom: origin });
+}