ggaction 0.0.16 → 0.0.18

package/src/grammar/scales/temporal.js

@@ -1,5 +1,5 @@
 import { cloneAndFreeze } from "../../core/immutable.js";
-import { utcTimestamp, validTimestamp } from "../timeUnit.js";
+import { utcTimestamp, validTimestamp, offsetUtcTimeUnit } from "../timeUnit.js";
 
 const TIME_UNITS = [
   { span: 2 * 365 * 24 * 60 * 60 * 1000, unit: "year" },
@@ -56,17 +56,6 @@ function floorUtc(timestamp, unit) {
   return Math.floor(timestamp / 1000) * 1000;
 }
 
-function offsetUtc(timestamp, unit) {
-  const date = new Date(timestamp);
-  if (unit === "year") return utcTimestamp(date.getUTCFullYear() + 1);
-  if (unit === "month") {
-    return utcTimestamp(date.getUTCFullYear(), date.getUTCMonth() + 1);
-  }
-  if (unit === "day") return timestamp + 24 * 60 * 60 * 1000;
-  if (unit === "hour") return timestamp + 60 * 60 * 1000;
-  if (unit === "minute") return timestamp + 60 * 1000;
-  return timestamp + 1000;
-}
 
 export function niceTimeDomain(domain) {
   const [minimum, maximum] = requireTimeDomain(domain);
@@ -74,7 +63,7 @@ export function niceTimeDomain(domain) {
   const unit = TIME_UNITS.find(item => maximum - minimum >= item.span).unit;
   const start = floorUtc(minimum, unit);
   const endFloor = floorUtc(maximum, unit);
-  const end = endFloor === maximum ? maximum : offsetUtc(endFloor, unit);
+  const end = endFloor === maximum ? maximum : offsetUtcTimeUnit(endFloor, unit);
   if (![start, end].every(validTimestamp)) {
     throw new RangeError("Nice time domain exceeds the supported date range.");
   }

package/src/grammar/scales/transformed.js

@@ -1,383 +1 @@
-import { cloneAndFreeze, isPlainObject } from "../../core/immutable.js";
-import { MAX_GENERATED_ITEMS } from "../../core/validation.js";
-import { interpolateNumber, inverseLerp, numericExtent } from "../numeric.js";
-import { niceTicks } from "../ticks.js";
-import { niceLinearDomain } from "./continuous.js";
-import {
-  SCALE_ROLES,
-  validateScaleTypeForRole
-} from "./types.js";
-import { validatePair } from "./validation.js";
-const TRANSFORMED_TYPES = Object.freeze(["log", "pow", "sqrt", "symlog"]);
-
-function positiveFinite(value, label) {
-  if (!Number.isFinite(value) || value <= 0) {
-    throw new RangeError(`${label} must be a positive finite number.`);
-  }
-  return value;
-}
-
-export function normalizeTransformParameters(type, options = {}) {
-  if (!TRANSFORMED_TYPES.includes(type) && type !== "linear") {
-    throw new Error(`Scale type "${type}" is not a quantitative transform.`);
-  }
-  if (!isPlainObject(options)) {
-    throw new TypeError("Scale transform options must be a plain object.");
-  }
-  const allowed = type === "log"
-    ? ["base"]
-    : type === "pow"
-      ? ["exponent"]
-      : type === "symlog" ? ["constant"] : [];
-  for (const key of Object.keys(options)) {
-    if (!allowed.includes(key)) {
-      throw new Error(`Scale type "${type}" does not support ${key}.`);
-    }
-  }
-  if (type === "log") {
-    const base = positiveFinite(options.base ?? 10, "Log scale base");
-    if (base === 1) throw new RangeError("Log scale base must not equal 1.");
-    return cloneAndFreeze({ base });
-  }
-  if (type === "pow") {
-    return cloneAndFreeze({
-      exponent: positiveFinite(options.exponent ?? 1, "Power scale exponent")
-    });
-  }
-  if (type === "sqrt") return cloneAndFreeze({ exponent: 0.5 });
-  if (type === "symlog") {
-    return cloneAndFreeze({
-      constant: positiveFinite(options.constant ?? 1, "Symlog scale constant")
-    });
-  }
-  return cloneAndFreeze({});
-}
-
-function signedTransformProportion(value, start, end, transform) {
-  const transformed = [start, end, value].map(item =>
-    Math.sign(item) * transform(Math.abs(item))
-  );
-  return transformed[0] !== transformed[1] &&
-    transformed.every(Number.isFinite)
-    ? inverseLerp(transformed[2], transformed[0], transformed[1])
-    : undefined;
-}
-
-function powerProportion(value, domain, exponent) {
-  const [start, end] = domain;
-  const direct = signedTransformProportion(
-    value, start, end, magnitude => magnitude ** exponent
-  );
-  if (direct !== undefined) return direct;
-  const scale = Math.max(Math.abs(start), Math.abs(end));
-  const normalized = signedTransformProportion(
-    value,
-    start,
-    end,
-    magnitude => magnitude === 0 ? 0 : Math.exp(exponent * (
-      Math.log(magnitude) - Math.log(scale)
-    ))
-  );
-  if (normalized !== undefined) return normalized;
-
-  if (
-    start !== 0 &&
-    end !== 0 &&
-    value !== 0 &&
-    Math.sign(start) === Math.sign(end)
-  ) {
-    const endLogRatio = Math.log(Math.abs(end)) - Math.log(Math.abs(start));
-    const valueLogRatio = Math.log(Math.abs(value)) - Math.log(Math.abs(start));
-    if (Math.abs(exponent * endLogRatio) < 1e-8) {
-      return valueLogRatio / endLogRatio;
-    }
-    const proportion = Math.expm1(exponent * valueLogRatio) /
-      Math.expm1(exponent * endLogRatio);
-    if (Number.isFinite(proportion)) return proportion;
-  }
-
-  return inverseLerp(value, start, end);
-}
-
-function logOnePlusRatio(value, constant) {
-  if (value === 0) return 0;
-  const ratio = Math.abs(value) / constant;
-  if (Number.isFinite(ratio)) return Math.sign(value) * Math.log1p(ratio);
-  const logRatio = Math.log(Math.abs(value)) - Math.log(constant);
-  return Math.sign(value) * (
-    Math.max(0, logRatio) + Math.log1p(Math.exp(-Math.abs(logRatio)))
-  );
-}
-
-function transformedProportion(value, domain, type, parameters) {
-  const [start, end] = domain;
-  if (type === "linear") return inverseLerp(value, start, end);
-  if (type === "log") {
-    const logarithm = Math.log10(parameters.base);
-    const direct = signedTransformProportion(
-      value, start, end, magnitude => Math.log10(magnitude) / logarithm
-    );
-    return direct ?? signedTransformProportion(
-      value, start, end, Math.log
-    ) ?? inverseLerp(value, start, end);
-  }
-  if (type === "pow" || type === "sqrt") {
-    return powerProportion(value, domain, parameters.exponent);
-  }
-
-  const transformedStart = logOnePlusRatio(start, parameters.constant);
-  const transformedEnd = logOnePlusRatio(end, parameters.constant);
-  if (transformedStart === transformedEnd) {
-    return inverseLerp(value, start, end);
-  }
-  const proportion = inverseLerp(
-    logOnePlusRatio(value, parameters.constant),
-    transformedStart,
-    transformedEnd
-  );
-  return Number.isFinite(proportion) ? proportion : inverseLerp(value, start, end);
-}
-
-export function validateTransformedDomain(type, domain, options = {}) {
-  validateScaleTypeForRole(type, SCALE_ROLES.quantitativePosition);
-  const validated = validatePair(domain, "Transformed scale domain");
-  if (validated[0] === validated[1]) {
-    throw new RangeError("Transformed scale domain values must be distinct.");
-  }
-  if (
-    type === "log" &&
-    (validated.includes(0) || Math.sign(validated[0]) !== Math.sign(validated[1]))
-  ) {
-    throw new RangeError(
-      "Log scale domain must be strictly positive or strictly negative."
-    );
-  }
-  normalizeTransformParameters(type, options);
-  return validated;
-}
-
-function radixPower(radix, exponent, logarithm) {
-  const direct = Number.isFinite(radix) ? radix ** exponent : Number.NaN;
-  if (Number.isFinite(direct) && direct > 0) return direct;
-  const transformed = exponent * logarithm;
-  if (transformed > Math.log(Number.MAX_VALUE)) return Number.POSITIVE_INFINITY;
-  if (transformed < Math.log(Number.MIN_VALUE)) return 0;
-  return Math.exp(transformed);
-}
-
-function logDomainInfo(domain, base) {
-  const low = Math.min(...domain);
-  const high = Math.max(...domain);
-  const negative = high < 0;
-  return [
-    base < 1 ? -Math.log(base) : Math.log(base),
-    base < 1 ? 1 / base : base,
-    domain[0] > domain[1],
-    negative,
-    negative ? Math.abs(high) : low,
-    negative ? Math.abs(low) : high
-  ];
-}
-
-function niceLogDomain(domain, base) {
-  const [logarithm, radix, reversed, negative, minimum, maximum] =
-    logDomainInfo(domain, base);
-  let lower = radixPower(
-    radix,
-    Math.floor(Math.log(minimum) / logarithm),
-    logarithm
-  );
-  let upper = radixPower(
-    radix,
-    Math.ceil(Math.log(maximum) / logarithm),
-    logarithm
-  );
-  if (!Number.isFinite(lower) || lower <= 0 || lower > minimum) lower = minimum;
-  if (!Number.isFinite(upper) || upper < maximum) upper = maximum;
-  const result = negative ? [-upper, -lower] : [lower, upper];
-  return cloneAndFreeze(reversed ? result.reverse() : result);
-}
-
-function padAutomaticTransformedDomain(type, value, options) {
-  const parameters = normalizeTransformParameters(type, options);
-  if (value === 0) {
-    if (type === "log") {
-      throw new RangeError(
-        "Log scale domain must be strictly positive or strictly negative."
-      );
-    }
-    return [-1, 1];
-  }
-  const magnitude = Math.abs(value);
-  let lower = magnitude / 2;
-  let upper = magnitude * 2;
-  if (type === "pow" || type === "sqrt") {
-    upper = magnitude * (2 - 2 ** -parameters.exponent) **
-      (1 / parameters.exponent);
-  } else if (type === "symlog") {
-    const center = Math.abs(logOnePlusRatio(value, parameters.constant));
-    if (center === 0) return [-1, 1];
-    upper = parameters.constant * Math.expm1(
-      2 * center - logOnePlusRatio(lower, parameters.constant)
-    );
-  }
-  if (!(lower < magnitude && upper > magnitude && Number.isFinite(upper))) {
-    lower = magnitude / 2;
-    upper = Number.isFinite(magnitude * 2) ? magnitude * 2 : magnitude;
-  }
-  if (type === "log" && lower === 0) lower = magnitude;
-  return value > 0
-    ? [lower, upper]
-    : [-upper, lower === 0 ? 0 : -lower];
-}
-
-export function resolveTransformedDomain({
-  type,
-  domain = "auto",
-  values,
-  nice = false,
-  zero = false,
-  ...options
-}) {
-  validateScaleTypeForRole(type, SCALE_ROLES.quantitativePosition);
-  if (!Array.isArray(values) || !values.every(Number.isFinite)) {
-    throw new TypeError("Transformed scale values must be finite numbers.");
-  }
-  if (typeof nice !== "boolean" || typeof zero !== "boolean") {
-    throw new TypeError("Scale nice and zero must be booleans.");
-  }
-  if (type === "log" && zero) {
-    throw new Error('Scale type "log" does not support zero.');
-  }
-  const explicit = domain !== "auto";
-  if (explicit) return validateTransformedDomain(type, domain, options);
-  if (values.length === 0) {
-    throw new Error("Cannot infer an automatic scale domain from no values.");
-  }
-  let resolved = numericExtent(values);
-  if (zero) resolved = [Math.min(0, resolved[0]), Math.max(0, resolved[1])];
-  if (resolved[0] === resolved[1]) {
-    resolved = padAutomaticTransformedDomain(type, resolved[0], options);
-  }
-  validateTransformedDomain(type, resolved, options);
-  if (nice) {
-    resolved = type === "log"
-      ? niceLogDomain(resolved, normalizeTransformParameters(type, options).base)
-      : niceLinearDomain(resolved);
-  }
-  return validateTransformedDomain(type, resolved, options);
-}
-
-export function resolveMappingRange(range, { reverse = false } = {}) {
-  const validated = validatePair(range, "Scale range");
-  if (typeof reverse !== "boolean") {
-    throw new TypeError("Scale reverse must be a boolean.");
-  }
-  return reverse
-    ? cloneAndFreeze([...validated].reverse())
-    : validated;
-}
-
-export function mapTransformedValues(
-  values,
-  domain,
-  range,
-  { type = "linear", clamp = false, reverse = false, ...options } = {}
-) {
-  if (!Array.isArray(values)) {
-    throw new TypeError("Scale values must be an array.");
-  }
-  if (typeof clamp !== "boolean") {
-    throw new TypeError("Scale clamp must be a boolean.");
-  }
-  const hasUnknown = Object.hasOwn(options, "unknown");
-  const { unknown, ...transformOptions } = options;
-  const parameters = normalizeTransformParameters(type, transformOptions);
-  const validatedDomain = validateTransformedDomain(type, domain, transformOptions);
-  const resolvedRange = resolveMappingRange(range, { reverse });
-  const span = resolvedRange[1] - resolvedRange[0];
-  return cloneAndFreeze(values.map(value => {
-    const valid = Number.isFinite(value) && !(type === "log" && (
-      value === 0 || Math.sign(value) !== Math.sign(validatedDomain[0])
-    ));
-    if (!valid) {
-      if (hasUnknown) return unknown;
-      throw new TypeError(`Scale type "${type}" received an invalid value.`);
-    }
-    let proportion = transformedProportion(
-      value,
-      validatedDomain,
-      type,
-      parameters
-    );
-    if (clamp) proportion = Math.max(0, Math.min(1, proportion));
-    const direct = resolvedRange[0] + proportion * span;
-    return Number.isFinite(span) && Number.isFinite(direct) && (
-      proportion !== 1 ||
-      Math.abs(direct - resolvedRange[1]) <=
-        Number.EPSILON * Math.abs(resolvedRange[1])
-    )
-      ? direct
-      : interpolateNumber(resolvedRange[0], resolvedRange[1], proportion);
-  }));
-}
-
-export function transformedTicks(type, domain, count, options = {}) {
-  const validated = validateTransformedDomain(type, domain, options);
-  if (!Number.isInteger(count) || count <= 0) {
-    throw new RangeError("Tick count must be a positive integer.");
-  }
-  if (type !== "log") return niceTicks(validated, count);
-  const { base } = normalizeTransformParameters(type, options);
-  const [
-    logarithm,
-    radix,
-    reversed,
-    negative,
-    minimumMagnitude,
-    maximumMagnitude
-  ] = logDomainInfo(validated, base);
-  const start = Math.ceil(
-    Math.log(minimumMagnitude) / logarithm - 1e-12
-  );
-  const end = Math.floor(
-    Math.log(maximumMagnitude) / logarithm + 1e-12
-  );
-  const available = end - start + 1;
-  const tickCount = available <= MAX_GENERATED_ITEMS
-    ? available
-    : Math.min(count, MAX_GENERATED_ITEMS);
-  const values = [];
-  for (let index = 0; index < tickCount; index += 1) {
-    const exponent = available <= MAX_GENERATED_ITEMS
-      ? start + index
-      : Math.round(start + (end - start) * index / Math.max(1, tickCount - 1));
-    const magnitude = radixPower(radix, exponent, logarithm);
-    const value = (negative ? -1 : 1) * magnitude;
-    if (
-      Number.isFinite(value) &&
-      magnitude >= minimumMagnitude &&
-      magnitude <= maximumMagnitude &&
-      (values.length === 0 || value !== values.at(-1))
-    ) {
-      values.push(value);
-    }
-  }
-  if (negative) values.reverse();
-  if (reversed) values.reverse();
-  return cloneAndFreeze(values.length === 0 ? [...validated] : values);
-}
-
-export function formatTransformedTick(type, value) {
-  if (type !== "log") return String(value);
-  const magnitude = Math.abs(value);
-  const units = [
-    [1_000_000_000, "B"],
-    [1_000_000, "M"],
-    [1_000, "K"]
-  ];
-  const unit = units.find(([threshold]) => magnitude >= threshold);
-  if (unit === undefined) return String(value);
-  const scaled = value / unit[0];
-  return `${Number(scaled.toPrecision(3))}${unit[1]}`;
-}
+import{cloneAndFreeze as h,isPlainObject as I}from"../../core/immutable.js";import{MAX_GENERATED_ITEMS as R}from"../../core/validation.js";import{interpolateNumber as D,inverseLerp as b,numericExtent as q}from"../numeric.js";import{niceTicks as $}from"../ticks.js";import{niceLinearDomain as j}from"./continuous.js";import{SCALE_ROLES as L,validateScaleTypeForRole as A}from"./types.js";import{validatePair as _}from"./validation.js";const z=Object.freeze(["log","pow","sqrt","symlog"]);function v(t,e){if(!Number.isFinite(t)||t<=0)throw new RangeError(`${e} must be a positive finite number.`);return t}function p(t,e={}){if(!z.includes(t)&&t!=="linear")throw new Error(`Scale type "${t}" is not a quantitative transform.`);if(!I(e))throw new TypeError("Scale transform options must be a plain object.");const o=t==="log"?["base"]:t==="pow"?["exponent"]:t==="symlog"?["constant"]:[];for(const n of Object.keys(e))if(!o.includes(n))throw new Error(`Scale type "${t}" does not support ${n}.`);if(t==="log"){const n=v(e.base??10,"Log scale base");if(n===1)throw new RangeError("Log scale base must not equal 1.");return h({base:n})}return t==="pow"?h({exponent:v(e.exponent??1,"Power scale exponent")}):t==="sqrt"?h({exponent:.5}):t==="symlog"?h({constant:v(e.constant??1,"Symlog scale constant")}):h({})}function E(t,e,o,n){const r=[e,o,t].map(i=>Math.sign(i)*n(Math.abs(i)));return r[0]!==r[1]&&r.every(Number.isFinite)?b(r[2],r[0],r[1]):void 0}function V(t,e,o){const[n,r]=e,i=E(t,n,r,c=>c**o);if(i!==void 0)return i;const s=Math.max(Math.abs(n),Math.abs(r)),a=E(t,n,r,c=>c===0?0:Math.exp(o*(Math.log(c)-Math.log(s))));if(a!==void 0)return a;if(n!==0&&r!==0&&t!==0&&Math.sign(n)===Math.sign(r)){const c=Math.log(Math.abs(r))-Math.log(Math.abs(n)),f=Math.log(Math.abs(t))-Math.log(Math.abs(n));if(Math.abs(o*c)<1e-8)return f/c;const u=Math.expm1(o*f)/Math.expm1(o*c);if(Number.isFinite(u))return u}return b(t,n,r)}function N(t,e){if(t===0)return 0;const o=Math.abs(t)/e;if(Number.isFinite(o))return Math.sign(t)*Math.log1p(o);const n=Math.log(Math.abs(t))-Math.log(e);return Math.sign(t)*(Math.max(0,n)+Math.log1p(Math.exp(-Math.abs(n))))}function C(t,e,o,n){const[r,i]=e;if(o==="linear")return b(t,r,i);if(o==="log"){const f=Math.log10(n.base);return E(t,r,i,d=>Math.log10(d)/f)??E(t,r,i,Math.log)??b(t,r,i)}if(o==="pow"||o==="sqrt")return V(t,e,n.exponent);const s=N(r,n.constant),a=N(i,n.constant);if(s===a)return b(t,r,i);const c=b(N(t,n.constant),s,a);return Number.isFinite(c)?c:b(t,r,i)}function x(t,e,o={}){A(t,L.quantitativePosition);const n=_(e,"Transformed scale domain");if(n[0]===n[1])throw new RangeError("Transformed scale domain values must be distinct.");if(t==="log"&&(n.includes(0)||Math.sign(n[0])!==Math.sign(n[1])))throw new RangeError("Log scale domain must be strictly positive or strictly negative.");return p(t,o),n}function P(t,e,o){const n=Number.isFinite(t)?t**e:Number.NaN;if(Number.isFinite(n)&&n>0)return n;const r=e*o;return r>Math.log(Number.MAX_VALUE)?Number.POSITIVE_INFINITY:r<Math.log(Number.MIN_VALUE)?0:Math.exp(r)}function O(t,e){const o=Math.min(...t),n=Math.max(...t),r=n<0;return[e<1?-Math.log(e):Math.log(e),e<1?1/e:e,t[0]>t[1],r,r?Math.abs(n):o,r?Math.abs(o):n]}function U(t,e){const[o,n,r,i,s,a]=O(t,e);let c=P(n,Math.floor(Math.log(s)/o),o),f=P(n,Math.ceil(Math.log(a)/o),o);(!Number.isFinite(c)||c<=0||c>s)&&(c=s),(!Number.isFinite(f)||f<a)&&(f=a);const u=i?[-f,-c]:[c,f];return h(r?u.reverse():u)}function X(t,e,o){const n=p(t,o);if(e===0){if(t==="log")throw new RangeError("Log scale domain must be strictly positive or strictly negative.");return[-1,1]}const r=Math.abs(e);let i=r/2,s=r*2;if(t==="pow"||t==="sqrt")s=r*(2-2**-n.exponent)**(1/n.exponent);else if(t==="symlog"){const a=Math.abs(N(e,n.constant));if(a===0)return[-1,1];s=n.constant*Math.expm1(2*a-N(i,n.constant))}return i<r&&s>r&&Number.isFinite(s)||(i=r/2,s=Number.isFinite(r*2)?r*2:r),t==="log"&&i===0&&(i=r),e>0?[i,s]:[-s,i===0?0:-i]}function W({type:t,domain:e="auto",values:o,nice:n=!1,zero:r=!1,...i}){if(A(t,L.quantitativePosition),!Array.isArray(o)||!o.every(Number.isFinite))throw new TypeError("Transformed scale values must be finite numbers.");if(typeof n!="boolean"||typeof r!="boolean")throw new TypeError("Scale nice and zero must be booleans.");if(t==="log"&&r)throw new Error('Scale type "log" does not support zero.');if(e!=="auto")return x(t,e,i);if(o.length===0)throw new Error("Cannot infer an automatic scale domain from no values.");let a=q(o);return r&&(a=[Math.min(0,a[0]),Math.max(0,a[1])]),a[0]===a[1]&&(a=X(t,a[0],i)),x(t,a,i),n&&(a=t==="log"?U(a,p(t,i).base):j(a)),x(t,a,i)}function Y(t,{reverse:e=!1}={}){const o=_(t,"Scale range");if(typeof e!="boolean")throw new TypeError("Scale reverse must be a boolean.");return e?h([...o].reverse()):o}function Z(t,e,o,{type:n="linear",clamp:r=!1,reverse:i=!1,...s}={}){if(!Array.isArray(t))throw new TypeError("Scale values must be an array.");if(typeof r!="boolean")throw new TypeError("Scale clamp must be a boolean.");const a=Object.hasOwn(s,"unknown"),{unknown:c,...f}=s,u=p(n,f),d=x(n,e,f),l=Y(o,{reverse:i}),w=l[1]-l[0];return h(t.map(g=>{if(!(Number.isFinite(g)&&!(n==="log"&&(g===0||Math.sign(g)!==Math.sign(d[0]))))){if(a)return c;throw new TypeError(`Scale type "${n}" received an invalid value.`)}let m=C(g,d,n,u);r&&(m=Math.max(0,Math.min(1,m)));const M=l[0]+m*w;return Number.isFinite(w)&&Number.isFinite(M)&&(m!==1||Math.abs(M-l[1])<=Number.EPSILON*Math.abs(l[1]))?M:D(l[0],l[1],m)}))}function tt(t,e,o,n={}){const r=x(t,e,n);if(!Number.isInteger(o)||o<=0)throw new RangeError("Tick count must be a positive integer.");if(t!=="log")return $(r,o);const{base:i}=p(t,n),[s,a,c,f,u,d]=O(r,i),l=Math.ceil(Math.log(u)/s-1e-12),w=Math.floor(Math.log(d)/s+1e-12),g=w-l+1,T=g<=R?g:Math.min(o,R),m=[];for(let M=0;M<T;M+=1){const k=g<=R?l+M:Math.round(l+(w-l)*M/Math.max(1,T-1)),S=P(a,k,s),F=(f?-1:1)*S;Number.isFinite(F)&&S>=u&&S<=d&&(m.length===0||F!==m.at(-1))&&m.push(F)}return f&&m.reverse(),c&&m.reverse(),h(m.length===0?[...r]:m)}function nt(t,e){if(t!=="log")return String(e);const o=Math.abs(e),r=[[1e9,"B"],[1e6,"M"],[1e3,"K"]].find(([s])=>o>=s);if(r===void 0)return String(e);const i=e/r[0];return`${Number(i.toPrecision(3))}${r[1]}`}export{nt as formatTransformedTick,Z as mapTransformedValues,p as normalizeTransformParameters,Y as resolveMappingRange,W as resolveTransformedDomain,tt as transformedTicks,x as validateTransformedDomain};

package/src/grammar/scales/types.js

@@ -16,7 +16,7 @@ export const SCALE_TYPES_BY_ROLE = Object.freeze({
   [SCALE_ROLES.bandPosition]: Object.freeze(["band"]),
   [SCALE_ROLES.pointPosition]: Object.freeze(["point"]),
   [SCALE_ROLES.discreteAppearance]: Object.freeze(["ordinal"]),
-  [SCALE_ROLES.continuousColor]: Object.freeze(["sequential"]),
+  [SCALE_ROLES.continuousColor]: Object.freeze(["sequential", "log", "sqrt", "symlog"]),
   [SCALE_ROLES.discretizedColor]: Object.freeze([
     "quantize", "quantile", "threshold"
   ])

package/src/grammar/scales/validation.js

@@ -1,66 +1 @@
-import { cloneAndFreeze } from "../../core/immutable.js";
-import { POSITION_CHANNELS } from "../../core/vocabulary.js";
-import { validateCompleteScaleType } from "./types.js";
-
-export function validatePair(value, label) {
-  if (
-    !Array.isArray(value) ||
-    value.length !== 2 ||
-    !value.every(Number.isFinite)
-  ) {
-    throw new TypeError(`${label} must be "auto" or two finite numbers.`);
-  }
-  return cloneAndFreeze(value);
-}
-
-export function validatePositionChannel(channel) {
-  if (!POSITION_CHANNELS.includes(channel)) {
-    throw new Error(`Unknown position channel "${channel}".`);
-  }
-  return channel;
-}
-
-export function validateScaleType(type) {
-  return validateCompleteScaleType(type);
-}
-
-export function validateSemanticScaleType(type) {
-  return validateCompleteScaleType(type);
-}
-
-export function validateLinearScaleType(type) {
-  if (type !== "linear") {
-    throw new Error(`Unsupported position scale type "${type}".`);
-  }
-  return type;
-}
-
-export function validateTimeScaleType(type) {
-  if (type !== "time") {
-    throw new Error(`Unsupported temporal scale type "${type}".`);
-  }
-  return type;
-}
-
-export function validateOrdinalScaleType(type) {
-  if (type !== "ordinal") {
-    throw new Error(`Unsupported color scale type "${type}".`);
-  }
-  return type;
-}
-
-export function validateScaleDomain(domain) {
-  return domain === "auto" ? domain : validatePair(domain, "Scale domain");
-}
-
-export function validateScaleRange(range) {
-  return range === "auto" ? range : validatePair(range, "Scale range");
-}
-
-export function validateSemanticScaleDomain(domain) {
-  if (domain === "auto") return domain;
-  if (!Array.isArray(domain) || domain.length === 0) {
-    throw new TypeError("Scale domain must be \"auto\" or a non-empty array.");
-  }
-  return cloneAndFreeze(domain);
-}
+import{cloneAndFreeze as o}from"../../core/immutable.js";import{POSITION_CHANNELS as c}from"../../core/vocabulary.js";import{validateCompleteScaleType as i}from"./types.js";function u(r,e,t=1){if(!Array.isArray(r)||r.length<t||!r.every(Number.isFinite))throw new TypeError(`${e} must contain finite numbers.`);return r}function s(r,e){if(u(r,e),r.some((t,n)=>n>0&&t<=r[n-1]))throw new RangeError(`${e} must be strictly increasing.`);return r}function a(r,e){if(!Array.isArray(r)||r.length!==2||!r.every(Number.isFinite))throw new TypeError(`${e} must be "auto" or two finite numbers.`);return o(r)}function m(r){if(!c.includes(r))throw new Error(`Unknown position channel "${r}".`);return r}function y(r){return i(r)}function w(r){return i(r)}function S(r){if(r!=="linear")throw new Error(`Unsupported position scale type "${r}".`);return r}function d(r){if(r!=="time")throw new Error(`Unsupported temporal scale type "${r}".`);return r}function h(r){if(r!=="ordinal")throw new Error(`Unsupported color scale type "${r}".`);return r}function x(r){return r==="auto"?r:a(r,"Scale domain")}function T(r){return r==="auto"?r:a(r,"Scale range")}function A(r){if(r==="auto")return r;if(!Array.isArray(r)||r.length===0)throw new TypeError('Scale domain must be "auto" or a non-empty array.');return o(r)}export{u as validateFiniteScaleArray,s as validateIncreasingScaleArray,S as validateLinearScaleType,h as validateOrdinalScaleType,a as validatePair,m as validatePositionChannel,x as validateScaleDomain,T as validateScaleRange,y as validateScaleType,A as validateSemanticScaleDomain,w as validateSemanticScaleType,d as validateTimeScaleType};

package/src/grammar/schemas/concreteGraphic.js

@@ -1,3 +1,5 @@
+import { validateGeneratedItemLimit } from "../../core/validation.js";
+import { validateFontStyle } from "../../core/font.js";
 import { isPlainObject } from "../../core/immutable.js";
 import { validatePathCommands } from "../pathCommands.js";
 import { validateFillPaint } from "../paint.js";
@@ -25,6 +27,14 @@ const TEXT_BASELINES = new Set([
 ]);
 
 export function validateConcreteGraphicValue(type, property, value) {
+  if (property === "lines") {
+    if (!Array.isArray(value) || value.length === 0 || value.some(line =>
+      !isPlainObject(line) || Object.keys(line).some(key => !["text", "x", "y"].includes(key)) ||
+      typeof line.text !== "string" || !Number.isFinite(line.x) || !Number.isFinite(line.y))) {
+      throw new TypeError("Text lines require non-empty resolved text/x/y records.");
+    }
+    validateGeneratedItemLimit(value.length, "Text line count");
+  }
   if (property === "fill") {
     if (typeof value === "string") {
       validateFillPaint(value, `${type}.fill`);
@@ -60,6 +70,7 @@ export function validateConcreteGraphicValue(type, property, value) {
   )) {
     throw new TypeError("text.fontWeight must be a non-empty string or finite number.");
   }
+  if (property === "fontStyle") validateFontStyle(value);
   if (property === "textAlign" && !TEXT_ALIGNS.has(value)) {
     throw new Error(`Unsupported text.textAlign "${value}".`);
   }

package/src/grammar/schemas/graphic.js

@@ -33,6 +33,7 @@ const GRAPHIC_PROPERTIES = Object.freeze({
     "fontSize",
     "fontFamily",
     "fontWeight",
+    "fontStyle",
     "text",
     "textAlign",
     "textBaseline",
@@ -85,10 +86,12 @@ const GRAPHIC_PROPERTIES = Object.freeze({
     "x",
     "y",
     "text",
+    "lines",
     "fill",
     "fontSize",
     "fontFamily",
     "fontWeight",
+    "fontStyle",
     "textAlign",
     "textBaseline",
     "rotation",

package/src/grammar/schemas/semanticPath.js

@@ -23,7 +23,7 @@ const ENCODING_PATHS = Object.freeze([
   "encoding.color.aggregate",
   "encoding.group.fields",
   "encoding.group.inferredFrom",
-  ...["x", "y", "x2", "y2", "theta", "color"].map(channel =>
+  ...["x", "y", "x2", "y2", "theta", "color", "stroke"].map(channel =>
     `encoding.${channel}.temporalUnit`
   ),
   "encoding.pathOrder.field",
@@ -49,7 +49,7 @@ const ENCODING_PATHS = Object.freeze([
 const ENTITY_PATHS = Object.freeze({
   dataset: {
     collection: "datasets",
-    properties: new Set(["source", "transform", "values"])
+    properties: new Set(["source", "transform", "schema", "values"])
   },
   layer: {
     collection: "layers",
@@ -64,6 +64,8 @@ const ENTITY_PATHS = Object.freeze({
       "transform",
       "mark.type",
       "mark.missing",
+      "mark.orientation",
+      "derivedBindings.regression",
       "layout.mode",
       ...ENCODING_PATHS
     ])
@@ -71,7 +73,7 @@ const ENTITY_PATHS = Object.freeze({
   scale: {
     collection: "scales",
     properties: new Set([
-      "type", "domain", "range", "nice", "zero", "clamp", "reverse",
+      "type", "domain", "range", "emptyDomain", "nice", "zero", "clamp", "reverse",
       "unknown", "base", "exponent", "constant", "interpolate", "radialMapping", "midpoint",
       "paddingInner", "paddingOuter", "padding", "align"
     ])