ggaction 0.0.4 → 0.0.5

package/src/actions/data/derived.js

@@ -3,9 +3,11 @@ 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 { requireLayer } from "../../selectors/layers.js";
 
 const OPTIONS = Object.freeze(["id", "source", "transform"]);
 const RELEASE_OPTIONS = Object.freeze(["id"]);
+const REBIND_OPTIONS = Object.freeze(["id", "data"]);
 
 export const createDerivedData = action(
   { op: "createDerivedData", description: "Create an immutable derived dataset definition." },
@@ -50,3 +52,23 @@ export const releaseDerivedData = action(
         });
   }
 );
+
+export const rebindLayerData = action(
+  {
+    op: "rebindLayerData",
+    description: "Rebind one semantic layer to an existing dataset."
+  },
+  function (args = {}) {
+    validateKeys(args, REBIND_OPTIONS, "rebindLayerData");
+    const id = validateUserId(args.id, "Layer id");
+    const data = validateUserId(args.data, "Layer dataset id");
+    requireLayer(this, id);
+    if (!hasDataset(this, data)) {
+      throw new Error(`Layer dataset "${data}" does not exist.`);
+    }
+    return this.editSemantic({
+      property: `layer[${id}].data`,
+      value: data
+    });
+  }
+);

package/src/actions/data/filter.js

@@ -125,6 +125,11 @@ export const filterMarks = action(
         candidate.data !== undefined &&
         findSelectionPolicy(candidate.mark?.type) !== undefined
     });
+    if (this.markConfigs[layer.id]?.itemFilterable === false) {
+      throw new Error(
+        `filterMarks does not support composite mark "${layer.id}"; filter its source dataset first.`
+      );
+    }
     const derivedId = `${layer.id}FilteredData`;
     if (hasDataset(this, derivedId)) {
       throw new Error(`Dataset "${derivedId}" already exists.`);

package/src/actions/data/gradientProfile.js

@@ -0,0 +1,65 @@
+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";
+
+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 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 });
+  }
+);

package/src/actions/data/horizon.js

@@ -0,0 +1,71 @@
+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";
+
+const OPTIONS = Object.freeze([
+  "id", "source", "x", "y", "groupBy", "bands", "baseline", "extent",
+  "resolve", "missing", "overflow", "palette", "as"
+]);
+
+function requestedTransform(args) {
+  return validateHorizonTransform({
+    type: "horizon",
+    x: args.x,
+    y: args.y,
+    ...(args.groupBy === undefined ? {} : { groupBy: args.groupBy }),
+    bands: args.bands ?? 3,
+    baseline: args.baseline ?? 0,
+    extent: args.extent ?? "auto",
+    resolve: args.resolve ?? "shared",
+    missing: args.missing ?? "break",
+    overflow: args.overflow ?? "clip",
+    palette: args.palette ?? {},
+    as: args.as
+  });
+}
+
+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 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 });
+  }
+);

package/src/actions/data/index.js

@@ -1,5 +1,9 @@
 import { createData } from "./create.js";
