fleux/dist/index.cjs.js

Towards Sane State Management

'use strict';

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

var React = require('react');

function _typeof(obj) {
  "@babel/helpers - typeof";

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

  return _typeof(obj);
}

function _classCallCheck(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}

function _defineProperties(target, props) {
  for (var i = 0; i < props.length; i++) {
    var descriptor = props[i];
    descriptor.enumerable = descriptor.enumerable || false;
    descriptor.configurable = true;
    if ("value" in descriptor) descriptor.writable = true;
    Object.defineProperty(target, descriptor.key, descriptor);
  }
}

function _createClass(Constructor, protoProps, staticProps) {
  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
  if (staticProps) _defineProperties(Constructor, staticProps);
  return Constructor;
}

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

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

function _inherits(subClass, superClass) {
  if (typeof superClass !== "function" && superClass !== null) {
    throw new TypeError("Super expression must either be null or a function");
  }

  subClass.prototype = Object.create(superClass && superClass.prototype, {
    constructor: {
      value: subClass,
      writable: true,
      configurable: true
    }
  });
  if (superClass) _setPrototypeOf(subClass, superClass);
}

function _getPrototypeOf(o) {
  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
    return o.__proto__ || Object.getPrototypeOf(o);
  };
  return _getPrototypeOf(o);
}

function _setPrototypeOf(o, p) {
  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
    o.__proto__ = p;
    return o;
  };

  return _setPrototypeOf(o, p);
}

function _isNativeReflectConstruct() {
  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
  if (Reflect.construct.sham) return false;
  if (typeof Proxy === "function") return true;

  try {
    Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
    return true;
  } catch (e) {
    return false;
  }
}

function _objectWithoutPropertiesLoose(source, excluded) {
  if (source == null) return {};
  var target = {};
  var sourceKeys = Object.keys(source);
  var key, i;

  for (i = 0; i < sourceKeys.length; i++) {
    key = sourceKeys[i];
    if (excluded.indexOf(key) >= 0) continue;
    target[key] = source[key];
  }

  return target;
}

function _objectWithoutProperties(source, excluded) {
  if (source == null) return {};

  var target = _objectWithoutPropertiesLoose(source, excluded);

  var key, i;

  if (Object.getOwnPropertySymbols) {
    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);

    for (i = 0; i < sourceSymbolKeys.length; i++) {
      key = sourceSymbolKeys[i];
      if (excluded.indexOf(key) >= 0) continue;
      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
      target[key] = source[key];
    }
  }

  return target;
}

function _assertThisInitialized(self) {
  if (self === void 0) {
    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  }

  return self;
}

function _possibleConstructorReturn(self, call) {
  if (call && (typeof call === "object" || typeof call === "function")) {
    return call;
  }

  return _assertThisInitialized(self);
}

function _createSuper(Derived) {
  var hasNativeReflectConstruct = _isNativeReflectConstruct();

  return function _createSuperInternal() {
    var Super = _getPrototypeOf(Derived),
        result;

    if (hasNativeReflectConstruct) {
      var NewTarget = _getPrototypeOf(this).constructor;

      result = Reflect.construct(Super, arguments, NewTarget);
    } else {
      result = Super.apply(this, arguments);
    }

    return _possibleConstructorReturn(this, result);
  };
}

function _slicedToArray(arr, i) {
  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
}

function _arrayWithHoles(arr) {
  if (Array.isArray(arr)) return arr;
}

function _iterableToArrayLimit(arr, i) {
  if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
  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"] != null) _i["return"]();
    } finally {
      if (_d) throw _e;
    }
  }

  return _arr;
}

function _unsupportedIterableToArray(o, minLen) {
  if (!o) return;
  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
  var n = Object.prototype.toString.call(o).slice(8, -1);
  if (n === "Object" && o.constructor) n = o.constructor.name;
  if (n === "Map" || n === "Set") return Array.from(o);
  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
}

