ggaction 0.0.4 → 0.0.5

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

@@ -9,6 +9,44 @@ function replaceAlternateBinding(program, target, channel, previous, usesField)
     : program;
 }
 
+function reconcileInheritedRulePosition(program, {
+  target,
+  channel,
+  layer,
+  hasField
+}) {
+  const config = program.markConfigs[target] ?? {};
+  const inherited = config.inheritedPosition;
+  if (layer.mark.type !== "rule" || inherited === undefined) return program;
+
+  let channels = inherited.channels.filter(candidate => candidate !== channel);
+  let next = program;
+  if (
+    !hasField &&
+    ["x", "y"].includes(channel) &&
+    layer.encoding?.x2 === undefined &&
+    layer.encoding?.y2 === undefined
+  ) {
+    const opposite = channel === "x" ? "y" : "x";
+    if (channels.includes(opposite) && layer.encoding?.[opposite] !== undefined) {
+      next = next.editSemantic({
+        property: `layer[${target}].encoding.${opposite}`,
+        remove: true
+      });
+      channels = channels.filter(candidate => candidate !== opposite);
+    }
+  }
+
+  const { inheritedPosition, ...rest } = config;
+  void inheritedPosition;
+  return next._withMarkConfig(target, channels.length === 0
+    ? rest
+    : {
+        ...rest,
+        inheritedPosition: { ...inherited, channels }
+      });
+}
+
 function applyBin(program, target, channel, previous, bin) {
   if (bin === undefined) return program;
   const [mode] = Object.keys(bin);
@@ -26,9 +64,26 @@ function applyBin(program, target, channel, previous, bin) {
   });
 }
 
