expensify-common 2.0.188 → 2.0.190

package/dist/esm/Cookie.d.ts

@@ -0,0 +1,68 @@
+declare namespace _default {
+    export let NAME_LAST_PAGE: string;
+    export let NAME_LAST_REPORTS_PAGE: string;
+    export let NAME_STASHED_SUPPORT: string;
+    export let NAME_WEB_COOKIE: string;
+    export let NAME_EXPENSES_VIEW_MODE: string;
+    export let MOBILE_APP_VERSION: string;
+    export let TWO_FACTOR_DEVICE_TOKEN: string;
+    export { enabled };
+    export { remove };
+    export { get };
+    export { getJSON };
+    export { has };
+    export { getHelpLink };
+    export { set };
+}
+export default _default;
+/**
+ * Detects if cookies are currently enabled in the browser
+ * by trying to create a cookie, see if it exists, and delete it afterwards again.
+ *
+ * @returns {Boolean} True if cookies are enabled, otherwise false.
+ */
+declare function enabled(): boolean;
+/**
+ * Deletes a cookie.
+ *
+ * @param {String} name The name of the cookie to delete.
+ */
+declare function remove(name: string): void;
+/**
+ * Fetches the value of a cookie.
+ *
+ * @param  {String} name The name of the cookie to fetch.
+ * @returns {String|null} The value of the cookie.
+ */
+declare function get(name: string): string | null;
+/**
+ * Parses a cookie value to JSON.
+ * Returns a default value specified by param or null.
+ *
+ * @param {String} name
+ * @param {Any|null} defaultValue
+ *
+ * @returns {Any|null}
+ */
+declare function getJSON(name: string, defaultValue?: Any | null): Any | null;
+/**
+ * Find a cookie that has been set.
+ *
+ * @param {String} name Name of the cookie to find
+ * @returns {Boolean} Whether or not the cookie is set
+ */
+declare function has(name: string): boolean;
+/**
+ * Returns help link when cookies are enabled or null.
+ *
+ * @returns {(String|null)}
+ */
+declare function getHelpLink(): (string | null);
+/**
+ * Sets the value of a cookie and when it will expire.
+ *
+ * @param {String} name The name of the cookie.
+ * @param {String} value The value of the cookie.
+ * @param {Number} [expiredays] The number of days until the cookie expires.
+ */
+declare function set(name: string, value: string, expiredays?: number): void;

package/dist/esm/Cookie.js

