ggaction 0.0.18 → 0.0.20

package/src/grammar/areaSeries.js

@@ -1,415 +1 @@
-import { cloneAndFreeze } from "../core/immutable.js";
-import { readNominalField, readQuantitativeField, readTemporalField } from "./scales/index.js";
-import { layoutSeriesPartition, validateColorLayout } from "./seriesLayout.js";
-import { stableOrderPathValues } from "./pathOrder.js";
-import { deriveCategoricalDensitySeries } from "./categoricalDensity.js";
-import { validatePathSeriesAppearance } from "./pathSeries.js";
-import { readAreaEndpoint, validateAreaEndpointPair } from "./areaEndpoints.js";
-import { validateGeneratedItemLimit } from "../core/validation.js";
-
-function indexSegments(segments) {
-  const indexed = [];
-  for (const segment of segments) indexed[segment.index] = segment;
-  return indexed;
-}
-
-export function deriveAreaSeries(rows, layer, options = {}) {
-  if (layer?.mark?.type !== "area") {
-    throw new Error("Area series derivation requires a semantic area mark.");
-  }
-  const { x, y, x2, y2 } = layer.encoding ?? {};
-  const vertical =
-    ["quantitative", "temporal", "nominal", "ordinal"].includes(x?.fieldType) &&
-    y?.fieldType === "quantitative" &&
-    y2?.fieldType === "quantitative" &&
-    x2 === undefined;
-  const horizontal =
-    ["quantitative", "temporal", "nominal", "ordinal"].includes(y?.fieldType) &&
-    x?.fieldType === "quantitative" &&
-    x2?.fieldType === "quantitative" &&
-    y2 === undefined;
-  if (vertical === horizontal) {
-    throw new Error(
-      `Area mark "${layer.id}" requires exactly one quantitative x/x2 or y/y2 range and one quantitative, temporal, or categorical independent position.`
-    );
-  }
-  const grouping = validatePathSeriesAppearance(rows, layer);
-  const orientation = vertical ? "vertical" : "horizontal";
-  const independent = vertical ? x : y;
-  const categorical = ["nominal", "ordinal"].includes(independent.fieldType);
-  const independentValues = categorical ? readNominalField(rows, independent.field) : independent.fieldType === "temporal"
-    ? readTemporalField(rows, independent.field, independent.temporalUnit)
-    : readQuantitativeField(rows, independent.field);
-  if (Object.hasOwn(independent, "datum")) throw new Error("Area independent position requires a field.");
-  const primary = vertical ? y : x;
-  const secondary = vertical ? y2 : x2;
-  validateAreaEndpointPair(primary, secondary);
-  const missing = layer.mark.missing ?? "error";
-  const lower = readAreaEndpoint(rows, primary, missing);
-  const upper = readAreaEndpoint(rows, secondary, missing);
-  const categoryOrder = categorical ? options[vertical ? "xDomain" : "yDomain"] ?? [...new Set(independentValues)] : undefined;
-  const ranks = new Map(categoryOrder?.map((value, index) => [value, index]));
-  if (categorical && independentValues.some(value => !ranks.has(value))) throw new Error("Area categorical domain must contain every observed position.");
-  const pathOrder = layer.encoding?.pathOrder;
-  const orderValues = pathOrder === undefined
-    ? undefined
-    : readQuantitativeField(rows, pathOrder.field);
-  const groups = new Map();
-
-  for (let index = 0; index < rows.length; index += 1) {
-    const tuple = grouping.map(field => rows[index][field]);
-    const key = JSON.stringify(tuple);
-    const series = groups.get(key) ?? {
-      key: Object.fromEntries(grouping.map((field, i) => [field, tuple[i]])),
-      values: []
-    };
-    series.values.push(vertical
-      ? {
-          x: independentValues[index],
-          y: lower[index],
-          y2: upper[index],
-          ...(missing === "break" ? { sourceIndex: index } : {}),
-          ...(orderValues === undefined ? {} : { pathOrder: orderValues[index] })
-        }
-      : {
-          x: lower[index],
-          x2: upper[index],
-          ...(missing === "break" ? { sourceIndex: index } : {}),
-          y: independentValues[index],
-          ...(orderValues === undefined ? {} : { pathOrder: orderValues[index] })
-        });
-    groups.set(key, series);
-  }
-  if (groups.size === 0) {
-    throw new Error(`Area mark "${layer.id}" has no values.`);
-  }
-  layoutRawAreaGroups(groups, { layer, vertical, primary, secondary });
-  const series = [...groups.values()].flatMap(item => {
-    const key = vertical ? "x" : "y";
-    const values = pathOrder === undefined
-      ? item.values.sort((left, right) => categorical ? ranks.get(left[key]) - ranks.get(right[key]) : left[key] - right[key])
-      : stableOrderPathValues(
-          item.values.map(({ pathOrder: _pathOrder, ...value }) => value),
-          item.values.map(value => value.pathOrder),
-          pathOrder.order
-        );
-    if (missing === "break") {
-      const segments = [];
-      let segment = [];
-      const emit = () => {
-        if (segment.length >= 2) segments.push({ key: item.key,
-          sourceIndices: segment.map(value => value.sourceIndex),
-          values: segment.map(({ sourceIndex, ...value }) => value) });
-        segment = [];
-      };
-      for (const value of values) {
-        if ((vertical ? value.y == null || value.y2 == null : value.x == null || value.x2 == null)) emit();
-        else segment.push(value);
-      }
-      emit();
-      return segments;
-    }
-    if (values.length < 2) {
-      throw new Error(
-        `Area series on mark "${layer.id}" requires at least two points.`
-      );
-    }
-    return { key: item.key, values };
-  });
-  if (series.length === 0) throw new Error(`Area mark "${layer.id}" has no valid segment with at least two points.`);
-  return cloneAndFreeze({
-    orientation,
-    xValues: series.flatMap(item => item.values.flatMap(value =>
-      vertical ? [value.x] : [value.x, value.x2]
-    )),
-    yValues: series.flatMap(item => item.values.flatMap(value =>
-      vertical ? [value.y, value.y2] : [value.y]
-    )),
-    series
-  });
-}
-
-export function deriveCenteredAreaSeries(rows, layer, options = {}) {
-  if (layer?.mark?.type !== "area") {
-    throw new Error("Centered area series derivation requires an area mark.");
-  }
-  const { x, y, x2, y2, group, color } = layer.encoding ?? {};
-  if (
-    !["quantitative", "temporal", "nominal", "ordinal"].includes(x?.fieldType) ||
-    y?.fieldType !== "quantitative" ||
-    y?.stack !== "center" ||
-    x2 !== undefined ||
-    y2 !== undefined
-  ) {
-    throw new Error(
-      `Centered area mark "${layer.id}" requires one x field and one quantitative y field without ranged endpoints.`
-    );
-  }
-  if (group?.fieldType !== "nominal") {
-    throw new Error(`Centered area mark "${layer.id}" requires a nominal group encoding.`);
-  }
-  if (color !== undefined && color.field !== group.field) {
-    throw new Error(
-      `Centered area color on mark "${layer.id}" must match its group field.`
-    );
-  }
-  const categorical = ["nominal", "ordinal"].includes(x.fieldType);
-  const xValues = categorical ? readNominalField(rows, x.field) : x.fieldType === "temporal"
-    ? readTemporalField(rows, x.field, x.temporalUnit)
-    : readQuantitativeField(rows, x.field);
-  const yValues = readQuantitativeField(rows, y.field);
-  const groups = readNominalField(rows, group.field);
-  const groupOrder = [];
-  const positions = new Set();
-  const byGroup = new Map();
-  for (let index = 0; index < rows.length; index += 1) {
-    const key = groups[index];
-    if (!byGroup.has(key)) {
-      groupOrder.push(key);
-      byGroup.set(key, new Map());
-    }
-    const values = byGroup.get(key);
-    if (values.has(xValues[index])) {
-      throw new Error(
-        `Centered area mark "${layer.id}" has duplicate ${group.field}/${x.field} rows.`
-      );
-    }
-    values.set(xValues[index], yValues[index]);
-    positions.add(xValues[index]);
-  }
-  const orderedPositions = categorical
-    ? (options.xDomain ?? [...positions]).filter(value => positions.has(value))
-    : [...positions].sort((left, right) => left - right);
-  if (orderedPositions.length !== positions.size) throw new Error("Area categorical domain must contain every observed position.");
-  if (groupOrder.length === 0 || orderedPositions.length < 2) {
-    throw new Error(
-      `Centered area mark "${layer.id}" requires at least two aligned positions.`
-    );
-  }
-  for (const [key, values] of byGroup) {
-    if (
-      values.size !== orderedPositions.length ||
-      orderedPositions.some(position => !values.has(position))
-    ) {
-      throw new Error(
-        `Centered area series "${String(key)}" requires one aligned value at every x position.`
-      );
-    }
-  }
-
-  const valuesBySeries = groupOrder.map(() => []);
-  for (const position of orderedPositions) {
-    const partition = groupOrder.map(key => byGroup.get(key).get(position));
-    const resolvedSegments = layoutSeriesPartition(partition, "center");
-    const segments = indexSegments(resolvedSegments);
-    let endpoint = resolvedSegments[0]?.start ?? 0;
-    for (let index = 0; index < groupOrder.length; index += 1) {
-      const segment = segments[index];
-      valuesBySeries[index].push({
-        x: position,
-        y: partition[index],
-        lower: segment?.start ?? endpoint,
-        upper: segment?.end ?? endpoint
-      });
-      if (segment !== undefined) endpoint = segment.end;
-    }
-  }
-  const series = groupOrder.map((key, index) => ({
-    key: {
-      [group.field]: key,
-      ...(color === undefined ? {} : { [color.field]: key })
-    },
-    values: valuesBySeries[index]
-  }));
-  return cloneAndFreeze({
-    mode: "y-center",
-    orientation: "vertical",
-    xValues: orderedPositions,
-    yValues: series.flatMap(item => item.values.flatMap(value => [
-      value.lower,
-      value.upper
-    ])),
-    series
-  });
-}
-
-export function deriveDensityAreaSeries(rows, layer, transform) {
-  if (layer?.mark?.type !== "area") {
-    throw new Error("Density area derivation requires a semantic area mark.");
-  }
-  if (layer.encoding?.pathOrder !== undefined) {
-    throw new Error(
-      `Density area mark "${layer.id}" does not support path order.`
-    );
-  }
-  if (transform?.type !== "density" || !Array.isArray(transform.as)) {
-    throw new Error(`Area mark "${layer.id}" requires density provenance.`);
-  }
-  if (transform.placement?.type === "category") {
-    return deriveCategoricalDensitySeries(rows, layer, transform);
-  }
-  const { x, y, group } = layer.encoding ?? {};
-  if (
-    x?.fieldType !== "quantitative" ||
-    y?.fieldType !== "quantitative"
-  ) {
-    throw new Error(
-      `Density area mark "${layer.id}" requires quantitative x and y encodings.`
-    );
-  }
-  const [valueField, densityField] = transform.as;
-  const mode = x.field === valueField && y.field === densityField
-    ? "y-density"
-    : x.field === densityField && y.field === valueField
-      ? "x-density"
-      : undefined;
-  if (mode === undefined) {
-    throw new Error(
-      `Density area mark "${layer.id}" must encode its value and density fields.`
-    );
-  }
-  if (transform.groupBy === undefined) {
-    if (group !== undefined) {
-      throw new Error(`Ungrouped density area mark "${layer.id}" cannot encode group.`);
-    }
-  } else if (
-    group?.field !== transform.groupBy ||
-    group.fieldType !== "nominal"
-  ) {
-    throw new Error(
-      `Density area mark "${layer.id}" must group by "${transform.groupBy}".`
-    );
-  }
-
-  const xValues = readQuantitativeField(rows, x.field);
-  const yValues = readQuantitativeField(rows, y.field);
-  const groupValues = transform.groupBy === undefined
-    ? rows.map(() => undefined)
-    : readNominalField(rows, transform.groupBy);
-  const groups = new Map();
-  for (let index = 0; index < rows.length; index += 1) {
-    const key = groupValues[index];
-    const series = groups.get(key) ?? {
-      key: transform.groupBy === undefined ? {} : { [transform.groupBy]: key },
-      values: []
-    };
-    series.values.push({ x: xValues[index], y: yValues[index] });
-    groups.set(key, series);
-  }
-  if (groups.size === 0) {
-    throw new Error(`Density area mark "${layer.id}" has no values.`);
-  }
-  const valueKey = mode === "y-density" ? "x" : "y";
-  const series = [...groups.values()].map(item => {
-    const values = item.values.sort((left, right) => left[valueKey] - right[valueKey]);
-    if (values.length < 2) {
-      throw new Error(
-        `Density area series on mark "${layer.id}" requires at least two points.`
-      );
-    }
-    return { key: item.key, values };
-  });
-  return cloneAndFreeze({ mode, series });
-}
-
-export function layoutDensityAreaSeries(derived, layout = "overlay") {
-  validateColorLayout(layout);
-  if (layout === "group") {
-    throw new Error('Density area series do not support "group" layout.');
-  }
-  if (derived?.mode !== "y-density") {
-    if (layout === "overlay") return derived;
-    throw new Error(
-      `Area layout "${layout}" currently requires vertical density series.`
-    );
-  }
-  const sampleCount = derived.series[0]?.values.length ?? 0;
-  if (
-    sampleCount === 0 ||
-    derived.series.some(series => series.values.length !== sampleCount)
-  ) {
-    throw new Error("Density area layout requires aligned non-empty samples.");
-  }
-
-  const valuesBySeries = derived.series.map(() => []);
-  for (let sample = 0; sample < sampleCount; sample += 1) {
-    const x = derived.series[0].values[sample].x;
-    const densities = derived.series.map(series => {
-      if (series.values[sample].x !== x) {
-        throw new Error("Density area layout requires one shared sample grid.");
-      }
-      return series.values[sample].y;
-    });
-    const resolvedSegments = layoutSeriesPartition(densities, layout);
-    const segments = indexSegments(resolvedSegments);
-    let zeroThicknessEndpoint = layout === "center"
-      ? resolvedSegments[0]?.start ?? 0
-      : 0;
-    for (let index = 0; index < derived.series.length; index += 1) {
-      const segment = segments[index];
-      valuesBySeries[index].push({
-        x,
-        lower: segment?.start ?? zeroThicknessEndpoint,
-        upper: segment?.end ?? zeroThicknessEndpoint
-      });
-      if (segment !== undefined && ["stack", "fill", "center"].includes(layout)) {
-        zeroThicknessEndpoint = segment.end;
-      }
-    }
-  }
-
-  return cloneAndFreeze({
-    mode: derived.mode,
-    series: derived.series.map((series, index) => ({
-      key: series.key,
-      values: valuesBySeries[index]
-    }))
-  });
-}
-
-export function layoutRawAreaGroups(groups, { layer, vertical, primary, secondary }) {
-  const mode = layer.layout?.mode ?? "overlay";
-  validateColorLayout(mode);
-  if (mode === "overlay") return;
-  if (mode === "group" || (mode === "center" && !vertical)) {
-    throw new Error(`Area layout "${mode}" is incompatible with this orientation.`);
-  }
-  const primaryDatum = Object.hasOwn(primary, "datum");
-  const secondaryDatum = Object.hasOwn(secondary, "datum");
-  if (primaryDatum === secondaryDatum || (primaryDatum ? primary.datum : secondary.datum) !== 0) {
-    throw new Error("Stacked area requires one value field and one zero datum endpoint.");
-  }
-  const position = vertical ? "x" : "y";
-  const lower = vertical ? "y" : "x", upper = `${lower}2`;
-  const measure = primaryDatum ? upper : lower;
-  const series = [...groups.values()];
-  const indices = series.map(item => {
-    const index = new Map();
-    for (const value of item.values) {
-      if (index.has(value[position])) throw new Error("Area layout requires unique group/position rows.");
-      index.set(value[position], value);
-    }
-    return index;
-  });
-  const positions = [...new Set(series.flatMap(item => item.values.map(value => value[position])))].sort((a, b) => a - b);
-  validateGeneratedItemLimit(positions.length * series.length, "Area layout cell count");
-  if (indices.some(index => index.size !== positions.length || positions.some(value => !index.has(value)))) {
-    throw new Error("Area layout requires an aligned row for every group and position.");
-  }
-  for (const position of positions) {
-    const points = indices.map(index => index.get(position));
-    if (points.some(point => point[measure] == null)) {
-      for (const point of points) { point[lower] = null; point[upper] = null; }
-      continue;
-    }
-    const segments = layoutSeriesPartition(points.map(point => point[measure]), mode);
-    const byIndex = new Map(segments.map(segment => [segment.index, segment]));
-    let endpoint = mode === "center" ? segments[0]?.start ?? 0 : 0;
-    points.forEach((point, index) => {
-      const segment = byIndex.get(index);
-      point[lower] = segment?.start ?? (mode === "diverging" ? 0 : endpoint);
-      point[upper] = segment?.end ?? (mode === "diverging" ? 0 : endpoint);
-      if (segment !== undefined && mode !== "diverging") endpoint = segment.end;
-    });
-  }
-}
+import{cloneAndFreeze as C}from"../core/immutable.js";import{readNominalField as z,readQuantitativeField as b,readTemporalField as I}from"./scales/index.js";import{layoutSeriesPartition as B,validateColorLayout as F}from"./seriesLayout.js";import{stableOrderPathValues as L}from"./pathOrder.js";import{deriveCategoricalDensitySeries as N}from"./categoricalDensity.js";import{validatePathSeriesAppearance as P}from"./pathSeries.js";import{readAreaEndpoint as j,validateAreaEndpointPair as J}from"./areaEndpoints.js";import{validateGeneratedItemLimit as K}from"../core/validation.js";function G(n){const e=[];for(const a of n)e[a.index]=a;return e}function ne(n,e,a={}){if(e?.mark?.type!=="area")throw new Error("Area series derivation requires a semantic area mark.");const{x:p,y:d,x2:l,y2:k}=e.encoding??{},u=["quantitative","temporal","nominal","ordinal"].includes(p?.fieldType)&&d?.fieldType==="quantitative"&&k?.fieldType==="quantitative"&&l===void 0,m=["quantitative","temporal","nominal","ordinal"].includes(d?.fieldType)&&p?.fieldType==="quantitative"&&l?.fieldType==="quantitative"&&k===void 0;if(u===m)throw new Error(`Area mark "${e.id}" requires exactly one quantitative x/x2 or y/y2 range and one quantitative, temporal, or categorical independent position.`);const w=P(n,e),c=u?"vertical":"horizontal",f=u?p:d,x=["nominal","ordinal"].includes(f.fieldType),y=x?z(n,f.field):f.fieldType==="temporal"?I(n,f.field,f.temporalUnit):b(n,f.field);if(Object.hasOwn(f,"datum"))throw new Error("Area independent position requires a field.");const v=u?d:p,o=u?k:l;J(v,o);const r=e.mark.missing??"error",g=j(n,v,r),O=j(n,o,r),s=x?a[u?"xDomain":"yDomain"]??[...new Set(y)]:void 0,t=new Map(s?.map((i,h)=>[i,h]));if(x&&y.some(i=>!t.has(i)))throw new Error("Area categorical domain must contain every observed position.");const E=e.encoding?.pathOrder,$=E===void 0?void 0:b(n,E.field),D=new Map;for(let i=0;i<n.length;i+=1){const h=w.map(q=>n[i][q]),M=JSON.stringify(h),T=D.get(M)??{key:Object.fromEntries(w.map((q,V)=>[q,h[V]])),values:[]};T.values.push(u?{x:y[i],y:g[i],y2:O[i],...r==="break"?{sourceIndex:i}:{},...$===void 0?{}:{pathOrder:$[i]}}:{x:g[i],x2:O[i],...r==="break"?{sourceIndex:i}:{},y:y[i],...$===void 0?{}:{pathOrder:$[i]}}),D.set(M,T)}if(D.size===0)throw new Error(`Area mark "${e.id}" has no values.`);Q(D,{layer:e,vertical:u,primary:v,secondary:o});const A=[...D.values()].flatMap(i=>{const h=u?"x":"y",M=E===void 0?i.values.sort((T,q)=>x?t.get(T[h])-t.get(q[h]):T[h]-q[h]):L(i.values.map(({pathOrder:T,...q})=>q),i.values.map(T=>T.pathOrder),E.order);if(r==="break"){const T=[];let q=[];const V=()=>{q.length>=2&&T.push({key:i.key,sourceIndices:q.map(S=>S.sourceIndex),values:q.map(({sourceIndex:S,...U})=>U)}),q=[]};for(const S of M)(u?S.y==null||S.y2==null:S.x==null||S.x2==null)?V():q.push(S);return V(),T}if(M.length<2)throw new Error(`Area series on mark "${e.id}" requires at least two points.`);return{key:i.key,values:M}});if(A.length===0)throw new Error(`Area mark "${e.id}" has no valid segment with at least two points.`);return C({orientation:c,xValues:A.flatMap(i=>i.values.flatMap(h=>u?[h.x]:[h.x,h.x2])),yValues:A.flatMap(i=>i.values.flatMap(h=>u?[h.y,h.y2]:[h.y])),series:A})}function te(n,e,a={}){if(e?.mark?.type!=="area")throw new Error("Centered area series derivation requires an area mark.");const{x:p,y:d,x2:l,y2:k,group:u,color:m}=e.encoding??{};if(!["quantitative","temporal","nominal","ordinal"].includes(p?.fieldType)||d?.fieldType!=="quantitative"||d?.stack!=="center"||l!==void 0||k!==void 0)throw new Error(`Centered area mark "${e.id}" requires one x field and one quantitative y field without ranged endpoints.`);if(u?.fieldType!=="nominal")throw new Error(`Centered area mark "${e.id}" requires a nominal group encoding.`);if(m!==void 0&&m.fieldType!=="quantitative"&&m.field!==u.field)throw new Error(`Centered area color on mark "${e.id}" must match its group field.`);P(n,e);const w=["nominal","ordinal"].includes(p.fieldType),c=w?z(n,p.field):p.fieldType==="temporal"?I(n,p.field,p.temporalUnit):b(n,p.field),f=b(n,d.field),x=z(n,u.field),y=[],v=new Set,o=new Map;for(let s=0;s<n.length;s+=1){const t=x[s];o.has(t)||(y.push(t),o.set(t,new Map));const E=o.get(t);if(E.has(c[s]))throw new Error(`Centered area mark "${e.id}" has duplicate ${u.field}/${p.field} rows.`);E.set(c[s],f[s]),v.add(c[s])}const r=w?(a.xDomain??[...v]).filter(s=>v.has(s)):[...v].sort((s,t)=>s-t);if(r.length!==v.size)throw new Error("Area categorical domain must contain every observed position.");if(y.length===0||r.length<2)throw new Error(`Centered area mark "${e.id}" requires at least two aligned positions.`);for(const[s,t]of o)if(t.size!==r.length||r.some(E=>!t.has(E)))throw new Error(`Centered area series "${String(s)}" requires one aligned value at every x position.`);const g=y.map(()=>[]);for(const s of r){const t=y.map(A=>o.get(A).get(s)),E=B(t,"center"),$=G(E);let D=E[0]?.start??0;for(let A=0;A<y.length;A+=1){const i=$[A];g[A].push({x:s,y:t[A],lower:i?.start??D,upper:i?.end??D}),i!==void 0&&(D=i.end)}}const O=y.map((s,t)=>({key:{[u.field]:s,...m===void 0||m.fieldType==="quantitative"?{}:{[m.field]:s}},values:g[t]}));return C({mode:"y-center",orientation:"vertical",xValues:r,yValues:O.flatMap(s=>s.values.flatMap(t=>[t.lower,t.upper])),series:O})}function re(n,e,a){if(e?.mark?.type!=="area")throw new Error("Density area derivation requires a semantic area mark.");if(e.encoding?.pathOrder!==void 0)throw new Error(`Density area mark "${e.id}" does not support path order.`);if(a?.type!=="density"||!Array.isArray(a.as))throw new Error(`Area mark "${e.id}" requires density provenance.`);if(a.placement?.type==="category")return N(n,e,a);const{x:p,y:d,group:l}=e.encoding??{};if(p?.fieldType!=="quantitative"||d?.fieldType!=="quantitative")throw new Error(`Density area mark "${e.id}" requires quantitative x and y encodings.`);const[k,u]=a.as,m=p.field===k&&d.field===u?"y-density":p.field===u&&d.field===k?"x-density":void 0;if(m===void 0)throw new Error(`Density area mark "${e.id}" must encode its value and density fields.`);if(a.groupBy===void 0){if(l!==void 0)throw new Error(`Ungrouped density area mark "${e.id}" cannot encode group.`)}else if(l?.field!==a.groupBy||l.fieldType!=="nominal")throw new Error(`Density area mark "${e.id}" must group by "${a.groupBy}".`);const w=b(n,p.field),c=b(n,d.field),f=a.groupBy===void 0?n.map(()=>{}):z(n,a.groupBy),x=new Map;for(let o=0;o<n.length;o+=1){const r=f[o],g=x.get(r)??{key:a.groupBy===void 0?{}:{[a.groupBy]:r},values:[]};g.values.push({x:w[o],y:c[o]}),x.set(r,g)}if(x.size===0)throw new Error(`Density area mark "${e.id}" has no values.`);const y=m==="y-density"?"x":"y",v=[...x.values()].map(o=>{const r=o.values.sort((g,O)=>g[y]-O[y]);if(r.length<2)throw new Error(`Density area series on mark "${e.id}" requires at least two points.`);return{key:o.key,values:r}});return C({mode:m,series:v})}function ie(n,e="overlay"){if(F(e),e==="group")throw new Error('Density area series do not support "group" layout.');if(n?.mode!=="y-density"){if(e==="overlay")return n;throw new Error(`Area layout "${e}" currently requires vertical density series.`)}const a=n.series[0]?.values.length??0;if(a===0||n.series.some(d=>d.values.length!==a))throw new Error("Density area layout requires aligned non-empty samples.");const p=n.series.map(()=>[]);for(let d=0;d<a;d+=1){const l=n.series[0].values[d].x,k=n.series.map(c=>{if(c.values[d].x!==l)throw new Error("Density area layout requires one shared sample grid.");return c.values[d].y}),u=B(k,e),m=G(u);let w=e==="center"?u[0]?.start??0:0;for(let c=0;c<n.series.length;c+=1){const f=m[c];p[c].push({x:l,lower:f?.start??w,upper:f?.end??w}),f!==void 0&&["stack","fill","center"].includes(e)&&(w=f.end)}}return C({mode:n.mode,series:n.series.map((d,l)=>({key:d.key,values:p[l]}))})}function Q(n,{layer:e,vertical:a,primary:p,secondary:d}){const l=e.layout?.mode??"overlay";if(F(l),l==="overlay")return;if(l==="group"||l==="center"&&!a)throw new Error(`Area layout "${l}" is incompatible with this orientation.`);const k=Object.hasOwn(p,"datum"),u=Object.hasOwn(d,"datum");if(k===u||(k?p.datum:d.datum)!==0)throw new Error("Stacked area requires one value field and one zero datum endpoint.");const m=a?"x":"y",w=a?"y":"x",c=`${w}2`,f=k?c:w,x=[...n.values()],y=x.map(o=>{const r=new Map;for(const g of o.values){if(r.has(g[m]))throw new Error("Area layout requires unique group/position rows.");r.set(g[m],g)}return r}),v=[...new Set(x.flatMap(o=>o.values.map(r=>r[m])))].sort((o,r)=>o-r);if(K(v.length*x.length,"Area layout cell count"),y.some(o=>o.size!==v.length||v.some(r=>!o.has(r))))throw new Error("Area layout requires an aligned row for every group and position.");for(const o of v){const r=y.map(t=>t.get(o));if(r.some(t=>t[f]==null)){for(const t of r)t[w]=null,t[c]=null;continue}const g=B(r.map(t=>t[f]),l),O=new Map(g.map(t=>[t.index,t]));let s=l==="center"?g[0]?.start??0:0;r.forEach((t,E)=>{const $=O.get(E);t[w]=$?.start??(l==="diverging"?0:s),t[c]=$?.end??(l==="diverging"?0:s),$!==void 0&&l!=="diverging"&&(s=$.end)})}}export{ne as deriveAreaSeries,te as deriveCenteredAreaSeries,re as deriveDensityAreaSeries,ie as layoutDensityAreaSeries,Q as layoutRawAreaGroups};

