ggaction 0.0.7 → 0.0.9

package/src/actions/marks/tick/actions.js

@@ -0,0 +1,225 @@
+import { action } from "../../../core/action.js";
+import { validateUserId } from "../../../core/identifiers.js";
+import {
+  validateNonEmptyString,
+  validateNonNegativeFinite,
+  validatePositiveFinite,
+  validateUnitInterval
+} from "../../../core/validation.js";
+import {
+  centeredDirectionalSegment,
+  resolveDirectionValues
+} from "../../../grammar/direction.js";
+import { resolveMarkGraphicPlacement } from
+  "../../../materialization/graphicHierarchy.js";
+import { resolveRowEncodingValues } from
+  "../../../materialization/rowEncoding.js";
+import { findDataset } from "../../../selectors/datasets.js";
+import { findLayer } from "../../../selectors/layers.js";
+import { DEFAULT_COLORS } from "../../../theme/defaults.js";
+import { rematerializeHighlightBaseline } from "../lifecycle.js";
+import {
+  applyLayeredMarkInheritance,
+  assertMarkAvailable,
+  materializeInheritedMark,
+  resolveLayeredMarkInheritance,
+  resolveMarkData,
+  resolveMarkId,
+  validateMarkOptions
+} from "../shared.js";
+
+const CREATE_OPTIONS = Object.freeze([
+  "id", "data", "length", "stroke", "strokeWidth", "opacity"
+]);
+const EDIT_OPTIONS = Object.freeze([
+  "target", "length", "stroke", "strokeWidth", "opacity"
+]);
+const REMATERIALIZE_OPTIONS = Object.freeze(["id"]);
+
+export const DEFAULT_TICK_CONFIG = Object.freeze({
+  length: 14,
+  stroke: DEFAULT_COLORS.mark,
+  strokeWidth: 2,
+  opacity: 1
+});
+
+function resolveTick(program, requested, operation) {
+  const candidates = program.semanticSpec.layers.filter(
+    layer => layer.mark?.type === "tick"
+  );
+  if (requested !== undefined) {
+    const id = validateUserId(requested, "Tick mark id");
+    const layer = findLayer(program, id);
+    if (layer?.mark?.type !== "tick") {
+      throw new Error(`Unknown tick mark "${id}".`);
+    }
+    return layer;
+  }
+  const current = findLayer(program, program.context.currentMark);
+  if (current?.mark?.type === "tick") return current;
+  if (candidates.length === 1) return candidates[0];
+  if (candidates.length === 0) {
+    throw new Error(`${operation} requires an existing tick mark.`);
+  }
+  throw new Error(`${operation} target is ambiguous; provide target.`);
+}
+
+function validateTickConfig(args, current = DEFAULT_TICK_CONFIG) {
+  return {
+    length: Object.hasOwn(args, "length")
+      ? validatePositiveFinite(args.length, "Tick length")
+      : current.length,
+    stroke: Object.hasOwn(args, "stroke")
+      ? validateNonEmptyString(args.stroke, "Tick stroke")
+      : current.stroke,
+    strokeWidth: Object.hasOwn(args, "strokeWidth")
+      ? validateNonNegativeFinite(args.strokeWidth, "Tick strokeWidth")
+      : current.strokeWidth,
+    opacity: Object.hasOwn(args, "opacity")
+      ? validateUnitInterval(args.opacity, "Tick opacity")
+      : current.opacity
+  };
+}
+
+export const createTickMark = action(
+  {
+    op: "createTickMark",
+    description: "Create a centered fixed-length Tick mark."
+  },
+  function (args = {}) {
+    validateMarkOptions(args, CREATE_OPTIONS, "createTickMark");
+    const id = resolveMarkId(this, args.id, {
+      defaultId: "tick",
+      label: "Tick mark id",
+      markType: "tick",
+      operation: "createTickMark"
+    });
+    const inherited = resolveLayeredMarkInheritance(this, args, "tick");
+    const { data } = resolveMarkData(this, {
+      ...args,
+      ...(args.data === undefined && this.context.currentData === undefined &&
+        inherited?.data !== undefined ? { data: inherited.data } : {})
+    });
+    const config = validateTickConfig(args);
+    assertMarkAvailable(this, id);
+
+    let created = this
+      .editSemantic({ property: `layer[${id}].mark.type`, value: "tick" })
+      .editSemantic({ property: `layer[${id}].data`, value: data });
+    created = applyLayeredMarkInheritance(created, id, inherited)
+      .createGraphics({
+        id,
+        type: "line",
+        length: 0,
+        ...resolveMarkGraphicPlacement(created, { data, markType: "tick" })
+      })
+      ._withMarkConfig(id, DEFAULT_TICK_CONFIG);
+    const materialized = materializeInheritedMark(created, id);
+    const appearance = Object.fromEntries(
+      ["length", "stroke", "strokeWidth", "opacity"]
+        .filter(property => Object.hasOwn(args, property))
+        .map(property => [property, config[property]])
+    );
+    return Object.keys(appearance).length === 0
+      ? materialized
+      : materialized.editTickMark({ target: id, ...appearance });
+  }
+);
+
+export const editTickMark = action(
+  {
+    op: "editTickMark",
+    description: "Edit Tick length and constant line appearance."
+  },
+  function (args = {}) {
+    validateMarkOptions(args, EDIT_OPTIONS, "editTickMark");
+    const editable = ["length", "stroke", "strokeWidth", "opacity"];
+    if (!editable.some(property => Object.hasOwn(args, property))) {
+      throw new Error(
+        "editTickMark requires length, stroke, strokeWidth, or opacity."
+      );
+    }
+    const layer = resolveTick(this, args.target, "editTickMark");
+    const config = validateTickConfig(args, {
+      ...DEFAULT_TICK_CONFIG,
+      ...this.markConfigs[layer.id]
+    });
+    return this
+      ._withMarkConfig(layer.id, config)
+      .rematerializeTickMark({ id: layer.id });
+  }
+);
+
+export const rematerializeTickMark = action(
+  {
+    op: "rematerializeTickMark",
+    description: "Recompute concrete centered Tick endpoints and appearance."
+  },
+  function (args = {}) {
+    validateMarkOptions(
+      args,
+      REMATERIALIZE_OPTIONS,
+      "rematerializeTickMark"
+    );
+    const id = validateUserId(args.id, "Tick mark id");
+    const highlighted = rematerializeHighlightBaseline(this, {
+      target: id,
+      operation: "rematerializeTickMark",
+      resetProperty: "length",
+      resetValue: 0
+    });
+    if (highlighted !== undefined) return highlighted;
+    const layer = findLayer(this, id);
+    if (layer?.mark?.type !== "tick") {
+      throw new Error(`Unknown tick mark "${id}".`);
+    }
+    const graphic = this.graphicSpec.objects[id];
+    if (graphic?.type !== "line" || !Array.isArray(graphic.items)) {
+      throw new Error(`Tick mark "${id}" requires line collection graphics.`);
+    }
+    const dataset = findDataset(this, layer.data);
+    if (dataset === undefined) {
+      throw new Error(`Tick mark "${id}" requires an existing dataset.`);
+    }
+    if (
+      layer.encoding?.x?.scale === undefined ||
+      layer.encoding?.y?.scale === undefined
+    ) {
+      return graphic.items.length === 0
+        ? this
+        : this.editGraphics({ target: id, property: "length", value: 0 });
+    }
+
+    const x = resolveRowEncodingValues(this, layer, dataset, "x");
+    const y = resolveRowEncodingValues(this, layer, dataset, "y");
+    const angles = resolveDirectionValues(dataset.values, layer.encoding?.angle);
+    const config = validateTickConfig({}, {
+      ...DEFAULT_TICK_CONFIG,
+      ...this.markConfigs[id]
+    });
+    const segments = dataset.values.map((_, index) =>
+      centeredDirectionalSegment({
+        x: x[index],
+        y: y[index],
+        degrees: angles?.[index] ?? 0,
+        length: config.length
+      })
+    );
+
+    return this
+      .editGraphics({ target: id, property: "length", value: segments.length })
+      .editGraphics({ target: id, property: "x1", value: segments.map(item => item.x1) })
+      .editGraphics({ target: id, property: "y1", value: segments.map(item => item.y1) })
+      .editGraphics({ target: id, property: "x2", value: segments.map(item => item.x2) })
+      .editGraphics({ target: id, property: "y2", value: segments.map(item => item.y2) })
+      .editGraphics({ target: id, property: "stroke", value: config.stroke })
+      .editGraphics({ target: id, property: "strokeWidth", value: config.strokeWidth })
+      .editGraphics({ target: id, property: "opacity", value: config.opacity });
+  }
+);
+
+export function registerTickMarkActions(ProgramClass) {
+  ProgramClass.prototype.createTickMark = createTickMark;
+  ProgramClass.prototype.editTickMark = editTickMark;
+  ProgramClass.prototype.rematerializeTickMark = rematerializeTickMark;
+}

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

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

