@colijnit/ioneconnector 256.1.2 → 256.1.4

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

@@ -1,12 +1,12 @@
-import { SortProperty } from '../interface/sort-property';
-import { SortDirection } from '../enum/sort-direction';
-export declare class SortUtils {
-    static SortObjectArray<T>(givenArray: T[], sortProperties: SortProperty[]): void;
-    static SortArray<T>(array: any[], direction?: SortDirection, evalType?: any): void;
-    static ToString(sortProperties: SortProperty[], activeOnly?: boolean): string;
-    private static _getSortValueAndSetEvalType;
-    private static _compareValue;
-    private static _compareBooleanValue;
-    private static _compareNumberValue;
-    private static _getSwitcherFromSortDirection;
-}
+import { SortProperty } from '../interface/sort-property';
+import { SortDirection } from '../enum/sort-direction';
+export declare class SortUtils {
+    static SortObjectArray<T>(givenArray: T[], sortProperties: SortProperty[]): void;
+    static SortArray<T>(array: any[], direction?: SortDirection, evalType?: any): void;
+    static ToString(sortProperties: SortProperty[], activeOnly?: boolean): string;
+    private static _getSortValueAndSetEvalType;
+    private static _compareValue;
+    private static _compareBooleanValue;
+    private static _compareNumberValue;
+    private static _getSwitcherFromSortDirection;
+}

package/build/utils/sort-utils.js