function _arrayLikeToArray(arr, len) {
  if (len == null || len > arr.length) len = arr.length;

  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];

  return arr2;
}

function _nonIterableRest() {
  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}

function _createForOfIteratorHelper(o, allowArrayLike) {
  var it;

  if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
      if (it) o = it;
      var i = 0;

      var F = function () {};

      return {
        s: F,
        n: function () {
          if (i >= o.length) return {
            done: true
          };
          return {
            done: false,
            value: o[i++]
          };
        },
        e: function (e) {
          throw e;
        },
        f: F
      };
    }

    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
  }

  var normalCompletion = true,
      didErr = false,
      err;
  return {
    s: function () {
      it = o[Symbol.iterator]();
    },
    n: function () {
      var step = it.next();
      normalCompletion = step.done;
      return step;
    },
    e: function (e) {
      didErr = true;
      err = e;
    },
    f: function () {
      try {
        if (!normalCompletion && it.return != null) it.return();
      } finally {
        if (didErr) throw err;
      }
    }
  };
}

var context = React.createContext();

var STORE_MARKER = Symbol("STORE_MARKER");
var STORE_GET = Symbol("STORE_GET");
var STORE_UNGET = Symbol("STORE_UNGET");
var STORE_GETACTIONS = Symbol("STORE_GETACTIONS");
var ACTION_MARKER = Symbol("ACTION_MARKER");

function preventWrites (obj, errorMessage) {
  return new Proxy(obj, {
    set: function set() {
      throw new Error(errorMessage || 'Refusing to write to immutable object.');
    }
  });
}

