@nativescript-community/ui-chart 1.2.36 → 2.0.1

package/data/ChartData.js

@@ -1,9 +1,32 @@
 import { AxisDependency } from '../components/YAxis';
 export class ChartData {
+    /**
+     * Default constructor.
+     */
+    // public ChartData() {
+    //     this.mDataSets = [];
+    // }
+    /**
+     * Constructor taking single or multiple DataSet objects.
+     *
+     * @param dataSets
+     */
     constructor(dataSets) {
+        /**
+         * maximum y-value in the value array across all axes
+         */
         this.mYMax = -Infinity;
+        /**
+         * the minimum y-value in the value array across all axes
+         */
         this.mYMin = Infinity;
+        /**
+         * maximum x-value in the value array
+         */
         this.mXMax = -Infinity;
+        /**
+         * minimum x-value in the value array
+         */
         this.mXMin = Infinity;
         this.mLeftAxisMax = -Infinity;
         this.mLeftAxisMin = Infinity;
@@ -12,25 +35,63 @@ export class ChartData {
         this.mDataSets = dataSets || [];
         this.notifyDataChanged();
     }
+    // /**
+    //  * Created because Arrays.asList(...) does not support modification.
+    //  *
+    //  * @param array
+    //  * @return
+    //  */
+    // private List<T> arrayToList(T[] array) {
+    //     List<T> list = new ArrayList<>();
+    //     for (T set : array) {
+    //         list.add(set);
+    //     }
+    //     return list;
+    // }
+    // /**
+    //  * constructor for chart data
+    //  *
+    //  * @param sets the dataset array
+    //  */
+    // public ChartData(List<T> sets) {
+    //     this.mDataSets = sets;
+    //     notifyDataChanged();
+    // }
+    /**
+     * Call this method to let the ChartData know that the underlying data has
+     * changed. Calling this performs all necessary recalculations needed when
+     * the contained data has changed.
+     */
     notifyDataChanged() {
         this.calcMinMax();
     }
+    /**
+     * Calc minimum and maximum y-values over all DataSets.
+     * Tell DataSets to recalculate their min and max y-values, this is only needed for autoScaleMinMax.
+     *
+     * @param fromX the x-value to start the calculation from
+     * @param toX   the x-value to which the calculation should be performed
+     */
     calcMinMaxYRange(fromX, toX) {
         for (const set of this.mDataSets) {
             set.calcMinMaxYRange(fromX, toX);
         }
+        // apply the new data
         this.calcMinMax();
     }
+    /**
+     * Calc minimum and maximum values (both x and y) over all DataSets.
+     */
     calcMinMax() {
-        if (this.mDataSets == null)
+        if (!this.mDataSets)
             return;
         this.mYMax = -Infinity;
         this.mYMin = Infinity;
         this.mXMax = -Infinity;
         this.mXMin = Infinity;
-        const visibleDatasets = this.getVisibleDataSets();
+        const visibleDatasets = this.visibleDataSets;
         for (const set of visibleDatasets) {
-            if (set.isVisible()) {
+            if (set.visible) {
                 this.calcMinMaxForDataSet(set);
             }
         }
@@ -38,38 +99,50 @@ export class ChartData {
         this.mLeftAxisMin = Infinity;
         this.mRightAxisMax = -Infinity;
         this.mRightAxisMin = Infinity;
+        // left axis
         const firstLeft = this.getFirstLeft(visibleDatasets);
-        if (firstLeft != null) {
-            this.mLeftAxisMax = firstLeft.getYMax();
-            this.mLeftAxisMin = firstLeft.getYMin();
+        if (firstLeft) {
+            this.mLeftAxisMax = firstLeft.yMax;
+            this.mLeftAxisMin = firstLeft.yMin;
             for (const dataSet of visibleDatasets) {
-                if (dataSet.getAxisDependency() === AxisDependency.LEFT) {
-                    if (dataSet.getYMin() < this.mLeftAxisMin)
-                        this.mLeftAxisMin = dataSet.getYMin();
-                    if (dataSet.getYMax() > this.mLeftAxisMax)
-                        this.mLeftAxisMax = dataSet.getYMax();
+                if (dataSet.axisDependency === AxisDependency.LEFT) {
+                    if (dataSet.yMin < this.mLeftAxisMin)
+                        this.mLeftAxisMin = dataSet.yMin;
+                    if (dataSet.yMax > this.mLeftAxisMax)
+                        this.mLeftAxisMax = dataSet.yMax;
                 }
             }
         }
+        // right axis
         const firstRight = this.getFirstRight(visibleDatasets);
-        if (firstRight != null) {
-            this.mRightAxisMax = firstRight.getYMax();
-            this.mRightAxisMin = firstRight.getYMin();
+        if (firstRight) {
+            this.mRightAxisMax = firstRight.yMax;
+            this.mRightAxisMin = firstRight.yMin;
             for (const dataSet of visibleDatasets) {
-                if (dataSet.getAxisDependency() === AxisDependency.RIGHT) {
-                    if (dataSet.getYMin() < this.mRightAxisMin)
-                        this.mRightAxisMin = dataSet.getYMin();
-                    if (dataSet.getYMax() > this.mRightAxisMax)
-                        this.mRightAxisMax = dataSet.getYMax();
+                if (dataSet.axisDependency === AxisDependency.RIGHT) {
+                    if (dataSet.yMin < this.mRightAxisMin)
+                        this.mRightAxisMin = dataSet.yMin;
+                    if (dataSet.yMax > this.mRightAxisMax)
+                        this.mRightAxisMax = dataSet.yMax;
                 }
             }
         }
     }
-    getDataSetCount() {
-        if (this.mDataSets == null)
+    /** ONLY GETTERS AND SETTERS BELOW THIS */
+    /**
+     * returns the number of LineDataSets this object contains
+     */
+    get dataSetCount() {
+        if (!this.mDataSets)
             return 0;
         return this.mDataSets.length;
     }
+    /**
+     * Returns the minimum y-value for the specified axis.
+     *
+     * @param axis
+     * @return
+     */
     getYMin(axis) {
         if (axis === undefined) {
             return this.mYMin;
@@ -95,6 +168,18 @@ export class ChartData {
                 return this.mRightAxisMin;
         }
     }
+    get yMin() {
+        return this.mYMin;
+    }
+    get yMax() {
+        return this.mYMax;
+    }
+    /**
+     * Returns the maximum y-value for the specified axis.
+     *
+     * @param axis
+     * @return
+     */
     getYMax(axis) {
         if (axis === undefined) {
             return this.mYMax;
@@ -120,39 +205,68 @@ export class ChartData {
                 return this.mRightAxisMax;
         }
     }
-    getXMin() {
+    /**
+     * Returns the minimum x-value this data object contains.
+     */
+    get xMin() {
         return this.mXMin;
     }
-    getXMax() {
+    /**
+     * Returns the maximum x-value this data object contains.
+     */
+    get xMax() {
         return this.mXMax;
     }
-    getDataSets() {
+    /**
+     * Returns all DataSet objects this ChartData object holds.
+     */
+    get dataSets() {
         return this.mDataSets;
     }
-    getVisibleDataSets() {
-        return this.mDataSets.filter((s) => s.isVisible());
-    }
-    getDataSetIndexByLabel(dataSets, label, ignorecase) {
+    get visibleDataSets() {
+        return this.mDataSets.filter((s) => s.visible);
+    }
+    /**
+     * Retrieve the index of a DataSet with a specific label from the ChartData.
+     * Search can be case sensitive or not. IMPORTANT: This method does
+     * calculations at runtime, do not over-use in performance critical
+     * situations.
+     *
+     * @param dataSets   the DataSet array to search
+     * @param label
+     * @param ignorecase if true, the search is not case-sensitive
+     * @return
+     */
+    getDataSetIndexByLabel(dataSets, label, ignorecase = false) {
         if (ignorecase) {
             const toTest = label.toLowerCase();
             for (let i = 0; i < dataSets.length; i++)
-                if (toTest === dataSets[i].getLabel()?.toLowerCase())
+                if (toTest === dataSets[i].label?.toLowerCase())
                     return i;
         }
         else {
             for (let i = 0; i < dataSets.length; i++)
-                if (label === dataSets[i].getLabel())
+                if (label === dataSets[i].label)
                     return i;
         }
         return -1;
     }
+    /**
+     * Returns the labels of all DataSets as a string array.
+     */
     getDataSetLabels() {
         const types = [];
         for (let i = 0; i < this.mDataSets.length; i++) {
-            types[i] = this.mDataSets[i].getLabel();
+            types[i] = this.mDataSets[i].label;
         }
         return types;
     }
+    /**
+     * Get the Entry for a corresponding highlight object
+     *
+     * @param highlight
+     * @return the entry that is highlighted
+     */
     getEntryForHighlight(highlight) {
         if (highlight.entry) {
             return highlight.entry;
@@ -163,6 +277,12 @@ export class ChartData {
             return this.mDataSets[highlight.dataSetIndex].getEntryForXValue(highlight.x, highlight.y);
         }
     }
+    /**
+     * Get the Entry for a corresponding highlight object
+     *
+     * @param highlight
+     * @return the entry that is highlighted
+     */
     getEntryAndIndexForHighlight(highlight) {
         if (highlight.entry) {
             return { entry: highlight.entry, index: highlight.entryIndex };
@@ -173,7 +293,16 @@ export class ChartData {
             return this.mDataSets[highlight.dataSetIndex].getEntryAndIndexForXValue(highlight.x, highlight.y);
         }
     }
-    getDataSetByLabel(label, ignorecase) {
+    /**
+     * Returns the DataSet object with the given label. Search can be case
+     * sensitive or not. IMPORTANT: This method does calculations at runtime.
+     * Use with care in performance critical situations.
+     *
+     * @param label
+     * @param ignorecase
+     * @return
+     */
+    getDataSetByLabel(label, ignorecase = false) {
         const index = this.getDataSetIndexByLabel(this.mDataSets, label, ignorecase);
         if (index < 0 || index >= this.mDataSets.length)
             return null;
@@ -181,28 +310,48 @@ export class ChartData {
             return this.mDataSets[index];
     }
     getDataSetByIndex(index) {
-        if (this.mDataSets == null || index < 0 || index >= this.mDataSets.length)
+        if (!this.mDataSets || index < 0 || index >= this.mDataSets.length)
             return null;
         return this.mDataSets[index];
     }
+    /**
+     * Adds a DataSet dynamically.
+     *
+     * @param d
+     */
     addDataSet(d) {
-        if (d == null)
+        if (!d)
             return;
-        if (d.isVisible()) {
+        if (d.visible) {
             this.calcMinMaxForDataSet(d);
         }
         this.mDataSets.push(d);
     }
+    /**
+     * Removes the given DataSet from this data object. Also recalculates all
+     * minimum and maximum values. Returns true if a DataSet was removed, false
+     * if no DataSet could be removed.
+     *
+     * @param d
+     */
     removeDataSet(d) {
-        if (d == null)
+        if (!d)
             return false;
         const index = this.mDataSets.indexOf(d);
+        // if a DataSet was removed
         if (index >= 0) {
             this.mDataSets.splice(index, 1);
             this.calcMinMax();
         }
         return index >= 0;
     }
+    /**
+     * Removes the DataSet at the given index in the DataSet array from the data
+     * object. Also recalculates all minimum and maximum values. Returns true if
+     * a DataSet was removed, false if no DataSet could be removed.
+     *
+     * @param index
+     */
     removeDataSetAtIndex(index) {
         if (index >= this.mDataSets.length || index < 0)
             return false;
@@ -210,20 +359,34 @@ export class ChartData {
         this.calcMinMax();
         return true;
     }
+    /**
+     * Adds an Entry to the DataSet at the specified index.
+     * Entries are added to the end of the list.
+     *
+     * @param e
+     * @param dataSetIndex
+     */
     addEntry(e, dataSetIndex) {
         if (this.mDataSets.length > dataSetIndex && dataSetIndex >= 0) {
             const set = this.mDataSets[dataSetIndex];
-            const length = set.getEntryCount();
+            // add the entry to the dataset
+            const length = set.entryCount;
             if (!set.addEntry(e))
                 return;
-            if (set.isVisible()) {
-                this.calcMinMaxForEntry(set, e, length, set.getAxisDependency());
+            if (set.visible) {
+                this.calcMinMaxForEntry(set, e, length, set.axisDependency);
             }
         }
         else {
             console.error('addEntry', 'Cannot add Entry because dataSetIndex too high or too low.');
         }
     }
+    /**
+     * Adjusts the current minimum and maximum values based on the provided Entry object.
+     *
+     * @param e
+     * @param axis
+     */
     calcMinMaxForEntry(set, e, entryIndex, axis) {
         const xKey = set.xProperty;
         const yKey = set.yProperty;
@@ -250,33 +413,46 @@ export class ChartData {
                 this.mRightAxisMin = yValue;
         }
     }
+    /**
+     * Adjusts the minimum and maximum values based on the given DataSet.
+     *
+     * @param d
+     */
     calcMinMaxForDataSet(d) {
-        if (this.mYMax < d.getYMax())
-            this.mYMax = d.getYMax();
-        if (this.mYMin > d.getYMin())
-            this.mYMin = d.getYMin();
-        if (this.mXMax < d.getXMax())
-            this.mXMax = d.getXMax();
-        if (this.mXMin > d.getXMin())
-            this.mXMin = d.getXMin();
-        if (d.getAxisDependency() === AxisDependency.LEFT) {
-            if (this.mLeftAxisMax < d.getYMax())
-                this.mLeftAxisMax = d.getYMax();
-            if (this.mLeftAxisMin > d.getYMin())
-                this.mLeftAxisMin = d.getYMin();
+        if (this.mYMax < d.yMax)
+            this.mYMax = d.yMax;
+        if (this.mYMin > d.yMin)
+            this.mYMin = d.yMin;
+        if (this.mXMax < d.xMax)
+            this.mXMax = d.xMax;
+        if (this.mXMin > d.xMin)
+            this.mXMin = d.xMin;
+        if (d.axisDependency === AxisDependency.LEFT) {
+            if (this.mLeftAxisMax < d.yMax)
+                this.mLeftAxisMax = d.yMax;
+            if (this.mLeftAxisMin > d.yMin)
+                this.mLeftAxisMin = d.yMin;
         }
         else {
-            if (this.mRightAxisMax < d.getYMax())
-                this.mRightAxisMax = d.getYMax();
-            if (this.mRightAxisMin > d.getYMin())
-                this.mRightAxisMin = d.getYMin();
-        }
-    }
+            if (this.mRightAxisMax < d.yMax)
+                this.mRightAxisMax = d.yMax;
+            if (this.mRightAxisMin > d.yMin)
+                this.mRightAxisMin = d.yMin;
+        }
+    }
+    /**
+     * Removes the given Entry object from the DataSet at the specified index.
+     *
+     * @param e
+     * @param dataSetIndex
+     */
     removeEntry(e, dataSetIndex) {
-        if (e == null || dataSetIndex >= this.mDataSets.length)
+        // entry null, outofbounds
+        if (!e || dataSetIndex >= this.mDataSets.length)
             return false;
         const set = this.mDataSets[dataSetIndex];
-        if (set != null) {
+        if (set) {
+            // remove the entry from the dataset
             const removed = set.removeEntry(e);
             if (removed) {
                 this.calcMinMax();
@@ -286,51 +462,109 @@ export class ChartData {
         else
             return false;
     }
+    /**
+     * Removes the Entry object closest to the given DataSet at the
+     * specified index. Returns true if an Entry was removed, false if no Entry
+     * was found that meets the specified requirements.
+     *
+     * @param xValue
+     * @param dataSetIndex
+     * @return
+     */
     removeEntryForXValue(xValue, dataSetIndex) {
         if (dataSetIndex >= this.mDataSets.length)
             return false;
         const dataSet = this.mDataSets[dataSetIndex];
         const e = dataSet.getEntryForXValue(xValue, NaN);
-        if (e == null)
+        if (!e)
             return false;
         return this.removeEntry(e, dataSetIndex);
     }
+    /**
+     * Removes the Entry object closest to the given DataSet at the
+     * specified index. Returns true if an Entry was removed, false if no Entry
+     * was found that meets the specified requirements.
+     *
+     * @param xValue
+     * @param dataSetIndex
+     * @return
+     */
+    removeEntryAtIndex(index, dataSetIndex) {
+        // entry null, outofbounds
+        if (dataSetIndex >= this.mDataSets.length)
+            return false;
+        const set = this.mDataSets[dataSetIndex];
+        if (set) {
+            // remove the entry from the dataset
+            const removed = set.removeEntryAtIndex(index);
+            if (removed) {
+                this.calcMinMax();
+            }
+            return removed;
+        }
+        else
+            return false;
+    }
+    /**
+     * Returns the DataSet that contains the provided Entry, or null, if no
+     * DataSet contains this Entry.
+     *
+     * @param e
+     * @return
+     */
     getDataSetForEntry(e) {
-        if (e == null)
+        // WARNING: wont work if index is used as xKey(xKey not set)
+        if (!e)
             return null;
         for (let i = 0; i < this.mDataSets.length; i++) {
             const set = this.mDataSets[i];
             const xKey = set.xProperty;
             const yKey = set.yProperty;
+            // for (let j = 0; j < set.entryCount; j++) {
             if (e === set.getEntryForXValue(e[xKey], e[yKey]))
                 return set;
+            // }
         }
         return null;
     }
+    /**
+     * Returns the DataSet that contains the provided Entry and the entry index, or null, if no
+     * DataSet contains this Entry.
+     *
+     * @param e
+     * @return
+     */
     getDataSetAndIndexForEntry(e) {
-        if (e == null)
+        // WARNING: wont work if index is used as xKey(xKey not set)
+        if (!e)
             return null;
         for (let i = 0; i < this.mDataSets.length; i++) {
             const set = this.mDataSets[i];
             const xKey = set.xProperty;
             const yKey = set.yProperty;
             const r = set.getEntryAndIndexForXValue(e[xKey], e[yKey]);
+            // for (let j = 0; j < set.entryCount; j++) {
             if (e === r.entry)
                 return { set, index: r.index };
+            // }
         }
         return null;
     }
-    getColors() {
-        if (this.mDataSets == null)
+    /**
+     * Returns all colors used across all DataSet objects this object
+     * represents.
+     */
+    get colors() {
+        if (!this.mDataSets)
             return null;
         let clrcnt = 0;
         for (let i = 0; i < this.mDataSets.length; i++) {
-            clrcnt += this.mDataSets[i].getColors().length;
+            clrcnt += this.mDataSets[i].colors.length;
         }
         const colors = [];
         let cnt = 0;
         for (let i = 0; i < this.mDataSets.length; i++) {
-            const clrs = this.mDataSets[i].getColors();
+            const clrs = this.mDataSets[i].colors;
             for (const clr of clrs) {
                 colors[cnt] = clr;
                 cnt++;
@@ -338,91 +572,162 @@ export class ChartData {
         }
         return colors;
     }
+    /**
+     * Returns the index of the provided DataSet in the DataSet array of this data object, or -1 if it does not exist.
+     *
+     * @param dataSet
+     * @return
+     */
     getIndexOfDataSet(dataSet) {
         return this.mDataSets.indexOf(dataSet);
     }
+    /**
+     * Returns the first DataSet from the datasets-array that has it's dependency on the left axis.
+     * Returns null if no DataSet with left dependency could be found.
+     */
     getFirstLeft(sets) {
         for (const dataSet of sets) {
-            if (dataSet.getAxisDependency() === AxisDependency.LEFT)
+            if (dataSet.axisDependency === AxisDependency.LEFT)
                 return dataSet;
         }
         return null;
     }
+    /**
+     * Returns the first DataSet from the datasets-array that has it's dependency on the right axis.
+     * Returns null if no DataSet with right dependency could be found.
+     */
     getFirstRight(sets) {
         for (const dataSet of sets) {
-            if (dataSet.getAxisDependency() === AxisDependency.RIGHT)
+            if (dataSet.axisDependency === AxisDependency.RIGHT)
                 return dataSet;
         }
         return null;
     }
-    setValueFormatter(f) {
-        if (f == null)
-            return;
-        else {
-            for (const set of this.mDataSets) {
-                set.setValueFormatter(f);
-            }
+    /**
+     * Sets a custom IValueFormatter for all DataSets this data object contains.
+     *
+     * @param f
+     */
+    set valueFormatter(f) {
+        for (const set of this.mDataSets) {
+            set.valueFormatter = f;
         }
     }
-    setValueTextColor(color) {
+    /**
+     * Sets the color of the value-text (color in which the value-labels are
+     * drawn) for all DataSets this data object contains.
+     *
+     * @param color
+     */
+    set valueTextColor(color) {
         for (const set of this.mDataSets) {
-            set.setValueTextColor(color);
+            set.valueTextColor = color;
         }
     }
-    setValueTextColors(colors) {
+    /**
+     * Sets the same list of value-colors for all DataSets this
+     * data object contains.
+     *
+     * @param colors
+     */
+    set valueTextColors(colors) {
         for (const set of this.mDataSets) {
-            set.setValueTextColors(colors);
+            set.valueTextColors = colors;
         }
     }
-    setValueTypeface(tf) {
+    /**
+     * Sets the Typeface for all value-labels for all DataSets this data object
+     * contains.
+     *
+     * @param tf
+     */
+    set valueTypeface(tf) {
         for (const set of this.mDataSets) {
-            set.setValueTypeface(tf);
+            set.valueTypeface = tf;
         }
     }
-    setValueTextSize(size) {
+    /**
+     * Sets the size (in dp) of the value-text for all DataSets this data object
+     * contains.
+     *
+     * @param size
+     */
+    set valueTextSize(size) {
         for (const set of this.mDataSets) {
-            set.setValueTextSize(size);
+            set.valueTextSize = size;
         }
     }
-    setDrawValues(enabled) {
+    /**
+     * Enables / disables drawing values (value-text) for all DataSets this data
+     * object contains.
+     *
+     * @param enabled
+     */
+    set drawValuesEnabled(enabled) {
         for (const set of this.mDataSets) {
-            set.setDrawValues(enabled);
+            set.drawValuesEnabled = enabled;
         }
     }
+    /**
+     * Enables / disables highlighting values for all DataSets this data object
+     * contains. If set to true, this means that values can
+     * be highlighted programmatically or by touch gesture.
+     */
     setHighlightEnabled(enabled) {
         for (const set of this.mDataSets) {
-            set.setHighlightEnabled(enabled);
+            set.highlightEnabled = enabled;
         }
     }
-    isHighlightEnabled() {
+    /**
+     * Returns true if highlighting of all underlying values is enabled, false
+     * if not.
+     */
+    get highlightEnabled() {
         for (const set of this.mDataSets) {
-            if (!set.isHighlightEnabled())
+            if (!set.highlightEnabled)
                 return false;
         }
         return true;
     }
+    /**
+     * Clears this data object from all DataSets and removes all Entries. Don't
+     * forget to invalidate the chart after this.
+     */
     clearValues() {
-        if (this.mDataSets != null) {
+        if (this.mDataSets) {
             this.mDataSets = [];
         }
         this.notifyDataChanged();
     }
+    /**
+     * Checks if this data object contains the specified DataSet. Returns true
+     * if so, false if not.
+     *
+     * @param dataSet
+     * @return
+     */
     contains(dataSet) {
         return this.mDataSets.indexOf(dataSet) >= 0;
     }
-    getEntryCount() {
+    /**
+     * Returns the total entry count across all DataSet objects this data object contains.
+     */
+    get entryCount() {
         let count = 0;
         for (const set of this.mDataSets) {
-            count += set.getEntryCount();
+            count += set.entryCount;
         }
         return count;
     }
-    getMaxEntryCountSet() {
-        if (this.mDataSets == null || this.mDataSets.length === 0)
+    /**
+     * Returns the DataSet object with the maximum number of entries or null if there are no DataSets.
+     */
+    get maxEntryCountSet() {
+        if (!this.mDataSets || this.mDataSets.length === 0)
             return null;
         let max = this.mDataSets[0];
         for (const set of this.mDataSets) {
-            if (set.getEntryCount() > max.getEntryCount())
+            if (set.entryCount > max.entryCount)
                 max = set;
         }
         return max;