ggaction 0.0.2 → 0.0.4

package/src/actions/encodings/color.js

@@ -1,329 +0,0 @@
-import { action } from "../../core/action.js";
-import {
-  readNominalField,
-  readQuantitativeField,
-  readScaleField,
-  readTemporalField,
-  validateNominalFieldType
-} from "../../grammar/scales.js";
-import {
-  BAR_GRAINS,
-  inferBarColorLayout,
-  resolveBarChannels,
-  resolveBarGrain
-} from "../../grammar/bars/policy.js";
-import { validateColorLayout } from "../../grammar/seriesLayout.js";
-import {
-  validateAggregate,
-  validateAggregateFieldType,
-  validateAggregateFieldValues
-} from "../../grammar/aggregate.js";
-import {
-  resolveColorScaleDefinition,
-  resolveQuantitativeColorScaleDefinition
-} from "../scales/definitions.js";
-import {
-  applyEncodingScale,
-  resolveReassignmentScaleOptions,
-  resolveTarget,
-  validateLineSeriesCompatibility,
-  validateOptions
-} from "./shared.js";
-import { applyMaterializationPlan } from "../../materialization/dependencies.js";
-import { planEncodingRematerialization } from "../../materialization/encodings.js";
-
-const COLOR_ENCODING_OPTIONS = Object.freeze([
-  "field", "target", "fieldType", "scale", "layout", "aggregate"
-]);
-
-function resolveColorLayout(layer, requested, barGrain) {
-  const existing = layer.encoding?.color === undefined
-    ? undefined
-    : layer.encoding.color.layout ?? (
-        layer.mark.type === "bar"
-          ? inferBarColorLayout(layer)
-          : layer.mark.type === "area"
-            ? "overlay"
-            : undefined
-      );
-  if (requested !== undefined) validateColorLayout(requested);
-  if (existing !== undefined && requested !== undefined && requested !== existing) {
-    throw new Error(
-      `Color layout transition from "${existing}" to "${requested}" is not supported.`
-    );
-  }
-  const layout = requested ?? existing ?? (
-    layer.mark.type === "bar"
-      ? barGrain === BAR_GRAINS.histogram ? "stack" : barGrain === BAR_GRAINS.ranged ? "overlay" : "group"
-      : layer.mark.type === "area"
-        ? "overlay"
-        : undefined
-  );
-
-  if (["point", "line"].includes(layer.mark.type) && layout !== undefined) {
-    throw new Error(`Color layout is not supported for ${layer.mark.type} marks.`);
-  }
-  if (layer.mark.type === "area" && layout === "group") {
-    throw new Error('Area color layout does not support "group".');
-  }
-  if (
-    layer.mark.type === "area" &&
-    layer.encoding?.y2 !== undefined &&
-    layout !== "overlay"
-  ) {
-    throw new Error('Ranged area color encoding supports only "overlay" layout.');
-  }
-  return layout;
-}
-
-function applyColorLayoutCompanion(
-  program,
-  { target, layer, layout, scale, field }
-) {
-  if (layout === undefined) return program;
-  if (layer.mark.type === "bar" && resolveBarGrain(layer) === BAR_GRAINS.ranged) return program;
-  if (layer.mark.type === "area" && layer.encoding?.y2 !== undefined) {
-    return program;
-  }
-  const channels = layer.mark.type === "bar" ? resolveBarChannels(layer) : undefined;
-  const measureChannel = channels?.measure ?? "y";
-  const measure = layer.encoding?.[measureChannel];
-  if (measure?.field === undefined || measure.scale === undefined) {
-    throw new Error(`Color layout on mark "${target}" requires a measure encoding.`);
-  }
-  const stack = layout === "fill"
-    ? "normalize"
-    : layout === "overlay" || layout === "group"
-      ? null
-      : "zero";
-  let next = program;
-  if (layout === "group") {
-    if (channels?.orientation === "horizontal") {
-      throw new Error('Horizontal bars do not support color layout "group" until yOffset is available.');
-    }
-    next = next.encodeXOffset({
-      field,
-      target,
-      scale: {
-        ...(layer.encoding?.xOffset?.scale === undefined
-          ? {}
-          : { id: layer.encoding.xOffset.scale }),
-        domain: scale.domain
-      }
-    });
-  }
-  return next[measureChannel === "x" ? "encodeX" : "encodeY"]({
-    target,
-    field: measure.field,
-    fieldType: measure.fieldType,
-    ...(measure.aggregate === undefined ? {} : { aggregate: measure.aggregate }),
-    stack
-  });
-}
-
-function encodeContinuousColor(program, args) {
-  if (!["quantitative", "temporal"].includes(args.fieldType)) {
-    throw new Error(`Unsupported color field type "${args.fieldType}".`);
-  }
-  if (args.layout !== undefined) {
-    throw new Error("Continuous color does not support layout.");
-  }
-  const { id: target, dataset, layer } = resolveTarget(
-    program,
-    args.target,
-    ["point", "bar"],
-    "continuous color mark"
-  );
-  const requestedScale = resolveReassignmentScaleOptions(
-    layer.encoding?.color,
-    args.scale ?? {}
-  );
-  const scale = resolveQuantitativeColorScaleDefinition(
-    program,
-    args.fieldType,
-    requestedScale
-  );
-  if (Object.hasOwn(scale, "unknown") && layer.mark.type !== "point") {
-    throw new Error(
-      "Continuous color scale unknown currently requires a row-owned point mark."
-    );
-  }
-  if (
-    layer.mark.type === "bar" &&
-    layer.encoding?.color?.fieldType === "nominal"
-  ) {
-    throw new Error(
-      "Continuous bar color cannot replace an existing nominal color layout."
-    );
-  }
-  let aggregate;
-  if (layer.mark.type === "point") {
-    if (args.aggregate !== undefined) {
-      throw new Error("Point continuous color does not support aggregate.");
-    }
-  } else {
-    if (args.fieldType !== "quantitative") {
-      throw new Error("Aggregate bar color currently requires a quantitative field.");
-    }
-    if (resolveBarGrain(layer) !== BAR_GRAINS.aggregate) {
-      throw new Error(
-        "Continuous bar color requires a complete categorical aggregate bar."
-      );
-    }
-    const channels = resolveBarChannels(layer);
-    const measure = layer.encoding?.[channels.measure];
-    aggregate = args.aggregate ?? (
-      measure?.field === args.field ? measure.aggregate : undefined
-    );
-    if (aggregate === undefined) {
-      throw new Error(
-        "Continuous bar color requires aggregate when its field differs from the measure field."
-      );
-    }
-    aggregate = validateAggregate(aggregate);
-    validateAggregateFieldType(aggregate, args.fieldType);
-    validateAggregateFieldValues(dataset.values, args.field, args.fieldType);
-  }
-  if (Object.hasOwn(scale, "unknown")) {
-    readScaleField(dataset.values, args.field, args.fieldType, {
-      allowUnknown: true
-    });
-  } else if (args.fieldType === "temporal") {
-    readTemporalField(dataset.values, args.field);
-  } else {
-    readQuantitativeField(dataset.values, args.field);
-  }
-  const next = program
-    .editSemantic({
-      property: `layer[${target}].encoding.color.field`,
-      value: args.field
-    })
-    .editSemantic({
-      property: `layer[${target}].encoding.color.fieldType`,
-      value: args.fieldType
-    })
-    .editSemantic({
-      property: `layer[${target}].encoding.color.scale`,
-      value: scale.id
-    });
-  const encoded = aggregate === undefined
-    ? next
-    : next.editSemantic({
-        property: `layer[${target}].encoding.color.aggregate`,
-        value: aggregate
-      });
-  const scaled = encoded.setQuantitativeColorScale(scale);
-  return applyMaterializationPlan(
-    scaled,
-    planEncodingRematerialization(scaled, {
-      target,
-      channel: "color",
-      scale: scale.id
-    })
-  );
-}
-
-const encodeColor = action(
-  {
-    op: "encodeColor",
-    description: "Encode a field as graphical color."
-  },
-  function (args = {}) {
-    validateOptions(args, COLOR_ENCODING_OPTIONS, "encodeColor");
-    const requestedFieldType = args.fieldType ?? "nominal";
-    if (requestedFieldType !== "nominal") {
-      return encodeContinuousColor(this, {
-        ...args,
-        fieldType: requestedFieldType
-      });
-    }
-    if (args.aggregate !== undefined) {
-      throw new Error("Nominal color does not support aggregate.");
-    }
-    const fieldType = validateNominalFieldType(requestedFieldType);
-    const { id: target, dataset, layer } = resolveTarget(
-      this,
-      args.target,
-      ["point", "line", "bar", "area"],
-      "color mark"
-    );
-    if (
-      layer.mark.type === "area" &&
-      (layer.encoding?.group?.field === undefined ||
-        layer.encoding.group.field !== args.field)
-    ) {
-      throw new Error(
-        "Area color encoding must match an existing group encoding."
-      );
-    }
-    validateLineSeriesCompatibility(layer, "color", args.field);
-
-    const barGrain = resolveBarGrain(layer);
-    if (layer.mark.type === "bar" && barGrain === undefined) {
-      throw new Error(
-        "Bar color encoding requires a complete histogram encoding or a complete ordinal aggregate encoding."
-      );
-    }
-    const layout = resolveColorLayout(layer, args.layout, barGrain);
-    const requestedScale = resolveReassignmentScaleOptions(
-      layer.encoding?.color,
-      args.scale ?? {}
-    );
-    const scale = resolveColorScaleDefinition(this, requestedScale);
-    if (Object.hasOwn(scale, "unknown") && layer.mark.type !== "point") {
-      throw new Error(
-        "Nominal color scale unknown currently requires a row-owned point mark."
-      );
-    }
-    if (Object.hasOwn(scale, "unknown")) {
-      readScaleField(dataset.values, args.field, fieldType, {
-        allowUnknown: true
-      });
-    } else {
-      readNominalField(dataset.values, args.field);
-    }
-
-    let next = this
-      .editSemantic({
-        property: `layer[${target}].encoding.color.field`,
-        value: args.field
-      })
-      .editSemantic({
-        property: `layer[${target}].encoding.color.fieldType`,
-        value: fieldType
-      })
-      .editSemantic({
-        property: `layer[${target}].encoding.color.scale`,
-        value: scale.id
-      });
-    if (layout !== undefined) {
-      next = next.editSemantic({
-        property: `layer[${target}].encoding.color.layout`,
-        value: layout
-      });
-    }
-    next = applyEncodingScale(next, scale, requestedScale, {
-      reassignment: layer.encoding?.color?.scale === scale.id
-    });
-    next = applyColorLayoutCompanion(next, {
-      target,
-      layer,
-      layout,
-      scale,
-      field: args.field
-    });
-
-    return applyMaterializationPlan(
-      next,
-      planEncodingRematerialization(next, {
-        target,
-        channel: "color",
-        scale: scale.id
-      })
-    );
-  }
-);
-
-export function registerColorEncodingAction(ProgramClass) {
-  ProgramClass.prototype.encodeColor = encodeColor;
-}

