ggaction 0.0.17 → 0.0.18

package/src/grammar/scales/size.js

@@ -1,456 +1 @@
-import { cloneAndFreeze } from "../../core/immutable.js";
-import { validateGeneratedItemLimit } from "../../core/validation.js";
-import { interpolateNumber } from "../numeric.js";
-import { validateSizeRange, resolveSizeRange } from "./appearance.js";
-import { mapLinearValues } from "./continuous.js";
-import { mapTransformedValues, resolveTransformedDomain } from "./transformed.js";
-import { validateScaleUnknown } from "./policies.js";
-import { validatePair } from "./validation.js";
-
-export const CONTINUOUS_SIZE_SCALE_TYPES = cloneAndFreeze([
-  "linear", "log", "sqrt", "pow"
-]);
-export const DISCRETE_SIZE_SCALE_TYPES = cloneAndFreeze([
-  "quantize", "quantile", "threshold"
-]);
-export const SIZE_SCALE_TYPES = cloneAndFreeze([
-  ...CONTINUOUS_SIZE_SCALE_TYPES,
-  ...DISCRETE_SIZE_SCALE_TYPES
-]);
-
-export function isContinuousSizeScaleType(type) {
-  return CONTINUOUS_SIZE_SCALE_TYPES.includes(type);
-}
-
-export function isDiscreteSizeScaleType(type) {
-  return DISCRETE_SIZE_SCALE_TYPES.includes(type);
-}
-
-export function isSizeScaleType(type) {
-  return SIZE_SCALE_TYPES.includes(type);
-}
-
-export function validateSizeScaleType(type) {
-  if (!isSizeScaleType(type)) {
-    throw new Error(`Scale type "${type}" is not valid for size.`);
-  }
-  return type;
-}
-
-function finiteArray(value, label, minimumLength = 1) {
-  if (
-    !Array.isArray(value) ||
-    value.length < minimumLength ||
-    !value.every(Number.isFinite)
-  ) {
-    throw new TypeError(`${label} must contain finite numbers.`);
-  }
-  return value;
-}
-
-function strictlyIncreasing(value, label) {
-  finiteArray(value, label);
-  if (value.some((item, index) => index > 0 && item <= value[index - 1])) {
-    throw new RangeError(`${label} must be strictly increasing.`);
-  }
-  return value;
-}
-
-function validateContinuousDomain(type, domain) {
-  const validated = validatePair(domain, "Size scale domain");
-  if (type !== "linear" && validated[0] === validated[1]) {
-    throw new RangeError(
-      `Size ${type} scale domain values must be distinct.`
-    );
-  }
-  if (type === "log" && validated.some(value => value <= 0)) {
-    throw new RangeError("Size log scale domain must be strictly positive.");
-  }
-  if (["sqrt", "pow"].includes(type) && validated.some(value => value < 0)) {
-    throw new RangeError(
-      `Size ${type} scale domain must be non-negative.`
-    );
-  }
-  return validated;
-}
-
-export function validateSizeScaleDomain(type, domain) {
-  validateSizeScaleType(type);
-  if (domain === "auto") {
-    if (type === "threshold") {
-      throw new Error("Threshold size scale requires an explicit domain.");
-    }
-    return domain;
-  }
-  if (isContinuousSizeScaleType(type)) {
-    return validateContinuousDomain(type, domain);
-  }
-  if (type === "quantize") {
-    const validated = validatePair(domain, "Quantize size domain");
-    if (validated[0] >= validated[1]) {
-      throw new RangeError(
-        "Quantize size domain must be a strictly increasing pair."
-      );
-    }
-    return validated;
-  }
-  if (type === "quantile") {
-    return cloneAndFreeze(finiteArray(domain, "Quantile size domain"));
-  }
-  return cloneAndFreeze(
-    strictlyIncreasing(domain, "Threshold size domain")
-  );
-}
-
-export function validateDiscreteSizeRange(range) {
-  finiteArray(range, "Discrete size range", 2);
-  validateGeneratedItemLimit(range.length, "Discrete size range length");
-  if (range.some(value => value < 0)) {
-    throw new RangeError(
-      "Discrete size range must contain non-negative areas."
-    );
-  }
-  if (range.some((value, index) => index > 0 && value < range[index - 1])) {
-    throw new RangeError("Discrete size range must be nondecreasing.");
-  }
-  return cloneAndFreeze(range);
-}
-
-export function validateSizeScaleRange(type, range) {
-  validateSizeScaleType(type);
-  if (isContinuousSizeScaleType(type)) return validateSizeRange(range);
-  if (range === "auto") {
-    throw new Error(`Size ${type} scale requires an explicit range.`);
-  }
-  return validateDiscreteSizeRange(range);
-}
-
-function sizeTypeFamily(type) {
-  return isContinuousSizeScaleType(type) ? "continuous" : type;
-}
-
-function requireBoolean(value, label) {
-  if (typeof value !== "boolean") {
-    throw new TypeError(`${label} must be a boolean.`);
-  }
-  return value;
-}
-
-function positiveFinite(value, label) {
-  if (!Number.isFinite(value) || value <= 0) {
-    throw new RangeError(`${label} must be a positive finite number.`);
-  }
-  return value;
-}
-
-export function normalizeSizeScaleDefinition({ previous = {}, patch = {} } = {}) {
-  const type = validateSizeScaleType(patch.type ?? previous.type ?? "linear");
-  const hasPrevious = previous.type !== undefined;
-  const typeChanged = hasPrevious && previous.type !== type;
-  if (typeChanged && sizeTypeFamily(previous.type) !== sizeTypeFamily(type) &&
-    !Object.hasOwn(patch, "domain")) {
-    throw new Error(
-      "Size scale type-family transition requires an explicit domain."
-    );
-  }
-  if (typeChanged && isDiscreteSizeScaleType(type) &&
-    !Object.hasOwn(patch, "range")) {
-    throw new Error(
-      `Size ${type} scale transition requires an explicit range.`
-    );
-  }
-  if (typeChanged && isDiscreteSizeScaleType(previous.type) &&
-    isContinuousSizeScaleType(type) && !Object.hasOwn(patch, "range")) {
-    throw new Error(
-      "Discrete-to-continuous size scale transition requires an explicit range."
-    );
-  }
-  for (const property of [
-    "nice", "zero", "constant", "padding", "paddingInner", "paddingOuter",
-    "align", "palette", "interpolate", "midpoint", "radialMapping"
-  ]) {
-    if (Object.hasOwn(patch, property)) {
-      throw new Error(`Size scale does not support ${property}.`);
-    }
-  }
-
-  const rawDomain = Object.hasOwn(patch, "domain")
-    ? patch.domain
-    : Object.hasOwn(previous, "domain")
-      ? previous.domain
-      : "auto";
-  const rawRange = Object.hasOwn(patch, "range")
-    ? patch.range
-    : Object.hasOwn(previous, "range")
-      ? previous.range
-      : "auto";
-  const definition = {
-    type,
-    domain: validateSizeScaleDomain(type, rawDomain),
-    range: validateSizeScaleRange(type, rawRange)
-  };
-
-  const reverse = Object.hasOwn(patch, "reverse")
-    ? patch.reverse
-    : previous.reverse;
-  if (reverse !== undefined) {
-    definition.reverse = requireBoolean(reverse, "Size scale reverse");
-  }
-
-  if (isContinuousSizeScaleType(type)) {
-    const clamp = Object.hasOwn(patch, "clamp")
-      ? patch.clamp
-      : isContinuousSizeScaleType(previous.type)
-        ? previous.clamp
-        : undefined;
-    if (clamp !== undefined) {
-      definition.clamp = requireBoolean(clamp, "Size scale clamp");
-    }
-  } else if (Object.hasOwn(patch, "clamp")) {
-    throw new Error(`Size ${type} scale does not support clamp.`);
-  }
-
-  if (type === "log") {
-    const base = Object.hasOwn(patch, "base")
-      ? patch.base
-      : !typeChanged && previous.type === "log"
-        ? previous.base
-        : 10;
-    definition.base = positiveFinite(base ?? 10, "Size log scale base");
-    if (definition.base === 1) {
-      throw new RangeError("Size log scale base must not equal 1.");
-    }
-  } else if (Object.hasOwn(patch, "base")) {
-    throw new Error(`Size ${type} scale does not support base.`);
-  }
-
-  if (type === "pow") {
-    const exponent = Object.hasOwn(patch, "exponent")
-      ? patch.exponent
-      : !typeChanged && previous.type === "pow"
-        ? previous.exponent
-        : undefined;
-    if (exponent === undefined) {
-      throw new Error("Size pow scale requires an explicit exponent.");
-    }
-    definition.exponent = positiveFinite(
-      exponent,
-      "Size pow scale exponent"
-    );
-  } else if (Object.hasOwn(patch, "exponent")) {
-    throw new Error(`Size ${type} scale does not support exponent.`);
-  }
-
-  const unknown = Object.hasOwn(patch, "unknown")
-    ? patch.unknown
-    : previous.unknown;
-  if (unknown !== undefined) {
-    definition.unknown = validateScaleUnknown("size", unknown);
-  }
-  return cloneAndFreeze(definition);
-}
-
-function validateSizeValues(values, type) {
-  if (!Array.isArray(values) || !values.every(Number.isFinite)) {
-    throw new TypeError("Size scale values must be finite numbers.");
-  }
-  if (type === "log" && values.some(value => value <= 0)) {
-    throw new RangeError("Size log scale values must be strictly positive.");
-  }
-  if (["sqrt", "pow"].includes(type) && values.some(value => value < 0)) {
-    throw new RangeError(`Size ${type} scale values must be non-negative.`);
-  }
-  return values;
-}
-
-function numericExtent(values) {
-  let minimum = values[0];
-  let maximum = values[0];
-  for (const value of values.slice(1)) {
-    minimum = Math.min(minimum, value);
-    maximum = Math.max(maximum, value);
-  }
-  return [minimum, maximum];
-}
-
-function resolveContinuousSizeDomain(definition, values) {
-  validateSizeValues(values, definition.type);
-  if (definition.domain !== "auto") {
-    return validateSizeScaleDomain(definition.type, definition.domain);
-  }
-  if (values.length === 0) {
-    throw new Error("Cannot infer an automatic size scale domain from no values.");
-  }
-  if (definition.type === "linear") {
-    return cloneAndFreeze(numericExtent(values));
-  }
-  if (["sqrt", "pow"].includes(definition.type) && values.every(value => value === 0)) {
-    return cloneAndFreeze([0, 1]);
-  }
-  const domain = resolveTransformedDomain({
-    type: definition.type,
-    domain: "auto",
-    values,
-    ...(definition.type === "log" ? { base: definition.base } : {}),
-    ...(definition.type === "pow" ? { exponent: definition.exponent } : {})
-  });
-  return validateSizeScaleDomain(definition.type, domain);
-}
-
-function quantile(sorted, probability) {
-  const position = (sorted.length - 1) * probability;
-  const lower = Math.floor(position);
-  const upper = Math.ceil(position);
-  return interpolateNumber(
-    sorted[lower],
-    sorted[upper],
-    position - lower
-  );
-}
-
-export function resolveSizeScale({
-  type,
-  domain = "auto",
-  range = "auto",
-  values = [],
-  ...options
-} = {}) {
-  const definition = normalizeSizeScaleDefinition({
-    patch: { type, domain, range, ...options }
-  });
-  validateSizeValues(values, definition.type);
-  if (isContinuousSizeScaleType(definition.type)) {
-    const resolvedDomain = resolveContinuousSizeDomain(definition, values);
-    const resolvedRange = [...resolveSizeRange(definition.range)];
-    if (definition.reverse === true) resolvedRange.reverse();
-    return cloneAndFreeze({
-      type: definition.type,
-      domain: resolvedDomain,
-      range: resolvedRange,
-      ...(definition.clamp === undefined ? {} : { clamp: definition.clamp }),
-      ...(definition.type === "log" ? { base: definition.base } : {}),
-      ...(definition.type === "pow" ? { exponent: definition.exponent } : {}),
-      ...(definition.unknown === undefined ? {} : { unknown: definition.unknown })
-    });
-  }
-
-  const resolvedRange = [...definition.range];
-  if (definition.reverse === true) resolvedRange.reverse();
-  const sample = [...values].sort((left, right) => left - right);
-  let resolvedDomain;
-  let thresholds;
-  if (definition.type === "quantize") {
-    if (definition.domain === "auto") {
-      if (sample.length === 0) {
-        throw new Error(
-          "Cannot infer an automatic quantize size domain from no values."
-        );
-      }
-      resolvedDomain = numericExtent(sample);
-      if (resolvedDomain[0] === resolvedDomain[1]) {
-        throw new RangeError(
-          "Quantize size scale requires a non-zero domain span."
-        );
-      }
-    } else {
-      resolvedDomain = [...definition.domain];
-    }
-    thresholds = Array.from(
-      { length: resolvedRange.length - 1 },
-      (_, index) => interpolateNumber(
-        resolvedDomain[0],
-        resolvedDomain[1],
-        (index + 1) / resolvedRange.length
-      )
-    );
-    if (thresholds.some((value, index) =>
-      value <= (index === 0 ? resolvedDomain[0] : thresholds[index - 1]) ||
-      value >= resolvedDomain[1]
-    )) {
-      throw new RangeError(
-        "Quantize size range requests more buckets than its domain can represent."
-      );
-    }
-  } else if (definition.type === "quantile") {
-    const source = definition.domain === "auto"
-      ? sample
-      : [...definition.domain].sort((left, right) => left - right);
-    if (source.length === 0) {
-      throw new Error(
-        "Cannot infer automatic quantile size thresholds from no values."
-      );
-    }
-    resolvedDomain = source;
-    thresholds = Array.from(
-      { length: resolvedRange.length - 1 },
-      (_, index) => quantile(
-        source,
-        (index + 1) / resolvedRange.length
-      )
-    );
-  } else {
-    resolvedDomain = [...definition.domain];
-    thresholds = [...definition.domain];
-    if (resolvedRange.length !== thresholds.length + 1) {
-      throw new RangeError(
-        "Threshold size range must contain exactly one more area than its domain."
-      );
-    }
-  }
-  return cloneAndFreeze({
-    type: definition.type,
-    domain: resolvedDomain,
-    thresholds,
-    range: resolvedRange,
-    ...(definition.unknown === undefined ? {} : { unknown: definition.unknown })
-  });
-}
-
-export function discretizedSizeIndex(value, thresholds) {
-  if (!Number.isFinite(value)) {
-    throw new TypeError("Discrete size values must be finite numbers.");
-  }
-  let index = 0;
-  while (index < thresholds.length && value >= thresholds[index]) index += 1;
-  return index;
-}
-
-function validateMappedAreas(areas) {
-  if (areas.some(area => !Number.isFinite(area) || area < 0)) {
-    throw new RangeError(
-      "Size scale mapping must produce non-negative finite areas."
-    );
-  }
-  return cloneAndFreeze(areas);
-}
-
-export function mapSizeValues(values, scale) {
-  validateSizeScaleType(scale?.type);
-  const hasUnknown = Object.hasOwn(scale, "unknown");
-  const finite = values.filter(Number.isFinite);
-  validateSizeValues(finite, scale.type);
-  if (!hasUnknown && finite.length !== values.length) {
-    throw new TypeError("Size scale values must be finite numbers.");
-  }
-  let mapped;
-  if (isDiscreteSizeScaleType(scale.type)) {
-    mapped = values.map(value => {
-      if (!Number.isFinite(value)) return scale.unknown;
-      return scale.range[discretizedSizeIndex(value, scale.thresholds)];
-    });
-  } else if (scale.type === "linear") {
-    mapped = mapLinearValues(values, scale.domain, scale.range, {
-      clamp: scale.clamp ?? false,
-      ...(hasUnknown ? { unknown: scale.unknown } : {})
-    });
-  } else {
-    mapped = mapTransformedValues(values, scale.domain, scale.range, {
-      type: scale.type,
-      clamp: scale.clamp ?? false,
-      ...(hasUnknown ? { unknown: scale.unknown } : {}),
-      ...(scale.type === "log" ? { base: scale.base } : {}),
-      ...(scale.type === "pow" ? { exponent: scale.exponent } : {})
-    });
-  }
-  return validateMappedAreas(mapped);
-}
+import{cloneAndFreeze as u}from"../../core/immutable.js";import{validateGeneratedItemLimit as g,validatePositiveFinite as R}from"../../core/validation.js";import{interpolateNumber as $,numericExtent as q}from"../numeric.js";import{isNominalValue as A}from"./fields.js";import{resolveOrdinalDomain as C,validateOrdinalDomain as I}from"./ordinal.js";import{mapLinearValues as _}from"./continuous.js";import{mapTransformedValues as j,resolveTransformedDomain as F}from"./transformed.js";import{validateSizeRange as N,DEFAULT_SIZE_RANGE as P,mapOrdinalValues as L}from"./appearance.js";import{validateScaleUnknown as V}from"./policies.js";import{validatePair as U,validateFiniteScaleArray as E}from"./validation.js";import{resolveDiscretizedDomain as Z,validateDiscretizedDomain as Y,discretizedColorIndex as G}from"./discretized.js";const x=u(["linear","log","sqrt","pow"]),O=u(["quantize","quantile","threshold"]),M=u([...x,...O,"ordinal"]);function m(e){return x.includes(e)}function f(e){return O.includes(e)}function ce(e){return e==="ordinal"||f(e)}function B(e){return M.includes(e)}function w(e){if(!B(e))throw new Error(`Scale type "${e}" is not valid for size.`);return e}function v(e,n,t){if(n==="log"&&e.some(o=>o<=0))throw new RangeError(`Size log scale ${t} must be strictly positive.`);if(["sqrt","pow"].includes(n)&&e.some(o=>o<0))throw new RangeError(`Size ${n} scale ${t} must be non-negative.`);return e}function H(e,n){const t=U(n,"Size scale domain");if(e!=="linear"&&t[0]===t[1])throw new RangeError(`Size ${e} scale domain values must be distinct.`);return v(t,e,"domain")}function z(e,n){return w(e),e==="ordinal"?I(n):m(e)?n==="auto"?n:H(e,n):Y(e,n,"size")}function J(e){if(E(e,"Discrete size range",2),g(e.length,"Discrete size range length"),e.some(n=>n<0))throw new RangeError("Discrete size range must contain non-negative areas.");if(e.some((n,t)=>t>0&&n<e[t-1]))throw new RangeError("Discrete size range must be nondecreasing.");return u(e)}function K(e,n){if(w(e),m(e))return N(n);if(e==="ordinal")return n==="auto"?n:(E(n,"Ordinal size range"),g(n.length,"Ordinal size range length"),y(n));if(n==="auto")throw new Error(`Size ${e} scale requires an explicit range.`);return J(n)}function D(e){return m(e)?"continuous":e}function Q({previous:e={},patch:n={}}={}){const t=w(n.type??e.type??"linear"),s=e.type!==void 0&&e.type!==t;if(s&&D(e.type)!==D(t)&&!Object.hasOwn(n,"domain"))throw new Error("Size scale type-family transition requires an explicit domain.");if(s&&f(t)&&!Object.hasOwn(n,"range"))throw new Error(`Size ${t} scale transition requires an explicit range.`);if(s&&f(e.type)&&m(t)&&!Object.hasOwn(n,"range"))throw new Error("Discrete-to-continuous size scale transition requires an explicit range.");for(const i of["nice","zero","constant","padding","paddingInner","paddingOuter","align","palette","interpolate","midpoint","radialMapping"])if(Object.hasOwn(n,i))throw new Error(`Size scale does not support ${i}.`);const r={domain:"auto",range:"auto",...e,...n},a={type:t,domain:z(t,r.domain),range:K(t,r.range)};for(const i of["reverse","clamp"]){if(i==="clamp"&&!m(t)){if(Object.hasOwn(n,i))throw new Error(`Size ${t} scale does not support clamp.`);continue}const p=Object.hasOwn(n,i)?n[i]:i==="clamp"&&!m(e.type)?void 0:e[i];if(p!==void 0){if(typeof p!="boolean")throw new TypeError(`Size scale ${i} must be a boolean.`);a[i]=p}}for(const[i,p,c]of[["base","log",10],["exponent","pow"]]){if(t!==p){if(Object.hasOwn(n,i))throw new Error(`Size ${t} scale does not support ${i}.`);continue}const l=Object.hasOwn(n,i)?n[i]:!s&&e.type===p?e[i]:c;if(i==="exponent"&&l===void 0)throw new Error("Size pow scale requires an explicit exponent.");if(a[i]=R(i==="base"?l??c:l,`Size ${t} scale ${i}`),i==="base"&&a.base===1)throw new RangeError("Size log scale base must not equal 1.")}const d=Object.hasOwn(n,"unknown")?n.unknown:e.unknown;return d!==void 0&&(a.unknown=V("size",d)),u(a)}function k(e,n){if(!Array.isArray(e)||!e.every(Number.isFinite))throw new TypeError("Size scale values must be finite numbers.");return v(e,n,"values")}function W(e,n){if(e.domain!=="auto")return z(e.type,e.domain);if(n.length===0)throw new Error("Cannot infer an automatic size scale domain from no values.");if(e.type==="linear")return u(q(n));if(["sqrt","pow"].includes(e.type)&&n.every(o=>o===0))return u([0,1]);const t=F({type:e.type,domain:"auto",values:n,...e.type==="log"?{base:e.base}:{},...e.type==="pow"?{exponent:e.exponent}:{}});return z(e.type,t)}function fe({type:e,domain:n="auto",range:t="auto",values:o=[],...s}={}){const r=Q({patch:{type:e,domain:n,range:t,...s}}),a=r.type==="ordinal",d=a?o.filter(A):k(o,r.type);if(a&&d.length!==o.length&&r.unknown===void 0)throw new TypeError("Ordinal size values must be nominal values.");if(a||m(r.type)){const l=a?C(r.domain,d):W(r,o);a&&g(l.length,"Ordinal size domain length");const S=r.range==="auto"?P:r.range,h=a&&r.range==="auto"?l.map((ne,T)=>$(S[0],S[1],l.length===1?.5:T/(l.length-1))):[...S];r.reverse===!0&&h.reverse();const b=u({type:r.type,domain:l,range:h,...r.clamp===void 0?{}:{clamp:r.clamp},...r.type==="log"?{base:r.base}:{},...r.type==="pow"?{exponent:r.exponent}:{},...r.unknown===void 0?{}:{unknown:r.unknown}});return a&&ee(o,b),b}const i=[...r.range];r.reverse===!0&&i.reverse();const{domain:p,thresholds:c}=Z({type:r.type,domain:r.domain,values:o,count:i.length,kind:"size"});return u({type:r.type,domain:p,thresholds:c,range:i,...r.unknown===void 0?{}:{unknown:r.unknown}})}function X(e,n){return G(e,n,"Discrete size")}function y(e){if(e.some(n=>!Number.isFinite(n)||n<0))throw new RangeError("Size scale mapping must produce non-negative finite areas.");return u(e)}function ee(e,n){w(n?.type);const t=Object.hasOwn(n,"unknown");if(n.type==="ordinal")return y(L(e,n.domain,n.range,t?{unknown:n.unknown}:{}));const o=e.filter(Number.isFinite);if(k(o,n.type),!t&&o.length!==e.length)throw new TypeError("Size scale values must be finite numbers.");let s;return f(n.type)?s=e.map(r=>Number.isFinite(r)?n.range[X(r,n.thresholds)]:n.unknown):s=(n.type==="linear"?_:j)(e,n.domain,n.range,{type:n.type,clamp:n.clamp??!1,...t?{unknown:n.unknown}:{},...n.type==="log"?{base:n.base}:{},...n.type==="pow"?{exponent:n.exponent}:{}}),y(s)}export{x as CONTINUOUS_SIZE_SCALE_TYPES,O as DISCRETE_SIZE_SCALE_TYPES,M as SIZE_SCALE_TYPES,X as discretizedSizeIndex,m as isContinuousSizeScaleType,f as isDiscreteSizeScaleType,ce as isEnumeratedSizeScaleType,B as isSizeScaleType,ee as mapSizeValues,Q as normalizeSizeScaleDefinition,fe as resolveSizeScale,J as validateDiscreteSizeRange,z as validateSizeScaleDomain,K as validateSizeScaleRange,w as validateSizeScaleType};

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.");
   }