expensify-common 2.0.188 → 2.0.190

package/dist/esm/fastMerge.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Merges two objects and removes null values if "shouldRemoveNullObjectValues" is set to true
+ *
+ * We generally want to remove null values from objects written to disk and cache, because it decreases the amount of data stored in memory and on disk.
+ * On native, when merging an existing value with new changes, SQLite will use JSON_PATCH, which removes top-level nullish values.
+ * To be consistent with the behaviour for merge, we'll also want to remove null values for "set" operations.
+ */
+declare function fastMerge<TObject>(target: TObject, source: TObject, shouldRemoveNullObjectValues?: boolean): TObject;
+export default fastMerge;

package/dist/esm/fastMerge.js

@@ -0,0 +1,58 @@
+'worklet';
+// Mostly copied from https://medium.com/@lubaka.a/how-to-remove-lodash-performance-improvement-b306669ad0e1
+/**
+ * Checks whether the given value can be merged. It has to be an object, but not an array, RegExp or Date.
+ */
+function isMergeableObject(value) {
+    const nonNullObject = value != null ? typeof value === 'object' : false;
+    return nonNullObject && Object.prototype.toString.call(value) !== '[object RegExp]' && Object.prototype.toString.call(value) !== '[object Date]' && !Array.isArray(value);
+}
+function fastMerge(target, source, shouldRemoveNullObjectValues = true) {
+    // We have to ignore arrays and nullish values here,
+    // otherwise "mergeObject" will throw an error,
+    // because it expects an object as "source"
+    if (Array.isArray(source) || source === null || source === undefined) {
+        return source;
+    }
+    //  Merges the source object into the target object.
+    const destination = {};
+    if (isMergeableObject(target)) {
+        // lodash adds a small overhead so we don't use it here
+        const targetKeys = Object.keys(target);
+        for (let i = 0; i < targetKeys.length; ++i) {
+            const key = targetKeys[i];
+            const sourceValue = source === null || source === void 0 ? void 0 : source[key];
+            const targetValue = target === null || target === void 0 ? void 0 : target[key];
+            // If shouldRemoveNullObjectValues is true, we want to remove null values from the merged object
+            const isSourceOrTargetNull = targetValue === null || sourceValue === null;
+            const shouldOmitSourceKey = shouldRemoveNullObjectValues && isSourceOrTargetNull;
+            if (!shouldOmitSourceKey) {
+                destination[key] = targetValue;
+            }
+        }
+    }
+    // lodash adds a small overhead so we don't use it here
+    const sourceKeys = Object.keys(source);
+    for (let i = 0; i < sourceKeys.length; ++i) {
+        const key = sourceKeys[i];
+        const sourceValue = source === null || source === void 0 ? void 0 : source[key];
+        const targetValue = target === null || target === void 0 ? void 0 : target[key];
+        // If shouldRemoveNullObjectValues is true, we want to remove null values from the merged object
+        const shouldOmitSourceKey = shouldRemoveNullObjectValues && sourceValue === null;
+        // If we pass undefined as the updated value for a key, we want to generally ignore it
+        const isSourceKeyUndefined = sourceValue === undefined;
+        if (!isSourceKeyUndefined && !shouldOmitSourceKey) {
+            const isSourceKeyMergable = isMergeableObject(sourceValue);
+            if (isSourceKeyMergable && targetValue) {
+                if (!shouldRemoveNullObjectValues || isSourceKeyMergable) {
+                    destination[key] = fastMerge(targetValue, sourceValue, shouldRemoveNullObjectValues);
+                }
+            }
+            else if (!shouldRemoveNullObjectValues || sourceValue !== null) {
+                destination[key] = sourceValue;
+            }
+        }
+    }
+    return destination;
+}
+export default fastMerge;

package/dist/esm/index.d.ts

