ggaction 0.0.16 → 0.0.18

package/src/grammar/regression/parameters.js

@@ -1,10 +1,39 @@
-import { cloneAndFreeze } from "../../core/immutable.js";
+import { cloneAndFreeze, isPlainObject } from "../../core/immutable.js";
 import { validateGeneratedItemLimit } from "../../core/validation.js";
 import { normalizeConfidenceInterval } from
   "../statistics/confidenceInterval.js";
 
 const MAX_POLYNOMIAL_DEGREE = 32;
 
+export function normalizeRegressionPredict(predict) {
+  if (predict === undefined) return undefined;
+  if (predict === false) throw new TypeError("Regression predict false is only valid in edits.");
+  if (!isPlainObject(predict)) {
+    throw new TypeError("Regression predict must be a plain object.");
+  }
+  const unknown = Object.keys(predict).find(key => !["values", "domain", "steps"].includes(key));
+  if (unknown !== undefined) throw new Error(`Unknown regression predict property "${unknown}".`);
+  const usesValues = Object.hasOwn(predict, "values");
+  const usesDomain = Object.hasOwn(predict, "domain") || Object.hasOwn(predict, "steps");
+  if (usesValues === usesDomain) throw new Error("Regression predict requires values or domain with steps.");
+  if (usesValues) {
+    const values = predict.values;
+    if (!Array.isArray(values) || values.length === 0 || values.some((value, index) =>
+      !Number.isFinite(value) || (index > 0 && !(value > values[index - 1]))
+    )) throw new TypeError("Regression predict values must be finite, unique, and strictly ascending.");
+    return cloneAndFreeze({ values: [...values] });
+  }
+  if (!Array.isArray(predict.domain) || predict.domain.length !== 2 ||
+      !predict.domain.every(Number.isFinite) || !(predict.domain[0] < predict.domain[1])) {
+    throw new TypeError("Regression predict domain must be two increasing finite numbers.");
+  }
+  if (!Number.isInteger(predict.steps) || predict.steps < 2) {
+    throw new RangeError("Regression predict steps must be an integer of at least two.");
+  }
+  validateGeneratedItemLimit(predict.steps, "Regression predict steps");
+  return cloneAndFreeze({ domain: [...predict.domain], steps: predict.steps });
+}
+
 export function requireRegressionField(field, label) {
   if (typeof field !== "string" || field.length === 0) {
     throw new TypeError(`${label} must be a non-empty string.`);
@@ -16,6 +45,7 @@ export function normalizeRegressionParameters({
   method = "linear",
   degree,
   span,
+  robustIterations,
   confidenceMethod,
   level,
   confidence,
@@ -40,11 +70,34 @@ export function normalizeRegressionParameters({
         "Regression LOESS span must be greater than zero and at most one."
       );
     }
-    return cloneAndFreeze({ method, span: resolvedSpan });
+    const iterations = robustIterations === undefined ? 0 : robustIterations;
+    if (!Number.isInteger(iterations) || iterations < 0 || iterations > 32) {
+      throw new RangeError("LOESS robustIterations must be an integer in [0, 32].");
+    }
+    return cloneAndFreeze({ method, span: resolvedSpan,
+      ...(iterations === 0 ? {} : { robustIterations: iterations }) });
+  }
+  if (robustIterations !== undefined) {
+    throw new Error("Regression robustIterations requires the loess method.");
   }
   if (span !== undefined) {
     throw new Error("Regression span requires the loess method.");
   }
+  if (interval === false) {
+    if (confidenceMethod !== undefined || level !== undefined || confidence !== undefined) {
+      throw new Error("Regression interval false cannot include confidence options.");
+    }
+    if (method === "polynomial") {
+      const resolvedDegree = degree ?? 2;
+      if (!Number.isInteger(resolvedDegree) || resolvedDegree < 1) {
+        throw new RangeError("Regression polynomial degree must be a positive integer.");
+      }
+      validateGeneratedItemLimit(resolvedDegree, "Regression polynomial degree", MAX_POLYNOMIAL_DEGREE);
+      return cloneAndFreeze({ method, degree: resolvedDegree, interval: false });
+    }
+    if (degree !== undefined) throw new Error("Regression degree requires the polynomial method.");
+    return cloneAndFreeze({ method, interval: false });
+  }
   if (level !== undefined && confidence !== undefined && level !== confidence) {
     throw new Error(
       "Regression level and confidence alias must match when both are provided."
@@ -96,7 +149,7 @@ export function validateRegressionTransform(transform) {
   const supported = [
     "type", "method", "x", "y", "groupBy", "confidenceMethod", "level",
     "confidence", "interval",
-    "degree", "span"
+    "degree", "span", "robustIterations", "predict", "missing"
   ];
   const unknown = Object.keys(transform).find(key => !supported.includes(key));
   if (unknown !== undefined) {
@@ -122,14 +175,20 @@ export function validateRegressionTransform(transform) {
     method: transform.method,
     degree: transform.degree,
     span: transform.span,
+    robustIterations: transform.robustIterations,
     confidenceMethod: transform.confidenceMethod,
     level: transform.level,
     confidence: transform.confidence,
     interval: transform.interval
   });
+  normalizeRegressionPredict(transform.predict);
+  if (transform.missing !== undefined && !["error", "drop"].includes(transform.missing)) {
+    throw new Error('Regression missing must be "error" or "drop".');
+  }
   if (normalized.method === "loess") return transform;
   if (
     transform.confidence === undefined &&
+    transform.interval !== false &&
     (transform.confidenceMethod === undefined || transform.level === undefined)
   ) {
     throw new Error("Regression confidence provenance requires method and level.");
@@ -142,6 +201,7 @@ export function validateRegressionTransform(transform) {
 
 export function normalizeRegressionTransform(args = {}) {
   const parameters = normalizeRegressionParameters(args);
+  const predict = normalizeRegressionPredict(args.predict);
   const transform = {
     type: "regression",
     method: parameters.method,
@@ -152,12 +212,15 @@ export function normalizeRegressionTransform(args = {}) {
       ? { degree: parameters.degree }
       : {}),
     ...(parameters.method === "loess"
-      ? { span: parameters.span }
-      : {
+      ? { span: parameters.span, ...(parameters.robustIterations === undefined
+          ? {} : { robustIterations: parameters.robustIterations }) }
+      : parameters.interval === false ? { interval: false } : {
           confidenceMethod: parameters.confidenceMethod,
           level: parameters.level,
           interval: parameters.interval
-        })
+        }),
+    ...(predict === undefined ? {} : { predict }),
+    ...(args.missing === undefined ? {} : { missing: args.missing })
   };
   validateRegressionTransform(transform);
   return cloneAndFreeze(transform);

package/src/grammar/roundedRect.js

@@ -5,8 +5,12 @@ import {
 } from "./strokeStyle.js";
 
 export const ROUNDED_RECT_K = 4 * (Math.sqrt(2) - 1) / 3;
+export const RECT_RADIUS_PROPERTIES = Object.freeze([
+  "cornerRadius", "cornerRadiusTopLeft", "cornerRadiusTopRight",
+  "cornerRadiusBottomRight", "cornerRadiusBottomLeft"
+]);
 export const RECT_STYLE_PROPERTIES = Object.freeze([
-  "cornerRadius",
+  ...RECT_RADIUS_PROPERTIES,
   ...STROKE_STYLE_PROPERTIES
 ]);
 
@@ -17,12 +21,12 @@ function requireFinite(value, property) {
   return value;
 }
 
-export function validateCornerRadius(value, label = "Rect style") {
+export function validateCornerRadius(value, label = "Rect style", property = "cornerRadius") {
   if (!Number.isFinite(value)) {
-    throw new TypeError(`${label} cornerRadius must be a finite number.`);
+    throw new TypeError(`${label} ${property} must be a finite number.`);
   }
   if (value < 0) {
-    throw new RangeError(`${label} cornerRadius must not be negative.`);
+    throw new RangeError(`${label} ${property} must not be negative.`);
   }
   return value;
 }
@@ -33,9 +37,9 @@ export function requestedRectStyleDetails(request = {}, label = "Rect style") {
   }
   return freezeOwned({
     ...requestedStrokeDetails(request, label),
-    ...(Object.hasOwn(request, "cornerRadius")
-      ? { cornerRadius: validateCornerRadius(request.cornerRadius, label) }
-      : {})
+    ...Object.fromEntries(RECT_RADIUS_PROPERTIES
+      .filter(property => Object.hasOwn(request, property))
+      .map(property => [property, validateCornerRadius(request[property], label, property)]))
   });
 }
 
@@ -65,60 +69,48 @@ export function resolveRoundedRectRadius(width, height, requestedRadius) {
   return Math.min(requestedRadius, width / 2, height / 2);
 }
 
+export function hasRectRadius(style = {}) {
+  return RECT_RADIUS_PROPERTIES.some(property => Object.hasOwn(style, property));
+}
+
+function resolveCornerRadii(width, height, requested) {
+  const style = typeof requested === "number" ? { cornerRadius: requested } : requested;
+  const details = requestedRectStyleDetails(style, "Rounded rect");
+  return RECT_RADIUS_PROPERTIES.slice(1).map(property => resolveRoundedRectRadius(
+    width, height, details[property] ?? details.cornerRadius ?? 0
+  ));
+}
+
 export function roundedRectCommands({ x, y, width, height, radius }) {
   const geometry = normalizeRectGeometry({ x, y, width, height });
-  const r = resolveRoundedRectRadius(
-    geometry.width,
-    geometry.height,
-    radius
-  );
-  if (!(r > 0)) {
+  const [tl, tr, br, bl] = resolveCornerRadii(geometry.width, geometry.height, radius);
+  if (![tl, tr, br, bl].some(value => value > 0)) {
     throw new RangeError("Rounded rect commands require a positive resolved radius.");
   }
   const right = geometry.x + geometry.width;
   const bottom = geometry.y + geometry.height;
-  const c = ROUNDED_RECT_K * r;
+  const k = ROUNDED_RECT_K;
   return freezeOwned([
-    { op: "M", x: geometry.x + r, y: geometry.y },
-    { op: "L", x: right - r, y: geometry.y },
+    { op: "M", x: geometry.x + tl, y: geometry.y },
+    { op: "L", x: right - tr, y: geometry.y },
     {
-      op: "C",
-      x1: right - r + c,
-      y1: geometry.y,
-      x2: right,
-      y2: geometry.y + r - c,
-      x: right,
-      y: geometry.y + r
+      op: "C", x1: right - tr + k * tr, y1: geometry.y,
+      x2: right, y2: geometry.y + tr - k * tr, x: right, y: geometry.y + tr
     },
-    { op: "L", x: right, y: bottom - r },
+    { op: "L", x: right, y: bottom - br },
     {
-      op: "C",
-      x1: right,
-      y1: bottom - r + c,
-      x2: right - r + c,
-      y2: bottom,
-      x: right - r,
-      y: bottom
+      op: "C", x1: right, y1: bottom - br + k * br,
+      x2: right - br + k * br, y2: bottom, x: right - br, y: bottom
     },
-    { op: "L", x: geometry.x + r, y: bottom },
+    { op: "L", x: geometry.x + bl, y: bottom },
     {
-      op: "C",
-      x1: geometry.x + r - c,
-      y1: bottom,
-      x2: geometry.x,
-      y2: bottom - r + c,
-      x: geometry.x,
-      y: bottom - r
+      op: "C", x1: geometry.x + bl - k * bl, y1: bottom,
+      x2: geometry.x, y2: bottom - bl + k * bl, x: geometry.x, y: bottom - bl
     },
-    { op: "L", x: geometry.x, y: geometry.y + r },
+    { op: "L", x: geometry.x, y: geometry.y + tl },
     {
-      op: "C",
-      x1: geometry.x,
-      y1: geometry.y + r - c,
-      x2: geometry.x + r - c,
-      y2: geometry.y,
-      x: geometry.x + r,
-      y: geometry.y
+      op: "C", x1: geometry.x, y1: geometry.y + tl - k * tl,
+      x2: geometry.x + tl - k * tl, y2: geometry.y, x: geometry.x + tl, y: geometry.y
     },
     { op: "Z" }
   ].map(command => freezeOwned(command)));
@@ -129,15 +121,11 @@ export function materializeRectItem(properties, requestedRadius = 0) {
     throw new TypeError("Rounded rect item properties must be a plain object.");
   }
   const geometry = normalizeRectGeometry(properties);
-  const radius = resolveRoundedRectRadius(
-    geometry.width,
-    geometry.height,
-    requestedRadius
-  );
+  const radii = resolveCornerRadii(geometry.width, geometry.height, requestedRadius);
   const appearance = Object.fromEntries(Object.entries(properties).filter(
     ([key]) => !["x", "y", "width", "height"].includes(key)
   ));
-  return radius === 0
+  return radii.every(radius => radius === 0)
     ? freezeOwned({
         type: "rect",
         properties: freezeOwned({ ...geometry, ...appearance })
@@ -145,7 +133,7 @@ export function materializeRectItem(properties, requestedRadius = 0) {
     : freezeOwned({
         type: "path",
         properties: freezeOwned({
-          commands: roundedRectCommands({ ...geometry, radius }),
+          commands: roundedRectCommands({ ...geometry, radius: requestedRadius }),
           ...appearance
         })
       });

package/src/grammar/scales/appearance.js

@@ -1,206 +1 @@
-import { cloneAndFreeze, isPlainObject } from "../../core/immutable.js";
-import { validateUnitInterval } from "../../core/validation.js";
-import { POINT_SHAPES } from "../pointShapes.js";
-import {
-  normalizePalette,
-  resolvePalette
-} from "../palettes.js";
-
-export const DASH10 = cloneAndFreeze([
-  [], [8, 4], [3, 3], [12, 4], [8, 3, 2, 3],
-  [12, 3, 3, 3], [2, 2], [10, 3, 2, 3, 2, 3], [14, 4, 4, 4], [6, 2, 2, 2]
-]);
-export const NAMED_DASH_PATTERNS = cloneAndFreeze({
-  solid: [],
-  dashed: [6, 4],
-  dotted: [1, 3],
-  dashdot: [6, 3, 1, 3]
-});
-
-export { POINT_SHAPES } from "../pointShapes.js";
-export const DEFAULT_SIZE_RANGE = cloneAndFreeze([24, 196]);
-export const DEFAULT_OPACITY_RANGE = cloneAndFreeze([0.2, 1]);
-export const DEFAULT_STROKE_WIDTH_RANGE = cloneAndFreeze([1, 8]);
-
-export function validateColorRange(range) {
-  if (range === "auto") return range;
-  if (Array.isArray(range)) {
-    if (
-      range.length === 0 ||
-      !range.every(color => typeof color === "string" && color.length > 0)
-    ) {
-      throw new TypeError("Color range must contain non-empty color strings.");
-    }
-    return cloneAndFreeze(range);
-  }
-  if (
-    !isPlainObject(range) ||
-    Object.keys(range).length !== 1 ||
-    !Object.hasOwn(range, "palette")
-  ) {
-    throw new Error("Color range must contain only a palette descriptor.");
-  }
-  normalizePalette(range.palette);
-  return cloneAndFreeze(range);
-}
-
-function isDashPattern(pattern) {
-  return (
-    Array.isArray(pattern) &&
-    pattern.length % 2 === 0 &&
-    pattern.every(value => Number.isFinite(value) && value >= 0) &&
-    (pattern.length === 0 || pattern.some(value => value > 0))
-  );
-}
-
-export function normalizeStrokeDashPattern(pattern) {
-  if (typeof pattern === "string") {
-    const resolved = NAMED_DASH_PATTERNS[pattern];
-    if (resolved === undefined) {
-      throw new Error(`Unknown stroke dash style "${pattern}".`);
-    }
-    return cloneAndFreeze(resolved);
-  }
-  if (!isDashPattern(pattern)) {
-    throw new TypeError(
-      "Stroke dash pattern must be a named style or an empty or nonzero even-length array of non-negative finite numbers."
-    );
-  }
-  return cloneAndFreeze(pattern);
-}
-
-export function validateStrokeDashRange(range) {
-  if (range === "auto") return range;
-  if (!Array.isArray(range) || range.length === 0) {
-    throw new TypeError(
-      "StrokeDash range must contain one or more named styles or direct patterns."
-    );
-  }
-  for (const pattern of range) normalizeStrokeDashPattern(pattern);
-  return cloneAndFreeze(range);
-}
-
-export function validateShapeRange(range) {
-  if (range === "auto") return range;
-  if (
-    !Array.isArray(range) ||
-    range.length === 0 ||
-    !range.every(shape => POINT_SHAPES.includes(shape)) ||
-    new Set(range).size !== range.length
-  ) {
-    throw new TypeError(
-      "Shape range must contain unique supported point shapes."
-    );
-  }
-  return cloneAndFreeze(range);
-}
-
-export function validateSizeRange(range) {
-  if (range === "auto") return range;
-  if (
-    !Array.isArray(range) ||
-    range.length !== 2 ||
-    !range.every(value => Number.isFinite(value) && value >= 0) ||
-    range[0] > range[1]
-  ) {
-    throw new TypeError(
-      "Size range must be an ascending pair of non-negative finite areas."
-    );
-  }
-  return cloneAndFreeze(range);
-}
-
-export function validateOpacityRange(range) {
-  if (range === "auto") return range;
-  if (
-    !Array.isArray(range) ||
-    range.length !== 2 ||
-    !range.every(value => Number.isFinite(value) && value >= 0 && value <= 1)
-  ) {
-    throw new TypeError(
-      "Opacity range must contain two finite values from 0 to 1."
-    );
-  }
-  return cloneAndFreeze(range);
-}
-
-export function validateStrokeWidthRange(range) {
-  if (range === "auto") return range;
-  if (
-    !Array.isArray(range) ||
-    range.length !== 2 ||
-    !range.every(value => Number.isFinite(value) && value >= 0) ||
-    range[0] > range[1]
-  ) {
-    throw new TypeError(
-      "StrokeWidth range must be an ascending pair of non-negative finite widths."
-    );
-  }
-  return cloneAndFreeze(range);
-}
-
-export function validateOpacityValue(value, label = "Opacity") {
-  return validateUnitInterval(value, label);
-}
-
-export function validateSemanticScaleRange(range) {
-  if (range === "auto") return range;
-  if (Array.isArray(range) && range.length > 0) return cloneAndFreeze(range);
-  if (isPlainObject(range) && Object.hasOwn(range, "palette")) {
-    normalizePalette(range.palette);
-    return cloneAndFreeze(range);
-  }
-  throw new TypeError("Scale range has an unsupported value.");
-}
-
-export function resolveColorRange(range, domainCount) {
-  const validated = validateColorRange(range);
-  if (validated === "auto") return TABLEAU10;
-  if (Array.isArray(validated)) return validated;
-  return resolvePalette(validated.palette, domainCount);
-}
-
-export function resolveStrokeDashRange(range) {
-  const validated = validateStrokeDashRange(range);
-  return validated === "auto"
-    ? DASH10
-    : cloneAndFreeze(validated.map(normalizeStrokeDashPattern));
-}
-
-export function resolveShapeRange(range) {
-  const validated = validateShapeRange(range);
-  return validated === "auto" ? POINT_SHAPES : validated;
-}
-
-export function resolveSizeRange(range) {
-  const validated = validateSizeRange(range);
-  return validated === "auto" ? DEFAULT_SIZE_RANGE : validated;
-}
-
-export function resolveOpacityRange(range) {
-  const validated = validateOpacityRange(range);
-  return validated === "auto" ? DEFAULT_OPACITY_RANGE : validated;
-}
-
-export function resolveStrokeWidthRange(range) {
-  const validated = validateStrokeWidthRange(range);
-  return validated === "auto" ? DEFAULT_STROKE_WIDTH_RANGE : validated;
-}
-
-export function mapOrdinalValues(values, domain, range, options = {}) {
-  const hasUnknown = Object.hasOwn(options, "unknown");
-  const indices = new Map(domain.map((value, index) => [value, index]));
-  return cloneAndFreeze(values.map(value => {
-    const index = indices.get(value);
-    if (index === undefined) {
-      if (hasUnknown) return options.unknown;
-      throw new Error(`Value "${value}" is outside the ordinal domain.`);
-    }
-    return range[index % range.length];
-  }));
-}
-
-export const TABLEAU10 = resolvePalette(
-  { name: "tableau10", count: 10 },
-  10
-);
+import{cloneAndFreeze as r,isPlainObject as s}from"../../core/immutable.js";import{validateUnitInterval as y}from"../../core/validation.js";import{POINT_SHAPES as u}from"../pointShapes.js";import{normalizePalette as c,resolvePalette as l}from"../palettes.js";const m=r([[],[8,4],[3,3],[12,4],[8,3,2,3],[12,3,3,3],[2,2],[10,3,2,3,2,3],[14,4,4,4],[6,2,2,2]]),A=r({solid:[],dashed:[6,4],dotted:[1,3],dashdot:[6,3,1,3]});import{POINT_SHAPES as g}from"../pointShapes.js";const v=r([24,196]),w=r([.2,1]),S=r([1,8]);function x(t){if(t==="auto")return t;if(Array.isArray(t)){if(t.length===0||!t.every(e=>typeof e=="string"&&e.length>0))throw new TypeError("Color range must contain non-empty color strings.");return r(t)}if(!s(t)||Object.keys(t).length!==1||!Object.hasOwn(t,"palette"))throw new Error("Color range must contain only a palette descriptor.");return c(t.palette),r(t)}function E(t){return Array.isArray(t)&&t.length%2===0&&t.every(e=>Number.isFinite(e)&&e>=0)&&(t.length===0||t.some(e=>e>0))}function p(t){if(typeof t=="string"){const e=A[t];if(e===void 0)throw new Error(`Unknown stroke dash style "${t}".`);return r(e)}if(!E(t))throw new TypeError("Stroke dash pattern must be a named style or an empty or nonzero even-length array of non-negative finite numbers.");return r(t)}function R(t){if(t==="auto")return t;if(!Array.isArray(t)||t.length===0)throw new TypeError("StrokeDash range must contain one or more named styles or direct patterns.");for(const e of t)p(e);return r(t)}function O(t){if(t==="auto")return t;if(!Array.isArray(t)||t.length===0||!t.every(e=>u.includes(e)))throw new TypeError("Shape range must contain supported point shapes.");return r(t)}function f(t,e){if(t==="auto")return t;if(!Array.isArray(t)||t.length!==2||!t.every(o=>Number.isFinite(o)&&o>=0)||t[0]>t[1])throw new TypeError(`${e} must be an ascending pair of non-negative finite ${e==="Size range"?"areas":"widths"}.`);return r(t)}function T(t){return f(t,"Size range")}function k(t){if(t==="auto")return t;if(!Array.isArray(t)||t.length!==2||!t.every(e=>Number.isFinite(e)&&e>=0&&e<=1))throw new TypeError("Opacity range must contain two finite values from 0 to 1.");return r(t)}function D(t){return f(t,"StrokeWidth range")}function F(t,e="Opacity"){return y(t,e)}function U(t){if(t==="auto")return t;if(Array.isArray(t)&&t.length>0)return r(t);if(s(t)&&Object.hasOwn(t,"palette"))return c(t.palette),r(t);throw new TypeError("Scale range has an unsupported value.")}function I(t,e){const o=x(t);return o==="auto"?b:Array.isArray(o)?o:l(o.palette,e)}function j(t){const e=R(t);return e==="auto"?m:r(e.map(p))}function C(t){const e=O(t);return e==="auto"?u:e}function H(t){const e=T(t);return e==="auto"?v:e}function L(t){const e=k(t);return e==="auto"?w:e}function W(t){const e=D(t);return e==="auto"?S:e}function $(t,e,o,a={}){const d=Object.hasOwn(a,"unknown"),h=new Map(e.map((n,i)=>[n,i]));return r(t.map(n=>{const i=h.get(n);if(i===void 0){if(d)return a.unknown;throw new Error(`Value "${n}" is outside the ordinal domain.`)}return o[i%o.length]}))}const b=l({name:"tableau10",count:10},10);export{m as DASH10,w as DEFAULT_OPACITY_RANGE,v as DEFAULT_SIZE_RANGE,S as DEFAULT_STROKE_WIDTH_RANGE,A as NAMED_DASH_PATTERNS,g as POINT_SHAPES,b as TABLEAU10,$ as mapOrdinalValues,p as normalizeStrokeDashPattern,I as resolveColorRange,L as resolveOpacityRange,C as resolveShapeRange,H as resolveSizeRange,j as resolveStrokeDashRange,W as resolveStrokeWidthRange,x as validateColorRange,k as validateOpacityRange,F as validateOpacityValue,U as validateSemanticScaleRange,O as validateShapeRange,T as validateSizeRange,R as validateStrokeDashRange,D as validateStrokeWidthRange};