ggaction 0.0.2 → 0.0.4

package/src/actions/marks/shared.js

@@ -4,13 +4,18 @@ import {
 } from "../../core/identifiers.js";
 import { findDataset } from "../../selectors/datasets.js";
 import { findLayer, hasLayer } from "../../selectors/layers.js";
+import { findSemanticScale } from "../../selectors/scales.js";
+import { resolveMarkPositionPolicy } from "../encodings/position/policies/index.js";
+import { getMarkMaterializationStep } from "../../materialization/marks/index.js";
+import {
+  POLAR_POSITION_CHANNELS,
+  CARTESIAN_POSITION_CHANNELS,
+  POSITION_CHANNELS
+} from "../../core/vocabulary.js";
+import { validateOptionObject } from "../../core/validation.js";
 
 export function validateMarkOptions(args, supported, operation) {
-  for (const key of Object.keys(args)) {
-    if (!supported.includes(key)) {
-      throw new Error(`Unknown ${operation} option "${key}".`);
-    }
-  }
+  validateOptionObject(args, supported, operation);
 }
 
 export function resolveMarkData(program, requested) {
@@ -60,30 +65,120 @@ export function assertMarkAvailable(program, id) {
   }
 }
 
-function inheritedPositionEncoding(encoding) {
-  if (encoding === undefined) return undefined;
-  return Object.fromEntries(
-    ["field", "datum", "fieldType", "scale", "title"]
+const POSITION_POLICY_PROPERTIES = Object.freeze(["aggregate", "bin", "stack"]);
+const POSITION_POLICY_SUBSETS = Object.freeze([
+  Object.freeze(["aggregate", "bin", "stack"]),
+  Object.freeze(["aggregate", "bin"]),
+  Object.freeze(["aggregate", "stack"]),
+  Object.freeze(["bin", "stack"]),
+  Object.freeze(["aggregate"]),
+  Object.freeze(["bin"]),
+  Object.freeze(["stack"]),
+  Object.freeze([])
+]);
+
+function inheritedPositionEncodings(encoding) {
+  if (encoding?.field === undefined) return undefined;
+  const base = Object.fromEntries(
+    ["field", "fieldType", "scale", "title"]
       .filter(property => Object.hasOwn(encoding, property))
       .map(property => [property, encoding[property]])
   );
+  const available = POSITION_POLICY_PROPERTIES.filter(property =>
+    Object.hasOwn(encoding, property)
+  );
+  const seen = new Set();
+  return POSITION_POLICY_SUBSETS.map(properties => ({
+    ...base,
+    ...Object.fromEntries(properties
+      .filter(property => available.includes(property))
+      .map(property => [property, encoding[property]]))
+  })).filter(candidate => {
+    const key = JSON.stringify(candidate);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function scaleSupportsEncoding(program, markType, channel, encoding) {
+  const scale = findSemanticScale(program, encoding.scale);
+  if (scale === undefined) return false;
+  const categorical = ["nominal", "ordinal"].includes(encoding.fieldType);
+  if (categorical) {
+    if (["bar", "rect"].includes(markType)) return scale.type === "band";
+    if (markType === "arc") return scale.type === "band";
+    return ["ordinal", "band", "point"].includes(scale.type);
+  }
+  if (encoding.fieldType === "temporal") return scale.type === "time";
+  return ["linear", "log", "pow", "sqrt", "symlog"].includes(scale.type);
 }
 
-function eligibleLayeredSource(layer, requestedData) {
+export function resolveCompatibleEncodings(program, source, markType) {
+  const dataset = findDataset(program, source.data);
+  if (dataset === undefined) return {};
+  const channels = POLAR_POSITION_CHANNELS.some(
+    channel => source.encoding?.[channel] !== undefined
+  )
+    ? POLAR_POSITION_CHANNELS
+    : CARTESIAN_POSITION_CHANNELS;
+  const pending = new Map(channels.map(channel => [
+    channel,
+    inheritedPositionEncodings(source.encoding?.[channel])
+  ]).filter(([, encodings]) => encodings !== undefined));
+  const candidate = {
+    id: "layered-inference",
+    data: source.data,
+    mark: { type: markType },
+    encoding: {}
+  };
+
+  for (let pass = 0; pass < 2; pass += 1) {
+    for (const [channel, encodings] of pending) {
+      for (const encoding of encodings) {
+        if (!scaleSupportsEncoding(program, markType, channel, encoding)) continue;
+        try {
+          const policy = resolveMarkPositionPolicy({
+            program,
+            layer: candidate,
+            dataset,
+            channel,
+            args: encoding,
+            field: encoding.field,
+            fieldType: encoding.fieldType
+          });
+          candidate.encoding[channel] = {
+            ...encoding,
+            ...Object.fromEntries(
+              Object.entries(policy).filter(([, value]) => value !== undefined)
+            )
+          };
+          pending.delete(channel);
+          break;
+        } catch {
+          // Try the next target-compatible policy subset. Another channel may
+          // also make a richer subset resolvable on the next pass.
+        }
+      }
+    }
+  }
+  return candidate.encoding;
+}
+
+function eligibleLayeredSource(program, layer, requestedData, markType) {
   if (layer?.data === undefined) return false;
   if (requestedData !== undefined && layer.data !== requestedData) return false;
-  return layer.encoding?.x !== undefined || layer.encoding?.y !== undefined;
+  return Object.keys(resolveCompatibleEncodings(program, layer, markType)).length > 0;
 }
 
-export function resolveLayeredMarkInheritance(program, requested = {}) {
-  const requestedData = Object.hasOwn(requested, "data")
-    ? validateUserId(requested.data, "Dataset id")
-    : undefined;
+export function resolveLayeredMarkInheritance(program, requested = {}, markType) {
+  if (Object.hasOwn(requested, "data")) return undefined;
+  const requestedData = program.context.currentData;
   const eligible = program.semanticSpec.layers.filter(layer =>
-    eligibleLayeredSource(layer, requestedData)
+    eligibleLayeredSource(program, layer, requestedData, markType)
   );
   const current = findLayer(program, program.context.currentMark);
-  const source = eligibleLayeredSource(current, requestedData)
+  const source = eligibleLayeredSource(program, current, requestedData, markType)
     ? current
     : eligible.length === 1
       ? eligible[0]
@@ -95,18 +190,54 @@ export function resolveLayeredMarkInheritance(program, requested = {}) {
     );
   }
   if (source === undefined) return undefined;
+  if (
+    markType === "bar" &&
+    (
+      source.encoding?.x?.bin !== undefined ||
+      source.encoding?.y?.bin !== undefined ||
+      (source.encoding?.x?.stack !== undefined && source.encoding.x.stack !== null) ||
+      (source.encoding?.y?.stack !== undefined && source.encoding.y.stack !== null) ||
+      source.encoding?.xOffset !== undefined ||
+      source.encoding?.yOffset !== undefined ||
+      source.encoding?.color?.layout !== undefined
+    )
+  ) {
+    return undefined;
+  }
 
   return {
     source: source.id,
     data: source.data,
     coordinate: source.coordinate,
-    encoding: Object.fromEntries(
-      ["x", "y"]
-        .map(channel => [
-          channel,
-          inheritedPositionEncoding(source.encoding?.[channel])
-        ])
-        .filter(([, encoding]) => encoding !== undefined)
-    )
+    encoding: resolveCompatibleEncodings(program, source, markType)
   };
 }
+
+export function applyLayeredMarkInheritance(program, id, inherited) {
+  let next = program;
+  if (inherited?.coordinate !== undefined) {
+    next = next.editSemantic({
+      property: `layer[${id}].coordinate`,
+      value: inherited.coordinate
+    });
+  }
+  for (const channel of POSITION_CHANNELS) {
+    for (const [property, value] of Object.entries(
+      inherited?.encoding[channel] ?? {}
+    )) {
+      next = next.editSemantic({
+        property: `layer[${id}].encoding.${channel}.${property}`,
+        value
+      });
+    }
+  }
+  return next;
+}
+
+export function materializeInheritedMark(program, id) {
+  const layer = findLayer(program, id);
+  const step = layer === undefined
+    ? undefined
+    : getMarkMaterializationStep(program, layer);
+  return step === undefined ? program : program[step.op](step.args);
+}

package/src/actions/marks/text/actions.js

@@ -0,0 +1,192 @@
+import { action } from "../../../core/action.js";
+import { validateUserId } from "../../../core/identifiers.js";
+import {
+  DEFAULT_TEXT_MARK,
+  normalizeTextMarkConfig
+} from "../../../grammar/text.js";
+import { canMaterializeText } from "../../../materialization/marks/index.js";
+import { resolveTextGraphicItems } from "../../../materialization/text.js";
+import { findLayer, resolveEligibleLayer } from "../../../selectors/layers.js";
+import {
+  applyLayeredMarkInheritance,
+  assertMarkAvailable,
+  resolveCompatibleEncodings,
+  resolveMarkData,
+  resolveMarkId,
+  validateMarkOptions
+} from "../shared.js";
+import { resolveMarkGraphicPlacement } from
+  "../../../materialization/graphicHierarchy.js";
+
+const STYLE_OPTIONS = Object.freeze([
+  "fill", "opacity", "fontSize", "fontFamily", "fontWeight",
+  "align", "baseline", "rotation", "dx", "dy"
+]);
+const CREATE_OPTIONS = Object.freeze(["id", "data", "text", ...STYLE_OPTIONS]);
+const EDIT_OPTIONS = Object.freeze(["target", ...STYLE_OPTIONS]);
+const REMATERIALIZE_OPTIONS = Object.freeze(["id"]);
+const SOURCE_TYPES = new Set(["point", "bar", "rule", "rect"]);
+
+function eligibleSource(program, layer, requestedData) {
+  if (
+    !SOURCE_TYPES.has(layer?.mark?.type) ||
+    layer.data === undefined ||
+    (requestedData !== undefined && layer.data !== requestedData)
+  ) return false;
+  const encodings = resolveCompatibleEncodings(program, layer, "text");
+  return encodings.x !== undefined && encodings.y !== undefined;
+}
+
+function resolveTextInheritance(program, args) {
+  if (Object.hasOwn(args, "data")) return undefined;
+  const requestedData = program.context.currentData;
+  const candidates = program.semanticSpec.layers.filter(layer =>
+    eligibleSource(program, layer, requestedData)
+  );
+  const current = findLayer(program, program.context.currentMark);
+  const source = eligibleSource(program, current, requestedData)
+    ? current
+    : candidates.length === 1
+      ? candidates[0]
+      : undefined;
+  if (source === undefined && candidates.length > 1) {
+    throw new Error(
+      "Text source inference is ambiguous; provide data and encode its position explicitly."
+    );
+  }
+  if (source === undefined) return undefined;
+  return {
+    source: source.id,
+    data: source.data,
+    coordinate: source.coordinate,
+    encoding: resolveCompatibleEncodings(program, source, "text")
+  };
+}
+
+function requireTextLayer(program, requested, operation) {
+  const id = requested === undefined ? undefined : validateUserId(requested, "Text mark id");
+  return resolveEligibleLayer(program, {
+    target: id,
+    predicate: layer => layer.mark?.type === "text",
+    label: `${operation} text mark`
+  });
+}
+
+const createTextMark = action(
+  {
+    op: "createTextMark",
+    description: "Create a semantic text annotation layer."
+  },
+  function (args = {}) {
+    validateMarkOptions(args, CREATE_OPTIONS, "createTextMark");
+    const id = resolveMarkId(this, args.id, {
+      defaultId: "text",
+      label: "Text mark id",
+      markType: "text",
+      operation: "createTextMark"
+    });
+    const inherited = resolveTextInheritance(this, args);
+    const { data } = resolveMarkData(this, {
+      ...args,
+      ...(args.data === undefined && inherited?.data !== undefined
+        ? { data: inherited.data }
+        : {})
+    });
+    assertMarkAvailable(this, id);
+
+    let next = this
+      .editSemantic({ property: `layer[${id}].mark.type`, value: "text" })
+      .editSemantic({ property: `layer[${id}].data`, value: data });
+    if (inherited?.source !== undefined) {
+      next = next.editSemantic({
+        property: `layer[${id}].source`,
+        value: inherited.source
+      });
+    }
+    next = applyLayeredMarkInheritance(next, id, inherited)
+      .createGraphics({
+        id,
+        type: "text",
+        length: 0,
+        ...resolveMarkGraphicPlacement(next, { data, markType: "text" })
+      })
+      ._withMarkConfig(id, { ...DEFAULT_TEXT_MARK, fillExplicit: false });
+
+    const style = Object.fromEntries(
+      STYLE_OPTIONS.filter(option => Object.hasOwn(args, option))
+        .map(option => [option, args[option]])
+    );
+    if (Object.keys(style).length > 0) {
+      next = next.editTextMark({ target: id, ...style });
+    }
+    return Object.hasOwn(args, "text")
+      ? next.encodeText({ target: id, value: args.text })
+      : next;
+  }
+);
+
+const rematerializeTextMark = action(
+  {
+    op: "rematerializeTextMark",
+    description: "Recompute concrete text content, anchors, and typography."
+  },
+  function (args = {}) {
+    validateMarkOptions(args, REMATERIALIZE_OPTIONS, "rematerializeTextMark");
+    const id = validateUserId(args.id, "Text mark id");
+    const layer = findLayer(this, id);
+    const graphic = this.graphicSpec.objects[id];
+    if (layer?.mark?.type !== "text") throw new Error(`Unknown text mark "${id}".`);
+    if (graphic?.type !== "text" || !Array.isArray(graphic.items)) {
+      throw new Error(`Text mark "${id}" requires text collection graphics.`);
+    }
+    if (!canMaterializeText(this, layer)) {
+      return graphic.items.length === 0
+        ? this
+        : this.editGraphics({ target: id, property: "length", value: 0 });
+    }
+    return this.editGraphics({
+      target: id,
+      property: "items",
+      value: resolveTextGraphicItems(
+        this,
+        layer,
+        this.markConfigs[id] ?? DEFAULT_TEXT_MARK
+      )
+    });
+  }
+);
+
+const editTextMark = action(
+  {
+    op: "editTextMark",
+    description: "Edit text typography, alignment, rotation, and offsets."
+  },
+  function (args = {}) {
+    validateMarkOptions(args, EDIT_OPTIONS, "editTextMark");
+    if (!STYLE_OPTIONS.some(option => Object.hasOwn(args, option))) {
+      throw new Error("editTextMark requires at least one editable property.");
+    }
+    const layer = requireTextLayer(this, args.target, "editTextMark");
+    const next = this._withMarkConfig(
+      layer.id,
+      {
+        ...normalizeTextMarkConfig(
+          args,
+          this.markConfigs[layer.id] ?? DEFAULT_TEXT_MARK
+        ),
+        fillExplicit: Object.hasOwn(args, "fill")
+          ? true
+          : this.markConfigs[layer.id]?.fillExplicit ?? false
+      }
+    );
+    return canMaterializeText(next, layer)
+      ? next.rematerializeTextMark({ id: layer.id })
+      : next;
+  }
+);
+
+export function registerTextMarkActions(ProgramClass) {
+  ProgramClass.prototype.createTextMark = createTextMark;
+  ProgramClass.prototype.editTextMark = editTextMark;
+  ProgramClass.prototype.rematerializeTextMark = rematerializeTextMark;
+}

package/src/actions/marks/text/index.js

@@ -0,0 +1 @@
+export { registerTextMarkActions } from "./actions.js";

package/src/actions/primitives/createGraphics.js

@@ -61,8 +61,11 @@ function resolvePlacement(graphicSpec, { id, type, parent, before, after }) {
     if (!isGraphicContainerType(parentGraphic.type)) {
       throw new Error(`Graphic parent "${parent}" must be a canvas or collection.`);
     }
-    if (type === "canvas") {
-      throw new Error("Canvas graphics cannot have a parent.");
+    if (
+      type === "canvas" &&
+      !graphicSpec.order.some(id => graphicSpec.objects[id]?.type === "canvas")
+    ) {
+      throw new Error("A nested Canvas requires an ordered root Canvas.");
     }
   }
   const anchor = before ?? after;
@@ -83,7 +86,7 @@ function resolvePlacement(graphicSpec, { id, type, parent, before, after }) {
   if (parent === undefined && before === "canvas") {
     throw new Error("createGraphics cannot place a graphic before the canvas.");
   }
-  if (type === "canvas") {
+  if (type === "canvas" && parent === undefined) {
     throw new Error("Canvas graphics do not accept before or after placement.");
   }
 }
@@ -99,7 +102,8 @@ function insertSibling(siblings, id, { before, after }) {
 const createGraphics = action(
   {
     op: "createGraphics",
-    description: "Create and optionally attach a concrete graphic."
+    description: "Create and optionally attach a concrete graphic.",
+    scope: "any"
   },
   function ({ id, type, length, parent, before, after } = {}) {
     if (typeof id !== "string" || !GRAPHIC_ID_PATTERN.test(id)) {
@@ -131,9 +135,12 @@ const createGraphics = action(
     }
     if (
       validatedType === "canvas" &&
-      Object.values(this.graphicSpec.objects).some(graphic => graphic.type === "canvas")
+      parent === undefined &&
+      this.graphicSpec.order.some(
+        objectId => this.graphicSpec.objects[objectId]?.type === "canvas"
+      )
     ) {
-      throw new Error("graphicSpec supports exactly one canvas.");
+      throw new Error("graphicSpec supports exactly one ordered canvas.");
     }
 
     const objects = {

package/src/actions/primitives/editGraphics.js

@@ -110,14 +110,17 @@ function editItems(owner, property, value, id) {
 }
 
 function removeGraphicTree(graphicSpec, id) {
-  if (graphicSpec.objects[id].type === "canvas") {
+  const parent = findGraphicParent(graphicSpec, id);
+  if (
+    graphicSpec.objects[id].type === "canvas" &&
+    parent?.kind !== "parent"
+  ) {
     throw new Error("The canvas root cannot be removed.");
   }
   const removedIds = new Set(collectGraphicSubtreeIds(graphicSpec, id));
   const objects = Object.fromEntries(
     Object.entries(graphicSpec.objects).filter(([objectId]) => !removedIds.has(objectId))
   );
-  const parent = findGraphicParent(graphicSpec, id);
   let order = graphicSpec.order;
   if (parent?.kind === "parent") {
     objects[parent.id] = freezeOwned({
@@ -131,7 +134,11 @@ function removeGraphicTree(graphicSpec, id) {
 }
 
 const editGraphics = action(
-  { op: "editGraphics", description: "Replace or remove concrete graphic state." },
+  {
+    op: "editGraphics",
+    description: "Replace or remove concrete graphic state.",
+    scope: "any"
+  },
   function ({ target, property, value, remove = false } = {}) {
     if (typeof target !== "string" || target.length === 0) {
       throw new TypeError("editGraphics requires a non-empty target string.");

package/src/actions/primitives/semantic.js

@@ -76,6 +76,13 @@ function removeEntity(spec, parsed) {
   const collection = spec[parsed.collection];
   const index = collection.findIndex(item => item.id === parsed.id);
   if (index === -1) return spec;
+  if (parsed.kind === "layer" && parsed.path.length === 0) {
+    const nextCollection = collection.filter((_, itemIndex) => itemIndex !== index);
+    return freezeOwned({
+      ...spec,
+      [parsed.collection]: freezeOwned(nextCollection)
+    });
+  }
   if (parsed.kind === "dataset" && parsed.path.length === 0) {
     const dataset = collection[index];
     if (dataset.source === undefined) {
@@ -115,7 +122,8 @@ function removeRootProperty(spec, root, path) {
 const editSemantic = action(
   {
     op: "editSemantic",
-    description: "Create, replace, or remove one semantic property."
+    description: "Create, replace, or remove one semantic property.",
+    scope: "any"
   },
   function ({ property, value, remove = false } = {}) {
     if (typeof remove !== "boolean") {
@@ -129,6 +137,13 @@ const editSemantic = action(
     }
 
     const parsed = parseSemanticPath(property, { allowContainer: remove });
+    if (this.compositionSpec !== undefined && !(
+      this.compositionSpec.type === "facet" && parsed.kind === "title"
+    )) {
+      throw new Error(
+        "editSemantic on a composition parent currently supports only facet title state."
+      );
+    }
     if (remove) {
       const semanticSpec = parsed.kind === "guide"
         ? removeRootProperty(this.semanticSpec, "guides", parsed.path)
@@ -140,10 +155,18 @@ const editSemantic = action(
         parsed.kind === "dataset" &&
         parsed.path.length === 0 &&
         this.context.currentData === parsed.id;
+      const clearsCurrentMark =
+        parsed.kind === "layer" &&
+        parsed.path.length === 0 &&
+        this.context.currentMark === parsed.id;
       return this._clone({
         semanticSpec,
-        ...(clearsCurrentData
-          ? { context: freezeOwned({ ...this.context, currentData: undefined }) }
+        ...(clearsCurrentData || clearsCurrentMark
+          ? { context: freezeOwned({
+              ...this.context,
+              ...(clearsCurrentData ? { currentData: undefined } : {}),
+              ...(clearsCurrentMark ? { currentMark: undefined } : {})
+            }) }
           : {})
       });
     }

package/src/actions/primitives/semanticValue.js

@@ -7,7 +7,7 @@ import {
   MARK_TYPES
 } from "../../core/vocabulary.js";
 import { validateAggregate } from "../../grammar/aggregate.js";
-import { findSemanticScale, hasDataset } from "../../selectors/index.js";
+import { findLayer, findSemanticScale, hasDataset } from "../../selectors/index.js";
 import { validateCoordinateType } from "../../grammar/coordinates.js";
 import {
   normalizeHistogramBin,
@@ -22,7 +22,7 @@ import {
   validateSemanticScaleDomain,
   validateSemanticScaleRange,
   validateSemanticScaleType
-} from "../../grammar/scales.js";
+} from "../../grammar/scales/index.js";
 
 function nonEmptyString(value, label) {
   if (typeof value !== "string" || value.length === 0) {
@@ -74,6 +74,21 @@ export function validateSemanticValue(program, parsed, value) {
   }
   if (parsed.kind === "layer") {
     const property = parsed.path.join(".");
+    if (property === "source") {
+      validateUserId(value, "Layer source id");
+      if (value === parsed.id) {
+        throw new Error("A layer cannot use itself as its source.");
+      }
+      const source = findLayer(program, value);
+      if (source === undefined) {
+        throw new Error(`Unknown source layer "${value}".`);
+      }
+      if (!["point", "bar", "rule", "rect"].includes(source.mark?.type)) {
+        throw new Error(
+          `Layer source "${value}" must be a point, bar, rule, or rect mark.`
+        );
+      }
+    }
     if (property.endsWith(".title")) {
       nonEmptyString(value, "Encoding title");
     }
@@ -173,8 +188,15 @@ export function validateSemanticValue(program, parsed, value) {
   if (parsed.kind === "guide" && parsed.id === "legend.series") {
     validateLegend(parsed.path.at(-1), value);
   }
-  if (parsed.kind === "guide" && parsed.id.startsWith("grid.")) {
-    validateUserId(value, `Grid ${parsed.path.at(-1)} id`);
+  if (parsed.kind === "guide" && (
+    parsed.id.startsWith("grid.") || parsed.id.startsWith("axis.")
+  )) {
+    const property = parsed.path.at(-1);
+    if (property === "title") nonEmptyString(value, "Axis title");
+    else {
+      const guideKind = parsed.id.startsWith("grid.") ? "Grid" : "Axis";
+      validateUserId(value, `${guideKind} ${property} id`);
+    }
   }
   if (parsed.kind === "title") {
     nonEmptyString(value, `Chart title ${parsed.path[0]}`);

package/src/actions/regression/components.js

@@ -7,8 +7,8 @@ import { resolveEligibleLayer } from "../../selectors/layers.js";
 import {
   REGRESSION_LOWER_FIELD,
   REGRESSION_UPPER_FIELD
-} from "../../grammar/regression.js";
-import { validateAreaCreateOutline } from "../marks/area.js";
+} from "../../grammar/regression/index.js";
+import { validateAreaCreateOutline } from "../marks/area/index.js";
 
 const BAND_OPTIONS = Object.freeze([
   "id", "data", "x", "lower", "upper", "groupBy", "coordinate", "xScale", "yScale",

package/src/actions/regression/create.js

@@ -1,6 +1,6 @@
 import { action } from "../../core/action.js";
 import { validateKeys } from "../../core/validation.js";
-import { normalizeRegressionParameters } from "../../grammar/regression.js";
+import { normalizeRegressionParameters } from "../../grammar/regression/index.js";
 import {
   findRegressionPoint,
   inferRegressionGroup,
@@ -87,7 +87,7 @@ export const createRegression = action(
         ...band
       });
     }
-    return next.createRegressionLine({
+    next = next.createRegressionLine({
       id: lineId,
       data: dataId,
       x,
@@ -98,5 +98,22 @@ export const createRegression = action(
       yScale,
       ...line
     });
+    return next._withMarkConfig(point.id, {
+      ...next.markConfigs[point.id],
+      regression: {
+        source: point.data,
+        x,
+        y,
+        groupBy,
+        coordinate,
+        xScale,
+        yScale,
+        colorScale,
+        dataId,
+        bandId: band === false ? undefined : bandId,
+        lineId,
+        parameters
+      }
+    });
   }
 );