ggaction 0.0.13 → 0.0.16

package/src/actions/data/bin.js

@@ -7,10 +7,10 @@ import { derivedCreator, derivedMaterializer } from "./shared.js";
 
 const OPTIONS = Object.freeze([
   "id", "source", "field", "maxBins", "step", "boundaries", "extent",
-  "nice", "zero", "includeEmpty", "members", "as"
+  "nice", "zero", "includeEmpty", "members", "as", "weight"
 ]);
 
-export const materializeBinData = derivedMaterializer(
+export const materializeBinData = /* @__PURE__ */ derivedMaterializer(
   "materializeBinData",
   "Materialize one immutable one-dimensional bin dataset.",
   "bin",
@@ -18,7 +18,7 @@ export const materializeBinData = derivedMaterializer(
   resolveBinTransform
 );
 
-export const createBinData = derivedCreator(
+export const createBinData = /* @__PURE__ */ derivedCreator(
   "createBinData",
   "Create reusable one-dimensional bin bounds, counts, and members.",
   OPTIONS,

package/src/actions/data/bin2d.js

@@ -1,29 +1,33 @@
-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 {
   deriveBin2DRows,
   normalizeBin2DTransform,
   requestedBin2DTransform
 } from "../../grammar/bin2d.js";
-import { applyLayerDataRematerialization } from
-  "../../materialization/dependencies.js";
-import { planDerivedDataRevision } from
-  "../../materialization/dataProvenance.js";
 import {
   findDataset,
-  findDatasetConsumer
+  resolveDatasetReference
 } from "../../selectors/datasets.js";
-import { requireLayer } from "../../selectors/layers.js";
+import {
+  normalizeDerivedDependentPolicy,
+  resolveDerivedDataOwner,
+  reviseDerivedData
+} from "./edit.js";
+import { normalizeDatasetTransformEdit } from "../../grammar/transforms.js";
 export { materializeBin2DData } from "./bin2dMaterialize.js";
 
 const OPTIONS = Object.freeze([
   "id", "source", "x", "y", "bins", "extent", "includeEmpty", "members", "as"
 ]);
 const EDIT_OPTIONS = Object.freeze([
-  "target", "source", "x", "y", "bins", "extent", "includeEmpty", "members", "as"
+  "target", "source", "x", "y", "bins", "extent", "includeEmpty",
+  "members", "as", "dependents"
 ]);
-const EDITABLE = Object.freeze(EDIT_OPTIONS.slice(1));
+const EDITABLE = Object.freeze(EDIT_OPTIONS.filter(option =>
+  !["target", "dependents"].includes(option)
+));
 const OUTPUT_FIELDS = Object.freeze([
   "x0", "x1", "y0", "y1", "count", "members"
 ]);
@@ -69,122 +73,6 @@ function requireCurrentBin2D(program, id, config) {
   return current;
 }
 
-function directLayerConsumers(program, data) {
-  return program.semanticSpec.layers
-    .filter(layer => layer.data === 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) {
-    throw new Error(
-      `Cannot replace 2D bin dataset "${data}" while derived dataset ` +
-      `"${dependent.id}" depends on it.`
-    );
-  }
-}
-
 function preflight(program, sourceId, transform) {
   const source = findDataset(program, sourceId);
   if (source?.values === undefined) {
@@ -204,32 +92,18 @@ function requireCompleteEditOutputFields(value, members) {
 }
 
 function editedTransform(owner, previous, args) {
-  const prior = requestedBin2DTransform(previous.transform[0]);
-  const option = property => Object.hasOwn(args, property)
-    ? args[property]
-    : prior[property];
-  const members = option("members");
-  let as = option("as");
-  if (!Object.hasOwn(args, "as")) {
-    as = { ...as };
-    if (members && as.members === undefined) {
-      as.members = `__${owner}_members`;
-    } else if (!members) {
-      delete as.members;
-    }
-  }
-  const transform = normalizeBin2DTransform({
-    id: owner,
-    x: option("x"),
-    y: option("y"),
-    bins: option("bins"),
-    extent: option("extent"),
-    includeEmpty: option("includeEmpty"),
-    members,
-    as
-  });
+  const patch = Object.fromEntries(EDITABLE.flatMap(property =>
+    property !== "source" && Object.hasOwn(args, property)
+      ? [[property, args[property]]]
+      : []
+  ));
+  const transform = normalizeDatasetTransformEdit(
+    previous.transform[0],
+    patch,
+    owner
+  );
   if (Object.hasOwn(args, "as")) {
-    requireCompleteEditOutputFields(args.as, members);
+    requireCompleteEditOutputFields(args.as, transform.members);
   }
   return transform;
 }
@@ -238,47 +112,39 @@ function sameRequestedTransform(left, right) {
   return JSON.stringify(left) === JSON.stringify(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",
-    previous: previous.id,
-    consumers
+function applyBin2DRevision(program, {
+  owner,
+  source,
+  transform,
+  dependents = "reject"
+}) {
+  return reviseDerivedData(program, {
+    resolved: resolveDerivedDataOwner(program, owner, "bin2d"),
+    definition: transform,
+    dependents,
+    source
   });
-  let next = program
-    .createDerivedData({ id: revision.id, source, transform: [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);
-  return next._withMaterializationConfig(
-    ["data", "bin2d", owner],
-    { current: revision.id }
-  );
 }
 
-export const createBin2DData = action(
+export const createBin2DData = /* @__PURE__ */ closedAction(
   {
     op: "createBin2DData",
     description: "Create or revise immutable rectangular 2D-bin values."
-  },
+  }, OPTIONS,
   function (args = {}) {
-    validateKeys(args, OPTIONS, "createBin2DData");
     const owner = validateUserId(args.id, "2D bin dataset id");
     const config = ownerConfig(this, owner);
     const previous = config === undefined
       ? undefined
       : requireCurrentBin2D(this, owner, config);
-    const source = validateUserId(
-      args.source ?? previous?.source ?? this.context.currentData,
-      "Source dataset id"
-    );
+    const source = resolveDatasetReference(
+      this,
+      validateUserId(
+        args.source ?? previous?.source ?? this.context.currentData,
+        "Source dataset id"
+      ),
+      "Source dataset"
+    ).id;
     const transform = normalizeBin2DTransform({ ...args, id: owner });
     preflight(this, source, transform);
 
@@ -301,22 +167,26 @@ export const createBin2DData = action(
   }
 );
 
-export const editBin2DData = action(
+export const editBin2DData = /* @__PURE__ */ closedAction(
   {
     op: "editBin2DData",
     description: "Partially revise one logical rectangular 2D-bin owner."
-  },
+  }, EDIT_OPTIONS,
   function (args = {}) {
-    validateKeys(args, EDIT_OPTIONS, "editBin2DData");
     if (!EDITABLE.some(option => Object.hasOwn(args, option))) {
       throw new Error("editBin2DData requires at least one transform or source option.");
     }
     const owner = resolveBin2DOwner(this, args.target);
     const previous = requireCurrentBin2D(this, owner, ownerConfig(this, owner));
-    const source = validateUserId(
-      args.source ?? previous.source,
-      "2D bin source dataset id"
-    );
+    const dependents = normalizeDerivedDependentPolicy(args.dependents);
+    const source = resolveDatasetReference(
+      this,
+      validateUserId(
+        args.source ?? previous.source,
+        "2D bin source dataset id"
+      ),
+      "2D bin source dataset"
+    ).id;
     const transform = editedTransform(owner, previous, args);
     if (
       source === previous.source &&
@@ -328,11 +198,11 @@ export const editBin2DData = action(
       throw new Error("editBin2DData requires an actual transform or source change.");
     }
     preflight(this, source, transform);
-    const revision = { owner, previous, source, transform };
-
-    // Execute one speculative immutable branch so every consumer plan is known
-    // to succeed before the returned action trace records its first child.
-    applyBin2DRevision(this, revision);
-    return applyBin2DRevision(this, revision);
+    return applyBin2DRevision(this, {
+      owner,
+      source,
+      transform,
+      dependents
+    });
   }
 );

package/src/actions/data/bin2dMaterialize.js

@@ -1,15 +1,14 @@
-import { action } from "../../core/action.js";
-import { validateKeys } from "../../core/validation.js";
+import { closedAction } from "../../core/action.js";
+
 import { deriveBin2DRows } from "../../grammar/bin2d.js";
 import { MATERIALIZE_OPTIONS, requireDerivedDataset } from "./shared.js";
 
-export const materializeBin2DData = action(
+export const materializeBin2DData = /* @__PURE__ */ closedAction(
   {
     op: "materializeBin2DData",
     description: "Materialize one immutable rectangular 2D-bin dataset."
-  },
+  }, MATERIALIZE_OPTIONS,
   function (args = {}) {
-    validateKeys(args, MATERIALIZE_OPTIONS, "materializeBin2DData");
     const { id, source, transform } = requireDerivedDataset(
       this,
       args.id,

package/src/actions/data/box.js

@@ -14,8 +14,8 @@ function materializer(type, op, select) {
   );
 }
 
-export const materializeBoxSummaryData = materializer("boxSummary", "materializeBoxSummaryData", value => value.summaries);
-export const materializeBoxOutlierData = materializer("boxOutlier", "materializeBoxOutlierData", value => value.outliers);
+export const materializeBoxSummaryData = /* @__PURE__ */ materializer("boxSummary", "materializeBoxSummaryData", value => value.summaries);
+export const materializeBoxOutlierData = /* @__PURE__ */ materializer("boxOutlier", "materializeBoxOutlierData", value => value.outliers);
 
 function creator(type, op, materialize) {
   return derivedCreator(
@@ -36,5 +36,5 @@ function creator(type, op, materialize) {
   );
 }
 
-export const createBoxSummaryData = creator("boxSummary", "createBoxSummaryData", "materializeBoxSummaryData");
-export const createBoxOutlierData = creator("boxOutlier", "createBoxOutlierData", "materializeBoxOutlierData");
+export const createBoxSummaryData = /* @__PURE__ */ creator("boxSummary", "createBoxSummaryData", "materializeBoxSummaryData");
+export const createBoxOutlierData = /* @__PURE__ */ creator("boxOutlier", "createBoxOutlierData", "materializeBoxOutlierData");

package/src/actions/data/complete.js

@@ -0,0 +1,26 @@
+import {
+  deriveCompleteRows,
+  normalizeCompleteTransform
+} from "../../grammar/complete.js";
+import { derivedCreator, derivedMaterializer } from "./shared.js";
+
+const OPTIONS = Object.freeze([
+  "id", "source", "key", "groupBy", "values", "sequence", "fill", "members"
+]);
+
+export const materializeCompleteData = /* @__PURE__ */ derivedMaterializer(
+  "materializeCompleteData",
+  "Materialize one immutable completed-key dataset.",
+  "complete",
+  deriveCompleteRows
+);
+
+export const createCompleteData = /* @__PURE__ */ derivedCreator(
+  "createCompleteData",
+  "Complete one key domain independently within observed groups.",
+  OPTIONS,
+  "Complete dataset id",
+  "Complete source dataset id",
+  normalizeCompleteTransform,
+  "materializeCompleteData"
+);

package/src/actions/data/computed.js

@@ -6,16 +6,16 @@ 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 arithmetic dataset.",
+  "Materialize one immutable row-level typed expression dataset.",
   "computed",
   deriveComputedRows
 );
 
-export const createComputedData = derivedCreator(
+export const createComputedData = /* @__PURE__ */ derivedCreator(
   "createComputedData",
-  "Create a finite computed field from a closed arithmetic expression.",
+  "Create a typed computed field from a closed expression.",
   OPTIONS,
   "Computed dataset id",
   "Computed source dataset id",

package/src/actions/data/create.js

@@ -1,28 +1,21 @@
-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 { hasDataset } from "../../selectors/index.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.");
-    }
-    if (hasDataset(this, id)) {
+    validateDataRows(args.values, "createData");
+    if (hasDataset(this, id) || hasDatasetOwner(this, id)) {
       throw new Error(`Dataset "${id}" already exists.`);
     }
     return this.editSemantic({

package/src/actions/data/density.js

@@ -1,28 +1,15 @@
-import { deriveKernelDensity } from "../../grammar/density.js";
+import {
+  deriveKernelDensity,
+  normalizeDensityTransform
+} from "../../grammar/density.js";
 import { derivedCreator, derivedMaterializer } from "./shared.js";
 
 const OPTIONS = Object.freeze([
   "id", "source", "field", "groupBy", "bandwidth", "extent", "steps",
-  "kernel", "normalization", "as"
+  "kernel", "normalization", "as", "weight"
 ]);
 const CATEGORICAL_OPTIONS = Object.freeze([...OPTIONS, "placement"]);
 
-function densityTransform(args, placement) {
-  return {
-    type: "density",
-    field: args.field,
-    ...(args.groupBy === undefined ? {} : { groupBy: args.groupBy }),
-    bandwidth: args.bandwidth ?? "auto",
-    extent: args.extent ?? "auto",
-    steps: args.steps ?? 100,
-    kernel: args.kernel ?? "gaussian",
-    normalization: args.normalization ?? "unit",
-    as: args.as ?? [`${args.field}_value`, `${args.field}_density`],
-    resolve: "shared",
-    ...(placement === undefined ? {} : { placement })
-  };
-}
-
 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.`);
@@ -32,10 +19,13 @@ function requestedTransform(args, op, categorical = false) {
       "createCategoricalDensityData requires normalized category placement."
     );
   }
-  return densityTransform(args, categorical ? args.placement : undefined);
+  return normalizeDensityTransform({
+    ...args,
+    ...(categorical ? { placement: args.placement } : {})
+  });
 }
 
-export const materializeDensityData = derivedMaterializer(
+export const materializeDensityData = /* @__PURE__ */ derivedMaterializer(
   "materializeDensityData",
   "Materialize one grouped kernel-density dataset.",
   "density",
@@ -43,7 +33,9 @@ export const materializeDensityData = derivedMaterializer(
   (result, transform) => [{
     ...transform,
     resolved: {
-      bandwidth: result.bandwidth,
+      ...(result.bandwidth === undefined
+        ? { bandwidths: result.bandwidths }
+        : { bandwidth: result.bandwidth }),
       extent: result.extent,
       ...(result.splitDomain === undefined
         ? {}
@@ -52,7 +44,7 @@ export const materializeDensityData = derivedMaterializer(
   }]
 );
 
-export const createDensityData = derivedCreator(
+export const createDensityData = /* @__PURE__ */ derivedCreator(
   "createDensityData",
   "Create grouped kernel-density values.",
   OPTIONS,
@@ -62,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,