@luxalgo/vela 0.7.2 → 0.7.4

package/dist/{statusline-model-DUKt7_TQ.d.cts → statusline-model-Bd4qKuD6.d.cts}

@@ -1,6 +1,6 @@
-import { D as DataProvider } from './DataProvider-D5uMiJYz.cjs';
-import { S as ScriptingEngine, V as Vela } from './contributions-CcBFe-91.cjs';
-import { W as WallClock, V as VisibleRangePreset } from './options-C7b_Qssu.cjs';
+import { D as DataProvider } from './DataProvider-RF1axuy1.cjs';
+import { S as ScriptingEngine, V as Vela } from './contributions-DpZeu7KP.cjs';
+import { W as WallClock, V as VisibleRangePreset } from './options-XVpfr9HV.cjs';
 
 /** The linkable dimensions. `crosshair` mirrors the pointer time onto same-group
  *  cells as GHOST crosshairs (renderers without the optional `setExternalCrosshair`

package/dist/{statusline-model-D8NL7o4L.d.ts → statusline-model-CPa_hmhd.d.ts}

@@ -1,6 +1,6 @@
-import { D as DataProvider } from './DataProvider-BALR0qPq.js';
-import { S as ScriptingEngine, V as Vela } from './contributions-BbhbZd3c.js';
-import { W as WallClock, V as VisibleRangePreset } from './options-C7b_Qssu.js';
+import { D as DataProvider } from './DataProvider-CVpN5sCq.js';
+import { S as ScriptingEngine, V as Vela } from './contributions-CspPrMAJ.js';
+import { W as WallClock, V as VisibleRangePreset } from './options-XVpfr9HV.js';
 
 /** The linkable dimensions. `crosshair` mirrors the pointer time onto same-group
  *  cells as GHOST crosshairs (renderers without the optional `setExternalCrosshair`

package/dist/ui.d.cts

@@ -1,4 +1,4 @@
-import { c as VelaTheme } from './options-C7b_Qssu.cjs';
+import { c as VelaTheme } from './options-XVpfr9HV.cjs';
 import { MachineSchema, Service, Machine } from '@zag-js/core';
 export { a as KeyBindingDescriptor, K as KeymapManager, b as KeymapOptions, R as ResolvedBinding } from './keymap-CGOz5F5f.cjs';
 import * as tooltip from '@zag-js/tooltip';

package/dist/ui.d.ts

@@ -1,4 +1,4 @@
-import { c as VelaTheme } from './options-C7b_Qssu.js';
+import { c as VelaTheme } from './options-XVpfr9HV.js';
 import { MachineSchema, Service, Machine } from '@zag-js/core';
 export { a as KeyBindingDescriptor, K as KeymapManager, b as KeymapOptions, R as ResolvedBinding } from './keymap-CGOz5F5f.js';
 import * as tooltip from '@zag-js/tooltip';

package/dist/vela.global.js

@@ -27865,6 +27865,32 @@ void main() {
     }
     return out;
   }
+  function foldOverlappingClusters(clusters, xOf, bucketPx = MARK_CLUSTER_PX) {
+    const byGroup = /* @__PURE__ */ new Map();
+    for (const c of clusters) {
+      const list = byGroup.get(c.group);
+      if (list) list.push(c);
+      else byGroup.set(c.group, [c]);
+    }
+    const out = [];
+    for (const list of byGroup.values()) {
+      list.sort((a, b) => a.bar - b.bar);
+      const runs = [];
+      let anchorX = Number.NaN;
+      for (const c of list) {
+        const x = xOf(c.bar);
+        const run = runs[runs.length - 1];
+        if (run && Number.isFinite(x) && Number.isFinite(anchorX) && x - anchorX < bucketPx) {
+          run.marks.push(...c.marks);
+        } else {
+          runs.push({ key: c.key, bar: c.bar, group: c.group, marks: [...c.marks] });
+          anchorX = x;
+        }
+      }
+      out.push(...runs);
+    }
+    return out;
+  }
   function groupRank(groups, clusters) {
     const rank = /* @__PURE__ */ new Map();
     groups.forEach((g, i) => rank.set(g.id, i));
@@ -27874,7 +27900,7 @@ void main() {
     return (group) => group === void 0 ? Number.MAX_SAFE_INTEGER : rank.get(group) ?? Number.MAX_SAFE_INTEGER - 1;
   }
   function layoutMarkLane(input) {
-    const clusters = clusterMarks(input.marks, input.barTimes, input.intervalMs, input.hidden);
+    const clusters = foldOverlappingClusters(clusterMarks(input.marks, input.barTimes, input.intervalMs, input.hidden), input.xOf);
     const rankOf = groupRank(input.groups, clusters);
     const byBar = /* @__PURE__ */ new Map();
     for (const c of clusters) {
@@ -39376,7 +39402,7 @@ ${overlayScrollbarCss(".vela-sd-pane")}
       for (const l of this.extLayers) {
         if (!l.def.repaintOnCursor) continue;
         const lp = this.layerPane(l) ?? pane;
-        if (lp.collapsed) continue;
+        if (lp.collapsed || this.layerHiddenWithCandles(l)) continue;
         l.instance.render(this.extLayerArgs(l, lp.scale, lp.bounds, nowMs));
         if (this.animZoom.on && l.instance.animating?.()) this.animator.start();
       }
@@ -39438,7 +39464,7 @@ ${overlayScrollbarCss(".vela-sd-pane")}
         let folded = null;
         for (const l of this.extLayers) {
           const lp = this.layerPane(l) ?? pane;
-          if (lp.collapsed) {
+          if (lp.collapsed || this.layerHiddenWithCandles(l)) {
             this.clearLayerCanvas(l.canvas);
             continue;
           }
@@ -39606,7 +39632,7 @@ ${overlayScrollbarCss(".vela-sd-pane")}
           const or2 = overlaySeriesRange(this.scene.indicators.values(), i0, i1, (id) => this.scene.offsetOf(id));
           if (or2) dr = dr ? { min: Math.min(dr.min, or2.min), max: Math.max(dr.max, or2.max) } : or2;
         }
-        const includeCandles = pane.kind === "price" && (!this.scene.candlesHidden || this.priceLayersAnchoredToBars(masterModels));
+        const includeCandles = pane.kind === "price" && (!this.scene.candlesHidden || this.priceLayersAnchoredToBars(masterModels) || !this.paneHasMeasurableContent(masterModels, dr));
         pane.scaleTarget = computePaneScale(masterModels, this.bars, includeCandles, i0, i1, dr, paneLogScale(this.scene, pane), (id) => this.scene.offsetOf(id));
         pane.percentBaseline = pane.kind === "price" ? this.bars[i0]?.close ?? 0 : this.firstVisibleValue(masterModels, i0);
         pane.axisFormat = void 0;
@@ -39838,16 +39864,31 @@ ${overlayScrollbarCss(".vela-sd-pane")}
       );
     }
     /**
-     * True when SDK-layer content on the price pane paints at BAR PRICES without
-     * contributing a series: the active chart type's own layer, or an overlay layer native
-     * (a series-less model whose type names a mounted layer). Hiding the candles must then
-     * keep the bars in the price scale — with nothing else on the pane the scale would fall
-     * to the {0,1} placeholder and every such layer would paint off-screen and vanish.
+     * True for the layer painting the ACTIVE chart type (the base entry whose id is the
+     * current price style) while the price series is hidden. The chart type IS the price
+     * series, so "hide chart" blanks its layer along with the bars; an indicator's layer
+     * (an overlay layer native, on any pane) is independent content and keeps painting.
+     */
+    layerHiddenWithCandles(l) {
+      return this.scene.candlesHidden && l.owner === null && l.def.id === this.scene.priceStyle;
+    }
+    /**
+     * True when an overlay layer native (a series-less model whose type names a mounted
+     * layer) sits on the price pane: it paints at BAR PRICES without contributing a series,
+     * so hiding the candles must keep the bars in the price scale — with nothing else on the
+     * pane the scale would fall to the {0,1} placeholder and the layer would paint off-screen
+     * and vanish. The chart type's own layer does not count: it is blanked with the candles.
      */
     priceLayersAnchoredToBars(masterModels) {
-      if (this.extLayers.some((l) => l.owner === null && l.def.id === this.scene.priceStyle)) return true;
       return masterModels.some((m) => m.series.length === 0 && !!m.native && this.extLayers.some((l) => l.def.id === m.native.type));
     }
+    /** True when the pane's master content contributes SOMETHING to its autoscale besides
+     *  the candles: a series painted on the pane (force_overlay ones scale elsewhere), a
+     *  price line, or a measured drawings range. Mirrors what `computePaneScale` considers. */
+    paneHasMeasurableContent(masterModels, drawings) {
+      if (drawings) return true;
+      return masterModels.some((m) => m.priceLines.length > 0 || m.series.some((s) => s.overlay !== true));
+    }
     /** Per-pane scale state for a host UI (e.g. a price-axis context menu): the pane's pixel
      *  band (`top`/`height`, so a click y maps to a pane) plus its current axis `mode`/`log`.
      *  Top-to-bottom order. Every pane is independent — the price pane from the scene setting,