ggaction 0.0.17 → 0.0.19

package/src/actions/charts/interval-regression.js

@@ -135,7 +135,7 @@ export const createIntervalPlot = /* @__PURE__ */ action(
 
 const REGRESSION_OPTIONS = Object.freeze([
   "id", "data", "coordinate", "x", "y", "color", "size", "shape", "point",
-  "groupBy", "method", "degree", "span", "confidenceMethod", "level", "confidence",
+  "groupBy", "method", "degree", "span", "robustIterations", "confidenceMethod", "level", "confidence",
   "interval", "band", "line", "guides"
 ]);
 
@@ -163,7 +163,7 @@ export const createRegressionPlot = /* @__PURE__ */ action(
       guides: false
     });
     const regression = Object.fromEntries([
-      "groupBy", "method", "degree", "span", "confidenceMethod", "level",
+      "groupBy", "method", "degree", "span", "robustIterations", "confidenceMethod", "level",
       "confidence", "interval", "band", "line"
     ].filter(key => Object.hasOwn(args, key)).map(key => [key, args[key]]));
     next = next.createRegression({ target: id, ...regression });

package/src/actions/charts/line.js

@@ -20,7 +20,7 @@ const OPTIONS = Object.freeze([
   "strokeDash", "line", "guides"
 ]);
 const LINE_OPTIONS = Object.freeze([
-  "strokeWidth", "curve", "stroke", "opacity", "closed",
+  "strokeWidth", "curve", "tension", "stroke", "opacity", "closed",
   ...STROKE_STYLE_PROPERTIES
 ]);
 

package/src/actions/charts/pie.js

@@ -1,52 +1,8 @@
 import { action } from "../../core/action.js";
-import { STROKE_STYLE_PROPERTIES } from "../../grammar/strokeStyle.js";
-import {
-  applyFacadeGuides, normalizeAppearance, normalizeCategoricalColor, normalizeCategoricalGuides,
-  normalizeArcCategory, normalizeCategoryAggregate, omitUndefinedOptions,
-  resolveFacadeData, resolveFacadeId, validateFacadeOptions
-} from "./shared.js";
-
-const OPERATION = "createPiePlot";
-const OPTIONS = ["id", "data", "coordinate", "category", "value", "aggregate", "color", "arc", "guides"];
-const ARC_OPTIONS = [
-  "innerRadius", "padAngle", "fill", "opacity", "stroke", "strokeWidth",
-  ...STROKE_STYLE_PROPERTIES
-];
-function guideOptions(value, color) {
-  const guides = normalizeCategoricalGuides(value, OPERATION, color);
-  if (guides === false) return false;
-  for (const key of ["axes", "grid"]) {
-    if (guides[key] !== undefined && guides[key] !== false) {
-      throw new TypeError(`${OPERATION} guides.${key} only accepts false.`);
-    }
-  }
-  return { ...guides, axes: false, grid: false };
-}
+import { createArcPlot } from "./radial.js";
 
 export const createPiePlot = /* @__PURE__ */ action({
-  op: OPERATION, description: "Create a categorical count or weighted-sum pie or donut plot."
+  op: "createPiePlot", description: "Create a categorical count or weighted-sum pie or donut plot."
 }, function (args = {}) {
-  validateFacadeOptions(args, OPTIONS, OPERATION);
-  const id = resolveFacadeId(this, args.id, { defaultId: "piePlot", operation: OPERATION });
-  const data = resolveFacadeData(this, args.data, OPERATION);
-  const category = normalizeArcCategory(args.category, OPERATION);
-  const aggregate = normalizeCategoryAggregate(args, OPERATION);
-  const arc = omitUndefinedOptions(normalizeAppearance(args.arc, ARC_OPTIONS, `${OPERATION} arc`));
-  const color = args.color === false ? undefined
-    : normalizeCategoricalColor(args.color === undefined ? category.field : args.color, `${OPERATION} color`);
-  if (color !== undefined && arc.fill !== undefined) {
-    throw new Error(`${OPERATION} arc.fill cannot be combined with color; use color:false.`);
-  }
-  const guides = guideOptions(args.guides, color);
-  let next = this.createArcMark({ id, data, ...arc }).encodeTheta({
-    ...category, target: id, aggregate,
-    ...(args.coordinate === undefined ? {} : { coordinate: args.coordinate }),
-    ...(aggregate === "sum" ? { weight: args.value } : {})
-  });
-  if (color !== undefined) next = next.encodeColor({ ...color, target: id });
-  next = applyFacadeGuides(next, guides, id, args.guides ?? {});
-  return next._withMarkConfig(id, {
-    ...next.markConfigs[id],
-    compositionRole: "pie"
-  });
+  return createArcPlot(this, args, { operation: "createPiePlot", defaultId: "piePlot" });
 });

