expensify-common 2.0.188 → 2.0.190

package/dist/esm/APIDeferred.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @param {jquery.Deferred} promise
+ * @param {String} [extractedProperty]
+ *
+ * @returns {Object}
+ */
+export default function APIDeferred(promise: jquery.Deferred, extractedProperty?: string): Object;

package/dist/esm/APIDeferred.js

@@ -0,0 +1,216 @@
+/**
+ * ----------------------------------------------------------------------------------------------
+ * WIP, This is in the process of migration from web-e. Please add methods to this as is needed.|
+ * ----------------------------------------------------------------------------------------------
+ */
+import get from 'lodash/get';
+import once from 'lodash/once';
+import * as Utils from './utils';
+import * as Func from './Func';
+/**
+ * @param {jquery.Deferred} promise
+ * @param {String} [extractedProperty]
+ *
+ * @returns {Object}
+ */
+export default function APIDeferred(promise, extractedProperty) {
+    /**
+     * @private
+     */
+    const extractedPropertyName = extractedProperty || null;
+    let cachedResponse = null;
+    const doneCallbacks = [];
+    const alwaysCallbacks = [];
+    const unhandledCallbacks = [];
+    const failCallbacks = [];
+    const errorHandlers = {};
+    if (!promise) {
+        throw new Error('Cannot instantiate APIDeferred without a Deferred promise');
+    }
+    /**
+     * @private
+     * @param {Object} [response]
+     * @returns {?Number}
+     */
+    function extractJSONCode(response) {
+        return response ? response.jsonCode : null;
+    }
+    /**
+     * Called when the jsonCode is not 200 and invokes the appropriate callbacks for the jsonCode
+     * If no callback is defined for the jsonCode then the unhandledCallbacks are invoked
+     * The failCallbacks are always called
+     *
+     * @private
+     * @param {Number} jsonCode
+     * @param {Object} [response]
+     */
+    function handleError(jsonCode, response) {
+        // Look for handlers for this error code
+        const handlers = get(errorHandlers, jsonCode, []);
+        if (handlers.length > 0) {
+            Func.bulkInvoke(handlers, [jsonCode, response]);
+        }
+        else {
+            // No explicit handlers, call the unhandled callbacks
+            Func.bulkInvoke(unhandledCallbacks, [jsonCode, response]);
+        }
+        // Always run the "fail" callbacks in case of error
+        Func.bulkInvoke(failCallbacks, [jsonCode, response]);
+    }
+    /**
+     * Called when network call succeeds or when a callback is added via any of the following methods after the promise is resolved:
+     *      done(), always(), handle(), unhandled(), or fail()
+     *
+     * @private
+     * @param {Object} [response]
+     */
+    function handleDone(response) {
+        let returnedData;
+        // Figure out if we need to extract a property from the response, and if it is there.
+        const jsonCode = extractJSONCode(response);
+        const propertyRequested = extractedPropertyName && extractedPropertyName !== null;
+        const requestedPropertyPresent = propertyRequested && response && response[extractedPropertyName] !== undefined;
+        const propertyRequestedButMissing = propertyRequested && !requestedPropertyPresent;
+        // Save the response for any callbacks that might run in the future
+        cachedResponse = response;
+        // Handle three different success/failure scenarios: ok (jsonCode == 200), exception (jsonCode != 200), other error
+        if (jsonCode === 200 && (!propertyRequested || requestedPropertyPresent)) {
+            // Get the data that was requested
+            returnedData = propertyRequested && requestedPropertyPresent ? response[extractedPropertyName] : response;
+            // And then run the success callbacks
+            Func.bulkInvoke(doneCallbacks, [returnedData]);
+        }
+        else if (jsonCode !== null && jsonCode !== 200) {
+            // Exception thrown, handle it
+            handleError(jsonCode, response);
+        }
+        else {
+            // Edge cases:
+            // If a specific property was requested but is missing, or if we got a blank response, throw an error
+            if (propertyRequestedButMissing) {
+                throw new Error(`Requested property " ${extractedPropertyName}" missing from response`);
+            }
+            if (!response) {
+                throw new Error('Blank response returned from API');
+            }
+        }
+        // Always run the "always" callbacks
+        Func.bulkInvoke(alwaysCallbacks, [response]);
+    }
+    /**
+     * Re-runs the "done" flow with a saved response to ensure that all callbacks are invoked,
+     * even if they were added after the deferred was resolved
+     *
+     * @private
+     */
+    function ensureFutureCallbacksFire() {
+        if (promise.state() === 'pending') {
+            return;
+        }
+        // Re-run the done handler with the response we saved
+        handleDone(cachedResponse);
+    }
+    // Attach the function to be called when the promise is resolved
+    // See handleDone() for more details
+    promise.done(handleDone);
+    return {
+        /**
+         * Attaches a callback that will be invoked when the jsonCode is 200
+         *
+         * @param {Function} callback A function that takes the response as a parameter
+         *
+         * @returns {APIDeferred} itself, for chaining
+         */
+        done(callback) {
+            if (Utils.isFunction(callback)) {
+                doneCallbacks.push(once(callback));
+                ensureFutureCallbacksFire();
+            }
+            return this;
+        },
+        /**
+         * Attaches a callback that will always be invoked
+         *
+         * @param {Function} callback A function that takes the response as a parameter
+         *
+         * @returns {APIDeferred} itself, for chaining
+         */
+        always(callback) {
+            if (Utils.isFunction(callback)) {
+                alwaysCallbacks.push(once(callback));
+                ensureFutureCallbacksFire();
+            }
+            return this;
+        },
+        /**
+         * Attaches a callback that will be invoked on non-200 jsonCodes
+         * Callbacks for jsonCode 200 are expected to be attached with done() and are therefore ignored here
+         *
+         * @param {Number[]} jsonCodes A list of error codes to handle
+         * @param {Function} callback A function that takes the jsonCode and response as parameters
+         *
+         * @returns {APIDeferred} itself, for chaining
+         */
+        handle(jsonCodes, callback) {
+            if (Utils.isFunction(callback)) {
+                for (const code of jsonCodes) {
+                    if (code === 200) {
+                        continue;
+                    }
+                    if (!errorHandlers[code]) {
+                        errorHandlers[code] = [];
+                    }
+                    errorHandlers[code].push(once(callback));
+                }
+                ensureFutureCallbacksFire();
+            }
+            return this;
+        },
+        /**
+         * Attaches a callback that will be invoked on all errors not explicitly handled via handle()
+         *
+         * @param {Function} callback A function that takes the jsonCode and response as parameters
+         *
+         * @returns {APIDeferred} itself, for chaining
+         */
+        unhandled(callback) {
+            if (Utils.isFunction(callback)) {
+                unhandledCallbacks.push(once(callback));
+                ensureFutureCallbacksFire();
+            }
+            return this;
+        },
+        /**
+         * Attaches a callback that will be always be invoked when the API does NOT return jsonCode 200, regardless of
+         * handle() or unhandled()
+         *
+         * @param {Function} callback A function that takes the jsonCode and response as parameters
+         *
+         * @returns {APIDeferred} itself, for chaining
+         */
+        fail(callback) {
+            if (Utils.isFunction(callback)) {
+                failCallbacks.push(once(callback));
+                ensureFutureCallbacksFire();
+            }
+            return this;
+        },
+        /**
+         * Attaches a callback that will be invoked when this deferred resolves successfully
+         *
+         * @param {Function} callback A function that takes the response as a parameter
+         *
+         * @returns {APIDeferred} itself, for chaining
+         */
+        then(callback) {
+            return promise.then((response) => {
+                const responseCode = extractJSONCode(response);
+                if (responseCode !== 200 || !Utils.isFunction(callback)) {
+                    return;
+                }
+                Func.invoke(callback, [response]);
+                return this;
+            });
+        },
+    };
+}

