ggaction 0.0.12 → 0.0.15

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

@@ -1,101 +1,7 @@
-import {
-  BAR_GRAINS,
-  resolveBarChannels,
-  resolveBarGrain,
-  resolveBarOffsetChannel
-} from "../../../grammar/bars/policy.js";
-import { resolveOffsetScaleDefinition } from "../../scales/definitions.js";
-import { isRangedArea } from "./policy.js";
-
 export function applyColorLayoutCompanion(
   program,
-  { target, layer, layout, scale, field }
+  { target, layer, layout, horizon }
 ) {
-  if (layout === undefined || layer.mark.type === "arc") return program;
-  if (
-    layer.mark.type === "bar" &&
-    resolveBarGrain(layer) === BAR_GRAINS.ranged
-  ) {
-    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)
-    : undefined;
-  const measureChannel = channels?.measure ?? "y";
-  const measure = layer.encoding?.[measureChannel];
-  if (measure?.field === undefined || measure.scale === undefined) {
-    throw new Error(`Color layout on mark "${target}" requires a measure encoding.`);
-  }
-  const stack = layout === "fill"
-    ? "normalize"
-    : layout === "center"
-      ? "center"
-    : layout === "overlay" || layout === "group"
-      ? null
-      : "zero";
-  let next = program;
-  if (layout === "group") {
-    const offsetChannel = resolveBarOffsetChannel(layer);
-    const method = offsetChannel === "xOffset" ? "encodeXOffset" : "encodeYOffset";
-    next = next[method]({
-      field,
-      target,
-      scale: {
-        ...(layer.encoding?.[offsetChannel]?.scale === undefined
-          ? {}
-          : { id: layer.encoding[offsetChannel].scale }),
-        domain: scale.domain
-      }
-    });
-  }
-  return next[measureChannel === "x" ? "encodeX" : "encodeY"]({
-    target,
-    field: measure.field,
-    fieldType: measure.fieldType,
-    ...(measure.aggregate === undefined ? {} : { aggregate: measure.aggregate }),
-    stack
-  });
-}
-
-export function preSynchronizeGroupedOffset(
-  program,
-  { target, layer, layout, field, fieldType, scale, requestedScale }
-) {
-  if (
-    layer.mark.type !== "bar" ||
-    layout !== "group" ||
-    layer.encoding?.color?.scale !== scale.id ||
-    !Object.keys(requestedScale).some(key => key !== "id")
-  ) {
-    return program;
-  }
-  const offsetChannel = resolveBarOffsetChannel(layer);
-  const offset = layer.encoding?.[offsetChannel];
-  if (offset?.scale === undefined) return program;
-  const offsetScale = resolveOffsetScaleDefinition(program, {
-    id: offset.scale,
-    domain: scale.domain
-  }, offsetChannel);
-  return program
-    .editSemantic({
-      property: `layer[${target}].encoding.${offsetChannel}.field`,
-      value: field
-    })
-    .editSemantic({
-      property: `layer[${target}].encoding.${offsetChannel}.fieldType`,
-      value: fieldType
-    })
-    .editSemantic({
-      property: `scale[${offsetScale.id}].domain`,
-      value: offsetScale.domain
-    });
+  if (layout === undefined || layer.mark.type === "arc" || horizon) return program;
+  return program.layoutSeries({ target, mode: layout });
 }

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

