expensify-common 2.0.188 → 2.0.190

package/dist/esm/Func.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Invokes the given callback with the given arguments
+ *
+ * @param {Function} callback
+ * @param {Array} [args]
+ * @param {Object} [scope]
+ *
+ * @returns {Mixed}
+ */
+export function invoke(callback: Function, args?: any[], scope?: Object): Mixed;
+/**
+ * This is nearly the same as invoke, except that it assumes that the callback returns a promise. The callback doesn't
+ * HAVE to return a promise, but it CAN, and if it doesn't, then we provide a promise
+ *
+ * @param {Function} callback
+ * @param {Array} [args]
+ * @param {Object} [scope]
+ *
+ * @returns {Promise}
+ */
+export function invokeAsync(callback: Function, args?: any[], scope?: Object): Promise<any>;
+/**
+ * Invokes all the given callbacks with the given arguments
+ *
+ * @param {Function[]} callbacks
+ * @param {Array} [args]
+ */
+export function bulkInvoke(callbacks: Function[], args?: any[]): void;
+/**
+ * Throws an uncaught error in an attempt to stop JS execution
+ */
+export function die(): void;
+/**
+ * Call the method on a list of objects
+ *
+ * @param {object|array} list
+ * @param {string} methodName
+ * @returns {Array}
+ */
+export function mapByName(list: object | array, methodName: string): any[];

package/dist/esm/Func.js

@@ -0,0 +1,69 @@
+import * as Utils from './utils';
+/**
+ * Invokes the given callback with the given arguments
+ *
+ * @param {Function} callback
+ * @param {Array} [args]
+ * @param {Object} [scope]
+ *
+ * @returns {Mixed}
+ */
+function invoke(callback, args, scope) {
+    if (!Utils.isFunction(callback)) {
+        return null;
+    }
+    return callback.apply(scope, args || []);
+}
+/**
+ * This is nearly the same as invoke, except that it assumes that the callback returns a promise. The callback doesn't
+ * HAVE to return a promise, but it CAN, and if it doesn't, then we provide a promise
+ *
+ * @param {Function} callback
+ * @param {Array} [args]
+ * @param {Object} [scope]
+ *
+ * @returns {Promise}
+ */
+function invokeAsync(callback, args, scope) {
+    if (!Utils.isFunction(callback)) {
+        return Promise.resolve();
+    }
+    let promiseFromCallback = callback.apply(scope, args || []);
+    // If there was not a promise returned from the prefetch callback, then create a dummy promise and resolve it
+    if (!promiseFromCallback) {
+        promiseFromCallback = Promise.resolve();
+    }
+    return promiseFromCallback;
+}
+/**
+ * Invokes all the given callbacks with the given arguments
+ *
+ * @param {Function[]} callbacks
+ * @param {Array} [args]
+ */
+function bulkInvoke(callbacks, args) {
+    for (const callback of callbacks) {
+        invoke(callback, args);
+    }
+}
+/**
+ * Throws an uncaught error in an attempt to stop JS execution
+ */
+function die() {
+    throw new Error('Aborting JavaScript execution');
+}
+/**
+ * Call the method on a list of objects
+ *
+ * @param {object|array} list
+ * @param {string} methodName
+ * @returns {Array}
+ */
+function mapByName(list, methodName) {
+    let arr = list;
+    if (!Array.isArray(arr)) {
+        arr = Object.values(arr);
+    }
+    return arr.map((item) => item[methodName].call(item));
+}
+export { invoke, invokeAsync, bulkInvoke, die, mapByName };

package/dist/esm/Log.d.ts

@@ -0,0 +1,3 @@
+declare const _default: Logger;
+export default _default;
+import Logger from './Logger';

package/dist/esm/Log.js

