update

Author: theKashey

README.md

@@ -33,6 +33,11 @@ It will know, that it should react only state.value. _Perfect_.
 
 [![NPM](https://nodei.co/npm/memoize-state.png?downloads=true&stars=true)](https://nodei.co/npm/memoize-state/)
 
+## Implementations
+- [React-memoize](https://github.com/theKashey/react-memoize) - magic memoization for React, componentWillReceiveProps optization, and selection from context.
+- [beautiful-react-redux](https://github.com/theKashey/beautiful-react-redux) - instant memoization for React-Redux
+- your project!  
+
 # API
 * `memoizeState(function, options)` - creates memoized variant of a function.
 - Name, length (argument count), and any other own key will be transferred to memoized result

lib/cache.js

@@ -0,0 +1,52 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+
+exports.updateCacheLine = updateCacheLine;
+exports.shallowEqualHit = shallowEqualHit;
+
+var _proxyequal = require('proxyequal');
+
+function updateCacheLine(cache, lineId, value) {
+  for (var i = lineId; i < cache.length - 1; i++) {
+    cache[i] = cache[i + 1];
+  }
+  cache[cache.length - 1] = value;
+}
+
+function shallowEqualHit(cache, args) {
+  for (var i = 0; i < cache.length; ++i) {
+    var found = cache[i];
+    var _found = found,
+        lineArgs = _found.args,
+        lineAffected = _found.affected,
+        lineValue = _found.result;
+
+
+    if (args.length !== lineArgs.length) {
+      continue;
+    }
+
+    for (var j = 0; j < args.length; ++j) {
+      var a = args[j];
+      var b = lineArgs[j];
+      var useAffected = lineAffected[j] ? lineAffected[j].useAffected : [];
+      var resultAffected = lineAffected[j] ? lineAffected[j].resultAffected : [];
+      if (a === b || (typeof a === 'undefined' ? 'undefined' : _typeof(a)) === 'object' && (useAffected.length === 0 || (0, _proxyequal.proxyShallowEqual)(a, b, useAffected)) && (resultAffected.length === 0 || (0, _proxyequal.proxyCompare)(a, b, resultAffected))) {
+        //pass
+      } else {
+        found = null;
+        break;
+      }
+    }
+    if (found) {
+      updateCacheLine(cache, i, found);
+      return lineValue;
+    }
+  }
+  return undefined;
+}

lib/call.js

@@ -0,0 +1,122 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+
+exports.callIn = callIn;
+
+var _proxyequal = require('proxyequal');
+
+var _cache = require('./cache');
+
+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 nothing = 'PROXY_EQUAL_NOTHING';
+var emptyArray = [];
+
+function addAffected(affected, object) {
+  var key = (0, _proxyequal.getProxyKey)(object);
+  affected[key.fingerPrint].resultAffected.push(key.suffix);
+}
+
+function deproxifyResult(result, affected, returnPureValue) {
+
+  var isInProxy = (0, _proxyequal.isProxyfied)(result);
+  if (isInProxy) {
+    addAffected(affected, result);
+    return (0, _proxyequal.deproxify)(result);
+  }
+
+  if ((typeof result === 'undefined' ? 'undefined' : _typeof(result)) === 'object') {
+    var sub = Array.isArray(result) ? [] : {};
+    var altered = false;
+
+    if (result && Object.getOwnPropertyDescriptor(result, '__proxyequal_scanEnd')) {
+      Object.defineProperty(result, '__proxyequal_scanEnd', {
+        value: 'here was spread guard',
+        configurable: true,
+        enumerable: false
+      });
+    }
+
+    for (var i in result) {
+      if (result.hasOwnProperty(i)) {
+        var data = result[i];
+        var newResult = deproxifyResult(data, affected, false);
+        if (data && newResult !== nothing) {
+          altered = true;
+          sub[i] = newResult;
+        } else {
+          sub[i] = data;
+        }
+      }
+    }
+    if (altered) {
+      return sub;
+    }
+    return returnPureValue ? result : nothing;
+  }
+
+  return returnPureValue ? result : nothing;
+}
+
+function callIn(that, cache, args, func, memoizationDepth) {
+  var proxyMap = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : [];
+
+  var proxies = args.map(function (arg, index) {
+    if (arg && (typeof arg === 'undefined' ? 'undefined' : _typeof(arg)) === 'object') {
+      var map = proxyMap[index];
+      if (!map) {
+        return proxyMap[index] = (0, _proxyequal.proxyState)(arg, index);
+      }
+      map.reset();
+      return map.replaceState(arg);
+    }
+    return undefined;
+  });
+  var callArgs = args.map(function (arg, index) {
+    return proxies[index] ? proxies[index].state : arg;
+  });
+
+  //call the real function
+  var preResult = func.call.apply(func, [that].concat(_toConsumableArray(callArgs)));
+  proxies.forEach(function (proxy) {
+    return proxy && proxy.seal();
+  });
+
+  var spreadDetected = [];
+  var affected = proxies.map(function (proxy) {
+    if (proxy) {
+      if (proxy.spreadDetected !== false) {
+        spreadDetected.push(proxy.spreadDetected);
+      }
+      var _affected = proxy.affected || emptyArray;
+
+      return {
+        useAffected: [].concat(_toConsumableArray(_affected)),
+        resultAffected: []
+      };
+    }
+    return undefined;
+  });
+  var result = deproxifyResult(preResult, affected, true);
+  var cacheLine = { args: args, affected: affected, result: result, callArgs: callArgs };
+  if (cache.length < memoizationDepth) {
+    cache.push(cacheLine);
+  } else {
+    (0, _cache.updateCacheLine)(cache, 0, cacheLine);
+  }
+
+  if (spreadDetected.length > 0) {
+    if (process.env.NODE_ENV !== 'production') {
+      console.warn('memoize-state: object spread detected in ', func, '. Keys affected: ', spreadDetected.map(function (key) {
+        return key ? key : 'root';
+      }), '. This is no-op.');
+    }
+  }
+
+  return result;
+}