ggaction 0.0.16 → 0.0.18

package/src/actions/regression/follow.js

@@ -0,0 +1,22 @@
+export function reconcileFollowingRegressions(program) {
+  let next = program;
+  for (const layer of program.semanticSpec.layers) {
+    if (layer.derivedBindings?.regression?.mode !== "follow") continue;
+    const config = next.markConfigs[layer.id]?.regression;
+    if (config === undefined) continue;
+    const x = layer.encoding?.x;
+    const y = layer.encoding?.y;
+    if (typeof layer.data !== "string" || x?.fieldType !== "quantitative" || y?.fieldType !== "quantitative" ||
+        typeof x.field !== "string" || typeof y.field !== "string") {
+      throw new Error(`Following regression source "${layer.id}" requires quantitative x/y fields and data.`);
+    }
+    if (config.source === layer.data && config.x === x.field && config.y === y.field) continue;
+    next = next.editRegression({
+      target: layer.id,
+      data: layer.data,
+      x: x.field,
+      y: y.field
+    });
+  }
+  return next;
+}

package/src/actions/regression/resolve.js

@@ -1,3 +1,5 @@
+import { requireStringValue as requireRegressionField } from "../../core/validation.js";
+export { requireStringValue as requireRegressionField } from "../../core/validation.js";
 import { isPlainObject } from "../../core/immutable.js";
 import { findLayer } from "../../selectors/layers.js";
 
@@ -8,12 +10,6 @@ export function requireRegressionObject(value, label) {
   return value;
 }
 