@@ -0,0 +1,35 @@
+/* eslint-disable no-console */
+import API from './API';
+import Network from './Network';
+import Logger from './Logger';
+import * as Utils from './utils';
+/**
+ * Network interface for logger.
+ *
+ * @param {Logger} logger
+ * @param {Object} params
+ * @param {Object} params.parameters
+ * @param {String} params.message
+ * @returns {Promise}
+ */
+function serverLoggingCallback(logger, params) {
+    return API(Network('/api/')).logToServer(params);
+}
+/**
+ * Local log messages for client logging.
+ *
+ * @param {String} message
+ */
+function clientLoggingCallback(message) {
+    if (Utils.isWindowAvailable() && typeof window.g_printableReport !== 'undefined' && window.g_printableReport === true) {
+        return;
+    }
+    if (window.console && Utils.isFunction(console.log)) {
+        console.log(message);
+    }
+}
+export default new Logger({
+    serverLoggingCallback,
+    clientLoggingCallback,
+    isDebug: Utils.isWindowAvailable() ? window.DEBUG : false,
+});

package/dist/esm/Logger.d.ts

@@ -0,0 +1,82 @@
+type Parameters = string | Record<string, unknown> | Array<Record<string, unknown>> | Error;
+type ServerLoggingCallbackOptions = {
+    api_setCookie: boolean;
+    logPacket: string;
+};
+type ServerLoggingCallback = (logger: Logger, options: ServerLoggingCallbackOptions) => Promise<{
+    requestID: string;
+}> | undefined;
+type ClientLoggingCallBack = (message: string, extraData: Parameters) => void;
+type LogLine = {
+    message: string;
+    parameters: Parameters;
+    onlyFlushWithOthers?: boolean;
+    timestamp: Date;
+    email?: string | null;
+};
+type LoggerOptions = {
+    serverLoggingCallback: ServerLoggingCallback;
+    isDebug: boolean;
+    clientLoggingCallback: ClientLoggingCallBack;
+    maxLogLinesBeforeFlush?: number;
+    getContextEmail?: () => string | null;
+};
+export default class Logger {
+    logLines: LogLine[];
+    serverLoggingCallback: ServerLoggingCallback;
+    clientLoggingCallback: ClientLoggingCallBack;
+    isDebug: boolean;
+    maxLogLinesBeforeFlush: number;
+    getContextEmail?: () => string | null;
+    constructor({ serverLoggingCallback, isDebug, clientLoggingCallback, maxLogLinesBeforeFlush, getContextEmail }: LoggerOptions);
+    /**
+     * Ask the server to write the log message
+     */
+    logToServer(): void;
+    /**
+     * Add a message to the list
+     * @param parameters The parameters associated with the message
+     * @param forceFlushToServer Should we force flushing all logs to server?
+     * @param onlyFlushWithOthers A request will never be sent to the server if all loglines have this set to true
+     */
+    add(message: string, parameters: Parameters, forceFlushToServer: boolean, onlyFlushWithOthers?: boolean, extraData?: Parameters): void;
+    /**
+     * Caches an informational message locally, to be sent to the server if
+     * needed later.
+     *
+     * @param message The message to log.
+     * @param sendNow if true, the message will be sent right away.
+     * @param parameters The parameters to send along with the message
+     * @param onlyFlushWithOthers A request will never be sent to the server if all loglines have this set to true
+     */
+    info(message: string, sendNow?: boolean, parameters?: Parameters, onlyFlushWithOthers?: boolean, extraData?: Parameters): void;
+    /**
+     * Logs an alert.
+     *
+     * @param message The message to alert.
+     * @param parameters The parameters to send along with the message
+     * @param includeStackTrace Must be disabled for testing
+     */
+    alert(message: string, parameters?: Parameters, includeStackTrace?: boolean): void;
+    /**
+     * Logs a warn.
+     *
+     * @param message The message to warn.
+     * @param parameters The parameters to send along with the message
+     */
+    warn(message: string, parameters?: Parameters): void;
+    /**
+     * Logs a hmmm.
+     *
+     * @param message The message to hmmm.
+     * @param parameters The parameters to send along with the message
+     */
+    hmmm(message: string, parameters?: Parameters): void;
+    /**
+     * Logs a message in the browser console.
+     *
+     * @param message The message to log.
+     */
+    client(message: string, extraData?: Parameters): void;
+}
+export {};

package/dist/esm/Logger.js

