ggaction 0.0.2 → 0.0.4

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/index.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");
+}

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

@@ -0,0 +1,255 @@
+import { deriveBarAggregates } from "../../../grammar/bars/aggregate.js";
+import {
+  BAR_GRAINS,
+  resolveBarChannels,
+  resolveBarColorLayout,
+  resolveBarOffsetChannel,
+  resolveBarGrain
+} from "../../../grammar/bars/policy.js";
+import { layoutSeriesPartition } from "../../../grammar/seriesLayout.js";
+import {
+  readNominalField,
+  readTemporalField
+} from "../../../grammar/scales/index.js";
+import { findSemanticScale } from "../../../selectors/scales.js";
+import { deriveHistogramSegments } from "../../bars/histogram.js";
+import {
+  channelMapFromRow,
+  finalizeItems,
+  itemKey,
+  ownFields,
+  uniqueFields
+} from "./common.js";
+
+function categoryValues(rows, encoding) {
+  return encoding.fieldType === "temporal"
+    ? readTemporalField(rows, encoding.field)
+    : readNominalField(rows, encoding.field);
+}
+
+function aggregateMembers(rows, layer, cell, channels) {
+  const category = layer.encoding[channels.category];
+  const categories = categoryValues(rows, category);
+  const categoryValue = cell[channels.category];
+  const color = layer.encoding?.color;
+  const colors = !["nominal", "ordinal"].includes(color?.fieldType)
+    ? undefined
+    : readNominalField(rows, color.field);
+  return rows.filter((_, index) =>
+    categories[index] === categoryValue &&
+    (colors === undefined || colors[index] === cell.color)
+  );
+}
+
+function aggregateCellDefinitions(program, layer, dataset) {
+  const channels = resolveBarChannels(layer);
+  const derived = deriveBarAggregates(dataset.values, layer).values;
+  const categoryEncoding = layer.encoding[channels.category];
+  const categoryScale = program.resolvedScales[categoryEncoding.scale];
+  const measureScale = program.resolvedScales[
+    layer.encoding[channels.measure].scale
+  ];
+  const colorEncoding = layer.encoding?.color;
+  const colorScale = program.resolvedScales[colorEncoding?.scale];
+  const offsetChannel = resolveBarOffsetChannel(layer);
+  const offsetScale = program.resolvedScales[layer.encoding?.[offsetChannel]?.scale];
+  const layout = resolveBarColorLayout(layer);
+
+  function definition(cell, start, end) {
+    const members = aggregateMembers(dataset.values, layer, cell, channels);
+    return {
+      fields: uniqueFields(members),
+      channels: {
+        [channels.category]: cell[channels.category],
+        [channels.measure]: start,
+        [`${channels.measure}2`]: end,
+        ...(cell.color === undefined ? {} : { color: cell.color }),
+        ...(layer.encoding?.[offsetChannel] === undefined
+          ? {}
+          : { [offsetChannel]: cell.color })
+      },
+      members
+    };
+  }
+
+  if (colorEncoding?.fieldType === "quantitative") {
+    const cells = new Map(derived.map(cell => [
+      cell[channels.category],
+      cell
+    ]));
+    const categories = ["ordinal", "band", "point"].includes(categoryScale.type)
+      ? categoryScale.domain
+      : [...new Set(derived.map(cell => cell[channels.category]))]
+          .sort((left, right) => left - right);
+    return categories.flatMap(category => {
+      const cell = cells.get(category);
+      return cell === undefined
+        ? []
+        : [definition(cell, measureScale.domain[0], cell[channels.measure])];
+    });
+  }
+
+  if (layout === "group" && offsetScale !== undefined) {
+    const categoryIndex = new Map(
+      categoryScale.domain.map((value, index) => [value, index])
+    );
+    const offsetIndex = new Map(
+      offsetScale.domain.map((value, index) => [value, index])
+    );
+    const cells = [...derived].sort((left, right) =>
+      categoryIndex.get(left[channels.category]) -
+        categoryIndex.get(right[channels.category]) ||
+      offsetIndex.get(left.color) - offsetIndex.get(right.color)
+    );
+    return cells.map(cell => definition(
+      cell,
+      measureScale.domain[0],
+      cell[channels.measure]
+    ));
+  }
+
+  const categories = ["ordinal", "band", "point"].includes(categoryScale.type)
+    ? categoryScale.domain
+    : [...new Set(derived.map(cell => cell[channels.category]))]
+        .sort((left, right) => left - right);
+  const series = colorScale?.domain ?? [undefined];
+  const lookup = new Map(derived.map(cell => [
+    JSON.stringify([cell[channels.category], cell.color]),
+    cell
+  ]));
+  const baseline = layout === "overlay" ? measureScale.domain[0] : 0;
+  return categories.flatMap(category => {
+    const cells = series.map(color =>
+      lookup.get(JSON.stringify([category, color]))
+    );
+    const values = cells.map(cell => cell?.[channels.measure] ?? 0);
+    return layoutSeriesPartition(values, layout, { baseline }).flatMap(segment => {
+      const cell = cells[segment.index];
+      return cell === undefined
+        ? []
+        : [definition(cell, segment.start, segment.end)];
+    });
+  });
+}
+
+function histogramDefinitions(program, layer, dataset) {
+  const xEncoding = layer.encoding.x;
+  const colorEncoding = layer.encoding?.color;
+  const segments = deriveHistogramSegments({
+    dataset,
+    layer,
+    xEncoding,
+    xScale: findSemanticScale(program, xEncoding.scale),
+    resolvedScales: program.resolvedScales
+  });
+  const colorScale = program.resolvedScales[colorEncoding?.scale];
+  return segments.map(segment => {
+    const colorValue = colorScale?.domain[segment.category];
+    return {
+      fields: uniqueFields(segment.members),
+      channels: {
+        x: segment.start,
+        x2: segment.end,
+        y: segment.stackStart,
+        y2: segment.stackEnd,
+        ...(colorValue === undefined ? {} : { color: colorValue })
+      },
+      members: segment.members
+    };
+  });
+}
+
+function rangedDefinitions(layer, dataset) {
+  return dataset.values.map(row => ({
+    fields: ownFields(row),
+    channels: channelMapFromRow(row, layer),
+    members: [row]
+  }));
+}
+
+function sharedChannels(definitions) {
+  if (definitions.length === 0) return {};
+  const shared = { ...definitions[0].channels };
+  for (const channel of Object.keys(shared)) {
+    if (!definitions.every(definition =>
+      definition.channels[channel] === shared[channel]
+    )) delete shared[channel];
+  }
+  return shared;
+}
+
+function barStackDefinitions(layer, barGrain, definitions) {
+  const layout = resolveBarColorLayout(layer);
+  if (!["stack", "fill", "diverging"].includes(layout)) {
+    throw new Error(
+      `Bar mark "${layer.id}" does not define stacked items at its current "${layout}" layout.`
+    );
+  }
+  if (barGrain === BAR_GRAINS.ranged) {
+    throw new Error(`Ranged bar mark "${layer.id}" has no stack grain.`);
+  }
+  const channels = resolveBarChannels(layer);
+  const categoryChannels = barGrain === BAR_GRAINS.histogram
+    ? ["x", "x2"]
+    : [channels.category];
+  const measure = channels.measure;
+  const secondary = `${measure}2`;
+  const groups = new Map();
+  definitions.forEach((definition, index) => {
+    const key = JSON.stringify(categoryChannels.map(channel =>
+      definition.channels[channel]
+    ));
+    const group = groups.get(key) ?? [];
+    group.push({ definition, index });
+    groups.set(key, group);
+  });
+
+  return [...groups.values()].map((entries, index) => {
+    const grouped = entries.map(entry => entry.definition);
+    const endpoints = grouped.flatMap(definition => [
+      definition.channels[measure],
+      definition.channels[secondary]
+    ]).filter(Number.isFinite);
+    if (endpoints.length === 0) {
+      throw new Error(
+        `Bar mark "${layer.id}" stack ${index} has no resolved semantic endpoints.`
+      );
+    }
+    const members = grouped.flatMap(definition => definition.members);
+    return {
+      key: itemKey(layer, "stack", index),
+      fields: uniqueFields(members),
+      channels: {
+        ...sharedChannels(grouped),
+        [measure]: Math.min(...endpoints),
+        [secondary]: Math.max(...endpoints)
+      },
+      members,
+      graphicIndices: entries.map(entry => entry.index)
+    };
+  });
+}
+
+export function resolveBarItems(program, layer, dataset, selectionGrain) {
+  const grain = resolveBarGrain(layer);
+  const definitions = grain === BAR_GRAINS.histogram
+    ? histogramDefinitions(program, layer, dataset)
+    : grain === BAR_GRAINS.aggregate
+      ? aggregateCellDefinitions(program, layer, dataset)
+      : grain === BAR_GRAINS.ranged
+        ? rangedDefinitions(layer, dataset)
+        : undefined;
+  if (definitions === undefined) {
+    throw new Error(`Bar mark "${layer.id}" is incomplete for selection.`);
+  }
+  if (selectionGrain === "stack") {
+    return finalizeItems(
+      program,
+      layer,
+      "stack",
+      barStackDefinitions(layer, grain, definitions),
+      "rect"
+    );
+  }
+  return finalizeItems(program, layer, grain, definitions, "rect");
+}