ggaction 0.0.13 → 0.0.16

package/src/grammar/normalize.js

@@ -0,0 +1,366 @@
+import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
+import {
+  inverseLerp,
+  numericExtent,
+  requireFiniteResult,
+  stableFiniteDeviation,
+  stableFiniteSum
+} from "./numeric.js";
+
+const TRANSFORM_KEYS = Object.freeze([
+  "type", "field", "as", "groupBy", "method", "variance",
+  "zeroDenominator", "baseline", "sortBy"
+]);
+const METHODS = Object.freeze([
+  "share", "zscore", "minmax", "index", "change", "percentChange"
+]);
+const ZERO_POLICIES = Object.freeze(["error", "null", "zero"]);
+const SORT_KEYS = Object.freeze(["field", "order"]);
+const ORDERS = Object.freeze(["ascending", "descending"]);
+const BASELINE_KEYS = Object.freeze(["position", "value"]);
+const BASELINE_METHODS = new Set(["index", "change", "percentChange"]);
+
+function rejectUnknownKeys(value, supported, label) {
+  const unknown = Object.keys(value).find(key => !supported.includes(key));
+  if (unknown !== undefined) throw new Error(`Unknown ${label} property "${unknown}".`);
+}
+
+function requireField(value, label) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new TypeError(`${label} must be a non-empty string.`);
+  }
+  return value;
+}
+
+function normalizeGroupBy(value) {
+  if (value === undefined) return [];
+  return Array.isArray(value) ? [...value] : [value];
+}
+
+function validateGroupBy(groupBy) {
+  if (!Array.isArray(groupBy) || groupBy.some(field =>
+    typeof field !== "string" || field.length === 0
+  )) {
+    throw new TypeError("Normalize groupBy must contain field names.");
+  }
+  if (new Set(groupBy).size !== groupBy.length) {
+    throw new Error("Normalize groupBy fields must be unique.");
+  }
+}
+
+function normalizeSortBy(value) {
+  if (value === undefined) return [];
+  if (!Array.isArray(value)) return value;
+  return value.map(sort => isPlainObject(sort)
+    ? { ...sort, order: sort.order ?? "ascending" }
+    : sort
+  );
+}
+
+function validateSortBy(sortBy) {
+  if (!Array.isArray(sortBy)) throw new TypeError("Normalize sortBy must be an array.");
+  const fields = [];
+  sortBy.forEach((sort, index) => {
+    if (!isPlainObject(sort)) {
+      throw new TypeError(`Normalize sortBy[${index}] must be a plain object.`);
+    }
+    rejectUnknownKeys(sort, SORT_KEYS, `normalize sortBy[${index}]`);
+    fields.push(requireField(sort.field, `Normalize sortBy[${index}].field`));
+    if (!ORDERS.includes(sort.order)) {
+      throw new Error(`Unsupported normalize sort order "${sort.order}".`);
+    }
+  });
+  if (new Set(fields).size !== fields.length) {
+    throw new Error("Normalize sortBy fields must be unique.");
+  }
+}
+
+function normalizeBaseline(value) {
+  if (!isPlainObject(value)) return value;
+  return { ...value };
+}
+
+function validateBaseline(baseline, sortBy) {
+  if (!isPlainObject(baseline)) {
+    throw new TypeError("Normalize baseline must be a plain object.");
+  }
+  rejectUnknownKeys(baseline, BASELINE_KEYS, "normalize baseline");
+  const modes = BASELINE_KEYS.filter(key => Object.hasOwn(baseline, key));
+  if (modes.length !== 1) {
+    throw new Error("Normalize baseline requires exactly one of position or value.");
+  }
+  if (modes[0] === "value") {
+    if (!Number.isFinite(baseline.value)) {
+      throw new TypeError("Normalize baseline value must be finite.");
+    }
+  } else {
+    if (!["first", "last"].includes(baseline.position)) {
+      throw new Error("Normalize baseline position must be first or last.");
+    }
+    if (sortBy.length === 0) {
+      throw new Error("Normalize baseline position requires non-empty sortBy.");
+    }
+  }
+}
+
+export function validateNormalizeTransform(transform) {
+  if (!isPlainObject(transform)) {
+    throw new TypeError("Normalize transform must be a plain object.");
+  }
+  rejectUnknownKeys(transform, TRANSFORM_KEYS, "normalize transform");
+  if (transform.type !== "normalize") {
+    throw new Error(`Unsupported normalize transform "${transform.type}".`);
+  }
+  requireField(transform.field, "Normalize field");
+  requireField(transform.as, "Normalize output field");
+  validateGroupBy(transform.groupBy);
+  if (!METHODS.includes(transform.method)) {
+    throw new Error(`Unsupported normalize method "${transform.method}".`);
+  }
+
+  const hasVariance = Object.hasOwn(transform, "variance");
+  const hasZero = Object.hasOwn(transform, "zeroDenominator");
+  const hasBaseline = Object.hasOwn(transform, "baseline");
+  const hasSort = Object.hasOwn(transform, "sortBy");
+  if (transform.method === "zscore") {
+    if (!["population", "sample"].includes(transform.variance)) {
+      throw new Error("Normalize zscore variance must be population or sample.");
+    }
+  } else if (hasVariance) {
+    throw new Error(`Normalize variance is not available for ${transform.method}.`);
+  }
+  if (hasZero && !ZERO_POLICIES.includes(transform.zeroDenominator)) {
+    throw new Error(`Unsupported normalize zeroDenominator "${transform.zeroDenominator}".`);
+  }
+  if (transform.method === "change" && hasZero) {
+    throw new Error("Normalize zeroDenominator is not available for change.");
+  }
+  if (BASELINE_METHODS.has(transform.method)) {
+    validateSortBy(transform.sortBy);
+    validateBaseline(transform.baseline, transform.sortBy);
+  } else {
+    if (hasBaseline) {
+      throw new Error(`Normalize baseline is not available for ${transform.method}.`);
+    }
+    if (hasSort) {
+      throw new Error(`Normalize sortBy is not available for ${transform.method}.`);
+    }
+  }
+  return transform;
+}
+
+export function normalizeNormalizeTransform(args = {}) {
+  const {
+    field,
+    as,
+    groupBy,
+    method,
+    variance,
+    zeroDenominator,
+    baseline,
+    sortBy
+  } = args;
+  const transform = {
+    type: "normalize",
+    field,
+    as,
+    groupBy: normalizeGroupBy(groupBy),
+    method
+  };
+  if (method === "zscore") transform.variance = variance ?? "population";
+  else if (Object.hasOwn(args, "variance")) transform.variance = variance;
+  if (method !== "change") transform.zeroDenominator = zeroDenominator ?? "error";
+  else if (Object.hasOwn(args, "zeroDenominator")) {
+    transform.zeroDenominator = zeroDenominator;
+  }
+  if (BASELINE_METHODS.has(method)) {
+    transform.baseline = normalizeBaseline(baseline ?? { position: "first" });
+    transform.sortBy = normalizeSortBy(sortBy);
+  } else {
+    if (Object.hasOwn(args, "baseline")) transform.baseline = normalizeBaseline(baseline);
+    if (Object.hasOwn(args, "sortBy")) transform.sortBy = normalizeSortBy(sortBy);
+  }
+  validateNormalizeTransform(transform);
+  return cloneAndFreeze(transform);
+}
+
+function scalarKey(value, label) {
+  if (value === null) return "null";
+  if (typeof value === "string") return `string:${value.length}:${value}`;
+  if (typeof value === "boolean") return `boolean:${value}`;
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return `number:${Object.is(value, -0) ? 0 : value}`;
+  }
+  throw new TypeError(
+    `${label} must contain null, strings, booleans, or finite numbers.`
+  );
+}
+
+function compareScalar(left, right, label) {
+  const leftMissing = left === null || left === undefined;
+  const rightMissing = right === null || right === undefined;
+  if (leftMissing || rightMissing) {
+    if (leftMissing && rightMissing) return 0;
+    return leftMissing ? 1 : -1;
+  }
+  if (typeof left !== typeof right ||
+    !["number", "string", "boolean"].includes(typeof left) ||
+    typeof left === "number" && (!Number.isFinite(left) || !Number.isFinite(right))) {
+    throw new TypeError(`${label} must contain one comparable primitive type.`);
+  }
+  if (left === right) return 0;
+  return left < right ? -1 : 1;
+}
+
+function compareEntries(left, right, sortBy) {
+  for (const sort of sortBy) {
+    const comparison = compareScalar(
+      left.row[sort.field],
+      right.row[sort.field],
+      `Normalize sort field "${sort.field}"`
+    );
+    if (comparison !== 0) return sort.order === "ascending" ? comparison : -comparison;
+  }
+  return left.index - right.index;
+}
+
+function validateRows(rows, transform) {
+  if (!Array.isArray(rows) || !rows.every(isPlainObject)) {
+    throw new TypeError("Normalize source rows must be plain objects.");
+  }
+  if (rows.length === 0) return;
+  const fields = [
+    transform.field,
+    ...transform.groupBy,
+    ...(transform.sortBy ?? []).map(sort => sort.field)
+  ];
+  rows.forEach((row, index) => {
+    if (Object.hasOwn(row, transform.as)) {
+      throw new Error(`Normalize output field "${transform.as}" already exists.`);
+    }
+    for (const field of fields) {
+      if (!Object.hasOwn(row, field)) {
+        throw new Error(`Normalize source does not contain field "${field}" at row ${index}.`);
+      }
+    }
+    if (!Number.isFinite(row[transform.field])) {
+      throw new TypeError(
+        `Normalize field "${transform.field}" must contain finite numbers at row ${index}.`
+      );
+    }
+    for (const field of transform.groupBy) {
+      scalarKey(row[field], `Normalize group field "${field}"`);
+    }
+    for (const sort of transform.sortBy ?? []) {
+      compareScalar(
+        row[sort.field],
+        row[sort.field],
+        `Normalize sort field "${sort.field}"`
+      );
+    }
+  });
+}
+
+function groupRows(rows, transform) {
+  const groups = new Map();
+  rows.forEach((row, index) => {
+    const key = transform.groupBy.length === 0
+      ? "all"
+      : transform.groupBy.map(field =>
+        scalarKey(row[field], `Normalize group field "${field}"`)
+      ).join("\0");
+    if (!groups.has(key)) groups.set(key, []);
+    groups.get(key).push({ row, index });
+  });
+  return [...groups.values()];
+}
+
+function zeroResult(policy, method) {
+  if (policy === "null") return null;
+  if (policy === "zero") return 0;
+  throw new RangeError(`Normalize ${method} denominator is zero.`);
+}
+
+function finiteOutput(value, method) {
+  return requireFiniteResult(value, `Normalize ${method} output`);
+}
+
+function zscore(value, mean, deviation, method) {
+  const difference = value - mean;
+  return finiteOutput(
+    Number.isFinite(difference) ? difference / deviation : value / deviation - mean / deviation,
+    method
+  );
+}
+
+function applyGroup(group, transform, outputs) {
+  const values = group.map(entry => entry.row[transform.field]);
+  if (transform.method === "share" && values.some(value => value < 0)) {
+    throw new RangeError("Normalize share does not accept negative values.");
+  }
+  if (transform.method === "share") {
+    const total = stableFiniteSum(values, "Normalize share sum");
+    group.forEach((entry, index) => {
+      outputs[entry.index] = total === 0
+        ? zeroResult(transform.zeroDenominator, transform.method)
+        : finiteOutput(values[index] / total, transform.method);
+    });
+    return;
+  }
+  if (transform.method === "minmax") {
+    const [minimum, maximum] = numericExtent(values);
+    group.forEach((entry, index) => {
+      outputs[entry.index] = minimum === maximum
+        ? zeroResult(transform.zeroDenominator, transform.method)
+        : finiteOutput(inverseLerp(values[index], minimum, maximum), transform.method);
+    });
+    return;
+  }
+  if (transform.method === "zscore") {
+    if (transform.variance === "sample" && values.length < 2) {
+      throw new RangeError("Normalize sample zscore requires at least two values.");
+    }
+    const { mean, deviation } = stableFiniteDeviation(values, {
+      sample: transform.variance === "sample",
+      label: "Normalize zscore deviation"
+    });
+    group.forEach((entry, index) => {
+      outputs[entry.index] = deviation === 0
+        ? zeroResult(transform.zeroDenominator, transform.method)
+        : zscore(values[index], mean, deviation, transform.method);
+    });
+    return;
+  }
+
+  const sorted = [...group].sort((left, right) =>
+    compareEntries(left, right, transform.sortBy)
+  );
+  const baseline = Object.hasOwn(transform.baseline, "value")
+    ? transform.baseline.value
+    : sorted[transform.baseline.position === "first" ? 0 : sorted.length - 1]
+      .row[transform.field];
+  group.forEach(entry => {
+    const value = entry.row[transform.field];
+    if (transform.method === "change") {
+      outputs[entry.index] = finiteOutput(value - baseline, transform.method);
+    } else if (baseline === 0) {
+      outputs[entry.index] = zeroResult(transform.zeroDenominator, transform.method);
+    } else if (transform.method === "index") {
+      outputs[entry.index] = finiteOutput(value / baseline * 100, transform.method);
+    } else {
+      outputs[entry.index] = finiteOutput(value / baseline - 1, transform.method);
+    }
+  });
+}
+
+export function deriveNormalizedRows(rows, transform) {
+  validateNormalizeTransform(transform);
+  validateRows(rows, transform);
+  if (rows.length === 0) return cloneAndFreeze([]);
+  const outputs = new Array(rows.length);
+  for (const group of groupRows(rows, transform)) applyGroup(group, transform, outputs);
+  return cloneAndFreeze(rows.map((row, index) => ({
+    ...row,
+    [transform.as]: outputs[index]
+  })));
+}

