ggaction 0.0.15 → 0.0.17

package/src/actions/primitives/semanticAction.js

@@ -1,5 +1,5 @@
 import { hasSemanticScaleReferences } from "../../selectors/scales.js";
-import { action } from "../../core/action.js";
+import { closedAction } from "../../core/action.js";
 import {
   cloneAndFreeze,
   freezeOwned,
@@ -7,6 +7,8 @@ import {
   removeOwnedPath
 } from "../../core/immutable.js";
 import { parseSemanticPath } from "../../grammar/schemas/semanticPath.js";
+import { deriveTransformSchema, inferDatasetSchema, validateRowsAgainstSchema } from "../../grammar/datasetSchema.js";
+
 
 const CONTEXT_KEYS = Object.freeze({
   dataset: "currentData",
@@ -43,7 +45,39 @@ function updateEntity(spec, parsed, value) {
   }
 
   const current = index === -1 ? { id: parsed.id } : collection[index];
-  const updated = setNestedProperty(current, parsed.path, value);
+  let updated = setNestedProperty(current, parsed.path, value);
+  if (
+    parsed.kind === "dataset" && parsed.path.length === 1 &&
+    parsed.path[0] === "transform" && current.schema === undefined &&
+    current.source !== undefined && value.length === 1
+  ) {
+    const source = collection.find(dataset => dataset.id === current.source);
+    if (source?.schema !== undefined) {
+      updated = setNestedProperty(updated, ["schema"], deriveTransformSchema(
+        source.schema,
+        value[0],
+        undefined,
+        { sourceId: source.id, ownerId: parsed.id }
+      ));
+    }
+  }
+  if (
+    parsed.kind === "dataset" && parsed.path.length === 1 &&
+    parsed.path[0] === "values" &&
+    (current.schema === undefined || current.schema.origin === "derived")
+  ) {
+    const source = current.source === undefined
+      ? undefined
+      : collection.find(dataset => dataset.id === current.source);
+    const schema = source?.schema !== undefined && current.transform?.length === 1
+      ? deriveTransformSchema(source.schema, current.transform[0], value, {
+          sourceId: source.id,
+          ownerId: parsed.id
+        })
+      : inferDatasetSchema(value);
+    validateRowsAgainstSchema(value, schema, `Dataset "${parsed.id}"`);
+    updated = setNestedProperty(updated, ["schema"], schema);
+  }
   const nextCollection = [...collection];
 
   if (index === -1) {
@@ -154,13 +188,14 @@ export function withRematerializedDerivedDataset(program, {
   id,
   source,
   transform,
-  values
+  values,
+  schema
 }) {
   const semanticSpec = {
     ...program.semanticSpec,
     datasets: program.semanticSpec.datasets.map(dataset =>
       dataset.id === id
-        ? { ...dataset, source, transform: [transform], values }
+        ? { ...dataset, source, transform: [transform], values, ...(schema === undefined ? {} : { schema }) }
         : dataset
     )
   };
@@ -191,13 +226,15 @@ export function withoutPreviewLayerEncodings(program, { id, channels }) {
 }
 
 export function createSemanticPrimitiveAction(validateSemanticValue, planNamedRemoval) {
-  return action(
+  return closedAction(
     {
       op: "editSemantic",
       description: "Create, replace, or remove one semantic property.",
       scope: "any"
-    },
-    function ({ property, value, remove = false } = {}) {
+    }, ["property", "value", "remove"],
+    function (args = {}) {
+
+      const { property, value, remove = false } = args;
       if (typeof remove !== "boolean") {
         throw new TypeError("editSemantic remove must be a boolean.");
       }

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

@@ -1,6 +1,10 @@
 import { validateUserId } from "../../../core/identifiers.js";
-import { isPlainObject } from "../../../core/immutable.js";
-import { hasDataset } from "../../../selectors/datasets.js";
+import { validateDataRows } from "../../../core/validation.js";
+import { findDataset, hasDataset } from "../../../selectors/datasets.js";
+import {
+  validateDatasetSchema,
+  validateRowsAgainstSchema
+} from "../../../grammar/datasetSchema.js";
 
 export function validateDatasetSemanticValue(
   program,
@@ -10,11 +14,17 @@ export function validateDatasetSemanticValue(
 ) {
   const property = parsed.path[0];
   if (property === "values") {
-    if (!Array.isArray(value) || !value.every(isPlainObject)) {
-      throw new TypeError("Dataset values must be an array of plain row objects.");
+    validateDataRows(value, `Dataset "${parsed.id}"`);
+    const schema = findDataset(program, parsed.id)?.schema;
+    if (schema !== undefined && schema.origin !== "derived") {
+      validateRowsAgainstSchema(value, schema, `Dataset "${parsed.id}"`);
     }
     return;
   }
+  if (property === "schema") {
+    validateDatasetSchema(value);
+    return;
+  }
   if (property === "source") {
     validateUserId(value, "Dataset source id");
     if (!hasDataset(program, value)) {

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

@@ -19,6 +19,8 @@ import { findLayer } from "../../../selectors/layers.js";
 import { validateNonEmptySemanticString } from "./shared.js";
 import { normalizeStatisticalWeight } from
   "../../../grammar/weightedStatistics.js";
+import { ITEM_MISSING_MARK_TYPES, validateItemMissing } from
+  "../../../grammar/itemMissing.js";
 
 function validateLayerSource(program, parsed, value, sourceMarkTypes) {
   validateUserId(value, "Layer source id");
@@ -52,8 +54,26 @@ export function validateLayerSemanticValue(
   if (property === "mark.type" && !MARK_TYPES.includes(value)) {
     throw new Error(`Unknown mark type "${value}".`);
   }
-  if (property === "mark.missing" && !["error", "break"].includes(value)) {
-    throw new Error(`Unsupported area missing policy "${value}".`);
+  if (property === "mark.missing") {
+    const markType = findLayer(program, parsed.id)?.mark?.type;
+    if (markType === "area") {
+      if (!["error", "break"].includes(value)) {
+        throw new Error(`Unsupported area missing policy "${value}".`);
+      }
+    } else if (ITEM_MISSING_MARK_TYPES.includes(markType)) {
+      validateItemMissing(value, `${markType} missing`);
+    } else {
+      throw new Error(`Mark type "${markType}" does not support a missing policy.`);
+    }
+  }
+  if (property === "derivedBindings.regression") {
+    if (!value || typeof value !== "object" || Array.isArray(value) ||
+        Object.keys(value).length !== 2 || value.mode !== "follow" ||
+        !Array.isArray(value.roles) || value.roles.length !== 3 ||
+        value.roles.join(",") !== "data,x,y") {
+      throw new Error("Regression derived binding must follow data, x, and y roles.");
+    }
+    return;
   }
   if (property === "layout.mode" && !COLOR_LAYOUTS.includes(value)) {
     throw new Error(`Unsupported series layout "${value}".`);

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

@@ -55,6 +55,12 @@ export function validateScaleSemanticValue(program, parsed, value) {
     return;
   }
   if (property === "domain") return validateSemanticScaleDomain(value);
+  if (property === "emptyDomain") {
+    if (!["preserve", "require-explicit"].includes(value)) {
+      throw new Error('Scale emptyDomain must be "preserve" or "require-explicit".');
+    }
+    return;
+  }
   if (property === "range") return validateSemanticScaleRange(value);
   if (["nice", "zero", "clamp", "reverse"].includes(property)) {
     if (typeof value !== "boolean") {

package/src/actions/regression/components.js

@@ -1,6 +1,6 @@
-import { action } from "../../core/action.js";
+import { closedAction } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
-import { validateKeys } from "../../core/validation.js";
+
 import { DEFAULT_COLORS } from "../../theme/defaults.js";
 import { findDataset } from "../../selectors/datasets.js";
 import { resolveEligibleLayer } from "../../selectors/layers.js";
@@ -72,13 +72,12 @@ function requireRegressionBandDataset(program, args) {
   return { dataset, transform };
 }
 
-export const createRegressionBand = action(
+export const createRegressionBand = /* @__PURE__ */ closedAction(
   {
     op: "createRegressionBand",
     description: "Create and encode a grouped regression confidence band."
-  },
+  }, BAND_OPTIONS,
   function (args = {}) {
-    validateKeys(args, BAND_OPTIONS, "createRegressionBand");
     const id = validateUserId(args.id, "Regression band id");
     const { transform } = requireRegressionBandDataset(this, args);
     validateAreaCreateOutline(args, "createRegressionBand");
@@ -121,13 +120,12 @@ export const createRegressionBand = action(
   }
 );
 
-export const editRegressionBand = action(
+export const editRegressionBand = /* @__PURE__ */ closedAction(
   {
     op: "editRegressionBand",
     description: "Edit regression-band fill, opacity, and outline."
-  },
+  }, EDIT_BAND_OPTIONS,
   function (args = {}) {
-    validateKeys(args, EDIT_BAND_OPTIONS, "editRegressionBand");
     const changes = [
       "color", "opacity", "stroke", "strokeWidth", "curve",
       ...STROKE_STYLE_PROPERTIES
@@ -157,13 +155,12 @@ export const editRegressionBand = action(
   }
 );
 
-export const editRegressionLine = action(
+export const editRegressionLine = /* @__PURE__ */ closedAction(
   {
     op: "editRegressionLine",
     description: "Edit regression-line width or curve."
-  },
+  }, EDIT_LINE_OPTIONS,
   function (args = {}) {
-    validateKeys(args, EDIT_LINE_OPTIONS, "editRegressionLine");
     if (
       !["strokeWidth", "curve", ...STROKE_STYLE_PROPERTIES]
         .some(property => Object.hasOwn(args, property))
@@ -187,13 +184,12 @@ export const editRegressionLine = action(
   }
 );
 
-export const createRegressionLine = action(
+export const createRegressionLine = /* @__PURE__ */ closedAction(
   {
     op: "createRegressionLine",
     description: "Create and encode grouped regression line paths."
-  },
+  }, LINE_OPTIONS,
   function (args = {}) {
-    validateKeys(args, LINE_OPTIONS, "createRegressionLine");
     const id = validateUserId(args.id, "Regression line id");
     let next = this
       .createLineMark({

package/src/actions/regression/create.js

@@ -1,6 +1,6 @@
-import { action } from "../../core/action.js";
+import { closedAction } from "../../core/action.js";
 import { validateKeys } from "../../core/validation.js";
-import { normalizeRegressionParameters } from "../../grammar/regression/index.js";
+import { normalizeRegressionParameters, normalizeRegressionPredict } from "../../grammar/regression/index.js";
 import { STROKE_STYLE_PROPERTIES } from "../../grammar/strokeStyle.js";
 import {
   findRegressionPoint,
@@ -12,15 +12,19 @@ import {
 const REGRESSION_OPTIONS = Object.freeze([
   "target", "x", "y", "groupBy", "method", "degree", "span",
   "confidenceMethod", "level", "confidence", "interval", "band", "line"
+  , "predict", "sourceBinding", "missing"
 ]);
 
-export const createRegression = action(
+export const createRegression = /* @__PURE__ */ closedAction(
   {
     op: "createRegression",
     description: "Fit and layer regression lines with optional interval bands."
-  },
+  }, REGRESSION_OPTIONS,
   function (args = {}) {
-    validateKeys(args, REGRESSION_OPTIONS, "createRegression");
+    const sourceBinding = args.sourceBinding ?? "fixed";
+    if (!["fixed", "follow"].includes(sourceBinding)) {
+      throw new Error('Regression sourceBinding must be "fixed" or "follow".');
+    }
     const point = findRegressionPoint(this, args.target);
     const x = args.x === undefined
       ? point.encoding.x.field
@@ -38,11 +42,21 @@ export const createRegression = action(
       );
     }
     const parameters = normalizeRegressionParameters(args);
+    const predict = normalizeRegressionPredict(args.predict);
+    const regressionDefinition = {
+      ...parameters,
+      ...(predict === undefined ? {} : { predict }),
+      ...(args.missing === undefined ? {} : { missing: args.missing })
+    };
     let band = false;
     if (parameters.method === "loess") {
       if (args.band !== undefined && args.band !== false) {
         throw new Error("LOESS regression does not support a band object.");
       }
+    } else if (parameters.interval === false) {
+      if (args.band !== undefined && args.band !== false) {
+        throw new Error("Regression interval false cannot include a band object.");
+      }
     } else if (args.band !== false) {
       band = requireRegressionObject(args.band ?? {}, "Regression band");
     }
@@ -79,7 +93,7 @@ export const createRegression = action(
         x,
         y,
         ...(groupBy === undefined ? {} : { groupBy }),
-        ...parameters
+        ...regressionDefinition
       });
     if (band !== false) {
       next = next.createRegressionBand({
@@ -106,7 +120,7 @@ export const createRegression = action(
       yScale,
       ...line
     });
-    return next._withMarkConfig(point.id, {
+    next = next._withMarkConfig(point.id, {
       ...next.markConfigs[point.id],
       regression: {
         source: point.data,
@@ -120,8 +134,14 @@ export const createRegression = action(
         dataId,
         bandId: band === false ? undefined : bandId,
         lineId,
-        parameters
+        parameters: regressionDefinition
       }
     });
+    return sourceBinding === "follow"
+      ? next.editSemantic({
+          property: `layer[${point.id}].derivedBindings.regression`,
+          value: { mode: "follow", roles: ["data", "x", "y"] }
+        })
+      : next;
   }
 );

package/src/actions/regression/edit.js

@@ -1,4 +1,4 @@
-import { action } from "../../core/action.js";
+import { closedAction } from "../../core/action.js";
 import { isPlainObject } from "../../core/immutable.js";
 import { validateUserId } from "../../core/identifiers.js";
 import {
@@ -7,7 +7,7 @@ import {
   validateNonNegativeFinite,
   validateUnitInterval
 } from "../../core/validation.js";
-import { normalizeRegressionParameters } from "../../grammar/regression/index.js";
+import { normalizeRegressionParameters, normalizeRegressionPredict } from "../../grammar/regression/index.js";
 import { validateCurveInterpolation } from "../../grammar/curveCommands.js";
 import {
   requestedStrokeDetails,
@@ -23,6 +23,7 @@ import { requireRegressionField } from "./resolve.js";
 const OPTIONS = Object.freeze([
   "target", "data", "x", "y", "groupBy", "method", "degree", "span",
   "confidenceMethod", "level", "confidence", "interval", "band", "line"
+  , "predict", "sourceBinding", "missing"
 ]);
 const BAND_OPTIONS = Object.freeze([
   "color", "opacity", "stroke", "strokeWidth", "curve",
@@ -115,7 +116,7 @@ function resolveParameters(previous, args) {
     if (Object.hasOwn(args, key)) raw[key] = args[key];
   }
   const inheritsLevel = !Object.hasOwn(raw, "confidence");
-  if (method === previous.method) {
+  if (method === previous.method && args.interval !== false) {
     for (const key of [
       "degree", "span", "confidenceMethod", "level", "interval"
     ]) {
@@ -127,7 +128,7 @@ function resolveParameters(previous, args) {
         raw[key] = previous[key];
       }
     }
-  } else if (method !== "loess" && previous.method !== "loess") {
+  } else if (method !== "loess" && previous.method !== "loess" && args.interval !== false) {
     for (const key of ["confidenceMethod", "level", "interval"]) {
       if (
         !Object.hasOwn(raw, key) &&
@@ -138,7 +139,19 @@ function resolveParameters(previous, args) {
       }
     }
   }
-  return normalizeRegressionParameters(raw);
+  const parameters = normalizeRegressionParameters(raw);
+  const predict = Object.hasOwn(args, "predict")
+    ? args.predict === false ? undefined : normalizeRegressionPredict(args.predict)
+    : previous.predict;
+  const missing = Object.hasOwn(args, "missing") ? args.missing : previous.missing;
+  if (missing !== undefined && !["error", "drop"].includes(missing)) {
+    throw new Error('Regression missing must be "error" or "drop".');
+  }
+  return {
+    ...parameters,
+    ...(predict === undefined ? {} : { predict }),
+    ...(missing === undefined ? {} : { missing })
+  };
 }
 
 function regressionColorScale(owner, current, groupBy) {
@@ -234,27 +247,42 @@ function updateRegressionBandSemantics(program, bandId, { x, groupBy }) {
   });
 }
 
-export const editRegression = action(
+export const editRegression = /* @__PURE__ */ closedAction(
   {
     op: "editRegression",
     description: "Revise a regression model and its owned visible components."
-  },
+  }, OPTIONS,
   function (args = {}) {
-    validateKeys(args, OPTIONS, "editRegression");
     if (!OPTIONS.slice(1).some(key => Object.hasOwn(args, key))) {
       throw new Error("editRegression requires a statistical or component option.");
     }
     const owner = resolveRegressionOwner(this, args.target);
     const current = this.markConfigs[owner.id].regression;
-    const source = Object.hasOwn(args, "data")
+    const currentBinding = owner.derivedBindings?.regression?.mode === "follow" ? "follow" : "fixed";
+    const sourceBinding = args.sourceBinding ?? currentBinding;
+    if (!["fixed", "follow"].includes(sourceBinding)) throw new Error('Regression sourceBinding must be "fixed" or "follow".');
+    const followed = sourceBinding === "follow" ? {
+      data: owner.data,
+      x: owner.encoding?.x?.fieldType === "quantitative" ? owner.encoding.x.field : undefined,
+      y: owner.encoding?.y?.fieldType === "quantitative" ? owner.encoding.y.field : undefined
+    } : undefined;
+    if (sourceBinding === "follow" && (!followed.data || !followed.x || !followed.y)) {
+      throw new Error(`Following regression source "${owner.id}" requires quantitative x/y fields and data.`);
+    }
+    for (const key of ["data", "x", "y"]) {
+      if (followed !== undefined && Object.hasOwn(args, key) && args[key] !== followed[key]) {
+        throw new Error(`Following regression ${key} must match source mark "${owner.id}".`);
+      }
+    }
+    const source = followed?.data ?? (Object.hasOwn(args, "data")
       ? validateUserId(args.data, "Regression data id")
-      : current.source;
-    const x = Object.hasOwn(args, "x")
+      : current.source);
+    const x = followed?.x ?? (Object.hasOwn(args, "x")
       ? requireRegressionField(args.x, "Regression x")
-      : current.x;
-    const y = Object.hasOwn(args, "y")
+      : current.x);
+    const y = followed?.y ?? (Object.hasOwn(args, "y")
       ? requireRegressionField(args.y, "Regression y")
-      : current.y;
+      : current.y);
     const groupBy = Object.hasOwn(args, "groupBy")
       ? args.groupBy === false
         ? undefined
@@ -273,12 +301,12 @@ export const editRegression = action(
     const linePatch = Object.hasOwn(args, "line")
       ? validateLinePatch(args.line)
       : undefined;
-    if (parameters.method === "loess" && bandPatch !== undefined && bandPatch !== false) {
+    if ((parameters.method === "loess" || parameters.interval === false) && bandPatch !== undefined && bandPatch !== false) {
       throw new Error("LOESS regression does not support a band object.");
     }
 
     const hadBand = current.bandId !== undefined;
-    const wantsBand = parameters.method !== "loess" &&
+    const wantsBand = parameters.method !== "loess" && parameters.interval !== false &&
       (bandPatch === false
         ? false
         : hadBand || bandPatch !== undefined || current.parameters.method === "loess");
@@ -386,6 +414,12 @@ export const editRegression = action(
       if (changesStatistics) {
         next = next.releaseDerivedData(revision.release);
       }
+      const binding = findLayer(next, owner.id)?.derivedBindings?.regression;
+      if (sourceBinding === "follow" && binding?.mode !== "follow") {
+        next = next.editSemantic({ property: `layer[${owner.id}].derivedBindings.regression`, value: { mode: "follow", roles: ["data", "x", "y"] } });
+      } else if (sourceBinding === "fixed" && binding !== undefined) {
+        next = next.editSemantic({ property: `layer[${owner.id}].derivedBindings.regression`, remove: true });
+      }
       return next;
     };
     return applyEdit(this);

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/resources/remove.js

@@ -1,3 +1,4 @@
+import { annotateError } from "../../core/diagnostics.js";
 import { action } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
 import { validateOptionObject } from "../../core/validation.js";
@@ -70,20 +71,20 @@ export function resolveResourceOwnership(program, { kind, id }) {
     if (resource !== undefined) return { ownership: "named", resource };
     const other = existingKind(program, id);
     if (other !== undefined) {
-      throw new Error(`Resource "${id}" exists as ${other}, not ${kind}.`);
+      throw annotateError(new Error(`Resource "${id}" exists as ${other}, not ${kind}.`), { code: "incompatible-resource", resourceId: id });
     }
-    throw new Error(`Unknown ${kind} "${id}".`);
+    throw annotateError(new Error(`Unknown ${kind} "${id}".`), { code: "missing-resource", resourceId: id });
   }
 
   const owners = dataOwners(program).filter(owner => owner.owner === id);
   if (owners.length > 1) {
-    throw new Error(`Data resource "${id}" has ambiguous logical ownership.`);
+    throw annotateError(new Error(`Data resource "${id}" has ambiguous logical ownership.`), { code: "ambiguous-resource", resourceId: id });
   }
   if (owners.length === 1) {
     const owner = owners[0];
     const current = exactResource(program, "data", owner.current);
     if (current === undefined) {
-      throw new Error(`Data owner "${id}" has no current dataset.`);
+      throw annotateError(new Error(`Data owner "${id}" has no current dataset.`), { code: "missing-resource", resourceId: id });
     }
     return { ownership: "standalone", resource: current, dataOwner: owner };
   }
@@ -98,9 +99,9 @@ export function resolveResourceOwnership(program, { kind, id }) {
   }
   const other = existingKind(program, id);
   if (other !== undefined) {
-    throw new Error(`Resource "${id}" exists as ${other}, not data.`);
+    throw annotateError(new Error(`Resource "${id}" exists as ${other}, not data.`), { code: "incompatible-resource", resourceId: id });
   }
-  throw new Error(`Unknown data "${id}".`);
+  throw annotateError(new Error(`Unknown data "${id}".`), { code: "missing-resource", resourceId: id });
 }
 
 function assertSupportedProgram(program, operation) {
@@ -126,10 +127,10 @@ export function planResourceRemoval(program, { kind, id, operation }) {
     value.path.at(-1) === "current"
   ));
   if (live.length > 0) {
-    throw new Error(
+    throw annotateError(new Error(
       `Cannot remove ${kind} "${id}"; live references: ` +
       live.map(formatReference).join("; ")
-    );
+    ), { code: "resource-in-use", resourceId: id, candidates: [...new Set(live.map(value => value.ownerId))] });
   }
   return Object.freeze({
     kind,
@@ -161,12 +162,12 @@ function removeResource(kind, operation, description) {
   );
 }
 
-export const removeData = removeResource(
+export const removeData = /* @__PURE__ */ removeResource(
   "data", "removeData", "Remove one unreferenced named dataset."
 );
-export const removeScale = removeResource(
+export const removeScale = /* @__PURE__ */ removeResource(
   "scale", "removeScale", "Remove one unreferenced named scale."
 );
-export const removeCoordinate = removeResource(
+export const removeCoordinate = /* @__PURE__ */ removeResource(
   "coordinate", "removeCoordinate", "Remove one unreferenced named coordinate."
 );

package/src/actions/scales/channels.js

@@ -10,7 +10,7 @@ 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 +18,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,21 +26,21 @@ 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",
+      "type", "domain", "range", "emptyDomain", "clamp", "reverse", "palette",
       "interpolate", "midpoint", "unknown"
     ])
   }),
@@ -48,37 +48,37 @@ const DEFINITIONS = Object.freeze({
     channel: "stroke",
     targetOnly: true,
     options: Object.freeze([
-      "type", "domain", "range", "clamp", "reverse", "palette",
+      "type", "domain", "range", "emptyDomain", "clamp", "reverse", "palette",
       "interpolate", "midpoint", "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"])
   })
 });