expensify-common 2.0.188 → 2.0.190

package/dist/esm/Num.js

@@ -0,0 +1,190 @@
+import Str from './str';
+export default {
+    /**
+     * Converts an exponential number into it's non-exponential string equivalent
+     *
+     * @param {Number} num
+     *
+     * @returns {String}
+     */
+    notExponential(num) {
+        const numStr = num.toString();
+        // If this number isn't exponential already, just return it.
+        if (numStr.indexOf('e') === -1) {
+            return num;
+        }
+        const numArr = numStr.split(/e\+/);
+        let exponent = parseInt(numArr[1], 10);
+        let value = parseFloat(numArr[0]);
+        // Convert the number into the largest possible non-exponent.
+        exponent -= 20;
+        value *= Math.pow(10, 20);
+        // Now we make it into a string and start appending '0's
+        value = value.toString();
+        while (exponent--) {
+            value += '0';
+        }
+        return value;
+    },
+    /**
+     * Format a number, similar to PHP's number_format.
+     *
+     * @param {Number} _a The number you want to format
+     * @param {Number} [b="0"] The number of decimal places you want
+     * @param {String} [_c=","] The decimal separator
+     * @param {String} [d="."] The thousands separator
+     *
+     * @todo should be camelCase / needs refactor
+     * @returns {String}
+     */
+    number_format(_a, b = 0, _c = '.', d = ',') {
+        let sign = '';
+        let a = _a;
+        let c = _c;
+        let e = null;
+        let f = null;
+        let g = null;
+        let h = null;
+        let i = null;
+        let j = null;
+        const multiplier = Math.pow(10, b);
+        a = Math.round(a * multiplier) / multiplier;
+        if (a < 0) {
+            a *= -1;
+            sign = '-';
+        }
+        e = String(this.notExponential(a));
+        f = e.split('.');
+        if (!f[0]) {
+            f[0] = '0';
+        }
+        if (!f[1]) {
+            f[1] = '';
+        }
+        if (f[1].length < b) {
+            g = f[1];
+            for (i = f[1].length + 1; i <= b; i++) {
+                g += '0';
+            }
+            f[1] = g;
+        }
+        if (d !== '' && f[0].length > 3) {
+            h = f[0];
+            f[0] = '';
+            for (j = 3; j < h.length; j += 3) {
+                const sliceStart = h.length - j;
+                i = h.slice(sliceStart, sliceStart + 3);
+                f[0] = `${d}${i}${f[0]}`;
+            }
+            j = h.substr(0, h.length % 3 === 0 ? 3 : h.length % 3);
+            f[0] = j + f[0];
+        }
+        c = b <= 0 ? '' : c;
+        return `${sign}${f[0]}${c}${f[1]}`;
+    },
+    generateRandom6DigitID() {
+        return Math.floor(Math.random() * 900000) + 100000; // 100000 - 999999
+    },
+    /**
+     * Converts a number to base 26 (using capital english letters as digits).
+     *
+     * @param {Number} num The number to convert to base 26.
+     *
+     * @returns {String} The number, converted to base 26.
+     */
+    toBase26LetterCode(num) {
+        const base26Digits = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+        const outputDigits = [];
+        for (let i = num; i >= 0; i = Math.floor(i / 26) - 1) {
+            outputDigits.push(base26Digits.charAt(i % 26));
+        }
+        return outputDigits.reverse().join('');
+    },
+    /**
+     * Check if a number is finite and not NaN. i.e.
+     *
+     * @param {number} number The number to test
+     *
+     * @returns {Boolean} true if the number is finite and not NaN.
+     */
+    isFiniteNumber(number) {
+        return typeof number === 'number' && Number.isFinite(number) && !Number.isNaN(number);
+    },
+    /**
+     * Truncates the given number to the given precision.
+     *
+     * @param {number} number the number to truncate.
+     * @param {number} decimals the number of decimals to keep.
+     *
+     * @returns {number} the truncated number.
+     */
+    toPrecision(number, decimals) {
+        const numeral = Math.pow(10, decimals);
+        return Math.round(number * numeral) / numeral;
+    },
+    /**
+     * Check if a number is between 2 numbers, including them.
+     *
+     * @param {number} number to check
+     * @param {number} a the 1st limit
+     * @param {number} b the 2nd limit
+     *
+     * @returns {boolean}
+     */
+    isNumberBetween(number, a, b) {
+        return number >= Math.min(a, b) && number <= Math.max(a, b);
+    },
+    /**
+     * Returns how many decimals to display (used for currencies).
+     *
+     * @param {Number} rate
+     * @returns {Number}
+     */
+    getDisplayDecimals(rate) {
+        if (rate % 1 === 0) {
+            return 2;
+        }
+        if ((rate * 10) % 1 === 0) {
+            return 3;
+        }
+        return 4;
+    },
+    tax: {
+        /**
+         * Calculate the pre-tax, or net amount
+         *
+         * @param {Number} total The total to calculate from, in negative cents
+         * @param {UserDefinedField} taxUDF The tax UDF
+         *
+         * @returns {number} The pre-tax amount, in negative cents
+         */
+        calculatePreTaxAmount(total, taxUDF) {
+            return total - taxUDF.getTaxAmount(total);
+        },
+        /**
+         * Calculate the tax amount from the total.
+         *
+         * @param {Number} total The total to calculate from
+         * @param {String} percentage The percentage, as a string, e.g. '20%'
+         *
+         * @returns {number} The amount of tax
+         */
+        calculateTaxFromPercentage(total, percentage) {
+            const percentageAsDecimal = Str.percentageStringToNumber(percentage) / 100;
+            const divisor = percentage ? percentageAsDecimal + 1 : 1;
+            return this.calculateTaxFromDivisor(total, divisor);
+        },
+        /**
+         * Calculate the tax amount from a divisor.
+         *
+         * @param {Number} total The total to calculate from
+         * @param {Number} divisor The divisor (0.1 = 10%)
+         *
+         * @returns {number} The amount of tax
+         */
+        calculateTaxFromDivisor(total, divisor) {
+            const amountExcludingTax = total / divisor;
+            return parseInt(Math.round(total - amountExcludingTax), 10);
+        },
+    },
+};