package/src/grammar/axisTextPlacement.js

@@ -0,0 +1 @@
+import{resolveTextLines as o}from"../core/textMetrics.js";function a(e,{title:i=!1}={}){if(Object.hasOwn(e,"align")&&!["left","center","right"].includes(e.align))throw new TypeError("Axis text align must be left, center, or right.");if(i){if(Object.hasOwn(e,"baseline")&&!["top","hanging","middle","alphabetic","ideographic","bottom"].includes(e.baseline))throw new TypeError("Axis title baseline must be a supported text baseline.");for(const t of["offset","alongOffset"])if(Object.hasOwn(e,t)&&!Number.isFinite(e[t]))throw new TypeError(`Axis title ${t} must be a finite number.`)}}function f(e,i){if(!/[\r\n]/u.test(e))return;const t=i.baseline??"middle",n=o(e,{fontSize:i.fontSize,align:i.align??"center",baseline:t,...t==="middle"?{blockAlign:"middle"}:{}});if(["bottom","ideographic"].includes(t)){const s=(n.length-1)*i.fontSize*1.2;return n.map(r=>({...r,y:r.y-s}))}return n.length>1?n:void 0}export{f as axisTitleTextLines,a as validateAxisTextPlacement};

package/src/grammar/colorSizeLegend.js