@@ -0,0 +1,148 @@
+const MAX_LOG_LINES_BEFORE_FLUSH = 50;
+// The server drops (and alerts on) any single log message whose byte length exceeds 1MB, so cap
+// each message just below that. We truncate rather than drop so oversized lines are still logged
+// (head of the message + a marker) instead of being lost. The margin leaves room for the marker.
+const ONE_MEGABYTE = 1024 * 1024;
+const MAX_LOG_MESSAGE_LENGTH = ONE_MEGABYTE - 1024;
+export default class Logger {
+    constructor({ serverLoggingCallback, isDebug, clientLoggingCallback, maxLogLinesBeforeFlush, getContextEmail }) {
+        // An array of log lines that limits itself to a certain number of entries (deleting the oldest)
+        this.logLines = [];
+        this.serverLoggingCallback = serverLoggingCallback;
+        this.clientLoggingCallback = clientLoggingCallback;
+        this.isDebug = isDebug;
+        this.maxLogLinesBeforeFlush = maxLogLinesBeforeFlush || MAX_LOG_LINES_BEFORE_FLUSH;
+        this.getContextEmail = getContextEmail;
+        // Public Methods
+        this.info = this.info.bind(this);
+        this.alert = this.alert.bind(this);
+        this.warn = this.warn.bind(this);
+        this.hmmm = this.hmmm.bind(this);
+        this.client = this.client.bind(this);
+    }
+    /**
+     * Ask the server to write the log message
+     */
+    logToServer() {
+        var _a, _b;
+        // We do not want to call the server with an empty list or if all the lines has onlyFlushWithOthers=true
+        if (!this.logLines.length || ((_a = this.logLines) === null || _a === void 0 ? void 0 : _a.every((l) => l.onlyFlushWithOthers))) {
+            return;
+        }
+        // We don't care about log setting web cookies so let's define it as false
+        const linesToLog = (_b = this.logLines) === null || _b === void 0 ? void 0 : _b.map((l) => {
+            // eslint-disable-next-line no-param-reassign
+            delete l.onlyFlushWithOthers;
+            return l;
+        });
+        this.logLines = [];
+        const promise = this.serverLoggingCallback(this, {
+            api_setCookie: false,
+            logPacket: JSON.stringify(linesToLog),
+        });
+        if (!promise) {
+            return;
+        }
+        promise.then((response) => {
+            if (!response.requestID) {
+                return;
+            }
+            this.info('Previous log requestID', false, { requestID: response.requestID }, true);
+        });
+    }
+    /**
+     * Add a message to the list
+     * @param parameters The parameters associated with the message
+     * @param forceFlushToServer Should we force flushing all logs to server?
+     * @param onlyFlushWithOthers A request will never be sent to the server if all loglines have this set to true
+     */
+    add(message, parameters, forceFlushToServer, onlyFlushWithOthers = false, extraData = '') {
+        // Capture the user's email at the moment this specific log line is created
+        // This ensures the log retains user context even if the session is cleared before sending
+        let email = null;
+        try {
+            email = this.getContextEmail ? this.getContextEmail() : null;
+        }
+        catch (_a) {
+            // Silently fail if getContextEmail throws - logging should not crash
+        }
+        let cappedMessage = message;
+        if (message.length > MAX_LOG_MESSAGE_LENGTH) {
+            const omittedCount = message.length - MAX_LOG_MESSAGE_LENGTH;
+            cappedMessage = `${message.slice(0, MAX_LOG_MESSAGE_LENGTH)}…[truncated ${omittedCount} characters]`;
+        }
+        const length = this.logLines.push({
+            message: cappedMessage,
+            parameters,
+            onlyFlushWithOthers,
+            timestamp: new Date(),
+            email,
+        });
+        if (this.isDebug) {
+            this.client(`${message} - ${JSON.stringify(parameters)}`, extraData);
+        }
+        // If we're over the limit, flush the logs
+        if (length > this.maxLogLinesBeforeFlush || forceFlushToServer) {
+            this.logToServer();
+        }
+    }
+    /**
+     * Caches an informational message locally, to be sent to the server if
+     * needed later.
+     *
+     * @param message The message to log.
+     * @param sendNow if true, the message will be sent right away.
+     * @param parameters The parameters to send along with the message
+     * @param onlyFlushWithOthers A request will never be sent to the server if all loglines have this set to true
+     */
+    info(message, sendNow = false, parameters = '', onlyFlushWithOthers = false, extraData = '') {
+        const msg = `[info] ${message}`;
+        this.add(msg, parameters, sendNow, onlyFlushWithOthers, extraData);
+    }
+    /**
+     * Logs an alert.
+     *
+     * @param message The message to alert.
+     * @param parameters The parameters to send along with the message
+     * @param includeStackTrace Must be disabled for testing
+     */
+    alert(message, parameters = {}, includeStackTrace = true) {
+        const msg = `[alrt] ${message}`;
+        const params = parameters;
+        if (includeStackTrace && typeof params === 'object' && !Array.isArray(params)) {
+            params.stack = JSON.stringify(new Error().stack);
+        }
+        this.add(msg, params, true);
+    }
+    /**
+     * Logs a warn.
+     *
+     * @param message The message to warn.
+     * @param parameters The parameters to send along with the message
+     */
+    warn(message, parameters = '') {
+        const msg = `[warn] ${message}`;
+        this.add(msg, parameters, true);
+    }
+    /**
+     * Logs a hmmm.
+     *
+     * @param message The message to hmmm.
+     * @param parameters The parameters to send along with the message
+     */
+    hmmm(message, parameters = '') {
+        const msg = `[hmmm] ${message}`;
+        this.add(msg, parameters, false);
+    }
+    /**
+     * Logs a message in the browser console.
+     *
+     * @param message The message to log.
+     */
+    client(message, extraData = '') {
+        if (!this.clientLoggingCallback) {
+            return;
+        }
+        this.clientLoggingCallback(message, extraData);
+    }
+}

