@paprika/seducer/lib/esm/useSeducer.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 _slicedToArray from "@babel/runtime-corejs2/helpers/slicedToArray";
import _defineProperty from "@babel/runtime-corejs2/helpers/defineProperty";

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; }

import React from "react";
import reducer from "./reducer";
import getTypes from "./getTypes";
export var useSeducer = function useSeducer(actions) {
  var initialState = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  var initializer = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined;
  var hasLogger = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
  var interceptors = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};

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

  var types = React.useMemo(function () {
    return getTypes(_objectSpread(_objectSpread({}, interceptors), actions));
  }, [actions, interceptors]);
  var reducerMemo = React.useMemo(function () {
    return reducer(actions, hasLogger, interceptors);
  }, [actions, hasLogger, interceptors]);

  var _React$useReducer = React.useReducer(reducerMemo, initialState, // if initializer is not a function just skipped by passing undefined so hasLogger can work
  typeof initializer === "function" ? initializer : undefined),
      _React$useReducer2 = _slicedToArray(_React$useReducer, 2),
      state = _React$useReducer2[0],
      dispatch = _React$useReducer2[1];
  /**
   * 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 [state, memoCustomDispatch, types];
};
//# sourceMappingURL=useSeducer.js.map