@primeui/chart-core 0.0.1-alpha.1

package/dist/chunk-3OZLP4I4.mjs

@@ -0,0 +1,190 @@
+import { renderCandlestickSvg } from './chunk-CINXJIRR.mjs';
+import { renderCandlestickCanvas } from './chunk-FHTC2YDB.mjs';
+import { DEFAULT_CANDLESTICK_WICK_WIDTH } from './chunk-NKUYIWAP.mjs';
+import { FIELD_DEFAULTS, batchResolveAccessor, resolveAccessor, makeItemContext, resolveDash } from './chunk-O2X6FF45.mjs';
+
+// src/series/candlestick/geometry.ts
+var DEFAULT_BAR_WIDTH_RATIO = 0.7;
+function calculateCandlestickLayout(props, chartArea, config, theme) {
+  const {
+    data,
+    timeField: time,
+    openField: openAcc = FIELD_DEFAULTS.openField,
+    highField: highAcc = FIELD_DEFAULTS.highField,
+    lowField: lowAcc = FIELD_DEFAULTS.lowField,
+    closeField: closeAcc = FIELD_DEFAULTS.closeField,
+    color: colorAcc,
+    variant = "candlestick",
+    // Direction colors stay undefined when user didn't pass them — SVG falls through
+    // to `.p-chart-candle-up/down/neutral` classes; canvas resolves to themed hex below.
+    upColor: userUpColor,
+    downColor: userDownColor,
+    neutralColor: userNeutralColor,
+    barWidthRatio = DEFAULT_BAR_WIDTH_RATIO,
+    wickStrokeWidth: wickStrokeWidthProp,
+    // Border props
+    borderUpColor,
+    borderDownColor,
+    borderNeutralColor,
+    borderDash: borderDashProp,
+    borderDashOffset: borderDashOffsetProp,
+    borderJoinStyle = "miter",
+    borderAlign = "center"
+  } = props;
+  const upColor = userUpColor ?? theme.positive;
+  const downColor = userDownColor ?? theme.negative;
+  const neutralColor = userNeutralColor ?? theme.candleNeutral;
+  const borderColor = typeof props.borderColor === "string" ? props.borderColor : void 0;
+  const borderWidth = typeof props.borderStrokeWidth === "number" ? props.borderStrokeWidth : 1;
+  const borderRadiusProp = typeof props.borderRadius === "number" ? props.borderRadius : typeof props.borderRadius === "object" && props.borderRadius !== null && !Array.isArray(props.borderRadius) ? props.borderRadius : void 0;
+  const { categoryScale, valueScale } = config;
+  const seriesExtras = { seriesIndex: props.order ?? 0, seriesId: props.id ?? "" };
+  const labels = batchResolveAccessor(time, data);
+  const opens = batchResolveAccessor(openAcc, data);
+  const highs = batchResolveAccessor(highAcc, data);
+  const lows = batchResolveAccessor(lowAcc, data);
+  const closes = batchResolveAccessor(closeAcc, data);
+  const bandwidth = categoryScale.bandwidth();
+  const bodyWidth = Math.max(1, bandwidth * barWidthRatio);
+  const candles = [];
+  for (let i = 0; i < data.length; i++) {
+    const label = String(labels[i] ?? i);
+    const o = Number(opens[i] ?? 0);
+    const h = Number(highs[i] ?? 0);
+    const l = Number(lows[i] ?? 0);
+    const c = Number(closes[i] ?? 0);
+    const catLeft = categoryScale(label);
+    if (catLeft === void 0 || !Number.isFinite(catLeft)) continue;
+    const cx = catLeft + bandwidth / 2;
+    const openY = valueScale(o);
+    const highY = valueScale(h);
+    const lowY = valueScale(l);
+    const closeY = valueScale(c);
+    if (isNaN(openY) || isNaN(highY) || isNaN(lowY) || isNaN(closeY)) continue;
+    const bodyTop = Math.min(openY, closeY);
+    const bodyBottom = Math.max(openY, closeY);
+    const direction = c > o ? "up" : c < o ? "down" : "neutral";
+    const prevClose = i > 0 ? Number(closes[i - 1] ?? c) : null;
+    const proDirection = prevClose === null ? direction : c > prevClose ? "up" : c < prevClose ? "down" : "neutral";
+    const isHollow = variant === "hollow";
+    const effectiveDirection = isHollow ? proDirection : direction;
+    const solidColor = effectiveDirection === "up" ? upColor : effectiveDirection === "down" ? downColor : neutralColor;
+    const perCandleColor = colorAcc ? resolveAccessor(colorAcc, makeItemContext(data[i], i, { value: c, category: label, ...seriesExtras })) : void 0;
+    const effectiveColor = typeof perCandleColor === "string" && perCandleColor ? perCandleColor : solidColor;
+    const bodyFill = isHollow && direction !== "down" ? null : effectiveColor;
+    const dirBorderColor = effectiveDirection === "up" ? borderUpColor ?? borderColor ?? effectiveColor : effectiveDirection === "down" ? borderDownColor ?? borderColor ?? effectiveColor : borderNeutralColor ?? borderColor ?? effectiveColor;
+    const bodyStroke = typeof perCandleColor === "string" && perCandleColor ? effectiveColor : dirBorderColor;
+    const wickColor = effectiveColor;
+    const directionUserBorder = effectiveDirection === "up" ? borderUpColor : effectiveDirection === "down" ? borderDownColor : borderNeutralColor;
+    const directionUserColor = effectiveDirection === "up" ? userUpColor : effectiveDirection === "down" ? userDownColor : userNeutralColor;
+    const useClass = perCandleColor === void 0 && directionUserColor === void 0 && directionUserBorder === void 0 && borderColor === void 0 ? effectiveDirection : null;
+    const left = cx - bodyWidth / 2;
+    const right = cx + bodyWidth / 2;
+    const visible = right >= chartArea.x && left <= chartArea.x + chartArea.width && highY <= chartArea.y + chartArea.height && lowY >= chartArea.y;
+    const candleCtx = makeItemContext(data[i], i, { value: c, category: label, ...seriesExtras });
+    const wickStrokeWidth = resolveAccessor(wickStrokeWidthProp, candleCtx, { arrayMode: "clip", fallback: DEFAULT_CANDLESTICK_WICK_WIDTH }) ?? DEFAULT_CANDLESTICK_WICK_WIDTH;
+    const candleBorderDash = resolveDash(borderDashProp, candleCtx);
+    const candleBorderDashOffset = resolveAccessor(borderDashOffsetProp, candleCtx, { arrayMode: "clip" });
+    candles.push({
+      dataIndex: i,
+      x: cx,
+      bodyTop,
+      bodyBottom,
+      openY,
+      closeY,
+      wickTop: highY,
+      wickBottom: lowY,
+      bodyWidth,
+      open: o,
+      high: h,
+      low: l,
+      close: c,
+      label,
+      direction,
+      proDirection,
+      bodyFill,
+      bodyStroke,
+      wickColor,
+      wickStrokeWidth,
+      borderDash: candleBorderDash,
+      borderDashOffset: candleBorderDashOffset,
+      useClass,
+      visible
+    });
+  }
+  const visibleCandles = candles.filter((c) => c.visible);
+  let domMin = Infinity;
+  let domMax = -Infinity;
+  for (let i = 0; i < lows.length; i++) {
+    const lv = Number(lows[i]);
+    const hv = Number(highs[i]);
+    if (!isNaN(lv) && lv < domMin) domMin = lv;
+    if (!isNaN(hv) && hv > domMax) domMax = hv;
+  }
+  const valueDomain = [isFinite(domMin) ? domMin : 0, isFinite(domMax) ? domMax : 100];
+  const borderStyle = {
+    borderStrokeWidth: borderWidth,
+    borderDash: candles[0]?.borderDash ?? [],
+    borderDashOffset: candles[0]?.borderDashOffset ?? 0,
+    borderJoinStyle,
+    borderAlign,
+    borderRadius: borderRadiusProp ?? 0
+  };
+  const layoutWickStrokeWidth = candles.length > 0 ? candles[0].wickStrokeWidth : DEFAULT_CANDLESTICK_WICK_WIDTH;
+  return {
+    candles,
+    visibleCandles,
+    categoryScale,
+    valueScale,
+    chartArea,
+    valueDomain,
+    variant,
+    wickStrokeWidth: layoutWickStrokeWidth,
+    borderStyle
+  };
+}
+function hitTestCandlestick(x, y, layout) {
+  for (const candle of layout.visibleCandles) {
+    const halfBody = candle.bodyWidth / 2;
+    if (Math.abs(x - candle.x) <= halfBody && y >= candle.wickTop && y <= candle.wickBottom) {
+      return candle.dataIndex;
+    }
+  }
+  return null;
+}
+function findNearestCandleIndex(x, layout) {
+  if (layout.visibleCandles.length === 0) return null;
+  let nearest = null;
+  let minDist = Infinity;
+  for (const candle of layout.visibleCandles) {
+    const dist = Math.abs(x - candle.x);
+    if (dist < minDist) {
+      minDist = dist;
+      nearest = candle;
+    }
+  }
+  return nearest ? nearest.dataIndex : null;
+}
+
+// src/series/candlestick/index.ts
+var candlestickRenderer = {
+  calculateLayout() {
+    throw new Error("Use calculateCandlestickLayout with shared scale config from useCartesianLayout");
+  },
+  renderSvg: renderCandlestickSvg,
+  renderCanvas: renderCandlestickCanvas,
+  hitTest(x, y, _props, layout) {
+    return hitTestCandlestick(x, y, layout);
+  },
+  getAxisHints(props, data) {
+    const categoryLabels = batchResolveAccessor(props.timeField, data);
+    const highVals = batchResolveAccessor(props.highField ?? FIELD_DEFAULTS.highField, data);
+    const lowVals = batchResolveAccessor(props.lowField ?? FIELD_DEFAULTS.lowField, data);
+    return {
+      categoryLabels: categoryLabels.map(String),
+      domainValues: [...highVals.map(Number), ...lowVals.map(Number)]
+    };
+  }
+};
+
+export { calculateCandlestickLayout, candlestickRenderer, findNearestCandleIndex, hitTestCandlestick };

