ggaction 0.0.18 → 0.0.19

package/src/grammar/schemas/graphicBounds.js

@@ -376,7 +376,7 @@ function hasActiveStroke(properties) {
     (properties.strokeWidth ?? 0) > 0;
 }
 
-function primitiveBounds(type, properties = {}, profile) {
+export function resolvePrimitiveGraphicBounds(type, properties = {}, profile) {
   const strokeExtent = hasActiveStroke(properties)
     ? properties.strokeWidth / 2
     : 0;
@@ -469,15 +469,34 @@ function ancestorOffset(graphicSpec, target) {
   }
 }
 
+function intersectVisibleBounds(bounds,clip) {
+  if(bounds===undefined)return undefined;
+  const result={left:Math.max(bounds.left,clip.left),right:Math.min(bounds.right,clip.right),
+    top:Math.max(bounds.top,clip.top),bottom:Math.min(bounds.bottom,clip.bottom)};
+  return result.right<=result.left||result.bottom<=result.top?undefined:result;
+}
+
+function clipAncestorBounds(graphicSpec,id,bounds) {
+  let parent=findGraphicParent(graphicSpec,id);
+  while(parent!==undefined){
+    if(parent.object.type==="canvas"&&findGraphicParent(graphicSpec,parent.id)!==undefined){
+      const [x,y]=ancestorOffset(graphicSpec,parent.id),p=parent.object.properties;
+      bounds=intersectVisibleBounds(bounds,{left:x+(p.x??0),right:x+(p.x??0)+p.width,top:y+(p.y??0),bottom:y+(p.y??0)+p.height});
+    }
+    parent=findGraphicParent(graphicSpec,parent.id);
+  }
+  return bounds;
+}
+
 function objectBounds(graphicSpec, id, object, ancestors, x, y, profile) {
   if (ancestors.has(id)) {
     throw new Error(`Graphic attachment cycle includes "${id}".`);
   }
   ancestors.add(id);
   let result = object.items === undefined
-    ? translateBounds(primitiveBounds(object.type, object.properties, profile), x, y)
+    ? translateBounds(resolvePrimitiveGraphicBounds(object.type, object.properties, profile), x, y)
     : unionBounds(object.items.map(item => translateBounds(
-        primitiveBounds(item.type ?? object.type, item.properties, profile),
+        resolvePrimitiveGraphicBounds(item.type ?? object.type, item.properties, profile),
         x,
         y
       )));
@@ -497,20 +516,25 @@ function objectBounds(graphicSpec, id, object, ancestors, x, y, profile) {
       );
     }
   }
