ggaction 0.0.15 → 0.0.17

package/src/actions/encodings/appearance.js

@@ -25,6 +25,8 @@ import {
   setEncodingProperties,
   validateOptions
 } from "./shared.js";
+import { applyRequestedItemMissingPolicy } from
+  "../../grammar/itemMissing.js";
 
 const RADIUS_OPTIONS = Object.freeze(["value", "target"]);
 const REMOVE_RADIUS_OPTIONS = Object.freeze(["target"]);
@@ -34,13 +36,14 @@ const OPACITY_OPTIONS = Object.freeze([
 const FIELD_OPTIONS = Object.freeze(["field", "target", "fieldType", "scale"]);
 function encodeAppearanceField(program, channel, args, operation) {
   validateOptions(args, FIELD_OPTIONS, operation);
-  const { id: target, dataset, layer } = resolveTarget(
+  const { id: target, dataset: sourceDataset, layer } = resolveTarget(
     program,
     args.target,
     ["point"],
     "point mark"
   );
   const expectedFieldType = channel === "shape" ? "nominal" : "quantitative";
+  const dataset = applyRequestedItemMissingPolicy(layer, sourceDataset, args.field);
   const fieldType = args.fieldType ?? expectedFieldType;
   if (fieldType !== expectedFieldType) {
     throw new Error(`${operation} requires a ${expectedFieldType} field.`);
@@ -79,7 +82,7 @@ function encodeAppearanceField(program, channel, args, operation) {
   return rematerializeEncoding(next, target, channel, scale.id, layer);
 }
 
-const encodeRadius = action(
+const encodeRadius = /* @__PURE__ */ action(
   {
     op: "encodeRadius",
     description: "Set a constant graphical radius on a point mark."
@@ -112,7 +115,7 @@ const encodeRadius = action(
   }
 );
 
-const encodePointRadius = action(
+const encodePointRadius = /* @__PURE__ */ action(
   {
     op: "encodePointRadius",
     description: "Set a constant graphical radius on a point mark."
@@ -146,7 +149,7 @@ const removePointRadius = /* @__PURE__ */ action(
   }
 );
 
-const encodeSize = action(
+const encodeSize = /* @__PURE__ */ action(
   {
     op: "encodeSize",
     description: "Encode a quantitative field as equal-area point size."
@@ -156,7 +159,7 @@ const encodeSize = action(
   }
 );
 
-const encodeShape = action(
+const encodeShape = /* @__PURE__ */ action(
   {
     op: "encodeShape",
     description: "Encode a nominal field as point shape."
@@ -196,7 +199,7 @@ const encodeOpacity = /* @__PURE__ */ action(
     if (hasValue && (args.fieldType !== undefined || args.scale !== undefined)) {
       throw new Error("Constant opacity does not accept fieldType or scale.");
     }
-    const { id: target, dataset, layer } = resolveTarget(
+    const { id: target, dataset: sourceDataset, layer } = resolveTarget(
       this,
       args.target,
       ["point", "rule", "line"],
@@ -222,6 +225,7 @@ const encodeOpacity = /* @__PURE__ */ action(
         : next.rematerializePointMark({ id: target });
       return applyDetachedScaleRematerialization(materialized, [layer]);
     }
+    const dataset = applyRequestedItemMissingPolicy(layer, sourceDataset, args.field);
     const fieldType = args.fieldType ?? "quantitative";
     if (fieldType !== "quantitative") {
       throw new Error("encodeOpacity requires a quantitative field.");

package/src/actions/encodings/barWidth.js

@@ -10,7 +10,7 @@ import { normalizeBarWidth } from "../../grammar/bars/geometry.js";
 
 const OPTIONS = Object.freeze(["band", "pixels", "target"]);
 
-const encodeBarWidth = action(
+const encodeBarWidth = /* @__PURE__ */ action(
   {
     op: "encodeBarWidth",
     description: "Override aggregate or ranged bar width within its category slot."

package/src/actions/encodings/channels.js

@@ -299,7 +299,7 @@ function finalScaleIds(before, after, originalLayer, finalLayer, requests) {
   );
 }
 
-const rematerializeEncodingScales = action(
+const rematerializeEncodingScales = /* @__PURE__ */ action(
   {
     op: "rematerializeEncodingScales",
     description: "Resolve every scale affected by one atomic encoding assignment."
@@ -390,7 +390,7 @@ function applyEncodingAssignments(program, plan) {
   return instantiateProgram(plan.state, program.constructor);
 }
 
-export const encodeChannels = action(
+export const encodeChannels = /* @__PURE__ */ action(
   {
     op: "encodeChannels",
     description: "Atomically assign multiple encoding channels to one mark."

package/src/actions/encodings/color/continuous.js

@@ -26,6 +26,8 @@ import {
 } from "./policy.js";
 
 import { applyTemporalUnit } from "../temporal.js";
+import { applyRequestedItemMissingPolicy } from
+  "../../../grammar/itemMissing.js";
 
 export function encodeContinuousColor(program, args) {
   if (!["quantitative", "temporal"].includes(args.fieldType)) {
@@ -34,12 +36,13 @@ export function encodeContinuousColor(program, args) {
   if (args.layout !== undefined) {
     throw new Error("Continuous color does not support layout.");
   }
-  const { id: target, dataset, layer } = resolveTarget(
+  const { id: target, dataset: sourceDataset, layer } = resolveTarget(
     program,
     args.target,
     ["point", "bar", "rect"],
     "continuous color mark"
   );
+  const dataset = applyRequestedItemMissingPolicy(layer, sourceDataset, args.field);
   assertNoConstantColor(program, layer);
   const temporalUnit = resolveTemporalUnit(args, args.fieldType, layer.encoding?.color);
   const requestedScale = resolveReassignmentScaleOptions(

package/src/actions/encodings/color/index.js

@@ -38,8 +38,10 @@ import {
 } from "./policy.js";
 
 import { applyTemporalUnit } from "../temporal.js";
+import { applyRequestedItemMissingPolicy } from
+  "../../../grammar/itemMissing.js";
 
-const encodeColor = action(
+const encodeColor = /* @__PURE__ */ action(
   {
     op: "encodeColor",
     description: "Encode a field as graphical color."
@@ -58,12 +60,13 @@ const encodeColor = action(
     }
     const fieldType = validateCategoricalFieldType(requestedFieldType);
     resolveTemporalUnit(args, fieldType);
-    const { id: target, dataset, layer } = resolveTarget(
+    const { id: target, dataset: sourceDataset, layer } = resolveTarget(
       this,
       args.target,
       ["point", "line", "bar", "area", "arc", "rect"],
       "color mark"
     );
+    const dataset = applyRequestedItemMissingPolicy(layer, sourceDataset, args.field);
     assertNoConstantColor(this, layer);
     const densityTransform = dataset.transform?.length === 1 &&
       dataset.transform[0].type === "density"

package/src/actions/encodings/density.js

@@ -114,7 +114,7 @@ function applyDensityPosition(program, layerId, definition, groupBy) {
   return next;
 }
 
-const encodeDensity = action(
+const encodeDensity = /* @__PURE__ */ action(
   {
     op: "encodeDensity",
     description: "Derive and encode a baseline or categorical kernel-density area."
@@ -259,7 +259,7 @@ function assertGroupingSelectionCompatibility(program, layer, changesGroup) {
   }
 }
 
-const editDensity = action(
+const editDensity = /* @__PURE__ */ action(
   {
     op: "editDensity",
     description: "Revise one density transform and rematerialize its consumers."

package/src/actions/encodings/histogram.js

@@ -6,7 +6,7 @@ const HISTOGRAM_OPTIONS = Object.freeze([
   "stack", "xScale", "yScale", "weight"
 ]);
 
-const encodeHistogram = action(
+const encodeHistogram = /* @__PURE__ */ action(
   {
     op: "encodeHistogram",
     description: "Encode a binned count histogram with a configurable layout stack."

package/src/actions/encodings/horizon.js

@@ -1,6 +1,6 @@
-import { action } from "../../core/action.js";
+import { closedAction } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
-import { validateOptionObject } from "../../core/validation.js";
+
 import {
   deriveHorizon,
   validateHorizonTransform
@@ -109,13 +109,12 @@ function applyScaleDefinition(program, current, definition) {
   return patch === undefined ? program : program.editScale(patch);
 }
 
-const editHorizon = action(
+const editHorizon = /* @__PURE__ */ closedAction(
   {
     op: "editHorizon",
     description: "Revise one Horizon transform and rematerialize its consumers."
-  },
+  }, EDIT_OPTIONS,
   function (args = {}) {
-    validateOptionObject(args, EDIT_OPTIONS, "editHorizon");
     if (Object.hasOwn(args, "groupBy") && args.groupBy === undefined) {
       throw new Error("editHorizon groupBy requires a field string or false.");
     }
@@ -278,13 +277,12 @@ const editHorizon = action(
   }
 );
 
-const encodeHorizon = action(
+const encodeHorizon = /* @__PURE__ */ closedAction(
   {
     op: "encodeHorizon",
     description: "Derive and encode one folded Horizon area."
-  },
+  }, OPTIONS,
   function (args = {}) {
-    validateOptionObject(args, OPTIONS, "encodeHorizon");
     const layer = findHorizonArea(this, args.target);
     validateUnusedHorizonEncodings(layer);
     const source = resolveHorizonSource(this, layer, args.source);

package/src/actions/encodings/offset.js

@@ -18,6 +18,8 @@ import {
   resolveBarChannels,
   resolveBarGrain
 } from "../../grammar/bars/policy.js";
+import { applyRequestedItemMissingPolicy } from
+  "../../grammar/itemMissing.js";
 
 const ENCODING_OPTIONS = Object.freeze([
   "field", "target", "fieldType", "scale", "paddingInner", "paddingOuter"
@@ -33,12 +35,13 @@ function createOffsetEncoding(channel) {
     function (args = {}) {
       validateOptions(args, ENCODING_OPTIONS, operation);
       const fieldType = validateCategoricalFieldType(args.fieldType ?? "nominal");
-      const { id: target, dataset, layer } = resolveTarget(
+      const { id: target, dataset: sourceDataset, layer } = resolveTarget(
         this,
         args.target,
         ["bar", "point", "rule"],
         "offset-compatible mark"
       );
+      const dataset = applyRequestedItemMissingPolicy(layer, sourceDataset, args.field);
 
       if (layer.mark.type === "bar") {
         const channels = resolveBarChannels(layer);
@@ -110,8 +113,8 @@ function createOffsetEncoding(channel) {
   );
 }
 
-const encodeXOffset = createOffsetEncoding("xOffset");
-const encodeYOffset = createOffsetEncoding("yOffset");
+const encodeXOffset = /* @__PURE__ */ createOffsetEncoding("xOffset");
+const encodeYOffset = /* @__PURE__ */ createOffsetEncoding("yOffset");
 
 export function registerOffsetEncodingAction(ProgramClass) {
   ProgramClass.prototype.encodeXOffset = encodeXOffset;

package/src/actions/encodings/parallel.js

@@ -1,5 +1,5 @@
-import { action } from "../../core/action.js";
-import { validateOptionObject } from "../../core/validation.js";
+import { closedAction } from "../../core/action.js";
+
 import {
   normalizeParallelDimensions,
   validateParallelKeyField,
@@ -19,13 +19,12 @@ const OPTIONS = Object.freeze([
   "target", "coordinate", "dimensions", "key", "missing"
 ]);
 
-export const encodeParallelCoordinates = action(
+export const encodeParallelCoordinates = /* @__PURE__ */ closedAction(
   {
     op: "encodeParallelCoordinates",
     description: "Atomically encode ordered Parallel-coordinate dimensions."
-  },
+  }, OPTIONS,
   function (args = {}) {
-    validateOptionObject(args, OPTIONS, "encodeParallelCoordinates");
     const { id: target, dataset, layer } = resolveTarget(
       this,
       args.target,

package/src/actions/encodings/pathOrder.js

@@ -1,9 +1,6 @@
-import { action } from "../../core/action.js";
+import { closedAction } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
-import {
-  validateNonEmptyString,
-  validateOptionObject
-} from "../../core/validation.js";
+import { validateNonEmptyString } from "../../core/validation.js";
 import { readQuantitativeField } from "../../grammar/scales/index.js";
 import { validatePathOrderDirection } from "../../grammar/pathOrder.js";
 import {
@@ -76,13 +73,12 @@ function rematerializePath(program, layer) {
     : program;
 }
 
-const encodePathOrder = action(
+const encodePathOrder = /* @__PURE__ */ closedAction(
   {
     op: "encodePathOrder",
     description: "Order vertices within each Cartesian path series."
-  },
+  }, ENCODE_OPTIONS,
   function (args = {}) {
-    validateOptionObject(args, ENCODE_OPTIONS, "encodePathOrder");
     const field = validateNonEmptyString(args.field, "Path order field");
     const fieldType = args.fieldType ?? "quantitative";
     if (fieldType !== "quantitative") {
@@ -102,13 +98,12 @@ const encodePathOrder = action(
   }
 );
 
-const removePathOrder = action(
+const removePathOrder = /* @__PURE__ */ closedAction(
   {
     op: "removePathOrder",
     description: "Remove explicit path order and restore automatic ordering."
-  },
+  }, REMOVE_OPTIONS,
   function (args = {}) {
-    validateOptionObject(args, REMOVE_OPTIONS, "removePathOrder");
     const layer = resolvePathOrderLayer(this, args.target, { active: true });
     const next = this.editSemantic({
       property: `layer[${layer.id}].encoding.pathOrder`,

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

@@ -141,7 +141,7 @@ function encodePosition(program, channel, args, operation) {
   return applyDetachedScaleRematerialization(next, [layer]);
 }
 
-const encodeX = action(
+const encodeX = /* @__PURE__ */ action(
   {
     op: "encodeX",
     description: "Encode a field as horizontal position."
@@ -151,7 +151,7 @@ const encodeX = action(
   }
 );
 
-const encodeY = action(
+const encodeY = /* @__PURE__ */ action(
   {
     op: "encodeY",
     description: "Encode a field as vertical position."
@@ -161,7 +161,7 @@ const encodeY = action(
   }
 );
 
-const encodeTheta = action(
+const encodeTheta = /* @__PURE__ */ action(
   {
     op: "encodeTheta",
     description: "Encode a field as Polar angle in clockwise degrees."
@@ -171,7 +171,7 @@ const encodeTheta = action(
   }
 );
 
-const encodeR = action(
+const encodeR = /* @__PURE__ */ action(
   {
     op: "encodeR",
     description: "Encode a quantitative field as Polar radius."

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
@@ -157,6 +159,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);

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.`);
   }
@@ -159,7 +164,7 @@ function encodeSecondaryPosition(program, channel, args, operation, types) {
   return next;
 }
 
-const encodeX2 = action(
+const encodeX2 = /* @__PURE__ */ action(
   {
     op: "encodeX2",
     description: "Encode a secondary horizontal endpoint."
@@ -175,7 +180,7 @@ const encodeX2 = action(
   }
 );
 
-const encodeY2 = action(
+const encodeY2 = /* @__PURE__ */ action(
   {
     op: "encodeY2",
     description: "Encode a secondary vertical endpoint."
@@ -222,10 +227,10 @@ function rangeAction(channel) {
   });
 }
 
-const encodeYRange = rangeAction("y");
-const encodeXRange = rangeAction("x");
+const encodeYRange = /* @__PURE__ */ rangeAction("y");
+const encodeXRange = /* @__PURE__ */ rangeAction("x");
 
-const encodeGroup = action(
+const encodeGroup = /* @__PURE__ */ action(
   {
     op: "encodeGroup",
     description: "Split path geometry by nominal identity fields without a scale."

package/src/actions/encodings/remove.js

@@ -1,6 +1,6 @@
-import { action } from "../../core/action.js";
+import { closedAction } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
-import { validateOptionObject } from "../../core/validation.js";
+
 import {
   getPositionChannelDefinition,
   POSITION_ENCODING_CHANNELS
@@ -203,13 +203,12 @@ function rematerializeTarget(program, target) {
   return next;
 }
 
-export const removeEncoding = action(
+export const removeEncoding = /* @__PURE__ */ closedAction(
   {
     op: "removeEncoding",
     description: "Remove one semantic encoding and its owned materialized state."
-  },
+  }, OPTIONS,
   function (args = {}) {
-    validateOptionObject(args, OPTIONS, "removeEncoding");
     if (!REMOVABLE_CHANNELS.includes(args.channel)) {
       throw new Error(
         `Unsupported removable encoding channel "${args.channel}".`

package/src/actions/encodings/ruleAppearance.js

@@ -14,12 +14,14 @@ 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"
 ]);
 
-const encodeStrokeWidth = action(
+const encodeStrokeWidth = /* @__PURE__ */ action(
   {
     op: "encodeStrokeWidth",
     description: "Assign constant or field-driven line or rule stroke width."
@@ -57,12 +59,13 @@ const encodeStrokeWidth = 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

@@ -15,7 +15,7 @@ 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 = {}) {
+export const layoutSeries = /* @__PURE__ */ 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");

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"
@@ -101,7 +103,7 @@ function validateStrokeField(dataset, layer, args, scale, temporalUnit) {
   }
 }
 
-export const encodeStroke = action(
+export const encodeStroke = /* @__PURE__ */ action(
   {
     op: "encodeStroke",
     description: "Assign constant or field-driven graphical stroke color."
@@ -122,7 +124,7 @@ export const encodeStroke = 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 = 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,12 +15,14 @@ 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"
 ]);
 
-const clearStrokeDashEncoding = action(
+const clearStrokeDashEncoding = /* @__PURE__ */ action(
   {
     op: "clearStrokeDashEncoding",
     description: "Remove the current semantic stroke-dash assignment."
@@ -58,7 +60,7 @@ function reconcileLegendAfterDashRemoval(program, target) {
     .rematerializeLegend();
 }
 
-const encodeStrokeDash = action(
+const encodeStrokeDash = /* @__PURE__ */ action(
   {
     op: "encodeStrokeDash",
     description: "Encode a nominal field as line stroke dash."
@@ -73,12 +75,15 @@ const encodeStrokeDash = 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

@@ -9,6 +9,8 @@ import {
   setEncodingProperties,
   validateOptions
 } from "./shared.js";
+import { applyRequestedItemMissingPolicy } from
+  "../../grammar/itemMissing.js";
 
 const OPTIONS = Object.freeze(["target", "field", "value", "content", "normalizeBy", "format"]);
 
@@ -25,7 +27,7 @@ function validateTextField(rows, field, format) {
   if (!found) throw new Error(`Unknown text field "${field}".`);
 }
 
-export const encodeText = action(
+export const encodeText = /* @__PURE__ */ action(
   {
     op: "encodeText",
     description: "Assign field, constant, or source semantic text content."
@@ -41,12 +43,15 @@ export const encodeText = 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