package/dist/esm/BrowserDetect.d.ts

@@ -0,0 +1,19 @@
+declare namespace _default {
+    export { BROWSERS };
+    export { MOBILE_PLATFORMS };
+    export let browser: string;
+    export let mobileDevice: string;
+}
+export default _default;
+declare namespace BROWSERS {
+    let EDGE: string;
+    let CHROME: string;
+    let SAFARI: string;
+    let OPERA: string;
+    let EXPLORER: string;
+    let MOZILLA: string;
+}
+declare namespace MOBILE_PLATFORMS {
+    let iOS: string;
+    let android: string;
+}

package/dist/esm/BrowserDetect.js

@@ -0,0 +1,105 @@
+import * as Utils from './utils';
+const BROWSERS = {
+    EDGE: 'Edge',
+    CHROME: 'Chrome',
+    SAFARI: 'Safari',
+    OPERA: 'Opera',
+    EXPLORER: 'Explorer',
+    MOZILLA: 'Mozilla',
+};
+const MOBILE_PLATFORMS = {
+    iOS: 'iOS',
+    android: 'android',
+};
+function searchString() {
+    if (!Utils.isWindowAvailable() || !Utils.isNavigatorAvailable()) {
+        return '';
+    }
+    const data = [
+        {
+            string: navigator.userAgent,
+            subString: 'Edge',
+            identity: BROWSERS.EDGE,
+        },
+        {
+            string: navigator.userAgent,
+            subString: 'Chrome',
+            identity: BROWSERS.CHROME,
+        },
+        {
+            string: navigator.vendor,
+            subString: 'Apple',
+            identity: BROWSERS.SAFARI,
+        },
+        {
+            prop: window.opera,
+            identity: BROWSERS.OPERA,
+        },
+        {
+            string: navigator.userAgent,
+            subString: 'Edge',
+            identity: BROWSERS.EDGE,
+        },
+        {
+            string: navigator.userAgent,
+            subString: 'MSIE',
+            identity: BROWSERS.EXPLORER,
+        },
+        {
+            string: navigator.userAgent,
+            subString: '.NET',
+            identity: BROWSERS.EXPLORER,
+        },
+        {
+            string: navigator.userAgent,
+            subString: 'Gecko',
+            identity: BROWSERS.MOZILLA,
+        },
+    ];
+    let dataString;
+    let dataProp;
+    for (let i = 0; i < data.length; i++) {
+        dataString = data[i].string;
+        dataProp = data[i].prop;
+        if (dataString) {
+            if (dataString.indexOf(data[i].subString) !== -1) {
+                return data[i].identity;
+            }
+        }
+        else if (dataProp) {
+            return data[i].identity;
+        }
+    }
+    return '';
+}
+function getMobileDevice() {
+    if (!Utils.isNavigatorAvailable() || !navigator.userAgent) {
+        return '';
+    }
+    const data = [
+        {
+            devices: ['iPhone', 'iPad', 'iPod'],
+            identity: MOBILE_PLATFORMS.iOS,
+        },
+        {
+            devices: ['Android'],
+            identity: MOBILE_PLATFORMS.android,
+        },
+    ];
+    const dataString = navigator.userAgent;
+    for (let i = 0; i < data.length; i++) {
+        const { devices, identity } = data[i];
+        for (let j = 0; j < devices.length; j++) {
+            if (dataString.indexOf(devices[j]) !== -1) {
+                return identity;
+            }
+        }
+    }
+    return '';
+}
+export default {
+    BROWSERS,
+    MOBILE_PLATFORMS,
+    browser: searchString(),
+    mobileDevice: getMobileDevice(),
+};