package/dist/esm/Network.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {String} endpoint
+ *
+ * @returns {Object}
+ */
+export default function Network(endpoint: string): Object;

package/dist/esm/Network.js

@@ -0,0 +1,168 @@
+import $ from 'jquery';
+import * as Utils from './utils';
+/**
+ * Adds our API command to the URL so the API call is more easily identified in the
+ * network tab of the JS console
+ *
+ * @param {string} command
+ * @param {string} url
+ * @returns {string}
+ */
+function addCommandToUrl(command, url) {
+    let newUrl = url;
+    if (command) {
+        // Add a ? to the end of the URL if there isn't one already
+        if (newUrl.indexOf('?') === -1) {
+            newUrl = `${newUrl}?`;
+        }
+        newUrl = `${newUrl}&command=${command}`;
+    }
+    return newUrl;
+}
+/**
+ * @param {String} endpoint
+ *
+ * @returns {Object}
+ */
+export default function Network(endpoint) {
+    // A flag that turns true when the user navigates away
+    let isNavigatingAway = false;
+    // If URL ends in `/` we're using /api/{command} format.
+    const isNewURLFormat = endpoint[endpoint.length - 1] === '/';
+    if (!endpoint) {
+        throw new Error('Cannot instantiate Network without an url endpoint');
+    }
+    // Attach a listener to the event indicating that we're leaving a page
+    if (Utils.isWindowAvailable()) {
+        window.onbeforeunload = () => {
+            isNavigatingAway = true;
+        };
+    }
+    return {
+        /**
+         * @param {String} url to fetch
+         * @returns {Deferred}
+         */
+        get(url) {
+            return $.get(url);
+        },
+        /**
+         * @param {Object} parameters
+         *
+         * @returns {$.Deferred}
+         */
+        post(parameters) {
+            // Build request
+            let newURL = endpoint;
+            if (isNewURLFormat) {
+                // Remove command from parameters and use it in the URL
+                const command = parameters.command;
+                // eslint-disable-next-line no-param-reassign
+                delete parameters.command;
+                newURL = `${endpoint}${command}`;
+            }
+            const settings = {
+                url: newURL,
+                type: 'POST',
+                data: parameters,
+            };
+            const formData = new FormData();
+            let shouldUseFormData = false;
+            // Add the API command to our URL (for console debugging purposes)
+            // Note that parameters.command is empty if we're using the new API format and this will do nothing.
+            settings.url = addCommandToUrl(parameters.command, settings.url);
+            // Check to see if parameters contains a File or Blob object
+            // If it does, we should use formData instead of parameters and update
+            // the ajax settings accordingly
+            for (const [key, value] of Object.entries(parameters)) {
+                if (value === undefined) {
+                    continue;
+                }
+                // Populate formData in case we need it
+                formData.append(key, value);
+                if (value instanceof File || value instanceof Blob) {
+                    shouldUseFormData = true;
+                }
+            }
+            if (shouldUseFormData) {
+                settings.processData = false;
+                settings.contentType = false;
+                settings.data = formData;
+            }
+            return $.ajax(settings);
+        },
+        /**
+         * Uses the fetch API to send a keepalive request that will complete
+         * even if the browser is closed
+         *
+         * Note: This method ONLY provides partial support for sending complex data structures.
+         * It supports a single level array of objects with no nested properties
+         * eg. [{one: 1}, {two:2}]
+         *
+         * @param {Object} parameters
+         * @returns {$.Deferred}
+         */
+        keepalive(parameters) {
+            // Build request
+            const settings = {
+                method: 'POST',
+                keepalive: true,
+                credentials: 'same-origin',
+            };
+            let url = endpoint;
+            // Add the API command to our URL (for console debugging purposes)
+            url = addCommandToUrl(parameters.command, url);
+            // Add our data as form data
+            const formData = new FormData();
+            for (const [key, value] of Object.entries(parameters)) {
+                if (value === undefined) {
+                    continue;
+                }
+                if (Array.isArray(value)) {
+                    for (const [i, valueItem] of value.entries()) {
+                        if (Utils.isObject(valueItem)) {
+                            for (const [valueItemObjectKey, valueItemObjectValue] of Object.entries(valueItem)) {
+                                formData.append(`${key}[${i}][${valueItemObjectKey}]`, valueItemObjectValue);
+                            }
+                        }
+                        else {
+                            formData.append(`${key}[${i}]`, valueItem);
+                        }
+                    }
+                }
+                else {
+                    formData.append(key, value);
+                }
+            }
+            settings.body = formData;
+            // Make our request via the fetch API but return it in the form of a jQuery promise
+            // so that our API can be consistent
+            const promise = new $.Deferred();
+            fetch(url, settings)
+                .then(() => {
+                // No need to return a response since there is no script to process it
+                // due to the browser being closed
+                promise.resolve();
+            })
+                .catch((error) => {
+                promise.reject(error);
+            });
+            return promise;
+        },
+        /**
+         * @param {Function} callback
+         */
+        registerNetworkFailureHandler(callback) {
+            $(document).ajaxError((event, jqxhr) => {
+                // Some browsers invoke the ajax error callbacks when navigating away during a pending ajax call
+                // Ignore this if navigating away
+                if (isNavigatingAway) {
+                    return;
+                }
+                const response = jqxhr.responseJSON;
+                const jsonCode = response ? parseInt(response.jsonCode, 10) : null;
+                callback(jsonCode, response);
+            });
+        },
+    };
+}

