@paprika/seducer/lib/esm/useSeducerWithContext.js

Seducer (simple reducer) is a wrapper on top of React.useReducer, making it easier to use

import _Object$keys from "@babel/runtime-corejs2/core-js/object/keys";
import _Object$getOwnPropertySymbols from "@babel/runtime-corejs2/core-js/object/get-own-property-symbols";
import _Object$getOwnPropertyDescriptor from "@babel/runtime-corejs2/core-js/object/get-own-property-descriptor";
import _Object$getOwnPropertyDescriptors from "@babel/runtime-corejs2/core-js/object/get-own-property-descriptors";
import _Object$defineProperties from "@babel/runtime-corejs2/core-js/object/define-properties";
import _Object$defineProperty from "@babel/runtime-corejs2/core-js/object/define-property";
import _defineProperty from "@babel/runtime-corejs2/helpers/defineProperty";
import _slicedToArray from "@babel/runtime-corejs2/helpers/slicedToArray";

function ownKeys(object, enumerableOnly) { var keys = _Object$keys(object); if (_Object$getOwnPropertySymbols) { var symbols = _Object$getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (_Object$getOwnPropertyDescriptors) { _Object$defineProperties(target, _Object$getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { _Object$defineProperty(target, key, _Object$getOwnPropertyDescriptor(source, key)); }); } } return target; }

/* eslint-disable no-param-reassign */
import React from "react";
import PropTypes from "prop-types";
import reducer from "./reducer";
import getTypes from "./getTypes";
export var contextState = /*#__PURE__*/React.createContext(null);
export var contextDispatch = /*#__PURE__*/React.createContext(null);
export var useSeducerWithContext = function useSeducerWithContext() {
  var _useDispatch = useDispatch(),
      _useDispatch2 = _slicedToArray(_useDispatch, 2),
      dispatch = _useDispatch2[0],
      types = _useDispatch2[1];

  return [useState(), dispatch, types];
};
var propTypes = {
  actions: PropTypes.shape({}),
  children: PropTypes.node.isRequired,
  displayName: PropTypes.string,
  hasLogger: PropTypes.bool,
  initialState: PropTypes.shape({}),
  initializer: PropTypes.func,
  interceptors: PropTypes.shape({})
};
var defaultProps = {
  actions: {},
  displayName: null,
  hasLogger: false,
  initialState: {},
  initializer: undefined,
  interceptors: {}
};
export function Provider(_ref) {
  var actions = _ref.actions,
      children = _ref.children,
      _ref$displayName = _ref.displayName,
      displayName = _ref$displayName === void 0 ? null : _ref$displayName,
      _ref$hasLogger = _ref.hasLogger,
      hasLogger = _ref$hasLogger === void 0 ? false : _ref$hasLogger,
      _ref$initialState = _ref.initialState,
      initialState = _ref$initialState === void 0 ? {} : _ref$initialState,
      _ref$initializer = _ref.initializer,
      initializer = _ref$initializer === void 0 ? undefined : _ref$initializer,
      _ref$interceptors = _ref.interceptors,
      interceptors = _ref$interceptors === void 0 ? {} : _ref$interceptors;

  if (!actions) {
    throw new Error("Actions are required for useSeducerWithContext, is an object with their actions as their properties");
  }

  if (typeof initializer !== "undefined" && typeof initializer !== "function") throw new Error("the initializer prop must be a function");
  var reducerMemo = React.useMemo(function () {
    return reducer(actions, hasLogger, interceptors);
  }, [actions, hasLogger, interceptors]);

  var _React$useReducer = React.useReducer(reducerMemo, initialState, initializer),
      _React$useReducer2 = _slicedToArray(_React$useReducer, 2),
      state = _React$useReducer2[0],
      dispatch = _React$useReducer2[1];

  var types = React.useMemo(function () {
    return getTypes(_objectSpread(_objectSpread({}, interceptors), actions));
  }, [actions, interceptors]);
  setContextDisplayName(contextState, displayName);
  /**
   * This is a helper that allowed to change the regular dispatch signature which is
   * dispatch({ type: "action", payload: value })
   * to
   * dispatch(types.type, value) which IMO is more versatile, shorter and pleasant to look at it.
   */

  var memoCustomDispatch = React.useCallback(function () {
    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

    var type = args[0],
        payload = args[1];
    dispatch({
      type: type,
      payload: payload
    });
  }, []);
  return /*#__PURE__*/React.createElement(contextState.Provider, {
    value: state
  }, /*#__PURE__*/React.createElement(contextDispatch.Provider, {
    value: [memoCustomDispatch, types]
  }, children));
}

var useState = function useState() {
  var state = React.useContext(contextState);

  if (state === undefined) {
    throw new Error("useState must be used with a Provider \n\nNormally this means that your component its not wrapped by a provider.\nEither move your component inside the <Provider /> component or \nimported it: import { Provider } and wrap your component within it. \n    ");
  }

  return state;
};

var useDispatch = function useDispatch() {
  var _React$useContext = React.useContext(contextDispatch),
      _React$useContext2 = _slicedToArray(_React$useContext, 2),
      dispatch = _React$useContext2[0],
      types = _React$useContext2[1];

  if (dispatch === undefined || types === undefined) {
    throw new Error("useDispatch must be used with a Provider \n\nNormally this means that your component its not wrapped by a provider.\nEither move your component inside the <Provider /> component or \nimported it: import { Provider } and wrap your component within it.\n    ");
  }

  return [dispatch, types];
};

function setContextDisplayName(contextState, displayName) {
  contextState.displayName = displayName ? "".concat(displayName, "State") : "ContextSimpleReducerState";
  contextDispatch.displayName = displayName ? "".concat(displayName, "Dispatch") : "ContextSimpleReducerDispatch";
}

Provider.propTypes = propTypes;
Provider.defaultProps = defaultProps;
//# sourceMappingURL=useSeducerWithContext.js.map