ggaction 0.0.2 → 0.0.3

package/src/materialization/scales/map.js

@@ -0,0 +1,40 @@
+import {
+  isContinuousColorScaleType,
+  isDiscretizedColorScaleType,
+  isOrdinalScaleType,
+  mapContinuousScaleValues,
+  mapDiscretizedColors,
+  mapOrdinalValues,
+  mapSequentialColors
+} from "../../grammar/scales.js";
+
+export function mapScaleConsumerValues(values, resolvedScale, channel) {
+  if (channel === "color" && isDiscretizedColorScaleType(resolvedScale.type)) {
+    return mapDiscretizedColors(values, resolvedScale);
+  }
+  if (channel === "color" && isContinuousColorScaleType(resolvedScale.type)) {
+    return mapSequentialColors(
+      values,
+      resolvedScale.domain,
+      resolvedScale.range,
+      {
+        interpolation: resolvedScale.interpolate,
+        clamp: resolvedScale.clamp ?? false,
+        ...(Object.hasOwn(resolvedScale, "unknown")
+          ? { unknown: resolvedScale.unknown }
+          : {})
+      }
+    );
+  }
+  if (
+    ["color", "strokeDash", "shape"].includes(channel) &&
+    isOrdinalScaleType(resolvedScale.type)
+  ) {
+    return mapOrdinalValues(values, resolvedScale.domain, resolvedScale.range, {
+      ...(Object.hasOwn(resolvedScale, "unknown")
+        ? { unknown: resolvedScale.unknown }
+        : {})
+    });
+  }
+  return mapContinuousScaleValues(values, resolvedScale);
+}

package/src/materialization/scales/policies/arc.js

@@ -0,0 +1,37 @@
+export function resolveArcAutoPositionRange({
+  consumers,
+  scale,
+  channel,
+  domain,
+  range,
+  markConfigs
+}) {
+  if (
+    (scale.range !== "auto" && scale.range !== undefined) ||
+    consumers.length === 0 ||
+    !consumers.every(consumer => consumer.layer.mark?.type === "arc")
+  ) {
+    return range;
+  }
+  if (channel === "radius") {
+    const ratios = consumers.map(
+      consumer => markConfigs[consumer.layer.id]?.innerRadius ?? 0
+    );
+    if (new Set(ratios).size !== 1) {
+      throw new Error(
+        `Shared arc radius scale "${scale.id}" requires one innerRadius policy.`
+      );
+    }
+    const outer = Math.max(...range);
+    return [outer * ratios[0], outer];
+  }
+  if (
+    channel === "theta" &&
+    scale.type === "band" &&
+    consumers.every(consumer => consumer.encoding.aggregate === undefined)
+  ) {
+    const step = (range[1] - range[0]) / domain.length;
+    return [range[0] - step / 2, range[1] - step / 2];
+  }
+  return range;
+}

package/src/materialization/scales/policies/bar.js

