expensify-common 2.0.8 → 2.0.10

package/dist/ExpensiMark.js

@@ -75,9 +75,8 @@ class ExpensiMark {
                     return `<pre>${group}</pre>`;
                 },
                 rawInputReplacement: (match, __, textWithinFences) => {
-                    const withinFences = match.replace(/(?:&#x60;&#x60;&#x60;)([\s\S]*?)(?:&#x60;&#x60;&#x60;)/g, '$1');
-                    const group = textWithinFences.replace(/(?:(?![\n\r])\s)/g, '&#32;');
-                    return `<pre data-code-raw="${withinFences}">${group}</pre>`;
+                    const group = textWithinFences.replace(/(?:(?![\n\r])\s)/g, '&#32;').replace(/<emoji>|<\/emoji>/g, '');
+                    return `<pre>${group}</pre>`;
                 },
             },
             /**
@@ -188,7 +187,7 @@ class ExpensiMark {
              */
             {
                 name: 'reportMentions',
-                regex: /(?<![^ \n*~_])(#[\p{Ll}0-9-]{1,80})/gimu,
+                regex: /(?<![^ \n*~_])(#[\p{Ll}0-9-]{1,80})(?![^<]*(?:<\/pre>|<\/code>))/gimu,
                 replacement: '<mention-report>$1</mention-report>',
             },
             /**

package/dist/components/form/element/dropdownItem.d.ts

@@ -12,7 +12,7 @@ declare class DropDownItem extends React.Component<any, any, any> {
      */
     destroyTooltip(): void;
     render(): React.JSX.Element;
-    tooltipContainer: any;
+    tooltipContainer: JQueryStatic | undefined;
 }
 declare namespace DropDownItem {
     export { propTypes };

package/dist/jquery.expensifyIframify.d.ts

@@ -5,6 +5,6 @@ declare namespace _default {
      * @param {jQuery} $
      * @param {Underscore} _
      */
-    function load($: jQuery, _: Underscore): void;
+    function load($: JQueryStatic, _: Underscore): void;
 }
 export default _default;

package/dist/str.d.ts

@@ -1,3 +1,10 @@
+/**
+ * Checks if parameter is a string or function
+ * if it is a function then we will call it with
+ * any additional arguments.
+ */
+declare function resultFn(parameter: string): string;
+declare function resultFn<R, A extends unknown[]>(parameter: (...args: A) => R, ...args: A): R;
 declare const Str: {
     /**
      * Return true if the string is ending with the provided suffix
@@ -9,7 +16,7 @@ declare const Str: {
     /**
      * Converts a USD string into th number of cents it represents.
      *
-     * @param  amountStr     A string representing a USD value.
+     * @param amountStr A string representing a USD value.
      * @param allowFraction Flag indicating if fractions of cents should be
      *                               allowed in the output.
      *
@@ -18,15 +25,10 @@ declare const Str: {
     fromUSDToNumber(amountStr: string, allowFraction: boolean): number;
     /**
      * Truncates the middle section of a string based on the max allowed length
-     *
-     * @param fullStr
-     * @param    maxLength
      */
     truncateInMiddle(fullStr: string, maxLength: number): string;
     /**
      * Convert new line to <br />
-     *
-     * @param str
      */
     nl2br(str: string): string;
     /**
@@ -40,14 +42,14 @@ declare const Str: {
      * HTML encodes the given string.
      *
      * @param s The string to encode.
-     * @returns @p s HTML encoded.
+     * @return string @p s HTML encoded.
      */
     htmlEncode(s: string): string;
     /**
      * Escape text while preventing any sort of double escape, so 'X & Y' -> 'X &amp; Y' and 'X &amp; Y' -> 'X &amp; Y'
      *
-     * @param s the string to escape
-     * @returns the escaped string
+     * @param s The string to escape
+     * @returns The escaped string
      */
     safeEscape(s: string): string;
     /**
@@ -55,7 +57,7 @@ declare const Str: {
      *
      * @param first string to compare
      * @param second string to compare
-     * @returns true when first === second, ignoring HTML encoding
+     * @returns True when first === second, ignoring HTML encoding
      */
     htmlEncodingInsensitiveEquals(first: string, second: string): boolean;
     /**
@@ -81,19 +83,14 @@ declare const Str: {
     recapitalize(val: string): string;
     /**
      * Replace all the non alphanumerical character by _
-     *
-     * @param input
      */
     sanitizeToAlphaNumeric(input: string): string;
     /**
      * Strip out all the non numerical characters
-     *
-     * @param input
      */
     stripNonNumeric(input: string): string;
     /**
      * Strips all non ascii characters from a string
-     * @param input
      * @returns The ascii version of the string.
      */
     stripNonASCIICharacters(input: string): string;
@@ -103,7 +100,7 @@ declare const Str: {
      * The ellipses will only be appended if @p text is longer than the @p length
      * given.
      *
-     * @param val   The string to reduce in size.
+     * @param val The string to reduce in size.
      * @param length The maximal length desired.
      * @returns The shortened @p text.
      */
@@ -117,13 +114,11 @@ declare const Str: {
     getRawByteSize(inputChar: string): number;
     /**
      * Gets the length of a string in bytes, including non-ASCII characters
-     * @param input
      * @returns The number of bytes used by string
      */
     getByteLength(input: string): number;
     /**
      * Shortens the input by max byte size instead of by character length
-     * @param input
      * @param maxSize The max size in bytes, e.g. 256
      * @returns Returns a shorted input if the input size exceeds the max
      */
@@ -131,9 +126,9 @@ declare const Str: {
     /**
      * Returns true if the haystack begins with the needle
      *
-     * @param haystack  The full string to be searched
-     * @param needle    The case-sensitive string to search for
-     * @returns 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: string, needle: string): boolean;
     /**
@@ -173,44 +168,42 @@ declare const Str: {
     /**
      * Checks that the string is a domain name (e.g. example.com)
      *
-     * @param string The string to check for domainnameness.
+     * @param str The string to check for domainnameness.
      *
-     * @returns True iff the string is a domain name
+     * @returns True if the string is a domain name
      */
-    isValidDomainName(string: string): boolean;
+    isValidDomainName(str: string): boolean;
     /**
      * Checks that the string is a valid url
      *
-     * @param string
-     *
      * @returns True if the string is a valid hyperlink
      */
-    isValidURL(string: string): boolean;
+    isValidURL(str: string): boolean;
     /**
      * 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 The string to check for email validity.
+     * @param str The string to check for email validity.
      *
-     * @returns True iff the string is an email
+     * @returns True if the string is an email
      */
-    isValidEmail(string: string): boolean;
+    isValidEmail(str: string): boolean;
     /**
      * Checks if the string is an valid email address formed during comment markdown formation.
      *
-     * @param string The string to check for email validity.
+     * @param str The string to check for email validity.
      *
      * @returns True if the string is an valid email created by comment markdown.
      */
-    isValidEmailMarkdown(string: string): boolean;
+    isValidEmailMarkdown(str: string): boolean;
     /**
      * Remove trailing comma from a string.
      *
-     * @param string The string with any trailing comma to be removed.
+     * @param str The string with any trailing comma to be removed.
      *
      * @returns string with the trailing comma removed
      */
-    removeTrailingComma(string: string): string;
+    removeTrailingComma(str: string): string;
     /**
      * Checks that the string is a list of coma separated email addresss.
      *
@@ -221,10 +214,8 @@ declare const Str: {
     areValidEmails(str: string): boolean;
     /**
      * Extract the email addresses from a string
-     *
-     * @param string
      */
-    extractEmail(string: string): RegExpMatchArray | null;
+    extractEmail(str: string): RegExpMatchArray | null;
     /**
      * Extracts the domain name from the given email address
      * (e.g. "domain.com" for "joe@domain.com").
@@ -254,57 +245,46 @@ declare const Str: {
     extractEmailLocalPart(email: string): string;
     /**
      * Sanitize phone number to return only numbers. Return null if non valid phone number.
-     *
-     * @param str
      */
     sanitizePhoneNumber(str: string): string | null;
     /**
      * Sanitize email. Return null if non valid email.
-     *
-     * @param str
      */
     sanitizeEmail(str: string): string | null;
     /**
      * Escapes all special RegExp characters from a string
      *
-     * @param string The subject
+     * @param str The subject
      *
      * @returns The escaped string
      */
-    escapeForRegExp(string: string): string;
+    escapeForRegExp(str: string): string;
     /**
      * Escapes all special RegExp characters from a string except for the period
      *
-     * @param string The subject
+     * @param str The subject
      * @returns The escaped string
      */
-    escapeForExpenseRule(string: string): string;
+    escapeForExpenseRule(str: string): string;
     /**
      * Adds a backslash in front of each of colon
      * if they don't already have a backslash in front of them
      *
-     * @param string The subject
+     * @param str The subject
      * @returns The escaped string
      */
-    addBackslashBeforeColonsForTagNamesComingFromQBD(string: string): string;
+    addBackslashBeforeColonsForTagNamesComingFromQBD(str: string): string;
     /**
      * Removes backslashes from string
      * eg: myString\[\]\* -> myString[]*
-     *
-     * @param string
-     *
      */
-    stripBackslashes(string: string): string;
+    stripBackslashes(str: string): string;
     /**
      * Checks if a string's length is in the specified range
      *
-     * @param string The subject
-     * @param minimumLength
-     * @param [maximumLength]
-     *
      * @returns true if the length is in the range, false otherwise
      */
-    isOfLength(string: string, minimumLength: number, maximumLength: number): boolean;
+    isOfLength(str: string, minimumLength: number, maximumLength: number): boolean;
     /**
      * Count the number of occurences of needle in haystack.
      * This is faster than counting the results of haystack.match( /needle/g )
@@ -321,8 +301,8 @@ declare const Str: {
      * Uppercases the first letter of each word
      * via https://github.com/kvz/phpjs/blob/master/functions/strings/ucwords.js
      *
-     * @param  str to uppercase words
-     * @returns  Uppercase worded string
+     * @param str to uppercase words
+     * @returns Uppercase worded string
      */
     ucwords(str: string): string;
     /**
@@ -346,83 +326,75 @@ declare const Str: {
     /**
      * Case insensitive compare function
      *
-     * @param string1 string to compare
-     * @param string2 string to compare
+     * @param strA string to compare
+     * @param strB string to compare
      *
      * @returns -1 if first string < second string
      *                   1 if first string > second string
      *                   0 if first string = second string
      */
-    caseInsensitiveCompare(string1: string, string2: string): 1 | 0 | -1;
+    caseInsensitiveCompare(strA: string, strB: string): 1 | 0 | -1;
     /**
      * Case insensitive equals
      *
-     * @param first string to compare
-     * @param second string to compare
+     * @param strA string to compare
+     * @param strB string to compare
      * @returns true when first == second except for case
      */
-    caseInsensitiveEquals(first: string, second: string): boolean;
+    caseInsensitiveEquals(strA: string, strB: string): boolean;
     /**
      * Compare function
      *
-     * @param string1 string to compare
-     * @param string2 string to compare
+     * @param strA string to compare
+     * @param strB string to compare
      *
      * @returns -1 if first string < second string
      *                   1 if first string > second string
      *                   0 if first string = second string
      */
-    compare(string1: string, string2: string): 1 | 0 | -1;
+    compare(strA: string, strB: string): 1 | 0 | -1;
     /**
      * Check if a file extension is supported by SmartReports
-     * @param  filename
      */
     isFileExtensionSmartReportsValid(filename: string): boolean;
     /**
      * Mask Permanent Account Number (PAN) the same way Auth does
-     * @param number account number
+     * @param num account number
      * @returns masked account number
      */
-    maskPAN(number: number | string): string;
+    maskPAN(num: number | string): string;
     /**
      * Checks if something is a string
      * Stolen from underscore
-     * @param obj
      */
-    isString(obj: unknown): boolean;
+    isString(obj: unknown): obj is string;
     /**
      * Checks if something is a number
      * Stolen from underscore
      * @param obj
      */
-    isNumber(obj: unknown): boolean;
+    isNumber(obj: unknown): obj is number;
     /**
      * Checks if something is a certain type
      * Stolen from underscore
-     * @param  obj
-     * @param  type one of ['Arguments', 'Function', 'String', 'Number', 'Date',
-     *                       'RegExp', 'Error', 'Symbol', 'Map', 'WeakMap', 'Set', 'WeakSet']
      */
     isTypeOf(obj: unknown, type: 'Arguments' | 'Function' | 'String' | 'Number' | 'Date' | 'RegExp' | 'Error' | 'Symbol' | 'Map' | 'WeakMap' | 'Set' | 'WeakSet'): boolean;
     /**
      * Checks to see if something is undefined
      * Stolen from underscore
-     * @param obj
      */
     isUndefined(obj: unknown): boolean;
     /**
      * Replace first N characters of the string with maskChar
      * eg: maskFirstNCharacters( '1234567890', 6, 'X' ) yields XXXXXX7890
-     * @param str string to mask
-     * @param n number of characters we want to mask from the string
-     * @param mask string we want replace the first N chars with
-     * @returns 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: string, n: number, mask: string): string;
+    maskFirstNCharacters(str: string, num: number, mask: string): string;
     /**
      * Trim a string
-     *
-     * @param str
      */
     trim(str: string): string;
     /**
@@ -431,64 +403,56 @@ declare const Str: {
      */
     percentageStringToNumber(percentageString: string): number;
     /**
-     * Remoce all the spaces from a string
-     * @param input
-     *
+     * Remove all the spaces from a string
      */
     removeSpaces(input: string): string;
     /**
      * 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
+     * console.log(Str.pluralize('puppy', 'puppies', 1)) { // puppy
+     * console.log(Str.pluralize('puppy', 'puppies', 3)) { // puppies
      *
      * @param singular form of the phrase
      * @param plural form of the phrase
-     * @param n the count which determines the plurality
+     * @param num the count which determines the plurality
      */
-    pluralize(singular: string, plural: string, n: number): string;
+    pluralize(singular: string, plural: string, num: number): string;
     /**
      * Returns whether or not a string is an encrypted number or not.
      *
-     * @param number that we want to see if its encrypted or not
+     * @param num that we want to see if its encrypted or not
      *
      * @returns Whether or not this string is an encrpypted number
      */
-    isEncryptedCardNumber(number: string): boolean;
+    isEncryptedCardNumber(num: string): boolean;
     /**
      * Converts a value to boolean, case-insensitive.
-     * @param value
      */
     toBool(value: unknown): boolean;
     /**
      * Checks if a string could be the masked version of another one.
      *
-     * @param first string to compare
-     * @param second string to compare
-     * @param [mask] defaults to X
-     * @returns true when first could be the masked version of second
+     * @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(first: string, second: string, mask: string): boolean;
+    maskedEquals(strA: string, strB: string, mask: string): boolean;
     /**
      * Bold any word matching the regexp in the text.
-     * @param text, htmlEncoded
-     * @param regexp
      */
     boldify(text: string, regexp: RegExp): string;
     /**
      * Check for whether a phone number is valid.
-     * @param phone
-     * @deprecated use isValidE164Phone to validate E.164 phone numbers, isValidPhoneFormat to validate phone number format, or isValidPhoneNumber to validate phone numbers in general
+     * @deprecated use isValidE164Phone to validate E.164 phone numbers or isValidPhoneFormat to validate phone numbers in general
      */
     isValidPhone(phone: string): boolean;
     /**
      * Check for whether a phone number is valid.
-     * @param phone
      */
     isValidPhoneNumber(phone: string): boolean;
     /**
      * Check for whether a phone number is valid according to E.164 standard.
-     * @param phone
      */
     isValidE164Phone(phone: string): boolean;
     /**
@@ -498,25 +462,18 @@ declare const Str: {
      * e164: +14404589784
      * national: (440) 458-9784
      * 123.456.7890
-     * @param phone
      */
     isValidPhoneFormat(phone: string): boolean;
     /**
      * We validate mentions by checking if it's first character is an allowed character.
-     *
-     * @param mention
      */
     isValidMention(mention: string): boolean;
     /**
      * Returns text without our SMS domain
-     *
-     * @param text
      */
     removeSMSDomain(text: string): string;
     /**
      * Returns true if the text is a valid E.164 phone number with our SMS domain removed
-     *
-     * @param text
      */
     isSMSLogin(text: string): boolean;
     /**
@@ -524,16 +481,15 @@ declare 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 str
-     * @param regex
      */
-    matchAll(str: string, regex: RegExp): Array<RegExpMatchArray & {input: string; index: number}>;
+    matchAll(str: string, regex: RegExp): Array<RegExpMatchArray & {
+        input: string;
+        index: number;
+    }>;
     /**
      * A simple GUID generator taken from https://stackoverflow.com/a/32760401/9114791
      *
      * @param [prefix] an optional prefix to put in front of the guid
-     *
      */
     guid(prefix?: string): string;
     /**
@@ -554,18 +510,11 @@ declare 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 parameter
      */
-    result: {
-        <R, A extends unknown[]>(parameter: string): string;
-        <R, A extends unknown[]>(parameter: (...args: A) => R, ...args: A): R;
-    };
+    result: typeof resultFn;
     /**
      * Get file extension for a given url with or
      * without query parameters
-     *
-     * @param url
      */
     getExtension(url: string): string | undefined;
     /**
@@ -582,8 +531,6 @@ declare const Str: {
      * supported by all platforms.
      *
      * https://reactnative.dev/docs/image#source
-     *
-     * @param url
      */
     isImage(url: string): boolean;
     /**
@@ -594,24 +541,17 @@ declare 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 url
      */
     isVideo(url: string): boolean;
     /**
      * Checks whether the given string is a +@ domain email account, such as
      * +@domain.com
      *
-     * @param email
      * @returns True if is a domain account email, otherwise false.
      */
     isDomainEmail(email: string): boolean;
     /**
      * Polyfill for String.prototype.replaceAll
-     *
-     * @param text
-     * @param searchValue
-     * @param replaceValue
      */
     replaceAll(text: string, searchValue: string | RegExp, replaceValue: string | ((...args: unknown[]) => string)): string;
 };