ggaction 0.0.9 → 0.0.11

package/src/actions/encodings/density.js

@@ -15,7 +15,7 @@ import { planDerivedDataRevision } from
 import { validateOptions } from "./shared.js";
 import { normalizeDensityPlacement } from "../../grammar/density.js";
 import { scaleEditPatch } from "../scales/patch.js";
-import { removeLegendKinds } from "../guides/legends/remove.js";
+import { removeOwnedColorLegends } from "../guides/legends/remove.js";
 import {
   requireDensityField,
   resolveDensityCategoryScaleOptions,
@@ -215,19 +215,6 @@ function assertGroupingSelectionCompatibility(program, layer, changesGroup) {
   }
 }
 
-function removeOwnedColorLegends(program, target) {
-  const kinds = Object.entries(program.guideConfigs.legend ?? {})
-    .filter(([kind, config]) =>
-      config?.target === target &&
-      (
-        config.channels?.includes("color") ||
-        ["gradient", "interval"].includes(kind)
-      )
-    )
-    .map(([kind]) => kind);
-  return kinds.length === 0 ? program : removeLegendKinds(program, kinds);
-}
-
 const editDensity = action(
   {
     op: "editDensity",
@@ -454,7 +441,6 @@ const editDensity = action(
       }
       return next;
     };
-    applyEdit(this);
     return applyEdit(this);
   }
 );

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

