ggaction 0.0.10 → 0.0.12

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"
@@ -36,27 +36,39 @@ function createOffsetEncoding(channel) {
       const { id: target, dataset, layer } = resolveTarget(
         this,
         args.target,
-        ["bar"],
-        "bar mark"
+        ["bar", "point", "rule"],
+        "offset-compatible mark"
       );
 
-      const channels = resolveBarChannels(layer);
-      if (
-        resolveBarGrain(layer) === undefined ||
-        channels?.category !== parentChannel
-      ) {
-        throw new Error(
-          `${operation} requires a complete bar with a ${parentChannel} category encoding.`
-        );
-      }
-      if (
-        layer.encoding?.color !== undefined &&
-        (resolveBarColorLayout(layer) !== "group" ||
-          layer.encoding.color.field !== args.field)
-      ) {
-        throw new Error(
-          `${operation} field must match a grouped bar color field.`
-        );
+      if (layer.mark.type === "bar") {
+        const channels = resolveBarChannels(layer);
+        if (
+          resolveBarGrain(layer) === undefined ||
+          channels?.category !== parentChannel
+        ) {
+          throw new Error(
+            `${operation} requires a complete bar with a ${parentChannel} category encoding.`
+          );
+        }
+        if (
+          layer.encoding?.color !== undefined &&
+          (resolveBarColorLayout(layer) !== "group" ||
+            layer.encoding.color.field !== args.field)
+        ) {
+          throw new Error(
+            `${operation} field must match a grouped bar color field.`
+          );
+        }
+      } else {
+        const parent = layer.encoding?.[parentChannel];
+        if (
+          parent === undefined ||
+          !["nominal", "ordinal"].includes(parent.fieldType)
+        ) {
+          throw new Error(
+            `${operation} requires a ${parentChannel} category encoding (categorical position).`
+          );
+        }
       }
 
       readNominalField(dataset.values, args.field);
@@ -67,7 +79,7 @@ function createOffsetEncoding(channel) {
       const scale = resolveOffsetScaleDefinition(this, requestedScale, channel);
       if (Object.hasOwn(scale, "unknown")) {
         throw new Error(
-          `${channel} scale unknown is not supported for grouped bars.`
+          `${channel} scale unknown is not supported for offset positions.`
         );
       }
       const padding = normalizeOffsetPadding(
@@ -76,39 +88,23 @@ 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
         });
       next = applyEncodingScale(next, scale, requestedScale, {
         reassignment: layer.encoding?.[channel]?.scale === scale.id
       });
-      if (layer.encoding?.color === undefined) {
+      if (layer.mark.type === "bar" && layer.encoding?.color === undefined) {
         return next
           .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/apply.js

@@ -80,6 +80,28 @@ function applyArcThetaWeight(program, target, channel, previous, aggregate, weig
   });
 }
 
+function removeStaleArcThetaAggregate(
+  program,
+  target,
+  channel,
+  previous,
+  fieldType,
+  aggregate
+) {
+  if (
+    channel !== "theta" ||
+    fieldType !== "quantitative" ||
+    aggregate !== undefined ||
+    previous?.aggregate === undefined
+  ) {
+    return program;
+  }
+  return program.editSemantic({
+    property: `layer[${target}].encoding.theta.aggregate`,
+    remove: true
+  });
+}
+
 export function applyPositionSemantics(program, {
   target,
   channel,
@@ -124,6 +146,14 @@ export function applyPositionSemantics(program, {
       value
     });
   }
+  next = removeStaleArcThetaAggregate(
+    next,
+    target,
+    channel,
+    previous,
+    fieldType,
+    aggregate
+  );
   return applyArcThetaWeight(
     next,
     target,

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

@@ -2,7 +2,7 @@ import { validateAggregate } from "../../../../grammar/aggregate.js";
 import { validateNonEmptyString } from "../../../../core/validation.js";
 import { emptyPositionPolicy } from "./common.js";
 
-export function resolveArcPositionPolicy({ channel, args, fieldType }) {
+export function resolveArcPositionPolicy({ channel, args, fieldType, layer }) {
   if (args.bin !== undefined) {
     throw new Error(`Arc ${channel} encoding does not support bin.`);
   }
@@ -10,6 +10,11 @@ export function resolveArcPositionPolicy({ channel, args, fieldType }) {
     throw new Error(`Arc ${channel} encoding does not support stack.`);
   }
   if (channel === "radius") {
+    if (layer.encoding?.theta?.fieldType === "quantitative") {
+      throw new Error(
+        "Arc radius encoding cannot be combined with quantitative theta."
+      );
+    }
     if (args.aggregate !== undefined) {
       throw new Error("Arc radius encoding does not support aggregate.");
     }
@@ -18,8 +23,24 @@ export function resolveArcPositionPolicy({ channel, args, fieldType }) {
     }
     return emptyPositionPolicy();
   }
+  if (fieldType === "quantitative") {
+    if (layer.encoding?.radius !== undefined) {
+      throw new Error(
+        "Quantitative arc theta cannot be combined with radius encoding."
+      );
+    }
+    if (args.aggregate !== undefined) {
+      throw new Error("Quantitative arc theta does not support aggregate.");
+    }
+    if (args.weight !== undefined) {
+      throw new Error("Quantitative arc theta does not support weight.");
+    }
+    return emptyPositionPolicy();
+  }
   if (!["ordinal", "nominal"].includes(fieldType)) {
-    throw new Error("Arc theta encoding requires an ordinal or nominal field.");
+    throw new Error(
+      "Arc theta encoding requires a quantitative, ordinal, or nominal field."
+    );
   }
   if (args.aggregate === undefined) {
     if (args.weight !== undefined) {

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,
@@ -21,7 +22,10 @@ import {
   validateAggregateFieldValues,
 } from "../../../grammar/aggregate.js";
 import { normalizeRuleDatum } from "../../../grammar/rules.js";
-import { readArcThetaWeights } from "../../../grammar/arcs.js";
+import {
+  readArcThetaValues,
+  readArcThetaWeights
+} from "../../../grammar/arcs.js";
 import { resolveMarkPositionPolicy } from "./policies/index.js";
 import {
   getPositionChannelDefinition,
@@ -33,6 +37,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 +106,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 +114,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"
@@ -119,9 +131,14 @@ export function resolvePositionEncoding(program, channel, args, operation) {
     : args.field;
   const datum = args.datum;
   const effectiveArgs = { ...args };
+  const directQuantitativeArcTheta =
+    layer.mark.type === "arc" &&
+    channel === "theta" &&
+    fieldType === "quantitative";
   for (const property of ["aggregate", "bin", "stack"]) {
     if (!Object.hasOwn(effectiveArgs, property) && previous !== undefined &&
-      Object.hasOwn(previous, property)) {
+      Object.hasOwn(previous, property) &&
+      !(directQuantitativeArcTheta && property === "aggregate")) {
       effectiveArgs[property] = previous[property];
     }
   }
@@ -169,6 +186,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 +196,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" &&
@@ -201,6 +228,8 @@ export function resolvePositionEncoding(program, channel, args, operation) {
     policy.aggregate === "sum"
   ) {
     readArcThetaWeights(dataset.values, policy.weight, layer.id);
+  } else if (directQuantitativeArcTheta) {
+    readArcThetaValues(dataset.values, field, layer.id);
   } else if (program.markConfigs[target]?.boxPlot !== undefined) {
     for (const [index, row] of dataset.values.entries()) {
       const value = row[field];