ggaction 0.0.11 → 0.0.13

package/src/grammar/stack.js

@@ -0,0 +1,170 @@
+import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
+import { layoutSeriesPartition } from "./seriesLayout.js";
+
+const TRANSFORM_KEYS = Object.freeze([
+  "type", "category", "group", "value", "mode", "as"
+]);
+const AS_KEYS = Object.freeze(["start", "end", "value", "share"]);
+const MODES = new Set(["stack", "fill", "center", "diverging"]);
+const MAX_OUTPUT_ROWS = 10_000;
+
+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 normalizeAs(value, field) {
+  const requested = value ?? {};
+  if (!isPlainObject(requested)) return requested;
+  return {
+    ...requested,
+    start: requested.start ?? `${field}_start`,
+    end: requested.end ?? `${field}_end`,
+    value: requested.value ?? `${field}_value`,
+    share: requested.share ?? `${field}_share`
+  };
+}
+
+export function normalizeStackTransform({ category, group, value, mode, as } = {}) {
+  const transform = {
+    type: "stack",
+    category,
+    group,
+    value,
+    mode: mode ?? "stack",
+    as: normalizeAs(as, value)
+  };
+  validateStackTransform(transform);
+  return cloneAndFreeze(transform);
+}
+
+export function validateStackTransform(transform) {
+  if (!isPlainObject(transform)) {
+    throw new TypeError("Stack transform must be a plain object.");
+  }
+  rejectUnknownKeys(transform, TRANSFORM_KEYS, "stack transform");
+  if (transform.type !== "stack") {
+    throw new Error(`Unsupported stack transform "${transform.type}".`);
+  }
+  const roles = [
+    requireField(transform.category, "Stack category"),
+    requireField(transform.group, "Stack group"),
+    requireField(transform.value, "Stack value")
+  ];
+  if (new Set(roles).size !== roles.length) {
+    throw new Error("Stack category, group, and value fields must be unique.");
+  }
+  if (!MODES.has(transform.mode)) {
+    throw new Error(`Unsupported stack mode "${transform.mode}".`);
+  }
+  if (!isPlainObject(transform.as)) {
+    throw new TypeError("Stack as must be a plain object.");
+  }
+  rejectUnknownKeys(transform.as, AS_KEYS, "stack as");
+  const outputs = AS_KEYS.map(key => requireField(transform.as[key], `Stack as.${key}`));
+  if (new Set(outputs).size !== outputs.length) {
+    throw new Error("Stack output fields must be unique.");
+  }
+  return 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 resolvedPartition(entries, mode) {
+  const values = entries.map(entry => entry.row.value);
+  const segments = layoutSeriesPartition(values, mode);
+  const byIndex = new Map(segments.map(segment => [segment.index, segment]));
+  const shares = layoutSeriesPartition(values.map(Math.abs), "fill");
+  const shareByIndex = new Map(shares.map(segment => [
+    segment.index,
+    segment.end - segment.start
+  ]));
+  let boundary = mode === "center" ? segments[0]?.start ?? 0 : 0;
+  return entries.map((entry, index) => {
+    const segment = byIndex.get(index);
+    const start = segment?.start ?? (mode === "diverging" ? 0 : boundary);
+    const end = segment?.end ?? start;
+    if (segment !== undefined && mode !== "diverging") boundary = segment.end;
+    return {
+      index: entry.index,
+      value: entry.row.value,
+      start,
+      end,
+      share: shareByIndex.get(index) ?? 0
+    };
+  });
+}
+
+export function deriveStackRows(rows, transform) {
+  validateStackTransform(transform);
+  if (rows.length > MAX_OUTPUT_ROWS) {
+    throw new RangeError(`Stack output cannot exceed ${MAX_OUTPUT_ROWS} rows.`);
+  }
+  const sourceFields = new Set(rows.flatMap(row => Object.keys(row)));
+  for (const output of Object.values(transform.as)) {
+    if (sourceFields.has(output)) {
+      throw new Error(`Stack output field "${output}" already exists.`);
+    }
+  }
+  const partitions = new Map();
+  const groups = new Map();
+  rows.forEach((source, index) => {
+    for (const field of [transform.category, transform.group, transform.value]) {
+      if (!Object.hasOwn(source, field)) {
+        throw new Error(`Stack source does not contain field "${field}" at row ${index}.`);
+      }
+    }
+    const categoryKey = scalarKey(source[transform.category], "Stack category field");
+    const groupKey = scalarKey(source[transform.group], "Stack group field");
+    if (!Number.isFinite(source[transform.value])) {
+      throw new TypeError(
+        `Stack value field "${transform.value}" must contain a finite number at row ${index}.`
+      );
+    }
+    if (!groups.has(groupKey)) groups.set(groupKey, groups.size);
+    let partition = partitions.get(categoryKey);
+    if (partition === undefined) {
+      partition = new Map();
+      partitions.set(categoryKey, partition);
+    }
+    if (partition.has(groupKey)) {
+      throw new Error("Stack source requires one row per category/group cell.");
+    }
+    partition.set(groupKey, {
+      index,
+      row: { groupKey, value: source[transform.value] }
+    });
+  });
+
+  const resolved = new Array(rows.length);
+  for (const partition of partitions.values()) {
+    const entries = [...partition.values()].sort((left, right) =>
+      groups.get(left.row.groupKey) - groups.get(right.row.groupKey)
+    );
+    for (const item of resolvedPartition(entries, transform.mode)) {
+      resolved[item.index] = item;
+    }
+  }
+  return rows.map((row, index) => ({
+    ...row,
+    [transform.as.start]: resolved[index].start,
+    [transform.as.end]: resolved[index].end,
+    [transform.as.value]: resolved[index].value,
+    [transform.as.share]: resolved[index].share
+  }));
+}

package/src/grammar/statistics/confidenceInterval.js

@@ -0,0 +1,101 @@
+import { cloneAndFreeze } from "../../core/immutable.js";
+import { studentTCriticalValue } from "./studentT.js";
+
+export const CONFIDENCE_INTERVAL_METHODS = Object.freeze([
+  "normal",
+  "student-t"
+]);
+
+function validateMethod(method, label) {
+  if (!CONFIDENCE_INTERVAL_METHODS.includes(method)) {
+    throw new Error(`Unsupported ${label} method "${method}".`);
+  }
+}
+
+function validateLevel(level, label) {
+  if (!Number.isFinite(level) || level <= 0 || level >= 1) {
+    throw new RangeError(`${label} level must be between 0 and 1.`);
+  }
+}
+
+// Peter J. Acklam's inverse-normal approximation. The exact 95% compatibility
+// value is handled by normalCriticalValue before this approximation is used.
+function inverseNormal(probability) {
+  const a = [
+    -3.969683028665376e1, 2.209460984245205e2,
+    -2.759285104469687e2, 1.38357751867269e2,
+    -3.066479806614716e1, 2.506628277459239
+  ];
+  const b = [
+    -5.447609879822406e1, 1.615858368580409e2,
+    -1.556989798598866e2, 6.680131188771972e1,
+    -1.328068155288572e1
+  ];
+  const c = [
+    -7.784894002430293e-3, -3.223964580411365e-1,
+    -2.400758277161838, -2.549732539343734,
+    4.374664141464968, 2.938163982698783
+  ];
+  const d = [
+    7.784695709041462e-3, 3.224671290700398e-1,
+    2.445134137142996, 3.754408661907416
+  ];
+  const low = 0.02425;
+  const high = 1 - low;
+  if (probability < low) {
+    const q = Math.sqrt(-2 * Math.log(probability));
+    return (((((c[0] * q + c[1]) * q + c[2]) * q + c[3]) * q + c[4]) * q + c[5]) /
+      ((((d[0] * q + d[1]) * q + d[2]) * q + d[3]) * q + 1);
+  }
+  if (probability > high) {
+    const q = Math.sqrt(-2 * Math.log(1 - probability));
+    return -(((((c[0] * q + c[1]) * q + c[2]) * q + c[3]) * q + c[4]) * q + c[5]) /
+      ((((d[0] * q + d[1]) * q + d[2]) * q + d[3]) * q + 1);
+  }
+  const q = probability - 0.5;
+  const r = q * q;
+  return (((((a[0] * r + a[1]) * r + a[2]) * r + a[3]) * r + a[4]) * r + a[5]) * q /
+    (((((b[0] * r + b[1]) * r + b[2]) * r + b[3]) * r + b[4]) * r + 1);
+}
+
+export function normalizeConfidenceInterval({
+  method,
+  level
+} = {}, {
+  defaultMethod,
+  defaultLevel = 0.95,
+  label = "Confidence interval"
+} = {}) {
+  validateMethod(defaultMethod, label);
+  const resolvedMethod = method ?? defaultMethod;
+  const resolvedLevel = level ?? defaultLevel;
+  validateMethod(resolvedMethod, label);
+  validateLevel(resolvedLevel, label);
+  return cloneAndFreeze({ method: resolvedMethod, level: resolvedLevel });
+}
+
+export function normalCriticalValue(level) {
+  validateLevel(level, "Normal confidence interval");
+  if (level === 0.95) return 1.96;
+  return inverseNormal((1 + level) / 2);
+}
+
+export function confidenceCriticalValue({
+  method,
+  level,
+  degreesOfFreedom
+}) {
+  const normalized = normalizeConfidenceInterval(
+    { method, level },
+    { defaultMethod: method, label: "Confidence interval" }
+  );
+  if (normalized.method === "normal") {
+    return normalCriticalValue(normalized.level);
+  }
+  if (!Number.isInteger(degreesOfFreedom) || degreesOfFreedom < 1) {
+    throw new RangeError(
+      "Student-t confidence interval degreesOfFreedom must be a positive integer."
+    );
+  }
+  return studentTCriticalValue(normalized.level, degreesOfFreedom);
+}

package/src/grammar/summary.js

@@ -0,0 +1,183 @@
+import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
+import {
+  aggregateRows,
+  isScalarAggregate,
+  validateAggregate,
+  validateAggregateFieldValues
+} from "./aggregate.js";
+
+const TRANSFORM_KEYS = Object.freeze([
+  "type", "groupBy", "aggregates", "members"
+]);
+const AGGREGATE_KEYS = Object.freeze(["op", "field", "as"]);
+const NOMINAL_OPERATIONS = new Set(["distinct", "valid", "missing"]);
+const MAX_OUTPUT_ROWS = 10_000;
+
+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 normalizeAggregate(value) {
+  if (!isPlainObject(value)) return value;
+  return {
+    ...value,
+    op: validateAggregate(value.op),
+    ...(Object.hasOwn(value, "field") ? { field: value.field } : {}),
+    as: value.as
+  };
+}
+
+export function normalizeSummaryTransform({ groupBy, aggregates, members } = {}) {
+  const transform = {
+    type: "summary",
+    groupBy: normalizeGroupBy(groupBy),
+    aggregates: Array.isArray(aggregates)
+      ? aggregates.map(normalizeAggregate)
+      : aggregates,
+    ...(members === undefined ? {} : { members })
+  };
+  validateSummaryTransform(transform);
+  return cloneAndFreeze(transform);
+}
+
+export function validateSummaryTransform(transform) {
+  if (!isPlainObject(transform)) {
+    throw new TypeError("Summary transform must be a plain object.");
+  }
+  rejectUnknownKeys(transform, TRANSFORM_KEYS, "summary transform");
+  if (transform.type !== "summary") {
+    throw new Error(`Unsupported summary transform "${transform.type}".`);
+  }
+  if (
+    !Array.isArray(transform.groupBy) ||
+    transform.groupBy.some(field => typeof field !== "string" || field.length === 0)
+  ) {
+    throw new TypeError("Summary groupBy must contain field names.");
+  }
+  if (new Set(transform.groupBy).size !== transform.groupBy.length) {
+    throw new Error("Summary groupBy fields must be unique.");
+  }
+  if (!Array.isArray(transform.aggregates) || transform.aggregates.length === 0) {
+    throw new TypeError("Summary aggregates must be a non-empty array.");
+  }
+  if (transform.aggregates.length > 64) {
+    throw new RangeError("Summary aggregates cannot contain more than 64 outputs.");
+  }
+  const outputs = new Set(transform.groupBy);
+  transform.aggregates.forEach((aggregate, index) => {
+    if (!isPlainObject(aggregate)) {
+      throw new TypeError(`Summary aggregate ${index} must be a plain object.`);
+    }
+    rejectUnknownKeys(aggregate, AGGREGATE_KEYS, `summary aggregate ${index}`);
+    const operation = validateAggregate(aggregate.op);
+    if (operation === "count") {
+      if (Object.hasOwn(aggregate, "field")) {
+        throw new Error("Summary count does not accept a field.");
+      }
+    } else {
+      requireField(aggregate.field, `Summary aggregate ${index} field`);
+    }
+    const output = requireField(aggregate.as, `Summary aggregate ${index} as`);
+    if (outputs.has(output)) {
+      throw new Error(`Summary output field "${output}" collides with another output.`);
+    }
+    outputs.add(output);
+  });
+  if (transform.members !== undefined) {
+    const members = requireField(transform.members, "Summary members");
+    if (outputs.has(members)) {
+      throw new Error(`Summary members field "${members}" collides with another output.`);
+    }
+  }
+  return 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 requireSourceFields(rows, transform) {
+  if (rows.length === 0) return;
+  const fields = new Set(rows.flatMap(row => Object.keys(row)));
+  for (const field of transform.groupBy) {
+    if (!fields.has(field)) {
+      throw new Error(`Summary source does not contain group field "${field}".`);
+    }
+  }
+  for (const aggregate of transform.aggregates) {
+    if (aggregate.field !== undefined && !fields.has(aggregate.field)) {
+      throw new Error(`Summary source does not contain aggregate field "${aggregate.field}".`);
+    }
+    const orderBy = isPlainObject(aggregate.op) ? aggregate.op.orderBy : undefined;
+    if (orderBy !== undefined && !fields.has(orderBy)) {
+      throw new Error(`Summary source does not contain order field "${orderBy}".`);
+    }
+  }
+}
+
+function validateAggregateValues(rows, aggregate) {
+  if (aggregate.op === "count") return;
+  if (isScalarAggregate(aggregate.op) && NOMINAL_OPERATIONS.has(aggregate.op)) {
+    validateAggregateFieldValues(rows, aggregate.field, "nominal");
+    return;
+  }
+  validateAggregateFieldValues(rows, aggregate.field, "quantitative");
+}
+
+export function deriveSummaryRows(rows, transform) {
+  validateSummaryTransform(transform);
+  requireSourceFields(rows, transform);
+  for (const aggregate of transform.aggregates) {
+    validateAggregateValues(rows, aggregate);
+  }
+
+  const groups = new Map();
+  if (transform.groupBy.length === 0) {
+    groups.set("all", { values: {}, rows });
+  } else {
+    rows.forEach(row => {
+      const values = Object.fromEntries(transform.groupBy.map(field => [field, row[field]]));
+      const key = transform.groupBy.map(field =>
+        scalarKey(row[field], `Summary group field "${field}"`)
+      ).join("|");
+      const group = groups.get(key) ?? { values, rows: [] };
+      group.rows.push(row);
+      groups.set(key, group);
+    });
+  }
+  if (groups.size > MAX_OUTPUT_ROWS) {
+    throw new RangeError(`Summary output cannot exceed ${MAX_OUTPUT_ROWS} groups.`);
+  }
+
+  return [...groups.values()].map(group => ({
+    ...group.values,
+    ...Object.fromEntries(transform.aggregates.map(aggregate => [
+      aggregate.as,
+      aggregateRows(group.rows, aggregate.field ?? "__row", aggregate.op)
+    ])),
+    ...(transform.members === undefined ? {} : { [transform.members]: group.rows })
+  }));
+}

package/src/grammar/text.js

@@ -1,5 +1,15 @@
 import { cloneAndFreeze } from "../core/immutable.js";
 import { validateConcreteGraphicValue } from "./schemas/concreteGraphic.js";
+import {
+  formatValue,
+  isUtcValueFormat,
+  validateValueFormat
+} from "./valueFormat.js";
+import { resolveRotation } from "./rotation.js";
+
+export function isSourceOwnedText(layer) {
+  return layer?.mark?.type === "text" && layer.source !== undefined;
+}
 
 export const DEFAULT_TEXT_MARK = cloneAndFreeze({
   fill: "#334155",
@@ -14,20 +24,13 @@ export const DEFAULT_TEXT_MARK = cloneAndFreeze({
   dy: 0
 });
 
-const FIXED_FORMAT = /^\.(\d{1,2})f$/;
-
 export function validateTextFormat(format) {
-  if (format === undefined || format === "auto") return format ?? "auto";
-  if (typeof format !== "string" || !FIXED_FORMAT.test(format)) {
+  if (format !== undefined && typeof format !== "string") {
     throw new Error(
-      'Text format must be "auto" or a fixed-decimal token such as ".1f".'
+      'Text format must be "auto" or a supported numeric/UTC format string.'
     );
   }
-  const decimals = Number(format.match(FIXED_FORMAT)[1]);
-  if (decimals > 12) {
-    throw new RangeError("Text fixed-decimal format supports at most 12 decimals.");
-  }
-  return format;
+  return validateValueFormat(format, "Text format");
 }
 
 export function formatTextValue(value, format = "auto") {
@@ -37,10 +40,11 @@ export function formatTextValue(value, format = "auto") {
     const text = String(value);
     return text.length === 0 ? undefined : text;
   }
-  if (!Number.isFinite(value)) {
-    throw new TypeError(`Text format "${resolved}" requires a finite number.`);
-  }
-  return value.toFixed(Number(resolved.match(FIXED_FORMAT)[1]));
+  return formatValue(value, {
+    format: resolved,
+    valueType: isUtcValueFormat(resolved) ? "temporal" : "quantitative",
+    label: "Text format"
+  });
 }
 
 export function normalizeTextMarkConfig(options, base = DEFAULT_TEXT_MARK) {
@@ -52,14 +56,16 @@ export function normalizeTextMarkConfig(options, base = DEFAULT_TEXT_MARK) {
     fontFamily: "fontFamily",
     fontWeight: "fontWeight",
     align: "textAlign",
-    baseline: "textBaseline",
-    rotation: "rotation"
+    baseline: "textBaseline"
   };
   for (const [option, property] of Object.entries(mapping)) {
     if (!Object.hasOwn(options, option)) continue;
     validateConcreteGraphicValue("text", property, options[option]);
     config[option] = options[option];
   }
+  if (Object.hasOwn(options, "rotation")) {
+    config.rotation = resolveRotation(options.rotation, "Text rotation");
+  }
   for (const property of ["dx", "dy"]) {
     if (!Object.hasOwn(options, property)) continue;
     if (!Number.isFinite(options[property])) {

package/src/grammar/timeUnit.js

@@ -1,5 +1,5 @@
 import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
-import { normalizeTemporalValue } from "./scales/fields.js";
+import { normalizeTemporalValue, validateTemporalUnit } from "./scales/fields.js";
 
 export function utcTimestamp(
   year,
@@ -18,6 +18,14 @@ export function validTimestamp(value) {
   return Number.isFinite(value) && Number.isFinite(new Date(value).getTime());
 }
 
+function utcBucket(...parts) {
+  const timestamp = utcTimestamp(...parts);
+  if (!validTimestamp(timestamp)) {
+    throw new RangeError("Time-unit bucket start is outside the supported Date range.");
+  }
+  return timestamp;
+}
+
 export const TIME_UNITS = cloneAndFreeze([
   "year",
   "quarter",
@@ -28,7 +36,7 @@ export const TIME_UNITS = cloneAndFreeze([
   "second"
 ]);
 
-const TRANSFORM_KEYS = Object.freeze(["type", "field", "unit", "as"]);
+const TRANSFORM_KEYS = Object.freeze(["type", "field", "unit", "as", "temporalUnit"]);
 
 function requireField(value, label) {
   if (typeof value !== "string" || value.length === 0) {
@@ -52,6 +60,7 @@ export function validateTimeUnitTransform(transform) {
   if (transform.type !== "timeUnit") {
     throw new Error(`Unsupported time-unit transform "${transform.type}".`);
   }
+  validateTemporalUnit(transform.temporalUnit);
   const field = requireField(transform.field, "Time-unit field");
   const output = requireField(transform.as, "Time-unit output field");
   if (field === output) {
@@ -63,8 +72,9 @@ export function validateTimeUnitTransform(transform) {
   return transform;
 }
 
-export function normalizeTimeUnitTransform({ field, unit, as } = {}) {
-  const transform = { type: "timeUnit", field, unit, as };
+export function normalizeTimeUnitTransform({ field, unit, as, temporalUnit } = {}) {
+  const transform = { type: "timeUnit", field, unit, as,
+    ...(temporalUnit === undefined ? {} : { temporalUnit }) };
   validateTimeUnitTransform(transform);
   return cloneAndFreeze(transform);
 }
@@ -82,15 +92,15 @@ export function floorUtcTimeUnit(timestamp, unit) {
   }
   const year = date.getUTCFullYear();
   const month = date.getUTCMonth();
-  if (unit === "year") return utcTimestamp(year);
-  if (unit === "quarter") return utcTimestamp(year, Math.floor(month / 3) * 3);
-  if (unit === "month") return utcTimestamp(year, month);
+  if (unit === "year") return utcBucket(year);
+  if (unit === "quarter") return utcBucket(year, Math.floor(month / 3) * 3);
+  if (unit === "month") return utcBucket(year, month);
   const day = date.getUTCDate();
-  if (unit === "day") return utcTimestamp(year, month, day);
+  if (unit === "day") return utcBucket(year, month, day);
   const hour = date.getUTCHours();
-  if (unit === "hour") return utcTimestamp(year, month, day, hour);
+  if (unit === "hour") return utcBucket(year, month, day, hour);
   const minute = date.getUTCMinutes();
-  if (unit === "minute") return utcTimestamp(year, month, day, hour, minute);
+  if (unit === "minute") return utcBucket(year, month, day, hour, minute);
   return Math.floor(timestamp / 1000) * 1000;
 }
 
@@ -108,7 +118,7 @@ export function deriveTimeUnitRows(rows, transform) {
     if (Object.hasOwn(row, transform.as)) {
       throw new Error(`Time-unit output field "${transform.as}" already exists.`);
     }
-    const timestamp = normalizeTemporalValue(row[transform.field], transform.field, index);
+    const timestamp = normalizeTemporalValue(row[transform.field], transform.field, index, transform.temporalUnit);
     return {
       ...row,
       [transform.as]: floorUtcTimeUnit(timestamp, transform.unit)

package/src/grammar/transformTopology.js

@@ -1,14 +1,20 @@
 const TRANSFORM_TOPOLOGY = Object.freeze({
+  bin: Object.freeze({ facetTopology: "statistical" }),
   bin2d: Object.freeze({ facetTopology: "statistical" }),
+  computed: Object.freeze({ facetTopology: "rowPreserving" }),
   boxOutlier: Object.freeze({ facetTopology: "statistical" }),
   boxSummary: Object.freeze({ facetTopology: "statistical" }),
   density: Object.freeze({ facetTopology: "statistical" }),
+  ecdf: Object.freeze({ facetTopology: "statistical" }),
   filter: Object.freeze({ facetTopology: "rowPreserving" }),
+  fold: Object.freeze({ facetTopology: "statistical" }),
   gradientProfile: Object.freeze({ facetTopology: "statistical" }),
   horizon: Object.freeze({ facetTopology: "statistical" }),
   interval: Object.freeze({ facetTopology: "statistical" }),
   markFilter: Object.freeze({ provenanceTransparent: true }),
   regression: Object.freeze({ facetTopology: "statistical" }),
+  summary: Object.freeze({ facetTopology: "statistical" }),
+  stack: Object.freeze({ facetTopology: "statistical" }),
   timeUnit: Object.freeze({ facetTopology: "rowPreserving" }),
   window: Object.freeze({ facetTopology: "statistical" })
 });