@primeui/chart-core 0.0.1-alpha.1

package/dist/canvas.utils-D2WHi2gL.d.mts

@@ -0,0 +1,167 @@
+import { SvgNode, GradientStop, SvgGradientOptions, SvgElementFactory } from '@primeui/chart-types';
+
+/**
+ * Create a virtual SVG node.
+ * All attribute values are coerced to strings; `undefined` values are skipped.
+ */
+declare function svgNode(tag: string, attributes?: Record<string, string | number | undefined>, children?: (SvgNode | string)[]): SvgNode;
+/** Set an attribute on a virtual node. Returns the node for chaining. */
+declare function setAttr(node: SvgNode, key: string, value: string | number): SvgNode;
+/** Append one or more children to a virtual node. */
+declare function appendChild(parent: SvgNode, ...children: (SvgNode | string)[]): SvgNode;
+/** Prepend a child (equivalent of `parent.insertBefore(child, parent.firstChild)`). */
+declare function prependChild(parent: SvgNode, child: SvgNode): SvgNode;
+/** Add a CSS class to the `class` attribute. */
+declare function addClass(node: SvgNode, cls: string): SvgNode;
+/**
+ * Build a space-separated CSS class string from mixed truthy/falsy parts.
+ * Falsy values (`false`, `''`, `null`, `undefined`) are dropped — lets renderers
+ * conditionally include state classes without if/else churn.
+ *
+ * ```ts
+ * const cls = svgClass('p-chart-bar', `p-chart-color-${idx}`, isHovered && 'p-chart-point-hover');
+ * ```
+ */
+declare function svgClass(...parts: (string | false | null | undefined)[]): string;
+/**
+ * Create SVG group node
+ */
+declare function createSvgGroup(transform?: string, attributes?: Record<string, string | number>): SvgNode;
+/**
+ * Create SVG path node
+ */
+declare function createSvgPath(d: string, attributes?: Record<string, string | number>): SvgNode;
+/**
+ * Create SVG text node
+ */
+declare function createSvgText(x: number, y: number, content?: string, attributes?: Record<string, string | number | undefined>): SvgNode;
+/**
+ * Create SVG rect node
+ */
+declare function createSvgRect(x: number, y: number, width: number, height: number, attributes?: Record<string, string | number>): SvgNode;
+/**
+ * Create SVG circle node
+ */
+declare function createSvgCircle(cx: number, cy: number, r: number, attributes?: Record<string, string | number>): SvgNode;
+/**
+ * Create SVG line node
+ */
+declare function createSvgLine(x1: number, y1: number, x2: number, y2: number, attributes?: Record<string, string | number>): SvgNode;
+/**
+ * Create SVG defs node for gradient/pattern definitions
+ */
+declare function createSvgDefs(): SvgNode;
+/**
+ * Create SVG linear gradient node
+ * @param id - Unique ID for the gradient
+ * @param x1, y1 - Start point (0-1 for percentage, or absolute coords if useAbsoluteCoords)
+ * @param x2, y2 - End point (0-1 for percentage, or absolute coords if useAbsoluteCoords)
+ * @param stops - Color stops
+ * @param options - Additional options
+ */
+declare function createSvgLinearGradient(id: string, x1: number, y1: number, x2: number, y2: number, stops: GradientStop[], options?: SvgGradientOptions): SvgNode;
+/**
+ * Create SVG radial gradient node
+ * @param id - Unique ID for the gradient
+ * @param cx, cy - Center point (0-1 for percentage, or absolute coords if useAbsoluteCoords)
+ * @param r - Radius (0-1 for percentage, or absolute value if useAbsoluteCoords)
+ * @param stops - Color stops
+ * @param options - Additional options
+ */
+declare function createSvgRadialGradient(id: string, cx: number, cy: number, r: number, stops: GradientStop[], options?: SvgGradientOptions): SvgNode;
+/**
+ * Override how the engine creates SVG DOM elements. Inject a factory for SSR or
+ * non-DOM environments (e.g. a React/Angular/Lit adapter running in Node), or pass
+ * `null` to restore the browser default.
+ *
+ * @example
+ * // SSR / Node: route creation through your DOM shim
+ * setSvgElementFactory({ createElement: (tag) => myDom.createElementNS(SVG_NS, tag) });
+ *
+ * // Reset to browser default
+ * setSvgElementFactory(null);
+ */
+declare function setSvgElementFactory(factory: SvgElementFactory | null): void;
+/**
+ * Create a single SVG element through the active factory. Renderers and controllers
+ * use this instead of `document.createElementNS` so element creation has one seam.
+ */
+declare function createSvgElement(tag: string): SVGElement;
+/**
+ * Recursively convert a virtual SvgNode tree into real SVG DOM elements via the
+ * active SVG element factory (browser by default).
+ */
+declare function materializeSvgNode(node: SvgNode): SVGElement;
+/**
+ * Materialize and cast as SVGGElement.
+ * Safe because all top-level renderer outputs are `<g>` elements.
+ */
+declare function materializeSvgGroup(node: SvgNode): SVGGElement;
+
+/**
+ * Execute a function with automatic canvas state save/restore.
+ * Ensures context state is properly restored even if an error occurs.
+ *
+ * @param ctx - Canvas 2D rendering context
+ * @param fn - Function to execute with saved state
+ * @returns The return value of fn
+ *
+ * @example
+ * ```ts
+ * withCanvasState(ctx, () => {
+ *     ctx.fillStyle = 'red';
+ *     ctx.translate(100, 100);
+ *     ctx.fillRect(0, 0, 50, 50);
+ * });
+ * // Context state is now restored to before the call
+ * ```
+ */
+declare function withCanvasState<T>(ctx: CanvasRenderingContext2D, fn: () => T): T;
+
+/**
+ * Read a numeric CSS variable off an element via `getComputedStyle`. The chart
+ * canvas is part of the document, so CSS variables defined on `:root`, the
+ * chart container, or inline on the canvas itself all cascade through.
+ *
+ * Lets canvas renderers consume the same `chart-style` tokens that drive SVG
+ * via class rules — so a global override like `--p-chart-bar-stroke-width: 2`
+ * affects both renderers identically.
+ *
+ * Returns `fallback` when the variable is unset, empty, or non-numeric, or
+ * when running outside a browser environment (SSR).
+ */
+declare function readCssNumber(el: Element | null | undefined, varName: string, fallback: number): number;
+/**
+ * Get the current device pixel ratio, clamped to a safe maximum.
+ */
+declare function getDevicePixelRatio(): number;
+/**
+ * Configure a canvas for HiDPI rendering.
+ * Sets the buffer size to (width * dpr, height * dpr), the CSS display size to (width, height),
+ * and applies ctx.setTransform so all drawing uses logical (CSS) pixel coordinates.
+ *
+ * @param canvas - The canvas element to configure
+ * @param width - Logical width in CSS pixels
+ * @param height - Logical height in CSS pixels
+ * @param overrideDpr - Optional device pixel ratio override. Defaults to window.devicePixelRatio.
+ * @returns The device pixel ratio that was applied
+ */
+declare function configureCanvasHiDPI(canvas: HTMLCanvasElement, width: number, height: number, overrideDpr?: number): number;
+/**
+ * Create a linear gradient for canvas
+ */
+declare function createCanvasLinearGradient(ctx: CanvasRenderingContext2D, x1: number, y1: number, x2: number, y2: number, stops: Array<{
+    offset: number;
+    color: string;
+    opacity?: number;
+}>): CanvasGradient;
+/**
+ * Create a radial gradient for canvas
+ */
+declare function createCanvasRadialGradient(ctx: CanvasRenderingContext2D, cx: number, cy: number, innerRadius: number, outerRadius: number, stops: Array<{
+    offset: number;
+    color: string;
+    opacity?: number;
+}>): CanvasGradient;
+
+export { addClass as a, appendChild as b, configureCanvasHiDPI as c, createCanvasLinearGradient as d, createCanvasRadialGradient as e, createSvgCircle as f, createSvgDefs as g, createSvgElement as h, createSvgGroup as i, createSvgLine as j, createSvgLinearGradient as k, createSvgPath as l, createSvgRadialGradient as m, createSvgRect as n, createSvgText as o, getDevicePixelRatio as p, materializeSvgGroup as q, materializeSvgNode as r, prependChild as s, readCssNumber as t, setAttr as u, setSvgElementFactory as v, svgClass as w, svgNode as x, withCanvasState as y };

