@webkrafters/react-observable-context 6.0.0-rc.2 → 6.0.0-rc.3

package/dist/constants.d.ts

@@ -0,0 +1,2 @@
+export { CLEAR_TAG, DELETE_TAG, GLOBAL_SELECTOR, MOVE_TAG, NULL_SELECTOR, PUSH_TAG, REPLACE_TAG, SET_TAG, SPLICE_TAG, Tag } from '@webkrafters/auto-immutable';
+export declare const FULL_STATE_SELECTOR = "@@STATE";

package/dist/constants.js

@@ -0,0 +1,68 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FULL_STATE_SELECTOR = exports.Tag = exports.SPLICE_TAG = exports.SET_TAG = exports.REPLACE_TAG = exports.PUSH_TAG = exports.NULL_SELECTOR = exports.MOVE_TAG = exports.GLOBAL_SELECTOR = exports.DELETE_TAG = exports.CLEAR_TAG = void 0;
+var auto_immutable_1 = require("@webkrafters/auto-immutable");
+Object.defineProperty(exports, "CLEAR_TAG", {
+  enumerable: true,
+  get: function get() {
+    return auto_immutable_1.CLEAR_TAG;
+  }
+});
+Object.defineProperty(exports, "DELETE_TAG", {
+  enumerable: true,
+  get: function get() {
+    return auto_immutable_1.DELETE_TAG;
+  }
+});
+Object.defineProperty(exports, "GLOBAL_SELECTOR", {
+  enumerable: true,
+  get: function get() {
+    return auto_immutable_1.GLOBAL_SELECTOR;
+  }
+});
+Object.defineProperty(exports, "MOVE_TAG", {
+  enumerable: true,
+  get: function get() {
+    return auto_immutable_1.MOVE_TAG;
+  }
+});
+Object.defineProperty(exports, "NULL_SELECTOR", {
+  enumerable: true,
+  get: function get() {
+    return auto_immutable_1.NULL_SELECTOR;
+  }
+});
+Object.defineProperty(exports, "PUSH_TAG", {
+  enumerable: true,
+  get: function get() {
+    return auto_immutable_1.PUSH_TAG;
+  }
+});
+Object.defineProperty(exports, "REPLACE_TAG", {
+  enumerable: true,
+  get: function get() {
+    return auto_immutable_1.REPLACE_TAG;
+  }
+});
+Object.defineProperty(exports, "SET_TAG", {
+  enumerable: true,
+  get: function get() {
+    return auto_immutable_1.SET_TAG;
+  }
+});
+Object.defineProperty(exports, "SPLICE_TAG", {
+  enumerable: true,
+  get: function get() {
+    return auto_immutable_1.SPLICE_TAG;
+  }
+});
+Object.defineProperty(exports, "Tag", {
+  enumerable: true,
+  get: function get() {
+    return auto_immutable_1.Tag;
+  }
+});
+exports.FULL_STATE_SELECTOR = '@@STATE';

package/dist/index.d.ts

@@ -0,0 +1,88 @@
+import type { ComponentType, ForwardRefExoticComponent, MemoExoticComponent, NamedExoticComponent, ReactNode, PropsWithoutRef, RefAttributes } from 'react';
+import type { Changes as BaseChanges, Connection, Immutable, Value } from '@webkrafters/auto-immutable';
+import { FULL_STATE_SELECTOR } from './constants';
+export type { BaseType, ClearCommand, KeyType, MoveCommand, PushCommand, ReplaceCommand, SetCommand, SpliceCommand, TagCommand, TagType, UpdateStats, UpdatePayload, UpdatePayloadArray } from '@webkrafters/auto-immutable';
+export type State = Value;
+export type Listener<T extends State = {}> = (changes: Changes<T>, changedPathsTokens: Readonly<Array<Array<string>>>, netChanges: Readonly<T>, mayHaveChangesAt: (pathTokens: Array<string>) => boolean) => void;
+export type ObservableProvider<T extends State> = ForwardRefExoticComponent<ProviderProps<T> & RefAttributes<StoreRef<T>>>;
+export interface ProviderProps<T extends State> {
+    children?: ReactNode;
+    prehooks?: Prehooks<T>;
+    storage?: IStorage<T>;
+    value: PartialState<T>;
+}
+export type ConnectProps<OWNPROPS extends OwnProps = IProps, STATE extends State = State, SELECTOR_MAP extends SelectorMap = SelectorMap> = {
+    [K in keyof Store<STATE, SELECTOR_MAP>]: Store<STATE, SELECTOR_MAP>[K];
+} & Omit<OWNPROPS, "ref"> & RefAttributes<OWNPROPS["ref"]>;
+export type ConnectedComponent<P extends OwnProps = IProps> = MemoExoticComponent<ForwardRefExoticComponent<PropsWithoutRef<Omit<P, "ref">> & RefAttributes<P["ref"]>>>;
+export type PropsExtract<C, STATE extends State, SELECTOR_MAP extends SelectorMap> = C extends ComponentType<ConnectProps<infer U, STATE, SELECTOR_MAP>> ? U extends OwnProps ? U : IProps : C extends NamedExoticComponent<ConnectProps<infer U, STATE, SELECTOR_MAP>> ? U extends OwnProps ? U : IProps : IProps;
+export type ExtractInjectedProps<STATE extends State = State, SELECTOR_MAP extends SelectorMap = SelectorMap, ALL_PROPS extends OwnProps = OwnProps> = Omit<ALL_PROPS, keyof Store<STATE> | keyof SELECTOR_MAP>;
+export interface IProps {
+    ref?: unknown;
+}
+export type OwnProps = IProps & Record<any, any>;
+export type Text = string | number;
+export type FullStateSelector = typeof FULL_STATE_SELECTOR;
+export type ObjectSelector = Record<Text, Text | FullStateSelector>;
+export type ArraySelector = Array<Text | FullStateSelector>;
+export type SelectorMap = ObjectSelector | ArraySelector | void;
+type ReplacePathSeps<P extends Text, T extends string> = P extends `${infer U}${T}${infer V}` ? ReplacePathSeps<`${U}.${V}`, T> : P;
+type TrimPathSep<P extends Text> = P extends `${infer U}]${never}` ? U : P;
+type NormalizePath<P extends Text> = TrimPathSep<ReplacePathSeps<ReplacePathSeps<ReplacePathSeps<P, ']['>, '].'>, '['>>;
+type Datum<P extends Text, S extends Record<Text, any> = State> = P extends `${infer K}.${infer P_1}` ? Datum<P_1, S[K]> : P extends '' ? S : any;
+type DataPoint<P extends Text, S extends State> = P extends FullStateSelector ? S : Datum<NormalizePath<P>, S>;
+export type Data<SELECTOR_MAP extends SelectorMap, STATE extends State = State> = (SELECTOR_MAP extends ObjectSelector ? {
+    [S_KEY in keyof SELECTOR_MAP]: DataPoint<SELECTOR_MAP[S_KEY], STATE>;
+} : SELECTOR_MAP extends ArraySelector ? {
+    [S_NUM: number]: DataPoint<SELECTOR_MAP[number], STATE>;
+} : Array<any>);
+export type Changes<T extends State = State> = BaseChanges<T>;
+export interface IStorage<T extends State = State> {
+    clone: (data: T) => T;
+    getItem: (key: string) => T;
+    removeItem: (key: string) => void;
+    setItem: (key: string, data: T) => void;
+}
+export type NonReactUsageReport = (...args: Array<unknown>) => void;
+export type PartialState<T extends State> = T extends Partial<infer U> ? T : Partial<T>;
+export interface Prehooks<T extends State = State> {
+    resetState?: (resetData: PartialState<T>, state: {
+        current: T;
+        original: T;
+    }) => boolean;
+    setState?: (newChanges: Changes<T>) => boolean;
+}
+export type Subscribe = <T extends State>(listener: Listener<T>) => Unsubscribe;
+export type Unsubscribe = (...args: Array<unknown>) => void;
+export interface IStore {
+    resetState: Function;
+    setState: Function;
+}
+export interface IStoreInternal extends IStore {
+    subscribe: Function;
+}
+export interface Store<T extends State, SELECTOR_MAP extends SelectorMap = SelectorMap> extends IStore {
+    data: Data<SELECTOR_MAP>;
+    resetState: (propertyPaths?: Array<string>) => void;
+    setState: (changes: Changes<T>) => void;
+}
+export interface StoreInternal<T extends State> extends IStoreInternal {
+    cache: Immutable<Partial<T>>;
+    resetState: (connection: Connection<T>, propertyPaths?: Array<string>) => void;
+    setState: (connection: Connection<T>, changes: Changes<T>) => void;
+    subscribe: Subscribe;
+}
+export interface StorePlaceholder extends IStoreInternal {
+    getState: NonReactUsageReport;
+    resetState: NonReactUsageReport;
+    setState: NonReactUsageReport;
+    subscribe: NonReactUsageReport;
+}
+export interface StoreRef<T extends State = State> extends StorePlaceholder {
+    getState: (propertyPaths?: Array<string>) => T;
+    resetState: (propertyPaths?: Array<string>) => void;
+    setState: (changes: Changes<T>) => void;
+    subscribe: Subscribe;
+}
+export { CLEAR_TAG, DELETE_TAG, FULL_STATE_SELECTOR, MOVE_TAG, NULL_SELECTOR, PUSH_TAG, REPLACE_TAG, SET_TAG, SPLICE_TAG, Tag, } from './constants';
+export { connect, createContext, ObservableContext, UsageError, useContext } from './main';

