@devexperts/dxcharts-lite 1.0.1

package/dist/chart/model/scaling/auto-scale.model.d.ts

@@ -0,0 +1,79 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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 { Index, Unit, ViewportModel, ViewportModelState } from './viewport.model';
+/**
+ * Provides the high and low values. Used for series in auto-scale calculation.
+ */
+export interface HighLowProvider {
+    isHighLowActive: () => boolean;
+    /**
+     * Calculates the Y high and low.
+     * @param state - (optional) used to calculate over some state in future
+     */
+    calculateHighLow: (state?: ViewportModelState) => HighLow;
+}
+export interface HighLow {
+    high: Unit;
+    low: Unit;
+    highIdx?: Index;
+    lowIdx?: Index;
+}
+type HighLowPostProcessor = (highLow: HighLow) => HighLow;
+/**
+ * Auxiliary sub-model to apply X,Y auto-scaling feature.
+ * Transforms the original ViewportModel.
+ * @doc-tags auto-scale,viewport,scaling
+ */
+export declare class AutoScaleViewportSubModel {
+    private delegate;
+    auto: boolean;
+    highLowProviders: Record<string, HighLowProvider>;
+    highLowPostPorcessor: Record<string, HighLowPostProcessor>;
+    constructor(delegate: ViewportModel, highLowProviders?: Record<string, HighLowProvider>);
+    /**
+     * Sets a HighLowProvider for a given name.
+     * @param {string} name - The name of the HighLowProvider.
+     * @param {HighLowProvider} provider - The HighLowProvider to be set.
+     */
+    setHighLowProvider(name: string, provider: HighLowProvider): void;
+    /**
+     * Deletes a high-low provider from the list of high-low providers.
+     * @param {string} name - The name of the high-low provider to be deleted.
+     */
+    deleteHighLowProvider(name: string): void;
+    /**
+     * Sets a HighLowPostProcessor for a given name.
+     *
+     * @param {string} name - The name of the HighLowPostProcessor.
+     * @param {HighLowPostProcessor} processor - The HighLowPostProcessor to be set.
+     * @returns {void}
+     */
+    setHighLowPostProcessor(name: string, processor: HighLowPostProcessor): void;
+    /**
+     * Sets the auto and recalculates the state of the viewport model.
+     * @param {ViewportModelState} state - The state of the viewport model.
+     * @param {boolean} auto - The auto value to set.
+     * @returns {void}
+     */
+    setAutoAndRecalculateState(state: ViewportModelState, auto: boolean): void;
+}
+/**
+ * Y auto-scale viewport transformer. Calculates highLow for all chart visuals and recalculates the Y scale.
+ * @param vm
+ * @param state
+ * @param highLowProviders
+ * @param highLowPostProcessors
+ */
+export declare const autoScaleYViewportTransformer: (vm: ViewportModel, state: ViewportModelState, highLowProviders: HighLowProvider[], highLowPostProcessors: HighLowPostProcessor[]) => void;
+/**
+ * Merges an array of HighLow objects into a single HighLow object.
+ * @param {HighLow[]} input - The array of HighLow objects to be merged.
+ * @returns {HighLow} - The merged HighLow object.
+ 
+*/
+export declare function mergeHighLow(input: HighLow[]): HighLow;
+export declare const getDefaultHighLow: () => HighLow;
+export {};