-export function requireRegressionField(value, label) {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new TypeError(`${label} must be a non-empty string.`);
-  }
-  return value;
-}
 
 export function findRegressionPoint(program, requested) {
   const eligible = program.semanticSpec.layers.filter(layer =>

package/src/actions/scales/channels.js

@@ -5,12 +5,13 @@ import { normalizePositionScaleChannel } from "../../core/vocabulary.js";
 import { findLayer } from "../../selectors/layers.js";
 import { requireSemanticScale } from "../../selectors/scales.js";
 import { findScaleConsumers } from "./consumers/index.js";
+import { axisScaleBindings } from "../../materialization/coordinateBounds.js";
 
 const DEFINITIONS = Object.freeze({
   editXScale: Object.freeze({
     channel: "x",
     options: Object.freeze([
-      "type", "domain", "range", "nice", "zero", "clamp", "reverse",
+      "type", "domain", "range", "emptyDomain", "nice", "zero", "clamp", "reverse",
       "base", "exponent", "constant", "paddingInner", "paddingOuter",
       "padding", "align", "unknown"
     ])
@@ -18,7 +19,7 @@ const DEFINITIONS = Object.freeze({
   editYScale: Object.freeze({
     channel: "y",
     options: Object.freeze([
-      "type", "domain", "range", "nice", "zero", "clamp", "reverse",
+      "type", "domain", "range", "emptyDomain", "nice", "zero", "clamp", "reverse",
       "base", "exponent", "constant", "paddingInner", "paddingOuter",
       "padding", "align", "unknown"
     ])
@@ -26,59 +27,59 @@ const DEFINITIONS = Object.freeze({
   editThetaScale: Object.freeze({
     channel: "theta",
     options: Object.freeze([
-      "type", "domain", "range", "nice", "zero", "clamp", "reverse",
+      "type", "domain", "range", "emptyDomain", "nice", "zero", "clamp", "reverse",
       "paddingInner", "paddingOuter", "padding", "align"
     ])
   }),
   editRScale: Object.freeze({
     channel: "radius",
     options: Object.freeze([
-      "type", "domain", "range", "nice", "zero", "clamp", "reverse",
+      "type", "domain", "range", "emptyDomain", "nice", "zero", "clamp", "reverse",
       "base", "exponent", "constant", "radialMapping"
     ])
   }),
   editColorScale: Object.freeze({
     channel: "color",
     options: Object.freeze([
-      "type", "domain", "range", "clamp", "reverse", "palette",
-      "interpolate", "midpoint", "unknown"
+      "type", "domain", "range", "emptyDomain", "clamp", "reverse", "palette",
+      "interpolate", "midpoint", "base", "constant", "unknown"
     ])
   }),
   editStrokeScale: Object.freeze({
     channel: "stroke",
     targetOnly: true,
     options: Object.freeze([
-      "type", "domain", "range", "clamp", "reverse", "palette",
-      "interpolate", "midpoint", "unknown"
+      "type", "domain", "range", "emptyDomain", "clamp", "reverse", "palette",
+      "interpolate", "midpoint", "base", "constant", "unknown"
     ])
   }),
   editSizeScale: Object.freeze({
     channel: "size",
     options: Object.freeze([
-      "type", "domain", "range", "unknown", "clamp", "reverse", "base",
+      "type", "domain", "range", "emptyDomain", "unknown", "clamp", "reverse", "base",
       "exponent"
     ])
   }),
   editOpacityScale: Object.freeze({
     channel: "opacity",
     options: Object.freeze([
-      "type", "domain", "range", "nice", "zero", "clamp", "reverse", "unknown"
+      "type", "domain", "range", "emptyDomain", "nice", "zero", "clamp", "reverse", "unknown"
     ])
   }),
   editShapeScale: Object.freeze({
     channel: "shape",
-    options: Object.freeze(["type", "domain", "range", "unknown"])
+    options: Object.freeze(["type", "domain", "range", "emptyDomain", "unknown"])
   }),
   editStrokeWidthScale: Object.freeze({
     channel: "strokeWidth",
     options: Object.freeze([
-      "type", "domain", "range", "nice", "zero", "clamp", "reverse",
+      "type", "domain", "range", "emptyDomain", "nice", "zero", "clamp", "reverse",
       "base", "exponent", "constant"
     ])
   }),
   editStrokeDashScale: Object.freeze({
     channel: "strokeDash",
-    options: Object.freeze(["type", "domain", "range"])
+    options: Object.freeze(["type", "domain", "range", "emptyDomain"])
   })
 });
 
@@ -99,9 +100,11 @@ function allConsumers(program) {
 }
 
 function channelScaleIds(program, channel) {
-  return [...new Set(allConsumers(program)
+  return [...new Set([...allConsumers(program)
     .filter(consumer => normalizePositionScaleChannel(consumer.channel) === channel)
-    .map(consumer => consumer.encoding.scale))];
+    .map(consumer => consumer.encoding.scale),
+    ...program.semanticSpec.scales.filter(scale => axisScaleBindings(program, scale.id)
+      .some(binding => binding.channel === channel)).map(scale => scale.id)])];
 }
 
 function requireSingleScale(ids, operation, scope) {
@@ -115,6 +118,8 @@ function requireSingleScale(ids, operation, scope) {
 function validateScaleChannel(program, id, channel, operation) {
   requireSemanticScale(program, id);
   const consumers = findScaleConsumers(program, id);
+  const axes = axisScaleBindings(program, id);
+  if (consumers.length === 0 && axes.length === 1 && axes[0].channel === channel) return id;
   if (consumers.length === 0) {
     throw new Error(`${operation} requires a scale bound to the ${channel} channel.`);
   }

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

@@ -5,6 +5,7 @@ import { readScaleField } from "../../../grammar/scales/index.js";
 import { findDataset } from "../../../selectors/datasets.js";
 import { requireSemanticScale } from "../../../selectors/scales.js";
 import { SCALED_ENCODING_CHANNELS } from "../../../core/vocabulary.js";
+import { applyItemMissingPolicy } from "../../../grammar/itemMissing.js";
 
 export function findScale(program, id) {
   return requireSemanticScale(program, id);
@@ -39,7 +40,7 @@ export function requireConsumerDataset(program, consumer) {
       `Mark "${consumer.layer.id}" references unknown dataset "${consumer.layer.data}".`
     );
   }
-  return dataset;
+  return applyItemMissingPolicy(consumer.layer, dataset);
 }
 
 export function isDirectCategoricalConsumer(consumer) {

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

@@ -1,8 +1,9 @@
 import { isPendingMeasuredRadiusConsumer } from "../../../materialization/scales/policies/arc.js";
-import { deriveMeasuredArcValues } from "../../../grammar/arcs.js";
+import { deriveMeasuredArcValues, deriveProportionalArcRadiusValues } from "../../../grammar/arcs.js";
 import { deriveBarAggregates } from "../../../grammar/bars/aggregate.js";
 import {
   BAR_GRAINS,
+  resolveBarChannels,
   resolveBarGrain
 } from "../../../grammar/bars/policy.js";
 import {
@@ -28,9 +29,15 @@ function lineDerivationOptions(program, consumer, dataset) {
 }
 
 export function resolveMarkFamilyConsumerValues(program, consumer, dataset) {
-  if (consumer.layer.mark?.type === "arc" && consumer.channel === "radius" &&
-    findScale(program, consumer.encoding.scale).radialMapping !== undefined) {
-    return { matched: true, values: isPendingMeasuredRadiusConsumer(consumer) ? [] : deriveMeasuredArcValues(dataset.values, consumer.layer).map(item => item.radius) };
+  if (consumer.layer.mark?.type === "arc" && consumer.channel === "radius") {
+    let derive;
+    if (findScale(program, consumer.encoding.scale).radialMapping !== undefined) derive = deriveMeasuredArcValues;
+    else if (consumer.layer.encoding?.theta?.fieldType === "quantitative" ||
+      consumer.layer.encoding?.theta?.aggregate !== undefined || consumer.encoding.aggregate !== undefined) {
+      derive = deriveProportionalArcRadiusValues;
+    }
+    if (derive !== undefined) return { matched: true, values: isPendingMeasuredRadiusConsumer(consumer)
+      ? [] : derive(dataset.values, consumer.layer).map(item => item.radius) };
   }
 
   if (consumer.layer.mark?.type === "rect") {
@@ -44,6 +51,10 @@ export function resolveMarkFamilyConsumerValues(program, consumer, dataset) {
     };
   }
   const { layer, channel } = consumer;
+  if (resolveBarGrain(layer) === BAR_GRAINS.centered &&
+      channel === resolveBarChannels(layer).measure && layer.encoding[`${channel}2`] === undefined) {
+    return { matched: true, values: [0, ...dataset.values.map(row => row[consumer.encoding.field])] };
+  }
   const encoding = layer.encoding ?? {};
   const appearance = ["stroke", "strokeWidth", "opacity"].includes(channel);
   if (
@@ -75,7 +86,7 @@ export function resolveMarkFamilyConsumerValues(program, consumer, dataset) {
         : channel === "x" ? derived.xValues : derived.yValues
     };
   }
-  if (resolveBarGrain(consumer.layer) === BAR_GRAINS.aggregate) {
+  if (resolveBarGrain(consumer.layer) === BAR_GRAINS.aggregate && ["x", "y", "color"].includes(consumer.channel)) {
     const derived = deriveBarAggregates(dataset.values, consumer.layer);
     if (consumer.channel === "color") {
       return {

package/src/actions/scales/create.js

@@ -24,6 +24,7 @@ const CREATE_SCALE_OPTIONS = Object.freeze([
   "id",
   "type",
   "domain",
+  "emptyDomain",
   "range",
   "nice",
   "zero",
@@ -86,14 +87,18 @@ export const createScale = /* @__PURE__ */ action(
     validateOptions(args);
     const id = validateUserId(args.id, "Scale id");
     const type = validateScaleType(args.type ?? "linear");
-    const colorType = isColorScaleType(type);
+    const colorType = isColorScaleType(type) && (
+      !["log", "sqrt", "symlog"].includes(type) || args.palette !== undefined ||
+      args.interpolate !== undefined || (Array.isArray(args.range) && typeof args.range[0] === "string") ||
+      args.range?.palette !== undefined
+    );
     if (args.palette !== undefined && args.range !== undefined) {
       throw new Error("Color scale cannot specify both palette and range.");
     }
     if (args.palette !== undefined && !colorType) {
       throw new Error(`Scale type "${type}" does not support palette.`);
     }
-    if (args.interpolate !== undefined && type !== "sequential") {
+    if (args.interpolate !== undefined && !colorType) {
       throw new Error(`Scale type "${type}" does not support interpolate.`);
     }
     const requestedRange = args.palette === undefined
@@ -128,6 +133,7 @@ export const createScale = /* @__PURE__ */ action(
         })
       : normalizeScaleDefinition({
           type,
+          color: colorType,
           patch: {
             ...args,
             ...(requestedRange === undefined ? {} : { range: requestedRange })
@@ -142,7 +148,7 @@ export const createScale = /* @__PURE__ */ action(
           validateRange: (scaleType, value) =>
             isDiscretizedColorScaleType(scaleType)
               ? validateDiscretizedColorRange(value)
-              : isContinuousColorScaleType(scaleType)
+              : colorType && isContinuousColorScaleType(scaleType)
                 ? validateSequentialColorRange(value)
                 : scaleType === "ordinal"
                   ? validateOrdinalRange(value)
@@ -164,7 +170,7 @@ export const createScale = /* @__PURE__ */ action(
       .editSemantic({ property: `scale[${id}].range`, value: definition.range });
 
     for (const property of [
-      "nice", "zero", "clamp", "reverse", "base", "exponent", "constant",
+      "emptyDomain", "nice", "zero", "clamp", "reverse", "base", "exponent", "constant",
       "paddingInner", "paddingOuter", "padding", "align", "interpolate", "midpoint",
       "radialMapping", "unknown"
     ]) {