package/dist/esm/PageEvent.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Event object used by page to do internal logic.
+ * Used with the method pageSubscribe and pageUnSubscribe
+ * of the PubSub for automatic clean up of pages events
+ *
+ * @param {String} eventName Name of the event to listen to
+ * @param {Function} callback Function to fire
+ * @class
+ */
+export default function _default(eventName: string, callback: Function): {
+    subscribe(scope: any): void;
+    unsubscribe(): void;
+};
+export default class _default {
+    /**
+     * Event object used by page to do internal logic.
+     * Used with the method pageSubscribe and pageUnSubscribe
+     * of the PubSub for automatic clean up of pages events
+     *
+     * @param {String} eventName Name of the event to listen to
+     * @param {Function} callback Function to fire
+     * @class
+     */
+    constructor(eventName: string, callback: Function);
+}

package/dist/esm/PageEvent.js

@@ -0,0 +1,22 @@
+import PubSub from './PubSub';
+/**
+ * Event object used by page to do internal logic.
+ * Used with the method pageSubscribe and pageUnSubscribe
+ * of the PubSub for automatic clean up of pages events
+ *
+ * @param {String} eventName Name of the event to listen to
+ * @param {Function} callback Function to fire
+ * @class
+ */
+export default function (eventName, callback) {
+    let id = null;
+    return {
+        subscribe(scope) {
+            id = PubSub.subscribe(eventName, callback, scope);
+        },
+        unsubscribe() {
+            PubSub.unsubscribe(id);
+            id = null;
+        },
+    };
+}

package/dist/esm/PubSub.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/esm/PubSub.js

