@devexperts/dxcharts-lite 1.0.1 → 2.0.0

package/dist/chart/model/scaling/viewport.model.js

@@ -1,6 +1,284 @@
 /*
- * Copyright (C) 2002 - 2023 Devexperts LLC
+ * Copyright (C) 2019 - 2023 Devexperts Solutions IE Limited
  * 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{Subject as n}from"rxjs";import{distinctUntilChanged as o,map as r,share as h}from"rxjs/operators";import{ChartBaseElement as a}from"../chart-base-element";import{keys as d}from"../../utils/object.utils";export const calculateZoom=(e,t)=>e/t,unitToPixels=(e,t)=>e/t,pixelsToUnits=(e,t)=>e*t,unitToPercent=(e,t)=>(e-t)*100/t,percentToUnit=(e,t)=>e*t/100+t,calcLogValue=e=>Math.log2(e),logValueToUnit=e=>Math.pow(2,e);export class ViewportModel extends a{constructor(){super(...arguments),this._xStart=0,this._xEnd=0,this._yStart=0,this._yEnd=0,this._zoomX=1,this._zoomY=1,this._inverseY=!1,this.changed=new n,this.xChanged=this.changed.pipe(r(()=>({start:this.xStart,end:this.xEnd})),o((t,s)=>t.start===s.start&&t.end===s.end),h()),this.yChanged=this.changed.pipe(r(()=>({start:this.yStart,end:this.yEnd})),o((t,s)=>t.start===s.start&&t.end===s.end),h())}toX(t){return this.getBounds().x+unitToPixels(t-this.xStart,this.zoomX)}xPixels(t){return unitToPixels(t,this.zoomX)}toY(t){return this.inverseY?this.getBounds().y+unitToPixels(t-this.yStart,this.zoomY):this.getBounds().y+this.getBounds().height-unitToPixels(t-this.yStart,this.zoomY)}yPixels(t){return unitToPixels(t,this.zoomY)}fromX(t){const s=t-this.getBounds().x;return pixelsToUnits(s+unitToPixels(this.xStart,this.zoomX),this.zoomX)}fromY(t){const s=t-this.getBounds().y;return this.inverseY?pixelsToUnits(s+unitToPixels(this.yStart,this.zoomY),this.zoomY):pixelsToUnits(this.getBounds().height-s+unitToPixels(this.yStart,this.zoomY),this.zoomY)}recalculateZoomX(){this.zoomX=this.calculateZoomX(this.xStart,this.xEnd)}recalculateZoomY(){this.zoomY=this.calculateZoomY(this.yStart,this.yEnd)}calculateZoomX(t,s){return calculateZoom(s-t,this.getBounds().width)}calculateZoomY(t,s){return calculateZoom(s-t,this.getBounds().height)}recalculateZoom(t=!0){this.recalculateZoomX(),this.recalculateZoomY(),t&&this.fireChanged()}setXScale(t,s,i=!0){this.xStart=t,this.xEnd=s,this.recalculateZoomX(),i&&this.fireChanged()}setYScale(t,s,i=!0){this.yStart=t,this.yEnd=s,this.recalculateZoomY(),i&&this.fireChanged()}export(){return{xStart:this.xStart,xEnd:this.xEnd,yStart:this.yStart,yEnd:this.yEnd,zoomX:this.zoomX,zoomY:this.zoomY,inverseY:this.inverseY}}apply(t){this.xStart=t.xStart,this.xEnd=t.xEnd,this.yStart=t.yStart,this.yEnd=t.yEnd,this.zoomX=t.zoomX,this.zoomY=t.zoomY,this.inverseY=t.inverseY,this.fireChanged()}fireChanged(){this.changed.next()}get xStart(){return this._xStart}set xStart(t){this._xStart=t}get xEnd(){return this._xEnd}set xEnd(t){this._xEnd=t}get yStart(){return this._yStart}set yStart(t){this._yStart=t}get yEnd(){return this._yEnd}set yEnd(t){this._yEnd=t}get zoomX(){return this._zoomX}set zoomX(t){this._zoomX=t}get zoomY(){return this._zoomY}set zoomY(t){this._zoomY=t}get inverseY(){return this._inverseY}set inverseY(t){this._inverseY=t}isViewportValid(){return this.xStart!==this.xEnd&&this.yStart!==this.yEnd&&isFinite(this.yStart)&&isFinite(this.yEnd)}}export const compareStates=(e,t)=>!d(e).some(s=>e[s]!==t[s]);
+import { Subject } from 'rxjs';
+import { distinctUntilChanged, map, share } from 'rxjs/operators';
+import { ChartBaseElement } from '../chart-base-element';
+import { keys } from '../../utils/object.utils';
+export const calculateZoom = (viewportUnits, viewportPixels) => viewportUnits / viewportPixels;
+export const unitToPixels = (units, zoom) => units / zoom;
+export const pixelsToUnits = (px, zoom) => px * zoom;
+export const unitToPercent = (value, baseline) => ((value - baseline) * 100) / baseline;
+export const percentToUnit = (percent, baseline) => (percent * baseline) / 100 + baseline;
+// log calculations
+export const calcLogValue = (value) => Math.log2(value);
+export const logValueToUnit = (logValue) => Math.pow(2, logValue);
+/**
+ * Abstract viewport model.
+ * Viewport has 4 coordinates: xStart, xEnd, yStart and yEnd - all stored in {@link Unit}.
+ * Main methods:
+ * - {@link toX} - converts xUnits to xPixels
+ * - {@link toY} - converts yUnits to yPixels
+ * - {@link fromX} - converts xPixels to xUnits
+ * - {@link fromY} - converts yPixels to yUnits
+ *
+ * To convert unit-pixels and vice versa uses {@link getBounds} method.
+ * zoomX and zoomY are proportions between units and pixels.
+ */
+export class ViewportModel extends ChartBaseElement {
+    constructor() {
+        super(...arguments);
+        //region base viewport model props
+        this._xStart = 0;
+        this._xEnd = 0;
+        this._yStart = 0;
+        this._yEnd = 0;
+        this._zoomX = 1;
+        this._zoomY = 1;
+        //endregion
+        // toggle Y inverse mode
+        this._inverseY = false;
+        //region subjects
+        this.changed = new Subject();
+        this.xChanged = this.changed.pipe(map(() => ({
+            start: this.xStart,
+            end: this.xEnd,
+        })), distinctUntilChanged((p, c) => p.start === c.start && p.end === c.end), share());
+        this.yChanged = this.changed.pipe(map(() => ({
+            start: this.yStart,
+            end: this.yEnd,
+        })), distinctUntilChanged((p, c) => p.start === c.start && p.end === c.end), share());
+    }
+    //endregion
+    //region conversion methods
+    /**
+     * Converts a unit value to pixels based on the current zoom level and xStart value.
+     * @param {Unit} unit - The unit value to be converted to pixels.
+     * @returns {Pixel} - The converted pixel value.
+     */
+    toX(unit) {
+        return this.getBounds().x + unitToPixels(unit - this.xStart, this.zoomX);
+    }
+    /**
+     * Converts a unit value to pixels based on the current zoom level in the x-axis.
+     * @param {Unit} unit - The unit value to be converted to pixels.
+     * @returns {Pixel} - The converted value in pixels.
+     */
+    xPixels(unit) {
+        return unitToPixels(unit, this.zoomX);
+    }
+    /**
+     * Converts a given unit value to pixel value in the Y-axis.
+     * @param {Unit} unit - The unit value to be converted to pixel value.
+     * @returns {Pixel} - The pixel value of the given unit value in the Y-axis.
+     */
+    toY(unit) {
+        if (this.inverseY) {
+            return this.getBounds().y + unitToPixels(unit - this.yStart, this.zoomY);
+        }
+        else {
+            // inverse by default because canvas calculation [0,0] point starts from top-left corner
+            return this.getBounds().y + this.getBounds().height - unitToPixels(unit - this.yStart, this.zoomY);
+        }
+    }
+    /**
+     * Converts a unit value to pixels based on the current zoom level in the Y axis.
+     * @param {Unit} unit - The unit value to be converted to pixels.
+     * @returns {Pixel} - The converted value in pixels.
+     */
+    yPixels(unit) {
+        return unitToPixels(unit, this.zoomY);
+    }
+    /**
+     * Converts a pixel value to a unit value based on the current zoom level and xStart value.
+     * @param {Pixel} px - The pixel value to convert to unit value.
+     * @returns {Unit} - The converted unit value.
+     */
+    fromX(px) {
+        const normalizedPx = px - this.getBounds().x;
+        return pixelsToUnits(normalizedPx + unitToPixels(this.xStart, this.zoomX), this.zoomX);
+    }
+    /**
+     * Converts a pixel value to a unit value along the y-axis.
+     * @param {Pixel} px - The pixel value to be converted.
+     * @returns {void}
+     */
+    fromY(px) {
+        const normalizedPx = px - this.getBounds().y;
+        if (this.inverseY) {
+            return pixelsToUnits(normalizedPx + unitToPixels(this.yStart, this.zoomY), this.zoomY);
+        }
+        else {
+            // inverse by default because canvas calculation [0,0] point starts from top-left corner
+            return pixelsToUnits(this.getBounds().height - normalizedPx + unitToPixels(this.yStart, this.zoomY), this.zoomY);
+        }
+    }
+    //endregion
+    /**
+     * Recalculates the zoom factor for the x-axis based on the start and end values of the x-axis.
+     * @function
+     * @name recalculateZoomX
+     * @memberof ClassName
+     * @instance
+     * @returns {void}
+     */
+    recalculateZoomX() {
+        this.zoomX = this.calculateZoomX(this.xStart, this.xEnd);
+    }
+    /**
+     * Recalculates the zoomY property of the object.
+     * The zoomY property is calculated using the yStart and yEnd properties of the object.
+     * @function
+     * @name recalculateZoomY
+     * @memberof Object
+     * @instance
+     * @returns {void}
+     */
+    recalculateZoomY() {
+        this.zoomY = this.calculateZoomY(this.yStart, this.yEnd);
+    }
+    /**
+     * Calculates the zoom factor for the x-axis based on the start and end units.
+     * @param {Unit} start - The start unit.
+     * @param {Unit} end - The end unit.
+     * @returns {Zoom} The zoom factor for the x-axis.
+     */
+    calculateZoomX(start, end) {
+        return calculateZoom(end - start, this.getBounds().width);
+    }
+    /**
+     * Calculates the zoom factor for the Y axis based on the start and end units.
+     * @param {Unit} start - The start unit.
+     * @param {Unit} end - The end unit.
+     * @returns {Zoom} The zoom factor for the Y axis.
+     */
+    calculateZoomY(start, end) {
+        return calculateZoom(end - start, this.getBounds().height);
+    }
+    /**
+     * Should be called when x/y start/end changes.
+     */
+    recalculateZoom(fireChanged = true) {
+        this.recalculateZoomX();
+        this.recalculateZoomY();
+        fireChanged && this.fireChanged();
+    }
+    /**
+     * Moves the viewport to exactly xStart..xEnd place.
+     * (you need to fire DRAW event after this)
+     * @param xStart - viewport start in units
+     * @param xEnd - viewport end in units
+     * @param fireChanged - fire changed event
+     */
+    setXScale(xStart, xEnd, fireChanged = true) {
+        this.xStart = xStart;
+        this.xEnd = xEnd;
+        this.recalculateZoomX();
+        fireChanged && this.fireChanged();
+    }
+    /**
+     * Moves the viewport to exactly yStart..yEnd place.
+     * (you need to fire DRAW event after this)
+     * @param yStart - viewport start in units
+     * @param yEnd - viewport end in units
+     * @param fireChanged - fire changed event
+     */
+    setYScale(yStart, yEnd, fireChanged = true) {
+        this.yStart = yStart;
+        this.yEnd = yEnd;
+        this.recalculateZoomY();
+        fireChanged && this.fireChanged();
+    }
+    /**
+     * Exports current state of VM.
+     */
+    export() {
+        return {
+            xStart: this.xStart,
+            xEnd: this.xEnd,
+            yStart: this.yStart,
+            yEnd: this.yEnd,
+            zoomX: this.zoomX,
+            zoomY: this.zoomY,
+            inverseY: this.inverseY,
+        };
+    }
+    /**
+     * Applies the state to current VM.
+     * @param state
+     */
+    apply(state) {
+        this.xStart = state.xStart;
+        this.xEnd = state.xEnd;
+        this.yStart = state.yStart;
+        this.yEnd = state.yEnd;
+        this.zoomX = state.zoomX;
+        this.zoomY = state.zoomY;
+        this.inverseY = state.inverseY;
+        this.fireChanged();
+    }
+    /**
+     * Emits a notification that the object has changed.
+     * @function
+     * @name fireChanged
+     * @memberof ClassName
+     * @instance
+     * @returns {void}
+     */
+    fireChanged() {
+        this.changed.next();
+    }
+    get xStart() {
+        return this._xStart;
+    }
+    set xStart(value) {
+        this._xStart = value;
+    }
+    get xEnd() {
+        return this._xEnd;
+    }
+    set xEnd(value) {
+        this._xEnd = value;
+    }
+    get yStart() {
+        return this._yStart;
+    }
+    set yStart(value) {
+        this._yStart = value;
+    }
+    get yEnd() {
+        return this._yEnd;
+    }
+    set yEnd(value) {
+        this._yEnd = value;
+    }
+    get zoomX() {
+        return this._zoomX;
+    }
+    set zoomX(value) {
+        this._zoomX = value;
+    }
+    get zoomY() {
+        return this._zoomY;
+    }
+    set zoomY(value) {
+        this._zoomY = value;
+    }
+    get inverseY() {
+        return this._inverseY;
+    }
+    set inverseY(value) {
+        this._inverseY = value;
+    }
+    /**
+     * Checks if the viewport is valid.
+     *
+     * @returns {boolean} - Returns true if the viewport is valid, false otherwise.
+     */
+    isViewportValid() {
+        return this.xStart !== this.xEnd && this.yStart !== this.yEnd && isFinite(this.yStart) && isFinite(this.yEnd);
+    }
+}
+export const compareStates = (a, b) => !keys(a).some(k => a[k] !== b[k]);