@@ -0,0 +1,39 @@
+import {sameOrderedValues,validateOptionObject,validateUnitInterval,validateNonNegativeFinite,validateNonEmptyString} from '../core/validation.js';
+import {isContinuousColorScaleType} from './scales/types.js';
+import {isContinuousSizeScaleType} from './scales/size.js';
+
+export function isColorSizeChannels(channels) {
+ return Array.isArray(channels)&&channels.length===2&&channels.includes('color')&&channels.includes('size');
+}
+
+export function resolveColorSizeMapping({layer,scales,pointConfig,coordinate}) {
+ const color=layer?.encoding?.color,size=layer?.encoding?.size;
+ const colorScale=scales[color?.scale],sizeScale=scales[size?.scale];
+ if(layer?.mark?.type!=='point'||coordinate?.type!=='cartesian'||
+   pointConfig?.shape!=='circle'||layer.encoding.shape!==undefined||
+   color?.fieldType!=='quantitative'||size?.fieldType!=='quantitative'||
+   typeof color.field!=='string'||color.field!==size.field||
+   color.aggregate!==size.aggregate||color.data!==size.data||
+   !isContinuousColorScaleType(colorScale?.type)||!isContinuousSizeScaleType(sizeScale?.type)) {
+  throw new Error('Color-size combination requires one Cartesian circle point owner with the same quantitative field and grain.');
+ }
+ const ends=scale=>[scale.domain?.[0],scale.domain?.at(-1)];
+ const domain=ends(colorScale),sizeDomain=ends(sizeScale);
+ if(!domain.every(Number.isFinite)||!sizeDomain.every(Number.isFinite)||
+   !sameOrderedValues(domain,sizeDomain)||domain[0]===domain[1]) {
+  throw new Error('Color-size combination requires identical finite numeric domain endpoints.');
+ }
+ return {target:layer.id,field:color.field,fieldType:'quantitative',colorScale:color.scale,sizeScale:size.scale,domain};
+}
+
+export function normalizeColorSizeSymbol(value,previous) {
+ if(value===undefined)return {...(previous??{type:'point',strokeWidth:0,opacity:1})};
+ if(value==='auto')return {type:'point',strokeWidth:0,opacity:1};
+ validateOptionObject(value,['type','stroke','strokeWidth','opacity'],'Color-size symbol');
+ if(value.type!==undefined&&value.type!=='point')throw new Error('Color-size symbols require type point.');
+ const symbol={type:'point',strokeWidth:0,opacity:1,...previous,...value};
+ if(symbol.stroke!==undefined)validateNonEmptyString(symbol.stroke,'Color-size symbol stroke');
+ validateNonNegativeFinite(symbol.strokeWidth,'Color-size symbol strokeWidth');
+ validateUnitInterval(symbol.opacity,'Color-size symbol opacity');
+ return symbol;
+}