@@ -1,121 +1,121 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SortUtils = void 0;
-const sort_direction_1 = require("../enum/sort-direction");
-const sort_type_enum_1 = require("../enum/sort-type.enum");
-const number_utils_1 = require("./number-utils");
-const string_utils_1 = require("./string-utils");
-class SortUtils {
-    static SortObjectArray(givenArray, sortProperties) {
-        if (!givenArray || !sortProperties || sortProperties.length === 0) {
-            return;
-        }
-        const sortedArray = givenArray.map((data, index) => {
-            const values = {};
-            sortProperties.forEach((sorter) => {
-                values[sorter.property] = SortUtils._getSortValueAndSetEvalType(data[sorter.property], sorter);
-                sorter.switcher = SortUtils._getSwitcherFromSortDirection(sorter.direction);
-            });
-            return { index: index, values: values };
-        }).sort((a, b) => {
-            let sort = 0;
-            for (const sortProperty of sortProperties) {
-                const aVal = a.values[sortProperty.property];
-                const bVal = b.values[sortProperty.property];
-                if (sortProperty.evalType === Number) {
-                    sort = SortUtils._compareNumberValue(aVal, bVal, sortProperty.switcher);
-                }
-                else if (sortProperty.evalType === Boolean) {
-                    sort = SortUtils._compareBooleanValue(aVal, bVal, sortProperty.switcher);
-                }
-                else {
-                    sort = SortUtils._compareValue(aVal, bVal, sortProperty.switcher);
-                }
-                if (sort !== 0) {
-                    break;
-                }
-            }
-            return sort;
-        }).map(sorter => givenArray[sorter.index]);
-        givenArray.length = 0;
-        sortedArray.forEach(item => {
-            givenArray.push(item);
-        });
-    }
-    static SortArray(array, direction = sort_direction_1.SortDirection.Ascending, evalType = String) {
-        const switcher = SortUtils._getSwitcherFromSortDirection(direction);
-        if (evalType === Number) {
-            array.sort((a, b) => {
-                return SortUtils._compareNumberValue(a, b, switcher);
-            });
-        }
-        else if (evalType === Boolean) {
-            array.sort((a, b) => {
-                if (!a) {
-                    a = false;
-                }
-                if (!b) {
-                    b = false;
-                }
-                return SortUtils._compareBooleanValue(a, b, switcher);
-            });
-        }
-        else {
-            array.sort((a, b) => {
-                return SortUtils._compareValue(a, b, switcher);
-            });
-        }
-    }
-    static ToString(sortProperties, activeOnly = true) {
-        let str = "";
-        if (sortProperties) {
-            for (let i = 0, len = sortProperties.length; i < len; i++) {
-                const prop = sortProperties[i];
-                if (activeOnly && prop.active === false) {
-                    continue;
-                }
-                str += prop.property + ": " + prop.direction + ", ";
-            }
-            str = str.substring(0, str.length - 2);
-        }
-        return str;
-    }
-    static _getSortValueAndSetEvalType(value, sorter) {
-        switch (sorter.type) {
-            case sort_type_enum_1.SortType.Boolean:
-                if (!value) {
-                    value = false;
-                }
-                sorter.evalType = Boolean;
-                break;
-            case sort_type_enum_1.SortType.Number:
-                value = number_utils_1.NumberUtils.ParseNumberOrDefault(value, 0);
-                sorter.evalType = Number;
-                break;
-            case sort_type_enum_1.SortType.Date:
-                value = value instanceof Date ? value.getTime() : 0;
-                sorter.evalType = Number;
-                break;
-            case sort_type_enum_1.SortType.String:
-            default:
-                value = string_utils_1.StringUtils.ParseString(value, "").toLocaleLowerCase();
-                sorter.evalType = String;
-                break;
-        }
-        return value;
-    }
-    static _compareValue(a, b, switcher = 1) {
-        return (a > b ? 1 : (a < b ? -1 : 0)) * switcher;
-    }
-    static _compareBooleanValue(a, b, switcher = 1) {
-        return ((a === b) ? 0 : (a ? -1 : 1)) * switcher;
-    }
-    static _compareNumberValue(a, b, switcher = 1) {
-        return (a - b) * switcher;
-    }
-    static _getSwitcherFromSortDirection(direction = sort_direction_1.SortDirection.Ascending) {
-        return direction === sort_direction_1.SortDirection.Ascending ? 1 : -1;
-    }
-}
-exports.SortUtils = SortUtils;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SortUtils = void 0;
+const sort_direction_1 = require("../enum/sort-direction");
+const sort_type_enum_1 = require("../enum/sort-type.enum");
+const number_utils_1 = require("./number-utils");
+const string_utils_1 = require("./string-utils");
+class SortUtils {
+    static SortObjectArray(givenArray, sortProperties) {
+        if (!givenArray || !sortProperties || sortProperties.length === 0) {
+            return;
+        }
+        const sortedArray = givenArray.map((data, index) => {
+            const values = {};
+            sortProperties.forEach((sorter) => {
+                values[sorter.property] = SortUtils._getSortValueAndSetEvalType(data[sorter.property], sorter);
+                sorter.switcher = SortUtils._getSwitcherFromSortDirection(sorter.direction);
+            });
+            return { index: index, values: values };
+        }).sort((a, b) => {
+            let sort = 0;
+            for (const sortProperty of sortProperties) {
+                const aVal = a.values[sortProperty.property];
+                const bVal = b.values[sortProperty.property];
+                if (sortProperty.evalType === Number) {
+                    sort = SortUtils._compareNumberValue(aVal, bVal, sortProperty.switcher);
+                }
+                else if (sortProperty.evalType === Boolean) {
+                    sort = SortUtils._compareBooleanValue(aVal, bVal, sortProperty.switcher);
+                }
+                else {
+                    sort = SortUtils._compareValue(aVal, bVal, sortProperty.switcher);
+                }
+                if (sort !== 0) {
+                    break;
+                }
+            }
+            return sort;
+        }).map(sorter => givenArray[sorter.index]);
+        givenArray.length = 0;
+        sortedArray.forEach(item => {
+            givenArray.push(item);
+        });
+    }
+    static SortArray(array, direction = sort_direction_1.SortDirection.Ascending, evalType = String) {
+        const switcher = SortUtils._getSwitcherFromSortDirection(direction);
+        if (evalType === Number) {
+            array.sort((a, b) => {
+                return SortUtils._compareNumberValue(a, b, switcher);
+            });
+        }
+        else if (evalType === Boolean) {
+            array.sort((a, b) => {
+                if (!a) {
+                    a = false;
+                }
+                if (!b) {
+                    b = false;
+                }
+                return SortUtils._compareBooleanValue(a, b, switcher);
+            });
+        }
+        else {
+            array.sort((a, b) => {
+                return SortUtils._compareValue(a, b, switcher);
+            });
+        }
+    }
+    static ToString(sortProperties, activeOnly = true) {
+        let str = "";
+        if (sortProperties) {
+            for (let i = 0, len = sortProperties.length; i < len; i++) {
+                const prop = sortProperties[i];
+                if (activeOnly && prop.active === false) {
+                    continue;
+                }
+                str += prop.property + ": " + prop.direction + ", ";
+            }
+            str = str.substring(0, str.length - 2);
+        }
+        return str;
+    }
+    static _getSortValueAndSetEvalType(value, sorter) {
+        switch (sorter.type) {
+            case sort_type_enum_1.SortType.Boolean:
+                if (!value) {
+                    value = false;
+                }
+                sorter.evalType = Boolean;
+                break;
+            case sort_type_enum_1.SortType.Number:
+                value = number_utils_1.NumberUtils.ParseNumberOrDefault(value, 0);
+                sorter.evalType = Number;
+                break;
+            case sort_type_enum_1.SortType.Date:
+                value = value instanceof Date ? value.getTime() : 0;
+                sorter.evalType = Number;
+                break;
+            case sort_type_enum_1.SortType.String:
+            default:
+                value = string_utils_1.StringUtils.ParseString(value, "").toLocaleLowerCase();
+                sorter.evalType = String;
+                break;
+        }
+        return value;
+    }
+    static _compareValue(a, b, switcher = 1) {
+        return (a > b ? 1 : (a < b ? -1 : 0)) * switcher;
+    }
+    static _compareBooleanValue(a, b, switcher = 1) {
+        return ((a === b) ? 0 : (a ? -1 : 1)) * switcher;
+    }
+    static _compareNumberValue(a, b, switcher = 1) {
+        return (a - b) * switcher;
+    }
+    static _getSwitcherFromSortDirection(direction = sort_direction_1.SortDirection.Ascending) {
+        return direction === sort_direction_1.SortDirection.Ascending ? 1 : -1;
+    }
+}
+exports.SortUtils = SortUtils;
 //# sourceMappingURL=sort-utils.js.map

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

