react-native-onyx 1.0.131 → 2.0.2

package/dist/OnyxCache.d.ts

@@ -0,0 +1,121 @@
+export default instance;
+declare const instance: OnyxCache;
+/**
+ * In memory cache providing data by reference
+ * Encapsulates Onyx cache related functionality
+ */
+declare class OnyxCache {
+    /**
+     * @private
+     * Cache of all the storage keys available in persistent storage
+     * @type {Set<string>}
+     */
+    private storageKeys;
+    /**
+     * @private
+     * Unique list of keys maintained in access order (most recent at the end)
+     * @type {Set<string>}
+     */
+    private recentKeys;
+    /**
+     * @private
+     * A map of cached values
+     * @type {Record<string, *>}
+     */
+    private storageMap;
+    /**
+     * @private
+     * Captured pending tasks for already running storage methods
+     * Using a map yields better performance on operations such a delete
+     * https://www.zhenghao.io/posts/object-vs-map
+     * @type {Map<string, Promise>}
+     */
+    private pendingPromises;
+    /**
+     * Get all the storage keys
+     * @returns {string[]}
+     */
+    getAllKeys(): string[];
+    /**
+     * Get a cached value from storage
+     * @param {string} key
+     * @returns {*}
+     */
+    getValue(key: string): any;
+    /**
+     * Check whether cache has data for the given key
+     * @param {string} key
+     * @returns {boolean}
+     */
+    hasCacheForKey(key: string): boolean;
+    /**
+     * Saves a key in the storage keys list
+     * Serves to keep the result of `getAllKeys` up to date
+     * @param {string} key
+     */
+    addKey(key: string): void;
+    /**
+     * Set's a key value in cache
+     * Adds the key to the storage keys list as well
+     * @param {string} key
+     * @param {*} value
+     * @returns {*} value - returns the cache value
+     */
+    set(key: string, value: any): any;
+    /**
+     * Forget the cached value for the given key
+     * @param {string} key
+     */
+    drop(key: string): void;
+    /**
+     * Deep merge data to cache, any non existing keys will be created
+     * @param {Record<string, *>} data - a map of (cache) key - values
+     */
+    merge(data: Record<string, any>): void;
+    /**
+     * Check whether the given task is already running
+     * @param {string} taskName - unique name given for the task
+     * @returns {*}
+     */
+    hasPendingTask(taskName: string): any;
+    /**
+     * Use this method to prevent concurrent calls for the same thing
+     * Instead of calling the same task again use the existing promise
+     * provided from this function
+     * @template T
+     * @param {string} taskName - unique name given for the task
+     * @returns {Promise<T>}
+     */
+    getTaskPromise<T>(taskName: string): Promise<T>;
+    /**
+     * Capture a promise for a given task so other caller can
+     * hook up to the promise if it's still pending
+     * @template T
+     * @param {string} taskName - unique name for the task
+     * @param {Promise<T>} promise
+     * @returns {Promise<T>}
+     */
+    captureTask<T_1>(taskName: string, promise: Promise<T_1>): Promise<T_1>;
+    /**
+     * @private
+     * Adds a key to the top of the recently accessed keys
+     * @param {string} key
+     */
+    private addToAccessedKeys;
+    /**
+     * Remove keys that don't fall into the range of recently used keys
+     */
+    removeLeastRecentlyUsedKeys(): void;
+    /**
+     * Set the recent keys list size
+     * @param {number} limit
+     */
+    setRecentKeysLimit(limit: number): void;
+    maxRecentKeysSize: number | undefined;
+    /**
+     * @param {String} key
+     * @param {*} value
+     * @returns {Boolean}
+     */
+    hasValueChanged(key: string, value: any): boolean;
+}

package/{lib → dist}/OnyxCache.js