@@ -0,0 +1,159 @@
+import BrowserDetect from './BrowserDetect';
+const CONST = {
+    /**
+     * Cookie storing the the name of the page we visited the last time
+     */
+    NAME_LAST_PAGE: 'lastPage',
+    /**
+     * Cookie storing the name of the reports page we visited the last time (e.g. reports, inbox)
+     */
+    NAME_LAST_REPORTS_PAGE: 'lastReportsPage',
+    /**
+     * Cookie storing a user's restricted-access support token
+     */
+    NAME_STASHED_SUPPORT: '_stashedSupportLogin',
+    /**
+     * Cookie set by expensify web that's used to identify a request as coming from web.
+     */
+    NAME_WEB_COOKIE: 'expensifyWeb',
+    /**
+     * Cookie storing the mode the user wants to use when viewing the expenses page.
+     */
+    NAME_EXPENSES_VIEW_MODE: 'expensesPageViewMode',
+    /**
+     * Cookie set that denotes a mobile request
+     */
+    MOBILE_APP_VERSION: 'appversion',
+    /**
+     * Two-Factor Auth device token
+     */
+    TWO_FACTOR_DEVICE_TOKEN: 'stashedTwoFactorLogin',
+};
+/**
+ * Deletes a cookie.
+ *
+ * @param {String} name The name of the cookie to delete.
+ */
+function remove(name) {
+    const date = new Date();
+    document.cookie = `${name}=; expires=${date.toUTCString()}`;
+}
+/**
+ * Sets the value of a cookie and when it will expire.
+ *
+ * @param {String} name The name of the cookie.
+ * @param {String} value The value of the cookie.
+ * @param {Number} [expiredays] The number of days until the cookie expires.
+ */
+function set(name, value, expiredays) {
+    // Get expiry date, set
+    const exdate = new Date();
+    exdate.setDate(exdate.getDate() + expiredays);
+    document.cookie = `${name}=${encodeURIComponent(value)}${expiredays === null ? '' : `;expires=${exdate.toUTCString()}`}`;
+}
+/**
+ * Detects if cookies are currently enabled in the browser
+ * by trying to create a cookie, see if it exists, and delete it afterwards again.
+ *
+ * @returns {Boolean} True if cookies are enabled, otherwise false.
+ */
+function enabled() {
+    // Check they have cookies enabled
+    const cookieName = `cookieTest_${Math.floor(Math.random() * 1000)}`;
+    const cookieValue = 'enabled';
+    set(cookieName, cookieValue, 1);
+    const result = document.cookie.indexOf(cookieName) >= 0 || false;
+    if (result) {
+        remove(cookieName);
+    }
+    return result;
+}
+/**
+ * Fetches the value of a cookie.
+ *
+ * @param  {String} name The name of the cookie to fetch.
+ * @returns {String|null} The value of the cookie.
+ */
+function get(name) {
+    if (!name || document.cookie.length <= 0) {
+        return null;
+    }
+    let start;
+    let end;
+    start = document.cookie.indexOf(`${name}=`);
+    if (start !== -1) {
+        start = start + name.length + 1;
+        end = document.cookie.indexOf(';', start);
+        if (end === -1) {
+            end = document.cookie.length;
+        }
+        return decodeURIComponent(document.cookie.substring(start, end));
+    }
+    return null;
+}
+/**
+ * Parses a cookie value to JSON.
+ * Returns a default value specified by param or null.
+ *
+ * @param {String} name
+ * @param {Any|null} defaultValue
+ *
+ * @returns {Any|null}
+ */
+function getJSON(name, defaultValue = null) {
+    let data;
+    try {
+        data = JSON.parse(get(name));
+    }
+    catch (_a) {
+        data = defaultValue;
+    }
+    return data;
+}
+/**
+ * Find a cookie that has been set.
+ *
+ * @param {String} name Name of the cookie to find
+ * @returns {Boolean} Whether or not the cookie is set
+ */
+function has(name) {
+    return get(name) !== null;
+}
+/**
+ * Returns help link when cookies are enabled or null.
+ *
+ * @returns {(String|null)}
+ */
+function getHelpLink() {
+    if (enabled()) {
+        return null;
+    }
+    let helpLink = 'http://www.google.com/search?q=enable+cookies';
+    // Set up help link according to browser
+    if (BrowserDetect.browser === BrowserDetect.BROWSERS.EXPLORER) {
+        helpLink = 'https://support.microsoft.com/en-us/help/17442/windows-internet-explorer-delete-manage-cookies';
+    }
+    else if (BrowserDetect.browser === BrowserDetect.BROWSERS.SAFARI) {
+        helpLink = 'https://support.apple.com/guide/safari/manage-cookies-and-website-data-sfri11471/mac';
+    }
+    else if (BrowserDetect.browser === BrowserDetect.BROWSERS.MOZILLA) {
+        helpLink = 'http://support.mozilla.com/en-US/kb/Enabling%20and%20disabling%20cookies';
+    }
+    else if (BrowserDetect.browser === BrowserDetect.BROWSERS.OPERA) {
+        helpLink = 'http://www.opera.com/help/tutorials/security/privacy/';
+    }
+    else if (BrowserDetect.browser === BrowserDetect.BROWSERS.CHROME) {
+        helpLink = 'http://www.google.com/support/chrome/bin/answer.py?answer=95647';
+    }
+    else if (BrowserDetect.browser === BrowserDetect.BROWSERS.EDGE) {
+        helpLink = 'https://privacy.microsoft.com/en-us/windows-10-microsoft-edge-and-privacy';
+    }
+    return helpLink;
+}
+export default Object.assign({ enabled,
+    remove,
+    get,
+    getJSON,
+    has,
+    getHelpLink,
+    set }, CONST);

package/dist/esm/CredentialsWrapper.d.ts

