@nativescript-community/ui-chart 1.2.36 → 2.0.1

package/utils/Utils.d.ts

@@ -1,61 +1,170 @@
-import { Canvas, FontMetrics, Matrix, Paint, Path, RectF } from '@nativescript-community/ui-canvas';
 import { TypedArray, arrayToNativeArray as arrayToNativeArrayFn, createArrayBuffer as createArrayBufferFn, createArrayBufferOrNativeArray as createArrayBufferOrNativeArrayFn, createNativeArray as createNativeArrayFn, nativeArrayToArray as nativeArrayToArrayFn, pointsFromBuffer as pointsFromBufferFn, supportsDirectArrayBuffers as supportsDirectArrayBuffersFn } from '@nativescript-community/arraybuffers';
-import Shape from '@nativescript-community/ui-canvas/shapes/shape';
-import { ImageSource, ObservableArray } from '@nativescript/core';
-import { Chart } from '../charts/Chart';
+import { Canvas, FontMetrics, Matrix, Paint, Path, RectF } from '@nativescript-community/ui-canvas';
+import { ObservableArray } from '@nativescript/core';
 import { DefaultValueFormatter } from '../formatter/DefaultValueFormatter';
 import { ValueFormatter } from '../formatter/ValueFormatter';
+import { MPPointF } from './MPPointF';
+import { MPSize } from './MPSize';
 export declare const ChartTraceCategory = "NativescriptChart";
-declare global {
-    const __runtimeVersion: string;
-}
 export declare enum CLogTypes {
-    log,
-    info,
-    warning,
-    error
+    log = 0,
+    info = 1,
+    warning = 2,
+    error = 3
 }
 export declare const CLog: (type: CLogTypes, ...args: any[]) => void;
