expensify-common 2.0.8 → 2.0.10

package/dist/str.js

@@ -27,19 +27,25 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 /* eslint-disable no-control-regex */
-const underscore_1 = __importDefault(require("underscore"));
+const escape_1 = __importDefault(require("lodash/escape"));
+const unescape_1 = __importDefault(require("lodash/unescape"));
 const awesome_phonenumber_1 = require("awesome-phonenumber");
 const HtmlEntities = __importStar(require("html-entities"));
 const Constants = __importStar(require("./CONST"));
 const UrlPatterns = __importStar(require("./Url"));
 const REMOVE_SMS_DOMAIN_PATTERN = /@expensify\.sms/gi;
+function resultFn(parameter, ...args) {
+    if (typeof parameter === 'function') {
+        return parameter(...args);
+    }
+    return parameter;
+}
 const Str = {
     /**
      * Return true if the string is ending with the provided suffix
      *
-     * @param {String} str String ot search in
-     * @param {String} suffix What to look for
-     * @return {Boolean}
+     * @param str String ot search in
+     * @param suffix What to look for
      */
     endsWith(str, suffix) {
         if (!str || !suffix) {
@@ -50,11 +56,11 @@ const Str = {
     /**
      * Converts a USD string into th number of cents it represents.
      *
-     * @param {String}  amountStr     A string representing a USD value.
-     * @param {Boolean} allowFraction Flag indicating if fractions of cents should be
+     * @param amountStr A string representing a USD value.
+     * @param allowFraction Flag indicating if fractions of cents should be
      *                               allowed in the output.
      *
-     * @return {Number} The cent value of the @p amountStr.
+     * @returns The cent value of the @p amountStr.
      */
     fromUSDToNumber(amountStr, allowFraction) {
         let amount = String(amountStr).replace(/[^\d.\-()]+/g, '');
@@ -63,20 +69,11 @@ const Str = {
             amount = `-${modifiedAmount}`;
         }
         amount = Number(amount) * 100;
-        // We round it here to a precision of 3 because some floating point numbers, when multiplied by 100
-        // don't give us a very pretty result. Try this in the JS console:
-        // 0.678 * 100
-        // 67.80000000000001
-        // 0.679 * 100
-        // 67.9
         amount = Math.round(amount * 1e3) / 1e3;
         return allowFraction ? amount : Math.round(amount);
     },
     /**
      * Truncates the middle section of a string based on the max allowed length
-     * @param {string} fullStr
-     * @param {int}    maxLength
-     * @returns {string}
      */
     truncateInMiddle(fullStr, maxLength) {
         if (fullStr.length <= maxLength) {
@@ -90,9 +87,6 @@ const Str = {
     },
     /**
      * Convert new line to <br />
-     *
-     * @param {String} str
-     * @returns {string}
      */
     nl2br(str) {
         return str.replace(/\n/g, '<br />');
@@ -100,8 +94,8 @@ const Str = {
     /**
      * Decodes the given HTML encoded string.
      *
-     * @param {String} s The string to decode.
-     * @return {String} The decoded string.
+     * @param s The string to decode.
+     * @returns The decoded string.
      */
     htmlDecode(s) {
         // Use jQuery if it exists or else use html-entities
@@ -113,8 +107,8 @@ const Str = {
     /**
      * HTML encodes the given string.
      *
-     * @param {String} s The string to encode.
-     * @return {String} @p s HTML encoded.
+     * @param s The string to encode.
+     * @return string @p s HTML encoded.
      */
     htmlEncode(s) {
         // Use jQuery if it exists or else use html-entities
@@ -126,18 +120,18 @@ const Str = {
     /**
      * Escape text while preventing any sort of double escape, so 'X & Y' -> 'X &amp; Y' and 'X &amp; Y' -> 'X &amp; Y'
      *
-     * @param {String} s the string to escape
-     * @return {String} the escaped string
+     * @param s The string to escape
+     * @returns The escaped string
      */
     safeEscape(s) {
-        return underscore_1.default.escape(underscore_1.default.unescape(s));
+        return (0, escape_1.default)((0, unescape_1.default)(s));
     },
     /**
      * HTML encoding insensitive equals.
      *
-     * @param {String} first string to compare
-     * @param {String} second string to compare
-     * @return {Boolean} true when first === second, ignoring HTML encoding
+     * @param first string to compare
+     * @param second string to compare
+     * @returns True when first === second, ignoring HTML encoding
      */
     htmlEncodingInsensitiveEquals(first, second) {
         return first === second || this.htmlDecode(first) === second || this.htmlEncode(first) === second;
@@ -145,8 +139,8 @@ const Str = {
     /**
      * Creates an ID that can be used as an HTML attribute from @p str.
      *
-     * @param {String} str A string to create an ID from.
-     * @return {String} The ID string made from @p str.
+     * @param str A string to create an ID from.
+     * @returns The ID string made from @p str.
      */
     makeID(str) {
         const modifiedString = String(str)
@@ -157,19 +151,18 @@ const Str = {
     /**
      * Extracts an ID made with Str.makeID from a larger string.
      *
-     * @param {String} str A string containing an id made with Str.makeID
-     * @return {String|null} The ID string.
+     * @param str A string containing an id made with Str.makeID
+     * @returns The ID string.
      */
     extractID(str) {
         const matches = str.match(/id[A-Z0-9_]+/);
-        return matches.length > 0 ? matches[0] : null;
+        return matches && matches.length > 0 ? matches[0] : null;
     },
     /**
      * Modifies the string so the first letter of each word is capitalized and the
      * rest lowercased.
      *
-     * @param {String} val The string to modify
-     * @return {String}
+     * @param val The string to modify
      */
     recapitalize(val) {
         // First replace every letter with its lowercase equivalent
@@ -188,26 +181,19 @@ const Str = {
     },
     /**
      * Replace all the non alphanumerical character by _
-     *
-     * @param {String} input
-     * @returns {String}
      */
     sanitizeToAlphaNumeric(input) {
         return String(input).replace(/[^\d\w]/g, '_');
     },
     /**
      * Strip out all the non numerical characters
-     *
-     * @param {String} input
-     * @returns {String}
      */
     stripNonNumeric(input) {
         return String(input).replace(/[^\d]/g, '');
     },
     /**
      * Strips all non ascii characters from a string
-     * @param {String} input
-     * @returns {String} The ascii version of the string.
+     * @returns The ascii version of the string.
      */
     stripNonASCIICharacters(input) {
         return String(input).replace(/[\u0000-\u0019\u0080-\uffff]/g, '');
@@ -218,9 +204,9 @@ const Str = {
      * The ellipses will only be appended if @p text is longer than the @p length
      * given.
      *
-     * @param {String} val   The string to reduce in size.
-     * @param {Number} length The maximal length desired.
-     * @return {String} The shortened @p text.
+     * @param val The string to reduce in size.
+     * @param length The maximal length desired.
+     * @returns The shortened @p text.
      */
     shortenText(val, length) {
         // Remove extra spaces because they don't show up in html anyway.
@@ -230,13 +216,13 @@ const Str = {
     },
     /**
      * Returns the byte size of a character
-     * @param {String} inputChar You can input more than one character, but it will only return the size of the first
+     * @param inputChar You can input more than one character, but it will only return the size of the first
      * one.
-     * @returns {Number} Byte size of the character
+     * @returns Byte size of the character
      */
     getRawByteSize(inputChar) {
         const onlyChar = String(inputChar);
-        const c = onlyChar.charCodeAt();
+        const c = onlyChar.charCodeAt(0);
         // If we are grabbing the byte size, we need to temporarily diable no-bitwise for linting
         /* eslint-disable no-bitwise */
         if (c < 1 << 7) {
@@ -262,23 +248,18 @@ const Str = {
     },
     /**
      * Gets the length of a string in bytes, including non-ASCII characters
-     * @param {String} input
-     * @returns {Number} The number of bytes used by string
+     * @returns The number of bytes used by string
      */
     getByteLength(input) {
         // Force string type
         const stringInput = String(input);
-        let byteLength = 0;
-        for (let i = 0; i < stringInput.length; i++) {
-            byteLength += this.getRawByteSize(stringInput[i]);
-        }
+        const byteLength = Array.from(stringInput).reduce((acc, char) => acc + this.getRawByteSize(char), 0);
         return byteLength;
     },
     /**
      * Shortens the input by max byte size instead of by character length
-     * @param {String} input
-     * @param {Number} maxSize The max size in bytes, e.g. 256
-     * @returns {String} Returns a shorted input if the input size exceeds the max
+     * @param maxSize The max size in bytes, e.g. 256
+     * @returns Returns a shorted input if the input size exceeds the max
      */
     shortenByByte(input, maxSize) {
         const stringInput = String(input);
@@ -296,9 +277,9 @@ const Str = {
     /**
      * Returns true if the haystack begins with the needle
      *
-     * @param {String} haystack  The full string to be searched
-     * @param {String} needle    The case-sensitive string to search for
-     * @return {Boolean} Retruns true if the haystack starts with the needle.
+     * @param haystack The full string to be searched
+     * @param needle  The case-sensitive string to search for
+     * @returns True if the haystack starts with the needle.
      */
     startsWith(haystack, needle) {
         return this.isString(haystack) && this.isString(needle) && haystack.substring(0, needle.length) === needle;
@@ -306,8 +287,8 @@ const Str = {
     /**
      * Gets the textual value of the given string.
      *
-     * @param {String} str The string to fetch the text value from.
-     * @return {String} The text from within the HTML string.
+     * @param str The string to fetch the text value from.
+     * @returns The text from within the HTML string.
      */
     stripHTML(str) {
         if (!this.isString(str)) {
@@ -318,8 +299,8 @@ const Str = {
     /**
      * Modifies the string so the first letter of the string is capitalized
      *
-     * @param {String} str The string to modify.
-     * @return {String} The recapitalized string.
+     * @param str The string to modify.
+     * @returns The recapitalized string.
      */
     UCFirst(str) {
         return str.substr(0, 1).toUpperCase() + str.substr(1);
@@ -329,9 +310,9 @@ const Str = {
      * of str to the first occurrence of substr.
      * Example: Str.cutAfter( 'hello$%world', '$%' ) // returns 'hello'
      *
-     * @param {String} str The string to modify.
-     * @param {String} substr The substring to search for.
-     * @return {String} The cut/trimmed string.
+     * @param str The string to modify.
+     * @param substr The substring to search for.
+     * @returns The cut/trimmed string.
      */
     cutAfter(str, substr) {
         const index = str.indexOf(substr);
@@ -345,9 +326,9 @@ const Str = {
      * occurrence of substr to the end of the string.
      * Example: Str.cutBefore( 'hello$%world', '$%' ) // returns 'world'
      *
-     * @param {String} str The string to modify.
-     * @param {String} substr The substring to search for.
-     * @return {String} The cut/trimmed string.
+     * @param str The string to modify.
+     * @param substr The substring to search for.
+     * @returns The cut/trimmed string.
      */
     cutBefore(str, substr) {
         const index = str.indexOf(substr);
@@ -359,60 +340,58 @@ const Str = {
     /**
      * Checks that the string is a domain name (e.g. example.com)
      *
-     * @param {String} string The string to check for domainnameness.
+     * @param str The string to check for domainnameness.
      *
-     * @returns {Boolean} True iff the string is a domain name
+     * @returns True if the string is a domain name
      */
-    isValidDomainName(string) {
-        return Boolean(String(string).match(Constants.CONST.REG_EXP.DOMAIN));
+    isValidDomainName(str) {
+        return Boolean(String(str).match(Constants.CONST.REG_EXP.DOMAIN));
     },
     /**
      * Checks that the string is a valid url
      *
-     * @param {String} string
-     *
-     * @returns {Boolean} True if the string is a valid hyperlink
+     * @returns True if the string is a valid hyperlink
      */
-    isValidURL(string) {
-        return Boolean(String(string).match(Constants.CONST.REG_EXP.HYPERLINK));
+    isValidURL(str) {
+        return Boolean(String(str).match(Constants.CONST.REG_EXP.HYPERLINK));
     },
     /**
      * Checks that the string is an email address.
      * NOTE: TLDs are not just 2-4 characters. Keep this in sync with _inputrules.php
      *
-     * @param {String} string The string to check for email validity.
+     * @param str The string to check for email validity.
      *
-     * @returns {Boolean} True iff the string is an email
+     * @returns True if the string is an email
      */
-    isValidEmail(string) {
-        return Boolean(String(string).match(Constants.CONST.REG_EXP.EMAIL));
+    isValidEmail(str) {
+        return Boolean(String(str).match(Constants.CONST.REG_EXP.EMAIL));
     },
     /**
      * Checks if the string is an valid email address formed during comment markdown formation.
      *
-     * @param {String} string The string to check for email validity.
+     * @param str The string to check for email validity.
      *
-     * @returns {Boolean} True if the string is an valid email created by comment markdown.
+     * @returns True if the string is an valid email created by comment markdown.
      */
-    isValidEmailMarkdown(string) {
-        return Boolean(String(string).match(`^${Constants.CONST.REG_EXP.MARKDOWN_EMAIL}$`));
+    isValidEmailMarkdown(str) {
+        return Boolean(String(str).match(`^${Constants.CONST.REG_EXP.MARKDOWN_EMAIL}$`));
     },
     /**
      * Remove trailing comma from a string.
      *
-     * @param {String} string The string with any trailing comma to be removed.
+     * @param str The string with any trailing comma to be removed.
      *
-     * @returns {String} string with the trailing comma removed
+     * @returns string with the trailing comma removed
      */
-    removeTrailingComma(string) {
-        return string.trim().replace(/(,$)/g, '');
+    removeTrailingComma(str) {
+        return str.trim().replace(/(,$)/g, '');
     },
     /**
      * Checks that the string is a list of coma separated email addresss.
      *
-     * @param {String} str The string to check for emails validity.
+     * @param str The string to check for emails validity.
      *
-     * @returns {Boolean} True if all emails are valid or if input is empty
+     * @returns True if all emails are valid or if input is empty
      */
     areValidEmails(str) {
         const string = this.removeTrailingComma(str);
@@ -420,30 +399,22 @@ const Str = {
             return true;
         }
         const emails = string.split(',');
-        let result = true;
-        for (let i = 0; i < emails.length; i += 1) {
-            if (!this.isValidEmail(emails[i].trim())) {
-                result = false;
-            }
-        }
+        const result = emails.every((email) => this.isValidEmail(email.trim()));
         return result;
     },
     /**
      * Extract the email addresses from a string
-     *
-     * @param {String} string
-     * @returns {String[]|null}
      */
-    extractEmail(string) {
-        return String(string).match(Constants.CONST.REG_EXP.EMAIL_SEARCH);
+    extractEmail(str) {
+        return String(str).match(Constants.CONST.REG_EXP.EMAIL_SEARCH);
     },
     /**
      * Extracts the domain name from the given email address
      * (e.g. "domain.com" for "joe@domain.com").
      *
-     * @param {String} email The email address.
+     * @param email The email address.
      *
-     * @returns {String} The domain name in the email address.
+     * @returns The domain name in the email address.
      */
     extractEmailDomain(email) {
         return this.cutBefore(email, '@');
@@ -452,9 +423,9 @@ const Str = {
      * Tries to extract the company name from the given email address
      * (e.g. "yelp" for "joe@yelp.co.uk").
      *
-     * @param {String} email The email address.
+     * @param email The email address.
      *
-     * @returns {String|null} The company name in the email address or null.
+     * @returns The company name in the email address or null.
      */
     extractCompanyNameFromEmailDomain(email) {
         const domain = this.extractEmailDomain(email);
@@ -471,18 +442,15 @@ const Str = {
      * Extracts the local part from the given email address
      * (e.g. "joe" for "joe@domain.com").
      *
-     * @param {String} email The email address.
+     * @param email The email address.
      *
-     * @returns {String} The local part in the email address.
+     * @returns The local part in the email address.
      */
     extractEmailLocalPart(email) {
         return this.cutAfter(email, '@');
     },
     /**
      * Sanitize phone number to return only numbers. Return null if non valid phone number.
-     *
-     * @param {String} str
-     * @returns {String|null}
      */
     sanitizePhoneNumber(str) {
         const string = str.replace(/(?!^\+)\D/g, '');
@@ -490,9 +458,6 @@ const Str = {
     },
     /**
      * Sanitize email. Return null if non valid email.
-     *
-     * @param {String} str
-     * @returns {String|null}
      */
     sanitizeEmail(str) {
         const string = str.toLowerCase().trim();
@@ -501,59 +466,52 @@ const Str = {
     /**
      * Escapes all special RegExp characters from a string
      *
-     * @param {String} string The subject
+     * @param str The subject
      *
-     * @returns {String} The escaped string
+     * @returns The escaped string
      */
-    escapeForRegExp(string) {
-        return string.replace(/[-[\]/{}()*+?.\\^$|]/g, '\\$&');
+    escapeForRegExp(str) {
+        return str.replace(/[-[\]/{}()*+?.\\^$|]/g, '\\$&');
     },
     /**
      * Escapes all special RegExp characters from a string except for the period
      *
-     * @param {String} string The subject
-     * @returns {String} The escaped string
+     * @param str The subject
+     * @returns The escaped string
      */
-    escapeForExpenseRule(string) {
-        return string.replace(/[-[\]/{}()*+?\\^$|]/g, '\\$&');
+    escapeForExpenseRule(str) {
+        return str.replace(/[-[\]/{}()*+?\\^$|]/g, '\\$&');
     },
     /**
      * Adds a backslash in front of each of colon
      * if they don't already have a backslash in front of them
      *
-     * @param {String} string The subject
-     * @returns {String} The escaped string
+     * @param str The subject
+     * @returns The escaped string
      */
-    addBackslashBeforeColonsForTagNamesComingFromQBD(string) {
-        return string.replace(/([^\\]):/g, '$1\\:');
+    addBackslashBeforeColonsForTagNamesComingFromQBD(str) {
+        return str.replace(/([^\\]):/g, '$1\\:');
     },
     /**
      * Removes backslashes from string
      * eg: myString\[\]\* -> myString[]*
-     *
-     * @param {String} string
-     * @returns {String}
      */
-    stripBackslashes(string) {
-        return string.replace(/\\/g, '');
+    stripBackslashes(str) {
+        return str.replace(/\\/g, '');
     },
     /**
      * Checks if a string's length is in the specified range
      *
-     * @param {String} string The subject
-     * @param {Number} minimumLength
-     * @param {Number} [maximumLength]
-     *
-     * @returns {Boolean} true if the length is in the range, false otherwise
+     * @returns true if the length is in the range, false otherwise
      */
-    isOfLength(string, minimumLength, maximumLength) {
-        if (!this.isString(string)) {
+    isOfLength(str, minimumLength, maximumLength) {
+        if (!this.isString(str)) {
             return false;
         }
-        if (string.length < minimumLength) {
+        if (str.length < minimumLength) {
             return false;
         }
-        if (!this.isUndefined(maximumLength) && string.length > maximumLength) {
+        if (!this.isUndefined(maximumLength) && str.length > maximumLength) {
             return false;
         }
         return true;
@@ -563,11 +521,11 @@ const Str = {
      * This is faster than counting the results of haystack.match( /needle/g )
      * via http://stackoverflow.com/questions/4009756/how-to-count-string-occurrence-in-string
      *
-     * @param {String} haystack The string to look inside of
-     * @param {String} needle What we're looking for
-     * @param {Boolean} allowOverlapping Defaults to false
+     * @param haystack The string to look inside of
+     * @param needle What we're looking for
+     * @param allowOverlapping Defaults to false
      *
-     * @returns {Integer} The number of times needle is in haystack.
+     * @returns The number of times needle is in haystack.
      */
     occurences(haystack, needle, allowOverlapping) {
         let count = 0;
@@ -592,8 +550,8 @@ const Str = {
      * Uppercases the first letter of each word
      * via https://github.com/kvz/phpjs/blob/master/functions/strings/ucwords.js
      *
-     * @param   {String}  str to uppercase words
-     * @returns {String}  Uppercase worded string
+     * @param str to uppercase words
+     * @returns Uppercase worded string
      */
     ucwords(str) {
         const capitalize = ($1) => $1.toUpperCase();
@@ -602,10 +560,10 @@ const Str = {
     /**
      * Returns true if the haystack contains the needle
      *
-     * @param {String} haystack The full string to be searched
-     * @param {String} needle The case-sensitive string to search for
+     * @param haystack The full string to be searched
+     * @param needle The case-sensitive string to search for
      *
-     * @return {Boolean} Retruns true if the haystack contains the needle
+     * @returns Returns true if the haystack contains the needle
      */
     contains(haystack, needle) {
         return haystack.indexOf(needle) !== -1;
@@ -613,10 +571,10 @@ const Str = {
     /**
      * Returns true if the haystack contains the needle, ignoring case
      *
-     * @param {String} haystack The full string to be searched
-     * @param {String} needle The case-insensitive string to search for
+     * @param haystack The full string to be searched
+     * @param needle The case-insensitive string to search for
      *
-     * @return {Boolean} Retruns true if the haystack contains the needle, ignoring case
+     * @returns Returns true if the haystack contains the needle, ignoring case
      */
     caseInsensitiveContains(haystack, needle) {
         return this.contains(haystack.toLowerCase(), needle.toLowerCase());
@@ -624,67 +582,66 @@ const Str = {
     /**
      * Case insensitive compare function
      *
-     * @param {String} string1 string to compare
-     * @param {String} string2 string to compare
+     * @param strA string to compare
+     * @param strB string to compare
      *
-     * @return {Number} -1 if first string < second string
+     * @returns -1 if first string < second string
      *                   1 if first string > second string
      *                   0 if first string = second string
      */
-    caseInsensitiveCompare(string1, string2) {
-        const lowerCase1 = string1.toLocaleLowerCase();
-        const lowerCase2 = string2.toLocaleLowerCase();
-        return this.compare(lowerCase1, lowerCase2);
+    caseInsensitiveCompare(strA, strB) {
+        const lowerCaseStrA = strA.toLocaleLowerCase();
+        const lowerCaseStrB = strB.toLocaleLowerCase();
+        return this.compare(lowerCaseStrA, lowerCaseStrB);
     },
     /**
      * Case insensitive equals
      *
-     * @param {String} first string to compare
-     * @param {String} second string to compare
-     * @return {Boolean} true when first == second except for case
+     * @param strA string to compare
+     * @param strB string to compare
+     * @returns true when first == second except for case
      */
-    caseInsensitiveEquals(first, second) {
-        return this.caseInsensitiveCompare(first, second) === 0;
+    caseInsensitiveEquals(strA, strB) {
+        return this.caseInsensitiveCompare(strA, strB) === 0;
     },
     /**
      * Compare function
      *
-     * @param {String} string1 string to compare
-     * @param {String} string2 string to compare
+     * @param strA string to compare
+     * @param strB string to compare
      *
-     * @return {Number} -1 if first string < second string
+     * @returns -1 if first string < second string
      *                   1 if first string > second string
      *                   0 if first string = second string
      */
-    compare(string1, string2) {
-        if (string1 < string2) {
+    compare(strA, strB) {
+        if (strA < strB) {
             return -1;
         }
-        if (string1 > string2) {
+        if (strA > strB) {
             return 1;
         }
         return 0;
     },
     /**
      * Check if a file extension is supported by SmartReports
-     * @param  {String}  filename
-     * @return {Boolean}
      */
     isFileExtensionSmartReportsValid(filename) {
+        var _a;
         // Allowed extensions. Make sure to keep them in sync with those defined
         // in SmartReport_Utils::templateFileUploadCheck()
         const allowedExtensions = ['xls', 'xlsx', 'xlsm', 'xltm'];
-        const extension = filename.split('.').pop().toLowerCase();
-        return allowedExtensions.indexOf(extension) > -1;
+        const extension = (_a = filename.split('.').pop()) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+        return !!extension && allowedExtensions.indexOf(extension) > -1;
     },
     /**
      * Mask Permanent Account Number (PAN) the same way Auth does
-     * @param {Number|String} number account number
-     * @return {String} masked account number
+     * @param num account number
+     * @returns masked account number
      */
-    maskPAN(number) {
+    maskPAN(num) {
         // cast to string
-        const accountNumber = String(number);
+        const accountNumber = String(num);
         const len = accountNumber.length;
         // Hide these numbers completely
         // We should not be getting account numbers this small or large
@@ -704,8 +661,6 @@ const Str = {
     /**
      * Checks if something is a string
      * Stolen from underscore
-     * @param  {Mixed} obj
-     * @return {Boolean}
      */
     isString(obj) {
         return this.isTypeOf(obj, 'String');
@@ -713,8 +668,7 @@ const Str = {
     /**
      * Checks if something is a number
      * Stolen from underscore
-     * @param  {Mixed} obj
-     * @return {Boolean}
+     * @param obj
      */
     isNumber(obj) {
         return this.isTypeOf(obj, 'Number');
@@ -722,10 +676,6 @@ const Str = {
     /**
      * Checks if something is a certain type
      * Stolen from underscore
-     * @param  {Mixed} obj
-     * @param  {String} type one of ['Arguments', 'Function', 'String', 'Number', 'Date',
-     *                       'RegExp', 'Error', 'Symbol', 'Map', 'WeakMap', 'Set', 'WeakSet']
-     * @return {Boolean}
      */
     isTypeOf(obj, type) {
         return Object.prototype.toString.call(obj) === `[object ${type}]`;
@@ -733,8 +683,6 @@ const Str = {
     /**
      * Checks to see if something is undefined
      * Stolen from underscore
-     * @param  {Mixed} obj
-     * @return {Boolean}
      */
     isUndefined(obj) {
         // eslint-disable-next-line no-void
@@ -743,40 +691,34 @@ const Str = {
     /**
      * Replace first N characters of the string with maskChar
      * eg: maskFirstNCharacters( '1234567890', 6, 'X' ) yields XXXXXX7890
-     * @param {String} str string to mask
-     * @param {Number} n number of characters we want to mask from the string
-     * @param {String} mask string we want replace the first N chars with
-     * @return {String} masked string
+     * @param str String to mask
+     * @param num Number of characters we want to mask from the string
+     * @param mask String we want replace the first N chars with
+     * @returns Masked string
      */
-    maskFirstNCharacters(str, n, mask) {
+    maskFirstNCharacters(str, num, mask) {
         // if str is empty, str or mask aren't strings,
         // or n is not a number, do nothing
-        if (!this.isString(str) || !this.isString(mask) || str.length === 0 || !this.isNumber(n)) {
+        if (!this.isString(str) || !this.isString(mask) || str.length === 0 || !this.isNumber(num)) {
             return str;
         }
-        return str.substring(0, n).replace(/./g, mask) + str.substring(n);
+        return str.substring(0, num).replace(/./g, mask) + str.substring(num);
     },
     /**
      * Trim a string
-     *
-     * @param {String} str
-     * @returns {string}
      */
     trim(str) {
         return $.trim(str);
     },
     /**
      * Convert a percentage string like '25%' to 25/
-     * @param {String} percentageString The percentage as a string
-     * @returns {Number}
+     * @param percentageString The percentage as a string
      */
     percentageStringToNumber(percentageString) {
         return Number(this.cutAfter(percentageString, '%'));
     },
     /**
-     * Remoce all the spaces from a string
-     * @param {string} input
-     * @returns {string}
+     * Remove all the spaces from a string
      */
     removeSpaces(input) {
         return String(input).replace(' ', '');
@@ -784,17 +726,15 @@ const Str = {
     /**
      * Returns the proper phrase depending on the count that is passed.
      * Example:
-     * console.log(Str.pluralize('puppy', 'puppies', 1)); // puppy
-     * console.log(Str.pluralize('puppy', 'puppies', 3)); // puppies
-     *
-     * @param {String} singular form of the phrase
-     * @param {String} plural form of the phrase
-     * @param {Number} n the count which determines the plurality
+     * console.log(Str.pluralize('puppy', 'puppies', 1)) { // puppy
+     * console.log(Str.pluralize('puppy', 'puppies', 3)) { // puppies
      *
-     * @return {String}
+     * @param singular form of the phrase
+     * @param plural form of the phrase
+     * @param num the count which determines the plurality
      */
-    pluralize(singular, plural, n) {
-        if (!n || n > 1) {
+    pluralize(singular, plural, num) {
+        if (!num || num > 1) {
             return plural;
         }
         return singular;
@@ -802,25 +742,23 @@ const Str = {
     /**
      * Returns whether or not a string is an encrypted number or not.
      *
-     * @param {String} number that we want to see if its encrypted or not
+     * @param num that we want to see if its encrypted or not
      *
-     * @return {Boolean} Whether or not this string is an encrpypted number
+     * @returns Whether or not this string is an encrpypted number
      */
-    isEncryptedCardNumber(number) {
+    isEncryptedCardNumber(num) {
         // Older encrypted versioning.
-        if (/^[\da-fA-F]+$/.test(number)) {
-            return number.length % 32 === 0;
+        if (/^[\da-fA-F]+$/.test(num)) {
+            return num.length % 32 === 0;
         }
         // Check with the new versioning.
-        if (/^[vV][\d]+:[\da-fA-F]+$/.test(number)) {
-            return number.split(':')[1].length % 32 === 0;
+        if (/^[vV][\d]+:[\da-fA-F]+$/.test(num)) {
+            return num.split(':')[1].length % 32 === 0;
         }
         return false;
     },
     /**
      * Converts a value to boolean, case-insensitive.
-     * @param {mixed} value
-     * @return {Boolean}
      */
     toBool(value) {
         if (this.isString(value)) {
@@ -831,14 +769,15 @@ const Str = {
     /**
      * Checks if a string could be the masked version of another one.
      *
-     * @param {String} first string to compare
-     * @param {String} second string to compare
-     * @param {String} [mask] defaults to X
-     * @return {Boolean} true when first could be the masked version of second
-     */
-    maskedEquals(first, second, mask) {
-        const firsts = first.match(/.{1,1}/g);
-        const seconds = second.match(/.{1,1}/g);
+     * @param strA String to compare
+     * @param strB String to compare
+     * @param [mask] Defaults to X
+     * @returns True when first could be the masked version of second
+     */
+    maskedEquals(strA, strB, mask) {
+        var _a, _b;
+        const firsts = (_a = strA.match(/.{1,1}/g)) !== null && _a !== void 0 ? _a : [];
+        const seconds = (_b = strB.match(/.{1,1}/g)) !== null && _b !== void 0 ? _b : [];
         const defaultMask = mask || 'X';
         if (firsts.length !== seconds.length) {
             return false;
@@ -852,18 +791,12 @@ const Str = {
     },
     /**
      * Bold any word matching the regexp in the text.
-     * @param {string} text, htmlEncoded
-     * @param {RegExp} regexp
-     * @return {string}
      */
     boldify(text, regexp) {
         return text.replace(regexp, '<strong>$1</strong>');
     },
     /**
      * Check for whether a phone number is valid.
-     * @param {String} phone
-     *
-     * @return {bool}
      * @deprecated use isValidE164Phone to validate E.164 phone numbers or isValidPhoneFormat to validate phone numbers in general
      */
     isValidPhone(phone) {
@@ -871,18 +804,12 @@ const Str = {
     },
     /**
      * Check for whether a phone number is valid.
-     * @param {String} phone
-     *
-     * @return {bool}
      */
     isValidPhoneNumber(phone) {
         return (0, awesome_phonenumber_1.parsePhoneNumber)(phone).possible;
     },
     /**
      * Check for whether a phone number is valid according to E.164 standard.
-     * @param {String} phone
-     *
-     * @return {bool}
      */
     isValidE164Phone(phone) {
         return Constants.CONST.SMS.E164_REGEX.test(phone);
@@ -894,18 +821,12 @@ const Str = {
      * e164: +14404589784
      * national: (440) 458-9784
      * 123.456.7890
-     * @param {String} phone
-     *
-     * @return {bool}
      */
     isValidPhoneFormat(phone) {
         return Constants.CONST.REG_EXP.GENERAL_PHONE_PART.test(phone);
     },
     /**
      * We validate mentions by checking if it's first character is an allowed character.
-     *
-     * @param {String} mention
-     * @returns {bool}
      */
     isValidMention(mention) {
         // Mentions can start @ proceeded by a space, eg "ping @user@domain.tld"
@@ -920,18 +841,12 @@ const Str = {
     },
     /**
      * Returns text without our SMS domain
-     *
-     * @param {String} text
-     * @return {String}
      */
     removeSMSDomain(text) {
         return text.replace(REMOVE_SMS_DOMAIN_PATTERN, '');
     },
     /**
      * Returns true if the text is a valid E.164 phone number with our SMS domain removed
-     *
-     * @param {String} text
-     * @return {String}
      */
     isSMSLogin(text) {
         return this.isValidE164Phone(this.removeSMSDomain(text));
@@ -941,28 +856,25 @@ const Str = {
      * JS yet, so this is a good way of doing it according to
      * https://github.com/airbnb/javascript/issues/1439#issuecomment-306297399 and doesn't get us in trouble with
      * linting rules.
-     *
-     * @param {String} str
-     * @param {RegExp} regex
-     *
-     * @returns {Array}
      */
     matchAll(str, regex) {
         const matches = [];
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const collectMatches = (...args) => {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             const match = Array.prototype.slice.call(args, 0, -2);
             match.input = args[args.length - 1];
             match.index = args[args.length - 2];
             matches.push(match);
         };
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         str.replace(regex, collectMatches);
         return matches;
     },
     /**
      * A simple GUID generator taken from https://stackoverflow.com/a/32760401/9114791
      *
-     * @param {String} [prefix] an optional prefix to put in front of the guid
-     * @returns {String}
+     * @param [prefix] an optional prefix to put in front of the guid
      */
     guid(prefix = '') {
         function s4() {
@@ -975,8 +887,8 @@ const Str = {
     /**
      * Takes in a URL and returns it with a leading '/'
      *
-     * @param {mixed} url The URL to be formatted
-     * @returns {String} The formatted URL
+     * @param url The URL to be formatted
+     * @returns The formatted URL
      */
     normalizeUrl(url) {
         return typeof url === 'string' && url.startsWith('/') ? url : `/${url}`;
@@ -984,8 +896,8 @@ const Str = {
     /**
      *  Formats a URL by converting the domain name to lowercase and adding the missing 'https://' protocol.
      *
-     * @param {url} url The URL to be formatted
-     * @returns {String} The formatted URL
+     * @param url The URL to be formatted
+     * @returns The formatted URL
      */
     sanitizeURL(url) {
         const regex = new RegExp(`^${UrlPatterns.URL_REGEX}$`, 'i');
@@ -1000,28 +912,21 @@ const Str = {
      * Checks if parameter is a string or function
      * if it is a function then we will call it with
      * any additional arguments.
-     *
-     * @param {String|Function} parameter
-     * @returns {String}
      */
-    result(parameter, ...args) {
-        return underscore_1.default.isFunction(parameter) ? parameter(...args) : parameter;
-    },
+    result: resultFn,
     /**
      * Get file extension for a given url with or
      * without query parameters
-     *
-     * @param {String} url
-     * @returns {String|undefined}
      */
     getExtension(url) {
-        return underscore_1.default.first(underscore_1.default.last(url.split('.')).split('?')).toLowerCase();
+        var _a, _b;
+        return (_b = (_a = url.split('.').pop()) === null || _a === void 0 ? void 0 : _a.split('?')[0]) === null || _b === void 0 ? void 0 : _b.toLowerCase();
     },
     /**
      * Takes in a URL and checks if the file extension is PDF
      *
-     * @param {String} url The URL to be checked
-     * @returns {Boolean} Whether file path is PDF or not
+     * @param url The URL to be checked
+     * @returns Whether file path is PDF or not
      */
     isPDF(url) {
         return this.getExtension(url) === 'pdf';
@@ -1033,12 +938,13 @@ const Str = {
      * supported by all platforms.
      *
      * https://reactnative.dev/docs/image#source
-     *
-     * @param {String} url
-     * @returns {Boolean}
      */
     isImage(url) {
-        return underscore_1.default.contains(['jpeg', 'jpg', 'gif', 'png', 'bmp', 'webp'], this.getExtension(url));
+        const extension = this.getExtension(url);
+        if (!extension) {
+            return false;
+        }
+        return ['jpeg', 'jpg', 'gif', 'png', 'bmp', 'webp'].includes(extension);
     },
     /**
      * Takes in a URL and checks if the file extension is a video
@@ -1048,30 +954,25 @@ const Str = {
      * https://developer.android.com/media/platform/supported-formats#video-formats
      * https://developer.apple.com/documentation/coremedia/1564239-video_codec_constants
      * https://developer.mozilla.org/en-US/docs/Web/Media/Formats/Video_codecs
-     *
-     * @param {String} url
-     * @returns {Boolean}
      */
     isVideo(url) {
-        return underscore_1.default.contains(['mov', 'mp4', 'webm', 'mkv'], this.getExtension(url));
+        const extension = this.getExtension(url);
+        if (!extension) {
+            return false;
+        }
+        return ['mov', 'mp4', 'webm', 'mkv'].includes(extension);
     },
     /**
      * Checks whether the given string is a +@ domain email account, such as
      * +@domain.com
      *
-     * @param {String} email
-     * @return {Boolean} True if is a domain account email, otherwise false.
+     * @returns True if is a domain account email, otherwise false.
      */
     isDomainEmail(email) {
         return this.startsWith(email, '+@');
     },
     /**
      * Polyfill for String.prototype.replaceAll
-     *
-     * @param {String} text
-     * @param {String|RegExp} searchValue
-     * @param {String|Function} replaceValue
-     * @returns {String}
      */
     replaceAll(text, searchValue, replaceValue) {
         return String.prototype.replaceAll.call(text, searchValue, replaceValue);