ggaction 0.0.15 → 0.0.17

package/src/actions/data/impute.js

@@ -8,14 +8,14 @@ const OPTIONS = Object.freeze([
   "id", "source", "fields", "groupBy", "sortBy", "method", "value", "edges", "maxGap"
 ]);
 
-export const materializeImputedData = derivedMaterializer(
+export const materializeImputedData = /* @__PURE__ */ derivedMaterializer(
   "materializeImputedData",
   "Materialize one immutable missing-value dataset.",
   "impute",
   deriveImputedRows
 );
 
-export const createImputedData = derivedCreator(
+export const createImputedData = /* @__PURE__ */ derivedCreator(
   "createImputedData",
   "Replace explicit missing cells within independent groups.",
   OPTIONS,

package/src/actions/data/index.js

@@ -35,6 +35,7 @@ import {
   materializeBin2DData
 } from "./bin2d.js";
 import { createData } from "./create.js";
+import { reviseData } from "./revise.js";
 import { createWindowData, materializeWindowData } from "./window.js";
 import { createSummaryData, materializeSummaryData } from "./summary.js";
 import { createBinData, materializeBinData } from "./bin.js";
@@ -47,62 +48,65 @@ import {
 import { createCompleteData, materializeCompleteData } from "./complete.js";
 import { createImputedData, materializeImputedData } from "./impute.js";
 import { createStackData, materializeStackData } from "./stack.js";
+import { createSortedData, materializeSortedData } from "./sort.js";
 import { EDIT_DERIVED_DATA_ACTIONS } from "./edit.js";
 import { createBoxSummaryData, createBoxOutlierData, materializeBoxSummaryData, materializeBoxOutlierData } from "./box.js";
 
 export function registerDataActions(ProgramClass) {
-  Object.assign(ProgramClass.prototype, EDIT_DERIVED_DATA_ACTIONS);
-  ProgramClass.prototype.createData = createData;
-  ProgramClass.prototype.createDerivedData = createDerivedData;
-  ProgramClass.prototype.bindMarkData = bindMarkData;
-  ProgramClass.prototype.releaseDerivedData = releaseDerivedData;
-  ProgramClass.prototype.rebindLayerData = rebindLayerData;
-  ProgramClass.prototype.createDensityData = createDensityData;
-  ProgramClass.prototype.createCategoricalDensityData =
-    createCategoricalDensityData;
-  ProgramClass.prototype.materializeFilteredData = materializeFilteredData;
-  ProgramClass.prototype.materializeMarkFilteredData = materializeMarkFilteredData;
-  ProgramClass.prototype.filterData = filterData;
-  ProgramClass.prototype.filterMarks = filterMarks;
-  ProgramClass.prototype.materializeEmptyMark = materializeEmptyMark;
-  ProgramClass.prototype.removeMarkFilter = removeMarkFilter;
-  ProgramClass.prototype.materializeRegressionData = materializeRegressionData;
-  ProgramClass.prototype.materializeDensityData = materializeDensityData;
-  ProgramClass.prototype.createGradientProfileData = createGradientProfileData;
-  ProgramClass.prototype.materializeGradientProfileData =
-    materializeGradientProfileData;
-  ProgramClass.prototype.createRegressionData = createRegressionData;
-  ProgramClass.prototype.materializeIntervalData = materializeIntervalData;
-  ProgramClass.prototype.createIntervalData = createIntervalData;
-  ProgramClass.prototype.createECDFData = createECDFData;
-  ProgramClass.prototype.materializeECDFData = materializeECDFData;
-  ProgramClass.prototype.createHorizonData = createHorizonData;
-  ProgramClass.prototype.materializeHorizonData = materializeHorizonData;
-  ProgramClass.prototype.createWindowData = createWindowData;
-  ProgramClass.prototype.materializeWindowData = materializeWindowData;
-  ProgramClass.prototype.createSummaryData = createSummaryData;
-  ProgramClass.prototype.materializeSummaryData = materializeSummaryData;
-  ProgramClass.prototype.createBinData = createBinData;
-  ProgramClass.prototype.materializeBinData = materializeBinData;
-  ProgramClass.prototype.createFoldData = createFoldData;
-  ProgramClass.prototype.materializeFoldData = materializeFoldData;
-  ProgramClass.prototype.createComputedData = createComputedData;
-  ProgramClass.prototype.materializeComputedData = materializeComputedData;
-  ProgramClass.prototype.createNormalizedData = createNormalizedData;
-  ProgramClass.prototype.materializeNormalizedData = materializeNormalizedData;
-  ProgramClass.prototype.createCompleteData = createCompleteData;
-  ProgramClass.prototype.materializeCompleteData = materializeCompleteData;
-  ProgramClass.prototype.createImputedData = createImputedData;
-  ProgramClass.prototype.materializeImputedData = materializeImputedData;
-  ProgramClass.prototype.createStackData = createStackData;
-  ProgramClass.prototype.materializeStackData = materializeStackData;
-  ProgramClass.prototype.createTimeUnitData = createTimeUnitData;
-  ProgramClass.prototype.materializeTimeUnitData = materializeTimeUnitData;
-  ProgramClass.prototype.createBin2DData = createBin2DData;
-  ProgramClass.prototype.editBin2DData = editBin2DData;
-  ProgramClass.prototype.materializeBin2DData = materializeBin2DData;
-  ProgramClass.prototype.createBoxSummaryData = createBoxSummaryData;
-  ProgramClass.prototype.createBoxOutlierData = createBoxOutlierData;
-  ProgramClass.prototype.materializeBoxSummaryData = materializeBoxSummaryData;
-  ProgramClass.prototype.materializeBoxOutlierData = materializeBoxOutlierData;
+  Object.assign(ProgramClass.prototype, EDIT_DERIVED_DATA_ACTIONS, {
+    createData,
+    reviseData,
+    createDerivedData,
+    bindMarkData,
+    releaseDerivedData,
+    rebindLayerData,
+    createDensityData,
+    createCategoricalDensityData,
+    materializeFilteredData,
+    materializeMarkFilteredData,
+    filterData,
+    filterMarks,
+    materializeEmptyMark,
+    removeMarkFilter,
+    materializeRegressionData,
+    materializeDensityData,
+    createGradientProfileData,
+    materializeGradientProfileData,
+    createRegressionData,
+    materializeIntervalData,
+    createIntervalData,
+    createECDFData,
+    materializeECDFData,
+    createHorizonData,
+    materializeHorizonData,
+    createWindowData,
+    materializeWindowData,
+    createSummaryData,
+    materializeSummaryData,
+    createBinData,
+    materializeBinData,
+    createFoldData,
+    materializeFoldData,
+    createComputedData,
+    materializeComputedData,
+    createNormalizedData,
+    materializeNormalizedData,
+    createCompleteData,
+    materializeCompleteData,
+    createImputedData,
+    materializeImputedData,
+    createStackData,
+    materializeStackData,
+    createSortedData,
+    materializeSortedData,
+    createTimeUnitData,
+    materializeTimeUnitData,
+    createBin2DData,
+    editBin2DData,
+    materializeBin2DData,
+    createBoxSummaryData,
+    createBoxOutlierData,
+    materializeBoxSummaryData,
+    materializeBoxOutlierData
+  });
 }

package/src/actions/data/interval.js

@@ -13,17 +13,18 @@ const OPTIONS = Object.freeze([
   "extent",
   "method",
   "level",
+  "missing",
   "as"
 ]);
 
-export const materializeIntervalData = derivedMaterializer(
+export const materializeIntervalData = /* @__PURE__ */ derivedMaterializer(
   "materializeIntervalData",
   "Materialize one grouped interval-summary dataset.",
   "interval",
   deriveInterval
 );
 
-export const createIntervalData = derivedCreator(
+export const createIntervalData = /* @__PURE__ */ derivedCreator(
   "createIntervalData",
   "Create immutable grouped interval-summary values.",
   OPTIONS,
@@ -42,6 +43,7 @@ export const createIntervalData = derivedCreator(
       extent: args.extent,
       method: args.method,
       level: args.level,
+      missing: args.missing,
       as
     });
   },

package/src/actions/data/intervalEdit.js

@@ -138,13 +138,7 @@ export function planIntervalRoleData(program, {
   };
 }
 
-export function planIntervalEdit(program, {
-  owner,
-  data,
-  consumers,
-  statistics,
-  operation
-}) {
+export function validateIntervalStatistics(statistics, operation) {
   if (!isPlainObject(statistics)) {
     throw new TypeError(`${operation} statistics must be a plain object.`);
   }
@@ -154,16 +148,9 @@ export function planIntervalEdit(program, {
       `${operation} statistics requires center, extent, method, or level.`
     );
   }
-  const previous = findDataset(program, data);
-  const transform = previous?.transform?.length === 1
-    ? previous.transform[0]
-    : undefined;
-  if (transform?.type !== "interval") {
-    throw new Error(
-      `${operation} statistics requires a statistical interval owner; ` +
-      "explicit interval fields cannot be converted by edit."
-    );
-  }
+}
+
+export function mergeIntervalStatistics(transform, statistics) {
   const center = Object.hasOwn(statistics, "center")
     ? statistics.center
     : transform.center;
@@ -181,7 +168,28 @@ export function planIntervalEdit(program, {
   } else if (extent === "ci" && transform.extent === "ci") {
     raw.level = transform.level;
   }
-  const parameters = normalizeIntervalParameters(raw);
+  return normalizeIntervalParameters(raw);
+}
+
+export function planIntervalEdit(program, {
+  owner,
+  data,
+  consumers,
+  statistics,
+  operation
+}) {
+  validateIntervalStatistics(statistics, operation);
+  const previous = findDataset(program, data);
+  const transform = previous?.transform?.length === 1
+    ? previous.transform[0]
+    : undefined;
+  if (transform?.type !== "interval") {
+    throw new Error(
+      `${operation} statistics requires a statistical interval owner; ` +
+      "explicit interval fields cannot be converted by edit."
+    );
+  }
+  const parameters = mergeIntervalStatistics(transform, statistics);
   const current = {
     center: transform.center,
     extent: transform.extent,

package/src/actions/data/normalize.js

@@ -9,14 +9,14 @@ const OPTIONS = Object.freeze([
   "variance", "zeroDenominator", "baseline", "sortBy"
 ]);
 
-export const materializeNormalizedData = derivedMaterializer(
+export const materializeNormalizedData = /* @__PURE__ */ derivedMaterializer(
   "materializeNormalizedData",
   "Materialize one immutable grouped normalization dataset.",
   "normalize",
   deriveNormalizedRows
 );
 
-export const createNormalizedData = derivedCreator(
+export const createNormalizedData = /* @__PURE__ */ derivedCreator(
   "createNormalizedData",
   "Create a row-preserving grouped normalization dataset.",
   OPTIONS,

package/src/actions/data/regression.js

@@ -1,6 +1,6 @@
-import { action } from "../../core/action.js";
+import { closedAction } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
-import { validateKeys } from "../../core/validation.js";
+
 import {
   deriveRegression,
   normalizeRegressionTransform
@@ -11,9 +11,10 @@ import { derivedMaterializer } from "./shared.js";
 const OPTIONS = Object.freeze([
   "id", "source", "x", "y", "groupBy", "method", "degree", "span",
   "confidenceMethod", "level", "confidence", "interval"
+  , "predict", "missing"
 ]);
 
-export const materializeRegressionData = derivedMaterializer(
+export const materializeRegressionData = /* @__PURE__ */ derivedMaterializer(
   "materializeRegressionData",
   "Materialize one regression derived dataset.",
   "regression",
@@ -27,14 +28,15 @@ export const materializeRegressionData = derivedMaterializer(
       confidenceMethod: transform.confidenceMethod,
       level: transform.level,
       confidence: transform.confidence,
-      interval: transform.interval
+      interval: transform.interval,
+      predict: transform.predict
+      , missing: transform.missing
     })
 );
 
-export const createRegressionData = action(
-  { op: "createRegressionData", description: "Create grouped regression values and optional interval bounds." },
+export const createRegressionData = /* @__PURE__ */ closedAction(
+  { op: "createRegressionData", description: "Create grouped regression values and optional interval bounds." }, OPTIONS,
   function (args = {}) {
-    validateKeys(args, OPTIONS, "createRegressionData");
     const id = validateUserId(args.id, "Regression dataset id");
     const requestedSource = validateUserId(
       args.source ?? this.context.currentData,

package/src/actions/data/revise.js

@@ -0,0 +1,80 @@
+import { closedAction } from "../../core/action.js";
+import { validateUserId } from "../../core/identifiers.js";
+
+import { requireDataset } from "../../selectors/datasets.js";
+import { requireLayer } from "../../selectors/layers.js";
+import { applyRevisionPlan, buildSourceRevisionPlan } from "./edit.js";
+import { resolveStoredSelection } from "../../materialization/selection/state.js";
+import { withGuideLayoutTransaction } from "../../materialization/guides/layout.js";
+import { assertFieldsAvailable } from "../../grammar/datasetSchema.js";
+
+let reviseFacet;
+
+function layerInputFields(layer) {
+  const fields = [];
+  const add = value => {
+    if (typeof value === "string" && value.length > 0) fields.push(value);
+  };
+  for (const encoding of Object.values(layer.encoding ?? {})) {
+    if (!encoding || typeof encoding !== "object") continue;
+    add(encoding.field);
+    add(encoding.weight);
+    add(encoding.key);
+    add(encoding.pathOrder?.field);
+    add(encoding.categoryOrder?.by?.field);
+    for (const field of encoding.fields ?? []) add(field);
+    for (const dimension of encoding.dimensions ?? []) add(dimension.field);
+  }
+  return [...new Set(fields)];
+}
+
+export function registerFacetDataRevision(handler) {
+  reviseFacet = handler;
+}
+
+export function reviseUnitData(program, { source, id, values, schema }) {
+  const plan = buildSourceRevisionPlan(program, source, id);
+  const original = requireDataset(program, source);
+  const inheritedSchema = schema ?? (original.schema?.origin === "declared"
+    ? { fields: original.schema.fields.map(({ name, storageType, nullable, optional }) => ({
+        name, storageType, nullable, optional
+      })) }
+    : undefined);
+  const created = program.createData({ id, values, ...(inheritedSchema === undefined ? {} : { schema: inheritedSchema }) });
+  const revisedSource = requireDataset(created, id);
+  for (const layer of program.semanticSpec.layers.filter(layer => layer.data === source)) {
+    assertFieldsAvailable(revisedSource.schema, layerInputFields(layer), {
+      data: id,
+      operation: "reviseData"
+    });
+  }
+  const next = withGuideLayoutTransaction(created, candidate =>
+    applyRevisionPlan(candidate, undefined, plan, { retain: new Set([source]) }));
+  for (const [selection, config] of Object.entries(next.materializationConfigs.selections ?? {})) {
+    if (plan.replacements.has(requireLayer(program, config.target).data)) {
+      resolveStoredSelection(next, selection);
+    }
+  }
+  return { program: next, plan };
+}
+
+export const reviseData = /* @__PURE__ */ closedAction(
+  { op: "reviseData", description: "Revise source data and its dependent chart.", scope: "any" }, ["source", "id", "values", "schema"],
+  function (args = {}) {
+    const source = validateUserId(args.source, "Source dataset id");
+    const id = validateUserId(args.id, "Revision dataset id");
+    if (this.compositionSpec !== undefined && this.compositionSpec.type !== "facet") {
+      throw new Error("Revise an explicit child, then use replaceCompositionChild for concat.");
+    }
+    const original = requireDataset(this, source);
+    if (original.source !== undefined || !Array.isArray(original.values)) {
+      throw new Error(`Source "${source}" must be a materialized original dataset.`);
+    }
+    const apply = this.compositionSpec === undefined
+      ? program => reviseUnitData(program, { source, id, values: args.values, schema: args.schema }).program
+      : program => reviseFacet(program, { source, id, values: args.values, schema: args.schema });
+    // The entire dependent materialization must succeed before returning a revision.
+    apply(this);
+    return apply(this);
+  }
+);

package/src/actions/data/revisionBindings.js

@@ -1,11 +1,7 @@
-import { isPlainObject } from "../../core/immutable.js";
+import { collectDataOwnerReferences, collectMarkConfigReferences } from "../../core/resourceReferences.js";
 import { datasetTransformOutputRoles } from "../../grammar/transforms.js";
 import { requireLayer } from "../../selectors/layers.js";
 
-const DATA_REFERENCE_KEYS = new Set([
-  "data", "dataset", "dataId", "filteredData", "originalData",
-  "outlierDataId", "profileId", "source", "summaryId"
-]);
 
 export function outputFieldChanges(previous, next) {
   const before = datasetTransformOutputRoles(previous);
@@ -107,39 +103,23 @@ export function rebindLayerOutputFields(program, id, changes) {
   return next;
 }
 
-function replaceReferences(value, replacements, key) {
-  if (Array.isArray(value)) {
-    let changed = false;
-    const items = value.map(item => {
-      const next = replaceReferences(item, replacements);
-      changed ||= next !== item;
-      return next;
-    });
-    return changed ? items : value;
-  }
-  if (!isPlainObject(value)) {
-    return DATA_REFERENCE_KEYS.has(key) && replacements.has(value)
-      ? replacements.get(value)
-      : value;
-  }
-  let changed = false;
-  const result = {};
-  for (const [childKey, child] of Object.entries(value)) {
-    const next = replaceReferences(child, replacements, childKey);
-    changed ||= next !== child;
-    result[childKey] = next;
-  }
-  return changed ? result : value;
+function replaceAtPath(value, [key, ...rest], replacement) {
+  const result = Array.isArray(value) ? [...value] : { ...value };
+  Object.defineProperty(result, key, { value: rest.length === 0
+    ? replacement : replaceAtPath(value[key], rest, replacement),
+    enumerable: true, configurable: true, writable: true });
+  return result;
 }
 
 export function rebindMaterializationDataReferences(program, replacements) {
   if (replacements.size === 0) return program;
   let next = program;
-  for (const [key, config] of Object.entries(program.materializationConfigs)) {
-    const replaced = replaceReferences(config, replacements, key);
-    if (replaced !== config) {
-      next = next._withMaterializationConfig([key], replaced);
-    }
+  for (const ref of [...collectMarkConfigReferences(program), ...collectDataOwnerReferences(program)]) {
+    if (ref.kind !== "data" || !replacements.has(ref.id)) continue;
+    const path = ref.ownerKind === "markConfig" ? ["marks", ref.ownerId, ...ref.path] : ref.path;
+    const [root, ...rest] = path;
+    next = next._withMaterializationConfig([root],
+      replaceAtPath(next.materializationConfigs[root], rest, replacements.get(ref.id)));
   }
   return next;
 }

package/src/actions/data/shared.js

@@ -5,6 +5,12 @@ import {
   findDataset,
   resolveDatasetReference
 } from "../../selectors/datasets.js";
+import {
+  assertFieldsAvailable,
+  deriveTransformSchema,
+  transformInputFields,
+  validateRowsAgainstSchema
+} from "../../grammar/datasetSchema.js";
 
 export const MATERIALIZE_OPTIONS = Object.freeze(["id"]);
 
@@ -37,17 +43,39 @@ export function derivedMaterializer(op, description, type, derive, resolve) {
       args.id,
       type
     );
+    assertFieldsAvailable(source.schema, transformInputFields(transform), {
+      data: source.id,
+      operation: op
+    });
     const result = derive(source.values, transform);
+    const values = Array.isArray(result) ? result : result.values;
+    const schema = deriveTransformSchema(source.schema, transform, values, {
+      sourceId: source.id,
+      ownerId: id
+    });
+    validateRowsAgainstSchema(values, schema, `Derived dataset "${id}"`);
     const program = resolve === undefined
       ? this
       : this.editSemantic({
           property: `dataset[${id}].transform`,
           value: resolve(result, transform)
         });
-    return program.editSemantic({
+    let next = program.editSemantic({
       property: `dataset[${id}].values`,
-      value: Array.isArray(result) ? result : result.values
+      value: values
     });
+    if (!Array.isArray(result) && result.report !== undefined) {
+      const report = {
+        ...result.report,
+        owner: { kind: "data", id },
+        inputs: [{ kind: "data", id: source.id }]
+      };
+      next = next._withMaterializationConfig(
+        ["calculations", "datasets", id],
+        report
+      );
+    }
+    return next;
   });
 }
 

package/src/actions/data/sort.js

@@ -0,0 +1,21 @@
+import { deriveSortedRows, normalizeSortTransform } from "../../grammar/sort.js";
+import { derivedCreator, derivedMaterializer } from "./shared.js";
+
+const OPTIONS = Object.freeze(["id", "source", "sortBy"]);
+
+export const materializeSortedData = /* @__PURE__ */ derivedMaterializer(
+  "materializeSortedData",
+  "Materialize one immutable stable sorted dataset.",
+  "sort",
+  deriveSortedRows
+);
+
+export const createSortedData = /* @__PURE__ */ derivedCreator(
+  "createSortedData",
+  "Create reusable rows in a stable explicit order.",
+  OPTIONS,
+  "Sorted dataset id",
+  "Sorted source dataset id",
+  normalizeSortTransform,
+  "materializeSortedData"
+);

package/src/actions/data/stack.js

@@ -8,14 +8,14 @@ const OPTIONS = Object.freeze([
   "id", "source", "category", "group", "value", "mode", "as"
 ]);
 
-export const materializeStackData = derivedMaterializer(
+export const materializeStackData = /* @__PURE__ */ derivedMaterializer(
   "materializeStackData",
   "Materialize one immutable category/series stack dataset.",
   "stack",
   deriveStackRows
 );
 
-export const createStackData = derivedCreator(
+export const createStackData = /* @__PURE__ */ derivedCreator(
   "createStackData",
   "Create reusable start, end, value, and share stack rows.",
   OPTIONS,

package/src/actions/data/summary.js

@@ -5,17 +5,17 @@ import {
 import { derivedCreator, derivedMaterializer } from "./shared.js";
 
 const OPTIONS = Object.freeze([
-  "id", "source", "groupBy", "aggregates", "members", "weight"
+  "id", "source", "groupBy", "aggregates", "members", "weight", "missing", "empty"
 ]);
 
-export const materializeSummaryData = derivedMaterializer(
+export const materializeSummaryData = /* @__PURE__ */ derivedMaterializer(
   "materializeSummaryData",
   "Materialize one immutable grouped summary dataset.",
   "summary",
   deriveSummaryRows
 );
 
-export const createSummaryData = derivedCreator(
+export const createSummaryData = /* @__PURE__ */ derivedCreator(
   "createSummaryData",
   "Create reusable grouped aggregate values and provenance.",
   OPTIONS,

package/src/actions/data/timeUnit.js

@@ -9,14 +9,14 @@ const OPTIONS = Object.freeze([
   "weekStartsOn", "weekRule"
 ]);
 
-export const materializeTimeUnitData = derivedMaterializer(
+export const materializeTimeUnitData = /* @__PURE__ */ derivedMaterializer(
   "materializeTimeUnitData",
   "Materialize one immutable UTC time-unit dataset.",
   "timeUnit",
   deriveTimeUnitRows
 );
 
-export const createTimeUnitData = derivedCreator(
+export const createTimeUnitData = /* @__PURE__ */ derivedCreator(
   "createTimeUnitData",
   "Create immutable UTC calendar bucket values.",
   OPTIONS,

package/src/actions/data/window.js

@@ -8,14 +8,14 @@ const OPTIONS = Object.freeze([
   "id", "source", "partitionBy", "sortBy", "operations", "temporalUnit"
 ]);
 
-export const materializeWindowData = derivedMaterializer(
+export const materializeWindowData = /* @__PURE__ */ derivedMaterializer(
   "materializeWindowData",
   "Materialize one immutable window-derived dataset.",
   "window",
   deriveWindowRows
 );
 
-export const createWindowData = derivedCreator(
+export const createWindowData = /* @__PURE__ */ derivedCreator(
   "createWindowData",
   "Create immutable partitioned window values.",
   OPTIONS,

package/src/actions/encodings/angle.js

@@ -5,6 +5,8 @@ import {
   setEncodingProperties,
   validateOptions
 } from "./shared.js";
+import { applyRequestedItemMissingPolicy } from
+  "../../grammar/itemMissing.js";
 
 const OPTIONS = Object.freeze(["target", "value", "field", "fieldType"]);
 
@@ -14,7 +16,7 @@ function rematerialize(program, layer, target) {
     : program.rematerializePointMark({ id: target });
 }
 
-export const encodeAngle = action(
+export const encodeAngle = /* @__PURE__ */ action(
   {
     op: "encodeAngle",
     description: "Assign direct clockwise degree rotation to point or Tick glyphs."
@@ -29,7 +31,7 @@ export const encodeAngle = action(
     if (hasValue && args.fieldType !== undefined) {
       throw new Error("Constant angle does not accept fieldType.");
     }
-    const { id: target, dataset, layer } = resolveTarget(
+    const { id: target, dataset: sourceDataset, layer } = resolveTarget(
       this,
       args.target,
       ["point", "tick"],
@@ -39,6 +41,7 @@ export const encodeAngle = action(
       throw new TypeError("encodeAngle value must be finite degrees.");
     }
     if (hasField) {
+      const dataset = applyRequestedItemMissingPolicy(layer, sourceDataset, args.field);
       const fieldType = args.fieldType ?? "quantitative";
       if (fieldType !== "quantitative") {
         throw new Error("encodeAngle requires a quantitative field.");