@@ -1,25 +1,25 @@
-import { TextPart } from '../interface/text-part';
-export declare class StringUtils {
-    static ReplaceOccurrencesIn(source: string, placeholder: string, ...replacementTexts: string[]): string;
-    static ParseString(arg: any, defaultValue?: string): string;
-    static IsString(str: any): boolean;
-    static AsLowerCaseIfString(str: any): any;
-    static IsStringWithLength(str: string): boolean;
-    static Format(str: string, format: any[]): string;
-    static GetFirstCapital(str: string): string;
-    static ToStringOrDefault(arg: any, defaultReturnVal?: string): string;
-    static CapitalizeFirstLetter(str: string): string;
-    static RemoveLastChars(str: string, amount: number): string;
-    static StringArrayToString(strArray: string[]): string;
-    static ToDictionaryKey(str: string): string;
-    static CloneStringArray(strArray: string[]): string[];
-    static StartsWithAny(strToCheck: string, prefixes: string[]): boolean;
-    static LeftString(str: string, char: string): string;
-    static RightString(str: string, char: string): string;
-    static StringToStringArray(str: string): string[];
-    static GetTextParts(text: string, partsFilter: string): TextPart[];
-    static IsValidEmail(str: string): boolean;
-    private static _escapeRegExp;
-    static htmlToPlainText(html: string): string;
-    static CreateUuid(): string;
-}
+import { TextPart } from '../interface/text-part';
+export declare class StringUtils {
+    static ReplaceOccurrencesIn(source: string, placeholder: string, ...replacementTexts: string[]): string;
+    static ParseString(arg: any, defaultValue?: string): string;
+    static IsString(str: any): boolean;
+    static AsLowerCaseIfString(str: any): any;
+    static IsStringWithLength(str: string): boolean;
+    static Format(str: string, format: any[]): string;
+    static GetFirstCapital(str: string): string;
+    static ToStringOrDefault(arg: any, defaultReturnVal?: string): string;
+    static CapitalizeFirstLetter(str: string): string;
+    static RemoveLastChars(str: string, amount: number): string;
+    static StringArrayToString(strArray: string[]): string;
+    static ToDictionaryKey(str: string): string;
+    static CloneStringArray(strArray: string[]): string[];
+    static StartsWithAny(strToCheck: string, prefixes: string[]): boolean;
+    static LeftString(str: string, char: string): string;
+    static RightString(str: string, char: string): string;
+    static StringToStringArray(str: string): string[];
+    static GetTextParts(text: string, partsFilter: string): TextPart[];
+    static IsValidEmail(str: string): boolean;
+    private static _escapeRegExp;
+    static htmlToPlainText(html: string): string;
+    static CreateUuid(): string;
+}