ggaction 0.0.3 → 0.0.4

package/src/grammar/statistics/studentT.js

@@ -0,0 +1,98 @@
+const LANCZOS = Object.freeze([
+  676.5203681218851,
+  -1259.1392167224028,
+  771.3234287776531,
+  -176.6150291621406,
+  12.507343278686905,
+  -0.13857109526572012,
+  9.984369578019572e-6,
+  1.5056327351493116e-7
+]);
+
+function logGamma(value) {
+  if (value < 0.5) {
+    return Math.log(Math.PI) - Math.log(Math.sin(Math.PI * value)) -
+      logGamma(1 - value);
+  }
+  const shifted = value - 1;
+  let sum = 0.9999999999998099;
+  for (const [index, coefficient] of LANCZOS.entries()) {
+    sum += coefficient / (shifted + index + 1);
+  }
+  const base = shifted + LANCZOS.length - 0.5;
+  return 0.5 * Math.log(2 * Math.PI) +
+    (shifted + 0.5) * Math.log(base) - base + Math.log(sum);
+}
+
+function betaContinuedFraction(a, b, value) {
+  const maximumIterations = 200;
+  const epsilon = 3e-14;
+  const floor = 1e-300;
+  const sum = a + b;
+  let c = 1;
+  let d = 1 - sum * value / (a + 1);
+  if (Math.abs(d) < floor) d = floor;
+  d = 1 / d;
+  let result = d;
+
+  for (let iteration = 1; iteration <= maximumIterations; iteration += 1) {
+    const even = 2 * iteration;
+    let coefficient = iteration * (b - iteration) * value /
+      ((a + even - 1) * (a + even));
+    d = 1 + coefficient * d;
+    if (Math.abs(d) < floor) d = floor;
+    c = 1 + coefficient / c;
+    if (Math.abs(c) < floor) c = floor;
+    d = 1 / d;
+    result *= d * c;
+
+    coefficient = -(a + iteration) * (sum + iteration) * value /
+      ((a + even) * (a + even + 1));
+    d = 1 + coefficient * d;
+    if (Math.abs(d) < floor) d = floor;
+    c = 1 + coefficient / c;
+    if (Math.abs(c) < floor) c = floor;
+    d = 1 / d;
+    const delta = d * c;
+    result *= delta;
+    if (Math.abs(delta - 1) <= epsilon) return result;
+  }
+  throw new Error("Student-t calculation did not converge.");
+}
+
+function regularizedIncompleteBeta(value, a, b) {
+  if (value === 0 || value === 1) return value;
+  const factor = Math.exp(
+    logGamma(a + b) - logGamma(a) - logGamma(b) +
+    a * Math.log(value) + b * Math.log1p(-value)
+  );
+  if (value < (a + 1) / (a + b + 2)) {
+    return factor * betaContinuedFraction(a, b, value) / a;
+  }
+  return 1 - factor * betaContinuedFraction(b, a, 1 - value) / b;
+}
+
+function studentTCdf(value, degreesOfFreedom) {
+  if (value === 0) return 0.5;
+  const ratio = degreesOfFreedom /
+    (degreesOfFreedom + value * value);
+  const tail = regularizedIncompleteBeta(
+    ratio,
+    degreesOfFreedom / 2,
+    0.5
+  ) / 2;
+  return value > 0 ? 1 - tail : tail;
+}
+
+export function studentTCriticalValue(level, degreesOfFreedom) {
+  const probability = (1 + level) / 2;
+  let low = 0;
+  let high = 1;
+  while (studentTCdf(high, degreesOfFreedom) < probability) high *= 2;
+  for (let iteration = 0; iteration < 100; iteration += 1) {
+    const midpoint = (low + high) / 2;
+    if (studentTCdf(midpoint, degreesOfFreedom) < probability) low = midpoint;
+    else high = midpoint;
+  }
+  return (low + high) / 2;
+}

package/src/grammar/transforms.js

@@ -4,7 +4,7 @@ import { validateDensityTransform } from "./density.js";
 import { validateFilterTransform } from "./filter.js";
 import { validateIntervalTransform } from "./interval.js";
 import { validateMarkFilterTransform } from "./markFilter.js";
