ggaction 0.0.12 → 0.0.13

package/src/actions/scales/materialize.js

@@ -1,8 +1,9 @@
+import { isPendingMeasuredRadiusConsumer } from "../../materialization/scales/policies/arc.js";
+import { findScale, findScaleConsumers } from "./consumers/index.js";
+import { resolveScalePreview, validatePendingMeasuredScale } from "./preview.js";
 import { action } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
-import { normalizePositionScaleChannel } from "../../core/vocabulary.js";
 import { validateKeys } from "../../core/validation.js";
-import { resolveGraphicBounds } from "../../layout/canvas.js";
 import {
   applyMaterializationPlan,
   planScaleGuideRematerialization
@@ -14,16 +15,6 @@ import {
 } from "../../materialization/marks/index.js";
 import { mapScaleConsumerValues } from
   "../../materialization/scales/map.js";
-import { resolveScaleMaterialization } from
-  "../../materialization/scales/resolve.js";
-import {
-  findScale,
-  findScaleConsumers,
-  resolveConsumerCategoryOrder,
-  resolveConsumerValues,
-  resolveSeriesLayoutScaleValues
-} from "./consumers/index.js";
-
 const OPTIONS = Object.freeze(["id", "guides", "marks"]);
 
 function validateOptions(args) {
@@ -36,16 +27,6 @@ function validateOptions(args) {
   }
 }
 
-function resolveScaleChannel(id, consumers) {
-  const channels = new Set(
-    consumers.map(consumer => normalizePositionScaleChannel(consumer.channel))
-  );
-  if (channels.size !== 1) {
-    throw new Error(`Scale "${id}" cannot be shared across channels.`);
-  }
-  return normalizePositionScaleChannel(consumers[0].channel);
-}
-
 export const rematerializeScale = action(
   {
     op: "rematerializeScale",
@@ -54,31 +35,14 @@ export const rematerializeScale = action(
   function (args = {}) {
     validateOptions(args);
     const id = validateUserId(args.id, "Scale id");
-    const scale = findScale(this, id);
+    const semanticScale = findScale(this, id);
     const consumers = findScaleConsumers(this, id);
-    if (consumers.length === 0) {
-      throw new Error(`Scale "${id}" has no supported consumers.`);
+    if (semanticScale.radialMapping !== undefined && consumers.length > 0 &&
+      consumers.every(isPendingMeasuredRadiusConsumer)) {
+      validatePendingMeasuredScale(this, semanticScale, consumers);
+      return this._withoutResolvedScale(id);
     }
-    const channel = resolveScaleChannel(id, consumers);
-    const valuesByConsumer = consumers.map(consumer => ({
-      consumer,
-      values: resolveConsumerValues(this, consumer),
-      categoryOrder: resolveConsumerCategoryOrder(this, consumer),
-      seriesLayout: resolveSeriesLayoutScaleValues(this, consumer)
-    }));
-    const resolvedScale = resolveScaleMaterialization({
-      id,
-      scale,
-      channel,
-      consumers,
-      valuesByConsumer,
-      bounds: ["color", "strokeDash", "strokeWidth", "shape", "size", "opacity", "xOffset", "yOffset"]
-        .includes(channel)
-        ? undefined
-        : resolveGraphicBounds(this),
-      resolvedScales: this.resolvedScales,
-      markConfigs: this.markConfigs
-    });
+    const { channel, valuesByConsumer, resolvedScale } = resolveScalePreview(this, id);
     let next = this._withResolvedScale(id, resolvedScale);
 
     for (const { consumer, values } of valuesByConsumer) {
@@ -94,7 +58,7 @@ export const rematerializeScale = action(
       );
       if (materializationMode === "rematerialize") {
         if (args.marks !== false) {
-          const step = getMarkRematerializationStep(consumer.layer);
+          const step = getMarkRematerializationStep(this, consumer.layer);
           if (step !== undefined) next = next[step.op](step.args);
         }
         continue;

package/src/actions/scales/patch.js

@@ -1,7 +1,7 @@
 const SCALE_EDIT_PROPERTIES = Object.freeze([
   "type", "domain", "range", "nice", "zero", "clamp", "reverse",
   "base", "exponent", "constant", "paddingInner", "paddingOuter",
-  "padding", "align", "interpolate", "unknown"
+  "padding", "align", "interpolate", "midpoint", "unknown"
 ]);
 
 function sameValue(left, right) {

package/src/actions/scales/preview.js

@@ -0,0 +1,39 @@
+import { resolveScaleRange } from "../../grammar/scales/index.js";
+import { resolveArcAutoPositionRange, validateMeasuredRadiusConsumers } from "../../materialization/scales/policies/arc.js";
+import { findSemanticScale } from "../../selectors/scales.js";
+import { normalizePositionScaleChannel } from "../../core/vocabulary.js";
+import { resolveGraphicBounds } from "../../layout/canvas.js";
+import { resolveScaleMaterialization } from "../../materialization/scales/resolve.js";
+import { findScale, findScaleConsumers, resolveConsumerCategoryOrder,
+  resolveConsumerValues, resolveSeriesLayoutScaleValues } from "./consumers/index.js";
+
+export function resolveScalePreview(program, id) {
+  const scale = findScale(program, id);
+  const consumers = findScaleConsumers(program, id);
+  if (consumers.length === 0) throw new Error(`Scale "${id}" has no supported consumers.`);
+  const channels = new Set(consumers.map(consumer => normalizePositionScaleChannel(consumer.channel)));
+  if (channels.size !== 1) throw new Error(`Scale "${id}" cannot be shared across channels.`);
+  const channel = channels.values().next().value;
+  const valuesByConsumer = consumers.map(consumer => {
+    if (program.markConfigs?.[consumer.layer.id]?.markFilter?.empty === true) {
+      return { consumer, values: [], categoryOrder: undefined, seriesLayout: undefined };
+    }
+    return { consumer,
+      values: resolveConsumerValues(program, consumer),
+      categoryOrder: resolveConsumerCategoryOrder(program, consumer),
+      seriesLayout: resolveSeriesLayoutScaleValues(program, consumer) };
+  });
+  const resolvedScale = resolveScaleMaterialization({ id, scale, channel, consumers, valuesByConsumer,
+    bounds: ["color", "strokeDash", "strokeWidth", "shape", "size", "opacity", "xOffset", "yOffset"].includes(channel)
+      ? undefined : resolveGraphicBounds(program),
+    resolvedScales: program.resolvedScales, markConfigs: program.markConfigs, thetaScales: scale.radialMapping === undefined ? undefined : Object.fromEntries(consumers.map(({ layer }) =>
+      [layer.id, findSemanticScale(program, layer.encoding?.theta?.scale)])) });
+  return { channel, consumers, valuesByConsumer, resolvedScale };
+}
+
+export function validatePendingMeasuredScale(program, scale, consumers) {
+  const range = resolveArcAutoPositionRange({ consumers, scale, channel: "radius",
+    range: resolveScaleRange(scale.range, "radius", resolveGraphicBounds(program)), markConfigs: program.markConfigs });
+  validateMeasuredRadiusConsumers({ scale, domain: scale.domain, range, consumers,
+    markConfigs: program.markConfigs, thetaScales: {} });
+}

package/src/actions/scales/quantitativeColor.js

@@ -7,7 +7,7 @@ const OPTIONS = Object.freeze([
   "type",
   "domain",
   "range",
-  "interpolate",
+  "interpolate", "midpoint",
   "clamp",
   "reverse",
   "unknown"
@@ -25,13 +25,17 @@ export const setQuantitativeColorScale = action(
     }
     const existing = findSemanticScale(this, args.id);
     if (existing !== undefined && existing.type !== args.type) {
-      throw new Error(
-        `Scale "${args.id}" cannot change type from "${existing.type}" to "${args.type}".`
-      );
+      if (typeof this.editScale !== "function") {
+        throw new Error("Color scale type transitions require the Full ChartProgram; use a new scale id in Basic.");
+      }
+      return this.editScale(args);
     }
     let next = this;
+    if (existing?.midpoint !== undefined && args.midpoint === undefined) {
+      next = next.editSemantic({ property: `scale[${args.id}].midpoint`, remove: true });
+    }
     for (const property of [
-      "type", "domain", "range", "interpolate", "clamp", "reverse", "unknown"
+      "type", "domain", "range", "interpolate", "midpoint", "clamp", "reverse", "unknown"
     ]) {
       if (!Object.hasOwn(args, property)) continue;
       if (existing?.[property] === args[property]) continue;

package/src/actions/theme/actions.js

@@ -0,0 +1,43 @@
+import { action } from "../../core/action.js";
+import { noOptions, validateOptionObject } from "../../core/validation.js";
+import { THEME_NAMES } from "../../theme/defaults.js";
+
+export const applyTheme = action(
+  {
+    op: "applyTheme",
+    description: "Apply persistent visual defaults to the chart program."
+  },
+  function (args = {}) {
+    validateOptionObject(args, ["theme"], "applyTheme", {
+      allowEmpty: false,
+      emptyMessage: "applyTheme requires theme.",
+      emptyError: Error
+    });
+    if (!THEME_NAMES.includes(args.theme)) {
+      throw new Error(`Unsupported theme "${args.theme}".`);
+    }
+    const previous = this.materializationConfigs.theme;
+    return this._withMaterializationConfig(["theme"], {
+      name: args.theme,
+      overrides: previous?.overrides ?? []
+    });
+  }
+);
+
+export const removeTheme = action(
+  {
+    op: "removeTheme",
+    description: "Remove program theme defaults while preserving local styles."
+  },
+  function (args = {}) {
+    noOptions(args, "removeTheme");
+    if (this.materializationConfigs.theme === undefined) {
+      throw new Error("removeTheme requires an active program theme.");
+    }
+    return this._withMaterializationConfig(["theme"], {
+      ...this.materializationConfigs.theme,
+      name: "light",
+      removing: true
+    });
+  }
+);

package/src/actions/theme/index.js

@@ -0,0 +1,9 @@
+import { setActionCompletionHook } from "../../core/action.js";
+import { applyTheme, removeTheme } from "./actions.js";
+import { reconcileProgramTheme } from "./reconcile.js";
+
+export function registerThemeActions(ProgramClass) {
+  ProgramClass.prototype.applyTheme = applyTheme;
+  ProgramClass.prototype.removeTheme = removeTheme;
+  setActionCompletionHook(reconcileProgramTheme);
+}