package/dist/esm/CLI.js

@@ -1,3 +1,12 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 /**
  * This file contains a CLI utility class which can be used to declaratively implement a strongly-typed CLI.
  * You provide a CLIConfig defining your arguments, then the class will handle parsing argv, type validation, error handling, and help messages.
@@ -6,15 +15,11 @@ import * as readline from 'readline';
 import SafeString from './SafeString.js';
 class CLI {
     constructor(config) {
+        var _a, _b, _c, _d, _e, _f;
         this.config = config;
         const rawArgs = process.argv.slice(2);
         // Initialize all flags to false by default (including built-in flags)
-        this.flags = {
-            ...Object.fromEntries(Object.keys(config.flags ?? {}).map((key) => [key, false])),
-            yes: false,
-            no: false,
-            help: false,
-        };
+        this.flags = Object.assign(Object.assign({}, Object.fromEntries(Object.keys((_a = config.flags) !== null && _a !== void 0 ? _a : {}).map((key) => [key, false]))), { yes: false, no: false, help: false });
         try {
             const parsedNamedArgs = {};
             const parsedPositionalArgs = {};
@@ -41,7 +46,7 @@ class CLI {
                             argValueBeforeParse = rawArgValue;
                         }
                         else {
-                            argValueBeforeParse = rawArgs.at(++i) ?? '';
+                            argValueBeforeParse = (_b = rawArgs.at(++i)) !== null && _b !== void 0 ? _b : '';
                             if (!argValueBeforeParse || argValueBeforeParse.startsWith('--')) {
                                 throw new Error(`Missing value for --${rawArgName}`);
                             }
@@ -56,7 +61,7 @@ class CLI {
                 }
                 else {
                     // Arg is a positional arg
-                    const spec = config.positionalArgs?.at(positionalIndex);
+                    const spec = (_c = config.positionalArgs) === null || _c === void 0 ? void 0 : _c.at(positionalIndex);
                     if (spec === undefined) {
                         throw new Error(`Unexpected arg: ${rawArg}`);
                     }
@@ -84,7 +89,7 @@ class CLI {
             }
             // Handle supersession logic
             const supersededArgs = new Set();
-            for (const [name, spec] of Object.entries(config.namedArgs ?? {})) {
+            for (const [name, spec] of Object.entries((_d = config.namedArgs) !== null && _d !== void 0 ? _d : {})) {
                 if (providedNamedArgs.has(name) && spec.supersedes) {
                     for (const supersededArg of spec.supersedes) {
                         supersededArgs.add(supersededArg);
@@ -95,7 +100,7 @@ class CLI {
                 }
             }
             // Validate that all required args are present, assign defaults where values are not parsed
-            for (const [name, spec] of Object.entries(config.namedArgs ?? {})) {
+            for (const [name, spec] of Object.entries((_e = config.namedArgs) !== null && _e !== void 0 ? _e : {})) {
                 if (name in parsedNamedArgs) {
                     if (supersededArgs.has(name)) {
                         parsedNamedArgs[name] = undefined;
@@ -117,7 +122,7 @@ class CLI {
                     throw new Error(`Missing required named argument --${name}`);
                 }
             }
-            for (const spec of config.positionalArgs ?? []) {
+            for (const spec of (_f = config.positionalArgs) !== null && _f !== void 0 ? _f : []) {
                 if (!(spec.name in parsedPositionalArgs)) {
                     if (spec.default !== undefined) {
                         parsedPositionalArgs[spec.name] = spec.default;
@@ -149,8 +154,9 @@ class CLI {
         }
     }
     printHelp() {
+        var _a;
         const { flags = {}, namedArgs = {}, positionalArgs = [] } = this.config;
-        const scriptName = process.argv.at(1) ?? 'script.ts';
+        const scriptName = (_a = process.argv.at(1)) !== null && _a !== void 0 ? _a : 'script.ts';
         const positionalUsage = positionalArgs
             .map((arg) => {
             const label = arg.variadic ? `${arg.name}...` : arg.name;
@@ -212,23 +218,25 @@ class CLI {
      * If --yes flag was passed, returns true immediately without prompting.
      * If --no flag was passed, returns false immediately without prompting.
      */
-    async promptUserConfirmation(message) {
-        // Check for built-in flags first
-        if (this.flags.yes) {
-            return true;
-        }
-        if (this.flags.no) {
-            return false;
-        }
-        const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout,
-        });
-        return new Promise((resolve) => {
-            rl.question(message, (answer) => {
-                rl.close();
-                const normalizedAnswer = answer.trim().toLowerCase();
-                resolve(normalizedAnswer === 'y' || normalizedAnswer === 'yes');
+    promptUserConfirmation(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Check for built-in flags first
+            if (this.flags.yes) {
+                return true;
+            }
+            if (this.flags.no) {
+                return false;
+            }
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            return new Promise((resolve) => {
+                rl.question(message, (answer) => {
+                    rl.close();
+                    const normalizedAnswer = answer.trim().toLowerCase();
+                    resolve(normalizedAnswer === 'y' || normalizedAnswer === 'yes');
+                });
             });
         });
     }