@leofavre/memory-game-component/dist/cjs/es6/state/memoryGameActions.js

A memory game web component.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.requestPlayAsync = exports.sendEvent = exports.disallowInteraction = exports.allowInteraction = exports.hideCards = exports.matchCards = exports.revealCard = exports.distributeCards = void 0;

var _sequence = _interopRequireDefault(require("../helpers/sequence.js"));

var _shuffle = _interopRequireDefault(require("../helpers/shuffle.js"));

var _waitInPromise = _interopRequireDefault(require("../helpers/waitInPromise.js"));

var _memoryGameSelectors = require("./memoryGameSelectors.js");

var _memoryGameConstants = require("./memoryGameConstants.js");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

const distributeCards = (cards, positions) => ({
  type: _memoryGameConstants.DISTRIBUTE_CARDS,
  cards,
  positions: positions || (0, _shuffle.default)((0, _sequence.default)(cards.length * 2))
});

exports.distributeCards = distributeCards;

const revealCard = position => ({
  type: _memoryGameConstants.REVEAL_CARD,
  position
});

exports.revealCard = revealCard;

const matchCards = () => ({
  type: _memoryGameConstants.MATCH_CARDS
});

exports.matchCards = matchCards;

const hideCards = () => ({
  type: _memoryGameConstants.HIDE_CARDS
});

exports.hideCards = hideCards;

const allowInteraction = () => ({
  type: _memoryGameConstants.ALLOW_INTERACTION
});

exports.allowInteraction = allowInteraction;

const disallowInteraction = () => ({
  type: _memoryGameConstants.DISALLOW_INTERACTION
});

exports.disallowInteraction = disallowInteraction;

const sendEvent = (name, detail) => ({
  type: _memoryGameConstants.SEND_EVENT,
  name,
  detail
});

exports.sendEvent = sendEvent;

const requestPlayAsync = position => async (dispatch, getState) => {
  const state = getState();
  let currentState = state;
  let matchHappened = false;

  if ((0, _memoryGameSelectors.isCardRevealed)(position, state)) {
    dispatch(sendEvent('error', 'Cannot reveal an already revealed card.'));
  } else if ((0, _memoryGameSelectors.isCardMatched)(position, state)) {
    dispatch(sendEvent('error', 'Cannot reveal an already matched card.'));
  } else if ((0, _memoryGameSelectors.isPairOfCardsVisible)(state)) {
    dispatch(sendEvent('error', 'Cannot reveal more than two cards.'));
  } else {
    currentState = dispatch(revealCard(position));
    dispatch(sendEvent('reveal', position));
  }

  if ((0, _memoryGameSelectors.isPairOfCardsVisible)(currentState)) {
    dispatch(disallowInteraction);
    currentState = dispatch(matchCards);

    if ((0, _memoryGameSelectors.isVisiblePairOfCardsAMatch)(currentState)) {
      dispatch(sendEvent('match', currentState.revealed));
      matchHappened = true;
    } else {
      await (0, _waitInPromise.default)(2000)();
    }

    if ((0, _memoryGameSelectors.isGameOver)(currentState)) {
      dispatch(disallowInteraction);
      dispatch(sendEvent('finish'));
    } else {
      const previouslyRevealed = currentState.revealed;
      currentState = dispatch(hideCards);

      if (!matchHappened) {
        dispatch(sendEvent('hide', previouslyRevealed));
      }

      dispatch(allowInteraction);
    }
  }
};

exports.requestPlayAsync = requestPlayAsync;