var createStore = function createStore() {
  var _Object$definePropert;

  var initialValues = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  var values = {};
  var callbacks = {};
  var selectors = {};
  var namedProtoActions = {};
  var namedActions = {};
  var store = {};

  var subscribe = function subscribe(name, callback) {
    if (typeof name !== 'string' && _typeof(name) !== 'symbol') {
      throw new TypeError('Cannot subscribe to a key of type: ' + _typeof(name) + '. Expecting \'string\' or \'symbol\'.');
    }

    if (typeof callbacks[name] === 'undefined') {
      create(name, this[name]);
    }

    callbacks[name].push(callback);
  };

  var unsubscribe = function unsubscribe(name, callback) {
    var i = -1;

    if (typeof callbacks[name] === 'undefined') {
      callbacks[name] = [];
    }

    i = callbacks[name].indexOf(callback);

    if (i > -1) {
      callbacks[name].splice(i, 1);
    }
  };

  var select = function select(selector) {
    var handler = {
      get: function get(target, prop) {
        if (typeof selector !== 'undefined') {
          if (typeof selectors[prop] === 'undefined') {
            selectors[prop] = [selector];
          }

          if (!selectors.hasOwnProperty(prop)) {
            return store[prop];
          }

          if (selectors[prop].indexOf(selector) === -1) {
            selectors[prop].push(selector);
          }
        }

        return store[prop];
      }
    };
    var proxy = new Proxy(store, handler);
    return selector(proxy);
  };

  var create = function create(name, initialValue) {
    if (typeof store[name] !== 'undefined') {
      if (typeof initialValue !== 'undefined' && initialValue !== store[name]) {
        throw Error("Refusing to override existing value with initialization data for prop ".concat(name, ". This error is caused by providing an initial value to a key that already exists. This is likely to be a mistake. Please create the key without an initialization value."));
      } else {
        values[name] = store[name];
      }
    } else {
      values[name] = initialValue;
    }

    callbacks[name] = [];
    Object.defineProperty(store, name, {
      enumerable: true,
      get: function get() {
        return values[name];
      },
      set: function set(value) {
        var oldValue = values[name];
        values[name] = value;
        callbacks[name].forEach(function (callback) {
          return callback(_defineProperty({}, name, value), _defineProperty({}, name, oldValue));
        });
      }
    });
  };

  var setValue = function setValue(prop, setter) {
    for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
      args[_key - 2] = arguments[_key];
    }

    return this[prop] = setter.apply(void 0, [this[prop]].concat(args));
  };

  var dispatch = function dispatch(action) {
    var _action;

    for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
      args[_key2 - 1] = arguments[_key2];
    }

    if (typeof action === 'string') {
      _action = namedProtoActions[action];
    } else if (action[ACTION_MARKER]) {
      return action.apply(void 0, args);
    } else if (typeof action === 'function') {
      _action = action;
    } else {
      throw new TypeError("Unable to dispatch action of type " + _typeof(action) + ". Action must be a function or an action name string.");
    }

    var immutableStore = preventWrites(store, 'Refusing to write to store while dispatching.');

    var diff = _action.apply(void 0, [immutableStore].concat(args));

    if (_typeof(diff) !== 'object') {
      throw new TypeError("Unable to merge action return value of type " + _typeof(diff) + " into the store. Return value should be a store slice object. (Did you accidentally dispatch a function that already dispatches internally?)");
    }

    var _callbacks = [];
    Object.entries(diff).forEach(function (_ref) {
      var _ref2 = _slicedToArray(_ref, 2),
          key = _ref2[0],
          value = _ref2[1];

      store[key] = value;
      (selectors[key] || []).forEach(function (selector) {
        if (_callbacks.indexOf(selector) === -1) {
          _callbacks.push(selector);
        }
      }); // _callbacks.push(...(selectors[key] || []));
      // _callbacks.push(...(callbacks[key] || []));
    });

    _callbacks.forEach(function (callback) {
      return callback(proxy);
    });

    return true;
  };

  var createAction = function createAction() {
    var action, name, proto;

    if (typeof (arguments.length <= 0 ? undefined : arguments[0]) === 'string') {
      name = arguments.length <= 0 ? undefined : arguments[0];
      proto = arguments.length <= 1 ? undefined : arguments[1];
      namedProtoActions[name] = proto;
    } else {
      proto = arguments.length <= 0 ? undefined : arguments[0];
    }

    action = function action() {
      for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
        args[_key3] = arguments[_key3];
      }

      return store.dispatch.apply(store, [proto].concat(args));
    };

    Object.defineProperty(action, ACTION_MARKER, {
      enumerable: false,
      writable: false,
      value: true
    });

    if (typeof (arguments.length <= 0 ? undefined : arguments[0]) === 'string') {
      namedActions[name] = action;
    }

    return action;
  };

  Object.defineProperties(store, (_Object$definePropert = {
    'subscribe': {
      enumerable: false,
      value: subscribe
    },
    'unsubscribe': {
      enumerable: false,
      value: unsubscribe
    },
    'select': {
      enumerable: false,
      value: select
    },
    'create': {
      enumerable: false,
      value: create
    },
    'set': {
      enumerable: false,
      value: setValue
    },
    'dispatch': {
      enumerable: false,
      value: dispatch
    },
    'createAction': {
      enumerable: false,
      value: createAction
    }
  }, _defineProperty(_Object$definePropert, STORE_MARKER, {
    enumerable: false,
    writable: false,
    value: true
  }), _defineProperty(_Object$definePropert, STORE_GET, {
    enumerable: false,
    value: function value(prop, callback) {
      if (typeof callback !== 'undefined') {
        if (typeof selectors[prop] === 'undefined') {
          selectors[prop] = [callback];
        }

        if (!selectors.hasOwnProperty(prop)) {
          return this[prop];
        }

        if (selectors[prop].indexOf(callback) === -1) {
          selectors[prop].push(callback);
        }
      }

      return this[prop];
    }
  }), _defineProperty(_Object$definePropert, STORE_UNGET, {
    enumerable: false,
    value: function value(prop, callback) {
      if (typeof selectors[prop] !== 'undefined') {
        var idx = selectors[prop].indexOf(callback);

        if (idx !== -1) {
          selectors[prop].splice(idx, 1);
        }

        return true;
      } else {
        return false;
      }
    }
  }), _defineProperty(_Object$definePropert, STORE_GETACTIONS, {
    enumerable: false,
    value: function value() {
      return namedActions;
    }
  }), _Object$definePropert));
  Object.entries(initialValues).forEach(function (_ref3) {
    var _ref4 = _slicedToArray(_ref3, 2),
        name = _ref4[0],
        value = _ref4[1];

    return create(name, value);
  });

  var handler = function () {
    return {
      set: function set(target, prop, value) {
        target[prop] = value;

        if (typeof selectors[prop] === 'undefined') {
          return true;
        }

        var _iterator = _createForOfIteratorHelper(selectors[prop]),
            _step;

        try {
          for (_iterator.s(); !(_step = _iterator.n()).done;) {
            var callback = _step.value;
            callback(prop, value);
          }
        } catch (err) {
          _iterator.e(err);
        } finally {
          _iterator.f();
        }

        return true;
      }
    };
  }();

  var proxy = new Proxy(store, handler);
  return proxy;
};

