ggaction 0.0.15 → 0.0.16

package/src/actions/data/intervalEdit.js

@@ -138,13 +138,7 @@ export function planIntervalRoleData(program, {
   };
 }
 
-export function planIntervalEdit(program, {
-  owner,
-  data,
-  consumers,
-  statistics,
-  operation
-}) {
+export function validateIntervalStatistics(statistics, operation) {
   if (!isPlainObject(statistics)) {
     throw new TypeError(`${operation} statistics must be a plain object.`);
   }
@@ -154,16 +148,9 @@ export function planIntervalEdit(program, {
       `${operation} statistics requires center, extent, method, or level.`
     );
   }
-  const previous = findDataset(program, data);
-  const transform = previous?.transform?.length === 1
-    ? previous.transform[0]
-    : undefined;
-  if (transform?.type !== "interval") {
-    throw new Error(
-      `${operation} statistics requires a statistical interval owner; ` +
-      "explicit interval fields cannot be converted by edit."
-    );
-  }
+}
+
+export function mergeIntervalStatistics(transform, statistics) {
   const center = Object.hasOwn(statistics, "center")
     ? statistics.center
     : transform.center;
@@ -181,7 +168,28 @@ export function planIntervalEdit(program, {
   } else if (extent === "ci" && transform.extent === "ci") {
     raw.level = transform.level;
   }
-  const parameters = normalizeIntervalParameters(raw);
+  return normalizeIntervalParameters(raw);
+}
+
+export function planIntervalEdit(program, {
+  owner,
+  data,
+  consumers,
+  statistics,
+  operation
+}) {
+  validateIntervalStatistics(statistics, operation);
+  const previous = findDataset(program, data);
+  const transform = previous?.transform?.length === 1
+    ? previous.transform[0]
+    : undefined;
+  if (transform?.type !== "interval") {
+    throw new Error(
+      `${operation} statistics requires a statistical interval owner; ` +
+      "explicit interval fields cannot be converted by edit."
+    );
+  }
+  const parameters = mergeIntervalStatistics(transform, statistics);
   const current = {
     center: transform.center,
     extent: transform.extent,

package/src/actions/data/normalize.js

@@ -9,14 +9,14 @@ const OPTIONS = Object.freeze([
   "variance", "zeroDenominator", "baseline", "sortBy"
 ]);
 
-export const materializeNormalizedData = derivedMaterializer(
+export const materializeNormalizedData = /* @__PURE__ */ derivedMaterializer(
   "materializeNormalizedData",
   "Materialize one immutable grouped normalization dataset.",
   "normalize",
   deriveNormalizedRows
 );
 
-export const createNormalizedData = derivedCreator(
+export const createNormalizedData = /* @__PURE__ */ derivedCreator(
   "createNormalizedData",
   "Create a row-preserving grouped normalization dataset.",
   OPTIONS,

package/src/actions/data/regression.js

@@ -1,6 +1,6 @@
-import { action } from "../../core/action.js";
+import { closedAction } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
-import { validateKeys } from "../../core/validation.js";
+
 import {
   deriveRegression,
   normalizeRegressionTransform
@@ -13,7 +13,7 @@ const OPTIONS = Object.freeze([
   "confidenceMethod", "level", "confidence", "interval"
 ]);
 
-export const materializeRegressionData = derivedMaterializer(
+export const materializeRegressionData = /* @__PURE__ */ derivedMaterializer(
   "materializeRegressionData",
   "Materialize one regression derived dataset.",
   "regression",
@@ -31,10 +31,9 @@ export const materializeRegressionData = derivedMaterializer(
     })
 );
 
-export const createRegressionData = action(
-  { op: "createRegressionData", description: "Create grouped regression values and optional interval bounds." },
+export const createRegressionData = /* @__PURE__ */ closedAction(
+  { op: "createRegressionData", description: "Create grouped regression values and optional interval bounds." }, OPTIONS,
   function (args = {}) {
-    validateKeys(args, OPTIONS, "createRegressionData");
     const id = validateUserId(args.id, "Regression dataset id");
     const requestedSource = validateUserId(
       args.source ?? this.context.currentData,

package/src/actions/data/revise.js

@@ -0,0 +1,48 @@
+import { closedAction } from "../../core/action.js";
+import { validateUserId } from "../../core/identifiers.js";
+
+import { requireDataset } from "../../selectors/datasets.js";
+import { requireLayer } from "../../selectors/layers.js";
+import { applyRevisionPlan, buildSourceRevisionPlan } from "./edit.js";
+import { resolveStoredSelection } from "../../materialization/selection/state.js";
+import { withGuideLayoutTransaction } from "../../materialization/guides/layout.js";
+
+let reviseFacet;
+
+export function registerFacetDataRevision(handler) {
+  reviseFacet = handler;
+}
+
+export function reviseUnitData(program, { source, id, values }) {
+  const plan = buildSourceRevisionPlan(program, source, id);
+  const created = program.createData({ id, values });
+  const next = withGuideLayoutTransaction(created, candidate =>
+    applyRevisionPlan(candidate, undefined, plan, { retain: new Set([source]) }));
+  for (const [selection, config] of Object.entries(next.materializationConfigs.selections ?? {})) {
+    if (plan.replacements.has(requireLayer(program, config.target).data)) {
+      resolveStoredSelection(next, selection);
+    }
+  }
+  return { program: next, plan };
+}
+
+export const reviseData = /* @__PURE__ */ closedAction(
+  { op: "reviseData", description: "Revise source data and its dependent chart.", scope: "any" }, ["source", "id", "values"],
+  function (args = {}) {
+    const source = validateUserId(args.source, "Source dataset id");
+    const id = validateUserId(args.id, "Revision dataset id");
+    if (this.compositionSpec !== undefined && this.compositionSpec.type !== "facet") {
+      throw new Error("Revise an explicit child, then use replaceCompositionChild for concat.");
+    }
+    const original = requireDataset(this, source);
+    if (original.source !== undefined || !Array.isArray(original.values)) {
+      throw new Error(`Source "${source}" must be a materialized original dataset.`);
+    }
+    const apply = this.compositionSpec === undefined
+      ? program => reviseUnitData(program, { source, id, values: args.values }).program
+      : program => reviseFacet(program, { source, id, values: args.values });
+    // The entire dependent materialization must succeed before returning a revision.
+    apply(this);
+    return apply(this);
+  }
+);

package/src/actions/data/revisionBindings.js

@@ -1,11 +1,7 @@
-import { isPlainObject } from "../../core/immutable.js";
+import { collectDataOwnerReferences, collectMarkConfigReferences } from "../../core/resourceReferences.js";
 import { datasetTransformOutputRoles } from "../../grammar/transforms.js";
 import { requireLayer } from "../../selectors/layers.js";
 
-const DATA_REFERENCE_KEYS = new Set([
-  "data", "dataset", "dataId", "filteredData", "originalData",
-  "outlierDataId", "profileId", "source", "summaryId"
-]);
 
 export function outputFieldChanges(previous, next) {
   const before = datasetTransformOutputRoles(previous);
@@ -107,39 +103,23 @@ export function rebindLayerOutputFields(program, id, changes) {
   return next;
 }
 
-function replaceReferences(value, replacements, key) {
-  if (Array.isArray(value)) {
-    let changed = false;
-    const items = value.map(item => {
-      const next = replaceReferences(item, replacements);
-      changed ||= next !== item;
-      return next;
-    });
-    return changed ? items : value;
-  }
-  if (!isPlainObject(value)) {
-    return DATA_REFERENCE_KEYS.has(key) && replacements.has(value)
-      ? replacements.get(value)
-      : value;
-  }
-  let changed = false;
-  const result = {};
-  for (const [childKey, child] of Object.entries(value)) {
-    const next = replaceReferences(child, replacements, childKey);
-    changed ||= next !== child;
-    result[childKey] = next;
-  }
-  return changed ? result : value;
+function replaceAtPath(value, [key, ...rest], replacement) {
+  const result = Array.isArray(value) ? [...value] : { ...value };
+  Object.defineProperty(result, key, { value: rest.length === 0
+    ? replacement : replaceAtPath(value[key], rest, replacement),
+    enumerable: true, configurable: true, writable: true });
+  return result;
 }
 
 export function rebindMaterializationDataReferences(program, replacements) {
   if (replacements.size === 0) return program;
   let next = program;
-  for (const [key, config] of Object.entries(program.materializationConfigs)) {
-    const replaced = replaceReferences(config, replacements, key);
-    if (replaced !== config) {
-      next = next._withMaterializationConfig([key], replaced);
-    }
+  for (const ref of [...collectMarkConfigReferences(program), ...collectDataOwnerReferences(program)]) {
+    if (ref.kind !== "data" || !replacements.has(ref.id)) continue;
+    const path = ref.ownerKind === "markConfig" ? ["marks", ref.ownerId, ...ref.path] : ref.path;
+    const [root, ...rest] = path;
+    next = next._withMaterializationConfig([root],
+      replaceAtPath(next.materializationConfigs[root], rest, replacements.get(ref.id)));
   }
   return next;
 }

package/src/actions/data/stack.js

@@ -8,14 +8,14 @@ const OPTIONS = Object.freeze([
   "id", "source", "category", "group", "value", "mode", "as"
 ]);
 
-export const materializeStackData = derivedMaterializer(
+export const materializeStackData = /* @__PURE__ */ derivedMaterializer(
   "materializeStackData",
   "Materialize one immutable category/series stack dataset.",
   "stack",
   deriveStackRows
 );
 
-export const createStackData = derivedCreator(
+export const createStackData = /* @__PURE__ */ derivedCreator(
   "createStackData",
   "Create reusable start, end, value, and share stack rows.",
   OPTIONS,

package/src/actions/data/summary.js

@@ -8,14 +8,14 @@ const OPTIONS = Object.freeze([
   "id", "source", "groupBy", "aggregates", "members", "weight"
 ]);
 
-export const materializeSummaryData = derivedMaterializer(
+export const materializeSummaryData = /* @__PURE__ */ derivedMaterializer(
   "materializeSummaryData",
   "Materialize one immutable grouped summary dataset.",
   "summary",
   deriveSummaryRows
 );
 
-export const createSummaryData = derivedCreator(
+export const createSummaryData = /* @__PURE__ */ derivedCreator(
   "createSummaryData",
   "Create reusable grouped aggregate values and provenance.",
   OPTIONS,

package/src/actions/data/timeUnit.js

@@ -9,14 +9,14 @@ const OPTIONS = Object.freeze([
   "weekStartsOn", "weekRule"
 ]);
 
-export const materializeTimeUnitData = derivedMaterializer(
+export const materializeTimeUnitData = /* @__PURE__ */ derivedMaterializer(
   "materializeTimeUnitData",
   "Materialize one immutable UTC time-unit dataset.",
   "timeUnit",
   deriveTimeUnitRows
 );
 
-export const createTimeUnitData = derivedCreator(
+export const createTimeUnitData = /* @__PURE__ */ derivedCreator(
   "createTimeUnitData",
   "Create immutable UTC calendar bucket values.",
   OPTIONS,

package/src/actions/data/window.js

@@ -8,14 +8,14 @@ const OPTIONS = Object.freeze([
   "id", "source", "partitionBy", "sortBy", "operations", "temporalUnit"
 ]);
 
-export const materializeWindowData = derivedMaterializer(
+export const materializeWindowData = /* @__PURE__ */ derivedMaterializer(
   "materializeWindowData",
   "Materialize one immutable window-derived dataset.",
   "window",
   deriveWindowRows
 );
 
-export const createWindowData = derivedCreator(
+export const createWindowData = /* @__PURE__ */ derivedCreator(
   "createWindowData",
   "Create immutable partitioned window values.",
   OPTIONS,

package/src/actions/encodings/angle.js

@@ -14,7 +14,7 @@ function rematerialize(program, layer, target) {
     : program.rematerializePointMark({ id: target });
 }
 
-export const encodeAngle = action(
+export const encodeAngle = /* @__PURE__ */ action(
   {
     op: "encodeAngle",
     description: "Assign direct clockwise degree rotation to point or Tick glyphs."

package/src/actions/encodings/appearance.js

@@ -79,7 +79,7 @@ function encodeAppearanceField(program, channel, args, operation) {
   return rematerializeEncoding(next, target, channel, scale.id, layer);
 }
 
-const encodeRadius = action(
+const encodeRadius = /* @__PURE__ */ action(
   {
     op: "encodeRadius",
     description: "Set a constant graphical radius on a point mark."
@@ -112,7 +112,7 @@ const encodeRadius = action(
   }
 );
 
-const encodePointRadius = action(
+const encodePointRadius = /* @__PURE__ */ action(
   {
     op: "encodePointRadius",
     description: "Set a constant graphical radius on a point mark."
@@ -146,7 +146,7 @@ const removePointRadius = /* @__PURE__ */ action(
   }
 );
 
-const encodeSize = action(
+const encodeSize = /* @__PURE__ */ action(
   {
     op: "encodeSize",
     description: "Encode a quantitative field as equal-area point size."
@@ -156,7 +156,7 @@ const encodeSize = action(
   }
 );
 
-const encodeShape = action(
+const encodeShape = /* @__PURE__ */ action(
   {
     op: "encodeShape",
     description: "Encode a nominal field as point shape."

package/src/actions/encodings/barWidth.js

@@ -10,7 +10,7 @@ import { normalizeBarWidth } from "../../grammar/bars/geometry.js";
 
 const OPTIONS = Object.freeze(["band", "pixels", "target"]);
 
-const encodeBarWidth = action(
+const encodeBarWidth = /* @__PURE__ */ action(
   {
     op: "encodeBarWidth",
     description: "Override aggregate or ranged bar width within its category slot."

package/src/actions/encodings/channels.js

@@ -299,7 +299,7 @@ function finalScaleIds(before, after, originalLayer, finalLayer, requests) {
   );
 }
 
-const rematerializeEncodingScales = action(
+const rematerializeEncodingScales = /* @__PURE__ */ action(
   {
     op: "rematerializeEncodingScales",
     description: "Resolve every scale affected by one atomic encoding assignment."
@@ -390,7 +390,7 @@ function applyEncodingAssignments(program, plan) {
   return instantiateProgram(plan.state, program.constructor);
 }
 
-export const encodeChannels = action(
+export const encodeChannels = /* @__PURE__ */ action(
   {
     op: "encodeChannels",
     description: "Atomically assign multiple encoding channels to one mark."

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

@@ -39,7 +39,7 @@ import {
 
 import { applyTemporalUnit } from "../temporal.js";
 
-const encodeColor = action(
+const encodeColor = /* @__PURE__ */ action(
   {
     op: "encodeColor",
     description: "Encode a field as graphical color."

package/src/actions/encodings/density.js

@@ -114,7 +114,7 @@ function applyDensityPosition(program, layerId, definition, groupBy) {
   return next;
 }
 
-const encodeDensity = action(
+const encodeDensity = /* @__PURE__ */ action(
   {
     op: "encodeDensity",
     description: "Derive and encode a baseline or categorical kernel-density area."
@@ -259,7 +259,7 @@ function assertGroupingSelectionCompatibility(program, layer, changesGroup) {
   }
 }
 
-const editDensity = action(
+const editDensity = /* @__PURE__ */ action(
   {
     op: "editDensity",
     description: "Revise one density transform and rematerialize its consumers."

package/src/actions/encodings/histogram.js

@@ -6,7 +6,7 @@ const HISTOGRAM_OPTIONS = Object.freeze([
   "stack", "xScale", "yScale", "weight"
 ]);
 
-const encodeHistogram = action(
+const encodeHistogram = /* @__PURE__ */ action(
   {
     op: "encodeHistogram",
     description: "Encode a binned count histogram with a configurable layout stack."

package/src/actions/encodings/horizon.js

@@ -1,6 +1,6 @@
-import { action } from "../../core/action.js";
+import { closedAction } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
-import { validateOptionObject } from "../../core/validation.js";
+
 import {
   deriveHorizon,
   validateHorizonTransform
@@ -109,13 +109,12 @@ function applyScaleDefinition(program, current, definition) {
   return patch === undefined ? program : program.editScale(patch);
 }
 
-const editHorizon = action(
+const editHorizon = /* @__PURE__ */ closedAction(
   {
     op: "editHorizon",
     description: "Revise one Horizon transform and rematerialize its consumers."
-  },
+  }, EDIT_OPTIONS,
   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.");
     }
@@ -278,13 +277,12 @@ const editHorizon = action(
   }
 );
 
-const encodeHorizon = action(
+const encodeHorizon = /* @__PURE__ */ closedAction(
   {
     op: "encodeHorizon",
     description: "Derive and encode one folded Horizon area."
-  },
+  }, OPTIONS,
   function (args = {}) {
-    validateOptionObject(args, OPTIONS, "encodeHorizon");
     const layer = findHorizonArea(this, args.target);
     validateUnusedHorizonEncodings(layer);
     const source = resolveHorizonSource(this, layer, args.source);

package/src/actions/encodings/offset.js

@@ -110,8 +110,8 @@ function createOffsetEncoding(channel) {
   );
 }
 
-const encodeXOffset = createOffsetEncoding("xOffset");
-const encodeYOffset = createOffsetEncoding("yOffset");
+const encodeXOffset = /* @__PURE__ */ createOffsetEncoding("xOffset");
+const encodeYOffset = /* @__PURE__ */ createOffsetEncoding("yOffset");
 
 export function registerOffsetEncodingAction(ProgramClass) {
   ProgramClass.prototype.encodeXOffset = encodeXOffset;

package/src/actions/encodings/parallel.js

@@ -1,5 +1,5 @@
-import { action } from "../../core/action.js";
-import { validateOptionObject } from "../../core/validation.js";
+import { closedAction } from "../../core/action.js";
+
 import {
   normalizeParallelDimensions,
   validateParallelKeyField,
@@ -19,13 +19,12 @@ const OPTIONS = Object.freeze([
   "target", "coordinate", "dimensions", "key", "missing"
 ]);
 
-export const encodeParallelCoordinates = action(
+export const encodeParallelCoordinates = /* @__PURE__ */ closedAction(
   {
     op: "encodeParallelCoordinates",
     description: "Atomically encode ordered Parallel-coordinate dimensions."
-  },
+  }, OPTIONS,
   function (args = {}) {
-    validateOptionObject(args, OPTIONS, "encodeParallelCoordinates");
     const { id: target, dataset, layer } = resolveTarget(
       this,
       args.target,

package/src/actions/encodings/pathOrder.js

@@ -1,9 +1,6 @@
-import { action } from "../../core/action.js";
+import { closedAction } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
-import {
-  validateNonEmptyString,
-  validateOptionObject
-} from "../../core/validation.js";
+import { validateNonEmptyString } from "../../core/validation.js";
 import { readQuantitativeField } from "../../grammar/scales/index.js";
 import { validatePathOrderDirection } from "../../grammar/pathOrder.js";
 import {
@@ -76,13 +73,12 @@ function rematerializePath(program, layer) {
     : program;
 }
 
-const encodePathOrder = action(
+const encodePathOrder = /* @__PURE__ */ closedAction(
   {
     op: "encodePathOrder",
     description: "Order vertices within each Cartesian path series."
-  },
+  }, ENCODE_OPTIONS,
   function (args = {}) {
-    validateOptionObject(args, ENCODE_OPTIONS, "encodePathOrder");
     const field = validateNonEmptyString(args.field, "Path order field");
     const fieldType = args.fieldType ?? "quantitative";
     if (fieldType !== "quantitative") {
@@ -102,13 +98,12 @@ const encodePathOrder = action(
   }
 );
 
-const removePathOrder = action(
+const removePathOrder = /* @__PURE__ */ closedAction(
   {
     op: "removePathOrder",
     description: "Remove explicit path order and restore automatic ordering."
-  },
+  }, REMOVE_OPTIONS,
   function (args = {}) {
-    validateOptionObject(args, REMOVE_OPTIONS, "removePathOrder");
     const layer = resolvePathOrderLayer(this, args.target, { active: true });
     const next = this.editSemantic({
       property: `layer[${layer.id}].encoding.pathOrder`,

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

@@ -141,7 +141,7 @@ function encodePosition(program, channel, args, operation) {
   return applyDetachedScaleRematerialization(next, [layer]);
 }
 
-const encodeX = action(
+const encodeX = /* @__PURE__ */ action(
   {
     op: "encodeX",
     description: "Encode a field as horizontal position."
@@ -151,7 +151,7 @@ const encodeX = action(
   }
 );
 
-const encodeY = action(
+const encodeY = /* @__PURE__ */ action(
   {
     op: "encodeY",
     description: "Encode a field as vertical position."
@@ -161,7 +161,7 @@ const encodeY = action(
   }
 );
 
-const encodeTheta = action(
+const encodeTheta = /* @__PURE__ */ action(
   {
     op: "encodeTheta",
     description: "Encode a field as Polar angle in clockwise degrees."
@@ -171,7 +171,7 @@ const encodeTheta = action(
   }
 );
 
-const encodeR = action(
+const encodeR = /* @__PURE__ */ action(
   {
     op: "encodeR",
     description: "Encode a quantitative field as Polar radius."

package/src/actions/encodings/ranged.js

@@ -159,7 +159,7 @@ function encodeSecondaryPosition(program, channel, args, operation, types) {
   return next;
 }
 
-const encodeX2 = action(
+const encodeX2 = /* @__PURE__ */ action(
   {
     op: "encodeX2",
     description: "Encode a secondary horizontal endpoint."
@@ -175,7 +175,7 @@ const encodeX2 = action(
   }
 );
 
-const encodeY2 = action(
+const encodeY2 = /* @__PURE__ */ action(
   {
     op: "encodeY2",
     description: "Encode a secondary vertical endpoint."
@@ -222,10 +222,10 @@ function rangeAction(channel) {
   });
 }
 
-const encodeYRange = rangeAction("y");
-const encodeXRange = rangeAction("x");
+const encodeYRange = /* @__PURE__ */ rangeAction("y");
+const encodeXRange = /* @__PURE__ */ rangeAction("x");
 
-const encodeGroup = action(
+const encodeGroup = /* @__PURE__ */ action(
   {
     op: "encodeGroup",
     description: "Split path geometry by nominal identity fields without a scale."

package/src/actions/encodings/remove.js

@@ -1,6 +1,6 @@
-import { action } from "../../core/action.js";
+import { closedAction } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
-import { validateOptionObject } from "../../core/validation.js";
+
 import {
   getPositionChannelDefinition,
   POSITION_ENCODING_CHANNELS
@@ -203,13 +203,12 @@ function rematerializeTarget(program, target) {
   return next;
 }
 
-export const removeEncoding = action(
+export const removeEncoding = /* @__PURE__ */ closedAction(
   {
     op: "removeEncoding",
     description: "Remove one semantic encoding and its owned materialized state."
-  },
+  }, OPTIONS,
   function (args = {}) {
-    validateOptionObject(args, OPTIONS, "removeEncoding");
     if (!REMOVABLE_CHANNELS.includes(args.channel)) {
       throw new Error(
         `Unsupported removable encoding channel "${args.channel}".`

package/src/actions/encodings/ruleAppearance.js

@@ -19,7 +19,7 @@ const WIDTH_OPTIONS = Object.freeze([
   "target", "value", "field", "fieldType", "scale"
 ]);
 
-const encodeStrokeWidth = action(
+const encodeStrokeWidth = /* @__PURE__ */ action(
   {
     op: "encodeStrokeWidth",
     description: "Assign constant or field-driven line or rule stroke width."

package/src/actions/encodings/seriesLayout.js

@@ -15,7 +15,7 @@ export function stackLayoutMode(stack) {
   return stack === "normalize" ? "fill" : stack === "center" ? "center" : stack === null ? "overlay" : "stack";
 }
 
-export const layoutSeries = action({ op: "layoutSeries", description: "Assign series placement independently of color." }, function (args = {}) {
+export const layoutSeries = /* @__PURE__ */ action({ op: "layoutSeries", description: "Assign series placement independently of color." }, function (args = {}) {
   validateOptions(args, ["target", "mode"], "layoutSeries");
   const mode = validateColorLayout(args.mode);
   const { id: target, layer, dataset } = resolveTarget(this, args.target, ["bar", "area"], "series mark");

package/src/actions/encodings/stroke.js

@@ -101,7 +101,7 @@ function validateStrokeField(dataset, layer, args, scale, temporalUnit) {
   }
 }
 
-export const encodeStroke = action(
+export const encodeStroke = /* @__PURE__ */ action(
   {
     op: "encodeStroke",
     description: "Assign constant or field-driven graphical stroke color."