ggaction 0.0.13 → 0.0.16

package/src/grammar/roundedRect.js

@@ -0,0 +1,180 @@
+import { freezeOwned, isPlainObject } from "../core/immutable.js";
+import {
+  requestedStrokeDetails,
+  STROKE_STYLE_PROPERTIES
+} from "./strokeStyle.js";
+
+export const ROUNDED_RECT_K = 4 * (Math.sqrt(2) - 1) / 3;
+export const RECT_STYLE_PROPERTIES = Object.freeze([
+  "cornerRadius",
+  ...STROKE_STYLE_PROPERTIES
+]);
+
+function requireFinite(value, property) {
+  if (!Number.isFinite(value)) {
+    throw new TypeError(`Rounded rect ${property} must be a finite number.`);
+  }
+  return value;
+}
+
+export function validateCornerRadius(value, label = "Rect style") {
+  if (!Number.isFinite(value)) {
+    throw new TypeError(`${label} cornerRadius must be a finite number.`);
+  }
+  if (value < 0) {
+    throw new RangeError(`${label} cornerRadius must not be negative.`);
+  }
+  return value;
+}
+
+export function requestedRectStyleDetails(request = {}, label = "Rect style") {
+  if (!isPlainObject(request)) {
+    throw new TypeError(`${label} details must be a plain object.`);
+  }
+  return freezeOwned({
+    ...requestedStrokeDetails(request, label),
+    ...(Object.hasOwn(request, "cornerRadius")
+      ? { cornerRadius: validateCornerRadius(request.cornerRadius, label) }
+      : {})
+  });
+}
+
+export function normalizeRectGeometry({ x, y, width, height }) {
+  x = requireFinite(x, "x");
+  y = requireFinite(y, "y");
+  width = requireFinite(width, "width");
+  height = requireFinite(height, "height");
+  if (width < 0) {
+    x += width;
+    width = -width;
+  }
+  if (height < 0) {
+    y += height;
+    height = -height;
+  }
+  return freezeOwned({ x, y, width, height });
+}
+
+export function resolveRoundedRectRadius(width, height, requestedRadius) {
+  requireFinite(width, "width");
+  requireFinite(height, "height");
+  validateCornerRadius(requestedRadius, "Rounded rect");
+  if (width < 0 || height < 0) {
+    throw new RangeError("Rounded rect width and height must not be negative.");
+  }
+  return Math.min(requestedRadius, width / 2, height / 2);
+}
+
+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)) {
+    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;
+  return freezeOwned([
+    { op: "M", x: geometry.x + r, y: geometry.y },
+    { op: "L", x: right - r, 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: "L", x: right, y: bottom - r },
+    {
+      op: "C",
+      x1: right,
+      y1: bottom - r + c,
+      x2: right - r + c,
+      y2: bottom,
+      x: right - r,
+      y: bottom
+    },
+    { op: "L", x: geometry.x + r, 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: "L", x: geometry.x, y: geometry.y + r },
+    {
+      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: "Z" }
+  ].map(command => freezeOwned(command)));
+}
+
+export function materializeRectItem(properties, requestedRadius = 0) {
+  if (!isPlainObject(properties)) {
+    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 appearance = Object.fromEntries(Object.entries(properties).filter(
+    ([key]) => !["x", "y", "width", "height"].includes(key)
+  ));
+  return radius === 0
+    ? freezeOwned({
+        type: "rect",
+        properties: freezeOwned({ ...geometry, ...appearance })
+      })
+    : freezeOwned({
+        type: "path",
+        properties: freezeOwned({
+          commands: roundedRectCommands({ ...geometry, radius }),
+          ...appearance
+        })
+      });
+}
+
+export function readRectItemGeometry(item) {
+  if (!isPlainObject(item) || !isPlainObject(item.properties)) return undefined;
+  if (item.type === "rect") {
+    try {
+      return normalizeRectGeometry(item.properties);
+    } catch {
+      return undefined;
+    }
+  }
+  const commands = item.type === "path" ? item.properties.commands : undefined;
+  if (
+    !Array.isArray(commands) ||
+    commands.length !== 10 ||
+    commands.map(command => command?.op).join("") !== "MLCLCLCLCZ"
+  ) return undefined;
+  const geometry = {
+    x: commands[7].x,
+    y: commands[0].y,
+    width: commands[2].x - commands[7].x,
+    height: commands[4].y - commands[0].y
+  };
+  try {
+    return normalizeRectGeometry(geometry);
+  } catch {
+    return undefined;
+  }
+}

package/src/grammar/rules.js

@@ -11,6 +11,7 @@ const VALUE_CHANNELS = Object.freeze([
   ...ENDPOINT_CHANNELS,
   "xOffset",
   "yOffset",
+  "stroke",
   "strokeDash",
   "strokeWidth",
   "opacity"

package/src/grammar/scales/colorConsumers.js

@@ -2,8 +2,27 @@ import { BAR_GRAINS, resolveBarChannels, resolveBarGrain } from "../bars/policy.
 import { validateAggregate, validateAggregateFieldType } from "../aggregate.js";
 import { isDiscretizedColorScaleType } from "./types.js";
 
-export function validateContinuousColorConsumer(layer, encoding, scale, { inferAggregate = false } = {}) {
+export function validateContinuousColorConsumer(layer, encoding, scale, {
+  inferAggregate = false,
+  channel = "color"
+} = {}) {
   const kind = layer.mark?.type;
+  if (channel === "stroke") {
+    if (!["point", "line", "area", "bar", "rect", "arc", "rule", "tick"].includes(kind)) {
+      throw new Error("Continuous stroke requires a supported graphical mark consumer.");
+    }
+    if (!['quantitative', 'temporal'].includes(encoding.fieldType) ||
+      (isDiscretizedColorScaleType(scale.type) && encoding.fieldType !== "quantitative")) {
+      throw new Error(`Scale type "${scale.type}" has an incompatible stroke field type.`);
+    }
+    if (encoding.aggregate !== undefined) {
+      throw new Error("Continuous stroke does not support aggregate.");
+    }
+    if (Object.hasOwn(scale, "unknown") && kind !== "point") {
+      throw new Error("Continuous stroke scale unknown currently requires a row-owned point mark.");
+    }
+    return undefined;
+  }
   if (!["point", "bar", "rect"].includes(kind)) {
     throw new Error("Continuous color requires a Point, aggregate Bar, or Rect consumer.");
   }

package/src/grammar/scales/continuous.js

@@ -94,10 +94,10 @@ export function resolveContinuousDomain({ domain, values, type, nice, zero }) {
   return resolved;
 }
 
-export function resolveScaleRange(range, channel, bounds) {
+export function resolveScaleRange(range, channel, bounds, polarFrame) {
   validatePositionChannel(channel);
   if (POLAR_POSITION_CHANNELS.includes(channel)) {
-    return resolvePolarScaleRange(range, channel, bounds);
+    return resolvePolarScaleRange(range, channel, bounds, polarFrame);
   }
   const validated = validateScaleRange(range);
   if (validated !== "auto") return validated;

package/src/grammar/scales/definition.js

@@ -24,13 +24,35 @@ function retainedValue(previous, patch, defaults, property, typeChanged) {
 }
 
 function validateBandParameters(definition, previous, patch, defaults, typeChanged) {
+  const hasPadding = Object.hasOwn(patch, "padding");
+  if (
+    hasPadding &&
+    (Object.hasOwn(patch, "paddingInner") || Object.hasOwn(patch, "paddingOuter"))
+  ) {
+    throw new Error(
+      "Scale padding cannot be combined with paddingInner or paddingOuter."
+    );
+  }
+  if (
+    hasPadding &&
+    (!Number.isFinite(patch.padding) || patch.padding < 0 || patch.padding >= 1)
+  ) {
+    throw new RangeError(
+      "Scale padding must be from 0 (inclusive) to 1 (exclusive)."
+    );
+  }
+  const normalizedPatch = hasPadding
+    ? { ...patch, paddingInner: patch.padding, paddingOuter: patch.padding }
+    : patch;
   const paddingInner = retainedValue(
-    previous, patch, defaults, "paddingInner", typeChanged
+    previous, normalizedPatch, defaults, "paddingInner", typeChanged
   ) ?? 0;
   const paddingOuter = retainedValue(
-    previous, patch, defaults, "paddingOuter", typeChanged
+    previous, normalizedPatch, defaults, "paddingOuter", typeChanged
   ) ?? 0;
-  const align = retainedValue(previous, patch, defaults, "align", typeChanged) ?? 0.5;
+  const align = retainedValue(
+    previous, normalizedPatch, defaults, "align", typeChanged
+  ) ?? 0.5;
   if (!Number.isFinite(paddingInner) || paddingInner < 0 || paddingInner >= 1) {
     throw new RangeError(
       "Scale paddingInner must be from 0 (inclusive) to 1 (exclusive)."
@@ -66,6 +88,7 @@ export function normalizeScaleDefinition({
   defaults = {},
   retainCoreOnTypeChange = false,
   retainCompatibleOnTypeChange = false,
+  allowOrdinalBandParameters = false,
   validateDomain,
   validateRange
 }) {
@@ -143,7 +166,7 @@ export function normalizeScaleDefinition({
   );
   if (midpoint !== undefined) definition.midpoint = midpoint;
 
-  if (type === "band") {
+  if (type === "band" || (type === "ordinal" && allowOrdinalBandParameters)) {
     validateBandParameters(definition, previous, patch, defaults, typeChanged);
   } else if (type === "point") {
     validatePointParameters(definition, previous, patch, defaults, typeChanged);

package/src/grammar/scales/index.js

@@ -7,6 +7,7 @@ export * from "./fields.js";
 export * from "./mapping.js";
 export * from "./ordinal.js";
 export * from "./policies.js";
+export * from "./size.js";
 export * from "./transformed.js";
 export * from "./types.js";
 export * from "./validation.js";

package/src/grammar/scales/ordinal.js

@@ -196,6 +196,7 @@ export function resolveOrdinalOffsetScale({
   parentBandwidth,
   paddingInner = 0,
   paddingOuter = 0,
+  align = 0.5,
   channel = "xOffset"
 }) {
   const resolvedDomain = resolveOrdinalDomain(domain, values);
@@ -217,6 +218,9 @@ export function resolveOrdinalOffsetScale({
       "Offset scale paddingOuter must be a non-negative finite number."
     );
   }
+  if (!Number.isFinite(align) || align < 0 || align > 1) {
+    throw new RangeError("Offset scale align must be between 0 and 1.");
+  }
   validateDomainValues(resolvedDomain, values, undefined, "ordinal");
   const denominator = Math.max(
     1,
@@ -231,15 +235,18 @@ export function resolveOrdinalOffsetScale({
   if (!Number.isFinite(bandwidth) || bandwidth <= 0) {
     throw new Error("Offset scale padding must leave a positive bandwidth.");
   }
+  const occupied = step * (resolvedDomain.length - paddingInner);
+  const start = resolvedRange[0] + (resolvedRange[1] - resolvedRange[0] - occupied) * align;
   return cloneAndFreeze({
     type: "ordinal",
     domain: resolvedDomain,
     range: resolvedRange,
     step,
-    start: resolvedRange[0] + step * paddingOuter,
+    start,
     bandwidth,
     paddingInner,
-    paddingOuter
+    paddingOuter,
+    align
   });
 }
 
@@ -296,7 +303,9 @@ export function mapOrdinalOffsetValues(values, scale) {
     return finitePosition(
       direct,
       scale,
-      (scale.paddingOuter + index + (1 - scale.paddingInner) / 2) /
+      (scale.paddingOuter * 2 * scale.align +
+        index +
+        (1 - scale.paddingInner) / 2) /
         denominator
     );
   }));

package/src/grammar/scales/policies.js

@@ -9,9 +9,9 @@ export function validateScaleUnknown(channel, value) {
     }
     return value;
   }
-  if (channel === "color") {
+  if (["color", "stroke"].includes(channel)) {
     if (typeof value !== "string" || value.length === 0) {
-      throw new TypeError("Scale unknown for color must be a non-empty color string.");
+      throw new TypeError(`Scale unknown for ${channel} must be a non-empty color string.`);
     }
     return value;
   }