redux-polling/dist/logic.js

Convenient way to support polling in your Redux app so you can focus on the business logic

'use strict';

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

var _extends2 = require('babel-runtime/helpers/extends');

var _extends3 = _interopRequireDefault(_extends2);

var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');

var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);

exports.start = start;
exports.stop = stop;
exports.reset = reset;
exports.request = request;
exports.addEntries = addEntries;

var _actions = require('./actions');

var _reducer = require('./reducer');

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

var timeouts = {};

function start(_ref, action, next) {
    var getState = _ref.getState,
        dispatch = _ref.dispatch;

    var state = getState();
    var pollingName = action.meta.pollingName;

    var _getPollingState = (0, _reducer.getPollingState)(state, pollingName),
        isActive = _getPollingState.isActive;

    if (isActive) {
        return false;
    }

    next(action);

    var requestAction = (0, _actions.createAction)(_actions.actionTypes.request, action.meta);
    dispatch(requestAction);

    return true;
}

function stop(_, action, next) {
    next(action);

    var _action$meta = action.meta,
        onStop = _action$meta.callbacks.onStop,
        pollingName = _action$meta.pollingName;

    if (typeof onStop === 'function') {
        onStop();
    }

    clearTimeout(timeouts[pollingName]);

    return true;
}

function reset(_, action, next) {
    next(action);

    var _action$meta2 = action.meta,
        onReset = _action$meta2.callbacks.onReset,
        pollingName = _action$meta2.pollingName;

    if (typeof onReset === 'function') {
        onReset();
    }

    clearTimeout(timeouts[pollingName]);

    return true;
}

function request(_ref2, action) {
    var getState = _ref2.getState,
        dispatch = _ref2.dispatch;

    var state = getState();
    var pollingName = action.meta.pollingName;

    var _getPollingState2 = (0, _reducer.getPollingState)(state, pollingName),
        isActive = _getPollingState2.isActive,
        requestPayload = _getPollingState2.requestPayload;

    if (!isActive) {
        return false;
    }

    var _action$meta3 = action.meta,
        callbacks = _action$meta3.callbacks,
        pollingInterval = _action$meta3.pollingInterval;

    var pollingFunc = callbacks.polling;
    return Promise.resolve(pollingFunc.apply(undefined, (0, _toConsumableArray3.default)(requestPayload).concat([getState]))).then(function (data) {
        var entries = void 0;
        if (data.multipleEntries === true) {
            if (Array.isArray(data.entries) === true) {
                entries = data.entries;
            } else {
                throw new Error('Entries must be an array when providing multiple entries');
            }
        } else {
            entries = [data];
        }
        var addEntriesAction = (0, _actions.createAction)(_actions.actionTypes.addEntries, action.meta, entries);
        dispatch(addEntriesAction);
    }, function (err) {
        return err;
    } // If exception during polling - do nothing
    ).then(function () {
        timeouts[pollingName] = setTimeout(function () {
            var requestAction = (0, _actions.createAction)(_actions.actionTypes.request, action.meta);
            dispatch(requestAction);
        }, pollingInterval);
    });
}

function addEntries(_ref3, action, next) {
    var getState = _ref3.getState;
    var shouldAddEntry = action.meta.callbacks.shouldAddEntry;

    var entries = action.payload;

    if (!Array.isArray(entries)) {
        throw new Error('Payload for ' + _actions.actionTypes.addEntries + ' must be array of entries');
    }

    if (typeof shouldAddEntry === 'function') {
        entries = entries.filter(function (entry) {
            return shouldAddEntry(entry, getState);
        });
    }

    if (entries.length > 0) {
        next((0, _extends3.default)({}, action, {
            payload: entries
        }));
    }

    return entries.length;
}