var isStore = function isStore(obj) {
  return obj[STORE_MARKER] === true && typeof obj.subscribe === 'function' && typeof obj.unsubscribe === 'function' && typeof obj.create === 'function';
};

var _jsxFileName = "/Users/peter/dev/state/src/connect.js";
var connect = function connect(Component, value) {
  var store;

  if (typeof value === 'undefined') {
    throw new TypeError('Failed to connect component: Refusing to connect without a store. If you want to use an empty store, pass `{}` to `connect`.');
  }

  if (isStore(value)) {
    store = value;
  } else {
    store = createStore(value);
  }

  return /*#__PURE__*/function (_React$Component) {
    _inherits(_class, _React$Component);

    var _super = _createSuper(_class);

    function _class() {
      _classCallCheck(this, _class);

      return _super.apply(this, arguments);
    }

    _createClass(_class, [{
      key: "render",
      value: function render() {
        return /*#__PURE__*/React.createElement(context.Provider, {
          value: store,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 23,
            columnNumber: 17
          }
        }, /*#__PURE__*/React.createElement(Component, _extends({}, this.props, {
          __source: {
            fileName: _jsxFileName,
            lineNumber: 24,
            columnNumber: 21
          }
        })));
      }
    }]);

    return _class;
  }(React.Component);
};

var justCompare = compare;
/*
  primitives: value1 === value2
  functions: value1.toString == value2.toString
  arrays: if length, sequence and values of properties are identical
  objects: if length, names and values of properties are identical
  compare([[1, [2, 3]], [[1, [2, 3]]); // true
  compare([[1, [2, 3], 4], [[1, [2, 3]]); // false
  compare({a: 2, b: 3}, {a: 2, b: 3}); // true
  compare({a: 2, b: 3}, {b: 3, a: 2}); // true
  compare({a: 2, b: 3, c: 4}, {a: 2, b: 3}); // false
  compare({a: 2, b: 3}, {a: 2, b: 3, c: 4}); // false
  compare([[1, [2, {a: 4}], 4], [[1, [2, {a: 4}]]); // true
*/

function compare(value1, value2) {
  if (value1 === value2) {
    return true;
  }
  /* eslint-disable no-self-compare */
  // if both values are NaNs return true


  if (value1 !== value1 && value2 !== value2) {
    return true;
  }

  if ({}.toString.call(value1) != {}.toString.call(value2)) {
    return false;
  }

  if (value1 !== Object(value1)) {
    // non equal primitives
    return false;
  }

  if (!value1) {
    return false;
  }

  if (Array.isArray(value1)) {
    return compareArrays(value1, value2);
  }

  if ({}.toString.call(value1) == '[object Object]') {
    return compareObjects(value1, value2);
  } else {
    return compareNativeSubtypes(value1, value2);
  }
}

function compareNativeSubtypes(value1, value2) {
  // e.g. Function, RegExp, Date
  return value1.toString() === value2.toString();
}