@@ -0,0 +1,111 @@
+import has from 'lodash/has';
+import once from 'lodash/once';
+import Log from './Log';
+import * as Utils from './utils';
+/**
+ * PubSub
+ *
+ * A simple publisher subscriber system for async / decouple/ cross module communication
+ */
+const eventMap = {};
+// Used to generate the uniq id of the event
+let counter = 0;
+/**
+ * Create a unique ID for each event subscriber
+ * @param {String} eventName Name of the event to listen to
+ * @returns {String} unique ID
+ */
+const generateID = (eventName) => {
+    counter++;
+    return `${eventName}@#@${counter}`;
+};
+/**
+ * Find the name of the event from the ID
+ * @param {string} eventID
+ * @returns {String}
+ */
+const extractEventName = (eventID = '') => eventID.substring(0, eventID.indexOf('@#@'));
+const PubSubModule = {
+    ERROR: 'ev_error',
+    /**
+     * Publish an event
+     *
+     * @param {String} eventName Name of the event to fire
+     * @param {Object} [param] Parameters to send with the event, send to the callback
+     * @returns {PubSub}
+     */
+    publish(eventName, param = {}) {
+        if (eventMap[eventName] === undefined) {
+            return;
+        }
+        const eventIDs = Object.keys(eventMap[eventName]);
+        if (eventName === this.ERROR) {
+            // Doing the split slice 2 because the 1st element of the stacktrace will always be from here (PubSub.publish)
+            // When debugging, we just need to know who called PubSub.publish (so, all next elements in the stack)
+            Log.hmmm('Error published', 0, { tplt: param.tplt, stackTrace: new Error().stack.split(' at ').slice(2) });
+        }
+        for (const eventID of eventIDs) {
+            const subscriber = eventMap[eventName][eventID];
+            if (subscriber) {
+                subscriber.callback.call(subscriber.scope, param);
+            }
+        }
+        return this;
+    },
+    /**
+     * Subscribes to an event and triggers the callback only once with the given scope
+     *
+     * @param  {String}   eventName
+     * @param  {Function} callback
+     * @param  {Object}   [optionalScope]
+     * @returns {String}
+     */
+    once(eventName, callback, optionalScope) {
+        const scope = Utils.isObject(optionalScope) && optionalScope !== null ? optionalScope : window;
+        const functionToCallOnce = once((...args) => callback.apply(scope, args));
+        return this.subscribe(eventName, functionToCallOnce);
+    },
+    /**
+     * Listen to an event and call the callback when it is done.
+     * Order of callback call is not guaranteed
+     *
+     * "PUBLIC" event ( aka for views ) are available in lib/constant.js
+     * "PRIVATE" event should be used only by system modules
+     *
+     * @param {String} eventName Name of the event to listen
+     * @param {Function} optionalCallback Callback function to call when event occur
+     * @param {Object} optionalScope
+     * @returns {String} event identifier that should be used to unsubscribe
+     */
+    subscribe(eventName, optionalCallback, optionalScope) {
+        if (!eventName) {
+            throw new Error('Attempted to subscribe to undefined event');
+        }
+        const callback = Utils.isFunction(optionalCallback) ? optionalCallback : () => { };
+        const scope = Utils.isObject(optionalScope) && optionalScope !== null ? optionalScope : window;
+        const eventID = generateID(eventName);
+        if (eventMap[eventName] === undefined) {
+            eventMap[eventName] = {};
+        }
+        eventMap[eventName][eventID] = {
+            callback,
+            scope,
+        };
+        return eventID;
+    },
+    /**
+     * Remove a subscriber
+     *
+     * @param {String} bindID The id of the element to delete
+     */
+    unsubscribe(bindID) {
+        const IDs = Array.isArray(bindID) ? bindID : [bindID];
+        for (const id of IDs) {
+            const eventName = extractEventName(id);
+            if (has(eventMap, `${eventName}.${id}`)) {
+                delete eventMap[eventName][id];
+            }
+        }
+    },
+};
+export default Utils.isWindowAvailable() && window.PubSub ? window.PubSub : PubSubModule;

package/dist/esm/ReportHistoryStore.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Creates a report history store with platform-specific API and PubSub implementations.
+ *
+ * @param {Object} API
+ * @param {Object} PubSub
+ * @returns {Object}
+ */
+export default function ReportHistoryStore(API: Object, PubSub: Object): Object;

package/dist/esm/ReportHistoryStore.js