package/dist/chart/model/scaling/x-zooming.functions.d.ts

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2002 - 2023 Devexperts LLC
+ * Copyright (C) 2019 - 2023 Devexperts Solutions IE Limited
  * 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/.
  */

package/dist/chart/model/scaling/x-zooming.functions.js

@@ -1,6 +1,40 @@
 /*
- * Copyright (C) 2002 - 2023 Devexperts LLC
+ * Copyright (C) 2019 - 2023 Devexperts Solutions IE Limited
  * 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 const zoomXToPercentViewportCalculator=(n,o,r,x,E)=>{const d=(o.xEnd-o.xStart)*x,l=d*r,c=d*(1-r);return E?(o.xStart=o.xStart+l,o.xEnd=o.xEnd-c):(o.xStart=o.xStart-l,o.xEnd=o.xEnd+c),o.zoomX=n.calculateZoomX(o.xStart,o.xEnd),o},zoomXToEndViewportCalculator=(n,o,r,x)=>zoomXToPercentViewportCalculator(n,o,1,r,x);
+/**
+ * Zooms to percentage of viewport proportionally.
+ * @param vm
+ * @param state
+ * @param viewportPercent
+ * @param zoomStrength - 0..1 number, 1=max strength
+ * @param zoomIn
+ * @doc-tags viewport,zoom,scaling
+ */
+export const zoomXToPercentViewportCalculator = (vm, state, viewportPercent, zoomStrength, zoomIn) => {
+    const deltaWidth = (state.xEnd - state.xStart) * zoomStrength;
+    const deltaStart = deltaWidth * viewportPercent;
+    const deltaEnd = deltaWidth * (1 - viewportPercent);
+    if (zoomIn) {
+        state.xStart = state.xStart + deltaStart;
+        state.xEnd = state.xEnd - deltaEnd;
+    }
+    else {
+        state.xStart = state.xStart - deltaStart;
+        state.xEnd = state.xEnd + deltaEnd;
+    }
+    state.zoomX = vm.calculateZoomX(state.xStart, state.xEnd);
+    return state;
+};
+/**
+ * Zooms to viewports end.
+ * @param vm
+ * @param state
+ * @param zoomStrength - 0..1 number, 1=max strength
+ * @param zoomIn
+ * @doc-tags viewport,zoom,scaling
+ */
+export const zoomXToEndViewportCalculator = (vm, state, zoomStrength, zoomIn) => {
+    return zoomXToPercentViewportCalculator(vm, state, 1, zoomStrength, zoomIn);
+};