package/src/actions/charts/radial.js

@@ -1,3 +1,4 @@
+import { findSemanticScale } from "../../selectors/scales.js";
 import { action } from "../../core/action.js";
 import { STROKE_STYLE_PROPERTIES } from "../../grammar/strokeStyle.js";
 import {
@@ -6,21 +7,22 @@ import {
   resolveFacadeData, resolveFacadeId, validateFacadeOptions
 } from "./shared.js";
 
-const OPTIONS = ["id", "data", "coordinate", "category", "value", "aggregate", "radiusScale", "color", "arc", "guides"];
+const OPTIONS = ["id", "data", "coordinate", "category", "value", "aggregate", "color", "arc", "guides"];
 const ARC_OPTIONS = [
   "innerRadius", "padAngle", "fill", "opacity", "stroke", "strokeWidth",
   ...STROKE_STYLE_PROPERTIES
 ];
 const RADIUS_OPTIONS = ["id", "type", "domain", "range", "zero", "nice", "reverse", "clamp"];
 
-function createMeasuredPlot(program, args, { operation, defaultId, mapping }) {
-  validateFacadeOptions(args, OPTIONS, operation);
+export function createArcPlot(program, args, { operation, defaultId, mapping }) {
+  const measured = mapping !== undefined;
+  validateFacadeOptions(args, [...OPTIONS, measured ? "radiusScale" : "radius"], operation);
   const id = resolveFacadeId(program, args.id, { defaultId, operation });
   const data = resolveFacadeData(program, args.data, operation);
   const category = normalizeArcCategory(args.category, operation);
   const aggregate = normalizeCategoryAggregate(args, operation);
   const arc = omitUndefinedOptions(normalizeAppearance(args.arc, ARC_OPTIONS, `${operation} arc`));
-  if (arc.padAngle !== undefined && arc.padAngle !== 0) throw new Error(`${operation} requires padAngle 0.`);
+  if (measured && arc.padAngle !== undefined && arc.padAngle !== 0) throw new Error(`${operation} requires padAngle 0.`);
   const radiusScale = args.radiusScale === undefined ? undefined
     : omitUndefinedOptions(normalizeAppearance(args.radiusScale, RADIUS_OPTIONS, `${operation} radiusScale`));
   const color = args.color === false ? undefined
@@ -28,23 +30,43 @@ function createMeasuredPlot(program, args, { operation, defaultId, mapping }) {
   if (color !== undefined && arc.fill !== undefined) {
     throw new Error(`${operation} arc.fill cannot be combined with color; use color:false.`);
   }
-  const guides = normalizeCategoricalGuides(args.guides, operation, color);
+  let guides = normalizeCategoricalGuides(args.guides, operation, color);
+  if (!measured && guides !== false) {
+    for (const key of ["axes", "grid"]) {
+      if (guides[key] !== undefined && guides[key] !== false) {
+        throw new TypeError(`${operation} guides.${key} only accepts false.`);
+      }
+    }
+    guides = { ...guides, axes: false, grid: false };
+  }
   let next = program.createArcMark({ id, data, ...arc }).encodeTheta({
-    ...category, target: id, ...(args.coordinate === undefined ? {} : { coordinate: args.coordinate })
-  }).encodeR({ target: id, aggregate, mapping,
-    ...(aggregate === "sum" ? { field: args.value } : {}),
-    ...(radiusScale === undefined ? {} : { scale: radiusScale }) });
+    ...category, target: id, ...(args.coordinate === undefined ? {} : { coordinate: args.coordinate }),
+    ...(!measured ? { aggregate, ...(aggregate === "sum" ? { weight: args.value } : {}) } : {})
+  });
+  if (measured) {
+    next = next.encodeR({ target: id, aggregate, mapping,
+      ...(aggregate === "sum" ? { field: args.value } : {}),
+      ...(radiusScale === undefined ? {} : { scale: radiusScale }) });
+  } else if (args.radius !== undefined) {
+    const radius = typeof args.radius === "string" ? { field: args.radius }
+      : normalizeAppearance(args.radius, ["field", "aggregate", "scale"], `${operation} radius`);
+    const scale = radius.scale ?? {};
+    next = next.encodeR({ target: id, ...omitUndefinedOptions(radius), scale: {
+      ...(scale.type !== "log" && findSemanticScale(next, scale.id ?? "radius") === undefined ? { zero: true } : {}),
+      ...scale
+    } });
+  }
   if (color !== undefined) next = next.encodeColor({ ...color, target: id });
   next = applyFacadeGuides(next, guides, id, args.guides ?? {});
   return next._withMarkConfig(id, {
     ...next.markConfigs[id],
-    compositionRole: "rose"
+    compositionRole: measured ? "rose" : "pie"
   });
 }
 
 export const createRosePlot = /* @__PURE__ */ action({ op: "createRosePlot", description: "Create equal-angle sectors with area proportional to category count or sum." }, function (args = {}) {
-  return createMeasuredPlot(this, args, { operation: "createRosePlot", defaultId: "rosePlot", mapping: "area" });
+  return createArcPlot(this, args, { operation: "createRosePlot", defaultId: "rosePlot", mapping: "area" });
 });
 export const createRadialBarPlot = /* @__PURE__ */ action({ op: "createRadialBarPlot", description: "Create equal-angle sectors with radial length proportional to category count or sum." }, function (args = {}) {
-  return createMeasuredPlot(this, args, { operation: "createRadialBarPlot", defaultId: "radialBarPlot", mapping: "radius-length" });
+  return createArcPlot(this, args, { operation: "createRadialBarPlot", defaultId: "radialBarPlot", mapping: "radius-length" });
 });

package/src/actions/charts/scatter.js

@@ -1,3 +1,4 @@
+import { encodeStroke } from "../encodings/stroke.js";
 import { action } from "../../core/action.js";
 import { validateNonNegativeFinite } from "../../core/validation.js";
 import { STROKE_STYLE_PROPERTIES } from "../../grammar/strokeStyle.js";
@@ -15,7 +16,7 @@ import {
 } from "./shared.js";
 
 const OPTIONS = Object.freeze([
-  "id", "data", "coordinate", "x", "y", "color", "size", "shape",
+  "id", "data", "coordinate", "x", "y", "color", "stroke", "size", "shape",
   "point", "guides"
 ]);
 const POINT_OPTIONS = Object.freeze([
@@ -43,6 +44,13 @@ export const createScatterPlot = /* @__PURE__ */ action(
     const x = normalizeFieldEncoding(args.x, "createScatterPlot x");
     const y = normalizeFieldEncoding(args.y, "createScatterPlot y");
     const color = normalizeEncoding(args.color, "createScatterPlot color");
+    const stroke = normalizeEncoding(args.stroke, "createScatterPlot stroke");
+    if (stroke !== undefined) {
+      if (typeof stroke.field !== "string" || stroke.field.length === 0 || Object.hasOwn(stroke, "value")) {
+        throw new TypeError("createScatterPlot stroke requires a field; constant stroke belongs in point.");
+      }
+      if (Object.hasOwn(point, "stroke")) throw new Error("createScatterPlot stroke conflicts with point.stroke.");
+    }
     const size = normalizeEncoding(args.size, "createScatterPlot size");
     const shape = normalizeEncoding(args.shape, "createScatterPlot shape");
     const guides = normalizeGuides(args.guides, "createScatterPlot");
@@ -51,12 +59,18 @@ export const createScatterPlot = /* @__PURE__ */ action(
       if (size !== undefined) throw new Error("createScatterPlot point radius conflicts with size.");
     }
 
+    const initialPoint = { ...point };
+    if (stroke !== undefined) delete initialPoint.strokeWidth;
     let next = this
-      .createPointMark({ id, data, ...point })
+      .createPointMark({ id, data, ...initialPoint })
       .encodeX(positionArgs(x, { target: id, coordinate: args.coordinate }))
       .encodeY(positionArgs(y, { target: id, coordinate: args.coordinate }));
     if (radius !== undefined) next = next.encodePointRadius({ target: id, value: radius });
     if (color !== undefined) next = next.encodeColor(targetArgs(color, id));
+    if (stroke !== undefined) {
+      next = encodeStroke.call(next, targetArgs(stroke, id));
+      if (Object.hasOwn(point, "strokeWidth")) next = next.editPointMark({ target: id, strokeWidth: point.strokeWidth });
+    }
     if (size !== undefined) next = next.encodeSize(targetArgs(size, id));
     if (shape !== undefined) next = next.encodeShape(targetArgs(shape, id));
     return applyFacadeGuides(next, guides, id);

package/src/actions/charts/shared.js

@@ -191,9 +191,9 @@ export function normalizeArcCategory(value, operation) {
 }
 
 export function normalizeCategoryAggregate(args, operation) {
-  const aggregate = args.aggregate === undefined ? "count" : args.aggregate;
+  const aggregate = args.aggregate === undefined ? args.value === undefined ? "count" : "sum" : args.aggregate;
   if (!["count", "sum"].includes(aggregate) || (aggregate === "sum") !== (args.value !== undefined)) {
-    throw new Error(`${operation} requires count without value or explicit sum with value.`);
+    throw new Error(`${operation} requires count without value or sum with value.`);
   }
   if (args.value !== undefined) validateNonEmptyString(args.value, `${operation} value`);
   return aggregate;

package/src/actions/charts/text.js

@@ -0,0 +1,35 @@
+import { action } from "../../core/action.js";
+import { TEXT_MARK_STYLE_OPTIONS } from "../../grammar/text.js";
+import {
+  applyFacadeGuides, normalizeAppearance, normalizeEncoding, normalizeFieldEncoding,
+  normalizeGuides, positionArgs, resolveFacadeData, resolveFacadeId, targetArgs,
+  validateFacadeOptions
+} from "./shared.js";
+
+const OPTIONS = Object.freeze(["id", "data", "coordinate", "x", "y", "text", "color", "style", "guides"]);
+const STYLE_OPTIONS = Object.freeze(["missing", ...TEXT_MARK_STYLE_OPTIONS.filter(key => key !== "inheritColor")]);
+
+export const createTextPlot = /* @__PURE__ */ action({
+  op: "createTextPlot", description: "Create a Cartesian text plot from existing chart data."
+}, function (args = {}) {
+  validateFacadeOptions(args, OPTIONS, "createTextPlot");
+  const id = resolveFacadeId(this, args.id, { defaultId: "textPlot", operation: "createTextPlot" });
+  const data = resolveFacadeData(this, args.data, "createTextPlot");
+  const x = normalizeFieldEncoding(args.x, "createTextPlot x");
+  const y = normalizeFieldEncoding(args.y, "createTextPlot y");
+  const text = normalizeEncoding(args.text, "createTextPlot text");
+  if (text === undefined) throw new Error("createTextPlot requires text.");
+  const color = normalizeEncoding(args.color, "createTextPlot color");
+  const style = normalizeAppearance(args.style, STYLE_OPTIONS, "createTextPlot style");
+  const guides = normalizeGuides(args.guides, "createTextPlot");
+  const apply = program => {
+    let next = program.createTextMark({ id, data, ...style })
+      .encodeX(positionArgs(x, { target: id, coordinate: args.coordinate }))
+      .encodeY(positionArgs(y, { target: id, coordinate: args.coordinate }))
+      .encodeText(targetArgs(text, id));
+    if (color !== undefined) next = next.encodeColor(targetArgs(color, id));
+    return applyFacadeGuides(next, guides, id);
+  };
+  apply(this);
+  return apply(this);
+});

package/src/actions/composition/actions.js

@@ -1,3 +1,4 @@
+import { resolveGraphicBounds } from "../../layout/canvas.js";
 import { inheritTextMetrics } from "../textMetrics/index.js";
 import { action, closedAction } from "../../core/action.js";
 import { ChartProgram as CoreChartProgram } from "../../core/ChartProgram.js";
@@ -19,7 +20,7 @@ const CONCAT_OPTIONS = Object.freeze([
   "id", "programs", "gap", "align", "padding"
 ]);
 const LAYOUT_EDIT_OPTIONS = Object.freeze([
-  "columns", "gap", "align", "padding"
+  "columns", "gap", "spacing", "align", "padding"
 ]);
 const REPLACEMENT_OPTIONS = Object.freeze(["target", "program"]);
 const INSERTION_OPTIONS = Object.freeze(["id", "program", "before", "after"]);
@@ -179,6 +180,7 @@ const editCompositionLayout = /* @__PURE__ */ closedAction(
         "editCompositionLayout columns is available only on a facet composition."
       );
     }
+    if (current.type !== "facet" && Object.hasOwn(args, "spacing")) throw new Error("Plot spacing requires a facet composition.");
     const padding = Object.hasOwn(args, "padding")
       ? normalizeCompositionPadding(args.padding, current.padding)
       : current.padding;
@@ -188,6 +190,8 @@ const editCompositionLayout = /* @__PURE__ */ closedAction(
         (current.facet.grid?.cells ?? []).map(cell => [cell.id, cell])
       );
       layout = resolveFacetLayout({
+        spacing: option(args, "spacing", current.spacing),
+        plots: current.children.map(id => ({ id, ...resolveGraphicBounds(this.children[id]) })),
         children: current.children.map((id, index) => ({
           ...childDescriptor({ id, program: this.children[id] }),
           value: current.facet.values[index],
@@ -218,7 +222,7 @@ const editCompositionLayout = /* @__PURE__ */ closedAction(
       children: this.children,
       compositionSpec: {
         ...current,
-        ...(current.type === "facet" ? { columns: layout.columns } : {}),
+        ...(current.type === "facet" ? { columns: layout.columns, ...(layout.spacing !== undefined ? { spacing: layout.spacing } : current.spacing !== undefined ? { spacing: "canvas" } : {}) } : {}),
         gap: layout.gap,
         align: layout.align,
         padding: layout.padding

package/src/actions/data/box.js

@@ -2,7 +2,7 @@ import { BOX_FIELDS, deriveBoxData, normalizeBoxTransform } from "../../grammar/
 import { derivedCreator, derivedMaterializer } from "./shared.js";
 
 const OPTIONS = Object.freeze([
-  "id", "source", "category", "field", "whisker", "factor", "as"
+  "id", "source", "category", "field", "whisker", "factor", "as", "summary"
 ]);
 
 function materializer(type, op, select) {
@@ -28,6 +28,7 @@ function creator(type, op, materialize) {
       type,
       category: args.category,
       field: args.field,
+      ...(args.summary === undefined ? {} : { summary: args.summary }),
       ...(args.whisker === undefined ? {} : { whisker: args.whisker }),
       ...(args.factor === undefined ? {} : { factor: args.factor }),
       as: args.as ?? BOX_FIELDS

package/src/actions/data/derived.js

@@ -1,4 +1,6 @@
 import { closedAction } from "../../core/action.js";
+import { validateGraphicItemLimit } from "../../core/validation.js";
+import { resolveGraphicItemCapacity } from "../../selectors/graphicCapacity.js";
 import { validateUserId } from "../../core/identifiers.js";
 
 import {
@@ -89,6 +91,7 @@ export const releaseDerivedData = /* @__PURE__ */ closedAction(
     next = next._withoutMaterializationConfig([
       "calculations", "datasets", validatedId
     ]);
+    next = next._withoutMaterializationConfig(["regressionFits", validatedId]);
     for (const owner of selfOwners) {
       const [, family, ownerId] = owner.path;
       next = next._withoutMaterializationConfig(["data", family, ownerId]);
@@ -110,10 +113,17 @@ export const rebindLayerData = /* @__PURE__ */ closedAction(
       requestedData,
       "Layer dataset"
     ).id;
-    requireLayer(this, id);
+    const layer = requireLayer(this, id);
     if (!hasDataset(this, data)) {
       throw new Error(`Layer dataset "${data}" does not exist.`);
     }
+    const dataset = findDataset(this, data);
+    if (layer.mark?.type === "point" && Array.isArray(dataset.values)) {
+      validateGraphicItemLimit(dataset.values.length, {
+        ...resolveGraphicItemCapacity(this, { id, label: "Point mark item count" }),
+        rawCount: dataset.values.length
+      });
+    }
     return this.editSemantic({
       property: `layer[${id}].data`,
       value: data

package/src/actions/data/edit.js

@@ -38,6 +38,7 @@ const CREATOR_BY_TYPE = Object.freeze({
   interval: "createIntervalData",
   normalize: "createNormalizedData",
   regression: "createRegressionData",
+  regressionStatistics: "createRegressionStatisticsData",
   sort: "createSortedData",
   stack: "createStackData",
   summary: "createSummaryData",
@@ -57,6 +58,7 @@ const REVISION_ROLE = Object.freeze({
   interval: "IntervalData",
   normalize: "NormalizedData",
   regression: "RegressionData",
+  regressionStatistics: "RegressionStatisticsData",
   sort: "SortedData",
   stack: "StackData",
   summary: "SummaryData",
@@ -509,7 +511,7 @@ export const editStackData = /* @__PURE__ */ focusedEditor(
 );
 export const editRegressionData = /* @__PURE__ */ focusedEditor(
   "editRegressionData", "regression", [
-    "x", "y", "groupBy", "method", "degree", "span", "confidenceMethod",
+    "x", "y", "groupBy", "method", "degree", "span", "robustIterations", "confidenceMethod",
     "level", "confidence", "interval", "predict"
   ]
 );

package/src/actions/data/index.js

@@ -21,6 +21,7 @@ import {
   materializeGradientProfileData
 } from "./gradientProfile.js";
 import { createRegressionData, materializeRegressionData } from "./regression.js";
+import { createRegressionStatisticsData, editRegressionStatisticsData, materializeRegressionStatisticsData } from "./regressionStatistics.js";
 import {
   createCategoricalDensityData,
   createDensityData,
@@ -69,6 +70,9 @@ export function registerDataActions(ProgramClass) {
     materializeEmptyMark,
     removeMarkFilter,
     materializeRegressionData,
+    materializeRegressionStatisticsData,
+    createRegressionStatisticsData,
+    editRegressionStatisticsData,
     materializeDensityData,
     createGradientProfileData,
     materializeGradientProfileData,

package/src/actions/data/regression.js

@@ -5,33 +5,42 @@ import {
   deriveRegression,
   normalizeRegressionTransform
 } from "../../grammar/regression/index.js";
-import { resolveDatasetReference } from "../../selectors/datasets.js";
+import { resolveDatasetReference, requireDataset, findDataset } from "../../selectors/datasets.js";
 import { derivedMaterializer } from "./shared.js";
 
 const OPTIONS = Object.freeze([
-  "id", "source", "x", "y", "groupBy", "method", "degree", "span",
+  "id", "source", "x", "y", "groupBy", "method", "degree", "span", "robustIterations",
   "confidenceMethod", "level", "confidence", "interval"
   , "predict", "missing"
 ]);
 
+function calculateRegression(values, transform) {
+  return deriveRegression(values, transform);
+}
+
+function retainFitStatistics(program, { id, result }) {
+  return result.fitStatistics === undefined ? program : program._withMaterializationConfig(
+    ["regressionFits", id], result.fitStatistics
+  );
+}
+
+function materializeMissingFitStatistics(program, args) {
+  const dataset = findDataset(program, args.id);
+  if (dataset?.values === undefined || dataset.transform?.length !== 1 ||
+      dataset.transform[0].type !== "regression" || dataset.transform[0].method !== "linear" ||
+      program.materializationConfigs.regressionFits?.[dataset.id] !== undefined) return undefined;
+  const source = requireDataset(program, dataset.source);
+  const result = calculateRegression(source.values, dataset.transform[0]);
+  return retainFitStatistics(program, { id: dataset.id, result });
+}
+
 export const materializeRegressionData = /* @__PURE__ */ derivedMaterializer(
   "materializeRegressionData",
   "Materialize one regression derived dataset.",
   "regression",
-  (values, transform) => deriveRegression(values, {
-      x: transform.x,
-      y: transform.y,
-      groupBy: transform.groupBy,
-      method: transform.method,
-      degree: transform.degree,
-      span: transform.span,
-      confidenceMethod: transform.confidenceMethod,
-      level: transform.level,
-      confidence: transform.confidence,
-      interval: transform.interval,
-      predict: transform.predict
-      , missing: transform.missing
-    })
+  calculateRegression,
+  undefined,
+  { before: materializeMissingFitStatistics, after: retainFitStatistics }
 );
 
 export const createRegressionData = /* @__PURE__ */ closedAction(

package/src/actions/data/regressionStatistics.js

@@ -0,0 +1,73 @@
+import { closedAction } from "../../core/action.js";
+import { validateUserId } from "../../core/identifiers.js";
+import { requireDataset, resolveDatasetReference, hasDataset, hasDatasetOwner } from "../../selectors/datasets.js";
+import {
+  requireRegressionStatisticsSource,
+  validateRegressionFitStatistics,
+  regressionStatisticsRows
+} from "../../grammar/regression/statistics.js";
+import { requireDerivedDataset } from "./shared.js";
+import { resolveDerivedDataOwner, reviseDerivedData } from "./edit.js";
+
+function ensureFitStatistics(program, source) {
+  requireRegressionStatisticsSource(source);
+  if (!Array.isArray(source.values)) throw new Error("Regression statistics requires a materialized linear fit source.");
+  const next = program.materializationConfigs.regressionFits?.[source.id] === undefined
+    ? program.materializeRegressionData({ id: source.id }) : program;
+  validateRegressionFitStatistics(next.materializationConfigs.regressionFits[source.id], source,
+    requireDataset(next, source.source));
+  return next;
+}
+
+function statisticsOwner(program, target) {
+  if (target !== undefined) return resolveDerivedDataOwner(program, target, "regressionStatistics");
+  const records = Object.entries(program.materializationConfigs.data?.regressionStatistics ?? {})
+    .map(([owner, config]) => ({ owner, current: config.current }));
+  const current = records.filter(record => record.current === program.context.currentData);
+  const candidate = current.length === 1 ? current[0] : records.length === 1 ? records[0] : undefined;
+  if (candidate === undefined) throw new Error(records.length === 0
+    ? "No standalone regression statistics dataset is available."
+    : "Regression statistics target is ambiguous; provide target.");
+  return resolveDerivedDataOwner(program, candidate.owner, "regressionStatistics");
+}
+
+export const materializeRegressionStatisticsData = /* @__PURE__ */ closedAction(
+  { op: "materializeRegressionStatisticsData", description: "Materialize statistics from an existing linear fit cache." }, ["id"],
+  function (args = {}) {
+    const { id, source } = requireDerivedDataset(this, args.id, "regressionStatistics");
+    const next = ensureFitStatistics(this, source);
+    const values = regressionStatisticsRows(next.materializationConfigs.regressionFits[source.id], source);
+    return next.editSemantic({ property: `dataset[${id}].values`, value: values });
+  }
+);
+
+export const createRegressionStatisticsData = /* @__PURE__ */ closedAction(
+  { op: "createRegressionStatisticsData", description: "Create counts, coefficients and R-squared from a linear regression dataset." }, ["id", "source"],
+  function (args = {}) {
+    const id = validateUserId(args.id, "Regression statistics dataset id");
+    if (hasDataset(this, id) || hasDatasetOwner(this, id)) throw new Error(`Dataset "${id}" already exists.`);
+    const source = resolveDatasetReference(this,
+      validateUserId(args.source, "Regression statistics source id"), "Regression statistics source");
+    const next = ensureFitStatistics(this, source)
+      .createDerivedData({ id, source: source.id, transform: [{ type: "regressionStatistics" }] })
+      .materializeRegressionStatisticsData({ id });
+    return this.actionStack.length === 1 ? next._withMaterializationConfig(
+      ["data", "regressionStatistics", id], { current: id }
+    ) : next;
+  }
+);
+
+export const editRegressionStatisticsData = /* @__PURE__ */ closedAction(
+  { op: "editRegressionStatisticsData", description: "Revise the source of a standalone regression statistics dataset." }, ["target", "source"],
+  function (args = {}) {
+    const resolved = statisticsOwner(this, args.target);
+    if (!Object.hasOwn(args, "source")) return this;
+    const source = resolveDatasetReference(this,
+      validateUserId(args.source, "Regression statistics source id"), "Regression statistics source");
+    if (source.id === resolved.dataset.source) return this;
+    const next = ensureFitStatistics(this, source);
+    return reviseDerivedData(next, {
+      resolved, source: source.id, definition: { type: "regressionStatistics" }, dependents: "recompute"
+    });
+  }
+);

package/src/actions/data/shared.js

@@ -35,9 +35,11 @@ export function requireDerivedDataset(program, id, type) {
   return { id: validatedId, dataset, source, transform: dataset.transform[0] };
 }
 
-export function derivedMaterializer(op, description, type, derive, resolve) {
+export function derivedMaterializer(op, description, type, derive, resolve, { before, after } = {}) {
   return action({ op, description }, function (args = {}) {
     validateKeys(args, MATERIALIZE_OPTIONS, op);
+    const existing = before?.(this, args);
+    if (existing !== undefined) return existing;
     const { id, source, transform } = requireDerivedDataset(
       this,
       args.id,
@@ -51,6 +53,7 @@ export function derivedMaterializer(op, description, type, derive, resolve) {
     const values = Array.isArray(result) ? result : result.values;
     const schema = deriveTransformSchema(source.schema, transform, values, {
       sourceId: source.id,
+      sourceTransform: source.transform?.[0],
       ownerId: id
     });
     validateRowsAgainstSchema(values, schema, `Derived dataset "${id}"`);
@@ -75,7 +78,7 @@ export function derivedMaterializer(op, description, type, derive, resolve) {
         report
       );
     }
-    return next;
+    return after === undefined ? next : after(next, { id, source, transform, result });
   });
 }
 
@@ -87,11 +90,12 @@ export function derivedCreator(
   sourceLabel,
   transform,
   materialize,
-  requireSource = false
+  requireSource = false,
+  defaultId
 ) {
   return action({ op, description }, function (args = {}) {
     validateKeys(args, options, op);
-    const id = validateUserId(args.id, idLabel);
+    const id = validateUserId(args.id === undefined ? defaultId : args.id, idLabel);
     const requestedSource = validateUserId(
       requireSource ? args.source : args.source ?? this.context.currentData,
       sourceLabel

package/src/actions/data/stack.js

@@ -22,5 +22,7 @@ export const createStackData = /* @__PURE__ */ derivedCreator(
   "Stack dataset id",
   "Stack source dataset id",
   normalizeStackTransform,
-  "materializeStackData"
+  "materializeStackData",
+  false,
+  "stacked"
 );