ggaction 0.0.12 → 0.0.13

package/src/actions/encodings/shared.js

@@ -1,15 +1,13 @@
+import { isSourceOwnedText } from "../../grammar/text.js";
 import { validateUserId } from "../../core/identifiers.js";
 import { findDataset } from "../../selectors/datasets.js";
 import { resolveEligibleLayer } from "../../selectors/layers.js";
 import { hasMaterializedLegend } from "../../materialization/legends.js";
-import { applyMaterializationPlan } from "../../materialization/dependencies.js";
+import { applyDetachedScaleRematerialization, applyMaterializationPlan } from "../../materialization/dependencies.js";
 import { planEncodingRematerialization } from "../../materialization/encodings.js";
 import { findSemanticScale } from "../../selectors/scales.js";
 import { validateOptionObject } from "../../core/validation.js";
-import {
-  getMarkGraphicTypes,
-  getPositionChannelDefinition
-} from "../../core/vocabulary.js";
+import { getMarkGraphicTypes, getPositionChannelDefinition } from "../../core/vocabulary.js";
 
 export function validateOptions(args, supported, operation) {
   validateOptionObject(args, supported, operation);
@@ -31,11 +29,16 @@ export function setEncodingProperties(
   return next;
 }
 
-export function rematerializeEncoding(program, target, channel, scale) {
-  return applyMaterializationPlan(
+export { applyDetachedScaleRematerialization };
+
+export function rematerializeEncoding(program, target, channel, scale, previousLayer) {
+  const next = applyMaterializationPlan(
     program,
     planEncodingRematerialization(program, { target, channel, scale })
   );
+  return previousLayer === undefined
+    ? next
+    : applyDetachedScaleRematerialization(next, [previousLayer]);
 }
 
 export function clearMarkGraphic(program, target) {
@@ -50,19 +53,6 @@ export function clearMarkGraphic(program, target) {
 }
 
 
-export function validateLineSeriesCompatibility(layer, channel, field) {
-  if (layer.mark?.type !== "line") return;
-  for (const companion of ["group", "color", "strokeDash"]) {
-    if (companion === channel) continue;
-    const companionField = layer.encoding?.[companion]?.field;
-    if (companionField !== undefined && companionField !== field) {
-      throw new Error(
-        `Line ${channel} field "${field}" must match ${companion} field "${companionField}".`
-      );
-    }
-  }
-}
-
 export function resolveReassignmentScaleOptions(encoding, options) {
   if (encoding?.scale === undefined || options?.id !== undefined) return options;
   return { ...options, id: encoding.scale };
@@ -72,13 +62,14 @@ export function applyEncodingScale(
   program,
   definition,
   options = {},
-  { reassignment = false } = {}
+  { reassignment = false, allowTypeChange = false } = {}
 ) {
   const existing = findSemanticScale(program, definition.id);
   if (existing === undefined) {
     return program.createScale(definition);
   }
   if (existing.type !== definition.type) {
+    if (reassignment && allowTypeChange) return program.editScale({ ...definition });
     throw new Error(
       `Scale "${definition.id}" cannot change type from "${existing.type}" to "${definition.type}".`
     );
@@ -88,7 +79,7 @@ export function applyEncodingScale(
   for (const property of [
     "domain", "range", "nice", "zero", "clamp", "reverse",
     "base", "exponent", "constant", "paddingInner", "paddingOuter",
-    "padding", "align", "unknown", "interpolate"
+    "padding", "align", "unknown", "interpolate", "radialMapping"
   ]) {
     if (Object.hasOwn(options, property)) patch[property] = definition[property];
   }
@@ -118,7 +109,7 @@ export function rebindPositionGuides(
   if (!ownsAxis && !ownsGrid) return program;
 
   const remaining = program.semanticSpec.layers.some(layer =>
-    layer.id !== target && layer.encoding?.[channel]?.scale === previousScale
+    layer.id !== target && !isSourceOwnedText(layer) && layer.encoding?.[channel]?.scale === previousScale
   );
   if (remaining) {
     throw new Error(
@@ -195,3 +186,14 @@ export function resolveTarget(
 
   return { id, dataset, layer };
 }
+
+export function inferSeriesGroup(program, layer, field, origin) {
+  const group = layer.encoding?.group;
+  if (group !== undefined && group.inferredFrom !== origin) {
+    if (origin === "offset" && (group.fields !== undefined || group.field !== field)) {
+      throw new Error("Offset field conflicts with the stored series group.");
+    }
+    return program;
+  }
+  return setEncodingProperties(program, layer.id, "group", { field, fieldType: "nominal", inferredFrom: origin });
+}

package/src/actions/encodings/strokeDash.js

@@ -11,10 +11,10 @@ import {
   resolveReassignmentScaleOptions,
   resolveTarget,
   setEncodingProperties,
-  validateLineSeriesCompatibility,
   validateOptions
 } from "./shared.js";
 import { findLayer } from "../../selectors/layers.js";
+import { validatePathSeriesAppearance } from "../../grammar/pathSeries.js";
 
 const STROKE_DASH_ENCODING_OPTIONS = Object.freeze([
   "field", "value", "target", "fieldType", "scale"
@@ -81,6 +81,9 @@ const encodeStrokeDash = action(
     );
     if (hasValue) {
       normalizeStrokeDashPattern(args.value);
+      validatePathSeriesAppearance(dataset.values, {
+        ...layer, encoding: { ...layer.encoding, strokeDash: { datum: args.value } }
+      });
       let next = layer.encoding?.strokeDash === undefined
         ? this
         : this.clearStrokeDashEncoding({ target });
@@ -89,13 +92,13 @@ const encodeStrokeDash = action(
         value: args.value
       });
       next = reconcileLegendAfterDashRemoval(next, target);
-      return layer.mark.type === "rule"
-        ? next.rematerializeRuleMark({ id: target })
-        : next.rematerializeLineMark({ id: target });
+      return rematerializeEncoding(next, target, "strokeDash", undefined, layer);
     }
 
     const fieldType = validateNominalFieldType(args.fieldType ?? "nominal");
-    validateLineSeriesCompatibility(layer, "strokeDash", args.field);
+    validatePathSeriesAppearance(dataset.values, {
+      ...layer, encoding: { ...layer.encoding, strokeDash: { field: args.field, fieldType } }
+    });
     const previous = layer.encoding?.strokeDash;
     const requestedScale = previous?.field === args.field
       ? resolveReassignmentScaleOptions(previous, args.scale ?? {})
@@ -120,7 +123,7 @@ const encodeStrokeDash = action(
       reassignment: previous?.scale === scale.id
     });
 
-    return rematerializeEncoding(next, target, "strokeDash", scale.id);
+    return rematerializeEncoding(next, target, "strokeDash", scale.id, layer);
   }
 );
 

package/src/actions/encodings/temporal.js

@@ -0,0 +1,7 @@
+export function applyTemporalUnit(program, target, channel, unit, previous) {
+  if (unit === previous?.temporalUnit) return program;
+  return program.editSemantic({
+    property: `layer[${target}].encoding.${channel}.temporalUnit`,
+    ...(unit === undefined ? { remove: true } : { value: unit })
+  });
+}

package/src/actions/encodings/text.js

@@ -1,6 +1,8 @@
 import { action } from "../../core/action.js";
 import { formatTextValue, validateTextFormat } from "../../grammar/text.js";
+import { normalizeMarkLabelContent, resolveMarkLabelValues } from "../../grammar/markLabels.js";
 import { canMaterializeText } from "../../materialization/marks/index.js";
+import { resolveMarkItems } from "../../materialization/selection/policies/index.js";
 import { findLayer } from "../../selectors/layers.js";
 import {
   resolveTarget,
@@ -8,7 +10,7 @@ import {
   validateOptions
 } from "./shared.js";
 
-const OPTIONS = Object.freeze(["target", "field", "value", "format"]);
+const OPTIONS = Object.freeze(["target", "field", "value", "content", "normalizeBy", "format"]);
 
 function validateTextField(rows, field, format) {
   if (typeof field !== "string" || field.length === 0) {
@@ -26,14 +28,18 @@ function validateTextField(rows, field, format) {
 export const encodeText = action(
   {
     op: "encodeText",
-    description: "Assign field-driven or constant text content."
+    description: "Assign field, constant, or source semantic text content."
   },
   function (args = {}) {
     validateOptions(args, OPTIONS, "encodeText");
     const hasField = Object.hasOwn(args, "field");
     const hasValue = Object.hasOwn(args, "value");
-    if (hasField === hasValue) {
-      throw new Error("encodeText requires exactly one of field or value.");
+    const hasContent = Object.hasOwn(args, "content");
+    if ([hasField, hasValue, hasContent].filter(Boolean).length !== 1) {
+      throw new Error("encodeText requires exactly one of field, value, or content.");
+    }
+    if (Object.hasOwn(args, "normalizeBy") && (!hasContent || args.content !== "share")) {
+      throw new Error("Text normalizeBy is only supported with share content.");
     }
     const { id: target, dataset, layer } = resolveTarget(
       this,
@@ -43,23 +49,32 @@ export const encodeText = action(
     );
     const previous = layer.encoding?.text;
     const format = validateTextFormat(args.format ?? previous?.format ?? "auto");
+    const content = hasContent
+      ? normalizeMarkLabelContent(findLayer(this, layer.source), args)
+      : undefined;
     if (hasField) validateTextField(dataset.values, args.field, format);
-    else if (formatTextValue(args.value, format) === undefined) {
+    else if (hasValue && formatTextValue(args.value, format) === undefined) {
       throw new Error("encodeText value must produce non-empty text.");
     }
 
+    const properties = {
+      ...(hasContent ? content : { [hasField ? "field" : "datum"]: hasField ? args.field : args.value }),
+      format
+    };
+    const proposed = { ...layer, encoding: { ...layer.encoding, text: properties } };
+    if (hasContent && canMaterializeText(this, proposed)) {
+      const source = findLayer(this, layer.source);
+      for (const value of resolveMarkLabelValues(source, resolveMarkItems(this, source.id), content)) {
+        formatTextValue(value, format);
+      }
+    }
     let next = this;
-    const alternate = hasField ? "datum" : "field";
-    if (Object.hasOwn(previous ?? {}, alternate)) {
-      next = next.editSemantic({
-        property: `layer[${target}].encoding.text.${alternate}`,
-        remove: true
-      });
+    for (const property of ["field", "datum", "content", "normalizeBy"]) {
+      if (Object.hasOwn(previous ?? {}, property) && !Object.hasOwn(properties, property)) {
+        next = next.editSemantic({ property: `layer[${target}].encoding.text.${property}`, remove: true });
+      }
     }
-    next = setEncodingProperties(next, target, "text", {
-      [hasField ? "field" : "datum"]: hasField ? args.field : args.value,
-      format
-    });
+    next = setEncodingProperties(next, target, "text", properties);
     const updated = findLayer(next, target);
     return canMaterializeText(next, updated)
       ? next.rematerializeTextMark({ id: target })

package/src/actions/errorBands/create.js

@@ -2,6 +2,7 @@ import { action } from "../../core/action.js";
 import { isPlainObject } from "../../core/immutable.js";
 import {
   validateKeys,
+  validateNonEmptyString,
 } from "../../core/validation.js";
 import { DEFAULT_COLORS } from "../../theme/defaults.js";
 import { validateCurveInterpolation } from "../../grammar/curveCommands.js";
@@ -23,7 +24,7 @@ const OPTIONS = Object.freeze([
   "boundaries"
 ]);
 
-const ERROR_BAND_POLICY = Object.freeze({
+export const ERROR_BAND_POLICY = Object.freeze({
   operation: "createErrorBand",
   resourceLabel: "error-band",
   defaultId: "errorBand",
@@ -40,8 +41,8 @@ const ERROR_BAND_POLICY = Object.freeze({
     "createErrorBand cannot infer the interval axis when both positions are quantitative; provide an interval option."
 });
 
-function resolveErrorBand(program, args) {
-  const resolved = resolveIntervalComposite(program, args, ERROR_BAND_POLICY);
+export function resolveErrorBand(program, args, policy = ERROR_BAND_POLICY) {
+  const resolved = resolveIntervalComposite(program, args, policy);
   if (resolved.groupField === resolved.position.field) {
     throw new Error(
       "createErrorBand groupBy must differ from the independent position field."
@@ -71,8 +72,9 @@ function resolveBoundaries(value, areaCurve) {
   });
 }
 
-function positionOptions({ target, field, fieldType, coordinate, scale }) {
-  return { target, field, fieldType, coordinate, scale: { id: scale } };
+function positionOptions({ target, field, fieldType, coordinate, scale, temporalUnit }) {
+  return { target, field, fieldType, coordinate, scale: { id: scale },
+    ...(temporalUnit === undefined ? {} : { temporalUnit }) };
 }
 
 export const createErrorBandBoundary = action(
@@ -103,6 +105,7 @@ export const createErrorBandBoundary = action(
         target: id,
         field: vertical ? bound : position.field,
         fieldType: vertical ? "quantitative" : position.fieldType,
+        temporalUnit: vertical ? undefined : position.temporalUnit,
         coordinate,
         scale: vertical ? intervalScale : positionScale
       }))
@@ -110,6 +113,7 @@ export const createErrorBandBoundary = action(
         target: id,
         field: vertical ? position.field : bound,
         fieldType: vertical ? position.fieldType : "quantitative",
+        temporalUnit: vertical ? position.temporalUnit : undefined,
         coordinate,
         scale: vertical ? positionScale : intervalScale
       }));
@@ -132,6 +136,7 @@ function positionArgs(resolved) {
     target: resolved.id,
     field: resolved.position.field,
     fieldType: resolved.position.fieldType,
+    ...(resolved.position.temporalUnit === undefined ? {} : { temporalUnit: resolved.position.temporalUnit }),
     coordinate: resolved.coordinate,
     scale: resolved.position.scale
   };
@@ -158,6 +163,7 @@ export const createErrorBand = action(
     const resolved = resolveErrorBand(this, args);
     const curve = validateCurveInterpolation(args.curve ?? "linear");
     const boundaries = resolveBoundaries(args.boundaries, curve);
+    if (args.fill !== undefined) validateNonEmptyString(args.fill, "Error-band fill");
     let next = createResolvedIntervalData(this, resolved);
     next = next.createAreaMark({
       id: resolved.id,
@@ -216,6 +222,13 @@ export const createErrorBand = action(
     return next._withMarkConfig(resolved.id, {
       ...next.markConfigs[resolved.id],
       errorBand: {
+        ...(args.fill === undefined ? {} : { fill: args.fill }),
+        source: resolved.source,
+        intervalMode: resolved.interval.mode,
+        ...(resolved.interval.mode === "statistical"
+          ? { intervalField: resolved.interval.field }
+          : { centerField: resolved.fields.center }),
+        transformGroupBy: resolved.groupBy,
         data: resolved.dataId,
         orientation: resolved.orientation,
         position: resolved.position,