ggaction 0.0.12 → 0.0.13

package/src/actions/data/derived.js

@@ -4,10 +4,22 @@ import { validateKeys } from "../../core/validation.js";
 import { hasDataset } from "../../selectors/index.js";
 import { findDataset } from "../../selectors/datasets.js";
 import { requireLayer } from "../../selectors/layers.js";
+import { applyLayerDataRematerialization } from
+  "../../materialization/dependencies.js";
 
 const OPTIONS = Object.freeze(["id", "source", "transform"]);
 const RELEASE_OPTIONS = Object.freeze(["id"]);
 const REBIND_OPTIONS = Object.freeze(["id", "data"]);
+const BIND_OPTIONS = Object.freeze(["target", "data"]);
+const OWNED_MARK_ROLES = Object.freeze([
+  "boxPlot",
+  "errorBand",
+  "errorBandBoundary",
+  "errorBar",
+  "gradientPlot",
+  "ecdfPlot",
+  "regression"
+]);
 
 export const createDerivedData = action(
   { op: "createDerivedData", description: "Create an immutable derived dataset definition." },
@@ -72,3 +84,57 @@ export const rebindLayerData = action(
     });
   }
 );
+
+function assertIndependentMark(program, layer) {
+  const config = program.markConfigs[layer.id] ?? {};
+  const role = OWNED_MARK_ROLES.find(key => config[key] !== undefined);
+  if (role !== undefined) {
+    throw new Error(
+      `Mark "${layer.id}" is owned by its ${role} lifecycle; use that ` +
+      "resource's edit action to change data roles."
+    );
+  }
+  const source = findDataset(program, layer.data);
+  const transform = source?.transform?.[0]?.type;
+  if (["density", "ecdf", "horizon", "markFilter"].includes(transform)) {
+    throw new Error(
+      `Mark "${layer.id}" consumes owned ${transform} data; use its ` +
+      "data or filter lifecycle action to change the source."
+    );
+  }
+}
+
+function applyMarkDataBinding(program, target, data) {
+  const rebound = program.rebindLayerData({ id: target, data });
+  return applyLayerDataRematerialization(rebound, target);
+}
+
+export const bindMarkData = action(
+  {
+    op: "bindMarkData",
+    description: "Atomically bind one independent mark to materialized data."
+  },
+  function (args = {}) {
+    validateKeys(args, BIND_OPTIONS, "bindMarkData");
+    const target = validateUserId(args.target, "Mark target id");
+    const data = validateUserId(args.data, "Mark dataset id");
+    const layer = requireLayer(this, target);
+    const dataset = findDataset(this, data);
+    if (dataset === undefined) {
+      throw new Error(`Mark dataset "${data}" does not exist.`);
+    }
+    if (!Array.isArray(dataset.values)) {
+      throw new Error(`Mark dataset "${data}" requires materialized values.`);
+    }
+    if (layer.data === data) {
+      throw new Error(`Mark "${target}" already uses dataset "${data}".`);
+    }
+    assertIndependentMark(this, layer);
+
+    // Finish the entire dependency plan on an immutable speculative branch.
+    // A field, type, coordinate, scale, guide, label, selection, or highlight
+    // incompatibility therefore rejects before this action returns any state.
+    applyMarkDataBinding(this, target, data);
+    return applyMarkDataBinding(this, target, data);
+  }
+);

package/src/actions/data/ecdf.js

@@ -0,0 +1,38 @@
+import {
+  deriveECDF,
+  normalizeECDFTransform,
+  resolveECDFTransform
+} from "../../grammar/ecdf.js";
+import { derivedCreator, derivedMaterializer } from "./shared.js";
+
+const OPTIONS = Object.freeze([
+  "id", "source", "field", "groupBy", "weight", "missing", "as"
+]);
+
+export const materializeECDFData = derivedMaterializer(
+  "materializeECDFData",
+  "Materialize one empirical cumulative distribution dataset.",
+  "ecdf",
+  deriveECDF,
+  resolveECDFTransform
+);
+
+export const createECDFData = derivedCreator(
+  "createECDFData",
+  "Create immutable empirical cumulative distribution values.",
+  OPTIONS,
+  "ECDF dataset id",
+  "ECDF source dataset id",
+  (args, id) => normalizeECDFTransform({
+    field: args.field,
+    groupBy: args.groupBy,
+    weight: args.weight,
+    missing: args.missing,
+    as: args.as ?? {
+      value: `__${id}_value`,
+      cumulative: `__${id}_cumulative`,
+      probability: `__${id}_probability`
+    }
+  }),
+  "materializeECDFData"
+);

