@primeui/chart-core 0.0.1-alpha.1

package/dist/chunk-RQ3CKQOX.mjs

@@ -0,0 +1,984 @@
+// src/utils/math/geometry.ts
+function crisp(value, strokeWidth = 1) {
+  if (strokeWidth % 2 === 0) return Math.round(value);
+  return Math.round(value) + 0.5;
+}
+var toRad = (degrees) => degrees * Math.PI / 180;
+var xCalc = (angle, radius) => {
+  return radius * Math.cos(toRad(angle));
+};
+var yCalc = (angle, radius) => {
+  return radius * Math.sin(toRad(angle));
+};
+var pointOnCircle = (cx, cy, angle, radius) => {
+  return {
+    x: cx + xCalc(angle, radius),
+    y: cy + yCalc(angle, radius)
+  };
+};
+var normalizeAngle = (angle) => {
+  const normalized = angle % 360;
+  return normalized < 0 ? normalized + 360 : normalized;
+};
+var normalizeAngleRelativeTo = (angle, rotation) => {
+  return normalizeAngle(angle - rotation) + rotation;
+};
+var calculateArcBoundingBox = (cx, cy, radius, startAngle, sweepAngle) => {
+  let minX = cx;
+  let maxX = cx;
+  let minY = cy;
+  let maxY = cy;
+  const endAngle = startAngle + sweepAngle;
+  const startPoint = pointOnCircle(cx, cy, startAngle, radius);
+  minX = Math.min(minX, startPoint.x);
+  maxX = Math.max(maxX, startPoint.x);
+  minY = Math.min(minY, startPoint.y);
+  maxY = Math.max(maxY, startPoint.y);
+  const endPoint = pointOnCircle(cx, cy, endAngle, radius);
+  minX = Math.min(minX, endPoint.x);
+  maxX = Math.max(maxX, endPoint.x);
+  minY = Math.min(minY, endPoint.y);
+  maxY = Math.max(maxY, endPoint.y);
+  const cardinalAngles = [0, 90, 180, 270];
+  for (const cardinal of cardinalAngles) {
+    if (isAngleInArc(cardinal, startAngle, sweepAngle)) {
+      const point = pointOnCircle(cx, cy, cardinal, radius);
+      minX = Math.min(minX, point.x);
+      maxX = Math.max(maxX, point.x);
+      minY = Math.min(minY, point.y);
+      maxY = Math.max(maxY, point.y);
+    }
+  }
+  const width = maxX - minX;
+  const height = maxY - minY;
+  const visualCenterX = (minX + maxX) / 2;
+  const visualCenterY = (minY + maxY) / 2;
+  const centerOffsetX = cx - visualCenterX;
+  const centerOffsetY = cy - visualCenterY;
+  return {
+    minX,
+    maxX,
+    minY,
+    maxY,
+    width,
+    height,
+    centerOffsetX,
+    centerOffsetY
+  };
+};
+var isAngleInArc = (angle, startAngle, sweepAngle) => {
+  const normalizedAngle = normalizeAngle(angle);
+  const normalizedStart = normalizeAngle(startAngle);
+  const endAngle = normalizedStart + sweepAngle;
+  if (sweepAngle >= 360) {
+    return true;
+  }
+  if (endAngle <= 360) {
+    return normalizedAngle >= normalizedStart && normalizedAngle <= endAngle;
+  } else {
+    const wrappedEnd = endAngle - 360;
+    return normalizedAngle >= normalizedStart || normalizedAngle <= wrappedEnd;
+  }
+};
+
+// src/utils/math/number.ts
+var clamp = (value, min, max) => {
+  return Math.min(Math.max(value, min), max);
+};
+var scaleLinear = (value, domainMin, domainMax, rangeMin, rangeMax) => {
+  return (value - domainMin) / (domainMax - domainMin) * (rangeMax - rangeMin) + rangeMin;
+};
+var findMin = (data) => {
+  let min = Infinity;
+  if (Array.isArray(data[0])) {
+    for (const arr of data) {
+      for (const val of arr) {
+        if (val < min) min = val;
+      }
+    }
+  } else {
+    for (const val of data) {
+      if (val < min) min = val;
+    }
+  }
+  return min;
+};
+var findMax = (data, isStacked = false) => {
+  if (Array.isArray(data[0])) {
+    const multiData = data;
+    if (isStacked) {
+      const numCategories = multiData[0]?.length ?? 0;
+      let maxSum = 0;
+      for (let catIdx = 0; catIdx < numCategories; catIdx++) {
+        let sum = 0;
+        for (let seriesIdx = 0; seriesIdx < multiData.length; seriesIdx++) {
+          sum += multiData[seriesIdx][catIdx];
+        }
+        maxSum = Math.max(maxSum, sum);
+      }
+      return maxSum;
+    }
+    let max2 = -Infinity;
+    for (const arr of multiData) {
+      for (const val of arr) {
+        if (val > max2) max2 = val;
+      }
+    }
+    return max2;
+  }
+  let max = -Infinity;
+  for (const val of data) {
+    if (val > max) max = val;
+  }
+  return max;
+};
+
+// src/utils/math/compare.ts
+function shallowEqual(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null) return false;
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false;
+  for (const key of keysA) {
+    if (!equalValue(a[key], b[key])) return false;
+  }
+  return true;
+}
+function equalValue(va, vb) {
+  if (va === vb) return true;
+  if (typeof va === "function" && typeof vb === "function") return true;
+  if (typeof va !== "object" || typeof vb !== "object") return false;
+  if (va === null || vb === null) return false;
+  const aIsArray = Array.isArray(va);
+  const bIsArray = Array.isArray(vb);
+  if (aIsArray !== bIsArray) return false;
+  if (aIsArray) {
+    const aArr = va;
+    const bArr = vb;
+    if (aArr.length !== bArr.length) return false;
+    for (let i = 0; i < aArr.length; i++) {
+      if (!equalValue(aArr[i], bArr[i])) return false;
+    }
+    return true;
+  }
+  return shallowEqual(va, vb);
+}
+
+// src/utils/math/ticks.ts
+function generateLogTicks(min, max, count = 5) {
+  const logMin = Math.floor(Math.log10(Math.max(min, 1e-10)));
+  const logMax = Math.ceil(Math.log10(Math.max(max, 1e-10)));
+  const decades = logMax - logMin;
+  if (decades <= 0) return [min, max];
+  const ticks = [];
+  if (decades <= count) {
+    const density = count / Math.max(decades, 1);
+    const subMults = density >= 9 ? [2, 3, 4, 5, 6, 7, 8, 9] : density >= 4 ? [2, 3, 5, 7] : density >= 2 ? [2, 5] : [];
+    for (let exp = logMin; exp <= logMax; exp++) {
+      const base = Math.pow(10, exp);
+      ticks.push(base);
+      for (const m of subMults) {
+        if (base * m <= max) ticks.push(base * m);
+      }
+    }
+  } else {
+    const step = Math.max(1, Math.ceil(decades / count));
+    for (let exp = logMin; exp <= logMax; exp += step) {
+      ticks.push(Math.pow(10, exp));
+    }
+  }
+  return ticks.filter((t) => t >= min && t <= max).sort((a, b) => a - b);
+}
+function generateNiceTicks(min, max, count = 5, exact = false) {
+  if (count < 2) count = 2;
+  const span = max - min;
+  if (span === 0) return [min];
+  const rawStep = span / (count - 1);
+  const magnitude = Math.pow(10, Math.floor(Math.log10(rawStep)));
+  const normalized = rawStep / magnitude;
+  const multiples = exact ? [1, 1.2, 1.5, 2, 2.5, 3, 4, 5, 6, 8, 10] : [1, 2, 2.5, 5, 10];
+  let chosen = multiples[multiples.length - 1];
+  for (let i = 0; i < multiples.length; i++) {
+    const m = multiples[i];
+    const accept = exact ? m >= normalized : normalized <= (m + (multiples[i + 1] ?? m)) / 2;
+    if (accept) {
+      chosen = m;
+      break;
+    }
+  }
+  const niceStep = Math.round(chosen * magnitude * 1e10) / 1e10;
+  const niceMin = Math.floor(min / niceStep) * niceStep;
+  const ticks = [];
+  for (let tick = niceMin; tick <= max + niceStep * 0.5; tick += niceStep) {
+    const rounded = Math.round(tick * 1e10) / 1e10;
+    if (rounded < min - niceStep * 1e-3) continue;
+    ticks.push(rounded);
+    if (ticks.length > count + 2) break;
+  }
+  if (exact) {
+    const onThreshold = min === 0;
+    while (ticks.length < count) {
+      const appendSide = ticks.length % 2 === 1 || onThreshold;
+      if (appendSide) {
+        ticks.push(Math.round((ticks[ticks.length - 1] + niceStep) * 1e10) / 1e10);
+      } else {
+        ticks.unshift(Math.round((ticks[0] - niceStep) * 1e10) / 1e10);
+      }
+    }
+  }
+  return ticks;
+}
+function generateIntervalTicks(min, max, interval) {
+  if (interval <= 0 || !isFinite(interval)) return generateNiceTicks(min, max);
+  const ticks = [];
+  const start = Math.ceil(min / interval) * interval;
+  const roundedStart = Math.round(start * 1e10) / 1e10;
+  for (let tick = roundedStart; tick <= max + interval * 1e-3; tick += interval) {
+    const rounded = Math.round(tick * 1e10) / 1e10;
+    ticks.push(rounded);
+    if (ticks.length > 200) break;
+  }
+  return ticks;
+}
+
+// src/utils/math/domain.ts
+function calculateNiceLogDomain(values) {
+  const positiveValues = values.filter((v) => v > 0);
+  if (positiveValues.length === 0) return [1, 10];
+  let min = Infinity;
+  let max = -Infinity;
+  for (const v of positiveValues) {
+    if (v < min) min = v;
+    if (v > max) max = v;
+  }
+  const FLOOR_STEPS = [1, 2, 5];
+  const CEIL_STEPS = [1, 2, 5, 10];
+  const floorNice = (v) => {
+    const k = Math.floor(Math.log10(v));
+    const base = Math.pow(10, k);
+    const m = v / base;
+    let step = FLOOR_STEPS[0];
+    for (const s of FLOOR_STEPS) if (s <= m + 1e-9) step = s;
+    return step * base;
+  };
+  const ceilNice = (v) => {
+    const k = Math.floor(Math.log10(v));
+    const base = Math.pow(10, k);
+    const m = v / base;
+    for (const s of CEIL_STEPS) if (s >= m - 1e-9) return s * base;
+    return 10 * base;
+  };
+  min = floorNice(min);
+  max = ceilNice(max);
+  if (min === max) max = min * 2;
+  return [min, max];
+}
+var DOMAIN_CACHE_MAX = 64;
+var domainCache = /* @__PURE__ */ new Map();
+function cacheDomain(key, result) {
+  if (domainCache.size >= DOMAIN_CACHE_MAX) {
+    const firstKey = domainCache.keys().next().value;
+    if (firstKey !== void 0) domainCache.delete(firstKey);
+  }
+  domainCache.set(key, result);
+}
+function calculateNiceDomain(values, options = {}) {
+  const { min: minOpt = "auto", max: maxOpt = "auto", includeZero = true, nice = true } = options;
+  if (values.length === 0) {
+    return [0, 1];
+  }
+  let rawMin = Infinity;
+  let rawMax = -Infinity;
+  for (const v of values) {
+    if (v < rawMin) rawMin = v;
+    if (v > rawMax) rawMax = v;
+  }
+  const cacheKey = `${rawMin}_${rawMax}_${minOpt}_${maxOpt}_${includeZero}_${nice}`;
+  const cached = domainCache.get(cacheKey);
+  if (cached) {
+    domainCache.delete(cacheKey);
+    domainCache.set(cacheKey, cached);
+    return cached;
+  }
+  let min = minOpt === "auto" ? rawMin : minOpt;
+  let max = maxOpt === "auto" ? rawMax : maxOpt;
+  if (includeZero) {
+    if (min > 0) min = 0;
+    if (max < 0) max = 0;
+  }
+  if (min === max) {
+    if (min === 0) return [0, 1];
+    const padding = Math.abs(min) * 0.1;
+    const result2 = [min - padding, max + padding];
+    cacheDomain(cacheKey, result2);
+    return result2;
+  }
+  let result;
+  if (nice) {
+    const span = max - min;
+    const magnitude = Math.pow(10, Math.floor(Math.log10(span)));
+    let niceMin = Math.floor(min / magnitude) * magnitude;
+    let niceMax = Math.ceil(max / magnitude) * magnitude;
+    const halfStep = magnitude / 2;
+    const tighterMax = Math.ceil(max / halfStep) * halfStep;
+    if (niceMax - max > halfStep && tighterMax >= max) niceMax = tighterMax;
+    const tighterMin = Math.floor(min / halfStep) * halfStep;
+    if (min - niceMin > halfStep && tighterMin <= min) niceMin = tighterMin;
+    if (niceMax < rawMax && !(includeZero && rawMax <= 0)) {
+      niceMax += magnitude;
+    }
+    if (niceMin >= rawMin && !(includeZero && rawMin >= 0)) {
+      niceMin -= magnitude;
+      if (rawMin >= 0) niceMin = Math.max(niceMin, 0);
+    }
+    if (includeZero) {
+      result = [Math.min(niceMin, 0), Math.max(niceMax, 0)];
+    } else {
+      result = [niceMin, niceMax];
+    }
+  } else {
+    result = [min, max];
+  }
+  cacheDomain(cacheKey, result);
+  return result;
+}
+
+// src/utils/devWarnings.ts
+var CHART_WARNING_PREFIX = "[PrimeUI Chart]";
+var issuedWarnings = /* @__PURE__ */ new Set();
+function getImportMetaEnv() {
+  return import.meta.env ?? {};
+}
+function isChartDevWarningsEnabled() {
+  const env = getImportMetaEnv();
+  return Boolean(env.DEV) && !env.PROD;
+}
+function warnChartDevOnce(key, message) {
+  if (!isChartDevWarningsEnabled() || issuedWarnings.has(key)) {
+    return;
+  }
+  issuedWarnings.add(key);
+  console.warn(`${CHART_WARNING_PREFIX} ${message}`);
+}
+
+// src/utils/math/scales.ts
+function createBandScale(domainValues, rangeValues, options = {}) {
+  const { chartPaddingMin = 0.05, chartPaddingMax = 0.05, categoryGap = 0.1 } = options;
+  const n = domainValues.length;
+  const rangeSpan = rangeValues[1] - rangeValues[0];
+  const paddingMinPx = rangeSpan * chartPaddingMin;
+  const paddingMaxPx = rangeSpan * chartPaddingMax;
+  const availableSpan = rangeSpan - paddingMinPx - paddingMaxPx;
+  const totalUnits = n - categoryGap;
+  const stepValue = n > 0 && totalUnits > 0 ? availableSpan / totalUnits : 0;
+  const bandwidthValue = stepValue * (1 - categoryGap);
+  const start = rangeValues[0] + paddingMinPx;
+  const indexMap = /* @__PURE__ */ new Map();
+  domainValues.forEach((cat, i) => indexMap.set(cat, i));
+  const scale = ((category) => {
+    const index = indexMap.get(category);
+    if (index === void 0) {
+      return NaN;
+    }
+    return start + index * stepValue;
+  });
+  scale.bandwidth = () => bandwidthValue;
+  scale.step = () => stepValue;
+  scale.domain = () => [...domainValues];
+  scale.range = () => [...rangeValues];
+  return scale;
+}
+function createVariwideBandScale(domainValues, rangeValues, options) {
+  const { chartPaddingMin = 0.05, chartPaddingMax = 0.05, categoryGap = 0.1, weights } = options;
+  const n = domainValues.length;
+  const rangeSpan = rangeValues[1] - rangeValues[0];
+  if (n === 0) {
+    const emptyScale = Object.assign((() => rangeValues[0]), { bandwidth: () => 0, bandwidthAt: () => 0, step: () => 0, domain: () => [], range: () => [...rangeValues] });
+    return emptyScale;
+  }
+  let totalWeight = 0;
+  for (const w of weights) totalWeight += Math.max(w, 0);
+  if (totalWeight === 0) totalWeight = n;
+  const paddingMinPx = rangeSpan * chartPaddingMin;
+  const paddingMaxPx = rangeSpan * chartPaddingMax;
+  const availableSpan = rangeSpan - paddingMinPx - paddingMaxPx;
+  const totalUnits = n - categoryGap;
+  const avgStep = totalUnits > 0 ? availableSpan / totalUnits : 0;
+  const gapPx = avgStep * categoryGap;
+  const totalGaps = (n - 1) * gapPx;
+  const barSpace = availableSpan - totalGaps;
+  const bandwidths = [];
+  for (let i = 0; i < n; i++) {
+    const w = Math.max(weights[i] ?? 0, 0) || totalWeight / n;
+    bandwidths[i] = w / totalWeight * barSpace;
+  }
+  const leftEdges = [];
+  let cursor = rangeValues[0] + paddingMinPx;
+  for (let i = 0; i < n; i++) {
+    leftEdges[i] = cursor;
+    cursor += bandwidths[i] + gapPx;
+  }
+  const indexMap = /* @__PURE__ */ new Map();
+  domainValues.forEach((cat, i) => indexMap.set(cat, i));
+  const avgBandwidth = barSpace / n;
+  const scale = ((category) => {
+    const idx = indexMap.get(category);
+    return idx !== void 0 ? leftEdges[idx] : rangeValues[0];
+  });
+  scale.bandwidth = () => avgBandwidth;
+  scale.bandwidthAt = (index) => bandwidths[index] ?? avgBandwidth;
+  scale.step = () => avgStep;
+  scale.domain = () => [...domainValues];
+  scale.range = () => [...rangeValues];
+  return scale;
+}
+function createLinearScale(domainValues, rangeValues) {
+  const domainSpan = domainValues[1] - domainValues[0];
+  const rangeSpan = rangeValues[1] - rangeValues[0];
+  const scale = ((value) => {
+    if (domainSpan === 0) return rangeValues[0];
+    return rangeValues[0] + (value - domainValues[0]) / domainSpan * rangeSpan;
+  });
+  scale.invert = (pixel) => {
+    if (rangeSpan === 0) return domainValues[0];
+    return domainValues[0] + (pixel - rangeValues[0]) / rangeSpan * domainSpan;
+  };
+  scale.ticks = (count = 5, exact = false) => {
+    return generateNiceTicks(domainValues[0], domainValues[1], count, exact);
+  };
+  scale.domain = () => [...domainValues];
+  scale.range = () => [...rangeValues];
+  return scale;
+}
+function createLogScale(domainValues, rangeValues) {
+  if (domainValues[0] <= 0) {
+    warnChartDevOnce(
+      "log-scale-nonpositive-domain",
+      `Logarithmic axis received a non-positive domain minimum (${domainValues[0]}). Values \u2264 0 cannot be represented on a log scale and are clamped to 1e-10 \u2014 negative/zero data points will be dropped or misplaced. Use a linear axis for data with non-positive values.`
+    );
+  }
+  const safeMin = Math.max(domainValues[0], 1e-10);
+  const safeMax = Math.max(domainValues[1], safeMin * 10);
+  const logMin = Math.log10(safeMin);
+  const logMax = Math.log10(safeMax);
+  const logSpan = logMax - logMin;
+  const rangeSpan = rangeValues[1] - rangeValues[0];
+  const scale = ((value) => {
+    if (logSpan === 0) return rangeValues[0];
+    const logValue = Math.log10(Math.max(value, 1e-10));
+    return rangeValues[0] + (logValue - logMin) / logSpan * rangeSpan;
+  });
+  scale.invert = (pixel) => {
+    if (rangeSpan === 0) return safeMin;
+    const logValue = logMin + (pixel - rangeValues[0]) / rangeSpan * logSpan;
+    return Math.pow(10, logValue);
+  };
+  scale.ticks = (count = 5) => {
+    return generateLogTicks(safeMin, safeMax, count);
+  };
+  scale.domain = () => [safeMin, safeMax];
+  scale.range = () => [...rangeValues];
+  return scale;
+}
+
+// src/utils/math/grouped-bar.ts
+function calculateGroupedBarLayout(seriesCount, groupWidth, barGap = 0.02) {
+  if (seriesCount <= 0 || seriesCount === 1) {
+    return { barWidth: groupWidth, getOffset: () => 0 };
+  }
+  const numberOfGaps = seriesCount - 1;
+  const gapWidth = groupWidth * barGap;
+  const totalGapWidth = gapWidth * numberOfGaps;
+  const barWidth = (groupWidth - totalGapWidth) / seriesCount;
+  const getOffset = (seriesIndex) => {
+    return seriesIndex * (barWidth + gapWidth);
+  };
+  return { barWidth, getOffset };
+}
+
+// src/utils/data/time/core.ts
+var MS = {
+  millisecond: 1,
+  second: 1e3,
+  minute: 6e4,
+  hour: 36e5,
+  day: 864e5,
+  week: 6048e5,
+  month: 2592e6,
+  // 30 days approx
+  quarter: 7776e6,
+  // 90 days approx
+  year: 31536e6
+  // 365 days approx
+};
+var TICK_INTERVALS = [
+  // milliseconds
+  { unit: "millisecond", count: 1 },
+  { unit: "millisecond", count: 2 },
+  { unit: "millisecond", count: 5 },
+  { unit: "millisecond", count: 10 },
+  { unit: "millisecond", count: 20 },
+  { unit: "millisecond", count: 50 },
+  { unit: "millisecond", count: 100 },
+  { unit: "millisecond", count: 200 },
+  { unit: "millisecond", count: 500 },
+  // seconds
+  { unit: "second", count: 1 },
+  { unit: "second", count: 2 },
+  { unit: "second", count: 5 },
+  { unit: "second", count: 10 },
+  { unit: "second", count: 15 },
+  { unit: "second", count: 30 },
+  // minutes
+  { unit: "minute", count: 1 },
+  { unit: "minute", count: 2 },
+  { unit: "minute", count: 5 },
+  { unit: "minute", count: 10 },
+  { unit: "minute", count: 15 },
+  { unit: "minute", count: 30 },
+  // hours
+  { unit: "hour", count: 1 },
+  { unit: "hour", count: 2 },
+  { unit: "hour", count: 3 },
+  { unit: "hour", count: 4 },
+  { unit: "hour", count: 6 },
+  { unit: "hour", count: 8 },
+  { unit: "hour", count: 12 },
+  // days
+  { unit: "day", count: 1 },
+  { unit: "day", count: 2 },
+  { unit: "day", count: 7 },
+  { unit: "day", count: 14 },
+  // weeks
+  { unit: "week", count: 1 },
+  { unit: "week", count: 2 },
+  { unit: "week", count: 4 },
+  // months
+  { unit: "month", count: 1 },
+  { unit: "month", count: 2 },
+  { unit: "month", count: 3 },
+  { unit: "month", count: 4 },
+  { unit: "month", count: 6 },
+  // quarters
+  { unit: "quarter", count: 1 },
+  // years
+  { unit: "year", count: 1 },
+  { unit: "year", count: 2 },
+  { unit: "year", count: 5 },
+  { unit: "year", count: 10 },
+  { unit: "year", count: 25 },
+  { unit: "year", count: 50 },
+  { unit: "year", count: 100 }
+];
+var DEFAULT_FORMATS = {
+  millisecond: { hour: "2-digit", minute: "2-digit", second: "2-digit", fractionalSecondDigits: 3 },
+  second: { hour: "2-digit", minute: "2-digit", second: "2-digit" },
+  minute: { hour: "2-digit", minute: "2-digit" },
+  hour: { hour: "2-digit", minute: "2-digit" },
+  day: { month: "short", day: "numeric" },
+  week: { month: "short", day: "numeric" },
+  month: { month: "short", year: "numeric" },
+  quarter: { month: "short", year: "numeric" },
+  year: { year: "numeric" }
+};
+function toTimestamp(value) {
+  if (value instanceof Date) return value.getTime();
+  if (typeof value === "number") return value;
+  if (typeof value === "string") {
+    const num = Number(value);
+    if (value.trim() !== "" && !isNaN(num)) return num;
+    const ms = Date.parse(value);
+    if (!isNaN(ms)) return ms;
+  }
+  return NaN;
+}
+function intervalSpanMs(interval) {
+  return MS[interval.unit] * interval.count;
+}
+function selectTickInterval(domainSpanMs, pixelWidth, config) {
+  if (config?.baseInterval) return config.baseInterval;
+  const minSpacing = config?.minTickSpacing ?? 80;
+  const maxTicks = Math.max(2, Math.floor(pixelWidth / minSpacing));
+  const minIntervalMs = config?.minInterval ? intervalSpanMs(config.minInterval) : 0;
+  for (const interval of TICK_INTERVALS) {
+    if (minIntervalMs > 0 && intervalSpanMs(interval) < minIntervalMs) continue;
+    const approxTicks = domainSpanMs / intervalSpanMs(interval);
+    if (approxTicks <= maxTicks) return interval;
+  }
+  return TICK_INTERVALS[TICK_INTERVALS.length - 1];
+}
+function floorToUnit(timestamp, unit, multiple) {
+  const d = new Date(timestamp);
+  switch (unit) {
+    case "millisecond": {
+      const ms = d.getUTCMilliseconds();
+      d.setUTCMilliseconds(ms - ms % multiple);
+      return d.getTime();
+    }
+    case "second": {
+      d.setUTCMilliseconds(0);
+      const s = d.getUTCSeconds();
+      d.setUTCSeconds(s - s % multiple);
+      return d.getTime();
+    }
+    case "minute": {
+      d.setUTCMilliseconds(0);
+      d.setUTCSeconds(0);
+      const m = d.getUTCMinutes();
+      d.setUTCMinutes(m - m % multiple);
+      return d.getTime();
+    }
+    case "hour": {
+      d.setUTCMilliseconds(0);
+      d.setUTCSeconds(0);
+      d.setUTCMinutes(0);
+      const h = d.getUTCHours();
+      d.setUTCHours(h - h % multiple);
+      return d.getTime();
+    }
+    case "day": {
+      d.setUTCMilliseconds(0);
+      d.setUTCSeconds(0);
+      d.setUTCMinutes(0);
+      d.setUTCHours(0);
+      if (multiple > 1) {
+        const daysSinceEpoch = Math.floor(d.getTime() / MS.day);
+        return (daysSinceEpoch - daysSinceEpoch % multiple) * MS.day;
+      }
+      return d.getTime();
+    }
+    case "week": {
+      d.setUTCMilliseconds(0);
+      d.setUTCSeconds(0);
+      d.setUTCMinutes(0);
+      d.setUTCHours(0);
+      const dow = d.getUTCDay();
+      const diff = dow === 0 ? 6 : dow - 1;
+      d.setUTCDate(d.getUTCDate() - diff);
+      if (multiple > 1) {
+        const weeksSinceEpoch = Math.floor(d.getTime() / MS.week);
+        const floored = weeksSinceEpoch - weeksSinceEpoch % multiple;
+        return floored * MS.week;
+      }
+      return d.getTime();
+    }
+    case "month": {
+      d.setUTCMilliseconds(0);
+      d.setUTCSeconds(0);
+      d.setUTCMinutes(0);
+      d.setUTCHours(0);
+      d.setUTCDate(1);
+      const m = d.getUTCMonth();
+      d.setUTCMonth(m - m % multiple);
+      return d.getTime();
+    }
+    case "quarter": {
+      d.setUTCMilliseconds(0);
+      d.setUTCSeconds(0);
+      d.setUTCMinutes(0);
+      d.setUTCHours(0);
+      d.setUTCDate(1);
+      const q = Math.floor(d.getUTCMonth() / 3);
+      d.setUTCMonth(q * 3);
+      return d.getTime();
+    }
+    case "year": {
+      d.setUTCMilliseconds(0);
+      d.setUTCSeconds(0);
+      d.setUTCMinutes(0);
+      d.setUTCHours(0);
+      d.setUTCDate(1);
+      d.setUTCMonth(0);
+      const y = d.getUTCFullYear();
+      d.setUTCFullYear(y - y % multiple);
+      return d.getTime();
+    }
+  }
+}
+function advanceByUnit(timestamp, unit, count) {
+  const d = new Date(timestamp);
+  switch (unit) {
+    case "millisecond":
+      return timestamp + count;
+    case "second":
+      return timestamp + count * MS.second;
+    case "minute":
+      return timestamp + count * MS.minute;
+    case "hour":
+      return timestamp + count * MS.hour;
+    case "day":
+      d.setUTCDate(d.getUTCDate() + count);
+      return d.getTime();
+    case "week":
+      d.setUTCDate(d.getUTCDate() + count * 7);
+      return d.getTime();
+    case "month":
+      d.setUTCMonth(d.getUTCMonth() + count);
+      return d.getTime();
+    case "quarter":
+      d.setUTCMonth(d.getUTCMonth() + count * 3);
+      return d.getTime();
+    case "year":
+      d.setUTCFullYear(d.getUTCFullYear() + count);
+      return d.getTime();
+  }
+}
+
+// src/utils/data/time/ticks.ts
+function generateTimeTicks(min, max, pixelWidth, config) {
+  const domainSpan = max - min;
+  if (domainSpan <= 0 || pixelWidth <= 0) {
+    return { ticks: [min], interval: { unit: "day", count: 1 } };
+  }
+  const interval = selectTickInterval(domainSpan, pixelWidth, config);
+  const ticks = [];
+  let current = floorToUnit(min, interval.unit, interval.count);
+  if (current < min) {
+    current = advanceByUnit(current, interval.unit, interval.count);
+  }
+  const MAX_TICKS = 200;
+  while (current <= max && ticks.length < MAX_TICKS) {
+    ticks.push(current);
+    const next = advanceByUnit(current, interval.unit, interval.count);
+    if (next <= current) break;
+    current = next;
+  }
+  return { ticks, interval };
+}
+var FORMATTER_CACHE_MAX = 50;
+var formatterCache = /* @__PURE__ */ new Map();
+function getFormatter(timezone, options, locale) {
+  const key = `${locale ?? ""}|${timezone ?? "UTC"}|${JSON.stringify(options)}`;
+  let fmt = formatterCache.get(key);
+  if (fmt) return fmt;
+  if (formatterCache.size >= FORMATTER_CACHE_MAX) {
+    const firstKey = formatterCache.keys().next().value;
+    if (firstKey !== void 0) formatterCache.delete(firstKey);
+  }
+  fmt = new Intl.DateTimeFormat(locale, { timeZone: timezone ?? "UTC", ...options });
+  formatterCache.set(key, fmt);
+  return fmt;
+}
+function formatDateTemplate(timestamp, template, timezone, locale) {
+  const d = new Date(timestamp);
+  const getPart = (opts) => {
+    return new Intl.DateTimeFormat(locale ?? "en-US", { timeZone: timezone ?? "UTC", ...opts }).format(d);
+  };
+  return template.replace(/YYYY|yyyy/g, getPart({ year: "numeric" })).replace(/MMM/g, getPart({ month: "short" })).replace(/MM/g, getPart({ month: "2-digit" })).replace(/dd/g, getPart({ day: "2-digit" })).replace(/HH/g, getPart({ hour: "2-digit", hour12: false })).replace(/mm/g, getPart({ minute: "2-digit" })).replace(/SSS/g, String(d.getUTCMilliseconds()).padStart(3, "0")).replace(/ss/g, getPart({ second: "2-digit" }));
+}
+function formatTimeTick(timestamp, unit, timezone, overrides, locale) {
+  const userFormat = overrides?.[unit];
+  if (typeof userFormat === "string") {
+    return formatDateTemplate(timestamp, userFormat, timezone, locale);
+  }
+  const options = userFormat ?? DEFAULT_FORMATS[unit];
+  const fmt = getFormatter(timezone, options, locale);
+  return fmt.format(new Date(timestamp));
+}
+function detectTickUnit(ticks) {
+  if (ticks.length < 2) return "day";
+  const avgInterval = (ticks[ticks.length - 1] - ticks[0]) / (ticks.length - 1);
+  if (avgInterval < MS.second) return "millisecond";
+  if (avgInterval < MS.minute) return "second";
+  if (avgInterval < MS.hour) return "minute";
+  if (avgInterval < MS.day) return "hour";
+  if (avgInterval < MS.week) return "day";
+  if (avgInterval < MS.month) return "week";
+  if (avgInterval < MS.quarter) return "month";
+  if (avgInterval < MS.year) return "quarter";
+  return "year";
+}
+function isPeriodBoundary(timestamp, tickUnit) {
+  const d = new Date(timestamp);
+  switch (tickUnit) {
+    case "millisecond":
+    case "second":
+    case "minute":
+      if (d.getUTCMinutes() === 0 && d.getUTCSeconds() === 0 && d.getUTCMilliseconds() === 0) {
+        return "hour";
+      }
+      return null;
+    case "hour":
+      if (d.getUTCHours() === 0) return "day";
+      return null;
+    case "day":
+    case "week":
+      if (d.getUTCMonth() === 0 && d.getUTCDate() === 1) return "year";
+      if (d.getUTCDate() === 1) return "month";
+      return null;
+    case "month":
+    case "quarter":
+      if (d.getUTCMonth() === 0) return "year";
+      return null;
+    case "year":
+      return null;
+  }
+}
+
+// src/utils/math/time-scale.ts
+function createTimeScale(domainValues, rangeValues, options) {
+  const domainSpan = domainValues[1] - domainValues[0];
+  const rangeSpan = rangeValues[1] - rangeValues[0];
+  const scale = ((value) => {
+    if (domainSpan === 0) return rangeValues[0];
+    return rangeValues[0] + (value - domainValues[0]) / domainSpan * rangeSpan;
+  });
+  scale.invert = (pixel) => {
+    if (rangeSpan === 0) return domainValues[0];
+    return domainValues[0] + (pixel - rangeValues[0]) / rangeSpan * domainSpan;
+  };
+  scale.ticks = () => {
+    const pixelWidth = Math.abs(rangeSpan);
+    const { ticks } = generateTimeTicks(domainValues[0], domainValues[1], pixelWidth, options?.tickConfig);
+    return ticks;
+  };
+  scale.domain = () => [...domainValues];
+  scale.range = () => [...rangeValues];
+  return scale;
+}
+function calculateNiceTimeDomain(timestamps, options) {
+  const valid = timestamps.filter((t) => !isNaN(t));
+  if (valid.length === 0) return [0, 1];
+  let rawMin = Infinity;
+  let rawMax = -Infinity;
+  for (const t of valid) {
+    if (t < rawMin) rawMin = t;
+    if (t > rawMax) rawMax = t;
+  }
+  const hasExplicitMin = options?.min !== void 0 && options.min !== "auto";
+  const hasExplicitMax = options?.max !== void 0 && options.max !== "auto";
+  if (hasExplicitMin) {
+    rawMin = typeof options.min === "number" ? options.min : toTimestamp(options.min);
+  }
+  if (hasExplicitMax) {
+    rawMax = typeof options.max === "number" ? options.max : toTimestamp(options.max);
+  }
+  if (rawMin === rawMax) {
+    rawMin -= 432e5;
+    rawMax += 432e5;
+  }
+  const span = rawMax - rawMin;
+  const interval = selectTickInterval(span, 600);
+  const unit = interval.unit;
+  const count = interval.count;
+  const niceMin = hasExplicitMin ? rawMin : floorToUnit(rawMin, unit, count);
+  let niceMax = hasExplicitMax ? rawMax : floorToUnit(rawMax, unit, count);
+  if (!hasExplicitMax && niceMax < rawMax) {
+    niceMax = advanceByUnit(niceMax, unit, count);
+  }
+  return [niceMin, niceMax];
+}
+function createTimeBandAdapter(timestamps, timeScale) {
+  const sorted = [...timestamps].sort((a, b) => a - b);
+  const domain = sorted.map(String);
+  const [rangeStart, rangeEnd] = timeScale.range();
+  const rangeSpan = Math.abs(rangeEnd - rangeStart);
+  let minGapMs = Infinity;
+  for (let i = 1; i < sorted.length; i++) {
+    const gap = sorted[i] - sorted[i - 1];
+    if (gap > 0 && gap < minGapMs) minGapMs = gap;
+  }
+  let bw;
+  if (sorted.length <= 1 || !isFinite(minGapMs)) {
+    bw = rangeSpan / Math.max(sorted.length, 1);
+  } else {
+    const [domMin, domMax] = timeScale.domain();
+    const domSpan = domMax - domMin;
+    bw = domSpan > 0 ? minGapMs / domSpan * rangeSpan * 0.8 : rangeSpan;
+  }
+  bw = Math.min(bw, rangeSpan / Math.max(sorted.length, 1));
+  const stepValue = sorted.length > 1 ? rangeSpan / (sorted.length - 1) : rangeSpan;
+  const halfBw = bw / 2;
+  const scale = ((category) => {
+    let ts = Number(category);
+    if (isNaN(ts)) ts = toTimestamp(category);
+    return timeScale(ts) - halfBw;
+  });
+  scale.bandwidth = () => bw;
+  scale.step = () => stepValue;
+  scale.domain = () => [...domain];
+  scale.range = () => [rangeStart, rangeEnd];
+  return scale;
+}
+function createOrdinalTimeScale(sortedTimestamps, rangeValues, options) {
+  const rangeSpan = rangeValues[1] - rangeValues[0];
+  const count = sortedTimestamps.length;
+  const lastIdx = Math.max(0, count - 1);
+  const tsToFracIdx = (value) => {
+    if (count === 0) return 0;
+    if (count === 1) return 0;
+    if (value <= sortedTimestamps[0]) return 0;
+    if (value >= sortedTimestamps[lastIdx]) return lastIdx;
+    let lo = 0;
+    let hi = lastIdx;
+    while (lo + 1 < hi) {
+      const mid = lo + hi >> 1;
+      if (sortedTimestamps[mid] === value) return mid;
+      if (sortedTimestamps[mid] < value) lo = mid;
+      else hi = mid;
+    }
+    const span = sortedTimestamps[hi] - sortedTimestamps[lo];
+    return lo + (span > 0 ? (value - sortedTimestamps[lo]) / span : 0);
+  };
+  const visMinTs = options?.visibleDomain?.[0] ?? sortedTimestamps[0] ?? 0;
+  const visMaxTs = options?.visibleDomain?.[1] ?? sortedTimestamps[lastIdx] ?? 1;
+  const rawVisMinIdx = tsToFracIdx(visMinTs);
+  const rawVisMaxIdx = tsToFracIdx(visMaxTs);
+  const rawVisSpan = rawVisMaxIdx - rawVisMinIdx;
+  const padStart = options?.padStart ?? 0;
+  const padEnd = options?.padEnd ?? 0;
+  const visMinIdx = rawVisMinIdx - padStart * rawVisSpan;
+  const visMaxIdx = rawVisMaxIdx + padEnd * rawVisSpan;
+  const visSpan = visMaxIdx - visMinIdx;
+  const scale = ((value) => {
+    if (count === 0 || visSpan <= 0) return rangeValues[0];
+    const idx = tsToFracIdx(value);
+    return rangeValues[0] + (idx - visMinIdx) / visSpan * rangeSpan;
+  });
+  scale.invert = (pixel) => {
+    if (count === 0 || visSpan <= 0) return sortedTimestamps[0] ?? 0;
+    const fracIdx = visMinIdx + (pixel - rangeValues[0]) / rangeSpan * visSpan;
+    const clamped = Math.max(0, Math.min(lastIdx, fracIdx));
+    const lo = Math.floor(clamped);
+    const hi = Math.min(lo + 1, lastIdx);
+    const frac = clamped - lo;
+    return sortedTimestamps[lo] + frac * (sortedTimestamps[hi] - sortedTimestamps[lo]);
+  };
+  scale.ticks = () => {
+    if (count === 0) return [];
+    const pixelWidth = Math.abs(rangeSpan);
+    const { ticks } = generateTimeTicks(visMinTs, visMaxTs, pixelWidth, options?.tickConfig);
+    return ticks;
+  };
+  scale.domain = () => [visMinTs, visMaxTs];
+  scale.range = () => [...rangeValues];
+  scale.dataFirstTs = count > 0 ? sortedTimestamps[0] : void 0;
+  scale.dataLastTs = count > 0 ? sortedTimestamps[lastIdx] : void 0;
+  return scale;
+}
+function createOrdinalTimeBandAdapter(sortedTimestamps, ordinalScale) {
+  const domain = sortedTimestamps.map(String);
+  const [rangeStart, rangeEnd] = ordinalScale.range();
+  const rangeSpan = Math.abs(rangeEnd - rangeStart);
+  let step;
+  if (sortedTimestamps.length > 1) {
+    step = Math.abs(ordinalScale(sortedTimestamps[1]) - ordinalScale(sortedTimestamps[0]));
+  } else {
+    step = rangeSpan;
+  }
+  const bw = Math.min(step * 0.8, rangeSpan);
+  const halfBw = bw / 2;
+  const scale = ((category) => {
+    let ts = Number(category);
+    if (isNaN(ts)) ts = toTimestamp(category);
+    return ordinalScale(ts) - halfBw;
+  });
+  scale.bandwidth = () => bw;
+  scale.step = () => step;
+  scale.domain = () => [...domain];
+  scale.range = () => [rangeStart, rangeEnd];
+  return scale;
+}
+
+export { DEFAULT_FORMATS, MS, TICK_INTERVALS, advanceByUnit, calculateArcBoundingBox, calculateGroupedBarLayout, calculateNiceDomain, calculateNiceLogDomain, calculateNiceTimeDomain, clamp, createBandScale, createLinearScale, createLogScale, createOrdinalTimeBandAdapter, createOrdinalTimeScale, createTimeBandAdapter, createTimeScale, createVariwideBandScale, crisp, detectTickUnit, findMax, findMin, floorToUnit, formatTimeTick, generateIntervalTicks, generateLogTicks, generateNiceTicks, generateTimeTicks, intervalSpanMs, isPeriodBoundary, normalizeAngle, normalizeAngleRelativeTo, pointOnCircle, scaleLinear, selectTickInterval, shallowEqual, toRad, toTimestamp, warnChartDevOnce, xCalc, yCalc };