ggaction 0.0.19 → 0.0.20

package/src/actions/marks/area/materialize.js

@@ -1,190 +1 @@
-import {
-  deriveCenteredAreaSeries,
-  deriveAreaSeries,
-  deriveDensityAreaSeries,
-  layoutDensityAreaSeries
-} from "../../../grammar/areaSeries.js";
-import {
-  mapContinuousScaleValues,
-  mapOrdinalPositionValues,
-  mapOrdinalValues
-} from "../../../grammar/scales/index.js";
-import { mapScaleConsumerValues } from
-  "../../../materialization/scales/map.js";
-import { buildAreaCurvePathCommands } from
-  "../../../grammar/curveCommands.js";
-import { buildLinearPathCommands } from
-  "../../../grammar/pathCommands.js";
-import { buildCategoricalDensityPaths } from
-  "../../../grammar/categoricalDensity.js";
-import { derivePathSeriesFieldValues } from "../../../grammar/pathSeries.js";
-
-function resolveAreaPaths({
-  derived,
-  densityTransform,
-  categoricalDensity,
-  xScale,
-  yScale,
-  densityScale,
-  layout,
-  curve
-}) {
-  if (categoricalDensity) {
-    return buildCategoricalDensityPaths(derived, {
-      categoryScale: densityTransform.placement.channel === "x" ? xScale : yScale,
-      valueScale: densityTransform.placement.channel === "x" ? yScale : xScale,
-      curve
-    });
-  }
-  return derived.series.map(series => {
-    if (densityTransform === undefined && derived.orientation === "horizontal") {
-      const y = (["point", "band"].includes(yScale.type) ? mapOrdinalPositionValues : mapContinuousScaleValues)(
-        series.values.map(value => value.y), yScale
-      );
-      const lower = mapContinuousScaleValues(
-        series.values.map(value => value.x),
-        xScale
-      );
-      const upper = mapContinuousScaleValues(
-        series.values.map(value => value.x2),
-        xScale
-      );
-      return buildAreaCurvePathCommands(
-        y.map((value, index) => ({ x: lower[index], y: value })),
-        y.map((value, index) => ({ x: upper[index], y: value })),
-        curve,
-        { independentAxis: "y" }
-      );
-    }
-    if (densityTransform !== undefined && derived.mode === "x-density") {
-      const y = (["point", "band"].includes(yScale.type) ? mapOrdinalPositionValues : mapContinuousScaleValues)(
-        series.values.map(value => value.y), yScale
-      );
-      const upper = mapContinuousScaleValues(
-        series.values.map(value => value.x),
-        xScale
-      );
-      const baseline = mapContinuousScaleValues([0], densityScale)[0];
-      if (curve === "linear") {
-        return buildLinearPathCommands([
-          { x: baseline, y: y[0] },
-          ...y.map((value, index) => ({ x: upper[index], y: value })),
-          { x: baseline, y: y.at(-1) }
-        ], { close: true });
-      }
-      return buildAreaCurvePathCommands(
-        y.map(value => ({ x: baseline, y: value })),
-        y.map((value, index) => ({ x: upper[index], y: value })),
-        curve,
-        { independentAxis: "y" }
-      );
-    }
-    const x = (["point", "band"].includes(xScale.type) ? mapOrdinalPositionValues : mapContinuousScaleValues)(
-      series.values.map(value => value.x),
-      xScale
-    );
-    const lowerValues = densityTransform === undefined
-      ? derived.mode === "y-center"
-        ? series.values.map(value => value.lower)
-        : series.values.map(value => value.y)
-      : derived.mode === "y-density"
-        ? series.values.map(value => value.lower)
-        : series.values.map(value => value.y);
-    const lower = mapContinuousScaleValues(lowerValues, yScale);
-    const upperValues = densityTransform === undefined
-      ? derived.mode === "y-center"
-        ? series.values.map(value => value.upper)
-        : series.values.map(value => value.y2)
-      : series.values.map(value => value.upper);
-    const upper = mapContinuousScaleValues(upperValues, yScale);
-    if (densityTransform !== undefined && layout === "overlay") {
-      const baseline = mapContinuousScaleValues([0], yScale)[0];
-      if (curve === "linear") {
-        return buildLinearPathCommands([
-          { x: x[0], y: baseline },
-          ...x.map((value, index) => ({ x: value, y: upper[index] })),
-          { x: x.at(-1), y: baseline }
-        ], { close: true });
-      }
-      return buildAreaCurvePathCommands(
-        x.map(value => ({ x: value, y: baseline })),
-        x.map((value, index) => ({ x: value, y: upper[index] })),
-        curve
-      );
-    }
-    return buildAreaCurvePathCommands(
-      x.map((value, index) => ({ x: value, y: lower[index] })),
-      x.map((value, index) => ({ x: value, y: upper[index] })),
-      curve
-    );
-  });
-}
-
-export function resolveAreaMaterialization({
-  rows,
-  layer,
-  densityTransform,
-  resolvedScales,
-  config
-}) {
-  const xScale = resolvedScales[layer.encoding.x.scale];
-  const yScale = resolvedScales[layer.encoding.y.scale];
-  const centered = densityTransform === undefined &&
-    layer.encoding?.y?.stack === "center";
-  const rawDerived = densityTransform === undefined
-    ? centered
-      ? deriveCenteredAreaSeries(rows, layer, { xDomain: xScale.domain })
-      : deriveAreaSeries(rows, layer, { xDomain: xScale.domain, yDomain: yScale.domain })
-    : deriveDensityAreaSeries(rows, layer, densityTransform);
-  const colorEncoding = layer.encoding?.color;
-  const layout = layer.layout?.mode ?? colorEncoding?.layout ?? "overlay";
-  const categoricalDensity = densityTransform?.placement?.type === "category";
-  const derived = densityTransform === undefined || categoricalDensity
-    ? rawDerived
-    : layoutDensityAreaSeries(rawDerived, layout);
-  const densityScale = densityTransform === undefined || categoricalDensity
-    ? undefined
-    : derived.mode === "y-density" ? yScale : xScale;
-  if (
-    densityScale !== undefined &&
-    (densityScale.domain[0] > 0 || densityScale.domain[1] < 0)
-  ) {
-    throw new Error(`Density area mark "${layer.id}" requires a scale domain containing zero.`);
-  }
-  const paths = resolveAreaPaths({
-    derived,
-    densityTransform,
-    categoricalDensity,
-    xScale,
-    yScale,
-    densityScale,
-    layout,
-    curve: config.curve ?? "linear"
-  });
-  const fills = config.errorBand?.fill !== undefined
-    ? paths.map(() => config.errorBand.fill)
-    : colorEncoding?.scale === undefined
-      ? paths.map(() => config.fill)
-      : mapOrdinalValues(
-          densityTransform !== undefined || centered
-            ? derived.series.map(series => series.key[colorEncoding.field])
-            : derivePathSeriesFieldValues(rows, derived.series, colorEncoding.field, "color"),
-          resolvedScales[colorEncoding.scale].domain,
-          resolvedScales[colorEncoding.scale].range
-        );
-  const strokeEncoding = layer.encoding?.stroke;
-  const strokes = strokeEncoding?.scale === undefined
-    ? undefined
-    : mapScaleConsumerValues(
-        derivePathSeriesFieldValues(
-          rows,
-          derived.series,
-          strokeEncoding.field,
-          "stroke",
-          strokeEncoding
-        ),
-        resolvedScales[strokeEncoding.scale],
-        "stroke"
-      );
-  return { paths, fills, strokes };
-}
+import{deriveCenteredAreaSeries as P,deriveAreaSeries as V,deriveDensityAreaSeries as w,layoutDensityAreaSeries as z}from"../../../grammar/areaSeries.js";import{mapContinuousScaleValues as c,mapOrdinalPositionValues as D}from"../../../grammar/scales/index.js";import{mapScaleConsumerValues as b}from"../../../materialization/scales/map.js";import{buildAreaCurvePathCommands as A}from"../../../grammar/curveCommands.js";import{buildLinearPathCommands as k}from"../../../grammar/pathCommands.js";import{buildCategoricalDensityPaths as E}from"../../../grammar/categoricalDensity.js";import{derivePathSeriesFieldValues as C}from"../../../grammar/pathSeries.js";function q({derived:d,densityTransform:a,categoricalDensity:m,xScale:l,yScale:u,densityScale:x,layout:v,curve:r}){return m?E(d,{categoryScale:a.placement.channel==="x"?l:u,valueScale:a.placement.channel==="x"?u:l,curve:r}):d.series.map(o=>{if(a===void 0&&d.orientation==="horizontal"){const e=(["point","band"].includes(u.type)?D:c)(o.values.map(n=>n.y),u),t=c(o.values.map(n=>n.x),l),p=c(o.values.map(n=>n.x2),l);return A(e.map((n,s)=>({x:t[s],y:n})),e.map((n,s)=>({x:p[s],y:n})),r,{independentAxis:"y"})}if(a!==void 0&&d.mode==="x-density"){const e=(["point","band"].includes(u.type)?D:c)(o.values.map(n=>n.y),u),t=c(o.values.map(n=>n.x),l),p=c([0],x)[0];return r==="linear"?k([{x:p,y:e[0]},...e.map((n,s)=>({x:t[s],y:n})),{x:p,y:e.at(-1)}],{close:!0}):A(e.map(n=>({x:p,y:n})),e.map((n,s)=>({x:t[s],y:n})),r,{independentAxis:"y"})}const i=(["point","band"].includes(l.type)?D:c)(o.values.map(e=>e.x),l),g=a===void 0?d.mode==="y-center"?o.values.map(e=>e.lower):o.values.map(e=>e.y):d.mode==="y-density"?o.values.map(e=>e.lower):o.values.map(e=>e.y),h=c(g,u),y=a===void 0?d.mode==="y-center"?o.values.map(e=>e.upper):o.values.map(e=>e.y2):o.values.map(e=>e.upper),f=c(y,u);if(a!==void 0&&v==="overlay"){const e=c([0],u)[0];return r==="linear"?k([{x:i[0],y:e},...i.map((t,p)=>({x:t,y:f[p]})),{x:i.at(-1),y:e}],{close:!0}):A(i.map(t=>({x:t,y:e})),i.map((t,p)=>({x:t,y:f[p]})),r)}return A(i.map((e,t)=>({x:e,y:h[t]})),i.map((e,t)=>({x:e,y:f[t]})),r)})}function G({rows:d,layer:a,densityTransform:m,resolvedScales:l,config:u}){const x=l[a.encoding.x.scale],v=l[a.encoding.y.scale],r=m===void 0&&a.encoding?.y?.stack==="center",o=m===void 0?r?P(d,a,{xDomain:x.domain}):V(d,a,{xDomain:x.domain,yDomain:v.domain}):w(d,a,m),i=a.encoding?.color,g=a.layout?.mode??i?.layout??"overlay",h=m?.placement?.type==="category",y=m===void 0||h?o:z(o,g),f=m===void 0||h?void 0:y.mode==="y-density"?v:x;if(f!==void 0&&(f.domain[0]>0||f.domain[1]<0))throw new Error(`Density area mark "${a.id}" requires a scale domain containing zero.`);const e=q({derived:y,densityTransform:m,categoricalDensity:h,xScale:x,yScale:v,densityScale:f,layout:g,curve:u.curve??"linear"}),t=u.errorBand?.fill!==void 0?e.map(()=>u.errorBand.fill):i?.scale===void 0?e.map(()=>u.fill):b(i.fieldType!=="quantitative"&&(m!==void 0||r)?y.series.map(s=>s.key[i.field]):C(d,y.series,i.field,"color",i),l[i.scale],"color"),p=a.encoding?.stroke,n=p?.scale===void 0?void 0:b(C(d,y.series,p.field,"stroke",p),l[p.scale],"stroke");return{paths:e,fills:t,strokes:n}}export{G as resolveAreaMaterialization};

