@flopflip/react-redux/dist/flopflip-react-redux.browser.esm.js

import { combineReducers } from 'redux';
import _createForOfIteratorHelper from '@babel/runtime/helpers/esm/createForOfIteratorHelper';
import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
import _objectSpread from '@babel/runtime/helpers/esm/objectSpread2';
import { isNil, selectAdapterConfigurationStatus, useAdapterContext, getIsFeatureEnabled, getFlagVariation, useAdapterSubscription, ConfigureAdapter, ToggleFeature as ToggleFeature$1, setDisplayName, wrapDisplayName, DEFAULT_FLAG_PROP_KEY, DEFAULT_FLAGS_PROP_KEY } from '@flopflip/react';
export { ReconfigureAdapter as ReconfigureFlopFlip, useAdapterReconfiguration } from '@flopflip/react';
import { AdapterSubscriptionStatus, AdapterConfigurationStatus } from '@flopflip/types';
import React, { useDebugValue, useCallback } from 'react';
import { useSelector, useDispatch } from 'react-redux';
import _toConsumableArray from '@babel/runtime/helpers/esm/toConsumableArray';
import _slicedToArray from '@babel/runtime/helpers/esm/slicedToArray';

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 (!isNil(flagValue)) {
          foundFlagVariation = flagValue;
        }
      }
    } catch (err) {
      _iterator.e(err);
    } finally {
      _iterator.f();
    }

    return foundFlagVariation;
  };
};

// Actions
var UPDATE_STATUS = '@flopflip/status/update';
var initialState = {
  subscriptionStatus: AdapterSubscriptionStatus.Subscribed,
  configurationStatus: 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 selectAdapterConfigurationStatus(status === null || status === void 0 ? void 0 : status.configurationStatus);
};

var flopflipReducer = combineReducers({
  flags: reducer$1,
  status: reducer
});
var createFlopflipReducer = function createFlopflipReducer() {
  var preloadedState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
    memory: {}
  };
  return 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 = useSelector(selectStatus);
  useDebugValue({
    adapterStatus: adapterStatus
  });
  return adapterStatus;
}

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

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

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

function useFlagVariations(flagNames) {
  var adapterContext = useAdapterContext();
  var allFlags = useSelector(selectFlags());
  var flagVariations = flagNames.map(function (requestedVariation) {
    return 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 = useDispatch();
  return useCallback(function (flagsChange) {
    return dispatch(updateFlags(flagsChange, adapterIdentifiers));
  }, [dispatch, adapterIdentifiers]);
};

var useUpdateStatus = function useUpdateStatus() {
  var dispatch = useDispatch();
  return 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();
  useAdapterSubscription(props.adapter);
  return /*#__PURE__*/React.createElement(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.createElement(ToggleFeature$1, 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.createElement(ToggledComponent, ownProps);
      if (UntoggledComponent) return /*#__PURE__*/React.createElement(UntoggledComponent, ownProps);
      return null;
    };

    return WrappedToggledComponent;
  };
}

var injectFeatureToggle = (function (flagName) {
  var propKey = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 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.createElement(Component, props);
    };

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

var injectFeatureToggles = (function (flagNames) {
  var propKey = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 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.createElement(Component, props);
    };

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

var version = '12.1.14';

export { Configure as ConfigureFlopFlip, STATE_SLICE as FLOPFLIP_STATE_SLICE, ToggleFeature, UPDATE_FLAGS, UPDATE_STATUS, branchOnFeatureToggle, createFlopFlipEnhancer, createFlopflipReducer, flopflipReducer, injectFeatureToggle, injectFeatureToggles, selectFlag as selectFeatureFlag, selectFlags as selectFeatureFlags, useAdapterStatus, useFeatureToggle, useFeatureToggles, useFlagVariation, useFlagVariations, version };