ggaction 0.0.9 → 0.0.11

package/src/actions/data/intervalEdit.js

@@ -1,12 +1,67 @@
 import { isPlainObject } from "../../core/immutable.js";
+import { validateUserId } from "../../core/identifiers.js";
 import { validateKeys } from "../../core/validation.js";
 import { normalizeIntervalParameters } from "../../grammar/interval.js";
 import { planDerivedDataRevision } from
   "../../materialization/dataProvenance.js";
 import { findDataset } from "../../selectors/datasets.js";
+import { resolveEligibleLayer } from "../../selectors/layers.js";
 
 const STATISTICS_OPTIONS = Object.freeze(["center", "extent", "level"]);
 
+export function ownOptions(value, options) {
+  return Object.fromEntries(
+    options.filter(key => Object.hasOwn(value, key)).map(key => [key, value[key]])
+  );
+}
+
+export function resolveIntervalOwner(program, requested, {
+  idLabel,
+  label,
+  mark,
+  config
+}) {
+  const target = requested === undefined
+    ? undefined
+    : validateUserId(requested, idLabel);
+  return resolveEligibleLayer(program, {
+    target,
+    label,
+    predicate: layer =>
+      layer.mark?.type === mark &&
+      program.markConfigs[layer.id]?.[config] !== undefined
+  });
+}
+
+export function createResolvedIntervalData(program, resolved) {
+  if (resolved.interval.mode !== "statistical") return program;
+  return program.createIntervalData({
+    id: resolved.dataId,
+    source: resolved.source,
+    field: resolved.interval.field,
+    groupBy: resolved.groupBy,
+    center: resolved.interval.center,
+    extent: resolved.interval.extent,
+    level: resolved.interval.level,
+    as: resolved.fields
+  });
+}
+
+export function applyIntervalRevision(program, interval) {
+  if (!interval.changed) return program;
+  let next = program.createIntervalData(interval.dataArgs);
+  for (const rebind of interval.revision.rebinds) {
+    next = next.rebindLayerData(rebind);
+  }
+  return next;
+}
+
+export function releaseIntervalRevision(program, interval) {
+  return interval.changed
+    ? program.releaseDerivedData(interval.revision.release)
+    : program;
+}
+
 export function planIntervalEdit(program, {
   owner,
   data,

package/src/actions/data/regression.js

@@ -5,23 +5,18 @@ import {
   deriveRegression,
   normalizeRegressionParameters
 } from "../../grammar/regression/index.js";
-import { MATERIALIZE_OPTIONS, requireDerivedDataset } from "./shared.js";
+import { derivedMaterializer } from "./shared.js";
 
 const OPTIONS = Object.freeze([
   "id", "source", "x", "y", "groupBy", "method", "degree", "span",
   "confidence", "interval"
 ]);
 
-export const materializeRegressionData = action(
-  { op: "materializeRegressionData", description: "Materialize one regression derived dataset." },
-  function (args = {}) {
-    validateKeys(args, MATERIALIZE_OPTIONS, "materializeRegressionData");
-    const { id, source, transform } = requireDerivedDataset(
-      this,
-      args.id,
-      "regression"
-    );
-    const result = deriveRegression(source.values, {
+export const materializeRegressionData = derivedMaterializer(
+  "materializeRegressionData",
+  "Materialize one regression derived dataset.",
+  "regression",
+  (values, transform) => deriveRegression(values, {
       x: transform.x,
       y: transform.y,
       groupBy: transform.groupBy,
@@ -30,12 +25,7 @@ export const materializeRegressionData = action(
       span: transform.span,
       confidence: transform.confidence,
       interval: transform.interval
-    });
-    return this.editSemantic({
-      property: `dataset[${id}].values`,
-      value: result.values
-    });
-  }
+    })
 );
 
 export const createRegressionData = action(

package/src/actions/data/shared.js

@@ -1,4 +1,6 @@
+import { action } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
+import { validateKeys } from "../../core/validation.js";
 import { findDataset } from "../../selectors/datasets.js";
 
 export const MATERIALIZE_OPTIONS = Object.freeze(["id"]);
@@ -23,3 +25,48 @@ export function requireDerivedDataset(program, id, type) {
   }
   return { id: validatedId, dataset, source, transform: dataset.transform[0] };
 }
+
+export function derivedMaterializer(op, description, type, derive, resolve) {
+  return action({ op, description }, function (args = {}) {
+    validateKeys(args, MATERIALIZE_OPTIONS, op);
+    const { id, source, transform } = requireDerivedDataset(
+      this,
+      args.id,
+      type
+    );
+    const result = derive(source.values, transform);
+    const program = resolve === undefined
+      ? this
+      : this.editSemantic({
+          property: `dataset[${id}].transform`,
+          value: resolve(result, transform)
+        });
+    return program.editSemantic({
+      property: `dataset[${id}].values`,
+      value: Array.isArray(result) ? result : result.values
+    });
+  });
+}
+
+export function derivedCreator(
+  op,
+  description,
+  options,
+  idLabel,
+  sourceLabel,
+  transform,
+  materialize,
+  requireSource = false
+) {
+  return action({ op, description }, function (args = {}) {
+    validateKeys(args, options, op);
+    const id = validateUserId(args.id, idLabel);
+    const source = validateUserId(
+      requireSource ? args.source : args.source ?? this.context.currentData,
+      sourceLabel
+    );
+    return this
+      .createDerivedData({ id, source, transform: [transform(args, id)] })
+      [materialize]({ id });
+  });
+}

package/src/actions/data/timeUnit.js

@@ -1,48 +1,24 @@
-import { action } from "../../core/action.js";
-import { validateUserId } from "../../core/identifiers.js";
-import { validateKeys } from "../../core/validation.js";
 import {
   deriveTimeUnitRows,
   normalizeTimeUnitTransform
 } from "../../grammar/timeUnit.js";
-import { MATERIALIZE_OPTIONS, requireDerivedDataset } from "./shared.js";
+import { derivedCreator, derivedMaterializer } from "./shared.js";
 
 const OPTIONS = Object.freeze(["id", "source", "field", "unit", "as"]);
 
-export const materializeTimeUnitData = action(
-  {
-    op: "materializeTimeUnitData",
-    description: "Materialize one immutable UTC time-unit dataset."
-  },
-  function (args = {}) {
-    validateKeys(args, MATERIALIZE_OPTIONS, "materializeTimeUnitData");
-    const { id, source, transform } = requireDerivedDataset(
-      this,
-      args.id,
-      "timeUnit"
-    );
-    return this.editSemantic({
-      property: `dataset[${id}].values`,
-      value: deriveTimeUnitRows(source.values, transform)
-    });
-  }
+export const materializeTimeUnitData = derivedMaterializer(
+  "materializeTimeUnitData",
+  "Materialize one immutable UTC time-unit dataset.",
+  "timeUnit",
+  deriveTimeUnitRows
 );
 
-export const createTimeUnitData = action(
-  {
-    op: "createTimeUnitData",
-    description: "Create immutable UTC calendar bucket values."
-  },
-  function (args = {}) {
-    validateKeys(args, OPTIONS, "createTimeUnitData");
-    const id = validateUserId(args.id, "Time-unit dataset id");
-    const source = validateUserId(
-      args.source ?? this.context.currentData,
-      "Source dataset id"
-    );
-    const transform = normalizeTimeUnitTransform(args);
-    return this
-      .createDerivedData({ id, source, transform: [transform] })
-      .materializeTimeUnitData({ id });
-  }
+export const createTimeUnitData = derivedCreator(
+  "createTimeUnitData",
+  "Create immutable UTC calendar bucket values.",
+  OPTIONS,
+  "Time-unit dataset id",
+  "Source dataset id",
+  normalizeTimeUnitTransform,
+  "materializeTimeUnitData"
 );

package/src/actions/data/window.js

@@ -1,50 +1,26 @@
-import { action } from "../../core/action.js";
-import { validateUserId } from "../../core/identifiers.js";
-import { validateKeys } from "../../core/validation.js";
 import {
   deriveWindowRows,
   normalizeWindowTransform
 } from "../../grammar/window.js";
-import { MATERIALIZE_OPTIONS, requireDerivedDataset } from "./shared.js";
+import { derivedCreator, derivedMaterializer } from "./shared.js";
 
 const OPTIONS = Object.freeze([
   "id", "source", "partitionBy", "sortBy", "operations"
 ]);
 
-export const materializeWindowData = action(
-  {
-    op: "materializeWindowData",
-    description: "Materialize one immutable window-derived dataset."
-  },
-  function (args = {}) {
-    validateKeys(args, MATERIALIZE_OPTIONS, "materializeWindowData");
-    const { id, source, transform } = requireDerivedDataset(
-      this,
-      args.id,
-      "window"
-    );
-    return this.editSemantic({
-      property: `dataset[${id}].values`,
-      value: deriveWindowRows(source.values, transform)
-    });
-  }
+export const materializeWindowData = derivedMaterializer(
+  "materializeWindowData",
+  "Materialize one immutable window-derived dataset.",
+  "window",
+  deriveWindowRows
 );
 
-export const createWindowData = action(
-  {
-    op: "createWindowData",
-    description: "Create immutable partitioned window values."
-  },
-  function (args = {}) {
-    validateKeys(args, OPTIONS, "createWindowData");
-    const id = validateUserId(args.id, "Window dataset id");
-    const source = validateUserId(
-      args.source ?? this.context.currentData,
-      "Source dataset id"
-    );
-    const transform = normalizeWindowTransform(args);
-    return this
-      .createDerivedData({ id, source, transform: [transform] })
-      .materializeWindowData({ id });
-  }
+export const createWindowData = derivedCreator(
+  "createWindowData",
+  "Create immutable partitioned window values.",
+  OPTIONS,
+  "Window dataset id",
+  "Source dataset id",
+  normalizeWindowTransform,
+  "materializeWindowData"
 );

package/src/actions/distributions/revision.js

@@ -5,6 +5,28 @@ import { resolvePositionScaleDefinition } from "../scales/definitions.js";
 
 const POSITION_CHANNELS = Object.freeze(["x", "y", "x2", "y2"]);
 
+export function currentDistributionPositions(owner, current) {
+  const vertical = current.orientation === "vertical";
+  const categoryEncoding = owner.encoding[vertical ? "x" : "y"];
+  const measureEncoding = owner.encoding[vertical ? "y" : "x"];
+  const category = {
+    field: current.category,
+    fieldType: current.categoryType ?? categoryEncoding.fieldType,
+    scale: categoryEncoding.scale
+  };
+  const measure = {
+    field: current.measure,
+    fieldType: "quantitative",
+    scale: measureEncoding.scale
+  };
+  return {
+    x: vertical ? category : measure,
+    y: vertical ? measure : category,
+    categoryScale: category.scale,
+    measureScale: measure.scale
+  };
+}
+
 export function resolveDistributionScalePlan(program, {
   channel,
   fieldType,
@@ -35,32 +57,81 @@ export function resolveDistributionScalePlan(program, {
   };
 }
 
+export function resolveDistributionRoles(program, owner, current, args, {
+  operation,
+  resolvePosition,
+  normalize,
+  quantitativeDefaults,
+  defaultFieldType = false
+}) {
+  const previous = currentDistributionPositions(owner, current);
+  const position = channel => {
+    let value = Object.hasOwn(args, channel)
+      ? resolvePosition(args[channel], channel, operation)
+      : previous[channel];
+    if (typeof value?.field !== "string" || value.field.length === 0) {
+      throw new TypeError(`${operation} ${channel} field must be a non-empty string.`);
+    }
+    if (defaultFieldType) {
+      value = { fieldType: value.fieldType ?? "quantitative", ...value };
+    }
+    return value;
+  };
+  const positions = normalize(position("x"), position("y"));
+  if (positions.orientation === undefined) {
+    throw new Error(
+      `${operation} requires one categorical axis and one quantitative axis.`
+    );
+  }
+  const vertical = positions.orientation === "vertical";
+  const plan = channel => resolveDistributionScalePlan(program, {
+    channel,
+    fieldType: positions[channel].fieldType,
+    requested: positions[channel].scale,
+    fallback: previous[vertical === (channel === "x")
+      ? "categoryScale"
+      : "measureScale"],
+    defaults: ["ordinal", "nominal"].includes(positions[channel].fieldType)
+      ? { discreteType: "band" }
+      : quantitativeDefaults
+  });
+  const xScale = plan("x");
+  const yScale = plan("y");
+  return {
+    orientation: positions.orientation,
+    x: { ...positions.x, scale: xScale.id },
+    y: { ...positions.y, scale: yScale.id },
+    xScale,
+    yScale,
+    category: vertical ? positions.x.field : positions.y.field,
+    categoryType: vertical ? positions.x.fieldType : positions.y.fieldType,
+    measure: vertical ? positions.y.field : positions.x.field,
+    previous
+  };
+}
+
+function setCartesianProperties(program, id, channel, properties) {
+  for (const [property, value] of Object.entries(properties)) {
+    program = program.editSemantic({
+      property: `layer[${id}].encoding.${channel}.${property}`,
+      value
+    });
+  }
+  return program;
+}
+
 export function setCartesianPosition(program, id, channel, {
   field,
   fieldType,
   scale,
   title
 }) {
-  let next = program
-    .editSemantic({
-      property: `layer[${id}].encoding.${channel}.field`,
-      value: field
-    })
-    .editSemantic({
-      property: `layer[${id}].encoding.${channel}.fieldType`,
-      value: fieldType
-    })
-    .editSemantic({
-      property: `layer[${id}].encoding.${channel}.scale`,
-      value: scale
-    });
-  if (title !== undefined) {
-    next = next.editSemantic({
-      property: `layer[${id}].encoding.${channel}.title`,
-      value: title
-    });
-  }
-  return next;
+  return setCartesianProperties(program, id, channel, {
+    field,
+    fieldType,
+    scale,
+    ...(title === undefined ? {} : { title })
+  });
 }
 
 export function setCartesianRange(
@@ -72,24 +143,73 @@ export function setCartesianRange(
   scale,
   title
 ) {
-  return setCartesianPosition(program, id, channel, {
+  program = setCartesianPosition(program, id, channel, {
     field: lower,
     fieldType: "quantitative",
     scale,
     title
-  })
-    .editSemantic({
-      property: `layer[${id}].encoding.${channel}2.field`,
-      value: upper
-    })
-    .editSemantic({
-      property: `layer[${id}].encoding.${channel}2.fieldType`,
-      value: "quantitative"
-    })
-    .editSemantic({
-      property: `layer[${id}].encoding.${channel}2.scale`,
-      value: scale
-    });
+  });
+  return setCartesianProperties(program, id, `${channel}2`, {
+    field: upper,
+    fieldType: "quantitative",
+    scale
+  });
+}
+
+export function updateDistributionPositions(
+  program,
+  owner,
+  current,
+  candidate,
+  { owned, lower, upper, title, update }
+) {
+  assertDistributionScaleHandoff(program, {
+    owned,
+    oldXScale: candidate.previous.x.scale,
+    oldYScale: candidate.previous.y.scale,
+    newXScale: candidate.xScale.id,
+    newYScale: candidate.yScale.id
+  });
+  let next = program;
+  for (const id of owned) next = clearCartesianPositions(next, id);
+  for (const scale of [candidate.xScale, candidate.yScale]) {
+    if (scale.create) next = next.createScale(scale.definition);
+  }
+  const vertical = candidate.orientation === "vertical";
+  const axes = {
+    category: vertical ? candidate.x : candidate.y,
+    measure: vertical ? candidate.y : candidate.x,
+    categoryChannel: vertical ? "x" : "y",
+    measureChannel: vertical ? "y" : "x"
+  };
+  next = setCartesianPosition(next, owner.id, axes.categoryChannel, {
+    field: candidate.category,
+    fieldType: candidate.categoryType,
+    scale: axes.category.scale
+  });
+  next = setCartesianRange(
+    next, owner.id, axes.measureChannel, lower, upper, axes.measure.scale, title
+  );
+  next = update(next, axes);
+  for (const id of new Set([candidate.xScale.id, candidate.yScale.id])) {
+    next = next.rematerializeScale({ id, marks: false, guides: false });
+  }
+  next = rebindDistributionGuides(next, {
+    oldXScale: candidate.previous.x.scale,
+    oldYScale: candidate.previous.y.scale,
+    newXScale: candidate.xScale.id,
+    newYScale: candidate.yScale.id,
+    oldXTitle: candidate.previous.x.field,
+    oldYTitle: candidate.previous.y.field,
+    newXTitle: candidate.x.field,
+    newYTitle: candidate.y.field,
+    oldMeasureChannel: current.orientation === "vertical" ? "y" : "x",
+    newMeasureChannel: axes.measureChannel
+  });
+  for (const scale of [candidate.xScale, candidate.yScale]) {
+    if (scale.edit !== undefined) next = next.editScale(scale.edit);
+  }
+  return next;
 }
 
 function axisMethods(channel) {

package/src/actions/encodings/angle.js

@@ -1,6 +1,10 @@
 import { action } from "../../core/action.js";
 import { readQuantitativeField } from "../../grammar/scales/index.js";
-import { resolveTarget, validateOptions } from "./shared.js";
+import {
+  resolveTarget,
+  setEncodingProperties,
+  validateOptions
+} from "./shared.js";
 
 const OPTIONS = Object.freeze(["target", "value", "field", "fieldType"]);
 
@@ -58,15 +62,10 @@ export const encodeAngle = action(
         value: args.value
       });
     } else {
-      next = next
-        .editSemantic({
-          property: `layer[${target}].encoding.angle.field`,
-          value: args.field
-        })
-        .editSemantic({
-          property: `layer[${target}].encoding.angle.fieldType`,
-          value: "quantitative"
-        });
+      next = setEncodingProperties(next, target, "angle", {
+        field: args.field,
+        fieldType: "quantitative"
+      });
     }
     return rematerialize(next, layer, target);
   }

package/src/actions/encodings/appearance.js

@@ -13,12 +13,13 @@ import {
   findLayer,
   resolveEligibleLayer
 } from "../../selectors/layers.js";
-import { applyMaterializationPlan } from "../../materialization/dependencies.js";
-import { planEncodingRematerialization } from "../../materialization/encodings.js";
 import {
   applyEncodingScale,
+  clearMarkGraphic,
+  rematerializeEncoding,
   resolveReassignmentScaleOptions,
   resolveTarget,
+  setEncodingProperties,
   validateOptions
 } from "./shared.js";
 
@@ -64,30 +65,15 @@ function encodeAppearanceField(program, channel, args, operation) {
     readQuantitativeField(dataset.values, args.field);
   }
 
-  let next = program
-    .editSemantic({
-      property: `layer[${target}].encoding.${channel}.field`,
-      value: args.field
-    })
-    .editSemantic({
-      property: `layer[${target}].encoding.${channel}.fieldType`,
-      value: fieldType
-    })
-    .editSemantic({
-      property: `layer[${target}].encoding.${channel}.scale`,
-      value: scale.id
-    });
+  let next = setEncodingProperties(program, target, channel, {
+    field: args.field,
+    fieldType,
+    scale: scale.id
+  });
   next = applyEncodingScale(next, scale, requestedScale, {
     reassignment: previous?.scale === scale.id
   });
-  return applyMaterializationPlan(
-    next,
-    planEncodingRematerialization(next, {
-      target,
-      channel,
-      scale: scale.id
-    })
-  );
+  return rematerializeEncoding(next, target, channel, scale.id);
 }
 
 const encodeRadius = action(
@@ -152,12 +138,7 @@ const removePointRadius = action(
     });
     const next = this
       ._withoutMaterializationConfig(["marks", layer.id, "radius"]);
-    const graphic = next.graphicSpec.objects[layer.id];
-    const baseline = graphic === undefined
-      ? next
-      : graphic.type === "collection"
-        ? next.editGraphics({ target: layer.id, property: "items", value: [] })
-        : next.editGraphics({ target: layer.id, property: "length", value: 0 });
+    const baseline = clearMarkGraphic(next, layer.id);
     return baseline.rematerializePointMark({ id: layer.id });
   }
 );
@@ -249,31 +230,16 @@ const encodeOpacity = action(
     }
     const { opacity, ...config } = this.markConfigs[target] ?? {};
     void opacity;
-    let next = this
-      ._withoutMaterializationConfig(["marks", target, "opacity"])
-      .editSemantic({
-        property: `layer[${target}].encoding.opacity.field`,
-        value: args.field
-      })
-      .editSemantic({
-        property: `layer[${target}].encoding.opacity.fieldType`,
-        value: fieldType
-      })
-      .editSemantic({
-        property: `layer[${target}].encoding.opacity.scale`,
-        value: scale.id
-      })
+    let next = setEncodingProperties(
+      this._withoutMaterializationConfig(["marks", target, "opacity"]),
+      target,
+      "opacity",
+      { field: args.field, fieldType, scale: scale.id }
+    );
     next = applyEncodingScale(next, scale, requestedScale, {
       reassignment: previous?.scale === scale.id
     });
-    return applyMaterializationPlan(
-      next,
-      planEncodingRematerialization(next, {
-        target,
-        channel: "opacity",
-        scale: scale.id
-      })
-    );
+    return rematerializeEncoding(next, target, "opacity", scale.id);
   }
 );
 

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

@@ -12,7 +12,9 @@ export function resolveDensityScaleOptions(value, defaults, label) {
   if (value !== undefined && !isPlainObject(value)) {
     throw new TypeError(`${label} must be a plain object.`);
   }
-  return { ...defaults, ...(value ?? {}) };
+  const scale = { ...defaults, ...(value ?? {}) };
+  if (value?.type === "log" && value.zero === undefined) delete scale.zero;
+  return scale;
 }
 
 export function resolveDensityCategoryScaleOptions(value, fallbackId) {