@@ -1,9 +1,12 @@
-import _ from 'underscore';
-import {deepEqual} from 'fast-equals';
-import utils from './utils';
-
-const isDefined = _.negate(_.isUndefined);
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const underscore_1 = __importDefault(require("underscore"));
+const fast_equals_1 = require("fast-equals");
+const utils_1 = __importDefault(require("./utils"));
+const isDefined = underscore_1.default.negate(underscore_1.default.isUndefined);
 /**
  * In memory cache providing data by reference
  * Encapsulates Onyx cache related functionality
@@ -16,21 +19,18 @@ class OnyxCache {
          * @type {Set<string>}
          */
         this.storageKeys = new Set();
-
         /**
          * @private
          * Unique list of keys maintained in access order (most recent at the end)
          * @type {Set<string>}
          */
         this.recentKeys = new Set();
-
         /**
          * @private
          * A map of cached values
          * @type {Record<string, *>}
          */
         this.storageMap = {};
-
         /**
          * @private
          * Captured pending tasks for already running storage methods
@@ -39,25 +39,9 @@ class OnyxCache {
          * @type {Map<string, Promise>}
          */
         this.pendingPromises = new Map();
-
         // bind all public methods to prevent problems with `this`
-        _.bindAll(
-            this,
-            'getAllKeys',
-            'getValue',
-            'hasCacheForKey',
-            'addKey',
-            'set',
-            'drop',
-            'merge',
-            'hasPendingTask',
-            'getTaskPromise',
-            'captureTask',
-            'removeLeastRecentlyUsedKeys',
-            'setRecentKeysLimit',
-        );
+        underscore_1.default.bindAll(this, 'getAllKeys', 'getValue', 'hasCacheForKey', 'addKey', 'set', 'drop', 'merge', 'hasPendingTask', 'getTaskPromise', 'captureTask', 'removeLeastRecentlyUsedKeys', 'setRecentKeysLimit');
     }
-
     /**
      * Get all the storage keys
      * @returns {string[]}
@@ -65,7 +49,6 @@ class OnyxCache {
     getAllKeys() {
         return Array.from(this.storageKeys);
     }
-
     /**
      * Get a cached value from storage
      * @param {string} key
@@ -75,7 +58,6 @@ class OnyxCache {
         this.addToAccessedKeys(key);
         return this.storageMap[key];
     }
-
     /**
      * Check whether cache has data for the given key
      * @param {string} key
@@ -84,7 +66,6 @@ class OnyxCache {
     hasCacheForKey(key) {
         return isDefined(this.storageMap[key]);
     }
-
     /**
      * Saves a key in the storage keys list
      * Serves to keep the result of `getAllKeys` up to date
@@ -93,7 +74,6 @@ class OnyxCache {
     addKey(key) {
         this.storageKeys.add(key);
     }
-
     /**
      * Set's a key value in cache
      * Adds the key to the storage keys list as well
@@ -105,10 +85,8 @@ class OnyxCache {
         this.addKey(key);
         this.addToAccessedKeys(key);
         this.storageMap[key] = value;
-
         return value;
     }
-
     /**
      * Forget the cached value for the given key
      * @param {string} key
@@ -118,26 +96,22 @@ class OnyxCache {
         this.storageKeys.delete(key);
         this.recentKeys.delete(key);
     }
-
     /**
      * Deep merge data to cache, any non existing keys will be created
      * @param {Record<string, *>} data - a map of (cache) key - values
      */
     merge(data) {
-        if (!_.isObject(data) || _.isArray(data)) {
+        if (!underscore_1.default.isObject(data) || underscore_1.default.isArray(data)) {
             throw new Error('data passed to cache.merge() must be an Object of onyx key/value pairs');
         }
-
         // lodash adds a small overhead so we don't use it here
         // eslint-disable-next-line prefer-object-spread, rulesdir/prefer-underscore-method
-        this.storageMap = Object.assign({}, utils.fastMerge(this.storageMap, data, false));
-
+        this.storageMap = Object.assign({}, utils_1.default.fastMerge(this.storageMap, data, false));
         const storageKeys = this.getAllKeys();
-        const mergedKeys = _.keys(data);
+        const mergedKeys = underscore_1.default.keys(data);
         this.storageKeys = new Set([...storageKeys, ...mergedKeys]);
-        _.each(mergedKeys, (key) => this.addToAccessedKeys(key));
+        underscore_1.default.each(mergedKeys, (key) => this.addToAccessedKeys(key));
     }
-
     /**
      * Check whether the given task is already running
      * @param {string} taskName - unique name given for the task
@@ -146,7 +120,6 @@ class OnyxCache {
     hasPendingTask(taskName) {
         return isDefined(this.pendingPromises.get(taskName));
     }
-
     /**
      * Use this method to prevent concurrent calls for the same thing
      * Instead of calling the same task again use the existing promise
@@ -158,7 +131,6 @@ class OnyxCache {
     getTaskPromise(taskName) {
         return this.pendingPromises.get(taskName);
     }
-
     /**
      * Capture a promise for a given task so other caller can
      * hook up to the promise if it's still pending
@@ -171,12 +143,9 @@ class OnyxCache {
         const returnPromise = promise.finally(() => {
             this.pendingPromises.delete(taskName);
         });
-
         this.pendingPromises.set(taskName, returnPromise);
-
         return returnPromise;
     }
-
     /**
      * @private
      * Adds a key to the top of the recently accessed keys
@@ -187,7 +156,6 @@ class OnyxCache {
         this.recentKeys.delete(key);
         this.recentKeys.add(key);
     }
-
     /**
      * Remove keys that don't fall into the range of recently used keys
      */
@@ -203,13 +171,11 @@ class OnyxCache {
             temp.push(value);
             numKeysToRemove--;
         }
-
         for (let i = 0; i < temp.length; ++i) {
             delete this.storageMap[temp[i]];
             this.recentKeys.delete(temp[i]);
         }
     }
