@primeui/chart-core 0.0.1-alpha.1

package/dist/chunk-BABQKA6K.mjs

@@ -0,0 +1,339 @@
+import { handleSyncedHighlightCartesian, handleSyncedHighlightRect, handleSyncedHighlightRadial, buildDatasetRegistrations } from './chunk-WYLILAOO.mjs';
+
+// src/sync/SyncBus.ts
+function resolveAxis(value, fallback) {
+  if (value === void 0 || value === false) return false;
+  if (value === true) return fallback;
+  return value;
+}
+function resolveSyncConfig(sync) {
+  if (sync === false) {
+    return { extremes: false, highlight: false, visibility: false };
+  }
+  if (sync === true || sync === void 0) {
+    return { extremes: "x", highlight: "x", visibility: true };
+  }
+  return {
+    extremes: resolveAxis(sync.extremes, "x"),
+    highlight: resolveAxis(sync.highlight, "x"),
+    visibility: sync.visibility ?? true
+  };
+}
+function includesAxis(config, axis) {
+  if (config === false) return false;
+  return config === axis || config === "xy";
+}
+function ensureRegistration(charts, chartId) {
+  let reg = charts.get(chartId);
+  if (!reg) {
+    reg = {
+      config: { extremes: false, highlight: false, visibility: false },
+      extremes: /* @__PURE__ */ new Set(),
+      highlight: /* @__PURE__ */ new Set(),
+      visibility: /* @__PURE__ */ new Set()
+    };
+    charts.set(chartId, reg);
+  }
+  return reg;
+}
+var SyncBus = class {
+  constructor() {
+    this.charts = /* @__PURE__ */ new Map();
+    // --- Axis width registry for stacked-pane alignment ---
+    this.axisWidthsMap = /* @__PURE__ */ new Map();
+    this._maxAxisWidths = { left: 0, right: 0 };
+    this.axisWidthsListeners = /* @__PURE__ */ new Set();
+    // --- Dataset registry for shared legend ---
+    this.datasetRegistry = /* @__PURE__ */ new Map();
+    this.datasetListeners = /* @__PURE__ */ new Set();
+  }
+  /** Publish this chart's natural (un-padded) Y-axis left/right widths. No-op if unchanged. */
+  publishAxisWidths(chartId, widths) {
+    const prev = this.axisWidthsMap.get(chartId);
+    if (prev && prev.left === widths.left && prev.right === widths.right) return;
+    this.axisWidthsMap.set(chartId, widths);
+    this.recomputeMaxAxisWidths();
+  }
+  /** Get the current max axis widths across all registered charts. */
+  getMaxAxisWidths() {
+    return this._maxAxisWidths;
+  }
+  /** Subscribe to max axis width changes. Returns an unsubscribe function. */
+  subscribeAxisWidths(callback) {
+    this.axisWidthsListeners.add(callback);
+    return () => {
+      this.axisWidthsListeners.delete(callback);
+    };
+  }
+  recomputeMaxAxisWidths() {
+    let left = 0;
+    let right = 0;
+    for (const w of this.axisWidthsMap.values()) {
+      if (w.left > left) left = w.left;
+      if (w.right > right) right = w.right;
+    }
+    const changed = left !== this._maxAxisWidths.left || right !== this._maxAxisWidths.right;
+    this._maxAxisWidths = { left, right };
+    if (changed) {
+      for (const cb of this.axisWidthsListeners) cb(this._maxAxisWidths);
+    }
+  }
+  /** Register datasets from a chart (for shared legend). Replaces previous entry for this chartId. */
+  registerDatasets(chartId, datasets) {
+    this.datasetRegistry.set(chartId, datasets);
+    this.notifyDatasetListeners();
+  }
+  /** Unregister datasets when a chart unmounts */
+  unregisterDatasets(chartId) {
+    if (this.datasetRegistry.delete(chartId)) {
+      this.notifyDatasetListeners();
+    }
+  }
+  /** Get all registered datasets across all charts */
+  getAllDatasets() {
+    return this.datasetRegistry;
+  }
+  /** Subscribe to dataset registry changes. Returns unsubscribe function. */
+  subscribeDatasets(callback) {
+    this.datasetListeners.add(callback);
+    return () => {
+      this.datasetListeners.delete(callback);
+    };
+  }
+  notifyDatasetListeners() {
+    for (const cb of this.datasetListeners) {
+      cb();
+    }
+  }
+  /** Register a chart instance with its sync config (no callbacks) */
+  register(chartId, config) {
+    const reg = ensureRegistration(this.charts, chartId);
+    reg.config = config;
+  }
+  subscribe(chartId, type, callback) {
+    const reg = ensureRegistration(this.charts, chartId);
+    const set = reg[type];
+    set.add(callback);
+    return () => {
+      set.delete(callback);
+    };
+  }
+  /** Update a chart's sync config (e.g. when sync prop changes) */
+  updateConfig(chartId, config) {
+    const registration = this.charts.get(chartId);
+    if (registration) {
+      registration.config = config;
+    }
+  }
+  /** Unregister a chart instance and all its subscriptions */
+  unregister(chartId) {
+    this.charts.delete(chartId);
+    this.unregisterDatasets(chartId);
+    if (this.axisWidthsMap.delete(chartId)) {
+      this.recomputeMaxAxisWidths();
+    }
+  }
+  /** Broadcast an extremes (zoom/pan) event from a source chart */
+  broadcastExtremes(event) {
+    for (const [chartId, reg] of this.charts) {
+      if (chartId === event.sourceId) continue;
+      if (!includesAxis(reg.config.extremes, event.axis)) continue;
+      for (const cb of reg.extremes) {
+        cb(event);
+      }
+    }
+  }
+  /** Broadcast a highlight (cursor) event from a source chart */
+  broadcastHighlight(event) {
+    for (const [chartId, reg] of this.charts) {
+      if (chartId === event.sourceId) continue;
+      if (!includesAxis(reg.config.highlight, event.axis)) continue;
+      for (const cb of reg.highlight) {
+        cb(event);
+      }
+    }
+  }
+  /** Broadcast a visibility (series toggle) event from a source chart */
+  broadcastVisibility(event) {
+    for (const [chartId, reg] of this.charts) {
+      if (chartId === event.sourceId) continue;
+      if (!reg.config.visibility) continue;
+      for (const cb of reg.visibility) {
+        cb(event);
+      }
+    }
+  }
+  /** Get number of registered charts */
+  get size() {
+    return this.charts.size;
+  }
+};
+
+// src/sync/ChartSyncCoordinator.ts
+function zoomWindowEquals(a, b) {
+  if (a === null || b === null) return a === b;
+  return a.min === b.min && a.max === b.max;
+}
+function zoomStateEquals(a, b) {
+  return zoomWindowEquals(a.x, b.x) && zoomWindowEquals(a.y, b.y);
+}
+var ChartSyncCoordinator = class {
+  constructor(syncInfo) {
+    this._isSyncing = false;
+    this.prevVisibility = /* @__PURE__ */ new Map();
+    this.prevZoomState = { x: null, y: null };
+    /**
+     * The last zoom value applied from an incoming sync event. Used by onZoomChange
+     * to suppress the echo even when the wrapper's apply effect fires asynchronously
+     * (after the `_isSyncing` microtask reset). Cleared once matched.
+     */
+    this._lastSyncedZoom = null;
+    this.syncInfo = syncInfo;
+  }
+  get isSyncing() {
+    return this._isSyncing;
+  }
+  // ========== Setup ==========
+  /**
+   * Wire up all incoming sync subscriptions.
+   * Call once after constructing the coordinator; store the returned
+   * cleanup function and invoke it on component unmount.
+   */
+  start(options) {
+    const { bus, chartId, config } = this.syncInfo;
+    const unsubs = [];
+    if (config.extremes) {
+      unsubs.push(
+        bus.subscribe(chartId, "extremes", (event) => {
+          this._isSyncing = true;
+          const current = options.getZoomState();
+          const next = event.reset ? {
+            x: event.axis === "x" ? null : current.x,
+            y: event.axis === "y" ? null : current.y
+          } : {
+            x: event.axis === "x" ? { min: event.min, max: event.max } : current.x,
+            y: event.axis === "y" ? { min: event.min, max: event.max } : current.y
+          };
+          this._lastSyncedZoom = next;
+          options.applyZoom(next);
+          queueMicrotask(() => {
+            this._isSyncing = false;
+          });
+        })
+      );
+    }
+    if (config.visibility) {
+      unsubs.push(
+        bus.subscribe(chartId, "visibility", (event) => {
+          if (event.itemLabel !== void 0) {
+            this._isSyncing = true;
+            options.applyItemToggle(event.seriesId, event.itemLabel);
+            queueMicrotask(() => {
+              this._isSyncing = false;
+            });
+            return;
+          }
+          if (!event.seriesId) return;
+          const datasets = options.getDatasets();
+          let localId = datasets.has(event.seriesId) ? event.seriesId : null;
+          if (!localId) {
+            const allEntries = [...bus.getAllDatasets().values()].flat();
+            const sourceDs = allEntries.find((ds) => ds.datasetId === event.seriesId);
+            if (sourceDs) {
+              const localDs = allEntries.find((ds) => ds.chartId === chartId && ds.label === sourceDs.label);
+              localId = localDs?.datasetId ?? null;
+            }
+          }
+          if (!localId) return;
+          this._isSyncing = true;
+          options.applyVisibility(localId, event.visible);
+          queueMicrotask(() => {
+            this._isSyncing = false;
+          });
+        })
+      );
+    }
+    if (config.highlight) {
+      unsubs.push(
+        bus.subscribe(chartId, "highlight", (event) => {
+          if (event.normalized === null) {
+            options.applyHighlight({ tooltip: null, hoverDatasetId: null, hoverIndex: null });
+            return;
+          }
+          const normalizedEvent = {
+            normalized: event.normalized,
+            categoryIndex: event.categoryIndex ?? void 0,
+            sourceType: event.sourceType
+          };
+          const { width, height } = options.getDimensions();
+          const datasets = options.getDatasets();
+          if (options.getIsCartesian()) {
+            options.applyHighlight(handleSyncedHighlightCartesian(normalizedEvent, options.getRendererDelegate(), options.getHasCrosshair(), options.getIsSharedMode(), datasets));
+          } else if (options.getIsRect() && event.categoryIndex != null) {
+            options.applyHighlight(handleSyncedHighlightRect(normalizedEvent, datasets, width, height));
+          } else if (event.categoryIndex != null) {
+            options.applyHighlight(handleSyncedHighlightRadial(normalizedEvent, datasets, options.getRendererDelegate(), width, height));
+          }
+        })
+      );
+    }
+    return () => {
+      for (const unsub of unsubs) unsub();
+      bus.unregisterDatasets(chartId);
+    };
+  }
+  // ========== Outgoing ==========
+  /** Re-register datasets with the shared legend bus. Call whenever datasets or theme change. */
+  updateDatasets(datasets, theme) {
+    const infos = buildDatasetRegistrations(this.syncInfo.chartId, datasets, theme);
+    this.syncInfo.bus.registerDatasets(this.syncInfo.chartId, infos);
+  }
+  /**
+   * Broadcast zoom state changes to other charts.
+   * Always call this when zoom state changes — the guard is handled internally.
+   */
+  onZoomChange(current) {
+    const prev = this.prevZoomState;
+    this.prevZoomState = current;
+    if (this._isSyncing || !this.syncInfo.config.extremes) return;
+    if (this._lastSyncedZoom && zoomStateEquals(this._lastSyncedZoom, current)) {
+      this._lastSyncedZoom = null;
+      return;
+    }
+    this._lastSyncedZoom = null;
+    const axis = this.syncInfo.config.extremes;
+    if (axis === "x" || axis === "xy") {
+      if (current.x) {
+        this.syncInfo.bus.broadcastExtremes({ sourceId: this.syncInfo.chartId, axis: "x", min: current.x.min, max: current.x.max });
+      } else if (prev.x) {
+        this.syncInfo.bus.broadcastExtremes({ sourceId: this.syncInfo.chartId, axis: "x", min: 0, max: 0, reset: true });
+      }
+    }
+    if (axis === "y" || axis === "xy") {
+      if (current.y) {
+        this.syncInfo.bus.broadcastExtremes({ sourceId: this.syncInfo.chartId, axis: "y", min: current.y.min, max: current.y.max });
+      } else if (prev.y) {
+        this.syncInfo.bus.broadcastExtremes({ sourceId: this.syncInfo.chartId, axis: "y", min: 0, max: 0, reset: true });
+      }
+    }
+  }
+  /**
+   * Diff visibility state and broadcast changes to other charts.
+   * Always call this on visibility change — guard and diffing are handled internally.
+   * prevVisibility is always updated regardless of isSyncing to prevent stale state
+   * on the next outgoing broadcast.
+   */
+  onVisibilityChange(visibility) {
+    const shouldBroadcast = !this._isSyncing && !!this.syncInfo.config.visibility;
+    for (const [dsId, visible] of visibility) {
+      const was = this.prevVisibility.get(dsId) ?? true;
+      if (visible !== was && shouldBroadcast) {
+        this.syncInfo.bus.broadcastVisibility({ sourceId: this.syncInfo.chartId, seriesId: dsId, visible });
+      }
+    }
+    this.prevVisibility.clear();
+    for (const [k, v] of visibility) this.prevVisibility.set(k, v);
+  }
+};
+
+export { ChartSyncCoordinator, SyncBus, resolveSyncConfig };

