@kwiz/common 1.0.107 → 1.0.109

package/src/helpers/strings.ts

@@ -1,338 +1,338 @@
-import { IDictionary } from "../types/common.types";
-import { filterEmptyEntries, makeUniqueArray } from "./collections.base";
-import { isNullOrEmptyString, isNullOrUndefined, isNumber, isString } from "./typecheckers";
-
-export function endsWith(str: string, value: string, ignoreCase?: boolean): boolean {
-    let str1 = str;
-    let find = value;
-    if (ignoreCase) {
-        str1 = str1.toLowerCase();
-        find = find.toLowerCase();
-    }
-
-    return str1.substr(str1.length - find.length) === find;
-}
-
-export function startsWith(str: string, value: string, ignoreCase?: boolean): boolean {
-    let str1 = str;
-    let find = value;
-    if (ignoreCase) {
-        str1 = str1.toLowerCase();
-        find = find.toLowerCase();
-    }
-    return str1.substr(0, find.length) === find;
-}
-
-/** remove space at start or end */
-export function trim(str: string): string {
-    return str.replace(/^\s+|\s+$/g, '');
-}
-
-export function trimEnd(str: string): string {
-    return str.replace(/\s+$/, "");
-}
-
-export function trimStart(str: string): string {
-    return str.replace(/^\s+/, "");
-}
-
-export function splice(str: string, start: number, delCount: number, insert: string) {
-    return str.slice(0, start) + insert + str.slice(start + Math.abs(delCount));
-}
-
-export function padRight(value: string | number, length: number, fillString: string = "0") {
-    if (isNumber(value))
-        value = value.toString(10);
-    let pad = isNullOrEmptyString(fillString) ? "0" : fillString[0];
-    return value + Array(length - value.length + 1).join(pad);
-}
-
-export function padLeft(value: string | number, length: number, fillString: string = "0") {
-    if (isNumber(value))
-        value = value.toString(10);
-    let pad = isNullOrEmptyString(fillString) ? "0" : fillString[0];
-    return Array(length - String(value).length + 1).join(pad) + value;
-}
-
-/** returns array of [token] found inside the string 
- * supports token formats [Author??Created by {0}::Unknown author] will return "Author" as the token
- * */
-export function GetTokens(StringFormat: string): string[] {
-    let tokensResult: string[] = [];
-    if (isNullOrEmptyString(StringFormat)) return tokensResult;
-
-    let tokens = StringFormat.match(/\[[^\]]*\]/g);
-    if (tokens && tokens.length > 0) {
-        tokens.forEach(token => {
-            let key = token.slice(1, token.length - 1);
-            key = GetTokenInfo(key).tokenName;
-            if (tokensResult.indexOf(key) < 0)
-                tokensResult.push(key);
-        });
-    }
-
-    return tokensResult;
-}
-
-/** replaces a string with [token] and [otherToken] with their matched provided values
- * supports token formats [Author??Created by {0}::Unknown author]
- */
-export function ReplaceTokens(StringFormat: string, TokenValues: IDictionary<string>, options?: {
-    /**set to true if you want to keep "[token]" in the string when a token value wasn't provided */
-    keepMissingTokens?: boolean;
-}): string {
-
-    let skipMissingTokens = options && options.keepMissingTokens;
-
-    if (isNullOrUndefined(StringFormat)) return null;
-    if (StringFormat !== '') {
-        let tokens = StringFormat.match(/\[[^\]]*\]/g);
-        if (tokens && tokens.length > 0) {
-            if (isNullOrUndefined(TokenValues)) TokenValues = {};
-
-            tokens.forEach(token => {
-                let key = token.slice(1, token.length - 1);
-                let tokenInfo = GetTokenInfo(key);
-                let value = TokenValues[tokenInfo.tokenName];
-                let skip = false;
-                if (isNullOrUndefined(value)) {
-                    value = "";
-                    skip = skipMissingTokens;//if true we won't replace this one
-                }
-                if (!skip || tokenInfo.hasFormat)
-                    StringFormat = StringFormat.replace(token, tokenInfo.getValue(value));
-            });
-        }
-    }
-    return StringFormat;
-}
-
-/** calls replace tokens on every dictionary value, or set null keys to "". This function ignores null/empty dictionaries */
-export function ReplaceTokensInDictionary(Dictionary: IDictionary<string>, TokenValues: IDictionary<string>) {
-    if (!isNullOrUndefined(Dictionary)) {
-        Object.keys(Dictionary).forEach(key => {
-            Dictionary[key] = isNullOrEmptyString(Dictionary[key]) ? "" : ReplaceTokens(Dictionary[key], TokenValues);
-        });
-    }
-}
-
-/** Normalizes a guid string, lower case and removes {} */
-export function normalizeGuid(text: string, removeDashes?: boolean): string {
-    if (isNullOrEmptyString(text) || !isString(text)) {
-        return text;
-    }
-    var guid = text.toLowerCase().trim();
-
-    if (guid.startsWith("{")) {
-        guid = guid.substr(1);
-    }
-
-    if (guid.endsWith("}")) {
-        guid = guid.substr(0, guid.length - 1);
-    }
-
-    if (removeDashes) {
-        guid = guid.replace(/-/g, '');
-    }
-
-    return guid;
-}
-
-export function isEmptyGuid(guid: { toString(): string; }) {
-    if (isNullOrEmptyString(guid)) return true;
-    else if (Number(normalizeGuid(guid.toString(), true)) === 0) return true;
-    return false;
-}
-
-export function escapeRegExp(text: string) {
-    return text.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
-}
-
-export function isValidDomainLogin(login: string) {
-    return /^[A-Za-z0-9\\._-]{7,}$/.test(login);
-}
-
-export function stripRichTextWhitespace(value: string) {
-    // richText fields in have random markup even when field is empty
-    // \u200B zero width space
-    // \u200C zero width non-joiner Unicode code point
-    // \u200D zero width joiner Unicode code point
-    // \uFEFF zero width no-break space Unicode code point       
-    return isString(value) ? value.replace(/[\u200B-\u200D\uFEFF]/g, "") : value;
-}
-
-/** allows min length 1, letters, numbers underscore only */
-export function isValidVarName(text: string) {
-    return /^[A-Za-z0-9_]{1,}$/.test(text);
-}
-
-/** allows min length 1, letters, numbers underscore and hyphen only */
-export function isValidHeaderName(text: string) {
-    return /^[A-Za-z0-9_-]{1,}$/.test(text);
-}
-
-/** returns token info with format  */
-export function GetTokenInfo(text: string) {
-    let split = text.split('??');
-    let hasFormat = split.length > 0 && !isNullOrEmptyString(split[1]);
-    let formatSplit = hasFormat ? split[1].split('::') : [];
-    let valueIfEmpty = formatSplit.length > 1 ? formatSplit[1] : "";
-    let formatIfNotEmpty = formatSplit[0];
-    let info = {
-        tokenName: hasFormat ? split[0] : text,
-        hasFormat: hasFormat,
-        getValue: (value: string) => {
-            if (!hasFormat) return value;
-            else {
-                if (isNullOrEmptyString(value)) return valueIfEmpty;
-                else return formatIfNotEmpty.replace('{0}', value);
-            }
-        }
-    };
-    return info;
-}
-
-/** return true if both strings are the same, or both are empty/null/undefined */
-export function stringEqualsOrEmpty(str1: string, str2: string, ignoreCase?: boolean) {
-    if (isNullOrEmptyString(str1) && isNullOrEmptyString(str2)) return true;
-    if (ignoreCase) {
-        if (!isNullOrEmptyString(str1)) str1 = str1.toLowerCase();
-        if (!isNullOrEmptyString(str2)) str2 = str2.toLowerCase();
-    }
-
-    return str1 === str2;
-}
-
-/** return true if str1 contains str2 */
-export function stringContains(str1: string, str2: string, ignoreCase?: boolean) {
-    if (isNullOrEmptyString(str1) && isNullOrEmptyString(str2)) return true;
-
-    if (isNullOrEmptyString(str1))
-        str1 = "";
-    if (isNullOrEmptyString(str2))
-        str2 = "";
-
-    if (ignoreCase) {
-        str1 = str1.toLowerCase();
-        str2 = str2.toLowerCase();
-    }
-
-    return str1.indexOf(str2) >= 0;
-}
-
-export function cleanupString(str: string, options: {
-    replaceNewLines?: string;
-    collapseMultipleSpaces?: string;
-    collapseMultipleDashes?: string;
-    collapseMultipleUnderscore?: string;
-}) {
-    if (isString(options.replaceNewLines))
-        str = str.replace(/\r/g, '')//no returns
-            .replace(/\n/g, options.replaceNewLines);//no line breaks
-    if (isString(options.collapseMultipleDashes))
-        str = str.replace(/-+/g, options.collapseMultipleSpaces);//no extra spaces
-    if (isString(options.collapseMultipleUnderscore))
-        str = str.replace(/_+/g, options.collapseMultipleUnderscore);//no extra spaces
-
-    // do this last, so it will collapse spaces added by previous options
-    if (isString(options.collapseMultipleSpaces)) {
-        str = str.replace(new RegExp(String.fromCharCode(160), "g"), '')//get rid of non-breaking spaces
-            .replace(/ +/g, options.collapseMultipleSpaces);//no extra spaces
-    }
-
-    return str;
-}
-
-/** normalizes &#160; to &nbsp; see Issue 752 */
-export function normalizeHtmlSpace(html: string) {
-    if (isNullOrEmptyString(html)) return html;
-    return html.replace(/&#160;/i, "&nbsp;");
-}
-
-export function replaceAll(str: string, find: string, replace: string, ignoreCase = false) {
-    //must call escapeRegExp on find, to make sure it works when there are protected regex characters
-    return str.replace(new RegExp(escapeRegExp(find), `g${ignoreCase ? 'i' : ''}`), replace);
-}
-
-export function capitalizeFirstLetter(str: string) {
-    return isNullOrEmptyString(str)
-        ? ""
-        : `${str.charAt(0).toUpperCase()}${str.substring(1)}`;
-}
-
-export function escapeXml(unsafe: string, isAttribute = false) {
-    if (isNullOrEmptyString(unsafe)) return "";
-    return isAttribute
-        ? unsafe.replace(/[<>&'"]/g, (c) => {
-            switch (c) {
-                case '<': return '&lt;';
-                case '>': return '&gt;';
-                case '&': return '&amp;';
-                case '\'': return '&apos;';
-                case '"': return '&quot;';
-            }
-            return c;
-        })
-        : unsafe.replace(/[<>&]/g, (c) => {
-            switch (c) {
-                case '<': return '&lt;';
-                case '>': return '&gt;';
-                case '&': return '&amp;';
-            }
-            return c;
-        });
-}
-
-/** uses regex str.match to replace each match by calling the replacer function (imported from CMS) */
-export function replaceRegex(str: string, regex: RegExp, replacer: (match: string) => string | null) {
-    let matches = str.match(regex);
-    if (!matches || matches.length < 1) return str;
-    //replace each found token only once
-    let unique = makeUniqueArray(matches);
-    //todo: this has a bug where tokens matched contain each other, example, match numbers and prefix with #: 10, 100 will match both and produce #10 ##100
-    unique.forEach(m => {
-        let replacement = replacer(m);
-        if (!isNullOrUndefined(replacement))//ignore nulls
-            str = replaceAll(str, m, replacement);
-    });
-    return str;
-}
-
-/** masks a long string, keeping X number for characters at the start/end and replacing the middle with the mask string (default: CC*****CCC) */
-export function maskString(str: string, options?: {
-    /** mask string, default ***** */
-    mask?: string;
-    /** characters to keep at start, default 2 */
-    start?: number;
-    /** characters to keep at end, default 2 */
-    end?: number;
-}) {
-    const mask = options && options.mask || "*****";
-    const start = options && isNumber(options.start) ? options.start : 2;
-    const end = options && isNumber(options.end) ? options.end : 2;
-    const prefix = start >= 0 ? str.slice(0, start) : str;
-    const sliceEnd = str.length - end;
-    const suffix = sliceEnd >= 0 ? str.slice(sliceEnd) : str;
-
-    return `${prefix}${mask}${suffix}`;
-}
-
-export function splitString(str: string, options: { maxLength?: number; marker?: string | RegExp; clearEmptyEntries?: boolean }) {
-    let strArr: string[] = [str];
-    if (!isNullOrUndefined(options.marker)) strArr = str.split(options.marker);
-    if (isNumber(options.maxLength) && options.maxLength > 0) {
-        let splitted: string[] = [];
-        strArr.forEach(currentStr => {
-            while (currentStr.length > 0) {
-                splitted.push(currentStr.slice(0, options.maxLength));
-                currentStr = currentStr.slice(options.maxLength);
-            }
-        });
-
-        strArr = splitted;
-    }
-
-    if (options.clearEmptyEntries)
-        strArr = filterEmptyEntries(strArr);
-    return strArr;
+import { IDictionary } from "../types/common.types";
+import { filterEmptyEntries, makeUniqueArray } from "./collections.base";
+import { isNullOrEmptyString, isNullOrUndefined, isNumber, isString } from "./typecheckers";
+
+export function endsWith(str: string, value: string, ignoreCase?: boolean): boolean {
+    let str1 = str;
+    let find = value;
+    if (ignoreCase) {
+        str1 = str1.toLowerCase();
+        find = find.toLowerCase();
+    }
+
+    return str1.substr(str1.length - find.length) === find;
+}
+
+export function startsWith(str: string, value: string, ignoreCase?: boolean): boolean {
+    let str1 = str;
+    let find = value;
+    if (ignoreCase) {
+        str1 = str1.toLowerCase();
+        find = find.toLowerCase();
+    }
+    return str1.substr(0, find.length) === find;
+}
+
+/** remove space at start or end */
+export function trim(str: string): string {
+    return str.replace(/^\s+|\s+$/g, '');
+}
+
+export function trimEnd(str: string): string {
+    return str.replace(/\s+$/, "");
+}
+
+export function trimStart(str: string): string {
+    return str.replace(/^\s+/, "");
+}
+
+export function splice(str: string, start: number, delCount: number, insert: string) {
+    return str.slice(0, start) + insert + str.slice(start + Math.abs(delCount));
+}
+
+export function padRight(value: string | number, length: number, fillString: string = "0") {
+    if (isNumber(value))
+        value = value.toString(10);
+    let pad = isNullOrEmptyString(fillString) ? "0" : fillString[0];
+    return value + Array(length - value.length + 1).join(pad);
+}
+
+export function padLeft(value: string | number, length: number, fillString: string = "0") {
+    if (isNumber(value))
+        value = value.toString(10);
+    let pad = isNullOrEmptyString(fillString) ? "0" : fillString[0];
+    return Array(length - String(value).length + 1).join(pad) + value;
+}
+
+/** returns array of [token] found inside the string 
+ * supports token formats [Author??Created by {0}::Unknown author] will return "Author" as the token
+ * */
+export function GetTokens(StringFormat: string): string[] {
+    let tokensResult: string[] = [];
+    if (isNullOrEmptyString(StringFormat)) return tokensResult;
+
+    let tokens = StringFormat.match(/\[[^\]]*\]/g);
+    if (tokens && tokens.length > 0) {
+        tokens.forEach(token => {
+            let key = token.slice(1, token.length - 1);
+            key = GetTokenInfo(key).tokenName;
+            if (tokensResult.indexOf(key) < 0)
+                tokensResult.push(key);
+        });
+    }
+
+    return tokensResult;
+}
+
+/** replaces a string with [token] and [otherToken] with their matched provided values
+ * supports token formats [Author??Created by {0}::Unknown author]
+ */
+export function ReplaceTokens(StringFormat: string, TokenValues: IDictionary<string>, options?: {
+    /**set to true if you want to keep "[token]" in the string when a token value wasn't provided */
+    keepMissingTokens?: boolean;
+}): string {
+
+    let skipMissingTokens = options && options.keepMissingTokens;
+
+    if (isNullOrUndefined(StringFormat)) return null;
+    if (StringFormat !== '') {
+        let tokens = StringFormat.match(/\[[^\]]*\]/g);
+        if (tokens && tokens.length > 0) {
+            if (isNullOrUndefined(TokenValues)) TokenValues = {};
+
+            tokens.forEach(token => {
+                let key = token.slice(1, token.length - 1);
+                let tokenInfo = GetTokenInfo(key);
+                let value = TokenValues[tokenInfo.tokenName];
+                let skip = false;
+                if (isNullOrUndefined(value)) {
+                    value = "";
+                    skip = skipMissingTokens;//if true we won't replace this one
+                }
+                if (!skip || tokenInfo.hasFormat)
+                    StringFormat = StringFormat.replace(token, tokenInfo.getValue(value));
+            });
+        }
+    }
+    return StringFormat;
+}
+
+/** calls replace tokens on every dictionary value, or set null keys to "". This function ignores null/empty dictionaries */
+export function ReplaceTokensInDictionary(Dictionary: IDictionary<string>, TokenValues: IDictionary<string>) {
+    if (!isNullOrUndefined(Dictionary)) {
+        Object.keys(Dictionary).forEach(key => {
+            Dictionary[key] = isNullOrEmptyString(Dictionary[key]) ? "" : ReplaceTokens(Dictionary[key], TokenValues);
+        });
+    }
+}
+
+/** Normalizes a guid string, lower case and removes {} */
+export function normalizeGuid(text: string, removeDashes?: boolean): string {
+    if (isNullOrEmptyString(text) || !isString(text)) {
+        return text;
+    }
+    var guid = text.toLowerCase().trim();
+
+    if (guid.startsWith("{")) {
+        guid = guid.substr(1);
+    }
+
+    if (guid.endsWith("}")) {
+        guid = guid.substr(0, guid.length - 1);
+    }
+
+    if (removeDashes) {
+        guid = guid.replace(/-/g, '');
+    }
+
+    return guid;
+}
+
+export function isEmptyGuid(guid: { toString(): string; }) {
+    if (isNullOrEmptyString(guid)) return true;
+    else if (Number(normalizeGuid(guid.toString(), true)) === 0) return true;
+    return false;
+}
+
+export function escapeRegExp(text: string) {
+    return text.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
+}
+
+export function isValidDomainLogin(login: string) {
+    return /^[A-Za-z0-9\\._-]{7,}$/.test(login);
+}
+
+export function stripRichTextWhitespace(value: string) {
+    // richText fields in have random markup even when field is empty
+    // \u200B zero width space
+    // \u200C zero width non-joiner Unicode code point
+    // \u200D zero width joiner Unicode code point
+    // \uFEFF zero width no-break space Unicode code point       
+    return isString(value) ? value.replace(/[\u200B-\u200D\uFEFF]/g, "") : value;
+}
+
+/** allows min length 1, letters, numbers underscore only */
+export function isValidVarName(text: string) {
+    return /^[A-Za-z0-9_]{1,}$/.test(text);
+}
+
+/** allows min length 1, letters, numbers underscore and hyphen only */
+export function isValidHeaderName(text: string) {
+    return /^[A-Za-z0-9_-]{1,}$/.test(text);
+}
+
+/** returns token info with format  */
+export function GetTokenInfo(text: string) {
+    let split = text.split('??');
+    let hasFormat = split.length > 0 && !isNullOrEmptyString(split[1]);
+    let formatSplit = hasFormat ? split[1].split('::') : [];
+    let valueIfEmpty = formatSplit.length > 1 ? formatSplit[1] : "";
+    let formatIfNotEmpty = formatSplit[0];
+    let info = {
+        tokenName: hasFormat ? split[0] : text,
+        hasFormat: hasFormat,
+        getValue: (value: string) => {
+            if (!hasFormat) return value;
+            else {
+                if (isNullOrEmptyString(value)) return valueIfEmpty;
+                else return formatIfNotEmpty.replace('{0}', value);
+            }
+        }
+    };
+    return info;
+}
+
+/** return true if both strings are the same, or both are empty/null/undefined */
+export function stringEqualsOrEmpty(str1: string, str2: string, ignoreCase?: boolean) {
+    if (isNullOrEmptyString(str1) && isNullOrEmptyString(str2)) return true;
+    if (ignoreCase) {
+        if (!isNullOrEmptyString(str1)) str1 = str1.toLowerCase();
+        if (!isNullOrEmptyString(str2)) str2 = str2.toLowerCase();
+    }
+
+    return str1 === str2;
+}
+
+/** return true if str1 contains str2 */
+export function stringContains(str1: string, str2: string, ignoreCase?: boolean) {
+    if (isNullOrEmptyString(str1) && isNullOrEmptyString(str2)) return true;
+
+    if (isNullOrEmptyString(str1))
+        str1 = "";
+    if (isNullOrEmptyString(str2))
+        str2 = "";
+
+    if (ignoreCase) {
+        str1 = str1.toLowerCase();
+        str2 = str2.toLowerCase();
+    }
+
+    return str1.indexOf(str2) >= 0;
+}
+
+export function cleanupString(str: string, options: {
+    replaceNewLines?: string;
+    collapseMultipleSpaces?: string;
+    collapseMultipleDashes?: string;
+    collapseMultipleUnderscore?: string;
+}) {
+    if (isString(options.replaceNewLines))
+        str = str.replace(/\r/g, '')//no returns
+            .replace(/\n/g, options.replaceNewLines);//no line breaks
+    if (isString(options.collapseMultipleDashes))
+        str = str.replace(/-+/g, options.collapseMultipleSpaces);//no extra spaces
+    if (isString(options.collapseMultipleUnderscore))
+        str = str.replace(/_+/g, options.collapseMultipleUnderscore);//no extra spaces
+
+    // do this last, so it will collapse spaces added by previous options
+    if (isString(options.collapseMultipleSpaces)) {
+        str = str.replace(new RegExp(String.fromCharCode(160), "g"), '')//get rid of non-breaking spaces
+            .replace(/ +/g, options.collapseMultipleSpaces);//no extra spaces
+    }
+
+    return str;
+}
+
+/** normalizes &#160; to &nbsp; see Issue 752 */
+export function normalizeHtmlSpace(html: string) {
+    if (isNullOrEmptyString(html)) return html;
+    return html.replace(/&#160;/i, "&nbsp;");
+}
+
+export function replaceAll(str: string, find: string, replace: string, ignoreCase = false) {
+    //must call escapeRegExp on find, to make sure it works when there are protected regex characters
+    return str.replace(new RegExp(escapeRegExp(find), `g${ignoreCase ? 'i' : ''}`), replace);
+}
+
+export function capitalizeFirstLetter(str: string) {
+    return isNullOrEmptyString(str)
+        ? ""
+        : `${str.charAt(0).toUpperCase()}${str.substring(1)}`;
+}
+
+export function escapeXml(unsafe: string, isAttribute = false) {
+    if (isNullOrEmptyString(unsafe)) return "";
+    return isAttribute
+        ? unsafe.replace(/[<>&'"]/g, (c) => {
+            switch (c) {
+                case '<': return '&lt;';
+                case '>': return '&gt;';
+                case '&': return '&amp;';
+                case '\'': return '&apos;';
+                case '"': return '&quot;';
+            }
+            return c;
+        })
+        : unsafe.replace(/[<>&]/g, (c) => {
+            switch (c) {
+                case '<': return '&lt;';
+                case '>': return '&gt;';
+                case '&': return '&amp;';
+            }
+            return c;
+        });
+}
+
+/** uses regex str.match to replace each match by calling the replacer function (imported from CMS) */
+export function replaceRegex(str: string, regex: RegExp, replacer: (match: string) => string | null) {
+    let matches = str.match(regex);
+    if (!matches || matches.length < 1) return str;
+    //replace each found token only once
+    let unique = makeUniqueArray(matches);
+    //todo: this has a bug where tokens matched contain each other, example, match numbers and prefix with #: 10, 100 will match both and produce #10 ##100
+    unique.forEach(m => {
+        let replacement = replacer(m);
+        if (!isNullOrUndefined(replacement))//ignore nulls
+            str = replaceAll(str, m, replacement);
+    });
+    return str;
+}
+
+/** masks a long string, keeping X number for characters at the start/end and replacing the middle with the mask string (default: CC*****CCC) */
+export function maskString(str: string, options?: {
+    /** mask string, default ***** */
+    mask?: string;
+    /** characters to keep at start, default 2 */
+    start?: number;
+    /** characters to keep at end, default 2 */
+    end?: number;
+}) {
+    const mask = options && options.mask || "*****";
+    const start = options && isNumber(options.start) ? options.start : 2;
+    const end = options && isNumber(options.end) ? options.end : 2;
+    const prefix = start >= 0 ? str.slice(0, start) : str;
+    const sliceEnd = str.length - end;
+    const suffix = sliceEnd >= 0 ? str.slice(sliceEnd) : str;
+
+    return `${prefix}${mask}${suffix}`;
+}
+
+export function splitString(str: string, options: { maxLength?: number; marker?: string | RegExp; clearEmptyEntries?: boolean }) {
+    let strArr: string[] = [str];
+    if (!isNullOrUndefined(options.marker)) strArr = str.split(options.marker);
+    if (isNumber(options.maxLength) && options.maxLength > 0) {
+        let splitted: string[] = [];
+        strArr.forEach(currentStr => {
+            while (currentStr.length > 0) {
+                splitted.push(currentStr.slice(0, options.maxLength));
+                currentStr = currentStr.slice(options.maxLength);
+            }
+        });
+
+        strArr = splitted;
+    }
+
+    if (options.clearEmptyEntries)
+        strArr = filterEmptyEntries(strArr);
+    return strArr;
 }