-
     /**
      * Set the recent keys list size
      * @param {number} limit
@@ -217,17 +183,14 @@ class OnyxCache {
     setRecentKeysLimit(limit) {
         this.maxRecentKeysSize = limit;
     }
-
     /**
      * @param {String} key
      * @param {*} value
      * @returns {Boolean}
      */
     hasValueChanged(key, value) {
-        return !deepEqual(this.storageMap[key], value);
+        return !(0, fast_equals_1.deepEqual)(this.storageMap[key], value);
     }
 }
-
 const instance = new OnyxCache();
-
-export default instance;
+exports.default = instance;

package/{lib/Str.js → dist/Str.d.ts}

@@ -1,5 +1,3 @@
-import _ from 'underscore';
-
 /**
  * Returns true if the haystack begins with the needle
  *
@@ -7,10 +5,7 @@ import _ from 'underscore';
  * @param {String} needle    The case-sensitive string to search for
  * @return {Boolean} Returns true if the haystack starts with the needle.
  */
-function startsWith(haystack, needle) {
-    return _.isString(haystack) && _.isString(needle) && haystack.startsWith(needle);
-}
-
+export 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.
@@ -20,8 +15,4 @@ function startsWith(haystack, needle) {
  * @param {String|Function} parameter
  * @returns {*}
  */
-function result(parameter, ...args) {
-    return _.isFunction(parameter) ? parameter(...args) : parameter;
-}
-
-export {startsWith, result};
+export function result(parameter: string | Function, ...args: any[]): any;

package/dist/Str.js

@@ -0,0 +1,31 @@
+"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.
+ */
+function startsWith(haystack, needle) {
+    return underscore_1.default.isString(haystack) && underscore_1.default.isString(needle) && 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;
+}
+exports.result = result;

package/dist/SyncQueue.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 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/{lib → dist}/SyncQueue.js

@@ -1,3 +1,5 @@
+"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.
@@ -11,7 +13,7 @@
  *     queue.push({key: 1, val: '1'});
  *     queue.push({key: 2, val: '2'});
  */
-export default class SyncQueue {
+class SyncQueue {
     /**
      * @param {Function} run - must return a promise
      */
@@ -20,7 +22,6 @@ export default class SyncQueue {
         this.isProcessing = false;
         this.run = run;
     }
-
     /**
      * Stop the queue from being processed and clear out any existing tasks
      */
@@ -28,32 +29,29 @@ export default class SyncQueue {
         this.queue = [];
         this.isProcessing = false;
     }
-
     process() {
         if (this.isProcessing || this.queue.length === 0) {
             return;
         }
-
         this.isProcessing = true;
-
-        const {data, resolve, reject} = this.queue.shift();
+        const { data, resolve, reject } = this.queue.shift();
         this.run(data)
             .then(resolve)
             .catch(reject)
             .finally(() => {
-                this.isProcessing = false;
-                this.process();
-            });
+            this.isProcessing = false;
+            this.process();
+        });
     }
-
     /**
      * @param {*} data
      * @returns {Promise}
      */
     push(data) {
         return new Promise((resolve, reject) => {
-            this.queue.push({resolve, reject, data});
+            this.queue.push({ resolve, reject, data });
             this.process();
         });
     }
 }