+  if(object.type==="canvas"&&findGraphicParent(graphicSpec,id)!==undefined){
+    result=intersectVisibleBounds(result,{left:childX,right:childX+object.properties.width,
+      top:childY,bottom:childY+object.properties.height});
+  }
   ancestors.delete(id);
   return result;
 }
 
 export function resolveConcreteGraphicBounds(graphicSpec, target, profile) {
   const found = requireGraphic(graphicSpec, target);
-  const [x, y] = ancestorOffset(graphicSpec, target);
-  return requireFiniteBounds(found.kind === "item"
+  const anchor=found.kind==="item"?found.ownerId:found.id;
+  const [x, y] = ancestorOffset(graphicSpec, anchor);
+  return requireFiniteBounds(clipAncestorBounds(graphicSpec,anchor,found.kind === "item"
     ? translateBounds(
-      primitiveBounds(found.object.type ?? found.owner.type, found.object.properties, profile),
+      resolvePrimitiveGraphicBounds(found.object.type ?? found.owner.type, found.object.properties, profile),
       x,
       y
     )
-    : objectBounds(graphicSpec, found.id, found.object, new Set(), x, y, profile));
+    : objectBounds(graphicSpec, found.id, found.object, new Set(), x, y, profile)));
 }
 
 export function unionConcreteGraphicBounds(graphicSpec, targets, profile) {

package/src/grammar/schemas/semanticPath.js

@@ -1,5 +1,6 @@
 import { USER_ID_SOURCE } from "../../core/identifiers.js";
 import {
+  AXIS_RESOURCE_CHANNELS,
   CARTESIAN_POSITION_CHANNELS,
   ENCODING_CHANNELS,
   SCALED_ENCODING_CHANNELS
@@ -65,6 +66,7 @@ const ENTITY_PATHS = Object.freeze({
       "mark.type",
       "mark.missing",
       "mark.orientation",
+      "mark.blend",
       "derivedBindings.regression",
       "layout.mode",
       ...ENCODING_PATHS
@@ -74,7 +76,7 @@ const ENTITY_PATHS = Object.freeze({
     collection: "scales",
     properties: new Set([
       "type", "domain", "range", "emptyDomain", "nice", "zero", "clamp", "reverse",
-      "unknown", "base", "exponent", "constant", "interpolate", "radialMapping", "midpoint",
+      "unknown", "base", "exponent", "constant", "interpolate", "whitePoint", "gamma", "radialMapping", "midpoint",
       "paddingInner", "paddingOuter", "padding", "align"
     ])
   },
@@ -101,6 +103,9 @@ const GUIDE_PATHS = new Set([
   "axis.parallel.coordinate",
   "axis.parallel.scales",
   "axis.parallel.titles",
+  "legend.colorSize.colorScale",
+  "legend.colorSize.sizeScale",
+  "legend.colorSize.title",
   "legend.color.scale",
   "legend.color.title",
   "legend.color.order",
@@ -137,6 +142,7 @@ const GUIDE_REMOVABLE_CONTAINERS = new Set([
   "grid.vertical",
   "grid.theta",
   "grid.radial",
+  "legend.colorSize",
   "legend.color",
   "legend.stroke",
   "legend.size",
@@ -147,6 +153,13 @@ const GUIDE_REMOVABLE_CONTAINERS = new Set([
 
 const TITLE_PATHS = new Set(["text", "subtitle"]);
 
+function isNamedAxisPath(path, container = false) {
+  const match = path.match(new RegExp(container
+    ? `^axis\\.(${USER_ID_SOURCE})$`
+    : `^axis\\.(${USER_ID_SOURCE})\\.(scale|coordinate|title|channel|position)$`));
+  return match !== null && !AXIS_RESOURCE_CHANNELS.includes(match[1]);
+}
+
 function splitPropertyPath(property) {
   return property.split(".");
 }
@@ -201,7 +214,9 @@ export function parseSemanticPath(property, { allowContainer = false } = {}) {
 
     if (
       !GUIDE_PATHS.has(propertyPath) &&
-      !(allowContainer && GUIDE_REMOVABLE_CONTAINERS.has(propertyPath))
+      !isNamedAxisPath(propertyPath) &&
+      !(allowContainer && (GUIDE_REMOVABLE_CONTAINERS.has(propertyPath) ||
+        isNamedAxisPath(propertyPath, true)))
     ) {
       throw new Error(`Unknown semantic property "${property}".`);
     }

package/src/grammar/summary.js

@@ -23,7 +23,7 @@ const TRANSFORM_KEYS = Object.freeze([
 ]);
 const AGGREGATE_KEYS = Object.freeze(["op", "field", "as"]);
 const NOMINAL_OPERATIONS = new Set(["distinct", "valid", "missing"]);
-const MAX_OUTPUT_ROWS = 10_000;
+const MAX_OUTPUT_ROWS = 30_000;
 
 function normalizeGroupBy(value) {
   if (value === undefined) return [];

package/src/grammar/timeUnit.js

@@ -52,6 +52,7 @@ function formatter(timeZone) {
     try {
       value = new Intl.DateTimeFormat("en-US-u-ca-gregory-nu-latn", {
         timeZone,
+        era: "short",
         year: "numeric",
         month: "2-digit",
         day: "2-digit",
@@ -68,7 +69,7 @@ function formatter(timeZone) {
   return CALENDAR_FORMATTERS.get(timeZone);
 }
 
-function validateTimeZone(timeZone) {
+export function validateTimeZone(timeZone) {
   if (typeof timeZone !== "string" || timeZone.length === 0) {
     throw new TypeError("Time-unit timeZone must be a non-empty IANA time-zone name.");
   }
@@ -178,17 +179,18 @@ export function calendarParts(timestamp, timeZone) {
   validateTimeZone(timeZone);
   const parts = Object.fromEntries(formatter(timeZone).formatToParts(timestamp)
     .filter(part => part.type !== "literal")
-    .map(part => [part.type, Number(part.value)]));
+    .map(part => [part.type, part.type === "era" ? part.value : Number(part.value)]));
+  const year = parts.era === "BC" ? 1 - parts.year : parts.year;
   const millisecond = ((timestamp % 1000) + 1000) % 1000;
   return {
-    year: parts.year,
+    year,
     month: parts.month,
     day: parts.day,
     hour: parts.hour,
     minute: parts.minute,
     second: parts.second,
     millisecond,
-    weekday: weekdayFromDate(parts.year, parts.month, parts.day)
+    weekday: weekdayFromDate(year, parts.month, parts.day)
   };
 }
 

package/src/grammar/transformTopology.js

@@ -16,6 +16,7 @@ const TRANSFORM_TOPOLOGY = Object.freeze({
   markFilter: Object.freeze({ provenanceTransparent: true }),
   normalize: Object.freeze({ facetTopology: "statistical" }),
   regression: Object.freeze({ facetTopology: "statistical" }),
+  regressionStatistics: Object.freeze({ facetTopology: "statistical" }),
   sort: Object.freeze({ facetTopology: "statistical" }),
   summary: Object.freeze({ facetTopology: "statistical" }),
   stack: Object.freeze({ facetTopology: "statistical" }),

package/src/grammar/transforms.js

@@ -1,4 +1,5 @@
 import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
+import { validateRegressionStatisticsTransform } from "./regression/statistics.js";
 import { validateBoxTransform } from "./boxPlot.js";
 import { normalizeBinTransform, validateBinTransform } from "./bin.js";
 import {
@@ -203,7 +204,7 @@ function normalizeRegressionEdit(transform, patch) {
       delete base.span;
       delete base.robustIterations;
     }
-    if (method === "loess" || base.method === "loess") {
+    if (["loess", "exp"].includes(method) || ["loess", "exp"].includes(base.method)) {
       for (const key of [
         "confidenceMethod", "level", "confidence", "interval"
       ]) delete base[key];
@@ -446,6 +447,15 @@ const TRANSFORM_POLICIES = Object.freeze({
     normalizeEdit: normalizeRegressionEdit,
     outputRoles: () => ({})
   }),
+  regressionStatistics: Object.freeze({
+    ...findTransformTopology("regressionStatistics"),
+    validate: validateRegressionStatisticsTransform,
+    materializeOp: "materializeRegressionStatisticsData",
+    replayTransform: requestedTransform,
+    editable: true,
+    normalizeEdit: (transform, patch) => validateRegressionStatisticsTransform({ ...transform, ...patch }),
+    outputRoles: () => ({ count: "count", intercept: "intercept", slope: "slope", rSquared: "rSquared" })
+  }),
   sort: Object.freeze({
     ...findTransformTopology("sort"),
     validate: validateSortTransform,