package/src/actions/encodings/position.js

@@ -1,176 +0,0 @@
-import { action } from "../../core/action.js";
-import {
-  canMaterializeArea,
-  canMaterializeLine,
-} from "../../materialization/marks.js";
-import { resolveBarGrain } from "../../grammar/bars/policy.js";
-import { resolvePositionEncoding } from "./position/resolve.js";
-import { findLayer } from "../../selectors/layers.js";
-import {
-  applyEncodingScale,
-  rebindPositionGuides
-} from "./shared.js";
-
-function encodePosition(program, channel, args, operation) {
-  const {
-    target,
-    layer,
-    previous,
-    requestedScale,
-    field,
-    datum,
-    hasField,
-    fieldType,
-    scale,
-    coordinate,
-    bin,
-    aggregate,
-    stack
-  } = resolvePositionEncoding(program, channel, args, operation);
-
-  let next = program
-    .createCoordinate({
-      id: coordinate.id,
-      type: coordinate.type,
-      layers: [target]
-    });
-  if (previous !== undefined) {
-    const alternate = hasField ? "datum" : "field";
-    if (Object.hasOwn(previous, alternate)) {
-      next = next.editSemantic({
-        property: `layer[${target}].encoding.${channel}.${alternate}`,
-        remove: true
-      });
-    }
-  }
-  next = next
-    .editSemantic({
-      property: `layer[${target}].encoding.${channel}.${hasField ? "field" : "datum"}`,
-      value: hasField ? field : datum
-    })
-    .editSemantic({
-      property: `layer[${target}].encoding.${channel}.fieldType`,
-      value: fieldType
-    });
-
-  if (layer.mark.type === "line" && channel === "y" && args.aggregate !== undefined) {
-    next = next.editSemantic({
-      property: `layer[${target}].encoding.y.aggregate`,
-      value: aggregate
-    });
-  }
-
-  if (layer.mark.type === "bar" && channel === "x" && bin !== undefined) {
-    const [mode] = Object.keys(bin);
-    const previousModes = Object.keys(layer.encoding?.x?.bin ?? {});
-    for (const previousMode of previousModes) {
-      if (previousMode === mode) continue;
-      next = next.editSemantic({
-        property: `layer[${target}].encoding.x.bin.${previousMode}`,
-        remove: true
-      });
-    }
-    next = next.editSemantic({
-      property: `layer[${target}].encoding.x.bin.${mode}`,
-      value: bin[mode]
-    });
-  }
-
-  if (layer.mark.type === "bar") {
-    if (aggregate !== undefined) {
-      next = next.editSemantic({
-        property: `layer[${target}].encoding.${channel}.aggregate`,
-        value: aggregate
-      });
-    }
-    if (stack !== undefined) {
-      next = next.editSemantic({
-        property: `layer[${target}].encoding.${channel}.stack`,
-        value: stack
-      });
-    }
-  }
-
-  if (layer.mark.type === "area" && channel === "y" && stack !== undefined) {
-    next = next.editSemantic({
-      property: `layer[${target}].encoding.y.stack`,
-      value: stack
-    });
-  }
-
-  next = next.editSemantic({
-      property: `layer[${target}].encoding.${channel}.scale`,
-      value: scale.id
-    });
-  next = applyEncodingScale(next, scale, requestedScale, {
-    reassignment: previous?.scale === scale.id
-  });
-  next = rebindPositionGuides(
-    next,
-    channel,
-    previous?.scale,
-    scale.id,
-    target
-  );
-
-  if (layer.mark.type === "line") {
-    const updated = findLayer(next, target);
-    return canMaterializeLine(next, updated)
-      ? next.rematerializeLineMark({ id: target })
-      : next.rematerializeScale({ id: scale.id });
-  }
-
-  if (layer.mark.type === "rule") {
-    return next.rematerializeRuleMark({ id: target });
-  }
-
-  if (layer.mark.type === "bar") {
-    const updated = findLayer(next, target);
-    const pendingBox = next.markConfigs[target]?.boxPlot;
-    if (pendingBox !== undefined && !pendingBox.materialized) {
-      return updated.encoding?.x !== undefined && updated.encoding?.y !== undefined
-        ? next.materializeBoxPlot({ id: target })
-        : next;
-    }
-    const materialized = resolveBarGrain(updated) !== undefined
-      ? next.rematerializeBarMark({ id: target })
-      : next.rematerializeScale({ id: scale.id });
-    return materialized;
-  }
-
-  next = next.rematerializeScale({ id: scale.id });
-  if (layer.mark.type === "area") {
-    const updated = findLayer(next, target);
-    return canMaterializeArea(next, updated)
-      ? next.rematerializeAreaMark({ id: target })
-      : next;
-  }
-  return layer.mark.type === "point"
-    ? next.rematerializePointMark({ id: target })
-    : next;
-}
-
-const encodeX = action(
-  {
-    op: "encodeX",
-    description: "Encode a field as horizontal position."
-  },
-  function (args = {}) {
-    return encodePosition(this, "x", args, "encodeX");
-  }
-);
-
-const encodeY = action(
-  {
-    op: "encodeY",
-    description: "Encode a field as vertical position."
-  },
-  function (args = {}) {
-    return encodePosition(this, "y", args, "encodeY");
-  }
-);
-
-export function registerPositionEncodingActions(ProgramClass) {
-  ProgramClass.prototype.encodeX = encodeX;
-  ProgramClass.prototype.encodeY = encodeY;
-}