@webkrafters/react-observable-context 4.4.3 → 4.5.0-rc

package/README.md

@@ -342,6 +342,7 @@ Routinely, the `value` prop is initialized with the full initial state. It may o
 
 <h2 id="selector-map">Selector Map</h2>
 A selector map is an object holding key:value pairs.<br />
+<i><b>An array of <a href="#property-path">property paths</a> is also acceptable:</b> indexes serve as keys for this purpose.</i><br />
 <span style="margin-right: 10px">-</span><code>key</code> refers to an arbitrary name to be assigned to a given property in the <a href="#store"><code>store.data</code></a>.<br />
 <span style="margin-right: 10px">-</span><code>value</code> refers to the <a href="#property-path">property path</a> leading to a state slice whose value will be assigned to and observed by this <a href="#store"><code>store.data</code></a> property.<br />
 <span style="margin-right: 10px">-</span>A special '<a href="#fullstate-selectorkey">@@STATE</a>' value may be used to access and observe the full state object.<br />
@@ -361,7 +362,9 @@ const state = {
   }
 };
 
-// a client observing the following selector map
+/* --------------------------------------------- */
+/* a client observing the following selector map */
+/* --------------------------------------------- */
 const selectorMap = {
   all: '@@STATE',
   myData: 'd',
@@ -373,7 +376,20 @@ store.data = {
   all: state,
   myData: state.d,
   secondFElement: state.d.f[1]
-}
+};
+
+/* --------------------------------------------------- */
+/* a client observing the following property path list */
+/* --------------------------------------------------- */
+const propertyPaths = [ '@@STATE', 'd', 'd.f[1]' ];
+
+// will receive the following store data
+store.data = {
+  0: state,
+  1: state.d,
+  2: state.d.f[1]
+};
+
 ```
 
 ## Storage

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

@@ -1,6 +1,6 @@
 export default useRenderKeyProvider;
-export type Provider<T extends import("../../../types").State> = (selectorMap: {
-    [selectorKey: string]: string | keyof T;
-}) => [string | keyof T];
+export type Provider<T extends import("../../../types").State, MAP extends BaseSelectorMap<T> = BaseSelectorMap<T>> = (selectorMap: SelectorMap<T, MAP>) => [string | keyof T];
+export type SelectorMap<STATE extends import("../../../types").State = import("../../../types").State, MAP extends BaseSelectorMap<STATE> = BaseSelectorMap<STATE>> = import("../../../types").SelectorMap<STATE>;
+export type BaseSelectorMap<STATE extends import("../../../types").State = import("../../../types").State> = import("../../../types").BaseSelectorMap<STATE>;
 export type State = import("../../../types").State;
-declare const useRenderKeyProvider: Provider<T>;
+declare const useRenderKeyProvider: Provider<T, BaseSelectorMap<T>>;

package/dist/main/index.d.ts

@@ -18,6 +18,10 @@ export function createContext<T extends import("../types").State>(): ObservableC
  * 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

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

@@ -16,6 +16,86 @@ function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _ty
 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); }
 var _default = setState;
 exports["default"] = _default;
+var setAtomic = function () {
+  var toStringProto = Object.prototype.toString;
+  var getCompositeDesc = function getCompositeDesc(value) {
+    return Array.isArray(value) ? 'ARRAY' : (0, _lodash2["default"])(value) ? 'OBJECT' : undefined;
+  };
+  var finalizeAtomicSet = function finalizeAtomicSet(state, changes, stateKey) {
+    var compositeChangeDesc = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : undefined;
+    var change = changes[stateKey];
+    if (!compositeChangeDesc) {
+      if (!(0, _tagFunctions.isClosedTag)(change)) {
+        state[stateKey] = change;
+        return;
+      }
+    } else if (compositeChangeDesc === 'ARRAY') {
+      state[stateKey] = [];
+    } else if (compositeChangeDesc === 'OBJECT') {
+      if (isIndexBasedObj(change)) {
+        state[stateKey] = [];
+      } else {
+        var newState = {};
+        for (var k in change) {
+          var childChange = change[k];
+          if (toStringProto.call(childChange) === '[object String]') {
+            newState[k] = childChange;
+            continue;
+          }
+          var hasProps = false;
+          for (var p in childChange !== null && childChange !== void 0 ? childChange : {}) {
+            hasProps = true;
+            break;
+          }
+          if (!hasProps) {
+            newState[k] = childChange;
+          } else if (isArrayTaggedPayload(childChange)) {
+            newState[k] = [];
+          }
+        }
+        state[stateKey] = newState;
+      }
+    }
+    return setAtomic(state, changes, stateKey);
+  };
+  var setAtomic = function setAtomic(state, changes, stateKey) {
+    var stats = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {
+      hasChanges: false
+    };
+    if ((0, _lodash["default"])(state[stateKey], changes[stateKey])) {
+      return;
+    }
+    var tagsResolved = resolveTags(state, changes, stateKey, stats);
+    var compositeChangeDesc = getCompositeDesc(changes[stateKey]);
+    if (Array.isArray(state[stateKey])) {
+      if (compositeChangeDesc === 'ARRAY') {
+        return setArray(state, changes, stateKey, stats);
+      }
+      if (compositeChangeDesc === 'OBJECT' && isIndexBasedObj(changes[stateKey])) {
+        return setArrayIndex(state, changes, stateKey, stats);
+      }
+    }
+    if (compositeChangeDesc === 'OBJECT' && (0, _lodash2["default"])(state[stateKey])) {
+      return setPlainObject(state, changes, stateKey, stats);
+    }
+    if (tagsResolved.length || !(stateKey in changes)) {
+      return;
+    }
+    ;
+    stats.hasChanges = true;
+    finalizeAtomicSet(state, changes, stateKey, compositeChangeDesc);
+  };
+  return setAtomic;
+}();
+function isArrayTaggedPayload(payload) {
+  for (var k in payload) {
+    if (!(0, _tagFunctions.isArrayOnlyTag)(k)) {
+      return false;
+    }
+  }
+  return true;
+}
+;
 function isIndexBasedObj(obj) {
   for (var k in obj) {
     if (!(k in _tagFunctions["default"] || Number.isInteger(+k))) {
@@ -32,6 +112,9 @@ function resolveTags(state, changes, stateKey, stats) {
   if (!(0, _utils.isDataContainer)(changes[stateKey])) {
     return resolvedTags;
   }
+  if (!(stateKey in state) && isArrayTaggedPayload(changes[stateKey])) {
+    state[stateKey] = [];
+  }
   for (var k in changes[stateKey]) {
     if (!(stateKey in changes)) {
       break;
@@ -82,31 +165,6 @@ function setArrayIndex(state, changes, rootKey, stats) {
     setAtomic(state[rootKey], changes[rootKey], i, stats);
   }
 }
-function setAtomic(state, changes, stateKey, stats) {
-  if ((0, _lodash["default"])(state[stateKey], changes[stateKey])) {
-    return;
-  }
-  var tagsResolved = resolveTags(state, changes, stateKey, stats);
-  var isPlainObjectNewState = (0, _lodash2["default"])(changes[stateKey]);
-  var isArrayNewState = Array.isArray(changes[stateKey]);
-  if (Array.isArray(state[stateKey])) {
-    if (isArrayNewState) {
-      return setArray(state, changes, stateKey, stats);
-    }
-    if (isPlainObjectNewState && isIndexBasedObj(changes[stateKey])) {
-      return setArrayIndex(state, changes, stateKey, stats);
-    }
-  }
-  if (isPlainObjectNewState && (0, _lodash2["default"])(state[stateKey])) {
-    return setPlainObject(state, changes, stateKey, stats);
-  }
-  if (tagsResolved.length || !(stateKey in changes)) {
-    return;
-  }
-  ;
-  stats.hasChanges = true;
-  state[stateKey] = isArrayNewState || isPlainObjectNewState ? (0, _utils.clonedeep)(changes[stateKey]) : changes[stateKey];
-}
 function setPlainObject(state, changes, rootKey, stats) {
   set(state[rootKey], changes[rootKey], stats);
 }

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

@@ -10,6 +10,7 @@ export function $set(state: T, stateKey: K, stats: Stats, changes: (import("../.
 }; })): void;
 export const $splice: TagFunction<T, K, import("../../../types").SpliceCommand>;
 export default tagMap;
+export const isArrayOnlyTag: (tag: TagKey | BaseType) => boolean;
 export const isClosedTag: (tag: TagKey | BaseType) => boolean;
 export type TagKey = keyof typeof tagMap;
 export type TagFunction<T extends any[] | import("../../../types").State, K extends keyof T, TAG extends {

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

@@ -3,7 +3,7 @@ function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" =
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.isClosedTag = exports["default"] = exports.$splice = exports.$set = exports.$replace = exports.$push = exports.$move = exports.$delete = exports.$clear = void 0;
+exports.isClosedTag = exports.isArrayOnlyTag = exports["default"] = exports.$splice = exports.$set = exports.$replace = exports.$push = exports.$move = exports.$delete = exports.$clear = void 0;
 var _lodash = _interopRequireDefault(require("lodash.isempty"));
 var _lodash2 = _interopRequireDefault(require("lodash.isequal"));
 var _lodash3 = _interopRequireDefault(require("lodash.isplainobject"));
@@ -287,10 +287,21 @@ exports.$splice = $splice;
 var tagMap = (_tagMap = {}, _defineProperty(_tagMap, _constants.CLEAR_TAG, $clear), _defineProperty(_tagMap, _constants.DELETE_TAG, $delete), _defineProperty(_tagMap, _constants.MOVE_TAG, $move), _defineProperty(_tagMap, _constants.PUSH_TAG, $push), _defineProperty(_tagMap, _constants.REPLACE_TAG, $replace), _defineProperty(_tagMap, _constants.SET_TAG, $set), _defineProperty(_tagMap, _constants.SPLICE_TAG, $splice), _tagMap);
 var _default = tagMap;
 exports["default"] = _default;
+var containsTag = function containsTag(tagsMap, tag) {
+  return tag in tagsMap && !Array.isArray(tag);
+};
+var isArrayOnlyTag = function () {
+  var _ARRAY_TAGS;
+  var ARRAY_TAGS = (_ARRAY_TAGS = {}, _defineProperty(_ARRAY_TAGS, _constants.MOVE_TAG, null), _defineProperty(_ARRAY_TAGS, _constants.PUSH_TAG, null), _defineProperty(_ARRAY_TAGS, _constants.SPLICE_TAG, null), _ARRAY_TAGS);
+  return function (tag) {
+    return containsTag(ARRAY_TAGS, tag);
+  };
+}();
+exports.isArrayOnlyTag = isArrayOnlyTag;
 var isClosedTag = function () {
   var NO_PARAM_TAGS = _defineProperty({}, _constants.CLEAR_TAG, null);
   return function (tag) {
-    return tag in NO_PARAM_TAGS && !Array.isArray(tag);
+    return containsTag(NO_PARAM_TAGS, tag);
   };
 }();
 exports.isClosedTag = isClosedTag;

package/dist/model/atom/index.js

@@ -17,6 +17,17 @@ function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) {
 function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
 function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
 function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } }
+var isFunction = function () {
+  var toString = Function.prototype.toString;
+  var is = function is(v) {
+    try {
+      return toString.call(v);
+    } catch (e) {
+      return false;
+    }
+  };
+  return is;
+}();
 var _connections = new WeakMap();
 var _value = new WeakMap();
 var Atom = function () {
@@ -59,7 +70,7 @@ var Atom = function () {
   }, {
     key: "setValue",
     value: function setValue(newValue) {
-      _classPrivateFieldSet(this, _value, (0, _utils.makeReadonly)((0, _utils.clonedeep)(newValue)));
+      _classPrivateFieldSet(this, _value, !isFunction(newValue) ? (0, _utils.makeReadonly)((0, _utils.clonedeep)(newValue)) : newValue);
     }
   }]);
   return Atom;

package/dist/types.d.ts

@@ -1,10 +1,10 @@
 declare const _default: any;
 export default _default;
-export type BaseSelectorMap<T extends State> = {
+export type BaseSelectorMap<T extends State> = (string | keyof T)[] | ({
     [dataPropKey: string]: string | keyof T;
 } & {
     [dataPropKey: string]: "@@STATE";
-};
+});
 export type BaseType = boolean | any[] | {
     [x: string]: any;
 } | KeyType;

package/package.json

@@ -133,5 +133,5 @@
     "test:watch": "eslint --fix && jest --updateSnapshot --watchAll"
   },
   "types": "dist/main/index.d.ts",
-  "version": "4.4.3"
+  "version": "4.5.0-rc"
 }