ggaction 0.0.4 → 0.0.6

package/src/actions/data/index.js

@@ -1,5 +1,9 @@
 import { createData } from "./create.js";
-import { createDerivedData, releaseDerivedData } from "./derived.js";
+import {
+  createDerivedData,
+  rebindLayerData,
+  releaseDerivedData
+} from "./derived.js";
 import {
   filterData,
   filterMarks,
@@ -7,24 +11,52 @@ import {
   materializeMarkFilteredData
 } from "./filter.js";
 import { createRegressionData, materializeRegressionData } from "./regression.js";
-import { createDensityData, materializeDensityData } from "./density.js";
+import {
+  createCategoricalDensityData,
+  createDensityData,
+  materializeDensityData
+} from "./density.js";
+import {
+  createGradientProfileData,
+  materializeGradientProfileData
+} from "./gradientProfile.js";
 import { createIntervalData, materializeIntervalData } from "./interval.js";
+import { createHorizonData, materializeHorizonData } from "./horizon.js";
+import { createWindowData, materializeWindowData } from "./window.js";
+import {
+  createBin2DData,
+  editBin2DData,
+  materializeBin2DData
+} from "./bin2d.js";
 import { createBoxSummaryData, createBoxOutlierData, materializeBoxSummaryData, materializeBoxOutlierData } from "./box.js";
 
 export function registerDataActions(ProgramClass) {
   ProgramClass.prototype.createData = createData;
   ProgramClass.prototype.createDerivedData = createDerivedData;
   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.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.createHorizonData = createHorizonData;
+  ProgramClass.prototype.materializeHorizonData = materializeHorizonData;
+  ProgramClass.prototype.createWindowData = createWindowData;
+  ProgramClass.prototype.materializeWindowData = materializeWindowData;
+  ProgramClass.prototype.createBin2DData = createBin2DData;
+  ProgramClass.prototype.editBin2DData = editBin2DData;
+  ProgramClass.prototype.materializeBin2DData = materializeBin2DData;
   ProgramClass.prototype.createBoxSummaryData = createBoxSummaryData;
   ProgramClass.prototype.createBoxOutlierData = createBoxOutlierData;
   ProgramClass.prototype.materializeBoxSummaryData = materializeBoxSummaryData;

package/src/actions/data/intervalEdit.js

@@ -0,0 +1,76 @@
+import { isPlainObject } from "../../core/immutable.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";
+
+const STATISTICS_OPTIONS = Object.freeze(["center", "extent", "level"]);
+
+export function planIntervalEdit(program, {
+  owner,
+  data,
+  consumers,
+  statistics,
+  operation
+}) {
+  if (!isPlainObject(statistics)) {
+    throw new TypeError(`${operation} statistics must be a plain object.`);
+  }
+  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.`
+    );
+  }
+  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 center = Object.hasOwn(statistics, "center")
+    ? statistics.center
+    : transform.center;
+  const extent = Object.hasOwn(statistics, "extent")
+    ? statistics.extent
+    : transform.extent;
+  const raw = { center, extent };
+  if (Object.hasOwn(statistics, "level")) {
+    raw.level = statistics.level;
+  } else if (extent === "ci" && transform.extent === "ci") {
+    raw.level = transform.level;
+  }
+  const parameters = normalizeIntervalParameters(raw);
+  const current = {
+    center: transform.center,
+    extent: transform.extent,
+    ...(transform.level === undefined ? {} : { level: transform.level })
+  };
+  const changed = JSON.stringify(parameters) !== JSON.stringify(current);
+  if (!changed) return { changed, parameters };
+
+  const revision = planDerivedDataRevision(program, {
+    owner,
+    role: "IntervalData",
+    previous: previous.id,
+    consumers
+  });
+  return {
+    changed,
+    parameters,
+    revision,
+    dataArgs: {
+      id: revision.id,
+      source: previous.source,
+      field: transform.field,
+      groupBy: transform.groupBy,
+      ...parameters,
+      as: transform.as
+    }
+  };
+}

package/src/actions/data/window.js

@@ -0,0 +1,50 @@
+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";
+
+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 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 });
+  }
+);

package/src/actions/distributions/revision.js

@@ -0,0 +1,326 @@
+import { DEFAULT_TICK_COUNT } from "../guides/tickValues.js";
+import { findLayer } from "../../selectors/layers.js";
+import { findSemanticScale } from "../../selectors/scales.js";
+import { resolvePositionScaleDefinition } from "../scales/definitions.js";
+
+const POSITION_CHANNELS = Object.freeze(["x", "y", "x2", "y2"]);
+
+export function resolveDistributionScalePlan(program, {
+  channel,
+  fieldType,
+  requested,
+  fallback,
+  defaults
+}) {
+  const options = requested === undefined
+    ? { id: fallback }
+    : typeof requested === "string"
+      ? { id: requested }
+      : { ...requested, id: requested.id ?? fallback };
+  const existing = findSemanticScale(program, options.id);
+  return {
+    id: options.id,
+    definition: resolvePositionScaleDefinition(
+      program,
+      channel,
+      fieldType,
+      options,
+      defaults
+    ),
+    create: existing === undefined,
+    edit: existing !== undefined && typeof requested === "object" &&
+      Object.keys(requested).some(key => key !== "id")
+      ? options
+      : undefined
+  };
+}
+
+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;
+}
+
+export function setCartesianRange(
+  program,
+  id,
+  channel,
+  lower,
+  upper,
+  scale,
+  title
+) {
+  return 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
+    });
+}
+
+function axisMethods(channel) {
+  const prefix = channel === "x" ? "X" : "Y";
+  return {
+    ticks: `edit${prefix}AxisTicks`,
+    labels: `edit${prefix}AxisLabels`,
+    title: `edit${prefix}AxisTitle`
+  };
+}
+
+function isDiscretePosition(scale) {
+  return ["ordinal", "band", "point"].includes(scale?.type);
+}
+
+function normalizeTickConfig(config, scale) {
+  if (config === undefined) return undefined;
+  if (isDiscretePosition(scale)) {
+    if (config.mode === "count" || config.inferredValues === true) {
+      const next = {
+        ...config,
+        mode: "values",
+        values: scale.domain,
+        inferredValues: true
+      };
+      delete next.count;
+      return next;
+    }
+    return config;
+  }
+  if (config.mode === "values" && config.inferredValues === true) {
+    const next = {
+      ...config,
+      mode: "count",
+      count: DEFAULT_TICK_COUNT,
+      inferredValues: true
+    };
+    delete next.values;
+    return next;
+  }
+  return config;
+}
+
+function outsideConsumer(program, owned, channel, scale) {
+  return program.semanticSpec.layers.some(layer =>
+    !owned.has(layer.id) && layer.encoding?.[channel]?.scale === scale
+  );
+}
+
+export function assertDistributionScaleHandoff(program, {
+  owned,
+  oldXScale,
+  oldYScale,
+  newXScale,
+  newYScale
+}) {
+  const ids = new Set(owned);
+  for (const [channel, previous, next] of [
+    ["x", oldXScale, newXScale],
+    ["y", oldYScale, newYScale]
+  ]) {
+    if (
+      previous !== next &&
+      outsideConsumer(program, ids, channel, previous)
+    ) {
+      throw new Error(
+        `Cannot hand off ${channel} scale "${previous}" while unrelated consumers remain.`
+      );
+    }
+  }
+}
+
+export function clearCartesianPositions(program, id) {
+  const layer = findLayer(program, id);
+  if (layer === undefined) return program;
+  let next = program;
+  for (const channel of POSITION_CHANNELS) {
+    if (layer.encoding?.[channel] === undefined) continue;
+    next = next.editSemantic({
+      property: `layer[${id}].encoding.${channel}`,
+      remove: true
+    });
+  }
+  return next;
+}
+
+function rebindAxis(program, channel, {
+  previousScale,
+  nextScale,
+  previousTitle,
+  nextTitle
+}) {
+  const semantic = program.semanticSpec.guides.axis?.[channel];
+  if (semantic?.scale !== previousScale) return program;
+  let next = program.editSemantic({
+    property: `guide.axis.${channel}.scale`,
+    value: nextScale
+  });
+  if (semantic.title === previousTitle) {
+    next = next.editSemantic({
+      property: `guide.axis.${channel}.title`,
+      value: nextTitle
+    });
+  }
+  const scale = next.resolvedScales[nextScale];
+  const ticks = normalizeTickConfig(
+    next.guideConfigs.axis?.[channel]?.ticks,
+    scale
+  );
+  if (ticks !== undefined) {
+    next = next._withGuideConfig(channel, "ticks", {
+      ...ticks,
+      scale: nextScale
+    });
+  }
+  const labels = next.guideConfigs.axis?.[channel]?.labels;
+  if (labels !== undefined) {
+    const tickConfig = next.guideConfigs.axis[channel].ticks;
+    next = next._withGuideConfig(channel, "labels", {
+      ...labels,
+      scale: nextScale,
+      mode: tickConfig.mode,
+      inferredValues: tickConfig.inferredValues,
+      ...(tickConfig.mode === "values"
+        ? { values: tickConfig.values }
+        : { count: tickConfig.count })
+    });
+    if (tickConfig.mode === "values") {
+      const config = next.guideConfigs.axis[channel].labels;
+      if (Object.hasOwn(config, "count")) {
+        const { count: _count, ...withoutCount } = config;
+        next = next._withGuideConfig(channel, "labels", withoutCount);
+      }
+    } else {
+      const config = next.guideConfigs.axis[channel].labels;
+      if (Object.hasOwn(config, "values")) {
+        const { values: _values, ...withoutValues } = config;
+        next = next._withGuideConfig(channel, "labels", withoutValues);
+      }
+    }
+  }
+  const title = next.guideConfigs.axis?.[channel]?.title;
+  if (title !== undefined) {
+    next = next._withGuideConfig(channel, "title", {
+      ...title,
+      scale: nextScale
+    });
+  }
+  const methods = axisMethods(channel);
+  if (ticks !== undefined) next = next[methods.ticks]();
+  if (labels !== undefined) next = next[methods.labels]();
+  if (title !== undefined) next = next[methods.title]();
+  return next;
+}
+
+function gridDirection(channel) {
+  return channel === "x" ? "vertical" : "horizontal";
+}
+
+function rebindGrid(program, {
+  previousMeasureChannel,
+  nextMeasureChannel,
+  previousScale,
+  nextScale
+}) {
+  const previousDirection = gridDirection(previousMeasureChannel);
+  const nextDirection = gridDirection(nextMeasureChannel);
+  const stored = program.guideConfigs.grid?.[previousDirection];
+  const semantic = program.semanticSpec.guides.grid?.[previousDirection];
+  if (stored === undefined || semantic?.scale !== previousScale) return program;
+  if (previousDirection === nextDirection) {
+    return program
+      .editSemantic({
+        property: `guide.grid.${previousDirection}.scale`,
+        value: nextScale
+      })
+      ._withGridConfig(previousDirection, {
+        ...stored,
+        scale: nextScale
+      })[`rematerialize${previousDirection === "horizontal" ? "Horizontal" : "Vertical"}Grid`]();
+  }
+  if (program.semanticSpec.guides.grid?.[nextDirection] !== undefined) {
+    throw new Error(
+      `Cannot hand off the ${previousDirection} grid because a ${nextDirection} grid already exists.`
+    );
+  }
+  const options = {
+    scale: nextScale,
+    coordinate: stored.coordinate,
+    color: stored.color,
+    lineWidth: stored.lineWidth,
+    strokeDash: stored.strokeDash,
+    ...(stored.inferredValues === true
+      ? {}
+      : stored.mode === "values"
+        ? { values: stored.values }
+        : { count: stored.count })
+  };
+  return program
+    .removeGrid({ [previousDirection]: true })
+    [`create${nextDirection === "horizontal" ? "Horizontal" : "Vertical"}Grid`](options);
+}
+
+export function rebindDistributionGuides(program, {
+  oldXScale,
+  oldYScale,
+  newXScale,
+  newYScale,
+  oldXTitle,
+  oldYTitle,
+  newXTitle,
+  newYTitle,
+  oldMeasureChannel,
+  newMeasureChannel
+}) {
+  let next = rebindAxis(program, "x", {
+    previousScale: oldXScale,
+    nextScale: newXScale,
+    previousTitle: oldXTitle,
+    nextTitle: newXTitle
+  });
+  next = rebindAxis(next, "y", {
+    previousScale: oldYScale,
+    nextScale: newYScale,
+    previousTitle: oldYTitle,
+    nextTitle: newYTitle
+  });
+  return rebindGrid(next, {
+    previousMeasureChannel: oldMeasureChannel,
+    nextMeasureChannel: newMeasureChannel,
+    previousScale: oldMeasureChannel === "x" ? oldXScale : oldYScale,
+    nextScale: newMeasureChannel === "x" ? newXScale : newYScale
+  });
+}

package/src/actions/encodings/appearance.js

@@ -9,7 +9,10 @@ import {
   resolveAppearanceScaleDefinition,
   resolveOpacityScaleDefinition
 } from "../scales/definitions.js";
-import { findLayer } from "../../selectors/layers.js";
+import {
+  findLayer,
+  resolveEligibleLayer
+} from "../../selectors/layers.js";
 import { applyMaterializationPlan } from "../../materialization/dependencies.js";
 import { planEncodingRematerialization } from "../../materialization/encodings.js";
 import {
@@ -20,6 +23,7 @@ import {
 } from "./shared.js";
 
 const RADIUS_OPTIONS = Object.freeze(["value", "target"]);
+const REMOVE_RADIUS_OPTIONS = Object.freeze(["target"]);
 const OPACITY_OPTIONS = Object.freeze([
   "value", "field", "target", "fieldType", "scale"
 ]);
@@ -129,6 +133,35 @@ const encodePointRadius = action(
   }
 );
 
+const removePointRadius = action(
+  {
+    op: "removePointRadius",
+    description: "Remove a constant point radius and restore the theme default."
+  },
+  function (args = {}) {
+    validateOptions(args, REMOVE_RADIUS_OPTIONS, "removePointRadius");
+    const requested = args.target === undefined
+      ? undefined
+      : args.target;
+    const layer = resolveEligibleLayer(this, {
+      target: requested,
+      predicate: candidate =>
+        candidate.mark?.type === "point" &&
+        this.markConfigs[candidate.id]?.radius !== undefined,
+      label: "point mark with an explicit radius"
+    });
+    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 });
+    return baseline.rematerializePointMark({ id: layer.id });
+  }
+);
+
 const encodeSize = action(
   {
     op: "encodeSize",
@@ -247,6 +280,7 @@ const encodeOpacity = action(
 export function registerAppearanceEncodingAction(ProgramClass) {
   ProgramClass.prototype.encodeRadius = encodeRadius;
   ProgramClass.prototype.encodePointRadius = encodePointRadius;
+  ProgramClass.prototype.removePointRadius = removePointRadius;
   ProgramClass.prototype.encodeSize = encodeSize;
   ProgramClass.prototype.encodeShape = encodeShape;
   ProgramClass.prototype.encodeOpacity = encodeOpacity;

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

@@ -19,6 +19,8 @@ import { applyMaterializationPlan } from "../../../materialization/dependencies.
 import {
   planEncodingRematerialization
 } from "../../../materialization/encodings.js";
+import { findUpstreamTransform } from
+  "../../../materialization/dataProvenance.js";
 import { encodeContinuousColor } from "./continuous.js";
 import {
   applyColorLayoutCompanion,
@@ -56,10 +58,24 @@ const encodeColor = action(
       "color mark"
     );
     assertNoConstantColor(this, layer);
+    const densityTransform = dataset.transform?.length === 1 &&
+      dataset.transform[0].type === "density"
+      ? dataset.transform[0]
+      : undefined;
+    const densitySeriesFields = densityTransform?.placement?.type === "category"
+      ? [densityTransform.groupBy, densityTransform.placement.split?.field]
+          .filter(Boolean)
+      : [];
+    const horizonTransform = findUpstreamTransform(this, dataset, "horizon");
+    const horizonColor = horizonTransform !== undefined &&
+      horizonTransform.as?.color === args.field &&
+      layer.encoding?.group?.field === horizonTransform.as?.group;
     if (
       layer.mark.type === "area" &&
       (layer.encoding?.group?.field === undefined ||
-        layer.encoding.group.field !== args.field)
+        layer.encoding.group.field !== args.field) &&
+      !densitySeriesFields.includes(args.field) &&
+      !horizonColor
     ) {
       throw new Error(
         "Area color encoding must match an existing group encoding."

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

@@ -18,6 +18,14 @@ export function applyColorLayoutCompanion(
   ) {
     return program;
   }
+  if (
+    layer.mark.type === "area" &&
+    [layer.encoding?.x, layer.encoding?.y].some(
+      encoding => ["nominal", "ordinal"].includes(encoding?.fieldType)
+    )
+  ) {
+    return program;
+  }
   if (isRangedArea(layer)) return program;
   const channels = layer.mark.type === "bar"
     ? resolveBarChannels(layer)