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

package/dist/index.js

@@ -1,389 +0,0 @@
-"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.clonedeep"));
-var _lodash2 = _interopRequireDefault(require("lodash.has"));
-var _lodash3 = _interopRequireDefault(require("lodash.isempty"));
-var _lodash4 = _interopRequireDefault(require("lodash.isequal"));
-var _lodash5 = _interopRequireDefault(require("lodash.isplainobject"));
-var _lodash6 = _interopRequireDefault(require("lodash.omit"));
-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 _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 _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 = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-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, 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 _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 = /*#__PURE__*/function (_Error) {
-  _inherits(UsageError, _Error);
-  var _super = _createSuper(UsageError);
-  function UsageError() {
-    _classCallCheck(this, UsageError);
-    return _super.apply(this, arguments);
-  }
-  return _createClass(UsageError);
-}( /*#__PURE__*/_wrapNativeSuper(Error));
-/**
- * @param {T} state
- * @return {PartialState<T>}
- * @template {State} T
- */
-exports.UsageError = UsageError;
-var defaultSelector = function defaultSelector(state) {
-  return state;
-};
-
-/**
- * @readonly
- * @type {Prehooks<T>}
- * @template {State} T
- */
-var defaultPrehooks = Object.freeze({});
-
-/** @type {OptionalTask} */
-var reportNonReactUsage = function reportNonReactUsage() {
-  throw new UsageError('Detected usage outside of this context\'s Provider component tree. Please apply the exported Provider component');
-};
-var _setState = function () {
-  var initDiff = function initDiff(propKey, changed, replaced) {
-    changed[propKey] = {};
-    replaced[propKey] = {};
-  };
-  var setAtomic = function setAtomic(state, newState, changed, replaced, stateKey) {
-    if ((0, _lodash4["default"])(state[stateKey], newState[stateKey])) {
-      return;
-    }
-    var isArrayNewState = Array.isArray(newState[stateKey]);
-    if (Array.isArray(state[stateKey]) && isArrayNewState) {
-      return setArray(state, newState, changed, replaced, stateKey);
-    }
-    var isPlainObjectNewState = (0, _lodash5["default"])(newState[stateKey]);
-    if ((0, _lodash5["default"])(state[stateKey]) && isPlainObjectNewState) {
-      return setPlainObject(state, newState, changed, replaced, stateKey);
-    }
-    if (stateKey in state) {
-      replaced[stateKey] = state[stateKey];
-    }
-    state[stateKey] = isArrayNewState || isPlainObjectNewState ? (0, _lodash["default"])(newState[stateKey]) : newState[stateKey];
-    changed[stateKey] = newState[stateKey];
-  };
-  var setArray = function setArray(state, newState, changed, replaced, rootKey) {
-    initDiff(rootKey, changed, replaced);
-    for (var i = 0, len = newState[rootKey].length; i < len; i++) {
-      setAtomic(state[rootKey], newState[rootKey], changed[rootKey], replaced[rootKey], i);
-    }
-  };
-  var setPlainObject = function setPlainObject(state, newState, changed, replaced, rootKey) {
-    initDiff(rootKey, changed, replaced);
-    set(state[rootKey], newState[rootKey], changed[rootKey], replaced[rootKey]);
-  };
-  var set = function set(state, newState) {
-    var changed = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-    var replaced = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
-    for (var k in newState) {
-      setAtomic(state, newState, changed, replaced, k);
-    }
-  };
-  /**
-   * @param {T} state
-   * @param {PartialState<T>} newState
-   * @param {Listener<T>} onStateChange
-   * @template {State} T
-   */
-  return function (state, newState, onStateChange) {
-    /** @type {PartialState<T>} */
-    var newChanges = {};
-    /** @type {PartialState<T>} */
-    var replacedValue = {};
-    set(state, newState, newChanges, replacedValue);
-    !(0, _lodash3["default"])(newChanges) && onStateChange(newChanges, replacedValue);
-  };
-}();
-
-/**
- * @param {Prehooks<T>} prehooks
- * @template {State} T
- */
-var usePrehooksRef = function usePrehooksRef(prehooks) {
-  var prehooksRef = (0, _react.useRef)(prehooks);
-  (0, _react.useEffect)(function () {
-    prehooksRef.current = prehooks;
-  }, [prehooks]);
-  return prehooksRef;
-};
-
-/**
- * @param {Prehooks<T>} prehooks
- * @param {T} value
- * @returns {Store<T>}
- * @template {State} T
- */
-var useStore = function useStore(prehooks, value) {
-  var prehooksRef = usePrehooksRef(prehooks);
-  var initialState = (0, _react.useRef)(value);
-
-  /** @type {[Set<Listener<T>>, Function]} */
-  var _useState = (0, _react.useState)(function () {
-      return new Set();
-    }),
-    _useState2 = _slicedToArray(_useState, 1),
-    listeners = _useState2[0];
-  /** @type {[T, Function]} */
-  var _useState3 = (0, _react.useState)(function () {
-      return (0, _lodash["default"])(value);
-    }),
-    _useState4 = _slicedToArray(_useState3, 1),
-    state = _useState4[0];
-
-  /** @type {Listener<T>} */
-  var onChange = function onChange(newValue, oldValue) {
-    return listeners.forEach(function (listener) {
-      return listener(newValue, oldValue);
-    });
-  };
-
-  /** @type {Store<T>["getState"]} */
-  var getState = (0, _react.useCallback)(function () {
-    var selector = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultSelector;
-    var slice = selector(state);
-    return _typeof(slice) === 'object' ? (0, _lodash["default"])(slice) : slice;
-  }, []);
-
-  /** @type {Store<T>["resetState"]} */
-  var resetState = (0, _react.useCallback)(function () {
-    var original = (0, _lodash["default"])(initialState.current);
-    (!('resetState' in prehooksRef.current) || prehooksRef.current.resetState({
-      current: (0, _lodash["default"])(state),
-      original: original
-    })) && _setState(state, original, onChange);
-  }, []);
-
-  /** @type {Store<T>["setState"]} */
-  var setState = (0, _react.useCallback)(function (changes) {
-    changes = (0, _lodash["default"])(changes);
-    (!('setState' in prehooksRef.current) || prehooksRef.current.setState(changes)) && _setState(state, changes, onChange);
-  }, []);
-
-  /** @type {Store<T>["subscribe"]} */
-  var subscribe = (0, _react.useCallback)(function (listener) {
-    listeners.add(listener);
-    return function () {
-      return listeners["delete"](listener);
-    };
-  }, []);
-  (0, _react.useEffect)(function () {
-    return setState((0, _lodash["default"])(value));
-  }, [value]);
-
-  /** @type {[Store<T>, Function]} */
-  var _useState5 = (0, _react.useState)(function () {
-      return {
-        getState: getState,
-        resetState: resetState,
-        setState: setState,
-        subscribe: subscribe
-      };
-    }),
-    _useState6 = _slicedToArray(_useState5, 1),
-    store = _useState6[0];
-  return store;
-};
-
-/** @type {FC<{child: ReactNode}>} */
-var ChildMemo = function () {
-  var useNodeMemo = function useNodeMemo(node) {
-    var nodeRef = (0, _react.useRef)(node);
-    if (!(0, _lodash4["default"])((0, _lodash6["default"])(nodeRef.current, '_owner'), (0, _lodash6["default"])(node, '_owner'))) {
-      nodeRef.current = node;
-    }
-    return nodeRef.current;
-  };
-  var ChildMemo = /*#__PURE__*/(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 /*#__PURE__*/_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;
-    } // memo element
-    if ((_child$props = child.props) !== null && _child$props !== void 0 && _child$props.children) {
-      child = /*#__PURE__*/(0, _react.cloneElement)(child, (0, _lodash6["default"])(child.props, 'children'), memoizeImmediateChildTree(child.props.children));
-    }
-    return /*#__PURE__*/_react["default"].createElement(ChildMemo, {
-      child: child
-    });
-  });
-};
-
-/** @param {Provider<Store<T>>} Provider */
-var makeObservable = function makeObservable(Provider) {
-  /**
-   * @type {FC<{
-   * 		children?: ReactNode,
-   * 		prehooks?: Prehooks<T>
-   * 		value: PartialState<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,
-      value = _ref3.value;
-    return /*#__PURE__*/_react["default"].createElement(Provider, {
-      value: useStore(prehooks, value)
-    }, memoizeImmediateChildTree(children));
-  };
-  Observable.displayName = 'ObservableContext.Provider';
-  return Observable;
-};
-
-/**
- * @returns {ObservableContext<T>}
- * @template {State} T
- */
-var createContext = function createContext() {
-  var Context = /*#__PURE__*/(0, _react.createContext)({
-    getState: reportNonReactUsage,
-    resetState: reportNonReactUsage,
-    setState: reportNonReactUsage,
-    subscribe: reportNonReactUsage
-  });
-  var provider = Context.Provider;
-  Context.Provider = makeObservable(provider);
-  return Context;
-};
-
-/**
- * Actively monitors the store and triggers component re-render if any of the watched keys in the state objects changes
- *
- * @param {ObservableContext<T>} context
- * @param {Array<string|keyof T>} [watchedKeys = []] A list of state object property paths to watch. A change in any of the referenced properties results in this component render.
- * @returns {Store<T>}
- * @template {State} T
- */
-exports.createContext = createContext;
-var useContext = function useContext(context) {
-  var watchedKeys = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
-  /** @type {Store<T>} */
-  var store = (0, _react.useContext)(context);
-  var _useState7 = (0, _react.useState)(false),
-    _useState8 = _slicedToArray(_useState7, 2),
-    tripRender = _useState8[1];
-  var watched = (0, _react.useMemo)(function () {
-    return Array.isArray(watchedKeys) ? Array.from(new Set(watchedKeys)) : [];
-  }, [watchedKeys]);
-  (0, _react.useEffect)(function () {
-    if (!watched.length) {
-      return;
-    }
-    return store.subscribe(function (newChanges) {
-      watched.some(function (w) {
-        return (0, _lodash2["default"])(newChanges, w);
-      }) && tripRender(function (s) {
-        return !s;
-      });
-    });
-  }, [watched]);
-  return store;
-};
-
-/**
- * @typedef {Context<Store<T>>} ObservableContext
- * @template {State} T
- */
-
-/**
- * @typedef {F extends void ? () => never : F} OptionalTask
- * @template [F=void]
- */
-
-/**
- * @typedef {(newValue: PartialState<T>, oldValue: PartialState<T>) => void} Listener
- * @template {State} T
- */
-
-/** @typedef {{[x:string]: *}} State */
-
-/**
- * @typedef {{[x:string]: *} & {[K in keyof T]?: T[K]}} PartialState
- * @template {State} T
- */
-
-/**
- * @typedef {(state: T) => *} Selector
- * @template {State} T
- */
-
-/**
- * @typedef {{
- * 		resetState?: (state: { current: T, original: T}) => boolean,
- * 		setState?: (newChanges: PartialState<T>) => boolean
- * }} Prehooks
- * @template {State} T
- */
-
-/**
- * @typedef {{
- *   getState: OptionalTask<(selector?: Selector<T>) => *>,
- *   resetState: OptionalTask<VoidFunction>,
- *   setState: OptionalTask<(changes: PartialState<T>) => void>,
- *   subscribe: OptionalTask<(listener: Listener<T>) => Unsubscribe>
- * }} Store
- * @template {State} T
- */
-
-/** @typedef {VoidFunction} Unsubscribe */
-
-/** @typedef {import("react").ReactNode} ReactNode */
-
-/**
- * @typedef {import("react").FC<P>} FC
- * @template [P={}]
- */
-
-/**
- * @typedef {import("react").Provider<T>} Provider
- * @template T
- */
-
-/**
- * @typedef {import("react").Context<T>} Context
- * @template T
- */
-exports.useContext = useContext;