ggaction 0.0.13 → 0.0.16

package/src/actions/encodings/shared.js

@@ -8,6 +8,7 @@ import { planEncodingRematerialization } from "../../materialization/encodings.j
 import { findSemanticScale } from "../../selectors/scales.js";
 import { validateOptionObject } from "../../core/validation.js";
 import { getMarkGraphicTypes, getPositionChannelDefinition } from "../../core/vocabulary.js";
+import { DEFAULT_TICK_COUNT } from "../guides/tickValues.js";
 
 export function validateOptions(args, supported, operation) {
   validateOptionObject(args, supported, operation);
@@ -105,33 +106,100 @@ export function rebindPositionGuides(
   const direction = definition.gridDirection;
   const grid = program.semanticSpec.guides.grid?.[direction];
   const ownsAxis = axis?.scale === previousScale;
+  const refreshesReboundAxis = axis?.scale === nextScale;
   const ownsGrid = grid?.scale === previousScale;
-  if (!ownsAxis && !ownsGrid) return program;
+  if (!ownsAxis && !ownsGrid && !refreshesReboundAxis) return program;
 
   const remaining = program.semanticSpec.layers.some(layer =>
     layer.id !== target && !isSourceOwnedText(layer) && layer.encoding?.[channel]?.scale === previousScale
   );
-  if (remaining) {
+  if ((ownsAxis || ownsGrid) && remaining) {
     throw new Error(
       `Cannot rebind ${channel} guides from shared scale "${previousScale}" while it has other consumers.`
     );
   }
 
   let next = program;
-  if (ownsAxis) {
-    next = next.editSemantic({
-      property: `guide.axis.${definition.guideChannel}.scale`,
-      value: nextScale
-    });
-    for (const component of ["line", "ticks", "labels", "title"]) {
-      const config = next.guideConfigs.axis?.[definition.guideChannel]?.[component];
-      if (config?.scale === previousScale) {
-        next = next._withGuideConfig(definition.guideChannel, component, {
-          ...config,
-          scale: nextScale
-        });
+  if (ownsAxis || refreshesReboundAxis) {
+    const previousAxisConfig = next.guideConfigs.axis?.[definition.guideChannel];
+    const previousTicks = previousAxisConfig?.ticks;
+    const previousLabels = previousAxisConfig?.labels;
+    const labelsFollowTicks = previousTicks !== undefined &&
+      previousLabels !== undefined &&
+      previousTicks.mode === previousLabels.mode &&
+      (previousTicks.mode === "count"
+        ? previousTicks.count === previousLabels.count
+        : previousTicks.values?.length === previousLabels.values?.length &&
+          previousTicks.values.every(
+            (value, index) => Object.is(value, previousLabels.values[index])
+          ));
+    if (ownsAxis) {
+      next = next.editSemantic({
+        property: `guide.axis.${definition.guideChannel}.scale`,
+        value: nextScale
+      });
+      for (const component of ["line", "ticks", "labels", "title"]) {
+        const config = next.guideConfigs.axis?.[definition.guideChannel]?.[component];
+        if (config?.scale === previousScale) {
+          next = next._withGuideConfig(definition.guideChannel, component, {
+            ...config,
+            scale: nextScale
+          });
+        }
       }
     }
+    const resolved = next.resolvedScales[nextScale] ??
+      findSemanticScale(next, nextScale);
+    const discrete = ["ordinal", "band", "point"].includes(resolved?.type);
+    let ticks = next.guideConfigs.axis?.[definition.guideChannel]?.ticks;
+    if (ticks !== undefined && discrete && ticks.mode !== "values") {
+      ticks = {
+        ...ticks,
+        mode: "values",
+        values: resolved.domain,
+        inferredValues: true
+      };
+      delete ticks.count;
+      next = next._withGuideConfig(definition.guideChannel, "ticks", ticks);
+    } else if (
+      ticks !== undefined &&
+      !discrete &&
+      ticks.mode === "values" &&
+      ticks.inferredValues === true
+    ) {
+      ticks = {
+        ...ticks,
+        mode: "count",
+        count: DEFAULT_TICK_COUNT,
+        inferredValues: true
+      };
+      delete ticks.values;
+      next = next._withGuideConfig(definition.guideChannel, "ticks", ticks);
+    } else if (
+      ticks !== undefined &&
+      discrete &&
+      ticks.inferredValues === true
+    ) {
+      ticks = { ...ticks, values: resolved.domain };
+      next = next._withGuideConfig(definition.guideChannel, "ticks", ticks);
+    }
+    if (previousLabels !== undefined && labelsFollowTicks && ticks !== undefined) {
+      const labels = {
+        ...next.guideConfigs.axis[definition.guideChannel].labels,
+        mode: ticks.mode,
+        inferredValues: ticks.inferredValues === true,
+        ...(ticks.mode === "values"
+          ? { values: ticks.values }
+          : { count: ticks.count })
+      };
+      if (ticks.mode === "values") delete labels.count;
+      else delete labels.values;
+      next = next._withGuideConfig(
+        definition.guideChannel,
+        "labels",
+        labels
+      );
+    }
   }
   if (ownsGrid) {
     next = next

package/src/actions/encodings/stroke.js

@@ -0,0 +1,226 @@
+import { action } from "../../core/action.js";
+import {
+  readNominalField,
+  readQuantitativeField,
+  readScaleField,
+  readTemporalField,
+  resolveTemporalUnit,
+  validateCategoricalFieldType
+} from "../../grammar/scales/index.js";
+import { validateContinuousColorConsumer } from
+  "../../grammar/scales/colorConsumers.js";
+import { validatePathSeriesAppearance } from "../../grammar/pathSeries.js";
+import { validateRuleStroke } from "../../grammar/ruleAppearance.js";
+import { assertEncodingSelectionCompatibility } from
+  "../../materialization/selection/compatibility.js";
+import {
+  resolveColorScaleDefinition,
+  resolveQuantitativeColorScaleDefinition
+} from "../scales/definitions.js";
+import { applyTemporalUnit } from "./temporal.js";
+import {
+  applyEncodingScale,
+  rematerializeEncoding,
+  resolveReassignmentScaleOptions,
+  resolveTarget,
+  setEncodingProperties,
+  validateOptions
+} from "./shared.js";
+
+const OPTIONS = Object.freeze([
+  "target", "value", "field", "fieldType", "temporalUnit", "scale"
+]);
+const MARK_TYPES = Object.freeze([
+  "point", "line", "area", "bar", "rect", "arc", "rule", "tick"
+]);
+
+function withoutConstantStroke(program, layer) {
+  const config = { ...program.markConfigs[layer.id] };
+  if (layer.mark.type === "bar") {
+    const appearance = { ...config.barAppearance };
+    delete appearance.stroke;
+    config.barAppearance = appearance;
+  } else {
+    delete config.stroke;
+    if (layer.mark.type === "area") delete config.strokeFromFill;
+  }
+  return program._withMarkConfig(layer.id, config);
+}
+
+function withConstantStroke(program, layer, value) {
+  const config = { ...program.markConfigs[layer.id] };
+  if (layer.mark.type === "bar") {
+    const appearance = { ...config.barAppearance, stroke: value };
+    if (config.barAppearance?.stroke === false && appearance.strokeWidth === undefined) {
+      appearance.strokeWidth = 0.5;
+    }
+    config.barAppearance = appearance;
+  } else {
+    const restores = config.stroke === false;
+    config.stroke = value;
+    if (layer.mark.type === "area") delete config.strokeFromFill;
+    if (
+      (restores || ["point", "area"].includes(layer.mark.type)) &&
+      config.strokeWidth === undefined
+    ) {
+      config.strokeWidth = 1;
+    }
+  }
+  return program._withMarkConfig(layer.id, config);
+}
+
+function hasStrokeLegend(program, target) {
+  return Object.values(program.guideConfigs.legend ?? {}).some(config =>
+    config?.target === target && (
+      config.channel === "stroke" || config.channels?.includes("stroke")
+    )
+  );
+}
+
+function validateStrokeField(dataset, layer, args, scale, temporalUnit) {
+  const { field, fieldType } = args;
+  validateContinuousColorConsumer(layer, args, scale, { channel: "stroke" });
+  if (["line", "area"].includes(layer.mark.type)) {
+    validatePathSeriesAppearance(dataset.values, {
+      ...layer,
+      encoding: {
+        ...layer.encoding,
+        stroke: { field, fieldType, temporalUnit, scale: scale.id }
+      }
+    });
+  }
+  if (Object.hasOwn(scale, "unknown")) {
+    readScaleField(dataset.values, field, fieldType, {
+      allowUnknown: true,
+      temporalUnit
+    });
+  } else if (fieldType === "temporal") {
+    readTemporalField(dataset.values, field, temporalUnit);
+  } else {
+    readQuantitativeField(dataset.values, field);
+  }
+}
+
+export const encodeStroke = /* @__PURE__ */ action(
+  {
+    op: "encodeStroke",
+    description: "Assign constant or field-driven graphical stroke color."
+  },
+  function (args = {}) {
+    validateOptions(args, OPTIONS, "encodeStroke");
+    const hasValue = Object.hasOwn(args, "value");
+    const hasField = Object.hasOwn(args, "field");
+    if (hasValue === hasField) {
+      throw new Error("encodeStroke requires exactly one of value or field.");
+    }
+    if (hasValue && (
+      args.fieldType !== undefined ||
+      args.temporalUnit !== undefined ||
+      args.scale !== undefined
+    )) {
+      throw new Error(
+        "Constant stroke does not accept fieldType, temporalUnit, or scale."
+      );
+    }
+    const { id: target, dataset, layer } = resolveTarget(
+      this,
+      args.target,
+      MARK_TYPES,
+      "stroke-capable mark"
+    );
+
+    if (hasValue) {
+      const value = validateRuleStroke(args.value);
+      if (
+        layer.mark.type === "rule" &&
+        layer.encoding?.stroke === undefined &&
+        !hasStrokeLegend(this, target)
+      ) {
+        return this
+          ._withMarkConfig(target, { ...this.markConfigs[target], stroke: value })
+          .rematerializeRuleMark({ id: target });
+      }
+      assertEncodingSelectionCompatibility(this, target, ["stroke"]);
+      let next = hasStrokeLegend(this, target)
+        ? this.removeLegend({ target, channels: ["stroke"] })
+        : this;
+      if (layer.encoding?.stroke !== undefined) {
+        next = next.editSemantic({
+          property: `layer[${target}].encoding.stroke`,
+          remove: true
+        });
+      }
+      next = withConstantStroke(next, layer, value);
+      return rematerializeEncoding(next, target, "stroke", undefined, layer);
+    }
+
+    const fieldType = args.fieldType ?? "nominal";
+    const previous = layer.encoding?.stroke;
+    const temporalUnit = resolveTemporalUnit(args, fieldType, previous);
+    const requestedScale = resolveReassignmentScaleOptions(
+      previous,
+      args.scale ?? {}
+    );
+    let scale;
+    if (["nominal", "ordinal"].includes(fieldType)) {
+      validateCategoricalFieldType(fieldType);
+      if (temporalUnit !== undefined) {
+        throw new Error("Categorical stroke does not support temporalUnit.");
+      }
+      scale = resolveColorScaleDefinition(this, requestedScale, "stroke");
+      if (Object.hasOwn(scale, "unknown")) {
+        readScaleField(dataset.values, args.field, fieldType, {
+          allowUnknown: true
+        });
+      } else {
+        readNominalField(dataset.values, args.field);
+      }
+      if (["line", "area"].includes(layer.mark.type)) {
+        validatePathSeriesAppearance(dataset.values, {
+          ...layer,
+          encoding: {
+            ...layer.encoding,
+            stroke: {
+              field: args.field,
+              fieldType,
+              scale: scale.id
+            }
+          }
+        });
+      }
+    } else if (["quantitative", "temporal"].includes(fieldType)) {
+      scale = resolveQuantitativeColorScaleDefinition(
+        this,
+        fieldType,
+        requestedScale,
+        "stroke"
+      );
+      validateStrokeField(
+        dataset,
+        layer,
+        { ...args, fieldType },
+        scale,
+        temporalUnit
+      );
+    } else {
+      throw new Error(`Unsupported stroke field type "${fieldType}".`);
+    }
+
+    let next = withoutConstantStroke(this, layer);
+    next = applyTemporalUnit(next, target, "stroke", temporalUnit, previous);
+    next = setEncodingProperties(next, target, "stroke", {
+      field: args.field,
+      fieldType,
+      scale: scale.id
+    });
+    next = applyEncodingScale(next, scale, requestedScale, {
+      reassignment: previous?.scale === scale.id,
+      allowTypeChange: true
+    });
+    return rematerializeEncoding(next, target, "stroke", scale.id, layer);
+  }
+);
+
+export function registerStrokeEncodingAction(ProgramClass) {
+  ProgramClass.prototype.encodeStroke = encodeStroke;
+}

package/src/actions/encodings/strokeDash.js

@@ -20,7 +20,7 @@ const STROKE_DASH_ENCODING_OPTIONS = Object.freeze([
   "field", "value", "target", "fieldType", "scale"
 ]);
 
-const clearStrokeDashEncoding = action(
+const clearStrokeDashEncoding = /* @__PURE__ */ action(
   {
     op: "clearStrokeDashEncoding",
     description: "Remove the current semantic stroke-dash assignment."
@@ -58,7 +58,7 @@ function reconcileLegendAfterDashRemoval(program, target) {
     .rematerializeLegend();
 }
 
-const encodeStrokeDash = action(
+const encodeStrokeDash = /* @__PURE__ */ action(
   {
     op: "encodeStrokeDash",
     description: "Encode a nominal field as line stroke dash."

package/src/actions/encodings/text.js

@@ -25,7 +25,7 @@ function validateTextField(rows, field, format) {
   if (!found) throw new Error(`Unknown text field "${field}".`);
 }
 
-export const encodeText = action(
+export const encodeText = /* @__PURE__ */ action(
   {
     op: "encodeText",
     description: "Assign field, constant, or source semantic text content."

package/src/actions/errorBands/create.js

@@ -1,11 +1,13 @@
-import { action } from "../../core/action.js";
+import { editGraphicProperties } from "../primitives/graphicProperties.js";
+import { action, closedAction } from "../../core/action.js";
 import { isPlainObject } from "../../core/immutable.js";
-import {
-  validateKeys,
-  validateNonEmptyString,
-} from "../../core/validation.js";
+import { validateNonEmptyString } from "../../core/validation.js";
 import { DEFAULT_COLORS } from "../../theme/defaults.js";
 import { validateCurveInterpolation } from "../../grammar/curveCommands.js";
+import {
+  requestedStrokeDetails,
+  STROKE_STYLE_PROPERTIES
+} from "../../grammar/strokeStyle.js";
 import { createResolvedIntervalData } from "../data/intervalEdit.js";
 import { resolveIntervalComposite } from "../intervals/resolve.js";
 import { errorBandBoundaries, resolveBoundaryAppearance } from "./edit.js";
@@ -21,6 +23,7 @@ const OPTIONS = Object.freeze([
   "fill",
   "opacity",
   "curve",
+  ...STROKE_STYLE_PROPERTIES,
   "boundaries"
 ]);
 
@@ -77,7 +80,7 @@ function positionOptions({ target, field, fieldType, coordinate, scale, temporal
     ...(temporalUnit === undefined ? {} : { temporalUnit }) };
 }
 
-export const createErrorBandBoundary = action(
+export const createErrorBandBoundary = /* @__PURE__ */ action(
   {
     op: "createErrorBandBoundary",
     description: "Create one lower or upper error-band boundary line."
@@ -96,11 +99,24 @@ export const createErrorBandBoundary = action(
     strokeWidth,
     strokeDash,
     opacity,
-    curve
+    curve,
+    lineCap,
+    lineJoin,
+    miterLimit
   } = {}) {
     const vertical = orientation === "vertical";
     let next = this
-      .createLineMark({ id, data, strokeWidth, curve })
+      .createLineMark({
+        id,
+        data,
+        strokeWidth,
+        curve,
+        ...requestedStrokeDetails(Object.fromEntries([
+          ["lineCap", lineCap],
+          ["lineJoin", lineJoin],
+          ["miterLimit", miterLimit]
+        ].filter(([, value]) => value !== undefined)), "Error-band boundary")
+      })
       .encodeY(positionOptions({
         target: id,
         field: vertical ? bound : position.field,
@@ -120,14 +136,11 @@ export const createErrorBandBoundary = action(
     if (groupBy !== undefined) {
       next = next.encodeGroup({ target: id, field: groupBy });
     }
-    return next
-      .editGraphics({ target: id, property: "stroke", value: stroke })
-      .editGraphics({
-        target: id,
-        property: "strokeDash",
-        value: next.graphicSpec.objects[id].items.map(() => strokeDash)
-      })
-      .editGraphics({ target: id, property: "opacity", value: opacity });
+    return editGraphicProperties(next, id, {
+      stroke: stroke,
+      strokeDash: next.graphicSpec.objects[id].items.map(() => strokeDash),
+      opacity: opacity
+    });
   }
 );
 
@@ -153,13 +166,13 @@ function rangeArgs(resolved) {
   };
 }
 
-export const createErrorBand = action(
+export const createErrorBand = /* @__PURE__ */ closedAction(
   {
     op: "createErrorBand",
     description: "Create a statistical or explicit interval band."
-  },
+  }, OPTIONS,
   function (args = {}) {
-    validateKeys(args, OPTIONS, "createErrorBand");
+    const strokeDetails = requestedStrokeDetails(args, "createErrorBand");
     const resolved = resolveErrorBand(this, args);
     const curve = validateCurveInterpolation(args.curve ?? "linear");
     const boundaries = resolveBoundaries(args.boundaries, curve);
@@ -170,7 +183,8 @@ export const createErrorBand = action(
       data: resolved.dataId,
       ...(args.fill === undefined ? {} : { fill: args.fill }),
       ...(args.opacity === undefined ? {} : { opacity: args.opacity }),
-      ...(Object.hasOwn(args, "curve") ? { curve } : {})
+      ...(Object.hasOwn(args, "curve") ? { curve } : {}),
+      ...strokeDetails
     });
     const vertical = resolved.orientation === "vertical";
     next = next[vertical ? "encodeX" : "encodeY"](positionArgs(resolved));