expensify-common 2.0.181 → 2.0.183

package/dist/ReportHistoryStore.js

@@ -1,154 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = ReportHistoryStore;
 const simply_deferred_1 = require("simply-deferred");
-class ReportHistoryStore {
-    // We need to instantiate the history cache with the platform specific implementations
-    constructor(API, PubSub) {
-        if (!API) {
-            throw new Error('Cannot instantiate ReportHistoryStore without API');
-        }
-        this.API = API;
-        /**
-         * Main report history cache
-         * Map of reportIDs with value of report history items array
-         */
-        this.cache = {};
-        /**
-         * PubSub instance used for the bindCacheClearingEvents method.
-         *
-         * Since Mobile and Web use different instances of PubSub, this is unfortunately necessary to subscribe to
-         * events in both code bases.
-         */
-        this.PubSub = PubSub;
-        /**
-         * Filters out actions we never want to display on web or mobile.
-         *
-         * @param {Object[]} historyItems
-         *
-         * @returns {Object[]}
-         */
-        this.filterHiddenActions = (historyItems) => historyItems.filter((historyItem) => historyItem.shouldShow);
-        /**
-         * Public Methods
-         */
-        return {
-            /**
-             * Returns the history for a given report.
-             * Note that we are unable to ask for the cached history.
-             *
-             * @param {Number} reportID
-             * @param {Boolean} ignoreCache - useful if you need to force the report history to reload completely.
-             *
-             * @returns {Deferred}
-             */
-            get: (reportID, ignoreCache = false) => {
-                const promise = new simply_deferred_1.Deferred();
-                this.get(reportID, ignoreCache)
-                    .done((reportHistory) => {
-                    promise.resolve(this.filterHiddenActions(reportHistory));
-                })
-                    .fail(promise.reject);
-                return promise;
-            },
-            /**
-             * Returns the history for a given report.
-             * Note that we are unable to ask for the cached history.
-             *
-             * @param {Number} reportID
-             * @param {Boolean} ignoreCache - useful if you need to force the report history to reload completely.
-             *
-             * @returns {Deferred}
-             */
-            getFlatHistory: (reportID, ignoreCache = false) => {
-                const promise = new simply_deferred_1.Deferred();
-                this.getFlatHistory(reportID, ignoreCache)
-                    .done((reportHistory) => {
-                    promise.resolve(this.filterHiddenActions(reportHistory));
-                })
-                    .fail(promise.reject);
-                return promise;
-            },
-            /**
-             * Set a history item directly into the cache. Checks to see if we have the previous item first.
-             *
-             * @param {Number} reportID
-             * @param {Object} reportAction
-             *
-             * @returns {Deferred}
-             */
-            insertIntoCache: (reportID, reportAction) => {
-                const promise = new simply_deferred_1.Deferred();
-                this.getFromCache(reportID)
-                    .done((cachedHistory) => {
-                    const sequenceNumber = reportAction.sequenceNumber;
-                    // Do we have the reportAction immediately before this one?
-                    // Note: History is zero indexed. So if we want to check if we have the previous message before an
-                    // incoming message with a sequenceNumber of 18 then we'd be looking for a cache length of 18
-                    // which would indicate that we have sequenceNumber 17)
-                    if (cachedHistory.length >= sequenceNumber) {
-                        // If we have the previous one then we can assume we have an up to date history minus the most recent
-                        // and must merge it into the cache
-                        this.mergeItems(reportID, [reportAction]);
-                        return promise.resolve(this.filterHiddenActions(this.cache[reportID]));
-                    }
-                    // If we get here we have an incomplete history and should get
-                    // the report history again, but this time do not check the cache first.
-                    this.get(reportID)
-                        .done((reportHistory) => promise.resolve(this.filterHiddenActions(reportHistory)))
-                        .fail(promise.reject);
-                })
-                    .fail(promise.reject);
-                return promise;
-            },
-            /**
-             * Set a history item directly into the cache. Checks to see if we have the previous item first.
-             *
-             * @param {Number} reportID
-             * @param {Object} reportAction
-             *
-             * @returns {Deferred}
-             */
-            insertIntoCacheByActionID: (reportID, reportAction) => {
-                const promise = new simply_deferred_1.Deferred();
-                this.getFromCache(reportID)
-                    .done((cachedHistory) => {
-                    // Do we have the reportAction immediately before this one?
-                    if (cachedHistory.some(({ reportActionID }) => reportActionID === reportAction.reportActionID)) {
-                        // If we have the previous one then we can assume we have an up to date history minus the most recent
-                        // and must merge it into the cache
-                        this.mergeHistoryByTimestamp(reportID, [reportAction]);
-                        return promise.resolve(this.filterHiddenActions(this.cache[reportID]));
-                    }
-                    // If we get here we have an incomplete history and should get
-                    // the report history again, but this time do not check the cache first.
-                    this.getFlatHistory(reportID)
-                        .done((reportHistory) => promise.resolve(this.filterHiddenActions(reportHistory)))
-                        .fail(promise.reject);
-                })
-                    .fail(promise.reject);
-                return promise;
-            },
-            /**
-             * Certain events need to completely clear the cache. This method allows other code modules using this
-             * (like Web, Mobile) to assign which events would do so.
-             *
-             * @param {String[]} events
-             */
-            bindCacheClearingEvents: (events) => {
-                events.forEach((event) => this.PubSub.subscribe(event, () => (this.cache = {})));
-            },
-            // We need this to be publically available for cases where we get the report history
-            // via PHP or html pages within the app e.g. printablereport.html
-            filterHiddenActions: this.filterHiddenActions,
-        };
+/**
+ * Creates a report history store with platform-specific API and PubSub implementations.
+ *
+ * @param {Object} API
+ * @param {Object} PubSub
+ * @returns {Object}
+ */
+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
      */
-    mergeItems(reportID, newHistory) {
+    function mergeItems(reportID, newHistory) {
         if (newHistory.length === 0) {
             return;
         }
@@ -157,9 +40,8 @@ class ReportHistoryStore {
                 prev.unshift(curr);
             }
             return prev;
-        }, this.cache[reportID] || []);
-        // Sort items in case they have become out of sync
-        this.cache[reportID] = newCache.sort((a, b) => b.sequenceNumber - a.sequenceNumber);
+        }, 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.
@@ -167,7 +49,7 @@ class ReportHistoryStore {
      * @param {Number} reportID
      * @param {Object[]} newHistory
      */
-    mergeHistoryByTimestamp(reportID, newHistory) {
+    function mergeHistoryByTimestamp(reportID, newHistory) {
         if (newHistory.length === 0) {
             return;
         }
@@ -176,9 +58,8 @@ class ReportHistoryStore {
                 prev.unshift(curr);
             }
             return prev;
-        }, this.cache[reportID] || []);
-        // Sort items in case they have become out of sync
-        this.cache[reportID] = newCache.sort((a, b) => b.reportActionTimestamp - a.reportActionTimestamp);
+        }, 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.
@@ -186,7 +67,7 @@ class ReportHistoryStore {
      * @param {Number} reportID
      * @param {Object[]} newHistory
      */
-    mergeHistoryByReportActionID(reportID, newHistory) {
+    function mergeHistoryByReportActionID(reportID, newHistory) {
         if (newHistory.length === 0) {
             return;
         }
@@ -195,37 +76,30 @@ class ReportHistoryStore {
                 prev.unshift(curr);
             }
             return prev;
-        }, this.cache[reportID] || []);
-        // Sort items in case they have become out of sync
-        this.cache[reportID] = newCache.sort((a, b) => b.reportActionTimestamp - a.reportActionTimestamp);
+        }, 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}
      */