function compareArrays(value1, value2) {
  var len = value1.length;

  if (len != value2.length) {
    return false;
  }

  var alike = true;

  for (var i = 0; i < len; i++) {
    if (!compare(value1[i], value2[i])) {
      alike = false;
      break;
    }
  }

  return alike;
}

function compareObjects(value1, value2) {
  var keys1 = Object.keys(value1).sort();
  var keys2 = Object.keys(value2).sort();
  var len = keys1.length;

  if (len != keys2.length) {
    return false;
  }

  for (var i = 0; i < len; i++) {
    var key1 = keys1[i];
    var key2 = keys2[i];

    if (!(key1 == key2 && compare(value1[key1], value2[key2]))) {
      return false;
    }
  }

  return true;
}

var defaultStore = createStore();

/*! *****************************************************************************
Copyright (c) Microsoft Corporation.

Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.

THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */

function __spreadArrays() {
    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
    for (var r = Array(s), k = 0, i = 0; i < il; i++)
        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
            r[k] = a[j];
    return r;
}

var justPascalCase = pascalCase;
/*
  pascalCase('the quick brown fox'); // 'TheQuickBrownFox'
  pascalCase('the_quick_brown_fox'); // 'TheQuickBrownFox'
  pascalCase('the-quick-brown-fox'); // 'TheQuickBrownFox'
  pascalCase('theQuickBrownFox'); // 'TheQuickBrownFox'
  pascalCase('thequickbrownfox'); // 'Thequickbrownfox'
  pascalCase('the - quick * brown# fox'); // 'TheQuickBrownFox'
  pascalCase('theQUICKBrownFox'); // 'TheQUICKBrownFox'
*/
// any combination of spaces and punctuation characters
// thanks to http://stackoverflow.com/a/25575009

