ggaction 0.0.12 → 0.0.15

package/src/actions/data/derived.js

@@ -1,21 +1,44 @@
 import { action } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
 import { validateKeys } from "../../core/validation.js";
-import { hasDataset } from "../../selectors/index.js";
-import { findDataset } from "../../selectors/datasets.js";
+import {
+  findDataset,
+  hasDataset,
+  hasDatasetOwner,
+  resolveDatasetReference
+} from "../../selectors/datasets.js";
 import { requireLayer } from "../../selectors/layers.js";
+import { applyLayerDataRematerialization } from
+  "../../materialization/dependencies.js";
+import { collectResourceReferences } from "../../core/resourceReferences.js";
 
 const OPTIONS = Object.freeze(["id", "source", "transform"]);
 const RELEASE_OPTIONS = Object.freeze(["id"]);
 const REBIND_OPTIONS = Object.freeze(["id", "data"]);
+const BIND_OPTIONS = Object.freeze(["target", "data"]);
+const OWNED_MARK_ROLES = Object.freeze([
+  "boxPlot",
+  "errorBand",
+  "errorBandBoundary",
+  "errorBar",
+  "gradientPlot",
+  "ecdfPlot",
+  "regression",
+  "statisticalReference"
+]);
 
 export const createDerivedData = action(
   { op: "createDerivedData", description: "Create an immutable derived dataset definition." },
   function (args = {}) {
     validateKeys(args, OPTIONS, "createDerivedData");
     const id = validateUserId(args.id, "Derived dataset id");
-    const source = validateUserId(args.source, "Source dataset id");
-    if (hasDataset(this, id)) {
+    const requestedSource = validateUserId(args.source, "Source dataset id");
+    const source = resolveDatasetReference(
+      this,
+      requestedSource,
+      "Source dataset"
+    ).id;
+    if (hasDataset(this, id) || hasDatasetOwner(this, id)) {
       throw new Error(`Dataset "${id}" already exists.`);
     }
     if (!hasDataset(this, source)) {
@@ -39,17 +62,26 @@ export const releaseDerivedData = action(
     if (dataset === undefined || dataset.source === undefined) {
       throw new Error(`Unknown derived dataset "${validatedId}".`);
     }
-    const referenced = this.semanticSpec.layers.some(
-      layer => layer.data === validatedId
-    ) || this.semanticSpec.datasets.some(
-      candidate => candidate.source === validatedId
+    const references = collectResourceReferences(this, {
+      kind: "data",
+      id: validatedId
+    });
+    const selfOwners = references.filter(reference =>
+      reference.ownerKind === "dataOwner" &&
+      reference.path.at(-1) === "current"
     );
-    return referenced
-      ? this
-      : this.editSemantic({
-          property: `dataset[${validatedId}]`,
-          remove: true
-        });
+    if (references.some(reference =>
+      reference.strength === "live" && !selfOwners.includes(reference)
+    )) return this;
+    let next = this.editSemantic({
+      property: `dataset[${validatedId}]`,
+      remove: true
+    });
+    for (const owner of selfOwners) {
+      const [, family, ownerId] = owner.path;
+      next = next._withoutMaterializationConfig(["data", family, ownerId]);
+    }
+    return next;
   }
 );
 
@@ -61,7 +93,12 @@ export const rebindLayerData = action(
   function (args = {}) {
     validateKeys(args, REBIND_OPTIONS, "rebindLayerData");
     const id = validateUserId(args.id, "Layer id");
-    const data = validateUserId(args.data, "Layer dataset id");
+    const requestedData = validateUserId(args.data, "Layer dataset id");
+    const data = resolveDatasetReference(
+      this,
+      requestedData,
+      "Layer dataset"
+    ).id;
     requireLayer(this, id);
     if (!hasDataset(this, data)) {
       throw new Error(`Layer dataset "${data}" does not exist.`);
@@ -72,3 +109,62 @@ export const rebindLayerData = action(
     });
   }
 );
+
+function assertIndependentMark(program, layer) {
+  const config = program.markConfigs[layer.id] ?? {};
+  const role = OWNED_MARK_ROLES.find(key => config[key] !== undefined);
+  if (role !== undefined) {
+    throw new Error(
+      `Mark "${layer.id}" is owned by its ${role} lifecycle; use that ` +
+      "resource's edit action to change data roles."
+    );
+  }
+  const source = findDataset(program, layer.data);
+  const transform = source?.transform?.[0]?.type;
+  if (["density", "ecdf", "horizon", "markFilter"].includes(transform)) {
+    throw new Error(
+      `Mark "${layer.id}" consumes owned ${transform} data; use its ` +
+      "data or filter lifecycle action to change the source."
+    );
+  }
+}
+
+function applyMarkDataBinding(program, target, data) {
+  const rebound = program.rebindLayerData({ id: target, data });
+  return applyLayerDataRematerialization(rebound, target);
+}
+
+export const bindMarkData = action(
+  {
+    op: "bindMarkData",
+    description: "Atomically bind one independent mark to materialized data."
+  },
+  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(
+      this,
+      requestedData,
+      "Mark dataset"
+    ).id;
+    const layer = requireLayer(this, target);
+    const dataset = findDataset(this, data);
+    if (dataset === undefined) {
+      throw new Error(`Mark dataset "${data}" does not exist.`);
+    }
+    if (!Array.isArray(dataset.values)) {
+      throw new Error(`Mark dataset "${data}" requires materialized values.`);
+    }
+    if (layer.data === data) {
+      throw new Error(`Mark "${target}" already uses dataset "${data}".`);
+    }
+    assertIndependentMark(this, layer);
+
+    // Finish the entire dependency plan on an immutable speculative branch.
+    // A field, type, coordinate, scale, guide, label, selection, or highlight
+    // incompatibility therefore rejects before this action returns any state.
+    applyMarkDataBinding(this, target, data);
+    return applyMarkDataBinding(this, target, data);
+  }
+);

package/src/actions/data/ecdf.js

@@ -0,0 +1,38 @@
+import {
+  deriveECDF,
+  normalizeECDFTransform,
+  resolveECDFTransform
+} from "../../grammar/ecdf.js";
+import { derivedCreator, derivedMaterializer } from "./shared.js";
+
+const OPTIONS = Object.freeze([
+  "id", "source", "field", "groupBy", "weight", "missing", "as"
+]);
+
+export const materializeECDFData = derivedMaterializer(
+  "materializeECDFData",
+  "Materialize one empirical cumulative distribution dataset.",
+  "ecdf",
+  deriveECDF,
+  resolveECDFTransform
+);
+
+export const createECDFData = derivedCreator(
+  "createECDFData",
+  "Create immutable empirical cumulative distribution values.",
+  OPTIONS,
+  "ECDF dataset id",
+  "ECDF source dataset id",
+  (args, id) => normalizeECDFTransform({
+    field: args.field,
+    groupBy: args.groupBy,
+    weight: args.weight,
+    missing: args.missing,
+    as: args.as ?? {
+      value: `__${id}_value`,
+      cumulative: `__${id}_cumulative`,
+      probability: `__${id}_probability`
+    }
+  }),
+  "materializeECDFData"
+);