package/dist/chart/model/scaling/auto-scale.model.js

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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 class AutoScaleViewportSubModel{constructor(o,e){this.delegate=o,this.auto=!0,this.highLowPostPorcessor={},this.highLowProviders=e!=null?e:{}}setHighLowProvider(o,e){this.highLowProviders[o]=e}deleteHighLowProvider(o){delete this.highLowProviders[o]}setHighLowPostProcessor(o,e){this.highLowPostPorcessor[o]=e}setAutoAndRecalculateState(o,e){this.auto=e,e&&autoScaleYViewportTransformer(this.delegate,o,Object.values(this.highLowProviders),Object.values(this.highLowPostPorcessor))}}export const autoScaleYViewportTransformer=(i,o,e,t)=>{const h=e.filter(r=>r.isHighLowActive()).map(r=>r.calculateHighLow(o)),l=mergeHighLow(h),s=t.reduce((r,c)=>c(r),l);o.yStart=s.low,o.yEnd=s.high,o.zoomY=i.calculateZoomY(o.yStart,o.yEnd)};export function mergeHighLow(i){if(i.length===0)return getDefaultHighLow();let o=i[0].high,e=i[0].low;return i.forEach(t=>{isFinite(t.high)&&t.high>=o&&(o=t.high),isFinite(t.low)&&t.low<=e&&(e=t.low)}),{low:e,high:o}}export const getDefaultHighLow=()=>({high:Number.MIN_SAFE_INTEGER,low:Number.MAX_SAFE_INTEGER});

package/dist/chart/model/scaling/constrait.functions.d.ts

@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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 { ChartConfigComponentsChart } from '../../chart.config';
+import { Bounds, BoundsProvider } from '../bounds.model';
+import VisualCandle from '../visual-candle';
+import { ViewportModelState } from './viewport.model';
+/**
+ * Return constraited state that handled zooming and moving chart near first/last candles
+ * this and other constraits that works with state should mutate and return state
+ * @param initialState
+ * @param state
+ * @param visualCandlesCoordinates
+ * @param candleLimit
+ * @param bounds
+ * @returns
+ * @doc-tags viewport,zoom,scaling
+ */
+export declare const candleEdgesConstrait: (state: ViewportModelState, visualCandlesCoordinates: VisualCandle[], candleLimit: number, bounds: Bounds) => {
+    xStart: number;
+    xEnd: number;
+    yStart: number;
+    yEnd: number;
+    zoomX: number;
+    zoomY: number;
+    inverseY: boolean;
+};
+/**
+ * This function limits minimum and maximum chart viewport dependening on visible x-units
+ * @returns
+ * @doc-tags viewport,zoom,scaling
+ */
+export declare const zoomConstraint: (initialState: ViewportModelState, state: ViewportModelState, chartConfig: ChartConfigComponentsChart, boundsProvider: BoundsProvider) => {
+    xStart: number;
+    xEnd: number;
+    yStart: number;
+    yEnd: number;
+    zoomX: number;
+    zoomY: number;
+    inverseY: boolean;
+};

package/dist/chart/model/scaling/constrait.functions.js

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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{at as S}from"../../utils/array.utils";import{calculateZoom as E,pixelsToUnits as w}from"./viewport.model";export const candleEdgesConstrait=(d,s,r,l)=>{var t,o,i,a;const n=Object.assign({},d),e=(o=(t=s[r])===null||t===void 0?void 0:t.startUnit)!==null&&o!==void 0?o:0,c=(a=(i=S(-r,s))===null||i===void 0?void 0:i.startUnit)!==null&&a!==void 0?a:0;let m=d.xStart,x=d.xEnd;return n.xStart>=c&&(m=c,x=x-(n.xStart-c)),n.xEnd<e&&(m=e-w(l.width,n.zoomX),x=e),n.xStart=m,n.xEnd=x,n},zoomConstraint=(d,s,r,l)=>{const t=Object.assign({},s),o=l(),i=t.xEnd-t.xStart,a=i<r.minCandles,n=o.width/r.minWidth,e=i>n;if(o.width>0){if(e)return t.xStart=t.xEnd-n,t.zoomX=E(t.xEnd-t.xStart,o.width),t;if(a)return t.xEnd=d.xEnd,t.xStart=t.xEnd-r.minCandles,t.zoomX=E(t.xEnd-t.xStart,o.width),t}return t};

package/dist/chart/model/scaling/lock-ratio.model.d.ts

