@devexperts/dxcharts-lite 1.0.2 → 2.0.1

package/dist/chart/utils/array.utils.js

@@ -3,4 +3,272 @@
  * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
  * If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
-import{identity as x}from"./function.utils";import{clamp as d,shiftRight as a}from"./math.utils";export function arrayIntersect(t,e,r=eqeqeq,n=!0){const i=t.filter(o=>e.some(c=>r(o,c)));return n?i.filter((o,c,u)=>u.indexOf(o)===c):i}export const reorderArray=(t,e)=>{const r=e.slice().filter(n=>t.find(i=>i===n));return t.map(n=>{var i;return e.indexOf(n)>=0&&(i=r.shift())!==null&&i!==void 0?i:n})},eqeqeq=(t,e)=>t===e,arraySubtract=(t,e,r)=>t.filter(n=>e.filter(i=>r(n,i)).length===0);const m=(t,e)=>t===e;export const arrayCompare=(t,e,r=m)=>t.length===e.length&&t.every((n,i)=>r(n,e[i]));export function moveInArray(t,e,r){const n=t.slice(),i=n[e];return n.splice(e,1),n.splice(r,0,i),n}export function moveInArrayMutable(t,e,r){const n=t.length,i=d(e,0,n-1),o=d(r,0,n-1),c=t[i];return t.splice(i,1),t.splice(o,0,c),t}export function replaceInArray(t,e,r){const n=t.slice(),i=n.findIndex(e);return i!==-1&&(n.splice(i,1),n.splice(i,0,r)),n}export const uniqueArray=t=>{const e={};return t.filter(r=>e[r]?!1:e[r]=!0)},groupBy=(t,e)=>t.reduce((r,n)=>((r[n[e]]=r[n[e]]||[]).push(n),r),{}),interleave=(t,e)=>[].concat(...t.map(r=>[r,e])).slice(0,-1),isTwoDimArray=t=>Array.isArray(t[0]),create2DArray=t=>Array.isArray(t[0])?t:[t],slice2DArray=(t,e,r)=>{const n=[];let i=0;for(const o of t){const c=Math.max(e-i,0),u=Math.max(r-i,-1),s=o.slice(c,u+1);s.length>0&&n.push(s),i+=o.length}return n},at=(t,e)=>t>=0?e[t]:e[e.length+t],flat=t=>Array.prototype.flat?t.flat():flatMap(t,x),flatMap=(t,e)=>{if(Array.prototype.flatMap)return t.flatMap(e);const r=[];for(let n=0;n<t.length;n++){const i=t[n];r.push(...e(i,n,t))}return r};export function binarySearch(t,e,r){const n=r!=null?r:x;return!t.length||e!==e?{index:-1,exact:!0}:p(t,e,0,t.length,n)}function p(t,e,r,n,i){const o=a(r+n,1),c=i(t[o]);return e===c?{index:o,exact:!0}:r===o?{index:r,exact:!1}:e<c?p(t,e,r,o,i):p(t,e,o,n,i)}export function lastOf(t){if(t&&t.length)return t[t.length-1]}export function arrayRemove(t){const e=this.indexOf(t);return e!==-1&&this.splice(e,1),this}export function arrayRemove2(t,e){if(!t)return;const r=t.indexOf(e);r!==-1&&t.splice(r,1)}export function firstOf(t){if(t)return t[0]}export function maxMin(t){function e(r,n){const i=t(n);return i==null||!isFinite(i)?r:[Math.max(r[0],i),Math.min(r[1],i)]}return function(r){const n=[Number.NEGATIVE_INFINITY,Number.POSITIVE_INFINITY];return r?r.reduce(e,n):n}}export function getElementsInRange(t,e,r,n=()=>0){const i=(c,u)=>{let s=0,l=c.length-1;for(;l>=s;){const f=Math.ceil((s+l)/2);n(c[f])<=u?s=f+1:l=f-1}return l},o=(c,u)=>{let s=0,l=c.length-1;for(;l>=s;){const f=Math.ceil((s+l)/2);n(c[f])>=u?l=f-1:s=f+1}return s};return t.slice(o(t,e),i(t,r)+1)}
+import { identity } from './function.utils';
+import { clamp, shiftRight } from './math.utils';
+/**
+ * Intersects 2 arrays.
+ * Example:
+ *  source: [1, 2, 3, 1]
+ *  target: [1, 2, 4, 5, 6]
+ *  result: [1, 2]
+ *  result (with duplicates): [1, 1, 2]
+ * @param source
+ * @param target
+ * @param compareFn
+ * @param removeDuplicates
+ * @doc-tags fp,utility
+ */
+export function arrayIntersect(source, target, compareFn = eqeqeq, removeDuplicates = true) {
+    const intersection = source.filter(a => target.some(b => compareFn(a, b)));
+    if (removeDuplicates) {
+        return intersection.filter((value, index, self) => self.indexOf(value) === index);
+    }
+    return intersection;
+}
+/**
+ * Reorders source array according to newOrder.
+ * Returns a reorder copy of the source array.
+ * Example:
+ * 	source: ['1', '2', '3']
+ * 	newOrder: ['3', '1']
+ * 	result: ['3', '2', '1']
+ */
+export const reorderArray = (source, newOrder) => {
+    // filter out elements which are not presented in the source array
+    const order = newOrder.slice().filter(i => source.find(s => s === i));
+    return source.map(el => {
+        var _a;
+        if (newOrder.indexOf(el) >= 0) {
+            return (_a = order.shift()) !== null && _a !== void 0 ? _a : el;
+        }
+        return el;
+    });
+};
+export const eqeqeq = (a, b) => a === b;
+/**
+ * Subtracts target from source array.
+ * Example:
+ *   source: [1, 2, 3, 4]
+ *   target: [2, 4, 6]
+ *   result: [1, 3]
+ * @param source
+ * @param target
+ * @param compareFn
+ */
+export const arraySubtract = (source, target, compareFn) => {
+    return source.filter(a => target.filter(b => compareFn(a, b)).length === 0);
+};
+const eqStrict = (a, b) => a === b;
+export const arrayCompare = (source, target, compareFn = eqStrict) => {
+    return source.length === target.length && source.every((w, i) => compareFn(w, target[i]));
+};
+export function moveInArray(arr, from, to) {
+    const result = arr.slice();
+    const item = result[from];
+    result.splice(from, 1);
+    result.splice(to, 0, item);
+    return result;
+}
+export function moveInArrayMutable(arr, _from, _to) {
+    const n = arr.length;
+    const from = clamp(_from, 0, n - 1);
+    const to = clamp(_to, 0, n - 1);
+    const item = arr[from];
+    arr.splice(from, 1);
+    arr.splice(to, 0, item);
+    return arr;
+}
+/**
+ * Replaces item in array with another one.
+ * @param arr
+ * @param itemFinder - predicate to find item
+ * @param replace - item to replace
+ */
+export function replaceInArray(arr, itemFinder, replace) {
+    const result = arr.slice();
+    const idx = result.findIndex(itemFinder);
+    if (idx !== -1) {
+        result.splice(idx, 1);
+        result.splice(idx, 0, replace);
+    }
+    return result;
+}
+export const uniqueArray = (arr) => {
+    const hashTable = {};
+    return arr.filter(item => (hashTable[item] ? false : (hashTable[item] = true)));
+};
+export const groupBy = (array, key) => {
+    return array.reduce((result, currentValue) => {
+        // If an array already present for key, push it to the array. Else create an array and push the object
+        (result[currentValue[key]] = result[currentValue[key]] || []).push(currentValue);
+        // Return the current iteration `result` value, this will be taken as next iteration `result` value and accumulate
+        return result;
+        // eslint-disable-next-line no-restricted-syntax
+    }, {}); // empty object is the initial value for result object
+};
+/**
+ * Inserts *something* between every two elements in the source array
+ * Example: interleave(['first', 'second', 'third'], 'bar') => ['first', 'bar', 'second', 'bar', 'third']
+ * @param arr
+ * @param something
+ */
+export const interleave = (arr, something) => 
+// eslint-disable-next-line no-restricted-syntax
+[].concat(...arr.map(n => [n, something])).slice(0, -1);
+export const isTwoDimArray = (arr) => Array.isArray(arr[0]);
+// @ts-ignore
+export const create2DArray = (arr) => (Array.isArray(arr[0]) ? arr : [arr]);
+export const slice2DArray = (arr, startIdx, endIdx) => {
+    const result = [];
+    let pointsCurrentIdx = 0;
+    for (const arr1D of arr) {
+        const localIdxStart = Math.max(startIdx - pointsCurrentIdx, 0);
+        const localEndIdx = Math.max(endIdx - pointsCurrentIdx, -1);
+        const newPoints = arr1D.slice(localIdxStart, localEndIdx + 1);
+        newPoints.length > 0 && result.push(newPoints);
+        pointsCurrentIdx += arr1D.length;
+    }
+    return result;
+};
+// Array.at() polyfill (as of December 2022 method is not supported on iOS <= v15)
+export const at = (idx, arr) => (idx >= 0 ? arr[idx] : arr[arr.length + idx]);
+// Array.flat() polyfill (support for chrome 66)
+export const flat = (arr) => {
+    // @ts-ignore
+    if (Array.prototype.flat) {
+        return arr.flat();
+    }
+    return flatMap(arr, identity);
+};
+// Array.flatMap() polyfill (support for chrome 66)
+export const flatMap = (arr, callback) => {
+    // @ts-ignore
+    if (Array.prototype.flatMap) {
+        return arr.flatMap(callback);
+    }
+    const result = [];
+    for (let i = 0; i < arr.length; i++) {
+        const item = arr[i];
+        result.push(...callback(item, i, arr));
+    }
+    return result;
+};
+// eslint-disable-next-line no-redeclare
+export function binarySearch(array, what, transform) {
+    // @ts-ignore
+    const applyTransform = transform !== null && transform !== void 0 ? transform : identity;
+    if (!array.length || what !== what) {
+        return {
+            index: -1,
+            exact: true,
+        };
+    }
+    return binarySearchFn(array, what, 0, array.length, applyTransform);
+}
+function binarySearchFn(array, what, from, to, transform) {
+    const center = shiftRight(from + to, 1);
+    const centerValue = transform(array[center]);
+    if (what === centerValue) {
+        return {
+            index: center,
+            exact: true,
+        };
+    }
+    else {
+        if (from === center) {
+            return {
+                index: from,
+                exact: false,
+            };
+        }
+        else {
+            if (what < centerValue) {
+                return binarySearchFn(array, what, from, center, transform);
+            }
+            else {
+                return binarySearchFn(array, what, center, to, transform);
+            }
+        }
+    }
+}
+export function lastOf(arr) {
+    if (arr && arr.length) {
+        return arr[arr.length - 1];
+    }
+}
+export function arrayRemove(element) {
+    const idx = this.indexOf(element);
+    if (idx !== -1) {
+        this.splice(idx, 1);
+    }
+    return this;
+}
+// ... and this is how a normal person would write "arrayRemove" function
+export function arrayRemove2(array, element) {
+    if (!array) {
+        return;
+    }
+    const idx = array.indexOf(element);
+    if (idx !== -1) {
+        array.splice(idx, 1);
+    }
+}
+export function firstOf(arr) {
+    if (arr) {
+        return arr[0];
+    }
+}
+/**
+ @param {Function} gather - get the comparing value from the array
+ */
+export function maxMin(gather) {
+    function reducer(a, b) {
+        const v = gather(b);
+        if (v === null || v === undefined || !isFinite(v)) {
+            return a;
+        }
+        else {
+            return [Math.max(a[0], v), Math.min(a[1], v)];
+        }
+    }
+    return function (arr) {
+        const defaultResult = [Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY];
+        if (arr) {
+            return arr.reduce(reducer, defaultResult);
+        }
+        return defaultResult;
+    };
+}
+export function getElementsInRange(array, leftBound, rightBound, transform = () => 0) {
+    const upperIndex = (arr, bound) => {
+        let l = 0;
+        let h = arr.length - 1;
+        while (h >= l) {
+            const midIndex = Math.ceil((l + h) / 2);
+            const mid = transform(arr[midIndex]);
+            if (mid <= bound) {
+                l = midIndex + 1;
+            }
+            else {
+                h = midIndex - 1;
+            }
+        }
+        return h;
+    };
+    const lowerIndex = (arr, bound) => {
+        let l = 0;
+        let h = arr.length - 1;
+        while (h >= l) {
+            const midIndex = Math.ceil((l + h) / 2);
+            const mid = transform(arr[midIndex]);
+            if (mid >= bound) {
+                h = midIndex - 1;
+            }
+            else {
+                l = midIndex + 1;
+            }
+        }
+        return l;
+    };
+    return array.slice(lowerIndex(array, leftBound), upperIndex(array, rightBound) + 1);
+}

