@luxalgo/vela 0.6.10 → 0.6.11

package/dist/vela.global.js

@@ -130,6 +130,12 @@ var Vela = (function (exports) {
     get visible() {
       return this.visibleState;
     }
+    inputValues() {
+      return this.controller.inputValuesOf(this.id);
+    }
+    propValues() {
+      return this.controller.propValuesOf(this.id);
+    }
     setInput(key, value) {
       this.controller.applyInputs(this.id, { [key]: value });
     }
@@ -7272,6 +7278,7 @@ var Vela = (function (exports) {
   var PREVIEW_BARS = 300;
   var SINGLE_LOAD_BARS = 5e3;
   var CHUNK_BARS = 1e4;
+  var FIRST_PAINT_BARS = 100;
   var GAP_FACTOR = 1.5;
   var HEAL_COOLDOWN_MS = 5e3;
   var EngineOrchestrator = class _EngineOrchestrator {
@@ -7541,6 +7548,7 @@ var Vela = (function (exports) {
         let painted = false;
         const paint = (bars, final) => {
           if (this.generation !== gen || !final && bars.length === 0) return;
+          if (!painted && !final && bars.length < Math.min(requested, FIRST_PAINT_BARS)) return;
           this.setBarSeries(bars, painted ? { preserveView: true } : void 0);
           if (!painted && bars.length > 0) {
             painted = true;
@@ -8171,6 +8179,15 @@ var Vela = (function (exports) {
       record.pendingCause = "inputs";
       if (record.session) record.session.update(record.inputValues);
       else if (record.native && !record.hidden) record.native.instance.setInputs(record.inputValues);
+      this.events.emit("indicator:inputs", { id });
+    }
+    /** IndicatorController: the CURRENT stored input values (defaults merged with edits). */
+    inputValuesOf(id) {
+      return { ...this.registry.get(id)?.inputValues };
+    }
+    /** IndicatorController: the CURRENT declaration-prop overrides. */
+    propValuesOf(id) {
+      return { ...this.registry.get(id)?.propValues };
     }
     /** IndicatorController: re-run an indicator with merged declaration-prop overrides.
      *  Same lifecycle as {@link applyInputs} — a prop change replays the whole script.
@@ -8184,6 +8201,7 @@ var Vela = (function (exports) {
       if (!record.hidden) this.setLoading(record, true);
       record.pendingCause = "inputs";
       record.session.update(record.inputValues, record.propValues);
+      this.events.emit("indicator:inputs", { id });
     }
     /** IndicatorController: tear down an indicator and (if now empty) its pane. */
     /** Live handles of every indicator on the chart (script + native), insertion order. */
@@ -17222,6 +17240,14 @@ ${STATIC_DECLS}
     const conds = Array.isArray(when) ? when : [when];
     return conds.every((c) => c.anyOf ? c.anyOf.some((x) => x === values[c.key]) : values[c.key] === c.equals);
   }
+  function inputDeltas(schema, values) {
+    const out = {};
+    for (const s of schema) {
+      const v = values[s.key];
+      if (v !== void 0 && JSON.stringify(v) !== JSON.stringify(s.defval)) out[s.key] = v;
+    }
+    return Object.keys(out).length > 0 ? out : void 0;
+  }
 
   // src/ui/components/select/controller.ts
   function selectController(opts) {
@@ -24194,6 +24220,7 @@ void main() {
   var DOUBLE_TAP_SLOP = 30;
   var TIME_SCALE_K = 4e-3;
   var WHEEL_ZOOM_K = 4e-3;
+  var WHEEL_PRICE_DRAG_PX = 0.25;
   function wheelZoomAnchor(coords, cursorX, rightEdge) {
     if (rightEdge) return { logical: coords.rightEdgeLogical, x: coords.width };
     return { logical: coords.xToLogical(cursorX), x: cursorX };
@@ -24324,7 +24351,7 @@ void main() {
           this.capture(e.pointerId);
           return;
         }
-        if (e.shiftKey && this.regionAt(x, y) === "data" && this.deps.drawingsMeasureStart?.(x, y)) {
+        if (e.shiftKey && this.regionAt(x, y) === "data" && this.deps.drawingsMeasureStart?.(x, y, this.snapMode(e))) {
           this.region = "drawing";
           this.capture(e.pointerId);
           return;
@@ -24438,7 +24465,7 @@ void main() {
         const wasTouch = e.pointerType === "touch";
         const tapRelease = this.dragging && !this.moved && (!wasTouch || Math.hypot(x - this.startX, y - this.startY) <= TOUCH_TAP_SLOP);
         if (this.dragging && this.region === "drawing") {
-          this.deps.drawingsPointerUp?.(x, y);
+          this.deps.drawingsPointerUp?.(x, y, this.snapMode(e));
         } else if (tapRelease && this.region === "data") {
           this.deps.onClick(x, y);
         } else if (this.dragging && this.region === "data") {
@@ -24459,7 +24486,7 @@ void main() {
         if (e.pointerType === "touch") this.touches.delete(e.pointerId);
         this.cancelLongPress();
         if (!this.dragging) return;
-        if (this.region === "drawing" && !Number.isNaN(this.cursorX)) this.deps.drawingsPointerUp?.(this.cursorX, this.cursorY);
+        if (this.region === "drawing" && !Number.isNaN(this.cursorX)) this.deps.drawingsPointerUp?.(this.cursorX, this.cursorY, this.snapMode(e));
         if (this.region === "crosshair" || e.pointerType === "touch") this.deps.onPointerMove(null, null);
         this.endGesture(e);
       };
@@ -24475,6 +24502,12 @@ void main() {
       this.onWheel = (e) => {
         e.preventDefault();
         this.deps.drawingsClearTransient?.();
+        const { x, y } = this.local(e);
+        if (this.regionAt(x, y) === "price" && e.deltaY !== 0) {
+          this.deps.beginPriceScale(x, y);
+          this.deps.priceScaleBy(e.deltaY * WHEEL_PRICE_DRAG_PX);
+          return;
+        }
         const coords = this.deps.getCoords();
         const vp = coords.getViewport();
         const pan = wheelPanDelta(e.deltaX, e.deltaY, e.shiftKey);
@@ -24482,9 +24515,8 @@ void main() {
           this.deps.apply({ barSpacing: vp.barSpacing, rightOffset: wheelPanRightOffset(vp.rightOffset, pan, coords.pxPerBar()) });
           return;
         }
-        const cursorX = this.local(e).x;
         const rightEdge = this.rightEdgeZoom && !(e.ctrlKey || e.metaKey);
-        const anchor = wheelZoomAnchor(coords, cursorX, rightEdge);
+        const anchor = wheelZoomAnchor(coords, x, rightEdge);
         const target = clampBarSpacing(vp.barSpacing * Math.exp(-e.deltaY * WHEEL_ZOOM_K));
         this.deps.zoomTo(target, anchor.logical, anchor.x);
       };
@@ -25966,6 +25998,15 @@ void main() {
   function fontSizePx(size3) {
     return size3 === "auto" ? 12 : namedFontSize(size3);
   }
+  function lineCoversWindow(a, b, extend, lo, hi) {
+    const minX = Math.min(a, b);
+    const maxX = Math.max(a, b);
+    if (a === b) return a >= lo && a <= hi;
+    if (extend === "both") return true;
+    if (extend === "left") return maxX >= lo;
+    if (extend === "right") return minX <= hi;
+    return maxX >= lo && minX <= hi;
+  }
   var DrawingSceneRenderer = class {
     constructor(deps, set = EMPTY_DRAWING_SET) {
       this.deps = deps;
@@ -26030,7 +26071,7 @@ void main() {
       };
       for (const ln of this.set.lines) {
         if (ln.invisible) continue;
-        if (!visible(this.logicalOf(ln.xloc, ln.x1), this.logicalOf(ln.xloc, ln.x2), ln.extend)) continue;
+        if (!lineCoversWindow(this.logicalOf(ln.xloc, ln.x1), this.logicalOf(ln.xloc, ln.x2), ln.extend, lo, hi)) continue;
         fold(ln.y1);
         fold(ln.y2);
       }
@@ -29970,6 +30011,22 @@ ${overlayScrollbarCss(".vela-sd-pane")}
       this.snapAt = changed ? { point: snapped, paneId } : null;
       return snapped;
     }
+    /**
+     * Resolve a cursor pixel through the magnet and return the snapped pixel — the same
+     * conversion drawing placement uses. Updates the snap-ring marker. The measure
+     * ruler goes through this so its endpoints follow weak/strong/Ctrl magnet too.
+     */
+    snapCursor(x, y, mode) {
+      const proj = this.deps.projector();
+      const paneId = proj.paneIdAtY(y) ?? "price";
+      const point = this.resolve(x, y, paneId, mode);
+      const sy = proj.yOf(point.price, paneId);
+      return { x: proj.xOf(point.time), y: sy ?? y };
+    }
+    /** Drop the snap-ring marker (a transient mode ended without going through `up`). */
+    clearSnapMarker() {
+      this.snapAt = null;
+    }
     /** Resolve a pixel to a data point with the segment angle locked to 45° steps around
      *  `pivot` (Shift held on a line tool). Works in PIXEL space — the user reasons about
      *  the angle they see, not about time/price units. The magnet is bypassed: snapping
@@ -32007,30 +32064,39 @@ ${overlayScrollbarCss(".vela-sd-pane")}
     isFinished() {
       return this.state === "finished";
     }
-    /** A press: begin the measurement, or finish it on the second click. */
-    down(x, y) {
+    /** A press: begin the measurement, or finish it on the second click.
+     *  `x,y` are the raw cursor (drag-slop vs click-move-click). `gx,gy` are the
+     *  graphic endpoints — magnet-snapped when the magnet is on, else the same as `x,y`. */
+    down(x, y, gx = x, gy = y) {
       if (this.state === "measuring") {
-        this.end = { x, y };
+        this.end = { x: gx, y: gy };
         this.state = "finished";
         return;
       }
-      this.start = { x, y };
-      this.end = { x, y };
+      this.start = { x: gx, y: gy };
+      this.end = { x: gx, y: gy };
       this.pressX = x;
       this.pressY = y;
       this.state = "measuring";
     }
+    /** Size the in-progress ruler. `x,y` are the graphic (magnet-snapped) cursor. */
     move(x, y) {
       if (this.state === "measuring") this.end = { x, y };
     }
     /** A release: finish if the press was actually dragged (press-drag-release), else wait
-     *  for the second click (click-move-click). */
-    up(x, y) {
+     *  for the second click (click-move-click). `x,y` are the raw cursor (slop); `gx,gy`
+     *  are the graphic end (magnet-snapped when the magnet is on). */
+    up(x, y, gx = x, gy = y) {
       if (this.state === "measuring" && Math.hypot(x - this.pressX, y - this.pressY) > DRAG_SLOP3) {
-        this.end = { x, y };
+        this.end = { x: gx, y: gy };
         this.state = "finished";
       }
     }
+    /** Current graphic endpoints in media pixels, or null when idle. */
+    points() {
+      if (!this.start || !this.end) return null;
+      return { start: this.start, end: this.end };
+    }
     clear() {
       this.state = "idle";
       this.start = null;
@@ -32407,11 +32473,13 @@ ${overlayScrollbarCss(".vela-sd-pane")}
     }
     /** Shift+press on the empty plot: arm the measure ruler AND start it at (x, y) in one
      *  gesture — the equivalent of clicking the toolbar's Measure button, then pressing.
-     *  Returns false when a mode/tool is already active (the normal press path owns it). */
-    beginMeasureAt(x, y) {
+     *  `snap` is the effective magnet (sticky mode, or Ctrl/Cmd-forced strong). Returns
+     *  false when a mode/tool is already active (the normal press path owns it). */
+    beginMeasureAt(x, y, snap = "off") {
       if (this.measureMode || this.eraserMode || this.activeTool != null) return false;
       this.withModeIntent(() => this.toggleMeasure());
-      this.measure.down(x, y);
+      const g = this.interaction.snapCursor(x, y, snap);
+      this.measure.down(x, y, g.x, g.y);
       this.render();
       return true;
     }
@@ -32433,7 +32501,8 @@ ${overlayScrollbarCss(".vela-sd-pane")}
         return;
       }
       if (this.measureMode) {
-        this.measure.down(x, y);
+        const g = this.interaction.snapCursor(x, y, snap);
+        this.measure.down(x, y, g.x, g.y);
         if (this.measure.isFinished()) this.withModeIntent(() => this.exitMeasure(false));
         this.render();
         return;
@@ -32446,7 +32515,8 @@ ${overlayScrollbarCss(".vela-sd-pane")}
         return;
       }
       if (this.measureMode) {
-        this.measure.move(x, y);
+        const g = this.interaction.snapCursor(x, y, snap);
+        this.measure.move(g.x, g.y);
         this.render();
         return;
       }
@@ -32464,13 +32534,14 @@ ${overlayScrollbarCss(".vela-sd-pane")}
         this.render();
       }
     }
-    pointerUp(x, y) {
+    pointerUp(x, y, snap = "off") {
       if (this.eraserMode) {
         this.erasing = false;
         return;
       }
       if (this.measureMode) {
-        this.measure.up(x, y);
+        const g = this.interaction.snapCursor(x, y, snap);
+        this.measure.up(x, y, g.x, g.y);
         if (this.measure.isFinished()) this.withModeIntent(() => this.exitMeasure(false));
         this.render();
         return;
@@ -32515,6 +32586,7 @@ ${overlayScrollbarCss(".vela-sd-pane")}
     /** Leave ruler mode. `clearGraphic` keeps a just-finished measurement on screen (false). */
     exitMeasure(clearGraphic = true) {
       this.measureMode = false;
+      this.interaction.clearSnapMarker();
       if (clearGraphic) this.measure.clear();
       this.toolbar.setMeasureActive(false);
       this.render();
@@ -32655,15 +32727,28 @@ ${overlayScrollbarCss(".vela-sd-pane")}
       if (this.eraserMode) return "pointer";
       return this.interaction.cursorAt(x, y);
     }
-    /** Right-click while placing: cancel the in-progress drawing and revert to the
-     *  pointer — the gesture is an explicit escape, so it disarms even in
-     *  stay-in-drawing-mode (where Escape would leave the tool armed). Returns whether
-     *  the press was consumed; false lets the host's context menu open normally. */
+    /** Right-click: an explicit escape back to the pointer. Cancels an in-progress
+     *  placement or measurement, and also plain-disarms an armed-but-idle drawing
+     *  tool or the eraser — so a right-click ALWAYS reverts to the pointer, even in
+     *  stay-in-drawing-mode (where Escape would leave a drawing tool armed).
+     *  Persistent toggles (magnet, stay-mode, favorites) are untouched. Returns
+     *  whether the press was consumed; false lets the host's context menu open
+     *  normally. */
     cancelPlacement() {
-      if (!this.interaction.isPlacing()) return false;
-      this.interaction.cancel();
-      if (this.activeTool != null) this.emit({ kind: "arm", type: null });
-      return true;
+      if (this.measureMode || this.eraserMode) {
+        this.withModeIntent(() => this.measureMode ? this.exitMeasure() : this.exitEraser());
+        return true;
+      }
+      if (this.interaction.isPlacing()) {
+        this.interaction.cancel();
+        if (this.activeTool != null) this.emit({ kind: "arm", type: null });
+        return true;
+      }
+      if (this.activeTool != null) {
+        this.emit({ kind: "arm", type: null });
+        return true;
+      }
+      return false;
     }
     /** Double-click over a drawing → suppress the chart's view reset (single-click already
      *  opens settings). Returns true only when a drawing is under the cursor. */
@@ -32689,6 +32774,10 @@ ${overlayScrollbarCss(".vela-sd-pane")}
           return true;
         }
         if (this.interaction.cancel()) return true;
+        if (this.measureMode) {
+          this.withModeIntent(() => this.exitMeasure());
+          return true;
+        }
         if (this.selectedIds.size) {
           this.clearSelection();
           return true;
@@ -35247,13 +35336,13 @@ ${overlayScrollbarCss(".vela-sd-pane")}
         resetView: () => this.resetView(),
         // User drawings claim a gesture before pan when armed / over a drawing.
         drawingsClaim: (x, y) => this.userDrawings?.claim(x, y) ?? false,
-        drawingsMeasureStart: (x, y) => this.userDrawings?.beginMeasureAt(x, y) ?? false,
+        drawingsMeasureStart: (x, y, snap) => this.userDrawings?.beginMeasureAt(x, y, snap) ?? false,
         drawingsDeleteAt: (x, y) => this.userDrawings?.deleteAt(x, y) ?? false,
         drawingsCancelPlacement: () => this.userDrawings?.cancelPlacement() ?? false,
         drawingsSnapMode: () => this.snapMode,
         drawingsPointerDown: (x, y, snap, shift3) => this.userDrawings?.pointerDown(x, y, snap, shift3),
         drawingsPointerMove: (x, y, snap, shift3) => this.userDrawings?.pointerMove(x, y, snap, shift3),
-        drawingsPointerUp: (x, y) => this.userDrawings?.pointerUp(x, y),
+        drawingsPointerUp: (x, y, snap) => this.userDrawings?.pointerUp(x, y, snap),
         drawingsCursor: (x, y) => this.userDrawings?.cursorAt(x, y) ?? null,
         drawingsDblClick: (x, y) => this.userDrawings?.dblClick(x, y) ?? false,
         drawingsClearTransient: () => this.userDrawings?.clearTransient()
@@ -35568,7 +35657,8 @@ ${overlayScrollbarCss(".vela-sd-pane")}
       }
       const skipFit = opts?.preserveView === true && this.didInitialFit;
       if (this.coords.width > 0 && !skipFit) {
-        this.fitContent();
+        if (this.didInitialFit) this.reframeKeepZoom();
+        else this.fitContent();
         this.didInitialFit = true;
       }
       if (!this.introPlayed && this.bars.length > 0) {
@@ -36216,6 +36306,7 @@ ${overlayScrollbarCss(".vela-sd-pane")}
       this.scaleDragHeight = res.height;
       this.scaleDragStart = { ...res.holder.scale };
       res.holder.manualScale = { ...res.holder.scale };
+      this.axisScaleButtons?.reposition();
       this.scheduler.invalidate(4 /* Full */);
     }
     /** Rescale the grabbed scale around its center by the total drag (down ⇒ zoom out). */
@@ -36247,6 +36338,7 @@ ${overlayScrollbarCss(".vela-sd-pane")}
       const res = this.resolveScaleHolder(x, y);
       if (!res) return;
       res.holder.manualScale = null;
+      this.axisScaleButtons?.reposition();
       this.scheduler.invalidate(4 /* Full */);
     }
     /**
@@ -36884,6 +36976,20 @@ ${overlayScrollbarCss(".vela-sd-pane")}
       this.coords.setViewport(v);
       this.targetBarSpacing = v.barSpacing;
     }
+    /** Re-frame after a series replacement (a symbol/timeframe switch): keep the user's
+     *  zoom (bar spacing), re-anchor the newest bars at the default right offset.
+     *  `clampViewport`'s fit-all-bars floor deliberately does NOT apply — a progressive
+     *  head may still be backfilling toward the previous depth, and raising the spacing
+     *  to its temporary bar count would lose the zoom this exists to keep. */
+    reframeKeepZoom() {
+      this.animator?.stop();
+      this.panVelocity = 0;
+      for (const pane of this.scene.panes.values()) pane.manualScale = null;
+      for (const sl of this.scene.indicatorScales.values()) sl.manualScale = null;
+      const v = { barSpacing: clampBarSpacing(this.coords.getViewport().barSpacing), rightOffset: defaultViewport().rightOffset };
+      this.coords.setViewport(v);
+      this.targetBarSpacing = v.barSpacing;
+    }
     paneBoundsFor(paneId) {
       const p = this.scene.panes.get(paneId);
       return { top: p?.bounds.top ?? 0, height: p?.bounds.height ?? 0, rightAxis: this.rightAxisW };
@@ -39313,6 +39419,7 @@ ${overlayScrollbarCss(".vela-sd-pane")}
   exports.getDrawingType = getDrawingType;
   exports.getNativeIndicator = getNativeIndicator;
   exports.iconMarkup = iconMarkup;
+  exports.inputDeltas = inputDeltas;
   exports.inputVisible = inputVisible;
   exports.legendActions = legendActions;
   exports.legendCallouts = legendCallouts;