@@ -0,0 +1,16 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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 { ViewportModelState, Zoom } from './viewport.model';
+export type ZoomXToZoomYRatio = number;
+export declare const ratioFromZoomXY: (zoomX: Zoom, zoomY: Zoom) => ZoomXToZoomYRatio;
+export declare const zoomXToZoomY: (zoomX: Zoom, ratio: ZoomXToZoomYRatio) => Zoom;
+export declare const zoomYToZoomX: (zoomY: Zoom, ratio: ZoomXToZoomYRatio) => Zoom;
+/**
+ * Locks the zoomY with zoomX and moves yEnd according to ratio changes.
+ * @param state
+ * @param zoomXYRatio
+ */
+export declare const lockedYEndViewportCalculator: (state: ViewportModelState, zoomXYRatio: ZoomXToZoomYRatio) => void;

package/dist/chart/model/scaling/lock-ratio.model.js

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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 ratioFromZoomXY=(o,n)=>o/n,zoomXToZoomY=(o,n)=>o/n,zoomYToZoomX=(o,n)=>o*n,lockedYEndViewportCalculator=(o,n)=>{const Y=o.zoomY;o.zoomY=zoomXToZoomY(o.zoomX,n);const c=o.zoomY/Y,m=o.yEnd-o.yStart,r=m*c-m;o.yEnd=o.yEnd+r};

package/dist/chart/model/scaling/move-chart.functions.d.ts

@@ -0,0 +1,20 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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 { Unit, ViewportModelState } from './viewport.model';
+/**
+ * Moves both xStart and xEnd without changing the viewport width (zoomX).
+ * @param state
+ * @param xStart - left starting point in units
+ * @doc-tags scaling,viewport
+ */
+export declare const moveXStart: (state: ViewportModelState, xStart: Unit) => void;
+/**
+ * Moves both yStart and yEnd without changing the viewport height (zoomY).
+ * @param state
+ * @param yStart - starting point in units
+ * @doc-tags scaling,viewport
+ */
+export declare const moveYStart: (state: ViewportModelState, yStart: Unit) => void;

package/dist/chart/model/scaling/move-chart.functions.js

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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 moveXStart=(n,o)=>{const r=n.xStart;n.xStart=o,n.xEnd=n.xEnd+(o-r)},moveYStart=(n,o)=>{const r=n.yStart;n.yStart=o,n.yEnd=n.yEnd+(o-r)};

package/dist/chart/model/scaling/viewport.model.d.ts