package/dist/chunk-3WEMHXZI.mjs

@@ -0,0 +1,198 @@
+import { cancelRaf, raf } from './chunk-EDAKJLNA.mjs';
+
+// src/animations/easing.ts
+var linear = (t) => t;
+var easeOutQuad = (t) => 1 - (1 - t) * (1 - t);
+var easeOutCubic = (t) => 1 - Math.pow(1 - t, 3);
+var easeOutQuart = (t) => 1 - Math.pow(1 - t, 4);
+var easeOutQuint = (t) => 1 - Math.pow(1 - t, 5);
+var easeOutExpo = (t) => t === 1 ? 1 : 1 - Math.pow(2, -10 * t);
+var easeInOutCubic = (t) => t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2;
+var easeInOutQuart = (t) => t < 0.5 ? 8 * t * t * t * t : 1 - Math.pow(-2 * t + 2, 4) / 2;
+var easeOutBack = (t) => {
+  const s = 1.70158;
+  const c3 = s + 1;
+  return 1 + c3 * Math.pow(t - 1, 3) + s * Math.pow(t - 1, 2);
+};
+var easeOutElastic = (t) => {
+  if (t === 0 || t === 1) return t;
+  const amplitude = 1;
+  const period = 0.3;
+  const s = period / (2 * Math.PI) * Math.asin(1 / amplitude);
+  return amplitude * Math.pow(2, -10 * t) * Math.sin((t - s) * (2 * Math.PI) / period) + 1;
+};
+var easeOutBounce = (t) => {
+  const n1 = 7.5625;
+  const d1 = 2.75;
+  if (t < 1 / d1) {
+    return n1 * t * t;
+  } else if (t < 2 / d1) {
+    return n1 * (t -= 1.5 / d1) * t + 0.75;
+  } else if (t < 2.5 / d1) {
+    return n1 * (t -= 2.25 / d1) * t + 0.9375;
+  } else {
+    return n1 * (t -= 2.625 / d1) * t + 0.984375;
+  }
+};
+var easeInBounce = (t) => 1 - easeOutBounce(1 - t);
+var easeInOutBounce = (t) => t < 0.5 ? (1 - easeOutBounce(1 - 2 * t)) / 2 : (1 + easeOutBounce(2 * t - 1)) / 2;
+var easingRegistry = /* @__PURE__ */ new Map([
+  ["linear", linear],
+  ["easeOutQuad", easeOutQuad],
+  ["easeOutCubic", easeOutCubic],
+  ["easeOutQuart", easeOutQuart],
+  ["easeOutQuint", easeOutQuint],
+  ["easeOutExpo", easeOutExpo],
+  ["easeInOutCubic", easeInOutCubic],
+  ["easeInOutQuart", easeInOutQuart],
+  ["easeOutBack", easeOutBack],
+  ["easeOutElastic", easeOutElastic],
+  ["easeOutBounce", easeOutBounce],
+  ["easeInBounce", easeInBounce],
+  ["easeInOutBounce", easeInOutBounce]
+]);
+function registerEasing(name, fn) {
+  easingRegistry.set(name, fn);
+}
+function getEasing(name) {
+  return easingRegistry.get(name) ?? easeOutQuart;
+}
+function hasEasing(name) {
+  return easingRegistry.has(name);
+}
+function getEasingNames() {
+  return Array.from(easingRegistry.keys());
+}
+var easings = {
+  linear,
+  easeOutQuad,
+  easeOutCubic,
+  easeOutQuart,
+  easeOutQuint,
+  easeOutExpo,
+  easeInOutCubic,
+  easeInOutQuart,
+  easeOutBack,
+  easeOutElastic,
+  easeOutBounce,
+  easeInBounce,
+  easeInOutBounce
+};
+
+// src/animations/controller.ts
+function parseAnimationConfig(animConfig) {
+  const enabled = animConfig?.enabled !== false;
+  const duration = animConfig?.duration ?? 1e3;
+  const easing = animConfig?.easing ?? easeOutQuart;
+  return { enabled, duration, easing };
+}
+var AnimationController = class {
+  constructor() {
+    this.frameId = null;
+    this.generation = 0;
+  }
+  /**
+   * Cancel any ongoing animation
+   */
+  cancel() {
+    if (this.frameId !== null) {
+      cancelRaf(this.frameId);
+      this.frameId = null;
+    }
+  }
+  /**
+   * Schedule a new animation frame, canceling any existing
+   * Returns the generation number for this animation
+   */
+  schedule(callback) {
+    this.cancel();
+    this.generation++;
+    this.frameId = raf(callback);
+    return this.generation;
+  }
+  /**
+   * Continue animation loop (called from within animation)
+   */
+  continue(callback) {
+    this.frameId = raf(callback);
+  }
+  /**
+   * Mark animation as complete
+   */
+  complete() {
+    this.frameId = null;
+  }
+  /**
+   * Check if animation is running
+   */
+  isRunning() {
+    return this.frameId !== null;
+  }
+  /**
+   * Get current generation (for checking if animation was interrupted)
+   */
+  getGeneration() {
+    return this.generation;
+  }
+  /**
+   * Check if the given generation is still current
+   */
+  isCurrentGeneration(gen) {
+    return gen === this.generation;
+  }
+  /**
+   * Full cleanup
+   */
+  destroy() {
+    this.cancel();
+    this.generation = 0;
+  }
+};
+function animate(options) {
+  const { duration, easing = easeOutQuart, onFrame, onComplete, onCancel } = options;
+  const easingFn = typeof easing === "string" ? getEasing(easing) : easing;
+  const controller = new AnimationController();
+  const startTime = performance.now();
+  let lastRawProgress = 0;
+  let resolvePromise;
+  let rejectPromise;
+  const finished = new Promise((resolve, reject) => {
+    resolvePromise = resolve;
+    rejectPromise = reject;
+  });
+  finished.catch(() => {
+  });
+  const tick = (currentTime) => {
+    const elapsed = currentTime - startTime;
+    const rawProgress = Math.min(elapsed / duration, 1);
+    lastRawProgress = rawProgress;
+    const easedProgress = easingFn(rawProgress);
+    onFrame(easedProgress);
+    if (rawProgress < 1) {
+      controller.continue(tick);
+    } else {
+      controller.complete();
+      onComplete?.();
+      resolvePromise();
+    }
+  };
+  controller.schedule(tick);
+  return {
+    cancel() {
+      if (controller.isRunning()) {
+        controller.cancel();
+        onCancel?.();
+        rejectPromise();
+      }
+    },
+    isRunning() {
+      return controller.isRunning();
+    },
+    getRawProgress() {
+      return lastRawProgress;
+    },
+    finished
+  };
+}
+
+export { AnimationController, animate, easeInBounce, easeInOutBounce, easeInOutCubic, easeInOutQuart, easeOutBack, easeOutBounce, easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easings, getEasing, getEasingNames, hasEasing, linear, parseAnimationConfig, registerEasing };