var wordSeparators = /[\s\u2000-\u206F\u2E00-\u2E7F\\'!"#$%&()*+,\-.\/:;<=>?@\[\]^_`{|}~]+/;

function pascalCase(str) {
  var words = str.split(wordSeparators);
  var len = words.length;
  var mappedWords = new Array(len);

  for (var i = 0; i < len; i++) {
    var word = words[i];

    if (word === '') {
      continue;
    }

    mappedWords[i] = word[0].toUpperCase() + word.slice(1);
  }

  return mappedWords.join('');
}

var justTypeof = typeOf;
/*
  typeOf({}); // 'object'
  typeOf([]); // 'array'
  typeOf(function() {}); // 'function'
  typeOf(async function() {}); // 'function'
  typeOf(/a/); // 'regexp'
  typeOf(new Date()); // 'date'
  typeOf(null); // 'null'
  typeOf(undefined); // 'undefined'
  typeOf('a'); // 'string'
  typeOf(1); // 'number'
  typeOf(true); // 'boolean'
*/

function typeOf(obj) {
  if (obj === null) {
    return 'null';
  }

  if (obj !== Object(obj)) {
    return typeof obj;
  }

  var result = {}.toString.call(obj).slice(8, -1).toLowerCase(); // strip function adornments (e.g. "sAsyncFunction")

  return result.toLowerCase().indexOf('function') > -1 ? 'function' : result;
}

var fromentries = function fromEntries(iterable) {
  return [...iterable].reduce((obj, [key, val]) => {
    obj[key] = val;
    return obj;
  }, {});
};

function parseProps(args) {
    var selectStateProps = function (store, ownProps) { return ({}); }, bindActionProps = function (store, ownProps) { return ({}); }, statePropNames = [];
    if (typeof args[0] === 'function') {
        selectStateProps = args[0];
    }
    else if (justTypeof(args[0]) !== 'null' && typeof args[0] !== 'undefined') {
        if (args.every(function (propName) { return typeof propName === 'string'; })) {
            statePropNames = args.map(function (name) { return [name, name]; });
        }
        else if (Array.isArray(args[0]) && args[0].every(function (propName) { return typeof propName === 'string'; })) {
            statePropNames = args[0].map(function (name) { return [name, name]; });
        }
        else if (typeof args[0] === 'object') {
            statePropNames = Object.entries(args[0]);
        }
        selectStateProps = function (store, ownProps) {
            var conflictingNames = statePropNames.filter(function (_a) {
                var _ = _a[0], name = _a[1];
                return ownProps.hasOwnProperty(name);
            }).concat(statePropNames.filter(function (_a) {
                var _ = _a[0], name = _a[1];
                return ownProps.hasOwnProperty('set' + justPascalCase(name));
            }));
            if (conflictingNames.length > 0) {
                throw Error("Refusing to overwrite store props with parent-injected prop. The name(s) " + conflictingNames + " exist in the store and are passed down from the parent component, resulting in a naming conflict.");
            }
            var getters = statePropNames.map(function (_a) {
                var propName = _a[0], storeName = _a[1];
                return [propName, store[storeName]];
            });
            var setters = statePropNames.map(function (_a) {
                var propName = _a[0], storeName = _a[1];
                return ['set' + justPascalCase(propName), store.createAction(function (store, setter) {
                        var _a;
                        var args = [];
                        for (var _i = 2; _i < arguments.length; _i++) {
                            args[_i - 2] = arguments[_i];
                        }
                        if (typeof setter !== 'function') {
                            throw new TypeError('Failed to set store property. Supplied setter is not a function.');
                        }
                        return (_a = {}, _a[storeName] = setter.apply(void 0, __spreadArrays([store[storeName]], args)), _a);
                    })];
            });
            return fromentries(getters.concat(setters));
        };
    }
    if (Array.isArray(args[1]) && args[1].every(function (action) { return typeof action === 'string'; })) {
        bindActionProps = function (store) { return fromentries(args[1].map(function (actionName) { return [actionName, function () {
                var args = [];
                for (var _i = 0; _i < arguments.length; _i++) {
                    args[_i] = arguments[_i];
                }
                return store.dispatch.apply(store, __spreadArrays([actionName], args));
            }]; })); };
    }
    else if (typeof args[1] === 'function') {
        bindActionProps = function (store, ownProps) { return args[1](store.dispatch, ownProps); };
    }
    else if (typeof args[1] === 'object') {
        bindActionProps = function (store) { return fromentries(Object.entries(args[1]).map(function (_a) {
            var _ = _a[0], action = _a[1];
            if (action[ACTION_MARKER]) {
                return [_, action];
            }
            else {
                return [_, function () {
                        var args = [];
                        for (var _i = 0; _i < arguments.length; _i++) {
                            args[_i] = arguments[_i];
                        }
                        return store.dispatch.apply(store, __spreadArrays([action], args));
                    }];
            }
        })); };
    }
    return [selectStateProps, bindActionProps];
}

var _jsxFileName$1 = "/Users/peter/dev/state/src/withState.js";

var withContext = function withContext(Component) {
  var ContextWrapper = /*#__PURE__*/function (_React$Component) {
    _inherits(ContextWrapper, _React$Component);

    var _super = _createSuper(ContextWrapper);

    function ContextWrapper() {
      _classCallCheck(this, ContextWrapper);

      return _super.apply(this, arguments);
    }

    _createClass(ContextWrapper, [{
      key: "render",
      value: function render() {
        var value = this.context || defaultStore;
        return /*#__PURE__*/React.createElement(Component, _extends({
          context: value
        }, this.props, {
          __source: {
            fileName: _jsxFileName$1,
            lineNumber: 16,
            columnNumber: 17
          }
        }));
      }
    }]);

    return ContextWrapper;
  }(React.Component);

  ContextWrapper.contextType = context;
  return ContextWrapper;
};

var statefulComponentFactory = function statefulComponentFactory(Component, selectStateProps, bindActionProps) {
  var currentlyRenderingComponent = undefined,
      actionProps,
      stateProps;
  var ComponentWithState = withContext(function ComponentWithContext(_ref) {
    var context = _ref.context,
        props = _objectWithoutProperties(_ref, ["context"]);

    var localProxy = new Proxy(context, {
      get: function get(target, prop) {
        return target[STORE_GET](prop, callback);
      }
    });

    var callback = function () {
      if (typeof selectStateProps === 'function') {
        return function (prop, value) {
          var updatedStore = _objectSpread2(_objectSpread2({}, localProxy), {}, _defineProperty({
            createAction: localProxy.createAction
          }, prop, value));

          var immutableStore = preventWrites(updatedStore, 'Refusing to write to store inside of mapStateToProps.');
          var updatedProps = selectStateProps(immutableStore, props);

          if (!justCompare(stateProps, updatedProps)) {
            stateProps = updatedProps;
            currentlyRenderingComponent.setState(_defineProperty({}, prop, value));
          }
        };
      } else {
        return function (prop, value) {
          currentlyRenderingComponent.setState(_defineProperty({}, prop, value));
        };
      }
    }();

    var immutableStore = preventWrites(localProxy, 'Refusing to write to store inside of mapStateToProps or mapDispatchToProps.');

    if (typeof selectStateProps === 'function') {
      stateProps = selectStateProps(immutableStore, props);
    }

    if (typeof bindActionProps === 'function') {
      actionProps = bindActionProps(immutableStore, props);
    }

    var ComponentWithStore = /*#__PURE__*/function (_React$Component2) {
      _inherits(ComponentWithStore, _React$Component2);

      var _super2 = _createSuper(ComponentWithStore);

      function ComponentWithStore(props) {
        var _this;

        _classCallCheck(this, ComponentWithStore);

        _this = _super2.call(this, props);
        currentlyRenderingComponent = _assertThisInitialized(_this);
        _this.state = {};
        return _this;
      }

      _createClass(ComponentWithStore, [{
        key: "render",
        value: function render() {
          return /*#__PURE__*/React.createElement(Component, _extends({
            store: localProxy,
            dispatch: localProxy.dispatch
          }, stateProps, actionProps, this.props, {
            __source: {
              fileName: _jsxFileName$1,
              lineNumber: 76,
              columnNumber: 21
            }
          }));
        }
      }]);

      return ComponentWithStore;
    }(React.Component);

    return /*#__PURE__*/React.createElement(ComponentWithStore, _extends({}, props, {
      __source: {
        fileName: _jsxFileName$1,
        lineNumber: 82,
        columnNumber: 13
      }
    }));
  });
  Object.entries(Component).forEach(function (_ref2) {
    var _ref3 = _slicedToArray(_ref2, 2),
        key = _ref3[0],
        value = _ref3[1];

    return ComponentWithState[key] = value;
  });
  return ComponentWithState;
};

var withState = function withState() {
  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
    args[_key] = arguments[_key];
  }

  if (args.length === 0) {
    return statefulComponentFactory;
  } else {
    var _parseProps = parseProps(args),
        _parseProps2 = _slicedToArray(_parseProps, 2),
        selectStateProps = _parseProps2[0],
        bindActionProps = _parseProps2[1];

    return function (Component) {
      var ComponentWithState = function ComponentWithState(ownProps) {
        var explicitlyBoundComponent = function explicitlyBoundComponent(_ref4) {
          var store = _ref4.store,
              props = _objectWithoutProperties(_ref4, ["store"]);

          return /*#__PURE__*/React.createElement(Component, _extends({}, props, {
            store: store,
            __source: {
              fileName: _jsxFileName$1,
              lineNumber: 109,
              columnNumber: 25
            }
          }));
        };

        var StatefulComponent = statefulComponentFactory(explicitlyBoundComponent, selectStateProps, bindActionProps);
        return /*#__PURE__*/React.createElement(StatefulComponent, _extends({}, ownProps, {
          __source: {
            fileName: _jsxFileName$1,
            lineNumber: 116,
            columnNumber: 21
          }
        }));
      };

      Object.entries(Component).forEach(function (_ref5) {
        var _ref6 = _slicedToArray(_ref5, 2),
            key = _ref6[0],
            value = _ref6[1];

        return ComponentWithState[key] = value;
      });
      return ComponentWithState;
    };
  }
};

