HORIZON PROJECT

'use strict';

Object.defineProperty(exports, "__esModule", {

    value: true

});

exports.default = memoize;

var _identity = require('lodash/identity');

var _identity2 = _interopRequireDefault(_identity);

var _rest = require('./internal/rest');

var _rest2 = _interopRequireDefault(_rest);

var _setImmediate = require('./internal/setImmediate');

var _setImmediate2 = _interopRequireDefault(_setImmediate);

var _initialParams = require('./internal/initialParams');

var _initialParams2 = _interopRequireDefault(_initialParams);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function has(obj, key) {

    return key in 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.

 *

 * 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 {Function} fn - The 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 {Function} 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) {

    var memo = Object.create(null);

    var queues = Object.create(null);

    hasher = hasher || _identity2.default;

    var memoized = (0, _initialParams2.default)(function memoized(args, callback) {

        var key = hasher.apply(null, args);

        if (has(memo, key)) {

            (0, _setImmediate2.default)(function () {

                callback.apply(null, memo[key]);

            });

        } else if (has(queues, key)) {

            queues[key].push(callback);

        } else {

            queues[key] = [callback];

            fn.apply(null, args.concat([(0, _rest2.default)(function (args) {

                memo[key] = args;

                var q = queues[key];

                delete queues[key];

                for (var i = 0, l = q.length; i < l; i++) {

                    q[i].apply(null, args);

                }

            })]));

        }

    });

    memoized.memo = memo;

    memoized.unmemoized = fn;

    return memoized;

}

module.exports = exports['default'];