package/dist/cartesian/index.d.mts

@@ -0,0 +1,94 @@
+import { StyledGroupBoundary, BandScale, BoxArea, FillRect, StyledRangeBoundary, SvgNode, AxisGroupDefinition, BarRenderProps, CartesianLayoutData, FeatureType, AnyFeatureProps, AxisGroupFeatureProps } from '@primeui/chart-types';
+export { I as BASELINE_TO_CANVAS, b as barFindAllNearest, a as barFindNearest, c as barHitTest, d as buildAnimatedFrame, J as buildFrameParams, e as buildStaticFrame, f as calculateCartesianArea, g as cancelDriverRafs, h as candlestickFindAllNearest, i as candlestickHitTest, j as collectLineMarkerOverlays, k as collectScatterMarkerOverlays, l as computeCartesianLayout, m as computeCategoryBracketGeometry, n as computeCrosshairLayout, o as computeNaturalAxisWidths, K as computeRangeBracketGeometry, p as computeStackBases, L as computeWaterfallBases, q as createAnimationDriver, M as detectCartesianMode, r as driveCartesianUpdate, s as isLayoutCriticalFeature, t as lineFindAllNearest, u as lineHitTest, v as mergeAllNearestResults, w as needsAxisPadding, x as normalizeCrosshairConfig, y as registerDatasetLayers, z as renderBracketsCanvas, N as renderBracketsSvg, A as renderWithCompositor, B as resolveBarLabels, C as resolveHoverRepaintFrame, D as resolveNearestHit, E as resolvePointLabels, F as resolveScatterLabels, G as scatterHitTest, O as transformValues, H as triggerCompositorRepaint } from '../stacking-CChuAcLN.mjs';
+
+/**
+ * Compute fill rectangles for category partition boundaries.
+ *
+ * @param boundaries - Styled group boundaries with optional fill config
+ * @param categoryScale - Band scale mapping categories to pixel positions
+ * @param cartesianArea - The chart plot area
+ * @param orientation - Chart orientation ('vertical' = categories on X, 'horizontal' = categories on Y)
+ */
+declare function computeCategoryFills(boundaries: StyledGroupBoundary[], categoryScale: BandScale, cartesianArea: BoxArea, orientation: 'horizontal' | 'vertical'): FillRect[];
+/**
+ * Compute fill rectangles for value range boundaries.
+ *
+ * @param boundaries - Styled range boundaries with optional fill config
+ * @param valueDomain - Value axis domain [min, max]
+ * @param valueScaleRange - Value axis pixel range [start, end]
+ * @param cartesianArea - The chart plot area
+ * @param orientation - Chart orientation ('vertical' = value on Y, 'horizontal' = value on X)
+ */
+declare function computeRangeFills(boundaries: StyledRangeBoundary[], valueDomain: [number, number], valueScaleRange: [number, number], cartesianArea: BoxArea, orientation: 'horizontal' | 'vertical'): FillRect[];
+/**
+ * Render fill rectangles as an SVG group element.
+ * Returns null if there are no fills.
+ */
+declare function renderFillsSvg(fills: FillRect[]): SvgNode | null;
+/**
+ * Render fill rectangles onto a canvas context.
+ */
+declare function renderFillsCanvas(ctx: CanvasRenderingContext2D, fills: FillRect[]): void;
+
+/**
+ * Build sorted categories and styled boundaries from declarative AxisGroup definitions.
+ * Used by the AxisGroup (template-driven) approach.
+ *
+ * Supports nested grouping: leaf groups (highest depth) define category ordering,
+ * parent groups (lower depth) span across their children's categories.
+ *
+ * Categories are reordered to match the group definitions (group order, then category order within each group).
+ * Categories present in data but not in any group definition are appended at the end ungrouped.
+ */
+declare function buildBoundariesFromAxisGroups(groups: AxisGroupDefinition[], dataCategories: string[]): {
+    sortedCategories: string[];
+    styledBoundaries: StyledGroupBoundary[];
+};
+/**
+ * Build styled range boundaries from AxisGroupDefinition entries that have range fields.
+ * Filters out category-based groups and resolves style shorthands.
+ */
+declare function buildStyledRanges(groups: AxisGroupDefinition[]): StyledRangeBoundary[];
+
+/**
+ * Resolve the actual axis ID for a dataset's value axis.
+ * When yAxisId is explicitly set (multi-axis), use it directly.
+ * When undefined (single-axis), route to the first value scale.
+ */
+declare function resolveValueAxisId(barProps: BarRenderProps<unknown>, layoutData: CartesianLayoutData): string;
+/**
+ * Resolve the tickFormat function for a dataset's value axis.
+ */
+declare function resolveValueAxisFormat(barProps: BarRenderProps<unknown>, orientation: 'vertical' | 'horizontal', layoutData: CartesianLayoutData | null): ((v: number) => string) | null;
+/**
+ * Format a numeric value using the dataset's value axis tickFormat function.
+ * Falls back to String(value) if no formatter is available.
+ */
+declare function formatHitValue(value: number, barProps: BarRenderProps<unknown>, orientation: 'vertical' | 'horizontal', layoutData: CartesianLayoutData | null): string;
+/**
+ * Format the value at the cursor's pixel position on the value axis.
+ * Uses scale.invert() to convert pixel → data value, then formats with tickFormat.
+ */
+declare function formatCursorValue(cursorX: number, cursorY: number, barProps: BarRenderProps<unknown>, orientation: 'vertical' | 'horizontal', layoutData: CartesianLayoutData | null): string;
+/**
+ * Format a raw category label as a readable date when the chart uses a time axis.
+ * Returns the original label unchanged if the chart doesn't use time axis.
+ */
+declare function formatTimeLabel(rawLabel: string, layoutData: CartesianLayoutData | null, locale?: string): string;
+
+/**
+ * Find all axis group features matching a prefix.
+ * e.g., prefix 'axisGroup:x' matches 'axisGroup:x' and 'axisGroup:x:bottom'
+ */
+declare function findAxisGroupFeatures(features: Map<FeatureType, {
+    type: FeatureType;
+    props: AnyFeatureProps;
+}>, prefix: string): AxisGroupFeatureProps[];
+/**
+ * Create an offset chart area for secondary axes.
+ * Extends the box area in the given direction by the offset amount,
+ * so that secondary axis layout calculations have the correct coordinate space.
+ */
+declare function createOffsetChartArea(area: BoxArea, position: string, offset: number): BoxArea;
+
+export { buildBoundariesFromAxisGroups, buildStyledRanges, computeCategoryFills, computeRangeFills, createOffsetChartArea, findAxisGroupFeatures, formatCursorValue, formatHitValue, formatTimeLabel, renderFillsCanvas, renderFillsSvg, resolveValueAxisFormat, resolveValueAxisId };

