lightweight-charts-drawing 0.6.0 → 0.6.2

package/CHANGELOG.md

@@ -1,5 +1,42 @@
 # Changelog
 
+## 0.6.2 (15/10/2026)
+
+### Changed
+
+- Drawing points are on whole bars, as in the reference app: a time between
+  two bars (a point drawn on another interval, a time in a gap between
+  sessions) is drawn on the bar that holds it, the last bar opening at or
+  before it (`timeToX`, `timeToBarIndex`, `timeToXFallback`); it was
+  interpolated between the two bars. The stored time is kept, so the point
+  comes back to its own bar on its own interval.
+- Drags follow the reference line tool rules: a point that stays on its bar
+  keeps its stored time (price-only anchor drags and body moves), a point
+  moved to another bar takes that bar's open time (`applyDrag`,
+  `translateDrawing`).
+
+### Added
+
+- `FutureAxis.pastSlots` / `pastTime` (optional): bars before the first
+  loaded bar on the host's trading calendar (whole bars both ways); without
+  them, calendar time with the median bar interval as before.
+- `FutureAxis.timeKey` (optional): where a time sits when the bar that holds
+  it is looked for (a host maps a daily bar time to its session open).
+- `FutureAxis` exported from the package entry.
+- Unit tests (`npm test`, vitest).
+
+## 0.6.1 (15/10/2026)
+
+### Added
+
+- `makeCoords(..., getFuture)` (optional 6th argument, `FutureAxis`): bars
+  after the last bar on the symbol's trading calendar, given by the host
+  (`slots(time, lastTime)`, `time(k, lastTime)`). With it a point placed after
+  the last bar takes the open time of its nearest future bar, a future time is
+  drawn on the future bar that holds it (`timeToX`, `xToTime`,
+  `timeToBarIndex`, `barIndexToTime`, `timeToXFallback`). Without it, calendar
+  time with the median bar interval as before.
+
 ## 0.6.0 (13/10/2026)
 
 ### Added

package/dist/index.d.ts

@@ -692,6 +692,28 @@ declare type FourPoint = {
  *  finalized with a double-click (the spec carries `variableLength: true`). */
 declare type FreehandKind = "polyline" | "path" | "brush" | "highlighter";
 
+/** The symbol's trading calendar around the loaded bars (the host knows the sessions). The time scale continues
+ *  after the last bar with the bars the symbol would open: the rest of the session, then the next sessions (nights,
+ *  weekends and holidays skipped); before the first loaded bar it counts the bars the symbol had. Times are epoch
+ *  seconds. A time is drawn on the bar that holds it (the last bar opening at or before it). */
+export declare type FutureAxis = {
+    /** Future bars that open after `lastTime` and at or before `time` (0 = still on the last bar). */
+    slots: (time: number, lastTime: number) => number;
+    /** Open time of the k-th future bar (k >= 1), null past the host's range. */
+    time: (k: number, lastTime: number) => number | null;
+    /** Bars from the bar that holds `time` to the first loaded bar (opening at `firstTime`), that bar counted
+     *  (>= 1 for a time before the first bar). Absent = calendar time with the median bar interval. */
+    pastSlots?: (time: number, firstTime: number) => number;
+    /** Open time of the k-th bar before the first loaded bar (k >= 1), null past the host's range. Give it with
+     *  `pastSlots`. */
+    pastTime?: (k: number, firstTime: number) => number | null;
+    /** Where a time sits when the bar that holds it is looked for, non-decreasing over the bar times. The host maps a
+     *  daily bar time to its session open (the reference opens a daily bar there: a pre-market time belongs to the
+     *  previous daily bar, a point drawn on a daily bar goes to the first intraday bar of its day). Identity when
+     *  absent. */
+    timeKey?: (time: number) => number;
+};
+
 /** One regression trend line (TV study plot style). */
 /** Gann level line (TV levels.N: color, width, visible). */
 declare type GannLine = {
@@ -817,7 +839,9 @@ export declare function makeCoords(chart: IChartApi, series: ISeriesApi<SeriesTy
 getIndicatorValues?: (sec: number | null) => number[], getTimeInfo?: () => {
     timeZone: string;
     intraday: boolean;
-}): Coords;
+}, 
+/** Future bars on the trading calendar; null (or absent) = calendar time extrapolated with the bar interval. */
+getFuture?: () => FutureAxis | null): Coords;
 
 /** Point-count migration (10/07/2026): several kinds moved to TV's point
  *  models. Old saved drawings are padded/synthesized best-effort so they keep
@@ -1286,9 +1310,10 @@ export declare type TimeAxisLabel = {
 
 /** Shared time→x with the off-bar fallback, for non-drawing renderers (event
  *  markers, etc.) that paint at arbitrary times. Mirrors the `timeToX` method:
- *  try lightweight-charts' exact mapping first, then the gap-aware logical
- *  interpolation. `sec` is UNIX seconds. Returns null with no data. */
-export declare function timeToXFallback(chart: IChartApi, sec: number, bars: OHLC[]): number | null;
+ *  try lightweight-charts' exact mapping first, then the bar that holds the
+ *  time (off the loaded bars: the host's calendar `future` when given).
+ *  `sec` is UNIX seconds. Returns null with no data. */
+export declare function timeToXFallback(chart: IChartApi, sec: number, bars: OHLC[], future?: FutureAxis | null): number | null;
 
 /** TV _onAnchoredChange: anchoring stores the current screen point as pane
  *  fractions; unanchoring turns the fixed point back into a data point (bar