@@ -0,0 +1,22 @@
+export { default as API } from './API';
+export { default as APIDeferred } from './APIDeferred';
+export { default as BrowserDetect } from './BrowserDetect';
+export { g_cloudFront, g_cloudFrontImg, CONST, UI, PUBLIC_DOMAINS_SET } from './CONST';
+export { default as Cookie } from './Cookie';
+export { default as CredentialsWrapper, LOGIN_PARTNER_DETAILS } from './CredentialsWrapper';
+export * as Device from './Device';
+export { default as ExpensiMark } from './ExpensiMark';
+export { default as Logger } from './Logger';
+export { default as Network } from './Network';
+export { default as Num } from './Num';
+export { default as PageEvent } from './PageEvent';
+export { default as PubSub } from './PubSub';
+export { default as ReportHistoryStore } from './ReportHistoryStore';
+export { default as Templates } from './Templates';
+export * as Url from './Url';
+export { default as fastMerge } from './fastMerge';
+export { default as Str } from './str';
+export { default as TLD_REGEX } from './tlds';
+export { default as md5 } from './md5';
+export { default as SafeString } from './SafeString';
+export { escapeText, isFunction, isNavigatorAvailable, isObject, isWindowAvailable, unescapeText } from './utils';

package/dist/esm/index.js

@@ -0,0 +1,22 @@
+export { default as API } from './API';
+export { default as APIDeferred } from './APIDeferred';
+export { default as BrowserDetect } from './BrowserDetect';
+export { g_cloudFront, g_cloudFrontImg, CONST, UI, PUBLIC_DOMAINS_SET } from './CONST';
+export { default as Cookie } from './Cookie';
+export { default as CredentialsWrapper, LOGIN_PARTNER_DETAILS } from './CredentialsWrapper';
+export * as Device from './Device';
+export { default as ExpensiMark } from './ExpensiMark';
+export { default as Logger } from './Logger';
+export { default as Network } from './Network';
+export { default as Num } from './Num';
+export { default as PageEvent } from './PageEvent';
+export { default as PubSub } from './PubSub';
+export { default as ReportHistoryStore } from './ReportHistoryStore';
+export { default as Templates } from './Templates';
+export * as Url from './Url';
+export { default as fastMerge } from './fastMerge';
+export { default as Str } from './str';
+export { default as TLD_REGEX } from './tlds';
+export { default as md5 } from './md5';
+export { default as SafeString } from './SafeString';
+export { escapeText, isFunction, isNavigatorAvailable, isObject, isWindowAvailable, unescapeText } from './utils';

package/dist/esm/jquery.expensifyIframify.d.ts

@@ -0,0 +1,9 @@
+declare namespace _default {
+    /**
+     * Loads the widget into jQuery
+     *
+     * @param {jQuery} $ jQuery instance
+     */
+    function load($: JQueryStatic): void;
+}
+export default _default;

package/dist/esm/jquery.expensifyIframify.js