package/dist/cartesian/index.mjs

@@ -0,0 +1,93 @@
+export { buildAnimatedFrame, buildBoundariesFromAxisGroups, buildFrameParams, buildStaticFrame, buildStyledRanges, calculateCartesianArea, cancelDriverRafs, computeCartesianLayout, computeNaturalAxisWidths, createAnimationDriver, createOffsetChartArea, driveCartesianUpdate, findAxisGroupFeatures, isLayoutCriticalFeature, mergeAllNearestResults, needsAxisPadding, renderWithCompositor, resolveHoverRepaintFrame, resolveNearestHit } from '../chunk-WY4AURRE.mjs';
+export { computeCrosshairLayout, normalizeCrosshairConfig } from '../chunk-QWQ6HY4I.mjs';
+import '../chunk-KNDZP446.mjs';
+export { barFindAllNearest, barFindNearest, barHitTest } from '../chunk-JGOVWSKH.mjs';
+import '../chunk-FRST55HY.mjs';
+import '../chunk-DN6AXQYZ.mjs';
+import '../chunk-EAMUNLRU.mjs';
+import '../chunk-BKP26M4K.mjs';
+import '../chunk-B4FTADAZ.mjs';
+import '../chunk-4C6EVJ54.mjs';
+export { candlestickFindAllNearest, candlestickHitTest } from '../chunk-M7B3JF43.mjs';
+import '../chunk-JO7VACY2.mjs';
+import '../chunk-3OZLP4I4.mjs';
+import '../chunk-CINXJIRR.mjs';
+import '../chunk-FHTC2YDB.mjs';
+import '../chunk-CHW4RKY3.mjs';
+import '../chunk-SANZPAJ4.mjs';
+import '../chunk-WFVOQ2QZ.mjs';
+import '../chunk-MTGMXRNF.mjs';
+import '../chunk-TQ6S34QZ.mjs';
+import '../chunk-3Z62EUJN.mjs';
+import '../chunk-J65DBT4R.mjs';
+import '../chunk-3FFJEX4A.mjs';
+import '../chunk-KQIFO5I3.mjs';
+export { computeStackBases, computeWaterfallBases, detectCartesianMode, lineFindAllNearest, lineHitTest, transformValues } from '../chunk-WFTX4AQJ.mjs';
+export { formatCursorValue, formatHitValue, formatTimeLabel, resolveValueAxisFormat, resolveValueAxisId } from '../chunk-DP2IZNN3.mjs';
+import '../chunk-6HSEJLSR.mjs';
+import '../chunk-HDFGCN2F.mjs';
+import '../chunk-ZQFK6CAE.mjs';
+import '../chunk-SXHVDJGF.mjs';
+import '../chunk-WCG35U6M.mjs';
+import '../chunk-ERVQB2VZ.mjs';
+import '../chunk-RBLZRT5K.mjs';
+import '../chunk-VWF57TS3.mjs';
+import '../chunk-IXOWSEHO.mjs';
+import '../chunk-53HW45JB.mjs';
+import '../chunk-LVMDQ4OJ.mjs';
+import '../chunk-TA4MVAEX.mjs';
+import '../chunk-AGU3NG6D.mjs';
+import '../chunk-2QRS4YQ5.mjs';
+import '../chunk-6STOLMCA.mjs';
+import '../chunk-AHYIS6EB.mjs';
+export { scatterHitTest } from '../chunk-LKC7MZKK.mjs';
+export { collectLineMarkerOverlays, collectScatterMarkerOverlays } from '../chunk-X4D7FKUS.mjs';
+export { registerDatasetLayers, triggerCompositorRepaint } from '../chunk-Q6PPVIHU.mjs';
+export { BASELINE_TO_CANVAS, resolveBarLabels, resolvePointLabels, resolveScatterLabels } from '../chunk-66T4MRC5.mjs';
+export { computeCategoryBracketGeometry, computeCategoryFills, computeRangeBracketGeometry, computeRangeFills, renderBracketsCanvas, renderBracketsSvg, renderFillsCanvas, renderFillsSvg } from '../chunk-QQBXUDM4.mjs';
+import '../chunk-7QQ6ETB4.mjs';
+import '../chunk-X7T34OLW.mjs';
+import '../chunk-SALTGZFR.mjs';
+import '../chunk-AUF4CHDP.mjs';
+import '../chunk-ZTL2FQEW.mjs';
+import '../chunk-VN7CKCSE.mjs';
+import '../chunk-AP3UYWYT.mjs';
+import '../chunk-DTWTCFRG.mjs';
+import '../chunk-PRDVPOZX.mjs';
+import '../chunk-VGLSBZDN.mjs';
+import '../chunk-XIHBK5D3.mjs';
+import '../chunk-55Y3WI6S.mjs';
+import '../chunk-RO4N6YFS.mjs';
+import '../chunk-VVI3OBPJ.mjs';
+import '../chunk-ZT2Z7ERM.mjs';
+import '../chunk-KP2TWD4Z.mjs';
+import '../chunk-3WEMHXZI.mjs';
+import '../chunk-KVDEROP6.mjs';
+import '../chunk-YBJ56XJS.mjs';
+import '../chunk-NPDZLYIF.mjs';
+import '../chunk-EDAKJLNA.mjs';
+import '../chunk-JWFBOPM6.mjs';
+import '../chunk-5JCI2DEB.mjs';
+import '../chunk-BZN2QHGP.mjs';
+import '../chunk-OGJ6IIBW.mjs';
+import '../chunk-ARRGOEFX.mjs';
+import '../chunk-22ST6YPP.mjs';
+import '../chunk-FFMT6OCO.mjs';
+import '../chunk-7CMVDIOU.mjs';
+import '../chunk-ADKLH73T.mjs';
+import '../chunk-OXTFAWSK.mjs';
+import '../chunk-R6Y3R7EW.mjs';
+import '../chunk-XTVE4P3L.mjs';
+import '../chunk-NKUYIWAP.mjs';
+import '../chunk-XQQCGFYB.mjs';
+import '../chunk-WH3C3Y7P.mjs';
+import '../chunk-OWW3K55O.mjs';
+import '../chunk-WA3OVISZ.mjs';
+import '../chunk-C36VWQ7A.mjs';
+import '../chunk-BETFQBM2.mjs';
+import '../chunk-WRULPWHD.mjs';
+import '../chunk-QS76E3TD.mjs';
+import '../chunk-O2X6FF45.mjs';
+import '../chunk-IEGLX7VL.mjs';
+import '../chunk-SSLTFJ3U.mjs';
+import '../chunk-RQ3CKQOX.mjs';

