ggaction 0.0.21 → 0.0.22

package/src/grammar/pathSeries.js

@@ -1,109 +1 @@
-import { validateNonEmptyString } from "../core/validation.js";
-import {
-  readNominalField,
-  readQuantitativeField,
-  readScaleField
-} from "./scales/fields.js";
-
-export function normalizeGroupFields(value) {
-  const fields = Array.isArray(value) ? [...value] : [value];
-  for (const field of fields) validateNonEmptyString(field, "Path group field");
-  if (fields.length === 0 || new Set(fields).size !== fields.length) {
-    throw new Error("Path group fields must be non-empty and unique.");
-  }
-  return fields;
-}
-
-export function pathGroupFields(layer) {
-  const group = layer.encoding?.group;
-  if (group !== undefined) {
-    if (group.fieldType !== "nominal") {
-      throw new Error(`Path group on mark "${layer.id}" must be nominal.`);
-    }
-    if (Object.hasOwn(group, "field") && Object.hasOwn(group, "fields")) {
-      throw new Error("Path group requires exactly one of field or fields.");
-    }
-    return normalizeGroupFields(group.fields ?? group.field);
-  }
-  if (layer.mark?.type !== "line") return [];
-  const color = layer.encoding?.color?.field;
-  const dash = layer.encoding?.strokeDash?.field;
-  if (color !== undefined && dash !== undefined && color !== dash) {
-    throw new Error("Line color field must match strokeDash field unless encodeGroup defines the series.");
-  }
-  return color === undefined && dash === undefined ? [] : [color ?? dash];
-}
-
-export function readPathSeriesFields(rows, layer) {
-  const fields = pathGroupFields(layer);
-  for (const field of fields) readNominalField(rows, field);
-  return fields;
-}
-
-function seriesValueIndex(rows, fields, field, channel, encoding = {}) {
-  const quantitative = channel === "strokeWidth" || channel === "opacity";
-  const values = channel === "stroke" || (channel === "color" && encoding.fieldType === "quantitative")
-    ? readScaleField(rows, field, encoding.fieldType ?? "nominal", {
-        temporalUnit: encoding.temporalUnit
-      })
-    : quantitative
-    ? readQuantitativeField(rows, field)
-    : readNominalField(rows, field);
-  const result = new Map();
-  rows.forEach((row, index) => {
-    const key = JSON.stringify(fields.map(field => row[field]));
-    const value = values[index];
-    if (channel === "strokeWidth" && value < 0) {
-      throw new RangeError(`Line strokeWidth field "${field}" cannot contain negative values.`);
-    }
-    if (result.has(key) && result.get(key) !== value) {
-      throw new Error(`Path ${channel} field "${field}" must have one value within each series.`);
-    }
-    result.set(key, value);
-  });
-  return result;
-}
-
-export function derivePathSeriesFieldValues(
-  rows,
-  series,
-  field,
-  channel,
-  encoding
-) {
-  const fields = Object.keys(series[0]?.key ?? {});
-  const values = seriesValueIndex(rows, fields, field, channel, encoding);
-  return series.map(item => values.get(JSON.stringify(Object.values(item.key))));
-}
-
-export function validatePathSeriesAppearance(rows, layer) {
-  if (!["line", "area"].includes(layer.mark?.type) ||
-      layer.encoding?.parallel !== undefined) return;
-  const grouping = readPathSeriesFields(rows, layer);
-  const channels = layer.mark.type === "line"
-    ? ["color", "stroke", "strokeDash", "strokeWidth", "opacity"]
-    : ["color", "stroke"];
-  for (const channel of channels) {
-    const encoding = layer.encoding?.[channel];
-    if (encoding?.field === undefined) continue;
-    const allowed = ["color", "stroke"].includes(channel)
-      ? channel === "color"
-        ? layer.mark.type === "area" ? ["nominal", "ordinal", "quantitative"] : ["nominal", "ordinal"]
-        : ["nominal", "ordinal", "quantitative", "temporal"]
-      : channel === "strokeDash" ? ["nominal"] : ["quantitative"];
-    if (!allowed.includes(encoding.fieldType)) {
-      throw new Error(`Path ${channel} encoding has an unsupported field type.`);
-    }
-    seriesValueIndex(rows, grouping, encoding.field, channel, encoding);
-  }
-  return grouping;
-}
-
-export function readSeriesIdentity(rows, layer) {
-  const group = layer.encoding?.group;
-  const fields = group === undefined ? [] : normalizeGroupFields(group.fields ?? group.field);
-  for (const field of fields) readNominalField(rows, field);
-  const values = rows.map(row => fields.length === 0 ? undefined : fields.length === 1
-    ? row[fields[0]] : JSON.stringify(fields.map(field => row[field])));
-  return { fields, values, domain: [...new Set(values)] };
-}
+import{validateNonEmptyString as S}from"../core/validation.js";import{readCategoricalLineColor as p,validateCategoricalColorConsumer as y}from"./scales/colorConsumers.js";import{readNominalField as f,readQuantitativeField as O,readScaleField as x}from"./scales/fields.js";function m(n){const e=Array.isArray(n)?[...n]:[n];for(const i of e)S(i,"Path group field");if(e.length===0||new Set(e).size!==e.length)throw new Error("Path group fields must be non-empty and unique.");return e}function E(n){const e=n.encoding?.group;if(e!==void 0){if(e.fieldType!=="nominal")throw new Error(`Path group on mark "${n.id}" must be nominal.`);if(Object.hasOwn(e,"field")&&Object.hasOwn(e,"fields"))throw new Error("Path group requires exactly one of field or fields.");return m(e.fields??e.field)}if(n.mark?.type!=="line")return[];const i=["nominal","ordinal"].includes(n.encoding?.color?.fieldType)?n.encoding.color.field:void 0,o=n.encoding?.strokeDash?.field;if(i!==void 0&&o!==void 0&&i!==o)throw new Error("Line color field must match strokeDash field unless encodeGroup defines the series.");return i===void 0&&o===void 0?[]:[i??o]}function h(n){return JSON.stringify(n.map(e=>e===void 0?{}:e))}function g(n,e){const i=n.encoding?.color,o=Array.isArray(e)?e.find(t=>t.id===i?.scale):e?.[i?.scale];return o!==void 0&&y(n,i,o)?o:void 0}function P(n,e,i){const o=E(e),t=g(e,i);for(const r of o)t&&e.encoding?.group===void 0&&r===e.encoding.color.field?p(n,r):f(n,r);return o}function k(n,e,i,o,t={},r){const l=o==="strokeWidth"||o==="opacity",d=o==="color"&&r!==void 0?p(n,i):o==="stroke"||o==="color"&&["quantitative","temporal"].includes(t.fieldType)?x(n,i,t.fieldType??"nominal",{temporalUnit:t.temporalUnit}):l?O(n,i):f(n,i),a=new Map;return n.forEach((c,v)=>{const s=h(e.map(w=>c[w])),u=d[v];if(o==="strokeWidth"&&u<0)throw new RangeError(`Line strokeWidth field "${i}" cannot contain negative values.`);if(a.has(s)&&a.get(s)!==u)throw new Error(`Path ${o} field "${i}" must have one value within each series.`);a.set(s,u)}),a}function F(n,e,i,o,t,r){if(e.length===0)return[];const l=Object.keys(e[0]?.key??{}),d=k(n,l,i,o,t,Object.hasOwn(r??{},"unknown")?r:void 0);return e.map(a=>d.get(h(Object.values(a.key))))}function j(n,e,i,o){if(!["line","area"].includes(e.mark?.type)||e.encoding?.parallel!==void 0)return;const t=o??P(n,e,i);if(o!==void 0)for(const d of t)f(n,d);const r=g(e,i),l=e.mark.type==="line"?["color","stroke","strokeDash","strokeWidth","opacity"]:["color","stroke"];for(const d of l){const a=e.encoding?.[d];if(a?.field===void 0)continue;if(!(["color","stroke"].includes(d)?d==="color"?e.mark.type==="area"?["nominal","ordinal","quantitative"]:["nominal","ordinal","quantitative","temporal"]:["nominal","ordinal","quantitative","temporal"]:d==="strokeDash"?["nominal","ordinal"]:["quantitative"]).includes(a.fieldType))throw new Error(`Path ${d} encoding has an unsupported field type.`);k(n,t,a.field,d,a,d==="color"?r:void 0)}return t}function A(n,e){const i=e.encoding?.group,o=i===void 0?[]:m(i.fields??i.field);for(const r of o)f(n,r);const t=n.map(r=>o.length===0?void 0:o.length===1?r[o[0]]:JSON.stringify(o.map(l=>r[l])));return{fields:o,values:t,domain:[...new Set(t)]}}export{F as derivePathSeriesFieldValues,m as normalizeGroupFields,E as pathGroupFields,h as pathSeriesKey,P as readPathSeriesFields,A as readSeriesIdentity,j as validatePathSeriesAppearance};

