dejavu-call/dist/main.js

Intercepts a function call and stores the result with the given context. In calls that have the same parameters, it will return the stored result. The proposal is to reduce the response time for processing heavy functions, but it always has the same resul

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.recall = exports.remember = exports.getHash = undefined;

var _pytils = require('pytils');

var _utils = require('./utils');

var _sha = require('./sha256');

var _sha2 = _interopRequireDefault(_sha);

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

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

var limit = 20;
var inMind = {};
var memorize = (0, _utils._memorize)(inMind, limit);

var _remember = function _remember(contextId, context, contextString, Throw) {
  return function (noMemo) {
    contextString = contextString ? contextString : (0, _utils.stringify)(context);
    if ((0, _pytils.hasProp)(inMind, contextId)) {
      var keeper = inMind[contextId];
      if ((0, _pytils.hasProp)(keeper.memo, contextString)) {
        return keeper.memo[contextString];
      }
      (0, _pytils.ifThrow)(Throw, 'dejavu-call: no memory found');
    }
    (0, _pytils.ifThrow)(Throw, 'dejavu-call: no keeper found');
    return noMemo(contextString);
  };
};

var getHash = exports.getHash = function getHash(data) {
  (0, _pytils.ifThrow)(!(0, _pytils.isString)(data), 'dejavu-call(getHash): data is a essential! and need to be a string');

  return (0, _sha2.default)(data);
};

var remember = exports.remember = function remember(contextId, context) {
  var contextString = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
  var Throw = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;

  (0, _utils.isEssential)(function () {
    return null;
  }, contextId, context);
  return _remember(contextId, context, contextString, Throw)(function () {
    return null;
  });
};

var recall = exports.recall = function recall(contextId, Service, context) {
  var contextString = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
  var Throw = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;

  (0, _utils.isEssential)(Service, contextId, context);
  return _remember(contextId, context, contextString, Throw)(function (contextString) {
    var result = Service.apply(undefined, _toConsumableArray(context));
    memorize(contextId, contextString, result);
    return result;
  });
};