package/dist/chart/model/time-zone.model.d.ts

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2002 - 2023 Devexperts LLC
+ * Copyright (C) 2019 - 2023 Devexperts Solutions IE Limited
  * 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/.
  */

package/dist/chart/model/time-zone.model.js

@@ -1,6 +1,114 @@
 /*
- * Copyright (C) 2002 - 2023 Devexperts LLC
+ * Copyright (C) 2019 - 2023 Devexperts Solutions IE Limited
  * 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{getTimezoneOffset as n}from"date-fns-tz";import{ReplaySubject as s}from"rxjs";import{memoize as f}from"../utils/perfomance/memoize.utils";import{dateTimeFormatterFactory as c}from"./date-time.formatter";export const memoizedTZOffset=f(n),getTimezoneOffset=(r,e)=>new Date(e).getTimezoneOffset()*60*1e3+memoizedTZOffset(r,e);export class TimeZoneModel{constructor(e){this.config=e,this.timeZoneChangedSubject=new s,this.currentTzOffset=t=>this.getOffset(this.config.timezone,t),this.formatterCache={},this.getOffset=(t,i)=>getTimezoneOffset(t,i),this.dateTimeFormatterFactory=this.initFormatterFactory(this.config.dateFormatter)}setTimeZone(e){this.config.timezone=e,this.formatterCache={},this.timeZoneChangedSubject.next(e)}observeTimeZoneChanged(){return this.timeZoneChangedSubject.asObservable()}initFormatterFactory(e){let t;if(e&&typeof e=="function")t=e;else if(e&&e.createFormatterFunction&&typeof e.createFormatterFunction=="function"){const i=e.createFormatterFunction;t=o=>i(o).bind(e)}else t=c(this.config,this.tzOffset);return t}getFormatterFactory(){return this.dateTimeFormatterFactory}getDateTimeFormatter(e){return this.formatterCache[e]===void 0&&(this.formatterCache[e]=this.dateTimeFormatterFactory(e)),this.formatterCache[e]}tzOffset(e){const t=o=>-new Date(o).getTimezoneOffset()*a;let i;return e?i=o=>memoizedTZOffset(e,o):i=t,o=>new Date(+o+i(o)-t(o))}}const a=60*1e3;
+import { getTimezoneOffset as getTimezoneOffsetDateFnsTz } from 'date-fns-tz';
+import { ReplaySubject } from 'rxjs';
+import { memoize } from '../utils/performance/memoize.utils';
+import { dateTimeFormatterFactory } from './date-time.formatter';
+export const memoizedTZOffset = memoize(getTimezoneOffsetDateFnsTz);
+export const getTimezoneOffset = (timezone, time) => {
+    // we must pass time here, because we can have daylight saving time, otherwise we will get wrong offset
+    const localOffset = new Date(time).getTimezoneOffset() * 60 * 1000;
+    return localOffset + memoizedTZOffset(timezone, time);
+};
+export class TimeZoneModel {
+    constructor(config) {
+        this.config = config;
+        this.timeZoneChangedSubject = new ReplaySubject();
+        this.currentTzOffset = (time) => this.getOffset(this.config.timezone, time);
+        this.formatterCache = {};
+        /**
+         * Calculates the offset of a given timezone from the local timezone.
+         * @private
+         * @param {string} timezone - The timezone to calculate the offset for.
+         */
+        this.getOffset = (timezone, time) => getTimezoneOffset(timezone, time);
+        this.dateTimeFormatterFactory = this.initFormatterFactory(this.config.dateFormatter);
+    }
+    /**
+     * Sets the timezone for the configuration and updates the current timezone offset.
+     * @param {string} timeZone - The timezone to set.
+     * @returns {void}
+     */
+    setTimeZone(timeZone) {
+        this.config.timezone = timeZone;
+        this.formatterCache = {};
+        this.timeZoneChangedSubject.next(timeZone);
+    }
+    /**
+     * Returns an Observable that emits a string value when the time zone is changed.
+     * The Observable is created from the timeZoneChangedSubject Subject.
+     * @returns {Observable<string>} An Observable that emits a string value when the time zone is changed.
+     */
+    observeTimeZoneChanged() {
+        return this.timeZoneChangedSubject.asObservable();
+    }
+    /**
+     * Initializes a DateTimeFormatterFactory object.
+     * @param {DateFormatter} [dateFormatter] - Optional DateFormatter object.
+     * @returns {DateTimeFormatterFactory} - Returns a DateTimeFormatterFactory object.
+     * If a plain function is provided as the dateFormatter parameter, it will be used as a date formatter without applying UTC datetime override for candles more than 1d period.
+     * If a custom date formatter exists, it will be used for datetime formatting applying optionally UTC datetime override for candles more than 1d period.
+     * If no dateFormatter is provided, a default DateTimeFormatterFactory object will be returned.
+     */
+    initFormatterFactory(dateFormatter) {
+        let result;
+        if (dateFormatter && typeof dateFormatter === 'function') {
+            // backward compatibility - if date formatter is a plain function then there is no need to use UTC datetime
+            // override for candles more than 1d period
+            result = dateFormatter;
+        }
+        else if (dateFormatter &&
+            dateFormatter.createFormatterFunction &&
+            typeof dateFormatter.createFormatterFunction === 'function') {
+            // if custom date formatter exists we use it for datetime formatting applying optionally
+            // UTC datetime override for candles more than 1d period
+            const createFormatter = dateFormatter.createFormatterFunction;
+            result = (pattern) => createFormatter(pattern).bind(dateFormatter);
+        }
+        else {
+            result = dateTimeFormatterFactory(this.config, this.tzOffset);
+        }
+        return result;
+    }
+    /**
+     * Returns the DateTimeFormatterFactory instance used by this class.
+     *
+     * @returns {DateTimeFormatterFactory} The DateTimeFormatterFactory instance used by this class.
+     */
+    getFormatterFactory() {
+        return this.dateTimeFormatterFactory;
+    }
+    getDateTimeFormatter(format) {
+        if (this.formatterCache[format] === undefined) {
+            this.formatterCache[format] = this.dateTimeFormatterFactory(format);
+        }
+        return this.formatterCache[format];
+    }
+    /**
+     * Gets the timezone offset value in milliseconds
+     * @param {string} timezone name
+     * @returns {function(time:Number):Date}
+     */
+    tzOffset(timezone) {
+        // we must pass time here, because we can have daylight saving time, otherwise we will get wrong offset
+        const localOffset = (time) => -new Date(time).getTimezoneOffset() * timeMultiplier;
+        let offset;
+        if (!timezone) {
+            offset = localOffset;
+        }
+        else {
+            // we must pass time here, because we can have daylight saving time, otherwise we will get wrong offset
+            offset = (time) => memoizedTZOffset(timezone, time);
+        }
+        // In JS Date object is created with local tz offset,
+        // so we have to subtract localOffset from current time
+        return time => {
+            return new Date(+time + offset(time) - localOffset(time));
+        };
+    }
+}
+// 1 hour in milliseconds
+const timeMultiplier = 60 * 1000;

