ggaction 0.0.16 → 0.0.18

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

@@ -13,6 +13,8 @@ import {
   validateFieldType,
   validatePositionChannel
 } from "../../../grammar/scales/index.js";
+import { applyRequestedItemMissingPolicy } from
+  "../../../grammar/itemMissing.js";
 import { resolvePositionScaleDefinition } from "../../scales/definitions.js";
 import { findCoordinate } from "../../../selectors/coordinates.js";
 import {
@@ -92,7 +94,7 @@ function resolveCoordinate(program, channel, layer, requestedId) {
 export function resolvePositionEncoding(program, channel, args, operation) {
   validateOptions(args, POSITION_ENCODING_OPTIONS, operation);
   validatePositionChannel(channel);
-  const { id: target, dataset, layer } = resolveTarget(
+  const { id: target, dataset: sourceDataset, layer } = resolveTarget(
     program,
     args.target,
     getPositionChannelDefinition(channel).markTypes
@@ -140,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)
@@ -157,6 +160,9 @@ export function resolvePositionEncoding(program, channel, args, operation) {
     xEncoding?.bin !== undefined && args.field === undefined
     ? xEncoding.field
     : args.field;
+  const dataset = hasField
+    ? applyRequestedItemMissingPolicy(layer, sourceDataset, field)
+    : applyRequestedItemMissingPolicy(layer, sourceDataset);
   const datum = args.datum;
   const temporalUnit = resolveTemporalUnit({ ...args, ...(hasDatum ? {} : { field }) }, fieldType, previous);
   const usesField = !countRadius && (!["rule", "area", "rect", "text", "point", "tick"].includes(layer.mark.type) || hasField);
@@ -174,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

@@ -14,6 +14,8 @@ import { deriveAreaSeries } from "../../grammar/areaSeries.js";
 import { resolvePositionEncoding } from "./position/resolve.js";
 import { resolveScalePreview } from "../scales/preview.js";
 import { findUpstreamTransform } from "../../materialization/dataProvenance.js";
+import { applyRequestedItemMissingPolicy } from
+  "../../grammar/itemMissing.js";
 
 const SECONDARY_OPTIONS = Object.freeze([
   "field", "datum", "target", "fieldType", "scale", "coordinate", "temporalUnit"
@@ -46,7 +48,7 @@ function validateSecondaryField(dataset, field, fieldType, temporalUnit) {
 
 function encodeSecondaryPosition(program, channel, args, operation, types) {
   validateOptions(args, SECONDARY_OPTIONS, operation);
-  const { id: target, dataset, layer } = resolveTarget(
+  const { id: target, dataset: sourceDataset, layer } = resolveTarget(
     program,
     args.target,
     types,
@@ -72,6 +74,9 @@ function encodeSecondaryPosition(program, channel, args, operation, types) {
   const rect = layer.mark.type === "rect";
   const hasField = Object.hasOwn(args, "field");
   const hasDatum = Object.hasOwn(args, "datum");
+  const dataset = hasField
+    ? applyRequestedItemMissingPolicy(layer, sourceDataset, args.field)
+    : applyRequestedItemMissingPolicy(layer, sourceDataset);
   if ((rule || area || rect) && hasField === hasDatum) {
     throw new Error(`${operation} requires exactly one of field or datum for a ${layer.mark.type} mark.`);
   }
@@ -122,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) {
@@ -205,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/ruleAppearance.js

@@ -14,6 +14,8 @@ import {
 import { findLayer } from "../../selectors/layers.js";
 import { validatePathSeriesAppearance } from "../../grammar/pathSeries.js";
 import { assertEncodingSelectionCompatibility } from "../../materialization/selection/compatibility.js";
+import { applyRequestedItemMissingPolicy } from
+  "../../grammar/itemMissing.js";
 
 const WIDTH_OPTIONS = Object.freeze([
   "target", "value", "field", "fieldType", "scale"
@@ -57,12 +59,13 @@ const encodeStrokeWidth = /* @__PURE__ */ action(
       next = next.rematerializeRuleMark({ id });
       return applyDetachedScaleRematerialization(next, [layer]);
     }
-    const { id, dataset, layer } = resolveTarget(
+    const { id, dataset: sourceDataset, layer } = resolveTarget(
       this,
       args.target,
       ["rule", "line"],
       "rule or line mark"
     );
+    const dataset = applyRequestedItemMissingPolicy(layer, sourceDataset, args.field);
     const fieldType = args.fieldType ?? "quantitative";
     if (fieldType !== "quantitative") {
       throw new Error("encodeStrokeWidth requires a quantitative field.");

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/stroke.js

@@ -26,6 +26,8 @@ import {
   setEncodingProperties,
   validateOptions
 } from "./shared.js";
+import { applyRequestedItemMissingPolicy } from
+  "../../grammar/itemMissing.js";
 
 const OPTIONS = Object.freeze([
   "target", "value", "field", "fieldType", "temporalUnit", "scale"
@@ -122,7 +124,7 @@ export const encodeStroke = /* @__PURE__ */ action(
         "Constant stroke does not accept fieldType, temporalUnit, or scale."
       );
     }
-    const { id: target, dataset, layer } = resolveTarget(
+    const { id: target, dataset: sourceDataset, layer } = resolveTarget(
       this,
       args.target,
       MARK_TYPES,
@@ -155,6 +157,7 @@ export const encodeStroke = /* @__PURE__ */ action(
     }
 
     const fieldType = args.fieldType ?? "nominal";
+    const dataset = applyRequestedItemMissingPolicy(layer, sourceDataset, args.field);
     const previous = layer.encoding?.stroke;
     const temporalUnit = resolveTemporalUnit(args, fieldType, previous);
     const requestedScale = resolveReassignmentScaleOptions(

package/src/actions/encodings/strokeDash.js

@@ -15,6 +15,8 @@ import {
 } from "./shared.js";
 import { findLayer } from "../../selectors/layers.js";
 import { validatePathSeriesAppearance } from "../../grammar/pathSeries.js";
+import { applyRequestedItemMissingPolicy } from
+  "../../grammar/itemMissing.js";
 
 const STROKE_DASH_ENCODING_OPTIONS = Object.freeze([
   "field", "value", "target", "fieldType", "scale"
@@ -73,12 +75,15 @@ const encodeStrokeDash = /* @__PURE__ */ action(
     if (hasValue && (args.fieldType !== undefined || args.scale !== undefined)) {
       throw new Error("Constant stroke dash does not accept fieldType or scale.");
     }
-    const { id: target, dataset, layer } = resolveTarget(
+    const { id: target, dataset: sourceDataset, layer } = resolveTarget(
       this,
       args.target,
       ["line", "rule"],
       "line or rule mark"
     );
+    const dataset = hasField
+      ? applyRequestedItemMissingPolicy(layer, sourceDataset, args.field)
+      : sourceDataset;
     if (hasValue) {
       normalizeStrokeDashPattern(args.value);
       validatePathSeriesAppearance(dataset.values, {

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";
@@ -9,14 +10,18 @@ import {
   setEncodingProperties,
   validateOptions
 } from "./shared.js";
+import { applyRequestedItemMissingPolicy } from
+  "../../grammar/itemMissing.js";
 
 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;
@@ -41,18 +46,21 @@ export const encodeText = /* @__PURE__ */ action(
     if (Object.hasOwn(args, "normalizeBy") && (!hasContent || args.content !== "share")) {
       throw new Error("Text normalizeBy is only supported with share content.");
     }
-    const { id: target, dataset, layer } = resolveTarget(
+    const { id: target, dataset: sourceDataset, layer } = resolveTarget(
       this,
       args.target,
       ["text"],
       "text mark"
     );
+    const dataset = hasField
+      ? applyRequestedItemMissingPolicy(layer, sourceDataset, args.field)
+      : applyRequestedItemMissingPolicy(layer, sourceDataset);
     const previous = layer.encoding?.text;
     const format = validateTextFormat(args.format ?? previous?.format ?? "auto");
     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;
       }
     }