package/src/actions/primitives/index.js

@@ -1,6 +1,33 @@
+import { isPlainObject } from "../../core/immutable.js";
+import { validateBin2DTransform } from "../../grammar/bin2d.js";
 import { registerCreateGraphicsAction } from "./createGraphics.js";
 import { registerEditGraphicsAction } from "./editGraphics.js";
 import { registerSemanticPrimitiveAction } from "./semantic.js";
+import { createSemanticPrimitiveAction } from "./semanticAction.js";
+import { createSemanticValueValidator } from "./semanticValidation/index.js";
+
+function validateBasicDatasetTransforms(value) {
+  if (!Array.isArray(value) || value.length !== 1 || !isPlainObject(value[0])) {
+    throw new TypeError(
+      "Dataset transform must contain exactly one plain object."
+    );
+  }
+  if (value[0].type !== "bin2d") {
+    throw new Error(`Unsupported dataset transform "${value[0].type}".`);
+  }
+  validateBin2DTransform(value[0]);
+}
+
+export function registerBasicPrimitiveActions(ProgramClass) {
+  const validateBasicSemanticValue = createSemanticValueValidator({
+    validateDatasetTransforms: validateBasicDatasetTransforms,
+    sourceMarkTypes: ["point", "bar", "rect"]
+  });
+  ProgramClass.prototype.editSemantic =
+    createSemanticPrimitiveAction(validateBasicSemanticValue);
+  registerCreateGraphicsAction(ProgramClass);
+  registerEditGraphicsAction(ProgramClass);
+}
 
 export function registerPrimitiveActions(ProgramClass) {
   registerSemanticPrimitiveAction(ProgramClass);

package/src/actions/primitives/semantic.js

@@ -1,191 +1,28 @@
-import { action } from "../../core/action.js";
+import { createSemanticPrimitiveAction } from "./semanticAction.js";
+import { validateDatasetTransforms } from "../../grammar/transforms.js";
 import {
-  cloneAndFreeze,
-  freezeOwned,
-  isPlainObject,
-  removeOwnedPath
-} from "../../core/immutable.js";
-import { parseSemanticPath } from "../../grammar/schemas/semanticPath.js";
-import { validateSemanticValue } from "./semanticValue.js";
-
-const CONTEXT_KEYS = Object.freeze({
-  dataset: "currentData",
-  layer: "currentMark",
-  scale: "currentScale",
-  coordinate: "currentCoordinate",
-  guide: "currentGuide"
-});
-
-function setNestedProperty(source, path, value) {
-  const [key, ...rest] = path;
-
-  if (rest.length === 0) {
-    return freezeOwned({ ...source, [key]: cloneAndFreeze(value) });
-  }
-
-  const child = isPlainObject(source[key]) ? source[key] : {};
-  return freezeOwned({
-    ...source,
-    [key]: setNestedProperty(child, rest, value)
-  });
-}
-
-function updateEntity(spec, parsed, value) {
-  const collection = spec[parsed.collection];
-  const index = collection.findIndex(item => item.id === parsed.id);
-
-  if (
-    parsed.kind === "dataset" &&
-    index !== -1 &&
-    Object.hasOwn(collection[index], "values")
-  ) {
-    throw new Error(`Dataset "${parsed.id}" is immutable after creation.`);
-  }
-
-  const current = index === -1 ? { id: parsed.id } : collection[index];
-  const updated = setNestedProperty(current, parsed.path, value);
-  const nextCollection = [...collection];
-
-  if (index === -1) {
-    nextCollection.push(updated);
-  } else {
-    nextCollection[index] = updated;
-  }
-
-  return freezeOwned({
-    ...spec,
-    [parsed.collection]: freezeOwned(nextCollection)
-  });
-}
-
-function updateGuides(spec, parsed, value) {
-  return freezeOwned({
-    ...spec,
-    guides: setNestedProperty(spec.guides, parsed.path, value)
-  });
-}
-
-function updateTitle(spec, parsed, value) {
-  return freezeOwned({
-    ...spec,
-    title: setNestedProperty(spec.title, parsed.path, value)
-  });
-}
-
-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) {
-      throw new Error(`Source dataset "${parsed.id}" is immutable after creation.`);
-    }
-    const referenced = spec.layers.some(layer => layer.data === parsed.id) ||
-      spec.datasets.some(candidate => candidate.source === parsed.id);
-    if (referenced) {
-      throw new Error(`Derived dataset "${parsed.id}" is still referenced.`);
-    }
-    const nextCollection = collection.filter((_, itemIndex) => itemIndex !== index);
-    return freezeOwned({
-      ...spec,
-      [parsed.collection]: freezeOwned(nextCollection)
-    });
+  validateParallelDimensions,
+  validateParallelKeyField,
+  validateParallelMissingPolicy
+} from "../../grammar/parallelCoordinates.js";
+import { createSemanticValueValidator } from "./semanticValidation/index.js";
+
+function validateParallel(property, value) {
+  if (property === "encoding.parallel.dimensions") {
+    validateParallelDimensions(value, { normalized: true });
+  } else if (property === "encoding.parallel.key") {
+    validateParallelKeyField(value);
+  } else if (property === "encoding.parallel.missing") {
+    validateParallelMissingPolicy(value);
   }
-  if (parsed.kind === "dataset") {
-    throw new Error(`Dataset "${parsed.id}" is immutable after creation.`);
-  }
-  const removed = removeOwnedPath(collection[index], parsed.path);
-  if (!removed.removed) return spec;
-  const nextCollection = [...collection];
-  nextCollection[index] = removed.value;
-  return freezeOwned({
-    ...spec,
-    [parsed.collection]: freezeOwned(nextCollection)
-  });
 }
 
