ggaction 0.0.9 → 0.0.11

package/src/actions/data/bin2d.js

@@ -14,6 +14,7 @@ import {
   findDataset,
   findDatasetConsumer
 } from "../../selectors/datasets.js";
+import { requireLayer } from "../../selectors/layers.js";
 export { materializeBin2DData } from "./bin2dMaterialize.js";
 
 const OPTIONS = Object.freeze([
@@ -24,7 +25,7 @@ const EDIT_OPTIONS = Object.freeze([
 ]);
 const EDITABLE = Object.freeze(EDIT_OPTIONS.slice(1));
 const OUTPUT_FIELDS = Object.freeze([
-  "x0", "x1", "y0", "y1", "count"
+  "x0", "x1", "y0", "y1", "count", "members"
 ]);
 
 function ownerConfig(program, id) {
@@ -74,6 +75,106 @@ function directLayerConsumers(program, data) {
     .map(layer => layer.id);
 }
 
+function outputFieldChanges(previous, next) {
+  return new Map(OUTPUT_FIELDS.flatMap(role => {
+    const from = previous.as[role];
+    const to = next.as[role];
+    return from !== undefined && from !== to
+      ? [[from, [role, to]]]
+      : [];
+  }));
+}
+
+function changedConsumerField(field, changes) {
+  const change = changes.get(field);
+  if (change === undefined) return field;
+  const [role, next] = change;
+  if (next === undefined) {
+    throw new Error(
+      `Cannot remove referenced 2D bin ${role} output field "${field}".`
+    );
+  }
+  return next;
+}
+
+function rebindLayerOutputFields(program, id, changes) {
+  const layer = requireLayer(program, id);
+  let next = program;
+  const changed = field => changedConsumerField(field, changes);
+  const editField = (property, field) => {
+    if (field === undefined) return;
+    const value = changed(field);
+    if (value !== field) next = next.editSemantic({ property, value });
+  };
+  for (const [channel, encoding] of Object.entries(layer.encoding ?? {})) {
+    editField(
+      `layer[${id}].encoding.${channel}.field`,
+      encoding?.field
+    );
+    const summary = encoding?.categoryOrder?.by;
+    if (summary?.field !== undefined) {
+      const field = changed(summary.field);
+      if (field !== summary.field) {
+        next = next.editSemantic({
+          property: `layer[${id}].encoding.${channel}.categoryOrder`,
+          value: { ...encoding.categoryOrder, by: { ...summary, field } }
+        });
+      }
+    }
+  }
+  editField(
+    `layer[${id}].encoding.theta.weight`,
+    layer.encoding?.theta?.weight
+  );
+
+  const parallel = layer.encoding?.parallel;
+  if (parallel?.dimensions !== undefined) {
+    const dimensions = parallel.dimensions.map(dimension => {
+      const field = changed(dimension.field);
+      return { ...dimension, field };
+    });
+    if (dimensions.some((dimension, index) =>
+      dimension.field !== parallel.dimensions[index].field
+    )) {
+      next = next.editSemantic({
+        property: `layer[${id}].encoding.parallel.dimensions`,
+        value: dimensions
+      });
+    }
+  }
+  editField(
+    `layer[${id}].encoding.parallel.key`,
+    parallel?.key
+  );
+
+  for (const [selectionId, config] of Object.entries(
+    program.materializationConfigs.selections ?? {}
+  )) {
+    if (config.target !== id) continue;
+    const selector = { ...config.selector };
+    if (selector.field !== undefined) {
+      selector.field = changed(selector.field);
+    }
+    if (selector.groupBy !== undefined) {
+      selector.groupBy = selector.groupBy.map(changed);
+    }
+    if (JSON.stringify(selector) !== JSON.stringify(config.selector)) {
+      next = next._withSelectionConfig(selectionId, { ...config, selector });
+    }
+  }
+
+  const jitter = program.materializationConfigs.jitters?.[id];
+  const key = jitter?.key === undefined
+    ? undefined
+    : changed(jitter.key);
+  if (key !== undefined && key !== jitter.key) {
+    next = next._withMaterializationConfig(
+      ["jitters", id], { ...jitter, key }
+    );
+  }
+  return next;
+}
+
 function rejectDerivedConsumers(program, data) {
   const dependent = findDatasetConsumer(program, data);
   if (dependent !== undefined) {
@@ -93,7 +194,7 @@ function preflight(program, sourceId, transform) {
 }
 
 function requireCompleteEditOutputFields(value, members) {
-  const required = [...OUTPUT_FIELDS, ...(members ? ["members"] : [])];
+  const required = OUTPUT_FIELDS.filter(field => field !== "members" || members);
   const missing = required.find(field => !Object.hasOwn(value, field));
   if (missing !== undefined) {
     throw new Error(
@@ -140,6 +241,7 @@ function sameRequestedTransform(left, right) {
 function applyBin2DRevision(program, { owner, previous, source, transform }) {
   rejectDerivedConsumers(program, previous.id);
   const consumers = directLayerConsumers(program, previous.id);
+  const changes = outputFieldChanges(previous.transform[0], transform);
   const revision = planDerivedDataRevision(program, {
     owner,
     role: "Bin2DData",
@@ -151,6 +253,7 @@ function applyBin2DRevision(program, { owner, previous, source, transform }) {
     .materializeBin2DData({ id: revision.id });
   for (const rebind of revision.rebinds) {
     next = next.rebindLayerData(rebind);
+    next = rebindLayerOutputFields(next, rebind.id, changes);
     next = applyLayerDataRematerialization(next, rebind.id);
   }
   next = next.releaseDerivedData(revision.release);

package/src/actions/data/box.js

@@ -1,39 +1,39 @@
-import { action } from "../../core/action.js";
-import { validateUserId } from "../../core/identifiers.js";
-import { validateKeys } from "../../core/validation.js";
 import { BOX_FIELDS, deriveBoxData, normalizeBoxTransform } from "../../grammar/boxPlot.js";
-import { MATERIALIZE_OPTIONS, requireDerivedDataset } from "./shared.js";
+import { derivedCreator, derivedMaterializer } from "./shared.js";
 
 const OPTIONS = Object.freeze([
   "id", "source", "category", "field", "whisker", "factor", "as"
 ]);
 
 function materializer(type, op, select) {
-  return action({ op, description: `Materialize ${type} box-plot data.` }, function (args = {}) {
-    validateKeys(args, MATERIALIZE_OPTIONS, op);
-    const { id, source, transform } = requireDerivedDataset(this, args.id, type);
-    return this.editSemantic({ property: `dataset[${id}].values`, value: select(deriveBoxData(source.values, transform)) });
-  });
+  return derivedMaterializer(
+    op,
+    `Materialize ${type} box-plot data.`,
+    type,
+    (values, transform) => select(deriveBoxData(values, transform))
+  );
 }
 
 export const materializeBoxSummaryData = materializer("boxSummary", "materializeBoxSummaryData", value => value.summaries);
 export const materializeBoxOutlierData = materializer("boxOutlier", "materializeBoxOutlierData", value => value.outliers);
 
 function creator(type, op, materialize) {
-  return action({ op, description: `Create immutable ${type} box-plot data.` }, function (args = {}) {
-    validateKeys(args, OPTIONS, op);
-    const id = validateUserId(args.id, "Box dataset id");
-    const source = validateUserId(args.source ?? this.context.currentData, "Box source dataset id");
-    const transform = normalizeBoxTransform({
+  return derivedCreator(
+    op,
+    `Create immutable ${type} box-plot data.`,
+    OPTIONS,
+    "Box dataset id",
+    "Box source dataset id",
+    args => normalizeBoxTransform({
       type,
       category: args.category,
       field: args.field,
       ...(args.whisker === undefined ? {} : { whisker: args.whisker }),
       ...(args.factor === undefined ? {} : { factor: args.factor }),
       as: args.as ?? BOX_FIELDS
-    });
-    return this.createDerivedData({ id, source, transform: [transform] })[materialize]({ id });
-  });
+    }),
+    materialize
+  );
 }
 
 export const createBoxSummaryData = creator("boxSummary", "createBoxSummaryData", "materializeBoxSummaryData");

package/src/actions/data/density.js

@@ -1,8 +1,5 @@
-import { action } from "../../core/action.js";
-import { validateUserId } from "../../core/identifiers.js";
-import { validateKeys } from "../../core/validation.js";
 import { deriveKernelDensity } from "../../grammar/density.js";
-import { MATERIALIZE_OPTIONS, requireDerivedDataset } from "./shared.js";
+import { derivedCreator, derivedMaterializer } from "./shared.js";
 
 const OPTIONS = Object.freeze([
   "id", "source", "field", "groupBy", "bandwidth", "extent", "steps",
@@ -26,84 +23,51 @@ function densityTransform(args, placement) {
   };
 }
 
-export const materializeDensityData = action(
-  { op: "materializeDensityData", description: "Materialize one grouped kernel-density dataset." },
-  function (args = {}) {
-    validateKeys(args, MATERIALIZE_OPTIONS, "materializeDensityData");
-    const { id, source, transform } = requireDerivedDataset(
-      this,
-      args.id,
-      "density"
+function requestedTransform(args, op, categorical = false) {
+  if (typeof args.field !== "string" || args.field.length === 0) {
+    throw new TypeError(`${op} requires a non-empty field string.`);
+  }
+  if (categorical && args.placement?.type !== "category") {
+    throw new Error(
+      "createCategoricalDensityData requires normalized category placement."
     );
-    const result = deriveKernelDensity(source.values, transform);
-    return this
-      .editSemantic({
-        property: `dataset[${id}].transform`,
-        value: [{
-          ...transform,
-          resolved: {
-            bandwidth: result.bandwidth,
-            extent: result.extent,
-            ...(result.splitDomain === undefined
-              ? {}
-              : { splitDomain: result.splitDomain })
-          }
-        }]
-      })
-      .editSemantic({
-        property: `dataset[${id}].values`,
-        value: result.values
-      });
   }
-);
+  return densityTransform(args, categorical ? args.placement : undefined);
+}
 
-export const createDensityData = action(
-  { op: "createDensityData", description: "Create grouped kernel-density values." },
-  function (args = {}) {
-    validateKeys(args, OPTIONS, "createDensityData");
-    const id = validateUserId(args.id, "Density dataset id");
-    const source = validateUserId(
-      args.source ?? this.context.currentData,
-      "Source dataset id"
-    );
-    if (typeof args.field !== "string" || args.field.length === 0) {
-      throw new TypeError("createDensityData requires a non-empty field string.");
+export const materializeDensityData = derivedMaterializer(
+  "materializeDensityData",
+  "Materialize one grouped kernel-density dataset.",
+  "density",
+  deriveKernelDensity,
+  (result, transform) => [{
+    ...transform,
+    resolved: {
+      bandwidth: result.bandwidth,
+      extent: result.extent,
+      ...(result.splitDomain === undefined
+        ? {}
+        : { splitDomain: result.splitDomain })
     }
-    const transform = densityTransform(args);
-    return this
-      .createDerivedData({ id, source, transform: [transform] })
-      .materializeDensityData({ id });
-  }
+  }]
 );
 
-export const createCategoricalDensityData = action(
-  {
-    op: "createCategoricalDensityData",
-    description: "Create category-placed kernel-density values."
-  },
-  function (args = {}) {
-    validateKeys(args, CATEGORICAL_OPTIONS, "createCategoricalDensityData");
-    const id = validateUserId(args.id, "Density dataset id");
-    const source = validateUserId(
-      args.source ?? this.context.currentData,
-      "Source dataset id"
-    );
-    if (typeof args.field !== "string" || args.field.length === 0) {
-      throw new TypeError(
-        "createCategoricalDensityData requires a non-empty field string."
-      );
-    }
-    if (args.placement?.type !== "category") {
-      throw new Error(
-        "createCategoricalDensityData requires normalized category placement."
-      );
-    }
-    return this
-      .createDerivedData({
-        id,
-        source,
-        transform: [densityTransform(args, args.placement)]
-      })
-      .materializeDensityData({ id });
-  }
+export const createDensityData = derivedCreator(
+  "createDensityData",
+  "Create grouped kernel-density values.",
+  OPTIONS,
+  "Density dataset id",
+  "Source dataset id",
+  args => requestedTransform(args, "createDensityData"),
+  "materializeDensityData"
+);
+
+export const createCategoricalDensityData = derivedCreator(
+  "createCategoricalDensityData",
+  "Create category-placed kernel-density values.",
+  CATEGORICAL_OPTIONS,
+  "Density dataset id",
+  "Source dataset id",
+  args => requestedTransform(args, "createCategoricalDensityData", true),
+  "materializeDensityData"
 );

package/src/actions/data/gradientProfile.js

@@ -1,65 +1,35 @@
-import { action } from "../../core/action.js";
-import { validateUserId } from "../../core/identifiers.js";
-import { validateKeys } from "../../core/validation.js";
 import {
   deriveGradientProfiles,
   normalizeGradientProfileTransform
 } from "../../grammar/gradientProfile.js";
-import { MATERIALIZE_OPTIONS, requireDerivedDataset } from "./shared.js";
+import { derivedCreator, derivedMaterializer } from "./shared.js";
 
 const OPTIONS = Object.freeze([
   "id", "source", "category", "field", "bandwidth", "extent", "steps",
   "kernel", "normalization", "center", "as"
 ]);
 
-export const materializeGradientProfileData = action(
-  {
-    op: "materializeGradientProfileData",
-    description: "Materialize one categorical density-profile dataset."
-  },
-  function (args = {}) {
-    validateKeys(
-      args,
-      MATERIALIZE_OPTIONS,
-      "materializeGradientProfileData"
-    );
-    const { id, source, transform } = requireDerivedDataset(
-      this,
-      args.id,
-      "gradientProfile"
-    );
-    const result = deriveGradientProfiles(source.values, transform);
-    return this
-      .editSemantic({
-        property: `dataset[${id}].transform`,
-        value: [{
-          ...transform,
-          resolved: {
-            bandwidth: result.bandwidth,
-            extent: result.extent,
-            intensityDomain: result.intensityDomain
-          }
-        }]
-      })
-      .editSemantic({ property: `dataset[${id}].values`, value: result.values });
-  }
+export const materializeGradientProfileData = derivedMaterializer(
+  "materializeGradientProfileData",
+  "Materialize one categorical density-profile dataset.",
+  "gradientProfile",
+  deriveGradientProfiles,
+  (result, transform) => [{
+    ...transform,
+    resolved: {
+      bandwidth: result.bandwidth,
+      extent: result.extent,
+      intensityDomain: result.intensityDomain
+    }
+  }]
 );
 
-export const createGradientProfileData = action(
-  {
-    op: "createGradientProfileData",
-    description: "Create one immutable categorical density-profile dataset."
-  },
-  function (args = {}) {
-    validateKeys(args, OPTIONS, "createGradientProfileData");
-    const id = validateUserId(args.id, "Gradient profile dataset id");
-    const source = validateUserId(
-      args.source ?? this.context.currentData,
-      "Gradient profile source dataset id"
-    );
-    const transform = normalizeGradientProfileTransform(args);
-    return this
-      .createDerivedData({ id, source, transform: [transform] })
-      .materializeGradientProfileData({ id });
-  }
+export const createGradientProfileData = derivedCreator(
+  "createGradientProfileData",
+  "Create one immutable categorical density-profile dataset.",
+  OPTIONS,
+  "Gradient profile dataset id",
+  "Gradient profile source dataset id",
+  normalizeGradientProfileTransform,
+  "materializeGradientProfileData"
 );

package/src/actions/data/horizon.js

@@ -1,11 +1,8 @@
-import { action } from "../../core/action.js";
-import { validateUserId } from "../../core/identifiers.js";
-import { validateKeys } from "../../core/validation.js";
 import {
   deriveHorizon,
   validateHorizonTransform
 } from "../../grammar/horizon.js";
-import { MATERIALIZE_OPTIONS, requireDerivedDataset } from "./shared.js";
+import { derivedCreator, derivedMaterializer } from "./shared.js";
 
 const OPTIONS = Object.freeze([
   "id", "source", "x", "y", "groupBy", "bands", "baseline", "extent",
@@ -29,43 +26,21 @@ function requestedTransform(args) {
   });
 }
 
-export const materializeHorizonData = action(
-  {
-    op: "materializeHorizonData",
-    description: "Materialize one immutable Horizon band dataset."
-  },
-  function (args = {}) {
-    validateKeys(args, MATERIALIZE_OPTIONS, "materializeHorizonData");
-    const { id, source, transform } = requireDerivedDataset(
-      this,
-      args.id,
-      "horizon"
-    );
-    const result = deriveHorizon(source.values, transform);
-    return this
-      .editSemantic({
-        property: `dataset[${id}].transform`,
-        value: [{ ...result.transform, resolved: result.resolved }]
-      })
-      .editSemantic({
-        property: `dataset[${id}].values`,
-        value: result.values
-      });
-  }
+export const materializeHorizonData = derivedMaterializer(
+  "materializeHorizonData",
+  "Materialize one immutable Horizon band dataset.",
+  "horizon",
+  deriveHorizon,
+  result => [{ ...result.transform, resolved: result.resolved }]
 );
 
-export const createHorizonData = action(
-  {
-    op: "createHorizonData",
-    description: "Create one immutable Horizon band dataset."
-  },
-  function (args = {}) {
-    validateKeys(args, OPTIONS, "createHorizonData");
-    const id = validateUserId(args.id, "Horizon dataset id");
-    const source = validateUserId(args.source, "Horizon source dataset id");
-    const transform = requestedTransform(args);
-    return this
-      .createDerivedData({ id, source, transform: [transform] })
-      .materializeHorizonData({ id });
-  }
+export const createHorizonData = derivedCreator(
+  "createHorizonData",
+  "Create one immutable Horizon band dataset.",
+  OPTIONS,
+  "Horizon dataset id",
+  "Horizon source dataset id",
+  requestedTransform,
+  "materializeHorizonData",
+  true
 );

package/src/actions/data/index.js

@@ -1,4 +1,7 @@
-import { createData } from "./create.js";
+import {
+  createTimeUnitData,
+  materializeTimeUnitData
+} from "./timeUnit.js";
 import {
   createDerivedData,
   rebindLayerData,
@@ -10,28 +13,25 @@ import {
   materializeFilteredData,
   materializeMarkFilteredData
 } from "./filter.js";
+import {
+  createGradientProfileData,
+  materializeGradientProfileData
+} from "./gradientProfile.js";
 import { createRegressionData, materializeRegressionData } from "./regression.js";
 import {
   createCategoricalDensityData,
   createDensityData,
   materializeDensityData
 } from "./density.js";
-import {
-  createGradientProfileData,
-  materializeGradientProfileData
-} from "./gradientProfile.js";
 import { createIntervalData, materializeIntervalData } from "./interval.js";
 import { createHorizonData, materializeHorizonData } from "./horizon.js";
-import { createWindowData, materializeWindowData } from "./window.js";
-import {
-  createTimeUnitData,
-  materializeTimeUnitData
-} from "./timeUnit.js";
 import {
   createBin2DData,
   editBin2DData,
   materializeBin2DData
 } from "./bin2d.js";
+import { createData } from "./create.js";
+import { createWindowData, materializeWindowData } from "./window.js";
 import { createBoxSummaryData, createBoxOutlierData, materializeBoxSummaryData, materializeBoxOutlierData } from "./box.js";
 
 export function registerDataActions(ProgramClass) {

package/src/actions/data/interval.js

@@ -1,11 +1,8 @@
-import { action } from "../../core/action.js";
-import { validateUserId } from "../../core/identifiers.js";
-import { validateKeys } from "../../core/validation.js";
 import {
   deriveInterval,
   normalizeIntervalTransform
 } from "../../grammar/interval.js";
-import { MATERIALIZE_OPTIONS, requireDerivedDataset } from "./shared.js";
+import { derivedCreator, derivedMaterializer } from "./shared.js";
 
 const OPTIONS = Object.freeze([
   "id",
@@ -18,43 +15,26 @@ const OPTIONS = Object.freeze([
   "as"
 ]);
 
-export const materializeIntervalData = action(
-  {
-    op: "materializeIntervalData",
-    description: "Materialize one grouped interval-summary dataset."
-  },
-  function (args = {}) {
-    validateKeys(args, MATERIALIZE_OPTIONS, "materializeIntervalData");
-    const { id, source, transform } = requireDerivedDataset(
-      this,
-      args.id,
-      "interval"
-    );
-    return this.editSemantic({
-      property: `dataset[${id}].values`,
-      value: deriveInterval(source.values, transform)
-    });
-  }
+export const materializeIntervalData = derivedMaterializer(
+  "materializeIntervalData",
+  "Materialize one grouped interval-summary dataset.",
+  "interval",
+  deriveInterval
 );
 
-export const createIntervalData = action(
-  {
-    op: "createIntervalData",
-    description: "Create immutable grouped interval-summary values."
-  },
-  function (args = {}) {
-    validateKeys(args, OPTIONS, "createIntervalData");
-    const id = validateUserId(args.id, "Interval dataset id");
-    const source = validateUserId(
-      args.source ?? this.context.currentData,
-      "Source dataset id"
-    );
+export const createIntervalData = derivedCreator(
+  "createIntervalData",
+  "Create immutable grouped interval-summary values.",
+  OPTIONS,
+  "Interval dataset id",
+  "Source dataset id",
+  (args, id) => {
     const as = args.as ?? {
       center: `__${id}_center`,
       lower: `__${id}_lower`,
       upper: `__${id}_upper`
     };
-    const transform = normalizeIntervalTransform({
+    return normalizeIntervalTransform({
       field: args.field,
       groupBy: args.groupBy,
       center: args.center,
@@ -62,8 +42,6 @@ export const createIntervalData = action(
       level: args.level,
       as
     });
-    return this
-      .createDerivedData({ id, source, transform: [transform] })
-      .materializeIntervalData({ id });
-  }
+  },
+  "materializeIntervalData"
 );