package/dist/chart/utils/auto-period-detector.utils.js

@@ -3,4 +3,42 @@
  * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
  * If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
-export function autoDetectPeriod(i){if(i.length>1){const f=i.reduce((t,e,o)=>{if(o!==i.length-1){const n=i[o+1].timestamp-e.timestamp;t[n]?t[n]++:t[n]=1}return t},{});let p=0,r;for(const t of Object.keys(f)){const e=parseInt(t,10),o=f[e];o>p&&e>0&&(p=o,r=e)}if(r)return r}}
+/**
+ * Automatically detect period of candle source.
+ * Cannot just take first-second candles distance because of non-trading hours.
+ * Naive approach:
+ *  1. get all time distances between candles
+ *  2. the most frequent distance = period
+ * @param candles
+ * @doc-tags tricky,period
+ */
+export function autoDetectPeriod(candles) {
+    if (candles.length > 1) {
+        // simply get distance between two candles
+        const periodToCount = candles.reduce((acc, candle, idx) => {
+            if (idx !== candles.length - 1) {
+                const period = candles[idx + 1].timestamp - candle.timestamp;
+                if (acc[period]) {
+                    acc[period]++;
+                }
+                else {
+                    acc[period] = 1;
+                }
+            }
+            return acc;
+        }, {});
+        let maxCount = 0;
+        let naivePeriod;
+        for (const _period of Object.keys(periodToCount)) {
+            const period = parseInt(_period, 10);
+            const count = periodToCount[period];
+            if (count > maxCount && period > 0) {
+                maxCount = count;
+                naivePeriod = period;
+            }
+        }
+        if (naivePeriod) {
+            return naivePeriod;
+        }
+    }
+}