package/dist/chunk-BETFQBM2.mjs

@@ -0,0 +1,197 @@
+// src/utils/specialized/squarify.utils.ts
+function worstAspectRatio(row, sideLength, totalRowArea) {
+  if (row.length === 0 || sideLength === 0) return Infinity;
+  const rowWidth = totalRowArea / sideLength;
+  if (rowWidth === 0) return Infinity;
+  let worst = 0;
+  for (const area of row) {
+    const itemLength = area / rowWidth;
+    const ratio = rowWidth > itemLength ? rowWidth / itemLength : itemLength / rowWidth;
+    if (ratio > worst) worst = ratio;
+  }
+  return worst;
+}
+function layoutRow(row, rect, totalArea, rowIndex) {
+  const rects = [];
+  const rowArea = row.reduce((s, item) => s + item.value, 0);
+  const isHorizontal = rect.w >= rect.h;
+  if (isHorizontal) {
+    const stripWidth = totalArea > 0 ? rowArea / totalArea * rect.w : 0;
+    let y = rect.y;
+    for (const item of row) {
+      const itemHeight = rowArea > 0 ? item.value / rowArea * rect.h : 0;
+      rects.push({ x: rect.x, y, width: stripWidth, height: itemHeight, index: item.index, depth: 0, _row: rowIndex });
+      y += itemHeight;
+    }
+    return {
+      rects,
+      remaining: { x: rect.x + stripWidth, y: rect.y, w: rect.w - stripWidth, h: rect.h }
+    };
+  } else {
+    const stripHeight = totalArea > 0 ? rowArea / totalArea * rect.h : 0;
+    let x = rect.x;
+    for (const item of row) {
+      const itemWidth = rowArea > 0 ? item.value / rowArea * rect.w : 0;
+      rects.push({ x, y: rect.y, width: itemWidth, height: stripHeight, index: item.index, depth: 0, _row: rowIndex });
+      x += itemWidth;
+    }
+    return {
+      rects,
+      remaining: { x: rect.x, y: rect.y + stripHeight, w: rect.w, h: rect.h - stripHeight }
+    };
+  }
+}
+function squarify(items, x, y, w, h) {
+  if (items.length === 0 || w <= 0 || h <= 0) return [];
+  const sorted = [...items].sort((a, b) => b.value - a.value);
+  const totalValue = sorted.reduce((s, item) => s + item.value, 0);
+  if (totalValue <= 0) return [];
+  const totalArea = w * h;
+  const scaled = sorted.map((item) => ({
+    value: item.value / totalValue * totalArea,
+    index: item.index
+  }));
+  const results = [];
+  let rect = { x, y, w, h };
+  let i = 0;
+  let rowIndex = 0;
+  while (i < scaled.length) {
+    const sideLength = Math.min(rect.w, rect.h);
+    const remainingArea = scaled.slice(i).reduce((s, item) => s + item.value, 0);
+    const row = [scaled[i]];
+    let rowAreaSum = scaled[i].value;
+    let currentWorst = worstAspectRatio([scaled[i].value], sideLength, rowAreaSum);
+    i++;
+    while (i < scaled.length) {
+      const candidate = scaled[i].value;
+      const newRowArea = rowAreaSum + candidate;
+      const newWorst = worstAspectRatio([...row.map((r) => r.value), candidate], sideLength, newRowArea);
+      if (newWorst > currentWorst) break;
+      row.push(scaled[i]);
+      rowAreaSum = newRowArea;
+      currentWorst = newWorst;
+      i++;
+    }
+    const { rects, remaining } = layoutRow(row, rect, remainingArea, rowIndex);
+    results.push(...rects);
+    rect = remaining;
+    rowIndex++;
+  }
+  return results;
+}
+function resquarify(items, x, y, w, h, previousRects) {
+  if (!previousRects || previousRects.length === 0 || previousRects.length !== items.length) {
+    return squarify(items, x, y, w, h);
+  }
+  if (items.length === 0 || w <= 0 || h <= 0) return [];
+  const sorted = [...items].sort((a, b) => b.value - a.value);
+  const totalValue = sorted.reduce((s, item) => s + item.value, 0);
+  if (totalValue <= 0) return [];
+  for (let k = 0; k < sorted.length; k++) {
+    if (sorted[k].index !== previousRects[k].index) {
+      return squarify(items, x, y, w, h);
+    }
+  }
+  let prevMinX = Infinity;
+  let prevMinY = Infinity;
+  let prevMaxX = -Infinity;
+  let prevMaxY = -Infinity;
+  for (const r of previousRects) {
+    if (r.x < prevMinX) prevMinX = r.x;
+    if (r.y < prevMinY) prevMinY = r.y;
+    if (r.x + r.width > prevMaxX) prevMaxX = r.x + r.width;
+    if (r.y + r.height > prevMaxY) prevMaxY = r.y + r.height;
+  }
+  const prevWidth = prevMaxX - prevMinX;
+  const prevHeight = prevMaxY - prevMinY;
+  const EPSILON = 0.5;
+  if (Math.abs(prevMinX - x) > EPSILON || Math.abs(prevMinY - y) > EPSILON || Math.abs(prevWidth - w) > EPSILON || Math.abs(prevHeight - h) > EPSILON) {
+    return squarify(items, x, y, w, h);
+  }
+  const totalArea = w * h;
+  const scaled = sorted.map((item) => ({
+    value: item.value / totalValue * totalArea,
+    index: item.index
+  }));
+  const result = new Array(sorted.length);
+  let i = 0;
+  while (i < previousRects.length) {
+    const rowIdx = previousRects[i]._row;
+    const rowStart = i;
+    while (i < previousRects.length && previousRects[i]._row === rowIdx) i++;
+    const rowEnd = i;
+    const first = previousRects[rowStart];
+    const sameX = previousRects.slice(rowStart, rowEnd).every((r) => r.x === first.x && r.width === first.width);
+    const rowItems = scaled.slice(rowStart, rowEnd);
+    const rowAreaSum = rowItems.reduce((s, it) => s + it.value, 0);
+    if (sameX) {
+      const stripX = first.x;
+      const stripWidth = first.width;
+      const stripY = first.y;
+      const stripHeight = previousRects[rowEnd - 1].y + previousRects[rowEnd - 1].height - stripY;
+      let cy = stripY;
+      for (let k = rowStart; k < rowEnd; k++) {
+        const cellHeight = rowAreaSum > 0 ? scaled[k].value / rowAreaSum * stripHeight : 0;
+        result[k] = {
+          x: stripX,
+          y: cy,
+          width: stripWidth,
+          height: cellHeight,
+          index: scaled[k].index,
+          depth: 0,
+          _row: rowIdx
+        };
+        cy += cellHeight;
+      }
+    } else {
+      const stripY = first.y;
+      const stripHeight = first.height;
+      const stripX = first.x;
+      const stripWidth = previousRects[rowEnd - 1].x + previousRects[rowEnd - 1].width - stripX;
+      let cx = stripX;
+      for (let k = rowStart; k < rowEnd; k++) {
+        const cellWidth = rowAreaSum > 0 ? scaled[k].value / rowAreaSum * stripWidth : 0;
+        result[k] = {
+          x: cx,
+          y: stripY,
+          width: cellWidth,
+          height: stripHeight,
+          index: scaled[k].index,
+          depth: 0,
+          _row: rowIdx
+        };
+        cx += cellWidth;
+      }
+    }
+  }
+  return result;
+}
+function sliceLayout(items, x, y, w, h) {
+  const total = items.reduce((s, item) => s + item.value, 0);
+  if (total <= 0) return [];
+  const rects = [];
+  let cy = y;
+  for (const item of items) {
+    const itemH = item.value / total * h;
+    rects.push({ x, y: cy, width: w, height: itemH, index: item.index, depth: 0 });
+    cy += itemH;
+  }
+  return rects;
+}
+function diceLayout(items, x, y, w, h) {
+  const total = items.reduce((s, item) => s + item.value, 0);
+  if (total <= 0) return [];
+  const rects = [];
+  let cx = x;
+  for (const item of items) {
+    const itemW = item.value / total * w;
+    rects.push({ x: cx, y, width: itemW, height: h, index: item.index, depth: 0 });
+    cx += itemW;
+  }
+  return rects;
+}
+function sliceDiceLayout(items, x, y, w, h, depth = 0) {
+  return depth % 2 === 0 ? sliceLayout(items, x, y, w, h) : diceLayout(items, x, y, w, h);
+}
+
+export { diceLayout, resquarify, sliceDiceLayout, sliceLayout, squarify };