@@ -0,0 +1,32 @@
+export default CredentialWrapper;
+declare namespace CredentialWrapper {
+    /**
+     * @returns {Promise} Promise resolves to an object containing partnerUserID and partnerUserSecret
+     */
+    function getCredentials(): Promise<any>;
+    /**
+     * @returns {Object} Object contains randomly generated partnerUserID and partnerUserSecret
+     */
+    function generateCredentials(): Object;
+    /**
+     * @param {Object} credentials
+     * @param {String} credentials.partnerUserID
+     * @param {String} credentials.partnerUserSecret
+     *
+     * @returns {Promise} Promise resolves to an object containing partnerUserID and partnerUserSecret
+     */
+    function setCredentials(credentials: {
+        partnerUserID: string;
+        partnerUserSecret: string;
+    }): Promise<any>;
+    /**
+     * @returns {Promise}
+     */
+    function clearCredentials(): Promise<any>;
+}
+export namespace LOGIN_PARTNER_DETAILS {
+    let CREDENTIALS_KEY: string;
+    let EXPENSIFY_PARTNER_PREFIX: string;
+    let PARTNER_NAME: string;
+    let PARTNER_PASSWORD: string;
+}

package/dist/esm/CredentialsWrapper.js

@@ -0,0 +1,46 @@
+import localForage from 'localforage';
+const LOGIN_PARTNER_DETAILS = {
+    CREDENTIALS_KEY: 'DEVICE_SESSION_CREDENTIALS',
+    EXPENSIFY_PARTNER_PREFIX: 'expensify.',
+    PARTNER_NAME: 'chat-expensify-com',
+    PARTNER_PASSWORD: 'e21965746fd75f82bb66',
+};
+const CredentialWrapper = {
+    /**
+     * @returns {Promise} Promise resolves to an object containing partnerUserID and partnerUserSecret
+     */
+    getCredentials() {
+        return localForage.getItem(LOGIN_PARTNER_DETAILS.CREDENTIALS_KEY);
+    },
+    /**
+     * @returns {Object} Object contains randomly generated partnerUserID and partnerUserSecret
+     */
+    generateCredentials() {
+        return {
+            partnerUserID: LOGIN_PARTNER_DETAILS.EXPENSIFY_PARTNER_PREFIX + crypto.randomUUID(),
+            partnerUserSecret: crypto.randomUUID(),
+        };
+    },
+    /**
+     * @param {Object} credentials
+     * @param {String} credentials.partnerUserID
+     * @param {String} credentials.partnerUserSecret
+     *
+     * @returns {Promise} Promise resolves to an object containing partnerUserID and partnerUserSecret
+     */
+    setCredentials(credentials) {
+        if (!credentials.partnerUserID || !credentials.partnerUserSecret) {
+            // eslint-disable-next-line prefer-promise-reject-errors
+            return Promise.reject('Invalid credential pair');
+        }
+        return localForage.setItem(LOGIN_PARTNER_DETAILS.CREDENTIALS_KEY, credentials);
+    },
+    /**
+     * @returns {Promise}
+     */
+    clearCredentials() {
+        return localForage.removeItem(LOGIN_PARTNER_DETAILS.CREDENTIALS_KEY);
+    },
+};
+export default CredentialWrapper;
+export { LOGIN_PARTNER_DETAILS };

package/dist/esm/Device.d.ts

@@ -0,0 +1,8 @@
+type DeviceInfo = {
+    os: string | undefined;
+    osVersion: string | undefined;
+    deviceName: string | undefined;
+    deviceVersion: string | undefined;
+};
+declare function getOSAndName(): DeviceInfo;
+export { getOSAndName, };

package/dist/esm/Device.js

