ggaction 0.0.17 → 0.0.18

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

@@ -1,12 +1,7 @@
+export { requireStringValue as requireDensityField } from "../../../core/validation.js";
 import { isPlainObject } from "../../../core/immutable.js";
 import { findSemanticScale } from "../../../selectors/scales.js";
 
-export function requireDensityField(value, label) {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new TypeError(`${label} must be a non-empty string.`);
-  }
-  return value;
-}
 
 export function resolveDensityScaleOptions(value, defaults, label) {
   if (value !== undefined && !isPlainObject(value)) {

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

@@ -11,11 +11,6 @@ export function resolveArcPositionPolicy({ channel, args, fieldType, layer }) {
     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.mapping !== undefined) {
       validateRadialMapping(args.mapping);
       if (fieldType !== "quantitative" || !["count", "sum"].includes(args.aggregate)) {
@@ -30,7 +25,16 @@ export function resolveArcPositionPolicy({ channel, args, fieldType, layer }) {
       return { ...emptyPositionPolicy(), aggregate: args.aggregate };
     }
     if (args.aggregate !== undefined) {
-      throw new Error("Arc radius encoding does not support aggregate.");
+      if (!["count", "sum"].includes(args.aggregate)) throw new Error("Arc radius aggregate supports count or sum.");
+      const theta = layer.encoding?.theta;
+      if (theta !== undefined && !["count", "sum"].includes(theta.aggregate)) {
+        throw new Error("Grouped arc radius requires aggregated categorical theta.");
+      }
+      if (args.aggregate === "count" && Object.hasOwn(args, "field")) {
+        throw new Error("Arc radius count does not accept a field.");
+      }
+      if (args.weight !== undefined) throw new Error("Arc radius encoding does not support weight.");
+      return { ...emptyPositionPolicy(), aggregate: args.aggregate };
     }
     if (args.weight !== undefined) {
       throw new Error("Arc radius encoding does not support weight.");
@@ -38,10 +42,8 @@ export function resolveArcPositionPolicy({ channel, args, fieldType, layer }) {
     return emptyPositionPolicy();
   }
   if (fieldType === "quantitative") {
-    if (layer.encoding?.radius !== undefined) {
-      throw new Error(
-        "Quantitative arc theta cannot be combined with radius encoding."
-      );
+    if (layer.encoding?.radius?.aggregate !== undefined) {
+      throw new Error("Grouped arc radius requires aggregated categorical theta.");
     }
     if (args.aggregate !== undefined) {
       throw new Error("Quantitative arc theta does not support aggregate.");

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

@@ -26,16 +26,16 @@ export function resolveAreaPositionPolicy({
   const density = dataset.transform?.find(transform => transform.type === "density");
   if (["nominal", "ordinal"].includes(fieldType)) {
     if (
-      density?.placement?.type !== "category" ||
+      density !== undefined && (density.placement?.type !== "category" ||
       density.placement.channel !== channel ||
-      density.placement.categoryField !== field
+      density.placement.categoryField !== field)
     ) {
       throw new Error(
         "Categorical area position requires a matching category density placement."
       );
     }
     if (args.aggregate !== undefined || args.bin !== undefined || args.stack !== undefined) {
-      throw new Error("Categorical density position does not support aggregate, bin, or stack.");
+      throw new Error("Categorical area position does not support aggregate, bin, or stack.");
     }
     return emptyPositionPolicy();
   }

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

@@ -26,7 +26,15 @@ function resolveBarChannelPolicy({
   let stack;
   const xEncoding = layer.encoding?.x;
   const opposite = layer.encoding?.[channel === "x" ? "y" : "x"];
-  const pendingBoxRange = program.markConfigs[layer.id]?.boxPlot !== undefined;
+  const pendingRange = program.markConfigs[layer.id]?.boxPlot !== undefined ||
+    layer.encoding?.[`${channel}2`] !== undefined;
+
+  if (layer.mark?.orientation !== undefined) {
+    if (fieldType !== "quantitative" || ["bin", "aggregate", "stack", "weight"].some(key => args[key] !== undefined)) {
+      throw new Error("Oriented numeric bars require raw quantitative positions without bin, aggregate, stack, or weight.");
+    }
+    return { bin, aggregate, stack };
+  }
 
   if (["nominal", "ordinal", "temporal"].includes(fieldType)) {
     if (args.aggregate !== undefined || args.bin !== undefined || args.stack !== undefined) {
@@ -73,11 +81,11 @@ function resolveBarChannelPolicy({
     }
     aggregate = args.aggregate ?? (
       ["nominal", "ordinal", "temporal"].includes(opposite?.fieldType) &&
-      !pendingBoxRange
+      !pendingRange
         ? "mean"
         : undefined
     );
-    if (pendingBoxRange && args.aggregate === undefined) {
+    if (pendingRange && args.aggregate === undefined) {
       return { bin, aggregate, stack };
     }
     stack = Object.hasOwn(args, "stack") ? args.stack : opposite === undefined ? undefined : null;
@@ -106,7 +114,8 @@ export function resolveBarPositionPolicy(context) {
   const policy = resolveBarChannelPolicy(context);
   const oppositeChannel = channel === "x" ? "y" : "x";
   const opposite = layer.encoding?.[oppositeChannel];
-  const pendingBoxRange = program.markConfigs[layer.id]?.boxPlot !== undefined;
+  const pendingRange = program.markConfigs[layer.id]?.boxPlot !== undefined ||
+    layer.encoding?.[`${channel}2`] !== undefined;
   const candidate = {
     ...layer,
     encoding: {
@@ -118,7 +127,7 @@ export function resolveBarPositionPolicy(context) {
   // Absence of an aggregate/stack is sufficient to represent an unresolved role.
   let companion;
   if (
-    !pendingBoxRange && resolveBarGrain(layer) === undefined &&
+    !pendingRange && resolveBarGrain(layer) === undefined &&
     opposite?.fieldType === "quantitative" && opposite.bin === undefined
   ) {
     const resolved = resolveBarChannelPolicy({
@@ -138,7 +147,7 @@ export function resolveBarPositionPolicy(context) {
     }
   }
   const orientation = resolveBarOrientation(candidate);
-  if (opposite !== undefined && orientation === undefined && !pendingBoxRange) {
+  if (opposite !== undefined && orientation === undefined && !pendingRange) {
     throw new Error(
       `Bar ${channel} encoding requires a quantitative field opposite a categorical position.`
     );

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

@@ -68,6 +68,13 @@ export function resolveLinePositionPolicy({
         stack: undefined
       };
     }
+    if (["nominal", "ordinal"].includes(fieldType)) {
+      if (layer.encoding?.y !== undefined && layer.encoding.y.aggregate === undefined &&
+          layer.encoding.y.fieldType !== "quantitative") {
+        throw new Error("Categorical line x requires a quantitative value or aggregate y encoding.");
+      }
+      return emptyPositionPolicy();
+    }
     const directPair =
       layer.encoding?.y?.aggregate === undefined &&
       ["quantitative", "temporal"].includes(layer.encoding?.y?.fieldType) &&
@@ -82,7 +89,7 @@ export function resolveLinePositionPolicy({
       )
     ) {
       throw new Error(
-        "Line x encoding requires a temporal field or a compatible derived quantitative field."
+        "Line x encoding requires a categorical or temporal field, or a compatible quantitative field."
       );
     }
     return emptyPositionPolicy();
@@ -93,15 +100,19 @@ export function resolveLinePositionPolicy({
   if (layer.encoding?.x?.bin !== undefined && args.aggregate === undefined) {
     throw new Error("Binned line x encoding requires an aggregate y encoding.");
   }
-  const quantitativePair =
+  if (["nominal", "ordinal"].includes(layer.encoding?.x?.fieldType) &&
+      args.aggregate === undefined && fieldType !== "quantitative") {
+    throw new Error("Categorical line x requires a quantitative value or aggregate y encoding.");
+  }
+  const continuousPair =
     fieldType === "quantitative" &&
-    layer.encoding?.x?.fieldType === "quantitative" &&
+    ["quantitative", "temporal", "nominal", "ordinal"].includes(layer.encoding?.x?.fieldType) &&
     layer.encoding.x.bin === undefined;
   const prospectiveDirect =
     args.aggregate === undefined &&
     (fieldType === "temporal" ||
       (fieldType === "quantitative" &&
-        (layer.encoding?.x === undefined || quantitativePair)));
+        (layer.encoding?.x === undefined || continuousPair)));
   if (interval || (windowOutput && args.aggregate === undefined) || prospectiveDirect) {
     if (!["quantitative", "temporal"].includes(fieldType)) {
       throw new Error(
@@ -125,12 +136,12 @@ export function resolveLinePositionPolicy({
 
   if (layer.encoding?.x !== undefined) {
     const compatibleAggregateX =
-      layer.encoding.x.fieldType === "temporal" ||
+      ["temporal", "nominal", "ordinal"].includes(layer.encoding.x.fieldType) ||
       (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."
+        "Aggregate line y encoding requires a temporal, categorical, or binned quantitative x encoding."
       );
     }
   }

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

@@ -142,7 +142,8 @@ export function resolvePositionEncoding(program, channel, args, operation) {
       ? undefined
       : args.mapping ?? findSemanticScale(program, previous?.scale)?.radialMapping
     : undefined;
-  const countRadius = mapping !== undefined && (args.aggregate ?? previous?.aggregate) === "count";
+  const countRadius = channel === "radius" && layer.mark.type === "arc" &&
+    !clearRadialMapping && (args.aggregate ?? previous?.aggregate) === "count";
   const requestedFieldType = args.fieldType ?? previous?.fieldType ?? (
     ["rule", "rect", "text", "point", "tick"].includes(layer.mark.type) && hasDatum
       ? inferDatumFieldType(args.datum, operation)
@@ -179,7 +180,7 @@ export function resolvePositionEncoding(program, channel, args, operation) {
     } else readScaleField(dataset.values, field, fieldType, { temporalUnit });
   }
   const effectiveArgs = { ...args };
-  if (clearRadialMapping) delete effectiveArgs.mapping;
+  if (clearRadialMapping && args.aggregate === undefined) delete effectiveArgs.mapping;
   else if (mapping !== undefined) effectiveArgs.mapping = mapping;
   const directQuantitativeArcTheta =
     layer.mark.type === "arc" &&

package/src/actions/encodings/ranged.js

@@ -127,6 +127,9 @@ function encodeSecondaryPosition(program, channel, args, operation, types) {
 
   let next = program;
   if (layer.mark.type === "bar") {
+    if (layer.mark.orientation !== undefined && primaryChannel !== (layer.mark.orientation === "vertical" ? "y" : "x")) {
+      throw new Error("Numeric bar endpoints must use the measure channel.");
+    }
     if (layer.layout?.mode !== undefined && layer.layout.mode !== "overlay") throw new Error("Ranged bars support only overlay layout; clear series layout before assigning endpoints.");
     for (const property of ["aggregate", "stack", "bin"]) {
       if (layer.encoding?.[primaryChannel]?.[property] !== undefined) {
@@ -210,6 +213,20 @@ function rangeAction(channel) {
     const { layer, dataset } = resolveTarget(this, args.target, ["area", "bar", "rect", "rule"], "ranged mark");
     let next = this;
     let lower = { field: args.lower }, upper = { field: args.upper };
+    if (layer.mark.type === "bar") {
+      if (layer.mark.orientation !== undefined && channel !== (layer.mark.orientation === "vertical" ? "y" : "x")) {
+        throw new Error("Numeric bar endpoints must use the measure channel.");
+      }
+      common.target = layer.id;
+      const resolved = resolvePositionEncoding(this, channel, {
+        ...common, ...lower,
+        ...(args.coordinate === undefined ? {} : { coordinate: args.coordinate }),
+        ...(args.scale === undefined ? {} : { scale: args.scale })
+      }, op);
+      next = setEncodingProperties(next, layer.id, `${channel}2`, {
+        ...upper, fieldType: common.fieldType, scale: resolved.scale.id
+      });
+    }
     if (layer.mark.type === "area") {
       common.target = layer.id;
       const prepared = prepareAreaRange(this, layer, dataset, channel, args, common);

package/src/actions/encodings/remove.js

@@ -26,6 +26,7 @@ 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";
+import { withGuideLayoutValidation } from "../../materialization/guides/layout.js";
 
 const OPTIONS = Object.freeze(["target", "channel"]);
 const REMOVABLE_CHANNELS = Object.freeze([
@@ -208,7 +209,7 @@ export const removeEncoding = /* @__PURE__ */ closedAction(
     op: "removeEncoding",
     description: "Remove one semantic encoding and its owned materialized state."
   }, OPTIONS,
-  function (args = {}) {
+  withGuideLayoutValidation(function (args = {}) {
     if (!REMOVABLE_CHANNELS.includes(args.channel)) {
       throw new Error(
         `Unsupported removable encoding channel "${args.channel}".`
@@ -259,7 +260,7 @@ export const removeEncoding = /* @__PURE__ */ closedAction(
     next = cleanupLegends(next, layer.id, channels);
     next = cleanupPositionGuides(next, removedPositions);
     return applyDetachedScaleRematerialization(rematerializeTarget(next, layer.id), [layer]);
-  }
+  })
 );
 
 export function registerEncodingRemovalAction(ProgramClass) {

package/src/actions/encodings/seriesLayout.js

@@ -48,6 +48,7 @@ export const layoutSeries = /* @__PURE__ */ action({ op: "layoutSeries", descrip
     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.centered && mode !== "overlay") throw new Error("Numeric-center 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.");

package/src/actions/encodings/text.js

@@ -1,4 +1,5 @@
 import { action } from "../../core/action.js";
+import { schemaField } from "../../grammar/datasetSchema.js";
 import { formatTextValue, validateTextFormat } from "../../grammar/text.js";
 import { normalizeMarkLabelContent, resolveMarkLabelValues } from "../../grammar/markLabels.js";
 import { canMaterializeText } from "../../materialization/marks/index.js";
@@ -14,11 +15,13 @@ import { applyRequestedItemMissingPolicy } from
 
 const OPTIONS = Object.freeze(["target", "field", "value", "content", "normalizeBy", "format"]);
 
-function validateTextField(rows, field, format) {
+function validateTextField(dataset, field, format) {
+  const rows = dataset.values;
   if (typeof field !== "string" || field.length === 0) {
     throw new TypeError("encodeText field must be a non-empty string.");
   }
-  let found = false;
+  let found = rows.length === 0 && dataset.schema !== undefined &&
+    schemaField(dataset.schema, field) !== undefined;
   for (const row of rows) {
     if (!Object.hasOwn(row, field)) continue;
     found = true;
@@ -57,7 +60,7 @@ export const encodeText = /* @__PURE__ */ action(
     const content = hasContent
       ? normalizeMarkLabelContent(findLayer(this, layer.source), args)
       : undefined;
-    if (hasField) validateTextField(dataset.values, args.field, format);
+    if (hasField) validateTextField(dataset, args.field, format);
     else if (hasValue && formatTextValue(args.value, format) === undefined) {
       throw new Error("encodeText value must produce non-empty text.");
     }

package/src/actions/errorBands/create.js

@@ -1,7 +1,7 @@
+import { validateFillPaint } from "../../grammar/paint.js";
 import { editGraphicProperties } from "../primitives/graphicProperties.js";
 import { action, closedAction } from "../../core/action.js";
 import { isPlainObject } from "../../core/immutable.js";
-import { validateNonEmptyString } from "../../core/validation.js";
 import { DEFAULT_COLORS } from "../../theme/defaults.js";
 import { validateCurveInterpolation } from "../../grammar/curveCommands.js";
 import {
@@ -176,7 +176,7 @@ export const createErrorBand = /* @__PURE__ */ closedAction(
     const resolved = resolveErrorBand(this, args);
     const curve = validateCurveInterpolation(args.curve ?? "linear");
     const boundaries = resolveBoundaries(args.boundaries, curve);
-    if (args.fill !== undefined) validateNonEmptyString(args.fill, "Error-band fill");
+    if (args.fill !== undefined) validateFillPaint(args.fill, "Error-band fill");
     let next = createResolvedIntervalData(this, resolved);
     next = next.createAreaMark({
       id: resolved.id,

package/src/actions/errorBands/edit.js

@@ -1,3 +1,4 @@
+import { validateFillPaint } from "../../grammar/paint.js";
 import { currentIntervalRoleArgs, resolveIntervalRoleScales, applyIntervalStatistics } from "../intervals/revision.js";
 import { closedAction } from "../../core/action.js";
 import { isPlainObject } from "../../core/immutable.js";
@@ -333,7 +334,7 @@ export const editErrorBand = /* @__PURE__ */ closedAction(
         if (owner.encoding?.color !== undefined) {
           throw new Error("editErrorBand fill conflicts with a color encoding; remove the color encoding first.");
         }
-        errorBand.fill = validateNonEmptyString(args.fill, "Error-band fill");
+        errorBand.fill = validateFillPaint(args.fill, "Error-band fill");
         config.fill = errorBand.fill;
       }
     }