package/src/grammar/pathSeries.js

@@ -1,5 +1,9 @@
 import { validateNonEmptyString } from "../core/validation.js";
-import { readNominalField, readQuantitativeField } from "./scales/fields.js";
+import {
+  readNominalField,
+  readQuantitativeField,
+  readScaleField
+} from "./scales/fields.js";
 
 export function normalizeGroupFields(value) {
   const fields = Array.isArray(value) ? [...value] : [value];
@@ -36,9 +40,13 @@ export function readPathSeriesFields(rows, layer) {
   return fields;
 }
 
-function seriesValueIndex(rows, fields, field, channel) {
+function seriesValueIndex(rows, fields, field, channel, encoding = {}) {
   const quantitative = channel === "strokeWidth" || channel === "opacity";
-  const values = quantitative
+  const values = channel === "stroke"
+    ? readScaleField(rows, field, encoding.fieldType ?? "nominal", {
+        temporalUnit: encoding.temporalUnit
+      })
+    : quantitative
     ? readQuantitativeField(rows, field)
     : readNominalField(rows, field);
   const result = new Map();
@@ -56,9 +64,15 @@ function seriesValueIndex(rows, fields, field, channel) {
   return result;
 }
 
-export function derivePathSeriesFieldValues(rows, series, field, channel) {
+export function derivePathSeriesFieldValues(
+  rows,
+  series,
+  field,
+  channel,
+  encoding
+) {
   const fields = Object.keys(series[0]?.key ?? {});
-  const values = seriesValueIndex(rows, fields, field, channel);
+  const values = seriesValueIndex(rows, fields, field, channel, encoding);
   return series.map(item => values.get(JSON.stringify(Object.values(item.key))));
 }
 
@@ -67,16 +81,20 @@ export function validatePathSeriesAppearance(rows, layer) {
       layer.encoding?.parallel !== undefined) return;
   const grouping = readPathSeriesFields(rows, layer);
   const channels = layer.mark.type === "line"
-    ? ["color", "strokeDash", "strokeWidth", "opacity"] : ["color"];
+    ? ["color", "stroke", "strokeDash", "strokeWidth", "opacity"]
+    : ["color", "stroke"];
   for (const channel of channels) {
     const encoding = layer.encoding?.[channel];
     if (encoding?.field === undefined) continue;
-    const allowed = channel === "color" ? ["nominal", "ordinal"]
+    const allowed = ["color", "stroke"].includes(channel)
+      ? channel === "color"
+        ? ["nominal", "ordinal"]
+        : ["nominal", "ordinal", "quantitative", "temporal"]
       : channel === "strokeDash" ? ["nominal"] : ["quantitative"];
     if (!allowed.includes(encoding.fieldType)) {
       throw new Error(`Path ${channel} encoding has an unsupported field type.`);
     }
-    seriesValueIndex(rows, grouping, encoding.field, channel);
+    seriesValueIndex(rows, grouping, encoding.field, channel, encoding);
   }
   return grouping;
 }

package/src/grammar/pointShapes.js

@@ -1,5 +1,6 @@
 import { cloneAndFreeze } from "../core/immutable.js";
 import { buildLinearPathCommands } from "./pathCommands.js";
+import { requestedStrokeDetails } from "./strokeStyle.js";
 
 export const POINT_SHAPES = cloneAndFreeze([
   "circle",
@@ -109,12 +110,13 @@ function normalizePolygon(points, x, y, area) {
   }));
 }
 
-function appearance(fill, stroke, strokeWidth, opacity) {
+function appearance(fill, stroke, strokeWidth, opacity, strokeDetails) {
   return {
     fill,
     ...(stroke === undefined ? {} : { stroke }),
     ...(strokeWidth === undefined ? {} : { strokeWidth }),
-    ...(opacity === undefined ? {} : { opacity })
+    ...(opacity === undefined ? {} : { opacity }),
+    ...requestedStrokeDetails(strokeDetails, "Point shape")
   };
 }
 
@@ -127,7 +129,10 @@ export function createPointShapeGraphic({
   stroke,
   strokeWidth,
   opacity,
-  angle
+  angle,
+  lineCap,
+  lineJoin,
+  miterLimit
 }) {
   const validated = validatePointShape(shape);
   if (![x, y, area].every(Number.isFinite) || area < 0) {
@@ -136,7 +141,11 @@ export function createPointShapeGraphic({
   if (typeof fill !== "string" || fill.length === 0) {
     throw new TypeError("Point shape fill must be a non-empty string.");
   }
-  const shared = appearance(fill, stroke, strokeWidth, opacity);
+  const shared = appearance(fill, stroke, strokeWidth, opacity, {
+    ...(lineCap === undefined ? {} : { lineCap }),
+    ...(lineJoin === undefined ? {} : { lineJoin }),
+    ...(miterLimit === undefined ? {} : { miterLimit })
+  });
   if (angle !== undefined && !Number.isFinite(angle)) {
     throw new TypeError("Point shape angle must be finite degrees.");
   }

package/src/grammar/polar.js

@@ -1,6 +1,12 @@
 import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
+import { validateOptionObject } from "../core/validation.js";
 import { validatePair } from "./scales/validation.js";
 
+const POLAR_FRAME_OPTIONS = Object.freeze(["center", "radius"]);
+const POLAR_CENTER_OPTIONS = Object.freeze(["x", "y"]);
+const POLAR_RADIUS_OPTIONS = Object.freeze(["unit", "value"]);
+const POLAR_RADIUS_UNITS = new Set(["fraction", "px"]);
+
 function validateBounds(bounds) {
   if (
     !isPlainObject(bounds) ||
@@ -15,12 +21,88 @@ function validateBounds(bounds) {
   return bounds;
 }
 
-export function resolvePolarFrame(bounds) {
+function finiteUnitInterval(value, label) {
+  if (!Number.isFinite(value) || value < 0 || value > 1) {
+    throw new RangeError(`${label} must be a finite number from 0 through 1.`);
+  }
+  return value;
+}
+
+export function normalizePolarFrameOptions(value) {
+  if (value === "auto") return value;
+  if (!isPlainObject(value)) {
+    throw new TypeError('Polar frame must be "auto" or a plain object.');
+  }
+  validateOptionObject(value, POLAR_FRAME_OPTIONS, "polar frame");
+  const center = value.center ?? {};
+  if (!isPlainObject(center)) {
+    throw new TypeError("Polar frame center must be a plain object.");
+  }
+  validateOptionObject(center, POLAR_CENTER_OPTIONS, "polar frame center");
+  const radius = value.radius ?? { unit: "fraction", value: 1 };
+  if (!isPlainObject(radius)) {
+    throw new TypeError("Polar frame radius must be a plain object.");
+  }
+  validateOptionObject(radius, POLAR_RADIUS_OPTIONS, "polar frame radius", {
+    allowEmpty: false,
+    emptyError: TypeError
+  });
+  if (!POLAR_RADIUS_UNITS.has(radius.unit)) {
+    throw new Error(`Unknown Polar frame radius unit "${radius.unit}".`);
+  }
+  if (!Number.isFinite(radius.value) || radius.value <= 0) {
+    throw new RangeError("Polar frame radius must be a positive finite number.");
+  }
+  if (radius.unit === "fraction" && radius.value > 1) {
+    throw new RangeError("Polar frame radius fraction must not exceed 1.");
+  }
+  return cloneAndFreeze({
+    center: {
+      x: finiteUnitInterval(center.x ?? 0.5, "Polar frame center x"),
+      y: finiteUnitInterval(center.y ?? 0.5, "Polar frame center y")
+    },
+    radius: {
+      unit: radius.unit,
+      value: radius.value
+    }
+  });
+}
+
+export function resolvePolarFrame(bounds, requestedFrame = "auto") {
   validateBounds(bounds);
+  if (requestedFrame === undefined || requestedFrame === "auto") {
+    return cloneAndFreeze({
+      centerX: bounds.x + bounds.width / 2,
+      centerY: bounds.y + bounds.height / 2,
+      availableRadius: Math.min(bounds.width, bounds.height) / 2
+    });
+  }
+  const requested = normalizePolarFrameOptions(requestedFrame);
+  const centerX = bounds.x + bounds.width * requested.center.x;
+  const centerY = bounds.y + bounds.height * requested.center.y;
+  const maximumRadius = Math.min(
+    centerX - bounds.x,
+    bounds.x + bounds.width - centerX,
+    centerY - bounds.y,
+    bounds.y + bounds.height - centerY
+  );
+  if (!Number.isFinite(maximumRadius) || maximumRadius <= 0) {
+    throw new RangeError(
+      "Polar frame center must leave a positive radius inside its bounds."
+    );
+  }
+  const availableRadius = requested.radius.unit === "fraction"
+    ? maximumRadius * requested.radius.value
+    : requested.radius.value;
+  if (availableRadius > maximumRadius) {
+    throw new RangeError(
+      `Polar frame radius ${availableRadius} exceeds the maximum radius ${maximumRadius}.`
+    );
+  }
   return cloneAndFreeze({
-    centerX: bounds.x + bounds.width / 2,
-    centerY: bounds.y + bounds.height / 2,
-    availableRadius: Math.min(bounds.width, bounds.height) / 2
+    centerX,
+    centerY,
+    availableRadius
   });
 }
 
@@ -50,7 +132,7 @@ export function validateRadialRange(range, availableRadius) {
   return validated;
 }
 
-export function resolvePolarScaleRange(range, channel, bounds) {
+export function resolvePolarScaleRange(range, channel, bounds, frame) {
   if (channel === "theta") {
     return range === "auto"
       ? cloneAndFreeze([0, 360])
@@ -59,10 +141,10 @@ export function resolvePolarScaleRange(range, channel, bounds) {
   if (channel !== "radius") {
     throw new Error(`Unknown Polar position channel "${channel}".`);
   }
-  const frame = resolvePolarFrame(bounds);
+  const resolvedFrame = frame ?? resolvePolarFrame(bounds);
   return range === "auto"
-    ? cloneAndFreeze([0, frame.availableRadius])
-    : validateRadialRange(range, frame.availableRadius);
+    ? cloneAndFreeze([0, resolvedFrame.availableRadius])
+    : validateRadialRange(range, resolvedFrame.availableRadius);
 }
 
 export function polarDirection(theta) {

package/src/grammar/regression/index.js

@@ -9,6 +9,7 @@ export {
 } from "./derive.js";
 export {
   normalizeRegressionParameters,
+  normalizeRegressionTransform,
   validateRegressionTransform
 } from "./parameters.js";
 

package/src/grammar/regression/parameters.js

@@ -139,3 +139,26 @@ export function validateRegressionTransform(transform) {
   }
   return transform;
 }
+
+export function normalizeRegressionTransform(args = {}) {
+  const parameters = normalizeRegressionParameters(args);
+  const transform = {
+    type: "regression",
+    method: parameters.method,
+    x: args.x,
+    y: args.y,
+    ...(args.groupBy === undefined ? {} : { groupBy: args.groupBy }),
+    ...(parameters.method === "polynomial"
+      ? { degree: parameters.degree }
+      : {}),
+    ...(parameters.method === "loess"
+      ? { span: parameters.span }
+      : {
+          confidenceMethod: parameters.confidenceMethod,
+          level: parameters.level,
+          interval: parameters.interval
+        })
+  };
+  validateRegressionTransform(transform);
+  return cloneAndFreeze(transform);
+}