package/dist/chart/utils/candles-generator-ts.utils.js

@@ -3,4 +3,23 @@
  * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
  * If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
-import a from"./candles-generator.utils.js";export function generateCandlesDataTS(e){return a(e)}
+import generateCandlesData from './candles-generator.utils.js';
+/**
+ * Generated mock candles data.
+ *
+ * @param config
+ *   quantity - avg number of candles
+ *   startY - avg candle Y to start generation with
+ *   avgCandleSize - avg size of candle
+ *   avgTrendLength:
+ *     sw - avg length of SIDEWAYS trend
+ *     down - avg length of DOWN trend
+ *     up - avg length of UP trend
+ *   withVolume - add random volumes or not
+ *   period - specify distance between candles (60 for 1m, 3600 for 1h, 84600 for 1d)
+ * @return Array<Candle>
+ * @doc-tags tricky
+ */
+export function generateCandlesDataTS(config) {
+    return generateCandlesData(config);
+}

package/dist/chart/utils/candles-generator.utils.js

@@ -3,4 +3,164 @@
  * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
  * If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
-"use strict";export default function p(r){r=r||{},r.quantity=r.quantity||200,r.startY=r.startY||50,r.avgCandleSize=r.avgCandleSize||2,r.avgTrendLength=r.avgTrendLength||{},r.avgTrendLength.sw=r.avgTrendLength.sw||10,r.avgTrendLength.down=r.avgTrendLength.down||10,r.avgTrendLength.up=r.avgTrendLength.up||10,r.withVolume=r.withVolume===!0||!1,r.period=r.period||3600;var a=[],n=r.quantity||200,m=10,u=10,h=10;r.avgTrendLength&&(m=r.avgTrendLength.sw||10,u=r.avgTrendLength.down||10,h=r.avgTrendLength.up||10);var t=r.startY||50,e=r.avgCandleSize||2,v=t-e,o=t+e,w=T(v,o,e);for(a.push(w);a.length<n;){var d=Math.random()*10;d>6?a=a.concat(b(a[a.length-1],e,m)):d>3?a=a.concat(L(a[a.length-1],e,h)):a=a.concat(i(a[a.length-1],e,u))}a=a.slice(0,r.quantity);let s=Math.round(new Date().getTime()/3e5)*3e5;s-=n*1e3*r.period;for(let M=0;M<a.length;M++){const l=a[M];Object.assign(l,{timestamp:s,isVisible:!0}),s+=1e3*r.period,r.withVolume&&(l.volume=Math.ceil(Math.random()*1e3+200))}return a}function T(r,a,n,m){var u=Math.random()*(a-r)+r,h;if(m&&m==="bull"||!m&&Math.random()>.5){var t=u+n;h=t<a?t:a}else{var e=u-n;h=e>r?e:r}var v=Math.max(u,h)+Math.random()*n*.2,o=Math.min(u,h)-Math.random()*n*.2;return{hi:v,lo:o,open:u,close:h,timestamp:0,volume:0}}function L(r,a,n){for(var m=[],u=Math.random()*n+n/2,h=r.lo,t=r.hi+a*1.2,e=0;e<u;e++){var v=Math.random()>.9?"bear":"bull",o=T(h,t,a,v);h=o.lo-a*(Math.random()*.1+.1),t=o.hi+a*(Math.random()*1.3+.1),Math.random()>.9&&(t=o.hi+a),m.push(o)}return m}function i(r,a,n){for(var m=[],u=Math.random()*n+n/2,h=r.hi-a*1.2,t=r.hi,e=0;e<u;e++){var v=Math.random()<.9?"bear":"bull",o=T(h,t,a,v);h=o.lo-a*(Math.random()*.3+.1),t=o.hi-a*(Math.random()*.1+.1),Math.random()>.9&&(t=o.lo-a),m.push(o)}return m}function b(r,a,n){var m=[],u=Math.random()*n+n/2;function h(s){var M,l;return Math.random()>.5?(M=s.lo-a*.2,l=s.hi+a*1.2):(M=s.lo-a*1.2,l=s.hi+a*.2),{from:M,to:l}}for(var t=h(r),e=t.from,v=t.to,o=0;o<u;o++){var w=Math.random()<.5?"bear":"bull",d=T(e,v,a,w);t=h(d),e=t.from,v=t.to,Math.random()>.9&&(Math.random()>.5?e=d.lo-a:v=d.hi+a),m.push(d)}return m}window.DXChart=Object.assign(Object.assign({},window.DXChart),{generateCandlesData:p});
+/* eslint-disable */
+'use strict';
+export default function generateCandlesData(config) {
+    // default generation config
+    config = config || {};
+    config.quantity = config.quantity || 200;
+    config.startY = config.startY || 50;
+    config.avgCandleSize = config.avgCandleSize || 2;
+    config.avgTrendLength = config.avgTrendLength || {};
+    config.avgTrendLength.sw = config.avgTrendLength.sw || 10;
+    config.avgTrendLength.down = config.avgTrendLength.down || 10;
+    config.avgTrendLength.up = config.avgTrendLength.up || 10;
+    config.withVolume = config.withVolume === true || false;
+    config.period = config.period || 3600;
+    var result = [];
+    var quantity = config.quantity || 200;
+    var swTrendLength = 10;
+    var downTrendLength = 10;
+    var upTrendLength = 10;
+    if (config.avgTrendLength) {
+        swTrendLength = config.avgTrendLength.sw || 10;
+        downTrendLength = config.avgTrendLength.down || 10;
+        upTrendLength = config.avgTrendLength.up || 10;
+    }
+    var startY = config.startY || 50;
+    var candleAvgSize = config.avgCandleSize || 2;
+    // generate 1st candle
+    var from = startY - candleAvgSize;
+    var to = startY + candleAvgSize;
+    var entryCandle = generateRandomCandle(from, to, candleAvgSize);
+    result.push(entryCandle);
+    // generate UP, DOWN or SW trends until quantity is filled
+    while (result.length < quantity) {
+        var r = Math.random() * 10;
+        if (r > 6) {
+            result = result.concat(generateCandlesSideways(result[result.length - 1], candleAvgSize, swTrendLength));
+        }
+        else if (r > 3) {
+            result = result.concat(generateCandlesUp(result[result.length - 1], candleAvgSize, upTrendLength));
+        }
+        else {
+            result = result.concat(generateCandlesDown(result[result.length - 1], candleAvgSize, downTrendLength));
+        }
+    }
+    result = result.slice(0, config.quantity);
+    // set candle timestamps
+    let time = Math.round(new Date().getTime() / 300000) * 300000;
+    time -= quantity * 1000 * config.period;
+    for (let i = 0; i < result.length; i++) {
+        const candle = result[i];
+        Object.assign(candle, {
+            timestamp: time,
+            isVisible: true,
+        });
+        time += 1000 * config.period;
+        if (config.withVolume) {
+            candle.volume = Math.ceil(Math.random() * 1000 + 200);
+        }
+    }
+    return result;
+}
+function generateRandomCandle(from, to, candleAvgSize, type) {
+    var open = Math.random() * (to - from) + from;
+    var close;
+    if ((type && type === 'bull') || (!type && Math.random() > 0.5)) {
+        var close1 = open + candleAvgSize;
+        close = close1 < to ? close1 : to;
+    }
+    else {
+        var close2 = open - candleAvgSize;
+        close = close2 > from ? close2 : from;
+    }
+    var high = Math.max(open, close) + Math.random() * candleAvgSize * 0.2;
+    var low = Math.min(open, close) - Math.random() * candleAvgSize * 0.2;
+    return {
+        hi: high,
+        lo: low,
+        open: open,
+        close: close,
+        timestamp: 0,
+        volume: 0,
+    };
+}
+function generateCandlesUp(entryCandle, candleAvgSize, trendLength) {
+    var result = [];
+    var randomTrendLength = Math.random() * trendLength + trendLength / 2;
+    var from = entryCandle.lo;
+    var to = entryCandle.hi + candleAvgSize * 1.2;
+    for (var i = 0; i < randomTrendLength; i++) {
+        var type = Math.random() > 0.9 ? 'bear' : 'bull';
+        var candle = generateRandomCandle(from, to, candleAvgSize, type);
+        from = candle.lo - candleAvgSize * (Math.random() * 0.1 + 0.1);
+        to = candle.hi + candleAvgSize * (Math.random() * 1.3 + 0.1);
+        // spike
+        if (Math.random() > 0.9) {
+            to = candle.hi + candleAvgSize;
+        }
+        result.push(candle);
+    }
+    return result;
+}
+function generateCandlesDown(entryCandle, candleAvgSize, trendLength) {
+    var result = [];
+    var randomTrendLength = Math.random() * trendLength + trendLength / 2;
+    var from = entryCandle.hi - candleAvgSize * 1.2;
+    var to = entryCandle.hi;
+    for (var i = 0; i < randomTrendLength; i++) {
+        var type = Math.random() < 0.9 ? 'bear' : 'bull';
+        var candle = generateRandomCandle(from, to, candleAvgSize, type);
+        from = candle.lo - candleAvgSize * (Math.random() * 0.3 + 0.1);
+        to = candle.hi - candleAvgSize * (Math.random() * 0.1 + 0.1);
+        // spike
+        if (Math.random() > 0.9) {
+            to = candle.lo - candleAvgSize;
+        }
+        result.push(candle);
+    }
+    return result;
+}
+function generateCandlesSideways(entryCandle, candleAvgSize, trendLength) {
+    var result = [];
+    var randomTrendLength = Math.random() * trendLength + trendLength / 2;
+    function nextFromTo(candle) {
+        var from;
+        var to;
+        if (Math.random() > 0.5) {
+            from = candle.lo - candleAvgSize * 0.2;
+            to = candle.hi + candleAvgSize * 1.2;
+        }
+        else {
+            from = candle.lo - candleAvgSize * 1.2;
+            to = candle.hi + candleAvgSize * 0.2;
+        }
+        return {
+            from: from,
+            to: to,
+        };
+    }
+    var fromTo = nextFromTo(entryCandle);
+    var from = fromTo.from;
+    var to = fromTo.to;
+    for (var i = 0; i < randomTrendLength; i++) {
+        var type = Math.random() < 0.5 ? 'bear' : 'bull';
+        var candle = generateRandomCandle(from, to, candleAvgSize, type);
+        fromTo = nextFromTo(candle);
+        from = fromTo.from;
+        to = fromTo.to;
+        // spike
+        if (Math.random() > 0.9) {
+            if (Math.random() > 0.5) {
+                from = candle.lo - candleAvgSize;
+            }
+            else {
+                to = candle.hi + candleAvgSize;
+            }
+        }
+        result.push(candle);
+    }
+    return result;
+}
+window['DXChart'] = Object.assign(Object.assign({}, window['DXChart']), { generateCandlesData });

