@colijnit/sharedcomponents 1.0.57 → 1.0.59

package/esm2015/lib/utils/object-utils.js

@@ -0,0 +1,278 @@
+import { isNill } from "./is-nill.function";
+import { notNill } from "./function/not-nill.function";
+// Static utility function holder related to objects.
+export class ObjectUtils {
+    /**
+     * Returns whether all given values exist: for all values it holds that they are not null nor undefined. Short-circuit check.
+     * @param {any} values Rest parameters with all objects to check existence for.
+     * @returns {boolean} True if ALL given values are not null nor undefined, otherwise false (if at least one value was null or undefined)
+     */
+    static AllExist(...values) {
+        let allExist = true;
+        for (let i = 0, len = values.length; i < len; i++) {
+            if (isNill(values[i])) {
+                allExist = false;
+                break;
+            }
+        }
+        return allExist;
+    }
+    /**
+     * Copies all properties from object 'from' to object 'to'. Overwrites properties on object 'to' if property already exists.
+     * Does not copy functions, only properties.
+     * @param {Object} from The source object from which to copy all properties of to the 'to' object.
+     * @param {Object} to The object to which the properties of the 'from' object will be copied.
+     * @param {boolean} [allowUndefined = true] wether the 'to' object may be assigned null or undefined values to any of its properties.
+     */
+    static CopyPropertiesFrom(from, to, allowUndefined = true) {
+        if (!to) {
+            to = {};
+        }
+        if (!from) {
+            return to;
+        }
+        ObjectUtils.ForOwnProperty(from, (value, key) => {
+            if (allowUndefined || notNill(value)) {
+                to[key] = value;
+            }
+        });
+        return to;
+    }
+    static DeepEquals(actual, expected) {
+        if (actual === expected) {
+            return true;
+        }
+        else if (actual instanceof Date && expected instanceof Date) {
+            return actual.getTime() === expected.getTime();
+        }
+        else if (!actual || !expected || typeof actual !== "object" && typeof expected !== "object") {
+            return actual === expected;
+        }
+        else {
+            return this._objEquiv(actual, expected);
+        }
+    }
+    // Performs given callback function for each own property of given plain object. Also works on string enums.
+    static ForOwnProperty(plainObject, callback) {
+        if (ObjectUtils.IsPlainObject(plainObject)) {
+            for (const key in plainObject) {
+                if (plainObject.hasOwnProperty(key) && typeof plainObject[key] !== "function") {
+                    const response = callback(plainObject[key], key);
+                    if (response === false) {
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    // Returns the class name of given argument. The argument can be an object or a class.
+    static GetClassName(objectOrClass) {
+        if (!objectOrClass) {
+            return undefined;
+            // arg was a class (or a function..)
+        }
+        else if (objectOrClass.constructor === Function) {
+            return objectOrClass.name; // .. which has its readable name stores like this
+            // else arg was an object
+        }
+        else {
+            const constructorString = objectOrClass.constructor.toString();
+            return constructorString.match(/\w+/g)[1];
+        }
+    }
+    // Returns a shallow clone of the given original object. The clone is a SIMPLE OBJECT with the same properties as the original.
+    static GetShallowClone(originalObject, objectClass) {
+        let clonedObject = undefined;
+        if (objectClass) {
+            clonedObject = new objectClass();
+        }
+        else {
+            clonedObject = {};
+        }
+        ObjectUtils.ForOwnProperty(originalObject, (value, key) => {
+            clonedObject[key] = value;
+        });
+        return clonedObject;
+    }
+    static GetDeepClone(originalObject, circular = true) {
+        // First create an empty object with
+        // same prototype of our original source
+        let propertyIndex;
+        let descriptor;
+        let keys;
+        let current;
+        let nextSource;
+        let indexOf;
+        const copies = [{
+                source: originalObject,
+                target: Object.create(Object.getPrototypeOf(originalObject))
+            }];
+        const cloneObject = copies[0].target;
+        const sourceReferences = [originalObject];
+        const targetReferences = [cloneObject];
+        // First in, first out
+        while (current = copies.shift()) { //NOSONAR
+            keys = Object.getOwnPropertyNames(current.source);
+            for (propertyIndex = 0; propertyIndex < keys.length; propertyIndex++) {
+                // Save the source's descriptor
+                descriptor = Object.getOwnPropertyDescriptor(current.source, keys[propertyIndex]);
+                if (!descriptor.value || typeof descriptor.value !== "object") {
+                    Object.defineProperty(current.target, keys[propertyIndex], descriptor);
+                    continue;
+                }
+                nextSource = descriptor.value;
+                descriptor.value = Array.isArray(nextSource) ?
+                    [] :
+                    Object.create(Object.getPrototypeOf(nextSource));
+                if (circular) {
+                    indexOf = sourceReferences.indexOf(nextSource);
+                    if (indexOf !== -1) {
+                        // The source is already referenced, just assign reference
+                        descriptor.value = targetReferences[indexOf];
+                        Object.defineProperty(current.target, keys[propertyIndex], descriptor);
+                        continue;
+                    }
+                    sourceReferences.push(nextSource);
+                    targetReferences.push(descriptor.value);
+                }
+                Object.defineProperty(current.target, keys[propertyIndex], descriptor);
+                copies.push({ source: nextSource, target: descriptor.value });
+            }
+        }
+        return cloneObject;
+    }
+    static IsEmpty(obj) {
+        return isNill(obj) || Object.getOwnPropertyNames(obj).length === 0;
+    }
+    // Returns whether given object is an existing, plain object. That is, it defined, its type if 'object' and it is NOT an array or func.
+    static IsPlainObject(object) {
+        return object !== null && !Array.isArray(object) && typeof object !== "function" && typeof object === "object";
+    }
+    /**
+     * Returns an instance of given class with data of given dataObject. Only works if that class has a default constructor without args.
+     * Does not actually create a new object if it alread is an instance of that class.
+     * @param {any} clazz A class that has a default constructor
+     * @param {any} [dataObject] The object with data to copy to the new instance of the class
+     * @returns {any} An object that is an instance of given class, with given data applied to it.
+     */
+    static MakeInstanceOf(clazz, dataObject) {
+        // dont make a clone if given dataObject already instance of clazz
+        if (dataObject instanceof clazz) {
+            return dataObject;
+        }
+        else {
+            const asClazz = new clazz();
+            ObjectUtils.CopyPropertiesFrom(dataObject, asClazz);
+            return asClazz;
+        }
+    }
+    // Returns the value of a random own property of given object.
+    static PickRandomPropertyValue(object) {
+        if (!object) {
+            return;
+        }
+        let result;
+        let count = 0;
+        for (const prop in object) {
+            if (object.hasOwnProperty(prop)) {
+                count++;
+                if (Math.random() < 1 / count) {
+                    result = object[prop];
+                }
+            }
+        }
+        return result;
+    }
+    // Returns a default if given value doesn't exist, otherwise just value.
+    static ValueOrDefault(value, defaultReturnVal = "") {
+        return notNill(value) ? value : defaultReturnVal;
+    }
+    static _isArguments(x) {
+        const supportsArgsClass = this._supportsArgumentsClass();
+        return supportsArgsClass ? this._isArgumentsWhenArgsClassSupported(x) : this._isArgumentsWhenArgsClassNotSupported(x);
+    }
+    static _isArgumentsWhenArgsClassNotSupported(object) {
+        return object &&
+            typeof object === "object" &&
+            typeof object.length === "number" &&
+            Object.prototype.hasOwnProperty.call(object, "callee") &&
+            !Object.prototype.propertyIsEnumerable.call(object, "callee") ||
+            false;
+    }
+    static _isArgumentsWhenArgsClassSupported(object) {
+        return Object.prototype.toString.call(object) === "[object Arguments]";
+    }
+    static _isBuffer(x) {
+        if (!x || typeof x !== "object" || typeof x.length !== "number") {
+            return false;
+        }
+        if (typeof x.copy !== "function" || typeof x.slice !== "function") {
+            return false;
+        }
+        return !(x.length > 0 && typeof x[0] !== "number");
+    }
+    static _isUndefinedOrNull(value) {
+        return value === null || value === undefined;
+    }
+    static _objEquiv(a, b) {
+        let i, key;
+        if (this._isUndefinedOrNull(a) || this._isUndefinedOrNull(b)) {
+            return false;
+        }
+        if (a.prototype !== b.prototype) {
+            return false;
+        }
+        if (this._isArguments(a)) {
+            if (!this._isArguments(b)) {
+                return false;
+            }
+            a = Array.prototype.slice.call(a);
+            b = Array.prototype.slice.call(b);
+            return this.DeepEquals(a, b);
+        }
+        if (this._isBuffer(a)) {
+            if (!this._isBuffer(b)) {
+                return false;
+            }
+            if (a.length !== b.length) {
+                return false;
+            }
+            for (i = 0; i < a.length; i++) {
+                if (a[i] !== b[i]) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        let ka;
+        let kb;
+        try {
+            ka = Object.keys(a);
+            kb = Object.keys(b);
+        }
+        catch (e) {
+            return false;
+        }
+        if (ka.length !== kb.length) {
+            return false;
+        }
+        ka.sort();
+        kb.sort();
+        for (i = ka.length - 1; i >= 0; i--) {
+            if (ka[i] !== kb[i]) {
+                return false;
+            }
+        }
+        for (i = ka.length - 1; i >= 0; i--) {
+            key = ka[i];
+            if (!this.DeepEquals(a[key], b[key])) {
+                return false;
+            }
+        }
+        return typeof a === typeof b;
+    }
+    static _supportsArgumentsClass() {
+        return Object.prototype.toString.call(arguments) === "[object Arguments]";
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"object-utils.js","sourceRoot":"","sources":["../../../../../projects/sharedcomponents/src/lib/utils/object-utils.ts"],"names":[],"mappings":"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","sourcesContent":["import {isNill} from \"./is-nill.function\";\nimport {notNill} from \"./function/not-nill.function\";\n\n// Static utility function holder related to objects.\nexport class ObjectUtils {\n\n    /**\n     * Returns whether all given values exist: for all values it holds that they are not null nor undefined. Short-circuit check.\n     * @param {any} values Rest parameters with all objects to check existence for.\n     * @returns {boolean} True if ALL given values are not null nor undefined, otherwise false (if at least one value was null or undefined)\n     */\n    public static AllExist(...values: any[]): boolean {\n        let allExist: boolean = true;\n        for (let i: number = 0, len: number = values.length; i < len; i++) {\n            if (isNill(values[i])) {\n                allExist = false;\n                break;\n            }\n        }\n        return allExist;\n    }\n\n    /**\n     * Copies all properties from object 'from' to object 'to'. Overwrites properties on object 'to' if property already exists.\n     * Does not copy functions, only properties.\n     * @param {Object} from The source object from which to copy all properties of to the 'to' object.\n     * @param {Object} to The object to which the properties of the 'from' object will be copied.\n     * @param {boolean} [allowUndefined = true] wether the 'to' object may be assigned null or undefined values to any of its properties.\n     */\n    public static CopyPropertiesFrom<T>(from: Object, to: T, allowUndefined: boolean = true): T {\n        if (!to) {\n            to = {} as T;\n        }\n        if (!from) {\n            return to;\n        }\n        ObjectUtils.ForOwnProperty(from, (value: any, key: string) => {\n            if (allowUndefined || notNill(value)) {\n                to[key] = value;\n            }\n        });\n        return to;\n    }\n\n    public static DeepEquals(actual: any, expected: any): boolean {\n        if (actual === expected) {\n            return true;\n        } else if (actual instanceof Date && expected instanceof Date) {\n            return actual.getTime() === expected.getTime();\n        } else if (!actual || !expected || typeof actual !== \"object\" && typeof expected !== \"object\") {\n            return actual === expected;\n        } else {\n            return this._objEquiv(actual, expected);\n        }\n    }\n\n    // Performs given callback function for each own property of given plain object. Also works on string enums.\n    public static ForOwnProperty(plainObject: any, callback: (propVal: any, key: string) => any): void {\n        if (ObjectUtils.IsPlainObject(plainObject)) {\n            for (const key in plainObject) {\n                if (plainObject.hasOwnProperty(key) && typeof plainObject[key] !== \"function\") {\n                    const response: boolean = callback(plainObject[key], key);\n                    if (response === false) {\n                        break;\n                    }\n                }\n            }\n        }\n    }\n\n    // Returns the class name of given argument. The argument can be an object or a class.\n    public static GetClassName(objectOrClass: any): string {\n        if (!objectOrClass) {\n            return undefined;\n            // arg was a class (or a function..)\n        } else if (objectOrClass.constructor === Function) {\n            return objectOrClass.name; // .. which has its readable name stores like this\n            // else arg was an object\n        } else {\n            const constructorString: string = objectOrClass.constructor.toString();\n            return constructorString.match(/\\w+/g)[1];\n        }\n    }\n\n    // Returns a shallow clone of the given original object. The clone is a SIMPLE OBJECT with the same properties as the original.\n    public static GetShallowClone(originalObject: any, objectClass?: any): any {\n        let clonedObject: any = undefined;\n\n        if (objectClass) {\n            clonedObject = new objectClass();\n        } else {\n            clonedObject = {};\n        }\n\n        ObjectUtils.ForOwnProperty(originalObject, (value: any, key: string) => {\n            clonedObject[key] = value;\n        });\n\n        return clonedObject;\n    }\n\n    public static GetDeepClone(originalObject: any, circular: boolean = true): any {\n        // First create an empty object with\n        // same prototype of our original source\n\n        let propertyIndex: number;\n        let descriptor: PropertyDescriptor;\n        let keys: string[];\n        let current: any;\n        let nextSource: any;\n        let indexOf: number;\n        const copies: any[] = [{\n            source: originalObject,\n            target: Object.create(Object.getPrototypeOf(originalObject))\n        }];\n        const cloneObject: any = copies[0].target;\n        const sourceReferences: any[] = [originalObject];\n        const targetReferences: any[] = [cloneObject];\n\n        // First in, first out\n        while (current = copies.shift()) { //NOSONAR\n            keys = Object.getOwnPropertyNames(current.source);\n\n            for (propertyIndex = 0; propertyIndex < keys.length; propertyIndex++) {\n                // Save the source's descriptor\n                descriptor = Object.getOwnPropertyDescriptor(current.source, keys[propertyIndex]);\n\n                if (!descriptor.value || typeof descriptor.value !== \"object\") {\n                    Object.defineProperty(current.target, keys[propertyIndex], descriptor);\n                    continue;\n                }\n\n                nextSource = descriptor.value;\n                descriptor.value = Array.isArray(nextSource) ?\n                    [] :\n                    Object.create(Object.getPrototypeOf(nextSource));\n\n                if (circular) {\n                    indexOf = sourceReferences.indexOf(nextSource);\n\n                    if (indexOf !== -1) {\n                        // The source is already referenced, just assign reference\n                        descriptor.value = targetReferences[indexOf];\n                        Object.defineProperty(current.target, keys[propertyIndex], descriptor);\n                        continue;\n                    }\n\n                    sourceReferences.push(nextSource);\n                    targetReferences.push(descriptor.value);\n                }\n\n                Object.defineProperty(current.target, keys[propertyIndex], descriptor);\n\n                copies.push({source: nextSource, target: descriptor.value});\n            }\n        }\n\n        return cloneObject;\n    }\n\n    public static IsEmpty(obj: any): boolean {\n        return isNill(obj) || Object.getOwnPropertyNames(obj).length === 0;\n    }\n\n    // Returns whether given object is an existing, plain object. That is, it defined, its type if 'object' and it is NOT an array or func.\n    public static IsPlainObject(object: any): boolean {\n        return object !== null && !Array.isArray(object) && typeof object !== \"function\" && typeof object === \"object\";\n    }\n\n    /**\n     * Returns an instance of given class with data of given dataObject. Only works if that class has a default constructor without args.\n     * Does not actually create a new object if it alread is an instance of that class.\n     * @param {any} clazz A class that has a default constructor\n     * @param {any} [dataObject] The object with data to copy to the new instance of the class\n     * @returns {any} An object that is an instance of given class, with given data applied to it.\n     */\n    public static MakeInstanceOf(clazz: any, dataObject?: any): any {\n        // dont make a clone if given dataObject already instance of clazz\n        if (dataObject instanceof clazz) {\n            return dataObject;\n        } else {\n            const asClazz: any = new clazz();\n            ObjectUtils.CopyPropertiesFrom(dataObject, asClazz);\n            return asClazz;\n        }\n    }\n\n    // Returns the value of a random own property of given object.\n    public static PickRandomPropertyValue(object: any): any {\n        if (!object) {\n            return;\n        }\n\n        let result: any;\n        let count: number = 0;\n        for (const prop in object) {\n            if (object.hasOwnProperty(prop)) {\n                count++;\n                if (Math.random() < 1 / count) {\n                    result = object[prop];\n                }\n            }\n        }\n        return result;\n    }\n\n    // Returns a default if given value doesn't exist, otherwise just value.\n    public static ValueOrDefault(value: any, defaultReturnVal: any = \"\"): any {\n        return notNill(value) ? value : defaultReturnVal;\n    }\n\n    private static _isArguments(x: any): boolean {\n        const supportsArgsClass: boolean = this._supportsArgumentsClass();\n        return supportsArgsClass ? this._isArgumentsWhenArgsClassSupported(x) : this._isArgumentsWhenArgsClassNotSupported(x);\n    }\n\n    private static _isArgumentsWhenArgsClassNotSupported(object: any): boolean {\n        return object &&\n            typeof object === \"object\" &&\n            typeof object.length === \"number\" &&\n            Object.prototype.hasOwnProperty.call(object, \"callee\") &&\n            !Object.prototype.propertyIsEnumerable.call(object, \"callee\") ||\n            false;\n    }\n\n    private static _isArgumentsWhenArgsClassSupported(object: any): boolean {\n        return Object.prototype.toString.call(object) === \"[object Arguments]\";\n    }\n\n    private static _isBuffer(x: any): boolean {\n        if (!x || typeof x !== \"object\" || typeof x.length !== \"number\") {\n            return false;\n        }\n        if (typeof x.copy !== \"function\" || typeof x.slice !== \"function\") {\n            return false;\n        }\n        return !(x.length > 0 && typeof x[0] !== \"number\");\n    }\n\n    private static _isUndefinedOrNull(value: any): boolean {\n        return value === null || value === undefined;\n    }\n\n    private static _objEquiv(a: any, b: any): boolean {\n        let i: number, key: string;\n        if (this._isUndefinedOrNull(a) || this._isUndefinedOrNull(b)) {\n            return false;\n        }\n\n        if (a.prototype !== b.prototype) {\n            return false;\n        }\n\n        if (this._isArguments(a)) {\n            if (!this._isArguments(b)) {\n                return false;\n            }\n            a = Array.prototype.slice.call(a);\n            b = Array.prototype.slice.call(b);\n            return this.DeepEquals(a, b);\n        }\n        if (this._isBuffer(a)) {\n            if (!this._isBuffer(b)) {\n                return false;\n            }\n            if (a.length !== b.length) {\n                return false;\n            }\n            for (i = 0; i < a.length; i++) {\n                if (a[i] !== b[i]) {\n                    return false;\n                }\n            }\n            return true;\n        }\n        let ka: string[];\n        let kb: string[];\n        try {\n            ka = Object.keys(a);\n            kb = Object.keys(b);\n        } catch (e) {\n            return false;\n        }\n\n        if (ka.length !== kb.length) {\n            return false;\n        }\n\n        ka.sort();\n        kb.sort();\n\n        for (i = ka.length - 1; i >= 0; i--) {\n            if (ka[i] !== kb[i]) {\n                return false;\n            }\n        }\n\n        for (i = ka.length - 1; i >= 0; i--) {\n            key = ka[i];\n            if (!this.DeepEquals(a[key], b[key])) {\n                return false;\n            }\n        }\n        return typeof a === typeof b;\n    }\n\n    private static _supportsArgumentsClass(): boolean {\n        return Object.prototype.toString.call(arguments) === \"[object Arguments]\";\n    }\n}\n"]}

package/esm2015/lib/utils/ref-code-utils.js

@@ -0,0 +1,49 @@
+// Static utility function holder related to ref codes and string enums (as in our string enum representations of the db table REF_CODE).
+import { NumberUtils } from "./number-utils";
+export class RefCodeUtils {
+    // Returns true if given valueToCheck is a composition of the second numeric argument. Usesul for checking user rights, for instance.
+    static Check(valueToCheck, powTwoNumToCheckAgainst) {
+        return NumberUtils.NumIsComposedOfOtherPowTwoNum(valueToCheck, powTwoNumToCheckAgainst);
+    }
+    /**
+     * Returns true if given number value is a composition of at least one of the rest numeric arguments. Usesul for checking user rights,
+     * for instance, or any other numerical composite refcode.
+     */
+    static CheckAny(valueToCheck, ...powTwoNumsToCheckAgainst) {
+        const len = powTwoNumsToCheckAgainst.length;
+        for (let i = 0; i < len; i++) {
+            if (RefCodeUtils.Check(valueToCheck, powTwoNumsToCheckAgainst[i])) {
+                return true;
+            }
+        }
+        return false;
+    }
+    static GetMultiRefCodeChoices(multiRefCode) {
+        const choices = [];
+        // magic number 22 was chosen as a 'high' power of two, i.e. we don't expect multi ref codes with more than 21 options
+        let powTwoExponent = 22;
+        let powTwoVal = Math.pow(2, powTwoExponent);
+        let remainder = multiRefCode;
+        while (remainder > 0) {
+            if (remainder - powTwoVal >= 0) {
+                choices.push(powTwoVal);
+                remainder -= powTwoVal;
+            }
+            powTwoExponent--;
+            powTwoVal = Math.pow(2, powTwoExponent);
+        }
+        choices.reverse();
+        return choices;
+    }
+    static GetNumbersArraySum(numbersArray) {
+        if (!Array.isArray(numbersArray) || numbersArray.length === 0) {
+            return;
+        }
+        let sum = 0;
+        numbersArray.forEach((num) => {
+            sum += num;
+        });
+        return sum;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/utils/string-utils.js

@@ -1,64 +1,93 @@
-// Static utility functions holder related to strings.
-export class StringUtils {
-    /**
-     * Returns a new string where given placeholder in given source string are replaced by given replacement texts.
-     *
-     * Example usage:
-     *
-     * source = "ABCDABCD"
-     * placeholder = "BC"
-     * replacementTexts = "Z", "Z" (REST arguments)
-     * OUTPUT = "AZDAZD"
-     *
-     * @param {string} source
-     * @param {string} placeholder
-     * @param {string} replacementTexts If only one is given, this function replaces all placeholders with that single replacementText.
-     * If more are given, placeholders without a corresponding replacementText will remain their original placeholder characters.
-     */
-    static ReplaceOccurrencesIn(source, placeholder, ...replacementTexts) {
-        // parameter guards
-        if (!(source)) {
-            return undefined;
-        }
-        if (!placeholder || replacementTexts.length === 0) {
-            return source;
-        }
-        let outString = source;
-        // one replacementText means replace for all
-        if (replacementTexts.length === 1) {
-            // "g" is the g flag to replace globally
-            outString = outString.replace(placeholder, replacementTexts[0]);
-        }
-        else {
-            // replace occurence i by replacementTexts[i], one at a time in loop (there might be a faster way..)
-            for (let i = 0, len = replacementTexts.length; i < len; i++) {
-                outString = outString.replace(placeholder, replacementTexts[i]);
-            }
-        }
-        return outString;
-    }
-    // Returns the given argument as a string. Returns given defaultValue if conversion of argument to string was impossible.
-    static ParseString(arg, defaultValue = "") {
-        if (!StringUtils.IsString(arg)) {
-            if (arg && typeof arg.toString === "function") {
-                arg = arg.toString();
-            }
-            else {
-                arg = defaultValue;
-            }
-        }
-        return arg;
-    }
-    static IsString(str) {
-        return typeof str === 'string';
-    }
-    // Returns whether given str is a string and has a length > 0.
-    static IsStringWithLength(str) {
-        return str && StringUtils.IsString(str) && str.length > 0;
-    }
-    // Returns given string, escaped for use as string literal in regular expressions.
-    static _escapeRegExp(str) {
-        return str; // .replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^$\|]/g, "\\$&");
-    }
-}
-//# sourceMappingURL=data:application/json;base64,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
+// Static utility functions holder related to strings.
+export class StringUtils {
+    /**
+     * Returns a new string where given placeholder in given source string are replaced by given replacement texts.
+     *
+     * Example usage:
+     *
+     * source = "ABCDABCD"
+     * placeholder = "BC"
+     * replacementTexts = "Z", "Z" (REST arguments)
+     * OUTPUT = "AZDAZD"
+     *
+     * @param {string} source
+     * @param {string} placeholder
+     * @param {string} replacementTexts If only one is given, this function replaces all placeholders with that single replacementText.
+     * If more are given, placeholders without a corresponding replacementText will remain their original placeholder characters.
+     */
+    static ReplaceOccurrencesIn(source, placeholder, ...replacementTexts) {
+        // parameter guards
+        if (!(source)) {
+            return undefined;
+        }
+        if (!placeholder || replacementTexts.length === 0) {
+            return source;
+        }
+        let outString = source;
+        // one replacementText means replace for all
+        if (replacementTexts.length === 1) {
+            // "g" is the g flag to replace globally
+            outString = outString.replace(placeholder, replacementTexts[0]);
+        }
+        else {
+            // replace occurence i by replacementTexts[i], one at a time in loop (there might be a faster way..)
+            for (let i = 0, len = replacementTexts.length; i < len; i++) {
+                outString = outString.replace(placeholder, replacementTexts[i]);
+            }
+        }
+        return outString;
+    }
+    // Returns the given argument as a string. Returns given defaultValue if conversion of argument to string was impossible.
+    static ParseString(arg, defaultValue = "") {
+        if (!StringUtils.IsString(arg)) {
+            if (arg && typeof arg.toString === "function") {
+                arg = arg.toString();
+            }
+            else {
+                arg = defaultValue;
+            }
+        }
+        return arg;
+    }
+    static IsString(str) {
+        return typeof str === 'string';
+    }
+    // Returns whether given str is a string and has a length > 0.
+    static IsStringWithLength(str) {
+        return str && StringUtils.IsString(str) && str.length > 0;
+    }
+    /**
+     * Example usage:
+     * str = 'File is to large to upload. Maximum file size is {0} Mb'
+     * format = [FileUtils.MaxUploadSizeInMb]
+     * output = File is to large to upload. Maximum file size is 3 Mb
+     *
+     * str = '{0} is way better than {1}'
+     * format = ['Angular2','Angular1']
+     * output = Angular2 is way better than Angular1
+     *
+     * @param str The string that contains {0} and {1} etc, for replacement by given format data
+     * @param format The format replacement data
+     * @returns {string}
+     */
+    static Format(str, format) {
+        const args = Array.prototype.slice.call(format);
+        return str.replace(/{(\d+)}/g, function (match, number) {
+            return typeof args[number] !== "undefined" ? (args[number] !== null ? args[number] : "") : "";
+        });
+    }
+    // Returns a new string string with N amount of characters removed from the end of it.
+    static RemoveLastChars(str, amount) {
+        if (str) {
+            return str.slice(0, -1 * amount);
+        }
+        else {
+            return str;
+        }
+    }
+    // Returns given string, escaped for use as string literal in regular expressions.
+    static _escapeRegExp(str) {
+        return str; // .replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^$\|]/g, "\\$&");
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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