package/dist/main/hooks/use-prehooks-ref/index.d.ts

@@ -0,0 +1,3 @@
+import type { Prehooks, State } from '../../..';
+declare function usePrehooksRef<T extends State>(prehooks: Prehooks<T>): import("react").MutableRefObject<Prehooks<T>>;
+export default usePrehooksRef;

package/dist/main/hooks/use-prehooks-ref/index.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var react_1 = require("react");
+function usePrehooksRef(prehooks) {
+  var prehooksRef = (0, react_1.useRef)(prehooks);
+  (0, react_1.useEffect)(function () {
+    prehooksRef.current = prehooks;
+  }, [prehooks]);
+  return prehooksRef;
+}
+;
+exports["default"] = usePrehooksRef;

package/dist/main/hooks/use-render-key-provider/index.d.ts

@@ -0,0 +1,5 @@
+import type { ArraySelector, ObjectSelector, SelectorMap, Text } from '../../..';
+declare function useRenderKeyProvider(selectorMap: ArraySelector): Array<Text>;
+declare function useRenderKeyProvider(selectorMap: ObjectSelector): Array<Text>;
+declare function useRenderKeyProvider(selectorMap: SelectorMap): Array<Text>;
+export default useRenderKeyProvider;

package/dist/main/hooks/use-render-key-provider/index.js

