acttrader-charts 1.0.15 → 1.0.17

package/README.md

@@ -55,6 +55,8 @@ const chart = new ChartEngine({
 // No manual loadData() needed — the engine calls dataLoader on start and on timeframe/duration changes.
 ```
 
+If the first fetch returns fewer than `minInitialBars` (default `10`), the engine automatically widens the lookback window and calls `dataLoader` again — up to the `maxLookbackMs` ceiling (default 365 days). This keeps the chart useful on weekends, holidays, or for instruments that just listed. If retries still yield zero bars, the engine shows a **"No data available"** overlay (customise the text via `labels.chart.noData`).
+
 ---
 
 ## Advanced Usage
@@ -160,13 +162,17 @@ chart.removeLevelByLabel('ORD-1');
 chart.setLevels([], 'label', 'price', 'pending'); // clear all of one type
 ```
 
+**Visual differentiation:** pending orders and ES/EL entry working orders render as **dashed** lines tinted by side (`pendingBuyLine` green / `pendingSellLine` red). True open positions render as **solid** lines: green/red when `pnl` is set (sign-colored), otherwise `positionLine` (purple/indigo). The info-box border matches the line color. Each true open position also gets a small colored price tag on the right-side price axis showing the entry price — same visual language as the Bid/Ask tag — so you can read the entry price without hunting for the info box.
+
 **TFC events:**
 
 ```ts
 // Confirmed drag of a pending order entry
-chart.on('tradeLevelEdit', ({ label, type, changes, isFullscreen }) => {
+chart.on('tradeLevelEdit', ({ label, type, data, changes, newLots, isFullscreen }) => {
     for (const c of changes) {
-        if (c.field === 'MAIN') myApi.modifyOrder(label, { price: c.newPrice });
+        // `c.newLots` is present on the MAIN change when qty was edited this session.
+        // `data.lots` is also overridden with the new qty for convenience.
+        if (c.field === 'MAIN') myApi.modifyOrder(label, { price: c.newPrice, qty: c.newLots ?? (data as any).lots });
         if (c.field === 'SL')   myApi.modifyOrder(label, { stopLoss: c.newPrice });
         if (c.field === 'TP')   myApi.modifyOrder(label, { takeProfit: c.newPrice });
     }
@@ -224,6 +230,7 @@ When `enableTrading` is on and live BID/ASK data is streaming, hovering / activa
 | `showVolume` | | `true` | Show volume overlay |
 | `showUI` | | `true` | Render top / bottom / left bars. When `false`, the loading overlay is also suppressed (mobile wrappers provide their own) |
 | `showDrawingTools` | | `true` | Show drawing toolbar and pencil button |
+| `showFullscreenButton` | | `true` | Show the fullscreen toggle button in the top bar. Set to `false` to hide it entirely. Mobile wrappers (Android / iOS) default this to `false` |
 | `timeframe` | | `"1D"` | Initial timeframe |
 | `duration` | | — | Initial active duration button |
 | `symbol` | | — | Symbol name shown in the top bar |
@@ -233,6 +240,8 @@ When `enableTrading` is on and live BID/ASK data is streaming, hovering / activa
 | `minLots` | | `1` | Default lot size in the trade popover |
 | `tickActivityMs` | | `30000` | ms the stream dot stays green after last tick |
 | `maxCandles` | | `200` | Max bars fetched per data-load request |
+| `minInitialBars` | | `10` | If `dataLoader` returns fewer bars, the fetch window auto-widens and retries (handles weekends, market closures, and sparse symbols) |
+| `maxLookbackMs` | | `31_536_000_000` | Hard ceiling on auto-widening lookback (ms). Retries stop once the window reaches this. Default: 365 days |
 | `prefetchThreshold` | | `80` | Bars from start of data at which historical fetch triggers (min 20) |
 | `mobileBarDivisor` | | `2` | Divide desktop visible bar count on touch devices (`2`, `3`, or `4`) |
 | `momentumScrollEnabled` | | `true` | Enable momentum (kinetic) scrolling — chart coasts after a fast flick |
@@ -487,8 +496,11 @@ chart.prependData(bars: OHLCVBar[]): this   // prepend historical bars (infinite
 chart.correctBar(barTime: number, bar: OHLCVBar): void  // replace a bar with authoritative data after close
 chart.setLoading(loading: boolean): this
 
-// Reset — clears all bars, the live price line, and any in-flight fetch.
-// Call before switching to a new symbol so no previous symbol data bleeds in.
+// Reset — clears all bars, the live price line, any in-flight fetch,
+// all user drawings, and all trade/position levels (including pending drafts).
+// Call before switching to a new symbol so no previous symbol state bleeds in.
+// If you only want to clear bars (e.g. refreshing the same symbol), call
+// chart.loadData([]) directly to preserve drawings.
 chart.resetData(): this
 ```
 
@@ -530,12 +542,17 @@ chart.setDrawingTool(tool: DrawingToolType | null): this
 ```ts
 chart.setLevels(levels, labelField, priceField, type): this
 chart.removeLevelByLabel(label: string): this
-chart.cancelCurrentEdit(): this   // cancel the active draft order or in-progress level edit; no-op when nothing is active
+chart.updateLevelMainPrice(label: string, price: number): this   // move an existing level's entry price; stages the edit so it survives subsequent setLevels refreshes until the server echoes the new price or cancelLevelEdit/cancelCurrentEdit is called
+chart.updateLevelBracket(label: string, bracketType: 'sl' | 'tp', price: number | null): this   // update or remove a SL/TP bracket on an existing level; same staging semantics as updateLevelMainPrice — pass null to remove
+chart.cancelLevelEdit(label: string): this   // drop any staged edit for this level and revert to last confirmed server state
+chart.cancelCurrentEdit(): this   // cancel the active draft order or any in-progress level edit; no-op when nothing is active
 chart.addLevelBracket(label: string, bracketType: 'sl' | 'tp'): this   // auto-place a SL or TP bracket at a default offset; emits tradeLevelBracketActivated with the computed price
-chart.setDraftBracketPnl(bracketType: 'sl' | 'tp', pnlText: string | null): this   // set estimated P&L text on a draft order bracket line; pass null to clear
+chart.setDraftBracketPnl(bracketType: 'sl' | 'tp', pnlText: string | null): this   // set estimated P&L text on the active bracket host — the draft order while drafting, or the currently selected existing pending order / position while modifying; pass null to clear
 chart.setTfcActive(enabled: boolean): this   // toggle TFC on/off at runtime; hides/shows all trade levels, draft orders, and floating trade button; fires tfcToggle event
 ```
 
+> **Staging semantics for `updateLevelMainPrice` / `updateLevelBracket`.** Calls to these methods register the change in the chart's pending-edit buffer (the same buffer chart-initiated drags use), so the edit stays visible even when the host app keeps pushing fresh server state via `setLevels` (e.g. per-tick PnL refreshes). When the server echoes back the new price in a later `setLevels` call, the staged edit is auto-released (mobile, i.e. `hideLevelConfirmCancel: true`). If a panel closes without submitting, call `cancelLevelEdit(label)` or `cancelCurrentEdit()` to drop the staged edit — otherwise it will keep overriding server state on the chart.
+
 ### Trade Button
 
 ```ts

package/dist/{MACD-DVxcNurb.d.cts → MACD-BbNppL1E.d.cts}

@@ -300,6 +300,8 @@ interface DialogLabels {
 interface ChartMiscLabels {
     /** Overlay text shown while data is being fetched. */
     loading: string;
+    /** Overlay text shown when a completed fetch returned zero bars. */
+    noData: string;
     /** Tooltip on the "jump to live edge" button. */
     scrollToLatest: string;
     /** Collapse button text in the indicator overlay when more than 2 indicators
@@ -548,6 +550,8 @@ interface ChartConfig {
     showDrawingTools?: boolean;
     /** If false, the settings gear button in the top bar is hidden entirely. Default: true */
     showSettings?: boolean;
+    /** If false, the fullscreen toggle button in the top bar is hidden entirely. Default: true */
+    showFullscreenButton?: boolean;
     timeframe?: Timeframe;
     duration?: Duration;
     symbol?: string;
@@ -604,10 +608,12 @@ interface ChartConfig {
         label: string;
         type: TradeLevelType;
         data: unknown;
+        newLots?: number;
         changes: Array<{
             field: 'MAIN' | 'SL' | 'TP' | 'ADD_SL' | 'ADD_TP' | 'REMOVE_SL' | 'REMOVE_TP';
             newPrice: number;
             data: unknown;
+            newLots?: number;
             bracketOrderLabel?: string;
         }>;
     }) => void;
@@ -675,6 +681,20 @@ interface ChartConfig {
      * of bars. Default: 200.
      */
     maxCandles?: number;
+    /**
+     * Minimum bars expected from the initial fetch before giving up. If the
+     * `dataLoader` returns fewer bars than this, ChartEngine automatically
+     * widens the lookback window and retries — this keeps charts useful after
+     * weekends, holidays, or for instruments with sparse recent history.
+     * Default: 10.
+     */
+    minInitialBars?: number;
+    /**
+     * Hard ceiling (in milliseconds) on how far back auto-widening retries
+     * can reach when chasing enough bars. Retries stop once the window meets
+     * or exceeds this value. Default: 365 days.
+     */
+    maxLookbackMs?: number;
     /**
      * How close (in bars) the viewport must be to the start of loaded data
      * before a historical fetch is triggered. Higher values prefetch earlier.
@@ -1139,16 +1159,29 @@ type ChartEventMap = {
     tradeLevelEdit: {
         label: string;
         type: TradeLevelType;
-        /** Parent level's data. */
+        /**
+         * Parent level's data. When the user edited the lot size during this session,
+         * the `lots` field of this object is overridden with the new value for convenience
+         * (so `data.lots` always reflects the effective qty being submitted). The original
+         * server fields (e.g. `Quantity`) are left untouched — use `newLots` when you need
+         * to distinguish "edited" from "unchanged".
+         */
         data: unknown;
         /** True when the chart is in fullscreen mode (native or CSS) at the time of the action. */
         isFullscreen: boolean;
+        /** Present when the user changed the lot size via the QTY pill flyout during this edit session. */
+        newLots?: number;
         changes: Array<{
             /** MAIN = entry price edit; SL/TP = bracket edit; ADD_SL/ADD_TP = new bracket placed; REMOVE_SL/REMOVE_TP = bracket removed. */
             field: 'MAIN' | 'SL' | 'TP' | 'ADD_SL' | 'ADD_TP' | 'REMOVE_SL' | 'REMOVE_TP';
             newPrice: number;
-            /** Bracket order's data when the bracket is a ToClose order; parent's data for inline brackets. */
+            /**
+             * Bracket order's data when the bracket is a ToClose order; parent's data for inline brackets.
+             * On the MAIN change, `lots` is overridden with the new qty when the user edited it (same rule as the top-level `data`).
+             */
             data: unknown;
+            /** Present on the MAIN change when the user edited the lot size during this session. */
+            newLots?: number;
             bracketOrderLabel?: string;
         }>;
     };

package/dist/{MACD-DVxcNurb.d.ts → MACD-BbNppL1E.d.ts}

@@ -300,6 +300,8 @@ interface DialogLabels {
 interface ChartMiscLabels {
     /** Overlay text shown while data is being fetched. */
     loading: string;
+    /** Overlay text shown when a completed fetch returned zero bars. */
+    noData: string;
     /** Tooltip on the "jump to live edge" button. */
     scrollToLatest: string;
     /** Collapse button text in the indicator overlay when more than 2 indicators
@@ -548,6 +550,8 @@ interface ChartConfig {
     showDrawingTools?: boolean;
     /** If false, the settings gear button in the top bar is hidden entirely. Default: true */
     showSettings?: boolean;
+    /** If false, the fullscreen toggle button in the top bar is hidden entirely. Default: true */
+    showFullscreenButton?: boolean;
     timeframe?: Timeframe;
     duration?: Duration;
     symbol?: string;
@@ -604,10 +608,12 @@ interface ChartConfig {
         label: string;
         type: TradeLevelType;
         data: unknown;
+        newLots?: number;
         changes: Array<{
             field: 'MAIN' | 'SL' | 'TP' | 'ADD_SL' | 'ADD_TP' | 'REMOVE_SL' | 'REMOVE_TP';
             newPrice: number;
             data: unknown;
+            newLots?: number;
             bracketOrderLabel?: string;
         }>;
     }) => void;
@@ -675,6 +681,20 @@ interface ChartConfig {
      * of bars. Default: 200.
      */
     maxCandles?: number;
+    /**
+     * Minimum bars expected from the initial fetch before giving up. If the
+     * `dataLoader` returns fewer bars than this, ChartEngine automatically
+     * widens the lookback window and retries — this keeps charts useful after
+     * weekends, holidays, or for instruments with sparse recent history.
+     * Default: 10.
+     */
+    minInitialBars?: number;
+    /**
+     * Hard ceiling (in milliseconds) on how far back auto-widening retries
+     * can reach when chasing enough bars. Retries stop once the window meets
+     * or exceeds this value. Default: 365 days.
+     */
+    maxLookbackMs?: number;
     /**
      * How close (in bars) the viewport must be to the start of loaded data
      * before a historical fetch is triggered. Higher values prefetch earlier.
@@ -1139,16 +1159,29 @@ type ChartEventMap = {
     tradeLevelEdit: {
         label: string;
         type: TradeLevelType;
-        /** Parent level's data. */
+        /**
+         * Parent level's data. When the user edited the lot size during this session,
+         * the `lots` field of this object is overridden with the new value for convenience
+         * (so `data.lots` always reflects the effective qty being submitted). The original
+         * server fields (e.g. `Quantity`) are left untouched — use `newLots` when you need
+         * to distinguish "edited" from "unchanged".
+         */
         data: unknown;
         /** True when the chart is in fullscreen mode (native or CSS) at the time of the action. */
         isFullscreen: boolean;
+        /** Present when the user changed the lot size via the QTY pill flyout during this edit session. */
+        newLots?: number;
         changes: Array<{
             /** MAIN = entry price edit; SL/TP = bracket edit; ADD_SL/ADD_TP = new bracket placed; REMOVE_SL/REMOVE_TP = bracket removed. */
             field: 'MAIN' | 'SL' | 'TP' | 'ADD_SL' | 'ADD_TP' | 'REMOVE_SL' | 'REMOVE_TP';
             newPrice: number;
-            /** Bracket order's data when the bracket is a ToClose order; parent's data for inline brackets. */
+            /**
+             * Bracket order's data when the bracket is a ToClose order; parent's data for inline brackets.
+             * On the MAIN change, `lots` is overridden with the new qty when the user edited it (same rule as the top-level `data`).
+             */
             data: unknown;
+            /** Present on the MAIN change when the user edited the lot size during this session. */
+            newLots?: number;
             bracketOrderLabel?: string;
         }>;
     };