ggaction 0.0.16 → 0.0.17

package/src/actions/regression/edit.js

@@ -7,7 +7,7 @@ import {
   validateNonNegativeFinite,
   validateUnitInterval
 } from "../../core/validation.js";
-import { normalizeRegressionParameters } from "../../grammar/regression/index.js";
+import { normalizeRegressionParameters, normalizeRegressionPredict } from "../../grammar/regression/index.js";
 import { validateCurveInterpolation } from "../../grammar/curveCommands.js";
 import {
   requestedStrokeDetails,
@@ -23,6 +23,7 @@ import { requireRegressionField } from "./resolve.js";
 const OPTIONS = Object.freeze([
   "target", "data", "x", "y", "groupBy", "method", "degree", "span",
   "confidenceMethod", "level", "confidence", "interval", "band", "line"
+  , "predict", "sourceBinding", "missing"
 ]);
 const BAND_OPTIONS = Object.freeze([
   "color", "opacity", "stroke", "strokeWidth", "curve",
@@ -115,7 +116,7 @@ function resolveParameters(previous, args) {
     if (Object.hasOwn(args, key)) raw[key] = args[key];
   }
   const inheritsLevel = !Object.hasOwn(raw, "confidence");
-  if (method === previous.method) {
+  if (method === previous.method && args.interval !== false) {
     for (const key of [
       "degree", "span", "confidenceMethod", "level", "interval"
     ]) {
@@ -127,7 +128,7 @@ function resolveParameters(previous, args) {
         raw[key] = previous[key];
       }
     }
-  } else if (method !== "loess" && previous.method !== "loess") {
+  } else if (method !== "loess" && previous.method !== "loess" && args.interval !== false) {
     for (const key of ["confidenceMethod", "level", "interval"]) {
       if (
         !Object.hasOwn(raw, key) &&
@@ -138,7 +139,19 @@ function resolveParameters(previous, args) {
       }
     }
   }
-  return normalizeRegressionParameters(raw);
+  const parameters = normalizeRegressionParameters(raw);
+  const predict = Object.hasOwn(args, "predict")
+    ? args.predict === false ? undefined : normalizeRegressionPredict(args.predict)
+    : previous.predict;
+  const missing = Object.hasOwn(args, "missing") ? args.missing : previous.missing;
+  if (missing !== undefined && !["error", "drop"].includes(missing)) {
+    throw new Error('Regression missing must be "error" or "drop".');
+  }
+  return {
+    ...parameters,
+    ...(predict === undefined ? {} : { predict }),
+    ...(missing === undefined ? {} : { missing })
+  };
 }
 
 function regressionColorScale(owner, current, groupBy) {
@@ -245,15 +258,31 @@ export const editRegression = /* @__PURE__ */ closedAction(
     }
     const owner = resolveRegressionOwner(this, args.target);
     const current = this.markConfigs[owner.id].regression;
-    const source = Object.hasOwn(args, "data")
+    const currentBinding = owner.derivedBindings?.regression?.mode === "follow" ? "follow" : "fixed";
+    const sourceBinding = args.sourceBinding ?? currentBinding;
+    if (!["fixed", "follow"].includes(sourceBinding)) throw new Error('Regression sourceBinding must be "fixed" or "follow".');
+    const followed = sourceBinding === "follow" ? {
+      data: owner.data,
+      x: owner.encoding?.x?.fieldType === "quantitative" ? owner.encoding.x.field : undefined,
+      y: owner.encoding?.y?.fieldType === "quantitative" ? owner.encoding.y.field : undefined
+    } : undefined;
+    if (sourceBinding === "follow" && (!followed.data || !followed.x || !followed.y)) {
+      throw new Error(`Following regression source "${owner.id}" requires quantitative x/y fields and data.`);
+    }
+    for (const key of ["data", "x", "y"]) {
+      if (followed !== undefined && Object.hasOwn(args, key) && args[key] !== followed[key]) {
+        throw new Error(`Following regression ${key} must match source mark "${owner.id}".`);
+      }
+    }
+    const source = followed?.data ?? (Object.hasOwn(args, "data")
       ? validateUserId(args.data, "Regression data id")
-      : current.source;
-    const x = Object.hasOwn(args, "x")
+      : current.source);
+    const x = followed?.x ?? (Object.hasOwn(args, "x")
       ? requireRegressionField(args.x, "Regression x")
-      : current.x;
-    const y = Object.hasOwn(args, "y")
+      : current.x);
+    const y = followed?.y ?? (Object.hasOwn(args, "y")
       ? requireRegressionField(args.y, "Regression y")
-      : current.y;
+      : current.y);
     const groupBy = Object.hasOwn(args, "groupBy")
       ? args.groupBy === false
         ? undefined
@@ -272,12 +301,12 @@ export const editRegression = /* @__PURE__ */ closedAction(
     const linePatch = Object.hasOwn(args, "line")
       ? validateLinePatch(args.line)
       : undefined;
-    if (parameters.method === "loess" && bandPatch !== undefined && bandPatch !== false) {
+    if ((parameters.method === "loess" || parameters.interval === false) && bandPatch !== undefined && bandPatch !== false) {
       throw new Error("LOESS regression does not support a band object.");
     }
 
     const hadBand = current.bandId !== undefined;
-    const wantsBand = parameters.method !== "loess" &&
+    const wantsBand = parameters.method !== "loess" && parameters.interval !== false &&
       (bandPatch === false
         ? false
         : hadBand || bandPatch !== undefined || current.parameters.method === "loess");
@@ -385,6 +414,12 @@ export const editRegression = /* @__PURE__ */ closedAction(
       if (changesStatistics) {
         next = next.releaseDerivedData(revision.release);
       }
+      const binding = findLayer(next, owner.id)?.derivedBindings?.regression;
+      if (sourceBinding === "follow" && binding?.mode !== "follow") {
+        next = next.editSemantic({ property: `layer[${owner.id}].derivedBindings.regression`, value: { mode: "follow", roles: ["data", "x", "y"] } });
+      } else if (sourceBinding === "fixed" && binding !== undefined) {
+        next = next.editSemantic({ property: `layer[${owner.id}].derivedBindings.regression`, remove: true });
+      }
       return next;
     };
     return applyEdit(this);

package/src/actions/regression/follow.js

@@ -0,0 +1,22 @@
+export function reconcileFollowingRegressions(program) {
+  let next = program;
+  for (const layer of program.semanticSpec.layers) {
+    if (layer.derivedBindings?.regression?.mode !== "follow") continue;
+    const config = next.markConfigs[layer.id]?.regression;
+    if (config === undefined) continue;
+    const x = layer.encoding?.x;
+    const y = layer.encoding?.y;
+    if (typeof layer.data !== "string" || x?.fieldType !== "quantitative" || y?.fieldType !== "quantitative" ||
+        typeof x.field !== "string" || typeof y.field !== "string") {
+      throw new Error(`Following regression source "${layer.id}" requires quantitative x/y fields and data.`);
+    }
+    if (config.source === layer.data && config.x === x.field && config.y === y.field) continue;
+    next = next.editRegression({
+      target: layer.id,
+      data: layer.data,
+      x: x.field,
+      y: y.field
+    });
+  }
+  return next;
+}

package/src/actions/scales/channels.js

@@ -10,7 +10,7 @@ const DEFINITIONS = Object.freeze({
   editXScale: Object.freeze({
     channel: "x",
     options: Object.freeze([
-      "type", "domain", "range", "nice", "zero", "clamp", "reverse",
+      "type", "domain", "range", "emptyDomain", "nice", "zero", "clamp", "reverse",
       "base", "exponent", "constant", "paddingInner", "paddingOuter",
       "padding", "align", "unknown"
     ])
@@ -18,7 +18,7 @@ const DEFINITIONS = Object.freeze({
   editYScale: Object.freeze({
     channel: "y",
     options: Object.freeze([
-      "type", "domain", "range", "nice", "zero", "clamp", "reverse",
+      "type", "domain", "range", "emptyDomain", "nice", "zero", "clamp", "reverse",
       "base", "exponent", "constant", "paddingInner", "paddingOuter",
       "padding", "align", "unknown"
     ])
@@ -26,21 +26,21 @@ const DEFINITIONS = Object.freeze({
   editThetaScale: Object.freeze({
     channel: "theta",
     options: Object.freeze([
-      "type", "domain", "range", "nice", "zero", "clamp", "reverse",
+      "type", "domain", "range", "emptyDomain", "nice", "zero", "clamp", "reverse",
       "paddingInner", "paddingOuter", "padding", "align"
     ])
   }),
   editRScale: Object.freeze({
     channel: "radius",
     options: Object.freeze([
-      "type", "domain", "range", "nice", "zero", "clamp", "reverse",
+      "type", "domain", "range", "emptyDomain", "nice", "zero", "clamp", "reverse",
       "base", "exponent", "constant", "radialMapping"
     ])
   }),
   editColorScale: Object.freeze({
     channel: "color",
     options: Object.freeze([
-      "type", "domain", "range", "clamp", "reverse", "palette",
+      "type", "domain", "range", "emptyDomain", "clamp", "reverse", "palette",
       "interpolate", "midpoint", "unknown"
     ])
   }),
@@ -48,37 +48,37 @@ const DEFINITIONS = Object.freeze({
     channel: "stroke",
     targetOnly: true,
     options: Object.freeze([
-      "type", "domain", "range", "clamp", "reverse", "palette",
+      "type", "domain", "range", "emptyDomain", "clamp", "reverse", "palette",
       "interpolate", "midpoint", "unknown"
     ])
   }),
   editSizeScale: Object.freeze({
     channel: "size",
     options: Object.freeze([
-      "type", "domain", "range", "unknown", "clamp", "reverse", "base",
+      "type", "domain", "range", "emptyDomain", "unknown", "clamp", "reverse", "base",
       "exponent"
     ])
   }),
   editOpacityScale: Object.freeze({
     channel: "opacity",
     options: Object.freeze([
-      "type", "domain", "range", "nice", "zero", "clamp", "reverse", "unknown"
+      "type", "domain", "range", "emptyDomain", "nice", "zero", "clamp", "reverse", "unknown"
     ])
   }),
   editShapeScale: Object.freeze({
     channel: "shape",
-    options: Object.freeze(["type", "domain", "range", "unknown"])
+    options: Object.freeze(["type", "domain", "range", "emptyDomain", "unknown"])
   }),
   editStrokeWidthScale: Object.freeze({
     channel: "strokeWidth",
     options: Object.freeze([
-      "type", "domain", "range", "nice", "zero", "clamp", "reverse",
+      "type", "domain", "range", "emptyDomain", "nice", "zero", "clamp", "reverse",
       "base", "exponent", "constant"
     ])
   }),
   editStrokeDashScale: Object.freeze({
     channel: "strokeDash",
-    options: Object.freeze(["type", "domain", "range"])
+    options: Object.freeze(["type", "domain", "range", "emptyDomain"])
   })
 });
 

package/src/actions/scales/consumers/common.js

@@ -5,6 +5,7 @@ import { readScaleField } from "../../../grammar/scales/index.js";
 import { findDataset } from "../../../selectors/datasets.js";
 import { requireSemanticScale } from "../../../selectors/scales.js";
 import { SCALED_ENCODING_CHANNELS } from "../../../core/vocabulary.js";
+import { applyItemMissingPolicy } from "../../../grammar/itemMissing.js";
 
 export function findScale(program, id) {
   return requireSemanticScale(program, id);
@@ -39,7 +40,7 @@ export function requireConsumerDataset(program, consumer) {
       `Mark "${consumer.layer.id}" references unknown dataset "${consumer.layer.data}".`
     );
   }
-  return dataset;
+  return applyItemMissingPolicy(consumer.layer, dataset);
 }
 
 export function isDirectCategoricalConsumer(consumer) {

package/src/actions/scales/create.js

@@ -24,6 +24,7 @@ const CREATE_SCALE_OPTIONS = Object.freeze([
   "id",
   "type",
   "domain",
+  "emptyDomain",
   "range",
   "nice",
   "zero",
@@ -164,7 +165,7 @@ export const createScale = /* @__PURE__ */ action(
       .editSemantic({ property: `scale[${id}].range`, value: definition.range });
 
     for (const property of [
-      "nice", "zero", "clamp", "reverse", "base", "exponent", "constant",
+      "emptyDomain", "nice", "zero", "clamp", "reverse", "base", "exponent", "constant",
       "paddingInner", "paddingOuter", "padding", "align", "interpolate", "midpoint",
       "radialMapping", "unknown"
     ]) {

package/src/actions/scales/definitions.js

@@ -37,7 +37,7 @@ import { resolveRequestedOffsetPolicy } from
   "../../materialization/scales/policies/offset.js";
 import { findScaleConsumers } from "./consumers/index.js";
 
-const BASE_OPTIONS = ["id", "type", "domain", "range"];
+const BASE_OPTIONS = ["id", "type", "domain", "range", "emptyDomain"];
 const UNKNOWN_OPTIONS = [...BASE_OPTIONS, "unknown"];
 const CLAMP_REVERSE = ["clamp", "reverse"];
 const BOOLEAN_OPTIONS = ["nice", "zero", ...CLAMP_REVERSE];

package/src/actions/scales/edit.js

@@ -26,7 +26,7 @@ import { hasExactLegendSamplingForScale } from
   "../guides/legends/sampling.js";
 
 const OPTIONS = Object.freeze([
-  "id", "type", "domain", "range", "nice", "zero", "clamp", "reverse",
+  "id", "type", "domain", "range", "emptyDomain", "nice", "zero", "clamp", "reverse",
   "base", "exponent", "constant", "paddingInner", "paddingOuter", "padding",
   "align", "interpolate", "midpoint", "unknown", "palette", "radialMapping"
 ]);

package/src/actions/scales/parallel.js

@@ -6,7 +6,7 @@ import { requireLayer } from "../../selectors/layers.js";
 import { requireSemanticScale } from "../../selectors/scales.js";
 
 const QUANTITATIVE_OPTIONS = Object.freeze([
-  "type", "domain", "range", "nice", "zero", "clamp", "reverse",
+  "type", "domain", "range", "emptyDomain", "nice", "zero", "clamp", "reverse",
   "base", "exponent", "constant", "unknown"
 ]);
 const ORDINAL_OPTIONS = Object.freeze([

package/src/actions/scales/patch.js

@@ -1,5 +1,5 @@
 const SCALE_EDIT_PROPERTIES = Object.freeze([
-  "type", "domain", "range", "nice", "zero", "clamp", "reverse",
+  "type", "domain", "range", "emptyDomain", "nice", "zero", "clamp", "reverse",
   "base", "exponent", "constant", "paddingInner", "paddingOuter",
   "padding", "align", "interpolate", "midpoint", "unknown"
 ]);

package/src/actions/scales/preview.js

@@ -9,7 +9,10 @@ import {
   resolveScaleConsumerBounds
 } from "../../materialization/coordinateBounds.js";
 import { requireCoordinate } from "../../selectors/coordinates.js";
-import { resolveScaleMaterialization } from "../../materialization/scales/resolve.js";
+import {
+  rememberResolvedScaleBinding,
+  resolveScaleMaterialization
+} from "../../materialization/scales/resolve.js";
 import { findScale, findScaleConsumers, resolveConsumerCategoryOrder,
   resolveConsumerValues, resolveSeriesLayoutScaleValues } from "./consumers/index.js";
 
@@ -126,6 +129,30 @@ export function resolveScalePreview(program, id) {
   return resolveScalePreviewAtBounds(program, id, bounds);
 }
 
+export function restoreResolvedScaleBindings(program) {
+  for (const scale of program.semanticSpec.scales) {
+    const resolved = program.resolvedScales[scale.id];
+    if (resolved === undefined) continue;
+    const consumers = findScaleConsumers(program, scale.id);
+    const channels = new Set(consumers.map(consumer =>
+      normalizePositionScaleChannel(consumer.channel)
+    ));
+    const families = new Set([...channels].map(channel =>
+      channel === "stroke" ? "color" : channel
+    ));
+    if (families.size === 1) {
+      const channel = channels.size === 1
+        ? channels.values().next().value
+        : families.values().next().value;
+      rememberResolvedScaleBinding(resolved, channel, consumers);
+    }
+  }
+  for (const child of Object.values(program.children)) {
+    restoreResolvedScaleBindings(child);
+  }
+  return program;
+}
+
 export function validatePendingMeasuredScale(program, scale, consumers) {
   const bounds = resolveScaleConsumerBounds(program, consumers);
   const range = resolveArcAutoPositionRange({ consumers, scale, channel: "radius",

package/src/actions/theme/reconcile.js

@@ -6,6 +6,7 @@ import {
   setThemeStateOverrides
 } from "./state.js";
 import { findLayer } from "../../selectors/layers.js";
+import { reconcileFollowingRegressions } from "../regression/follow.js";
 
 let rematerializeThemeHighlights = program => program;
 
@@ -979,6 +980,7 @@ function collectOverrides(program) {
 }
 
 export function reconcileProgramTheme(program, { source, metadata }) {
+  program = reconcileFollowingRegressions(program);
   const storedState = program.materializationConfigs.theme;
   if (storedState === undefined) return program;
   // Data/context/trace-only transitions cannot change authored appearance.

package/src/core/action.js

@@ -192,7 +192,8 @@ export function action(metadata, implementation) {
   const ownedMetadata = freezeOwned({
     op: metadata.op,
     description: metadata.description,
-    scope
+    scope,
+    ...(Array.isArray(metadata.options) ? { options: [...metadata.options] } : {})
   });
 
   const wrappedAction = function wrappedAction(args = {}) {
@@ -240,7 +241,7 @@ export function action(metadata, implementation) {
 // Private built-in convenience: action() owns the object boundary and trace,
 // while each definition supplies its closed option vocabulary exactly once.
 export function closedAction(metadata, options, implementation) {
-  return action(metadata, function (args = {}) {
+  return action({ ...metadata, options }, function (args = {}) {
     if (options !== undefined) validateKeys(args, options, metadata.op);
     return implementation.call(this, args);
   });

package/src/core/programState.js

@@ -34,12 +34,16 @@ export function ownChildPrograms(children, ProgramClass) {
 // domain's dependency validation and before the primitive deletion.
 export function releaseNamedResourceOwnership(program, { kind, id, dataOwner }) {
   if (kind !== "data") return program;
-  const materializationConfigs = dataOwner === undefined
+  let materializationConfigs = dataOwner === undefined
     ? program.materializationConfigs
     : removeMaterializationConfig(
         program.materializationConfigs,
         ["data", dataOwner.family, dataOwner.owner]
       ).value;
+  materializationConfigs = removeMaterializationConfig(
+    materializationConfigs,
+    ["calculations", "datasets", dataOwner?.current ?? id]
+  ).value;
   const context = program.context.currentData === id
     ? freezeOwned({ ...program.context, currentData: undefined })
     : program.context;

package/src/grammar/bin.js

@@ -15,7 +15,7 @@ import {
 
 const TRANSFORM_KEYS = Object.freeze([
   "type", "field", "bin", "extent", "nice", "zero", "includeEmpty",
-  "members", "as", "weight", "resolved"
+  "members", "as", "weight", "missing", "resolved"
 ]);
 const AS_KEYS = Object.freeze(["lower", "upper", "count", "members"]);
 const RESOLVED_KEYS = Object.freeze(["domain", "step", "boundaries"]);
@@ -59,7 +59,8 @@ export function normalizeBinTransform({
   includeEmpty,
   members,
   as,
-  weight
+  weight,
+  missing
 } = {}) {
   const selected = [maxBins, step, boundaries].filter(value => value !== undefined);
   if (selected.length > 1) {
@@ -83,7 +84,8 @@ export function normalizeBinTransform({
     as: normalizeAs(field, as, resolvedMembers),
     ...(weight === undefined
       ? {}
-      : { weight: normalizeStatisticalWeight(weight, "Bin weight") })
+      : { weight: normalizeStatisticalWeight(weight, "Bin weight") }),
+    ...(missing === undefined ? {} : { missing })
   };
   validateBinTransform(transform);
   return cloneAndFreeze(transform);
@@ -101,6 +103,9 @@ export function validateBinTransform(transform) {
   if (transform.weight !== undefined) {
     normalizeStatisticalWeight(transform.weight, "Bin weight");
   }
+  if (transform.missing !== undefined && !["error", "drop"].includes(transform.missing)) {
+    throw new Error('Bin missing must be "error" or "drop".');
+  }
   normalizeHistogramBin(transform.bin);
   if (
     transform.extent !== "auto" &&
@@ -142,22 +147,31 @@ export function validateBinTransform(transform) {
   return transform;
 }
 
-function readValues(rows, field) {
-  return rows.map((row, index) => {
+function readValues(rows, field, missing) {
+  const eligible = [];
+  let excluded = 0;
+  rows.forEach((row, index) => {
     const value = row[field];
+    if (value === null || value === undefined) {
+      if (missing === "drop") { excluded += 1; return; }
+      throw new TypeError(`Bin field "${field}" must contain a finite number at row ${index}.`);
+    }
     if (!Number.isFinite(value)) {
       throw new TypeError(`Bin field "${field}" must contain a finite number at row ${index}.`);
     }
-    return value;
+    eligible.push({ row, index });
   });
+  return { eligible, excluded };
 }
 
 export function deriveBinRows(rows, transform) {
   validateBinTransform(transform);
-  const values = readValues(rows, transform.field);
+  const selected = readValues(rows, transform.field, transform.missing);
+  const eligibleRows = selected.eligible.map(entry => entry.row);
+  const values = eligibleRows.map(row => row[transform.field]);
   const weights = transform.weight === undefined
     ? undefined
-    : readStatisticalWeights(rows, transform.weight, "Bin");
+    : readStatisticalWeights(eligibleRows, transform.weight, "Bin");
   if (weights !== undefined) {
     validateWeightedNumericFields(weights.entries, [transform.field], "Bin");
   }
@@ -188,7 +202,7 @@ export function deriveBinRows(rows, transform) {
   });
   const members = resolved.boundaries.slice(0, -1).map(() => []);
   const entries = weightSummary === undefined
-    ? rows.map((row, index) => ({ row, index }))
+    ? selected.eligible
     : weightSummary.positive;
   entries.forEach(entry => {
     const value = entry.row[transform.field];
@@ -217,7 +231,22 @@ export function deriveBinRows(rows, transform) {
       domain: resolved.domain,
       ...(resolved.step === undefined ? {} : { step: resolved.step }),
       boundaries: resolved.boundaries
-    }
+    },
+    ...(transform.missing === undefined ? {} : {
+      report: {
+        version: 1,
+        owner: { kind: "data", id: "pending" },
+        inputs: [],
+        units: [{
+          role: transform.as.count,
+          group: {},
+          inputRows: rows.length,
+          usedRows: eligibleRows.length,
+          excludedRows: selected.excluded,
+          excludedByReason: selected.excluded === 0 ? {} : { "missing-value": selected.excluded }
+        }]
+      }
+    })
   };
 }