@flopflip/react-redux/dist/flopflip-react-redux.cjs.dev.js

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var redux = require('redux');
var _createForOfIteratorHelper = require('@babel/runtime/helpers/createForOfIteratorHelper');
var _defineProperty = require('@babel/runtime/helpers/defineProperty');
var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
var react = require('@flopflip/react');
var types = require('@flopflip/types');
var React = require('react');
var reactRedux = require('react-redux');
var _toConsumableArray = require('@babel/runtime/helpers/toConsumableArray');
var _slicedToArray = require('@babel/runtime/helpers/slicedToArray');

function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }

var React__default = /*#__PURE__*/_interopDefault(React);

var STATE_SLICE = '@flopflip';

// Actions
var UPDATE_FLAGS = '@flopflip/flags/update';
var initialState$1 = {
  memory: {}
}; // Reducer

var reducer$1 = function reducer() {
  var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState$1;
  var action = arguments.length > 1 ? arguments[1] : undefined;

  switch (action.type) {
    case UPDATE_FLAGS:
      {
        if (action.payload.id) {
          return _objectSpread(_objectSpread({}, state), {}, _defineProperty({}, action.payload.id, _objectSpread(_objectSpread({}, state === null || state === void 0 ? void 0 : state[action.payload.id]), action.payload.flags)));
        }

        return _objectSpread(_objectSpread({}, state), Object.fromEntries(action.payload.adapterIdentifiers.map(function (adapterInterfaceIdentifier) {
          return [adapterInterfaceIdentifier, _objectSpread(_objectSpread({}, state === null || state === void 0 ? void 0 : state[adapterInterfaceIdentifier]), action.payload.flags)];
        })));
      }

    default:
      return state;
  }
};
var createReducer = function createReducer() {
  var preloadedState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState$1;
  return function () {
    var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : preloadedState;
    var action = arguments.length > 1 ? arguments[1] : undefined;
    return reducer$1(state, action);
  };
}; // Action Creators

var updateFlags = function updateFlags(flagsChange, adapterIdentifiers) {
  return {
    type: UPDATE_FLAGS,
    payload: _objectSpread(_objectSpread({}, flagsChange), {}, {
      adapterIdentifiers: adapterIdentifiers
    })
  };
}; // Selectors

var selectFlags = function selectFlags() {
  return function (state) {
    var _state$STATE_SLICE$fl;

    return (_state$STATE_SLICE$fl = state[STATE_SLICE].flags) !== null && _state$STATE_SLICE$fl !== void 0 ? _state$STATE_SLICE$fl : {};
  };
};
var selectFlag = function selectFlag(flagName, adapterIdentifiers) {
  return function (state) {
    var allFlags = selectFlags()(state);
    var foundFlagVariation = false;

    var _iterator = _createForOfIteratorHelper(adapterIdentifiers),
        _step;

    try {
      for (_iterator.s(); !(_step = _iterator.n()).done;) {
        var _allFlags$adapterInte;

        var adapterInterfaceIdentifier = _step.value;
        var flagValue = (_allFlags$adapterInte = allFlags[adapterInterfaceIdentifier]) === null || _allFlags$adapterInte === void 0 ? void 0 : _allFlags$adapterInte[flagName];

        if (!react.isNil(flagValue)) {
          foundFlagVariation = flagValue;
        }
      }
    } catch (err) {
      _iterator.e(err);
    } finally {
      _iterator.f();
    }

    return foundFlagVariation;
  };
};

// Actions
var UPDATE_STATUS = '@flopflip/status/update';
var initialState = {
  subscriptionStatus: types.AdapterSubscriptionStatus.Subscribed,
  configurationStatus: types.AdapterConfigurationStatus.Unconfigured
}; // Reducer

var reducer = function reducer() {
  var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
  var action = arguments.length > 1 ? arguments[1] : undefined;

  switch (action.type) {
    case UPDATE_STATUS:
      return _objectSpread(_objectSpread({}, state), action.payload.status);

    default:
      return state;
  }
};

var updateStatus = function updateStatus(statusChange) {
  return {
    type: UPDATE_STATUS,
    payload: statusChange
  };
}; // Selectors

var selectStatus = function selectStatus(state) {
  var status = state[STATE_SLICE].status;
  return react.selectAdapterConfigurationStatus(status === null || status === void 0 ? void 0 : status.configurationStatus);
};

