react-native-onyx 2.0.11 → 2.0.13

package/dist/Logger.d.ts

@@ -1,13 +1,18 @@
-declare type LogData = {
+type LogData = {
     message: string;
     level: 'alert' | 'info';
 };
-
+type LoggerCallback = (data: LogData) => void;
 /**
  * Register the logging callback
- *
- * @param callback
  */
-declare function registerLogger(callback: (data: LogData) => void): void;
-
-export {registerLogger};
+declare function registerLogger(callback: LoggerCallback): void;
+/**
+ * Send an alert message to the logger
+ */
+declare function logAlert(message: string): void;
+/**
+ * Send an info message to the logger
+ */
+declare function logInfo(message: string): void;
+export { registerLogger, logInfo, logAlert };

package/dist/Logger.js

@@ -1,12 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.logAlert = exports.logInfo = exports.registerLogger = void 0;
-// Logging callback
+// eslint-disable-next-line @typescript-eslint/no-empty-function
 let logger = () => { };
 /**
  * Register the logging callback
- *
- * @param {Function} callback
  */
 function registerLogger(callback) {
     logger = callback;
@@ -14,8 +12,6 @@ function registerLogger(callback) {
 exports.registerLogger = registerLogger;
 /**
  * Send an alert message to the logger
- *
- * @param {String} message
  */
 function logAlert(message) {
     logger({ message: `[Onyx] ${message}`, level: 'alert' });
@@ -23,8 +19,6 @@ function logAlert(message) {
 exports.logAlert = logAlert;
 /**
  * Send an info message to the logger
- *
- * @param {String} message
  */
 function logInfo(message) {
     logger({ message: `[Onyx] ${message}`, level: 'info' });

package/dist/Onyx.js

@@ -694,13 +694,70 @@ function addKeyToRecentlyAccessedIfNeeded(mapping) {
  * @param {Object} mapping
  */
 function getCollectionDataAndSendAsObject(matchingKeys, mapping) {
-    Promise.all(underscore_1.default.map(matchingKeys, (key) => get(key)))
-        .then((values) => underscore_1.default.reduce(values, (finalObject, value, i) => {
-        // eslint-disable-next-line no-param-reassign
-        finalObject[matchingKeys[i]] = value;
-        return finalObject;
-    }, {}))
-        .then((val) => sendDataToConnection(mapping, val, undefined, true));
+    // Keys that are not in the cache
+    const missingKeys = [];
+    // Tasks that are pending
+    const pendingTasks = [];
+    // Keys for the tasks that are pending
+    const pendingKeys = [];
+    // We are going to combine all the data from the matching keys into a single object
+    const data = {};
+    /**
+     * We are going to iterate over all the matching keys and check if we have the data in the cache.
+     * If we do then we add it to the data object. If we do not then we check if there is a pending task
+     * for the key. If there is then we add the promise to the pendingTasks array and the key to the pendingKeys
+     * array. If there is no pending task then we add the key to the missingKeys array.
+     *
+     * These missingKeys will be later to use to multiGet the data from the storage.
+     */
+    matchingKeys.forEach((key) => {
+        const cacheValue = OnyxCache_1.default.getValue(key);
+        if (cacheValue) {
+            data[key] = cacheValue;
+            return;
+        }
+        const pendingKey = `get:${key}`;
+        if (OnyxCache_1.default.hasPendingTask(pendingKey)) {
+            pendingTasks.push(OnyxCache_1.default.getTaskPromise(pendingKey));
+            pendingKeys.push(key);
+        }
+        else {
+            missingKeys.push(key);
+        }
+    });
+    Promise.all(pendingTasks)
+        // We are going to wait for all the pending tasks to resolve and then add the data to the data object.
+        .then((values) => {
+        values.forEach((value, index) => {
+            data[pendingKeys[index]] = value;
+        });
+        return Promise.resolve();
+    })
+        // We are going to get the missing keys using multiGet from the storage.
+        .then(() => {
+        if (missingKeys.length === 0) {
+            return Promise.resolve();
+        }
+        return storage_1.default.multiGet(missingKeys);
+    })
+        // We are going to add the data from the missing keys to the data object and also merge it to the cache.
+        .then((values) => {
+        if (!values || values.length === 0) {
+            return Promise.resolve();
+        }
+        // temp object is used to merge the missing data into the cache
+        const temp = {};
+        values.forEach((value) => {
+            data[value[0]] = value[1];
+            temp[value[0]] = value[1];
+        });
+        OnyxCache_1.default.merge(temp);
+        return Promise.resolve();
+    })
+        // We are going to send the data to the subscriber.
+        .finally(() => {
+        sendDataToConnection(mapping, data, undefined, true);
+    });
 }
 /**
  * Subscribes a react component's state directly to a store key

package/dist/Str.d.ts

@@ -1,18 +1,17 @@
 /**
  * Returns true if the haystack begins with the needle
  *
- * @param {String} haystack  The full string to be searched
- * @param {String} needle    The case-sensitive string to search for
- * @return {Boolean} Returns true if the haystack starts with the needle.
+ * @param haystack  The full string to be searched
+ * @param needle    The case-sensitive string to search for
+ * @return Returns true if the haystack starts with the needle.
  */
-export function startsWith(haystack: string, needle: string): boolean;
+declare function startsWith(haystack: string, needle: string): boolean;
 /**
  * Checks if parameter is a string or function.
  * If it is a string, then we will just return it.
  * If it is a function, then we will call it with
  * any additional arguments and return the result.
- *
- * @param {String|Function} parameter
- * @returns {*}
  */
-export function result(parameter: string | Function, ...args: any[]): any;
+declare function result(parameter: string): string;
+declare function result<TFunction extends (...a: TArgs) => unknown, TArgs extends unknown[]>(parameter: TFunction, ...args: TArgs): ReturnType<TFunction>;
+export { startsWith, result };

package/dist/Str.js

@@ -1,31 +1,18 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.result = exports.startsWith = void 0;
-const underscore_1 = __importDefault(require("underscore"));
 /**
  * Returns true if the haystack begins with the needle
  *
- * @param {String} haystack  The full string to be searched
- * @param {String} needle    The case-sensitive string to search for
- * @return {Boolean} Returns true if the haystack starts with the needle.
+ * @param haystack  The full string to be searched
+ * @param needle    The case-sensitive string to search for
+ * @return Returns true if the haystack starts with the needle.
  */
 function startsWith(haystack, needle) {
-    return underscore_1.default.isString(haystack) && underscore_1.default.isString(needle) && haystack.startsWith(needle);
+    return typeof haystack === 'string' && typeof needle === 'string' && haystack.startsWith(needle);
 }
 exports.startsWith = startsWith;
-/**
- * Checks if parameter is a string or function.
- * If it is a string, then we will just return it.
- * If it is a function, then we will call it with
- * any additional arguments and return the result.
- *
- * @param {String|Function} parameter
- * @returns {*}
- */
 function result(parameter, ...args) {
-    return underscore_1.default.isFunction(parameter) ? parameter(...args) : parameter;
+    return typeof parameter === 'function' ? parameter(...args) : parameter;
 }
 exports.result = result;

package/dist/createDeferredTask.d.ts

@@ -1,12 +1,11 @@
+type DeferredTask = {
+    promise: Promise<void>;
+    resolve?: () => void;
+};
 /**
  * Create a deferred task that can be resolved when we call `resolve()`
  * The returned promise will complete when we call `resolve`
  * Useful when we want to wait for a tasks that is resolved from an external action
- *
- * @template T
- * @returns {{ resolve: function(*), promise: Promise<T|void> }}
  */
-export default function createDeferredTask<T>(): {
-    resolve: (arg0: any) => any;
-    promise: Promise<void | T>;
-};
+export default function createDeferredTask(): DeferredTask;
+export {};

package/dist/createDeferredTask.js

@@ -4,9 +4,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * Create a deferred task that can be resolved when we call `resolve()`
  * The returned promise will complete when we call `resolve`
  * Useful when we want to wait for a tasks that is resolved from an external action
- *
- * @template T
- * @returns {{ resolve: function(*), promise: Promise<T|void> }}
  */
 function createDeferredTask() {
     const deferred = {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-onyx",
-  "version": "2.0.11",
+  "version": "2.0.13",
   "author": "Expensify, Inc.",
   "homepage": "https://expensify.com",
   "description": "State management for React Native",

package/dist/SyncQueue.d.ts

@@ -1,32 +0,0 @@
-/**
- * Synchronous queue that can be used to ensure promise based tasks are run in sequence.
- * Pass to the constructor a function that returns a promise to run the task then add data.
- *
- * @example
- *
- *     const queue = new SyncQueue(({key, val}) => {
- *         return someAsyncProcess(key, val);
- *     });
- *
- *     queue.push({key: 1, val: '1'});
- *     queue.push({key: 2, val: '2'});
- */
-export default class SyncQueue {
-    /**
-     * @param {Function} run - must return a promise
-     */
-    constructor(run: Function);
-    queue: any[];
-    isProcessing: boolean;
-    run: Function;
-    /**
-     * Stop the queue from being processed and clear out any existing tasks
-     */
-    abort(): void;
-    process(): void;
-    /**
-     * @param {*} data
-     * @returns {Promise}
-     */
-    push(data: any): Promise<any>;
-}

package/dist/SyncQueue.js

@@ -1,57 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * Synchronous queue that can be used to ensure promise based tasks are run in sequence.
- * Pass to the constructor a function that returns a promise to run the task then add data.
- *
- * @example
- *
- *     const queue = new SyncQueue(({key, val}) => {
- *         return someAsyncProcess(key, val);
- *     });
- *
- *     queue.push({key: 1, val: '1'});
- *     queue.push({key: 2, val: '2'});
- */
-class SyncQueue {
-    /**
-     * @param {Function} run - must return a promise
-     */
-    constructor(run) {
-        this.queue = [];
-        this.isProcessing = false;
-        this.run = run;
-    }
-    /**
-     * Stop the queue from being processed and clear out any existing tasks
-     */
-    abort() {
-        this.queue = [];
-        this.isProcessing = false;
-    }
-    process() {
-        if (this.isProcessing || this.queue.length === 0) {
-            return;
-        }
-        this.isProcessing = true;
-        const { data, resolve, reject } = this.queue.shift();
-        this.run(data)
-            .then(resolve)
-            .catch(reject)
-            .finally(() => {
-            this.isProcessing = false;
-            this.process();
-        });
-    }
-    /**
-     * @param {*} data
-     * @returns {Promise}
-     */
-    push(data) {
-        return new Promise((resolve, reject) => {
-            this.queue.push({ resolve, reject, data });
-            this.process();
-        });
-    }
-}
-exports.default = SyncQueue;

package/dist/compose.d.ts

@@ -1,19 +0,0 @@
-/**
- * This is a utility function taken directly from Redux. (We don't want to add Redux as a dependency)
- * It enables functional composition, useful for the chaining/composition of HOCs.
- *
- * For example, instead of:
- *
- * export default hoc1(config1, hoc2(config2, hoc3(config3)))(Component);
- *
- * Use this instead:
- *
- * export default compose(
- *     hoc1(config1),
- *     hoc2(config2),
- *     hoc3(config3),
- * )(Component)
- *
- * @returns {Function}
- */
-export default function compose(...funcs: any[]): Function;

package/dist/compose.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * This is a utility function taken directly from Redux. (We don't want to add Redux as a dependency)
- * It enables functional composition, useful for the chaining/composition of HOCs.
- *
- * For example, instead of:
- *
- * export default hoc1(config1, hoc2(config2, hoc3(config3)))(Component);
- *
- * Use this instead:
- *
- * export default compose(
- *     hoc1(config1),
- *     hoc2(config2),
- *     hoc3(config3),
- * )(Component)
- *
- * @returns {Function}
- */
-function compose(...funcs) {
-    if (funcs.length === 0) {
-        return (arg) => arg;
-    }
-    if (funcs.length === 1) {
-        return funcs[0];
-    }
-    // eslint-disable-next-line rulesdir/prefer-underscore-method
-    return funcs.reduce((a, b) => (...args) => a(b(...args)));
-}
-exports.default = compose;