@colijnit/ioneconnector 3.1.18 → 3.1.20

package/build/utils/number-utils.js

@@ -1,269 +1,269 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NumberUtils = void 0;
-const object_utils_1 = require("./object-utils");
-const array_utils_1 = require("./array-utils");
-const not_nill_function_1 = require("./function/not-nill.function");
-const is_nill_function_1 = require("./function/is-nill.function");
-class NumberUtils {
-    static ParseIntNumberInput(arg) {
-        return NumberUtils.ParseInt(NumberUtils._NumberInputToNumberStr(arg));
-    }
-    static ParseInt(arg) {
-        if ((0, is_nill_function_1.isNill)(arg) || Array.isArray(arg)) {
-            return undefined;
-        }
-        return parseInt(arg, 10);
-    }
-    static ParseFloatNumberInput(arg, decimalPrecision = 2) {
-        return NumberUtils.ParseFloat(NumberUtils._NumberInputToNumberStr(arg), decimalPrecision);
-    }
-    static ParseFloatNumberInputKeepPrecision(arg) {
-        const correctedInputStr = NumberUtils._NumberInputToNumberStr(arg);
-        const decimalPrecision = this.GetDecimalPlaces(correctedInputStr);
-        return NumberUtils.ParseFloat(correctedInputStr, decimalPrecision);
-    }
-    static ParseFloat(arg, decimalPrecision = 2) {
-        if (!object_utils_1.ObjectUtils.AllExist(arg, decimalPrecision) || Array.isArray(arg)) {
-            return NaN;
-        }
-        if (!NumberUtils.IsInteger(decimalPrecision) || decimalPrecision < 0) {
-            decimalPrecision = 2;
-        }
-        else if (decimalPrecision > 20) {
-            decimalPrecision = 20;
-        }
-        return parseFloat(parseFloat(arg).toFixed(decimalPrecision));
-    }
-    static ParseFloatKeepPrecision(arg) {
-        const decimalPrecision = this.GetDecimalPlaces(arg);
-        return this.ParseFloat(arg, decimalPrecision);
-    }
-    static ParseNumberOrDefault(arg, defaultValue = 0) {
-        if (Array.isArray(arg)) {
-            return defaultValue;
-        }
-        if (!NumberUtils.IsNumber(arg)) {
-            arg = parseFloat(arg);
-            arg = isNaN(arg) ? defaultValue : arg;
-        }
-        return arg;
-    }
-    static IsInteger(arg) {
-        if (isNaN(arg) || Array.isArray(arg)) {
-            return false;
-        }
-        const argAsFloat = parseFloat(arg);
-        return ((argAsFloat | 0) === argAsFloat);
-    }
-    static GetDecimalPlaces(arg, maxAnswer = 1000) {
-        const match = ("" + arg).match(/(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/);
-        if (!match) {
-            return 0;
-        }
-        let answer = Math.max(0, (match[1] ? match[1].length : 0)
-            - (match[2] ? +match[2] : 0));
-        if (answer > maxAnswer) {
-            answer = maxAnswer;
-        }
-        return answer;
-    }
-    static ParseNumberInputOrDefault(numberInput, defaultValue = 0) {
-        return NumberUtils.ParseNumberOrDefault(NumberUtils._NumberInputToNumberStr(numberInput), defaultValue);
-    }
-    static IsNumber(arg) {
-        return typeof arg === "number" && !isNaN(arg);
-    }
-    static IsNaN(arg) {
-        return isNaN(arg) || !NumberUtils.IsNumber(arg);
-    }
-    static NaN(number, substitute = 0) {
-        return NumberUtils.IsNaN(number) ? substitute : number;
-    }
-    static IsParsableNumber(arg) {
-        if (Array.isArray(arg)) {
-            return false;
-        }
-        return !isNaN(parseFloat(arg));
-    }
-    static IsParsableNumberInput(numberInput) {
-        return NumberUtils.IsParsableNumber(NumberUtils._NumberInputToNumberStr(numberInput));
-    }
-    static IsStringNumber(arg) {
-        if (!NumberUtils.IsParsableNumber(arg)) {
-            return false;
-        }
-        else {
-            return arg.toString().length === parseFloat(arg).toString().length;
-        }
-    }
-    static IsListOfNumbers(arg, separator = ",") {
-        const nrs = arg.split(separator);
-        if (nrs.length === 0) {
-            return false;
-        }
-        return nrs.filter(s => NumberUtils.IsStringNumber(s)).length === nrs.length;
-    }
-    static ParseStringNumber(arg) {
-        if (!this.IsStringNumber(arg)) {
-            return NaN;
-        }
-        return NumberUtils.ParseFloatKeepPrecision(arg);
-    }
-    static ParseStringNumberDefault(arg, defaultValue = 0) {
-        return NumberUtils.NaN(NumberUtils.ParseStringNumber(arg), defaultValue);
-    }
-    static RandomInt(lowerBoundInt, upperBoundInt) {
-        if (!NumberUtils.IsNumber(lowerBoundInt) || !NumberUtils.IsNumber(upperBoundInt) || lowerBoundInt > upperBoundInt) {
-            return NaN;
-        }
-        lowerBoundInt = Math.trunc(lowerBoundInt);
-        upperBoundInt = Math.trunc(upperBoundInt);
-        if (lowerBoundInt === upperBoundInt) {
-            return lowerBoundInt;
-        }
-        const delta = upperBoundInt - lowerBoundInt;
-        return (Math.round(Math.random() * delta) + lowerBoundInt);
-    }
-    static AddThousandsCommasTo(value) {
-        if ((0, is_nill_function_1.isNill)(value)) {
-            return "";
-        }
-        return value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
-    }
-    static NumIsComposedOfOtherPowTwoNum(bigNrToCheck, powTwoNumItShouldBeComposedOf) {
-        if (!bigNrToCheck) {
-            return false;
-        }
-        else if (!powTwoNumItShouldBeComposedOf) {
-            return true;
-        }
-        else {
-            return ((bigNrToCheck & powTwoNumItShouldBeComposedOf) === powTwoNumItShouldBeComposedOf);
-        }
-    }
-    static NrOrDefault(nr, defaultNr = 0) {
-        if ((0, not_nill_function_1.notNill)(nr) && NumberUtils.IsNumber(nr)) {
-            return nr;
-        }
-        else {
-            return defaultNr;
-        }
-    }
-    static CheckPrecisionAndScale(nrToCheck, precision, scale = 0) {
-        if (!object_utils_1.ObjectUtils.AllExist(nrToCheck, precision, scale)) {
-            return { isOk: true, nearestOkNr: NaN };
-        }
-        if (precision < 1 || precision - scale < 1) {
-            return { isOk: false, nearestOkNr: NaN };
-        }
-        const isNegative = (nrToCheck < 0);
-        const nrParts = nrToCheck.toString().split(".");
-        if (isNegative) {
-            nrParts[0] = nrParts[0].slice(1);
-        }
-        const numCountBeforeDot = nrParts[0].length;
-        const allowedNumCountBeforeDot = precision - scale;
-        if (numCountBeforeDot <= allowedNumCountBeforeDot) {
-            return { isOk: true, nearestOkNr: nrToCheck };
-        }
-        else {
-            const numCountToRemove = numCountBeforeDot - allowedNumCountBeforeDot;
-            nrParts[0] = nrParts[0].slice(0, -1 * numCountToRemove);
-            if (isNegative) {
-                nrParts[0] = "-" + nrParts[0];
-            }
-            let nearestOkNr;
-            if (nrParts[1]) {
-                nearestOkNr = Number(nrParts[0] + "." + nrParts[1]);
-            }
-            else {
-                nearestOkNr = Number(nrParts[0]);
-            }
-            return { isOk: false, nearestOkNr: nearestOkNr };
-        }
-    }
-    static CheckWithinSteppedBounds(nrToCheck, min, max, stepSize = 1) {
-        if (nrToCheck < min || nrToCheck > max) {
-            return { isOk: false, remainder: undefined };
-        }
-        let remainder = (nrToCheck - min) % stepSize;
-        remainder = NumberUtils.ParseFloat(remainder, NumberUtils._GetLargestDecimalPrecisionOf(nrToCheck, min, stepSize));
-        return { isOk: (remainder === 0), remainder: remainder };
-    }
-    static GetNearestNumberWithinSteppedBounds(originalNr, min, max, stepSize = 1) {
-        if (originalNr < min) {
-            return min;
-        }
-        else if (originalNr > max) {
-            return NumberUtils.GetTrueSteppedBoundsMax(min, max, stepSize);
-        }
-        const boundsCheck = NumberUtils.CheckWithinSteppedBounds(originalNr, min, max, stepSize);
-        if (boundsCheck.isOk) {
-            return originalNr;
-        }
-        let answer;
-        const remainder = boundsCheck.remainder;
-        if (remainder) {
-            if ((remainder / stepSize) < 0.5) {
-                answer = (originalNr - remainder >= min ? originalNr - remainder : min);
-            }
-            else {
-                answer = (originalNr + stepSize - remainder <= max ? originalNr + stepSize - remainder :
-                    NumberUtils.GetTrueSteppedBoundsMax(min, max, stepSize));
-            }
-        }
-        else {
-            answer = originalNr;
-        }
-        answer = NumberUtils.ParseFloat(answer, NumberUtils._GetLargestDecimalPrecisionOf(originalNr, min, max, stepSize));
-        return answer;
-    }
-    static GetTrueSteppedBoundsMax(min, max, stepSize = 1) {
-        const maxSteps = Math.floor((max - min) / stepSize);
-        return NumberUtils.ParseFloat(min + maxSteps * stepSize, NumberUtils._GetLargestDecimalPrecisionOf(min, min, max));
-    }
-    static GetNearestNumberWithinBounds(originalNr, min, max) {
-        let answer = originalNr;
-        if (originalNr < min) {
-            answer = min;
-        }
-        else if (originalNr > max) {
-            answer = max;
-        }
-        return answer;
-    }
-    static ToString(nr) {
-        if (!NumberUtils.IsNaN(nr)) {
-            return "" + nr;
-        }
-        else {
-            return "";
-        }
-    }
-    static DecimalsToStepIncrement(numberOfDecimals) {
-        return parseFloat(Math.pow(10, -1 * numberOfDecimals).toFixed(numberOfDecimals));
-    }
-    static Round(value, decimals) {
-        const factor = Math.pow(10, decimals);
-        return Math.round(value * factor) / factor;
-    }
-    static PrecisionScaleToMaxValue(precision, scale) {
-        const oneStep = this.DecimalsToStepIncrement(scale);
-        const maxExclusive = Math.pow(10, precision - scale);
-        return maxExclusive - oneStep;
-    }
-    static DifferenceBetweenNumbers(numberA, numberB) {
-        return Math.abs(numberA - numberB);
-    }
-    static _GetLargestDecimalPrecisionOf(...args) {
-        return array_utils_1.ArrayUtils.GetMaxCalculatedValue(args, (arg) => {
-            return NumberUtils.GetDecimalPlaces(arg);
-        });
-    }
-    static _NumberInputToNumberStr(numberInput) {
-        return (numberInput + "").replace(",", ".");
-    }
-}
-exports.NumberUtils = NumberUtils;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NumberUtils = void 0;
+const object_utils_1 = require("./object-utils");
+const array_utils_1 = require("./array-utils");
+const not_nill_function_1 = require("./function/not-nill.function");
+const is_nill_function_1 = require("./function/is-nill.function");
+class NumberUtils {
+    static ParseIntNumberInput(arg) {
+        return NumberUtils.ParseInt(NumberUtils._NumberInputToNumberStr(arg));
+    }
+    static ParseInt(arg) {
+        if ((0, is_nill_function_1.isNill)(arg) || Array.isArray(arg)) {
+            return undefined;
+        }
+        return parseInt(arg, 10);
+    }
+    static ParseFloatNumberInput(arg, decimalPrecision = 2) {
+        return NumberUtils.ParseFloat(NumberUtils._NumberInputToNumberStr(arg), decimalPrecision);
+    }
+    static ParseFloatNumberInputKeepPrecision(arg) {
+        const correctedInputStr = NumberUtils._NumberInputToNumberStr(arg);
+        const decimalPrecision = this.GetDecimalPlaces(correctedInputStr);
+        return NumberUtils.ParseFloat(correctedInputStr, decimalPrecision);
+    }
+    static ParseFloat(arg, decimalPrecision = 2) {
+        if (!object_utils_1.ObjectUtils.AllExist(arg, decimalPrecision) || Array.isArray(arg)) {
+            return NaN;
+        }
+        if (!NumberUtils.IsInteger(decimalPrecision) || decimalPrecision < 0) {
+            decimalPrecision = 2;
+        }
+        else if (decimalPrecision > 20) {
+            decimalPrecision = 20;
+        }
+        return parseFloat(parseFloat(arg).toFixed(decimalPrecision));
+    }
+    static ParseFloatKeepPrecision(arg) {
+        const decimalPrecision = this.GetDecimalPlaces(arg);
+        return this.ParseFloat(arg, decimalPrecision);
+    }
+    static ParseNumberOrDefault(arg, defaultValue = 0) {
+        if (Array.isArray(arg)) {
+            return defaultValue;
+        }
+        if (!NumberUtils.IsNumber(arg)) {
+            arg = parseFloat(arg);
+            arg = isNaN(arg) ? defaultValue : arg;
+        }
+        return arg;
+    }
+    static IsInteger(arg) {
+        if (isNaN(arg) || Array.isArray(arg)) {
+            return false;
+        }
+        const argAsFloat = parseFloat(arg);
+        return ((argAsFloat | 0) === argAsFloat);
+    }
+    static GetDecimalPlaces(arg, maxAnswer = 1000) {
+        const match = ("" + arg).match(/(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/);
+        if (!match) {
+            return 0;
+        }
+        let answer = Math.max(0, (match[1] ? match[1].length : 0)
+            - (match[2] ? +match[2] : 0));
+        if (answer > maxAnswer) {
+            answer = maxAnswer;
+        }
+        return answer;
+    }
+    static ParseNumberInputOrDefault(numberInput, defaultValue = 0) {
+        return NumberUtils.ParseNumberOrDefault(NumberUtils._NumberInputToNumberStr(numberInput), defaultValue);
+    }
+    static IsNumber(arg) {
+        return typeof arg === "number" && !isNaN(arg);
+    }
+    static IsNaN(arg) {
+        return isNaN(arg) || !NumberUtils.IsNumber(arg);
+    }
+    static NaN(number, substitute = 0) {
+        return NumberUtils.IsNaN(number) ? substitute : number;
+    }
+    static IsParsableNumber(arg) {
+        if (Array.isArray(arg)) {
+            return false;
+        }
+        return !isNaN(parseFloat(arg));
+    }
+    static IsParsableNumberInput(numberInput) {
+        return NumberUtils.IsParsableNumber(NumberUtils._NumberInputToNumberStr(numberInput));
+    }
+    static IsStringNumber(arg) {
+        if (!NumberUtils.IsParsableNumber(arg)) {
+            return false;
+        }
+        else {
+            return arg.toString().length === parseFloat(arg).toString().length;
+        }
+    }
+    static IsListOfNumbers(arg, separator = ",") {
+        const nrs = arg.split(separator);
+        if (nrs.length === 0) {
+            return false;
+        }
+        return nrs.filter(s => NumberUtils.IsStringNumber(s)).length === nrs.length;
+    }
+    static ParseStringNumber(arg) {
+        if (!this.IsStringNumber(arg)) {
+            return NaN;
+        }
+        return NumberUtils.ParseFloatKeepPrecision(arg);
+    }
+    static ParseStringNumberDefault(arg, defaultValue = 0) {
+        return NumberUtils.NaN(NumberUtils.ParseStringNumber(arg), defaultValue);
+    }
+    static RandomInt(lowerBoundInt, upperBoundInt) {
+        if (!NumberUtils.IsNumber(lowerBoundInt) || !NumberUtils.IsNumber(upperBoundInt) || lowerBoundInt > upperBoundInt) {
+            return NaN;
+        }
+        lowerBoundInt = Math.trunc(lowerBoundInt);
+        upperBoundInt = Math.trunc(upperBoundInt);
+        if (lowerBoundInt === upperBoundInt) {
+            return lowerBoundInt;
+        }
+        const delta = upperBoundInt - lowerBoundInt;
+        return (Math.round(Math.random() * delta) + lowerBoundInt);
+    }
+    static AddThousandsCommasTo(value) {
+        if ((0, is_nill_function_1.isNill)(value)) {
+            return "";
+        }
+        return value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+    }
+    static NumIsComposedOfOtherPowTwoNum(bigNrToCheck, powTwoNumItShouldBeComposedOf) {
+        if (!bigNrToCheck) {
+            return false;
+        }
+        else if (!powTwoNumItShouldBeComposedOf) {
+            return true;
+        }
+        else {
+            return ((bigNrToCheck & powTwoNumItShouldBeComposedOf) === powTwoNumItShouldBeComposedOf);
+        }
+    }
+    static NrOrDefault(nr, defaultNr = 0) {
+        if ((0, not_nill_function_1.notNill)(nr) && NumberUtils.IsNumber(nr)) {
+            return nr;
+        }
+        else {
+            return defaultNr;
+        }
+    }
+    static CheckPrecisionAndScale(nrToCheck, precision, scale = 0) {
+        if (!object_utils_1.ObjectUtils.AllExist(nrToCheck, precision, scale)) {
+            return { isOk: true, nearestOkNr: NaN };
+        }
+        if (precision < 1 || precision - scale < 1) {
+            return { isOk: false, nearestOkNr: NaN };
+        }
+        const isNegative = (nrToCheck < 0);
+        const nrParts = nrToCheck.toString().split(".");
+        if (isNegative) {
+            nrParts[0] = nrParts[0].slice(1);
+        }
+        const numCountBeforeDot = nrParts[0].length;
+        const allowedNumCountBeforeDot = precision - scale;
+        if (numCountBeforeDot <= allowedNumCountBeforeDot) {
+            return { isOk: true, nearestOkNr: nrToCheck };
+        }
+        else {
+            const numCountToRemove = numCountBeforeDot - allowedNumCountBeforeDot;
+            nrParts[0] = nrParts[0].slice(0, -1 * numCountToRemove);
+            if (isNegative) {
+                nrParts[0] = "-" + nrParts[0];
+            }
+            let nearestOkNr;
+            if (nrParts[1]) {
+                nearestOkNr = Number(nrParts[0] + "." + nrParts[1]);
+            }
+            else {
+                nearestOkNr = Number(nrParts[0]);
+            }
+            return { isOk: false, nearestOkNr: nearestOkNr };
+        }
+    }
+    static CheckWithinSteppedBounds(nrToCheck, min, max, stepSize = 1) {
+        if (nrToCheck < min || nrToCheck > max) {
+            return { isOk: false, remainder: undefined };
+        }
+        let remainder = (nrToCheck - min) % stepSize;
+        remainder = NumberUtils.ParseFloat(remainder, NumberUtils._GetLargestDecimalPrecisionOf(nrToCheck, min, stepSize));
+        return { isOk: (remainder === 0), remainder: remainder };
+    }
+    static GetNearestNumberWithinSteppedBounds(originalNr, min, max, stepSize = 1) {
+        if (originalNr < min) {
+            return min;
+        }
+        else if (originalNr > max) {
+            return NumberUtils.GetTrueSteppedBoundsMax(min, max, stepSize);
+        }
+        const boundsCheck = NumberUtils.CheckWithinSteppedBounds(originalNr, min, max, stepSize);
+        if (boundsCheck.isOk) {
+            return originalNr;
+        }
+        let answer;
+        const remainder = boundsCheck.remainder;
+        if (remainder) {
+            if ((remainder / stepSize) < 0.5) {
+                answer = (originalNr - remainder >= min ? originalNr - remainder : min);
+            }
+            else {
+                answer = (originalNr + stepSize - remainder <= max ? originalNr + stepSize - remainder :
+                    NumberUtils.GetTrueSteppedBoundsMax(min, max, stepSize));
+            }
+        }
+        else {
+            answer = originalNr;
+        }
+        answer = NumberUtils.ParseFloat(answer, NumberUtils._GetLargestDecimalPrecisionOf(originalNr, min, max, stepSize));
+        return answer;
+    }
+    static GetTrueSteppedBoundsMax(min, max, stepSize = 1) {
+        const maxSteps = Math.floor((max - min) / stepSize);
+        return NumberUtils.ParseFloat(min + maxSteps * stepSize, NumberUtils._GetLargestDecimalPrecisionOf(min, min, max));
+    }
+    static GetNearestNumberWithinBounds(originalNr, min, max) {
+        let answer = originalNr;
+        if (originalNr < min) {
+            answer = min;
+        }
+        else if (originalNr > max) {
+            answer = max;
+        }
+        return answer;
+    }
+    static ToString(nr) {
+        if (!NumberUtils.IsNaN(nr)) {
+            return "" + nr;
+        }
+        else {
+            return "";
+        }
+    }
+    static DecimalsToStepIncrement(numberOfDecimals) {
+        return parseFloat(Math.pow(10, -1 * numberOfDecimals).toFixed(numberOfDecimals));
+    }
+    static Round(value, decimals) {
+        const factor = Math.pow(10, decimals);
+        return Math.round(value * factor) / factor;
+    }
+    static PrecisionScaleToMaxValue(precision, scale) {
+        const oneStep = this.DecimalsToStepIncrement(scale);
+        const maxExclusive = Math.pow(10, precision - scale);
+        return maxExclusive - oneStep;
+    }
+    static DifferenceBetweenNumbers(numberA, numberB) {
+        return Math.abs(numberA - numberB);
+    }
+    static _GetLargestDecimalPrecisionOf(...args) {
+        return array_utils_1.ArrayUtils.GetMaxCalculatedValue(args, (arg) => {
+            return NumberUtils.GetDecimalPlaces(arg);
+        });
+    }
+    static _NumberInputToNumberStr(numberInput) {
+        return (numberInput + "").replace(",", ".");
+    }
+}
+exports.NumberUtils = NumberUtils;
 //# sourceMappingURL=number-utils.js.map

package/build/utils/object-utils.d.ts

@@ -1,21 +1,21 @@
-export declare class ObjectUtils {
-    static AllExist(...values: any[]): boolean;
-    static CopyPropertiesFrom<T>(from: Object, to: T, allowUndefined?: boolean): T;
-    static DeepEquals(actual: any, expected: any): boolean;
-    static ForOwnProperty(plainObject: any, callback: (propVal: any, key: string) => any): void;
-    static GetClassName(objectOrClass: any): string;
-    static GetShallowClone(originalObject: any, objectClass?: any): any;
-    static GetDeepClone(originalObject: any, circular?: boolean): any;
-    static IsEmpty(obj: any): boolean;
-    static IsPlainObject(object: any): boolean;
-    static MakeInstanceOf(clazz: any, dataObject?: any): any;
-    static PickRandomPropertyValue(object: any): any;
-    static ValueOrDefault(value: any, defaultReturnVal?: any): any;
-    private static _isArguments;
-    private static _isArgumentsWhenArgsClassNotSupported;
-    private static _isArgumentsWhenArgsClassSupported;
-    private static _isBuffer;
-    private static _isUndefinedOrNull;
-    private static _objEquiv;
-    private static _supportsArgumentsClass;
-}
+export declare class ObjectUtils {
+    static AllExist(...values: any[]): boolean;
+    static CopyPropertiesFrom<T>(from: Object, to: T, allowUndefined?: boolean): T;
+    static DeepEquals(actual: any, expected: any): boolean;
+    static ForOwnProperty(plainObject: any, callback: (propVal: any, key: string) => any): void;
+    static GetClassName(objectOrClass: any): string;
+    static GetShallowClone(originalObject: any, objectClass?: any): any;
+    static GetDeepClone(originalObject: any, circular?: boolean): any;
+    static IsEmpty(obj: any): boolean;
+    static IsPlainObject(object: any): boolean;
+    static MakeInstanceOf(clazz: any, dataObject?: any): any;
+    static PickRandomPropertyValue(object: any): any;
+    static ValueOrDefault(value: any, defaultReturnVal?: any): any;
+    private static _isArguments;
+    private static _isArgumentsWhenArgsClassNotSupported;
+    private static _isArgumentsWhenArgsClassSupported;
+    private static _isBuffer;
+    private static _isUndefinedOrNull;
+    private static _objEquiv;
+    private static _supportsArgumentsClass;
+}