@@ -167,7 +167,11 @@ export function resolveHorizonPaletteColors(transform) {
   for (const sign of ["negative", "positive"]) {
     const palette = transform.palette[sign];
     const dense = palette.count === undefined && transform.bands > 1
-      ? resolvePalette({ ...palette, count: transform.bands * 2 }, transform.bands * 2)
+      ? resolvePalette(
+          { ...palette, count: transform.bands * 2 },
+          transform.bands * 2,
+          transform.bands * 2
+        )
       : resolvePalette(palette, transform.bands);
     const colors = palette.count === undefined && transform.bands > 1
       ? Array.from({ length: transform.bands }, (_, index) =>
@@ -181,11 +185,17 @@ export function resolveHorizonPaletteColors(transform) {
   return { domain, range };
 }
 
-export function resolveFoldedHorizonScaleOptions(target, requested) {
+export function resolveFoldedHorizonScaleOptions(target, requested, existing = {}) {
   if (requested !== undefined && !isPlainObject(requested)) {
     throw new TypeError("Horizon y scale must be a plain object.");
   }
-  const options = requested ?? {};
+  const patch = requested ?? {};
+  validateOptionObject(
+    patch,
+    ["id", "type", "domain", "range", "clamp", "reverse"],
+    "Horizon y scale"
+  );
+  const options = { ...existing, ...patch };
   if (
     options.domain !== undefined &&
     (!Array.isArray(options.domain) ||

package/src/actions/encodings/horizon.js

@@ -5,6 +5,7 @@ import {
   deriveHorizon,
   validateHorizonTransform
 } from "../../grammar/horizon.js";
+import { numericExtent } from "../../grammar/numeric.js";
 import {
   normalizeTemporalValue,
   readQuantitativeField
@@ -217,7 +218,7 @@ const editHorizon = action(
       id: currentX.id,
       ...(emptyXDomain === undefined
         ? {}
-        : { domain: [Math.min(...emptyXDomain), Math.max(...emptyXDomain)] }),
+        : { domain: numericExtent(emptyXDomain) }),
       ...(xTypeChanged && requestedXScale.type === undefined
         ? { type: x.fieldType === "temporal" ? "time" : "linear" }
         : {})
@@ -233,11 +234,11 @@ const editHorizon = action(
     if (requestedYScale.id !== undefined && requestedYScale.id !== currentY.id) {
       throw new Error("editHorizon y scale cannot change its id.");
     }
-    const nextY = resolveFoldedHorizonScaleOptions(layer.id, {
-      ...currentY,
-      ...requestedYScale,
-      id: currentY.id
-    });
+    const nextY = resolveFoldedHorizonScaleOptions(
+      layer.id,
+      { ...requestedYScale, id: currentY.id },
+      currentY
+    );
     next = applyScaleDefinition(next, currentY, nextY);
 
     const colors = resolveHorizonPaletteColors(candidate);
@@ -314,7 +315,7 @@ const encodeHorizon = action(
         : {})
     };
     if (Array.isArray(xScale.domain) && xScale.domain.length > 2) {
-      xScale.domain = [Math.min(...xScale.domain), Math.max(...xScale.domain)];
+      xScale.domain = numericExtent(xScale.domain);
     }
     const yScale = resolveFoldedHorizonScaleOptions(layer.id, y.scale);
     const colors = resolveHorizonPaletteColors(transform);

package/src/actions/encodings/index.js

@@ -1,18 +1,18 @@
-import { registerAppearanceEncodingAction } from "./appearance.js";
-import { registerAngleEncodingAction } from "./angle.js";
-import { registerBarWidthEncodingAction } from "./barWidth.js";
-import { registerColorEncodingAction } from "./color/index.js";
 import { registerDensityEncodingAction } from "./density.js";
-import { registerHistogramEncodingAction } from "./histogram.js";
-import { registerHorizonEncodingAction } from "./horizon.js";
-import { registerOffsetEncodingAction } from "./offset.js";
 import { registerPathOrderEncodingActions } from "./pathOrder.js";
+import { registerHorizonEncodingAction } from "./horizon.js";
+import { registerHistogramEncodingAction } from "./histogram.js";
 import { registerPositionEncodingActions } from "./position/index.js";
 import { registerRangedEncodingActions } from "./ranged.js";
+import { registerAngleEncodingAction } from "./angle.js";
+import { registerOffsetEncodingAction } from "./offset.js";
+import { registerParallelEncodingAction } from "./parallel.js";
+import { registerColorEncodingAction } from "./color/index.js";
+import { registerTextEncodingAction } from "./text.js";
+import { registerAppearanceEncodingAction } from "./appearance.js";
 import { registerStrokeDashEncodingActions } from "./strokeDash.js";
 import { registerRuleAppearanceEncodingActions } from "./ruleAppearance.js";
-import { registerTextEncodingAction } from "./text.js";
-import { registerParallelEncodingAction } from "./parallel.js";
+import { registerBarWidthEncodingAction } from "./barWidth.js";
 import { registerEncodingRemovalAction } from "./remove.js";
 
 export function registerEncodingActions(ProgramClass) {

package/src/actions/encodings/offset.js

@@ -6,8 +6,10 @@ import {
 import { resolveOffsetScaleDefinition } from "../scales/definitions.js";
 import {
   applyEncodingScale,
+  rematerializeEncoding,
   resolveReassignmentScaleOptions,
   resolveTarget,
+  setEncodingProperties,
   validateOptions
 } from "./shared.js";
 import {
@@ -16,8 +18,6 @@ import {
   resolveBarGrain
 } from "../../grammar/bars/policy.js";
 import { normalizeOffsetPadding } from "../../grammar/bars/geometry.js";
-import { applyMaterializationPlan } from "../../materialization/dependencies.js";
-import { planEncodingRematerialization } from "../../materialization/encodings.js";
 
 const ENCODING_OPTIONS = Object.freeze([
   "field", "target", "fieldType", "scale", "paddingInner", "paddingOuter"
@@ -76,20 +76,11 @@ function createOffsetEncoding(channel) {
         channel
       );
 
-      let next = this
-        .editSemantic({
-          property: `layer[${target}].encoding.${channel}.field`,
-          value: args.field
-        })
-        .editSemantic({
-          property: `layer[${target}].encoding.${channel}.fieldType`,
-          value: fieldType
-        })
-        .editSemantic({
-          property: `layer[${target}].encoding.${channel}.scale`,
-          value: scale.id
-        })
-        ._withMarkConfig(target, {
+      let next = setEncodingProperties(this, target, channel, {
+        field: args.field,
+        fieldType,
+        scale: scale.id
+      })._withMarkConfig(target, {
           ...this.markConfigs[target],
           [channel]: padding
         });
@@ -101,14 +92,7 @@ function createOffsetEncoding(channel) {
           .rematerializeScale({ id: scale.id })
           .editGraphics({ target, property: "length", value: 0 });
       }
-      return applyMaterializationPlan(
-        next,
-        planEncodingRematerialization(next, {
-          target,
-          channel,
-          scale: scale.id
-        })
-      );
+      return rematerializeEncoding(next, target, channel, scale.id);
     }
   );
 }

package/src/actions/encodings/parallel.js

@@ -7,7 +7,11 @@ import {
   validateParallelRows
 } from "../../grammar/parallelCoordinates.js";
 import { resolvePositionScaleDefinition } from "../scales/definitions.js";
-import { applyEncodingScale, resolveTarget } from "./shared.js";
+import {
+  applyEncodingScale,
+  resolveTarget,
+  setEncodingProperties
+} from "./shared.js";
 import { resolveParallelCoordinate } from "../coordinates/parallel.js";
 
 const OPTIONS = Object.freeze([
@@ -76,15 +80,10 @@ export const encodeParallelCoordinates = action(
         value: coordinate.id
       });
     }
-    next = next
-      .editSemantic({
-        property: `layer[${target}].encoding.parallel.dimensions`,
-        value: storedDimensions
-      })
-      .editSemantic({
-        property: `layer[${target}].encoding.parallel.missing`,
-        value: missing
-      });
+    next = setEncodingProperties(next, target, "parallel", {
+      dimensions: storedDimensions,
+      missing
+    });
     if (key === undefined && layer.encoding?.parallel?.key !== undefined) {
       next = next.editSemantic({
         property: `layer[${target}].encoding.parallel.key`,

package/src/actions/encodings/pathOrder.js

@@ -15,6 +15,7 @@ import {
   canMaterializeLine
 } from "../../materialization/marks/index.js";
 import { findLayer } from "../../selectors/layers.js";
+import { setEncodingProperties } from "./shared.js";
 
 const ENCODE_OPTIONS = Object.freeze([
   "target", "field", "fieldType", "order"
@@ -92,19 +93,11 @@ const encodePathOrder = action(
     const dataset = assertPathOrderCompatible(this, layer, "encodePathOrder");
     readQuantitativeField(dataset.values, field);
 
-    const next = this
-      .editSemantic({
-        property: `layer[${layer.id}].encoding.pathOrder.field`,
-        value: field
-      })
-      .editSemantic({
-        property: `layer[${layer.id}].encoding.pathOrder.fieldType`,
-        value: fieldType
-      })
-      .editSemantic({
-        property: `layer[${layer.id}].encoding.pathOrder.order`,
-        value: order
-      });
+    const next = setEncodingProperties(this, layer.id, "pathOrder", {
+      field,
+      fieldType,
+      order
+    });
     return rematerializePath(next, findLayer(next, layer.id));
   }
 );

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

@@ -1,15 +1,15 @@
-import { validatePositionFieldCompatibility } from
-  "../../../../grammar/positionCompatibility.js";
+import { resolveTickPositionPolicy } from "./tick.js";
 import {
   isCategoricalDensityPosition,
   resolveAreaPositionPolicy
 } from "./area.js";
-import { resolveArcPositionPolicy } from "./arc.js";
 import { resolveBarPositionPolicy } from "./bar.js";
 import { resolveLinePositionPolicy } from "./line.js";
 import { resolvePointPositionPolicy } from "./point.js";
 import { resolveRulePositionPolicy } from "./rule.js";
-import { resolveTickPositionPolicy } from "./tick.js";
+import { resolveArcPositionPolicy } from "./arc.js";
+import { validatePositionFieldCompatibility } from
+  "../../../../grammar/positionCompatibility.js";
 
 const POSITION_POLICIES = Object.freeze({
   area: resolveAreaPositionPolicy,

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

@@ -2,17 +2,20 @@ import {
   validateAggregate,
   validateAggregateFieldType
 } from "../../../../grammar/aggregate.js";
-import { emptyPositionPolicy } from "./common.js";
+import { emptyPositionPolicy, resolveBin } from "./common.js";
 
-function rejectSharedOptions(args, channel) {
-  if (args.bin !== undefined) {
-    throw new Error(`Line ${channel} encoding does not support bin.`);
-  }
+function rejectStack(args, channel) {
   if (args.stack !== undefined) {
     throw new Error(`Line ${channel} encoding does not support stack.`);
   }
 }
 
+function rejectBin(args, channel) {
+  if (args.bin !== undefined) {
+    throw new Error(`Line ${channel} encoding does not support bin.`);
+  }
+}
+
 export function resolveLinePositionPolicy({
   program,
   layer,
@@ -27,7 +30,8 @@ export function resolveLinePositionPolicy({
     if (config.curve !== undefined && config.curve !== "linear") {
       throw new Error("Polar line position currently requires curve \"linear\".");
     }
-    rejectSharedOptions(args, channel);
+    rejectBin(args, channel);
+    rejectStack(args, channel);
     if (args.aggregate !== undefined) {
       throw new Error(`Line ${channel} encoding does not support aggregate.`);
     }
@@ -44,6 +48,26 @@ export function resolveLinePositionPolicy({
   );
 
   if (channel === "x") {
+    rejectStack(args, "x");
+    if (args.aggregate !== undefined) {
+      throw new Error("Line x encoding does not support aggregate.");
+    }
+    if (args.bin !== undefined) {
+      if (fieldType !== "quantitative") {
+        throw new Error("Binned line x encoding requires a quantitative field.");
+      }
+      if (
+        layer.encoding?.y !== undefined &&
+        layer.encoding.y.aggregate === undefined
+      ) {
+        throw new Error("Binned line x encoding requires an aggregate y encoding.");
+      }
+      return {
+        bin: resolveBin(args.bin),
+        aggregate: undefined,
+        stack: undefined
+      };
+    }
     const directPair =
       layer.encoding?.y?.aggregate === undefined &&
       ["quantitative", "temporal"].includes(layer.encoding?.y?.fieldType) &&
@@ -61,17 +85,18 @@ export function resolveLinePositionPolicy({
         "Line x encoding requires a temporal field or a compatible derived quantitative field."
       );
     }
-    if (args.aggregate !== undefined) {
-      throw new Error("Line x encoding does not support aggregate.");
-    }
-    rejectSharedOptions(args, "x");
     return emptyPositionPolicy();
   }
 
-  rejectSharedOptions(args, "y");
+  rejectBin(args, "y");
+  rejectStack(args, "y");
+  if (layer.encoding?.x?.bin !== undefined && args.aggregate === undefined) {
+    throw new Error("Binned line x encoding requires an aggregate y encoding.");
+  }
   const quantitativePair =
     fieldType === "quantitative" &&
-    layer.encoding?.x?.fieldType === "quantitative";
+    layer.encoding?.x?.fieldType === "quantitative" &&
+    layer.encoding.x.bin === undefined;
   const prospectiveDirect =
     args.aggregate === undefined &&
     (fieldType === "temporal" ||
@@ -98,11 +123,16 @@ export function resolveLinePositionPolicy({
     return emptyPositionPolicy();
   }
 
-  if (
-    layer.encoding?.x !== undefined &&
-    layer.encoding.x.fieldType !== "temporal"
-  ) {
-    throw new Error("Aggregate line y encoding requires a temporal x encoding.");
+  if (layer.encoding?.x !== undefined) {
+    const compatibleAggregateX =
+      layer.encoding.x.fieldType === "temporal" ||
+      (layer.encoding.x.fieldType === "quantitative" &&
+        layer.encoding.x.bin !== undefined);
+    if (!compatibleAggregateX) {
+      throw new Error(
+        "Aggregate line y encoding requires a temporal or binned quantitative x encoding."
+      );
+    }
   }
 
   const aggregate = validateAggregate(args.aggregate);

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

@@ -1,6 +1,7 @@
 import { validateUserId } from "../../../core/identifiers.js";
 import { getPositionCoordinateDefaults } from "../../../grammar/coordinates.js";
 import {
+  isNominalValue,
   readNominalField,
   readQuantitativeField,
   readScaleField,
@@ -33,6 +34,12 @@ const POSITION_ENCODING_OPTIONS = Object.freeze([
   "aggregate", "bin", "stack", "weight"
 ]);
 
+function inferRuleDatumFieldType(datum, operation) {
+  if (Number.isFinite(datum)) return "quantitative";
+  if (isNominalValue(datum)) return "nominal";
+  throw new Error(`${operation} datum requires an explicit fieldType.`);
+}
+
 function validateCoordinateFamily(layer, channel, operation) {
   const family = getPositionChannelDefinition(channel).family;
   const incompatible = positionChannelsForFamily(
@@ -96,7 +103,7 @@ export function resolvePositionEncoding(program, channel, args, operation) {
     if (hasField === hasDatum) {
       throw new Error(`${operation} requires exactly one of field or datum for a rule mark.`);
     }
-    if (args.fieldType === undefined) {
+    if (hasField && args.fieldType === undefined) {
       throw new Error(`${operation} requires fieldType for a rule mark.`);
     }
   } else if (hasDatum) {
@@ -104,10 +111,12 @@ export function resolvePositionEncoding(program, channel, args, operation) {
   }
   const previous = layer.encoding?.[channel];
   const requestedFieldType = args.fieldType ?? previous?.fieldType ?? (
-    layer.mark.type === "arc" && channel === "theta" &&
-      ["count", "sum"].includes(args.aggregate)
-      ? "nominal"
-      : "quantitative"
+    layer.mark.type === "rule" && hasDatum
+      ? inferRuleDatumFieldType(args.datum, operation)
+      : layer.mark.type === "arc" && channel === "theta" &&
+          ["count", "sum"].includes(args.aggregate)
+        ? "nominal"
+        : "quantitative"
   );
   const fieldType = requestedFieldType === "nominal"
     ? "nominal"
@@ -169,6 +178,8 @@ export function resolvePositionEncoding(program, channel, args, operation) {
         : fieldType === "temporal"
           ? { nice: true }
           : { discreteType: "band" }
+      : layer.mark.type === "line" && channel === "x" && policy.bin !== undefined
+        ? { nice: true, zero: false }
       : ["ordinal", "nominal"].includes(fieldType)
         ? {
             discreteType: ["arc", "rect"].includes(layer.mark.type)
@@ -177,6 +188,14 @@ export function resolvePositionEncoding(program, channel, args, operation) {
           }
         : {}
   );
+  if (
+    layer.mark.type === "bar" &&
+    program.markConfigs[target]?.boxPlot === undefined &&
+    scale.type === "log" &&
+    policy.bin === undefined
+  ) {
+    throw new Error('Bar scale type "log" does not support zero baselines.');
+  }
   if (
     layer.mark.type === "arc" &&
     channel === "theta" &&

package/src/actions/encodings/ranged.js

@@ -11,11 +11,13 @@ import {
 import { normalizeRuleDatum } from "../../grammar/rules.js";
 import {
   canMaterializeArea,
-  canMaterializeLine
+  canMaterializeLine,
+  getPositionEncodingMaterializationSteps
 } from "../../materialization/marks/index.js";
 import { findLayer } from "../../selectors/layers.js";
 import {
   resolveTarget,
+  setEncodingProperties,
   validateLineSeriesCompatibility,
   validateOptions
 } from "./shared.js";
@@ -138,28 +140,21 @@ function encodeSecondaryPosition(program, channel, args, operation, types) {
       });
     }
   }
-  next = next
-    .editSemantic({
-      property: `layer[${target}].encoding.${channel}.${hasField ? "field" : "datum"}`,
-      value: hasField ? args.field : args.datum
-    })
-    .editSemantic({
-      property: `layer[${target}].encoding.${channel}.fieldType`,
-      value: fieldType
-    })
-    .editSemantic({
-      property: `layer[${target}].encoding.${channel}.scale`,
-      value: primary.scale
-    })
-    .rematerializeScale({ id: primary.scale });
-  if (rule) return next.rematerializeRuleMark({ id: target });
-  return layer.mark.type === "bar"
-    ? next.rematerializeBarMark({ id: target })
-    : layer.mark.type === "rect"
-      ? next.rematerializeRectMark({ id: target })
-      : canMaterializeArea(next, findLayer(next, target))
-        ? next.rematerializeAreaMark({ id: target })
-        : next;
+  next = setEncodingProperties(next, target, channel, {
+    [hasField ? "field" : "datum"]: hasField ? args.field : args.datum,
+    fieldType,
+    scale: primary.scale
+  });
+
+  const updated = findLayer(next, target);
+  for (const step of getPositionEncodingMaterializationSteps(
+    next,
+    updated,
+    primary.scale
+  )) {
+    next = next[step.op](step.args);
+  }
+  return next;
 }
 
 const encodeX2 = action(

package/src/actions/encodings/remove.js

@@ -16,6 +16,7 @@ import {
 } from "../../materialization/marks/index.js";
 import { findLayer } from "../../selectors/layers.js";
 import { removeLegendKinds } from "../guides/legends/remove.js";
+import { clearMarkGraphic } from "./shared.js";
 
 const OPTIONS = Object.freeze(["target", "channel"]);
 const REMOVABLE_CHANNELS = Object.freeze([
@@ -35,6 +36,10 @@ const SPECIALIZED_LEGEND_KIND = Object.freeze({
   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(
@@ -178,22 +183,15 @@ function reconcileCategoricalLegend(program, target, channels) {
     return removeLegendKinds(program, [kind]);
   }
   const next = removeLegendKinds(program, [kind]);
-  return next.createLegend({
-    target,
-    channels: remaining,
-    position: config.position,
-    align: config.align,
-    direction: config.direction,
-    ...(config.columns === undefined ? {} : { columns: config.columns }),
-    offset: config.offset,
-    titlePosition: config.titlePosition,
-    ...(config.inferredTitle ? {} : { title: config.title }),
-    symbol: config.symbol,
-    labels: config.labels,
-    titleStyle: config.titleStyle,
-    itemGap: config.itemGap,
-    border: config.border
-  });
+  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);
 }
 
 function cleanupLegends(program, target, channels) {
@@ -204,18 +202,10 @@ function cleanupLegends(program, target, channels) {
   return kinds.length === 0 ? next : removeLegendKinds(next, kinds);
 }
 
-function clearGraphic(program, target) {
-  const graphic = program.graphicSpec.objects[target];
-  if (graphic === undefined) return program;
-  return graphic.type === "collection"
-    ? program.editGraphics({ target, property: "items", value: [] })
-    : program.editGraphics({ target, property: "length", value: 0 });
-}
-
 function rematerializeTarget(program, target) {
   const layer = findLayer(program, target);
   const step = getMarkMaterializationStep(program, layer);
-  const baseline = clearGraphic(program, target);
+  const baseline = clearMarkGraphic(program, target);
   let next = step === undefined
     ? baseline
     : baseline[step.op](step.args);

package/src/actions/encodings/ruleAppearance.js

@@ -7,12 +7,12 @@ import { readQuantitativeField } from "../../grammar/scales/index.js";
 import { resolveStrokeWidthScaleDefinition } from "../scales/definitions.js";
 import {
   applyEncodingScale,
+  rematerializeEncoding,
   resolveReassignmentScaleOptions,
   resolveTarget,
+  setEncodingProperties,
   validateOptions
 } from "./shared.js";
-import { applyMaterializationPlan } from "../../materialization/dependencies.js";
-import { planEncodingRematerialization } from "../../materialization/encodings.js";
 import { findLayer } from "../../selectors/layers.js";
 
 const STROKE_OPTIONS = Object.freeze(["target", "value"]);
@@ -91,31 +91,16 @@ const encodeStrokeWidth = action(
     const scale = resolveStrokeWidthScaleDefinition(this, requestedScale);
     const { strokeWidth, ...config } = this.markConfigs[id] ?? {};
     void strokeWidth;
-    let next = this
-      ._withMarkConfig(id, config)
-      .editSemantic({
-        property: `layer[${id}].encoding.strokeWidth.field`,
-        value: args.field
-      })
-      .editSemantic({
-        property: `layer[${id}].encoding.strokeWidth.fieldType`,
-        value: fieldType
-      })
-      .editSemantic({
-        property: `layer[${id}].encoding.strokeWidth.scale`,
-        value: scale.id
-      });
+    let next = setEncodingProperties(
+      this._withMarkConfig(id, config),
+      id,
+      "strokeWidth",
+      { field: args.field, fieldType, scale: scale.id }
+    );
     next = applyEncodingScale(next, scale, requestedScale, {
       reassignment: previous?.scale === scale.id
     });
-    return applyMaterializationPlan(
-      next,
-      planEncodingRematerialization(next, {
-        target: id,
-        channel: "strokeWidth",
-        scale: scale.id
-      })
-    );
+    return rematerializeEncoding(next, id, "strokeWidth", scale.id);
   }
 );