-import { createDerivedData, releaseDerivedData } from "./derived.js";
+import {
+  createDerivedData,
+  rebindLayerData,
+  releaseDerivedData
+} from "./derived.js";
 import {
   filterData,
   filterMarks,
@@ -7,24 +11,47 @@ import {
   materializeMarkFilteredData
 } from "./filter.js";
 import { createRegressionData, materializeRegressionData } from "./regression.js";
-import { createDensityData, materializeDensityData } from "./density.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 { createBin2DData, materializeBin2DData } from "./bin2d.js";
 import { createBoxSummaryData, createBoxOutlierData, materializeBoxSummaryData, materializeBoxOutlierData } from "./box.js";
 
 export function registerDataActions(ProgramClass) {
   ProgramClass.prototype.createData = createData;
   ProgramClass.prototype.createDerivedData = createDerivedData;
   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.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.createHorizonData = createHorizonData;
+  ProgramClass.prototype.materializeHorizonData = materializeHorizonData;
+  ProgramClass.prototype.createWindowData = createWindowData;
+  ProgramClass.prototype.materializeWindowData = materializeWindowData;
+  ProgramClass.prototype.createBin2DData = createBin2DData;
+  ProgramClass.prototype.materializeBin2DData = materializeBin2DData;
   ProgramClass.prototype.createBoxSummaryData = createBoxSummaryData;
   ProgramClass.prototype.createBoxOutlierData = createBoxOutlierData;
   ProgramClass.prototype.materializeBoxSummaryData = materializeBoxSummaryData;

package/src/actions/data/window.js

@@ -0,0 +1,50 @@
+import { action } from "../../core/action.js";
+import { validateUserId } from "../../core/identifiers.js";
+import { validateKeys } from "../../core/validation.js";
+import {
+  deriveWindowRows,
+  normalizeWindowTransform
+} from "../../grammar/window.js";
+import { MATERIALIZE_OPTIONS, requireDerivedDataset } from "./shared.js";
+
+const OPTIONS = Object.freeze([
+  "id", "source", "partitionBy", "sortBy", "operations"
+]);
+
+export const materializeWindowData = action(
+  {
+    op: "materializeWindowData",
+    description: "Materialize one immutable window-derived dataset."
+  },
+  function (args = {}) {
+    validateKeys(args, MATERIALIZE_OPTIONS, "materializeWindowData");
+    const { id, source, transform } = requireDerivedDataset(
+      this,
+      args.id,
+      "window"
+    );
+    return this.editSemantic({
+      property: `dataset[${id}].values`,
+      value: deriveWindowRows(source.values, transform)
+    });
+  }
+);
+
+export const createWindowData = action(
+  {
+    op: "createWindowData",
+    description: "Create immutable partitioned window values."
+  },
+  function (args = {}) {
+    validateKeys(args, OPTIONS, "createWindowData");
+    const id = validateUserId(args.id, "Window dataset id");
+    const source = validateUserId(
+      args.source ?? this.context.currentData,
+      "Source dataset id"
+    );
+    const transform = normalizeWindowTransform(args);
+    return this
+      .createDerivedData({ id, source, transform: [transform] })
+      .materializeWindowData({ id });
+  }
+);

package/src/actions/encodings/color/index.js

@@ -19,6 +19,8 @@ import { applyMaterializationPlan } from "../../../materialization/dependencies.
 import {
   planEncodingRematerialization
 } from "../../../materialization/encodings.js";
+import { findUpstreamTransform } from
+  "../../../materialization/dataProvenance.js";
 import { encodeContinuousColor } from "./continuous.js";
 import {
   applyColorLayoutCompanion,
@@ -56,10 +58,24 @@ const encodeColor = action(
       "color mark"
     );
     assertNoConstantColor(this, layer);
+    const densityTransform = dataset.transform?.length === 1 &&
+      dataset.transform[0].type === "density"
+      ? dataset.transform[0]
+      : undefined;
+    const densitySeriesFields = densityTransform?.placement?.type === "category"
+      ? [densityTransform.groupBy, densityTransform.placement.split?.field]
+          .filter(Boolean)
+      : [];
+    const horizonTransform = findUpstreamTransform(this, dataset, "horizon");
+    const horizonColor = horizonTransform !== undefined &&
+      horizonTransform.as?.color === args.field &&
+      layer.encoding?.group?.field === horizonTransform.as?.group;
     if (
       layer.mark.type === "area" &&
       (layer.encoding?.group?.field === undefined ||
-        layer.encoding.group.field !== args.field)
+        layer.encoding.group.field !== args.field) &&
+      !densitySeriesFields.includes(args.field) &&
+      !horizonColor
     ) {
       throw new Error(
         "Area color encoding must match an existing group encoding."

package/src/actions/encodings/color/layout.js

@@ -18,6 +18,14 @@ export function applyColorLayoutCompanion(
   ) {
     return program;
   }
+  if (
+    layer.mark.type === "area" &&
+    [layer.encoding?.x, layer.encoding?.y].some(
+      encoding => ["nominal", "ordinal"].includes(encoding?.fieldType)
+    )
+  ) {
+    return program;
+  }
   if (isRangedArea(layer)) return program;
   const channels = layer.mark.type === "bar"
     ? resolveBarChannels(layer)

package/src/actions/encodings/density/resolve.js

@@ -0,0 +1,109 @@
+import { isPlainObject } from "../../../core/immutable.js";
+import { findSemanticScale } from "../../../selectors/scales.js";
+
+export function requireDensityField(value, label) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new TypeError(`${label} must be a non-empty string.`);
+  }
+  return value;
+}
+
+export function resolveDensityScaleOptions(value, defaults, label) {
+  if (value !== undefined && !isPlainObject(value)) {
+    throw new TypeError(`${label} must be a plain object.`);
+  }
+  return { ...defaults, ...(value ?? {}) };
+}
+
+export function resolveDensityCategoryScaleOptions(value, fallbackId) {
+  const scale = resolveDensityScaleOptions(
+    value,
+    { type: "band" },
+    "Density placement scale"
+  );
+  if ((scale.type ?? "band") !== "band") {
+    throw new Error('Density category placement requires scale type "band".');
+  }
+  return {
+    ...(fallbackId === undefined ? {} : { id: fallbackId }),
+    ...scale,
+    type: "band"
+  };
+}
+
+function valueScaleForTransition(program, layer, transform) {
+  const densityChannel = transform.placement?.channel ?? (
+    layer.encoding.x.field === transform.as[1] ? "x" : "y"
+  );
+  const valueChannel = densityChannel === "x" ? "y" : "x";
+  return findSemanticScale(program, layer.encoding[valueChannel].scale);
+}
+
+export function resolveDensityTransitionScaleDefinitions(
+  program,
+  layer,
+  transform,
+  placement,
+  rawPlacement
+) {
+  const valueScale = valueScaleForTransition(program, layer, transform);
+  if (valueScale === undefined) {
+    throw new Error(`Density area "${layer.id}" requires its value scale.`);
+  }
+  const { id: _valueId, range: _valueRange, ...valueDefinition } = valueScale;
+  void _valueId;
+  void _valueRange;
+  const valueChannel = placement?.channel === "x" ? "y" : "x";
+  const companionChannel = valueChannel === "x" ? "y" : "x";
+  const companionDefinition = placement === undefined
+    ? { type: "linear", domain: "auto", range: "auto", nice: true, zero: true }
+    : resolveDensityCategoryScaleOptions(rawPlacement.scale);
+  return {
+    [valueChannel]: { ...valueDefinition, range: "auto" },
+    [companionChannel]: companionDefinition
+  };
+}
+
+export function resolveDensityPositionDefinition({
+  layer,
+  output,
+  groupBy,
+  placement,
+  coordinate,
+  valueScale,
+  densityScale,
+  placementScale
+}) {
+  if (placement === undefined) {
+    const xIsDensity = layer.densityChannel === "x";
+    return {
+      x: {
+        field: output[xIsDensity ? 1 : 0],
+        fieldType: "quantitative",
+        scale: xIsDensity ? densityScale : valueScale,
+        coordinate
+      },
+      y: {
+        field: output[xIsDensity ? 0 : 1],
+        fieldType: "quantitative",
+        scale: xIsDensity ? valueScale : densityScale,
+        coordinate
+      }
+    };
+  }
+  const category = {
+    field: placement.categoryField,
+    fieldType: "nominal",
+    scale: placementScale,
+    coordinate
+  };
+  const value = {
+    field: output[0],
+    fieldType: "quantitative",
+    scale: valueScale,
+    coordinate
+  };
+  return placement.channel === "x"
+    ? { x: category, y: value }
+    : { x: value, y: category };
+}