@@ -0,0 +1,223 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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 } from 'rxjs';
+import { ChartBaseElement } from '../chart-base-element';
+import { ViewportMovementAnimation } from '../../animation/types/viewport-movement-animation';
+import { Bounds } from '../bounds.model';
+export type Unit = number;
+export type Price = number;
+export type Pixel = number;
+export type Zoom = number;
+export declare const calculateZoom: (viewportUnits: Unit, viewportPixels: Pixel) => Zoom;
+export declare const unitToPixels: (units: Unit, zoom: Zoom) => Pixel;
+export declare const pixelsToUnits: (px: Pixel, zoom: Zoom) => Unit;
+export type Index = Unit;
+export type Timestamp = Unit;
+export type Percent = Unit;
+export type LogValue = Unit;
+export type YUnit = Price | Percent | LogValue;
+export declare const unitToPercent: (value: Unit, baseLine: Unit) => Percent;
+export declare const percentToUnit: (percent: Percent, baseLine: Unit) => Unit;
+export declare const calcLogValue: (value: Price) => LogValue;
+export declare const logValueToUnit: (logValue: LogValue) => number;
+/**
+ * This interface describes chart entity which transforms some units to pixel values.
+ * We need to separate this interface and viewport-model.
+ * Viewport model describes piece of chart viewport:
+ * - main chart pane
+ * - underlay study pane
+ *
+ * But sometimes in viewport we have units which are not the price (price is default unit for y-axis).
+ * In this case we need special logic to convert price to viewport units and this logic might vary for different chart entities.
+ * A good example is chart candle series:
+ * let's assume we use percents for as y-axis units, then each candle series will use their own logic to get percent unit from the price.
+ * Thus, we need to segregate interface of ViewportModel and Viewable interface.
+ * You can think of ViewportModel as a screen and Viewable as a figure which should be drawn on the screen.
+ */
+export interface Viewable {
+    toX(unit: Unit): Pixel;
+    toY(unit: Unit): Pixel;
+    xPixels(unit: Unit): Pixel;
+    yPixels(unit: Unit): Pixel;
+}
+/**
+ * Represents state of ViewportModel.
+ * When the model is calculated step-by-step, this state acts like an intermediate result.
+ * Only when all calculations are complete - we {@link ViewportModel#apply} result.
+ */
+export interface ViewportModelState {
+    xStart: Unit;
+    xEnd: Unit;
+    yStart: Unit;
+    yEnd: Unit;
+    zoomX: Zoom;
+    zoomY: Zoom;
+    inverseY: boolean;
+}
+/**
+ * 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 declare abstract class ViewportModel extends ChartBaseElement implements Viewable {
+    currentAnimation?: ViewportMovementAnimation;
+    private _xStart;
+    private _xEnd;
+    private _yStart;
+    private _yEnd;
+    private _zoomX;
+    private _zoomY;
+    private _inverseY;
+    /**
+     * An abstract method that returns the bounds of a chart, volumes, studies, etc.
+     * @returns {Bounds} The bounds of the specified element.
+     */
+    abstract getBounds(): Bounds;
+    changed: Subject<void>;
+    xChanged: import("rxjs").Observable<{
+        start: number;
+        end: number;
+    }>;
+    yChanged: import("rxjs").Observable<{
+        start: number;
+        end: number;
+    }>;
+    /**
+     * 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: Unit): Pixel;
+    /**
+     * 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: Unit): Pixel;
+    /**
+     * 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: Unit): Pixel;
+    /**
+     * 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: Unit): Pixel;
+    /**
+     * 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: Pixel): Unit;
+    /**
+     * 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: Pixel): Unit;
+    /**
+     * 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(): void;
+    /**
+     * 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(): void;
+    /**
+     * 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: Unit, end: Unit): Zoom;
+    /**
+     * 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: Unit, end: Unit): Zoom;
+    /**
+     * Should be called when x/y start/end changes.
+     */
+    recalculateZoom(fireChanged?: boolean): void;
+    /**
+     * 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: Unit, xEnd: Unit, fireChanged?: boolean): void;
+    /**
+     * 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: Unit, yEnd: Unit, fireChanged?: boolean): void;
+    /**
+     * Exports current state of VM.
+     */
+    export(): ViewportModelState;
+    /**
+     * Applies the state to current VM.
+     * @param state
+     */
+    apply(state: ViewportModelState): void;
+    /**
+     * Emits a notification that the object has changed.
+     * @function
+     * @name fireChanged
+     * @memberof ClassName
+     * @instance
+     * @returns {void}
+     */
+    fireChanged(): void;
+    get xStart(): Unit;
+    set xStart(value: Unit);
+    get xEnd(): Unit;
+    set xEnd(value: Unit);
+    get yStart(): Unit;
+    set yStart(value: Unit);
+    get yEnd(): Unit;
+    set yEnd(value: Unit);
+    get zoomX(): Zoom;
+    set zoomX(value: Zoom);
+    get zoomY(): Zoom;
+    set zoomY(value: Zoom);
+    get inverseY(): boolean;
+    set inverseY(value: boolean);
+    /**
+     * Checks if the viewport is valid.
+     *
+     * @returns {boolean} - Returns true if the viewport is valid, false otherwise.
+     */
+    isViewportValid(): boolean;
+}
+export declare const compareStates: (a: ViewportModelState, b: ViewportModelState) => boolean;

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

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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]);

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

@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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 { ViewportModel, ViewportModelState } from './viewport.model';
+import { ViewportPercent } from '../scale.model';
+/**
+ * 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 declare const zoomXToPercentViewportCalculator: (vm: ViewportModel, state: ViewportModelState, viewportPercent: ViewportPercent, zoomStrength: number, zoomIn: boolean) => ViewportModelState;
+/**
+ * Zooms to viewports end.
+ * @param vm
+ * @param state
+ * @param zoomStrength - 0..1 number, 1=max strength
+ * @param zoomIn
+ * @doc-tags viewport,zoom,scaling
+ */
+export declare const zoomXToEndViewportCalculator: (vm: ViewportModel, state: ViewportModelState, zoomStrength: number, zoomIn: boolean) => ViewportModelState;

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

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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);

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

