ggaction 0.0.16 → 0.0.18

package/src/grammar/scales/color.js

@@ -1,382 +1 @@
-import { cloneAndFreeze, isPlainObject } from "../../core/immutable.js";
-import { validateGeneratedItemLimit } from "../../core/validation.js";
-import {
-  normalizePalette,
-  resolveContinuousPalette
-} from "../palettes.js";
-import { inverseLerp } from "../numeric.js";
-
-export const CONTINUOUS_COLOR_INTERPOLATIONS = cloneAndFreeze([
-  "rgb",
-  "hsl",
-  "hsl-long",
-  "lab",
-  "hcl",
-  "hcl-long",
-  "cubehelix",
-  "cubehelix-long"
-]);
-
-const BASIC_COLORS = 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 clamp(value, minimum = 0, maximum = 1) {
-  return Math.max(minimum, Math.min(maximum, value));
-}
-
-function hue(value) {
-  return ((value % 360) + 360) % 360;
-}
-
-function hslToRgb({ h, s, l }) {
-  const chroma = (1 - Math.abs(2 * l - 1)) * s;
-  const segment = hue(h) / 60;
-  const second = chroma * (1 - Math.abs(segment % 2 - 1));
-  const [red, green, blue] = segment < 1 ? [chroma, second, 0]
-    : segment < 2 ? [second, chroma, 0]
-      : segment < 3 ? [0, chroma, second]
-        : segment < 4 ? [0, second, chroma]
-          : segment < 5 ? [second, 0, chroma]
-            : [chroma, 0, second];
-  const match = l - chroma / 2;
-  return { r: red + match, g: green + match, b: blue + match };
-}
-
-function parseColor(value) {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new TypeError("Continuous color range requires non-empty color strings.");
-  }
-  const normalized = BASIC_COLORS[value.toLowerCase()] ?? value.toLowerCase();
-  let match = normalized.match(/^#([0-9a-f]{3})$/i);
-  if (match) {
-    return Object.fromEntries(["r", "g", "b"].map((channel, index) => [
-      channel,
-      Number.parseInt(match[1][index].repeat(2), 16) / 255
-    ]));
-  }
-  match = normalized.match(/^#([0-9a-f]{6})$/i);
-  if (match) {
-    return {
-      r: Number.parseInt(match[1].slice(0, 2), 16) / 255,
-      g: Number.parseInt(match[1].slice(2, 4), 16) / 255,
-      b: Number.parseInt(match[1].slice(4, 6), 16) / 255
-    };
-  }
-  match = normalized.match(
-    /^rgb\(\s*([\d.]+)%?\s*,\s*([\d.]+)%?\s*,\s*([\d.]+)%?\s*\)$/
-  );
-  if (match) {
-    const percentage = normalized.includes("%");
-    const divisor = percentage ? 100 : 255;
-    const channels = match.slice(1).map(item => Number(item) / divisor);
-    if (channels.every(item => Number.isFinite(item) && item >= 0 && item <= 1)) {
-      return { r: channels[0], g: channels[1], b: channels[2] };
-    }
-  }
-  match = normalized.match(
-    /^hsl\(\s*([-\d.]+)\s*,\s*([\d.]+)%\s*,\s*([\d.]+)%\s*\)$/
-  );
-  if (match) {
-    const h = Number(match[1]);
-    const s = Number(match[2]) / 100;
-    const l = Number(match[3]) / 100;
-    if ([h, s, l].every(Number.isFinite) && s >= 0 && s <= 1 && l >= 0 && l <= 1) {
-      return hslToRgb({ h, s, l });
-    }
-  }
-  throw new Error(`Unsupported continuous color "${value}".`);
-}
-
-function rgbToHex({ r, g, b }) {
-  return `#${[r, g, b].map(channel =>
-    Math.round(clamp(channel) * 255).toString(16).padStart(2, "0")
-  ).join("")}`;
-}
-
-function byteChannels({ r, g, b }) {
-  return [r, g, b].map(channel => Math.round(channel * 255));
-}
-
-function rgbToHsl({ r, g, b }) {
-  const maximum = Math.max(r, g, b);
-  const minimum = Math.min(r, g, b);
-  const delta = maximum - minimum;
-  const l = (maximum + minimum) / 2;
-  if (delta === 0) return { h: 0, s: 0, l };
-  const s = delta / (1 - Math.abs(2 * l - 1));
-  const raw = maximum === r
-    ? ((g - b) / delta) % 6
-    : maximum === g
-      ? (b - r) / delta + 2
-      : (r - g) / delta + 4;
-  return { h: hue(raw * 60), s, l };
-}
-
-function linearRgb(channel) {
-  return channel <= 0.04045
-    ? channel / 12.92
-    : ((channel + 0.055) / 1.055) ** 2.4;
-}
-
-function encodedRgb(channel) {
-  return channel <= 0.0031308
-    ? 12.92 * channel
-    : 1.055 * channel ** (1 / 2.4) - 0.055;
-}
-
-function rgbToLab(color) {
-  const r = linearRgb(color.r);
-  const g = linearRgb(color.g);
-  const b = linearRgb(color.b);
-  const x = (0.4124564 * r + 0.3575761 * g + 0.1804375 * b) / 0.95047;
-  const y = 0.2126729 * r + 0.7151522 * g + 0.072175 * b;
-  const z = (0.0193339 * r + 0.119192 * g + 0.9503041 * b) / 1.08883;
-  const convert = value => value > 216 / 24389
-    ? Math.cbrt(value)
-    : 841 / 108 * value + 4 / 29;
-  const fx = convert(x);
-  const fy = convert(y);
-  const fz = convert(z);
-  return { l: 116 * fy - 16, a: 500 * (fx - fy), b: 200 * (fy - fz) };
-}
-
-function labToRgb({ l, a, b }) {
-  const fy = (l + 16) / 116;
-  const fx = fy + a / 500;
-  const fz = fy - b / 200;
-  const convert = value => value ** 3 > 216 / 24389
-    ? value ** 3
-    : 108 / 841 * (value - 4 / 29);
-  const x = 0.95047 * convert(fx);
-  const y = convert(fy);
-  const z = 1.08883 * convert(fz);
-  return {
-    r: encodedRgb(3.2404542 * x - 1.5371385 * y - 0.4985314 * z),
-    g: encodedRgb(-0.969266 * x + 1.8760108 * y + 0.041556 * z),
-    b: encodedRgb(0.0556434 * x - 0.2040259 * y + 1.0572252 * z)
-  };
-}
-
-function labToHcl({ l, a, b }) {
-  return { h: hue(Math.atan2(b, a) * 180 / Math.PI), c: Math.hypot(a, b), l };
-}
-
-function hclToLab({ h, c, l }) {
-  const radians = h * Math.PI / 180;
-  return { l, a: Math.cos(radians) * c, b: Math.sin(radians) * c };
-}
-
-function rgbToCubehelix({ r, g, b }) {
-  const A = -0.14861;
-  const B = 1.78277;
-  const C = -0.29227;
-  const D = -0.90649;
-  const E = 1.97294;
-  const ED = E * D;
-  const EB = E * B;
-  const BC_DA = B * C - D * A;
-  const l = (BC_DA * b + ED * r - EB * g) / (BC_DA + ED - EB);
-  const blue = b - l;
-  const k = (E * (g - l) - C * blue) / D;
-  const denominator = E * l * (1 - l);
-  return {
-    h: hue(Math.atan2(k, blue) * 180 / Math.PI - 120),
-    s: denominator === 0 ? 0 : Math.hypot(k, blue) / denominator,
-    l
-  };
-}
-
-function cubehelixToRgb({ h, s, l }) {
-  const angle = (h + 120) * Math.PI / 180;
-  const amplitude = s * l * (1 - l);
-  const cosine = Math.cos(angle);
-  const sine = Math.sin(angle);
-  return {
-    r: l + amplitude * (-0.14861 * cosine + 1.78277 * sine),
-    g: l + amplitude * (-0.29227 * cosine - 0.90649 * sine),
-    b: l + amplitude * (1.97294 * cosine)
-  };
-}
-
-function interpolateHue(left, right, amount, long) {
-  let delta = right - left;
-  if (!long) delta = ((delta + 540) % 360) - 180;
-  return hue(left + delta * amount);
-}
-
-function mix(left, right, amount, method) {
-  if (method.startsWith("hsl")) {
-    const a = rgbToHsl(left);
-    const b = rgbToHsl(right);
-    return hslToRgb({
-      h: interpolateHue(a.h, b.h, amount, method.endsWith("-long")),
-      s: a.s + (b.s - a.s) * amount,
-      l: a.l + (b.l - a.l) * amount
-    });
-  }
-  if (method === "lab") {
-    const a = rgbToLab(left);
-    const b = rgbToLab(right);
-    return labToRgb({
-      l: a.l + (b.l - a.l) * amount,
-      a: a.a + (b.a - a.a) * amount,
-      b: a.b + (b.b - a.b) * amount
-    });
-  }
-  if (method.startsWith("hcl")) {
-    const a = labToHcl(rgbToLab(left));
-    const b = labToHcl(rgbToLab(right));
-    return labToRgb(hclToLab({
-      h: interpolateHue(a.h, b.h, amount, method.endsWith("-long")),
-      c: a.c + (b.c - a.c) * amount,
-      l: a.l + (b.l - a.l) * amount
-    }));
-  }
-  const a = rgbToCubehelix(left);
-  const b = rgbToCubehelix(right);
-  return cubehelixToRgb({
-    h: interpolateHue(a.h, b.h, amount, method.endsWith("-long")),
-    s: a.s + (b.s - a.s) * amount,
-    l: a.l + (b.l - a.l) * amount
-  });
-}
-
-export function validateContinuousColorInterpolation(value) {
-  if (!CONTINUOUS_COLOR_INTERPOLATIONS.includes(value)) {
-    throw new Error(`Unsupported continuous color interpolation "${value}".`);
-  }
-  return value;
-}
-
-export function validateSequentialColorRange(value) {
-  if (value === "auto") return value;
-  if (Array.isArray(value)) {
-    validateGeneratedItemLimit(value.length, "Sequential color range length");
-    if (value.length < 2) {
-      throw new TypeError("Sequential color range requires at least two colors.");
-    }
-    value.forEach(parseColor);
-    return cloneAndFreeze(value);
-  }
-  if (
-    !isPlainObject(value) ||
-    Object.keys(value).length !== 1 ||
-    !Object.hasOwn(value, "palette")
-  ) {
-    throw new TypeError("Sequential color range requires colors or a palette descriptor.");
-  }
-  const palette = normalizePalette(value.palette);
-  if (palette.count !== undefined && palette.count < 2) {
-    throw new RangeError(
-      "Sequential palette count must be an integer of at least 2."
-    );
-  }
-  return cloneAndFreeze({ palette });
-}
-
-export function resolveSequentialColorStops(value) {
-  const range = validateSequentialColorRange(value);
-  if (range === "auto") return resolveContinuousPalette("viridis");
-  return Array.isArray(range)
-    ? cloneAndFreeze(range.map(color => rgbToHex(parseColor(color))))
-    : resolveContinuousPalette(range.palette);
-}
-
-function interpolateColors(colors, position, method, shouldClamp) {
-  const bounded = shouldClamp ? clamp(position) : position;
-  const scaled = bounded * (colors.length - 1);
-  const left = Math.max(0, Math.min(colors.length - 2, Math.floor(scaled)));
-  const right = left + 1;
-  const amount = scaled - left;
-  if (method === "rgb") {
-    const leftChannels = byteChannels(colors[left]);
-    const rightChannels = byteChannels(colors[right]);
-    return `#${leftChannels.map((channel, index) =>
-      Math.round(clamp(
-        channel + (rightChannels[index] - channel) * amount,
-        0,
-        255
-      )).toString(16).padStart(2, "0")
-    ).join("")}`;
-  }
-  return rgbToHex(mix(colors[left], colors[right], amount, method));
-}
-
-export function interpolateColorStops(stops, position, interpolation = "rgb") {
-  const method = validateContinuousColorInterpolation(interpolation);
-  if (!Array.isArray(stops) || stops.length < 2) {
-    throw new TypeError("Color interpolation requires at least two stops.");
-  }
-  const colors = stops.map(parseColor);
-  return interpolateColors(colors, position, method, true);
-}
-
-export function validateSequentialMidpoint(value, type, domain = "auto") {
-  if (value === undefined || value === "auto") return undefined;
-  if (type !== "sequential") {
-    throw new Error(`Scale type "${type}" does not support midpoint.`);
-  }
-  if (!Number.isFinite(value)) {
-    throw new TypeError("Scale midpoint must be finite or auto.");
-  }
-  if (domain !== "auto" && (
-    !Array.isArray(domain) || domain.length !== 2 || !domain.every(Number.isFinite) ||
-    !(value > Math.min(...domain) && value < Math.max(...domain))
-  )) {
-    throw new RangeError("Scale midpoint must lie strictly inside its resolved domain.");
-  }
-  return value;
-}
-
-export function mapSequentialColors(
-  values,
-  domain,
-  stops,
-  options = {}
-) {
-  const { interpolation = "rgb", clamp: shouldClamp = false } = options;
-  const hasUnknown = Object.hasOwn(options, "unknown");
-  if (!Array.isArray(domain) || domain.length !== 2 || !domain.every(Number.isFinite)) {
-    throw new TypeError("Sequential color domain must contain two finite numbers.");
-  }
-  if (!Array.isArray(values) || (!hasUnknown && !values.every(Number.isFinite))) {
-    throw new TypeError("Sequential color values must be finite numbers.");
-  }
-  if (typeof shouldClamp !== "boolean") {
-    throw new TypeError("Sequential color clamp must be a boolean.");
-  }
-  const midpoint = validateSequentialMidpoint(options.midpoint, "sequential", domain);
-  const [start, end] = domain;
-  const constant = start === end;
-  const method = validateContinuousColorInterpolation(interpolation);
-  if (!Array.isArray(stops) || stops.length < 2) {
-    throw new TypeError("Color interpolation requires at least two stops.");
-  }
-  const colors = stops.map(parseColor);
-  return cloneAndFreeze(values.map(value => {
-    if (!Number.isFinite(value)) {
-      if (hasUnknown) return options.unknown;
-      throw new TypeError("Sequential color values must be finite numbers.");
-    }
-    const raw = midpoint === undefined
-      ? constant ? 0.5 : inverseLerp(value, start, end)
-      : (end > start ? value <= midpoint : value >= midpoint)
-        ? inverseLerp(value, start, midpoint) / 2
-        : 0.5 + inverseLerp(value, midpoint, end) / 2;
-    return interpolateColors(colors, raw, method, shouldClamp);
-  }));
-}
+import{mapTransformedValues as $}from"./transformed.js";import{cloneAndFreeze as p,isPlainObject as k}from"../../core/immutable.js";import{validateGeneratedItemLimit as F}from"../../core/validation.js";import{normalizePalette as P,resolveContinuousPalette as T}from"../palettes.js";import{inverseLerp as w}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 M(t,r=0,n=1){return Math.max(r,Math.min(n,t))}function m(t){return(t%360+360)%360}function x({h:t,s:r,l:n}){const e=(1-Math.abs(2*n-1))*r,s=m(t)/60,i=e*(1-Math.abs(s%2-1)),[o,c,l]=s<1?[e,i,0]:s<2?[i,e,0]:s<3?[0,e,i]:s<4?[0,i,e]:s<5?[i,0,e]:[e,0,i],a=n-e/2;return{r:o+a,g:c+a,b:l+a}}function y(t){if(typeof t!="string"||t.length===0)throw new TypeError("Continuous color range requires non-empty color strings.");const r=D[t.toLowerCase()]??t.toLowerCase();let n=r.match(/^#([0-9a-f]{3})$/i);if(n)return Object.fromEntries(["r","g","b"].map((e,s)=>[e,Number.parseInt(n[1][s].repeat(2),16)/255]));if(n=r.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=r.match(/^rgb\(\s*([\d.]+)%?\s*,\s*([\d.]+)%?\s*,\s*([\d.]+)%?\s*\)$/),n){const s=r.includes("%")?100:255,i=n.slice(1).map(o=>Number(o)/s);if(i.every(o=>Number.isFinite(o)&&o>=0&&o<=1))return{r:i[0],g:i[1],b:i[2]}}if(n=r.match(/^hsl\(\s*([-\d.]+)\s*,\s*([\d.]+)%\s*,\s*([\d.]+)%\s*\)$/),n){const e=Number(n[1]),s=Number(n[2])/100,i=Number(n[3])/100;if([e,s,i].every(Number.isFinite)&&s>=0&&s<=1&&i>=0&&i<=1)return x({h:e,s,l:i})}throw new Error(`Unsupported continuous color "${t}".`)}function q({r:t,g:r,b:n}){return`#${[t,r,n].map(e=>Math.round(M(e)*255).toString(16).padStart(2,"0")).join("")}`}function N({r:t,g:r,b:n}){return[t,r,n].map(e=>Math.round(e*255))}function A({r:t,g:r,b:n}){const e=Math.max(t,r,n),s=Math.min(t,r,n),i=e-s,o=(e+s)/2;if(i===0)return{h:0,s:0,l:o};const c=i/(1-Math.abs(2*o-1)),l=e===t?(r-n)/i%6:e===r?(n-t)/i+2:(t-r)/i+4;return{h:m(l*60),s:c,l:o}}function C(t){return t<=.04045?t/12.92:((t+.055)/1.055)**2.4}function E(t){return t<=.0031308?12.92*t:1.055*t**(1/2.4)-.055}function d(t){const r=C(t.r),n=C(t.g),e=C(t.b),s=(.4124564*r+.3575761*n+.1804375*e)/.95047,i=.2126729*r+.7151522*n+.072175*e,o=(.0193339*r+.119192*n+.9503041*e)/1.08883,c=u=>u>216/24389?Math.cbrt(u):841/108*u+4/29,l=c(s),a=c(i),f=c(o);return{l:116*a-16,a:500*(l-a),b:200*(a-f)}}function O({l:t,a:r,b:n}){const e=(t+16)/116,s=e+r/500,i=e-n/200,o=f=>f**3>216/24389?f**3:108/841*(f-4/29),c=.95047*o(s),l=o(e),a=1.08883*o(i);return{r:E(3.2404542*c-1.5371385*l-.4985314*a),g:E(-.969266*c+1.8760108*l+.041556*a),b:E(.0556434*c-.2040259*l+1.0572252*a)}}function I({l:t,a:r,b:n}){return{h:m(Math.atan2(n,r)*180/Math.PI),c:Math.hypot(r,n),l:t}}function U({h:t,c:r,l:n}){const e=t*Math.PI/180;return{l:n,a:Math.cos(e)*r,b:Math.sin(e)*r}}function R({r:t,g:r,b:n}){const l=-1.7884503806,a=1.97294*1.78277,f=1.78277*-.29227- -.90649*-.14861,u=(f*n+l*t-a*r)/(f+l-a),b=n-u,h=(1.97294*(r-u)- -.29227*b)/-.90649,g=1.97294*u*(1-u);return{h:m(Math.atan2(h,b)*180/Math.PI-120),s:g===0?0:Math.hypot(h,b)/g,l:u}}function W({h:t,s:r,l:n}){const e=(t+120)*Math.PI/180,s=r*n*(1-n),i=Math.cos(e),o=Math.sin(e);return{r:n+s*(-.14861*i+1.78277*o),g:n+s*(-.29227*i-.90649*o),b:n+s*(1.97294*i)}}function S(t,r,n,e){let s=r-t;return e||(s=(s+540)%360-180),m(t+s*n)}function H(t,r,n,e){if(e.startsWith("hsl")){const o=A(t),c=A(r);return x({h:S(o.h,c.h,n,e.endsWith("-long")),s:o.s+(c.s-o.s)*n,l:o.l+(c.l-o.l)*n})}if(e==="lab"){const o=d(t),c=d(r);return O({l:o.l+(c.l-o.l)*n,a:o.a+(c.a-o.a)*n,b:o.b+(c.b-o.b)*n})}if(e.startsWith("hcl")){const o=I(d(t)),c=I(d(r));return O(U({h:S(o.h,c.h,n,e.endsWith("-long")),c:o.c+(c.c-o.c)*n,l:o.l+(c.l-o.l)*n}))}const s=R(t),i=R(r);return W({h:S(s.h,i.h,n,e.endsWith("-long")),s:s.s+(i.s-s.s)*n,l:s.l+(i.l-s.l)*n})}function j(t){if(!B.includes(t))throw new Error(`Unsupported continuous color interpolation "${t}".`);return t}function _(t){if(t==="auto")return t;if(Array.isArray(t)){if(F(t.length,"Sequential color range length"),t.length<2)throw new TypeError("Sequential color range requires at least two colors.");return t.forEach(y),p(t)}if(!k(t)||Object.keys(t).length!==1||!Object.hasOwn(t,"palette"))throw new TypeError("Sequential color range requires colors or a palette descriptor.");const r=P(t.palette);if(r.count!==void 0&&r.count<2)throw new RangeError("Sequential palette count must be an integer of at least 2.");return p({palette:r})}function Y(t){const r=_(t);return r==="auto"?T("viridis"):Array.isArray(r)?p(r.map(n=>q(y(n)))):T(r.palette)}function z(t,r,n,e){const i=(e?M(r):r)*(t.length-1),o=Math.max(0,Math.min(t.length-2,Math.floor(i))),c=o+1,l=i-o;if(n==="rgb"){const a=N(t[o]),f=N(t[c]);return`#${a.map((u,b)=>Math.round(M(u+(f[b]-u)*l,0,255)).toString(16).padStart(2,"0")).join("")}`}return q(H(t[o],t[c],l,n))}function Z(t,r,n="rgb"){const e=j(n);if(!Array.isArray(t)||t.length<2)throw new TypeError("Color interpolation requires at least two stops.");const s=t.map(y);return z(s,r,e,!0)}function L(t,r,n="auto"){if(!(t===void 0||t==="auto")){if(r!=="sequential")throw new Error(`Scale type "${r}" 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 G(t,r,n,e={}){const{interpolation:s="rgb",clamp:i=!1}=e;if(["log","sqrt","symlog"].includes(e.type)){L(e.midpoint,e.type,r);const h=$(t,r,[0,1],{type:e.type,clamp:i,...e.type==="log"?{base:e.base}:{},...e.type==="symlog"?{constant:e.constant}:{},...Object.hasOwn(e,"unknown")?{unknown:NaN}:{}});return G(h,[0,1],n,{...e,type:"sequential"})}const o=Object.hasOwn(e,"unknown");if(!Array.isArray(r)||r.length!==2||!r.every(Number.isFinite))throw new TypeError("Sequential color domain must contain two finite numbers.");if(!Array.isArray(t)||!o&&!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 c=L(e.midpoint,"sequential",r),[l,a]=r,f=l===a,u=j(s);if(!Array.isArray(n)||n.length<2)throw new TypeError("Color interpolation requires at least two stops.");const b=n.map(y);return p(t.map(h=>{if(!Number.isFinite(h)){if(o)return e.unknown;throw new TypeError("Sequential color values must be finite numbers.")}const g=c===void 0?f?.5:w(h,l,a):(a>l?h<=c:h>=c)?w(h,l,c)/2:.5+w(h,c,a)/2;return z(b,g,u,i)}))}export{B as CONTINUOUS_COLOR_INTERPOLATIONS,Z as interpolateColorStops,G as mapSequentialColors,Y as resolveSequentialColorStops,j as validateContinuousColorInterpolation,_ as validateSequentialColorRange,L as validateSequentialMidpoint};

package/src/grammar/scales/colorConsumers.js

@@ -7,6 +7,9 @@ export function validateContinuousColorConsumer(layer, encoding, scale, {
   channel = "color"
 } = {}) {
   const kind = layer.mark?.type;
+  if (["log", "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.");
@@ -23,8 +26,8 @@ export function validateContinuousColorConsumer(layer, encoding, scale, {
     }
     return undefined;
   }
-  if (!["point", "bar", "rect"].includes(kind)) {
-    throw new Error("Continuous color requires a Point, aggregate Bar, or Rect consumer.");
+  if (!["point", "bar", "rect", "text"].includes(kind)) {
+    throw new Error("Continuous color requires a Point, aggregate Bar, Rect, or Text consumer.");
   }
   if (!["quantitative", "temporal"].includes(encoding.fieldType) ||
     (isDiscretizedColorScaleType(scale.type) && encoding.fieldType !== "quantitative")) {

package/src/grammar/scales/definition.js

@@ -1,190 +1 @@
-import { validateMeasuredRadiusScale } from "./radial.js";
-import { validateContinuousColorInterpolation, validateSequentialMidpoint } from "./color.js";
-import { isTransformedScaleType } from "./mapping.js";
-import {
-  normalizeTransformParameters,
-  validateTransformedDomain
-} from "./transformed.js";
-import {
-  isContinuousColorScaleType,
-  validateScalePropertyForType
-} from "./types.js";
-
-const BOOLEAN_PROPERTIES = Object.freeze([
-  "nice", "zero", "clamp", "reverse"
-]);
-const TYPE_PARAMETERS = Object.freeze(["base", "exponent", "constant"]);
-
-function retainedValue(previous, patch, defaults, property, typeChanged) {
-  if (Object.hasOwn(patch, property)) return patch[property];
-  if (!typeChanged && Object.hasOwn(previous, property)) {
-    return previous[property];
-  }
-  return defaults[property];
-}
-
-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, normalizedPatch, defaults, "paddingInner", typeChanged
-  ) ?? 0;
-  const paddingOuter = retainedValue(
-    previous, normalizedPatch, defaults, "paddingOuter", typeChanged
-  ) ?? 0;
-  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)."
-    );
-  }
-  if (!Number.isFinite(paddingOuter) || paddingOuter < 0) {
-    throw new RangeError("Scale paddingOuter must be non-negative and finite.");
-  }
-  if (!Number.isFinite(align) || align < 0 || align > 1) {
-    throw new RangeError("Scale align must be between 0 and 1.");
-  }
-  Object.assign(definition, { paddingInner, paddingOuter, align });
-}
-
-function validatePointParameters(definition, previous, patch, defaults, typeChanged) {
-  const padding = retainedValue(
-    previous, patch, defaults, "padding", typeChanged
-  ) ?? 0.5;
-  const align = retainedValue(previous, patch, defaults, "align", typeChanged) ?? 0.5;
-  if (!Number.isFinite(padding) || padding < 0) {
-    throw new RangeError("Scale padding must be non-negative and finite.");
-  }
-  if (!Number.isFinite(align) || align < 0 || align > 1) {
-    throw new RangeError("Scale align must be between 0 and 1.");
-  }
-  Object.assign(definition, { padding, align });
-}
-
-export function normalizeScaleDefinition({
-  type,
-  previous = {},
-  patch = {},
-  defaults = {},
-  retainCoreOnTypeChange = false,
-  retainCompatibleOnTypeChange = false,
-  allowOrdinalBandParameters = false,
-  validateDomain,
-  validateRange
-}) {
-  const typeChanged = previous.type !== undefined && previous.type !== type;
-  const rawDomain = Object.hasOwn(patch, "domain")
-    ? patch.domain
-    : (!typeChanged || retainCoreOnTypeChange) && Object.hasOwn(previous, "domain")
-      ? previous.domain
-      : defaults.domain ?? "auto";
-  const rawRange = Object.hasOwn(patch, "range")
-    ? patch.range
-    : (!typeChanged || retainCoreOnTypeChange) && Object.hasOwn(previous, "range")
-      ? previous.range
-      : defaults.range ?? "auto";
-  const definition = {
-    type,
-    domain: validateDomain(type, rawDomain),
-    range: validateRange(type, rawRange)
-  };
-
-  for (const property of BOOLEAN_PROPERTIES) {
-    let value = retainedValue(previous, patch, defaults, property, typeChanged);
-    if (
-      value === undefined &&
-      typeChanged &&
-      retainCompatibleOnTypeChange &&
-      Object.hasOwn(previous, property)
-    ) {
-      try {
-        validateScalePropertyForType(type, property);
-        value = previous[property];
-      } catch {
-        value = undefined;
-      }
-    }
-    if (value === undefined) continue;
-    if (typeof value !== "boolean") {
-      throw new TypeError(`Scale ${property} must be a boolean.`);
-    }
-    validateScalePropertyForType(type, property);
-    definition[property] = value;
-  }
-
-  const requested = Object.fromEntries(TYPE_PARAMETERS.flatMap(property => {
-    const value = retainedValue(previous, patch, defaults, property, typeChanged);
-    return value === undefined ? [] : [[property, value]];
-  }));
-  if (isTransformedScaleType(type)) {
-    const parameters = normalizeTransformParameters(type, requested);
-    if (type === "log") definition.base = parameters.base;
-    if (type === "pow") definition.exponent = parameters.exponent;
-    if (type === "symlog") definition.constant = parameters.constant;
-    if (definition.domain !== "auto") {
-      validateTransformedDomain(type, definition.domain, requested);
-    }
-  } else {
-    for (const property of Object.keys(requested)) {
-      validateScalePropertyForType(type, property);
-    }
-  }
-
-  const interpolate = retainedValue(
-    previous, patch, defaults, "interpolate", typeChanged
-  );
-  if (isContinuousColorScaleType(type)) {
-    definition.interpolate = validateContinuousColorInterpolation(
-      interpolate ?? "rgb"
-    );
-  } else if (interpolate !== undefined) {
-    throw new Error(`Scale type "${type}" does not support interpolate.`);
-  }
-
-  const midpoint = validateSequentialMidpoint(
-    retainedValue(previous, patch, defaults, "midpoint", typeChanged), type, definition.domain
-  );
-  if (midpoint !== undefined) definition.midpoint = midpoint;
-
-  if (type === "band" || (type === "ordinal" && allowOrdinalBandParameters)) {
-    validateBandParameters(definition, previous, patch, defaults, typeChanged);
-  } else if (type === "point") {
-    validatePointParameters(definition, previous, patch, defaults, typeChanged);
-  } else {
-    for (const property of ["paddingInner", "paddingOuter", "padding", "align"]) {
-      if (Object.hasOwn(patch, property)) {
-        validateScalePropertyForType(type, property);
-      }
-    }
-  }
-
-  const radialMapping = Object.hasOwn(patch, "radialMapping") ? patch.radialMapping : previous.radialMapping;
-  if (radialMapping !== undefined) {
-    definition.radialMapping = radialMapping;
-    validateMeasuredRadiusScale({ ...definition,
-      ...(Object.hasOwn(patch, "unknown") || Object.hasOwn(previous, "unknown")
-        ? { unknown: patch.unknown ?? previous.unknown } : {})
-    }, { allowAuto: true });
-  }
-  return definition;
-}
+import{validateMeasuredRadiusScale as I}from"./radial.js";import{validateContinuousColorInterpolation as M,validateSequentialMidpoint as x}from"./color.js";import{isTransformedScaleType as T}from"./mapping.js";import{normalizeTransformParameters as D,validateTransformedDomain as F}from"./transformed.js";import{isContinuousColorScaleType as N,validateScalePropertyForType as O}from"./types.js";const k=Object.freeze(["nice","zero","clamp","reverse"]),z=Object.freeze(["base","exponent","constant"]);function m(i,t,n,e,o){return Object.hasOwn(t,e)?t[e]:!o&&Object.hasOwn(i,e)?i[e]:n[e]}function q(i,t,n,e,o){const l=Object.hasOwn(n,"padding");if(l&&(Object.hasOwn(n,"paddingInner")||Object.hasOwn(n,"paddingOuter")))throw new Error("Scale padding cannot be combined with paddingInner or paddingOuter.");if(l&&(!Number.isFinite(n.padding)||n.padding<0||n.padding>=1))throw new RangeError("Scale padding must be from 0 (inclusive) to 1 (exclusive).");const d=l?{...n,paddingInner:n.padding,paddingOuter:n.padding}:n,g=m(t,d,e,"paddingInner",o)??0,w=m(t,d,e,"paddingOuter",o)??0,c=m(t,d,e,"align",o)??.5;if(!Number.isFinite(g)||g<0||g>=1)throw new RangeError("Scale paddingInner must be from 0 (inclusive) to 1 (exclusive).");if(!Number.isFinite(w)||w<0)throw new RangeError("Scale paddingOuter must be non-negative and finite.");if(!Number.isFinite(c)||c<0||c>1)throw new RangeError("Scale align must be between 0 and 1.");Object.assign(i,{paddingInner:g,paddingOuter:w,align:c})}function A(i,t,n,e,o){const l=m(t,n,e,"padding",o)??.5,d=m(t,n,e,"align",o)??.5;if(!Number.isFinite(l)||l<0)throw new RangeError("Scale padding must be non-negative and finite.");if(!Number.isFinite(d)||d<0||d>1)throw new RangeError("Scale align must be between 0 and 1.");Object.assign(i,{padding:l,align:d})}function V({type:i,color:t=!1,previous:n={},patch:e={},defaults:o={},retainCoreOnTypeChange:l=!1,retainCompatibleOnTypeChange:d=!1,allowOrdinalBandParameters:g=!1,validateDomain:w,validateRange:c}){const s=n.type!==void 0&&n.type!==i,R=Object.hasOwn(e,"domain")?e.domain:(!s||l)&&Object.hasOwn(n,"domain")?n.domain:o.domain??"auto",P=Object.hasOwn(e,"range")?e.range:(!s||l)&&Object.hasOwn(n,"range")?n.range:o.range??"auto",r={type:i,domain:w(i,R),range:c(i,P)},u=m(n,e,o,"emptyDomain",s);if(u!==void 0){if(!["preserve","require-explicit"].includes(u))throw new Error('Scale emptyDomain must be "preserve" or "require-explicit".');r.emptyDomain=u}for(const a of k){let f=m(n,e,o,a,s);if(f===void 0&&s&&d&&Object.hasOwn(n,a))try{O(i,a),f=n[a]}catch{f=void 0}if(f!==void 0){if(typeof f!="boolean")throw new TypeError(`Scale ${a} must be a boolean.`);O(i,a),r[a]=f}}const j=Object.fromEntries(z.flatMap(a=>{const f=m(n,e,o,a,s);return f===void 0?[]:[[a,f]]}));if(T(i)){const a=D(i,j);i==="log"&&(r.base=a.base),i==="pow"&&(r.exponent=a.exponent),i==="symlog"&&(r.constant=a.constant),r.domain!=="auto"&&F(i,r.domain,j)}else for(const a of Object.keys(j))O(i,a);let b=m(n,e,o,"interpolate",s);if(i==="sequential"||t&&N(i))b===void 0&&d&&(b=n.interpolate),r.interpolate=M(b??"rgb");else if(b!==void 0)throw new Error(`Scale type "${i}" does not support interpolate.`);const S=x(m(n,e,o,"midpoint",s),i,r.domain);if(S!==void 0&&(r.midpoint=S),i==="band"||i==="ordinal"&&g)q(r,n,e,o,s);else if(i==="point")A(r,n,e,o,s);else for(const a of["paddingInner","paddingOuter","padding","align"])Object.hasOwn(e,a)&&O(i,a);const E=Object.hasOwn(e,"radialMapping")?e.radialMapping:n.radialMapping;return E!==void 0&&(r.radialMapping=E,I({...r,...Object.hasOwn(e,"unknown")||Object.hasOwn(n,"unknown")?{unknown:e.unknown??n.unknown}:{}},{allowAuto:!0})),r}export{V as normalizeScaleDefinition};