var prepareWriteActions = function prepareWriteActions() {
  for (var _len = arguments.length, props = new Array(_len), _key = 0; _key < _len; _key++) {
    props[_key] = arguments[_key];
  }

  return fromentries(props.map(function (prop) {
    return ['set' + justPascalCase(prop), function (store, setter) {
      for (var _len2 = arguments.length, args = new Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
        args[_key2 - 2] = arguments[_key2];
      }

      return _objectSpread2(_objectSpread2({}, store), {}, _defineProperty({}, prop, setter.apply(void 0, [store[prop]].concat(args))));
    }];
  }));
};

var getNamedActions = function getNamedActions(store) {
  return store[STORE_GETACTIONS]();
};

var useStore = function useStore() {
  var store = React.useContext(context);
  var stateProps = {};
  var subscriptions = [];

  var callback = function callback(prop, value) {
    if (!justCompare(stateProps[prop], value)) {
      stateProps[prop] = value;
      localState[1](_defineProperty({}, prop, value));
    }
  };

  var localProxy = new Proxy(store, {
    get: function get(target, prop) {
      subscriptions.push([prop, callback]);
      return target[STORE_GET](prop, callback);
    }
  });
  React.useEffect(function () {
    return function () {
      var _iterator = _createForOfIteratorHelper(subscriptions),
          _step;

      try {
        for (_iterator.s(); !(_step = _iterator.n()).done;) {
          var subscription = _step.value;
          store[STORE_UNGET](subscription[0], subscription[1]);
        }
      } catch (err) {
        _iterator.e(err);
      } finally {
        _iterator.f();
      }
    };
  });
  var localState = React.useState(localProxy);
  stateProps = _objectSpread2({}, localState[0]);
  return localProxy;
};
var useDispatch = function useDispatch() {
  return React.useContext(context).dispatch;
};
var useActions = function useActions() {
  var store = React.useContext(context);
  return getNamedActions(store);
};
var useSelector = function useSelector(selectStateProps) {
  var store = React.useContext(context);
  var stateProps = {};
  var subscriptions = [];

  var callback = function callback(prop, value) {
    localState[1](_objectSpread2(_objectSpread2({}, localProxy), {}, _defineProperty({}, prop, value)));
  };

  var localProxy = new Proxy(store, {
    get: function get(target, prop) {
      subscriptions.push([prop, callback]);
      return target[STORE_GET](prop, callback);
    }
  });
  React.useEffect(function () {
    return function () {
      var _iterator2 = _createForOfIteratorHelper(subscriptions),
          _step2;

      try {
        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
          var subscription = _step2.value;
          store[STORE_UNGET](subscription[0], subscription[1]);
        }
      } catch (err) {
        _iterator2.e(err);
      } finally {
        _iterator2.f();
      }
    };
  });
  var localState = React.useState(localProxy);
  var immutableStore = preventWrites(localState[0], 'Refusing to write to store inside of mapStateToProps.');
  stateProps = selectStateProps(immutableStore);
  return _objectSpread2(_objectSpread2({}, stateProps), {}, {
    dispatch: store.dispatch
  });
};

exports.connect = connect;
exports.createStore = createStore;
exports.getNamedActions = getNamedActions;
exports.isStore = isStore;
exports.prepareWriteActions = prepareWriteActions;
exports.useActions = useActions;
exports.useDispatch = useDispatch;
exports.useSelector = useSelector;
exports.useStore = useStore;
exports.withState = withState;
//# sourceMappingURL=index.cjs.js.map