-    get(reportID, ignoreCache) {
+    function get(reportID, ignoreCache) {
         const promise = new simply_deferred_1.Deferred();
-        // Remove the cache entry if we're ignoring the cache, since we'll be replacing it later.
         if (ignoreCache) {
-            delete this.cache[reportID];
+            delete store.cache[reportID];
         }
-        // We'll poll the API for the un-cached history
-        const cachedHistory = this.cache[reportID] || [];
+        const cachedHistory = store.cache[reportID] || [];
         const firstHistoryItem = cachedHistory[0] || {};
-        // Grab the most recent sequenceNumber we have and poll the API for fresh data
-        this.API.Report_GetHistory({
+        store.API.Report_GetHistory({
             reportID,
             offset: firstHistoryItem.sequenceNumber || 0,
         })
             .done((recentHistory) => {
-            // Update history with new items fetched
-            this.mergeItems(reportID, recentHistory);
-            // Return history for this report
-            promise.resolve(this.cache[reportID]);
+            mergeItems(reportID, recentHistory);
+            promise.resolve(store.cache[reportID]);
         })
             .fail(promise.reject);
         return promise;
@@ -235,23 +109,19 @@ class ReportHistoryStore {
      *
      * @param {Number} reportID
      * @param {Boolean} ignoreCache
-     *
      * @returns {Deferred}
      */
-    getFlatHistory(reportID, ignoreCache) {
+    function getFlatHistory(reportID, ignoreCache) {
         const promise = new simply_deferred_1.Deferred();
-        // Remove the cache entry if we're ignoring the cache, since we'll be replacing it later.
         if (ignoreCache) {
-            delete this.cache[reportID];
+            delete store.cache[reportID];
         }
-        this.API.Report_GetHistory({
+        store.API.Report_GetHistory({
             reportID,
         })
             .done((recentHistory) => {
-            // Update history with new items fetched
-            this.mergeHistoryByReportActionID(reportID, recentHistory);
-            // Return history for this report
-            promise.resolve(this.cache[reportID]);
+            mergeHistoryByReportActionID(reportID, recentHistory);
+            promise.resolve(store.cache[reportID]);
         })
             .fail(promise.reject);
         return promise;
@@ -260,17 +130,73 @@ class ReportHistoryStore {
      * Gets the history from the cache if it exists. Otherwise fully loads the history.
      *
      * @param {Number} reportID
-     *
-     * @return {Deferrred}
+     * @returns {Deferred}
      */
-    getFromCache(reportID) {
+    function getFromCache(reportID) {
         const promise = new simply_deferred_1.Deferred();
-        const cachedHistory = this.cache[reportID] || [];
-        // If comment is not in cache then fetch it
+        const cachedHistory = store.cache[reportID] || [];
         if (cachedHistory.length === 0) {
-            return this.getFlatHistory(reportID);
+            return getFlatHistory(reportID);
         }
         return promise.resolve(cachedHistory);
     }
+    return {
+        get: (reportID, ignoreCache = false) => {
+            const promise = new simply_deferred_1.Deferred();
+            get(reportID, ignoreCache)
+                .done((reportHistory) => {
+                promise.resolve(filterHiddenActions(reportHistory));
+            })
+                .fail(promise.reject);
+            return promise;
+        },
+        getFlatHistory: (reportID, ignoreCache = false) => {
+            const promise = new simply_deferred_1.Deferred();
+            getFlatHistory(reportID, ignoreCache)
+                .done((reportHistory) => {
+                promise.resolve(filterHiddenActions(reportHistory));
+            })
+                .fail(promise.reject);
+            return promise;
+        },
+        insertIntoCache: (reportID, reportAction) => {
+            const promise = new simply_deferred_1.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 simply_deferred_1.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,
+    };
 }
-exports.default = ReportHistoryStore;

package/dist/Templates.d.ts

@@ -1,35 +1,36 @@
-declare const _default: {
+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
-     * @return {String}
+     * @returns {String}
      */
-    get(templatePath: any[], data?: Object): string;
+    function get(templatePath: any[], data?: Object): string;
     /**
      * Given a templatePath, does it have a registered template?
      * @param  {Array} templatePath
-     * @return {Boolean}
+     * @returns {Boolean}
      */
-    has(templatePath: any[]): boolean;
+    function has(templatePath: any[]): boolean;
     /**
      * Inits the templating engine, and slurps all DOM templates in an internal data structure
      */
-    init(): void;
+    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
      */
-    register(wantedNamespace: any[], templateData: object): void;
+    function register(wantedNamespace: any[], templateData: object): void;
     /**
      * Removes a namespace from the templateStore (only used for testing purposes)
      *
      * @param {String} nameSpace
      */
-    unregister(nameSpace: string): void;
+    function unregister(nameSpace: string): void;
     /**
      * Replace the DOM HTML with the template value
      *
@@ -37,7 +38,7 @@ declare const _default: {
      * @param {Array} templatePath
      * @param {Object} [data] Information that need to be injected into the template
      */
-    insert($target: JQueryStatic, templatePath: any[], data?: Object): void;
+    function insert($target: JQueryStatic, templatePath: any[], data?: Object): void;
     /**
      * Append the template value into a DOM elements
      *
@@ -45,7 +46,7 @@ declare const _default: {
      * @param {Array} templatePath
      * @param {Object} data Information that need to be injected into the template
      */
-    prepend($target: JQueryStatic, templatePath: any[], data: Object): void;
+    function prepend($target: JQueryStatic, templatePath: any[], data: Object): void;
     /**
      * Prepend the template value into a DOM elements
      *
@@ -53,6 +54,5 @@ declare const _default: {
      * @param {array} templatePath
      * @param {object} [data] Information that need to be injected into the template
      */
-    append($target: JQueryStatic, templatePath: array, data?: object): void;
-};
-export default _default;
+    function append($target: JQueryStatic, templatePath: array, data?: object): void;
+}