@@ -0,0 +1,36 @@
+"use strict";
+
+var __importDefault = void 0 && (void 0).__importDefault || function (mod) {
+  return mod && mod.__esModule ? mod : {
+    "default": mod
+  };
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var react_1 = require("react");
+var lodash_isplainobject_1 = __importDefault(require("lodash.isplainobject"));
+function getCurrKeys(selectorMap) {
+  if ((0, lodash_isplainobject_1["default"])(selectorMap) || Array.isArray(selectorMap)) {
+    return Array.from(new Set(Object.values(selectorMap)));
+  }
+  if (typeof selectorMap === 'undefined' || selectorMap === null) {
+    return [];
+  }
+  throw new TypeError('Incompatible Selector Map type provided.');
+}
+;
+function useRenderKeyProvider(selectorMap) {
+  var renderKeys = (0, react_1.useRef)([]);
+  return (0, react_1.useMemo)(function () {
+    var currKeys = getCurrKeys(selectorMap);
+    if (renderKeys.current.length !== currKeys.length || renderKeys.current.some(function (k, i) {
+      return k !== currKeys[i];
+    })) {
+      renderKeys.current = currKeys;
+    }
+    return renderKeys.current;
+  }, [selectorMap]);
+}
+;
+exports["default"] = useRenderKeyProvider;

package/dist/main/hooks/use-store/index.d.ts

@@ -0,0 +1,10 @@
+import type { IStorage, StoreInternal, PartialState, Prehooks, State } from '../../..';
+export declare const deps: {
+    createStorageKey: () => string;
+};
+interface CurrentStorage<T extends State> extends IStorage<T> {
+    isKeyRequired?: boolean;
+}
+/** @param storage - is Closed to modification post-initialization */
+declare const useStore: <T extends State>(prehooks: Prehooks<T>, value: PartialState<T>, storage?: CurrentStorage<T>) => StoreInternal<T>;
+export default useStore;

package/dist/main/hooks/use-store/index.js

@@ -0,0 +1,261 @@
+"use strict";
+
+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 _excluded = ["length"],
+  _excluded2 = ["length"];
+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 _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 _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 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 _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 _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 _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 _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 _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; }
+var __importDefault = void 0 && (void 0).__importDefault || function (mod) {
+  return mod && mod.__esModule ? mod : {
+    "default": mod
+  };
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.deps = void 0;
+var react_1 = require("react");
+var lodash_isboolean_1 = __importDefault(require("lodash.isboolean"));
+var lodash_isempty_1 = __importDefault(require("lodash.isempty"));
+var data_distillery_1 = __importDefault(require("@webkrafters/data-distillery"));
+var path_dotize_1 = __importDefault(require("@webkrafters/path-dotize"));
+var auto_immutable_1 = __importDefault(require("@webkrafters/auto-immutable"));
+var constants_1 = require("../../../constants");
+var storage_1 = __importDefault(require("../../../model/storage"));
+var use_prehooks_ref_1 = __importDefault(require("../use-prehooks-ref"));
+var iCount = -1;
+var createStorageKey = function createStorageKey() {
+  return "".concat(++iCount, ":").concat(Date.now(), ":").concat(Math.random());
+};
+// to facilitate testing
+exports.deps = {
+  createStorageKey: createStorageKey
+};
+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;
+}
+var consumer = {};
+function transformPayload(payload) {
+  if ((0, lodash_isempty_1["default"])(payload) || !(constants_1.FULL_STATE_SELECTOR in payload)) {
+    return payload;
+  }
+  payload = _objectSpread(_objectSpread({}, payload), {}, _defineProperty({}, constants_1.GLOBAL_SELECTOR, payload[constants_1.FULL_STATE_SELECTOR]));
+  delete payload[constants_1.FULL_STATE_SELECTOR];
+  return payload;
+}
+/** @param storage - is Closed to modification post-initialization */
+var useStore = function useStore(prehooks, value, storage) {
+  var connKey = (0, react_1.useRef)();
+  var mounted = (0, react_1.useRef)(false);
+  var prehooksRef = (0, use_prehooks_ref_1["default"])(prehooks);
+  var storageKey = (0, react_1.useRef)();
+  var _ref = (0, react_1.useState)(function () {
+      if (connKey.current === undefined) {
+        var _cache = new auto_immutable_1["default"](value);
+        var self = _cache.connect();
+        connKey.current = self.instanceId;
+        consumer[connKey.current] = {
+          cache: _cache,
+          self: self
+        };
+      }
+      return [consumer[connKey.current].cache, consumer[connKey.current].self];
+    }),
+    _ref2 = _slicedToArray(_ref, 1),
+    _ref2$ = _slicedToArray(_ref2[0], 2),
+    cache = _ref2$[0],
+    ownConnection = _ref2$[1];
+  var _ref3 = (0, react_1.useState)(function () {
+      return new Set();
+    }),
+    _ref4 = _slicedToArray(_ref3, 1),
+    listeners = _ref4[0];
+  var _ref5 = (0, react_1.useState)(function () {
+      var isKeyRequired = true;
+      var _storage = storage;
+      if (!storage) {
+        _storage = new storage_1["default"]();
+        isKeyRequired = _storage.isKeyRequired;
+      }
+      storageKey.current = isKeyRequired ? exports.deps.createStorageKey() : null;
+      return _storage;
+    }),
+    _ref6 = _slicedToArray(_ref5, 1),
+    _storage = _ref6[0];
+  var getChangHandler = (0, react_1.useCallback)(function (changes) {
+    return function (netChanges, changedPathsTokens) {
+      var mayHaveChangesAt = createChangePathSearch(changedPathsTokens);
+      listeners.forEach(function (listener) {
+        return listener(changes, changedPathsTokens, netChanges, mayHaveChangesAt);
+      });
+    };
+  }, []);
+  var resetState = (0, react_1.useCallback)(function (connection) {
+    var propertyPaths = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+    var original = _storage.clone(_storage.getItem(storageKey.current));
+    var resetData;
+    if (!propertyPaths.length) {
+      resetData = {};
+    } else if (propertyPaths.includes(constants_1.FULL_STATE_SELECTOR)) {
+      resetData = (0, lodash_isempty_1["default"])(original) ? constants_1.CLEAR_TAG : _defineProperty({}, constants_1.REPLACE_TAG, original);
+    } else {
+      var visitedPathMap = {};
+      var transformer = function transformer(_ref8) {
+        var trail = _ref8.trail,
+          value = _ref8.value;
+        visitedPathMap[trail.join('.')] = null;
+        return _defineProperty({}, constants_1.REPLACE_TAG, value);
+      };
+      resetData = (0, data_distillery_1["default"])(original, propertyPaths, transformer);
+      if (Object.keys(visitedPathMap).length < propertyPaths.length) {
+        var _iterator = _createForOfIteratorHelper(propertyPaths),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var path = _step.value;
+            path = (0, path_dotize_1["default"])(path);
+            if (path in visitedPathMap) {
+              continue;
+            }
+            var trail = path.split('.');
+            var keyTuple = trail.slice(-1);
+            trail = trail.slice(0, -1);
+            var node = resetData;
+            var _iterator2 = _createForOfIteratorHelper(trail),
+              _step2;
+            try {
+              for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                var t = _step2.value;
+                if ((0, lodash_isempty_1["default"])(node[t])) {
+                  node[t] = {};
+                }
+                node = node[t];
+              }
+            } catch (err) {
+              _iterator2.e(err);
+            } finally {
+              _iterator2.f();
+            }
+            if (constants_1.DELETE_TAG in node) {
+              var _node$constants_1$DEL;
+              (_node$constants_1$DEL = node[constants_1.DELETE_TAG]).push.apply(_node$constants_1$DEL, _toConsumableArray(keyTuple));
+            } else {
+              node[constants_1.DELETE_TAG] = keyTuple;
+            }
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+      }
+    }
+    runPrehook(prehooksRef.current, 'resetState', [resetData, {
+      current: connection.get(constants_1.GLOBAL_SELECTOR)[constants_1.GLOBAL_SELECTOR],
+      original: original
+    }]) && connection.set(resetData, getChangHandler(resetData));
+  }, []);
+  var setState = (0, react_1.useCallback)(function (connection, changes) {
+    if (!runPrehook(prehooksRef.current, 'setState', [changes])) {
+      return;
+    }
+    if (!Array.isArray(changes)) {
+      changes = transformPayload(changes);
+    } else {
+      changes = changes.slice();
+      for (var c = changes.length; c--;) {
+        changes[c] = transformPayload(changes[c]);
+      }
+    }
+    connection.set(changes, getChangHandler(changes));
+  }, []);
+  var subscribe = (0, react_1.useCallback)(function (listener) {
+    listeners.add(listener);
+    return function () {
+      return listeners["delete"](listener);
+    };
+  }, []);
+  (0, react_1.useEffect)(function () {
+    var sKey = storageKey.current;
+    _storage.setItem(sKey, _storage.clone(value));
+    return function () {
+      _storage.removeItem(sKey);
+      ownConnection.disconnect();
+      delete consumer[connKey.current];
+      connKey.current = undefined;
+      cache.close();
+      listeners.clear();
+    };
+  }, []);
+  (0, react_1.useEffect)(function () {
+    if (!mounted.current) {
+      mounted.current = true;
+      return;
+    }
+    setState(ownConnection, value);
+  }, [value]);
+  return (0, react_1.useState)(function () {
+    return {
+      cache: cache,
+      resetState: resetState,
+      setState: setState,
+      subscribe: subscribe
+    };
+  })[0];
+};
+exports["default"] = useStore;
+/**
+ * @param {string[][]} changedPathsTokens - list containing tokenized changed object paths.
+ * @returns {Function} - function verifying that a random tokenized object path falls within the changed paths domain.
+ */
+function createChangePathSearch(_ref0) {
+  var length = _ref0.length,
+    pathTokenGroups = _objectWithoutProperties(_ref0, _excluded);
+  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 (_ref1) {
+    var length = _ref1.length,
+      pathTokens = _objectWithoutProperties(_ref1, _excluded2);
+    var obj = root;
+    for (var p = 0; p < length; p++) {
+      var _key = pathTokens[p];
+      if (_key in obj) {
+        obj = obj[_key];
+        continue;
+      }
+      return !Object.keys(obj).length;
+    }
+    return true;
+  };
+}