package/dist/chunk-3Z62EUJN.mjs

@@ -0,0 +1,138 @@
+import { CHAR_WIDTH_RATIO, formatCompactValue, measureFontMetrics } from './chunk-XTVE4P3L.mjs';
+import { resolveColorScaleRange, interpolateColor } from './chunk-QS76E3TD.mjs';
+import { FIELD_DEFAULTS, batchResolveAccessor } from './chunk-O2X6FF45.mjs';
+import { hexToRgbString } from './chunk-SSLTFJ3U.mjs';
+
+// src/series/heatmap/geometry.ts
+var DEFAULT_HEATMAP_NULL_COLOR = "#f3f4f6";
+var DEFAULT_HEATMAP_CELL_PADDING = 1;
+var HEATMAP_LABEL_TIERS = [
+  { minArea: 8e3, minWidth: 60, minHeight: 40, fontSize: 14 },
+  { minArea: 4e3, minWidth: 45, minHeight: 30, fontSize: 12 },
+  { minArea: 2e3, minWidth: 35, minHeight: 24, fontSize: 11 },
+  { minArea: 1e3, minWidth: 28, minHeight: 20, fontSize: 10 },
+  { minArea: 500, minWidth: 22, minHeight: 16, fontSize: 9 },
+  { minArea: 250, minWidth: 18, minHeight: 14, fontSize: 8 }
+];
+function getHeatmapLabelInfo(cell) {
+  if (!cell.label) return { fontSize: 0, show: false };
+  const area = cell.width * cell.height;
+  for (const tier of HEATMAP_LABEL_TIERS) {
+    if (area >= tier.minArea && cell.width >= tier.minWidth && cell.height >= tier.minHeight) {
+      const textWidth = cell.label.length * CHAR_WIDTH_RATIO * tier.fontSize;
+      if (textWidth > cell.width - 6) continue;
+      return { fontSize: tier.fontSize, show: true };
+    }
+  }
+  return { fontSize: 0, show: false };
+}
+function calculateHeatmapLayout(props, chartArea, scales, theme) {
+  const { data, columnField: xField = FIELD_DEFAULTS.columnField, rowField: yField = FIELD_DEFAULTS.rowField, valueField = FIELD_DEFAULTS.valueField } = props;
+  const { xScale, yScale } = scales;
+  const cellPadding = props.spacing ?? DEFAULT_HEATMAP_CELL_PADDING;
+  const showEmptyCells = props.showEmptyCells !== false;
+  const showLabels = props.showLabels === true;
+  const labelFormat = props.labelFormat;
+  const xValues = batchResolveAccessor(xField, data);
+  const yValues = batchResolveAccessor(yField, data);
+  const rawValues = batchResolveAccessor(valueField, data);
+  const keyValues = props.keyField ? batchResolveAccessor(props.keyField, data) : null;
+  const xCategories = xScale.domain();
+  const yCategories = yScale.domain();
+  let minVal = Infinity;
+  let maxVal = -Infinity;
+  for (const v of rawValues) {
+    if (v != null && isFinite(v)) {
+      if (v < minVal) minVal = v;
+      if (v > maxVal) maxVal = v;
+    }
+  }
+  if (!isFinite(minVal)) {
+    minVal = 0;
+    maxVal = 1;
+  }
+  if (props.min != null) minVal = props.min;
+  if (props.max != null) maxVal = props.max;
+  const valueRange = [minVal, maxVal];
+  const range = maxVal - minVal;
+  const heatDefaults = theme ? [theme.heatColorMin, theme.heatColorMax] : void 0;
+  const colorResult = resolveColorScaleRange({ colorScale: props.colorScale, colorRange: props.colorRange, color: props.color, defaultColors: heatDefaults }, minVal, maxVal);
+  const isOpacityMode = colorResult === null;
+  const resolvedColorScale = colorResult?.colorScale ?? [];
+  const resolvedColorRange = colorResult?.colorRange ?? [];
+  const cellMap = /* @__PURE__ */ new Map();
+  for (let i = 0; i < data.length; i++) {
+    const key = `${String(xValues[i])}|${String(yValues[i])}`;
+    cellMap.set(key, i);
+  }
+  const cells = [];
+  const bandwidth = xScale.bandwidth();
+  const yBandwidth = yScale.bandwidth();
+  const nullColor = props.nullColor ?? theme?.heatNull ?? DEFAULT_HEATMAP_NULL_COLOR;
+  for (let rowIdx = 0; rowIdx < yCategories.length; rowIdx++) {
+    const yCat = yCategories[rowIdx];
+    for (let colIdx = 0; colIdx < xCategories.length; colIdx++) {
+      const xCat = xCategories[colIdx];
+      const key = `${xCat}|${yCat}`;
+      const dataIdx = cellMap.get(key);
+      const px = xScale(xCat);
+      const py = yScale(yCat);
+      if (px === void 0 || py === void 0) continue;
+      const rawVal = dataIdx !== void 0 ? rawValues[dataIdx] : null;
+      const isEmpty = rawVal == null;
+      if (isEmpty && !showEmptyCells) continue;
+      let color;
+      if (isEmpty) {
+        color = nullColor;
+      } else if (isOpacityMode) {
+        const opacity = range > 0 ? 0.15 + 0.85 * (rawVal - minVal) / range : 1;
+        color = `rgba(${hexToRgbString(props.color)},${opacity.toFixed(3)})`;
+      } else {
+        color = interpolateColor(resolvedColorScale, resolvedColorRange, rawVal);
+      }
+      let label = null;
+      if (showLabels && !isEmpty) {
+        label = labelFormat ? labelFormat(rawVal) : formatCompactValue(rawVal);
+      }
+      cells.push({
+        x: px + cellPadding,
+        y: py + cellPadding,
+        width: Math.max(0, bandwidth - cellPadding * 2),
+        height: Math.max(0, yBandwidth - cellPadding * 2),
+        color,
+        opacity: 1,
+        value: rawVal,
+        label,
+        xLabel: xCat,
+        yLabel: yCat,
+        index: dataIdx ?? -1,
+        dataKey: dataIdx !== void 0 && keyValues ? keyValues[dataIdx] : void 0,
+        row: rowIdx,
+        col: colIdx,
+        isEmpty
+      });
+    }
+  }
+  return { cells, chartArea, xCategories, yCategories, valueRange, resolvedColorScale, resolvedColorRange };
+}
+function hitTestHeatmap(layout, x, y) {
+  for (const cell of layout.cells) {
+    if (cell.isEmpty) continue;
+    if (x >= cell.x && x <= cell.x + cell.width && y >= cell.y && y <= cell.y + cell.height) {
+      return cell;
+    }
+  }
+  return null;
+}
+
+// src/series/heatmap/shared.ts
+function resolveLabelMidToAlpha(cache, fontSize, fontFamily) {
+  let midToAlpha = cache.get(fontSize);
+  if (midToAlpha === void 0) {
+    midToAlpha = measureFontMetrics(fontSize, fontFamily, "600").midToAlpha;
+    cache.set(fontSize, midToAlpha);
+  }
+  return midToAlpha;
+}
+
+export { calculateHeatmapLayout, getHeatmapLabelInfo, hitTestHeatmap, resolveLabelMidToAlpha };