@@ -0,0 +1,132 @@
+import { normalizeOffsetPadding } from "../../../grammar/bars/geometry.js";
+import {
+  BAR_GRAINS,
+  resolveBarChannels,
+  resolveBarGrain
+} from "../../../grammar/bars/policy.js";
+import { resolveHistogramBins } from "../../../grammar/histogram.js";
+
+export function resolveBinnedBarDomain({
+  valuesByConsumer,
+  channel,
+  scale,
+  id,
+  allValues
+}) {
+  const binnedBars = valuesByConsumer.filter(
+    ({ consumer }) =>
+      consumer.layer.mark?.type === "bar" &&
+      consumer.encoding.bin !== undefined
+  );
+  if (binnedBars.length === 0) return undefined;
+  if (channel !== "x" || binnedBars.length !== valuesByConsumer.length) {
+    throw new Error(
+      `Binned scale "${id}" cannot be shared with an unbinned consumer.`
+    );
+  }
+  const binDefinitions = new Set(
+    binnedBars.map(({ consumer }) => JSON.stringify(consumer.encoding.bin))
+  );
+  if (binDefinitions.size !== 1) {
+    throw new Error(`Binned scale "${id}" requires one shared bin definition.`);
+  }
+  return resolveHistogramBins({
+    values: allValues,
+    bin: binnedBars[0].consumer.encoding.bin,
+    domain: scale.domain,
+    nice: scale.nice ?? true,
+    zero: scale.zero ?? false
+  }).domain;
+}
+
+export function resolveOffsetScalePolicy({
+  consumers,
+  resolvedScales,
+  markConfigs,
+  id,
+  channel
+}) {
+  const parentChannel = channel === "xOffset" ? "x" : "y";
+  const bandwidths = consumers.map(consumer => {
+    if (parentChannel === "x" && consumer.layer.encoding?.x?.bin !== undefined) {
+      return 1;
+    }
+    const parentScaleId = consumer.layer.encoding?.[parentChannel]?.scale;
+    return resolvedScales[parentScaleId]?.bandwidth;
+  });
+  if (
+    bandwidths.some(value => !Number.isFinite(value)) ||
+    new Set(bandwidths).size !== 1
+  ) {
+    throw new Error(
+      `${channel} scale "${id}" requires one shared resolved ${parentChannel} bandwidth.`
+    );
+  }
+  const paddings = consumers.map(consumer => normalizeOffsetPadding(
+    markConfigs[consumer.layer.id]?.[channel],
+    undefined,
+    channel
+  ));
+  const signatures = new Set(
+    paddings.map(padding => JSON.stringify(padding))
+  );
+  if (signatures.size !== 1) {
+    throw new Error(
+      `${channel} scale "${id}" requires one shared padding policy.`
+    );
+  }
+  return {
+    parentBandwidth: bandwidths[0],
+    ...paddings[0]
+  };
+}
+
+export function resolveTemporalBarBand(consumers, domain, range, values) {
+  const temporalBars = consumers.filter(consumer => {
+    const channels = resolveBarChannels(consumer.layer);
+    return resolveBarGrain(consumer.layer) === BAR_GRAINS.aggregate &&
+      channels?.category === consumer.channel &&
+      consumer.encoding.fieldType === "temporal";
+  });
+  if (temporalBars.length === 0) return undefined;
+  const temporalFields = new Set(
+    temporalBars.map(consumer => consumer.encoding.field)
+  );
+  const compatibleLines = consumers.filter(consumer =>
+    consumer.layer.mark?.type === "line" &&
+    consumer.encoding.fieldType === "temporal" &&
+    temporalFields.has(consumer.encoding.field)
+  );
+  if (temporalBars.length + compatibleLines.length !== consumers.length) {
+    throw new Error(
+      "A temporal bar position scale requires compatible bar or line consumers of one field."
+    );
+  }
+  const ordered = [...new Set(values)].sort((left, right) => left - right);
+  if (ordered.length < 2) {
+    throw new Error("Temporal bar position requires at least two distinct values.");
+  }
+  const minimumGap = Math.min(
+    ...ordered.slice(1).map((value, index) => value - ordered[index])
+  );
+  const domainSpan = Math.abs(domain[1] - domain[0]);
+  if (!(minimumGap > 0) || !(domainSpan > 0)) {
+    throw new Error("Temporal bar position requires an increasing time domain.");
+  }
+  const direction = Math.sign(range[1] - range[0]) || 1;
+  const estimatedBandwidth = Math.abs(range[1] - range[0]) * minimumGap /
+    (domainSpan + minimumGap);
+  const resolvedRange = [
+    range[0] + direction * estimatedBandwidth / 2,
+    range[1] - direction * estimatedBandwidth / 2
+  ];
+  const positions = ordered.map(value =>
+    resolvedRange[0] +
+      (value - domain[0]) / (domain[1] - domain[0]) *
+      (resolvedRange[1] - resolvedRange[0])
+  );
+  const bandwidth = Math.min(
+    ...positions.slice(1).map((value, index) => Math.abs(value - positions[index]))
+  );
+  return { bandwidth, range: resolvedRange };
+}

package/src/materialization/scales/policies/series.js