package/src/actions/scales/consumers/common.js

@@ -1,5 +1,5 @@
 import { isSourceOwnedText } from "../../../grammar/text.js";
-import { readSeriesIdentity } from "../../../grammar/pathSeries.js";
+import { readSeriesIdentity, validatePathSeriesAppearance } from "../../../grammar/pathSeries.js";
 import { readAreaEndpoint } from "../../../grammar/areaEndpoints.js";
 import { readScaleField } from "../../../grammar/scales/index.js";
 import { findDataset } from "../../../selectors/datasets.js";
@@ -59,6 +59,12 @@ export function readConsumerFieldValues(
   if (consumer.layer.mark.type === "bar" && consumer.layer.encoding?.group !== undefined && ["xOffset", "yOffset"].includes(consumer.channel)) {
     return readSeriesIdentity(dataset.values, consumer.layer).values;
   }
+  if (consumer.layer.mark.type === "area" && consumer.channel === "color" && fieldType === "quantitative") {
+    validatePathSeriesAppearance(dataset.values, consumer.layer);
+    const identities = readSeriesIdentity(dataset.values, consumer.layer).values;
+    const values = readScaleField(dataset.values, field, fieldType);
+    return [...new Map(identities.map((identity, index) => [identity, values[index]])).values()];
+  }
   const parallel = consumer.role === "parallelDimension";
   if (!parallel && !isDirectCategoricalConsumer(consumer) &&
     fieldType !== "quantitative" && fieldType !== "temporal" &&

package/src/grammar/aggregate.js

@@ -40,7 +40,7 @@ export function isAggregate(value) {
   return isScalarAggregate(value) || isParameterizedAggregate(value);
 }
 
-export function validateAggregate(value) {
+export function validateAggregate(value, { allowBootstrap = false } = {}) {
   if (typeof value === "string") {
     if (!SCALAR_OPERATIONS.has(value)) {
       throw new Error(`Unsupported aggregate "${value}".`);
@@ -97,7 +97,8 @@ export function validateAggregate(value) {
       op: value.op,
       ...normalizeConfidenceInterval(value, {
         defaultMethod: "normal",
-        label: "Aggregate confidence interval"
+        label: "Aggregate confidence interval",
+        allowBootstrap
       })
     };
   }

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};