@webkrafters/eagleeye 1.0.0-beta.0

package/dist/main/index.js

@@ -0,0 +1,1062 @@
+"use strict";
+
+var _excluded = ["trail"],
+  _excluded2 = ["length"],
+  _excluded3 = ["length"],
+  _excluded4 = ["length"];
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, i = _objectWithoutPropertiesLoose(e, t); if (Object.getOwnPropertySymbols) { var n = Object.getOwnPropertySymbols(e); for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); } return i; }
+function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+var __createBinding = void 0 && (void 0).__createBinding || (Object.create ? function (o, m, k, k2) {
+  if (k2 === undefined) k2 = k;
+  var desc = Object.getOwnPropertyDescriptor(m, k);
+  if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+    desc = {
+      enumerable: true,
+      get: function get() {
+        return m[k];
+      }
+    };
+  }
+  Object.defineProperty(o, k2, desc);
+} : function (o, m, k, k2) {
+  if (k2 === undefined) k2 = k;
+  o[k2] = m[k];
+});
+var __setModuleDefault = void 0 && (void 0).__setModuleDefault || (Object.create ? function (o, v) {
+  Object.defineProperty(o, "default", {
+    enumerable: true,
+    value: v
+  });
+} : function (o, v) {
+  o["default"] = v;
+});
+var __runInitializers = void 0 && (void 0).__runInitializers || function (thisArg, initializers, value) {
+  var useValue = arguments.length > 2;
+  for (var i = 0; i < initializers.length; i++) {
+    value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+  }
+  return useValue ? value : void 0;
+};
+var __esDecorate = void 0 && (void 0).__esDecorate || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+  function accept(f) {
+    if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected");
+    return f;
+  }
+  var kind = contextIn.kind,
+    key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+  var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+  var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+  var _,
+    done = false;
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    var context = {};
+    for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+    for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+    context.addInitializer = function (f) {
+      if (done) throw new TypeError("Cannot add initializers after decoration has completed");
+      extraInitializers.push(accept(f || null));
+    };
+    var result = (0, decorators[i])(kind === "accessor" ? {
+      get: descriptor.get,
+      set: descriptor.set
+    } : descriptor[key], context);
+    if (kind === "accessor") {
+      if (result === void 0) continue;
+      if (result === null || _typeof(result) !== "object") throw new TypeError("Object expected");
+      if (_ = accept(result.get)) descriptor.get = _;
+      if (_ = accept(result.set)) descriptor.set = _;
+      if (_ = accept(result.init)) initializers.unshift(_);
+    } else if (_ = accept(result)) {
+      if (kind === "field") initializers.unshift(_);else descriptor[key] = _;
+    }
+  }
+  if (target) Object.defineProperty(target, contextIn.name, descriptor);
+  done = true;
+};
+var __importStar = void 0 && (void 0).__importStar || function () {
+  var _ownKeys = function ownKeys(o) {
+    _ownKeys = Object.getOwnPropertyNames || function (o) {
+      var ar = [];
+      for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+      return ar;
+    };
+    return _ownKeys(o);
+  };
+  return function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k = _ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+    __setModuleDefault(result, mod);
+    return result;
+  };
+}();
+var __importDefault = void 0 && (void 0).__importDefault || function (mod) {
+  return mod && mod.__esModule ? mod : {
+    "default": mod
+  };
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EagleEyeContext = exports.Streamer = exports.ACCESS_SYM = exports.deps = void 0;
+exports.createEagleEye = createEagleEye;
+exports.mkReadonly = mkReadonly;
+var lodash_isboolean_1 = __importDefault(require("lodash.isboolean"));
+var lodash_isempty_1 = __importDefault(require("lodash.isempty"));
+var lodash_isequal_1 = __importDefault(require("lodash.isequal"));
+var lodash_isplainobject_1 = __importDefault(require("lodash.isplainobject"));
+var lodash_set_1 = __importDefault(require("lodash.set"));
+var get_property_1 = __importDefault(require("@webkrafters/get-property"));
+var path_dotize_1 = __importDefault(require("@webkrafters/path-dotize"));
+var auto_immutable_1 = __importDefault(require("@webkrafters/auto-immutable"));
+var constants = __importStar(require("../constants"));
+var storage_1 = __importDefault(require("../model/storage"));
+var __1 = require("..");
+var iCount = -1;
+var createStorageKey = function createStorageKey() {
+  return "".concat(++iCount, ":").concat(Date.now(), ":").concat(Math.random());
+};
+exports.deps = {
+  createStorageKey: createStorageKey
+};
+var defaultPrehooks = Object.freeze({});
+var FULL_STATE_SELECTOR = constants.FULL_STATE_SELECTOR;
+exports.ACCESS_SYM = Symbol('KNOWN_ENTITY_ID');
+var Event = /*#__PURE__*/function () {
+  function Event() {
+    _classCallCheck(this, Event);
+    this.listeners = new Set();
+  }
+  return _createClass(Event, [{
+    key: "emit",
+    value: function emit() {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      this.listeners.forEach(function (listener) {
+        return listener.apply(void 0, args);
+      });
+    }
+  }, {
+    key: "addListener",
+    value: function addListener(listener) {
+      this.listeners.add(listener);
+    }
+  }, {
+    key: "removeListener",
+    value: function removeListener(listener) {
+      this.listeners["delete"](listener);
+    }
+  }]);
+}();
+var Streamer = function () {
+  var _a;
+  var _instanceExtraInitializers = [];
+  var _set_selectorMap_decorators;
+  var _addListener_decorators;
+  var _endStream_decorators;
+  var _removeListener_decorators;
+  var _resetState_decorators;
+  var _setState_decorators;
+  var _subscribe_decorators;
+  var _unsubscribe_decorators;
+  return _a = /*#__PURE__*/function () {
+    function Streamer(context, selectorMap) {
+      var _this = this;
+      _classCallCheck(this, Streamer);
+      this._context = (__runInitializers(this, _instanceExtraInitializers), null);
+      this._internalStore = null;
+      this._data = {};
+      this.eventMap = {
+        'data-changed': new Event(),
+        'stream-ending': new Event()
+      };
+      this._phase = __1.Phase.UN_OPENED;
+      this._selectorMap = null;
+      this._unsubClosing = null;
+      this._unsubscribe = null;
+      this._dataSourceListener = function (changes, changePathsTokens, netChanges, mayHaveChangesAt) {
+        for (var renderKeys = _this._renderKeys, rLen = renderKeys.length, r = 0; r < rLen; r++) {
+          if (renderKeys[r] !== FULL_STATE_SELECTOR && !mayHaveChangesAt((0, path_dotize_1["default"])(renderKeys[r]).split('.'))) {
+            continue;
+          }
+          return _this._updateData();
+        }
+      };
+      this._updateData = function () {
+        var hasChanges = false;
+        var selectorEntries = Object.entries(_this._selectorMap);
+        var state = _this._internalStore.getState(_this._renderKeys);
+        for (var _i = 0, _selectorEntries = selectorEntries; _i < _selectorEntries.length; _i++) {
+          var _this$_data$label;
+          var _selectorEntries$_i = _slicedToArray(_selectorEntries[_i], 2),
+            label = _selectorEntries$_i[0],
+            path = _selectorEntries$_i[1];
+          if (path !== FULL_STATE_SELECTOR) {
+            var slice = (0, get_property_1["default"])(state, path)._value;
+            if (_this._data[label] === slice) {
+              continue;
+            }
+            _this._data[label] = slice;
+            hasChanges = true;
+            continue;
+          }
+          var keys = Object.keys((_this$_data$label = _this._data[label]) !== null && _this$_data$label !== void 0 ? _this$_data$label : {});
+          var _hasChanges = keys.length !== Object.keys(state).length;
+          for (var i = keys.length, data = _this._data[label]; !_hasChanges && i--;) {
+            _hasChanges = data[keys[i]] !== state[keys[i]];
+          }
+          if (!_hasChanges) {
+            continue;
+          }
+          _this._data[label] = state;
+          hasChanges = true;
+        }
+        hasChanges && _this._refreshDataRef();
+      };
+      this._context = context;
+      this._setupInternalStore();
+      if ((0, lodash_isempty_1["default"])(selectorMap)) {
+        this._phase = __1.Phase.OPENED;
+        return;
+      }
+      this._integrateSelectors(selectorMap);
+      this._phase = __1.Phase.OPENED;
+    }
+    return _createClass(Streamer, [{
+      key: "closed",
+      get: function get() {
+        return !this._internalStore || this._internalStore.closed;
+      }
+    }, {
+      key: "data",
+      get: function get() {
+        return this._data;
+      }
+    }, {
+      key: "phase",
+      get: function get() {
+        return this._phase;
+      }
+    }, {
+      key: "streaming",
+      get: function get() {
+        return this._phase === __1.Phase.OPENED || this._phase === __1.Phase.UN_OPENED;
+      }
+    }, {
+      key: "selectorMap",
+      set: function set(selectorMap) {
+        if (!selectorMap || (0, lodash_isempty_1["default"])(selectorMap)) {
+          selectorMap = null;
+        }
+        if (selectorMap === this._selectorMap || (0, lodash_isequal_1["default"])(selectorMap, this._selectorMap) || this._phase === __1.Phase.UN_OPENED) {
+          return;
+        }
+        this._updateInternalStore();
+        this._integrateSelectors(selectorMap);
+      }
+    }, {
+      key: "addListener",
+      value: function addListener(eventType, listener) {
+        this.eventMap[eventType].addListener(listener);
+      }
+    }, {
+      key: "endStream",
+      value: function endStream() {
+        this._phase = __1.Phase.CLOSING;
+        this.eventMap['stream-ending'].emit(__1.ShutdownReason.LOCAL);
+        this._internalStore.close();
+        this._reclaim();
+      }
+    }, {
+      key: "removeListener",
+      value: function removeListener(eventType, listener) {
+        this.eventMap[eventType].removeListener(listener);
+      }
+    }, {
+      key: "resetState",
+      value: function resetState() {
+        var propertyPaths = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this._renderKeys;
+        propertyPaths.length && this._internalStore.resetState(propertyPaths);
+      }
+    }, {
+      key: "setState",
+      value: function setState(changes) {
+        this._internalStore.setState(changes);
+      }
+    }, {
+      key: "subscribe",
+      value: function subscribe() {
+        this._unsubscribe || (this._unsubscribe = this._internalStore.subscribe('data-updated', this._dataSourceListener));
+      }
+    }, {
+      key: "unsubscribe",
+      value: function unsubscribe() {
+        if (!this._unsubscribe) {
+          return;
+        }
+        this._unsubscribe();
+        this._unsubscribe = null;
+      }
+    }, {
+      key: "_renderKeys",
+      get: function get() {
+        var _this$_selectorMap;
+        return Object.values((_this$_selectorMap = this._selectorMap) !== null && _this$_selectorMap !== void 0 ? _this$_selectorMap : {});
+      }
+    }, {
+      key: "_integrateSelectors",
+      value: function _integrateSelectors(selectorMap) {
+        this._selectorMap = selectorMap;
+        if (!selectorMap) {
+          this._data = {};
+          return this._refreshDataRef();
+        }
+        this.subscribe();
+        var state = this._internalStore.getState(this._renderKeys);
+        var newData = {};
+        for (var k in selectorMap) {
+          newData[k] = selectorMap[k] !== FULL_STATE_SELECTOR ? (0, get_property_1["default"])(state, selectorMap[k]).value : state;
+        }
+        this._data = newData;
+        this._refreshDataRef();
+      }
+    }, {
+      key: "_reclaim",
+      value: function _reclaim() {
+        this._selectorMap && this.unsubscribe();
+        this._unsubClosing();
+        this._context = null;
+        this._internalStore = null;
+        this.eventMap = null;
+        this._unsubClosing = null;
+        this._unsubscribe = null;
+        this._phase = __1.Phase.CLOSED;
+      }
+    }, {
+      key: "_refreshDataRef",
+      value: function _refreshDataRef() {
+        this._data = _objectSpread({}, this._data);
+        this.eventMap['data-changed'].emit();
+      }
+    }, {
+      key: "_setupInternalStore",
+      value: function _setupInternalStore() {
+        var _this2 = this;
+        this._internalStore = this._context.createInternalStore(exports.ACCESS_SYM);
+        this._unsubClosing = this._internalStore.subscribe('closing', function (r) {
+          _this2._phase = __1.Phase.CLOSING;
+          _this2.eventMap['stream-ending'].emit(r);
+          _this2._reclaim();
+        });
+      }
+    }, {
+      key: "_updateInternalStore",
+      value: function _updateInternalStore() {
+        this._selectorMap && this.unsubscribe();
+        this._unsubClosing();
+        this._internalStore.close();
+        this._setupInternalStore();
+      }
+    }]);
+  }(), function () {
+    var _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+    _set_selectorMap_decorators = [streamable];
+    _addListener_decorators = [streamable];
+    _endStream_decorators = [streamable];
+    _removeListener_decorators = [streamable];
+    _resetState_decorators = [streamable];
+    _setState_decorators = [streamable];
+    _subscribe_decorators = [streamable];
+    _unsubscribe_decorators = [streamable];
+    __esDecorate(_a, null, _set_selectorMap_decorators, {
+      kind: "setter",
+      name: "selectorMap",
+      "static": false,
+      "private": false,
+      access: {
+        has: function has(obj) {
+          return "selectorMap" in obj;
+        },
+        set: function set(obj, value) {
+          obj.selectorMap = value;
+        }
+      },
+      metadata: _metadata
+    }, null, _instanceExtraInitializers);
+    __esDecorate(_a, null, _addListener_decorators, {
+      kind: "method",
+      name: "addListener",
+      "static": false,
+      "private": false,
+      access: {
+        has: function has(obj) {
+          return "addListener" in obj;
+        },
+        get: function get(obj) {
+          return obj.addListener;
+        }
+      },
+      metadata: _metadata
+    }, null, _instanceExtraInitializers);
+    __esDecorate(_a, null, _endStream_decorators, {
+      kind: "method",
+      name: "endStream",
+      "static": false,
+      "private": false,
+      access: {
+        has: function has(obj) {
+          return "endStream" in obj;
+        },
+        get: function get(obj) {
+          return obj.endStream;
+        }
+      },
+      metadata: _metadata
+    }, null, _instanceExtraInitializers);
+    __esDecorate(_a, null, _removeListener_decorators, {
+      kind: "method",
+      name: "removeListener",
+      "static": false,
+      "private": false,
+      access: {
+        has: function has(obj) {
+          return "removeListener" in obj;
+        },
+        get: function get(obj) {
+          return obj.removeListener;
+        }
+      },
+      metadata: _metadata
+    }, null, _instanceExtraInitializers);
+    __esDecorate(_a, null, _resetState_decorators, {
+      kind: "method",
+      name: "resetState",
+      "static": false,
+      "private": false,
+      access: {
+        has: function has(obj) {
+          return "resetState" in obj;
+        },
+        get: function get(obj) {
+          return obj.resetState;
+        }
+      },
+      metadata: _metadata
+    }, null, _instanceExtraInitializers);
+    __esDecorate(_a, null, _setState_decorators, {
+      kind: "method",
+      name: "setState",
+      "static": false,
+      "private": false,
+      access: {
+        has: function has(obj) {
+          return "setState" in obj;
+        },
+        get: function get(obj) {
+          return obj.setState;
+        }
+      },
+      metadata: _metadata
+    }, null, _instanceExtraInitializers);
+    __esDecorate(_a, null, _subscribe_decorators, {
+      kind: "method",
+      name: "subscribe",
+      "static": false,
+      "private": false,
+      access: {
+        has: function has(obj) {
+          return "subscribe" in obj;
+        },
+        get: function get(obj) {
+          return obj.subscribe;
+        }
+      },
+      metadata: _metadata
+    }, null, _instanceExtraInitializers);
+    __esDecorate(_a, null, _unsubscribe_decorators, {
+      kind: "method",
+      name: "unsubscribe",
+      "static": false,
+      "private": false,
+      access: {
+        has: function has(obj) {
+          return "unsubscribe" in obj;
+        },
+        get: function get(obj) {
+          return obj.unsubscribe;
+        }
+      },
+      metadata: _metadata
+    }, null, _instanceExtraInitializers);
+    if (_metadata) Object.defineProperty(_a, Symbol.metadata, {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: _metadata
+    });
+  }(), _a;
+}();
+exports.Streamer = Streamer;
+var EagleEyeContext = function () {
+  var _a;
+  var _instanceExtraInitializers = [];
+  var _get_stream_decorators;
+  var _set_prehooks_decorators;
+  var _set_storage_decorators;
+  var _createInternalStore_decorators;
+  var _dispose_decorators;
+  var _disconnectInternalStore_decorators;
+  var _getState_decorators;
+  var _notifyClosing_decorators;
+  var _resetState_decorators;
+  var _setState_decorators;
+  var _subscribe_decorators;
+  return _a = /*#__PURE__*/function () {
+    function EagleEyeContext() {
+      var _this3 = this;
+      var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      var prehooks = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+      var storage = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+      _classCallCheck(this, EagleEyeContext);
+      this._cache = __runInitializers(this, _instanceExtraInitializers);
+      this.eventMap = {
+        closing: new Event(),
+        'data-updated': new Event()
+      };
+      this.storageKey = null;
+      this._stream = function (selectorMap) {
+        return new Streamer(_this3, selectorMap);
+      };
+      if (!(value instanceof auto_immutable_1["default"])) {
+        this.inchoateValue = value;
+        this._cache = new auto_immutable_1["default"](this.inchoateValue);
+      } else {
+        this._cache = value;
+        var tConnection = this._cache.connect();
+        this.inchoateValue = tConnection.get()[constants.GLOBAL_SELECTOR];
+        tConnection.disconnect();
+        this._cacheCloseMonitor = function () {
+          _this3.notifyClosing(__1.ShutdownReason.CACHE);
+          _this3._store.close();
+          _this3._reclaim();
+        };
+        this._cache.onClose(this._cacheCloseMonitor);
+      }
+      this.prehooks = prehooks;
+      this.storage = storage;
+      this._store = this._createInternalStore();
+      var ctx = this;
+      this._storeRef = {
+        getState: function getState() {
+          var propertyPaths = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+          return ctx._store.getState(propertyPaths);
+        },
+        resetState: function resetState() {
+          var propertyPaths = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+          return ctx._store.resetState(propertyPaths);
+        },
+        setState: function setState(changes) {
+          return ctx._store.setState(changes);
+        },
+        subscribe: function subscribe(eventType, listener) {
+          return ctx._store.subscribe(eventType, listener);
+        }
+      };
+    }
+    return _createClass(EagleEyeContext, [{
+      key: "cache",
+      get: function get() {
+        return this._cache;
+      }
+    }, {
+      key: "closed",
+      get: function get() {
+        return !this._cache;
+      }
+    }, {
+      key: "prehooks",
+      get: function get() {
+        return this._prehooks;
+      },
+      set: function set(prehooks) {
+        this._prehooks = prehooks !== null && prehooks !== void 0 ? prehooks : defaultPrehooks;
+      }
+    }, {
+      key: "storage",
+      get: function get() {
+        return this._storage;
+      },
+      set: function set(storage) {
+        var _storage;
+        var data;
+        (_storage = storage) !== null && _storage !== void 0 ? _storage : storage = new storage_1["default"]();
+        if (typeof this._storage !== 'undefined') {
+          data = this._storage.getItem(this.storageKey);
+          this._storage.removeItem(this.storageKey);
+        } else {
+          data = storage.clone(this.inchoateValue);
+          this.inchoateValue = undefined;
+        }
+        this._storage = storage;
+        this.storageKey = this._storage.isKeyRequired ? exports.deps.createStorageKey() : null;
+        this._storage.setItem(this.storageKey, data);
+      }
+    }, {
+      key: "store",
+      get: function get() {
+        return this._storeRef;
+      }
+    }, {
+      key: "stream",
+      get: function get() {
+        return this._stream;
+      }
+    }, {
+      key: "createInternalStore",
+      value: function createInternalStore() {
+        var access = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+        if (access === exports.ACCESS_SYM) {
+          return this._createInternalStore();
+        }
+        throw new Error('May not create internal stores out of context. Please use `this.store` to obtain externally available store reference.');
+      }
+    }, {
+      key: "dispose",
+      value: function dispose() {
+        this.notifyClosing(__1.ShutdownReason.CONTEXT);
+        this._cacheCloseMonitor ? this._cache.offClose(this._cacheCloseMonitor) : this._cache.close();
+        this._store.close();
+        this._reclaim();
+      }
+    }, {
+      key: "createUpdateEmitterFor",
+      value: function createUpdateEmitterFor(changes) {
+        var _this4 = this;
+        return function (netChanges, changedPathsTokens) {
+          return _this4.eventMap['data-updated'].emit(changes, changedPathsTokens, netChanges, createChangePathSearch(changedPathsTokens));
+        };
+      }
+    }, {
+      key: "disconnectInternalStore",
+      value: function disconnectInternalStore(connection) {
+        connection.disconnect();
+      }
+    }, {
+      key: "getState",
+      value: function getState(connection, propertyPaths) {
+        return _getState(connection, propertyPaths);
+      }
+    }, {
+      key: "notifyClosing",
+      value: function notifyClosing(reason) {
+        this.eventMap.closing.emit(reason);
+      }
+    }, {
+      key: "resetState",
+      value: function resetState(connection, propertyPaths) {
+        var CLEAR_TAG = constants.CLEAR_TAG,
+          DELETE_TAG = constants.DELETE_TAG,
+          FULL_STATE_SELECTOR = constants.FULL_STATE_SELECTOR,
+          GLOBAL_SELECTOR = constants.GLOBAL_SELECTOR,
+          REPLACE_TAG = constants.REPLACE_TAG;
+        var original = this.storage.clone(this.storage.getItem(this.storageKey));
+        var resetData = {};
+        if (propertyPaths.includes(FULL_STATE_SELECTOR)) {
+          resetData = (0, lodash_isempty_1["default"])(original) ? CLEAR_TAG : _defineProperty({}, REPLACE_TAG, original);
+        } else {
+          var _iterator = _createForOfIteratorHelper(propertyPaths),
+            _step;
+          try {
+            for (_iterator.s(); !(_step = _iterator.n()).done;) {
+              var path = _step.value;
+              var node = resetData;
+              var tokens = (0, path_dotize_1["default"])(path).split('.');
+              var _ref2 = (0, get_property_1["default"])(original, tokens),
+                trail = _ref2.trail,
+                pInfo = _objectWithoutProperties(_ref2, _excluded);
+              for (var length = trail.length, keys = _objectWithoutProperties(trail, _excluded2), k = 0; k < length; k++) {
+                if (REPLACE_TAG in node) {
+                  continue;
+                }
+                var key = keys[k];
+                if (!(key in node)) {
+                  node[key] = {};
+                }
+                node = node[key];
+              }
+              if (REPLACE_TAG in node) {
+                continue;
+              }
+              if (pInfo.exists) {
+                for (var _k in node) {
+                  delete node[_k];
+                }
+                node[REPLACE_TAG] = pInfo._value;
+                continue;
+              }
+              if (!(DELETE_TAG in node)) {
+                node[DELETE_TAG] = [];
+              }
+              var deletingKey = tokens[trail.length];
+              !node[DELETE_TAG].includes(deletingKey) && node[DELETE_TAG].push(deletingKey);
+            }
+          } catch (err) {
+            _iterator.e(err);
+          } finally {
+            _iterator.f();
+          }
+        }
+        runPrehook(this._prehooks, 'resetState', [resetData, {
+          current: connection.get()[GLOBAL_SELECTOR],
+          original: original
+        }]) && connection.set(resetData, this.createUpdateEmitterFor(resetData));
+      }
+    }, {
+      key: "setState",
+      value: function setState(connection, changes) {
+        runPrehook(this._prehooks, 'setState', [changes]) && connection.set(changes, this.createUpdateEmitterFor(changes));
+      }
+    }, {
+      key: "subscribe",
+      value: function subscribe(eventType, listener) {
+        var event = this.eventMap[eventType];
+        event.addListener(listener);
+        return function () {
+          return event.removeListener(listener);
+        };
+      }
+    }, {
+      key: "_createInternalStore",
+      value: function _createInternalStore() {
+        var ctx = this;
+        var connection = ctx._cache.connect();
+        return {
+          close: function close() {
+            ctx.disconnectInternalStore(connection);
+            connection = null;
+          },
+          get closed() {
+            return !connection;
+          },
+          getState: function getState(propertyPaths) {
+            return ctx.getState(connection, propertyPaths);
+          },
+          resetState: function resetState(propertyPaths) {
+            return ctx.resetState(connection, propertyPaths);
+          },
+          setState: function setState(changes) {
+            return ctx.setState(connection, changes);
+          },
+          subscribe: function subscribe(eventType, listener) {
+            return ctx.subscribe(eventType, listener);
+          }
+        };
+      }
+    }, {
+      key: "_reclaim",
+      value: function _reclaim() {
+        this._storage.removeItem(this.storageKey);
+        this._cache = null;
+        this._prehooks = null;
+        this._storage = null;
+        this.eventMap = null;
+        this.inchoateValue = null;
+        this.storageKey = null;
+        this._stream = null;
+        this._cacheCloseMonitor = null;
+      }
+    }]);
+  }(), function () {
+    var _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+    _get_stream_decorators = [invokable];
+    _set_prehooks_decorators = [invokable];
+    _set_storage_decorators = [invokable];
+    _createInternalStore_decorators = [invokable];
+    _dispose_decorators = [invokable];
+    _disconnectInternalStore_decorators = [invokable];
+    _getState_decorators = [invokable];
+    _notifyClosing_decorators = [invokable];
+    _resetState_decorators = [invokable];
+    _setState_decorators = [invokable];
+    _subscribe_decorators = [invokable];
+    __esDecorate(_a, null, _get_stream_decorators, {
+      kind: "getter",
+      name: "stream",
+      "static": false,
+      "private": false,
+      access: {
+        has: function has(obj) {
+          return "stream" in obj;
+        },
+        get: function get(obj) {
+          return obj.stream;
+        }
+      },
+      metadata: _metadata
+    }, null, _instanceExtraInitializers);
+    __esDecorate(_a, null, _set_prehooks_decorators, {
+      kind: "setter",
+      name: "prehooks",
+      "static": false,
+      "private": false,
+      access: {
+        has: function has(obj) {
+          return "prehooks" in obj;
+        },
+        set: function set(obj, value) {
+          obj.prehooks = value;
+        }
+      },
+      metadata: _metadata
+    }, null, _instanceExtraInitializers);
+    __esDecorate(_a, null, _set_storage_decorators, {
+      kind: "setter",
+      name: "storage",
+      "static": false,
+      "private": false,
+      access: {
+        has: function has(obj) {
+          return "storage" in obj;
+        },
+        set: function set(obj, value) {
+          obj.storage = value;
+        }
+      },
+      metadata: _metadata
+    }, null, _instanceExtraInitializers);
+    __esDecorate(_a, null, _createInternalStore_decorators, {
+      kind: "method",
+      name: "createInternalStore",
+      "static": false,
+      "private": false,
+      access: {
+        has: function has(obj) {
+          return "createInternalStore" in obj;
+        },
+        get: function get(obj) {
+          return obj.createInternalStore;
+        }
+      },
+      metadata: _metadata
+    }, null, _instanceExtraInitializers);
+    __esDecorate(_a, null, _dispose_decorators, {
+      kind: "method",
+      name: "dispose",
+      "static": false,
+      "private": false,
+      access: {
+        has: function has(obj) {
+          return "dispose" in obj;
+        },
+        get: function get(obj) {
+          return obj.dispose;
+        }
+      },
+      metadata: _metadata
+    }, null, _instanceExtraInitializers);
+    __esDecorate(_a, null, _disconnectInternalStore_decorators, {
+      kind: "method",
+      name: "disconnectInternalStore",
+      "static": false,
+      "private": false,
+      access: {
+        has: function has(obj) {
+          return "disconnectInternalStore" in obj;
+        },
+        get: function get(obj) {
+          return obj.disconnectInternalStore;
+        }
+      },
+      metadata: _metadata
+    }, null, _instanceExtraInitializers);
+    __esDecorate(_a, null, _getState_decorators, {
+      kind: "method",
+      name: "getState",
+      "static": false,
+      "private": false,
+      access: {
+        has: function has(obj) {
+          return "getState" in obj;
+        },
+        get: function get(obj) {
+          return obj.getState;
+        }
+      },
+      metadata: _metadata
+    }, null, _instanceExtraInitializers);
+    __esDecorate(_a, null, _notifyClosing_decorators, {
+      kind: "method",
+      name: "notifyClosing",
+      "static": false,
+      "private": false,
+      access: {
+        has: function has(obj) {
+          return "notifyClosing" in obj;
+        },
+        get: function get(obj) {
+          return obj.notifyClosing;
+        }
+      },
+      metadata: _metadata
+    }, null, _instanceExtraInitializers);
+    __esDecorate(_a, null, _resetState_decorators, {
+      kind: "method",
+      name: "resetState",
+      "static": false,
+      "private": false,
+      access: {
+        has: function has(obj) {
+          return "resetState" in obj;
+        },
+        get: function get(obj) {
+          return obj.resetState;
+        }
+      },
+      metadata: _metadata
+    }, null, _instanceExtraInitializers);
+    __esDecorate(_a, null, _setState_decorators, {
+      kind: "method",
+      name: "setState",
+      "static": false,
+      "private": false,
+      access: {
+        has: function has(obj) {
+          return "setState" in obj;
+        },
+        get: function get(obj) {
+          return obj.setState;
+        }
+      },
+      metadata: _metadata
+    }, null, _instanceExtraInitializers);
+    __esDecorate(_a, null, _subscribe_decorators, {
+      kind: "method",
+      name: "subscribe",
+      "static": false,
+      "private": false,
+      access: {
+        has: function has(obj) {
+          return "subscribe" in obj;
+        },
+        get: function get(obj) {
+          return obj.subscribe;
+        }
+      },
+      metadata: _metadata
+    }, null, _instanceExtraInitializers);
+    if (_metadata) Object.defineProperty(_a, Symbol.metadata, {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: _metadata
+    });
+  }(), _a;
+}();
+exports.EagleEyeContext = EagleEyeContext;
+function createEagleEye() {
+  var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return new EagleEyeContext(props.value, props.prehooks, props.storage);
+}
+function createChangePathSearch(_ref3) {
+  var length = _ref3.length,
+    pathTokenGroups = _objectWithoutProperties(_ref3, _excluded3);
+  var root = {};
+  for (var g = 0; g < length; g++) {
+    for (var obj = root, tokens = pathTokenGroups[g], tLen = tokens.length, t = 0; t < tLen; t++) {
+      var key = tokens[t];
+      if (!(key in obj)) {
+        obj[key] = {};
+      }
+      obj = obj[key];
+    }
+  }
+  return function (_ref4) {
+    var length = _ref4.length,
+      pathTokens = _objectWithoutProperties(_ref4, _excluded4);
+    var obj = root;
+    for (var p = 0; p < length; p++) {
+      var _key2 = pathTokens[p];
+      if (_key2 in obj) {
+        obj = obj[_key2];
+        continue;
+      }
+      return !Object.keys(obj).length;
+    }
+    return true;
+  };
+}
+function _getState(connection, propertyPaths) {
+  var FULL_STATE_SELECTOR = constants.FULL_STATE_SELECTOR,
+    GLOBAL_SELECTOR = constants.GLOBAL_SELECTOR;
+  if (!propertyPaths.length || propertyPaths.indexOf(FULL_STATE_SELECTOR) !== -1) {
+    return connection.get()[GLOBAL_SELECTOR];
+  }
+  var data = connection.get.apply(connection, _toConsumableArray(propertyPaths));
+  var state = {};
+  for (var d in data) {
+    (0, lodash_set_1["default"])(state, d, data[d]);
+  }
+  return mkReadonly(state);
+}
+function mkReadonly(v) {
+  if (Object.isFrozen(v)) {
+    return v;
+  }
+  if ((0, lodash_isplainobject_1["default"])(v) || Array.isArray(v)) {
+    for (var k in v) {
+      v[k] = mkReadonly(v[k]);
+    }
+  }
+  return Object.freeze(v);
+}
+function runPrehook(prehooks, name, args) {
+  if (!(name in prehooks)) {
+    return true;
+  }
+  var res = prehooks[name].apply(prehooks, _toConsumableArray(args));
+  if (!(0, lodash_isboolean_1["default"])(res)) {
+    throw new TypeError("`".concat(name, "` prehook must return a boolean value."));
+  }
+  return res;
+}
+function invokable(method, context) {
+  return function () {
+    if (!this.closed) {
+      for (var _len2 = arguments.length, args = new Array(_len2), _key3 = 0; _key3 < _len2; _key3++) {
+        args[_key3] = arguments[_key3];
+      }
+      return method.apply(this, args);
+    }
+  };
+}
+function streamable(method, context) {
+  return function () {
+    if (this.streaming) {
+      for (var _len3 = arguments.length, args = new Array(_len3), _key4 = 0; _key4 < _len3; _key4++) {
+        args[_key4] = arguments[_key4];
+      }
+      return method.apply(this, args);
+    }
+  };
+}