@@ -0,0 +1,397 @@
+/**
+ * This is a jQuery plugin that provides some iFrame functionality like
+ * posting messages to the parent window.
+ *
+ * Usage:
+ *
+ * From inside the iFrame:
+ * $.fn.expensifyIframeify( 'resize', { height: 100, width: 400 } );
+ * $.fn.expensifyIframeify( 'tellParent', { name: 'say', data: { msg: 'Hello world!' } } );
+ *
+ * From inside the parent:
+ * $( '#myIframe' ).expensifyIframeify( 'on', 'resize', function( data ) { ... } );
+ * $( '#myIframe' ).expensifyIframeify( 'on', 'say', function( data ) {
+ *     // alerts "Hello world!"
+ *     alert( data.msg );
+ * });
+ */
+export default {
+    /**
+     * Loads the widget into jQuery
+     *
+     * @param {jQuery} $ jQuery instance
+     */
+    load($) {
+        /**
+         * Holds the value normally stored in window.location.origin but it's calculated
+         * according to the suggested solutions
+         * Issue:
+         * - https://github.com/Expensify/Expensify/issues/13192#issuecomment-100322844
+         * Solution suggested in the following sites:
+         * - http://stackoverflow.com/questions/22564167/window-location-origin-gives-wrong-path-when-using-ie
+         * - http://tosbourn.com/a-fix-for-window-location-origin-in-internet-explorer/
+         *
+         * Believe it or not before this change this was causing a syntax error in IE10 that disappears with this change
+         *
+         * @type {String} jQuery Element
+         */
+        const defaultOrigin = `${window.location.protocol}//${window.location.hostname}`;
+        /**
+         * This indicates from and to which domains we need to send the messages.
+         * @type {object}
+         */
+        const allowedCommunications = {
+            'https://www.expensify.com': ['https://secure.expensify.com', 'https://www.expensify.com'],
+            'https://secure.expensify.com': ['https://www.expensify.com', 'https://secure.expensify.com', 'https://salesforce.expensify.com'],
+            'https://staging.expensify.com': ['https://staging.expensify.com', 'https://staging-secure.expensify.com'],
+            'https://staging-secure.expensify.com': ['https://staging.expensify.com', 'https://staging-secure.expensify.com'],
+            'https://www.expensify.com.dev': ['https://secure.expensify.com.dev', 'https://www.expensify.com.dev'],
+            'https://secure.expensify.com.dev': ['https://www.expensify.com.dev', 'https://secure.expensify.com.dev'],
+            'https://salesforce.expensify.com': ['https://secure.expensify.com'],
+            'https://www.google.com': ['https://secure.expensify.com.dev', 'https://secure.expensify.com'],
+            'https://cdn.plaid.com': ['https://secure.expensify.com'],
+        };
+        /**
+         * Holds a reference to the jQuery iFrame object
+         *
+         * @type {object} jQuery Element
+         */
+        let iframeElement = null;
+        /**
+         * Whether or not the parent window is listening to the message event
+         *
+         * @type {Boolean}
+         */
+        let parentIsListening = false;
+        /**
+         * Whether or not the plugin has been initialized
+         * @type {Boolean}
+         */
+        let wasInitalized = false;
+        /**
+         * Whether or not the iframe is listening to the message event
+         *
+         * @type {Boolean}
+         */
+        let iframeIsListening = false;
+        /**
+         * Keeps a record of if this script is running from the "parent" or the "iframe"
+         * so that we only have to do this logic once.
+         */
+        let whatIAm;
+        /**
+         * Default settings for our plugin
+         *
+         * @type {object}
+         */
+        let settings = {
+            origin: defaultOrigin,
+            debug: false,
+        };
+        /**
+         * Holds all of our registered event handlers
+         *
+         * @type {object}
+         */
+        let eventHandlers = {};
+        /**
+         * A method for logging things to the console for debugging
+         * @param {...any} args
+         */
+        function log(...args) {
+            if (!settings.debug) {
+                return;
+            }
+            // Make an array out of our arguments
+            const mainArguments = Array.prototype.slice.call(args);
+            const source = whatIAm === 'parent' ? 'Parent' : 'Iframe';
+            mainArguments.unshift(`${source}:`);
+            mainArguments.unshift('[EXPENSIFYIFRAMEIFY]');
+            console.log(...mainArguments); // eslint-disable-line no-console
+        }
+        /**
+         * Forms the message to send to our parent. The message structure is like:
+         *
+         * Full example:
+         * iframeify:<iframeId>:<name>☢<data>
+         *
+         * Lite example:
+         * iframeify:<name>
+         *
+         * Where:
+         *     - <iframeId> (optional) is the "id" attribute of the iframe
+         *     - <name> (required) is the name of the event
+         *     - <data> (optional) is a stringified glob of data
+         *
+         * @param {string} name the name of the message to send
+         * @param {object} data to send in the message
+         * @param {boolean|undefined} postToIframe if true, then we post the message
+         *                                         to the iFrame or else we post
+         *                                         the message to the parent
+         */
+        function postMessage(name, data, postToIframe) {
+            let msg = 'iframeify';
+            if (iframeElement.iframeId) {
+                msg += `:${iframeElement.iframeId}`;
+            }
+            msg += `:${name}`;
+            if (data) {
+                msg += '☢';
+                msg += JSON.stringify(data);
+            }
+            const isCommunicationAllowed = allowedCommunications[settings.origin];
+            if (!isCommunicationAllowed) {
+                log('not posting message, communication from this domain is not allowed', settings.origin, name, data);
+            }
+            let targetOrigin;
+            // Sending message from the iFrame to the parent
+            // Only post a message if this is in an iFrame
+            if (!postToIframe && window.parent !== window) {
+                targetOrigin = `${window.parent.location.protocol}//${window.parent.location.hostname}`;
+                log('posting message to parent', targetOrigin, msg);
+                window.parent.postMessage(msg, targetOrigin);
+            }
+            // Sending message from the parent to the iFrame
+            if (postToIframe && iframeElement[0].contentWindow) {
+                targetOrigin = `${iframeElement[0].contentWindow.location.protocol}//${iframeElement[0].contentWindow.location.hostname}`;
+                log('posting message to iframe', targetOrigin, msg);
+                iframeElement[0].contentWindow.postMessage(msg, targetOrigin);
+            }
+        }
+        /**
+         * Calls all the methods associated with the event name
+         * and passes it the given data
+         *
+         * @param {string} name of the event
+         * @param {mixed} data passed to the event handler
+         * @param {string} [iframeId]
+         */
+        function trigger(name, data, iframeId) {
+            log(`heard event "${name}"`, data);
+            const id = iframeId || iframeElement.iframeId;
+            if (eventHandlers[id] && eventHandlers[id][name] && eventHandlers[id][name].length) {
+                const listeners = eventHandlers[id][name];
+                for (let i = 0; i < listeners.length; i += 1) {
+                    listeners[i](data);
+                }
+            }
+        }
+        /**
+         * Handles the window message by parsing the data
+         * and relaying it to our event listeners
+         *
+         * @param {Event} e jQuery event
+         */
+        function handleWindowMessage(e) {
+            // Use the original event to get our data properly
+            const event = e.originalEvent;
+            if (!event.origin || !event.target) {
+                return;
+            }
+            if (allowedCommunications[event.origin] &&
+                allowedCommunications[event.origin].indexOf('*') === -1 &&
+                allowedCommunications[event.origin].indexOf(`${event.target.location.protocol}//${event.target.location.hostname}`) === -1) {
+                log('not handling message, communication from this domain is not allowed', settings.origin);
+                return;
+            }
+            if (!event.data || (typeof event.data !== 'string' && !(event.data instanceof String))) {
+                return;
+            }
+            // Get the pieces of our message (should be two)
+            const msgParts = event.data.split('☢');
+            if (!msgParts.length) {
+                return;
+            }
+            // Get the pieces of our name (should be two or three)
+            // and extract the event name and the iframe ID
+            const nameParts = msgParts[0].split(':');
+            if (!nameParts.length || nameParts.length > 3) {
+                return;
+            }
+            let iframeId = null;
+            let eventName = null;
+            let data = null;
+            if (nameParts.length === 3) {
+                iframeId = nameParts[1];
+                eventName = nameParts[2];
+            }
+            else if (nameParts.length === 2) {
+                eventName = nameParts[1];
+            }
+            // Get the data
+            if (msgParts.length > 1) {
+                try {
+                    data = JSON.parse(msgParts[1]);
+                }
+                catch (_a) {
+                    // This should only happen if someone didn't code something right
+                    console.error('Could not parse JSON response for some reason', event.data);
+                }
+            }
+            // Trigger any listeners for this event
+            trigger(eventName, data, iframeId);
+        }
+        const actions = {
+            // Add actions here
+            /**
+             * Tells the parent to dynamically resize the iFrame
+             *
+             * @param {object} args
+             * @param {string} args.id the ID of the iFrame to resize
+             * @param {integer} args.height (optional) the height to set the iFrame to
+             * @param {integer} args.width (optional) the width to set the iFrame to
+             */
+            resize(args) {
+                const size = {};
+                if (args.height !== undefined) {
+                    size.height = args.height;
+                }
+                if (args.width !== undefined) {
+                    size.width = args.width;
+                }
+                postMessage('resize', size);
+            },
+            /**
+             * Tell our parent a generic message
+             *
+             * @param {object} args
+             * @param {string} args.name the name of the message to post
+             * @param {object} args.data (optional) to send with the message
+             */
+            tellParent(args) {
+                postMessage(args.name, args.data);
+            },
+            /**
+             * Tell our iFrame a generic message
+             *
+             * @param {object} args
+             * @param {string} args.name the name of the message to post
+             * @param {object} args.data (optional) to send with the message
+             */
+            tellIframe(args) {
+                postMessage(args.name, args.data, true);
+            },
+            /**
+             * Register an event handler. The callback will be stored
+             * for the particular iFrame ID so that you can listen to
+             * multiple iFrames if you want
+             *
+             * @param {string} name of the event
+             * @param {Function} callback
+             */
+            on(name, callback) {
+                log(`listening to event "${name}"`);
+                if (!eventHandlers[iframeElement.iframeId]) {
+                    eventHandlers[iframeElement.iframeId] = {};
+                }
+                if (!eventHandlers[iframeElement.iframeId][name]) {
+                    eventHandlers[iframeElement.iframeId][name] = [];
+                }
+                eventHandlers[iframeElement.iframeId][name].push(callback);
+            },
+            /**
+             * Unregister all handlers for an event. If name is null
+             * then all handlers will be removed
+             *
+             * @param {string} name (optional) of the event
+             */
+            off(name) {
+                log(`stop listening to event "${name}"`);
+                if (iframeElement.iframeId) {
+                    if (eventHandlers[iframeElement.iframeId]) {
+                        if (!name) {
+                            eventHandlers[iframeElement.iframeId] = {};
+                        }
+                        else {
+                            delete eventHandlers[iframeElement.iframeId][name];
+                        }
+                    }
+                }
+                else if (!name) {
+                    eventHandlers = {};
+                }
+                else {
+                    for (const handlerMap of Object.values(eventHandlers)) {
+                        delete handlerMap[name];
+                    }
+                }
+            },
+            /**
+             * Tears down the plugin by
+             * - removing all event handlers
+             * - stop listening to the 'message' window event
+             */
+            destroy() {
+                $(window).off('message', handleWindowMessage);
+                parentIsListening = false;
+                iframeIsListening = false;
+                iframeElement = null;
+            },
+        };
+        /* eslint-disable no-param-reassign */
+        /**
+         * The method that we expose to jQuery. Is used to set options
+         * or perform actions
+         *
+         * @param {mixed} actionOrOptions string of an action to perform
+         *                                object of options to set
+         * @param {object} args to pass to an action method
+         * @param {function} callback (optional) for event handlers
+         *
+         * @returns {[type]}
+         */
+        $.fn.expensifyIframeify = function (actionOrOptions, args, callback) {
+            /* eslint-enable no-param-reassign */
+            const urlArray = defaultOrigin.split('://');
+            const domainArray = urlArray[1].split('.');
+            const subdomain = domainArray.shift();
+            const domainWithoutSubdomain = domainArray.join('.');
+            // There are some browsers that don't support document.domain so we have to manually create it
+            document.domain = domainWithoutSubdomain;
+            iframeElement = this;
+            if (!wasInitalized) {
+                // Determine if this is the parent, or the iframe
+                // Because our site runs inside of an iframe in salesforce, the parent
+                // will actually think it's an iframe too. So here, we detect that we're on
+                // the salesforce subdomain and we know that we should be the parent
+                whatIAm = window.parent === window || subdomain === 'salesforce' ? 'parent' : 'iframe';
+                log('I am the:', whatIAm);
+                wasInitalized = true;
+            }
+            // The iframeId is pulled from the frameElement (if this is inside an iFrame)
+            // or it's pulled from the element that this plugin was called from.
+            //
+            // Example:
+            // $( '#myIframe' ).expensifyIframeify();
+            //
+            // 'myIframe' would be the frameId
+            iframeElement.iframeId = whatIAm === 'iframe' ? $(window.frameElement).attr('id') : iframeElement.attr('id');
+            // Figure out if we are doing an action or setting options
+            if (typeof actionOrOptions === 'string') {
+                if (typeof actions[actionOrOptions] !== 'undefined') {
+                    actions[actionOrOptions](args, callback);
+                }
+            }
+            else {
+                // Extend our default settings
+                settings = $.extend(settings, actionOrOptions);
+            }
+            // If this is the parent page, then we can start listening to messages
+            // from the iFrame
+            if (whatIAm === 'parent' && !parentIsListening) {
+                $(window).on('message', handleWindowMessage);
+                parentIsListening = true;
+                log('parent is listening for messages');
+            }
+            // If this is the iFrame, then we can start listening to messages
+            // from the iFrame
+            if (whatIAm === 'iframe' && !iframeIsListening) {
+                $(window).on('message', handleWindowMessage);
+                iframeIsListening = true;
+                log('iframe is listening for messages');
+            }
+            // make this plugin chainable
+            return this;
+        };
+    },
+};

package/dist/esm/md5.d.ts

@@ -0,0 +1,2 @@
+declare function md5(s: string): string;
+export default md5;