@@ -0,0 +1,24 @@
+import { UAParser } from 'ua-parser-js';
+function getOSAndName() {
+    var _a;
+    const parser = new UAParser();
+    const { browser, os } = parser.getResult();
+    let osVersion = os.version;
+    // Detection logic inspired by UAParser guide on iOS 26:
+    // https://docs.uaparser.dev/guides/how-to-detect-ios-26-using-javascript.html
+    const [osMajor, osMinor] = ((_a = os.version) !== null && _a !== void 0 ? _a : '').split('.');
+    const osMajorInt = parseInt(osMajor, 10);
+    const osMinorInt = parseInt(osMinor, 10);
+    if (browser.name === 'Mobile Safari' && browser.major === '26' && os.name === 'iOS' && (osMajorInt > 18 || (osMajorInt === 18 && osMinorInt >= 6))) {
+        osVersion = '26';
+    }
+    return {
+        os: os.name,
+        osVersion,
+        deviceName: browser.name,
+        deviceVersion: browser.version,
+    };
+}
+export { 
+// eslint-disable-next-line import/prefer-default-export
+getOSAndName, };

package/dist/esm/ExpenseRule.d.ts

@@ -0,0 +1,39 @@
+export default class ExpenseRule {
+    /**
+     * Checks the passed value against the actual based on what the condition (matches, greater, less than, etc.)
+     *
+     * @param {string} condition
+     * @param {Mixed} ruleValue
+     * @param {Mixed} transactionValue
+     * @returns {boolean}
+     */
+    static checkCondition(condition: string, ruleValue: Mixed, transactionValue: Mixed): boolean;
+    /**
+     * Creates a new instance of this class.
+     *
+     * @param {Object|Array} ruleArray
+     */
+    constructor(ruleArray: Object | any[]);
+    /**
+     * Returns the applyWhen array associated with the passed field
+     * i.e. field == category returns [field: 'category', condition: 'matches', value: 'car']
+     *
+     * @param {string} field
+     *
+     * @returns {Object}
+     */
+    getApplyWhenByField(field: string): Object;
+    /**
+     * Get the externalID saved deep in the tax field
+     *
+     * @returns {String}
+     */
+    getExternalTaxID(): string;
+    /**
+     * Checks if the passed expense matches this expense rule
+     *
+     * @param {SExpense3} expense
+     * @returns {boolean}
+     */
+    isMatch(expense: SExpense3): boolean;
+}

package/dist/esm/ExpenseRule.js

