redux-wings/build/index.js

It gives your Redux wings!

(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.index = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});
var IDLE = exports.IDLE = 'AsyncStates.IDLE';
var PROCESSING = exports.PROCESSING = 'AsyncStates.PROCESSING';
var SUCCESS = exports.SUCCESS = 'AsyncStates.SUCCESS';
var ERROR = exports.ERROR = 'AsyncStates.ERROR';

exports.default = {
    IDLE: IDLE, PROCESSING: PROCESSING, SUCCESS: SUCCESS, ERROR: ERROR
};

},{}],2:[function(require,module,exports){
"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
function composeReducers() {
  for (var _len = arguments.length, reducers = Array(_len), _key = 0; _key < _len; _key++) {
    reducers[_key] = arguments[_key];
  }

  if (reducers.length === 0) {
    return function (x) {
      return x;
    };
  }

  if (reducers.length === 1) {
    return reducers[0];
  }

  return reducers.reduce(function (a, b) {
    return function (value) {
      for (var _len2 = arguments.length, rest = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
        rest[_key2 - 1] = arguments[_key2];
      }

      return a.apply(undefined, [b.apply(undefined, [value].concat(rest))].concat(rest));
    };
  });
}

exports.default = composeReducers;
module.exports = exports["default"];

},{}],3:[function(require,module,exports){
'use strict';

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

var _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; };

var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

var _AsyncStates = require('./AsyncStates');

var _AsyncStates2 = _interopRequireDefault(_AsyncStates);

var _createAsyncAction = require('./createAsyncAction');

var _createAsyncAction2 = _interopRequireDefault(_createAsyncAction);

var _nameConversions = require('./utils/nameConversions');

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

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

/**
 * Creates a set of actions and possibly 
 * pure functions to augment your reducers
 * for async state mapping
 * 
 * @param param0
 * @param param0.sliceNamespace {String}
 * 
 */
function createActions(_ref) {
    var sliceNamespace = _ref.sliceNamespace,
        actions = _ref.actions;

    var newActions = {};
    var stateUpdateMap = new Map();

    actions.forEach(function (entry) {

        // if "requestHandler" or "stateVariable"
        // was requested, we know that we are working
        // with an asynchronous action

        if ((typeof entry === 'undefined' ? 'undefined' : _typeof(entry)) == 'object' && (entry.requestHandler || entry.stateVariable)) {
            var namespace = entry.namespace,
                requestHandler = entry.requestHandler,
                stateVariable = entry.stateVariable;


            (0, _createAsyncAction2.default)({
                actions: newActions,
                sliceNamespace: sliceNamespace,
                namespace: namespace,
                requestHandler: requestHandler
            });

            // if stateVariable also specified,
            // populate a reducer function

            if (stateVariable) {
                var _stateUpdateMap$set;

                var actionNSPrefix = sliceNamespace + '/' + (0, _nameConversions.toUpperSnakeCase)(namespace);

                stateUpdateMap.set(stateVariable, (_stateUpdateMap$set = {}, _defineProperty(_stateUpdateMap$set, actionNSPrefix + '_REQUEST', _AsyncStates.PROCESSING), _defineProperty(_stateUpdateMap$set, actionNSPrefix + '_SUCCESS', _AsyncStates.SUCCESS), _defineProperty(_stateUpdateMap$set, actionNSPrefix + '_ERROR', _AsyncStates.ERROR), _stateUpdateMap$set));
            }
        }

        // otherwise, we are working with
        // a non async function and just
        // want to generate an action dispatcher
        // and namespace

        else if (typeof entry == 'string') {
                var _namespace = (typeof entry === 'undefined' ? 'undefined' : _typeof(entry)) == 'object' ? entry.namespace : entry;

                var actionNSUC = (0, _nameConversions.toUpperSnakeCase)(_namespace);
                newActions[actionNSUC] = sliceNamespace + '/' + actionNSUC;
                newActions[_namespace] = function (payload) {
                    return {
                        type: newActions[actionNSUC], payload: payload
                    };
                };
            }
    });

    // create function to represent reducer
    // that can handle all state variables
    // specified to transform based on action
    // passed

    function asyncReducer(state) {
        var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
        var payload = params.payload,
            type = params.type;


        var newState = state; // will be modified immutably

        // iterate through each state variable

        var _iteratorNormalCompletion = true;
        var _didIteratorError = false;
        var _iteratorError = undefined;

        try {
            for (var _iterator = stateUpdateMap[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                var _step$value = _slicedToArray(_step.value, 2),
                    stateVariable = _step$value[0],
                    actionTypeDict = _step$value[1];

                // if a state is first being created by containing
                // reducer, it should populate extra state variables
                // as "IDLE"; note we do not process this as a changing
                // state because it is simply populating the variable
                // where it hadn't existed, hence no new ref as redux
                // always triggers an initial render for first state

                if (typeof state[stateVariable] == 'undefined') {
                    state[stateVariable] = _AsyncStates2.default.IDLE;
                }

                // now lets check if actionTypeDict contains matches 
                // for setting a new state variable

                if (actionTypeDict[type] && stateVariable != actionTypeDict[type]) {
                    newState = Object.assign(_extends({}, state), _defineProperty({}, stateVariable, actionTypeDict[type]));
                }
            }
        } catch (err) {
            _didIteratorError = true;
            _iteratorError = err;
        } finally {
            try {
                if (!_iteratorNormalCompletion && _iterator.return) {
                    _iterator.return();
                }
            } finally {
                if (_didIteratorError) {
                    throw _iteratorError;
                }
            }
        }

        return newState;
    };

    return {
        actions: newActions,
        asyncReducer: asyncReducer
    };
}

exports.default = createActions;
module.exports = exports['default'];

},{"./AsyncStates":1,"./createAsyncAction":4,"./utils/nameConversions":6}],4:[function(require,module,exports){
'use strict';

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

var _nameConversions = require('./utils/nameConversions');

var actionVariants = ['REQUEST', 'SUCCESS', 'ERROR'];

/**
 * populates a set of redux actions with
 * action namespace XXX and provides constants for
 * 
 * 
 * @param {Object} param0
 * @param {String} param0.namespace
 * @param {String} param0.sliceNamespace
 * @param {function} param0.requestHandler 
 */
function createAsyncAction(_ref) {
    var actions = _ref.actions,
        namespace = _ref.namespace,
        sliceNamespace = _ref.sliceNamespace,
        requestHandler = _ref.requestHandler;

    var actionNsUC = (0, _nameConversions.toUpperSnakeCase)(namespace);

    // populate namespaces for each variant

    actionVariants.forEach(function (variant) {
        var actionType = sliceNamespace + '/' + actionNsUC + '_' + variant;

        actions[actionNsUC + '_' + variant] = actionType;
    });

    // populate request logic

    var requestMethodNs = namespace + 'Request';

    actions[requestMethodNs] = function () {
        var payload = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : undefined;

        return function (dispatch, getState) {

            // signal that request was made

            dispatch({
                type: actions[actionNsUC + '_REQUEST'],
                payload: payload
            });

            // call async request caller

            return requestHandler(payload, getState).then(function (response) {
                return new Promise(function (resolve, reject) {
                    dispatch({
                        type: actions[actionNsUC + '_SUCCESS'],
                        payload: response
                    });

                    resolve(response);
                });
            }).catch(function (error) {
                dispatch({
                    type: actions[actionNsUC + '_ERROR'],
                    payload: error
                });
            });
        };
    };
}

exports.default = createAsyncAction;
module.exports = exports['default'];

},{"./utils/nameConversions":6}],5:[function(require,module,exports){
'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.AsyncStates = exports.composeReducers = exports.createActions = exports.createAsyncAction = undefined;

var _createAsyncAction = require('./createAsyncAction');

var _createAsyncAction2 = _interopRequireDefault(_createAsyncAction);

var _createActions = require('./createActions');

var _createActions2 = _interopRequireDefault(_createActions);

var _AsyncStates = require('./AsyncStates');

var _AsyncStates2 = _interopRequireDefault(_AsyncStates);

var _composeReducers = require('./composeReducers');

var _composeReducers2 = _interopRequireDefault(_composeReducers);

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

exports.default = {
    createAsyncAction: _createAsyncAction2.default,
    createActions: _createActions2.default,
    composeReducers: _composeReducers2.default,
    AsyncStates: _AsyncStates2.default
};
exports.createAsyncAction = _createAsyncAction2.default;
exports.createActions = _createActions2.default;
exports.composeReducers = _composeReducers2.default;
exports.AsyncStates = _AsyncStates2.default;

},{"./AsyncStates":1,"./composeReducers":2,"./createActions":3,"./createAsyncAction":4}],6:[function(require,module,exports){
'use strict';

/**
 * toSnakeCase('userId') => "user_id"
 * toSnakeCase('waitAMoment') => "wait_a_moment"
 * toSnakeCase('TurboPascal') => "turbo_pascal"
 */
function toSnakeCase(str) {
    return str.replace(/([a-z\d])([A-Z])/g, '$1' + '_' + '$2').replace(/([A-Z]+)([A-Z][a-z\d]+)/g, '$1' + '_' + '$2').toLowerCase();
}

/**
 * toSnakeCase('userId') => "user_id"
 * toSnakeCase('waitAMoment') => "WAIT_A_MOMENT"
 * toSnakeCase('TurboPascal') => "TURBO_PASCALE"
 */
function toUpperSnakeCase(str) {
    return toSnakeCase(str).toUpperCase();
}

/**
 * toCamelCase('user_id') => "userId"
 * toCamelCase('wait_a_moment') => "waitAMoment"
 * toCamelCase('turbo_pascal') => "turboPascal"
 */
function toCamelCase(str) {
    var returnValue = str.toLowerCase().replace(/(_+[a-z])/g, function (m) {
        return '' + m.toUpperCase();
    }).replace(/_/g, '');

    // fix cases where first character is _
    // (mainly for MySQL tables)
    if (str.charAt(0) == '_') {
        returnValue = '_' + returnValue.charAt(0).toLowerCase() + returnValue.substr(1);
    }

    return returnValue;
}

module.exports = {
    toCamelCase: toCamelCase,
    toSnakeCase: toSnakeCase,
    toUpperSnakeCase: toUpperSnakeCase
};

},{}]},{},[5])(5)
});