package/dist/main/index.d.ts

@@ -0,0 +1,58 @@
+import type { ElementType, NamedExoticComponent } from 'react';
+import type { ConnectedComponent, ConnectProps, ExtractInjectedProps, IStoreInternal, ObservableProvider, SelectorMap, State, Store } from '..';
+import React from 'react';
+declare const __CTX_SYM__: unique symbol;
+export declare class ObservableContext<T extends State> {
+    private cxt;
+    private provider;
+    constructor();
+    get [__CTX_SYM__](): React.Context<IStoreInternal>;
+    get Consumer(): React.Consumer<IStoreInternal>;
+    get Provider(): ObservableProvider<T>;
+}
+export declare function createContext<T extends State = State>(): ObservableContext<T>;
+/**
+ * Actively monitors the store and triggers component re-render if any of the watched keys in the state objects changes
+ *
+ * @param context - Refers to the PublicObservableContext<T> type of the ObservableContext<T>
+ * @param [selectorMap = {}] - Key:value pairs where `key` => arbitrary key given to a Store.data property holding a state slice and `value` => property path to a state slice used by this component: see examples below. May add a mapping for a certain arbitrary key='state' and value='@@STATE' to indicate a desire to obtain the entire state object and assign to a `state` property of Store.data. A change in any of the referenced properties results in this component render. When using '@@STATE', note that any change within the state object will result in this component render.
+ * @see {ObservableContext<STATE>}
+ *
+ * @example
+ * a valid property path follows the `lodash` object property path convention.
+ * for a state = { a: 1, b: 2, c: 3, d: { e: 5, f: [6, { x: 7, y: 8, z: 9 } ] } }
+ * Any of the following is an applicable selector map.
+ * ['d', 'a'] => {
+ * 		0: { e: 5, f: [6, { x: 7, y: 8, z: 9 } ] },
+ * 		1: 1
+ * }
+ * {myData: 'd', count: 'a'} => {
+ * 		myData: { e: 5, f: [6, { x: 7, y: 8, z: 9 } ] },
+ * 		count: 1
+ * }
+ * {count: 'a'} => {count: 1} // same applies to {count: 'b'} = {count: 2}; {count: 'c'} = {count: 3}
+ * {myData: 'd'} => {mydata: { e: 5, f: [6, { x: 7, y: 8, z: 9 } ] }}
+ * {xyz: 'd.e'} => {xyz: 5}
+ * {def: 'd.e.f'} => {def: [6, { x: 7, y: 8, z: 9 } ]}
+ * {f1: 'd.e.f[0]'} or {f1: 'd.e.f.0'} => {f1: 6}
+ * {secondFElement: 'd.e.f[1]'} or {secondFElement: 'd.e.f.1'} => {secondFElement: { x: 7, y: 8, z: 9 }}
+ * {myX: 'd.e.f[1].x'} or {myX: 'd.e.f.1.x'} => {myX: 7} // same applies to {myY: 'd.e.f[1].y'} = {myY: 8}; {myZ: 'd.e.f[1].z'} = {myZ: 9}
+ * {myData: '@@STATE'} => {myData: state}
+ */
+export declare function useContext<STATE extends State, SELECTOR_MAP extends SelectorMap>(context: ObservableContext<STATE>, selectorMap?: SELECTOR_MAP): Store<STATE, SELECTOR_MAP>;
+/**
+ * Provides an HOC function for connecting its WrappedComponent argument to the context store.
+ *
+ * The HOC function automatically memoizes any un-memoized WrappedComponent argument.
+ *
+ * @param context - Refers to the PublicObservableContext<T> type of the ObservableContext<T>
+ * @param [selectorMap] - Key:value pairs where `key` => arbitrary key given to a Store.data property holding a state slice and `value` => property path to a state slice used by this component: see examples below. May add a mapping for a certain arbitrary key='state' and value='@@STATE' to indicate a desire to obtain the entire state object and assign to a `state` property of Store.data. A change in any of the referenced properties results in this component render. When using '@@STATE', note that any change within the state object will result in this component render.
+ * @see {useContext} for selectorMap sample
+ */
+export declare function connect<STATE extends State = State, SELECTOR_MAP extends SelectorMap = SelectorMap>(context: ObservableContext<STATE>, selectorMap?: SELECTOR_MAP): {
+    <P extends ExtractInjectedProps<STATE, SELECTOR_MAP>>(WrappedComponent: ElementType<ConnectProps<P, STATE, SELECTOR_MAP>>): ConnectedComponent<P>;
+    <P extends ExtractInjectedProps<STATE, SELECTOR_MAP>>(WrappedComponent: NamedExoticComponent<ConnectProps<P, STATE, SELECTOR_MAP>>): ConnectedComponent<P>;
+};
+export declare class UsageError extends Error {
+}
+export {};