@@ -5,7 +5,7 @@ import {
 import { validateColorLayout } from "../../../grammar/seriesLayout.js";
 
 export const COLOR_ENCODING_OPTIONS = Object.freeze([
-  "field", "target", "fieldType", "scale", "palette", "layout", "aggregate"
+  "field", "target", "fieldType", "scale", "palette", "layout", "aggregate", "temporalUnit"
 ]);
 
 export function resolveColorScaleOptions(args) {
@@ -24,6 +24,7 @@ export function assertNoConstantColor(program, layer) {
   const hasConstant = {
     point: config?.fill !== undefined,
     line: config?.stroke !== undefined,
+    area: config?.errorBand?.fill !== undefined,
     bar: config?.barAppearance?.fill !== undefined,
     arc: config?.fill !== undefined,
     rect: config?.fillExplicit === true
@@ -53,12 +54,7 @@ export function resolveColorLayout(layer, requested, barGrain) {
             : undefined
       );
   if (requested !== undefined) validateColorLayout(requested);
-  if (existing !== undefined && requested !== undefined && requested !== existing) {
-    throw new Error(
-      `Color layout transition from "${existing}" to "${requested}" is not supported.`
-    );
-  }
-  const layout = requested ?? existing ?? (
+  const layout = requested ?? layer.layout?.mode ?? existing ?? (
     layer.mark.type === "bar"
       ? barGrain === BAR_GRAINS.histogram
         ? "stack"
@@ -84,7 +80,8 @@ export function resolveColorLayout(layer, requested, barGrain) {
   ) {
     throw new Error('Arc color layout currently supports only "overlay".');
   }
-  if (isRangedArea(layer) && layout !== "overlay") {
+  if (isRangedArea(layer) && layer.encoding?.x2?.datum === undefined && layer.encoding?.y2?.datum === undefined &&
+    layer.encoding?.x?.datum === undefined && layer.encoding?.y?.datum === undefined && layout !== "overlay") {
     throw new Error('Ranged area color encoding supports only "overlay" layout.');
   }
   return layout;

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,
@@ -26,14 +28,55 @@ import {
 
 const OPTIONS = Object.freeze([
   "field", "target", "source", "groupBy", "bandwidth", "extent", "steps",
-  "kernel", "normalization", "as", "densityChannel", "coordinate",
+  "kernel", "normalization", "weight", "as", "densityChannel", "coordinate",
   "valueScale", "densityScale", "placement"
 ]);
 const EDIT_OPTIONS = Object.freeze([
   "target", "source", "field", "groupBy", "bandwidth", "extent", "steps",
-  "kernel", "normalization", "placement"
+  "kernel", "normalization", "weight", "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(
@@ -150,6 +193,7 @@ const encodeDensity = action(
       ...(args.normalization === undefined
         ? {}
         : { normalization: args.normalization }),
+      ...(args.weight === undefined ? {} : { weight: args.weight }),
       ...(args.as === undefined ? {} : { as: args.as }),
       ...(placement === undefined ? {} : { placement })
     };
@@ -241,17 +285,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 +322,7 @@ const editDensity = action(
               ? {}
               : { split: transform.placement.split })
           }, {
-            densityChannel: transform.placement.channel,
+            densityChannel,
             groupBy,
             categoryField
           });
@@ -290,6 +351,7 @@ const editDensity = action(
     const option = property => Object.hasOwn(args, property)
       ? args[property]
       : transform[property];
+    const weight = option("weight");
 
     const dataArgs = {
       id: revision.id,
@@ -304,12 +366,12 @@ const editDensity = action(
       kernel: option("kernel") ?? "gaussian",
       normalization: option("normalization") ?? "unit",
       as: transform.as,
+      ...(weight === undefined || weight === false ? {} : { weight }),
       ...(requestedPlacement === undefined
         ? {}
         : { 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 +422,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 +430,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 +449,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 +504,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/histogram.js

@@ -3,7 +3,7 @@ import { validateOptions } from "./shared.js";
 
 const HISTOGRAM_OPTIONS = Object.freeze([
   "field", "target", "coordinate", "maxBins", "binStep", "binBoundaries",
-  "stack", "xScale", "yScale"
+  "stack", "xScale", "yScale", "weight"
 ]);
 
 const encodeHistogram = action(
@@ -28,7 +28,8 @@ const encodeHistogram = action(
         : { maxBins: args.maxBins ?? 10 };
     const x = {
       field: args.field,
-      bin
+      bin,
+      ...(args.weight === undefined ? {} : { weight: args.weight })
     };
     const y = {
       stack: Object.hasOwn(args, "stack") ? args.stack : "zero"

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";
@@ -12,10 +13,13 @@ import { registerTextEncodingAction } from "./text.js";
 import { registerAppearanceEncodingAction } from "./appearance.js";
 import { registerStrokeDashEncodingActions } from "./strokeDash.js";
 import { registerRuleAppearanceEncodingActions } from "./ruleAppearance.js";
+import { registerStrokeEncodingAction } from "./stroke.js";
 import { registerBarWidthEncodingAction } from "./barWidth.js";
 import { registerEncodingRemovalAction } from "./remove.js";
+import { registerAtomicEncodingAction } from "./channels.js";
 
 export function registerEncodingActions(ProgramClass) {
+  registerSeriesLayoutAction(ProgramClass);
   registerPositionEncodingActions(ProgramClass);
   registerRangedEncodingActions(ProgramClass);
   registerOffsetEncodingAction(ProgramClass);
@@ -29,7 +33,9 @@ export function registerEncodingActions(ProgramClass) {
   registerAppearanceEncodingAction(ProgramClass);
   registerAngleEncodingAction(ProgramClass);
   registerRuleAppearanceEncodingActions(ProgramClass);
+  registerStrokeEncodingAction(ProgramClass);
   registerTextEncodingAction(ProgramClass);
   registerParallelEncodingAction(ProgramClass);
   registerEncodingRemovalAction(ProgramClass);
+  registerAtomicEncodingAction(ProgramClass);
 }