@@ -0,0 +1,76 @@
+import {
+  isTransformedScaleType,
+  resolveContinuousDomain,
+  resolveTransformedDomain
+} from "../../../grammar/scales.js";
+
+export function resolveSeriesLayoutDomain({
+  id,
+  scale,
+  valuesByConsumer,
+  seriesLayouts
+}) {
+  if (!seriesLayouts.some(Boolean)) return undefined;
+  const activeLayouts = seriesLayouts.filter(Boolean);
+  const layouts = new Set(activeLayouts.map(item => item.layout));
+  if (layouts.size !== 1) {
+    throw new Error(`Series layout scale "${id}" requires one layout policy.`);
+  }
+  const layoutConsumers = valuesByConsumer.filter(
+    (_, index) => seriesLayouts[index] !== undefined
+  );
+  const directConsumers = valuesByConsumer.filter(
+    (_, index) => seriesLayouts[index] === undefined
+  );
+  const compatibleDirect = directConsumers.every(({ consumer }) =>
+    layoutConsumers.every(({ consumer: layoutConsumer }) => {
+      const aggregate = layoutConsumer.encoding.aggregate;
+      return aggregate !== "count" &&
+        consumer.encoding.fieldType === "quantitative" &&
+        consumer.encoding.field === layoutConsumer.encoding.field;
+    })
+  );
+  if (!compatibleDirect) {
+    throw new Error(
+      `Series layout scale "${id}" cannot be shared with another policy.`
+    );
+  }
+  const layout = activeLayouts[0].layout;
+  const values = [
+    ...activeLayouts.flatMap(item => item.values),
+    ...directConsumers.flatMap(item => item.values)
+  ];
+  if (
+    ["group", "overlay"].includes(layout) &&
+    scale.domain !== "auto" &&
+    (Math.min(...scale.domain) > 0 || Math.max(...scale.domain) < 0)
+  ) {
+    throw new Error(
+      `Series layout scale "${id}" requires an explicit domain containing zero.`
+    );
+  }
+  const nice = layout === "fill" && scale.domain === "auto"
+    ? false
+    : scale.nice;
+  const zero = layout === "fill" && scale.domain === "auto"
+    ? false
+    : scale.zero;
+  return isTransformedScaleType(scale.type)
+    ? resolveTransformedDomain({
+        type: scale.type,
+        domain: scale.domain,
+        values,
+        nice: nice ?? false,
+        zero: zero ?? false,
+        ...(scale.base === undefined ? {} : { base: scale.base }),
+        ...(scale.exponent === undefined ? {} : { exponent: scale.exponent }),
+        ...(scale.constant === undefined ? {} : { constant: scale.constant })
+      })
+    : resolveContinuousDomain({
+        domain: scale.domain,
+        values,
+        type: scale.type,
+        nice,
+        zero
+      });
+}

package/src/materialization/scales/resolve.js