@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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 getTimezoneOffsetDateFnsTz } from 'date-fns-tz';
+import { Observable } from 'rxjs';
+import { DateFormatter, FullChartConfig } from '../chart.config';
+import { DateTimeFormatter, DateTimeFormatterFactory } from './date-time.formatter';
+import { Timestamp } from './scaling/viewport.model';
+export interface TimeZone {
+    readonly timeZone: string;
+    readonly name: string;
+    readonly utcOffset: string;
+}
+export declare const memoizedTZOffset: typeof getTimezoneOffsetDateFnsTz;
+export declare const getTimezoneOffset: (timezone: string, time: Timestamp) => number;
+export declare class TimeZoneModel {
+    private config;
+    private timeZoneChangedSubject;
+    private dateTimeFormatterFactory;
+    currentTzOffset: (time: Timestamp) => number;
+    constructor(config: FullChartConfig);
+    /**
+     * Sets the timezone for the configuration and updates the current timezone offset.
+     * @param {string} timeZone - The timezone to set.
+     * @returns {void}
+     */
+    setTimeZone(timeZone: string): void;
+    /**
+     * 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(): Observable<string>;
+    /**
+     * 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?: DateFormatter): DateTimeFormatterFactory;
+    /**
+     * Returns the DateTimeFormatterFactory instance used by this class.
+     *
+     * @returns {DateTimeFormatterFactory} The DateTimeFormatterFactory instance used by this class.
+     */
+    getFormatterFactory(): DateTimeFormatterFactory;
+    private formatterCache;
+    getDateTimeFormatter(format: string): DateTimeFormatter;
+    /**
+     * Calculates the offset of a given timezone from the local timezone.
+     * @private
+     * @param {string} timezone - The timezone to calculate the offset for.
+     */
+    private getOffset;
+    /**
+     * Gets the timezone offset value in milliseconds
+     * @param {string} timezone name
+     * @returns {function(time:Number):Date}
+     */
+    tzOffset(timezone: string): (time: number) => Date;
+}

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

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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;

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

@@ -0,0 +1,106 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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 { Candle } from './candle.model';
+import { Pixel, Unit, Viewable } from './scaling/viewport.model';
+import { PriceMovement } from './candle-series.model';
+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 {
+    width: Unit;
+    high: Unit;
+    low: Unit;
+    open: Unit;
+    name: PriceMovement;
+    candle: Candle;
+    startUnit: Unit;
+    hasBorder: boolean;
+    isActive: boolean;
+    isHollow: boolean;
+    constructor(x: number, width: number, open: number, close: number, high: number, low: number, name: PriceMovement, candle: Candle, hasBorder?: boolean, isActive?: boolean, isHollow?: boolean);
+    /**
+     * 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: Viewable): Pixel;
+    /**
+     * 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: Viewable): Pixel;
+    /**
+     * Returns coordinates of vertical line used to draw candle's body in case of small candle width
+     * @returns {[x,y,x2,y2]}
+     */
+    bodyAsVLine(viewable: Viewable): [number, number, number, number] | undefined;
+    /**
+     * Returns rectangle used to draw candles' body
+     * @returns {[x,y,width,height]}
+     */
+    bodyRect(viewable: Viewable): [number, number, number, number];
+    /**
+     * Returns the current candle object.
+     *
+     * @returns {Candle} The current candle object.
+     */
+    getCandle(): Candle;
+    /**
+     * Returns candle Y points in ascending order
+     */
+    yBodyKeyPoints(viewable: Viewable): [Pixel, Pixel, Pixel, Pixel];
+    /**
+     * 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: Viewable): Pixel;
+    /**
+     * 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: Viewable): Pixel;
+    /**
+     * 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: Viewable): Pixel;
+    /**
+     * 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: Viewable): Pixel;
+    /**
+     * 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: Viewable): Pixel;
+    /**
+     * 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: Viewable): Pixel;
+}

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

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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))}}