@coorpacademy/progression-engine/es/compute-next-step/compute-next-step.js

import _intersection from "lodash/fp/intersection";
import _findIndex from "lodash/fp/findIndex";
import _includes from "lodash/fp/includes";
import _shuffle from "lodash/fp/shuffle";
import _isEmpty from "lodash/fp/isEmpty";
import _isEqual from "lodash/fp/isEqual";
import _sortBy from "lodash/fp/sortBy";
import _filter from "lodash/fp/filter";
import _last from "lodash/fp/last";
import _slice from "lodash/fp/slice";
import _size from "lodash/fp/size";
import _head from "lodash/fp/head";
import _pipe from "lodash/fp/pipe";
import _find from "lodash/fp/find";
import _get from "lodash/fp/get";
import _map from "lodash/fp/map";

function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

import selectRule from '../rule-engine/select-rule';
import updateVariables from '../rule-engine/apply-instructions';
import updateState from '../update-state';

const hasNoMoreLives = (config, state) => !config.livesDisabled && state.lives <= 0;

const getContentRef = _get('content.ref');

const hasRemainingLifeRequests = state => state.remainingLifeRequests > 0;

const stepIsAlreadyExtraLife = state => getContentRef(state) === 'extraLife';

const hasRulesToApply = chapterContent => {
  return !!(chapterContent && Array.isArray(chapterContent.rules) && !_isEmpty(chapterContent.rules));
};

export const nextSlidePool = (config, availableContent, state) => {
  if (state.nextContent.type === 'chapter') {
    const content = _find({
      ref: state.nextContent.ref
    }, availableContent) || null;
    return {
      currentChapterContent: content,
      nextChapterContent: content,
      temporaryNextContent: {
        type: 'slide',
        ref: ''
      }
    };
  }

  const lastSlideRef = _pipe(_get('slides'), _last)(state);

  const _currentIndex = _findIndex(({
    slides
  }) => !!_find({
    _id: lastSlideRef
  }, slides), availableContent);

  const currentIndex = _currentIndex !== -1 ? _currentIndex : 0;
  const currentChapterPool = availableContent[currentIndex] || null;

  const currentChapterSlideIds = _pipe(_get('slides'), _map('_id'))(currentChapterPool || []);

  const slidesAnsweredForThisChapter = _intersection(state.slides, currentChapterSlideIds);

  const isChapterCompleted = _size(slidesAnsweredForThisChapter) >= Math.min(config.slidesToComplete, _size(currentChapterSlideIds));
  const hasRules = hasRulesToApply(currentChapterPool);
  const shouldChangeChapter = !hasRules && isChapterCompleted;

  if (shouldChangeChapter) {
    const nextChapterContent = _pipe(_slice(currentIndex + 1, _size(availableContent)), _filter(content => !_isEmpty(content.slides)), _head)(availableContent);

    return {
      currentChapterContent: currentChapterPool,
      nextChapterContent,
      temporaryNextContent: {
        type: 'slide',
        ref: ''
      }
    };
  }

  return {
    currentChapterContent: currentChapterPool,
    nextChapterContent: currentChapterPool,
    temporaryNextContent: state.nextContent
  };
};

const _getChapterContent = (config, availableContent, state) => {
  const firstContent = _pipe(_filter(content => !_isEmpty(content.slides)), _head)(availableContent);

  if (!state) {
    return {
      currentChapterContent: firstContent,
      nextChapterContent: firstContent,
      temporaryNextContent: {
        type: 'slide',
        ref: ''
      }
    };
  }

  return nextSlidePool(config, availableContent, state);
};

const getChapterContent = (config, availableContent, state) => {
  const res = _getChapterContent(config, availableContent, state);

  if (!res.currentChapterContent) {
    return null;
  }

  return res;
};

const sortByPosition = _sortBy(slide => typeof slide.position === 'number' ? -slide.position : 0);

const pickNextSlide = _pipe(_shuffle, sortByPosition, _head);

const isTargetingIsCorrect = condition => condition.target.scope === 'slide' && condition.target.field === 'isCorrect';

const getIsCorrect = (isCorrect, chapterRule) => {
  if (chapterRule.conditions.some(isTargetingIsCorrect)) return isCorrect;
  return null;
};

const computeNextSlide = (config, chapterContent, state) => {
  const remainingSlides = _filter(_pipe(_get('_id'), slideId => !state || !_includes(slideId, state.slides)), chapterContent.slides);

  return {
    type: 'slide',
    ref: pickNextSlide(remainingSlides)._id
  };
};

