ggaction 0.0.15 → 0.0.16

package/src/actions/data/computed.js

@@ -6,14 +6,14 @@ import { derivedCreator, derivedMaterializer } from "./shared.js";
 
 const OPTIONS = Object.freeze(["id", "source", "as", "expression"]);
 
-export const materializeComputedData = derivedMaterializer(
+export const materializeComputedData = /* @__PURE__ */ derivedMaterializer(
   "materializeComputedData",
   "Materialize one immutable row-level typed expression dataset.",
   "computed",
   deriveComputedRows
 );
 
-export const createComputedData = derivedCreator(
+export const createComputedData = /* @__PURE__ */ derivedCreator(
   "createComputedData",
   "Create a typed computed field from a closed expression.",
   OPTIONS,

package/src/actions/data/create.js

@@ -1,27 +1,20 @@
-import { action } from "../../core/action.js";
+import { closedAction } from "../../core/action.js";
 import { resolveOptionalUserId } from "../../core/identifiers.js";
-import { isPlainObject } from "../../core/immutable.js";
-import { validateKeys } from "../../core/validation.js";
+import { validateDataRows } from "../../core/validation.js";
 import { hasDataset, hasDatasetOwner } from "../../selectors/index.js";
 
 const OPTIONS = Object.freeze(["id", "values"]);
 
-export const createData = action(
-  { op: "createData", description: "Create an immutable named dataset." },
+export const createData = /* @__PURE__ */ closedAction(
+  { op: "createData", description: "Create an immutable named dataset." }, OPTIONS,
   function (args = {}) {
-    validateKeys(args, OPTIONS, "createData");
     const id = resolveOptionalUserId(args.id, {
       defaultId: "data",
       label: "Dataset id",
       operation: "createData",
       ambiguous: this.semanticSpec.datasets.length > 0
     });
-    if (!Array.isArray(args.values)) {
-      throw new TypeError("createData requires values to be an array.");
-    }
-    if (!args.values.every(isPlainObject)) {
-      throw new TypeError("createData requires every row to be a plain object.");
-    }
+    validateDataRows(args.values, "createData");
     if (hasDataset(this, id) || hasDatasetOwner(this, id)) {
       throw new Error(`Dataset "${id}" already exists.`);
     }

package/src/actions/data/density.js

@@ -25,7 +25,7 @@ function requestedTransform(args, op, categorical = false) {
   });
 }
 
-export const materializeDensityData = derivedMaterializer(
+export const materializeDensityData = /* @__PURE__ */ derivedMaterializer(
   "materializeDensityData",
   "Materialize one grouped kernel-density dataset.",
   "density",
@@ -44,7 +44,7 @@ export const materializeDensityData = derivedMaterializer(
   }]
 );
 
-export const createDensityData = derivedCreator(
+export const createDensityData = /* @__PURE__ */ derivedCreator(
   "createDensityData",
   "Create grouped kernel-density values.",
   OPTIONS,
@@ -54,7 +54,7 @@ export const createDensityData = derivedCreator(
   "materializeDensityData"
 );
 
-export const createCategoricalDensityData = derivedCreator(
+export const createCategoricalDensityData = /* @__PURE__ */ derivedCreator(
   "createCategoricalDensityData",
   "Create category-placed kernel-density values.",
   CATEGORICAL_OPTIONS,

package/src/actions/data/derived.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 {
   findDataset,
   hasDataset,
@@ -27,10 +27,9 @@ const OWNED_MARK_ROLES = Object.freeze([
   "statisticalReference"
 ]);
 
-export const createDerivedData = action(
-  { op: "createDerivedData", description: "Create an immutable derived dataset definition." },
+export const createDerivedData = /* @__PURE__ */ closedAction(
+  { op: "createDerivedData", description: "Create an immutable derived dataset definition." }, OPTIONS,
   function (args = {}) {
-    validateKeys(args, OPTIONS, "createDerivedData");
     const id = validateUserId(args.id, "Derived dataset id");
     const requestedSource = validateUserId(args.source, "Source dataset id");
     const source = resolveDatasetReference(
@@ -50,13 +49,12 @@ export const createDerivedData = action(
   }
 );
 
-export const releaseDerivedData = action(
+export const releaseDerivedData = /* @__PURE__ */ closedAction(
   {
     op: "releaseDerivedData",
     description: "Release one unreferenced derived dataset."
-  },
+  }, RELEASE_OPTIONS,
   function (args = {}) {
-    validateKeys(args, RELEASE_OPTIONS, "releaseDerivedData");
     const validatedId = validateUserId(args.id, "Derived dataset id");
     const dataset = findDataset(this, validatedId);
     if (dataset === undefined || dataset.source === undefined) {
@@ -85,13 +83,12 @@ export const releaseDerivedData = action(
   }
 );
 
-export const rebindLayerData = action(
+export const rebindLayerData = /* @__PURE__ */ closedAction(
   {
     op: "rebindLayerData",
     description: "Rebind one semantic layer to an existing dataset."
-  },
+  }, REBIND_OPTIONS,
   function (args = {}) {
-    validateKeys(args, REBIND_OPTIONS, "rebindLayerData");
     const id = validateUserId(args.id, "Layer id");
     const requestedData = validateUserId(args.data, "Layer dataset id");
     const data = resolveDatasetReference(
@@ -134,13 +131,12 @@ function applyMarkDataBinding(program, target, data) {
   return applyLayerDataRematerialization(rebound, target);
 }
 
-export const bindMarkData = action(
+export const bindMarkData = /* @__PURE__ */ closedAction(
   {
     op: "bindMarkData",
     description: "Atomically bind one independent mark to materialized data."
-  },
+  }, BIND_OPTIONS,
   function (args = {}) {
-    validateKeys(args, BIND_OPTIONS, "bindMarkData");
     const target = validateUserId(args.target, "Mark target id");
     const requestedData = validateUserId(args.data, "Mark dataset id");
     const data = resolveDatasetReference(

package/src/actions/data/ecdf.js

@@ -9,7 +9,7 @@ const OPTIONS = Object.freeze([
   "id", "source", "field", "groupBy", "weight", "missing", "as"
 ]);
 
-export const materializeECDFData = derivedMaterializer(
+export const materializeECDFData = /* @__PURE__ */ derivedMaterializer(
   "materializeECDFData",
   "Materialize one empirical cumulative distribution dataset.",
   "ecdf",
@@ -17,7 +17,7 @@ export const materializeECDFData = derivedMaterializer(
   resolveECDFTransform
 );
 
-export const createECDFData = derivedCreator(
+export const createECDFData = /* @__PURE__ */ derivedCreator(
   "createECDFData",
   "Create immutable empirical cumulative distribution values.",
   OPTIONS,

package/src/actions/data/edit.js

@@ -1,4 +1,4 @@
-import { action } from "../../core/action.js";
+import { action, closedAction } from "../../core/action.js";
 import { isPlainObject } from "../../core/immutable.js";
 import { validateUserId } from "../../core/identifiers.js";
 import { validateKeys } from "../../core/validation.js";
@@ -254,7 +254,7 @@ function buildRevisionPlan(
       `Derived dataset "${resolved.owner}" cannot use one of its dependents as source.`
     );
   }
-  const reserved = new Set();
+  const reserved = new Set(resolved.revision === undefined ? [] : [resolved.revision]);
   const revisions = [];
   const replacements = new Map();
   const add = (dataset, ownerRecord, transform, requestedSource) => {
@@ -274,7 +274,12 @@ function buildRevisionPlan(
     revisions.push(revision);
     replacements.set(dataset.id, id);
   };
-  add(resolved.dataset, resolved, definition, rootSource);
+  if (resolved.revision === undefined) {
+    add(resolved.dataset, resolved, definition, rootSource);
+  } else {
+    revisions.push({ old: resolved.current, id: resolved.revision });
+    replacements.set(resolved.current, resolved.revision);
+  }
   if (dependents === "recompute") {
     for (const dataset of downstream) {
       const policy = findTransformPolicy(dataset.transform[0].type);
@@ -292,14 +297,15 @@ function directLayerConsumers(program, data) {
     .map(layer => layer.id);
 }
 
-function applyRevisionPlan(program, resolved, plan) {
+export function applyRevisionPlan(program, resolved, plan, { retain = new Set() } = {}) {
   const root = plan.revisions[0];
-  const changes = outputFieldChanges(
+  const changes = resolved === undefined ? new Map() : outputFieldChanges(
     resolved.dataset.transform[0],
     root.transform
   );
   let next = program;
   for (const revision of plan.revisions) {
+    if (revision.transform === undefined) continue;
     const policy = findTransformPolicy(revision.transform.type);
     next = next.createDerivedData({
       id: revision.id,
@@ -345,6 +351,7 @@ function applyRevisionPlan(program, resolved, plan) {
     next = applyLayerDataRematerialization(next, consumer.id);
   }
   for (const revision of [...plan.revisions].reverse()) {
+    if (retain.has(revision.old)) continue;
     next = next.releaseDerivedData({ id: revision.old });
   }
 
@@ -353,6 +360,12 @@ function applyRevisionPlan(program, resolved, plan) {
   return next._withContext({ ...program.context, currentData });
 }
 
+export function buildSourceRevisionPlan(program, source, id) {
+  return buildRevisionPlan(program, {
+    current: source, dataset: findDataset(program, source), revision: id
+  }, undefined, "recompute");
+}
+
 function sameRequested(left, right) {
   return JSON.stringify(left) === JSON.stringify(right);
 }
@@ -375,13 +388,12 @@ export function reviseDerivedData(program, {
   return applyRevisionPlan(program, resolved, plan);
 }
 
-export const editDerivedData = action(
+export const editDerivedData = /* @__PURE__ */ closedAction(
   {
     op: "editDerivedData",
     description: "Atomically revise one standalone derived-data definition."
-  },
+  }, GENERIC_OPTIONS,
   function (args = {}) {
-    validateKeys(args, GENERIC_OPTIONS, "editDerivedData");
     if (!Object.hasOwn(args, "target")) {
       throw new TypeError("editDerivedData requires target.");
     }
@@ -448,72 +460,72 @@ function focusedEditor(op, type, properties) {
   );
 }
 
-export const editComputedData = focusedEditor(
+export const editComputedData = /* @__PURE__ */ focusedEditor(
   "editComputedData", "computed", ["as", "expression"]
 );
-export const editFilteredData = focusedEditor(
+export const editFilteredData = /* @__PURE__ */ focusedEditor(
   "editFilteredData", "filter", ["field", "oneOf", "predicate", "range"]
 );
-export const editFoldData = focusedEditor(
+export const editFoldData = /* @__PURE__ */ focusedEditor(
   "editFoldData", "fold", ["fields", "as"]
 );
-export const editSummaryData = focusedEditor(
+export const editSummaryData = /* @__PURE__ */ focusedEditor(
   "editSummaryData", "summary", ["groupBy", "aggregates", "members", "weight"]
 );
-export const editBinData = focusedEditor(
+export const editBinData = /* @__PURE__ */ focusedEditor(
   "editBinData", "bin", [
     "field", "maxBins", "step", "boundaries", "extent", "nice", "zero",
     "includeEmpty", "members", "as", "weight"
   ]
 );
-export const editTimeUnitData = focusedEditor(
+export const editTimeUnitData = /* @__PURE__ */ focusedEditor(
   "editTimeUnitData", "timeUnit", [
     "field", "unit", "as", "temporalUnit", "timeZone", "weekStartsOn",
     "weekRule"
   ]
 );
-export const editWindowData = focusedEditor(
+export const editWindowData = /* @__PURE__ */ focusedEditor(
   "editWindowData", "window", [
     "partitionBy", "sortBy", "operations", "temporalUnit"
   ]
 );
-export const editDensityData = focusedEditor(
+export const editDensityData = /* @__PURE__ */ focusedEditor(
   "editDensityData", "density", [
     "field", "groupBy", "bandwidth", "extent", "steps", "kernel",
     "normalization", "as", "weight"
   ]
 );
-export const editStackData = focusedEditor(
+export const editStackData = /* @__PURE__ */ focusedEditor(
   "editStackData", "stack", ["category", "group", "value", "mode", "as"]
 );
-export const editRegressionData = focusedEditor(
+export const editRegressionData = /* @__PURE__ */ focusedEditor(
   "editRegressionData", "regression", [
     "x", "y", "groupBy", "method", "degree", "span", "confidenceMethod",
     "level", "confidence", "interval"
   ]
 );
-export const editIntervalData = focusedEditor(
+export const editIntervalData = /* @__PURE__ */ focusedEditor(
   "editIntervalData", "interval", [
     "field", "groupBy", "center", "extent", "method", "level", "as"
   ]
 );
-export const editECDFData = focusedEditor(
+export const editECDFData = /* @__PURE__ */ focusedEditor(
   "editECDFData", "ecdf", [
     "field", "groupBy", "weight", "missing", "as"
   ]
 );
-export const editNormalizedData = focusedEditor(
+export const editNormalizedData = /* @__PURE__ */ focusedEditor(
   "editNormalizedData", "normalize", [
     "field", "as", "groupBy", "method", "variance", "zeroDenominator",
     "baseline", "sortBy"
   ]
 );
-export const editCompleteData = focusedEditor(
+export const editCompleteData = /* @__PURE__ */ focusedEditor(
   "editCompleteData", "complete", [
     "key", "groupBy", "values", "sequence", "fill", "members"
   ]
 );
-export const editImputedData = focusedEditor(
+export const editImputedData = /* @__PURE__ */ focusedEditor(
   "editImputedData", "impute", [
     "fields", "groupBy", "sortBy", "method", "value", "edges", "maxGap"
   ]

package/src/actions/data/filter.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 { withPreviewDatasetValues } from
   "../primitives/semanticAction.js";
 import {
@@ -50,10 +50,9 @@ function retainedHistogramBoundaries(layer, items) {
   return boundaries.length < 2 ? undefined : boundaries;
 }
 
-export const materializeFilteredData = action(
-  { op: "materializeFilteredData", description: "Materialize one filtered derived dataset." },
+export const materializeFilteredData = /* @__PURE__ */ closedAction(
+  { op: "materializeFilteredData", description: "Materialize one filtered derived dataset." }, MATERIALIZE_OPTIONS,
   function (args = {}) {
-    validateKeys(args, MATERIALIZE_OPTIONS, "materializeFilteredData");
     const { id, source, transform } = requireDerivedDataset(
       this,
       args.id,
@@ -66,10 +65,9 @@ export const materializeFilteredData = action(
   }
 );
 
-export const filterData = action(
-  { op: "filterData", description: "Create a named dataset from one field filter." },
+export const filterData = /* @__PURE__ */ closedAction(
+  { op: "filterData", description: "Create a named dataset from one field filter." }, OPTIONS,
   function (args = {}) {
-    validateKeys(args, OPTIONS, "filterData");
     const id = validateUserId(args.id, "Filtered dataset id");
     const requestedSource = validateUserId(
       args.source ?? this.context.currentData,
@@ -97,13 +95,12 @@ export const filterData = action(
   }
 );
 
-export const materializeMarkFilteredData = action(
+export const materializeMarkFilteredData = /* @__PURE__ */ closedAction(
   {
     op: "materializeMarkFilteredData",
     description: "Materialize member rows retained by one final-item mark selection."
-  },
+  }, MATERIALIZE_OPTIONS,
   function (args = {}) {
-    validateKeys(args, MATERIALIZE_OPTIONS, "materializeMarkFilteredData");
     const { id, dataset, source, transform } = requireDerivedDataset(
       this,
       args.id,
@@ -170,13 +167,12 @@ export const materializeMarkFilteredData = action(
   }
 );
 
-export const materializeEmptyMark = action(
+export const materializeEmptyMark = /* @__PURE__ */ closedAction(
   {
     op: "materializeEmptyMark",
     description: "Clear one active empty-filter mark without changing its domains."
-  },
+  }, EMPTY_MARK_OPTIONS,
   function (args = {}) {
-    validateKeys(args, EMPTY_MARK_OPTIONS, "materializeEmptyMark");
     const id = validateUserId(args.id, "Empty mark id");
     const layer = requireLayer(this, id);
     const owner = this.markConfigs[id]?.markFilter;
@@ -261,13 +257,12 @@ function sameSelector(left, right) {
   return JSON.stringify(left) === JSON.stringify(right);
 }
 
-export const removeMarkFilter = action(
+export const removeMarkFilter = /* @__PURE__ */ closedAction(
   {
     op: "removeMarkFilter",
     description: "Remove one active final-item filter and restore its source."
-  },
+  }, REMOVE_MARK_FILTER_OPTIONS,
   function (args = {}) {
-    validateKeys(args, REMOVE_MARK_FILTER_OPTIONS, "removeMarkFilter");
     const target = args.target === undefined
       ? undefined
       : validateUserId(args.target, "Mark filter target id");
@@ -280,13 +275,12 @@ export const removeMarkFilter = action(
   }
 );
 
-export const filterMarks = action(
+export const filterMarks = /* @__PURE__ */ closedAction(
   {
     op: "filterMarks",
     description: "Retain selected final mark items through immutable derived data."
-  },
+  }, MARK_OPTIONS,
   function (args = {}) {
-    validateKeys(args, MARK_OPTIONS, "filterMarks");
     if (args.mode !== undefined && !["replace", "compose"].includes(args.mode)) {
       throw new Error(`Unknown mark filter mode "${args.mode}".`);
     }

package/src/actions/data/fold.js

@@ -6,14 +6,14 @@ import { derivedCreator, derivedMaterializer } from "./shared.js";
 
 const OPTIONS = Object.freeze(["id", "source", "fields", "as"]);
 
-export const materializeFoldData = derivedMaterializer(
+export const materializeFoldData = /* @__PURE__ */ derivedMaterializer(
   "materializeFoldData",
   "Materialize one immutable wide-to-long dataset.",
   "fold",
   deriveFoldRows
 );
 
-export const createFoldData = derivedCreator(
+export const createFoldData = /* @__PURE__ */ derivedCreator(
   "createFoldData",
   "Create reusable key/value rows from selected wide fields.",
   OPTIONS,

package/src/actions/data/gradientProfile.js

@@ -9,7 +9,7 @@ const OPTIONS = Object.freeze([
   "kernel", "normalization", "center", "as"
 ]);
 
-export const materializeGradientProfileData = derivedMaterializer(
+export const materializeGradientProfileData = /* @__PURE__ */ derivedMaterializer(
   "materializeGradientProfileData",
   "Materialize one categorical density-profile dataset.",
   "gradientProfile",
@@ -24,7 +24,7 @@ export const materializeGradientProfileData = derivedMaterializer(
   }]
 );
 
-export const createGradientProfileData = derivedCreator(
+export const createGradientProfileData = /* @__PURE__ */ derivedCreator(
   "createGradientProfileData",
   "Create one immutable categorical density-profile dataset.",
   OPTIONS,

package/src/actions/data/horizon.js

@@ -26,7 +26,7 @@ function requestedTransform(args) {
   });
 }
 
-export const materializeHorizonData = derivedMaterializer(
+export const materializeHorizonData = /* @__PURE__ */ derivedMaterializer(
   "materializeHorizonData",
   "Materialize one immutable Horizon band dataset.",
   "horizon",
@@ -34,7 +34,7 @@ export const materializeHorizonData = derivedMaterializer(
   result => [{ ...result.transform, resolved: result.resolved }]
 );
 
-export const createHorizonData = derivedCreator(
+export const createHorizonData = /* @__PURE__ */ derivedCreator(
   "createHorizonData",
   "Create one immutable Horizon band dataset.",
   OPTIONS,

package/src/actions/data/impute.js

@@ -8,14 +8,14 @@ const OPTIONS = Object.freeze([
   "id", "source", "fields", "groupBy", "sortBy", "method", "value", "edges", "maxGap"
 ]);
 
-export const materializeImputedData = derivedMaterializer(
+export const materializeImputedData = /* @__PURE__ */ derivedMaterializer(
   "materializeImputedData",
   "Materialize one immutable missing-value dataset.",
   "impute",
   deriveImputedRows
 );
 
-export const createImputedData = derivedCreator(
+export const createImputedData = /* @__PURE__ */ derivedCreator(
   "createImputedData",
   "Replace explicit missing cells within independent groups.",
   OPTIONS,

package/src/actions/data/index.js

@@ -35,6 +35,7 @@ import {
   materializeBin2DData
 } from "./bin2d.js";
 import { createData } from "./create.js";
+import { reviseData } from "./revise.js";
 import { createWindowData, materializeWindowData } from "./window.js";
 import { createSummaryData, materializeSummaryData } from "./summary.js";
 import { createBinData, materializeBinData } from "./bin.js";
@@ -51,58 +52,58 @@ import { EDIT_DERIVED_DATA_ACTIONS } from "./edit.js";
 import { createBoxSummaryData, createBoxOutlierData, materializeBoxSummaryData, materializeBoxOutlierData } from "./box.js";
 
 export function registerDataActions(ProgramClass) {
-  Object.assign(ProgramClass.prototype, EDIT_DERIVED_DATA_ACTIONS);
-  ProgramClass.prototype.createData = createData;
-  ProgramClass.prototype.createDerivedData = createDerivedData;
-  ProgramClass.prototype.bindMarkData = bindMarkData;
-  ProgramClass.prototype.releaseDerivedData = releaseDerivedData;
-  ProgramClass.prototype.rebindLayerData = rebindLayerData;
-  ProgramClass.prototype.createDensityData = createDensityData;
-  ProgramClass.prototype.createCategoricalDensityData =
-    createCategoricalDensityData;
-  ProgramClass.prototype.materializeFilteredData = materializeFilteredData;
-  ProgramClass.prototype.materializeMarkFilteredData = materializeMarkFilteredData;
-  ProgramClass.prototype.filterData = filterData;
-  ProgramClass.prototype.filterMarks = filterMarks;
-  ProgramClass.prototype.materializeEmptyMark = materializeEmptyMark;
-  ProgramClass.prototype.removeMarkFilter = removeMarkFilter;
-  ProgramClass.prototype.materializeRegressionData = materializeRegressionData;
-  ProgramClass.prototype.materializeDensityData = materializeDensityData;
-  ProgramClass.prototype.createGradientProfileData = createGradientProfileData;
-  ProgramClass.prototype.materializeGradientProfileData =
-    materializeGradientProfileData;
-  ProgramClass.prototype.createRegressionData = createRegressionData;
-  ProgramClass.prototype.materializeIntervalData = materializeIntervalData;
-  ProgramClass.prototype.createIntervalData = createIntervalData;
-  ProgramClass.prototype.createECDFData = createECDFData;
-  ProgramClass.prototype.materializeECDFData = materializeECDFData;
-  ProgramClass.prototype.createHorizonData = createHorizonData;
-  ProgramClass.prototype.materializeHorizonData = materializeHorizonData;
-  ProgramClass.prototype.createWindowData = createWindowData;
-  ProgramClass.prototype.materializeWindowData = materializeWindowData;
-  ProgramClass.prototype.createSummaryData = createSummaryData;
-  ProgramClass.prototype.materializeSummaryData = materializeSummaryData;
-  ProgramClass.prototype.createBinData = createBinData;
-  ProgramClass.prototype.materializeBinData = materializeBinData;
-  ProgramClass.prototype.createFoldData = createFoldData;
-  ProgramClass.prototype.materializeFoldData = materializeFoldData;
-  ProgramClass.prototype.createComputedData = createComputedData;
-  ProgramClass.prototype.materializeComputedData = materializeComputedData;
-  ProgramClass.prototype.createNormalizedData = createNormalizedData;
-  ProgramClass.prototype.materializeNormalizedData = materializeNormalizedData;
-  ProgramClass.prototype.createCompleteData = createCompleteData;
-  ProgramClass.prototype.materializeCompleteData = materializeCompleteData;
-  ProgramClass.prototype.createImputedData = createImputedData;
-  ProgramClass.prototype.materializeImputedData = materializeImputedData;
-  ProgramClass.prototype.createStackData = createStackData;
-  ProgramClass.prototype.materializeStackData = materializeStackData;
-  ProgramClass.prototype.createTimeUnitData = createTimeUnitData;
-  ProgramClass.prototype.materializeTimeUnitData = materializeTimeUnitData;
-  ProgramClass.prototype.createBin2DData = createBin2DData;
-  ProgramClass.prototype.editBin2DData = editBin2DData;
-  ProgramClass.prototype.materializeBin2DData = materializeBin2DData;
-  ProgramClass.prototype.createBoxSummaryData = createBoxSummaryData;
-  ProgramClass.prototype.createBoxOutlierData = createBoxOutlierData;
-  ProgramClass.prototype.materializeBoxSummaryData = materializeBoxSummaryData;
-  ProgramClass.prototype.materializeBoxOutlierData = materializeBoxOutlierData;
+  Object.assign(ProgramClass.prototype, EDIT_DERIVED_DATA_ACTIONS, {
+    createData,
+    reviseData,
+    createDerivedData,
+    bindMarkData,
+    releaseDerivedData,
+    rebindLayerData,
+    createDensityData,
+    createCategoricalDensityData,
+    materializeFilteredData,
+    materializeMarkFilteredData,
+    filterData,
+    filterMarks,
+    materializeEmptyMark,
+    removeMarkFilter,
+    materializeRegressionData,
+    materializeDensityData,
+    createGradientProfileData,
+    materializeGradientProfileData,
+    createRegressionData,
+    materializeIntervalData,
+    createIntervalData,
+    createECDFData,
+    materializeECDFData,
+    createHorizonData,
+    materializeHorizonData,
+    createWindowData,
+    materializeWindowData,
+    createSummaryData,
+    materializeSummaryData,
+    createBinData,
+    materializeBinData,
+    createFoldData,
+    materializeFoldData,
+    createComputedData,
+    materializeComputedData,
+    createNormalizedData,
+    materializeNormalizedData,
+    createCompleteData,
+    materializeCompleteData,
+    createImputedData,
+    materializeImputedData,
+    createStackData,
+    materializeStackData,
+    createTimeUnitData,
+    materializeTimeUnitData,
+    createBin2DData,
+    editBin2DData,
+    materializeBin2DData,
+    createBoxSummaryData,
+    createBoxOutlierData,
+    materializeBoxSummaryData,
+    materializeBoxOutlierData
+  });
 }

package/src/actions/data/interval.js

@@ -16,14 +16,14 @@ const OPTIONS = Object.freeze([
   "as"
 ]);
 
-export const materializeIntervalData = derivedMaterializer(
+export const materializeIntervalData = /* @__PURE__ */ derivedMaterializer(
   "materializeIntervalData",
   "Materialize one grouped interval-summary dataset.",
   "interval",
   deriveInterval
 );
 
-export const createIntervalData = derivedCreator(
+export const createIntervalData = /* @__PURE__ */ derivedCreator(
   "createIntervalData",
   "Create immutable grouped interval-summary values.",
   OPTIONS,