package/src/grammar/pointPolygon.js

@@ -0,0 +1,81 @@
+import { cloneAndFreeze, isOwned, isPlainObject } from "../core/immutable.js";
+
+const normalizedShapes = new WeakMap();
+const MAX_VERTICES = 1024;
+const MAX_COORDINATE = 1_000_000;
+
+export function pointPolygonArea(points) {
+  let twiceArea = 0;
+  for (let index = 0; index < points.length; index += 1) {
+    const current = points[index], next = points[(index + 1) % points.length];
+    twiceArea += current.x * next.y - next.x * current.y;
+  }
+  return Math.abs(twiceArea) / 2;
+}
+
+function samePoint(a, b) {
+  return a.x === b.x && a.y === b.y;
+}
+
+function turn(a, b, c) {
+  return (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
+}
+
+function onSegment(a, b, p) {
+  return p.x >= Math.min(a.x, b.x) && p.x <= Math.max(a.x, b.x) &&
+    p.y >= Math.min(a.y, b.y) && p.y <= Math.max(a.y, b.y);
+}
+
+function intersects(a, b, c, d) {
+  const abC = turn(a, b, c), abD = turn(a, b, d);
+  const cdA = turn(c, d, a), cdB = turn(c, d, b);
+  return (Math.sign(abC) * Math.sign(abD) < 0 && Math.sign(cdA) * Math.sign(cdB) < 0) ||
+    (abC === 0 && onSegment(a, b, c)) || (abD === 0 && onSegment(a, b, d)) ||
+    (cdA === 0 && onSegment(c, d, a)) || (cdB === 0 && onSegment(c, d, b));
+}
+
+export function normalizePointPolygon(shape) {
+  if (isOwned(shape) && normalizedShapes.has(shape)) return normalizedShapes.get(shape);
+  if (!isPlainObject(shape) || !Object.hasOwn(shape, "polygon") ||
+      Object.keys(shape).some(key => !["polygon", "normalization"].includes(key)) ||
+      !Array.isArray(shape.polygon) || shape.polygon.length < 3 || shape.polygon.length > MAX_VERTICES + 1) {
+    throw new TypeError("Point polygon requires a polygon array of 3 to 1024 vertices and optional normalization.");
+  }
+  if (Object.hasOwn(shape, "normalization") && !["area", "radius"].includes(shape.normalization)) {
+    throw new Error('Point polygon normalization must be "area" or "radius".');
+  }
+  for (const point of shape.polygon) {
+    if (!isPlainObject(point) || Object.keys(point).length !== 2 ||
+        !Object.hasOwn(point, "x") || !Object.hasOwn(point, "y") ||
+        ![point.x, point.y].every(value => Number.isFinite(value) && Math.abs(value) <= MAX_COORDINATE)) {
+      throw new TypeError("Point polygon vertices require finite x/y coordinates with magnitude at most 1000000.");
+    }
+  }
+  const points = samePoint(shape.polygon[0], shape.polygon.at(-1))
+    ? shape.polygon.slice(0, -1) : shape.polygon;
+  if (points.length < 3 || points.length > MAX_VERTICES) {
+    throw new RangeError("Point polygon requires 3 to 1024 vertices after closing-point normalization.");
+  }
+  const area = pointPolygonArea(points);
+  if (!Number.isFinite(area) || area <= 0) {
+    throw new RangeError("Point polygon must have positive finite area.");
+  }
+  for (let i = 0; i < points.length; i += 1) {
+    const a = points[i], b = points[(i + 1) % points.length], c = points[(i + 2) % points.length];
+    if (samePoint(a, b) || (turn(a, b, c) === 0 &&
+        (b.x - a.x) * (c.x - b.x) + (b.y - a.y) * (c.y - b.y) < 0)) {
+      throw new Error("Point polygon edges must not be empty or backtrack.");
+    }
+    for (let j = i + 1; j < points.length; j += 1) {
+      if (j === i + 1 || (i === 0 && j === points.length - 1)) continue;
+      if (intersects(a, b, points[j], points[(j + 1) % points.length])) {
+        throw new Error("Point polygon must be simple, without crossing or touching nonadjacent edges.");
+      }
+    }
+  }
+  const normalized = cloneAndFreeze({ polygon: points,
+    ...(Object.hasOwn(shape, "normalization") ? { normalization: shape.normalization } : {}) });
+  normalizedShapes.set(normalized, normalized);
+  if (isOwned(shape)) normalizedShapes.set(shape, normalized);
+  return normalized;
+}

package/src/grammar/pointShapes.js

@@ -1,6 +1,7 @@
 import { cloneAndFreeze } from "../core/immutable.js";
 import { buildLinearPathCommands } from "./pathCommands.js";
 import { requestedStrokeDetails } from "./strokeStyle.js";
+import { normalizePointPolygon, pointPolygonArea } from "./pointPolygon.js";
 
 export const POINT_SHAPES = cloneAndFreeze([
   "circle",
@@ -22,6 +23,7 @@ export const POINT_SHAPES = cloneAndFreeze([
 const SHAPE_SET = new Set(POINT_SHAPES);
 
 export function validatePointShape(shape) {
+  if (shape !== null && typeof shape === "object") return normalizePointPolygon(shape);
   if (typeof shape !== "string" || !SHAPE_SET.has(shape)) {
     throw new Error(`Unsupported point shape "${shape}".`);
   }
@@ -35,16 +37,6 @@ export function getPointGraphicType(shape) {
   return "path";
 }
 
-function polygonArea(points) {
-  let twiceArea = 0;
-  for (let index = 0; index < points.length; index += 1) {
-    const current = points[index];
-    const next = points[(index + 1) % points.length];
-    twiceArea += current.x * next.y - next.x * current.y;
-  }
-  return Math.abs(twiceArea) / 2;
-}
-
 function rotate(points, angle) {
   const cosine = Math.cos(angle);
   const sine = Math.sin(angle);
@@ -70,6 +62,7 @@ function alternatingPolygon(count, innerRadius, rotation = -Math.PI / 2) {
 }
 
 function shapePolygon(shape) {
+  if (typeof shape === "object") return shape.polygon;
   const arm = 0.32;
   const plus = [
     { x: -arm, y: -1 }, { x: arm, y: -1 },
@@ -116,12 +109,17 @@ function shapePolygon(shape) {
   }[shape];
 }
 
-function normalizePolygon(points, x, y, area) {
-  const scale = Math.sqrt(area / polygonArea(points));
-  return points.map(point => ({
+function normalizePolygon(points, x, y, area, normalization = "area") {
+  const scale = Math.sqrt(area / (normalization === "radius" ? Math.PI : pointPolygonArea(points)));
+  if (!Number.isFinite(scale)) throw new RangeError("Point polygon normalization exceeds finite geometry.");
+  const normalized = points.map(point => ({
     x: x + point.x * scale,
     y: y + point.y * scale
   }));
+  if (normalized.some(point => !Number.isFinite(point.x) || !Number.isFinite(point.y))) {
+    throw new RangeError("Point polygon normalization exceeds finite geometry.");
+  }
+  return normalized;
 }
 
 function appearance(fill, stroke, strokeWidth, opacity, strokeDetails) {
@@ -192,7 +190,8 @@ export function createPointShapeGraphic({
           rotate(shapePolygon(validated), (angle ?? 0) * Math.PI / 180),
           x,
           y,
-          area
+          area,
+          validated.normalization
         ),
         { close: true }
       ),
@@ -230,7 +229,8 @@ export function resolvePointShapeExtent({
     rotate(shapePolygon(validated), (angle ?? 0) * Math.PI / 180),
     0,
     0,
-    area
+    area,
+    validated.normalization
   );
   return cloneAndFreeze({
     x: Math.max(0, ...points.map(point => Math.abs(point.x))) + strokeExtent,

package/src/grammar/rects.js

@@ -30,5 +30,5 @@ export function resolveRectMode(layer) {
 }
 
 export function rectUsesFields(layer) {
-  return ["x", "y", "x2", "y2", "color"].some(channel => Object.hasOwn(layer.encoding?.[channel] ?? {}, "field"));
+  return ["x", "y", "x2", "y2", "color", "stroke", "opacity", "strokeWidth"].some(channel => Object.hasOwn(layer.encoding?.[channel] ?? {}, "field"));
 }

package/src/grammar/regression/derive.js

@@ -1,195 +1 @@
-import { cloneAndFreeze } from "../../core/immutable.js";
-import {
-  readNominalField,
-  readQuantitativeField
-} from "../scales/index.js";
-import { fitRegressionGroup, predictRegressionAt, linearRegressionStatistics } from "./models.js";
-import { requireFiniteResult } from "../numeric.js";
-import {
-  validateGeneratedItemLimit,
-  validateWorkLimit
-} from "../../core/validation.js";
-import {
-  normalizeRegressionParameters,
-  requireRegressionField
-} from "./parameters.js";
-
-export const REGRESSION_LOWER_FIELD = "__regression_ci_lower";
-export const REGRESSION_UPPER_FIELD = "__regression_ci_upper";
-
-export function deriveRegression(values, {
-  x,
-  y,
-  groupBy,
-  method,
-  degree,
-  span,
-  robustIterations,
-  confidenceMethod,
-  level,
-  confidence,
-  interval,
-  predict,
-  missing
-} = {}) {
-  if (!Array.isArray(values)) {
-    throw new TypeError("Regression values must be an array.");
-  }
-  requireRegressionField(x, "Regression x field");
-  requireRegressionField(y, "Regression y field");
-  if (groupBy !== undefined) {
-    requireRegressionField(groupBy, "Regression groupBy field");
-  }
-  const parameters = normalizeRegressionParameters({
-    method,
-    degree,
-    span,
-    robustIterations,
-    confidenceMethod,
-    level,
-    confidence,
-    interval
-  });
-  let missingRows = 0;
-  const eligibleValues = missing === undefined ? values : values.filter((row, index) => {
-    const xValue = row?.[x];
-    const yValue = row?.[y];
-    if (xValue === null || xValue === undefined || yValue === null || yValue === undefined) {
-      if (missing === "error") throw new TypeError(`Regression x/y pair is missing at row ${index}.`);
-      missingRows += 1;
-      return false;
-    }
-    if (!Number.isFinite(xValue) || !Number.isFinite(yValue)) {
-      throw new TypeError(`Regression x/y fields must contain finite numbers at row ${index}.`);
-    }
-    return true;
-  });
-  readQuantitativeField(eligibleValues, x);
-  readQuantitativeField(eligibleValues, y);
-  if (groupBy !== undefined) readNominalField(eligibleValues, groupBy);
-
-  const groupedRows = new Map();
-  if (groupBy === undefined) {
-    groupedRows.set(undefined, eligibleValues);
-  } else {
-    for (const row of eligibleValues) {
-      const group = row[groupBy];
-      const rows = groupedRows.get(group) ?? [];
-      rows.push(row);
-      groupedRows.set(group, rows);
-    }
-  }
-  const groups = [...groupedRows.keys()];
-  const models = [];
-  const statistics = [];
-  const rows = [];
-  let work = 0;
-
-  for (const group of groups) {
-    const groupRows = groupedRows.get(group);
-    const observedX = [...new Set(groupRows.map(row => row[x]))]
-      .sort((left, right) => left - right);
-    const xValues = predict?.values ?? (predict?.domain === undefined
-      ? observedX
-      : Array.from({ length: predict.steps }, (_, index) => {
-          if (index === 0) return predict.domain[0];
-          if (index === predict.steps - 1) return predict.domain[1];
-          const ratio = index / (predict.steps - 1);
-          return requireFiniteResult(
-            predict.domain[0] * (1 - ratio) + predict.domain[1] * ratio,
-            "Regression prediction grid"
-          );
-        }));
-    validateGeneratedItemLimit(rows.length + xValues.length, "Regression generated row count");
-    if (parameters.method === "polynomial") {
-      const size = parameters.degree + 1;
-      work += groupRows.length * size ** 2 + size ** 3;
-    } else if (parameters.method === "loess") {
-      const observedSet = new Set(observedX);
-      const newPredictions = predict === undefined ? 0 :
-        xValues.filter(value => !observedSet.has(value)).length;
-      work += groupRows.length *
-        (observedX.length * (1 + (parameters.robustIterations ?? 0)) + newPredictions) *
-        Math.ceil(Math.log2(groupRows.length + 1));
-    }
-    validateWorkLimit(work, "Regression computation");
-    const model = fitRegressionGroup(groupRows, {
-      x,
-      y,
-      group,
-      parameters
-    });
-    models.push({ ...(groupBy === undefined ? {} : { group }), ...model, xValues });
-    if (parameters.method === "linear") statistics.push({
-      ...(groupBy === undefined ? {} : { group }),
-      ...linearRegressionStatistics(groupRows, model, { x, y })
-    });
-
-    for (const xValue of xValues) {
-      const prediction = predictRegressionAt(model, xValue, parameters);
-      const fitted = requireFiniteResult(
-        prediction.prediction,
-        `Regression group "${group === undefined ? "all" : String(group)}" prediction`
-      );
-      const lower = parameters.method === "loess" || parameters.interval === false
-        ? undefined
-        : requireFiniteResult(
-            fitted - prediction.margin,
-            `Regression group "${group === undefined ? "all" : String(group)}" lower interval`
-          );
-      const upper = parameters.method === "loess" || parameters.interval === false
-        ? undefined
-        : requireFiniteResult(
-            fitted + prediction.margin,
-            `Regression group "${group === undefined ? "all" : String(group)}" upper interval`
-          );
-      rows.push({
-        ...(groupBy === undefined ? {} : { [groupBy]: group }),
-        [x]: xValue,
-        [y]: fitted,
-        ...(parameters.method === "loess" || parameters.interval === false ? {} : {
-          [REGRESSION_LOWER_FIELD]: lower,
-          [REGRESSION_UPPER_FIELD]: upper
-        })
-      });
-    }
-  }
-
-  return cloneAndFreeze({
-    fields: {
-      x,
-      y,
-      ...(groupBy === undefined ? {} : { group: groupBy }),
-      ...(parameters.method === "loess" || parameters.interval === false ? {} : {
-        lower: REGRESSION_LOWER_FIELD,
-        upper: REGRESSION_UPPER_FIELD
-      })
-    },
-    parameters,
-    groups,
-    models,
-    ...(parameters.method === "linear" ? {
-      fitStatistics: { version: 1, method: "linear", groups: statistics }
-    } : {}),
-    values: rows,
-    ...(missing === undefined ? {} : {
-      report: {
-        version: 1,
-        owner: { kind: "data", id: "pending" },
-        inputs: [],
-        units: [{
-          role: "fit",
-          group: {},
-          inputRows: values.length,
-          usedRows: eligibleValues.length,
-          excludedRows: missingRows,
-          excludedByReason: missingRows === 0 ? {} : { "missing-value": missingRows }
-        }]
-      }
-    })
-  });
-}
-
-export function deriveLinearRegression(values, options = {}) {
-  return deriveRegression(values, { ...options, method: "linear" });
-}
+import{cloneAndFreeze as W,isOwned as M,isPlainObject as q}from"../../core/immutable.js";import{readNominalField as J,readQuantitativeField as P}from"../scales/index.js";import{fitRegressionGroup as K,predictRegressionAt as Q,linearRegressionStatistics as U}from"./models.js";import{requireFiniteResult as _}from"../numeric.js";import{validateGeneratedItemLimit as X,validateWorkLimit as C}from"../../core/validation.js";import{normalizeRegressionParameters as H,requireRegressionField as I}from"./parameters.js";const A="__regression_ci_lower",V="__regression_ci_upper",E=new WeakMap,$=["x","y","groupBy","method","degree","span","robustIterations","confidenceMethod","level","confidence","interval","predict","missing"];function Y(s,n={}){if(!M(s)||!q(n)||$.some(e=>{const b=Object.getOwnPropertyDescriptor(n,e);return b?!Object.hasOwn(b,"value"):e in n}))return j(s,n);const a=$.map(e=>n[e]),i=M(s)&&a.every(e=>e==null||typeof e=="string"||typeof e=="boolean"||typeof e=="number"&&Number.isFinite(e)&&!Object.is(e,-0)),h=i?JSON.stringify(a.map(e=>[typeof e,e])):void 0,R=i?E.get(s)?.get(h):void 0;if(R!==void 0)return R;const w=j(s,n);if(i){E.has(s)||E.set(s,new Map);const e=E.get(s);e.size>=32&&e.delete(e.keys().next().value),e.set(h,w)}return w}function j(s,{x:n,y:a,groupBy:i,method:h,degree:R,span:w,robustIterations:e,confidenceMethod:b,level:x,confidence:z,interval:G,predict:f,missing:O}={}){if(!Array.isArray(s))throw new TypeError("Regression values must be an array.");I(n,"Regression x field"),I(a,"Regression y field"),i!==void 0&&I(i,"Regression groupBy field");const t=H({method:h,degree:R,span:w,robustIterations:e,confidenceMethod:b,level:x,confidence:z,interval:G});let S=0;const m=O===void 0?s:s.filter((r,o)=>{const u=r?.[n],c=r?.[a];if(u==null||c===null||c===void 0){if(O==="error")throw new TypeError(`Regression x/y pair is missing at row ${o}.`);return S+=1,!1}if(!Number.isFinite(u)||!Number.isFinite(c))throw new TypeError(`Regression x/y fields must contain finite numbers at row ${o}.`);return!0});P(m,n),P(m,a),i!==void 0&&J(m,i);const p=new Map;if(i===void 0)p.set(void 0,m);else for(const r of m){const o=r[i],u=p.get(o)??[];u.push(r),p.set(o,u)}const N=[...p.keys()],k=[],L=[],F=[];let y=0;for(const r of N){const o=p.get(r),u=[...new Set(o.map(d=>d[n]))].sort((d,l)=>d-l),c=f?.values??(f?.domain===void 0?u:Array.from({length:f.steps},(d,l)=>{if(l===0)return f.domain[0];if(l===f.steps-1)return f.domain[1];const g=l/(f.steps-1);return _(f.domain[0]*(1-g)+f.domain[1]*g,"Regression prediction grid")}));if(X(F.length+c.length,"Regression generated row count"),t.method==="polynomial"){const d=t.degree+1;y+=o.length*d**2+d**3}else if(t.method==="loess"){const d=new Set(u),l=f===void 0?0:c.filter(g=>!d.has(g)).length;y+=o.length*(u.length*(1+(t.robustIterations??0))+l)*Math.ceil(Math.log2(o.length+1))}C(y,"Regression computation");const v=K(o,{x:n,y:a,group:r,parameters:t});k.push({...i===void 0?{}:{group:r},...v,xValues:c}),t.method==="linear"&&L.push({...i===void 0?{}:{group:r},...U(o,v,{x:n,y:a})});for(const d of c){const l=Q(v,d,t),g=_(l.prediction,`Regression group "${r===void 0?"all":String(r)}" prediction`),D=t.method==="loess"||t.interval===!1?void 0:_(g-l.margin,`Regression group "${r===void 0?"all":String(r)}" lower interval`),T=t.method==="loess"||t.interval===!1?void 0:_(g+l.margin,`Regression group "${r===void 0?"all":String(r)}" upper interval`);F.push({...i===void 0?{}:{[i]:r},[n]:d,[a]:g,...t.method==="loess"||t.interval===!1?{}:{[A]:D,[V]:T}})}}return W({fields:{x:n,y:a,...i===void 0?{}:{group:i},...t.method==="loess"||t.interval===!1?{}:{lower:A,upper:V}},parameters:t,groups:N,models:k,...t.method==="linear"?{fitStatistics:{version:1,method:"linear",groups:L}}:{},values:F,...O===void 0?{}:{report:{version:1,owner:{kind:"data",id:"pending"},inputs:[],units:[{role:"fit",group:{},inputRows:s.length,usedRows:m.length,excludedRows:S,excludedByReason:S===0?{}:{"missing-value":S}}]}}})}function ie(s,n={}){return Y(s,{...n,method:"linear"})}export{A as REGRESSION_LOWER_FIELD,V as REGRESSION_UPPER_FIELD,ie as deriveLinearRegression,Y as deriveRegression};

package/src/grammar/scales/appearance.js

@@ -1 +1 @@
-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};
+import{cloneAndFreeze as r,isPlainObject as s}from"../../core/immutable.js";import{validateUnitInterval as h}from"../../core/validation.js";import{POINT_SHAPES as y,validatePointShape as m}from"../pointShapes.js";import{normalizePalette as u,resolvePalette as p}from"../palettes.js";const A=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]]),w=r({solid:[],dashed:[6,4],dotted:[1,3],dashdot:[6,3,1,3]});import{POINT_SHAPES as M}from"../pointShapes.js";const v=r([24,196]),S=r([.2,1]),x=r([1,8]);function E(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 u(t.palette),r(t)}function R(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 c(t){if(typeof t=="string"){const e=w[t];if(e===void 0)throw new Error(`Unknown stroke dash style "${t}".`);return r(e)}if(!R(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 T(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)c(e);return r(t)}function O(t){if(t==="auto")return t;if(!Array.isArray(t)||t.length===0)throw new TypeError("Shape range must contain supported point shapes.");try{return r(t.map(m))}catch(e){throw new TypeError("Shape range must contain supported point shapes.",{cause:e})}}function l(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 k(t){return l(t,"Size range")}function D(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 P(t){return l(t,"StrokeWidth range")}function U(t,e="Opacity"){return h(t,e)}function I(t){if(t==="auto")return t;if(Array.isArray(t)&&t.length>0)return r(t);if(s(t)&&Object.hasOwn(t,"palette"))return u(t.palette),r(t);throw new TypeError("Scale range has an unsupported value.")}function j(t,e){const o=E(t);return o==="auto"?b:Array.isArray(o)?o:p(o.palette,e)}function C(t){const e=T(t);return e==="auto"?A:r(e.map(c))}function H(t){const e=O(t);return e==="auto"?y:e}function g(t){const e=k(t);return e==="auto"?v:e}function L(t){const e=D(t);return e==="auto"?S:e}function W(t){const e=P(t);return e==="auto"?x:e}function $(t,e,o,a={}){const d=Object.hasOwn(a,"unknown"),f=new Map(e.map((n,i)=>[n,i]));return r(t.map(n=>{const i=f.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=p({name:"tableau10",count:10},10);export{A as DASH10,S as DEFAULT_OPACITY_RANGE,v as DEFAULT_SIZE_RANGE,x as DEFAULT_STROKE_WIDTH_RANGE,w as NAMED_DASH_PATTERNS,M as POINT_SHAPES,b as TABLEAU10,$ as mapOrdinalValues,c as normalizeStrokeDashPattern,j as resolveColorRange,L as resolveOpacityRange,H as resolveShapeRange,g as resolveSizeRange,C as resolveStrokeDashRange,W as resolveStrokeWidthRange,E as validateColorRange,D as validateOpacityRange,U as validateOpacityValue,I as validateSemanticScaleRange,O as validateShapeRange,k as validateSizeRange,T as validateStrokeDashRange,P as validateStrokeWidthRange};

package/src/grammar/scales/color.js

@@ -1 +1 @@
-import{mapTransformedValues as F}from"./transformed.js";import{cloneAndFreeze as p,isPlainObject as j}from"../../core/immutable.js";import{validateGeneratedItemLimit as $}from"../../core/validation.js";import{normalizePalette as k,resolveContinuousPalette as S}from"../palettes.js";import{inverseLerp as C}from"../numeric.js";const B=p(["rgb","hsl","hsl-long","lab","hcl","hcl-long","cubehelix","cubehelix-long"]),D=Object.freeze({black:"#000000",blue:"#0000ff",cyan:"#00ffff",gray:"#808080",green:"#008000",grey:"#808080",magenta:"#ff00ff",navy:"#000080",orange:"#ffa500",purple:"#800080",red:"#ff0000",teal:"#008080",white:"#ffffff",yellow:"#ffff00"});function E(t,e=0,n=1){return Math.max(e,Math.min(n,t))}function d(t){return(t%360+360)%360}function q({h:t,s:e,l:n}){const r=(1-Math.abs(2*n-1))*e,o=d(t)/60,i=r*(1-Math.abs(o%2-1)),[a,u,l]=o<1?[r,i,0]:o<2?[i,r,0]:o<3?[0,r,i]:o<4?[0,i,r]:o<5?[i,0,r]:[r,0,i],s=n-r/2;return{r:a+s,g:u+s,b:l+s}}function w(t){if(typeof t!="string"||t.length===0)throw new TypeError("Continuous color range requires non-empty color strings.");const e=D[t.toLowerCase()]??t.toLowerCase();let n=e.match(/^#([0-9a-f]{3})$/i);if(n)return Object.fromEntries(["r","g","b"].map((r,o)=>[r,Number.parseInt(n[1][o].repeat(2),16)/255]));if(n=e.match(/^#([0-9a-f]{6})$/i),n)return{r:Number.parseInt(n[1].slice(0,2),16)/255,g:Number.parseInt(n[1].slice(2,4),16)/255,b:Number.parseInt(n[1].slice(4,6),16)/255};if(n=e.match(/^rgb\(\s*([\d.]+)%?\s*,\s*([\d.]+)%?\s*,\s*([\d.]+)%?\s*\)$/),n){const o=e.includes("%")?100:255,i=n.slice(1).map(a=>Number(a)/o);if(i.every(a=>Number.isFinite(a)&&a>=0&&a<=1))return{r:i[0],g:i[1],b:i[2]}}if(n=e.match(/^hsl\(\s*([-\d.]+)\s*,\s*([\d.]+)%\s*,\s*([\d.]+)%\s*\)$/),n){const r=Number(n[1]),o=Number(n[2])/100,i=Number(n[3])/100;if([r,o,i].every(Number.isFinite)&&o>=0&&o<=1&&i>=0&&i<=1)return q({h:r,s:o,l:i})}throw new Error(`Unsupported continuous color "${t}".`)}function N({r:t,g:e,b:n}){return`#${[t,e,n].map(r=>Math.round(E(r)*255).toString(16).padStart(2,"0")).join("")}`}function T({r:t,g:e,b:n}){return[t,e,n].map(r=>Math.round(r*255))}function A({r:t,g:e,b:n}){const r=Math.max(t,e,n),o=Math.min(t,e,n),i=r-o,a=(r+o)/2;if(i===0)return{h:0,s:0,l:a};const u=i/(1-Math.abs(2*a-1)),l=r===t?(e-n)/i%6:r===e?(n-t)/i+2:(t-e)/i+4;return{h:d(l*60),s:u,l:a}}function x(t){return t<=.04045?t/12.92:((t+.055)/1.055)**2.4}function m(t){return t<=.0031308?12.92*t:1.055*t**(1/2.4)-.055}function y(t,e="d65"){const n=x(t.r),r=x(t.g),o=x(t.b),i=e==="d50"?(.4360747*n+.3850649*r+.1430804*o)/.96422:(.4124564*n+.3575761*r+.1804375*o)/.95047,a=e==="d50"?.2225045*n+.7168786*r+.0606169*o:.2126729*n+.7151522*r+.072175*o,u=e==="d50"?(.0139322*n+.0971045*r+.7141733*o)/.82521:(.0193339*n+.119192*r+.9503041*o)/1.08883,l=b=>b>216/24389?Math.cbrt(b):841/108*b+4/29,s=l(i),c=l(a),f=l(u);return{l:116*c-16,a:500*(s-c),b:200*(c-f)}}function O({l:t,a:e,b:n},r="d65"){const o=(t+16)/116,i=o+e/500,a=o-n/200,u=f=>f**3>216/24389?f**3:108/841*(f-4/29),l=(r==="d50"?.96422:.95047)*u(i),s=u(o),c=(r==="d50"?.82521:1.08883)*u(a);return r==="d50"?{r:m(3.1338561*l-1.6168667*s-.4906146*c),g:m(-.9787684*l+1.9161415*s+.033454*c),b:m(.0719453*l-.2289914*s+1.4052427*c)}:{r:m(3.2404542*l-1.5371385*s-.4985314*c),g:m(-.969266*l+1.8760108*s+.041556*c),b:m(.0556434*l-.2040259*s+1.0572252*c)}}function I({l:t,a:e,b:n}){return{h:d(Math.atan2(n,e)*180/Math.PI),c:Math.hypot(e,n),l:t}}function H({h:t,c:e,l:n}){const r=t*Math.PI/180;return{l:n,a:Math.cos(r)*e,b:Math.sin(r)*e}}function R({r:t,g:e,b:n}){const l=-1.7884503806,s=1.97294*1.78277,c=1.78277*-.29227- -.90649*-.14861,f=(c*n+l*t-s*e)/(c+l-s),b=n-f,h=(1.97294*(e-f)- -.29227*b)/-.90649,g=1.97294*f*(1-f);return{h:d(Math.atan2(h,b)*180/Math.PI-120),s:g===0?0:Math.hypot(h,b)/g,l:f}}function U({h:t,s:e,l:n}){const r=(t+120)*Math.PI/180,o=e*n*(1-n),i=Math.cos(r),a=Math.sin(r);return{r:n+o*(-.14861*i+1.78277*a),g:n+o*(-.29227*i-.90649*a),b:n+o*(1.97294*i)}}function M(t,e,n,r){let o=e-t;return r||(o=(o+540)%360-180),d(t+o*n)}function W(t,e,n,r,o){const i=o.whitePoint??"d65";if(r.startsWith("hsl")){const s=A(t),c=A(e);return q({h:M(s.h,c.h,n,r.endsWith("-long")),s:s.s+(c.s-s.s)*n,l:s.l+(c.l-s.l)*n})}if(r==="lab"){const s=y(t,i),c=y(e,i);return O({l:s.l+(c.l-s.l)*n,a:s.a+(c.a-s.a)*n,b:s.b+(c.b-s.b)*n},i)}if(r.startsWith("hcl")){const s=I(y(t,i)),c=I(y(e,i));return O(H({h:M(s.h,c.h,n,r.endsWith("-long")),c:s.c+(c.c-s.c)*n,l:s.l+(c.l-s.l)*n}),i)}const a=R(t),u=R(e),l=n**(o.gamma??1);if(!Number.isFinite(l))throw new RangeError("Continuous cubehelix gamma produced a nonfinite interpolation.");return U({h:M(a.h,u.h,n,r.endsWith("-long")),s:a.s+(u.s-a.s)*n,l:a.l+(u.l-a.l)*l})}function P(t){if(!B.includes(t))throw new Error(`Unsupported continuous color interpolation "${t}".`);return t}function _(t,e={}){const n={};if(e.whitePoint!==void 0){if(!["lab","hcl","hcl-long"].includes(t))throw new Error("Scale whitePoint requires Lab or HCL interpolation.");if(!["d65","d50"].includes(e.whitePoint))throw new Error("Scale whitePoint must be d65 or d50.");n.whitePoint=e.whitePoint}if(e.gamma!==void 0){if(!["cubehelix","cubehelix-long"].includes(t))throw new Error("Scale gamma requires cubehelix interpolation.");if(!Number.isFinite(e.gamma)||e.gamma<=0)throw new RangeError("Scale gamma must be a positive finite number.");n.gamma=e.gamma}return n}function G(t){if(t==="auto")return t;if(Array.isArray(t)){if($(t.length,"Sequential color range length"),t.length<2)throw new TypeError("Sequential color range requires at least two colors.");return t.forEach(w),p(t)}if(!j(t)||Object.keys(t).length!==1||!Object.hasOwn(t,"palette"))throw new TypeError("Sequential color range requires colors or a palette descriptor.");const e=k(t.palette);if(e.count!==void 0&&e.count<2)throw new RangeError("Sequential palette count must be an integer of at least 2.");return p({palette:e})}function Z(t){const e=G(t);return e==="auto"?S("viridis"):Array.isArray(e)?p(e.map(n=>N(w(n)))):S(e.palette)}function L(t,e,n,r,o={}){const a=(r?E(e):e)*(t.length-1),u=Math.max(0,Math.min(t.length-2,Math.floor(a))),l=u+1,s=a-u;if(n==="rgb"){const c=T(t[u]),f=T(t[l]);return`#${c.map((b,h)=>Math.round(E(b+(f[h]-b)*s,0,255)).toString(16).padStart(2,"0")).join("")}`}return N(W(t[u],t[l],s,n,o))}function v(t,e,n="rgb"){const r=P(n);if(!Array.isArray(t)||t.length<2)throw new TypeError("Color interpolation requires at least two stops.");const o=t.map(w);return L(o,e,r,!0)}function z(t,e,n="auto"){if(!(t===void 0||t==="auto")){if(e!=="sequential")throw new Error(`Scale type "${e}" does not support midpoint.`);if(!Number.isFinite(t))throw new TypeError("Scale midpoint must be finite or auto.");if(n!=="auto"&&(!Array.isArray(n)||n.length!==2||!n.every(Number.isFinite)||!(t>Math.min(...n)&&t<Math.max(...n))))throw new RangeError("Scale midpoint must lie strictly inside its resolved domain.");return t}}function V(t,e,n,r={}){const{interpolation:o="rgb",clamp:i=!1}=r;if(_(o,r),["log","pow","sqrt","symlog"].includes(r.type)){z(r.midpoint,r.type,e);const h=F(t,e,[0,1],{type:r.type,clamp:i,...r.type==="log"?{base:r.base}:{},...r.type==="pow"?{exponent:r.exponent}:{},...r.type==="symlog"?{constant:r.constant}:{},...Object.hasOwn(r,"unknown")?{unknown:NaN}:{}});return V(h,[0,1],n,{...r,type:"sequential"})}const a=Object.hasOwn(r,"unknown");if(!Array.isArray(e)||e.length!==2||!e.every(Number.isFinite))throw new TypeError("Sequential color domain must contain two finite numbers.");if(!Array.isArray(t)||!a&&!t.every(Number.isFinite))throw new TypeError("Sequential color values must be finite numbers.");if(typeof i!="boolean")throw new TypeError("Sequential color clamp must be a boolean.");const u=z(r.midpoint,"sequential",e),[l,s]=e,c=l===s,f=P(o);if(!Array.isArray(n)||n.length<2)throw new TypeError("Color interpolation requires at least two stops.");const b=n.map(w);return p(t.map(h=>{if(!Number.isFinite(h)){if(a)return r.unknown;throw new TypeError("Sequential color values must be finite numbers.")}const g=u===void 0?c?.5:C(h,l,s):(s>l?h<=u:h>=u)?C(h,l,u)/2:.5+C(h,u,s)/2;return L(b,g,f,i,r)}))}export{B as CONTINUOUS_COLOR_INTERPOLATIONS,v as interpolateColorStops,V as mapSequentialColors,_ as normalizeColorInterpolationOptions,Z as resolveSequentialColorStops,P as validateContinuousColorInterpolation,G as validateSequentialColorRange,z as validateSequentialMidpoint};
+import{mapTransformedValues as z}from"./transformed.js";import{cloneAndFreeze as p,isPlainObject as $}from"../../core/immutable.js";import{validateGeneratedItemLimit as k}from"../../core/validation.js";import{normalizePalette as B,resolveContinuousPalette as S}from"../palettes.js";import{inverseLerp as x}from"../numeric.js";const D=p(["rgb","hsl","hsl-long","lab","hcl","hcl-long","cubehelix","cubehelix-long"]),H=Object.freeze({black:"#000000",blue:"#0000ff",cyan:"#00ffff",gray:"#808080",green:"#008000",grey:"#808080",magenta:"#ff00ff",navy:"#000080",orange:"#ffa500",purple:"#800080",red:"#ff0000",teal:"#008080",white:"#ffffff",yellow:"#ffff00"});function w(t,e=0,n=1){return Math.max(e,Math.min(n,t))}function y(t){return(t%360+360)%360}function q({h:t,s:e,l:n}){const r=(1-Math.abs(2*n-1))*e,o=y(t)/60,i=r*(1-Math.abs(o%2-1)),[s,u,c]=o<1?[r,i,0]:o<2?[i,r,0]:o<3?[0,r,i]:o<4?[0,i,r]:o<5?[i,0,r]:[r,0,i],l=n-r/2;return{r:s+l,g:u+l,b:c+l}}function E(t){if(typeof t!="string"||t.length===0)throw new TypeError("Continuous color range requires non-empty color strings.");const e=H[t.toLowerCase()]??t.toLowerCase();let n=e.match(/^#([0-9a-f]{3})$/i);if(n)return Object.fromEntries(["r","g","b"].map((r,o)=>[r,Number.parseInt(n[1][o].repeat(2),16)/255]));if(n=e.match(/^#([0-9a-f]{6})$/i),n)return{r:Number.parseInt(n[1].slice(0,2),16)/255,g:Number.parseInt(n[1].slice(2,4),16)/255,b:Number.parseInt(n[1].slice(4,6),16)/255};if(n=e.match(/^rgb\(\s*([\d.]+)%?\s*,\s*([\d.]+)%?\s*,\s*([\d.]+)%?\s*\)$/),n){const o=e.includes("%")?100:255,i=n.slice(1).map(s=>Number(s)/o);if(i.every(s=>Number.isFinite(s)&&s>=0&&s<=1))return{r:i[0],g:i[1],b:i[2]}}if(n=e.match(/^hsl\(\s*([-\d.]+)\s*,\s*([\d.]+)%\s*,\s*([\d.]+)%\s*\)$/),n){const r=Number(n[1]),o=Number(n[2])/100,i=Number(n[3])/100;if([r,o,i].every(Number.isFinite)&&o>=0&&o<=1&&i>=0&&i<=1)return q({h:r,s:o,l:i})}throw new Error(`Unsupported continuous color "${t}".`)}function T({r:t,g:e,b:n}){return`#${[t,e,n].map(r=>Math.round(w(r)*255).toString(16).padStart(2,"0")).join("")}`}function O({r:t,g:e,b:n}){return[t,e,n].map(r=>Math.round(r*255))}function A({r:t,g:e,b:n}){const r=Math.max(t,e,n),o=Math.min(t,e,n),i=r-o,s=(r+o)/2;if(i===0)return{h:0,s:0,l:s};const u=i/(1-Math.abs(2*s-1)),c=r===t?(e-n)/i%6:r===e?(n-t)/i+2:(t-e)/i+4;return{h:y(c*60),s:u,l:s}}function N(t){return t<=.04045?t/12.92:((t+.055)/1.055)**2.4}function g(t){return t<=.0031308?12.92*t:1.055*t**(1/2.4)-.055}function C(t,e="d65"){const n=N(t.r),r=N(t.g),o=N(t.b),i=e==="d50"?(.4360747*n+.3850649*r+.1430804*o)/.96422:(.4124564*n+.3575761*r+.1804375*o)/.95047,s=e==="d50"?.2225045*n+.7168786*r+.0606169*o:.2126729*n+.7151522*r+.072175*o,u=e==="d50"?(.0139322*n+.0971045*r+.7141733*o)/.82521:(.0193339*n+.119192*r+.9503041*o)/1.08883,c=m=>m>216/24389?Math.cbrt(m):841/108*m+4/29,l=c(i),f=c(s),h=c(u);return{l:116*f-16,a:500*(l-f),b:200*(f-h)}}function I({l:t,a:e,b:n},r="d65"){const o=(t+16)/116,i=o+e/500,s=o-n/200,u=h=>h**3>216/24389?h**3:108/841*(h-4/29),c=(r==="d50"?.96422:.95047)*u(i),l=u(o),f=(r==="d50"?.82521:1.08883)*u(s);return r==="d50"?{r:g(3.1338561*c-1.6168667*l-.4906146*f),g:g(-.9787684*c+1.9161415*l+.033454*f),b:g(.0719453*c-.2289914*l+1.4052427*f)}:{r:g(3.2404542*c-1.5371385*l-.4985314*f),g:g(-.969266*c+1.8760108*l+.041556*f),b:g(.0556434*c-.2040259*l+1.0572252*f)}}function R({l:t,a:e,b:n},r=!1){return{h:r?void 0:y(Math.atan2(n,e)*180/Math.PI),c:r?0:Math.hypot(e,n),l:t}}function U({h:t,c:e,l:n}){const r=t*Math.PI/180;return{l:n,a:Math.cos(r)*e,b:Math.sin(r)*e}}function j({r:t,g:e,b:n}){const c=-1.7884503806,l=1.97294*1.78277,f=1.78277*-.29227- -.90649*-.14861,h=(f*n+c*t-l*e)/(f+c-l),m=n-h,b=(1.97294*(e-h)- -.29227*m)/-.90649,a=1.97294*h*(1-h);return{h:y(Math.atan2(b,m)*180/Math.PI-120),s:a===0?0:Math.hypot(b,m)/a,l:h}}function W({h:t,s:e,l:n}){const r=(t+120)*Math.PI/180,o=e*n*(1-n),i=Math.cos(r),s=Math.sin(r);return{r:n+o*(-.14861*i+1.78277*s),g:n+o*(-.29227*i-.90649*s),b:n+o*(1.97294*i)}}function M(t,e,n,r){let o=e-t;return r||(o=(o+540)%360-180),y(t+o*n)}function _(t,e,n,r,o){const i=o.whitePoint??"d65";if(r.startsWith("hsl")){const a=A(t),d=A(e);return q({h:M(a.h,d.h,n,r.endsWith("-long")),s:a.s+(d.s-a.s)*n,l:a.l+(d.l-a.l)*n})}if(r==="lab"){const a=C(t,i),d=C(e,i);return I({l:a.l+(d.l-a.l)*n,a:a.a+(d.a-a.a)*n,b:a.b+(d.b-a.b)*n},i)}if(r.startsWith("hcl")){const a=R(C(t,i),t.r===t.g&&t.g===t.b),d=R(C(e,i),e.r===e.g&&e.g===e.b);return I(U({h:a.h===void 0?d.h??0:d.h===void 0?a.h:M(a.h,d.h,n,r.endsWith("-long")),c:a.c+(d.c-a.c)*n,l:a.l+(d.l-a.l)*n}),i)}const s=j(t),u=j(e),c=o.gamma??1,l=n**c,f=c<0&&n===0;if(!Number.isFinite(l)&&!f)throw new RangeError("Continuous cubehelix gamma produced a nonfinite interpolation.");const h=s.s+(u.s-s.s)*n,m=f&&s.l===u.l?s.l:s.l+(u.l-s.l)*l;if(f&&h===0){const a=Number.isNaN(m)?0:w(m);return{r:a,g:a,b:a}}const b=W({h:M(s.h,u.h,n,r.endsWith("-long")),s:h,l:m});if(f)return Object.fromEntries(Object.entries(b).map(([a,d])=>[a,Number.isNaN(d)?0:w(d)]));if(c<0&&!Object.values(b).every(Number.isFinite))throw new RangeError("Continuous cubehelix gamma produced a nonfinite interpolation.");return b}function P(t){if(!D.includes(t))throw new Error(`Unsupported continuous color interpolation "${t}".`);return t}function G(t,e={}){const n={};if(e.whitePoint!==void 0){if(!["lab","hcl","hcl-long"].includes(t))throw new Error("Scale whitePoint requires Lab or HCL interpolation.");if(!["d65","d50"].includes(e.whitePoint))throw new Error("Scale whitePoint must be d65 or d50.");n.whitePoint=e.whitePoint}if(e.gamma!==void 0){if(!["cubehelix","cubehelix-long"].includes(t))throw new Error("Scale gamma requires cubehelix interpolation.");if(!Number.isFinite(e.gamma))throw new RangeError("Scale gamma must be a finite number.");n.gamma=e.gamma}return n}function V(t){if(t==="auto")return t;if(Array.isArray(t)){if(k(t.length,"Sequential color range length"),t.length<2)throw new TypeError("Sequential color range requires at least two colors.");return t.forEach(E),p(t)}if(!$(t)||Object.keys(t).length!==1||!Object.hasOwn(t,"palette"))throw new TypeError("Sequential color range requires colors or a palette descriptor.");const e=B(t.palette);if(e.count!==void 0&&e.count<2)throw new RangeError("Sequential palette count must be an integer of at least 2.");return p({palette:e})}function v(t){const e=V(t);return e==="auto"?S("viridis"):Array.isArray(e)?p(e.map(n=>T(E(n)))):S(e.palette)}function F(t,e,n,r,o={}){const s=(r?w(e):e)*(t.length-1),u=Math.max(0,Math.min(t.length-2,Math.floor(s))),c=u+1,l=s-u;if(n==="rgb"){const f=O(t[u]),h=O(t[c]);return`#${f.map((m,b)=>Math.round(w(m+(h[b]-m)*l,0,255)).toString(16).padStart(2,"0")).join("")}`}return T(_(t[u],t[c],l,n,o))}function tt(t,e,n="rgb"){const r=P(n);if(!Array.isArray(t)||t.length<2)throw new TypeError("Color interpolation requires at least two stops.");const o=t.map(E);return F(o,e,r,!0)}function L(t,e,n="auto"){if(!(t===void 0||t==="auto")){if(e!=="sequential")throw new Error(`Scale type "${e}" does not support midpoint.`);if(!Number.isFinite(t))throw new TypeError("Scale midpoint must be finite or auto.");if(n!=="auto"&&(!Array.isArray(n)||n.length!==2||!n.every(Number.isFinite)||!(t>Math.min(...n)&&t<Math.max(...n))))throw new RangeError("Scale midpoint must lie strictly inside its resolved domain.");return t}}function J(t,e,n,r={}){const{interpolation:o="rgb",clamp:i=!1}=r;if(G(o,r),["log","pow","sqrt","symlog"].includes(r.type)){L(r.midpoint,r.type,e);const b=z(t,e,[0,1],{type:r.type,clamp:i,...r.type==="log"?{base:r.base}:{},...r.type==="pow"?{exponent:r.exponent}:{},...r.type==="symlog"?{constant:r.constant}:{},...Object.hasOwn(r,"unknown")?{unknown:NaN}:{}});return J(b,[0,1],n,{...r,type:"sequential"})}const s=Object.hasOwn(r,"unknown");if(!Array.isArray(e)||e.length!==2||!e.every(Number.isFinite))throw new TypeError("Sequential color domain must contain two finite numbers.");if(!Array.isArray(t)||!s&&!t.every(Number.isFinite))throw new TypeError("Sequential color values must be finite numbers.");if(typeof i!="boolean")throw new TypeError("Sequential color clamp must be a boolean.");const u=L(r.midpoint,"sequential",e),[c,l]=e,f=c===l,h=P(o);if(!Array.isArray(n)||n.length<2)throw new TypeError("Color interpolation requires at least two stops.");const m=n.map(E);return p(t.map(b=>{if(!Number.isFinite(b)){if(s)return r.unknown;throw new TypeError("Sequential color values must be finite numbers.")}const a=u===void 0?f?.5:x(b,c,l):(l>c?b<=u:b>=u)?x(b,c,u)/2:.5+x(b,u,l)/2;return F(m,a,h,i,r)}))}export{D as CONTINUOUS_COLOR_INTERPOLATIONS,tt as interpolateColorStops,J as mapSequentialColors,G as normalizeColorInterpolationOptions,v as resolveSequentialColorStops,P as validateContinuousColorInterpolation,V as validateSequentialColorRange,L as validateSequentialMidpoint};

package/src/grammar/scales/colorConsumers.js

@@ -1,63 +1 @@
-import { BAR_GRAINS, resolveBarChannels, resolveBarGrain } from "../bars/policy.js";
-import { validateAggregate, validateAggregateFieldType } from "../aggregate.js";
-import { isDiscretizedColorScaleType } from "./types.js";
-
-export function validateContinuousColorConsumer(layer, encoding, scale, {
-  inferAggregate = false,
-  channel = "color"
-} = {}) {
-  const kind = layer.mark?.type;
-  if (["log", "pow", "sqrt", "symlog"].includes(scale.type) && encoding.fieldType !== "quantitative") {
-    throw new Error(`Scale type "${scale.type}" requires quantitative color.`);
-  }
-  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", "text", "area"].includes(kind)) {
-    throw new Error("Continuous color requires a Point, aggregate Bar, Rect, Text, or quantitative Area consumer.");
-  }
-  if (!["quantitative", "temporal"].includes(encoding.fieldType) ||
-    (isDiscretizedColorScaleType(scale.type) && encoding.fieldType !== "quantitative")) {
-    throw new Error(`Scale type "${scale.type}" has an incompatible color field type.`);
-  }
-  if (Object.hasOwn(scale, "unknown") && kind !== "point") {
-    throw new Error("Continuous color scale unknown currently requires a row-owned point mark.");
-  }
-  if (kind === "area" && encoding.fieldType !== "quantitative") {
-    throw new Error("Continuous area color requires a quantitative field.");
-  }
-  if (kind !== "bar") {
-    if (encoding.aggregate !== undefined) throw new Error(`${kind} continuous color does not support aggregate.`);
-    return undefined;
-  }
-  if (["nominal", "ordinal"].includes(layer.encoding?.color?.fieldType)) {
-    throw new Error("Continuous bar color cannot replace an existing nominal color layout.");
-  }
-  if (encoding.fieldType !== "quantitative") {
-    throw new Error("Aggregate bar color currently requires a quantitative field.");
-  }
-  if (resolveBarGrain(layer) !== BAR_GRAINS.aggregate) {
-    throw new Error("Continuous bar color requires a complete categorical aggregate bar.");
-  }
-  const measure = layer.encoding?.[resolveBarChannels(layer).measure];
-  const aggregate = encoding.aggregate ?? (inferAggregate && measure?.field === encoding.field ? measure.aggregate : undefined);
-  if (aggregate === undefined) {
-    throw new Error("Continuous bar color requires aggregate when its field differs from the measure field.");
-  }
-  validateAggregate(aggregate);
-  validateAggregateFieldType(aggregate, encoding.fieldType);
-  return aggregate;
-}
+import{isNominalValue as d,readNominalField as s}from"./fields.js";import{BAR_GRAINS as f,resolveBarChannels as p,resolveBarGrain as c}from"../bars/policy.js";import{validateAggregate as w,validateAggregateFieldType as g}from"../aggregate.js";import{isDiscretizedColorScaleType as l}from"./types.js";function m(o,e){if(o.mark?.type!=="tick")return;const{color:r,stroke:t}=o.encoding??{};if(r!==void 0&&t!==void 0||e==="color"&&t!==void 0||e==="stroke"&&r!==void 0)throw new Error("Tick color and stroke cannot coexist; remove the existing encoding before switching channels.");if(r!==void 0&&!["quantitative","temporal"].includes(r.fieldType))throw new Error("Tick color requires a quantitative or temporal field.")}function v(o,e,r,{inferAggregate:t=!1,channel:n="color"}={}){const i=o.mark?.type;if(m(o,n),["log","pow","sqrt","symlog"].includes(r.type)&&e.fieldType!=="quantitative")throw new Error(`Scale type "${r.type}" requires quantitative color.`);if(n==="stroke"){if(!["point","line","area","bar","rect","arc","rule","tick"].includes(i))throw new Error("Continuous stroke requires a supported graphical mark consumer.");if(!["quantitative","temporal"].includes(e.fieldType)||l(r.type)&&e.fieldType!=="quantitative")throw new Error(`Scale type "${r.type}" has an incompatible stroke field type.`);if(e.aggregate!==void 0)throw new Error("Continuous stroke does not support aggregate.");if(Object.hasOwn(r,"unknown")&&i!=="point")throw new Error("Continuous stroke scale unknown currently requires a row-owned point mark.");return}if(!["point","line","bar","rect","text","area","arc","tick"].includes(i))throw new Error("Continuous color requires a Point, Line, aggregate Bar, Rect, Text, Arc, Tick, or quantitative Area consumer.");if(!["quantitative","temporal"].includes(e.fieldType)||l(r.type)&&e.fieldType!=="quantitative")throw new Error(`Scale type "${r.type}" has an incompatible color field type.`);if(Object.hasOwn(r,"unknown")&&i!=="point")throw new Error("Continuous color scale unknown currently requires a row-owned point mark.");if(i==="area"&&e.fieldType!=="quantitative")throw new Error("Continuous area color requires a quantitative field.");if(i!=="bar"){if(e.aggregate!==void 0)throw new Error(`${i} continuous color does not support aggregate.`);return}if(["nominal","ordinal"].includes(o.encoding?.color?.fieldType))throw new Error("Continuous bar color cannot replace an existing nominal color layout.");if(e.fieldType!=="quantitative")throw new Error("Aggregate bar color currently requires a quantitative field.");if(c(o)!==f.aggregate)throw new Error("Continuous bar color requires a complete categorical aggregate bar.");const u=o.encoding?.[p(o).measure],a=e.aggregate??(t&&u?.field===e.field?u.aggregate:void 0);if(a===void 0)throw new Error("Continuous bar color requires aggregate when its field differs from the measure field.");return w(a),g(a,e.fieldType),a}function C(o,e,r,t="color"){if(!Object.hasOwn(r,"unknown")||o.mark?.type==="point")return!1;const n=o.encoding??{};if(t==="strokeDash"){if(!["line","rule"].includes(o.mark?.type)||!["nominal","ordinal"].includes(e.fieldType)||r.type!=="ordinal"||n.parallel!==void 0||n.theta!==void 0||n.radius!==void 0||[n.x,n.y,n.x2,n.y2].some(i=>i?.aggregate!==void 0||i?.bin!==void 0))throw new Error("StrokeDash unknown requires a Cartesian line or rule with categorical ordinal mapping.");return!1}if(o.mark?.type!=="line"||t!=="color"||!["nominal","ordinal"].includes(e.fieldType)||r.type!=="ordinal"||!Array.isArray(r.domain)||r.domain.length===0||n.parallel!==void 0||n.theta!==void 0||n.radius!==void 0||[n.x,n.y].some(i=>i?.aggregate!==void 0||i?.bin!==void 0))throw new Error("Categorical unknown requires a row-owned point or a Cartesian line with explicit ordinal domain.");return!0}function T(o,e){return s([],e),o.map((r,t)=>{const n=r[e];if(n==null||d(n))return n;throw new TypeError(`Field "${e}" must contain a nominal value at row ${t}.`)})}export{T as readCategoricalLineColor,C as validateCategoricalColorConsumer,v as validateContinuousColorConsumer,m as validateTickColorChannels};