@webkrafters/react-observable-context 3.0.0-rc.1 → 4.0.0-alpha.0

package/dist/main/hooks/use-render-keys-manager/index.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.NULL_STATE_SELECTOR = exports.FULL_STATE_SELECTOR = void 0;
+var _react = require("react");
+var _lodash = _interopRequireDefault(require("lodash.isempty"));
+var _lodash2 = _interopRequireDefault(require("lodash.isequal"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+var FULL_STATE_SELECTOR = '@@STATE';
+exports.FULL_STATE_SELECTOR = FULL_STATE_SELECTOR;
+var NULL_STATE_SELECTOR = '';
+exports.NULL_STATE_SELECTOR = NULL_STATE_SELECTOR;
+/**
 * @param {string[]} renderKeys
 * @returns {string[]}
 */
+var useRenderKeysManager = function useRenderKeysManager(renderKeys) {
+  var curKeys = (0, _react.useRef)([]);
+  var managedKeys = (0, _react.useMemo)(function () {
+    if (!(0, _lodash2["default"])(curKeys.current, renderKeys)) {
+      curKeys.current = renderKeys;
+    }
+    return curKeys.current;
+  }, [renderKeys]);
+  return (0, _react.useMemo)(function () {
+    var selectors = Array.isArray(managedKeys) ? Array.from(new Set(managedKeys)) : [];
+    if ((0, _lodash["default"])(selectors)) {
+      selectors[0] = NULL_STATE_SELECTOR;
+    } else if (managedKeys.includes(FULL_STATE_SELECTOR)) {
+      selectors.length = 0;
+    }
+    return selectors;
+  }, [managedKeys]);
+};
+var _default = useRenderKeysManager;
+exports["default"] = _default;

package/dist/main/hooks/use-state-manager/index.d.ts

@@ -0,0 +1 @@
+export default useStateManager;
 * @param {T} initStateValue
 * @template {State} T
 */
    select: (clientId: string, ...propertyPaths?: string[]) => Readonly<import("../../../types").PartialState<T>>;
    state: T;
    stateWatch: Listener<T>;
    unlink: (clientId: string) => void;

package/dist/main/hooks/use-state-manager/index.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _react = require("react");
+var _lodash = _interopRequireDefault(require("lodash.clonedeep"));
+var _accessorCache = _interopRequireDefault(require("../../../model/accessor-cache"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _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(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+function _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0) { ; } } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i["return"] && (_r = _i["return"](), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+/**
 * @param {T} initStateValue
 * @template {State} T
 */
+var useStateManager = function useStateManager(initStateValue) {
+  /** @type {[T, Function]} */
+  var _useState = (0, _react.useState)(function () {
+      return (0, _lodash["default"])(initStateValue);
+    }),
+    _useState2 = _slicedToArray(_useState, 1),
+    state = _useState2[0];
+  /** @type {[AccessorCache<T>, Function]} */
+  var _useState3 = (0, _react.useState)(function () {
+      return new _accessorCache["default"](state);
+    }),
+    _useState4 = _slicedToArray(_useState3, 1),
+    cache = _useState4[0];
+  /** @type {StoreInternal<T>["getState"]} */
+  var select = (0, _react.useCallback)(cache.get.bind(cache), []);
+  /** @type {Listener<T>} */
+  var stateWatch = (0, _react.useCallback)(cache.watchSource.bind(cache), []);
+  /** @type {StoreInternal<T>["unlinkCache"]} */
+  var unlink = (0, _react.useCallback)(function (clientId) {
+    return cache.unlinkClient(clientId);
+  }, []);
+  return (0, _react.useState)(function () {
+    return {
+      select: select,
+      state: state,
+      stateWatch: stateWatch,
+      unlink: unlink
+    };
+  })[0];
+};
+var _default = useStateManager;
+exports["default"] = _default;

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

@@ -0,0 +1 @@
+export namespace deps {
    export { _setState as setState };
    export { v4 as uuid };
 * @param {Prehooks<T>} prehooks
 * @param {T} value
 * @param {IStorage<T>} [storage] Closed to modification post-initialization
 * @template {State} T
 */
    getState: (clientId: string, ...propertyPaths?: string[]) => Readonly<import("../../../types").PartialState<T>>;
    resetState: VoidFunction;
    setState: (changes: import("../../../types").PartialState<T>) => void;
    subscribe: (listener: import("../../../types").Listener<T>) => VoidFunction;
    unlinkCache: (clientId: string) => void;

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

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.deps = exports["default"] = void 0;
+var _react = require("react");
+var _lodash = _interopRequireDefault(require("lodash.clonedeep"));
+var _uuid = require("uuid");
+var _storage2 = _interopRequireDefault(require("../../../model/storage"));
+var _usePrehooksRef = _interopRequireDefault(require("../use-prehooks-ref"));
+var _useStateManager2 = _interopRequireDefault(require("../use-state-manager"));
+var _setState2 = _interopRequireDefault(require("../../set-state"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _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(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+function _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0) { ; } } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i["return"] && (_r = _i["return"](), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+var deps = {
+  setState: _setState2["default"],
+  uuid: _uuid.v4
+};
+exports.deps = deps;
+/**
 * @param {Prehooks<T>} prehooks
 * @param {T} value
 * @param {IStorage<T>} [storage] Closed to modification post-initialization
 * @template {State} T
 */
+var useStore = function useStore(prehooks, value, storage) {
+  var mounted = (0, _react.useRef)(false);
+  var prehooksRef = (0, _usePrehooksRef["default"])(prehooks);
+  /** @type {MutableRefObject<string>} */
+  var storageKey = (0, _react.useRef)();
+  var _useStateManager = (0, _useStateManager2["default"])(value),
+    select = _useStateManager.select,
+    state = _useStateManager.state,
+    stateWatch = _useStateManager.stateWatch,
+    unlink = _useStateManager.unlink;
+  /** @type {[Set<Listener<T>>, Function]} */
+  var _useState = (0, _react.useState)(function () {
+      return new Set();
+    }),
+    _useState2 = _slicedToArray(_useState, 1),
+    listeners = _useState2[0];
+  /** @type {[IStorage<T>, Function]} */
+  var _useState3 = (0, _react.useState)(function () {
+      var isKeyRequired = true;
+      var _storage = storage;
+      if (!storage) {
+        _storage = new _storage2["default"]();
+        isKeyRequired = _storage.isKeyRequired;
+      }
+      storageKey.current = isKeyRequired ? "".concat(deps.uuid(), ":").concat(Date.now(), ":").concat(Math.random()) : null;
+      return _storage;
+    }),
+    _useState4 = _slicedToArray(_useState3, 1),
+    _storage = _useState4[0];
+  /** @type {Listener<T>} */
+  var onChange = function onChange(state) {
+    return listeners.forEach(function (listener) {
+      return listener(state);
+    });
+  };
+  /** @type {StoreInternal<T>["resetState"]} */
+  var resetState = (0, _react.useCallback)(function () {
+    var original = _storage.getItem(storageKey.current);
+    (!('resetState' in prehooksRef.current) || prehooksRef.current.resetState({
+      current: (0, _lodash["default"])(state),
+      original: original
+    })) && deps.setState(state, original, onChange);
+  }, []);
+  /** @type {StoreInternal<T>["setState"]} */
+  var setState = (0, _react.useCallback)(function (changes) {
+    changes = (0, _lodash["default"])(changes);
+    (!('setState' in prehooksRef.current) || prehooksRef.current.setState(changes)) && deps.setState(state, changes, onChange);
+  }, []);
+  /** @type {StoreInternal<T>["subscribe"]} */
+  var subscribe = (0, _react.useCallback)(function (listener) {
+    listeners.add(listener);
+    return function () {
+      return listeners["delete"](listener);
+    };
+  }, []);
+  (0, _react.useEffect)(function () {
+    var sKey = storageKey.current;
+    _storage.setItem(sKey, value);
+    return function () {
+      return _storage.removeItem(sKey);
+    };
+  }, []);
+  (0, _react.useEffect)(function () {
+    if (!mounted.current) {
+      mounted.current = true;
+      return;
+    }
+    setState((0, _lodash["default"])(value));
+  }, [value]);
+  (0, _react.useEffect)(function () {
+    if (!listeners.size) {
+      listeners.add(stateWatch);
+    } else {
+      var newList = Array.from(listeners);
+      newList.unshift(stateWatch);
+      listeners.clear();
+      newList.forEach(function (l) {
+        listeners.add(l);
+      });
+    }
+    return function () {
+      return listeners["delete"](stateWatch);
+    };
+  }, [stateWatch]);
+  return (0, _react.useState)(function () {
+    return {
+      getState: select,
+      resetState: resetState,
+      setState: setState,
+      subscribe: subscribe,
+      unlinkCache: unlink
+    };
+  })[0];
+};
+var _default = useStore;
+exports["default"] = _default;

package/dist/main/index.d.ts

@@ -0,0 +1 @@
+export class UsageError extends Error {
    Provider: ObservableProvider<S>;
    children?: ReactNode;
    prehooks?: Prehooks<T>;
    storage?: IStorage<T>;
    value: PartialState<T>;

package/dist/main/index.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useContext = exports.createContext = exports.UsageError = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _lodash = _interopRequireDefault(require("lodash.isequal"));
+var _lodash2 = _interopRequireDefault(require("lodash.omit"));
+var _uuid = require("uuid");
+var _useRenderKeysManager = _interopRequireDefault(require("./hooks/use-render-keys-manager"));
+var _useStore = _interopRequireDefault(require("./hooks/use-store"));
+var _excluded = ["getState", "subscribe", "unlinkCache"];
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _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(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _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(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+function _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0) { ; } } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i["return"] && (_r = _i["return"](), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
+function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct.bind(); } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+var UsageError = function (_Error) {
+  _inherits(UsageError, _Error);
+  var _super = _createSuper(UsageError);
+  function UsageError() {
+    _classCallCheck(this, UsageError);
+    return _super.apply(this, arguments);
+  }
+  return _createClass(UsageError);
+}( _wrapNativeSuper(Error));
+exports.UsageError = UsageError;
+/**
 * @readonly
 * @type {Prehooks<T>}
 * @template {State} T
 */
+var defaultPrehooks = Object.freeze({});
+/** @type {NonReactUsageReport} */
+var reportNonReactUsage = function reportNonReactUsage() {
+  throw new UsageError('Detected usage outside of this context\'s Provider component tree. Please apply the exported Provider component');
+};
+/** @type {FC<{child: ReactNode}>} */
+var ChildMemo = function () {
+  var useNodeMemo = function useNodeMemo(node) {
+    var nodeRef = (0, _react.useRef)(node);
+    if (!(0, _lodash["default"])((0, _lodash2["default"])(nodeRef.current, '_owner'), (0, _lodash2["default"])(node, '_owner'))) {
+      nodeRef.current = node;
+    }
+    return nodeRef.current;
+  };
+  var ChildMemo = (0, _react.memo)(function (_ref) {
+    var child = _ref.child;
+    return child;
+  });
+  ChildMemo.displayName = 'ObservableContext.Provider.Internal.Guardian.ChildMemo';
+  var Guardian = function Guardian(_ref2) {
+    var child = _ref2.child;
+    return _react["default"].createElement(ChildMemo, {
+      child: useNodeMemo(child)
+    });
+  };
+  Guardian.displayName = 'ObservableContext.Provider.Internal.Guardian';
+  return Guardian;
+}();
+/** @type {(children: ReactNode) => ReactNode} */
+var memoizeImmediateChildTree = function memoizeImmediateChildTree(children) {
+  return _react.Children.map(children, function (child) {
+    var _child$props;
+    if (_typeof(child.type) === 'object' && 'compare' in child.type) {
+      return child;
+    }
+    if ((_child$props = child.props) !== null && _child$props !== void 0 && _child$props.children) {
+      child = (0, _react.cloneElement)(child, (0, _lodash2["default"])(child.props, 'children'), memoizeImmediateChildTree(child.props.children));
+    }
+    return _react["default"].createElement(ChildMemo, {
+      child: child
+    });
+  });
+};
+/** @param {Provider<IStore>} Provider */
+var makeObservable = function makeObservable(Provider) {
+  /**
   * @type {ObservableProvider<T>}
   * @template {State} T
   */
+  var Observable = function Observable(_ref3) {
+    var _ref3$children = _ref3.children,
+      children = _ref3$children === void 0 ? null : _ref3$children,
+      _ref3$prehooks = _ref3.prehooks,
+      prehooks = _ref3$prehooks === void 0 ? defaultPrehooks : _ref3$prehooks,
+      _ref3$storage = _ref3.storage,
+      storage = _ref3$storage === void 0 ? null : _ref3$storage,
+      value = _ref3.value;
+    return _react["default"].createElement(Provider, {
+      value: (0, _useStore["default"])(prehooks, value, storage)
+    }, memoizeImmediateChildTree(children));
+  };
+  Observable.displayName = 'ObservableContext.Provider';
+  return Observable;
+};
+/**
 * @returns {ObservableContext<T>} Refers to the IObservableContext<T> type of the ObservableContext<T>
 * @template {State} T
 * @see {ObservableContext<T>}
 */
+var createContext = function createContext() {
+  var Context = (0, _react.createContext)({
+    getState: reportNonReactUsage,
+    resetState: reportNonReactUsage,
+    setState: reportNonReactUsage,
+    subscribe: reportNonReactUsage
+  });
+  var provider = Context.Provider;
+  Context.Provider = makeObservable(provider);
+  return Context;
+};
+exports.createContext = createContext;
+/**
 * Actively monitors the store and triggers component re-render if any of the watched keys in the state objects changes
 *
 * @param {ObservableContext<T>} context Refers to the PublicObservableContext<T> type of the ObservableContext<T>
 * @param {Array<string|keyof T>} [renderKeys = []] a list of paths to state object properties used by this component: see examples below. May use `['@@STATE']` to indicate a desire to obtain the entire state object. A change in any of the referenced properties results in this component render. When using `['@@STATE']`, any change in the state object results in this component render.
 * @returns {Store<T>}
 * @template {State} T
 * @see {ObservableContext<T>}
 * @example
 * a valid renderKey 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 a valid renderKey
 * 'a' => 1
 * 'd' => { e: 5, f: [6, { x: 7, y: 8, z: 9 } ] }
 * 'd.e' => 5
 * 'd.e.f => [6, { x: 7, y: 8, z: 9 } ]
 * 'd.e.f[0]' or 'd.e.f.0' => 6
 * 'd.e.f[1]' or 'd.e.f.1' => { x: 7, y: 8, z: 9 }
 * 'd.e.f[1].x' or 'd.e.f.1.x' => 7
 * '@@STATE' => state
 */
+var useContext = function useContext(context) {
+  var renderKeys = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  /** @type {StoreInternal<T>} */
+  var _useContext2 = (0, _react.useContext)(context),
+    _getState = _useContext2.getState,
+    subscribe = _useContext2.subscribe,
+    unlinkCache = _useContext2.unlinkCache,
+    store = _objectWithoutProperties(_useContext2, _excluded);
+  var _useState = (0, _react.useState)(_uuid.v4),
+    _useState2 = _slicedToArray(_useState, 1),
+    clientId = _useState2[0];
+  var _renderKeys = (0, _useRenderKeysManager["default"])(renderKeys);
+  /** @returns {Readonly<PartialState<T>>} */
+  var getState = function getState() {
+    return _getState.apply(void 0, [clientId].concat(_toConsumableArray(_renderKeys)));
+  };
+  var _useState3 = (0, _react.useState)(getState),
+    _useState4 = _slicedToArray(_useState3, 2),
+    data = _useState4[0],
+    setData = _useState4[1];
+  (0, _react.useMemo)(function () {
+    return setData(getState());
+  }, [_renderKeys]);
+  (0, _react.useEffect)(function () {
+    return subscribe(function () {
+      return setData(getState());
+    });
+  }, [_renderKeys]);
+  (0, _react.useEffect)(function () {
+    return function () {
+      return unlinkCache(clientId);
+    };
+  }, []);
+  return (0, _react.useMemo)(function () {
+    return _objectSpread({
+      data: data
+    }, store);
+  }, [data]);
+};
+exports.useContext = useContext;

package/dist/main/set-state/index.d.ts

@@ -0,0 +1 @@
+export default setState;
    [rootKey: number]: {
        [x: string]: any;
    };
    [x: string]: any;
    [rootKey: string]: {
        [x: string]: any;
    };
    [rootKey: symbol]: {
        [x: string]: any;
    };
    [rootKey: number]: T;
    [rootKey: string]: T;
    [rootKey: symbol]: T;
    hasChanges: boolean;
 * @param {T} state
 * @param {PartialState<T>} newState
 * @param {Listener<T>} [onStateChange]
 * @template {State} T
 */

package/dist/main/set-state/index.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _lodash = _interopRequireDefault(require("lodash.clonedeep"));
+var _lodash2 = _interopRequireDefault(require("lodash.isequal"));
+var _lodash3 = _interopRequireDefault(require("lodash.isplainobject"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, 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 normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _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(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+/** @param {{[x:string]: any}} obj */
+var isIndexBasedObj = function isIndexBasedObj(obj) {
+  return Object.keys(obj).every(function (k) {
+    var i = +k;
+    return Number.isInteger(i) && i > -1;
+  });
+};
+/**
 * Mutates its arguments
 *
 * @param {HasArrayRoot<K>|HasObjectRoot<K>} state
 * @param {HasArrayRoot<K>|HasObjectRoot<K>} newState
 * @param {K} stateKey
 * @param {Stats} stats
 * @template {KeyTypes} K
 */
+function setAtomic(state, newState, stateKey, stats) {
+  if ((0, _lodash2["default"])(state[stateKey], newState[stateKey])) {
+    return;
+  }
+  var isPlainObjectNewState = (0, _lodash3["default"])(newState[stateKey]);
+  var isArrayNewState = Array.isArray(newState[stateKey]);
+  if (Array.isArray(state[stateKey])) {
+    if (isArrayNewState) {
+      return setArray(state, newState, stateKey, stats);
+    }
+    if (isPlainObjectNewState && isIndexBasedObj(newState[stateKey])) {
+      return setArrayIndex(state, newState, stateKey, stats);
+    }
+  }
+  if (isPlainObjectNewState && (0, _lodash3["default"])(state[stateKey])) {
+    return setPlainObject(state, newState, stateKey, stats);
+  }
+  stats.hasChanges = true;
+  state[stateKey] = isArrayNewState || isPlainObjectNewState ? (0, _lodash["default"])(newState[stateKey]) : newState[stateKey];
+}
+;
+/**
 * Mutates its arguments
 *
 * @param {HasArrayRoot<K>} state
 * @param {HasArrayRoot<K>} newState
 * @param {K} rootKey
 * @param {Stats} stats
 * @template {KeyTypes} K
 */
+function setArray(state, newState, rootKey, stats) {
+  var nsLength = newState[rootKey].length;
+  if (state[rootKey].length !== nsLength) {
+    state[rootKey].length = nsLength;
+    stats.hasChanges = true;
+  }
+  for (var i = 0; i < nsLength; i++) {
+    setAtomic(state[rootKey], newState[rootKey], i, stats);
+  }
+}
+;
+/**
 * Mutates its arguments
 *
 * @param {HasArrayRoot<K>} state
 * @param {HasObjectRoot<K>} newState
 * @param {K} rootKey
 * @param {Stats} stats
 * @template {KeyTypes} K
 */
+function setArrayIndex(state, newState, rootKey, stats) {
+  var incomingIndexes = Object.keys(newState[rootKey]).map(function (i) {
+    return +i;
+  });
+  var maxIncomingIndex = Math.max.apply(Math, _toConsumableArray(incomingIndexes));
+  if (maxIncomingIndex >= state[rootKey].length) {
+    state[rootKey].length = maxIncomingIndex + 1;
+    stats.hasChanges = true;
+  }
+  var _iterator = _createForOfIteratorHelper(incomingIndexes),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var i = _step.value;
+      setAtomic(state[rootKey], newState[rootKey], i, stats);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+}
+;
+/**
 * Mutates its arguments
 *
 * @param {HasObjectRoot<K>} state
 * @param {HasObjectRoot<K>} newState
 * @param {K} rootKey
 * @param {Stats} stats
 * @template {KeyTypes} K
 */
+function setPlainObject(state, newState, rootKey, stats) {
+  set(state[rootKey], newState[rootKey], stats);
+}
+;
+/**
 * Mutates its arguments
 *
 * @param {HasObjectRoot} state
 * @param {HasObjectRoot} newState
 * @param {Stats} stats
 */
+function set(state, newState, stats) {
+  for (var k in newState) {
+    setAtomic(state, newState, k, stats);
+  }
+}
+;
+/**
 * @param {T} state
 * @param {PartialState<T>} newState
 * @param {Listener<T>} [onStateChange]
 * @template {State} T
 */
+function setState(state, newState, onStateChange) {
+  var stats = {
+    hasChanges: false
+  };
+  set(state, newState, stats);
+  stats.hasChanges && (onStateChange === null || onStateChange === void 0 ? void 0 : onStateChange(state));
+}
+;
+var _default = setState;
+exports["default"] = _default;

package/dist/model/accessor-cache/index.d.ts

@@ -0,0 +1 @@
+export default AccessorCache;
    /** @param {T} origin State object reference from which slices stored in this cache are to be curated */
    constructor(origin: T);
    /**
     * Gets state slice from the cache matching the `propertyPaths`.\
     * If not found, creates a new entry for the client from source, and returns it.
     *
     * @param {string} clientId
     * @param {...string} propertyPaths
     * @return {Readonly<PartialState<T>>}
     */
    get(clientId: string, ...propertyPaths: string[]): Readonly<PartialState<T>>;
    /**
     * Unlinks a consumer from the cache: performing synchronized state cleanup
     *
     * @param {string} clientId
     */
    unlinkClient(clientId: string): void;
    /** Observes the origin state bearing ObservableContext store for state changes to update accessors. */
    watchSource(): void;
    #private;