ggaction 0.0.18 → 0.0.19

package/src/actions/marks/bar/edit.js

@@ -18,20 +18,20 @@ import { validateFillPaint } from "../../../grammar/paint.js";
 import { validateItemMissing } from "../../../grammar/itemMissing.js";
 
 const EDIT_OPTIONS = Object.freeze([
-  "target", "missing", "fill", "opacity", "stroke", "strokeWidth", ...RECT_RADIUS_PROPERTIES,
+  "target", "missing", "blend", "fill", "opacity", "stroke", "strokeWidth", ...RECT_RADIUS_PROPERTIES,
   ...STROKE_STYLE_PROPERTIES
 ]);
 
 export const editBarMark = /* @__PURE__ */ action(
   {
     op: "editBarMark",
-    description: "Edit whole-bar fill, opacity, and outline appearance."
+    description: "Edit whole-bar fill, opacity, outline, and compositing appearance."
   },
   function (args = {}) {
     validateMarkOptions(args, EDIT_OPTIONS, "editBarMark");
     const styleDetails = requestedRectStyleDetails(args, "editBarMark");
     const changes = [
-      "missing", "fill", "opacity", "stroke", "strokeWidth", ...RECT_RADIUS_PROPERTIES,
+      "missing", "blend", "fill", "opacity", "stroke", "strokeWidth", ...RECT_RADIUS_PROPERTIES,
       ...STROKE_STYLE_PROPERTIES
     ];
     if (!changes.some(key => Object.hasOwn(args, key))) {
@@ -66,13 +66,12 @@ export const editBarMark = /* @__PURE__ */ action(
       );
     }
 
-    const semantic = Object.hasOwn(args, "missing")
-      ? this.editSemantic({
-          property: `layer[${layer.id}].mark.missing`,
-          value: validateItemMissing(args.missing, "Bar missing")
-        })
-      : this;
-    const config = { ...semantic.markConfigs[layer.id] };
+    if (Object.hasOwn(args, "blend") && !["normal", "difference"].includes(args.blend)) {
+      throw new Error("Bar blend must be normal or difference.");
+    }
+    const missing = Object.hasOwn(args, "missing")
+      ? validateItemMissing(args.missing, "Bar missing") : undefined;
+    const config = { ...this.markConfigs[layer.id] };
     const appearance = { ...config.barAppearance };
     Object.assign(appearance, styleDetails);
     if (Object.hasOwn(args, "fill")) {
@@ -106,10 +105,22 @@ export const editBarMark = /* @__PURE__ */ action(
       );
     }
 
-    const next = semantic._withMarkConfig(layer.id, {
+    let semantic = missing === undefined ? this : this.editSemantic({
+      property: `layer[${layer.id}].mark.missing`, value: missing
+    });
+    if (Object.hasOwn(args, "blend")) {
+      if (args.blend === "difference") {
+        semantic = semantic.editSemantic({property: `layer[${layer.id}].mark.blend`, value: "difference"});
+      } else if (layer.mark.blend !== undefined) {
+        semantic = semantic.editSemantic({property: `layer[${layer.id}].mark.blend`, remove: true});
+      }
+    }
+    const editsAppearance = changes.some(key => key !== "missing" && key !== "blend" &&
+      Object.hasOwn(args, key));
+    const next = editsAppearance ? semantic._withMarkConfig(layer.id, {
       ...config,
       barAppearance: appearance
-    });
+    }) : semantic;
     const materialized = canMaterializeBar(next, layer)
       ? next.rematerializeBarMark({ id: layer.id })
       : next;

package/src/actions/marks/bar/materialize.js

@@ -1,3 +1,4 @@
+import { findLayer } from "../../../selectors/layers.js";
 import { editGraphicProperties } from "../../primitives/graphicProperties.js";
 import { action } from "../../../core/action.js";
 import { validateUserId } from "../../../core/identifiers.js";
@@ -20,9 +21,13 @@ const REMATERIALIZE_OPTIONS = Object.freeze(["id", "scales"]);
 
 function editRectangles(program, id, rectangles) {
   const appearance = program.markConfigs[id]?.barAppearance ?? {};
+  const blend = findLayer(program, id)?.mark?.blend;
+  if (blend !== undefined) rectangles = rectangles.map(rect => ({...rect, blend}));
   const hasShapeStyle = RECT_STYLE_PROPERTIES
     .some(property => Object.hasOwn(appearance, property));
-  if (hasShapeStyle) {
+  const previousBlend = program.graphicSpec.objects[id]?.items?.some(item =>
+    item.properties?.blend !== undefined);
+  if (hasShapeStyle || blend !== undefined || previousBlend) {
     const radius = appearance;
     return replaceGraphicItems(
       program,

package/src/actions/marks/point/materialize.js

@@ -1,3 +1,4 @@
+import { validateGraphicItemLimit } from "../../../core/validation.js";
 import { editGraphicProperties } from "../../primitives/graphicProperties.js";
 import { action } from "../../../core/action.js";
 import { validateUserId } from "../../../core/identifiers.js";
@@ -29,6 +30,8 @@ import {
 } from "../../../theme/defaults.js";
 import { findDataset } from "../../../selectors/datasets.js";
 import { findLayer } from "../../../selectors/layers.js";
+import { resolveGraphicItemCapacity } from "../../../selectors/graphicCapacity.js";
+import { getMarkGraphicTypes } from "../../../core/vocabulary.js";
 import { canMaterializePoint } from "../../../materialization/marks/capabilities.js";
 import { rematerializeHighlightBaseline } from "../lifecycle.js";
 import {
@@ -335,13 +338,14 @@ export const rematerializePointMark = /* @__PURE__ */ action(
     if (layer?.mark?.type !== "point") {
       throw new Error(`Unknown point mark "${id}".`);
     }
-    if (!["circle", "rect", "path", "collection"].includes(graphic?.type)) {
+    if (!getMarkGraphicTypes("point").includes(graphic?.type)) {
       throw new Error(`Point mark "${id}" requires point graphics.`);
     }
     const sourceDataset = findDataset(resolved, layer.data);
     if (sourceDataset === undefined) {
       throw new Error(`Point mark "${id}" requires an existing dataset.`);
     }
+    validateGraphicItemLimit(sourceDataset.values.length, resolveGraphicItemCapacity(resolved, { id, label: "Point mark item count" }));
     const dataset = applyItemMissingPolicy(layer, sourceDataset);
 
     if (graphic.items.length === 0 && !canMaterializePoint(resolved, layer)) {

package/src/actions/marks/remove.js

@@ -1,3 +1,4 @@
+import { cartesianAxisOwners, axisTargetArgs } from "../../selectors/axes.js";
 import { ownedChildren, ownership } from "../../selectors/markOwners.js";
 import { isSourceOwnedText } from "../../grammar/text.js";
 import { closedAction } from "../../core/action.js";
@@ -183,16 +184,15 @@ function cleanupPositionGuides(program, scales) {
   let next = program;
   for (const channel of POSITION_CHANNELS) {
     const definition = getPositionChannelDefinition(channel);
-    const axis = next.semanticSpec.guides.axis?.[channel];
-    if (
-      axis !== undefined &&
-      scales[channel].has(axis.scale) &&
-      !hasScaleConsumer(next, channel, axis.scale)
-    ) {
-      next = next[REMOVE_AXIS[channel]]({
-        scale: axis.scale,
-        ...(axis.coordinate === undefined ? {} : { coordinate: axis.coordinate })
-      });
+    const owners = ["x", "y"].includes(channel)
+      ? cartesianAxisOwners(next).filter(owner => owner.channel === channel)
+      : [{ id: channel, channel, semantic: next.semanticSpec.guides.axis?.[channel] }];
+    for (const owner of owners) {
+      const axis = owner.semantic;
+      if (axis !== undefined && scales[channel].has(axis.scale) && !hasScaleConsumer(next, channel, axis.scale)) {
+        next = next[REMOVE_AXIS[channel]]({ ...axisTargetArgs(owner.id, channel), scale: axis.scale,
+          ...(axis.coordinate === undefined ? {} : { coordinate: axis.coordinate }) });
+      }
     }
     const grid = next.semanticSpec.guides.grid?.[definition.gridDirection];
     if (

package/src/actions/primitives/createGraphics.js

@@ -1,7 +1,8 @@
+import { validateGraphicItemLimit } from "../../core/validation.js";
 import { closedAction } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
 import { freezeOwned } from "../../core/immutable.js";
-import { validateGeneratedItemLimit } from "../../core/validation.js";
+import { resolveGraphicItemCapacity } from "../../selectors/graphicCapacity.js";
 import {
   isDrawableGraphicType,
   isGraphicContainerType,
@@ -118,7 +119,7 @@ const createGraphics = /* @__PURE__ */ closedAction(
       throw new TypeError("createGraphics length must be a non-negative integer.");
     }
     if (length !== undefined) {
-      validateGeneratedItemLimit(length, "createGraphics length");
+      validateGraphicItemLimit(length, resolveGraphicItemCapacity(this, { id, label: "createGraphics length", type: validatedType }));
     }
     if (validatedType === "collection" && length !== undefined) {
       throw new Error("Heterogeneous collections use editGraphics items instead of length.");

package/src/actions/primitives/editGraphics.js

@@ -1,6 +1,7 @@
+import { validateGraphicItemLimit } from "../../core/validation.js";
 import { closedAction } from "../../core/action.js";
 import { cloneAndFreeze, freezeOwned, isPlainObject } from "../../core/immutable.js";
-import { validateGeneratedItemLimit } from "../../core/validation.js";
+import { resolveGraphicItemCapacity } from "../../selectors/graphicCapacity.js";
 import {
   isPrimitiveDrawableGraphicType,
   isStructuralGraphicType,
@@ -43,14 +44,14 @@ function validateCollectionItem(item, ownerId, index) {
   });
 }
 
-function replaceCollectionItems(value, id) {
+function replaceCollectionItems(value, id, program) {
   if (!Array.isArray(value)) throw new TypeError("collection.items must be an array.");
-  validateGeneratedItemLimit(value.length, "collection.items length");
+  validateGraphicItemLimit(value.length, resolveGraphicItemCapacity(program, { id, label: "collection.items length" }));
   return freezeOwned(value.map((item, index) => validateCollectionItem(item, id, index)));
 }
 
-function replaceDrawableItems(value, id, type) {
-  const items = replaceCollectionItems(value, id);
+function replaceDrawableItems(value, id, type, program) {
+  const items = replaceCollectionItems(value, id, program);
   if (!items.every(item => item.type === type)) {
     return freezeOwned({ type: "collection", items });
   }
@@ -102,15 +103,15 @@ function editGeneratedItem(owner, itemIndex, property, value) {
   return freezeOwned({ ...owner, items: freezeOwned(items) });
 }
 
-function editItems(owner, property, value, id) {
+function editItems(owner, property, value, id, program) {
   if (owner.type === "collection" && property === "items") {
-    return freezeOwned({ ...owner, items: replaceCollectionItems(value, id) });
+    return freezeOwned({ ...owner, items: replaceCollectionItems(value, id, program) });
   }
   if (property === "length") {
     if (!Number.isInteger(value) || value < 0) {
       throw new TypeError("Graphic collection length must be a non-negative integer.");
     }
-    validateGeneratedItemLimit(value, "Graphic collection length");
+    validateGraphicItemLimit(value, resolveGraphicItemCapacity(program, { id, label: "Graphic collection length" }));
     const items = owner.items.slice(0, value);
     for (let index = items.length; index < value; index += 1) {
       if (owner.type === "collection") {
@@ -189,6 +190,9 @@ const editGraphics = /* @__PURE__ */ closedAction(
 
     const ownerId = found.kind === "item" ? found.ownerId : found.id;
     const owner = found.kind === "item" ? found.owner : found.object;
+    if (owner.items !== undefined) validateGraphicItemLimit(owner.items.length, resolveGraphicItemCapacity(this, {
+      id: ownerId, label: "Graphic collection length"
+    }));
     const replacesDrawableItems =
       found.kind === "object" && property === "items" &&
       owner.items !== undefined && owner.type !== "collection";
@@ -199,7 +203,7 @@ const editGraphics = /* @__PURE__ */ closedAction(
           : owner.type, property);
     let updated;
     if (replacesDrawableItems) {
-      updated = replaceDrawableItems(value, ownerId, owner.type);
+      updated = replaceDrawableItems(value, ownerId, owner.type, this);
     } else if (found.kind === "item") {
       if (validatedProperty === "length" || validatedProperty === "items") {
         throw new Error(`${validatedProperty} can only target an owning graphic.`);
@@ -212,12 +216,12 @@ const editGraphics = /* @__PURE__ */ closedAction(
         properties: setGraphicProperty(owner.properties, validatedProperty, value)
       });
     } else if (owner.items !== undefined) {
-      updated = editItems(owner, validatedProperty, value, ownerId);
+      updated = editItems(owner, validatedProperty, value, ownerId, this);
     } else if (validatedProperty === "length") {
       if (!Number.isInteger(value) || value < 0) {
         throw new TypeError("Graphic collection length must be a non-negative integer.");
       }
-      validateGeneratedItemLimit(value, "Graphic collection length");
+      validateGraphicItemLimit(value, resolveGraphicItemCapacity(this, { id: ownerId, label: "Graphic collection length" }));
       updated = freezeOwned({
         type: owner.type,
         items: freezeOwned(Array.from({ length: value }, (_, index) => freezeOwned({

package/src/actions/primitives/graphicProperties.js

@@ -1,6 +1 @@
-export function editGraphicProperties(program, target, properties) {
-  for (const [property, value] of Object.entries(properties)) {
-    program = program.editGraphics({ target, property, value });
-  }
-  return program;
-}
+export { editGraphicProperties } from "../../core/graphicProperties.js";

package/src/actions/primitives/semanticAction.js

@@ -57,7 +57,7 @@ function updateEntity(spec, parsed, value) {
         source.schema,
         value[0],
         undefined,
-        { sourceId: source.id, ownerId: parsed.id }
+        { sourceId: source.id, ownerId: parsed.id, sourceTransform: source.transform?.[0] }
       ));
     }
   }
@@ -72,6 +72,7 @@ function updateEntity(spec, parsed, value) {
     const schema = source?.schema !== undefined && current.transform?.length === 1
       ? deriveTransformSchema(source.schema, current.transform[0], value, {
           sourceId: source.id,
+          sourceTransform: source.transform?.[0],
           ownerId: parsed.id
         })
       : inferDatasetSchema(value);
@@ -225,6 +226,31 @@ export function withoutPreviewLayerEncodings(program, { id, channels }) {
   return program._clone({ semanticSpec });
 }
 
+// Composition materialization may retain this native two-scale guide meaning.
+// Use the existing semantic primitives on a private unit adapter; this does not
+// relax the public composition guard or accept arbitrary semantic paths.
+export function synchronizeFacetColorSizeMeaning(program, meaning) {
+  if (program.compositionSpec?.type !== "facet") {
+    throw new Error("Color-size parent meaning requires a facet composition.");
+  }
+  if (meaning !== undefined && (!isPlainObject(meaning) ||
+      Object.keys(meaning).some(key => !["colorScale", "sizeScale", "title"].includes(key)))) {
+    throw new Error("Color-size parent meaning requires its native scale bindings and title.");
+  }
+  let unit = new program.constructor({ semanticSpec: program.semanticSpec, graphicSpec: program.graphicSpec,
+    resolvedScales: program.resolvedScales, materializationConfigs: program.materializationConfigs,
+    context: program.context, trace: program.trace, actionStack: program.actionStack,
+    actionSequence: program._actionSequence });
+  if (unit.semanticSpec.guides.legend?.colorSize !== undefined) {
+    unit = unit.editSemantic({ property: "guide.legend.colorSize", remove: true });
+  }
+  if (meaning !== undefined) for (const [property, value] of Object.entries(meaning)) {
+    unit = unit.editSemantic({ property: `guide.legend.colorSize.${property}`, value });
+  }
+  return program._clone({ semanticSpec: unit.semanticSpec, context: unit.context,
+    trace: unit.trace, actionStack: unit.actionStack, actionSequence: unit._actionSequence });
+}
+
 export function createSemanticPrimitiveAction(validateSemanticValue, planNamedRemoval) {
   return closedAction(
     {

package/src/actions/primitives/semanticValidation/guide.js

@@ -1,3 +1,4 @@
+import {isSizeShapeChannels} from "../../../grammar/legendCombinations.js";
 import { normalizeLegendOrder } from "../../../grammar/categoryOrder.js";
 import { validateUserId } from "../../../core/identifiers.js";
 import { CATEGORICAL_LEGEND_CHANNELS } from "../../../core/vocabulary.js";
@@ -16,7 +17,7 @@ function validateLegend(property, value) {
     throw new Error(`Legend ${property} must not contain duplicates.`);
   }
   if (property === "channels") {
-    if (!value.every(channel => CATEGORICAL_LEGEND_CHANNELS.includes(channel))) {
+    if (!isSizeShapeChannels(value) && !value.every(channel => CATEGORICAL_LEGEND_CHANNELS.includes(channel))) {
       throw new Error("Legend channels support only color, strokeDash, and shape.");
     }
     return;
@@ -26,6 +27,11 @@ function validateLegend(property, value) {
 
 export function validateGuideSemanticValue(_program, parsed, value) {
   const property = parsed.path.at(-1);
+  if (parsed.id === "legend.colorSize") {
+    if(property === "title") validateNonEmptySemanticString(value,"Legend title");
+    else validateUserId(value,"Legend scale id");
+    return;
+  }
   if (parsed.id === "axis.parallel" && property === "titles") {
     validateParallelAxisTitles(value);
     return;
@@ -44,6 +50,10 @@ export function validateGuideSemanticValue(_program, parsed, value) {
       throw new TypeError("Parallel axis scales must contain at least two ids.");
     }
     value.forEach(id => validateUserId(id, "Parallel axis scale id"));
+  } else if (parsed.id.startsWith("axis.") && property === "channel") {
+    if (!["x", "y"].includes(value)) throw new Error("Named Cartesian axis channel requires x or y.");
+  } else if (parsed.id.startsWith("axis.") && property === "position") {
+    if (!["top", "bottom", "left", "right"].includes(value)) throw new Error("Named Cartesian axis position requires a physical side.");
   } else if (property === "title") {
     validateNonEmptySemanticString(value, "Axis title");
   } else {

package/src/actions/primitives/semanticValidation/layer.js

@@ -70,6 +70,10 @@ export function validateLayerSemanticValue(
       !["vertical", "horizontal"].includes(value))) {
     throw new Error("Bar orientation must be vertical or horizontal.");
   }
+  if (property === "mark.blend" &&
+      (findLayer(program, parsed.id)?.mark?.type !== "bar" || value !== "difference")) {
+    throw new Error("Bar blend must be difference; remove the optional intent for normal painting.");
+  }
   if (property === "derivedBindings.regression") {
     if (!value || typeof value !== "object" || Array.isArray(value) ||
         Object.keys(value).length !== 2 || value.mode !== "follow" ||

package/src/actions/regression/edit.js

@@ -19,6 +19,7 @@ import { findLayer } from "../../selectors/layers.js";
 import { removeOwnedMark } from "../marks/remove.js";
 import { removeOwnedColorLegends } from "../guides/legends/remove.js";
 import { requireRegressionField } from "./resolve.js";
+import { buildSourceRevisionPlan, applyRevisionPlan } from "../data/edit.js";
 
 const OPTIONS = Object.freeze([
   "target", "data", "x", "y", "groupBy", "method", "degree", "span", "robustIterations",
@@ -128,7 +129,7 @@ function resolveParameters(previous, args) {
         raw[key] = previous[key];
       }
     }
-  } else if (method !== "loess" && previous.method !== "loess" && args.interval !== false) {
+  } else if (!["loess", "exp"].includes(method) && !["loess", "exp"].includes(previous.method) && args.interval !== false) {
     for (const key of ["confidenceMethod", "level", "interval"]) {
       if (
         !Object.hasOwn(raw, key) &&
@@ -295,6 +296,11 @@ export const editRegression = /* @__PURE__ */ closedAction(
     const changesParameters = JSON.stringify(parameters) !==
       JSON.stringify(current.parameters);
     const changesStatistics = changesProvenance || changesParameters;
+    const hasStatistics = this.semanticSpec.datasets.some(dataset =>
+      dataset.source === current.dataId && dataset.transform?.[0]?.type === "regressionStatistics");
+    if (hasStatistics && parameters.method !== "linear") {
+      throw new Error("Remove dependent regression statistics before changing the linear fit method.");
+    }
     const bandPatch = Object.hasOwn(args, "band")
       ? validateBandPatch(args.band)
       : undefined;
@@ -302,14 +308,16 @@ export const editRegression = /* @__PURE__ */ closedAction(
       ? validateLinePatch(args.line)
       : undefined;
     if ((parameters.method === "loess" || parameters.interval === false) && bandPatch !== undefined && bandPatch !== false) {
-      throw new Error("LOESS regression does not support a band object.");
+      throw new Error(parameters.method === "loess"
+        ? "LOESS regression does not support a band object."
+        : "Regression interval false cannot include a band object.");
     }
 
     const hadBand = current.bandId !== undefined;
     const wantsBand = parameters.method !== "loess" && parameters.interval !== false &&
       (bandPatch === false
         ? false
-        : hadBand || bandPatch !== undefined || current.parameters.method === "loess");
+        : hadBand || bandPatch !== undefined || ["loess", "exp"].includes(current.parameters.method));
     const revision = changesStatistics
       ? planDerivedDataRevision(this, {
           owner: owner.id,
@@ -321,6 +329,8 @@ export const editRegression = /* @__PURE__ */ closedAction(
           ]
         })
       : undefined;
+    const statisticsRevision = changesStatistics && hasStatistics
+      ? buildSourceRevisionPlan(this, current.dataId, revision.id) : undefined;
 
     const applyEdit = program => {
       let dataId = current.dataId;
@@ -412,6 +422,8 @@ export const editRegression = /* @__PURE__ */ closedAction(
         }
       });
       if (changesStatistics) {
+        if (statisticsRevision !== undefined) next = applyRevisionPlan(next, undefined,
+          statisticsRevision, { retain: new Set([current.dataId]) });
         next = next.releaseDerivedData(revision.release);
       }
       const binding = findLayer(next, owner.id)?.derivedBindings?.regression;

package/src/actions/scales/channels.js

@@ -42,7 +42,7 @@ const DEFINITIONS = Object.freeze({
     channel: "color",
     options: Object.freeze([
       "type", "domain", "range", "emptyDomain", "clamp", "reverse", "palette",
-      "interpolate", "midpoint", "base", "constant", "unknown"
+      "interpolate", "whitePoint", "gamma", "midpoint", "base", "exponent", "constant", "unknown"
     ])
   }),
   editStrokeScale: Object.freeze({
@@ -50,7 +50,7 @@ const DEFINITIONS = Object.freeze({
     targetOnly: true,
     options: Object.freeze([
       "type", "domain", "range", "emptyDomain", "clamp", "reverse", "palette",
-      "interpolate", "midpoint", "base", "constant", "unknown"
+      "interpolate", "whitePoint", "gamma", "midpoint", "base", "exponent", "constant", "unknown"
     ])
   }),
   editSizeScale: Object.freeze({

package/src/actions/scales/create.js

@@ -38,7 +38,7 @@ const CREATE_SCALE_OPTIONS = Object.freeze([
   "padding",
   "align",
   "palette",
-  "interpolate", "midpoint",
+  "interpolate", "whitePoint", "gamma", "midpoint",
   "radialMapping", "unknown"
 ]);
 
@@ -88,7 +88,7 @@ export const createScale = /* @__PURE__ */ action(
     const id = validateUserId(args.id, "Scale id");
     const type = validateScaleType(args.type ?? "linear");
     const colorType = isColorScaleType(type) && (
-      !["log", "sqrt", "symlog"].includes(type) || args.palette !== undefined ||
+      !["log", "pow", "sqrt", "symlog"].includes(type) || args.palette !== undefined ||
       args.interpolate !== undefined || (Array.isArray(args.range) && typeof args.range[0] === "string") ||
       args.range?.palette !== undefined
     );
@@ -171,7 +171,7 @@ export const createScale = /* @__PURE__ */ action(
 
     for (const property of [
       "emptyDomain", "nice", "zero", "clamp", "reverse", "base", "exponent", "constant",
-      "paddingInner", "paddingOuter", "padding", "align", "interpolate", "midpoint",
+      "paddingInner", "paddingOuter", "padding", "align", "interpolate", "whitePoint", "gamma", "midpoint",
       "radialMapping", "unknown"
     ]) {
       if (definition[property] === undefined) continue;

package/src/actions/scales/definitions.js

@@ -1 +1 @@
-import{prepareScaleEdit as M}from"./editPolicy.js";import{validateUserId as m}from"../../core/identifiers.js";import{isPlainObject as W}from"../../core/immutable.js";import{validateKeys as u}from"../../core/validation.js";import{validateColorRange as U,isContinuousColorScaleType as w,normalizeTransformParameters as B,validateTransformedDomain as F,validateContinuousColorInterpolation as K,validateSequentialMidpoint as Q,validateLinearScaleType as z,validateOpacityRange as H,validateOrdinalDomain as E,validateOrdinalScaleType as N,validateScaleDomain as h,validateScaleRange as _,validateShapeRange as V,validateStrokeDashRange as Y,validateStrokeWidthRange as Z,validateSequentialColorRange as G,validateDiscretizedColorDomain as J,validateDiscretizedColorRange as X,validateTimeScaleType as ee,normalizeScaleDefinition as k,SCALE_ROLES as P,validateScalePropertyForType as A,validateScaleTypeForRole as b,isDiscretePositionScaleType as te,normalizeSizeScaleDefinition as ae,withScaleUnknown as O}from"../../grammar/scales/index.js";import{validateRadialRange as ne,validateThetaRange as ie}from"../../grammar/polar.js";import{findSemanticScale as p}from"../../selectors/scales.js";import{normalizeOffsetScalePolicy as re}from"../../grammar/bars/geometry.js";import{resolveRequestedOffsetPolicy as oe}from"../../materialization/scales/policies/offset.js";import{findScaleConsumers as ce}from"./consumers/index.js";const T=["id","type","domain","range","emptyDomain"],j=[...T,"unknown"],S=["clamp","reverse"],v=["nice","zero",...S],q=["base","exponent","constant"],de=[...T,...v,...q,"paddingInner","paddingOuter","padding","align","unknown"],C=[...T,"palette","unknown"],L=[...C,"interpolate","midpoint","base","constant",...S],le=[...T,...v,"unknown"],se=[...T,...v,...q],ue=[...j,"clamp","reverse","base","exponent"];function y(i){if(!W(i))throw new TypeError("Encoding scale must be a plain object.")}function D(i,e,t){for(const a of e){if(i[a]!==void 0&&typeof i[a]!="boolean")throw new TypeError(`Scale ${a} must be a boolean.`);t!==void 0&&i[a]!==void 0&&A(t,a)}}function R(i,e,t,a){for(const n of a){const r=e[n]??t?.[n];r!==void 0&&(i[n]=r)}return i}function x(i){if(i.palette!==void 0&&i.range!==void 0)throw new Error("Color scale cannot specify both palette and range.")}function Ce(i,e,t,a,n={}){y(a),u(a,de,"scale");const r=m(a.id??e,"Scale id"),o=p(i,r),c=["ordinal","nominal"].includes(t),f=t==="temporal"?"time":c?n.discreteType??"point":"linear",d=a.type??o?.type??f;if(t==="temporal")ee(d);else if(c){if(!te(d))throw new Error(`Scale type "${d}" is not valid for discrete position.`)}else e==="theta"?z(d):b(d,P.quantitativePosition);const l={id:r,...k({type:d,previous:o,patch:{...a,...n.radialMapping===void 0?{}:{radialMapping:n.radialMapping}},defaults:{...o===void 0&&n.nice!==void 0?{nice:n.nice}:{},...o===void 0&&n.zero!==void 0&&(d!=="log"||n.zero)?{zero:n.zero}:{}},retainCoreOnTypeChange:!0,retainCompatibleOnTypeChange:!0,validateDomain:(g,s)=>c?E(s):h(s),validateRange:(g,s)=>e==="theta"?ie(s):e==="radius"?ne(s):_(s)})};return O(l,{...o,...a},e)}function De(i,e,t="color"){y(e),u(e,C,"scale"),x(e);const a=m(e.id??t,"Scale id"),n=p(i,a),r=n?.type==="ordinal"?n:void 0,o=e.palette===void 0?e.range:{palette:e.palette};return O({id:a,type:N(e.type??r?.type??"ordinal"),domain:E(e.domain??r?.domain??"auto"),range:U(o??r?.range??"auto")},{...r,...e},t)}function fe(i,e){if(i==="auto")return i;if(!Array.isArray(i)||i.length!==2)throw new TypeError("Continuous color domain must contain two values or auto.");const t=i.map(a=>e==="quantitative"?a:typeof a=="string"?Date.parse(a):a);if(!t.every(Number.isFinite)||t[0]===t[1])throw new TypeError("Continuous color domain requires two distinct valid values.");return t}function me(i,e,t,a="color"){y(t),u(t,L,"scale"),x(t);const n=m(t.id??a,"Scale id"),r=p(i,n),o=w(r?.type)?r:void 0,c=t.type??o?.type??"sequential";if(!w(c))throw new Error(`Unsupported continuous color scale type "${c}".`);D(t,S);const f=t.palette===void 0?t.range:{palette:t.palette},d={id:n,type:c,domain:fe(t.domain??o?.domain??"auto",e),range:G(f??o?.range??{palette:"viridis"}),interpolate:K(t.interpolate??o?.interpolate??"rgb")};if(c!=="sequential"&&e!=="quantitative")throw new Error(`Scale type "${c}" requires quantitative color.`);const l=Object.fromEntries(["base","constant"].flatMap(s=>{const I=t[s]??o?.[s];return I===void 0?[]:[[s,I]]}));if(c!=="sequential"){const s=B(c,l);c==="log"&&(d.base=s.base),c==="symlog"&&(d.constant=s.constant),d.domain!=="auto"&&F(c,d.domain,l)}else if(Object.keys(l).length)throw new Error("Sequential color does not support transform parameters.");const g=Q(Object.hasOwn(t,"midpoint")?t.midpoint:o?.midpoint,c,d.domain);if(g!==void 0){if(e!=="quantitative")throw new Error("Scale midpoint requires quantitative color consumers.");d.midpoint=g}return O(R(d,t,o,S),{...o,...t},a)}function Re(i,e,t,a="color"){y(t);const n=p(i,t.id??a),r=n!==void 0&&(w(n.type)||["quantize","quantile","threshold"].includes(n.type)),o=t.type??(r?n.type:"sequential");if(r&&n.type!==o){if(u(t,w(o)?L:[...C,...S],"scale"),e!=="quantitative")throw new Error("Color scale type transition requires quantitative color.");return{id:n.id,...M(i,n,a,[],t)}}if(w(o))return me(i,e,t,a);if(u(t,[...C,...S],"scale"),e!=="quantitative")throw new Error(`Scale type "${o}" requires quantitative color.`);b(o,P.discretizedColor),x(t),D(t,S,o);const c=m(t.id??a,"Scale id"),f=n?.type===o?n:void 0,d=t.palette===void 0?t.range:{palette:t.palette},l={id:c,type:o,domain:J(o,t.domain??f?.domain??"auto"),range:X(d??f?.range??{palette:"viridis"})};return O(R(l,t,f,S),{...n,...t},a)}function $(i,e,t,a){y(e),u(e,j,"scale");const n=m(e.id??t,"Scale id"),r=p(i,n);return O({id:n,type:N(e.type??r?.type??"ordinal"),domain:E(e.domain??r?.domain??"auto"),range:a(e.range??r?.range??"auto")},{...r,...e},t)}function he(i,e){return $(i,e,"strokeDash",Y)}function Pe(i,e,t,a="quantitative"){if(y(t),e==="size"){u(t,ue,"scale");const n=m(t.id??e,"Scale id"),r=p(i,n),o=["nominal","ordinal"].includes(a),c=ae({previous:r,patch:{...t,type:t.type??r?.type??(o?"ordinal":"linear")}});if(c.type==="ordinal"!==o)throw new Error("Size scale type must match its field type.");return{id:n,...c}}return $(i,t,e,V)}function be(i,e){y(e),u(e,le,"scale");const t=m(e.id??"opacity","Scale id"),a=p(i,t),n=z(e.type??a?.type??"linear");D(e,v,n);const r={id:t,type:n,domain:h(e.domain??a?.domain??"auto"),range:H(e.range??a?.range??"auto")};return O(R(r,e,a,v),{...a,...e},"opacity")}function xe(i,e){y(e),u(e,se,"scale");const t=m(e.id??"strokeWidth","Scale id"),a=p(i,t),n=e.type??a?.type??"linear";b(n,P.quantitativePosition),D(e,v,n);for(const c of q)e[c]!==void 0&&A(n,c);const r=h(e.domain??a?.domain??"auto");if(r!=="auto"&&r.some(c=>c<0))throw new RangeError("StrokeWidth scale domain cannot contain negative values.");const o={id:t,type:n,domain:r,range:Z(e.range??a?.range??"auto")};return R(o,e,a,[...v,...q])}function Ie(i,e,t="xOffset"){y(e),u(e,["id","type","domain","range","reverse","padding","paddingInner","paddingOuter","align"],"scale");const a=m(e.id??t,"Scale id"),n=p(i,a),r=e.type??n?.type??"ordinal";if(r!=="ordinal")throw new Error(`Scale type "${r}" is not valid for ${t}.`);if(Object.hasOwn(e,"range")&&e.range!=="auto")throw new Error(`${t} scale range is derived from its parent categorical slot.`);const o=ce(i,a).filter(l=>l.channel===t),c=oe({scale:n,consumers:o,markConfigs:i.markConfigs,id:a,channel:t}),f=re(e,c,t),d=Object.fromEntries(Object.entries(e).filter(([l])=>!["id","padding"].includes(l)));return{id:a,...k({type:r,previous:n,patch:{...d,...f},allowOrdinalBandParameters:!0,validateDomain:(l,g)=>E(g),validateRange:(l,g)=>_(g)})}}export{Pe as resolveAppearanceScaleDefinition,De as resolveColorScaleDefinition,Ie as resolveOffsetScaleDefinition,be as resolveOpacityScaleDefinition,Ce as resolvePositionScaleDefinition,Re as resolveQuantitativeColorScaleDefinition,me as resolveSequentialColorScaleDefinition,he as resolveStrokeDashScaleDefinition,xe as resolveStrokeWidthScaleDefinition};
+import{prepareScaleEdit as U}from"./editPolicy.js";import{validateUserId as p}from"../../core/identifiers.js";import{isPlainObject as B}from"../../core/immutable.js";import{validateKeys as f}from"../../core/validation.js";import{validateColorRange as F,isContinuousColorScaleType as E,normalizeTransformParameters as K,validateTransformedDomain as Q,validateContinuousColorInterpolation as H,normalizeColorInterpolationOptions as V,validateSequentialMidpoint as Y,validateLinearScaleType as _,validateOpacityRange as Z,validateOrdinalDomain as h,validateOrdinalScaleType as j,validateScaleDomain as P,validateScaleRange as k,validateShapeRange as G,validateStrokeDashRange as J,validateStrokeWidthRange as X,validateSequentialColorRange as ee,validateDiscretizedColorDomain as te,validateDiscretizedColorRange as ne,validateTimeScaleType as ae,normalizeScaleDefinition as A,SCALE_ROLES as R,validateScalePropertyForType as L,validateScaleTypeForRole as I,isDiscretePositionScaleType as ie,normalizeSizeScaleDefinition as re,withScaleUnknown as w}from"../../grammar/scales/index.js";import{validateRadialRange as oe,validateThetaRange as ce}from"../../grammar/polar.js";import{findSemanticScale as g}from"../../selectors/scales.js";import{normalizeOffsetScalePolicy as le}from"../../grammar/bars/geometry.js";import{resolveRequestedOffsetPolicy as de}from"../../materialization/scales/policies/offset.js";import{findScaleConsumers as se}from"./consumers/index.js";const C=["id","type","domain","range","emptyDomain"],M=[...C,"unknown"],S=["clamp","reverse"],O=["nice","zero",...S],q=["base","exponent","constant"],ue=[...C,...O,...q,"paddingInner","paddingOuter","padding","align","unknown"],D=[...C,"palette","unknown"],$=[...D,"interpolate","whitePoint","gamma","midpoint","base","exponent","constant",...S],fe=[...C,...O,"unknown"],me=[...C,...O,...q],pe=[...M,"clamp","reverse","base","exponent"];function y(i){if(!B(i))throw new TypeError("Encoding scale must be a plain object.")}function b(i,t,e){for(const n of t){if(i[n]!==void 0&&typeof i[n]!="boolean")throw new TypeError(`Scale ${n} must be a boolean.`);e!==void 0&&i[n]!==void 0&&L(e,n)}}function x(i,t,e,n){for(const a of n){const o=t[a]??e?.[a];o!==void 0&&(i[a]=o)}return i}function z(i){if(i.palette!==void 0&&i.range!==void 0)throw new Error("Color scale cannot specify both palette and range.")}function be(i,t,e,n,a={}){y(n),f(n,ue,"scale");const o=p(n.id??t,"Scale id"),r=g(i,o),c=["ordinal","nominal"].includes(e),m=e==="temporal"?"time":c?a.discreteType??"point":"linear",l=n.type??r?.type??m;if(e==="temporal")ae(l);else if(c){if(!ie(l))throw new Error(`Scale type "${l}" is not valid for discrete position.`)}else t==="theta"?_(l):I(l,R.quantitativePosition);const s={id:o,...A({type:l,previous:r,patch:{...n,...a.radialMapping===void 0?{}:{radialMapping:a.radialMapping}},defaults:{...r===void 0&&a.nice!==void 0?{nice:a.nice}:{},...r===void 0&&a.zero!==void 0&&(l!=="log"||a.zero)?{zero:a.zero}:{}},retainCoreOnTypeChange:!0,retainCompatibleOnTypeChange:!0,validateDomain:(v,u)=>c?h(u):P(u),validateRange:(v,u)=>t==="theta"?ce(u):t==="radius"?oe(u):k(u)})};return w(s,{...r,...n},t)}function xe(i,t,e="color"){y(t),f(t,D,"scale"),z(t);const n=p(t.id??e,"Scale id"),a=g(i,n),o=a?.type==="ordinal"?a:void 0,r=t.palette===void 0?t.range:{palette:t.palette};return w({id:n,type:j(t.type??o?.type??"ordinal"),domain:h(t.domain??o?.domain??"auto"),range:F(r??o?.range??"auto")},{...o,...t},e)}function ge(i,t){if(i==="auto")return i;if(!Array.isArray(i)||i.length!==2)throw new TypeError("Continuous color domain must contain two values or auto.");const e=i.map(n=>t==="quantitative"?n:typeof n=="string"?Date.parse(n):n);if(!e.every(Number.isFinite)||e[0]===e[1])throw new TypeError("Continuous color domain requires two distinct valid values.");return e}function ye(i,t,e,n="color"){y(e),f(e,$,"scale"),z(e);const a=p(e.id??n,"Scale id"),o=g(i,a),r=E(o?.type)?o:void 0,c=e.type??r?.type??"sequential";if(!E(c))throw new Error(`Unsupported continuous color scale type "${c}".`);b(e,S);const m=e.palette===void 0?e.range:{palette:e.palette},l={id:a,type:c,domain:ge(e.domain??r?.domain??"auto",t),range:ee(m??r?.range??{palette:"viridis"}),interpolate:H(e.interpolate??r?.interpolate??"rgb")},s=Object.hasOwn(e,"interpolate")&&e.interpolate!==r?.interpolate,v=Object.fromEntries(["whitePoint","gamma"].flatMap(d=>{const T=Object.hasOwn(e,d)?e[d]:s?void 0:r?.[d];return T===void 0?[]:[[d,T]]}));if(Object.assign(l,V(l.interpolate,v)),c!=="sequential"&&t!=="quantitative")throw new Error(`Scale type "${c}" requires quantitative color.`);const u=Object.fromEntries(["base","exponent","constant"].flatMap(d=>{const T=e[d]??(c===r?.type?r?.[d]:void 0);return T===void 0?[]:[[d,T]]}));if(c!=="sequential"){const d=K(c,u);c==="log"&&(l.base=d.base),c==="pow"&&(l.exponent=d.exponent),c==="symlog"&&(l.constant=d.constant),l.domain!=="auto"&&Q(c,l.domain,u)}else if(Object.keys(u).length)throw new Error("Sequential color does not support transform parameters.");const N=Y(Object.hasOwn(e,"midpoint")?e.midpoint:r?.midpoint,c,l.domain);if(N!==void 0){if(t!=="quantitative")throw new Error("Scale midpoint requires quantitative color consumers.");l.midpoint=N}return w(x(l,e,r,S),{...r,...e},n)}function Pe(i,t,e,n="color"){y(e);const a=g(i,e.id??n),o=a!==void 0&&(E(a.type)||["quantize","quantile","threshold"].includes(a.type)),r=e.type??(o?a.type:"sequential");if(o&&a.type!==r){if(f(e,E(r)?$:[...D,...S],"scale"),t!=="quantitative")throw new Error("Color scale type transition requires quantitative color.");return{id:a.id,...U(i,a,n,[],e)}}if(E(r))return ye(i,t,e,n);if(f(e,[...D,...S],"scale"),t!=="quantitative")throw new Error(`Scale type "${r}" requires quantitative color.`);I(r,R.discretizedColor),z(e),b(e,S,r);const c=p(e.id??n,"Scale id"),m=a?.type===r?a:void 0,l=e.palette===void 0?e.range:{palette:e.palette},s={id:c,type:r,domain:te(r,e.domain??m?.domain??"auto"),range:ne(l??m?.range??{palette:"viridis"})};return w(x(s,e,m,S),{...a,...e},n)}function W(i,t,e,n){y(t),f(t,M,"scale");const a=p(t.id??e,"Scale id"),o=g(i,a);return w({id:a,type:j(t.type??o?.type??"ordinal"),domain:h(t.domain??o?.domain??"auto"),range:n(t.range??o?.range??"auto")},{...o,...t},e)}function Re(i,t){return W(i,t,"strokeDash",J)}function Ie(i,t,e,n="quantitative"){if(y(e),t==="size"){f(e,pe,"scale");const a=p(e.id??t,"Scale id"),o=g(i,a),r=["nominal","ordinal"].includes(n),c=re({previous:o,patch:{...e,type:e.type??o?.type??(r?"ordinal":"linear")}});if(c.type==="ordinal"!==r)throw new Error("Size scale type must match its field type.");return{id:a,...c}}return W(i,e,t,G)}function ze(i,t){y(t),f(t,fe,"scale");const e=p(t.id??"opacity","Scale id"),n=g(i,e),a=_(t.type??n?.type??"linear");b(t,O,a);const o={id:e,type:a,domain:P(t.domain??n?.domain??"auto"),range:Z(t.range??n?.range??"auto")};return w(x(o,t,n,O),{...n,...t},"opacity")}function Ne(i,t){y(t),f(t,me,"scale");const e=p(t.id??"strokeWidth","Scale id"),n=g(i,e),a=t.type??n?.type??"linear";I(a,R.quantitativePosition),b(t,O,a);for(const c of q)t[c]!==void 0&&L(a,c);const o=P(t.domain??n?.domain??"auto");if(o!=="auto"&&o.some(c=>c<0))throw new RangeError("StrokeWidth scale domain cannot contain negative values.");const r={id:e,type:a,domain:o,range:X(t.range??n?.range??"auto")};return x(r,t,n,[...O,...q])}function _e(i,t,e="xOffset"){y(t),f(t,["id","type","domain","range","reverse","padding","paddingInner","paddingOuter","align"],"scale");const n=p(t.id??e,"Scale id"),a=g(i,n),o=t.type??a?.type??"ordinal";if(o!=="ordinal")throw new Error(`Scale type "${o}" is not valid for ${e}.`);if(Object.hasOwn(t,"range")&&t.range!=="auto")throw new Error(`${e} scale range is derived from its parent categorical slot.`);const r=se(i,n).filter(s=>s.channel===e),c=de({scale:a,consumers:r,markConfigs:i.markConfigs,id:n,channel:e}),m=le(t,c,e),l=Object.fromEntries(Object.entries(t).filter(([s])=>!["id","padding"].includes(s)));return{id:n,...A({type:o,previous:a,patch:{...l,...m},allowOrdinalBandParameters:!0,validateDomain:(s,v)=>h(v),validateRange:(s,v)=>k(v)})}}export{Ie as resolveAppearanceScaleDefinition,xe as resolveColorScaleDefinition,_e as resolveOffsetScaleDefinition,ze as resolveOpacityScaleDefinition,be as resolvePositionScaleDefinition,Pe as resolveQuantitativeColorScaleDefinition,ye as resolveSequentialColorScaleDefinition,Re as resolveStrokeDashScaleDefinition,Ne as resolveStrokeWidthScaleDefinition};

package/src/actions/scales/edit.js

@@ -28,7 +28,7 @@ import { hasExactLegendSamplingForScale } from
 const OPTIONS = Object.freeze([
   "id", "type", "domain", "range", "emptyDomain", "nice", "zero", "clamp", "reverse",
   "base", "exponent", "constant", "paddingInner", "paddingOuter", "padding",
-  "align", "interpolate", "midpoint", "unknown", "palette", "radialMapping"
+  "align", "interpolate", "whitePoint", "gamma", "midpoint", "unknown", "palette", "radialMapping"
 ]);
 const EDITABLE = Object.freeze(
   OPTIONS.filter(option => !["id", "palette"].includes(option))

package/src/actions/scales/editPolicy.js

@@ -12,6 +12,7 @@ import {
   validateDiscretizedColorDomain,
   validateDiscretizedColorRange,
   validateOrdinalDomain,
+  validateOrdinalRange,
   validateScaleDomain,
   validateScaleRange,
   validateScaleType,
@@ -66,6 +67,7 @@ function validateRangeForChannel(scale, channel, value) {
   if (channel === "strokeDash") return validateStrokeDashRange(value);
   if (channel === "size") return validateSizeRange(value);
   if (channel === "strokeWidth") return validateStrokeWidthRange(value);
+  if (channel === undefined) return validateOrdinalRange(value);
   return validateScaleRange(value);
 }
 
@@ -217,6 +219,7 @@ function normalizeDefinition(program, scale, channel, consumers, patch) {
     patch: normalizedPatch,
     retainCoreOnTypeChange: true,
     retainCompatibleOnTypeChange: true,
+    allowColorReset: true,
     allowOrdinalBandParameters: offset,
     validateDomain: (scaleType, value) =>
       isDiscretizedColorScaleType(scaleType)

package/src/actions/scales/patch.js

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

package/src/actions/scales/quantitativeColor.js

@@ -7,7 +7,7 @@ const OPTIONS = Object.freeze([
   "type",
   "domain",
   "range",
-  "interpolate", "midpoint", "base", "constant",
+  "interpolate", "whitePoint", "gamma", "midpoint", "base", "exponent", "constant",
   "clamp",
   "reverse",
   "unknown"
@@ -19,7 +19,7 @@ export const setQuantitativeColorScale = /* @__PURE__ */ closedAction(
     description: "Create or update an internal quantitative color scale."
   }, OPTIONS,
   function (args = {}) {
-    if (!["sequential", "log", "sqrt", "symlog", "quantize", "quantile", "threshold"].includes(args.type)) {
+    if (!["sequential", "log", "pow", "sqrt", "symlog", "quantize", "quantile", "threshold"].includes(args.type)) {
       throw new Error(`Unsupported quantitative color scale type "${args.type}".`);
     }
     const existing = findSemanticScale(this, args.id);
@@ -30,11 +30,16 @@ export const setQuantitativeColorScale = /* @__PURE__ */ closedAction(
       return this.editScale(args);
     }
     let next = this;
+    for (const property of ["whitePoint", "gamma"]) {
+      if (existing?.[property] !== undefined && args[property] === undefined) {
+        next = next.editSemantic({ property: `scale[${args.id}].${property}`, remove: true });
+      }
+    }
     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", "midpoint", "base", "constant", "clamp", "reverse", "unknown"
+      "type", "domain", "range", "interpolate", "whitePoint", "gamma", "midpoint", "base", "exponent", "constant", "clamp", "reverse", "unknown"
     ]) {
       if (!Object.hasOwn(args, property)) continue;
       if (existing?.[property] === args[property]) continue;