@@ -0,0 +1,77 @@
+export default class ExpenseRule {
+    /**
+     * Creates a new instance of this class.
+     *
+     * @param {Object|Array} ruleArray
+     */
+    constructor(ruleArray) {
+        // It's not 100% certain that `ruleArray` is an array or an object, so support both of them so the app doesn't crash
+        if (Array.isArray(ruleArray)) {
+            for (const [key, value] of ruleArray.entries()) {
+                this[key] = value;
+            }
+        }
+        else if (ruleArray && typeof ruleArray === 'object') {
+            for (const key of Object.keys(ruleArray)) {
+                this[key] = ruleArray[key];
+            }
+        }
+    }
+    /**
+     * Returns the applyWhen array associated with the passed field
+     * i.e. field == category returns [field: 'category', condition: 'matches', value: 'car']
+     *
+     * @param {string} field
+     *
+     * @returns {Object}
+     */
+    getApplyWhenByField(field) {
+        return this.applyWhen.find((conditions) => conditions.field === field) || {};
+    }
+    /**
+     * Get the externalID saved deep in the tax field
+     *
+     * @returns {String}
+     */
+    getExternalTaxID() {
+        return this.tax.field_id_TAX.externalID || '';
+    }
+    /**
+     * Checks if the passed expense matches this expense rule
+     *
+     * @param {SExpense3} expense
+     * @returns {boolean}
+     */
+    isMatch(expense) {
+        let isMatch = true;
+        for (const conditions of this.applyWhen) {
+            switch (conditions.field) {
+                case 'category':
+                    if (!ExpenseRule.checkCondition(conditions.condition, conditions.value, expense.getCategory())) {
+                        isMatch = false;
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+        return isMatch;
+    }
+    /**
+     * Checks the passed value against the actual based on what the condition (matches, greater, less than, etc.)
+     *
+     * @param {string} condition
+     * @param {Mixed} ruleValue
+     * @param {Mixed} transactionValue
+     * @returns {boolean}
+     */
+    static checkCondition(condition, ruleValue, transactionValue) {
+        // Add more condition types (Greater than, Less than, Contains) below
+        switch (condition) {
+            case 'matches':
+                return ruleValue === transactionValue;
+            default:
+                return false;
+        }
+    }
+}

package/dist/esm/ExpensiMark.d.ts

@@ -0,0 +1,197 @@
+import Logger from './Logger';
+type Extras = {
+    reportIDToName?: Record<string, string>;
+    accountIDToName?: Record<string, string>;
+    /**
+     * @deprecated Replaced with mediaAttributeCachingFn
+     */
+    cacheVideoAttributes?: (vidSource: string, attrs: string) => void;
+    /**
+     * @deprecated Replaced with mediaAttributeCache
+     */
+    videoAttributeCache?: Record<string, string>;
+    /**
+     * Function used to cache HTML tag attributes during conversion to and from Markdown
+     * @param mediaSource URI to media source
+     * @param attrs Additional attributes to be cached
+     */
+    mediaAttributeCachingFn?: (mediaSource: string, attrs: string) => void;
+    /**
+     * Key/value cache for HTML tag attributes, where the key is media source URI, value is cached attributes
+     */
+    mediaAttributeCache?: Record<string, string>;
+};
+export type { Extras };
+type ReplacementFn = (extras: Extras, ...matches: string[]) => string;
+type Replacement = ReplacementFn | string;
+type ProcessFn = (textToProcess: string, replacement: Replacement, shouldKeepRawInput: boolean) => string;
+type CommonRule = {
+    name: string;
+    replacement: Replacement;
+    rawInputReplacement?: Replacement;
+    pre?: (input: string) => string;
+    post?: (input: string) => string;
+    shouldSkipProcessing?: (textToCheck: string) => boolean;
+};
+type RuleWithRegex = CommonRule & {
+    regex: RegExp;
+};
+type RuleWithProcess = CommonRule & {
+    process: ProcessFn;
+};
+type Rule = RuleWithRegex | RuleWithProcess;
+type ReplaceOptions = {
+    extras?: Extras;
+    filterRules?: string[];
+    disabledRules?: string[];
+    shouldEscapeText?: boolean;
+    shouldKeepRawInput?: boolean;
+};
+type TruncateOptions = {
+    ellipsis?: string;
+    truncateLastWord?: boolean;
+    slop?: number;
+    removeImageTag?: boolean;
+};
+declare function resolveAttributeCache(extras?: Extras): {
+    attrCachingFn: ((vidSource: string, attrs: string) => void) | undefined;
+    attrCache: Record<string, string> | undefined;
+};
+/**
+ * replace block element with '\n' if :
+ * 1. We have text within the element.
+ * 2. The text does not end with a new line.
+ * 3. It's not the last element in the string.
+ */
+declare function replaceBlockElementWithNewLine(htmlString: string): string;
+/** Check if the input text includes only the open or the close tag of an element. */
+declare function containsNonPairTag(textToCheck: string): boolean;
+/**
+ * Truncate HTML string and keep tag safe.
+ * pulled from https://github.com/huang47/nodejs-html-truncate/blob/master/lib/truncate.js
+ */
+declare function truncateHTML(html: string, maxLength: number, options?: TruncateOptions): string;
+export default class ExpensiMark {
+    static Log: Logger;
+    /**
+     * Set the logger to use for logging inside of the ExpensiMark class
+     * @param logger - The logger object to use
+     */
+    static setLogger(logger: Logger): void;
+    /** Rules to apply to the text */
+    rules: Rule[];
+    /**
+     * The list of regex replacements to do on a HTML comment for converting it to markdown.
+     * Order of rules is important
+     */
+    htmlToMarkdownRules: RuleWithRegex[];
+    /**
+     * The list of rules to covert the HTML to text.
+     * Order of rules is important
+     */
+    htmlToTextRules: RuleWithRegex[];
+    /**
+     * The list of rules that we have to exclude in shouldKeepWhitespaceRules list.
+     */
+    whitespaceRulesToDisable: string[];
+    /**
+     * The list of rules that have to be applied when shouldKeepWhitespace flag is true.
+     */
+    filterRules: (rule: Rule) => boolean;
+    /**
+     * Filters rules to determine which should keep whitespace.
+     */
+    shouldKeepWhitespaceRules: Rule[];
+    /**
+     * maxQuoteDepth is the maximum depth of nested quotes that we want to support.
+     */
+    maxQuoteDepth: number;
+    /**
+     * currentQuoteDepth is the current depth of nested quotes that we are processing.
+     */
+    currentQuoteDepth: number;
+    constructor();
+    /**
+     * Retrieves the HTML ruleset based on the provided filter rules, disabled rules, and shouldKeepRawInput flag.
+     * @param filterRules - An array of rule names to filter the ruleset.
+     * @param disabledRules - An array of rule names to disable in the ruleset.
+     * @param shouldKeepRawInput - A boolean flag indicating whether to keep raw input.
+     */
+    getHtmlRuleset(filterRules: string[], disabledRules: string[], shouldKeepRawInput: boolean): Rule[];
+    /**
+     * Replaces markdown with html elements
+     *
+     * @param text - Text to parse as markdown
+     * @param [options] - Options to customize the markdown parser
+     * @param [options.filterRules=[]] - An array of name of rules as defined in this class.
+     * If not provided, all available rules will be applied.
+     * @param [options.shouldEscapeText=true] - Whether or not the text should be escaped
+     * @param [options.disabledRules=[]] - An array of name of rules as defined in this class.
+     * If not provided, all available rules will be applied. If provided, the rules in the array will be skipped.
+     */
+    replace(text: string, { filterRules, shouldEscapeText, shouldKeepRawInput, disabledRules, extras }?: ReplaceOptions): string;
+    /**
+     * Checks matched URLs for validity and replace valid links with html elements
+     */
+    modifyTextForUrlLinks(regex: RegExp, textToCheck: string, replacement: ReplacementFn): string;
+    /**
+     * Checks matched Emails for validity and replace valid links with html elements
+     */
+    modifyTextForEmailLinks(regex: RegExp, textToCheck: string, replacement: ReplacementFn, shouldKeepRawInput: boolean): string;
+    /**
+     * Unpacks nested quote HTML tags that have been packed by the 'quote' rule in this.rules for shouldKeepRawInput = false
+     *
+     * For example, it parses the following HTML:
+     * <blockquote>
+     *     quote 1
+     *    <blockquote>
+     *      quote 2
+     *    </blockquote>
+     *    quote 3
+     * </blockquote>
+     *
+     * into:
+     * <blockquote> quote 1</blockquote>
+     * <blockquote><blockquote> quote 2</blockquote>
+     * <blockquote> quote 3</blockquote>
+     *
+     * Note that there will always be only a single closing tag, even if multiple opening tags exist.
+     * Only one closing tag is needed to detect if a nested quote has ended.
+     */
+    static unpackNestedQuotes(text: string): string;
+    /**
+     * Replaces HTML with markdown
+     */
+    htmlToMarkdown(htmlString: string, extras?: Extras): string;
+    /**
+     * Convert HTML to text
+     */
+    htmlToText(htmlString: string, extras?: Extras): string;
+    /**
+     * Main text to html 'quote' parsing logic.
+     * Removes &gt;( ) from text and recursively calls replace function to process nested quotes and build blockquote HTML result.
+     * @param shouldKeepRawInput determines if the raw input should be kept for nested quotes.
+     */
+    replaceQuoteText(text: string, shouldKeepRawInput: boolean): {
+        replacedText: string;
+        shouldAddSpace: boolean;
+    };
+    getAttributeCache: typeof resolveAttributeCache;
+    replaceBlockElementWithNewLine: typeof replaceBlockElementWithNewLine;
+    containsNonPairTag: typeof containsNonPairTag;
+    truncateHTML: typeof truncateHTML;
+    /**
+     * @returns array or undefined if exception occurs when executing regex matching
+     */
+    extractLinksInMarkdownComment(comment: string): string[] | undefined;
+    /**
+     * Compares two markdown comments and returns a list of the links removed in a new comment.
+     */
+    getRemovedMarkdownLinks(oldComment: string, newComment: string): string[];
+    /**
+     * Escapes the content of an HTML attribute value
+     * @param content - string content that possible contains HTML
+     * @returns original MD content escaped for use in HTML attribute value
+     */
+    escapeAttributeContent(content: string): string;
+}