+function applyArcThetaWeight(program, target, channel, previous, aggregate, weight) {
+  if (channel !== "theta") return program;
+  if (aggregate !== "sum") {
+    return previous?.weight === undefined
+      ? program
+      : program.editSemantic({
+          property: `layer[${target}].encoding.theta.weight`,
+          remove: true
+        });
+  }
+  return program.editSemantic({
+    property: `layer[${target}].encoding.theta.weight`,
+    value: weight
+  });
+}
+
 export function applyPositionSemantics(program, {
   target,
   channel,
+  layer,
   previous,
   field,
   datum,
@@ -36,10 +91,17 @@ export function applyPositionSemantics(program, {
   fieldType,
   bin,
   aggregate,
-  stack
+  stack,
+  weight
 }) {
-  let next = replaceAlternateBinding(
-    program,
+  let next = reconcileInheritedRulePosition(program, {
+    target,
+    channel,
+    layer,
+    hasField
+  });
+  next = replaceAlternateBinding(
+    next,
     target,
     channel,
     previous,
@@ -62,5 +124,12 @@ export function applyPositionSemantics(program, {
       value
     });
   }
-  return next;
+  return applyArcThetaWeight(
+    next,
+    target,
+    channel,
+    previous,
+    aggregate,
+    weight
+  );
 }

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

@@ -24,7 +24,8 @@ function encodePosition(program, channel, args, operation) {
     coordinate,
     bin,
     aggregate,
-    stack
+    stack,
+    weight
   } = resolvePositionEncoding(program, channel, args, operation);
 
   let next = program
@@ -36,6 +37,7 @@ function encodePosition(program, channel, args, operation) {
   next = applyPositionSemantics(next, {
     target,
     channel,
+    layer,
     previous,
     field,
     datum,
@@ -43,7 +45,8 @@ function encodePosition(program, channel, args, operation) {
     fieldType,
     bin,
     aggregate,
-    stack
+    stack,
+    weight
   });
 
   next = next.editSemantic({
@@ -71,6 +74,16 @@ function encodePosition(program, channel, args, operation) {
     }
   }
 
+  if (layer.mark.type === "rect") {
+    const updated = findLayer(next, target);
+    const pendingGradient = next.markConfigs[target]?.gradientPlot;
+    if (pendingGradient !== undefined && !pendingGradient.materialized) {
+      return updated.encoding?.x !== undefined && updated.encoding?.y !== undefined
+        ? next.materializeGradientPlot({ id: target })
+        : next;
+    }
+  }
+
   const updated = findLayer(next, target);
   for (const step of getPositionEncodingMaterializationSteps(
     next,

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

@@ -1,4 +1,5 @@
 import { validateAggregate } from "../../../../grammar/aggregate.js";
+import { validateNonEmptyString } from "../../../../core/validation.js";
 import { emptyPositionPolicy } from "./common.js";
 
 export function resolveArcPositionPolicy({ channel, args, fieldType }) {
@@ -12,15 +13,37 @@ export function resolveArcPositionPolicy({ channel, args, fieldType }) {
     if (args.aggregate !== undefined) {
       throw new Error("Arc radius encoding does not support aggregate.");
     }
+    if (args.weight !== undefined) {
+      throw new Error("Arc radius encoding does not support weight.");
+    }
     return emptyPositionPolicy();
   }
   if (!["ordinal", "nominal"].includes(fieldType)) {
     throw new Error("Arc theta encoding requires an ordinal or nominal field.");
   }
-  if (args.aggregate === undefined) return emptyPositionPolicy();
+  if (args.aggregate === undefined) {
+    if (args.weight !== undefined) {
+      throw new Error('Arc theta weight requires aggregate: "sum".');
+    }
+    return emptyPositionPolicy();
+  }
   const aggregate = validateAggregate(args.aggregate);
-  if (aggregate !== "count") {
-    throw new Error('Arc theta aggregate currently supports only "count".');
+  if (!["count", "sum"].includes(aggregate)) {
+    throw new Error('Arc theta aggregate supports only "count" or "sum".');
+  }
+  if (aggregate === "count") {
+    if (args.weight !== undefined) {
+      throw new Error('Arc theta weight requires aggregate: "sum".');
+    }
+    return { bin: undefined, aggregate, stack: undefined, weight: undefined };
+  }
+  if (args.weight === undefined) {
+    throw new Error('Arc theta aggregate "sum" requires weight.');
   }
-  return { bin: undefined, aggregate, stack: undefined };
+  return {
+    bin: undefined,
+    aggregate,
+    stack: undefined,
+    weight: validateNonEmptyString(args.weight, "Arc theta weight")
+  };
 }

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

@@ -1,6 +1,37 @@
 import { validateStack, emptyPositionPolicy } from "./common.js";
 
-export function resolveAreaPositionPolicy({ dataset, channel, args, fieldType }) {
+export function isCategoricalDensityPosition({
+  layer,
+  dataset,
+  channel,
+  fieldType,
+  field
+}) {
+  const density = dataset.transform?.find(transform => transform.type === "density");
+  return layer.mark?.type === "area" &&
+    ["nominal", "ordinal"].includes(fieldType) &&
+    density?.placement?.type === "category" &&
+    density.placement.channel === channel &&
+    density.placement.categoryField === field;
+}
+
+export function resolveAreaPositionPolicy({ dataset, channel, args, fieldType, field }) {
+  const density = dataset.transform?.find(transform => transform.type === "density");
+  if (["nominal", "ordinal"].includes(fieldType)) {
+    if (
+      density?.placement?.type !== "category" ||
+      density.placement.channel !== channel ||
+      density.placement.categoryField !== field
+    ) {
+      throw new Error(
+        "Categorical area position requires a matching category density placement."
+      );
+    }
+    if (args.aggregate !== undefined || args.bin !== undefined || args.stack !== undefined) {
+      throw new Error("Categorical density position does not support aggregate, bin, or stack.");
+    }
+    return emptyPositionPolicy();
+  }
   if (!["quantitative", "temporal"].includes(fieldType)) {
     throw new Error(
       "Area position encoding requires quantitative or temporal fields."
@@ -12,7 +43,7 @@ export function resolveAreaPositionPolicy({ dataset, channel, args, fieldType })
   if (args.stack === undefined) return emptyPositionPolicy();
   if (
     channel !== "y" ||
-    !dataset.transform?.some(transform => transform.type === "density")
+    density === undefined
   ) {
     throw new Error("Area stack currently requires a density y encoding.");
   }

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

@@ -1,6 +1,9 @@
 import { validatePositionFieldCompatibility } from
   "../../../../grammar/positionCompatibility.js";
-import { resolveAreaPositionPolicy } from "./area.js";
+import {
+  isCategoricalDensityPosition,
+  resolveAreaPositionPolicy
+} from "./area.js";
 import { resolveArcPositionPolicy } from "./arc.js";
 import { resolveBarPositionPolicy } from "./bar.js";
 import { resolveLinePositionPolicy } from "./line.js";
@@ -20,7 +23,9 @@ const POSITION_POLICIES = Object.freeze({
 
 export function resolveMarkPositionPolicy(context) {
   const { layer, channel, fieldType } = context;
-  validatePositionFieldCompatibility(layer.mark.type, channel, fieldType);
+  if (!isCategoricalDensityPosition(context)) {
+    validatePositionFieldCompatibility(layer.mark.type, channel, fieldType);
+  }
   const policy = POSITION_POLICIES[layer.mark.type];
   if (policy === undefined) {
     throw new Error(`Unsupported position policy for mark "${layer.mark.type}".`);

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

@@ -44,9 +44,14 @@ export function resolveLinePositionPolicy({
       layer.encoding?.y?.aggregate === undefined &&
       ["quantitative", "temporal"].includes(layer.encoding?.y?.fieldType) &&
       fieldType === "quantitative";
+    const pendingQuantitativePair =
+      layer.encoding?.y === undefined && fieldType === "quantitative";
     if (
       fieldType !== "temporal" &&
-      !((regression || interval || directPair) && fieldType === "quantitative")
+      !(
+        (regression || interval || directPair || pendingQuantitativePair) &&
+        fieldType === "quantitative"
+      )
     ) {
       throw new Error(
         "Line x encoding requires a temporal field or a compatible derived quantitative field."
@@ -60,10 +65,14 @@ export function resolveLinePositionPolicy({
   }
 
   rejectSharedOptions(args, "y");
+  const quantitativePair =
+    fieldType === "quantitative" &&
+    layer.encoding?.x?.fieldType === "quantitative";
   const prospectiveDirect =
     args.aggregate === undefined &&
     (fieldType === "temporal" ||
-      (fieldType === "quantitative" && layer.encoding?.x === undefined));
+      (fieldType === "quantitative" &&
+        (layer.encoding?.x === undefined || quantitativePair)));
   if (interval || prospectiveDirect) {
     if (!["quantitative", "temporal"].includes(fieldType)) {
       throw new Error(
@@ -85,6 +94,13 @@ export function resolveLinePositionPolicy({
     return emptyPositionPolicy();
   }
 
+  if (
+    layer.encoding?.x !== undefined &&
+    layer.encoding.x.fieldType !== "temporal"
+  ) {
+    throw new Error("Aggregate line y encoding requires a temporal x encoding.");
+  }
+
   const aggregate = validateAggregate(args.aggregate);
   validateAggregateFieldType(aggregate, fieldType);
   return { bin: undefined, aggregate, stack: undefined };

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

@@ -21,6 +21,7 @@ import {
   validateAggregateFieldValues,
 } from "../../../grammar/aggregate.js";
 import { normalizeRuleDatum } from "../../../grammar/rules.js";
+import { readArcThetaWeights } from "../../../grammar/arcs.js";
 import { resolveMarkPositionPolicy } from "./policies/index.js";
 import {
   getPositionChannelDefinition,
@@ -29,7 +30,7 @@ import {
 
 const POSITION_ENCODING_OPTIONS = Object.freeze([
   "field", "datum", "target", "fieldType", "scale", "coordinate",
-  "aggregate", "bin", "stack"
+  "aggregate", "bin", "stack", "weight"
 ]);
 
 function validateCoordinateFamily(layer, channel, operation) {
@@ -82,6 +83,12 @@ export function resolvePositionEncoding(program, channel, args, operation) {
     args.target,
     getPositionChannelDefinition(channel).markTypes
   );
+  if (
+    Object.hasOwn(args, "weight") &&
+    !(layer.mark.type === "arc" && channel === "theta")
+  ) {
+    throw new Error(`${operation} weight is supported only for arc theta encoding.`);
+  }
   validateCoordinateFamily(layer, channel, operation);
   const hasField = Object.hasOwn(args, "field");
   const hasDatum = Object.hasOwn(args, "datum");
@@ -97,7 +104,8 @@ export function resolvePositionEncoding(program, channel, args, operation) {
   }
   const previous = layer.encoding?.[channel];
   const requestedFieldType = args.fieldType ?? previous?.fieldType ?? (
-    layer.mark.type === "arc" && channel === "theta" && args.aggregate === "count"
+    layer.mark.type === "arc" && channel === "theta" &&
+      ["count", "sum"].includes(args.aggregate)
       ? "nominal"
       : "quantitative"
   );
@@ -117,6 +125,14 @@ export function resolvePositionEncoding(program, channel, args, operation) {
       effectiveArgs[property] = previous[property];
     }
   }
+  if (
+    !Object.hasOwn(effectiveArgs, "weight") &&
+    effectiveArgs.aggregate === "sum" &&
+    previous !== undefined &&
+    Object.hasOwn(previous, "weight")
+  ) {
+    effectiveArgs.weight = previous.weight;
+  }
   const policy = resolveMarkPositionPolicy({
     program,
     layer,
@@ -179,6 +195,12 @@ export function resolvePositionEncoding(program, channel, args, operation) {
   } else if (aggregateOutput) {
     validateAggregateFieldType(policy.aggregate, fieldType);
     validateAggregateFieldValues(dataset.values, field, fieldType);
+  } else if (
+    layer.mark.type === "arc" &&
+    channel === "theta" &&
+    policy.aggregate === "sum"
+  ) {
+    readArcThetaWeights(dataset.values, policy.weight, layer.id);
   } else if (program.markConfigs[target]?.boxPlot !== undefined) {
     for (const [index, row] of dataset.values.entries()) {
       const value = row[field];

package/src/actions/encodings/ranged.js

@@ -157,7 +157,9 @@ function encodeSecondaryPosition(program, channel, args, operation, types) {
     ? next.rematerializeBarMark({ id: target })
     : layer.mark.type === "rect"
       ? next.rematerializeRectMark({ id: target })
-      : next.rematerializeAreaMark({ id: target });
+      : canMaterializeArea(next, findLayer(next, target))
+        ? next.rematerializeAreaMark({ id: target })
+        : next;
 }
 
 const encodeX2 = action(

package/src/actions/encodings/ruleAppearance.js

@@ -3,9 +3,22 @@ import {
   validateRuleStroke,
   validateRuleStrokeWidth
 } from "../../grammar/ruleAppearance.js";
-import { resolveTarget, validateOptions } from "./shared.js";
+import { readQuantitativeField } from "../../grammar/scales/index.js";
+import { resolveStrokeWidthScaleDefinition } from "../scales/definitions.js";
+import {
+  applyEncodingScale,
+  resolveReassignmentScaleOptions,
+  resolveTarget,
+  validateOptions
+} from "./shared.js";
+import { applyMaterializationPlan } from "../../materialization/dependencies.js";
+import { planEncodingRematerialization } from "../../materialization/encodings.js";
+import { findLayer } from "../../selectors/layers.js";
 
-const OPTIONS = Object.freeze(["target", "value"]);
+const STROKE_OPTIONS = Object.freeze(["target", "value"]);
+const WIDTH_OPTIONS = Object.freeze([
+  "target", "value", "field", "fieldType", "scale"
+]);
 
 const encodeStroke = action(
   {
@@ -13,7 +26,7 @@ const encodeStroke = action(
     description: "Set a constant graphical stroke on a rule mark."
   },
   function (args = {}) {
-    validateOptions(args, OPTIONS, "encodeStroke");
+    validateOptions(args, STROKE_OPTIONS, "encodeStroke");
     const { id } = resolveTarget(this, args.target, ["rule"], "rule mark");
     return this
       ._withMarkConfig(id, {
@@ -30,14 +43,79 @@ const encodeStrokeWidth = action(
     description: "Set a constant graphical stroke width on a rule mark."
   },
   function (args = {}) {
-    validateOptions(args, OPTIONS, "encodeStrokeWidth");
-    const { id } = resolveTarget(this, args.target, ["rule"], "rule mark");
-    return this
-      ._withMarkConfig(id, {
-        ...this.markConfigs[id],
-        strokeWidth: validateRuleStrokeWidth(args.value)
+    validateOptions(args, WIDTH_OPTIONS, "encodeStrokeWidth");
+    const hasValue = Object.hasOwn(args, "value");
+    const hasField = Object.hasOwn(args, "field");
+    if (hasValue === hasField) {
+      throw new Error("encodeStrokeWidth requires exactly one of value or field.");
+    }
+    if (hasValue) {
+      const { id } = resolveTarget(this, args.target, ["rule"], "rule mark");
+      let next = this.guideConfigs.legend?.strokeWidth?.target === id
+        ? this.removeLegend({ target: id })
+        : this;
+      if (findLayer(next, id)?.encoding?.strokeWidth !== undefined) {
+        next = next.editSemantic({
+          property: `layer[${id}].encoding.strokeWidth`,
+          remove: true
+        });
+      }
+      return next
+        ._withMarkConfig(id, {
+          ...next.markConfigs[id],
+          strokeWidth: validateRuleStrokeWidth(args.value)
+        })
+        .rematerializeRuleMark({ id });
+    }
+    const { id, dataset, layer } = resolveTarget(
+      this,
+      args.target,
+      ["rule", "line"],
+      "rule or line mark"
+    );
+    const fieldType = args.fieldType ?? "quantitative";
+    if (fieldType !== "quantitative") {
+      throw new Error("encodeStrokeWidth requires a quantitative field.");
+    }
+    const values = readQuantitativeField(dataset.values, args.field);
+    if (values.some(value => value < 0)) {
+      throw new RangeError(
+        `encodeStrokeWidth field "${args.field}" cannot contain negative values.`
+      );
+    }
+    const previous = layer.encoding?.strokeWidth;
+    const requestedScale = resolveReassignmentScaleOptions(
+      previous,
+      args.scale ?? {}
+    );
+    const scale = resolveStrokeWidthScaleDefinition(this, requestedScale);
+    const { strokeWidth, ...config } = this.markConfigs[id] ?? {};
+    void strokeWidth;
+    let next = this
+      ._withMarkConfig(id, config)
+      .editSemantic({
+        property: `layer[${id}].encoding.strokeWidth.field`,
+        value: args.field
       })
-      .rematerializeRuleMark({ id });
+      .editSemantic({
+        property: `layer[${id}].encoding.strokeWidth.fieldType`,
+        value: fieldType
+      })
+      .editSemantic({
+        property: `layer[${id}].encoding.strokeWidth.scale`,
+        value: scale.id
+      });
+    next = applyEncodingScale(next, scale, requestedScale, {
+      reassignment: previous?.scale === scale.id
+    });
+    return applyMaterializationPlan(
+      next,
+      planEncodingRematerialization(next, {
+        target: id,
+        channel: "strokeWidth",
+        scale: scale.id
+      })
+    );
   }
 );
 

package/src/actions/facets/actions.js

@@ -14,7 +14,7 @@ import { compositionChildDescriptor } from
   "../../materialization/composition.js";
 import { DEFAULT_COLORS, DEFAULT_FONT_FAMILY } from "../../theme/defaults.js";
 import { deriveFacetChildren } from "./derive.js";
-import { rebindLayerData, replayDerivedData } from "./replay.js";
+import { replayDerivedData } from "./replay.js";
 import { composeFacetGuides } from "./guides.js";
 
 const FACET_OPTIONS = Object.freeze([
@@ -155,7 +155,6 @@ export const editFacetHeaders = action(
 
 export function registerFacetActions(ProgramClass) {
   ProgramClass.prototype.replayDerivedData = replayDerivedData;
-  ProgramClass.prototype.rebindLayerData = rebindLayerData;
   ProgramClass.prototype.composeFacetGuides = composeFacetGuides;
   ProgramClass.prototype.facet = facet;
   ProgramClass.prototype.editFacetHeaders = editFacetHeaders;

package/src/actions/facets/derive.js

@@ -12,6 +12,7 @@ import { buildMaterializationPlan } from "../../materialization/planner.js";
 import { requireDataset } from "../../selectors/datasets.js";
 import { requireLayer } from "../../selectors/layers.js";
 import { findSemanticScale } from "../../selectors/scales.js";
+import { findTransformPolicy } from "../../grammar/transforms.js";
 
 function sharedHistogramBoundaries(program) {
   const boundaries = new Map();
@@ -59,6 +60,23 @@ function replayDatasetId(cell, owner) {
   return `${cell.id}-${owner}-data`;
 }
 
+function rebindReplayedGradientPlots(child, base, datasets) {
+  let next = child;
+  for (const [id, markConfig] of Object.entries(base.markConfigs)) {
+    const gradientPlot = markConfig.gradientPlot;
+    if (gradientPlot?.materialized !== true) continue;
+    const profile = datasets.get(gradientPlot.profileId);
+    const source = datasets.get(gradientPlot.source);
+    if (profile === undefined || source === undefined) {
+      throw new Error(
+        `Facet gradient plot "${id}" is missing replayed profile dependencies.`
+      );
+    }
+    next = next.rebindGradientPlotProfile({ id, profile, source });
+  }
+  return next;
+}
+
 function cellMaterializationPlan(program) {
   const scaleIds = [...new Set(program.semanticSpec.layers.flatMap(layer =>
     Object.values(layer.encoding ?? {})
@@ -72,7 +90,13 @@ function cellMaterializationPlan(program) {
   return buildMaterializationPlan({ scales });
 }
 
-function deriveCellProgram(base, definition, cell, histogramBoundaries) {
+function deriveCellProgram(
+  base,
+  definition,
+  cell,
+  histogramBoundaries,
+  scales
+) {
   let child = base.filterData({
     id: cell.data,
     source: definition.data,
@@ -88,10 +112,15 @@ function deriveCellProgram(base, definition, cell, histogramBoundaries) {
       );
     }
     const id = replayDatasetId(cell, replay.id);
+    const policy = findTransformPolicy(replay.transform.type);
+    const transform = policy?.facetReplayTransform?.(
+      replay.transform,
+      { scales }
+    ) ?? replay.transform;
     child = child.replayDerivedData({
       id,
       source,
-      transform: replay.transform
+      transform
     });
     datasets.set(replay.id, id);
   }
@@ -109,6 +138,7 @@ function deriveCellProgram(base, definition, cell, histogramBoundaries) {
       histogramBoundaries.get(layer.id)
     );
   }
+  child = rebindReplayedGradientPlots(child, base, datasets);
   return applyMaterializationPlan(child, cellMaterializationPlan(child));
 }
 
@@ -163,7 +193,7 @@ export function deriveFacetChildren(
     : new Map();
   const independentlyResolved = Object.fromEntries(definition.cells.map(cell => [
     cell.id,
-    deriveCellProgram(template, definition, cell, bins)
+    deriveCellProgram(template, definition, cell, bins, resolutionRequest)
   ]));
   const resolution = resolveFacetScaleDomains(
     template.semanticSpec,

package/src/actions/facets/replay.js

@@ -2,33 +2,25 @@ import { action } from "../../core/action.js";
 import { isPlainObject } from "../../core/immutable.js";
 import { validateUserId } from "../../core/identifiers.js";
 import { validateKeys } from "../../core/validation.js";
+import { findTransformPolicy } from "../../grammar/transforms.js";
 import { hasDataset } from "../../selectors/datasets.js";
-import { requireLayer } from "../../selectors/layers.js";
 
 const REPLAY_OPTIONS = Object.freeze(["id", "source", "transform"]);
-const REBIND_OPTIONS = Object.freeze(["id", "data"]);
-const MATERIALIZERS = Object.freeze({
-  filter: "materializeFilteredData",
-  regression: "materializeRegressionData",
-  density: "materializeDensityData",
-  interval: "materializeIntervalData",
-  boxSummary: "materializeBoxSummaryData",
-  boxOutlier: "materializeBoxOutlierData"
-});
 
 function requestedTransform(transform) {
   if (!isPlainObject(transform)) {
     throw new TypeError("replayDerivedData transform must be a plain object.");
   }
-  const materialize = MATERIALIZERS[transform.type];
-  if (materialize === undefined) {
+  const policy = findTransformPolicy(transform.type);
+  if (policy?.facetTopology === undefined) {
     throw new Error(
       `replayDerivedData does not support transform "${transform.type ?? "unknown"}".`
     );
   }
-  if (transform.type !== "density") return { transform, materialize };
-  const { resolved: _resolved, ...requested } = transform;
-  return { transform: requested, materialize };
+  return {
+    transform: policy.replayTransform?.(transform) ?? transform,
+    materialize: policy.materializeOp
+  };
 }
 
 export const replayDerivedData = action(
@@ -46,24 +38,3 @@ export const replayDerivedData = action(
       [resolved.materialize]({ id });
   }
 );
-
-export const rebindLayerData = action(
-  {
-    op: "rebindLayerData",
-    description: "Rebind one facet-cell layer to its replayed dataset."
-  },
-  function (args = {}) {
-    validateKeys(args, REBIND_OPTIONS, "rebindLayerData");
-    const id = validateUserId(args.id, "Facet layer id");
-    const data = validateUserId(args.data, "Facet layer dataset id");
-    requireLayer(this, id);
-    if (!hasDataset(this, data)) {
-      throw new Error(`Facet layer dataset "${data}" does not exist.`);
-    }
-    return this.editSemantic({
-      property: `layer[${id}].data`,
-      value: data
-    });
-  }
-);
-