var flopflipReducer = redux.combineReducers({
  flags: reducer$1,
  status: reducer
});
var createFlopflipReducer = function createFlopflipReducer() {
  var preloadedState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
    memory: {}
  };
  return redux.combineReducers({
    flags: createReducer(preloadedState),
    status: reducer
  });
};

function createFlopFlipEnhancer(adapter, adapterArgs) {
  return function (next) {
    return function () {
      var store = next.apply(void 0, arguments); // eslint-disable-next-line @typescript-eslint/no-floating-promises

      adapter.configure(adapterArgs, {
        // NOTE: This is like `bindActionCreators` but the bound action
        // creators are renamed to fit the adapter API and conventions.
        onFlagsStateChange: function onFlagsStateChange(flagsChange) {
          store.dispatch(updateFlags(flagsChange, [adapter.id]));
        },
        onStatusStateChange: function onStatusStateChange(statusChange) {
          store.dispatch(updateStatus(statusChange));
        }
      });
      return store;
    };
  };
}

function useAdapterStatus() {
  var adapterStatus = reactRedux.useSelector(selectStatus);
  React.useDebugValue({
    adapterStatus: adapterStatus
  });
  return adapterStatus;
}

function useFeatureToggle(flagName) {
  var flagVariation = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
  var adapterContext = react.useAdapterContext();
  var allFlags = reactRedux.useSelector(selectFlags());
  var isFeatureEnabled = react.getIsFeatureEnabled(allFlags, adapterContext.adapterEffectIdentifiers, flagName, flagVariation);
  React.useDebugValue({
    flagName: flagName,
    flagVariation: flagVariation,
    isEnabled: isFeatureEnabled
  });
  return isFeatureEnabled;
}

function useFeatureToggles(flags) {
  var allFlags = reactRedux.useSelector(selectFlags());
  var adapterContext = react.useAdapterContext();
  var requestedFlags = Object.entries(flags).reduce(function (previousFlags, _ref) {
    var _ref2 = _slicedToArray(_ref, 2),
        flagName = _ref2[0],
        flagVariation = _ref2[1];

    var isFeatureEnabled = react.getIsFeatureEnabled(allFlags, adapterContext.adapterEffectIdentifiers, flagName, flagVariation);
    return [].concat(_toConsumableArray(previousFlags), [isFeatureEnabled]);
  }, []);
  return requestedFlags;
}

function useFlagVariations(flagNames) {
  var adapterContext = react.useAdapterContext();
  var allFlags = reactRedux.useSelector(selectFlags());
  var flagVariations = flagNames.map(function (requestedVariation) {
    return react.getFlagVariation(allFlags, adapterContext.adapterEffectIdentifiers, requestedVariation);
  });
  return flagVariations;
}

function useFlagVariation(flagName) {
  var _useFlagVariations = useFlagVariations([flagName]),
      _useFlagVariations2 = _slicedToArray(_useFlagVariations, 1),
      flagVariation = _useFlagVariations2[0];

  return flagVariation;
}

var useUpdateFlags = function useUpdateFlags(_ref) {
  var adapterIdentifiers = _ref.adapterIdentifiers;
  var dispatch = reactRedux.useDispatch();
  return React.useCallback(function (flagsChange) {
    return dispatch(updateFlags(flagsChange, adapterIdentifiers));
  }, [dispatch, adapterIdentifiers]);
};

var useUpdateStatus = function useUpdateStatus() {
  var dispatch = reactRedux.useDispatch();
  return React.useCallback(function (statusChange) {
    return dispatch(updateStatus(statusChange));
  }, [dispatch]);
};

var defaultProps = {
  defaultFlags: {},
  shouldDeferAdapterConfiguration: false
};

var Configure = function Configure(props) {
  var adapterIdentifiers = [props.adapter.id];
  var handleUpdateFlags = useUpdateFlags({
    adapterIdentifiers: adapterIdentifiers
  });
  var handleUpdateStatus = useUpdateStatus();
  react.useAdapterSubscription(props.adapter);
  return /*#__PURE__*/React__default['default'].createElement(react.ConfigureAdapter, {
    adapter: props.adapter,
    adapterArgs: props.adapterArgs,
    defaultFlags: props.defaultFlags,
    shouldDeferAdapterConfiguration: props.shouldDeferAdapterConfiguration,
    onFlagsStateChange: handleUpdateFlags,
    onStatusStateChange: handleUpdateStatus
  }, props.children);
};