@@ -0,0 +1,199 @@
+import { Deferred } from 'simply-deferred';
+/**
+ * Creates a report history store with platform-specific API and PubSub implementations.
+ *
+ * @param {Object} API
+ * @param {Object} PubSub
+ * @returns {Object}
+ */
+export default function ReportHistoryStore(API, PubSub) {
+    if (!API) {
+        throw new Error('Cannot instantiate ReportHistoryStore without API');
+    }
+    const store = {
+        API,
+        cache: {},
+        PubSub,
+    };
+    /**
+     * Filters out actions we never want to display on web or mobile.
+     *
+     * @param {Object[]} historyItems
+     * @returns {Object[]}
+     */
+    const filterHiddenActions = (historyItems) => historyItems.filter((historyItem) => historyItem.shouldShow);
+    /**
+     * Merges history items into the cache and creates it if it doesn't yet exist.
+     *
+     * @param {Number} reportID
+     * @param {Object[]} newHistory
+     */
+    function mergeItems(reportID, newHistory) {
+        if (newHistory.length === 0) {
+            return;
+        }
+        const newCache = newHistory.reverse().reduce((prev, curr) => {
+            if (!prev.some((item) => item.sequenceNumber === curr.sequenceNumber)) {
+                prev.unshift(curr);
+            }
+            return prev;
+        }, store.cache[reportID] || []);
+        store.cache[reportID] = newCache.sort((a, b) => b.sequenceNumber - a.sequenceNumber);
+    }
+    /**
+     * Merges history items into the cache and creates it if it doesn't yet exist.
+     *
+     * @param {Number} reportID
+     * @param {Object[]} newHistory
+     */
+    function mergeHistoryByTimestamp(reportID, newHistory) {
+        if (newHistory.length === 0) {
+            return;
+        }
+        const newCache = newHistory.reverse().reduce((prev, curr) => {
+            if (!prev.some((item) => item.reportActionTimestamp === curr.reportActionTimestamp)) {
+                prev.unshift(curr);
+            }
+            return prev;
+        }, store.cache[reportID] || []);
+        store.cache[reportID] = newCache.sort((a, b) => b.reportActionTimestamp - a.reportActionTimestamp);
+    }
+    /**
+     * Merges history items by reportActionID into the cache and creates it if it doesn't yet exist.
+     *
+     * @param {Number} reportID
+     * @param {Object[]} newHistory
+     */
+    function mergeHistoryByReportActionID(reportID, newHistory) {
+        if (newHistory.length === 0) {
+            return;
+        }
+        const newCache = newHistory.reverse().reduce((prev, curr) => {
+            if (!prev.some((item) => item.reportActionID === curr.reportActionID)) {
+                prev.unshift(curr);
+            }
+            return prev;
+        }, store.cache[reportID] || []);
+        store.cache[reportID] = newCache.sort((a, b) => b.reportActionTimestamp - a.reportActionTimestamp);
+    }
+    /**
+     * Gets the history.
+     *
+     * @param {Number} reportID
+     * @param {Boolean} ignoreCache
+     * @returns {Deferred}
+     */
+    function get(reportID, ignoreCache) {
+        const promise = new Deferred();
+        if (ignoreCache) {
+            delete store.cache[reportID];
+        }
+        const cachedHistory = store.cache[reportID] || [];
+        const firstHistoryItem = cachedHistory[0] || {};
+        store.API.Report_GetHistory({
+            reportID,
+            offset: firstHistoryItem.sequenceNumber || 0,
+        })
+            .done((recentHistory) => {
+            mergeItems(reportID, recentHistory);
+            promise.resolve(store.cache[reportID]);
+        })
+            .fail(promise.reject);
+        return promise;
+    }
+    /**
+     * Gets the history. This flow does not depend on the deprecated sequence number in report actions.
+     *
+     * @param {Number} reportID
+     * @param {Boolean} ignoreCache
+     * @returns {Deferred}
+     */
+    function getFlatHistory(reportID, ignoreCache) {
+        const promise = new Deferred();
+        if (ignoreCache) {
+            delete store.cache[reportID];
+        }
+        store.API.Report_GetHistory({
+            reportID,
+        })
+            .done((recentHistory) => {
+            mergeHistoryByReportActionID(reportID, recentHistory);
+            promise.resolve(store.cache[reportID]);
+        })
+            .fail(promise.reject);
+        return promise;
+    }
+    /**
+     * Gets the history from the cache if it exists. Otherwise fully loads the history.
+     *
+     * @param {Number} reportID
+     * @returns {Deferred}
+     */
+    function getFromCache(reportID) {
+        const promise = new Deferred();
+        const cachedHistory = store.cache[reportID] || [];
+        if (cachedHistory.length === 0) {
+            return getFlatHistory(reportID);
+        }
+        return promise.resolve(cachedHistory);
+    }
+    return {
+        get: (reportID, ignoreCache = false) => {
+            const promise = new Deferred();
+            get(reportID, ignoreCache)
+                .done((reportHistory) => {
+                promise.resolve(filterHiddenActions(reportHistory));
+            })
+                .fail(promise.reject);
+            return promise;
+        },
+        getFlatHistory: (reportID, ignoreCache = false) => {
+            const promise = new Deferred();
+            getFlatHistory(reportID, ignoreCache)
+                .done((reportHistory) => {
+                promise.resolve(filterHiddenActions(reportHistory));
+            })
+                .fail(promise.reject);
+            return promise;
+        },
+        insertIntoCache: (reportID, reportAction) => {
+            const promise = new Deferred();
+            getFromCache(reportID)
+                .done((cachedHistory) => {
+                const sequenceNumber = reportAction.sequenceNumber;
+                if (cachedHistory.length >= sequenceNumber) {
+                    mergeItems(reportID, [reportAction]);
+                    return promise.resolve(filterHiddenActions(store.cache[reportID]));
+                }
+                get(reportID)
+                    .done((reportHistory) => promise.resolve(filterHiddenActions(reportHistory)))
+                    .fail(promise.reject);
+            })
+                .fail(promise.reject);
+            return promise;
+        },
+        insertIntoCacheByActionID: (reportID, reportAction) => {
+            const promise = new Deferred();
+            getFromCache(reportID)
+                .done((cachedHistory) => {
+                if (cachedHistory.some(({ reportActionID }) => reportActionID === reportAction.reportActionID)) {
+                    mergeHistoryByTimestamp(reportID, [reportAction]);
+                    return promise.resolve(filterHiddenActions(store.cache[reportID]));
+                }
+                getFlatHistory(reportID)
+                    .done((reportHistory) => promise.resolve(filterHiddenActions(reportHistory)))
+                    .fail(promise.reject);
+            })
+                .fail(promise.reject);
+            return promise;
+        },
+        bindCacheClearingEvents: (events) => {
+            for (const event of events) {
+                store.PubSub.subscribe(event, () => {
+                    store.cache = {};
+                });
+            }
+        },
+        filterHiddenActions,
+    };
+}

