redux-ephemeral/lib/index.js

'use strict';

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; }; /**
                                                                                                                                                                                                                                                                   * Imports
                                                                                                                                                                                                                                                                   */

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.lookup = exports.destroyEphemeral = exports.createEphemeral = exports.isEphemeral = exports.toEphemeral = undefined;

var _miniHamt = require('mini-hamt');

var hamt = _interopRequireWildcard(_miniHamt);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

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

/**
 * Action types
 */

var CREATE = 'CREATE_EPHEMERAL';
var DESTROY = 'DESTROY_EPHEMERAL';

/**
 * Ephemeral state reducer
 */

function ephemeralReducer() {
  var state = arguments.length <= 0 || arguments[0] === undefined ? hamt.empty : arguments[0];
  var action = arguments[1];
  var _action$meta$ephemera = action.meta.ephemeral;
  var reducer = _action$meta$ephemera.reducer;
  var key = _action$meta$ephemera.key;

  switch (action.type) {
    case CREATE:
      return hamt.set(state, key, action.payload);
    case DESTROY:
      return hamt.del(state, key);
    default:
      return hamt.set(state, key, reducer(hamt.get(state, key), action));
  }

  return state;
}

/**
 * Action creators
 */

function toEphemeral(key, reducer, action) {
  return _extends({}, action, {
    meta: _extends({}, action.meta || {}, {
      ephemeral: {
        key: key,
        reducer: reducer
      }
    })
  });
}

function createEphemeral(key, initialState) {
  return {
    type: CREATE,
    payload: initialState,
    meta: {
      ephemeral: { key: key }
    }
  };
}

function destroyEphemeral(key) {
  return {
    type: DESTROY,
    meta: {
      ephemeral: { key: key }
    }
  };
}

function lookup(state, key) {
  return hamt.get(state || hamt.empty, key);
}

/**
 * Mount reducer
 */

function mount(prop, reducer) {
  return function (state, action) {
    return isEphemeral(action) ? _extends({}, state, _defineProperty({}, prop, ephemeralReducer(state[prop], action))) : reducer(state, action);
  };
}

function isEphemeral(action) {
  return action.meta && action.meta.hasOwnProperty('ephemeral');
}

/**
 * Exports
 */

exports.default = mount;
exports.toEphemeral = toEphemeral;
exports.isEphemeral = isEphemeral;
exports.createEphemeral = createEphemeral;
exports.destroyEphemeral = destroyEphemeral;
exports.lookup = lookup;