@@ -0,0 +1,326 @@
+import {
+  isContinuousColorScaleType,
+  isDiscretePositionScaleType,
+  isDiscretizedColorScaleType,
+  isOrdinalScaleType,
+  isTransformedScaleType,
+  normalizeTransformParameters,
+  resolveColorRange,
+  resolveContinuousDomain,
+  resolveDiscretePositionScale,
+  resolveDiscretizedColorScale,
+  resolveOpacityRange,
+  resolveOrdinalDomain,
+  resolveOrdinalOffsetScale,
+  resolveOrdinalPositionScale,
+  resolveScaleRange,
+  resolveSequentialColorStops,
+  resolveShapeRange,
+  resolveSizeRange,
+  resolveStrokeDashRange,
+  resolveTransformedDomain,
+  SCALE_ROLES,
+  validateLinearScaleType,
+  validateOrdinalScaleType,
+  validateScaleTypeForRole,
+  validateTimeScaleType
+} from "../../grammar/scales.js";
+import { resolveArcAutoPositionRange } from "./policies/arc.js";
+import {
+  resolveBinnedBarDomain,
+  resolveOffsetScalePolicy,
+  resolveTemporalBarBand
+} from "./policies/bar.js";
+import { resolveSeriesLayoutDomain } from "./policies/series.js";
+import { OFFSET_POSITION_CHANNELS } from "../../core/vocabulary.js";
+
+function resolveDefaultDomain({
+  scale,
+  allValues,
+  isOrdinalAppearance,
+  isOrdinalOffset,
+  isOrdinalPosition,
+  isDiscretePosition
+}) {
+  if (
+    isOrdinalAppearance ||
+    isOrdinalOffset ||
+    isOrdinalPosition ||
+    isDiscretePosition
+  ) {
+    return resolveOrdinalDomain(scale.domain, allValues);
+  }
+  if (isTransformedScaleType(scale.type)) {
+    return resolveTransformedDomain({
+      type: scale.type,
+      domain: scale.domain,
+      values: allValues,
+      nice: scale.nice ?? false,
+      zero: scale.zero ?? false,
+      ...(scale.base === undefined ? {} : { base: scale.base }),
+      ...(scale.exponent === undefined ? {} : { exponent: scale.exponent }),
+      ...(scale.constant === undefined ? {} : { constant: scale.constant })
+    });
+  }
+  return resolveContinuousDomain({
+    domain: scale.domain,
+    values: allValues,
+    type: scale.type,
+    nice: scale.nice,
+    zero: scale.zero
+  });
+}
+
+function resolveRange({
+  scale,
+  channel,
+  domain,
+  bounds,
+  consumers,
+  markConfigs,
+  isSequentialColor,
+  isDiscretizedColor,
+  isOrdinalOffset,
+  discretizedScale
+}) {
+  if (channel === "color") {
+    if (isDiscretizedColor) return discretizedScale.range;
+    if (isSequentialColor) return resolveSequentialColorStops(scale.range);
+    return resolveColorRange(scale.range, domain.length);
+  }
+  if (channel === "strokeDash") return resolveStrokeDashRange(scale.range);
+  if (channel === "shape") return resolveShapeRange(scale.range);
+  if (channel === "size") return resolveSizeRange(scale.range);
+  if (channel === "opacity") return resolveOpacityRange(scale.range);
+  if (isOrdinalOffset) return undefined;
+  return resolveArcAutoPositionRange({
+    consumers,
+    scale,
+    channel,
+    domain,
+    range: resolveScaleRange(scale.range, channel, bounds),
+    markConfigs
+  });
+}
+
+function resolveContinuousScale({
+  scale,
+  domain,
+  range,
+  isSequentialColor,
+  isOrdinalAppearance
+}) {
+  return {
+    type: isSequentialColor
+      ? "sequential"
+      : isOrdinalAppearance
+        ? validateOrdinalScaleType(scale.type)
+        : scale.type === "time"
+          ? validateTimeScaleType(scale.type)
+          : isTransformedScaleType(scale.type)
+            ? validateScaleTypeForRole(
+                scale.type,
+                SCALE_ROLES.quantitativePosition
+              )
+            : validateLinearScaleType(scale.type),
+    domain,
+    range,
+    ...(scale.clamp === undefined ? {} : { clamp: scale.clamp }),
+    ...(scale.type === "log"
+      ? {
+          base: normalizeTransformParameters("log", {
+            ...(scale.base === undefined ? {} : { base: scale.base })
+          }).base
+        }
+      : scale.type === "pow"
+        ? {
+            exponent: normalizeTransformParameters("pow", {
+              ...(scale.exponent === undefined
+                ? {}
+                : { exponent: scale.exponent })
+            }).exponent
+          }
+        : scale.type === "symlog"
+          ? {
+              constant: normalizeTransformParameters("symlog", {
+                ...(scale.constant === undefined
+                  ? {}
+                  : { constant: scale.constant })
+              }).constant
+            }
+          : {}),
+    ...(isSequentialColor ? { interpolate: scale.interpolate ?? "rgb" } : {}),
+    ...(Object.hasOwn(scale, "unknown") ? { unknown: scale.unknown } : {})
+  };
+}
+
+function reverseResolvedScale(scale) {
+  const range = [...scale.range].reverse();
+  const direction = Math.sign(range[1] - range[0]) || 1;
+  const offset = scale.start === undefined
+    ? undefined
+    : Math.abs(scale.start - scale.range[0]);
+  return {
+    ...scale,
+    range,
+    ...(scale.step === undefined ? {} : { step: -scale.step }),
+    ...(offset === undefined ? {} : { start: range[0] + direction * offset })
+  };
+}
+
+export function resolveScaleMaterialization({
+  id,
+  scale,
+  channel,
+  consumers,
+  valuesByConsumer,
+  bounds,
+  resolvedScales,
+  markConfigs
+}) {
+  const allValues = valuesByConsumer
+    .flatMap(item => item.values)
+    .filter(value => value !== undefined);
+  const isSequentialColor = channel === "color" &&
+    isContinuousColorScaleType(scale.type);
+  const isDiscretizedColor = channel === "color" &&
+    isDiscretizedColorScaleType(scale.type);
+  const isOrdinalAppearance =
+    ["color", "strokeDash", "shape"].includes(channel) &&
+    isOrdinalScaleType(scale.type);
+  const isOrdinalOffset = OFFSET_POSITION_CHANNELS.includes(channel);
+  const isOrdinalPosition =
+    !isOrdinalAppearance && !isOrdinalOffset && isOrdinalScaleType(scale.type);
+  const isDiscretePosition =
+    !isOrdinalAppearance &&
+    !isOrdinalOffset &&
+    isDiscretePositionScaleType(scale.type);
+
+  let discretizedScale;
+  if (isDiscretizedColor) {
+    discretizedScale = resolveDiscretizedColorScale({
+      type: scale.type,
+      domain: scale.domain,
+      range: scale.range,
+      values: allValues
+    });
+  }
+  const binnedDomain = isDiscretizedColor
+    ? undefined
+    : resolveBinnedBarDomain({
+        valuesByConsumer,
+        channel,
+        scale,
+        id,
+        allValues
+      });
+  const seriesLayouts = valuesByConsumer.map(item => item.seriesLayout);
+  const seriesDomain = isDiscretizedColor || binnedDomain !== undefined
+    ? undefined
+    : resolveSeriesLayoutDomain({
+        id,
+        scale,
+        valuesByConsumer,
+        seriesLayouts
+      });
+  const domain = isDiscretizedColor
+    ? discretizedScale.domain
+    : binnedDomain ?? seriesDomain ?? resolveDefaultDomain({
+        scale,
+        allValues,
+        isOrdinalAppearance,
+        isOrdinalOffset,
+        isOrdinalPosition,
+        isDiscretePosition
+      });
+  const range = resolveRange({
+    scale,
+    channel,
+    domain,
+    bounds,
+    consumers,
+    markConfigs,
+    isSequentialColor,
+    isDiscretizedColor,
+    isOrdinalOffset,
+    discretizedScale
+  });
+  if (channel === "shape" && domain.length > range.length) {
+    throw new Error(
+      `Shape scale "${id}" requires at least one distinct shape per domain value.`
+    );
+  }
+
+  let resolvedScale = isDiscretizedColor
+    ? discretizedScale
+    : isOrdinalOffset
+      ? resolveOrdinalOffsetScale({
+          domain: scale.domain,
+          values: allValues,
+          range: scale.range,
+          ...resolveOffsetScalePolicy({
+            consumers,
+            resolvedScales,
+            markConfigs,
+            id,
+            channel
+          }),
+          channel
+        })
+      : isDiscretePosition
+        ? resolveDiscretePositionScale({
+            type: scale.type,
+            domain: scale.domain,
+            values: allValues,
+            range: channel === "theta" && consumers.every(
+              consumer => consumer.layer.mark?.type === "arc"
+            ) ? range : scale.range,
+            channel,
+            bounds,
+            ...(scale.type === "band"
+              ? {
+                  paddingInner: scale.paddingInner,
+                  paddingOuter: scale.paddingOuter
+                }
+              : { padding: scale.padding }),
+            align: scale.align,
+            unknown: scale.unknown
+          })
+        : isOrdinalPosition
+          ? resolveOrdinalPositionScale({
+              domain: scale.domain,
+              values: allValues,
+              range: scale.range,
+              channel,
+              bounds,
+              unknown: scale.unknown
+            })
+          : resolveContinuousScale({
+              scale,
+              domain,
+              range,
+              isSequentialColor,
+              isOrdinalAppearance
+            });
+  if (Object.hasOwn(scale, "unknown") && !Object.hasOwn(resolvedScale, "unknown")) {
+    resolvedScale = { ...resolvedScale, unknown: scale.unknown };
+  }
+  if (scale.type === "time" && ["x", "y"].includes(channel)) {
+    const temporalBarBand = resolveTemporalBarBand(
+      consumers,
+      domain,
+      range,
+      allValues
+    );
+    if (temporalBarBand !== undefined) {
+      resolvedScale = {
+        ...resolvedScale,
+        range: temporalBarBand.range,
+        bandwidth: temporalBarBand.bandwidth
+      };
+    }
+  }
+  return scale.reverse === true
+    ? reverseResolvedScale(resolvedScale)
+    : resolvedScale;
+}

