ggaction 0.0.12 → 0.0.13

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

@@ -46,20 +46,52 @@ export function resolveDensityTransitionScaleDefinitions(
   layer,
   transform,
   placement,
-  rawPlacement
+  rawPlacement,
+  rawValueScale
 ) {
   const valueScale = valueScaleForTransition(program, layer, transform);
   if (valueScale === undefined) {
     throw new Error(`Density area "${layer.id}" requires its value scale.`);
   }
-  const { id: _valueId, range: _valueRange, ...valueDefinition } = valueScale;
+  if (rawValueScale?.id !== undefined && rawValueScale.id !== valueScale.id) {
+    throw new Error("editDensity value scale cannot change its id.");
+  }
+  const { id: _valueId, range: _valueRange, ...storedValueDefinition } = valueScale;
   void _valueId;
   void _valueRange;
+  const valueDefinition = resolveDensityScaleOptions(
+    rawValueScale,
+    storedValueDefinition,
+    "Density valueScale"
+  );
+  delete valueDefinition.id;
+  delete valueDefinition.range;
   const valueChannel = placement?.channel === "x" ? "y" : "x";
   const companionChannel = valueChannel === "x" ? "y" : "x";
-  const companionDefinition = placement === undefined
-    ? { type: "linear", domain: "auto", range: "auto", nice: true, zero: true }
-    : resolveDensityCategoryScaleOptions(rawPlacement.scale);
+  let companionDefinition;
+  if (placement === undefined) {
+    companionDefinition = {
+      type: "linear", domain: "auto", range: "auto", nice: true, zero: true
+    };
+  } else {
+    const currentCategoryChannel = transform.placement?.channel;
+    const currentCategoryScale = currentCategoryChannel === undefined
+      ? undefined
+      : findSemanticScale(program, layer.encoding[currentCategoryChannel].scale);
+    const { id: _categoryId, range: _categoryRange, ...storedCategoryDefinition } =
+      currentCategoryScale ?? {};
+    void _categoryId;
+    void _categoryRange;
+    companionDefinition = resolveDensityCategoryScaleOptions({
+      domain: "auto",
+      range: "auto",
+      paddingInner: 0,
+      paddingOuter: 0,
+      align: 0.5,
+      ...storedCategoryDefinition,
+      ...(rawPlacement?.scale ?? {})
+    });
+  }
   return {
     [valueChannel]: { ...valueDefinition, range: "auto" },
     [companionChannel]: companionDefinition

package/src/actions/encodings/density.js

@@ -16,6 +16,8 @@ import { validateOptions } from "./shared.js";
 import { normalizeDensityPlacement } from "../../grammar/density.js";
 import { scaleEditPatch } from "../scales/patch.js";
 import { removeOwnedColorLegends } from "../guides/legends/remove.js";
+import { rebindDistributionGuides } from "../distributions/revision.js";
+import { findSemanticScale } from "../../selectors/scales.js";
 import {
   requireDensityField,
   resolveDensityCategoryScaleOptions,
@@ -31,9 +33,50 @@ const OPTIONS = Object.freeze([
 ]);
 const EDIT_OPTIONS = Object.freeze([
   "target", "source", "field", "groupBy", "bandwidth", "extent", "steps",
-  "kernel", "normalization", "placement"
+  "kernel", "normalization", "densityChannel", "valueScale", "placement"
 ]);
 const EDITABLE = Object.freeze(EDIT_OPTIONS.filter(option => option !== "target"));
+const SCALE_PROPERTIES = Object.freeze([
+  "type", "domain", "range", "nice", "zero", "clamp", "reverse",
+  "base", "exponent", "constant", "paddingInner", "paddingOuter",
+  "padding", "align", "interpolate", "midpoint", "unknown"
+]);
+
+function replaceScaleDefinition(program, id, definition) {
+  const current = findSemanticScale(program, id);
+  let next = program;
+  for (const property of SCALE_PROPERTIES) {
+    if (Object.hasOwn(current, property) && !Object.hasOwn(definition, property)) {
+      next = next.editSemantic({ property: `scale[${id}].${property}`, remove: true });
+    }
+  }
+  for (const property of SCALE_PROPERTIES) {
+    if (!Object.hasOwn(definition, property)) continue;
+    next = next.editSemantic({
+      property: `scale[${id}].${property}`,
+      value: definition[property]
+    });
+  }
+  return next;
+}
+
+function replaceDensityPositions(program, layerId, definition) {
+  let next = program;
+  for (const channel of ["x", "y"]) {
+    const value = definition[channel];
+    for (const [property, propertyValue] of Object.entries({
+      field: value.field,
+      fieldType: value.fieldType,
+      scale: typeof value.scale === "string" ? value.scale : value.scale.id
+    })) {
+      next = next.editSemantic({
+        property: `layer[${layerId}].encoding.${channel}.${property}`,
+        value: propertyValue
+      });
+    }
+  }
+  return next;
+}
 
 function findArea(program, requested) {
   const areas = program.semanticSpec.layers.filter(layer => layer.mark?.type === "area");
@@ -80,7 +123,7 @@ const encodeDensity = action(
     validateOptions(args, OPTIONS, "encodeDensity");
     const layer = findArea(this, args.target);
     const field = requireDensityField(args.field, "Density field");
-    const groupBy = args.groupBy === undefined
+    const groupBy = args.groupBy === undefined || args.groupBy === false
       ? undefined
       : requireDensityField(args.groupBy, "Density groupBy");
     const source = validateUserId(
@@ -241,17 +284,34 @@ const editDensity = action(
       : transform.groupBy;
     const changesGroup = groupBy !== transform.groupBy;
     assertGroupingSelectionCompatibility(this, layer, changesGroup);
+    const currentDensityChannel = transform.placement?.channel ?? (
+      layer.encoding.x.field === transform.as[1] ? "x" : "y"
+    );
+    const changesPlacementMode = Object.hasOwn(args, "placement") &&
+      (transform.placement === undefined) !==
+        (args.placement?.type === "baseline");
+    const densityChannel = Object.hasOwn(args, "densityChannel")
+      ? args.densityChannel
+      : changesPlacementMode
+        ? currentDensityChannel === "x" ? "y" : "x"
+        : currentDensityChannel;
+    if (!["x", "y"].includes(densityChannel)) {
+      throw new Error(`Unsupported densityChannel "${densityChannel}".`);
+    }
+    const changesDensityChannel = densityChannel !== currentDensityChannel;
     const categoryField = densityCategoryField(layer, transform, groupBy);
     const requestedPlacement = Object.hasOwn(args, "placement")
       ? normalizeDensityPlacement(args.placement, {
-          densityChannel: transform.placement?.channel ?? "x",
+          densityChannel,
           groupBy,
           categoryField: categoryField ?? groupBy ??
             `${layer.id}DensityCategory`
         })
-      : transform.placement === undefined || !changesGroup
+      : transform.placement === undefined
         ? transform.placement
-        : normalizeDensityPlacement({
+        : !changesGroup && !changesDensityChannel
+          ? transform.placement
+          : normalizeDensityPlacement({
             type: "category",
             ...(transform.placement.side === undefined
               ? {}
@@ -261,7 +321,7 @@ const editDensity = action(
               ? {}
               : { split: transform.placement.split })
           }, {
-            densityChannel: transform.placement.channel,
+            densityChannel,
             groupBy,
             categoryField
           });
@@ -308,8 +368,7 @@ const editDensity = action(
         ? {}
         : { placement: requestedPlacement })
     };
-    const changesPlacementMode = Object.hasOwn(args, "placement") &&
-      (transform.placement === undefined) !== (requestedPlacement === undefined);
+    const rebuildsPositions = changesPlacementMode || changesDensityChannel;
     const applyEdit = program => {
       let next = requestedPlacement === undefined
         ? program.createDensityData(dataArgs)
@@ -360,7 +419,7 @@ const editDensity = action(
         }
       }
 
-      if (changesPlacementMode) {
+      if (rebuildsPositions) {
         const xScaleId = layer.encoding?.x?.scale;
         const yScaleId = layer.encoding?.y?.scale;
         const scaleDefinitions = resolveDensityTransitionScaleDefinitions(
@@ -368,24 +427,18 @@ const editDensity = action(
           layer,
           transform,
           requestedPlacement,
-          args.placement
-        );
-        next = next
-          .editSemantic({
-            property: `layer[${layer.id}].encoding.x`,
-            remove: true
-          })
-          .editSemantic({
-            property: `layer[${layer.id}].encoding.y`,
-            remove: true
-          });
-        next = next
-          .editScale(scaleEditPatch(xScaleId, scaleDefinitions.x))
-          .editScale(scaleEditPatch(yScaleId, scaleDefinitions.y));
-        const densityChannel = requestedPlacement?.channel ?? (
-          layer.encoding.x.field === transform.as[1] ? "x" : "y"
+          args.placement,
+          args.valueScale
         );
-        const valueChannel = requestedPlacement?.channel === "x" ? "y" : "x";
+        if (
+          args.placement?.scale?.id !== undefined &&
+          args.placement.scale.id !== layer.encoding[requestedPlacement.channel].scale
+        ) {
+          throw new Error("editDensity placement scale cannot change its id.");
+        }
+        next = replaceScaleDefinition(next, xScaleId, scaleDefinitions.x);
+        next = replaceScaleDefinition(next, yScaleId, scaleDefinitions.y);
+        const valueChannel = densityChannel === "x" ? "y" : "x";
         const definition = resolveDensityPositionDefinition({
           layer: { densityChannel },
           output: transform.as,
@@ -393,23 +446,46 @@ const editDensity = action(
           placement: requestedPlacement,
           coordinate: layer.coordinate,
           valueScale: {
-            id: valueChannel === "y" ? yScaleId : xScaleId,
-            ...scaleDefinitions[valueChannel]
+            ...scaleDefinitions[valueChannel],
+            id: valueChannel === "y" ? yScaleId : xScaleId
           },
           densityScale: requestedPlacement === undefined
             ? {
-                id: densityChannel === "x" ? xScaleId : yScaleId,
-                ...scaleDefinitions[densityChannel]
+                ...scaleDefinitions[densityChannel],
+                id: densityChannel === "x" ? xScaleId : yScaleId
               }
             : undefined,
           placementScale: requestedPlacement === undefined
             ? undefined
             : {
-                id: requestedPlacement.channel === "x" ? xScaleId : yScaleId,
-                ...scaleDefinitions[requestedPlacement.channel]
+                ...scaleDefinitions[requestedPlacement.channel],
+                id: requestedPlacement.channel === "x" ? xScaleId : yScaleId
               }
         });
-        next = applyDensityPosition(next, layer.id, definition, groupBy);
+        next = replaceDensityPositions(next, layer.id, definition);
+        next = next.rematerializeScale({ id: xScaleId, marks: false, guides: false })
+          .rematerializeScale({ id: yScaleId, marks: false, guides: false });
+        const oldValueChannel = currentDensityChannel === "x" ? "y" : "x";
+        next = rebindDistributionGuides(next, {
+          oldXScale: xScaleId,
+          oldYScale: yScaleId,
+          newXScale: xScaleId,
+          newYScale: yScaleId,
+          oldXTitle: oldValueChannel === "x"
+            ? transform.field
+            : transform.placement?.categoryField ?? transform.as[1],
+          oldYTitle: oldValueChannel === "y"
+            ? transform.field
+            : transform.placement?.categoryField ?? transform.as[1],
+          newXTitle: valueChannel === "x"
+            ? field
+            : requestedPlacement?.categoryField ?? transform.as[1],
+          newYTitle: valueChannel === "y"
+            ? field
+            : requestedPlacement?.categoryField ?? transform.as[1],
+          oldMeasureChannel: oldValueChannel,
+          newMeasureChannel: valueChannel
+        });
       } else if (
         requestedPlacement !== undefined &&
         Object.hasOwn(args.placement ?? {}, "scale")
@@ -425,6 +501,17 @@ const editDensity = action(
         }
         next = next.editScale(scaleEditPatch(scaleId, requestedScale));
       }
+      if (!rebuildsPositions && Object.hasOwn(args, "valueScale")) {
+        const valueChannel = densityChannel === "x" ? "y" : "x";
+        const scaleId = layer.encoding[valueChannel].scale;
+        if (args.valueScale?.id !== undefined && args.valueScale.id !== scaleId) {
+          throw new Error("editDensity value scale cannot change its id.");
+        }
+        next = next.editScale(scaleEditPatch(scaleId, {
+          ...args.valueScale,
+          id: scaleId
+        }));
+      }
 
       next = applyMaterializationPlan(
         next,

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

@@ -4,6 +4,7 @@ import { validateOptionObject } from "../../../core/validation.js";
 import { resolvePalette } from "../../../grammar/palettes.js";
 import {
   normalizeTemporalValue,
+  resolveTemporalUnit,
   readNominalField
 } from "../../../grammar/scales/index.js";
 import {
@@ -42,7 +43,7 @@ function fieldOption(value, role) {
   }
   validateOptionObject(
     value,
-    ["field", "fieldType", "scale"],
+    ["field", "fieldType", "scale", "temporalUnit"],
     `Horizon ${role}`
   );
   return value;
@@ -80,6 +81,7 @@ function uniqueStoredEncoding(program, dataset, role) {
     JSON.stringify([
       encoding.field,
       encoding.fieldType,
+      encoding.temporalUnit,
       encoding.scale,
       encoding.title
     ]),
@@ -103,6 +105,7 @@ export function resolveHorizonField(program, layer, dataset, requested, role) {
     return {
       field: inferred.field,
       fieldType: inferred.fieldType,
+      ...(inferred.temporalUnit === undefined ? {} : { temporalUnit: inferred.temporalUnit }),
       ...(role === "x" && inferred.scale !== undefined
         ? { scale: { id: inferred.scale } }
         : {}),
@@ -127,7 +130,9 @@ export function resolveHorizonField(program, layer, dataset, requested, role) {
       `Horizon ${role} fieldType must be ${role === "x" ? "quantitative or temporal" : "quantitative"}.`
     );
   }
+  const temporalUnit = resolveTemporalUnit(option, fieldType, matching);
   return {
+    ...(temporalUnit === undefined ? {} : { temporalUnit }),
     field: option.field,
     fieldType,
     ...(option.scale !== undefined
@@ -140,9 +145,7 @@ export function resolveHorizonField(program, layer, dataset, requested, role) {
 }
 
 export function resolveHorizonGroupBy(layer, dataset, requested) {
-  if (requested === false) {
-    throw new Error("encodeHorizon groupBy must be a field string when provided.");
-  }
+  if (requested === false) return undefined;
   const value = requested ?? layer.encoding?.group?.field;
   if (value === undefined) return undefined;
   if (typeof value !== "string" || value.length === 0) {
@@ -262,6 +265,7 @@ export function resolveEditedHorizonField(
       [role]: {
         field: prior.field,
         fieldType: prior.fieldType,
+        ...(prior.temporalUnit === undefined ? {} : { temporalUnit: prior.temporalUnit }),
         scale: layer.encoding[role].scale,
         ...(role === "x" && layer.encoding.x.title !== undefined
           ? { title: layer.encoding.x.title }

package/src/actions/encodings/horizon.js

@@ -42,6 +42,8 @@ import {
   validateUnusedHorizonEncodings
 } from "./horizon/resolve.js";
 
+import { applyTemporalUnit } from "./temporal.js";
+
 const OPTIONS = Object.freeze([
   "target", "source", "x", "y", "groupBy", "bands", "baseline", "extent",
   "resolve", "missing", "overflow", "palette"
@@ -69,16 +71,17 @@ function applyHorizonEncoding(program, {
   colorScale
 }) {
   let next = clearOwnedEncodings(program, layer)
+    .editSemantic({
+      property: `layer[${layer.id}].encoding.x.title`,
+      value: layer.encoding?.x?.title ?? inferHorizonTitle(transform.x.field)
+    })
     .encodeX({
       target: layer.id,
       field: transform.as.x,
       fieldType: transform.x.fieldType,
+      ...(transform.x.fieldType === "temporal" ? { temporalUnit: "timestamp" } : {}),
       scale: xScale
     })
-    .editSemantic({
-      property: `layer[${layer.id}].encoding.x.title`,
-      value: layer.encoding?.x?.title ?? inferHorizonTitle(transform.x.field)
-    })
     .encodeY({
       target: layer.id,
       field: transform.as.lower,
@@ -113,6 +116,9 @@ const editHorizon = action(
   },
   function (args = {}) {
     validateOptionObject(args, EDIT_OPTIONS, "editHorizon");
+    if (Object.hasOwn(args, "groupBy") && args.groupBy === undefined) {
+      throw new Error("editHorizon groupBy requires a field string or false.");
+    }
     if (!EDITABLE.some(option => Object.hasOwn(args, option))) {
       throw new Error("editHorizon requires at least one Horizon option.");
     }
@@ -145,7 +151,8 @@ const editHorizon = action(
     );
     const candidate = validateHorizonTransform({
       type: "horizon",
-      x: { field: x.field, fieldType: x.fieldType },
+      x: { field: x.field, fieldType: x.fieldType,
+        ...(x.temporalUnit === undefined ? {} : { temporalUnit: x.temporalUnit }) },
       y: { field: y.field, fieldType: y.fieldType },
       ...(groupBy === undefined ? {} : { groupBy }),
       bands: args.bands ?? prior.bands,
@@ -189,6 +196,8 @@ const editHorizon = action(
         value: x.fieldType
       });
     }
+    next = applyTemporalUnit(next, layer.id, "x",
+      x.fieldType === "temporal" ? "timestamp" : undefined, layer.encoding.x);
     if (Object.hasOwn(args, "x")) {
       next = next.editSemantic({
         property: `layer[${layer.id}].encoding.x.title`,
@@ -210,7 +219,7 @@ const editHorizon = action(
       requestedXScale.domain === undefined &&
       currentX.domain === "auto"
       ? source.values.map((row, index) => x.fieldType === "temporal"
-          ? normalizeTemporalValue(row[x.field], x.field, index)
+          ? normalizeTemporalValue(row[x.field], x.field, index, x.temporalUnit)
           : row[x.field])
       : undefined;
     const nextX = resolvePositionScaleDefinition(next, "x", x.fieldType, {
@@ -285,7 +294,8 @@ const encodeHorizon = action(
     const as = horizonOutputFields(layer.id);
     const transform = validateHorizonTransform({
       type: "horizon",
-      x: { field: x.field, fieldType: x.fieldType },
+      x: { field: x.field, fieldType: x.fieldType,
+        ...(x.temporalUnit === undefined ? {} : { temporalUnit: x.temporalUnit }) },
       y: { field: y.field, fieldType: y.fieldType },
       ...(groupBy === undefined ? {} : { groupBy }),
       bands: args.bands ?? 3,
@@ -308,7 +318,7 @@ const encodeHorizon = action(
         ? {
             domain: source.values.map((row, index) =>
               x.fieldType === "temporal"
-                ? normalizeTemporalValue(row[x.field], x.field, index)
+                ? normalizeTemporalValue(row[x.field], x.field, index, x.temporalUnit)
                 : row[x.field]
             )
           }

package/src/actions/encodings/index.js

@@ -1,3 +1,4 @@
+import { registerSeriesLayoutAction } from "./seriesLayout.js";
 import { registerDensityEncodingAction } from "./density.js";
 import { registerPathOrderEncodingActions } from "./pathOrder.js";
 import { registerHorizonEncodingAction } from "./horizon.js";
@@ -16,6 +17,7 @@ import { registerBarWidthEncodingAction } from "./barWidth.js";
 import { registerEncodingRemovalAction } from "./remove.js";
 
 export function registerEncodingActions(ProgramClass) {
+  registerSeriesLayoutAction(ProgramClass);
   registerPositionEncodingActions(ProgramClass);
   registerRangedEncodingActions(ProgramClass);
   registerOffsetEncodingAction(ProgramClass);

package/src/actions/encodings/offset.js

@@ -1,3 +1,5 @@
+import { inferSeriesGroup } from "./shared.js";
+import { findSemanticScale } from "../../selectors/scales.js";
 import { action } from "../../core/action.js";
 import {
   readNominalField,
@@ -13,7 +15,6 @@ import {
   validateOptions
 } from "./shared.js";
 import {
-  resolveBarColorLayout,
   resolveBarChannels,
   resolveBarGrain
 } from "../../grammar/bars/policy.js";
@@ -50,15 +51,7 @@ function createOffsetEncoding(channel) {
             `${operation} requires a complete bar with a ${parentChannel} category encoding.`
           );
         }
-        if (
-          layer.encoding?.color !== undefined &&
-          (resolveBarColorLayout(layer) !== "group" ||
-            layer.encoding.color.field !== args.field)
-        ) {
-          throw new Error(
-            `${operation} field must match a grouped bar color field.`
-          );
-        }
+
       } else {
         const parent = layer.encoding?.[parentChannel];
         if (
@@ -88,7 +81,8 @@ function createOffsetEncoding(channel) {
         channel
       );
 
-      let next = setEncodingProperties(this, target, channel, {
+      const grouped = layer.mark.type === "bar" ? inferSeriesGroup(this, layer, args.field, "offset") : this;
+      let next = setEncodingProperties(grouped, target, channel, {
         field: args.field,
         fieldType,
         scale: scale.id
@@ -99,12 +93,12 @@ function createOffsetEncoding(channel) {
       next = applyEncodingScale(next, scale, requestedScale, {
         reassignment: layer.encoding?.[channel]?.scale === scale.id
       });
-      if (layer.mark.type === "bar" && layer.encoding?.color === undefined) {
-        return next
-          .rematerializeScale({ id: scale.id })
-          .editGraphics({ target, property: "length", value: 0 });
+      if (layer.mark.type === "bar") {
+        if (findSemanticScale(this, scale.id) === undefined && args.scale?.id === undefined) next = next._withMarkConfig(target, { ...next.markConfigs[target], seriesOffsetScale: scale.id });
+        if (layer.layout?.mode !== "group" || layer.encoding?.group?.field !== args.field) return next.layoutSeries({ target, mode: "group" });
+        return rematerializeEncoding(next, target, channel, scale.id, layer);
       }
-      return rematerializeEncoding(next, target, channel, scale.id);
+      return rematerializeEncoding(next, target, channel, scale.id, layer);
     }
   );
 }

package/src/actions/encodings/parallel.js

@@ -13,6 +13,7 @@ import {
   setEncodingProperties
 } from "./shared.js";
 import { resolveParallelCoordinate } from "../coordinates/parallel.js";
+import { applyLayerDataRematerialization } from "../../materialization/dependencies.js";
 
 const OPTIONS = Object.freeze([
   "target", "coordinate", "dimensions", "key", "missing"
@@ -98,14 +99,7 @@ export const encodeParallelCoordinates = action(
     for (let index = 0; index < definitions.length; index += 1) {
       next = applyEncodingScale(next, definitions[index], dimensions[index].scaleOptions);
     }
-    for (const definition of definitions) {
-      next = next.rematerializeScale({
-        id: definition.id,
-        guides: false,
-        marks: false
-      });
-    }
-    return next.rematerializeLineMark({ id: target, scales: false });
+    return applyLayerDataRematerialization(next, target);
   }
 );
 

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

@@ -1,3 +1,5 @@
+import { applyTemporalUnit } from "../temporal.js";
+
 function replaceAlternateBinding(program, target, channel, previous, usesField) {
   if (previous === undefined) return program;
   const alternate = usesField ? "datum" : "field";
@@ -111,6 +113,7 @@ export function applyPositionSemantics(program, {
   datum,
   hasField,
   fieldType,
+  temporalUnit,
   bin,
   aggregate,
   stack,
@@ -128,16 +131,19 @@ export function applyPositionSemantics(program, {
     channel,
     previous,
     hasField
-  )
-    .editSemantic({
+  );
+  if (hasField || datum !== undefined) {
+    next = next.editSemantic({
       property: `layer[${target}].encoding.${channel}.${hasField ? "field" : "datum"}`,
       value: hasField ? field : datum
-    })
-    .editSemantic({
+    });
+  }
+  next = next.editSemantic({
       property: `layer[${target}].encoding.${channel}.fieldType`,
       value: fieldType
     });
 
+  next = applyTemporalUnit(next, target, channel, temporalUnit, previous);
   next = applyBin(next, target, channel, previous, bin);
   for (const [property, value] of Object.entries({ aggregate, stack })) {
     if (value === undefined) continue;