package/dist/esm/SafeString.js

@@ -23,7 +23,7 @@ export default function SafeString(value) {
             try {
                 return JSON.stringify(value);
             }
-            catch {
+            catch (_a) {
                 return '[object Array]';
             }
         }
@@ -41,7 +41,7 @@ export default function SafeString(value) {
         try {
             return JSON.stringify(obj);
         }
-        catch {
+        catch (_b) {
             return '[object Object]';
         }
     }

package/dist/esm/Templates.d.ts

@@ -0,0 +1,58 @@
+export default Templates;
+declare namespace Templates {
+    /**
+     * Given a templatePath, return the value
+     *
+     * @param {Array} templatePath
+     * @param {Object} [data] Information that need to be injected into the template
+     * @returns {String}
+     */
+    function get(templatePath: any[], data?: Object): string;
+    /**
+     * Given a templatePath, does it have a registered template?
+     * @param  {Array} templatePath
+     * @returns {Boolean}
+     */
+    function has(templatePath: any[]): boolean;
+    /**
+     * Inits the templating engine, and slurps all DOM templates in an internal data structure
+     */
+    function init(): void;
+    /**
+     * Register a new json object in the template manager
+     *
+     * @param {Array} wantedNamespace Namespace where we want to store the templates
+     * @param {object} templateData The literal object that contain the templates
+     */
+    function register(wantedNamespace: any[], templateData: object): void;
+    /**
+     * Removes a namespace from the templateStore (only used for testing purposes)
+     *
+     * @param {String} nameSpace
+     */
+    function unregister(nameSpace: string): void;
+    /**
+     * Replace the DOM HTML with the template value
+     *
+     * @param {jQuery} $target Element(s) that will be updated
+     * @param {Array} templatePath
+     * @param {Object} [data] Information that need to be injected into the template
+     */
+    function insert($target: JQueryStatic, templatePath: any[], data?: Object): void;
+    /**
+     * Append the template value into a DOM elements
+     *
+     * @param {jQuery} $target Element(s) that will be updated
+     * @param {Array} templatePath
+     * @param {Object} data Information that need to be injected into the template
+     */
+    function prepend($target: JQueryStatic, templatePath: any[], data: Object): void;
+    /**
+     * Prepend the template value into a DOM elements
+     *
+     * @param {jQuery} $target Element(s) that will be updated
+     * @param {array} templatePath
+     * @param {object} [data] Information that need to be injected into the template
+     */
+    function append($target: JQueryStatic, templatePath: array, data?: object): void;
+}