package/src/materialization/selection/items/arc.js

@@ -0,0 +1,29 @@
+import { deriveArcSectors } from "../../../grammar/arcs.js";
+import { resolvePolarFrame } from "../../../grammar/polar.js";
+import { resolveGraphicBounds } from "../../../layout/canvas.js";
+import { finalizeItems, uniqueFields } from "./common.js";
+
+export function resolveArcItems(program, layer, dataset) {
+  const thetaScale = program.resolvedScales[layer.encoding?.theta?.scale];
+  const radiusScale = program.resolvedScales[layer.encoding?.radius?.scale];
+  const frame = resolvePolarFrame(resolveGraphicBounds(program));
+  const derived = deriveArcSectors(dataset.values, layer, {
+    thetaScale,
+    ...(radiusScale === undefined ? {} : { radiusScale }),
+    frame,
+    innerRadiusRatio: program.markConfigs[layer.id]?.innerRadius ?? 0
+  });
+  const definitions = derived.sectors.map(sector => {
+    const members = sector.sourceIndices.map(index => dataset.values[index]);
+    return {
+      fields: uniqueFields(members),
+      channels: {
+        theta: sector.theta,
+        ...(sector.radius === undefined ? {} : { radius: sector.radius }),
+        ...(sector.color === undefined ? {} : { color: sector.color })
+      },
+      members
+    };
+  });
+  return finalizeItems(program, layer, "sector", definitions, "path");
+}