Configure.displayName = 'ConfigureFlopflip';
Configure.defaultProps = defaultProps;

var ToggleFeature = function ToggleFeature(props) {
  var isFeatureEnabled = useFeatureToggle(props.flag, props.variation);
  return /*#__PURE__*/React__default['default'].createElement(react.ToggleFeature, Object.assign({}, props, {
    isFeatureEnabled: isFeatureEnabled
  }));
};

ToggleFeature.displayName = 'ToggleFeature';

function branchOnFeatureToggle(_ref, UntoggledComponent) {
  var flagName = _ref.flag,
      flagVariation = _ref.variation;
  return function (ToggledComponent) {
    var WrappedToggledComponent = function WrappedToggledComponent(ownProps) {
      var isFeatureEnabled = useFeatureToggle(flagName, flagVariation);
      if (isFeatureEnabled) return /*#__PURE__*/React__default['default'].createElement(ToggledComponent, ownProps);
      if (UntoggledComponent) return /*#__PURE__*/React__default['default'].createElement(UntoggledComponent, ownProps);
      return null;
    };

    return WrappedToggledComponent;
  };
}

var injectFeatureToggle = (function (flagName) {
  var propKey = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : react.DEFAULT_FLAG_PROP_KEY;
  return function (Component) {
    var WrappedComponent = function WrappedComponent(ownProps) {
      var _useFlagVariations = useFlagVariations([flagName]),
          _useFlagVariations2 = _slicedToArray(_useFlagVariations, 1),
          flagVariation = _useFlagVariations2[0];

      var props = _objectSpread(_objectSpread({}, ownProps), {}, _defineProperty({}, propKey, flagVariation));

      return /*#__PURE__*/React__default['default'].createElement(Component, props);
    };

    react.setDisplayName(react.wrapDisplayName(WrappedComponent, 'injectFeatureToggle'));
    return WrappedComponent;
  };
});

var injectFeatureToggles = (function (flagNames) {
  var propKey = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : react.DEFAULT_FLAGS_PROP_KEY;
  return function (Component) {
    var WrappedComponent = function WrappedComponent(ownProps) {
      var flagVariations = useFlagVariations(flagNames);
      var flags = Object.fromEntries(flagNames.map(function (flagName, indexOfFlagName) {
        return [flagName, flagVariations[indexOfFlagName]];
      }));

      var props = _objectSpread(_objectSpread({}, ownProps), {}, _defineProperty({}, propKey, flags));

      return /*#__PURE__*/React__default['default'].createElement(Component, props);
    };

    react.setDisplayName(react.wrapDisplayName(WrappedComponent, 'injectFeatureToggles'));
    return WrappedComponent;
  };
});

var version = '12.1.14';

Object.defineProperty(exports, 'ReconfigureFlopFlip', {
  enumerable: true,
  get: function () {
    return react.ReconfigureAdapter;
  }
});
Object.defineProperty(exports, 'useAdapterReconfiguration', {
  enumerable: true,
  get: function () {
    return react.useAdapterReconfiguration;
  }
});
exports.ConfigureFlopFlip = Configure;
exports.FLOPFLIP_STATE_SLICE = STATE_SLICE;
exports.ToggleFeature = ToggleFeature;
exports.UPDATE_FLAGS = UPDATE_FLAGS;
exports.UPDATE_STATUS = UPDATE_STATUS;
exports.branchOnFeatureToggle = branchOnFeatureToggle;
exports.createFlopFlipEnhancer = createFlopFlipEnhancer;
exports.createFlopflipReducer = createFlopflipReducer;
exports.flopflipReducer = flopflipReducer;
exports.injectFeatureToggle = injectFeatureToggle;
exports.injectFeatureToggles = injectFeatureToggles;
exports.selectFeatureFlag = selectFlag;
exports.selectFeatureFlags = selectFlags;
exports.useAdapterStatus = useAdapterStatus;
exports.useFeatureToggle = useFeatureToggle;
exports.useFeatureToggles = useFeatureToggles;
exports.useFlagVariation = useFlagVariation;
exports.useFlagVariations = useFlagVariations;
exports.version = version;