package/dist/chart/model/visual-candle.d.ts

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2002 - 2023 Devexperts LLC
+ * Copyright (C) 2019 - 2023 Devexperts Solutions IE Limited
  * 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/.
  */

package/dist/chart/model/visual-candle.js

@@ -1,6 +1,139 @@
 /*
- * Copyright (C) 2002 - 2023 Devexperts LLC
+ * Copyright (C) 2019 - 2023 Devexperts Solutions IE Limited
  * 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{floorToDPR as s,roundToDPR as l}from"../utils/device/device-pixel-ratio.utils";import{VisualSeriesPoint as u}from"./data-series.model";export default class y extends u{constructor(t,o,h,i,n,r,e,d,a=!1,c=!1,Y=!1){super(t,i),this.startUnit=t-o/2,this.width=o,this.open=h,this.high=n,this.low=r,this.name=e,this.candle=d,this.hasBorder=a,this.isActive=c,this.isHollow=Y}bodyHeight(t){return s(Math.abs(t.toY(this.open)-t.toY(this.close)))}candleHeight(t){return s(Math.abs(t.toY(this.high)-t.toY(this.low)))}bodyAsVLine(t){if(this.width<2)return[this.centerUnit,this.yLineStart(t),this.width,this.candleHeight(t)]}bodyRect(t){return[this.startUnit,this.yBodyStart(t),this.width,this.bodyHeight(t)]}getCandle(){return this.candle}yBodyKeyPoints(t){const o=s(t.toY(this.high)),h=s(t.toY(this.low)),i=s(t.toY(this.open)),n=s(t.toY(this.close)),[r,e]=i>n?[n,i]:[i,n],[d,a]=o>h?[h,o]:[o,h];return[d,r,e,a]}yLineEnd(t){return s(Math.max(t.toY(this.high),t.toY(this.low)))}yLineStart(t){return s(Math.min(t.toY(this.high),t.toY(this.low)))}yBodyStart(t){return s(Math.min(t.toY(this.open),t.toY(this.close)))}yBodyEnd(t){return s(Math.max(t.toY(this.open),t.toY(this.close)))}xCenter(t){return this.x(t)}xStart(t){return l(t.toX(this.startUnit))}}
+import { floorToDPR, roundToDPR } from '../utils/device/device-pixel-ratio.utils';
+import { VisualSeriesPoint } from './data-series.model';
+/**
+ * Candle's visual representation. Candle's coordinates are adjusted by .5 unit to prevent anti-aliasing effect for
+ * lines with 1px width
+ *
+ * @param x wick location on X-axis
+ * @param width candle's width
+ * @param op open price location on Y axis
+ * @param cl close price location on Y axis
+ * @param lineStart wick's top location on Y axis
+ * @param lineEnd wick's bottom location on Y axis
+ * @param name candle's direction: up | down | none
+ * @param candle original candle
+ * @param hasBorder flag denoting if border should be drawn
+ * @constructor
+ */
+export default class VisualCandle extends VisualSeriesPoint {
+    constructor(x, width, open, close, high, low, name, candle, hasBorder = false, isActive = false, isHollow = false) {
+        super(x, close);
+        this.startUnit = x - width / 2;
+        this.width = width;
+        this.open = open;
+        this.high = high;
+        this.low = low;
+        this.name = name;
+        this.candle = candle;
+        this.hasBorder = hasBorder;
+        this.isActive = isActive;
+        this.isHollow = isHollow;
+    }
+    /**
+     * Calculates the height of the body of a viewable element.
+     * @param {Viewable} viewable - The viewable element.
+     * @returns {Pixel} - The height of the body in pixels.
+     */
+    bodyHeight(viewable) {
+        return floorToDPR(Math.abs(viewable.toY(this.open) - viewable.toY(this.close)));
+    }
+    /**
+     * Calculates the height of a candle in pixels based on the high and low values of the candle and the viewable area.
+     *
+     * @param {Viewable} viewable - The viewable area object.
+     * @returns {Pixel} - The height of the candle in pixels.
+     */
+    candleHeight(viewable) {
+        return floorToDPR(Math.abs(viewable.toY(this.high) - viewable.toY(this.low)));
+    }
+    /**
+     * Returns coordinates of vertical line used to draw candle's body in case of small candle width
+     * @returns {[x,y,x2,y2]}
+     */
+    bodyAsVLine(viewable) {
+        if (this.width < 2) {
+            return [this.centerUnit, this.yLineStart(viewable), this.width, this.candleHeight(viewable)];
+        }
+    }
+    /**
+     * Returns rectangle used to draw candles' body
+     * @returns {[x,y,width,height]}
+     */
+    bodyRect(viewable) {
+        // candle is drawn using wick as center
+        return [this.startUnit, this.yBodyStart(viewable), this.width, this.bodyHeight(viewable)];
+    }
+    /**
+     * Returns the current candle object.
+     *
+     * @returns {Candle} The current candle object.
+     */
+    getCandle() {
+        return this.candle;
+    }
+    /**
+     * Returns candle Y points in ascending order
+     */
+    yBodyKeyPoints(viewable) {
+        const highY = floorToDPR(viewable.toY(this.high));
+        const lowY = floorToDPR(viewable.toY(this.low));
+        const openY = floorToDPR(viewable.toY(this.open));
+        const closeY = floorToDPR(viewable.toY(this.close));
+        const [bodyStart, bodyEnd] = openY > closeY ? [closeY, openY] : [openY, closeY];
+        const [lineStart, lineEnd] = highY > lowY ? [lowY, highY] : [highY, lowY];
+        return [lineStart, bodyStart, bodyEnd, lineEnd];
+    }
+    /**
+     * Calculates the y-coordinate of the end of a line segment that is within the viewable area.
+     * @param {Viewable} viewable - The viewable area object.
+     * @returns {Pixel} - The y-coordinate of the end of the line segment in pixels.
+     */
+    yLineEnd(viewable) {
+        return floorToDPR(Math.max(viewable.toY(this.high), viewable.toY(this.low)));
+    }
+    /**
+     * Returns the pixel value of the starting point of the y-axis line on the given viewable area.
+     * @param {Viewable} viewable - The viewable area to calculate the pixel value on.
+     * @returns {Pixel} - The pixel value of the starting point of the y-axis line.
+     */
+    yLineStart(viewable) {
+        return floorToDPR(Math.min(viewable.toY(this.high), viewable.toY(this.low)));
+    }
+    /**
+     * Calculates the starting y-coordinate of the body of a viewable object.
+     * @param {Viewable} viewable - The viewable object for which the starting y-coordinate of the body is to be calculated.
+     * @returns {Pixel} - The starting y-coordinate of the body of the viewable object.
+     */
+    yBodyStart(viewable) {
+        return floorToDPR(Math.min(viewable.toY(this.open), viewable.toY(this.close)));
+    }
+    /**
+     * Calculates the maximum pixel value of the y-coordinate of the viewable object's end point and the open and close values of the current object.
+     * @param {Viewable} viewable - The viewable object whose end point is to be compared with the open and close values of the current object.
+     * @returns {Pixel} - The maximum pixel value of the y-coordinate of the viewable object's end point and the open and close values of the current object.
+     */
+    yBodyEnd(viewable) {
+        return floorToDPR(Math.max(viewable.toY(this.open), viewable.toY(this.close)));
+    }
+    /**
+     * Calculates the x-coordinate of the center of a viewable object in pixels.
+     * @param {Viewable} viewable - The viewable object whose center is to be calculated.
+     * @returns {Pixel} - The x-coordinate of the center of the viewable object in pixels.
+     */
+    xCenter(viewable) {
+        return this.x(viewable);
+    }
+    /**
+     * Returns the starting pixel position of a viewable object
+     * @param {Viewable} viewable - The viewable object to get the starting pixel position from
+     * @returns {Pixel} - The starting pixel position of the viewable object
+     */
+    xStart(viewable) {
+        return roundToDPR(viewable.toX(this.startUnit));
+    }
+}

package/dist/chart/utils/__tests__/array.utils.test.d.ts

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2002 - 2023 Devexperts LLC
+ * Copyright (C) 2019 - 2023 Devexperts Solutions IE Limited
  * 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/.
  */