ggaction 0.0.13 → 0.0.16

package/src/actions/data/derived.js

@@ -1,11 +1,16 @@
-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 { 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"]);
@@ -18,16 +23,21 @@ const OWNED_MARK_ROLES = Object.freeze([
   "errorBar",
   "gradientPlot",
   "ecdfPlot",
-  "regression"
+  "regression",
+  "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 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,41 +49,53 @@ 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) {
       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;
   }
 );
 
-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 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.`);
@@ -109,15 +131,19 @@ 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 data = validateUserId(args.data, "Mark dataset 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) {

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,