-function removeRootProperty(spec, root, path) {
-  const removed = removeOwnedPath(spec[root], path);
-  return removed.removed
-    ? freezeOwned({ ...spec, [root]: removed.value })
-    : spec;
-}
-
-const editSemantic = action(
-  {
-    op: "editSemantic",
-    description: "Create, replace, or remove one semantic property.",
-    scope: "any"
-  },
-  function ({ property, value, remove = false } = {}) {
-    if (typeof remove !== "boolean") {
-      throw new TypeError("editSemantic remove must be a boolean.");
-    }
-    if (remove && value !== undefined) {
-      throw new Error("editSemantic cannot combine value and remove.");
-    }
-    if (!remove && value === undefined) {
-      throw new TypeError("editSemantic requires a value.");
-    }
-
-    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)
-        : parsed.kind === "title"
-          ? removeRootProperty(this.semanticSpec, "title", parsed.path)
-          : removeEntity(this.semanticSpec, parsed);
-      if (semanticSpec === this.semanticSpec) return this;
-      const clearsCurrentData =
-        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 || clearsCurrentMark
-          ? { context: freezeOwned({
-              ...this.context,
-              ...(clearsCurrentData ? { currentData: undefined } : {}),
-              ...(clearsCurrentMark ? { currentMark: undefined } : {})
-            }) }
-          : {})
-      });
-    }
-    validateSemanticValue(this, parsed, value);
-
-    const semanticSpec = parsed.kind === "guide"
-      ? updateGuides(this.semanticSpec, parsed, value)
-      : parsed.kind === "title"
-        ? updateTitle(this.semanticSpec, parsed, value)
-        : updateEntity(this.semanticSpec, parsed, value);
-    const contextKey = CONTEXT_KEYS[parsed.kind];
-    const context = contextKey === undefined
-      ? this.context
-      : freezeOwned({ ...this.context, [contextKey]: parsed.id });
-
-    return this._clone({ semanticSpec, context });
-  }
-);
-
 export function registerSemanticPrimitiveAction(ProgramClass) {
-  ProgramClass.prototype.editSemantic = editSemantic;
+  const validateSemanticValue = createSemanticValueValidator({
+    validateDatasetTransforms,
+    validateParallel,
+    sourceMarkTypes: ["point", "bar", "rule", "rect"]
+  });
+  ProgramClass.prototype.editSemantic =
+    createSemanticPrimitiveAction(validateSemanticValue);
 }

