nedux/es/nedux.js

the next redux state management

import { BehaviorSubject } from 'rxjs';

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

function ownKeys(object, enumerableOnly) {
  var keys = Object.keys(object);

  if (Object.getOwnPropertySymbols) {
    var symbols = Object.getOwnPropertySymbols(object);
    if (enumerableOnly) symbols = symbols.filter(function (sym) {
      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
    });
    keys.push.apply(keys, symbols);
  }

  return keys;
}

function _objectSpread2(target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = arguments[i] != null ? arguments[i] : {};

    if (i % 2) {
      ownKeys(Object(source), true).forEach(function (key) {
        _defineProperty(target, key, source[key]);
      });
    } else if (Object.getOwnPropertyDescriptors) {
      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
    } else {
      ownKeys(Object(source)).forEach(function (key) {
        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
      });
    }
  }

  return target;
}

var createStore = function createStore(initState, middleware) {
  if (middleware === void 0) {
    middleware = [];
  }

  // Map each `initState` entries to a BehaviorSubject
  var subjects = Object.keys(initState).reduce(function (acc, key) {
    var _objectSpread2$1;

    var defaultValue = initState[key];
    var subject = new BehaviorSubject(defaultValue);
    return _objectSpread2({}, acc, (_objectSpread2$1 = {}, _objectSpread2$1[key] = subject, _objectSpread2$1));
  }, {});
  /**
   * Get the stored value at the key
   * @param key target key
   */

  var get = function get(key) {
    return subjects[key].getValue();
  };
  /**
   * Set a new value of the property `key` of the store
   * @param key target key
   * @param value new value
   */


  var set = function set(key, value) {
    subjects[key].next(typeof value === 'function' ? value(get(key)) : value);
  }; // @todo conditional typing return

  /**
   * Subscribe to a key of the store
   * @param key target key you want to subscribe
   * @param observer observer that will be called each time the value of key has changed
   */


  var subscribe = function subscribe(key, observer, _temp) {
    var _ref = _temp === void 0 ? {} : _temp,
        _ref$withInitialValue = _ref.withInitialValue,
        withInitialValue = _ref$withInitialValue === void 0 ? false : _ref$withInitialValue;

    var hasBeenInitialized = false;

    var validObserverFactory = function validObserverFactory(k) {
      return typeof observer === 'function' ? {
        next: function next(value) {
          return observer(value, k);
        }
      } : observer;
    };

    var wrappedObserverFactory = function wrappedObserverFactory(k) {
      var validObserver = validObserverFactory(k);
      return _objectSpread2({}, validObserver, {
        next: withInitialValue ? validObserver.next : function (nextValue) {
          if (hasBeenInitialized) {
            validObserver.next && validObserver.next(nextValue);
          } else {
            hasBeenInitialized = true;
          }
        }
      });
    };

    return key === '' ? Object.keys(subjects).map(function (key) {
      return subjects[key].subscribe(wrappedObserverFactory(key));
    }) : subjects[key].subscribe(wrappedObserverFactory(key));
  }; // Create the store


  var store = {
    get: get,
    set: set,
    subscribe: subscribe
  }; // Initialize all middleware

  middleware.forEach(function (factory) {
    return factory(store);
  });
  return store;
};

export { createStore };