| 'use strict'; |
| |
| Object.defineProperty(exports, "__esModule", { |
| value: true |
| }); |
| exports.default = memoize; |
| |
| var _setImmediate = require('./internal/setImmediate'); |
| |
| var _setImmediate2 = _interopRequireDefault(_setImmediate); |
| |
| var _initialParams = require('./internal/initialParams'); |
| |
| var _initialParams2 = _interopRequireDefault(_initialParams); |
| |
| var _wrapAsync = require('./internal/wrapAsync'); |
| |
| var _wrapAsync2 = _interopRequireDefault(_wrapAsync); |
| |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } |
| |
| /** |
| * Caches the results of an async function. When creating a hash to store |
| * function results against, the callback is omitted from the hash and an |
| * optional hash function can be used. |
| * |
| * **Note: if the async function errs, the result will not be cached and |
| * subsequent calls will call the wrapped function.** |
| * |
| * If no hash function is specified, the first argument is used as a hash key, |
| * which may work reasonably if it is a string or a data type that converts to a |
| * distinct string. Note that objects and arrays will not behave reasonably. |
| * Neither will cases where the other arguments are significant. In such cases, |
| * specify your own hash function. |
| * |
| * The cache of results is exposed as the `memo` property of the function |
| * returned by `memoize`. |
| * |
| * @name memoize |
| * @static |
| * @memberOf module:Utils |
| * @method |
| * @category Util |
| * @param {AsyncFunction} fn - The async function to proxy and cache results from. |
| * @param {Function} hasher - An optional function for generating a custom hash |
| * for storing results. It has all the arguments applied to it apart from the |
| * callback, and must be synchronous. |
| * @returns {AsyncFunction} a memoized version of `fn` |
| * @example |
| * |
| * var slow_fn = function(name, callback) { |
| * // do something |
| * callback(null, result); |
| * }; |
| * var fn = async.memoize(slow_fn); |
| * |
| * // fn can now be used as if it were slow_fn |
| * fn('some name', function() { |
| * // callback |
| * }); |
| */ |
| function memoize(fn, hasher = v => v) { |
| var memo = Object.create(null); |
| var queues = Object.create(null); |
| var _fn = (0, _wrapAsync2.default)(fn); |
| var memoized = (0, _initialParams2.default)((args, callback) => { |
| var key = hasher(...args); |
| if (key in memo) { |
| (0, _setImmediate2.default)(() => callback(null, ...memo[key])); |
| } else if (key in queues) { |
| queues[key].push(callback); |
| } else { |
| queues[key] = [callback]; |
| _fn(...args, (err, ...resultArgs) => { |
| // #1465 don't memoize if an error occurred |
| if (!err) { |
| memo[key] = resultArgs; |
| } |
| var q = queues[key]; |
| delete queues[key]; |
| for (var i = 0, l = q.length; i < l; i++) { |
| q[i](err, ...resultArgs); |
| } |
| }); |
| } |
| }); |
| memoized.memo = memo; |
| memoized.unmemoized = fn; |
| return memoized; |
| } |
| module.exports = exports['default']; |