+/**
+ * Utilities class that has some helper methods. Needs to be initialized by
+ * calling Utils.init(...) before usage. Inside the Chart.init() method, this is
+ * done, if the Utils are used before that, Utils.init(...) needs to be called
+ * manually.
+ *
+
+ */
 export declare namespace Utils {
     const density: number;
     const DEG2RAD: number;
     const RAD2DEG: number;
     const NUMBER_EPSILON: number;
-    function init(context: any): void;
+    /**
+     * initialize method, called inside the Chart.init() method.
+     *
+     * @param context
+     */
+    function init(): void;
+    /**
+     * This method converts dp unit to equivalent pixels, depending on device
+     * density. NEEDS UTILS TO BE INITIALIZED BEFORE USAGE.
+     *
+     * @param dp A value in dp (density independent pixels) unit. Which we need
+     *           to convert into pixels
+     * @return A let value to represent px equivalent to dp depending on
+     * device density
+     */
     function convertDpToPixel(dp: any): number;
+    /**
+     * This method converts device specific pixels to density independent
+     * pixels. NEEDS UTILS TO BE INITIALIZED BEFORE USAGE.
+     *
+     * @param px A value in px (pixels) unit. Which we need to convert into db
+     * @return A let value to represent dp equivalent to px value
+     */
     function convertPixelsToDp(px: any): any;
+    /**
+     * calculates the approximate width of a text, depending on a demo text
+     * avoid repeated calls (e.g. inside drawing methods)
+     *
+     * @param paint
+     * @param demoText
+     * @return
+     */
     function calcTextWidth(paint: Paint, demoText: string): number;
+    /**
+     * calculates the approximate height of a text, depending on a demo text
+     * avoid repeated calls (e.g. inside drawing methods)
+     *
+     * @param paint
+     * @param demoText
+     * @return
+     */
     function calcTextHeight(paint: Paint, demoText: string): number;
     function getLineHeightFromMetrics(fontMetrics: FontMetrics): number;
     function getLineHeight(paint: Paint, fontMetrics?: FontMetrics): number;
     function getLineSpacingFromMetrics(fontMetrics: FontMetrics): number;
     function getLineSpacing(paint: Paint, fontMetrics?: FontMetrics): number;
+    /**
+     * calculates the approximate size of a text, depending on a demo text
+     * avoid repeated calls (e.g. inside drawing methods)
+     *
+     * @param paint
+     * @param demoText
+     * @param outputFSize An output variable, modified by the function.
+     */
     function calcTextSize(paint: Paint, demoText: any): {
         width: number;
         height: number;
     };
     function generateDefaultValueFormatter(): DefaultValueFormatter;
     function getDefaultValueFormatter(): ValueFormatter;
+    /**
+     * Formats the given number to the given number of decimals, and returns the
+     * number as a string, maximum 35 characters.
+     *
+     * @param number
+     * @param digitCount
+     * @param separateThousands set this to true to separate thousands values
+     * @param separateChar      a caracter to be paced between the "thousands"
+     * @return
+     */
     function formatNumber(number: any, digitCount: any, separateThousands: any, separateChar?: string): string;
+    /**
+     * rounds the given number to the next significant number
+     *
+     * @param number
+     * @return
+     */
     function roundToNextSignificant(number: any): number;
+    /**
+     * Returns the appropriate number of decimals to be used for the provided
+     * number.
+     *
+     * @param number
+     * @return
+     */
     function getDecimals(number: any): number;
+    /**
+     * Replacement for the Math.nextUp(...) method that is only available in
+     * HONEYCOMB and higher. Dat's some seeeeek sheeet.
+     *
+     * @param d
+     * @return
+     */
     function nextUp(x: any): any;
     function toRadians(degrees: any): number;
+    /**
+     * Returns a recyclable MPPointF instance.
+     * Calculates the position around a center point, depending on the distance
+     * from the center, and the angle of the position around the center.
+     *
+     * @param center
+     * @param dist
+     * @param angle  in degrees, converted to radians internally
+     * @return
+     */
     function getPosition(center: any, dist: any, angle: any, outputPoint?: any): any;
+    /**
+     * returns an angle between 0 < 360 (not less than zero, less than 360)
+     */
     function getNormalizedAngle(angle: any): number;
-    function drawIcon(canvas: Canvas, chart: Chart<any, any, any>, icon: ImageSource | Shape, x: any, y: any): void;
-    function drawXAxisValue(c: Canvas, text: any, x: any, y: any, paint: Paint, anchor: any, angleDegrees: any): void;
-    function drawMultilineText(c: Canvas, textLayout: any, x: any, y: any, textpaint: Paint, anchor: any, angleDegrees: any, lineHeight: any): void;
-    function drawMultilineTextConstrained(c: Canvas, text: any, x: any, y: any, paint: Paint, constrainedToSize: any, anchor: any, angleDegrees: any, lineHeight: any): void;
+    function drawXAxisValue(c: Canvas, text: string, x: number, y: number, paint: Paint, anchor: MPPointF, angleDegrees: number): void;
+    function drawMultilineText(c: Canvas, textLayout: any, x: number, y: number, anchor: MPPointF, angleDegrees: number, lineHeight: number): void;
+    function drawMultilineTextConstrained(c: Canvas, text: string, x: number, y: number, paint: Paint, constrainedToSize: MPSize, anchor: MPPointF, angleDegrees: number, lineHeight: number): void;
+    /**
+     * Returns a recyclable FSize instance.
+     * Represents size of a rotated rectangle by degrees.
+     *
+     * @param rectangleWidth
+     * @param rectangleHeight
+     * @param degrees
+     * @return A Recyclable FSize instance
+     */
     function getSizeOfRotatedRectangleByDegrees(rectangleWidth: any, rectangleHeight: any, degrees: any): {
         width: number;
         height: number;
     };
+    /**
+     * Returns a recyclable FSize instance.
+     * Represents size of a rotated rectangle by radians.
+     *
+     * @param rectangleWidth
+     * @param rectangleHeight
+     * @param radians
+     * @return A Recyclable FSize instance
+     */
     function getSizeOfRotatedRectangleByRadians(rectangleWidth: any, rectangleHeight: any, radians: any): {
         width: number;
         height: number;
     };
-    function logMethod(target: any, key: any, descriptor: any): any;
     const supportsDirectArrayBuffers: typeof supportsDirectArrayBuffersFn;
     const createArrayBuffer: typeof createArrayBufferFn;
     const pointsFromBuffer: typeof pointsFromBufferFn;
@@ -71,7 +180,20 @@ export declare namespace Utils {
     function getTempPaint(): Paint;
     function getTemplatePaint(template: string): Paint;
     function clipPathSupported(): boolean;
+    /**
+     * Calculates the sum across all values of the given array.
+     *
+     * @param values
+     * @return
+     */
     function calcSum(values: number[]): number;
+    /**
+     * Calculates the sum of positive numbers and negative numbers separately,
+     * across all values of the given array.
+     *
+     * @param values
+     * @return
+     */
     function calcPosNegSum(values: number[]): {
         pos: number;
         neg: number;

package/utils/Utils.js

@@ -1,16 +1,15 @@
-import { Align, FontMetrics, Matrix, Paint, Path, Rect, RectF, StaticLayout, Style } from '@nativescript-community/ui-canvas';
 import { arrayToNativeArray as arrayToNativeArrayFn, createArrayBuffer as createArrayBufferFn, createArrayBufferOrNativeArray as createArrayBufferOrNativeArrayFn, createNativeArray as createNativeArrayFn, nativeArrayToArray as nativeArrayToArrayFn, pointsFromBuffer as pointsFromBufferFn, supportsDirectArrayBuffers as supportsDirectArrayBuffersFn } from '@nativescript-community/arraybuffers';
-import Shape from '@nativescript-community/ui-canvas/shapes/shape';
+import { Align, FontMetrics, LayoutAlignment, Matrix, Paint, Path, Rect, RectF, StaticLayout, Style } from '@nativescript-community/ui-canvas';
 import { ObservableArray, Trace } from '@nativescript/core';
 import { Screen } from '@nativescript/core/platform';
 import { DefaultValueFormatter } from '../formatter/DefaultValueFormatter';
 export const ChartTraceCategory = 'NativescriptChart';
 export var CLogTypes;
 (function (CLogTypes) {
-    CLogTypes[CLogTypes["log"] = Trace.messageType.log] = "log";
-    CLogTypes[CLogTypes["info"] = Trace.messageType.info] = "info";
-    CLogTypes[CLogTypes["warning"] = Trace.messageType.warn] = "warning";
-    CLogTypes[CLogTypes["error"] = Trace.messageType.error] = "error";
+    CLogTypes[CLogTypes["log"] = 0] = "log";
+    CLogTypes[CLogTypes["info"] = 1] = "info";
+    CLogTypes[CLogTypes["warning"] = 2] = "warning";
+    CLogTypes[CLogTypes["error"] = 3] = "error";
 })(CLogTypes || (CLogTypes = {}));
 export const CLog = (type, ...args) => {
     Trace.write(args.map((a) => (a && typeof a === 'object' ? JSON.stringify(a) : a)).join(' '), ChartTraceCategory, type);
@@ -22,9 +21,22 @@ function getSDK() {
     }
     return SDK_INT;
 }
+/**
+ * Utilities class that has some helper methods. Needs to be initialized by
+ * calling Utils.init(...) before usage. Inside the Chart.init() method, this is
+ * done, if the Utils are used before that, Utils.init(...) needs to be called
+ * manually.
+ *
+
+ */
 export var Utils;
 (function (Utils) {
+    // const mainScreen = screen.mainScreen;
     Utils.density = Screen.mainScreen.scale;
+    //    const mMetrics;
+    // const mMinimumFlingVelocity = 50;
+    // const mMaximumFlingVelocity = 8000;
+    // const DOUBLE_EPSILON = Number.EPSILON;
     Utils.DEG2RAD = Math.PI / 180.0;
     Utils.RAD2DEG = 180.0 / Math.PI;
     Utils.NUMBER_EPSILON = Number.EPSILON;
@@ -33,30 +45,67 @@ export var Utils;
     const mFontMetricsBuffer = new FontMetrics();
     const mCalcTextSizeRect = new Rect(0, 0, 0, 0);
     const mDefaultValueFormatter = generateDefaultValueFormatter();
+    /**
+     * Math.pow(...) is very expensive, so avoid calling it and create it
+     * yourself.
+     */
     const POW_10 = [1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000];
     const EPSILON = Math.pow(2, -52);
     const MAX_VALUE = (2 - EPSILON) * Math.pow(2, 1023);
     const MIN_VALUE = Math.pow(2, -1022);
-    function init(context) {
-        if (context == null) {
-            console.error('MPChartLib-Utils', 'Utils.init(...) PROVIDED CONTEXT OBJECT IS NULL');
-        }
-        else {
-        }
-    }
+    /**
+     * initialize method, called inside the Chart.init() method.
+     *
+     * @param context
+     */
+    function init() { }
     Utils.init = init;
+    /**
+     * This method converts dp unit to equivalent pixels, depending on device
+     * density. NEEDS UTILS TO BE INITIALIZED BEFORE USAGE.
+     *
+     * @param dp A value in dp (density independent pixels) unit. Which we need
+     *           to convert into pixels
+     * @return A let value to represent px equivalent to dp depending on
+     * device density
+     */
     function convertDpToPixel(dp) {
         return dp * Utils.density;
+        // return dp;
     }
     Utils.convertDpToPixel = convertDpToPixel;
+    /**
+     * This method converts device specific pixels to density independent
+     * pixels. NEEDS UTILS TO BE INITIALIZED BEFORE USAGE.
+     *
+     * @param px A value in px (pixels) unit. Which we need to convert into db
+     * @return A let value to represent dp equivalent to px value
+     */
     function convertPixelsToDp(px) {
         return px;
+        // return px / density;
     }
     Utils.convertPixelsToDp = convertPixelsToDp;
+    /**
+     * calculates the approximate width of a text, depending on a demo text
+     * avoid repeated calls (e.g. inside drawing methods)
+     *
+     * @param paint
+     * @param demoText
+     * @return
+     */
     function calcTextWidth(paint, demoText) {
         return paint.measureText(demoText);
     }
     Utils.calcTextWidth = calcTextWidth;
+    /**
+     * calculates the approximate height of a text, depending on a demo text
+     * avoid repeated calls (e.g. inside drawing methods)
+     *
+     * @param paint
+     * @param demoText
+     * @return
+     */
     function calcTextHeight(paint, demoText) {
         mCalcTextHeightRect.set(0, 0, 0, 0);
         paint.getTextBounds(demoText, 0, demoText.length, mCalcTextHeightRect);
@@ -81,6 +130,14 @@ export var Utils;
         return getLineSpacingFromMetrics(fontMetrics);
     }
     Utils.getLineSpacing = getLineSpacing;
+    /**
+     * calculates the approximate size of a text, depending on a demo text
+     * avoid repeated calls (e.g. inside drawing methods)
+     *
+     * @param paint
+     * @param demoText
+     * @param outputFSize An output variable, modified by the function.
+     */
     function calcTextSize(paint, demoText) {
         const r = mCalcTextSizeRect;
         r.set(0, 0, 0, 0);
@@ -95,10 +152,21 @@ export var Utils;
         return new DefaultValueFormatter(1);
     }
     Utils.generateDefaultValueFormatter = generateDefaultValueFormatter;
+    /// - returns: The default value formatter used for all chart components that needs a default
     function getDefaultValueFormatter() {
         return mDefaultValueFormatter;
     }
     Utils.getDefaultValueFormatter = getDefaultValueFormatter;
+    /**
+     * Formats the given number to the given number of decimals, and returns the
+     * number as a string, maximum 35 characters.
+     *
+     * @param number
+     * @param digitCount
+     * @param separateThousands set this to true to separate thousands values
+     * @param separateChar      a caracter to be paced between the "thousands"
+     * @return
+     */
     function formatNumber(number, digitCount, separateThousands, separateChar = '.') {
         const out = [];
         let neg = false;
@@ -126,10 +194,12 @@ export var Utils;
             lval = lval / 10;
             out[ind--] = digit + '0';
             charCount++;
+            // add decimal point
             if (charCount === digitCount) {
                 out[ind--] = ',';
                 charCount++;
                 decimalPointAdded = true;
+                // add thousand separators
             }
             else if (separateThousands && lval !== 0 && charCount > digitCount) {
                 if (decimalPointAdded) {
@@ -146,10 +216,12 @@ export var Utils;
                 }
             }
         }
+        // if number around zero (between 1 and -1)
         if (zero) {
             out[ind--] = '0';
             charCount += 1;
         }
+        // if the number is negative
         if (neg) {
             out[ind--] = '-';
             charCount += 1;
@@ -158,6 +230,12 @@ export var Utils;
         return out.slice(out.length - start).join('');
     }
     Utils.formatNumber = formatNumber;
+    /**
+     * rounds the given number to the next significant number
+     *
+     * @param number
+     * @return
+     */
     function roundToNextSignificant(number) {
         if (!Number.isFinite(number) || isNaN(number) || number === 0.0)
             return 0;
@@ -168,6 +246,13 @@ export var Utils;
         return shifted / magnitude;
     }
     Utils.roundToNextSignificant = roundToNextSignificant;
+    /**
+     * Returns the appropriate number of decimals to be used for the provided
+     * number.
+     *
+     * @param number
+     * @return
+     */
     function getDecimals(number) {
         const i = roundToNextSignificant(number);
         if (!Number.isFinite(i) || i === 0)
@@ -175,6 +260,13 @@ export var Utils;
         return Math.ceil(-Math.log10(i)) + 2;
     }
     Utils.getDecimals = getDecimals;
+    /**
+     * Replacement for the Math.nextUp(...) method that is only available in
+     * HONEYCOMB and higher. Dat's some seeeeek sheeet.
+     *
+     * @param d
+     * @return
+     */
     function nextUp(x) {
         if (x !== x) {
             return x;
@@ -211,6 +303,16 @@ export var Utils;
         return degrees * (pi / 180);
     }
     Utils.toRadians = toRadians;
+    /**
+     * Returns a recyclable MPPointF instance.
+     * Calculates the position around a center point, depending on the distance
+     * from the center, and the angle of the position around the center.
+     *
+     * @param center
+     * @param dist
+     * @param angle  in degrees, converted to radians internally
+     * @return
+     */
     function getPosition(center, dist, angle, outputPoint) {
         if (outputPoint) {
             outputPoint.x = center.x + dist * Math.cos(toRadians(angle));
@@ -223,41 +325,43 @@ export var Utils;
         };
     }
     Utils.getPosition = getPosition;
+    /**
+     * returns an angle between 0 < 360 (not less than zero, less than 360)
+     */
     function getNormalizedAngle(angle) {
         while (angle < 0)
             angle += 360;
         return angle % 360;
     }
     Utils.getNormalizedAngle = getNormalizedAngle;
-    function drawIcon(canvas, chart, icon, x, y) {
-        if (icon instanceof Shape) {
-            const availableWidth = canvas.getWidth();
-            const availableHeight = canvas.getHeight();
-            const width = icon.getWidth(availableWidth, availableHeight);
-            const height = icon.getHeight(availableWidth, availableHeight);
-            canvas.save();
-            canvas.translate(x - width / 2, y - height / 2);
-            icon.drawMyShapeOnCanvas(canvas, chart, availableWidth, availableHeight);
-            canvas.restore();
-        }
-        else {
-            const drawOffsetX = x - icon.width / 2;
-            const drawOffsetY = y - icon.height / 2;
-            canvas.drawBitmap(__ANDROID__ ? icon.android : icon, drawOffsetX, drawOffsetY, null);
-        }
-    }
-    Utils.drawIcon = drawIcon;
+    // const mDrawableBoundsCache = new Rect(0, 0, 0, 0);
+    // export function drawImage(canvas: Canvas, drawable: ImageSource, x, y, width, height) {
+    //     const drawOffsetx = x - width / 2;
+    //     const drawOffsety = y - height / 2;
+    //     drawable.copyBounds(mDrawableBoundsCache);
+    //     drawable.setBounds(this.mDrawableBoundsCache.left, this.mDrawableBoundsCache.top, this.mDrawableBoundsCache.left + width, this.mDrawableBoundsCache.top + width);
+    //     canvas.save();
+    //     // translate to the correct position and draw
+    //     canvas.translate(drawOffsetx, drawOffsety);
+    //     drawable.draw(canvas);
+    //     canvas.restore();
+    // }
     function drawXAxisValue(c, text, x, y, paint, anchor, angleDegrees) {
         let drawOffsetX = 0;
         let drawOffsetY = 0;
+        // Android does not snap the bounds to line boundaries,
+        // and draws from bottom to top.
+        // And we want to normalize it.
         drawOffsetY += -mFontMetricsBuffer.ascent;
         if (angleDegrees !== 0) {
             const lineHeight = getLineHeightFromMetrics(mFontMetricsBuffer);
             paint.getTextBounds(text, 0, text.length, mDrawTextRectBuffer);
+            // Move the text drawing rect in a way that it always rotates around its center
             drawOffsetX -= mDrawTextRectBuffer.width() * 0.5;
             drawOffsetY -= lineHeight * 0.5;
             let translateX = x;
             let translateY = y;
+            // Move the "outer" rect relative to the anchor, assuming its centered
             if (anchor.x !== 0.5 || anchor.y !== 0.5) {
                 const rotatedSize = getSizeOfRotatedRectangleByDegrees(mDrawTextRectBuffer.width(), lineHeight, angleDegrees);
                 translateX -= rotatedSize.width * (anchor.x - 0.5);
@@ -278,24 +382,35 @@ export var Utils;
             drawOffsetY += y;
             c.drawText(text, drawOffsetX, drawOffsetY, paint);
         }
+        // paint.setTextAlign(originalTextAlign);
     }
     Utils.drawXAxisValue = drawXAxisValue;
-    function drawMultilineText(c, textLayout, x, y, textpaint, anchor, angleDegrees, lineHeight) {
+    function drawMultilineText(c, textLayout, x, y, anchor, angleDegrees, lineHeight) {
         let drawOffsetX = 0;
         let drawOffsetY = 0;
         const drawWidth = textLayout.getWidth();
         const drawHeight = textLayout.getLineCount() * lineHeight;
+        // Android sometimes has pre-padding
         drawOffsetX -= mDrawTextRectBuffer.left;
+        // Android does not snap the bounds to line boundaries,
+        //  and draws from bottom to top.
+        // And we want to normalize it.
         drawOffsetY += drawHeight;
+        // To have a consistent point of reference, we always draw left-aligned
+        // Paint.Align originalTextAlign = paint.getTextAlign();
+        // paint.setTextAlign(Paint.Align.LEFT);
         if (angleDegrees !== 0) {
+            // Move the text drawing rect in a way that it always rotates around its center
             drawOffsetX -= drawWidth * 0.5;
             drawOffsetY -= drawHeight * 0.5;
             let translateX = x;
             let translateY = y;
+            // Move the "outer" rect relative to the anchor, assuming its centered
             if (anchor.x !== 0.5 || anchor.y !== 0.5) {
                 const rotatedSize = getSizeOfRotatedRectangleByDegrees(drawWidth, drawHeight, angleDegrees);
                 translateX -= rotatedSize.width * (anchor.x - 0.5);
                 translateY -= rotatedSize.height * (anchor.y - 0.5);
+                // FSize.recycleInstance(rotatedSize);
             }
             c.save();
             c.translate(translateX, translateY);
@@ -316,18 +431,37 @@ export var Utils;
             textLayout.draw(c);
             c.restore();
         }
+        // paint.setTextAlign(originalTextAlign);
     }
     Utils.drawMultilineText = drawMultilineText;
     function drawMultilineTextConstrained(c, text, x, y, paint, constrainedToSize, anchor, angleDegrees, lineHeight) {
-        const textLayout = new StaticLayout(text, paint, Math.max(Math.ceil(constrainedToSize.width), 1), 0, 1, 0, false);
-        drawMultilineText(c, textLayout, x, y, paint, anchor, angleDegrees, lineHeight);
+        const textLayout = new StaticLayout(text, paint, Math.max(Math.ceil(constrainedToSize.width), 1), LayoutAlignment.ALIGN_NORMAL, 1, 0, false);
+        drawMultilineText(c, textLayout, x, y, anchor, angleDegrees, lineHeight);
     }
     Utils.drawMultilineTextConstrained = drawMultilineTextConstrained;
+    /**
+     * Returns a recyclable FSize instance.
+     * Represents size of a rotated rectangle by degrees.
+     *
+     * @param rectangleWidth
+     * @param rectangleHeight
+     * @param degrees
+     * @return A Recyclable FSize instance
+     */
     function getSizeOfRotatedRectangleByDegrees(rectangleWidth, rectangleHeight, degrees) {
         const radians = degrees * Utils.DEG2RAD;
         return getSizeOfRotatedRectangleByRadians(rectangleWidth, rectangleHeight, radians);
     }
     Utils.getSizeOfRotatedRectangleByDegrees = getSizeOfRotatedRectangleByDegrees;
+    /**
+     * Returns a recyclable FSize instance.
+     * Represents size of a rotated rectangle by radians.
+     *
+     * @param rectangleWidth
+     * @param rectangleHeight
+     * @param radians
+     * @return A Recyclable FSize instance
+     */
     function getSizeOfRotatedRectangleByRadians(rectangleWidth, rectangleHeight, radians) {
         return {
             width: Math.abs(rectangleWidth * Math.cos(radians)) + Math.abs(rectangleHeight * Math.sin(radians)),
@@ -335,29 +469,6 @@ export var Utils;
         };
     }
     Utils.getSizeOfRotatedRectangleByRadians = getSizeOfRotatedRectangleByRadians;
-    function logMethod(target, key, descriptor) {
-        if (descriptor === undefined) {
-            descriptor = Object.getOwnPropertyDescriptor(target, key);
-        }
-        const originalMethod = descriptor.value;
-        descriptor.value = function () {
-            const args = [];
-            for (let _i = 0; _i < arguments.length; _i++) {
-                args[_i - 0] = arguments[_i];
-            }
-            const a = args
-                .map(function (a) {
-                return JSON.stringify(a);
-            })
-                .join();
-            const result = originalMethod.apply(this, args);
-            const r = JSON.stringify(result);
-            console.log('Call: ' + key + '(' + a + ') => ' + r);
-            return result;
-        };
-        return descriptor;
-    }
-    Utils.logMethod = logMethod;
     Utils.supportsDirectArrayBuffers = supportsDirectArrayBuffersFn;
     Utils.createArrayBuffer = createArrayBufferFn;
     Utils.pointsFromBuffer = pointsFromBufferFn;
@@ -445,6 +556,7 @@ export var Utils;
             }
             case 'black-fill': {
                 paint = new Paint();
+                paint.setColor('black');
                 paint.setStyle(Style.FILL);
                 break;
             }
@@ -479,9 +591,15 @@ export var Utils;
         return true;
     }
     Utils.clipPathSupported = clipPathSupported;
+    /**
+     * Calculates the sum across all values of the given array.
+     *
+     * @param values
+     * @return
+     */
     function calcSum(values) {
         let sum = 0;
-        if (values == null) {
+        if (!values) {
             return sum;
         }
         for (const f of values) {
@@ -490,9 +608,16 @@ export var Utils;
         return sum;
     }
     Utils.calcSum = calcSum;
+    /**
+     * Calculates the sum of positive numbers and negative numbers separately,
+     * across all values of the given array.
+     *
+     * @param values
+     * @return
+     */
     function calcPosNegSum(values) {
         const sums = { pos: 0, neg: 0 };
-        if (values == null) {
+        if (!values) {
             return sums;
         }
         const sumNeg = 0;
@@ -509,7 +634,7 @@ export var Utils;
     }
     Utils.calcPosNegSum = calcPosNegSum;
     function calcSumToIndex(index, values, desc) {
-        if (values == null)
+        if (!values)
             return 0;
         let remainder = 0;
         let lastIndex = values.length - 1;