package/src/actions/data/filter.js

@@ -1,22 +1,27 @@
 import { action } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
 import { validateKeys } from "../../core/validation.js";
+import { withPreviewDatasetValues } from
+  "../primitives/semanticAction.js";
 import {
   deriveFilteredRows,
   normalizeFilterTransform
 } from "../../grammar/filter.js";
 import {
   deriveMarkFilteredRows,
+  markFilterSelectors,
   normalizeMarkFilterTransform
 } from "../../grammar/markFilter.js";
 import { resolveMarkFilterSelection } from "../../materialization/selection/filter.js";
 import { findSelectionPolicy } from
   "../../materialization/selection/policies/index.js";
 import {
-  applyLayerDataRematerialization
+  applyLayerDataRematerialization,
+  applyLayerEmptyDataView
 } from "../../materialization/dependencies.js";
 import {
   hasDataset,
+  findDataset,
   requireLayer,
   resolveEligibleLayer
 } from "../../selectors/index.js";
@@ -29,7 +34,9 @@ const MARK_SELECTOR_KEYS = Object.freeze([
   "grain", "field", "channel", "property", "op", "value", "values",
   "min", "max", "inclusive", "count", "groupBy", "ties"
 ]);
-const MARK_OPTIONS = Object.freeze(["target", ...MARK_SELECTOR_KEYS]);
+const MARK_OPTIONS = Object.freeze(["target", "mode", ...MARK_SELECTOR_KEYS]);
+const REMOVE_MARK_FILTER_OPTIONS = Object.freeze(["target"]);
+const EMPTY_MARK_OPTIONS = Object.freeze(["id"]);
 
 function retainedHistogramBoundaries(layer, items) {
   if (layer.mark?.type !== "bar" || layer.encoding?.x?.bin === undefined) {
@@ -96,15 +103,168 @@ export const materializeMarkFilteredData = action(
         `Mark filter target "${transform.target}" must still use source dataset "${dataset.source}".`
       );
     }
-    const resolved = resolveMarkFilterSelection(
-      this,
-      transform.target,
-      transform.selector
-    );
-    return this.editSemantic({
+    let preview = this;
+    let currentRows = source.values;
+    const selectors = markFilterSelectors(transform);
+    for (const [index, selector] of selectors.entries()) {
+      const resolved = resolveMarkFilterSelection(
+        preview,
+        transform.target,
+        selector
+      );
+      currentRows = deriveMarkFilteredRows(
+        currentRows,
+        resolved.items,
+        resolved.keys
+      );
+      if (index < selectors.length - 1) {
+        preview = withPreviewDatasetValues(preview, {
+          id,
+          values: currentRows,
+          target: transform.target
+        });
+        preview = currentRows.length === 0
+          ? applyLayerEmptyDataView(preview, transform.target)
+          : applyLayerDataRematerialization(preview, transform.target);
+        currentRows = findDataset(preview, id).values;
+      }
+    }
+    if (selectors.length > 1) {
+      preview = withPreviewDatasetValues(preview, {
+        id,
+        omitValues: true
+      });
+    }
+    let next = preview.editSemantic({
       property: `dataset[${id}].values`,
-      value: deriveMarkFilteredRows(source.values, resolved.items, resolved.keys)
+      value: currentRows
+    });
+    if (requireLayer(next, transform.target).data !== id) {
+      next = next.editSemantic({
+        property: `layer[${transform.target}].data`,
+        value: id
+      });
+    }
+    next = next._withMarkConfig(transform.target, {
+      ...next.markConfigs[transform.target],
+      markFilter: {
+        ...next.markConfigs[transform.target].markFilter,
+        empty: currentRows.length === 0
+      }
+    });
+    return currentRows.length === 0
+      ? next.materializeEmptyMark({ id: transform.target })
+      : applyLayerDataRematerialization(next, transform.target);
+  }
+);
+
+export const materializeEmptyMark = action(
+  {
+    op: "materializeEmptyMark",
+    description: "Clear one active empty-filter mark without changing its domains."
+  },
+  function (args = {}) {
+    validateKeys(args, EMPTY_MARK_OPTIONS, "materializeEmptyMark");
+    const id = validateUserId(args.id, "Empty mark id");
+    const layer = requireLayer(this, id);
+    const owner = this.markConfigs[id]?.markFilter;
+    const dataset = findDataset(this, layer.data);
+    if (owner?.empty !== true || dataset?.values?.length !== 0) {
+      throw new Error(`Mark "${id}" does not own an active empty filter.`);
+    }
+    return applyLayerEmptyDataView(this, id);
+  }
+);
+
+function activeMarkFilter(program, layer) {
+  const configured = program.markConfigs[layer.id]?.markFilter;
+  const dataset = findDataset(program, layer.data);
+  const transform = dataset?.transform?.[0];
+  if (
+    dataset?.source === undefined ||
+    transform?.type !== "markFilter" ||
+    transform.target !== layer.id
+  ) {
+    return undefined;
+  }
+  return {
+    dataset: dataset.id,
+    source: dataset.source,
+    selectors: markFilterSelectors(transform),
+    ...(configured?.originalBin === undefined
+      ? {}
+      : { originalBin: configured.originalBin })
+  };
+}
+
+function withoutMarkFilterConfig(program, id) {
+  const config = program.markConfigs[id] ?? {};
+  const { markFilter: unused, ...remaining } = config;
+  void unused;
+  return program._withMarkConfig(id, remaining);
+}
+
+function restoreHistogramBin(program, layer, originalBin) {
+  let next = program;
+  const current = layer.encoding?.x?.bin ?? {};
+  for (const property of ["maxBins", "step", "boundaries"]) {
+    if (Object.hasOwn(originalBin, property)) {
+      next = next.editSemantic({
+        property: `layer[${layer.id}].encoding.x.bin.${property}`,
+        value: originalBin[property]
+      });
+    } else if (Object.hasOwn(current, property)) {
+      next = next.editSemantic({
+        property: `layer[${layer.id}].encoding.x.bin.${property}`,
+        remove: true
+      });
+    }
+  }
+  return next;
+}
+
+function removeActiveMarkFilter(program, layer, owner) {
+  let next = program.editSemantic({
+    property: `layer[${layer.id}].data`,
+    value: owner.source
+  });
+  if (owner.originalBin !== undefined) {
+    next = restoreHistogramBin(next, requireLayer(next, layer.id), owner.originalBin);
+  }
+  next = withoutMarkFilterConfig(next, layer.id)
+    .releaseDerivedData({ id: owner.dataset })
+    ._withContext({ currentData: owner.source });
+  return applyLayerDataRematerialization(next, layer.id);
+}
+
+function nextMarkFilterDatasetId(program, layerId) {
+  const base = `${layerId}FilteredData`;
+  if (!hasDataset(program, base)) return base;
+  let revision = 2;
+  while (hasDataset(program, `${base}${revision}`)) revision += 1;
+  return `${base}${revision}`;
+}
+
+function sameSelector(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+
+export const removeMarkFilter = action(
+  {
+    op: "removeMarkFilter",
+    description: "Remove one active final-item filter and restore its source."
+  },
+  function (args = {}) {
+    validateKeys(args, REMOVE_MARK_FILTER_OPTIONS, "removeMarkFilter");
+    const target = args.target === undefined
+      ? undefined
+      : validateUserId(args.target, "Mark filter target id");
+    const layer = resolveEligibleLayer(this, {
+      target,
+      label: "mark filter",
+      predicate: candidate => activeMarkFilter(this, candidate) !== undefined
     });
+    return removeActiveMarkFilter(this, layer, activeMarkFilter(this, layer));
   }
 );
 
@@ -115,6 +275,9 @@ export const filterMarks = action(
   },
   function (args = {}) {
     validateKeys(args, MARK_OPTIONS, "filterMarks");
+    if (args.mode !== undefined && !["replace", "compose"].includes(args.mode)) {
+      throw new Error(`Unknown mark filter mode "${args.mode}".`);
+    }
     const target = args.target === undefined
       ? undefined
       : validateUserId(args.target, "Filter mark target id");
@@ -130,46 +293,67 @@ export const filterMarks = action(
         `filterMarks does not support composite mark "${layer.id}"; filter its source dataset first.`
       );
     }
-    const derivedId = `${layer.id}FilteredData`;
-    if (hasDataset(this, derivedId)) {
-      throw new Error(`Dataset "${derivedId}" already exists.`);
-    }
+    const owner = activeMarkFilter(this, layer);
     const selector = Object.fromEntries(
       MARK_SELECTOR_KEYS.flatMap(key =>
         Object.hasOwn(args, key) ? [[key, args[key]]] : []
       )
     );
     const resolved = resolveMarkFilterSelection(this, layer.id, selector);
-    if (resolved.keys.length === 0) {
-      throw new Error("filterMarks requires at least one matching mark item.");
+    const previousSelector = owner?.selectors.at(-1);
+    if (previousSelector !== undefined && sameSelector(previousSelector, resolved.selector)) {
+      return this;
+    }
+    if (owner !== undefined && args.mode === undefined) {
+      throw new Error(
+        "Repeated filterMarks requires mode \"replace\" or \"compose\"."
+      );
     }
-    const transform = normalizeMarkFilterTransform(layer.id, resolved.selector);
-    const boundaries = retainedHistogramBoundaries(layer, resolved.items);
-    let next = this
+    const selectors = owner === undefined || args.mode === "replace"
+      ? [resolved.selector]
+      : [...owner.selectors, resolved.selector];
+    let next = owner === undefined
+      ? this
+      : removeActiveMarkFilter(this, layer, owner);
+    const baseLayer = requireLayer(next, layer.id);
+    const first = resolveMarkFilterSelection(next, layer.id, selectors[0]);
+    const transform = normalizeMarkFilterTransform(layer.id, selectors);
+    const boundaries = retainedHistogramBoundaries(baseLayer, first.items);
+    const originalBin = baseLayer.mark?.type === "bar" &&
+      baseLayer.encoding?.x?.bin !== undefined
+      ? baseLayer.encoding.x.bin
+      : undefined;
+    const derivedId = nextMarkFilterDatasetId(next, layer.id);
+    next = next
       .createDerivedData({
         id: derivedId,
-        source: layer.data,
+        source: baseLayer.data,
         transform: [transform]
-      })
-      .materializeMarkFilteredData({ id: derivedId });
+      });
     if (boundaries !== undefined) {
       for (const property of ["maxBins", "step"]) {
-        if (Object.hasOwn(layer.encoding.x.bin, property)) {
+        if (Object.hasOwn(baseLayer.encoding.x.bin, property)) {
           next = next.editSemantic({
-            property: `layer[${layer.id}].encoding.x.bin.${property}`,
+            property: `layer[${baseLayer.id}].encoding.x.bin.${property}`,
             remove: true
           });
         }
       }
       next = next.editSemantic({
-        property: `layer[${layer.id}].encoding.x.bin.boundaries`,
+        property: `layer[${baseLayer.id}].encoding.x.bin.boundaries`,
         value: boundaries
       });
     }
-    next = next.editSemantic({
-      property: `layer[${layer.id}].data`,
-      value: derivedId
+    next = next._withMarkConfig(baseLayer.id, {
+      ...next.markConfigs[baseLayer.id],
+      markFilter: {
+        dataset: derivedId,
+        source: baseLayer.data,
+        selectors,
+        empty: false,
+        ...(originalBin === undefined ? {} : { originalBin })
+      }
     });
-    return applyLayerDataRematerialization(next, layer.id);
+    return next.materializeMarkFilteredData({ id: derivedId });
   }
 );

package/src/actions/data/fold.js

@@ -0,0 +1,24 @@
+import {
+  deriveFoldRows,
+  normalizeFoldTransform
+} from "../../grammar/fold.js";
+import { derivedCreator, derivedMaterializer } from "./shared.js";
+
+const OPTIONS = Object.freeze(["id", "source", "fields", "as"]);
+
+export const materializeFoldData = derivedMaterializer(
+  "materializeFoldData",
+  "Materialize one immutable wide-to-long dataset.",
+  "fold",
+  deriveFoldRows
+);
+
+export const createFoldData = derivedCreator(
+  "createFoldData",
+  "Create reusable key/value rows from selected wide fields.",
+  OPTIONS,
+  "Fold dataset id",
+  "Fold source dataset id",
+  normalizeFoldTransform,
+  "materializeFoldData"
+);

package/src/actions/data/index.js

@@ -4,12 +4,15 @@ import {
 } from "./timeUnit.js";
 import {
   createDerivedData,
+  bindMarkData,
   rebindLayerData,
   releaseDerivedData
 } from "./derived.js";
 import {
   filterData,
   filterMarks,
+  materializeEmptyMark,
+  removeMarkFilter,
   materializeFilteredData,
   materializeMarkFilteredData
 } from "./filter.js";
@@ -24,6 +27,7 @@ import {
   materializeDensityData
 } from "./density.js";
 import { createIntervalData, materializeIntervalData } from "./interval.js";
+import { createECDFData, materializeECDFData } from "./ecdf.js";
 import { createHorizonData, materializeHorizonData } from "./horizon.js";
 import {
   createBin2DData,
@@ -32,11 +36,17 @@ import {
 } from "./bin2d.js";
 import { createData } from "./create.js";
 import { createWindowData, materializeWindowData } from "./window.js";
+import { createSummaryData, materializeSummaryData } from "./summary.js";
+import { createBinData, materializeBinData } from "./bin.js";
+import { createFoldData, materializeFoldData } from "./fold.js";
+import { createComputedData, materializeComputedData } from "./computed.js";
+import { createStackData, materializeStackData } from "./stack.js";
 import { createBoxSummaryData, createBoxOutlierData, materializeBoxSummaryData, materializeBoxOutlierData } from "./box.js";
 
 export function registerDataActions(ProgramClass) {
   ProgramClass.prototype.createData = createData;
   ProgramClass.prototype.createDerivedData = createDerivedData;
+  ProgramClass.prototype.bindMarkData = bindMarkData;
   ProgramClass.prototype.releaseDerivedData = releaseDerivedData;
   ProgramClass.prototype.rebindLayerData = rebindLayerData;
   ProgramClass.prototype.createDensityData = createDensityData;
@@ -46,6 +56,8 @@ export function registerDataActions(ProgramClass) {
   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;
@@ -54,10 +66,22 @@ export function registerDataActions(ProgramClass) {
   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.createStackData = createStackData;
+  ProgramClass.prototype.materializeStackData = materializeStackData;
   ProgramClass.prototype.createTimeUnitData = createTimeUnitData;
   ProgramClass.prototype.materializeTimeUnitData = materializeTimeUnitData;
   ProgramClass.prototype.createBin2DData = createBin2DData;

package/src/actions/data/interval.js

@@ -11,6 +11,7 @@ const OPTIONS = Object.freeze([
   "groupBy",
   "center",
   "extent",
+  "method",
   "level",
   "as"
 ]);
@@ -39,6 +40,7 @@ export const createIntervalData = derivedCreator(
       groupBy: args.groupBy,
       center: args.center,
       extent: args.extent,
+      method: args.method,
       level: args.level,
       as
     });

package/src/actions/data/intervalEdit.js

@@ -7,7 +7,7 @@ import { planDerivedDataRevision } from
 import { findDataset } from "../../selectors/datasets.js";
 import { resolveEligibleLayer } from "../../selectors/layers.js";
 
-const STATISTICS_OPTIONS = Object.freeze(["center", "extent", "level"]);
+const STATISTICS_OPTIONS = Object.freeze(["center", "extent", "method", "level"]);
 
 export function ownOptions(value, options) {
   return Object.fromEntries(
@@ -42,6 +42,7 @@ export function createResolvedIntervalData(program, resolved) {
     groupBy: resolved.groupBy,
     center: resolved.interval.center,
     extent: resolved.interval.extent,
+    method: resolved.interval.method,
     level: resolved.interval.level,
     as: resolved.fields
   });
@@ -49,7 +50,9 @@ export function createResolvedIntervalData(program, resolved) {
 
 export function applyIntervalRevision(program, interval) {
   if (!interval.changed) return program;
-  let next = program.createIntervalData(interval.dataArgs);
+  let next = interval.dataArgs === undefined
+    ? program
+    : program.createIntervalData(interval.dataArgs);
   for (const rebind of interval.revision.rebinds) {
     next = next.rebindLayerData(rebind);
   }
@@ -57,11 +60,84 @@ export function applyIntervalRevision(program, interval) {
 }
 
 export function releaseIntervalRevision(program, interval) {
-  return interval.changed
+  return interval.changed && interval.revision.release !== undefined
     ? program.releaseDerivedData(interval.revision.release)
     : program;
 }
 
+export function findIntervalTransform(program, data) {
+  const dataset = findDataset(program, data);
+  return dataset?.transform?.length === 1 &&
+    dataset.transform[0].type === "interval"
+    ? dataset.transform[0]
+    : undefined;
+}
+
+export function collectIntervalConsumers(program, owners) {
+  const consumers = new Set(owners);
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const layer of program.semanticSpec.layers ?? []) {
+      if (
+        layer.source !== undefined &&
+        consumers.has(layer.source) &&
+        !consumers.has(layer.id)
+      ) {
+        consumers.add(layer.id);
+        changed = true;
+      }
+    }
+  }
+  return [...consumers];
+}
+
+export function planIntervalRoleData(program, {
+  owner,
+  currentData,
+  candidate,
+  consumers
+}) {
+  const previousTransform = findIntervalTransform(program, currentData);
+  if (candidate.interval.mode === "statistical") {
+    const revision = planDerivedDataRevision(program, {
+      owner,
+      role: "IntervalData",
+      ...(previousTransform === undefined ? {} : { previous: currentData }),
+      consumers
+    });
+    return {
+      changed: true,
+      revision,
+      dataId: revision.id,
+      dataArgs: {
+        id: revision.id,
+        source: candidate.source,
+        field: candidate.interval.field,
+        groupBy: candidate.groupBy,
+        center: candidate.interval.center,
+        extent: candidate.interval.extent,
+        method: candidate.interval.method,
+        level: candidate.interval.level,
+        as: candidate.fields
+      }
+    };
+  }
+  const changed = currentData !== candidate.source;
+  return {
+    changed,
+    dataId: candidate.source,
+    revision: {
+      rebinds: changed
+        ? consumers.map(id => ({ id, data: candidate.source }))
+        : [],
+      ...(previousTransform === undefined
+        ? {}
+        : { release: { id: currentData } })
+    }
+  };
+}
+
 export function planIntervalEdit(program, {
   owner,
   data,
@@ -75,7 +151,7 @@ export function planIntervalEdit(program, {
   validateKeys(statistics, STATISTICS_OPTIONS, `${operation} statistics`);
   if (!STATISTICS_OPTIONS.some(key => Object.hasOwn(statistics, key))) {
     throw new Error(
-      `${operation} statistics requires center, extent, or level.`
+      `${operation} statistics requires center, extent, method, or level.`
     );
   }
   const previous = findDataset(program, data);
@@ -95,6 +171,11 @@ export function planIntervalEdit(program, {
     ? statistics.extent
     : transform.extent;
   const raw = { center, extent };
+  if (Object.hasOwn(statistics, "method")) {
+    raw.method = statistics.method;
+  } else if (extent === "ci" && transform.extent === "ci") {
+    raw.method = transform.method;
+  }
   if (Object.hasOwn(statistics, "level")) {
     raw.level = statistics.level;
   } else if (extent === "ci" && transform.extent === "ci") {
@@ -104,6 +185,7 @@ export function planIntervalEdit(program, {
   const current = {
     center: transform.center,
     extent: transform.extent,
+    ...(transform.method === undefined ? {} : { method: transform.method }),
     ...(transform.level === undefined ? {} : { level: transform.level })
   };
   const changed = JSON.stringify(parameters) !== JSON.stringify(current);