package/dist/chart/utils/candles.utils.js

@@ -3,4 +3,45 @@
  * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
  * If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
-import{binarySearch as c,firstOf as d,lastOf as s}from"./array.utils";import{floor as v}from"./math.utils";export const searchCandleIndex=(e,o,r,u=1e3)=>{var t,i,n,l;const f=(i=(t=d(r))===null||t===void 0?void 0:t.timestamp)!==null&&i!==void 0?i:0,x=(l=(n=s(r))===null||n===void 0?void 0:n.timestamp)!==null&&l!==void 0?l:0;return e>x?o?{index:r.length-1+Math.ceil((e-x)/u),exact:!0}:{index:r.length-1,exact:!0}:e<f?o?{index:v((e-f)/u),exact:!0}:{index:-1,exact:!0}:c(r,e,a=>a.timestamp)};
+import { binarySearch, firstOf, lastOf } from './array.utils';
+import { floor } from './math.utils';
+export const searchCandleIndex = (timestamp, shouldExtrapolate, candles, periodMs = 1000) => {
+    var _a, _b, _c, _d;
+    const firstTimestamp = (_b = (_a = firstOf(candles)) === null || _a === void 0 ? void 0 : _a.timestamp) !== null && _b !== void 0 ? _b : 0;
+    const lastTimestamp = (_d = (_c = lastOf(candles)) === null || _c === void 0 ? void 0 : _c.timestamp) !== null && _d !== void 0 ? _d : 0;
+    if (timestamp > lastTimestamp) {
+        // TODO rework the code below, it looks very very sus ( ≖.≖)
+        if (shouldExtrapolate) {
+            // div by 1000 because periodDuration is in seconds
+            return {
+                // -1 to skip fake candle and get the last existing/visible one if reached last index
+                index: candles.length - 1 + Math.ceil((timestamp - lastTimestamp) / periodMs),
+                exact: true,
+            };
+        }
+        else {
+            return {
+                // -1 to skip fake candle and get the last existing/visible one if reached last index
+                index: candles.length - 1,
+                exact: true,
+            };
+        }
+    }
+    else if (timestamp < firstTimestamp) {
+        if (shouldExtrapolate) {
+            return {
+                index: floor((timestamp - firstTimestamp) / periodMs),
+                exact: true,
+            };
+        }
+        else {
+            return {
+                index: -1,
+                exact: true,
+            };
+        }
+    }
+    else {
+        return binarySearch(candles, timestamp, candle => candle.timestamp);
+    }
+};