+exports.default = SyncQueue;

package/dist/batch.d.ts

@@ -0,0 +1,2 @@
+import { unstable_batchedUpdates } from 'react-dom';
+export default unstable_batchedUpdates;

package/dist/batch.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_dom_1 = require("react-dom");
+exports.default = react_dom_1.unstable_batchedUpdates;

package/dist/batch.native.d.ts

@@ -0,0 +1,2 @@
+import { unstable_batchedUpdates } from 'react-native';
+export default unstable_batchedUpdates;

package/dist/batch.native.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_native_1 = require("react-native");
+exports.default = react_native_1.unstable_batchedUpdates;

package/dist/compose.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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/{lib → dist}/compose.js

@@ -1,3 +1,5 @@
+"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.
@@ -16,19 +18,14 @@
  *
  * @returns {Function}
  */
-export default function compose(...funcs) {
+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)),
-    );
+    return funcs.reduce((a, b) => (...args) => a(b(...args)));
 }
+exports.default = compose;

package/dist/createDeferredTask.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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>;
+};

package/{lib → dist}/createDeferredTask.js

@@ -1,3 +1,5 @@
+"use strict";
+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`
@@ -6,11 +8,11 @@
  * @template T
  * @returns {{ resolve: function(*), promise: Promise<T|void> }}
  */
-export default function createDeferredTask() {
+function createDeferredTask() {
     const deferred = {};
     deferred.promise = new Promise((res) => {
         deferred.resolve = res;
     });
-
     return deferred;
 }
+exports.default = createDeferredTask;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import Onyx, {OnyxUpdate, ConnectOptions} from './Onyx';
+import {CustomTypeOptions, OnyxCollection, OnyxEntry, NullishDeep, KeyValueMapping, OnyxKey, Selector, WithOnyxInstanceState} from './types';
+import withOnyx from './withOnyx';
+
+export default Onyx;
+export {CustomTypeOptions, OnyxCollection, OnyxEntry, OnyxUpdate, withOnyx, ConnectOptions, NullishDeep, KeyValueMapping, OnyxKey, Selector, WithOnyxInstanceState};

package/dist/index.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withOnyx = void 0;
+const Onyx_1 = __importDefault(require("./Onyx"));
+const withOnyx_1 = __importDefault(require("./withOnyx"));
+exports.withOnyx = withOnyx_1.default;
+exports.default = Onyx_1.default;

package/dist/metrics/PerformanceUtils.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Provide insights into why a setState() call occurred by diffing the before and after values.
+ *
+ * @param {Object} mapping
+ * @param {*} previousValue
+ * @param {*} newValue
+ * @param {String} caller
+ * @param {String} [keyThatChanged]
+ */
+export function logSetStateCall(mapping: Object, previousValue: any, newValue: any, caller: string, keyThatChanged?: string | undefined): void;
+/**
+ * @param {Boolean} debug
+ */
+export function setShouldDebugSetState(debug: boolean): void;