export const prepareStateToSwitchChapters = (chapterRule, state) => {
  if (!state) {
    return state;
  }

  return updateVariables(chapterRule.instructions)(_extends(_extends({}, state), {}, {
    nextContent: chapterRule.destination
  }));
};
export const computeNextStepForNewChapter = (config, state, chapterRule, isCorrect, availableContent) => {
  // eslint-disable-next-line no-use-before-define
  const nextStep = computeNextStep(config, prepareStateToSwitchChapters(chapterRule, state), availableContent, null);

  if (!nextStep) {
    return null;
  }

  return {
    nextContent: nextStep.nextContent,
    instructions: chapterRule.instructions.concat(nextStep.instructions || []),
    isCorrect: getIsCorrect(isCorrect, chapterRule)
  };
};

const extendPartialAction = (action, state) => {
  if (!action) {
    return null;
  }

  switch (action.type) {
    case 'answer':
      {
        const nextContent = action.payload.content || (state ? state.nextContent : {
          ref: '',
          type: 'node'
        });
        return {
          type: 'answer',
          payload: {
            answer: action.payload.answer,
            godMode: action.payload.godMode,
            isCorrect: action.payload.isCorrect,
            content: nextContent,
            nextContent,
            instructions: null
          }
        };
      }

    case 'extraLifeAccepted':
      {
        const nextContent = state ? state.nextContent : {
          ref: '',
          type: 'node'
        };
        return {
          type: 'extraLifeAccepted',
          payload: {
            content: nextContent,
            nextContent,
            instructions: null
          }
        };
      }

    default:
      return null;
  }
};

const computeNextStep = (config, _state, availableContent, partialAction) => {
  const action = extendPartialAction(partialAction, _state);
  const isCorrect = !!action && action.type === 'answer' && !!action.payload.isCorrect;
  const answer = !!action && action.type === 'answer' && action.payload.answer || [];
  const state = !_state || !action ? _state : updateState(config, _state, [action]);
  const chapterContent = getChapterContent(config, availableContent, state);

  if (!chapterContent) {
    return null;
  }

  const {
    currentChapterContent,
    nextChapterContent,
    temporaryNextContent
  } = chapterContent;
  const hasRules = hasRulesToApply(nextChapterContent);

  if (!hasRules) {
    if (state && hasNoMoreLives(config, state)) {
      return {
        nextContent: !stepIsAlreadyExtraLife(state) && hasRemainingLifeRequests(state) ? {
          type: 'node',
          ref: 'extraLife'
        } : {
          type: 'failure',
          ref: 'failExitNode'
        },
        instructions: null,
        isCorrect
      };
    } else if (!nextChapterContent) {
      // If user has answered all questions, return success endpoint
      return {
        nextContent: {
          type: 'success',
          ref: 'successExitNode'
        },
        instructions: null,
        isCorrect
      };
    }
  }

  if (hasRules) {
    const allAnswers = !!state && state.allAnswers || []; // $FlowFixMe nextChapterContent.rules = array not emtpy -> checked by hasRulesToApply

    const chapterRule = selectRule(nextChapterContent.rules, _extends(_extends({}, state), {}, {
      nextContent: temporaryNextContent,
      allAnswers: [...allAnswers, {
        slideRef: temporaryNextContent.ref,
        answer,
        isCorrect
      }]
    }));

    if (!chapterRule) {
      return null;
    }

    if (chapterRule.destination.type === 'chapter') {
      return computeNextStepForNewChapter(config, state, chapterRule, isCorrect, availableContent);
    }

    return {
      nextContent: chapterRule.destination,
      instructions: chapterRule.instructions,
      isCorrect: _isEqual(currentChapterContent, nextChapterContent) ? getIsCorrect(isCorrect, chapterRule) : isCorrect
    };
  }

  if (nextChapterContent && Array.isArray(nextChapterContent.slides) && nextChapterContent.slides.length > 0) {
    const stateWithDecrementedLives = state ? _extends(_extends({}, state), {}, {
      nextContent: temporaryNextContent
    }) : state;
    const nextContent = computeNextSlide(config, nextChapterContent, stateWithDecrementedLives);
    return {
      nextContent,
      instructions: null,
      isCorrect
    };
  }

  return null;
};

export default computeNextStep;
//# sourceMappingURL=compute-next-step.js.map