package/dist/chunk-22ST6YPP.mjs

@@ -0,0 +1,304 @@
+import { DEFAULT_LABEL_SPACING } from './chunk-NKUYIWAP.mjs';
+import { batchResolveAccessor } from './chunk-O2X6FF45.mjs';
+import { TICK_INTERVALS, intervalSpanMs, toTimestamp, floorToUnit, calculateNiceDomain, generateNiceTicks } from './chunk-RQ3CKQOX.mjs';
+
+// src/utils/data/time/grouping.ts
+function buildOrdinalTimeMapping(timestamps) {
+  const sorted = [...new Set(timestamps)].sort((a, b) => a - b);
+  const indexOf = (ts) => {
+    let lo = 0;
+    let hi = sorted.length - 1;
+    while (lo <= hi) {
+      const mid = lo + hi >> 1;
+      if (sorted[mid] === ts) return mid;
+      if (sorted[mid] < ts) lo = mid + 1;
+      else hi = mid - 1;
+    }
+    if (lo >= sorted.length) return sorted.length - 1;
+    if (hi < 0) return 0;
+    return Math.abs(sorted[lo] - ts) < Math.abs(sorted[hi] - ts) ? lo : hi;
+  };
+  const timestampAt = (index) => {
+    return sorted[Math.max(0, Math.min(index, sorted.length - 1))];
+  };
+  return { sortedTimestamps: sorted, indexOf, timestampAt };
+}
+function selectGroupingInterval(domainSpanMs, dataLength, targetPoints) {
+  for (const interval of TICK_INTERVALS) {
+    const bucketCount = domainSpanMs / intervalSpanMs(interval);
+    if (bucketCount <= targetPoints) return interval;
+  }
+  return TICK_INTERVALS[TICK_INTERVALS.length - 1];
+}
+function groupTimeData(data, categoryAccessor, valueAccessor, interval, method) {
+  if (data.length === 0) return [];
+  const buckets = /* @__PURE__ */ new Map();
+  for (const item of data) {
+    const ts = toTimestamp(item[categoryAccessor]);
+    if (isNaN(ts)) continue;
+    const bucketKey = floorToUnit(ts, interval.unit, interval.count);
+    let bucket = buckets.get(bucketKey);
+    if (!bucket) {
+      bucket = { timestamp: bucketKey, values: [], firstItem: item };
+      buckets.set(bucketKey, bucket);
+    }
+    const val = Number(item[valueAccessor]);
+    if (!isNaN(val)) {
+      bucket.values.push(val);
+    }
+  }
+  const result = [];
+  for (const [, bucket] of buckets) {
+    const aggregated = aggregate(bucket.values, method);
+    result.push({
+      ...bucket.firstItem,
+      [categoryAccessor]: new Date(bucket.timestamp),
+      [valueAccessor]: aggregated
+    });
+  }
+  result.sort((a, b) => toTimestamp(a[categoryAccessor]) - toTimestamp(b[categoryAccessor]));
+  return result;
+}
+function aggregate(values, method) {
+  if (values.length === 0) return 0;
+  switch (method) {
+    case "sum":
+      return values.reduce((a, b) => a + b, 0);
+    case "min":
+      return Math.min(...values);
+    case "max":
+      return Math.max(...values);
+    case "first":
+      return values[0];
+    case "last":
+      return values[values.length - 1];
+    case "ohlc":
+      return values[values.length - 1];
+    case "average":
+    default:
+      return values.reduce((a, b) => a + b, 0) / values.length;
+  }
+}
+
+// src/utils/data/domain.utils.ts
+function mergeDomainContributions(baseDomains, contributions) {
+  const mergedCategoryDomains = /* @__PURE__ */ new Map();
+  const includeZeroAxes = /* @__PURE__ */ new Set();
+  for (const c of contributions) {
+    if (c.includeZeroAxes) {
+      for (const axisId of c.includeZeroAxes) includeZeroAxes.add(axisId);
+    }
+  }
+  for (const c of contributions) {
+    for (const [axisId, domain] of c.valueDomains) {
+      const existing = baseDomains.get(axisId);
+      const includeZero = includeZeroAxes.has(axisId);
+      if (existing) {
+        const newMin = Math.min(existing[0], domain[0]);
+        const newMax = Math.max(existing[1], domain[1]);
+        baseDomains.set(axisId, calculateNiceDomain([newMin, newMax], { includeZero }));
+      } else {
+        baseDomains.set(axisId, [domain[0], domain[1]]);
+      }
+    }
+  }
+  for (const c of contributions) {
+    if (!c.categoryDomains) continue;
+    for (const [axisId, domain] of c.categoryDomains) {
+      const existing = mergedCategoryDomains.get(axisId);
+      if (existing) {
+        mergedCategoryDomains.set(axisId, calculateNiceDomain([Math.min(existing[0], domain[0]), Math.max(existing[1], domain[1])], { includeZero: false }));
+      } else {
+        mergedCategoryDomains.set(axisId, [domain[0], domain[1]]);
+      }
+    }
+  }
+  return mergedCategoryDomains;
+}
+function computeCartesianDomain(params) {
+  const { valuesPerDataset, visibleMask, categoryCount, mode, waterfallBases, tickCount = 5, exactTickCount = false, includeZero = true } = params;
+  const hasVisible = visibleMask.some(Boolean);
+  if (!hasVisible) {
+    return [0, 1];
+  }
+  let valueDomain;
+  if (mode.isPercentStacked) {
+    valueDomain = [0, 100];
+  } else if (mode.isWaterfall) {
+    const endpoints = [0];
+    for (let i = 0; i < categoryCount; i++) {
+      const base = waterfallBases[i];
+      let catSum = 0;
+      for (const vals of valuesPerDataset) {
+        catSum += vals[i];
+      }
+      endpoints.push(base, base + catSum);
+    }
+    valueDomain = calculateNiceDomain(endpoints, { includeZero });
+  } else if (mode.isStacked) {
+    const endpoints = [0];
+    for (let catIdx = 0; catIdx < categoryCount; catIdx++) {
+      let posSum = 0;
+      let negSum = 0;
+      for (const values of valuesPerDataset) {
+        const v = values[catIdx] ?? 0;
+        if (v >= 0) posSum += v;
+        else negSum += v;
+      }
+      endpoints.push(posSum, negSum);
+    }
+    valueDomain = calculateNiceDomain(endpoints, { includeZero });
+  } else {
+    const visibleValues = valuesPerDataset.filter((_, i) => visibleMask[i]).flat();
+    valueDomain = calculateNiceDomain(visibleValues, { includeZero });
+  }
+  if (!mode.isPercentStacked) {
+    const ticks = generateNiceTicks(valueDomain[0], valueDomain[1], tickCount, exactTickCount);
+    if (ticks.length > 0) {
+      valueDomain = [Math.min(valueDomain[0], ticks[0]), Math.max(valueDomain[1], ticks[ticks.length - 1])];
+    }
+  }
+  return valueDomain;
+}
+function expandDomainWithValues(valueDomains, axisId, values, includeZero) {
+  if (values.length === 0) return;
+  const existing = valueDomains.get(axisId);
+  if (existing) {
+    const newMin = Math.min(existing[0], ...values);
+    const newMax = Math.max(existing[1], ...values);
+    valueDomains.set(axisId, calculateNiceDomain([newMin, newMax], { includeZero }));
+  } else {
+    valueDomains.set(axisId, calculateNiceDomain(values, { includeZero }));
+  }
+}
+function resolveIncludeZero(targetAxisId, valueAxes, barAxisIds) {
+  const targetAxisConfig = valueAxes.get(targetAxisId);
+  const explicitStartFromZero = targetAxisConfig?.props?.startFromZero;
+  return explicitStartFromZero ?? barAxisIds.has(targetAxisId);
+}
+function computeDomainContribution(valueSeries, categorySeries) {
+  const valueRaw = /* @__PURE__ */ new Map();
+  const includeZeroAxes = /* @__PURE__ */ new Set();
+  for (const s of valueSeries) {
+    if (s.values.length === 0) continue;
+    if (s.includeZero) includeZeroAxes.add(s.axisId);
+    const sMin = Math.min(...s.values);
+    const sMax = Math.max(...s.values);
+    const existing = valueRaw.get(s.axisId);
+    if (existing) {
+      existing.min = Math.min(existing.min, sMin);
+      existing.max = Math.max(existing.max, sMax);
+      if (s.includeZero) existing.includeZero = true;
+    } else {
+      valueRaw.set(s.axisId, { min: sMin, max: sMax, includeZero: s.includeZero });
+    }
+  }
+  const valueDomains = /* @__PURE__ */ new Map();
+  for (const [axisId, raw] of valueRaw) {
+    valueDomains.set(axisId, calculateNiceDomain([raw.min, raw.max], { includeZero: raw.includeZero }));
+  }
+  let categoryDomains;
+  if (categorySeries && categorySeries.length > 0) {
+    const categoryRaw = /* @__PURE__ */ new Map();
+    for (const s of categorySeries) {
+      if (s.values.length === 0) continue;
+      const sMin = Math.min(...s.values);
+      const sMax = Math.max(...s.values);
+      const existing = categoryRaw.get(s.axisId);
+      if (existing) {
+        existing.min = Math.min(existing.min, sMin);
+        existing.max = Math.max(existing.max, sMax);
+      } else {
+        categoryRaw.set(s.axisId, { min: sMin, max: sMax, includeZero: s.includeZero });
+      }
+    }
+    categoryDomains = /* @__PURE__ */ new Map();
+    for (const [axisId, raw] of categoryRaw) {
+      categoryDomains.set(axisId, calculateNiceDomain([raw.min, raw.max], { includeZero: raw.includeZero }));
+    }
+  }
+  return {
+    valueDomains,
+    includeZeroAxes: includeZeroAxes.size > 0 ? includeZeroAxes : void 0,
+    categoryDomains: categoryDomains?.size ? categoryDomains : void 0
+  };
+}
+function computeVisibleValues(series, xMin, xMax) {
+  const result = /* @__PURE__ */ new Map();
+  for (const s of series) {
+    const vals = result.get(s.axisId) ?? [];
+    for (let i = 0; i < s.xValues.length; i++) {
+      if (s.xValues[i] >= xMin && s.xValues[i] <= xMax && !isNaN(s.yValues[i])) {
+        vals.push(s.yValues[i]);
+      }
+    }
+    if (vals.length > 0) result.set(s.axisId, vals);
+  }
+  return result;
+}
+function expandScatterBubblePadding(params) {
+  const { scatterDatasets, valueDomains, scatterXDomains, firstValueAxisId, firstCategoryAxisId, chartArea, isLogValueAxis, isLogCategoryAxis } = params;
+  const expandLog = ([lo, hi], r, axisLen) => {
+    if (lo <= 0 || hi <= 0 || axisLen <= 0 || axisLen <= 2 * r) return [lo, hi];
+    const logSpan = Math.log10(hi) - Math.log10(lo);
+    const logPad = r * logSpan / (axisLen - 2 * r);
+    return [Math.pow(10, Math.log10(lo) - logPad), Math.pow(10, Math.log10(hi) + logPad)];
+  };
+  const maxRadiusByXAxis = /* @__PURE__ */ new Map();
+  const maxRadiusByYAxis = /* @__PURE__ */ new Map();
+  for (const sd of scatterDatasets) {
+    if (!sd.visible) continue;
+    let maxRadius = typeof sd.props.markerSize === "number" ? sd.props.markerSize : Array.isArray(sd.props.markerSize) ? Math.max(...sd.props.markerSize.filter((v) => typeof v === "number")) : 6;
+    if (sd.props.sizeField) {
+      const sizeValues = batchResolveAccessor(sd.props.sizeField, sd.props.data ?? []).filter((v) => v != null && !isNaN(v));
+      if (sizeValues.length > 0) {
+        maxRadius = sd.props.maxSize ?? 40;
+      }
+    }
+    const targetXAxisId = sd.props.xAxisId ?? firstCategoryAxisId;
+    const targetYAxisId = sd.props.yAxisId ?? firstValueAxisId;
+    maxRadiusByXAxis.set(targetXAxisId, Math.max(maxRadiusByXAxis.get(targetXAxisId) ?? 0, maxRadius));
+    maxRadiusByYAxis.set(targetYAxisId, Math.max(maxRadiusByYAxis.get(targetYAxisId) ?? 0, maxRadius));
+  }
+  for (const [axisId, r] of maxRadiusByXAxis) {
+    const xDomain = scatterXDomains.get(axisId);
+    if (!xDomain || chartArea.width <= 0) continue;
+    if (isLogCategoryAxis?.(axisId)) {
+      scatterXDomains.set(axisId, expandLog(xDomain, r, chartArea.width));
+    } else if (chartArea.width > 2 * r) {
+      const xRange = xDomain[1] - xDomain[0];
+      const xPadding = r * xRange / (chartArea.width - 2 * r);
+      scatterXDomains.set(axisId, [xDomain[0] - xPadding, xDomain[1] + xPadding]);
+    }
+  }
+  for (const [axisId, r] of maxRadiusByYAxis) {
+    const yDomain = valueDomains.get(axisId);
+    if (!yDomain || chartArea.height <= 0) continue;
+    if (isLogValueAxis?.(axisId)) {
+      valueDomains.set(axisId, expandLog(yDomain, r, chartArea.height));
+    } else if (chartArea.height > 2 * r) {
+      const yRange = yDomain[1] - yDomain[0];
+      const yPadding = r * yRange / (chartArea.height - 2 * r);
+      valueDomains.set(axisId, [yDomain[0] - yPadding, yDomain[1] + yPadding]);
+    }
+  }
+}
+function expandDataLabelPadding(params) {
+  const { valueDomains, dataLabelFontSize, orientation, chartArea, axisIds, isLogAxis, isPercentStackedAxis } = params;
+  const labelPx = dataLabelFontSize + DEFAULT_LABEL_SPACING;
+  const axisLen = orientation === "vertical" ? chartArea.height : chartArea.width;
+  if (axisLen <= labelPx) return;
+  for (const axisId of axisIds) {
+    if (isLogAxis?.(axisId) || isPercentStackedAxis?.(axisId)) continue;
+    const domain = valueDomains.get(axisId);
+    if (!domain) continue;
+    const [lo, hi] = domain;
+    const span = hi - lo;
+    if (span <= 0) continue;
+    const dataPad = labelPx * span / axisLen;
+    domain[1] = hi + dataPad;
+    if (lo < 0) domain[0] = lo - dataPad;
+  }
+}
+
+export { buildOrdinalTimeMapping, computeCartesianDomain, computeDomainContribution, computeVisibleValues, expandDataLabelPadding, expandDomainWithValues, expandScatterBubblePadding, groupTimeData, mergeDomainContributions, resolveIncludeZero, selectGroupingInterval };

package/dist/chunk-2QK2KOBN.mjs

@@ -0,0 +1,10 @@
+import { definePlugin } from '@primeui/core';
+
+// src/plugins/defineChartPlugin.ts
+function defineChartPlugin(name, install, opts) {
+  const plugin = definePlugin(name, (ctx) => install(ctx));
+  if (opts) plugin.chartPluginOptions = opts;
+  return plugin;
+}
+
+export { defineChartPlugin };