package/dist/esm/Num.d.ts

@@ -0,0 +1,95 @@
+declare namespace _default {
+    /**
+     * Converts an exponential number into it's non-exponential string equivalent
+     *
+     * @param {Number} num
+     *
+     * @returns {String}
+     */
+    function notExponential(num: number): string;
+    /**
+     * 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}
+     */
+    function number_format(_a: number, b?: number, _c?: string, d?: string): string;
+    function generateRandom6DigitID(): number;
+    /**
+     * 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.
+     */
+    function toBase26LetterCode(num: number): string;
+    /**
+     * 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.
+     */
+    function isFiniteNumber(number: number): boolean;
+    /**
+     * 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.
+     */
+    function toPrecision(number: number, decimals: number): number;
+    /**
+     * 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}
+     */
+    function isNumberBetween(number: number, a: number, b: number): boolean;
+    /**
+     * Returns how many decimals to display (used for currencies).
+     *
+     * @param {Number} rate
+     * @returns {Number}
+     */
+    function getDisplayDecimals(rate: number): number;
+    namespace 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
+         */
+        function calculatePreTaxAmount(total: number, taxUDF: UserDefinedField): number;
+        /**
+         * 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
+         */
+        function calculateTaxFromPercentage(total: number, percentage: string): number;
+        /**
+         * 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
+         */
+        function calculateTaxFromDivisor(total: number, divisor: number): number;
+    }
+}
+export default _default;