package/src/grammar/computed.js

@@ -1,4 +1,5 @@
 import {parseTimeValue,validateParseTimeFormat} from "./parseTime.js";
+import { calendarParts, validateTimeZone } from "./timeUnit.js";
 import { rejectUnknownProperties as rejectUnknownKeys } from "../core/validation.js";
 import { requireStringValue as requireField } from "../core/validation.js";
 import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
@@ -6,7 +7,7 @@ import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
 const TRANSFORM_KEYS = Object.freeze(["type", "as", "expression"]);
 const ARITHMETIC_BINARY = new Set(["add", "subtract", "multiply", "divide"]);
 const COMPARISONS = new Set(["eq", "neq", "lt", "lte", "gt", "gte"]);
-const NUMERIC_UNARY = new Set(["negate", "absolute", "log", "sqrt"]);
+const NUMERIC_UNARY = new Set(["negate", "absolute", "log", "sqrt", "floor"]);
 const BOOLEAN_UNARY = new Set(["not", "isNull"]);
 const LOGICAL = new Set(["and", "or"]);
 const VARIADIC = new Set(["coalesce", "concat"]);
@@ -107,6 +108,14 @@ function inspectExpression(expression, depth, state, optionalPathRoot = false) {
       inspectExpression(expression.operand, depth + 1, state);
       return;
     }