-import { validateRegressionTransform } from "./regression.js";
+import { validateRegressionTransform } from "./regression/index.js";
 
 const TRANSFORM_VALIDATORS = Object.freeze({
   boxOutlier: validateBoxTransform,

package/src/materialization/bars/aggregate.js

@@ -13,7 +13,7 @@ import {
   mapContinuousScaleValues,
   mapOrdinalPositionValues,
   mapSequentialColors
-} from "../../grammar/scales.js";
+} from "../../grammar/scales/index.js";
 import {
   DEFAULT_BAR_FILL,
   DEFAULT_BAR_STROKE,

package/src/materialization/bars/grouped.js

@@ -2,7 +2,7 @@ import { deriveBarAggregates } from "../../grammar/bars/aggregate.js";
 import {
   mapContinuousScaleValues,
   mapOrdinalPositionValues
-} from "../../grammar/scales.js";
+} from "../../grammar/scales/index.js";
 import { sameOrderedValues } from "../../core/validation.js";
 import {
   DEFAULT_BAR_STROKE,

package/src/materialization/bars/histogram.js

@@ -8,7 +8,7 @@ import {
   mapOrdinalValues,
   readNominalField,
   readQuantitativeField
-} from "../../grammar/scales.js";
+} from "../../grammar/scales/index.js";
 import { resolveBarColorLayout } from "../../grammar/bars/policy.js";
 import { layoutSeriesPartition } from "../../grammar/seriesLayout.js";
 import {

package/src/materialization/bars/ranged.js

@@ -1,4 +1,4 @@
-import { mapContinuousScaleValues, mapOrdinalPositionValues, mapOrdinalValues } from "../../grammar/scales.js";
+import { mapContinuousScaleValues, mapOrdinalPositionValues, mapOrdinalValues } from "../../grammar/scales/index.js";
 import { resolveBarWidth } from "../../grammar/bars/geometry.js";
 import { DEFAULT_BAR_FILL, DEFAULT_BAR_STROKE, DEFAULT_BAR_STROKE_WIDTH } from "./resolve.js";
 

package/src/materialization/density.js

@@ -1,4 +1,4 @@
-import { getMarkMaterializationStep } from "./marks.js";
+import { getMarkMaterializationStep } from "./marks/index.js";
 import { requireLayer } from "../selectors/layers.js";
 import { buildMaterializationPlan } from "./planner.js";
 

package/src/materialization/dependencies.js

@@ -3,48 +3,17 @@ import {
   getExistingMarkRematerializationStep,
   getMarkMaterializationStep,
   getSourceDependentMarkSteps
-} from "./marks.js";
+} from "./marks/index.js";
 import { requireLayer } from "../selectors/layers.js";
 import {
   applyMaterializationPlan,
   buildMaterializationPlan
 } from "./planner.js";
+import { hasMaterializedLegend } from "./legends.js";
 import {
-  hasMaterializedLegend,
-  materializedLegendUsesScale
-} from "./legends.js";
-import { POSITION_ENCODING_CHANNELS } from "../core/vocabulary.js";
-
-function usesPositionalScale(program, id) {
-  return program.semanticSpec.layers.some(layer =>
-    POSITION_ENCODING_CHANNELS.some(
-      channel => layer.encoding?.[channel]?.scale === id
-    )
-  );
-}
-
-function usesRadialScale(program, id) {
-  return program.semanticSpec.layers.some(layer =>
-    layer.encoding?.radius?.scale === id
-  );
-}
-
-function needsCanvasScaleRematerialization(program, scale) {
-  return (
-    (scale.range === "auto" ||
-      usesRadialScale(program, scale.id) ||
-      program.semanticSpec.guides.axis?.x?.scale === scale.id ||
-      program.semanticSpec.guides.axis?.y?.scale === scale.id ||
-      program.semanticSpec.guides.axis?.theta?.scale === scale.id ||
-      program.semanticSpec.guides.axis?.radius?.scale === scale.id ||
-      program.semanticSpec.guides.grid?.horizontal?.scale === scale.id ||
-      program.semanticSpec.guides.grid?.vertical?.scale === scale.id ||
-      program.semanticSpec.guides.grid?.theta?.scale === scale.id ||
-      program.semanticSpec.guides.grid?.radial?.scale === scale.id) &&
-    program.resolvedScales[scale.id] !== undefined &&
-    usesPositionalScale(program, scale.id)
-  );
-}
+  needsCanvasScaleRematerialization,
+  planScaleGuideRematerialization
+} from "./scaleGuideDependencies.js";
 
 function hasTitle(program) {
   return (
@@ -96,57 +65,6 @@ export function planCanvasRematerialization(program) {
   return buildMaterializationPlan({ scales, marks, guides, layout });
 }
 
-export function planScaleGuideRematerialization(program, id) {
-  const guides = [];
-  const objects = program.graphicSpec?.objects ?? {};
-  const guideConfigs = program.guideConfigs ?? {};
-  if (
-    objects.xAxisLine &&
-    program.semanticSpec.guides.axis?.x?.scale === id
-  ) {
-    guides.push({ op: "editXAxisLine" });
-  }
-  if (
-    objects.yAxisLine &&
-    program.semanticSpec.guides.axis?.y?.scale === id
-  ) {
-    guides.push({ op: "editYAxisLine" });
-  }
-  for (const channel of ["x", "y"]) {
-    for (const component of ["ticks", "labels", "title"]) {
-      if (guideConfigs.axis?.[channel]?.[component]?.scale === id) {
-        const suffix = component[0].toUpperCase() + component.slice(1);
-        guides.push({ op: `edit${channel.toUpperCase()}Axis${suffix}` });
-      }
-    }
-  }
-  for (const channel of ["theta", "radius"]) {
-    const prefix = channel === "theta" ? "Theta" : "Radial";
-    for (const component of ["line", "ticks", "labels", "title"]) {
-      if (guideConfigs.axis?.[channel]?.[component]?.scale === id) {
-        const suffix = component[0].toUpperCase() + component.slice(1);
-        guides.push({ op: `edit${prefix}Axis${suffix}` });
-      }
-    }
-  }
-  if (guideConfigs.grid?.horizontal?.scale === id) {
-    guides.push({ op: "rematerializeHorizontalGrid" });
-  }
-  if (guideConfigs.grid?.vertical?.scale === id) {
-    guides.push({ op: "rematerializeVerticalGrid" });
-  }
-  if (guideConfigs.grid?.theta?.scale === id) {
-    guides.push({ op: "rematerializeThetaGrid" });
-  }
-  if (guideConfigs.grid?.radial?.scale === id) {
-    guides.push({ op: "rematerializeRadialGrid" });
-  }
-  if (materializedLegendUsesScale(program, id)) {
-    guides.push({ op: "rematerializeLegend" });
-  }
-  return buildMaterializationPlan({ guides });
-}
-
 export function planLayerDataRematerialization(program, id) {
   const layer = requireLayer(program, id);
   const scaleIds = [...new Set(
@@ -187,3 +105,4 @@ export function applyLayerDataRematerialization(program, id) {
 }
 
 export { applyMaterializationPlan } from "./planner.js";
+export { planScaleGuideRematerialization };

package/src/materialization/encodings.js

@@ -2,9 +2,9 @@ import { hasMaterializedLegend } from "./legends.js";
 import { requireLayer } from "../selectors/layers.js";
 import {
   getEncodingMaterializationStages
-} from "./marks.js";
+} from "./marks/index.js";
 import { buildMaterializationPlan } from "./planner.js";
-import { getSourceDependentMarkSteps } from "./marks.js";
+import { getSourceDependentMarkSteps } from "./marks/index.js";
 
 export function planEncodingRematerialization(program, {
   target,

package/src/materialization/facetGuides/index.js

@@ -0,0 +1,2 @@
+export { prepareSharedFacetLegend } from "./preparation.js";
+export { applyFacetGuideComposition } from "./placement.js";

package/src/materialization/facetGuides/legacyCategorical.js

@@ -0,0 +1,125 @@
+import {
+  resolveSharedFacetLegends
+} from "../../grammar/facets/guides.js";
+import { mapOrdinalValues } from "../../grammar/scales/index.js";
+import { DEFAULT_COLORS, DEFAULT_FONT_FAMILY } from "../../theme/defaults.js";
+
+function textItem(text, x, y, options = {}) {
+  return {
+    type: "text",
+    properties: {
+      x,
+      y,
+      text: String(text),
+      fill: options.color ?? DEFAULT_COLORS.strongText,
+      fontSize: options.fontSize ?? 12,
+      fontFamily: options.fontFamily ?? DEFAULT_FONT_FAMILY,
+      fontWeight: options.fontWeight ?? "normal",
+      textAlign: options.textAlign ?? "left",
+      textBaseline: options.textBaseline ?? "middle"
+    }
+  };
+}
+
+function collection(program, id, items) {
+  return program
+    .createGraphics({ id, type: "collection", parent: "canvas" })
+    .editGraphics({ target: id, property: "items", value: items });
+}
+
+export function resolveLegacyCategoricalLegend(program) {
+  const encodings = program.semanticSpec.layers.flatMap(layer =>
+    layer.encoding?.color === undefined
+      ? []
+      : [{ layer, encoding: layer.encoding.color }]
+  );
+  if (encodings.length === 0) return undefined;
+  const fields = new Set(encodings.map(entry => entry.encoding.field));
+  const scales = new Set(encodings.map(entry => entry.encoding.scale));
+  const marks = new Set(encodings.map(entry => entry.layer.mark?.type));
+  if (fields.size !== 1 || scales.size !== 1 || marks.size !== 1) {
+    throw new Error(
+      "Shared facet legend requires one compatible color field, scale, and mark recipe."
+    );
+  }
+  if (encodings.some(entry =>
+    !["nominal", "ordinal"].includes(entry.encoding.fieldType)
+  )) {
+    return undefined;
+  }
+  const firstId = program.compositionSpec.children[0];
+  const scaleId = encodings[0].encoding.scale;
+  const scale = program.children[firstId].resolvedScales[scaleId];
+  if (scale?.type !== "ordinal") return undefined;
+  const config = {
+    kind: "color",
+    target: encodings[0].layer.id,
+    field: encodings[0].encoding.field,
+    scale: scaleId,
+    title: encodings[0].encoding.field
+  };
+  const compatibility = resolveSharedFacetLegends(
+    program.compositionSpec.children.map(id => ({
+      id,
+      guideConfigs: { legend: { color: config } },
+      resolvedScales: program.children[id].resolvedScales
+    }))
+  );
+  return {
+    mode: "legacyCategorical",
+    compatibility,
+    reservation: { gap: 18, width: 132 },
+    legend: {
+      field: config.field,
+      mark: encodings[0].layer.mark.type,
+      domain: scale.domain,
+      colors: mapOrdinalValues(scale.domain, scale.domain, scale.range)
+    }
+  };
+}
+
+export function materializeLegacyCategoricalLegend(program, prepared, layout) {
+  const legend = prepared.legend;
+  const items = [textItem(legend.field, layout.legend.x, layout.legend.y, {
+    fontSize: 12,
+    fontWeight: 700,
+    textBaseline: "top"
+  })];
+  legend.domain.forEach((value, index) => {
+    const y = layout.legend.y + 29 + index * 26;
+    items.push(legend.mark === "point"
+      ? {
+          type: "circle",
+          properties: {
+            x: layout.legend.x + 7,
+            y,
+            radius: 5.5,
+            fill: legend.colors[index],
+            stroke: "#ffffff",
+            strokeWidth: 0.35,
+            opacity: 1
+          }
+        }
+      : {
+          type: "rect",
+          properties: {
+            x: layout.legend.x + 1,
+            y: y - 6,
+            width: 12,
+            height: 12,
+            fill: legend.colors[index],
+            stroke: "#ffffff",
+            strokeWidth: 0.6,
+            opacity: 1
+          }
+        });
+    items.push(textItem(value, layout.legend.x + 22, y, {
+      fontSize: 10.5
+    }));
+  });
+  return collection(
+    program,
+    `${program.compositionSpec.id}-legend`,
+    items
+  );
+}

package/src/materialization/facetGuides/placement.js

@@ -0,0 +1,126 @@
+import { isPlainObject } from "../../core/immutable.js";
+import { planFacetGuideOwnership } from "../../grammar/facets/guides.js";
+import {
+  axisGraphicIds,
+  allLegendGraphicIds
+} from "../guides/resources.js";
+import { attachSnapshotObject } from "../composition.js";
+import { namespaceGraphicId } from "../compositionSnapshot.js";
+import {
+  materializeLegacyCategoricalLegend
+} from "./legacyCategorical.js";
+import { legendKinds, prepareSharedFacetLegend } from "./preparation.js";
+
+function copyLegendConfig(program, source) {
+  let next = program;
+  for (const [kind, config] of Object.entries(source.guideConfigs.legend ?? {})) {
+    next = next._withLegendConfig(kind, config);
+  }
+  return next;
+}
+
+function removeNamespacedGraphics(program, namespace, ids) {
+  let next = program;
+  for (const id of ids) {
+    const target = namespaceGraphicId(namespace, id);
+    if (next.graphicSpec.objects[target] !== undefined) {
+      next = next.editGraphics({ target, remove: true });
+    }
+  }
+  return next;
+}
+
+function gradientAnchor(prepared, plot, layout) {
+  const strips = prepared.source.graphicSpec.objects.colorGradientStrips;
+  if (strips?.items?.[0] === undefined) return undefined;
+  const properties = strips.items[0].properties;
+  const length = prepared.source.guideConfigs.legend.gradient.gradient.length;
+  return {
+    sourceX: properties.x,
+    sourceY: properties.y,
+    targetX: layout.legend.x,
+    targetY: plot.y + (plot.height - length) / 2
+  };
+}
+
+function legendTranslation(prepared, plot, layout) {
+  const gradient = gradientAnchor(prepared, plot, layout);
+  if (gradient !== undefined) {
+    return {
+      x: gradient.targetX - gradient.sourceX,
+      y: gradient.targetY - gradient.sourceY
+    };
+  }
+  const height = prepared.bounds.bottom - prepared.bounds.top;
+  return {
+    x: layout.legend.x - prepared.bounds.left,
+    y: plot.y + Math.max(0, (plot.height - height) / 2) - prepared.bounds.top
+  };
+}
+
+function attachParentLegend(program, prepared, plot, layout) {
+  const translation = legendTranslation(prepared, plot, layout);
+  const canvas = prepared.source.graphicSpec.objects.canvas;
+  const id = `${program.compositionSpec.id}-shared-legend`;
+  let next = copyLegendConfig(program, prepared.source)
+    .createGraphics({ id, type: "canvas", parent: "canvas" });
+  for (const [property, value] of Object.entries({
+    x: translation.x,
+    y: translation.y,
+    width: canvas.properties.width,
+    height: canvas.properties.height,
+    background: "transparent"
+  })) {
+    next = next.editGraphics({ target: id, property, value });
+  }
+  for (const root of prepared.roots) {
+    next = attachSnapshotObject(next, prepared.source.graphicSpec, root, id);
+  }
+  return next;
+}
+
+export function applyFacetGuideComposition(program, { layout, plot } = {}) {
+  if (!isPlainObject(layout) || !Array.isArray(layout.children)) {
+    throw new TypeError("Facet guide composition requires a resolved layout.");
+  }
+  if (!isPlainObject(plot)) {
+    throw new TypeError("Facet guide composition requires resolved plot bounds.");
+  }
+  const prepared = prepareSharedFacetLegend(program);
+  const children = layout.children.map(cell => {
+    const child = program.children[cell.id];
+    return {
+      id: cell.id,
+      axes: Object.keys(child.guideConfigs.axis ?? {})
+        .filter(channel => ["x", "y"].includes(channel)),
+      legendKinds: legendKinds(child)
+    };
+  });
+  const ownership = planFacetGuideOwnership({
+    placements: layout.children,
+    children,
+    axes: program.compositionSpec.facet.guides.axes,
+    legend: program.compositionSpec.facet.guides.legend,
+    ...(prepared === undefined ? {} : { sharedLegends: prepared.compatibility })
+  });
+  let next = program;
+  for (const cell of layout.children) {
+    const namespace = `${program.compositionSpec.id}-${cell.id}`;
+    const childPlan = ownership.children[cell.id];
+    for (const channel of childPlan.removeAxes) {
+      next = removeNamespacedGraphics(next, namespace, axisGraphicIds(channel));
+    }
+    if (childPlan.removeLegends.length > 0) {
+      next = removeNamespacedGraphics(
+        next,
+        namespace,
+        allLegendGraphicIds(childPlan.removeLegends)
+      );
+    }
+  }
+  if (prepared === undefined) return next;
+  if (prepared.mode === "legacyCategorical") {
+    return materializeLegacyCategoricalLegend(next, prepared, layout);
+  }
+  return attachParentLegend(next, prepared, plot, layout);
+}