package/dist/main/index.js

@@ -0,0 +1,441 @@
+"use strict";
+
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _possibleConstructorReturn(t, e) { if (e && ("object" == _typeof(e) || "function" == typeof e)) return e; if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined"); return _assertThisInitialized(t); }
+function _assertThisInitialized(e) { if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return e; }
+function _inherits(t, e) { if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function"); t.prototype = Object.create(e && e.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), Object.defineProperty(t, "prototype", { writable: !1 }), e && _setPrototypeOf(t, e); }
+function _wrapNativeSuper(t) { var r = "function" == typeof Map ? new Map() : void 0; return _wrapNativeSuper = function _wrapNativeSuper(t) { if (null === t || !_isNativeFunction(t)) return t; if ("function" != typeof t) throw new TypeError("Super expression must either be null or a function"); if (void 0 !== r) { if (r.has(t)) return r.get(t); r.set(t, Wrapper); } function Wrapper() { return _construct(t, arguments, _getPrototypeOf(this).constructor); } return Wrapper.prototype = Object.create(t.prototype, { constructor: { value: Wrapper, enumerable: !1, writable: !0, configurable: !0 } }), _setPrototypeOf(Wrapper, t); }, _wrapNativeSuper(t); }
+function _construct(t, e, r) { if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments); var o = [null]; o.push.apply(o, e); var p = new (t.bind.apply(t, o))(); return r && _setPrototypeOf(p, r.prototype), p; }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _isNativeFunction(t) { try { return -1 !== Function.toString.call(t).indexOf("[native code]"); } catch (n) { return "function" == typeof t; } }
+function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
+function _getPrototypeOf(t) { return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, _getPrototypeOf(t); }
+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 _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 _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 _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 _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); }
+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); }
+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 __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.UsageError = exports.ObservableContext = void 0;
+exports.createContext = createContext;
+exports.useContext = useContext;
+exports.connect = connect;
+var react_1 = __importStar(require("react"));
+var lodash_isequal_1 = __importDefault(require("lodash.isequal"));
+var lodash_isplainobject_1 = __importDefault(require("lodash.isplainobject"));
+var lodash_omit_1 = __importDefault(require("lodash.omit"));
+var lodash_set_1 = __importDefault(require("lodash.set"));
+var path_dotize_1 = __importDefault(require("@webkrafters/path-dotize"));
+var constants = __importStar(require("../constants"));
+var use_render_key_provider_1 = __importDefault(require("./hooks/use-render-key-provider"));
+var use_store_1 = __importDefault(require("./hooks/use-store"));
+var __CTX_SYM__ = Symbol('Context Symbol');
+var reportNonReactUsage = function reportNonReactUsage() {
+  throw new UsageError('Detected usage outside of this context\'s Provider component tree. Please apply the exported Provider component');
+};
+var ObservableContext = /*#__PURE__*/function () {
+  function ObservableContext() {
+    _classCallCheck(this, ObservableContext);
+    this.cxt = (0, react_1.createContext)({
+      getState: reportNonReactUsage,
+      resetState: reportNonReactUsage,
+      setState: reportNonReactUsage,
+      subscribe: reportNonReactUsage
+    });
+    this.provider = makeObservable(this.cxt.Provider);
+  }
+  return _createClass(ObservableContext, [{
+    key: __CTX_SYM__,
+    get: function get() {
+      return this.cxt;
+    }
+  }, {
+    key: "Consumer",
+    get: function get() {
+      return this.cxt.Consumer;
+    }
+  }, {
+    key: "Provider",
+    get: function get() {
+      return this.provider;
+    }
+  }]);
+}();
+exports.ObservableContext = ObservableContext;
+function createContext() {
+  return new ObservableContext();
+}
+;
+var connRegister = {};
+function getConnectionFrom(connKey, cache) {
+  if (connKey.current === undefined) {
+    try {
+      var connection = cache.connect();
+      connKey.current = connection.instanceId;
+      connRegister[connKey.current] = connection;
+    } catch (e) {
+      reportNonReactUsage();
+    }
+  }
+  return connRegister[connKey.current];
+}
+/**
+ * Actively monitors the store and triggers component re-render if any of the watched keys in the state objects changes
+ *
+ * @param context - Refers to the PublicObservableContext<T> type of the ObservableContext<T>
+ * @param [selectorMap = {}] - Key:value pairs where `key` => arbitrary key given to a Store.data property holding a state slice and `value` => property path to a state slice used by this component: see examples below. May add a mapping for a certain arbitrary key='state' and value='@@STATE' to indicate a desire to obtain the entire state object and assign to a `state` property of Store.data. A change in any of the referenced properties results in this component render. When using '@@STATE', note that any change within the state object will result in this component render.
+ * @see {ObservableContext<STATE>}
+ *
+ * @example
+ * a valid property path follows the `lodash` object property path convention.
+ * for a state = { a: 1, b: 2, c: 3, d: { e: 5, f: [6, { x: 7, y: 8, z: 9 } ] } }
+ * Any of the following is an applicable selector map.
+ * ['d', 'a'] => {
+ * 		0: { e: 5, f: [6, { x: 7, y: 8, z: 9 } ] },
+ * 		1: 1
+ * }
+ * {myData: 'd', count: 'a'} => {
+ * 		myData: { e: 5, f: [6, { x: 7, y: 8, z: 9 } ] },
+ * 		count: 1
+ * }
+ * {count: 'a'} => {count: 1} // same applies to {count: 'b'} = {count: 2}; {count: 'c'} = {count: 3}
+ * {myData: 'd'} => {mydata: { e: 5, f: [6, { x: 7, y: 8, z: 9 } ] }}
+ * {xyz: 'd.e'} => {xyz: 5}
+ * {def: 'd.e.f'} => {def: [6, { x: 7, y: 8, z: 9 } ]}
+ * {f1: 'd.e.f[0]'} or {f1: 'd.e.f.0'} => {f1: 6}
+ * {secondFElement: 'd.e.f[1]'} or {secondFElement: 'd.e.f.1'} => {secondFElement: { x: 7, y: 8, z: 9 }}
+ * {myX: 'd.e.f[1].x'} or {myX: 'd.e.f.1.x'} => {myX: 7} // same applies to {myY: 'd.e.f[1].y'} = {myY: 8}; {myZ: 'd.e.f[1].z'} = {myZ: 9}
+ * {myData: '@@STATE'} => {myData: state}
+ */
+function useContext(context, selectorMap) {
+  var _react_1$default$useC = react_1["default"].useContext(context[__CTX_SYM__]),
+    cache = _react_1$default$useC.cache,
+    _resetState = _react_1$default$useC.resetState,
+    _setState = _react_1$default$useC.setState,
+    subscribe = _react_1$default$useC.subscribe;
+  var connKey = (0, react_1.useRef)();
+  var _react_1$default$useS = react_1["default"].useState(function () {
+      return getConnectionFrom(connKey, cache);
+    }),
+    _react_1$default$useS2 = _slicedToArray(_react_1$default$useS, 1),
+    connection = _react_1$default$useS2[0];
+  var _renderKeys = (0, use_render_key_provider_1["default"])(selectorMap);
+  var refineKeys = function refineKeys() {
+    var rKeys = _renderKeys.slice();
+    if (fullStateSelectorIndex !== -1) {
+      rKeys[fullStateSelectorIndex] = constants.GLOBAL_SELECTOR;
+    }
+    return rKeys;
+  };
+  /* Reverses selectorMap i.e. {selectorKey: propertyPath} => {propertyPath: selectorKey} */
+  var _ref = (0, react_1.useMemo)(function () {
+      var map = {};
+      if (!_renderKeys.length) {
+        return [map, _renderKeys.indexOf(constants.FULL_STATE_SELECTOR)];
+      }
+      for (var selectorKey in selectorMap) {
+        map[selectorMap[selectorKey]] = selectorKey;
+      }
+      return [map, _renderKeys.indexOf(constants.FULL_STATE_SELECTOR)];
+    }, [_renderKeys]),
+    _ref2 = _slicedToArray(_ref, 2),
+    selectorMapInverse = _ref2[0],
+    fullStateSelectorIndex = _ref2[1];
+  var _react_1$default$useS3 = react_1["default"].useState(function () {
+      var _connection;
+      var data = {};
+      if (!_renderKeys.length) {
+        return data;
+      }
+      var state = (_connection = connection).get.apply(_connection, _toConsumableArray(refineKeys()));
+      var _iterator = _createForOfIteratorHelper(_renderKeys),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var propertyPath = _step.value;
+          data[selectorMapInverse[propertyPath]] = state[propertyPath === constants.FULL_STATE_SELECTOR ? constants.GLOBAL_SELECTOR : propertyPath];
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      return data;
+    }),
+    _react_1$default$useS4 = _slicedToArray(_react_1$default$useS3, 2),
+    data = _react_1$default$useS4[0],
+    setData = _react_1$default$useS4[1];
+  var dataSourceListener = function dataSourceListener(changes, changePathsTokens, netChanges, mayHaveChangesAt) {
+    for (var _Len = _renderKeys.length, _ = 0; _ < _Len; _++) {
+      if (_renderKeys[_] !== constants.FULL_STATE_SELECTOR && !mayHaveChangesAt((0, path_dotize_1["default"])(_renderKeys[_]).split('.'))) {
+        continue;
+      }
+      return updateData();
+    }
+  };
+  var updateData = function updateData() {
+    var _connection2;
+    var hasChanges = false;
+    var state = (_connection2 = connection).get.apply(_connection2, _toConsumableArray(refineKeys()));
+    var _iterator2 = _createForOfIteratorHelper(_renderKeys),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var propertyPath = _step2.value;
+        var selectorKey = selectorMapInverse[propertyPath];
+        if (propertyPath === constants.FULL_STATE_SELECTOR) {
+          if (data[selectorKey] === state[constants.GLOBAL_SELECTOR]) {
+            continue;
+          }
+          data[selectorKey] = state[constants.GLOBAL_SELECTOR];
+          hasChanges = true;
+          continue;
+        }
+        if (data[selectorKey] === state[propertyPath]) {
+          continue;
+        }
+        data[selectorKey] = state[propertyPath];
+        hasChanges = true;
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+    hasChanges && setData(_objectSpread({}, data));
+  };
+  var resetState = (0, react_1.useCallback)(function () {
+    var propertyPath = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _renderKeys;
+    return _resetState(connection, propertyPath);
+  }, [_resetState, connection]);
+  var setState = (0, react_1.useCallback)(function (changes) {
+    return _setState(connection, changes);
+  }, [_setState, connection]);
+  react_1["default"].useEffect(function () {
+    // istanbul ignore if
+    if (cache.closed) {
+      return;
+    }
+    connection = getConnectionFrom(connKey, cache);
+    if (!_renderKeys.length) {
+      var _default = {};
+      !(0, lodash_isequal_1["default"])(_default, data) && setData(_default);
+      return;
+    }
+    for (var selectorKey in data) {
+      if (!(selectorMap[selectorKey] in selectorMapInverse)) {
+        delete data[selectorKey];
+      }
+    }
+    var unsubscribe = subscribe(dataSourceListener);
+    updateData();
+    return function () {
+      if (cache.closed) {
+        return;
+      }
+      unsubscribe();
+      connection.disconnect();
+      delete connRegister[connKey.current];
+      connKey.current = undefined;
+    };
+  }, [_renderKeys, cache]);
+  return (0, react_1.useMemo)(function () {
+    return {
+      data: data,
+      resetState: resetState,
+      setState: setState
+    };
+  }, [data]);
+}
+;
+/**
+ * Provides an HOC function for connecting its WrappedComponent argument to the context store.
+ *
+ * The HOC function automatically memoizes any un-memoized WrappedComponent argument.
+ *
+ * @param context - Refers to the PublicObservableContext<T> type of the ObservableContext<T>
+ * @param [selectorMap] - Key:value pairs where `key` => arbitrary key given to a Store.data property holding a state slice and `value` => property path to a state slice used by this component: see examples below. May add a mapping for a certain arbitrary key='state' and value='@@STATE' to indicate a desire to obtain the entire state object and assign to a `state` property of Store.data. A change in any of the referenced properties results in this component render. When using '@@STATE', note that any change within the state object will result in this component render.
+ * @see {useContext} for selectorMap sample
+ */
+function connect(context, selectorMap) {
+  function connector(WrappedComponent) {
+    var Wrapped = !((0, lodash_isplainobject_1["default"])(WrappedComponent) && 'compare' in WrappedComponent) ? (0, react_1.memo)(WrappedComponent) : WrappedComponent;
+    var ConnectedComponent = (0, react_1.memo)((0, react_1.forwardRef)(function (ownProps, ref) {
+      var store = useContext(context, selectorMap);
+      return react_1["default"].createElement(Wrapped, _objectSpread(_objectSpread(_objectSpread({}, store), ownProps), {}, {
+        ref: ref
+      }));
+    }));
+    ConnectedComponent.displayName = 'ObservableContext.Connected';
+    return ConnectedComponent;
+  }
+  return connector;
+}
+var UsageError = /*#__PURE__*/function (_Error) {
+  function UsageError() {
+    _classCallCheck(this, UsageError);
+    return _callSuper(this, UsageError, arguments);
+  }
+  _inherits(UsageError, _Error);
+  return _createClass(UsageError);
+}(/*#__PURE__*/_wrapNativeSuper(Error));
+exports.UsageError = UsageError;
+;
+var ChildMemo = function () {
+  var useNodeMemo = function useNodeMemo(node) {
+    var nodeRef = (0, react_1.useRef)(node);
+    if (!(0, lodash_isequal_1["default"])((0, lodash_omit_1["default"])(nodeRef.current, '_owner'), (0, lodash_omit_1["default"])(node, '_owner'))) {
+      nodeRef.current = node;
+    }
+    return nodeRef.current;
+  };
+  var ChildMemo = (0, react_1.memo)(function (_ref3) {
+    var child = _ref3.child;
+    return react_1["default"].createElement(react_1["default"].Fragment, null, child);
+  });
+  ChildMemo.displayName = 'ObservableContext.Provider.Internal.Guardian.ChildMemo';
+  var Guardian = function Guardian(_ref4) {
+    var child = _ref4.child;
+    return react_1["default"].createElement(ChildMemo, {
+      child: useNodeMemo(child)
+    });
+  };
+  Guardian.displayName = 'ObservableContext.Provider.Internal.Guardian';
+  return Guardian;
+}();
+var defaultPrehooks = Object.freeze({});
+function makeObservable(Provider) {
+  var Observable = (0, react_1.forwardRef)(function (_ref5, storeRef) {
+    var _ref5$children = _ref5.children,
+      children = _ref5$children === void 0 ? null : _ref5$children,
+      _ref5$prehooks = _ref5.prehooks,
+      prehooks = _ref5$prehooks === void 0 ? defaultPrehooks : _ref5$prehooks,
+      _ref5$storage = _ref5.storage,
+      storage = _ref5$storage === void 0 ? null : _ref5$storage,
+      value = _ref5.value;
+    var connKey = (0, react_1.useRef)();
+    var store = (0, use_store_1["default"])(prehooks, value, storage);
+    var _ref6 = (0, react_1.useState)(function () {
+        return getConnectionFrom(connKey, store.cache);
+      }),
+      _ref7 = _slicedToArray(_ref6, 1),
+      connection = _ref7[0];
+    var getState = (0, react_1.useCallback)(function () {
+      var propertyPaths = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+      if (!propertyPaths.length || propertyPaths.indexOf(constants.FULL_STATE_SELECTOR) !== -1) {
+        return connection.get(constants.GLOBAL_SELECTOR)[constants.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 state;
+    }, []);
+    (0, react_1.useImperativeHandle)(storeRef, function () {
+      var _storeRef$current;
+      return _objectSpread(_objectSpread({}, (_storeRef$current = storeRef === null || storeRef === void 0 ? void 0 : storeRef.current) !== null && _storeRef$current !== void 0 ? _storeRef$current : {}), {}, {
+        getState: getState,
+        resetState: function resetState(propertyPaths) {
+          return store.resetState(connection, propertyPaths);
+        },
+        setState: function setState(changes) {
+          return store.setState(connection, changes);
+        },
+        subscribe: store.subscribe
+      });
+    }, [storeRef === null || storeRef === void 0 ? void 0 : storeRef.current]);
+    (0, react_1.useEffect)(function () {
+      return function () {
+        connection.disconnect();
+        delete connRegister[connKey.current];
+        connKey.current = undefined;
+      };
+    }, []);
+    return react_1["default"].createElement(Provider, {
+      value: store
+    }, memoizeImmediateChildTree(children));
+  });
+  Observable.displayName = 'ObservableContext.Provider';
+  return Observable;
+}
+function memoizeImmediateChildTree(children) {
+  return react_1.Children.map(children, function (_child) {
+    var _child2, _child$type$$$typeof, _child$props;
+    var child = _child;
+    if (!((_child2 = child) !== null && _child2 !== void 0 && _child2.type) ||
+    // skip memoized or non element(s)
+    _typeof(child.type) === 'object' && ((_child$type$$$typeof = child.type.$$typeof) === null || _child$type$$$typeof === void 0 ? void 0 : _child$type$$$typeof.toString()) === 'Symbol(react.memo)') {
+      return child;
+    }
+    if ((_child$props = child.props) !== null && _child$props !== void 0 && _child$props.children) {
+      child = (0, react_1.cloneElement)(child, (0, lodash_omit_1["default"])(child.props, 'children'), memoizeImmediateChildTree(child.props.children));
+    }
+    return react_1["default"].createElement(ChildMemo, {
+      child: child
+    });
+  });
+}

package/dist/model/storage/index.d.ts

@@ -0,0 +1,12 @@
+import type { IStorage, State } from '../..';
+declare class Storage<T extends State> implements IStorage<T> {
+    #private;
+    static supportsSession: boolean;
+    constructor();
+    get isKeyRequired(): boolean;
+    clone(data: any): T;
+    getItem(key: string): T;
+    removeItem(key: string): void;
+    setItem(key: string, data: T): void;
+}
+export default Storage;

package/dist/model/storage/index.js

@@ -0,0 +1,124 @@
+"use strict";
+
+var _globalThis$sessionSt;
+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); }
+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); }
+var __classPrivateFieldSet = void 0 && (void 0).__classPrivateFieldSet || function (receiver, state, value, kind, f) {
+  if (kind === "m") throw new TypeError("Private method is not writable");
+  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+  return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
+};
+var __classPrivateFieldGet = void 0 && (void 0).__classPrivateFieldGet || function (receiver, state, kind, f) {
+  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = void 0 && (void 0).__importDefault || function (mod) {
+  return mod && mod.__esModule ? mod : {
+    "default": mod
+  };
+};
+var _MemoryStorage_data, _SessionStorage_storage, _Storage_storage;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var clone_total_1 = __importDefault(require("@webkrafters/clone-total"));
+var MemoryStorage = /*#__PURE__*/function () {
+  function MemoryStorage() {
+    _classCallCheck(this, MemoryStorage);
+    _MemoryStorage_data.set(this, void 0);
+    __classPrivateFieldSet(this, _MemoryStorage_data, null, "f");
+  }
+  return _createClass(MemoryStorage, [{
+    key: "clone",
+    value: function clone(data) {
+      return (0, clone_total_1["default"])(data);
+    }
+  }, {
+    key: "getItem",
+    value: function getItem(key) {
+      return __classPrivateFieldGet(this, _MemoryStorage_data, "f");
+    }
+  }, {
+    key: "removeItem",
+    value: function removeItem(key) {
+      __classPrivateFieldSet(this, _MemoryStorage_data, null, "f");
+    }
+  }, {
+    key: "setItem",
+    value: function setItem(key, data) {
+      __classPrivateFieldSet(this, _MemoryStorage_data, data, "f");
+    }
+  }]);
+}();
+_MemoryStorage_data = new WeakMap();
+var SessionStorage = /*#__PURE__*/function () {
+  function SessionStorage() {
+    _classCallCheck(this, SessionStorage);
+    _SessionStorage_storage.set(this, void 0);
+    __classPrivateFieldSet(this, _SessionStorage_storage, globalThis.sessionStorage, "f");
+  }
+  return _createClass(SessionStorage, [{
+    key: "clone",
+    value: function clone(data) {
+      return data;
+    }
+  }, {
+    key: "getItem",
+    value: function getItem(key) {
+      return JSON.parse(__classPrivateFieldGet(this, _SessionStorage_storage, "f").getItem(key));
+    }
+  }, {
+    key: "removeItem",
+    value: function removeItem(key) {
+      return __classPrivateFieldGet(this, _SessionStorage_storage, "f").removeItem(key);
+    }
+  }, {
+    key: "setItem",
+    value: function setItem(key, data) {
+      return __classPrivateFieldGet(this, _SessionStorage_storage, "f").setItem(key, JSON.stringify(data));
+    }
+  }]);
+}();
+_SessionStorage_storage = new WeakMap();
+var Storage = /*#__PURE__*/function () {
+  function Storage() {
+    _classCallCheck(this, Storage);
+    _Storage_storage.set(this, void 0);
+    __classPrivateFieldSet(this, _Storage_storage, Storage.supportsSession ? new SessionStorage() : new MemoryStorage(), "f");
+  }
+  return _createClass(Storage, [{
+    key: "isKeyRequired",
+    get: function get() {
+      return __classPrivateFieldGet(this, _Storage_storage, "f") instanceof SessionStorage;
+    }
+  }, {
+    key: "clone",
+    value: function clone(data) {
+      return __classPrivateFieldGet(this, _Storage_storage, "f").clone(data);
+    }
+  }, {
+    key: "getItem",
+    value: function getItem(key) {
+      return __classPrivateFieldGet(this, _Storage_storage, "f").getItem(key);
+    }
+  }, {
+    key: "removeItem",
+    value: function removeItem(key) {
+      __classPrivateFieldGet(this, _Storage_storage, "f").removeItem(key);
+    }
+  }, {
+    key: "setItem",
+    value: function setItem(key, data) {
+      __classPrivateFieldGet(this, _Storage_storage, "f").setItem(key, data);
+    }
+  }]);
+}();
+_Storage_storage = new WeakMap();
+Storage.supportsSession = typeof ((_globalThis$sessionSt = globalThis.sessionStorage) === null || _globalThis$sessionSt === void 0 ? void 0 : _globalThis$sessionSt.setItem) === 'undefined';
+exports["default"] = Storage;

package/package.json

@@ -45,6 +45,7 @@
     "lodash.isequal": "^4.5.0",
     "lodash.isplainobject": "^4.0.6",
     "lodash.omit": "^4.5.0",
+    "lodash.set": "^4.3.2",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
     "react-performance-testing": "^2.0.0",
@@ -55,20 +56,7 @@
   },
   "files": [
     "logo.png",
-    "dist\\main\\hooks\\use-store\\index.js",
-    "dist\\main\\hooks\\use-store\\index.d.ts",
-    "dist\\main\\hooks\\use-render-key-provider\\index.js",
-    "dist\\main\\hooks\\use-render-key-provider\\index.d.ts",
-    "dist\\main\\hooks\\use-prehooks-ref\\index.js",
-    "dist\\main\\hooks\\use-prehooks-ref\\index.d.ts",
-    "dist\\model\\storage\\index.js",
-    "dist\\model\\storage\\index.d.ts",
-    "dist\\main\\index.js",
-    "dist\\main\\index.d.ts",
-    "dist\\index.js",
-    "dist\\index.d.ts",
-    "dist\\constants.js",
-    "dist\\constants.d.ts"
+    "dist"
   ],
   "homepage": "https://eagleeye.js.org",
   "keywords": [
@@ -102,6 +90,7 @@
     "lodash.isequal": ">= 0.1.0",
     "lodash.isplainobject": ">= 0.8.0",
     "lodash.omit": ">= 0.1.0",
+    "lodash.set": ">= 0.1.0",
     "react": ">= 16.8.0 <19"
   },
   "publishConfig": {
@@ -113,15 +102,14 @@
   },
   "scripts": {
     "build": "eslint --fix && rm -rf dist && tsc && babel dist -d dist",
-    "postbuild": "node ./post-build",
     "test": "eslint --fix && jest --coverage --updateSnapshot",
     "test:clean": "jest --clearCache",
     "test:core": "jest --updateSnapshot",
     "test:watch": "eslint --fix && jest --updateSnapshot --watchAll"
   },
   "types": "dist/index.d.ts",
-  "version": "6.0.0-rc.2",
+  "version": "6.0.0-rc.3",
   "dependencies": {
     "@webkrafters/auto-immutable": "^2.0.0-rc.10"
   }
-}
+}