+    if (expression.op === "datePart") {
+      rejectUnknownKeys(expression, ["op", "part", "operand", "timeZone"], "computed calendar expression");
+      requireNode(expression, "operand", expression.op);
+      if (expression.part !== "year") throw new Error("Computed datePart supports part year only.");
+      if (Object.hasOwn(expression, "timeZone")) validateTimeZone(expression.timeZone);
+      inspectExpression(expression.operand, depth + 1, state);
+      return;
+    }
     if (expression.op === "parseTime") {
       rejectUnknownKeys(expression, ["op", "operand", "format"], "computed time expression");
       requireNode(expression, "operand", expression.op);
@@ -339,6 +348,18 @@ function evaluate(expression, row, rowIndex) {
       ? value === null
       : !boolean(value, operation, rowIndex);
   }
+  if (operation === "datePart") {
+    const value = evaluate(expression.operand, row, rowIndex);
+    if (value === null) return null;
+    number(value, operation, rowIndex);
+    if (Math.abs(value) > 8_640_000_000_000_000) {
+      throw new RangeError(`Computed datePart timestamp is outside the supported Date range at row ${rowIndex}.`);
+    }
+    const timestamp = new Date(value).getTime();
+    return (expression.timeZone ?? "UTC") === "UTC"
+      ? new Date(timestamp).getUTCFullYear()
+      : calendarParts(timestamp, expression.timeZone).year;
+  }
   if (operation === "parseTime") {
     return parseTimeValue(evaluate(expression.operand, row, rowIndex), expression.format);
   }
@@ -360,6 +381,7 @@ function evaluate(expression, row, rowIndex) {
     }
     const result = operation === "negate" ? -value
       : operation === "absolute" ? Math.abs(value)
+        : operation === "floor" ? Math.floor(value)
         : operation === "log" ? Math.log(value)
           : Math.sqrt(value);
     if (!Number.isFinite(result)) {

package/src/grammar/datasetSchema.js

@@ -1,6 +1,7 @@
 import { requireStringValue as requireName } from "../core/validation.js";
 import { annotateError } from "../core/diagnostics.js";
 import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
+import { requireRegressionStatisticsSource, REGRESSION_STATISTIC_FIELDS } from "./regression/statistics.js";
 
 const STORAGE_TYPES = new Set([
   "number", "string", "boolean", "array", "object", "unknown", "mixed"
@@ -267,7 +268,7 @@ function generatedField(name, storageType, transform, role, inputs = []) {
   };
 }
 
-export function deriveTransformSchema(inputSchema, transform, values, { sourceId, ownerId } = {}) {
+export function deriveTransformSchema(inputSchema, transform, values, { sourceId, ownerId, sourceTransform } = {}) {
   const input = validateDatasetSchema(inputSchema);
   const definition = { ...transform, __sourceId: sourceId, __ownerId: ownerId };
   const retain = ["filter", "markFilter", "sort", "computed", "timeUnit", "window", "normalize", "stack", "impute", "complete"];
@@ -300,6 +301,12 @@ export function deriveTransformSchema(inputSchema, transform, values, { sourceId
       generatedField(transform.as.count, "number", definition, "count", [transform.x, transform.y])
     ];
     if (transform.as.members !== undefined) push(generatedField(transform.as.members, "array", definition, "members"));
+  } else if (transform.type === "regressionStatistics") {
+    const fit = requireRegressionStatisticsSource({ transform: sourceTransform === undefined ? [] : [sourceTransform] });
+    fields = [
+      ...(fit.groupBy === undefined ? [] : [inheritedField(input, fit.groupBy)]),
+      ...REGRESSION_STATISTIC_FIELDS.map(name => generatedField(name, "number", definition, name))
+    ].filter(Boolean);
   } else if (transform.type === "regression") {
     fields = [inheritedField(input, transform.x), inheritedField(input, transform.y)].filter(Boolean);
     if (transform.groupBy !== undefined) fields.unshift(inheritedField(input, transform.groupBy));
@@ -367,7 +374,8 @@ export function deriveTransformSchema(inputSchema, transform, values, { sourceId
       if (planned.lineage === undefined && !["complete", "impute"].includes(transform.type)) {
         return planned;
       }
-      return { ...planned, storageType: field.storageType, nullable: field.nullable, optional: field.optional };
+      return { ...planned, storageType: transform.type === "regressionStatistics" && planned.storageType === "number"
+        ? "number" : field.storageType, nullable: field.nullable, optional: field.optional };
     });
     for (const field of inferred.fields) {
       if (!fields.some(planned => planned.name === field.name)) fields.push(field);

package/src/grammar/displayLabels.js

@@ -44,6 +44,14 @@ export function normalizeDisplayLabelMap(value, label = "labelMap") {
   return Object.freeze(normalized);
 }
 
+export function normalizeNumericDisplayLabelMap(value, label = "labelMap") {
+  const map = normalizeDisplayLabelMap(value, label);
+  if (map.some(entry => typeof entry.value !== "number" || !Number.isFinite(entry.value))) {
+    throw new TypeError(`${label} values must be finite numbers.`);
+  }
+  return map;
+}
+
 export function resolveDisplayLabel(value, map, fallback) {
   if (map !== undefined) {
     for (const entry of map) {