@primeui/chart-core 0.0.1-alpha.1

package/dist/chunk-WPFUV7K3.mjs

@@ -0,0 +1,488 @@
+import { candlestickHitTest, candlestickFindAllNearest } from './chunk-M7B3JF43.mjs';
+import { buildCandlestickFingerprint } from './chunk-JO7VACY2.mjs';
+import { calculateCandlestickLayout } from './chunk-3OZLP4I4.mjs';
+import { registerDatasetLayers, triggerCompositorRepaint } from './chunk-Q6PPVIHU.mjs';
+import { AnimatedScene, resolveAnimatedProps, CANDLESTICK_ANIMATABLE_PROPS } from './chunk-VN7CKCSE.mjs';
+import { reconcileSvgChildren } from './chunk-KP2TWD4Z.mjs';
+import { parseAnimationConfig } from './chunk-3WEMHXZI.mjs';
+import { raf, cancelRaf } from './chunk-EDAKJLNA.mjs';
+import { buildAccessibilityRenderContext, generateSeriesDescription } from './chunk-OGJ6IIBW.mjs';
+import { collectItems } from './chunk-FFMT6OCO.mjs';
+import { materializeSvgNode, setAttr } from './chunk-SSLTFJ3U.mjs';
+
+// src/series/candlestick/controller/index.ts
+function buildCandlestickSvgChildren(params) {
+  const { paint, frameLayouts, frameRenderProps, context, hover } = params;
+  const children = [];
+  for (const [dsId, csLayout] of frameLayouts) {
+    const props = frameRenderProps.get(dsId);
+    if (!props) continue;
+    const propsWithHover = {
+      ...props,
+      hoveredIndex: hover.datasetId === dsId ? hover.index : null
+    };
+    const node = paint.renderSvg(propsWithHover, csLayout, context);
+    setAttr(node, "data-dataset", dsId);
+    if (context.accessibility?.enabled && context.accessibility.landmarkVerbosity === "all") {
+      setAttr(node, "role", "region");
+      setAttr(node, "aria-label", generateSeriesDescription(props.name ?? dsId, "candlestick", csLayout.visibleCandles.length));
+    }
+    children.push(node);
+  }
+  return children;
+}
+var CANDLE_REGISTRY = {
+  number: ["x", "bodyWidth", "wickTop", "wickBottom", "bodyTop", "bodyBottom", "openY", "closeY"],
+  color: []
+};
+var CandlestickRendererController = class {
+  constructor(paint) {
+    this.layoutCache = /* @__PURE__ */ new Map();
+    this.renderPropsCache = /* @__PURE__ */ new Map();
+    this.candlestickDatasets = [];
+    this.lastInput = null;
+    // Animation lifecycle — local raf clock + fingerprint for phase detection.
+    this._animRafId = null;
+    // Single source of truth for the current hover. Written ONLY by applyHover, read by the
+    // update() bake, renderFrame (scene loop) and the canvas re-bake. Must NOT live on `input`:
+    // the scene-loop tick captures a stale `input` while update() swaps `this.lastInput`, so an
+    // input-coupled hover lags by a hover (the "hover twice to show" bug). Mirrors radar/polar.
+    this._hover = { datasetId: null, index: null };
+    this._lastFingerprint = "";
+    this._lastRenderedLayout = null;
+    // Render-time caches — include visible + exiting entries. Populated by
+    // _renderSceneFrame each tick so exiting candles' fade-out still paints.
+    // cellLayouts/renderPropsMap from update() are visible-only (mirrors Scatter's
+    // 4-cache split): hit-test reads from _lastRenderedLayout (which mirrors
+    // renderLayouts), while these two stash the latest renderable state per
+    // dataset for the fallback chain.
+    this._renderLayouts = /* @__PURE__ */ new Map();
+    this._activeRenderPropsCache = /* @__PURE__ */ new Map();
+    // Per-dataset property-animation overrides resolved from AnimatedPropertyStore.
+    // Set by `applyPropertyAnimations()` each property-animation tick and merged
+    // into render props uniformly across all candles of the dataset at every
+    // cache-write site (_renderSceneFrame). Cleared by `destroy()`.
+    //
+    // Step 10 keeps this per-dataset only. Per-candle granularity is Step 14;
+    // the scene elements are already keyed per-candle from the Step 3 migration,
+    // but the override map is intentionally coarse for this phase.
+    this._propertyOverrides = /* @__PURE__ */ new Map();
+    // DOM targets
+    this.svgGroup = null;
+    this.canvasEl = null;
+    this.onFrame = null;
+    this._paint = paint;
+    this._scene = new AnimatedScene({
+      // ENTER: candle collapses to a zero-height segment at baselineY.
+      // baselineY is stored on the target state so we can read it here.
+      emptyState: (target) => ({
+        ...target,
+        wickTop: target.baselineY,
+        wickBottom: target.baselineY,
+        bodyTop: target.baselineY,
+        bodyBottom: target.baselineY,
+        openY: target.baselineY,
+        closeY: target.baselineY
+      }),
+      // EXIT: same shape — candle shrinks back to baseline at its current x.
+      exitEmptyState: (target) => ({
+        ...target,
+        wickTop: target.baselineY,
+        wickBottom: target.baselineY,
+        bodyTop: target.baselineY,
+        bodyBottom: target.baselineY,
+        openY: target.baselineY,
+        closeY: target.baselineY
+      }),
+      registry: CANDLE_REGISTRY
+    });
+  }
+  // ================================================================
+  // PUBLIC API
+  // ================================================================
+  update(input) {
+    this.lastInput = input;
+    this.svgGroup = input.svgGroup ?? null;
+    this.canvasEl = input.canvasEl ?? null;
+    const { datasets, datasetVisibility, chartArea, chartId, width, height, categoryScale, valueScales, firstValueAxisId, hoverConfig, compositor } = input;
+    const sortedDatasets = Array.from(datasets.entries()).sort(([, a], [, b]) => a.order - b.order);
+    this.candlestickDatasets = collectItems(sortedDatasets, datasetVisibility).candlestick;
+    if ((this.candlestickDatasets.length === 0 || !categoryScale || !valueScales || valueScales.size === 0) && this._scene.getElements().length === 0) {
+      this.layoutCache.clear();
+      this.renderPropsCache.clear();
+      this._renderLayouts.clear();
+      this._activeRenderPropsCache.clear();
+      this._propertyOverrides.clear();
+      this.candlestickDatasets = [];
+      this._cancelRaf();
+      this._scene.reset();
+      this._lastFingerprint = "";
+      this._lastRenderedLayout = null;
+      if (input.renderer === "svg" && this.svgGroup) {
+        while (this.svgGroup.firstChild) this.svgGroup.removeChild(this.svgGroup.firstChild);
+      }
+      return;
+    }
+    const visibleDatasets = this.candlestickDatasets.filter((d) => d.visible);
+    const layouts = /* @__PURE__ */ new Map();
+    const renderPropsMap = /* @__PURE__ */ new Map();
+    const hasScales = !!categoryScale && !!valueScales && valueScales.size > 0;
+    if (hasScales) {
+      const sharedValueScale = valueScales.values().next().value;
+      for (const cd of visibleDatasets) {
+        const targetAxisId = cd.props.yAxisId ?? firstValueAxisId;
+        const targetValueScale = valueScales.get(targetAxisId) ?? sharedValueScale;
+        layouts.set(cd.id, {
+          ...calculateCandlestickLayout(
+            cd.props,
+            chartArea,
+            {
+              categoryScale,
+              valueScale: targetValueScale
+            },
+            input.theme
+          ),
+          datasetIndex: 0
+        });
+        const overrides = this._propertyOverrides.get(cd.id);
+        renderPropsMap.set(cd.id, {
+          ...cd.props,
+          ...overrides ?? {},
+          hoveredIndex: this._hover.datasetId === cd.id ? this._hover.index : null,
+          effects: hoverConfig ? { dimOpacity: hoverConfig.dimOpacity, hoverBrightness: hoverConfig.brightness } : void 0
+        });
+      }
+    }
+    this.layoutCache = layouts;
+    this.renderPropsCache = renderPropsMap;
+    const context = { chartId, width, height, renderer: input.renderer, chartArea, theme: input.theme, accessibility: buildAccessibilityRenderContext(input.features) };
+    if (input.renderer === "canvas" && compositor) {
+      registerDatasetLayers(
+        compositor,
+        "candlestick",
+        layouts.keys(),
+        (dsId) => datasets.get(dsId)?.order ?? 0,
+        (dsId) => (ctx) => {
+          const csLayout = this._lastRenderedLayout?.get(dsId) ?? this.layoutCache.get(dsId);
+          const csProps = this.renderPropsCache.get(dsId);
+          if (!csLayout || !csProps) return;
+          this._paint.renderCanvas(csProps, csLayout, ctx, context);
+        }
+      );
+    }
+    const baselineY = chartArea.y + chartArea.height;
+    const animConfig = input.features.get("animation")?.props;
+    const { enabled, duration, easing } = parseAnimationConfig(animConfig);
+    const limit = animConfig?.limit ?? 5e3;
+    const fingerprint = buildCandlestickFingerprint(layouts);
+    const phase = this._lastFingerprint === "" ? "entrance" : fingerprint !== this._lastFingerprint ? "update" : "static";
+    let totalCandles = 0;
+    for (const l of layouts.values()) totalCandles += l.candles.length;
+    const shouldAnimate = enabled && duration > 0 && totalCandles <= limit && phase !== "static";
+    const sceneTargets = this._buildSceneTargets(layouts, baselineY);
+    const currentElements = this._scene.getElements();
+    let hasExits = false;
+    for (const el of currentElements) {
+      if (!sceneTargets.has(el.id)) {
+        hasExits = true;
+        break;
+      }
+    }
+    const currentIds = new Set(currentElements.map((el) => el.id));
+    let hasEnters = false;
+    for (const id of sceneTargets.keys()) {
+      if (!currentIds.has(id)) {
+        hasEnters = true;
+        break;
+      }
+    }
+    const isMidAnimInterrupt = phase === "update" && this._animRafId !== null;
+    const shouldSnapUpdates = phase === "update" && !isMidAnimInterrupt && !hasExits && !hasEnters;
+    const numbersDuration = shouldSnapUpdates ? 0 : shouldAnimate ? duration : 0;
+    const opts = {
+      numbers: { duration: numbersDuration, easing },
+      colors: { duration: numbersDuration, easing }
+    };
+    if (phase === "static" && this._animRafId !== null) {
+      this._commit(fingerprint);
+      return;
+    }
+    this._cancelRaf();
+    this._scene.diff(sceneTargets, opts);
+    if (shouldAnimate && !shouldSnapUpdates) {
+      this._renderSceneFrame(layouts, renderPropsMap, context, input);
+      const tick = (now) => {
+        this._animRafId = null;
+        const { allIdle } = this._scene.tick(now);
+        this._renderSceneFrame(layouts, renderPropsMap, context, input);
+        if (!allIdle) {
+          this._animRafId = raf(tick);
+        }
+      };
+      this._animRafId = raf(tick);
+    } else {
+      this._scene.tick(performance.now());
+      this._renderSceneFrame(layouts, renderPropsMap, context, input);
+    }
+    this._commit(fingerprint);
+  }
+  /**
+   * Build the per-candle scene-target map from the computed cell layouts.
+   * Element id format: `${datasetId}::${dataIndex}`. Preserves the hotfix's
+   * index-based identity for matching candles across data updates.
+   *
+   * `baselineY` is included on every target so the scene's `emptyState`
+   * callback can read it (the callback receives only `target: T`, no
+   * external context).
+   */
+  _buildSceneTargets(cellLayouts, baselineY) {
+    const targets = /* @__PURE__ */ new Map();
+    for (const [datasetId, layout] of cellLayouts) {
+      for (const candle of layout.candles) {
+        const id = `${datasetId}::${candle.dataIndex}`;
+        targets.set(id, {
+          x: candle.x,
+          bodyWidth: candle.bodyWidth,
+          wickTop: candle.wickTop,
+          wickBottom: candle.wickBottom,
+          bodyTop: candle.bodyTop,
+          bodyBottom: candle.bodyBottom,
+          openY: candle.openY,
+          closeY: candle.closeY,
+          baselineY,
+          bodyFill: candle.bodyFill,
+          bodyStroke: candle.bodyStroke,
+          wickColor: candle.wickColor,
+          wickStrokeWidth: candle.wickStrokeWidth,
+          useClass: candle.useClass,
+          direction: candle.direction,
+          proDirection: candle.proDirection,
+          borderDash: candle.borderDash,
+          borderDashOffset: candle.borderDashOffset,
+          visible: candle.visible,
+          dataIndex: candle.dataIndex,
+          datasetId,
+          label: candle.label,
+          open: candle.open,
+          high: candle.high,
+          low: candle.low,
+          close: candle.close
+        });
+      }
+    }
+    return targets;
+  }
+  /**
+   * Walk the scene and rebuild per-dataset CandlestickRenderData reflecting
+   * the current visual state. Used by the raf tick loop AND for one-shot
+   * static renders. Stores the result in `_lastRenderedLayout` so hitTest
+   * and the canvas compositor paint closure continue to read live state.
+   *
+   * The interrupt-safety contract previously provided by snapshotting
+   * `_lastRenderedLayout` as the next tween's start is now structural via
+   * AnimatedElement.setTarget capturing `current[field]` automatically per
+   * candle. `_lastRenderedLayout` here is a READ-only projection of the
+   * scene used by hit-test and compositor callbacks.
+   */
+  _renderSceneFrame(cellLayouts, renderPropsMap, context, input) {
+    const candlesByDataset = /* @__PURE__ */ new Map();
+    for (const el of this._scene.getElements()) {
+      const s = el.current;
+      const candle = {
+        x: s.x,
+        bodyWidth: s.bodyWidth,
+        wickTop: s.wickTop,
+        wickBottom: s.wickBottom,
+        bodyTop: s.bodyTop,
+        bodyBottom: s.bodyBottom,
+        openY: s.openY,
+        closeY: s.closeY,
+        bodyFill: s.bodyFill,
+        bodyStroke: s.bodyStroke,
+        wickColor: s.wickColor,
+        wickStrokeWidth: s.wickStrokeWidth,
+        useClass: s.useClass,
+        direction: s.direction,
+        proDirection: s.proDirection,
+        borderDash: s.borderDash,
+        borderDashOffset: s.borderDashOffset,
+        visible: s.visible,
+        dataIndex: s.dataIndex,
+        label: s.label,
+        open: s.open,
+        high: s.high,
+        low: s.low,
+        close: s.close
+      };
+      let arr = candlesByDataset.get(s.datasetId);
+      if (!arr) {
+        arr = [];
+        candlesByDataset.set(s.datasetId, arr);
+      }
+      arr.push(candle);
+    }
+    const frameLayouts = /* @__PURE__ */ new Map();
+    const frameRenderProps = /* @__PURE__ */ new Map();
+    const datasetIds = /* @__PURE__ */ new Set([...cellLayouts.keys(), ...candlesByDataset.keys()]);
+    for (const datasetId of datasetIds) {
+      const targetLayout = cellLayouts.get(datasetId) ?? this._renderLayouts.get(datasetId);
+      if (!targetLayout) continue;
+      const baseRenderProps = renderPropsMap.get(datasetId) ?? this._activeRenderPropsCache.get(datasetId);
+      if (!baseRenderProps) continue;
+      const overrides = this._propertyOverrides.get(datasetId);
+      const renderProps = overrides ? { ...baseRenderProps, ...overrides } : baseRenderProps;
+      const liveCandles = candlesByDataset.get(datasetId) ?? [];
+      liveCandles.sort((a, b) => a.dataIndex - b.dataIndex);
+      frameLayouts.set(datasetId, {
+        ...targetLayout,
+        candles: liveCandles,
+        visibleCandles: liveCandles.filter((c) => c.visible)
+      });
+      frameRenderProps.set(datasetId, renderProps);
+    }
+    this._renderLayouts = frameLayouts;
+    this._activeRenderPropsCache = frameRenderProps;
+    this._lastRenderedLayout = frameLayouts;
+    this.renderFrame(frameLayouts, frameRenderProps, context, input);
+  }
+  _cancelRaf() {
+    if (this._animRafId !== null) {
+      cancelRaf(this._animRafId);
+      this._animRafId = null;
+    }
+  }
+  _commit(fingerprint) {
+    this._lastFingerprint = fingerprint;
+  }
+  renderFrame(frameLayouts, renderPropsMap, context, input) {
+    if (input.renderer === "svg" && this.svgGroup) {
+      const group = this.svgGroup;
+      const children = buildCandlestickSvgChildren({ paint: this._paint, frameLayouts, frameRenderProps: renderPropsMap, context, hover: this._hover });
+      group.replaceChildren(...children.map(materializeSvgNode));
+    }
+    if (triggerCompositorRepaint(input.renderer, this.canvasEl, input.compositor)) ; else if (input.renderer === "canvas") {
+      const ctx = this.canvasEl?.getContext("2d");
+      if (ctx) {
+        for (const [dsId, csLayout] of frameLayouts) {
+          const csProps = renderPropsMap.get(dsId);
+          if (!csProps) continue;
+          this._paint.renderCanvas(csProps, csLayout, ctx, context);
+        }
+      }
+    }
+  }
+  applyHover(hover) {
+    if (this.layoutCache.size === 0 || !this.lastInput) return;
+    const input = this.lastInput;
+    this._hover = hover;
+    if (this._animRafId !== null) return;
+    if (input.renderer === "svg" && this.svgGroup) {
+      const context = {
+        chartId: input.chartId,
+        width: input.width,
+        height: input.height,
+        renderer: input.renderer,
+        chartArea: input.chartArea,
+        theme: input.theme,
+        accessibility: buildAccessibilityRenderContext(input.features)
+      };
+      const children = buildCandlestickSvgChildren({
+        paint: this._paint,
+        frameLayouts: this._renderLayouts,
+        frameRenderProps: this._activeRenderPropsCache,
+        context,
+        hover
+      });
+      reconcileSvgChildren(this.svgGroup, children);
+      return;
+    }
+    if (input.renderer === "canvas" && input.compositor) {
+      for (const [dsId, props] of this.renderPropsCache) {
+        this.renderPropsCache.set(dsId, { ...props, hoveredIndex: hover.datasetId === dsId ? hover.index : null });
+      }
+      triggerCompositorRepaint(input.renderer, this.canvasEl, input.compositor);
+    }
+  }
+  /**
+   * Apply animated property values without triggering a full layout cycle.
+   * Called from the property-animation framework wrapper each animation tick.
+   *
+   * Per-dataset: writes overrides into `_propertyOverrides` (or deletes the
+   * entry when the store has no live values for it), then patches downstream
+   * caches and triggers a repaint. The overrides apply uniformly to all
+   * candles of the dataset — per-candle granularity is Step 14.
+   *
+   * SVG: candlestick renders candles imperatively each frame from
+   * `_activeRenderPropsCache`, so a `renderFrameCycle()` call replays the
+   * merged props onto the DOM. Canvas: refreshes the cache then triggers
+   * compositor repaint so the layer paint callback reads the merged props.
+   */
+  applyPropertyAnimations(store) {
+    const input = this.lastInput;
+    if (!input) return;
+    let appliedAny = false;
+    for (const [dsId, baseProps] of this.renderPropsCache) {
+      const overrides = resolveAnimatedProps(store, "candlestick", dsId, CANDLESTICK_ANIMATABLE_PROPS);
+      if (Object.keys(overrides).length === 0) {
+        if (this._propertyOverrides.delete(dsId)) appliedAny = true;
+        continue;
+      }
+      appliedAny = true;
+      this._propertyOverrides.set(dsId, overrides);
+      this.renderPropsCache.set(dsId, { ...baseProps, ...overrides });
+      const activeBase = this._activeRenderPropsCache.get(dsId);
+      if (activeBase) {
+        this._activeRenderPropsCache.set(dsId, { ...activeBase, ...overrides });
+      }
+    }
+    if (!appliedAny) return;
+    if (triggerCompositorRepaint(input.renderer, this.canvasEl, input.compositor)) return;
+    if (input.renderer === "svg") {
+      this.renderFrameCycle();
+    }
+  }
+  /**
+   * Full re-render of the current scene state.
+   *
+   * Used by the property-animation framework wrapper: when a property
+   * animation completes and its override is released from the store,
+   * `_renderSceneFrame()` rebuilds `_activeRenderPropsCache` from the now-empty
+   * overrides map, then projects the cleaned props to DOM / canvas so SVG
+   * attributes snap back to base values.
+   */
+  renderFrameCycle() {
+    const input = this.lastInput;
+    if (!input) return;
+    const context = { chartId: input.chartId, width: input.width, height: input.height, renderer: input.renderer, chartArea: input.chartArea, theme: input.theme, accessibility: buildAccessibilityRenderContext(input.features) };
+    this._renderSceneFrame(this.layoutCache, this.renderPropsCache, context, input);
+  }
+  hitTest(x, y) {
+    const layouts = this._lastRenderedLayout ?? this.layoutCache;
+    return candlestickHitTest(x, y, { layouts, renderPropsCache: this.renderPropsCache, layoutData: this.lastInput?.layoutData ?? null });
+  }
+  findAllNearest(x, y) {
+    const layouts = this._lastRenderedLayout ?? this.layoutCache;
+    return candlestickFindAllNearest(x, y, { layouts, renderPropsCache: this.renderPropsCache, layoutData: this.lastInput?.layoutData ?? null });
+  }
+  getSvgOutput() {
+    return null;
+  }
+  get hasData() {
+    return this.candlestickDatasets.length > 0;
+  }
+  get layouts() {
+    return this.layoutCache;
+  }
+  destroy() {
+    this._cancelRaf();
+    this._scene.reset();
+    this._lastFingerprint = "";
+    this._lastRenderedLayout = null;
+    this._renderLayouts.clear();
+    this._activeRenderPropsCache.clear();
+    this._propertyOverrides.clear();
+    this.lastInput?.compositor?.removeLayersByPrefix("candlestick:");
+  }
+};
+
+export { CandlestickRendererController };