ggaction 0.0.19 → 0.0.21

package/src/grammar/interval.js

@@ -4,6 +4,9 @@ import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
 import { aggregateScalarValues } from "./aggregate.js";
 import { requireFiniteResult, stableDecimal } from "./numeric.js";
 import {
+  createBootstrapMeanSampler,
+  bootstrapMeanBounds,
+  validateBootstrapDrawCount,
   confidenceCriticalValue,
   normalizeConfidenceInterval
 } from "./statistics/confidenceInterval.js";
@@ -91,7 +94,8 @@ export function validateIntervalTransform(transform) {
   if (transform.extent === "ci") {
     normalizeConfidenceInterval(transform, {
       defaultMethod: "student-t",
-      label: "Interval CI"
+      label: "Interval CI",
+      allowBootstrap: true
     });
   } else if (transform.method !== undefined) {
     throw new Error("Interval method is supported only for ci extent.");
@@ -117,11 +121,12 @@ export function normalizeIntervalParameters({
   extent = "ci",
   method,
   level
-} = {}) {
+} = {}, { allowBootstrap = false } = {}) {
   const confidence = extent === "ci"
     ? normalizeConfidenceInterval({ method, level }, {
         defaultMethod: "student-t",
-        label: "Interval CI"
+        label: "Interval CI",
+        allowBootstrap
       })
     : undefined;
   const candidate = {
@@ -164,7 +169,11 @@ function isMissing(value) {
 }
 
 
-function deriveGroup(values, transform) {
+function deriveGroup(values, transform, bootstrapSampler) {
+  if (bootstrapSampler !== undefined) {
+    const bounds = bootstrapMeanBounds(bootstrapSampler(values), transform.level);
+    return bounds === undefined ? undefined : { center: aggregateScalarValues(values, "mean"), ...bounds };
+  }
   if (transform.center === "median") {
     if (values.length === 0) return undefined;
     return {
@@ -235,15 +244,23 @@ export function deriveInterval(rows, transform) {
     groups.get(key).values.push(value);
   }
 
+  const bootstrapMethod = transform.method?.type === "bootstrap"
+    ? normalizeConfidenceInterval(transform, { defaultMethod: "student-t", allowBootstrap: true }).method : undefined;
+  if (bootstrapMethod !== undefined) {
+    validateBootstrapDrawCount(bootstrapMethod.samples * [...groups.values()].reduce((count, group) => count + group.values.length, 0));
+  }
+  const bootstrapSampler = bootstrapMethod === undefined ? undefined : createBootstrapMeanSampler(bootstrapMethod);
+
+  const outputValue = bootstrapSampler === undefined ? stableDecimal : requireFiniteResult;
   const output = [];
   for (const group of groups.values()) {
-    const result = deriveGroup(group.values, transform);
+    const result = deriveGroup(group.values, transform, bootstrapSampler);
     if (result === undefined) continue;
     output.push({
       ...group.fields,
-      [transform.as.center]: stableDecimal(result.center),
-      [transform.as.lower]: stableDecimal(result.lower),
-      [transform.as.upper]: stableDecimal(result.upper)
+      [transform.as.center]: outputValue(result.center),
+      [transform.as.lower]: outputValue(result.lower),
+      [transform.as.upper]: outputValue(result.upper)
     });
   }
   if (transform.missing === undefined) return cloneAndFreeze(output);
@@ -277,7 +294,7 @@ export function normalizeIntervalTransform({
 }) {
   nonEmptyString(field, "Interval field");
   const grouping = normalizeGrouping(groupBy);
-  const parameters = normalizeIntervalParameters({ center, extent, method, level });
+  const parameters = normalizeIntervalParameters({ center, extent, method, level }, { allowBootstrap: true });
   const transform = {
     type: "interval",
     field,

package/src/grammar/pathSeries.js

@@ -42,7 +42,7 @@ export function readPathSeriesFields(rows, layer) {
 
 function seriesValueIndex(rows, fields, field, channel, encoding = {}) {
   const quantitative = channel === "strokeWidth" || channel === "opacity";
-  const values = channel === "stroke"
+  const values = channel === "stroke" || (channel === "color" && encoding.fieldType === "quantitative")
     ? readScaleField(rows, field, encoding.fieldType ?? "nominal", {
         temporalUnit: encoding.temporalUnit
       })
@@ -88,7 +88,7 @@ export function validatePathSeriesAppearance(rows, layer) {
     if (encoding?.field === undefined) continue;
     const allowed = ["color", "stroke"].includes(channel)
       ? channel === "color"
-        ? ["nominal", "ordinal"]
+        ? layer.mark.type === "area" ? ["nominal", "ordinal", "quantitative"] : ["nominal", "ordinal"]
         : ["nominal", "ordinal", "quantitative", "temporal"]
       : channel === "strokeDash" ? ["nominal"] : ["quantitative"];
     if (!allowed.includes(encoding.fieldType)) {

package/src/grammar/scales/colorConsumers.js

@@ -26,8 +26,8 @@ export function validateContinuousColorConsumer(layer, encoding, scale, {
     }
     return undefined;
   }
-  if (!["point", "bar", "rect", "text"].includes(kind)) {
-    throw new Error("Continuous color requires a Point, aggregate Bar, Rect, or Text consumer.");
+  if (!["point", "bar", "rect", "text", "area"].includes(kind)) {
+    throw new Error("Continuous color requires a Point, aggregate Bar, Rect, Text, or quantitative Area consumer.");
   }
   if (!["quantitative", "temporal"].includes(encoding.fieldType) ||
     (isDiscretizedColorScaleType(scale.type) && encoding.fieldType !== "quantitative")) {
@@ -36,6 +36,9 @@ export function validateContinuousColorConsumer(layer, encoding, scale, {
   if (Object.hasOwn(scale, "unknown") && kind !== "point") {
     throw new Error("Continuous color scale unknown currently requires a row-owned point mark.");
   }
+  if (kind === "area" && encoding.fieldType !== "quantitative") {
+    throw new Error("Continuous area color requires a quantitative field.");
+  }
   if (kind !== "bar") {
     if (encoding.aggregate !== undefined) throw new Error(`${kind} continuous color does not support aggregate.`);
     return undefined;

package/src/grammar/statistics/confidenceInterval.js

@@ -1,101 +1 @@
-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);
-}
+import{quantileSorted as d,requireFiniteResult as c}from"../numeric.js";import{cloneAndFreeze as m,isPlainObject as w}from"../../core/immutable.js";import{studentTCriticalValue as g}from"./studentT.js";const h=Object.freeze(["normal","student-t"]);function l(e,n,r=!1){if(r&&w(e)){const t=Object.keys(e).find(a=>!["type","seed","samples"].includes(a));if(t!==void 0)throw new Error(`Unknown bootstrap method property "${t}".`);if(e.type!=="bootstrap")throw new Error(`Unsupported ${n} method type.`);if(!Number.isInteger(e.seed)||e.seed<1||e.seed>2147483646)throw new RangeError("Bootstrap seed must be an integer between 1 and 2147483646.");const o=e.samples===void 0?1e3:e.samples;if(!Number.isInteger(o)||o<1||o>1e4)throw new RangeError("Bootstrap samples must be an integer between 1 and 10000.");return{type:"bootstrap",seed:e.seed,samples:o}}if(!h.includes(e))throw new Error(`Unsupported ${n} method "${e}".`);return e}function f(e,n){if(!Number.isFinite(e)||e<=0||e>=1)throw new RangeError(`${n} level must be between 0 and 1.`)}function E(e){const n=[-39.69683028665376,220.9460984245205,-275.9285104469687,138.357751867269,-30.66479806614716,2.506628277459239],r=[-54.47609879822406,161.5858368580409,-155.6989798598866,66.80131188771972,-13.28068155288572],t=[-.007784894002430293,-.3223964580411365,-2.400758277161838,-2.549732539343734,4.374664141464968,2.938163982698783],o=[.007784695709041462,.3224671290700398,2.445134137142996,3.754408661907416],a=.02425,u=1-a;if(e<a){const s=Math.sqrt(-2*Math.log(e));return(((((t[0]*s+t[1])*s+t[2])*s+t[3])*s+t[4])*s+t[5])/((((o[0]*s+o[1])*s+o[2])*s+o[3])*s+1)}if(e>u){const s=Math.sqrt(-2*Math.log(1-e));return-(((((t[0]*s+t[1])*s+t[2])*s+t[3])*s+t[4])*s+t[5])/((((o[0]*s+o[1])*s+o[2])*s+o[3])*s+1)}const p=e-.5,i=p*p;return(((((n[0]*i+n[1])*i+n[2])*i+n[3])*i+n[4])*i+n[5])*p/(((((r[0]*i+r[1])*i+r[2])*i+r[3])*i+r[4])*i+1)}function b({method:e,level:n}={},{defaultMethod:r,defaultLevel:t=.95,label:o="Confidence interval",allowBootstrap:a=!1}={}){l(r,o);const u=l(e??r,o,a),p=n??t;return f(p,o),m({method:u,level:p})}function B(e){return f(e,"Normal confidence interval"),e===.95?1.96:E((1+e)/2)}function q({method:e,level:n,degreesOfFreedom:r}){const t=b({method:e,level:n},{defaultMethod:e,label:"Confidence interval"});if(t.method==="normal")return B(t.level);if(!Number.isInteger(r)||r<1)throw new RangeError("Student-t confidence interval degreesOfFreedom must be a positive integer.");return g(t.level,r)}function x(e){if(!Number.isSafeInteger(e)||e<0||e>5e7)throw new RangeError("Bootstrap resampling cannot exceed 50000000 draws per action.")}function M(e){const n=l(e,"Bootstrap mean interval",!0);if(n?.type!=="bootstrap")throw new Error("Bootstrap sampler requires a bootstrap method.");let r=n.seed;return t=>{if(t.length===0)return[];const o=[];for(let a=0;a<n.samples;a+=1){let u=0;for(let p=0;p<t.length;p+=1)r=(1103515245*r+12345)%2147483647,u+=t[Math.floor(r/2147483647*t.length)];o.push(c(u/t.length,"Bootstrap sample mean"))}return o.sort((a,u)=>a-u)}}function I(e,n=.95){if(f(n,"Bootstrap mean interval"),e.length===0)return;const r=(1-n)/2;return{lower:c(d(e,r),"Bootstrap lower endpoint"),upper:c(d(e,1-r),"Bootstrap upper endpoint")}}export{h as CONFIDENCE_INTERVAL_METHODS,I as bootstrapMeanBounds,q as confidenceCriticalValue,M as createBootstrapMeanSampler,B as normalCriticalValue,b as normalizeConfidenceInterval,x as validateBootstrapDrawCount};

package/src/grammar/summary.js

@@ -1,320 +1 @@
-import { scalarKey } from "./transformKeys.js";
-import { rejectUnknownProperties as rejectUnknownKeys } from "../core/validation.js";
-import { requireStringValue as requireField } from "../core/validation.js";
-import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
-import {
-  aggregateRows,
-  isScalarAggregate,
-  validateAggregate,
-  validateAggregateFieldValues
-} from "./aggregate.js";
-import {
-  calculateWeightedAggregate,
-  normalizeStatisticalWeight,
-  readStatisticalWeights,
-  summarizeStatisticalWeights,
-  validateWeightedAggregate,
-  validateWeightedNumericFields,
-  weightedRows
-} from "./weightedStatistics.js";
-
-const TRANSFORM_KEYS = Object.freeze([
-  "type", "groupBy", "aggregates", "members", "weight", "missing", "empty"
-]);
-const AGGREGATE_KEYS = Object.freeze(["op", "field", "as"]);
-const NOMINAL_OPERATIONS = new Set(["distinct", "valid", "missing"]);
-const MAX_OUTPUT_ROWS = 30_000;
-
-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, weight, missing, empty } = {}) {
-  const transform = {
-    type: "summary",
-    groupBy: normalizeGroupBy(groupBy),
-    aggregates: Array.isArray(aggregates)
-      ? aggregates.map(normalizeAggregate)
-      : aggregates,
-    ...(members === undefined ? {} : { members }),
-    ...(weight === undefined
-      ? {}
-      : { weight: normalizeStatisticalWeight(weight, "Summary weight") }),
-    ...(missing === undefined ? {} : { missing }),
-    ...(empty === undefined ? {} : { empty })
-  };
-  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 (transform.weight !== undefined) validateWeightedAggregate(operation);
-    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.`);
-    }
-  }
-  if (transform.weight !== undefined) {
-    normalizeStatisticalWeight(transform.weight, "Summary weight");
-  }
-  if (transform.missing !== undefined && !["error", "drop"].includes(transform.missing)) {
-    throw new Error('Summary missing must be "error" or "drop".');
-  }
-  if (transform.empty !== undefined && !["null", "identity"].includes(transform.empty)) {
-    throw new Error('Summary empty must be "null" or "identity".');
-  }
-  return transform;
-}
-
-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}".`);
-    }
-  }
-  if (transform.weight !== undefined && !fields.has(transform.weight.field)) {
-    throw new Error(`Summary source does not contain weight field "${transform.weight.field}".`);
-  }
-}
-
-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);
-  const explicitWeighted = transform.weight !== undefined && transform.missing !== undefined;
-  let weightEntries;
-  if (transform.weight === undefined) {
-    for (const aggregate of transform.aggregates) {
-      validateAggregateValues(rows, aggregate);
-    }
-  } else if (!explicitWeighted) {
-    weightEntries = readStatisticalWeights(rows, transform.weight, "Summary").entries;
-    validateWeightedNumericFields(
-      weightEntries,
-      [...new Set(transform.aggregates.flatMap(aggregate =>
-        aggregate.field === undefined ? [] : [aggregate.field]
-      ))],
-      "Summary"
-    );
-  } else {
-    // Explicit missing policy is evaluated per measure. Validate every
-    // nonmissing value now, while leaving nullish value/weight pairs for the
-    // reason-priority accounting below.
-    readStatisticalWeights(
-      rows.filter(row => row[transform.weight.field] !== null && row[transform.weight.field] !== undefined),
-      transform.weight,
-      "Summary"
-    );
-    for (const aggregate of transform.aggregates) {
-      if (aggregate.field === undefined) continue;
-      validateAggregateValues(
-        rows.filter(row => row[aggregate.field] !== null && row[aggregate.field] !== undefined),
-        aggregate
-      );
-    }
-  }
-  if (transform.missing === "error") {
-    if (transform.weight !== undefined) {
-      const weightIndex = rows.findIndex(row =>
-        row[transform.weight.field] === null || row[transform.weight.field] === undefined
-      );
-      if (weightIndex !== -1) {
-        throw new TypeError(`Summary weight "${transform.weight.field}" is missing at row ${weightIndex}.`);
-      }
-    }
-    for (const aggregate of transform.aggregates) {
-      if (aggregate.field === undefined) continue;
-      const index = rows.findIndex(row => row[aggregate.field] === null || row[aggregate.field] === undefined);
-      if (index !== -1) throw new TypeError(`Summary field "${aggregate.field}" is missing at row ${index}.`);
-    }
-  }
-
-  const groups = new Map();
-  if (transform.groupBy.length === 0) {
-    groups.set("all", {
-      values: {},
-      rows,
-      ...(weightEntries === undefined ? {} : { entries: weightEntries })
-    });
-  } else {
-    rows.forEach((row, index) => {
-      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: [],
-        ...(weightEntries === undefined ? {} : { entries: [] })
-      };
-      group.rows.push(row);
-      if (weightEntries !== undefined) group.entries.push(weightEntries[index]);
-      groups.set(key, group);
-    });
-  }
-  if (groups.size > MAX_OUTPUT_ROWS) {
-    throw new RangeError(`Summary output cannot exceed ${MAX_OUTPUT_ROWS} groups.`);
-  }
-
-  const units = [];
-  const values = [...groups.values()].map(group => {
-    const sharedWeightSummary = transform.weight === undefined || explicitWeighted
-      ? undefined
-      : summarizeStatisticalWeights(
-          group.entries,
-          transform.weight.kind,
-          "Summary group"
-        );
-    const aggregated = Object.fromEntries(transform.aggregates.map(aggregate => {
-      let missingValue = 0;
-      let missingWeight = 0;
-      let zeroWeightRows = 0;
-      let measureWeightSummary = sharedWeightSummary;
-      if (explicitWeighted) {
-        const eligible = group.rows.filter(row => {
-          if (aggregate.field !== undefined &&
-              (row[aggregate.field] === null || row[aggregate.field] === undefined)) {
-            missingValue += 1;
-            return false;
-          }
-          if (row[transform.weight.field] === null || row[transform.weight.field] === undefined) {
-            missingWeight += 1;
-            return false;
-          }
-          return true;
-        });
-        const entries = readStatisticalWeights(eligible, transform.weight, "Summary").entries;
-        zeroWeightRows = entries.filter(entry => entry.weight === 0).length;
-        measureWeightSummary = summarizeStatisticalWeights(
-          entries,
-          transform.weight.kind,
-          "Summary group"
-        );
-      }
-      let value = measureWeightSummary === undefined
-        ? aggregateRows(group.rows, aggregate.field ?? "__row", aggregate.op)
-        : calculateWeightedAggregate(
-            measureWeightSummary,
-            aggregate.field,
-            aggregate.op,
-            `Summary aggregate "${aggregate.as}"`
-          );
-      if (value === undefined && transform.empty !== undefined) {
-        const op = typeof aggregate.op === "string" ? aggregate.op : aggregate.op.op;
-        value = transform.empty === "identity" && op === "sum" ? 0 : null;
-      }
-      if (transform.missing !== undefined || transform.empty !== undefined) {
-        const missing = explicitWeighted
-          ? missingValue + missingWeight
-          : aggregate.field === undefined ? 0 : group.rows.filter(row => row[aggregate.field] === null || row[aggregate.field] === undefined).length;
-        units.push({
-          role: aggregate.as,
-          group: group.values,
-          inputRows: group.rows.length,
-          usedRows: group.rows.length - missing,
-          excludedRows: missing,
-          excludedByReason: missing === 0 ? {} : {
-            ...(missingValue === 0 && explicitWeighted ? {} : { "missing-value": explicitWeighted ? missingValue : missing }),
-            ...(missingWeight === 0 ? {} : { "missing-weight": missingWeight })
-          },
-          ...(explicitWeighted ? { zeroWeightRows } : {})
-        });
-      }
-      return [aggregate.as, value];
-    }));
-    return {
-      ...group.values,
-      ...aggregated,
-      ...(transform.members === undefined
-        ? {}
-        : {
-            [transform.members]: sharedWeightSummary === undefined
-              ? group.rows
-              : weightedRows(sharedWeightSummary)
-          })
-    };
-  });
-  if (transform.missing === undefined && transform.empty === undefined) return values;
-  return {
-    values,
-    report: cloneAndFreeze({
-      version: 1,
-      owner: { kind: "data", id: "pending" },
-      inputs: [],
-      units
-    })
-  };
-}
+import{createBootstrapMeanSampler as q,bootstrapMeanBounds as I,validateBootstrapDrawCount as U}from"./statistics/confidenceInterval.js";import{scalarKey as V}from"./transformKeys.js";import{rejectUnknownProperties as W}from"../core/validation.js";import{requireStringValue as E}from"../core/validation.js";import{cloneAndFreeze as v,isPlainObject as g}from"../core/immutable.js";import{aggregateRows as G,isScalarAggregate as K,validateAggregate as B,validateAggregateFieldValues as z}from"./aggregate.js";import{calculateWeightedAggregate as P,normalizeStatisticalWeight as M,readStatisticalWeights as A,summarizeStatisticalWeights as k,validateWeightedAggregate as J,validateWeightedNumericFields as L,weightedRows as Y}from"./weightedStatistics.js";const C=Object.freeze(["type","groupBy","aggregates","members","weight","missing","empty"]),D=Object.freeze(["op","field","as"]),X=new Set(["distinct","valid","missing"]),N=3e4;function H(e){return e===void 0?[]:Array.isArray(e)?[...e]:[e]}function Q(e){return g(e)?{...e,op:B(e.op,{allowBootstrap:!0}),...Object.hasOwn(e,"field")?{field:e.field}:{},as:e.as}:e}function ue({groupBy:e,aggregates:i,members:n,weight:o,missing:u,empty:l}={}){const m={type:"summary",groupBy:H(e),aggregates:Array.isArray(i)?i.map(Q):i,...n===void 0?{}:{members:n},...o===void 0?{}:{weight:M(o,"Summary weight")},...u===void 0?{}:{missing:u},...l===void 0?{}:{empty:l}};return x(m),v(m)}function x(e){if(!g(e))throw new TypeError("Summary transform must be a plain object.");if(W(e,C,"summary transform"),e.type!=="summary")throw new Error(`Unsupported summary transform "${e.type}".`);if(!Array.isArray(e.groupBy)||e.groupBy.some(n=>typeof n!="string"||n.length===0))throw new TypeError("Summary groupBy must contain field names.");if(new Set(e.groupBy).size!==e.groupBy.length)throw new Error("Summary groupBy fields must be unique.");if(!Array.isArray(e.aggregates)||e.aggregates.length===0)throw new TypeError("Summary aggregates must be a non-empty array.");if(e.aggregates.length>64)throw new RangeError("Summary aggregates cannot contain more than 64 outputs.");const i=new Set(e.groupBy);if(e.aggregates.forEach((n,o)=>{if(!g(n))throw new TypeError(`Summary aggregate ${o} must be a plain object.`);W(n,D,`summary aggregate ${o}`);const u=B(n.op,{allowBootstrap:!0});if(e.weight!==void 0&&J(u),u==="count"){if(Object.hasOwn(n,"field"))throw new Error("Summary count does not accept a field.")}else E(n.field,`Summary aggregate ${o} field`);const l=E(n.as,`Summary aggregate ${o} as`);if(i.has(l))throw new Error(`Summary output field "${l}" collides with another output.`);i.add(l)}),e.members!==void 0){const n=E(e.members,"Summary members");if(i.has(n))throw new Error(`Summary members field "${n}" collides with another output.`)}if(e.weight!==void 0&&M(e.weight,"Summary weight"),e.missing!==void 0&&!["error","drop"].includes(e.missing))throw new Error('Summary missing must be "error" or "drop".');if(e.empty!==void 0&&!["null","identity"].includes(e.empty))throw new Error('Summary empty must be "null" or "identity".');return e}function Z(e,i){if(e.length===0)return;const n=new Set(e.flatMap(o=>Object.keys(o)));for(const o of i.groupBy)if(!n.has(o))throw new Error(`Summary source does not contain group field "${o}".`);for(const o of i.aggregates){if(o.field!==void 0&&!n.has(o.field))throw new Error(`Summary source does not contain aggregate field "${o.field}".`);const u=g(o.op)?o.op.orderBy:void 0;if(u!==void 0&&!n.has(u))throw new Error(`Summary source does not contain order field "${u}".`)}if(i.weight!==void 0&&!n.has(i.weight.field))throw new Error(`Summary source does not contain weight field "${i.weight.field}".`)}function F(e,i){if(i.op!=="count"){if(K(i.op)&&X.has(i.op)){z(e,i.field,"nominal");return}z(e,i.field,"quantitative")}}function se(e,i){x(i),Z(e,i);const n=i.aggregates.map(t=>({...t,op:B(t.op,{allowBootstrap:!0})})),o=i.weight!==void 0&&i.missing!==void 0;let u;if(i.weight===void 0)for(const t of n)F(e,t);else if(!o)u=A(e,i.weight,"Summary").entries,L(u,[...new Set(n.flatMap(t=>t.field===void 0?[]:[t.field]))],"Summary");else{A(e.filter(t=>t[i.weight.field]!==null&&t[i.weight.field]!==void 0),i.weight,"Summary");for(const t of n)t.field!==void 0&&F(e.filter(d=>d[t.field]!==null&&d[t.field]!==void 0),t)}if(i.missing==="error"){if(i.weight!==void 0){const t=e.findIndex(d=>d[i.weight.field]===null||d[i.weight.field]===void 0);if(t!==-1)throw new TypeError(`Summary weight "${i.weight.field}" is missing at row ${t}.`)}for(const t of n){if(t.field===void 0)continue;const d=e.findIndex(f=>f[t.field]===null||f[t.field]===void 0);if(d!==-1)throw new TypeError(`Summary field "${t.field}" is missing at row ${d}.`)}}const l=new Map;if(i.groupBy.length===0?l.set("all",{values:{},rows:e,...u===void 0?{}:{entries:u}}):e.forEach((t,d)=>{const f=Object.fromEntries(i.groupBy.map(a=>[a,t[a]])),c=i.groupBy.map(a=>V(t[a],`Summary group field "${a}"`)).join("|"),r=l.get(c)??{values:f,rows:[],...u===void 0?{}:{entries:[]}};r.rows.push(t),u!==void 0&&r.entries.push(u[d]),l.set(c,r)}),l.size>N)throw new RangeError(`Summary output cannot exceed ${N} groups.`);const m=new Map;let O=0;for(const t of n){const d=t.op?.method;if(d?.type!=="bootstrap")continue;const f=JSON.stringify([t.field,d.samples,d.seed]);m.has(f)||(O+=d.samples*e.filter(c=>Number.isFinite(c[t.field])).length,U(O),m.set(f,q(d)))}const $=[],R=[...l.values()].map(t=>{const d=new Map,f=i.weight===void 0||o?void 0:k(t.entries,i.weight.kind,"Summary group"),c=Object.fromEntries(n.map(r=>{let a=0,h=0,j=0,S=f;if(o){const s=t.rows.filter(p=>r.field!==void 0&&(p[r.field]===null||p[r.field]===void 0)?(a+=1,!1):p[i.weight.field]===null||p[i.weight.field]===void 0?(h+=1,!1):!0),y=A(s,i.weight,"Summary").entries;j=y.filter(p=>p.weight===0).length,S=k(y,i.weight.kind,"Summary group")}const w=r.op?.method;let T;if(w?.type==="bootstrap"){const s=JSON.stringify([r.field,w.samples,w.seed]);if(!d.has(s)){const p=t.rows.map(_=>_[r.field]).filter(Number.isFinite);d.set(s,m.get(s)(p))}T=I(d.get(s),r.op.level)?.[r.op.op==="ciLower"?"lower":"upper"]}let b=w?.type==="bootstrap"?T:S===void 0?G(t.rows,r.field??"__row",r.op):P(S,r.field,r.op,`Summary aggregate "${r.as}"`);if(b===void 0&&i.empty!==void 0){const s=typeof r.op=="string"?r.op:r.op.op;b=i.empty==="identity"&&s==="sum"?0:null}if(i.missing!==void 0||i.empty!==void 0){const s=o?a+h:r.field===void 0?0:t.rows.filter(y=>y[r.field]===null||y[r.field]===void 0).length;$.push({role:r.as,group:t.values,inputRows:t.rows.length,usedRows:t.rows.length-s,excludedRows:s,excludedByReason:s===0?{}:{...a===0&&o?{}:{"missing-value":o?a:s},...h===0?{}:{"missing-weight":h}},...o?{zeroWeightRows:j}:{}})}return[r.as,b]}));return{...t.values,...c,...i.members===void 0?{}:{[i.members]:f===void 0?t.rows:Y(f)}}});return i.missing===void 0&&i.empty===void 0?R:{values:R,report:v({version:1,owner:{kind:"data",id:"pending"},inputs:[],units:$})}}export{se as deriveSummaryRows,ue as normalizeSummaryTransform,x as validateSummaryTransform};

package/src/materialization/marks/grouping.js

@@ -45,7 +45,7 @@ export function assertPathGroupCompatible(program, layer, dataset, group) {
     ![undefined, "overlay"].includes(layer.encoding?.color?.layout)
   )) {
     if (group?.fields !== undefined ||
-        (layer.encoding?.color !== undefined && field !== layer.encoding.color.field)) {
+        (layer.encoding?.color !== undefined && layer.encoding.color.fieldType !== "quantitative" && field !== layer.encoding.color.field)) {
       throw new Error("Area layout requires one group field matching its color field.");
     }
   }

package/src/version.js

@@ -1,2 +1,2 @@
 // Must match package.json; enforced by the snapshot producer-version test.
-export const packageVersion = "0.0.19";
+export const packageVersion = "0.0.21";

package/types/index.d.ts

@@ -391,6 +391,8 @@ export type {
   StackDataMode,
   StackDataOptions,
   StackDataOutputFields,
+  BootstrapMeanIntervalMethod,
+  MeanConfidenceIntervalMethod,
   SummaryAggregateOptions,
   SummaryDataOptions,
   YStackMode,

package/types/program.d.ts

@@ -563,7 +563,7 @@ export type DatasetIntervalTransform = {
   | {
       center: "mean";
       extent: "ci";
-      method?: ConfidenceIntervalMethod;
+      method?: MeanConfidenceIntervalMethod;
       level: number;
     }
   | {
@@ -1001,7 +1001,7 @@ export interface DatasetSummaryTransform {
   empty?: "null" | "identity";
 }
 export interface SummaryAggregateOptions {
-  op: AggregateOperation;
+  op: AggregateOperation | { op: "ciLower" | "ciUpper"; method: BootstrapMeanIntervalMethod; level?: number };
   field?: string;
   as: string;
 }
@@ -1106,6 +1106,13 @@ export type ScalarAggregateOperation =
   | "variance" | "varianceP" | "stdev" | "stdevP" | "stderr"
   | "q1" | "q3" | "ciLower" | "ciUpper";
 export type ConfidenceIntervalMethod = "normal" | "student-t";
+/** Seeded percentile bootstrap of nonweighted means; samples defaults to 1000. */
+export interface BootstrapMeanIntervalMethod {
+  type: "bootstrap";
+  seed: number;
+  samples?: number;
+}
+export type MeanConfidenceIntervalMethod = ConfidenceIntervalMethod | BootstrapMeanIntervalMethod;
 export type ParameterizedAggregateOperation =
   | { op: "quantile"; probability: number }
   | {
@@ -2372,7 +2379,7 @@ export interface IntervalDataOptions {
   groupBy?: string | readonly string[];
   center?: IntervalCenter;
   extent?: IntervalExtent;
-  method?: ConfidenceIntervalMethod;
+  method?: MeanConfidenceIntervalMethod;
   level?: number;
   missing?: "error" | "drop";
   as?: IntervalOutputFields;
@@ -4321,6 +4328,10 @@ export type DiscretizedColorScaleOptions =
   | QuantileColorScaleOptions
   | ThresholdColorScaleOptions;
 
+/** Area quantitative color requires one finite value per existing series;
+ * aggregate, temporal color and unknown fallback remain mark-specific restrictions.
+ * Area authoring uses the Full facade; createAreaPlot.color stays categorical.
+ */
 export type ColorEncodingOptions =
   | CategoricalEncodingOptions
   | {