ggaction 0.0.9 → 0.0.11

package/src/actions/errorBars/create.js

@@ -2,8 +2,10 @@ import { action } from "../../core/action.js";
 import { validateKeys } from "../../core/validation.js";
 import { findLayer } from "../../selectors/layers.js";
 import { DEFAULT_COLORS } from "../../theme/defaults.js";
-import { resolveErrorBarAppearance } from "./options.js";
-import { resolveErrorBar } from "./resolve.js";
+import { createResolvedIntervalData, ownOptions } from
+  "../data/intervalEdit.js";
+import { resolveIntervalComposite } from "../intervals/resolve.js";
+import { errorBarCaps, resolveErrorBarAppearance } from "./edit.js";
 
 const OPTIONS = Object.freeze([
   "id",
@@ -21,13 +23,34 @@ const OPTIONS = Object.freeze([
   "opacity"
 ]);
 
+const ERROR_BAR_POLICY = Object.freeze({
+  operation: "createErrorBar",
+  resourceLabel: "error-bar",
+  defaultId: "errorBar",
+  ownerLabel: "Error-bar id",
+  positionTypes: Object.freeze(["nominal", "ordinal", "temporal"]),
+  defaultPositionType: "nominal",
+  defaultIntervalChannel: "y",
+  scaleDefaults: () => ({}),
+  intervalScaleDefaults: Object.freeze({ nice: true, zero: false }),
+  allowExplicitGrouping: false,
+  ambiguousMessage:
+    "createErrorBar requires one quantitative interval axis and one nominal, ordinal, or temporal position axis."
+});
+
+function resolveErrorBar(program, args) {
+  const resolved = resolveIntervalComposite(program, args, ERROR_BAR_POLICY);
+  return {
+    ...resolved,
+    lowerCapId: `${resolved.id}LowerCap`,
+    upperCapId: `${resolved.id}UpperCap`
+  };
+}
+
 function resolveAppearance(args) {
-  const appearanceArgs = Object.fromEntries(
-    ["caps", "capSize", "stroke", "strokeWidth", "strokeDash", "opacity"]
-      .filter(key => Object.hasOwn(args, key))
-      .map(key => [key, args[key]])
-  );
-  return resolveErrorBarAppearance(appearanceArgs, {
+  return resolveErrorBarAppearance(ownOptions(args, [
+    "caps", "capSize", "stroke", "strokeWidth", "strokeDash", "opacity"
+  ]), {
     defaults: {
       caps: true,
       capSize: 8,
@@ -40,6 +63,51 @@ function resolveAppearance(args) {
   });
 }
 
+export const createErrorBarCap = action(
+  {
+    op: "createErrorBarCap",
+    description: "Create one fixed-pixel error-bar cap."
+  },
+  function (args = {}) {
+    validateKeys(args, [
+      "id", "data", "orientation", "positionField", "positionFieldType",
+      "intervalField", "coordinate", "positionScale", "intervalScale",
+      "capSize", "stroke", "strokeWidth", "strokeDash", "opacity"
+    ], "createErrorBarCap");
+    if (!["vertical", "horizontal"].includes(args.orientation)) {
+      throw new Error(`Unsupported error-bar orientation "${args.orientation}".`);
+    }
+    const vertical = args.orientation === "vertical";
+    const positionAction = vertical ? "encodeX" : "encodeY";
+    const intervalAction = vertical ? "encodeY" : "encodeX";
+    return this
+      .createRuleMark({ id: args.id, data: args.data })
+      [positionAction]({
+        target: args.id,
+        field: args.positionField,
+        fieldType: args.positionFieldType,
+        coordinate: args.coordinate,
+        scale: { id: args.positionScale }
+      })
+      [intervalAction]({
+        target: args.id,
+        field: args.intervalField,
+        fieldType: "quantitative",
+        coordinate: args.coordinate,
+        scale: { id: args.intervalScale }
+      })
+      .encodeStroke({ target: args.id, value: args.stroke })
+      .encodeStrokeWidth({ target: args.id, value: args.strokeWidth })
+      .encodeStrokeDash({ target: args.id, value: args.strokeDash })
+      .encodeOpacity({ target: args.id, value: args.opacity })
+      .materializeRuleSpan({
+        id: args.id,
+        orientation: vertical ? "horizontal" : "vertical",
+        size: args.capSize
+      });
+  }
+);
+
 function positionArgs(resolved) {
   return {
     target: resolved.id,
@@ -69,21 +137,7 @@ export const createErrorBar = action(
     validateKeys(args, OPTIONS, "createErrorBar");
     const resolved = resolveErrorBar(this, args);
     const appearance = resolveAppearance(args);
-    let next = this;
-
-    if (resolved.interval.mode === "statistical") {
-      next = next.createIntervalData({
-        id: resolved.dataId,
-        source: resolved.source,
-        field: resolved.interval.field,
-        groupBy: resolved.groupBy,
-        center: resolved.interval.center,
-        extent: resolved.interval.extent,
-        level: resolved.interval.level,
-        as: resolved.fields
-      });
-    }
-
+    let next = createResolvedIntervalData(this, resolved);
     next = next.createRuleMark({ id: resolved.id, data: resolved.dataId });
     const positionAction = resolved.position.channel === "x" ? "encodeX" : "encodeY";
     const intervalAction = resolved.interval.channel === "x" ? "encodeX" : "encodeY";
@@ -108,10 +162,7 @@ export const createErrorBar = action(
 
     const intervalLayer = findLayer(next, resolved.id);
     if (appearance.caps) {
-      for (const [id, field] of [
-        [resolved.lowerCapId, resolved.fields.lower],
-        [resolved.upperCapId, resolved.fields.upper]
-      ]) {
+      for (const [id, field] of errorBarCaps(resolved)) {
         next = next.createErrorBarCap({
           id,
           data: resolved.dataId,

package/src/actions/errorBars/edit.js

@@ -1,26 +1,77 @@
 import { action } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
-import { validateKeys } from "../../core/validation.js";
-import { findLayer, resolveEligibleLayer } from "../../selectors/layers.js";
-import { planIntervalEdit } from "../data/intervalEdit.js";
 import {
-  ERROR_BAR_APPEARANCE_OPTIONS,
-  ERROR_BAR_EDIT_OPTIONS,
-  resolveErrorBarAppearance
-} from "./options.js";
+  validateKeys,
+  validatePositiveFinite
+} from "../../core/validation.js";
+import {
+  normalizeStrokeDashPattern,
+  validateOpacityValue
+} from "../../grammar/scales/index.js";
+import {
+  validateRuleStroke,
+  validateRuleStrokeWidth
+} from "../../grammar/ruleAppearance.js";
+import { findLayer } from "../../selectors/layers.js";
+import {
+  applyIntervalRevision,
+  ownOptions,
+  planIntervalEdit,
+  releaseIntervalRevision,
+  resolveIntervalOwner
+} from "../data/intervalEdit.js";
+
+export const ERROR_BAR_EDIT_OPTIONS = Object.freeze([
+  "target", "caps", "capSize", "stroke", "strokeWidth",
+  "strokeDash", "opacity", "statistics"
+]);
+
+export const ERROR_BAR_APPEARANCE_OPTIONS = Object.freeze(
+  ERROR_BAR_EDIT_OPTIONS.filter(option =>
+    option !== "target" && option !== "statistics"
+  )
+);
+
+export function resolveErrorBarAppearance(args, { defaults, operation }) {
+  validateKeys(args, ERROR_BAR_EDIT_OPTIONS, operation);
+  const caps = args.caps ?? defaults.caps;
+  if (typeof caps !== "boolean") {
+    throw new TypeError(`${operation} caps must be a boolean.`);
+  }
+  const capSize = args.capSize ?? defaults.capSize;
+  validatePositiveFinite(capSize, `${operation} capSize`);
+  const stroke = validateRuleStroke(
+    args.stroke ?? defaults.stroke,
+    `${operation} stroke`
+  );
+  const strokeWidth = validateRuleStrokeWidth(
+    args.strokeWidth ?? defaults.strokeWidth,
+    `${operation} strokeWidth`
+  );
+  const strokeDash = args.strokeDash ?? defaults.strokeDash;
+  normalizeStrokeDashPattern(strokeDash);
+  const opacity = validateOpacityValue(
+    args.opacity ?? defaults.opacity,
+    `${operation} opacity`
+  );
+  return { caps, capSize, stroke, strokeWidth, strokeDash, opacity };
+}
 
 const REMATERIALIZE_OPTIONS = Object.freeze(["id"]);
 
+export function errorBarCaps(config) {
+  return [
+    [config.lowerCapId, config.fields?.lower ?? config.lowerField],
+    [config.upperCapId, config.fields?.upper ?? config.upperField]
+  ];
+}
+
 function resolveOwner(program, requested) {
-  const target = requested === undefined
-    ? undefined
-    : validateUserId(requested, "Error-bar id");
-  return resolveEligibleLayer(program, {
-    target,
+  return resolveIntervalOwner(program, requested, {
+    idLabel: "Error-bar id",
     label: "error bar",
-    predicate: layer =>
-      layer.mark?.type === "rule" &&
-      program.markConfigs[layer.id]?.errorBar !== undefined
+    mark: "rule",
+    config: "errorBar"
   });
 }
 
@@ -82,10 +133,7 @@ export const rematerializeErrorBar = action(
       throw new Error(`Unknown error bar "${id}".`);
     }
     let next = rematerializeRuleAppearance(this, id, config);
-    const capDefinitions = [
-      [config.lowerCapId, config.lowerField],
-      [config.upperCapId, config.upperField]
-    ];
+    const capDefinitions = errorBarCaps(config);
     if (!config.caps) {
       for (const [capId] of capDefinitions) next = removeCap(next, capId);
       return next;
@@ -118,22 +166,20 @@ export const editErrorBar = action(
     }
     const owner = resolveOwner(this, args.target);
     const current = this.markConfigs[owner.id].errorBar;
-    const appearanceArgs = Object.fromEntries(
-      ERROR_BAR_APPEARANCE_OPTIONS
-        .filter(key => Object.hasOwn(args, key))
-        .map(key => [key, args[key]])
-    );
-    const appearance = resolveErrorBarAppearance(appearanceArgs, {
+    const appearance = resolveErrorBarAppearance(
+      ownOptions(args, ERROR_BAR_APPEARANCE_OPTIONS), {
       defaults: current,
       operation: "editErrorBar"
-    });
+      }
+    );
     const interval = Object.hasOwn(args, "statistics")
       ? planIntervalEdit(this, {
           owner: owner.id,
           data: current.data,
           consumers: [
             owner.id,
-            ...[current.lowerCapId, current.upperCapId]
+            ...errorBarCaps(current)
+              .map(([id]) => id)
               .filter(id => findLayer(this, id) !== undefined)
           ],
           statistics: args.statistics,
@@ -141,27 +187,14 @@ export const editErrorBar = action(
         })
       : { changed: false };
 
-    const applyEdit = program => {
-      let next = program;
-      if (interval.changed) {
-        next = next.createIntervalData(interval.dataArgs);
-        for (const rebind of interval.revision.rebinds) {
-          next = next.rebindLayerData(rebind);
-        }
+    const next = applyIntervalRevision(this, interval);
+    return releaseIntervalRevision(next._withMarkConfig(owner.id, {
+      ...next.markConfigs[owner.id],
+      errorBar: {
+        ...current,
+        ...appearance,
+        ...(interval.changed ? { data: interval.revision.id } : {})
       }
-      next = next._withMarkConfig(owner.id, {
-        ...next.markConfigs[owner.id],
-        errorBar: {
-          ...current,
-          ...appearance,
-          ...(interval.changed ? { data: interval.revision.id } : {})
-        }
-      }).rematerializeErrorBar({ id: owner.id });
-      return interval.changed
-        ? next.releaseDerivedData(interval.revision.release)
-        : next;
-    };
-    if (interval.changed) applyEdit(this);
-    return applyEdit(this);
+    }).rematerializeErrorBar({ id: owner.id }), interval);
   }
 );

package/src/actions/errorBars/index.js

@@ -1,5 +1,4 @@
-import { createErrorBarCap } from "./components.js";
-import { createErrorBar } from "./create.js";
+import { createErrorBar, createErrorBarCap } from "./create.js";
 import { editErrorBar, rematerializeErrorBar } from "./edit.js";
 
 export function registerErrorBarActions(ProgramClass) {

package/src/actions/facets/actions.js

@@ -7,9 +7,10 @@ import {
   validatePositiveFinite
 } from "../../core/validation.js";
 import { resolveFacetDefinition } from "../../grammar/facets/index.js";
-import { normalizeFacetScalePolicies } from
-  "../../grammar/facets/scales.js";
-import { FACET_SCALE_CHANNELS } from "../../grammar/facets/scales.js";
+import {
+  FACET_SCALE_CHANNELS,
+  normalizeFacetScalePolicies
+} from "../../grammar/facets/scales.js";
 import { resolveFacetLayout } from "../../layout/facets.js";
 import { compositionChildDescriptor } from
   "../../materialization/composition.js";
@@ -17,6 +18,7 @@ import { DEFAULT_COLORS, DEFAULT_FONT_FAMILY } from "../../theme/defaults.js";
 import { deriveFacetChildren } from "./derive.js";
 import { replayDerivedData } from "./replay.js";
 import { composeFacetGuides } from "./guides.js";
+import { applyCompositionState } from "../composition/actions.js";
 
 const FACET_OPTIONS = Object.freeze([
   "id", "field", "data", "columns", "gap", "align", "padding", "scales",
@@ -48,25 +50,6 @@ function normalizeGuides(guides) {
   return { axes, legend };
 }
 
-function normalizeHeaderPatch(args, previous) {
-  validateOptionObject(args, HEADER_OPTIONS, "editFacetHeaders", {
-    allowEmpty: false,
-    emptyMessage: "editFacetHeaders requires at least one change."
-  });
-  const next = { ...previous, ...args };
-  validatePositiveFinite(next.fontSize, "Facet header fontSize");
-  validateNonEmptyString(next.fontFamily, "Facet header fontFamily");
-  validateNonEmptyString(next.color, "Facet header color");
-  validateNonNegativeFinite(next.offset, "Facet header offset");
-  if (!(
-    (typeof next.fontWeight === "string" && next.fontWeight.length > 0) ||
-    Number.isFinite(next.fontWeight)
-  )) {
-    throw new TypeError("Facet header fontWeight must be a non-empty string or number.");
-  }
-  return next;
-}
-
 function requireFacetProgram(program, operation) {
   program._assertCompositionProgram(operation);
   if (program.compositionSpec.type !== "facet") {
@@ -74,16 +57,6 @@ function requireFacetProgram(program, operation) {
   }
 }
 
-function currentFacetDefinition(program) {
-  const current = program.compositionSpec;
-  return resolveFacetDefinition(program.semanticSpec, {
-    id: current.id,
-    data: current.facet.data,
-    field: current.facet.field,
-    values: current.facet.values
-  });
-}
-
 function facetUnitTemplate(program) {
   const seed = program.children[program.compositionSpec.children[0]];
   if (seed === undefined) {
@@ -106,20 +79,19 @@ function facetUnitTemplate(program) {
   });
 }
 
-function applicableScaleRequest(program, channels) {
-  return Object.fromEntries(FACET_SCALE_CHANNELS.flatMap(channel =>
+function rederiveFacet(program, { scales, guides }) {
+  const current = program.compositionSpec;
+  const definition = resolveFacetDefinition(program.semanticSpec, {
+    id: current.id,
+    data: current.facet.data,
+    field: current.facet.field,
+    values: current.facet.values
+  });
+  const request = Object.fromEntries(FACET_SCALE_CHANNELS.flatMap(channel =>
     program.semanticSpec.layers.some(
       layer => layer.encoding?.[channel]?.scale !== undefined
-    )
-      ? [[channel, channels[channel]]]
-      : []
+    ) ? [[channel, scales[channel]]] : []
   ));
-}
-
-function rederiveFacet(program, { scales, guides }) {
-  const current = program.compositionSpec;
-  const definition = currentFacetDefinition(program);
-  const request = applicableScaleRequest(program, scales);
   const normalized = normalizeFacetScalePolicies(program.semanticSpec, request);
   const derived = deriveFacetChildren(facetUnitTemplate(program), definition, {
     closeInheritedAction: true,
@@ -134,14 +106,10 @@ function rederiveFacet(program, { scales, guides }) {
       guides
     }
   };
-  let next = program._withCompositionState({
+  return applyCompositionState(program, {
     children: derived.children,
     compositionSpec
-  });
-  for (const id of compositionSpec.children) {
-    next = next.useProgram({ id });
-  }
-  return next.materializeComposition();
+  }, compositionSpec.children);
 }
 
 export const facet = action(
@@ -189,18 +157,16 @@ export const facet = action(
         guides
       }
     };
-    let next = this
-      ._withCompositionState({
+    return applyCompositionState(
+      this._withMaterializationConfig(["facets", definition.id], {
+        headers: DEFAULT_HEADERS
+      }),
+      {
         children: derived.children,
         compositionSpec
-      })
-      ._withMaterializationConfig(["facets", definition.id], {
-        headers: DEFAULT_HEADERS
-      });
-    for (const id of compositionSpec.children) {
-      next = next.useProgram({ id });
-    }
-    return next.materializeComposition();
+      },
+      compositionSpec.children
+    );
   }
 );
 
@@ -217,7 +183,23 @@ export const editFacetHeaders = action(
     if (!isPlainObject(config?.headers)) {
       throw new Error(`Facet "${id}" requires header configuration.`);
     }
-    const headers = normalizeHeaderPatch(args, config.headers);
+    validateOptionObject(args, HEADER_OPTIONS, "editFacetHeaders", {
+      allowEmpty: false,
+      emptyMessage: "editFacetHeaders requires at least one change."
+    });
+    const headers = { ...config.headers, ...args };
+    validatePositiveFinite(headers.fontSize, "Facet header fontSize");
+    validateNonEmptyString(headers.fontFamily, "Facet header fontFamily");
+    validateNonEmptyString(headers.color, "Facet header color");
+    validateNonNegativeFinite(headers.offset, "Facet header offset");
+    if (!(
+      (typeof headers.fontWeight === "string" && headers.fontWeight.length > 0) ||
+      Number.isFinite(headers.fontWeight)
+    )) {
+      throw new TypeError(
+        "Facet header fontWeight must be a non-empty string or number."
+      );
+    }
     return this
       ._withMaterializationConfig(["facets", id], { ...config, headers })
       .materializeComposition();
@@ -252,14 +234,10 @@ export const editFacetScales = action(
     )) {
       throw new Error("editFacetScales requires at least one channel policy change.");
     }
-    const request = applicableScaleRequest(this, scales);
-    const normalized = normalizeFacetScalePolicies(this.semanticSpec, request);
-    const applyEdit = program => rederiveFacet(program, {
-      scales: normalized.channels,
+    return rederiveFacet(this, {
+      scales,
       guides: current.guides
     });
-    applyEdit(this);
-    return applyEdit(this);
   }
 );
 
@@ -277,12 +255,10 @@ export const editFacetGuides = action(
     });
     const current = this.compositionSpec.facet;
     const guides = normalizeGuides({ ...current.guides, ...args });
-    const applyEdit = program => rederiveFacet(program, {
+    return rederiveFacet(this, {
       scales: current.scales,
       guides
     });
-    applyEdit(this);
-    return applyEdit(this);
   }
 );
 

package/src/actions/facets/derive.js

@@ -56,40 +56,6 @@ function applySharedHistogramBoundaries(program, layerId, boundaries) {
   });
 }
 
-function replayDatasetId(cell, owner) {
-  return `${cell.id}-${owner}-data`;
-}
-
-function rebindReplayedGradientPlots(child, base, datasets) {
-  let next = child;
-  for (const [id, markConfig] of Object.entries(base.markConfigs)) {
-    const gradientPlot = markConfig.gradientPlot;
-    if (gradientPlot?.materialized !== true) continue;
-    const profile = datasets.get(gradientPlot.profileId);
-    const source = datasets.get(gradientPlot.source);
-    if (profile === undefined || source === undefined) {
-      throw new Error(
-        `Facet gradient plot "${id}" is missing replayed profile dependencies.`
-      );
-    }
-    next = next.rebindGradientPlotProfile({ id, profile, source });
-  }
-  return next;
-}
-
-function cellMaterializationPlan(program) {
-  const scaleIds = [...new Set(program.semanticSpec.layers.flatMap(layer =>
-    Object.values(layer.encoding ?? {})
-      .map(encoding => encoding?.scale)
-      .filter(id => id !== undefined)
-  ))];
-  const scales = scaleIds.map(id => ({
-    op: "rematerializeScale",
-    args: { id, guides: false, marks: false }
-  }));
-  return buildMaterializationPlan({ scales });
-}
-
 function deriveCellProgram(
   base,
   definition,
@@ -111,7 +77,7 @@ function deriveCellProgram(
         `Facet replay source "${replay.source}" is not available in cell "${cell.id}".`
       );
     }
-    const id = replayDatasetId(cell, replay.id);
+    const id = `${cell.id}-${replay.id}-data`;
     const policy = findTransformPolicy(replay.transform.type);
     const transform = policy?.facetReplayTransform?.(
       replay.transform,
@@ -138,8 +104,29 @@ function deriveCellProgram(
       histogramBoundaries.get(layer.id)
     );
   }
-  child = rebindReplayedGradientPlots(child, base, datasets);
-  return applyMaterializationPlan(child, cellMaterializationPlan(child));
+  for (const [id, markConfig] of Object.entries(base.markConfigs)) {
+    const gradientPlot = markConfig.gradientPlot;
+    if (gradientPlot?.materialized !== true) continue;
+    const profile = datasets.get(gradientPlot.profileId);
+    const source = datasets.get(gradientPlot.source);
+    if (profile === undefined || source === undefined) {
+      throw new Error(
+        `Facet gradient plot "${id}" is missing replayed profile dependencies.`
+      );
+    }
+    child = child.rebindGradientPlotProfile({ id, profile, source });
+  }
+  const scaleIds = [...new Set(child.semanticSpec.layers.flatMap(layer =>
+    Object.values(layer.encoding ?? {})
+      .map(encoding => encoding?.scale)
+      .filter(id => id !== undefined)
+  ))];
+  return applyMaterializationPlan(child, buildMaterializationPlan({
+    scales: scaleIds.map(id => ({
+      op: "rematerializeScale",
+      args: { id, guides: false, marks: false }
+    }))
+  }));
 }
 
 function applyResolvedDomains(program, childId, resolution, baseResolved) {
@@ -186,14 +173,14 @@ export function deriveFacetChildren(
   const template = stripTitle && base.semanticSpec.title.text !== undefined
     ? base.removeTitle()
     : base;
-  const resolutionRequest = scales ?? {};
-  const xPolicy = resolutionRequest.x ?? "shared";
+  scales ??= {};
+  const xPolicy = scales.x ?? "shared";
   const bins = xPolicy === "shared"
     ? sharedHistogramBoundaries(template)
     : new Map();
   const independentlyResolved = Object.fromEntries(definition.cells.map(cell => [
     cell.id,
-    deriveCellProgram(template, definition, cell, bins, resolutionRequest)
+    deriveCellProgram(template, definition, cell, bins, scales)
   ]));
   const resolution = resolveFacetScaleDomains(
     template.semanticSpec,
@@ -201,14 +188,19 @@ export function deriveFacetChildren(
       id,
       child.resolvedScales
     ])),
-    resolutionRequest,
+    scales,
     template.resolvedScales
   );
   const resolvedChildren = Object.fromEntries(
-    Object.entries(independentlyResolved).map(([id, child]) => [
-      id,
-      applyResolvedDomains(child, id, resolution, template.resolvedScales)
-    ])
+    Object.entries(independentlyResolved).map(([id, child]) => {
+      const resolved = applyResolvedDomains(
+        child,
+        id,
+        resolution,
+        template.resolvedScales
+      );
+      return [id, closeInheritedAction ? resolved._exitAction() : resolved];
+    })
   );
   const sharedScales = Object.fromEntries(
     Object.entries(resolution.scales)
@@ -216,14 +208,7 @@ export function deriveFacetChildren(
       .map(([id]) => [id, resolvedChildren[definition.cells[0].id].resolvedScales[id]])
   );
   return freezeOwned({
-    children: freezeOwned(Object.fromEntries(
-      Object.entries(resolvedChildren).map(([id, child]) => [
-        id,
-        closeInheritedAction
-          ? child._exitAction()
-          : child
-      ])
-    )),
+    children: freezeOwned(resolvedChildren),
     sharedScales: freezeOwned(sharedScales),
     resolution
   });

package/src/actions/facets/replay.js

@@ -3,7 +3,6 @@ import { isPlainObject } from "../../core/immutable.js";
 import { validateUserId } from "../../core/identifiers.js";
 import { validateKeys } from "../../core/validation.js";
 import { findTransformPolicy } from "../../grammar/transforms.js";
-import { hasDataset } from "../../selectors/datasets.js";
 
 const REPLAY_OPTIONS = Object.freeze(["id", "source", "transform"]);