package/src/actions/primitives/semanticAction.js

@@ -0,0 +1,188 @@
+import { action } from "../../core/action.js";
+import {
+  cloneAndFreeze,
+  freezeOwned,
+  isPlainObject,
+  removeOwnedPath
+} from "../../core/immutable.js";
+import { parseSemanticPath } from "../../grammar/schemas/semanticPath.js";
+
+const CONTEXT_KEYS = Object.freeze({
+  dataset: "currentData",
+  layer: "currentMark",
+  scale: "currentScale",
+  coordinate: "currentCoordinate",
+  guide: "currentGuide"
+});
+
+function setNestedProperty(source, path, value) {
+  const [key, ...rest] = path;
+
+  if (rest.length === 0) {
+    return freezeOwned({ ...source, [key]: cloneAndFreeze(value) });
+  }
+
+  const child = isPlainObject(source[key]) ? source[key] : {};
+  return freezeOwned({
+    ...source,
+    [key]: setNestedProperty(child, rest, value)
+  });
+}
+
+function updateEntity(spec, parsed, value) {
+  const collection = spec[parsed.collection];
+  const index = collection.findIndex(item => item.id === parsed.id);
+
+  if (
+    parsed.kind === "dataset" &&
+    index !== -1 &&
+    Object.hasOwn(collection[index], "values")
+  ) {
+    throw new Error(`Dataset "${parsed.id}" is immutable after creation.`);
+  }
+
+  const current = index === -1 ? { id: parsed.id } : collection[index];
+  const updated = setNestedProperty(current, parsed.path, value);
+  const nextCollection = [...collection];
+
+  if (index === -1) {
+    nextCollection.push(updated);
+  } else {
+    nextCollection[index] = updated;
+  }
+
+  return freezeOwned({
+    ...spec,
+    [parsed.collection]: freezeOwned(nextCollection)
+  });
+}
+
+function updateGuides(spec, parsed, value) {
+  return freezeOwned({
+    ...spec,
+    guides: setNestedProperty(spec.guides, parsed.path, value)
+  });
+}
+
+function updateTitle(spec, parsed, value) {
+  return freezeOwned({
+    ...spec,
+    title: setNestedProperty(spec.title, parsed.path, value)
+  });
+}
+
+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) {
+      throw new Error(`Source dataset "${parsed.id}" is immutable after creation.`);
+    }
+    const referenced = spec.layers.some(layer => layer.data === parsed.id) ||
+      spec.datasets.some(candidate => candidate.source === parsed.id);
+    if (referenced) {
+      throw new Error(`Derived dataset "${parsed.id}" is still referenced.`);
+    }
+    const nextCollection = collection.filter((_, itemIndex) => itemIndex !== index);
+    return freezeOwned({
+      ...spec,
+      [parsed.collection]: freezeOwned(nextCollection)
+    });
+  }
+  if (parsed.kind === "dataset") {
+    throw new Error(`Dataset "${parsed.id}" is immutable after creation.`);
+  }
+  const removed = removeOwnedPath(collection[index], parsed.path);
+  if (!removed.removed) return spec;
+  const nextCollection = [...collection];
+  nextCollection[index] = removed.value;
+  return freezeOwned({
+    ...spec,
+    [parsed.collection]: freezeOwned(nextCollection)
+  });
+}
+
+function removeRootProperty(spec, root, path) {
+  const removed = removeOwnedPath(spec[root], path);
+  return removed.removed
+    ? freezeOwned({ ...spec, [root]: removed.value })
+    : spec;
+}
+
+export function createSemanticPrimitiveAction(validateSemanticValue) {
+  return action(
+    {
+      op: "editSemantic",
+      description: "Create, replace, or remove one semantic property.",
+      scope: "any"
+    },
+    function ({ property, value, remove = false } = {}) {
+      if (typeof remove !== "boolean") {
+        throw new TypeError("editSemantic remove must be a boolean.");
+      }
+      if (remove && value !== undefined) {
+        throw new Error("editSemantic cannot combine value and remove.");
+      }
+      if (!remove && value === undefined) {
+        throw new TypeError("editSemantic requires a value.");
+      }
+
+      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)
+          : parsed.kind === "title"
+            ? removeRootProperty(this.semanticSpec, "title", parsed.path)
+            : removeEntity(this.semanticSpec, parsed);
+        if (semanticSpec === this.semanticSpec) return this;
+        const clearsCurrentData =
+          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 || clearsCurrentMark
+            ? { context: freezeOwned({
+                ...this.context,
+                ...(clearsCurrentData ? { currentData: undefined } : {}),
+                ...(clearsCurrentMark ? { currentMark: undefined } : {})
+              }) }
+            : {})
+        });
+      }
+      validateSemanticValue(this, parsed, value);
+
+      const semanticSpec = parsed.kind === "guide"
+        ? updateGuides(this.semanticSpec, parsed, value)
+        : parsed.kind === "title"
+          ? updateTitle(this.semanticSpec, parsed, value)
+          : updateEntity(this.semanticSpec, parsed, value);
+      const contextKey = CONTEXT_KEYS[parsed.kind];
+      const context = contextKey === undefined
+        ? this.context
+        : freezeOwned({ ...this.context, [contextKey]: parsed.id });
+
+      return this._clone({ semanticSpec, context });
+    }
+  );
+}

package/src/actions/primitives/semanticValidation/dataset.js

@@ -1,9 +1,13 @@
 import { validateUserId } from "../../../core/identifiers.js";
 import { isPlainObject } from "../../../core/immutable.js";
-import { validateDatasetTransforms } from "../../../grammar/transforms.js";
 import { hasDataset } from "../../../selectors/datasets.js";
 
-export function validateDatasetSemanticValue(program, parsed, value) {
+export function validateDatasetSemanticValue(
+  program,
+  parsed,
+  value,
+  validateTransforms
+) {
   const property = parsed.path[0];
   if (property === "values") {
     if (!Array.isArray(value) || !value.every(isPlainObject)) {
@@ -18,5 +22,5 @@ export function validateDatasetSemanticValue(program, parsed, value) {
     }
     return;
   }
-  if (property === "transform") validateDatasetTransforms(value);
+  if (property === "transform") validateTransforms(value);
 }