@startlibs/core 1.0.0-alpha-6o → 1.0.0-alpha-6s

package/lib/index.js

@@ -7,8 +7,10 @@ var _createClass = require('@babel/runtime/helpers/createClass');
 var _possibleConstructorReturn = require('@babel/runtime/helpers/possibleConstructorReturn');
 var _getPrototypeOf = require('@babel/runtime/helpers/getPrototypeOf');
 var _inherits = require('@babel/runtime/helpers/inherits');
+var _debounce = require('lodash/fp/debounce');
 var React = require('react');
 var _objectDestructuringEmpty = require('@babel/runtime/helpers/objectDestructuringEmpty');
+var _objectSpread = require('@babel/runtime/helpers/objectSpread');
 var _extends = require('@babel/runtime/helpers/extends');
 var _objectWithoutProperties = require('@babel/runtime/helpers/objectWithoutProperties');
 var _slicedToArray = require('@babel/runtime/helpers/slicedToArray');
@@ -17,19 +19,29 @@ var _uniqueId = require('lodash/fp/uniqueId');
 var _differenceBy = require('lodash/fp/differenceBy');
 var _set = require('lodash/fp/set');
 var _findIndex = require('lodash/fp/findIndex');
-var _update = require('lodash/fp/update');
+var _isFinite = require('lodash/fp/isFinite');
+var _max = require('lodash/fp/max');
 var _flatMap = require('lodash/fp/flatMap');
 var _without = require('lodash/fp/without');
-var _identity = require('lodash/fp/identity');
+var _union = require('lodash/fp/union');
+var _update = require('lodash/fp/update');
+var _flow = require('lodash/fp/flow');
 var ReactDOM = require('react-dom');
 var styled = require('styled-components');
 var utils = require('@startlibs/utils');
-var _objectSpread = require('@babel/runtime/helpers/objectSpread');
+var _toConsumableArray = require('@babel/runtime/helpers/toConsumableArray');
 var _typeof = require('@babel/runtime/helpers/typeof');
 var _defineProperty = require('@babel/runtime/helpers/defineProperty');
 var mitt = require('mitt');
-var _toConsumableArray = require('@babel/runtime/helpers/toConsumableArray');
 var _isArray = require('lodash/fp/isArray');
+require('@babel/runtime/helpers/asyncToGenerator');
+require('@babel/runtime/regenerator');
+require('@babel/runtime/helpers/awaitAsyncGenerator');
+require('@babel/runtime/helpers/wrapAsyncGenerator');
+var _ = require('lodash/fp');
+var _taggedTemplateLiteral = require('@babel/runtime/helpers/taggedTemplateLiteral');
+require('polished');
+var emotion = require('emotion');
 var _isFunction = require('lodash/fp/isFunction');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
@@ -39,8 +51,10 @@ var _createClass__default = /*#__PURE__*/_interopDefaultLegacy(_createClass);
 var _possibleConstructorReturn__default = /*#__PURE__*/_interopDefaultLegacy(_possibleConstructorReturn);
 var _getPrototypeOf__default = /*#__PURE__*/_interopDefaultLegacy(_getPrototypeOf);
 var _inherits__default = /*#__PURE__*/_interopDefaultLegacy(_inherits);
+var _debounce__default = /*#__PURE__*/_interopDefaultLegacy(_debounce);
 var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
 var _objectDestructuringEmpty__default = /*#__PURE__*/_interopDefaultLegacy(_objectDestructuringEmpty);
+var _objectSpread__default = /*#__PURE__*/_interopDefaultLegacy(_objectSpread);
 var _extends__default = /*#__PURE__*/_interopDefaultLegacy(_extends);
 var _objectWithoutProperties__default = /*#__PURE__*/_interopDefaultLegacy(_objectWithoutProperties);
 var _slicedToArray__default = /*#__PURE__*/_interopDefaultLegacy(_slicedToArray);
@@ -49,18 +63,22 @@ var _uniqueId__default = /*#__PURE__*/_interopDefaultLegacy(_uniqueId);
 var _differenceBy__default = /*#__PURE__*/_interopDefaultLegacy(_differenceBy);
 var _set__default = /*#__PURE__*/_interopDefaultLegacy(_set);
 var _findIndex__default = /*#__PURE__*/_interopDefaultLegacy(_findIndex);
-var _update__default = /*#__PURE__*/_interopDefaultLegacy(_update);
+var _isFinite__default = /*#__PURE__*/_interopDefaultLegacy(_isFinite);
+var _max__default = /*#__PURE__*/_interopDefaultLegacy(_max);
 var _flatMap__default = /*#__PURE__*/_interopDefaultLegacy(_flatMap);
 var _without__default = /*#__PURE__*/_interopDefaultLegacy(_without);
-var _identity__default = /*#__PURE__*/_interopDefaultLegacy(_identity);
+var _union__default = /*#__PURE__*/_interopDefaultLegacy(_union);
+var _update__default = /*#__PURE__*/_interopDefaultLegacy(_update);
+var _flow__default = /*#__PURE__*/_interopDefaultLegacy(_flow);
 var ReactDOM__default = /*#__PURE__*/_interopDefaultLegacy(ReactDOM);
 var styled__default = /*#__PURE__*/_interopDefaultLegacy(styled);
-var _objectSpread__default = /*#__PURE__*/_interopDefaultLegacy(_objectSpread);
+var _toConsumableArray__default = /*#__PURE__*/_interopDefaultLegacy(_toConsumableArray);
 var _typeof__default = /*#__PURE__*/_interopDefaultLegacy(_typeof);
 var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
 var mitt__default = /*#__PURE__*/_interopDefaultLegacy(mitt);
-var _toConsumableArray__default = /*#__PURE__*/_interopDefaultLegacy(_toConsumableArray);
 var _isArray__default = /*#__PURE__*/_interopDefaultLegacy(_isArray);
+var ___default = /*#__PURE__*/_interopDefaultLegacy(_);
+var _taggedTemplateLiteral__default = /*#__PURE__*/_interopDefaultLegacy(_taggedTemplateLiteral);
 var _isFunction__default = /*#__PURE__*/_interopDefaultLegacy(_isFunction);
 
 var callList = function callList(list, firstArg) {
@@ -107,6 +125,11 @@ var willUseSharedCallback = function willUseSharedCallback() {
     return listenerCallbacks;
   };
 
+  var lastCall = {
+    current: null,
+    index: 0
+  };
+
   var call = function call() {
     for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
       args[_key2] = arguments[_key2];
@@ -114,6 +137,8 @@ var willUseSharedCallback = function willUseSharedCallback() {
 
     var resp = callList.apply(void 0, [get()].concat(args));
     callList.apply(void 0, [getListeners()].concat(args));
+    lastCall.current = args;
+    lastCall.index++;
     return resp;
   };
 
@@ -129,6 +154,7 @@ var willUseSharedCallback = function willUseSharedCallback() {
       ref.current = callback;
     }
 
+    var lastCallIndex = lastCall.index;
     useEffect(function () {
       if (!ref.current) {
         return;
@@ -138,6 +164,10 @@ var willUseSharedCallback = function willUseSharedCallback() {
         addListener(ref);
       } else {
         add(ref);
+
+        if (lastCallIndex !== lastCall.index && lastCall.current) {
+          callList.apply(void 0, [[ref]].concat(_toConsumableArray__default['default'](lastCall.current)));
+        }
       }
 
       return function () {
@@ -203,6 +233,26 @@ var willUseSharedState = function willUseSharedState(initialValue) {
   }, clear];
 };
 
+var not_defined = {};
+var useConstant = function useConstant(value) {
+  var ref = React.useRef(not_defined);
+
+  if (ref.current === not_defined) {
+    ref.current = value;
+  }
+
+  return ref.current;
+};
+var useLazyConstant = function useLazyConstant(value) {
+  var ref = React.useRef(not_defined);
+
+  if (ref.current === not_defined) {
+    ref.current = utils.callIfFunction(value);
+  }
+
+  return ref.current;
+};
+
 var SlotContext = React__default['default'].createContext(new Map());
 
 var _willUseSharedState = willUseSharedState(),
@@ -226,30 +276,45 @@ var SlotProvider = function SlotProvider(_ref) {
 };
 var Slot = function Slot(_ref2) {
   var name = _ref2.name,
-      rest = _objectWithoutProperties__default['default'](_ref2, ["name"]);
+      children = _ref2.children,
+      rest = _objectWithoutProperties__default['default'](_ref2, ["name", "children"]);
 
   var ref = React.useRef();
+  var slotInfo = useConstant({
+    ref: ref
+  });
   var slots = React.useContext(SlotContext);
   React.useLayoutEffect(function () {
     var previous = slots.get(name);
-    var update = (previous === null || previous === void 0 ? void 0 : previous.update) || _identity__default['default'];
+    var updates = (previous === null || previous === void 0 ? void 0 : previous.updates) || [];
 
     if (previous === null || previous === void 0 ? void 0 : previous.children) ;
 
-    slots.set(name, {
-      refs: ((previous === null || previous === void 0 ? void 0 : previous.refs) || []).concat([ref])
+    slots.set(name, _flow__default['default'](_update__default['default']('infos', _union__default['default']([slotInfo])))(previous));
+    updates.forEach(function (v) {
+      return v({});
     });
-    update();
     return function () {
+      var _previous$infos, _previous$updates;
+
       var previous = slots.get(name);
-      previous.refs = _without__default['default']([ref], previous.refs);
+      previous.infos = _without__default['default']([slotInfo], previous.infos);
 
-      if (!previous.refs.length) {
+      if (!((_previous$infos = previous.infos) === null || _previous$infos === void 0 ? void 0 : _previous$infos.length) && !((_previous$updates = previous.updates) === null || _previous$updates === void 0 ? void 0 : _previous$updates.length)) {
         slots.delete(name);
       }
     };
   }, [name]);
-  return React__default['default'].createElement("div", _extends__default['default']({
+  return children ? React__default['default'].createElement(React__default['default'].Fragment, null, React__default['default'].createElement("div", _extends__default['default']({
+    "data-id": name
+  }, rest, {
+    ref: ref
+  })), React__default['default'].Children.map(children, function (c) {
+    return React__default['default'].cloneElement(c, _objectSpread__default['default']({}, c.props, {
+      name: name,
+      stack: Number.MIN_SAFE_INTEGER
+    }));
+  })) : React__default['default'].createElement("div", _extends__default['default']({
     "data-id": name
   }, rest, {
     ref: ref
@@ -269,12 +334,12 @@ var FillBeforeFlip = function FillBeforeFlip(_ref3) {
   React.useLayoutEffect(function () {
     var _slots$get;
 
-    var slotRefs = ((_slots$get = slots.get(name)) === null || _slots$get === void 0 ? void 0 : _slots$get.refs) || [];
+    var infos = ((_slots$get = slots.get(name)) === null || _slots$get === void 0 ? void 0 : _slots$get.infos) || [];
 
     var mounted = _flatMap__default['default'](function (_ref4) {
-      var current = _ref4.current;
-      return current;
-    }, slotRefs);
+      var ref = _ref4.ref;
+      return ref === null || ref === void 0 ? void 0 : ref.current;
+    }, infos);
 
     var clones = [];
 
@@ -299,30 +364,62 @@ var FillBeforeFlip = function FillBeforeFlip(_ref3) {
   }, children);
 };
 
+var useFillState = function useFillState(name, stack) {
+  var forceUpdate = React__default['default'].useState(false)[1];
+  var slots = React.useContext(SlotContext);
+  var renderSlot = slots.get(name);
+
+  var maxStack = _max__default['default'](renderSlot === null || renderSlot === void 0 ? void 0 : renderSlot.stacks);
+
+  var onStack = !_isFinite__default['default'](maxStack) || maxStack === stack;
+  React.useLayoutEffect(function () {
+    var slot = slots.get(name);
+
+    var updatedSlot = _flow__default['default'](_update__default['default']('updates', _union__default['default']([forceUpdate])), _update__default['default']('stacks', _union__default['default']([stack])))(slot);
+
+    slots.set(name, updatedSlot);
+    updatedSlot.updates.forEach(function (v) {
+      return v({});
+    });
+    return function () {
+      var previous = slots.get(name);
+      var index = previous.updates.indexOf(forceUpdate);
+
+      var next = _flow__default['default'](_update__default['default']('updates', utils._s.removeAt(index)), _update__default['default']('stacks', utils._s.removeAt(index)))(previous);
+
+      slots.set(name, next);
+      next.updates.forEach(function (v) {
+        return v({});
+      });
+    };
+  }, []);
+  return [renderSlot, onStack];
+};
+
 var Fill = function Fill(_ref5) {
   var name = _ref5.name,
       children = _ref5.children,
-      withFlip = _ref5.withFlip;
-  var slots = React.useContext(SlotContext);
-  var forceUpdate = React__default['default'].useState({})[1];
-  var slot = slots.get(name);
+      _ref5$stack = _ref5.stack,
+      stack = _ref5$stack === void 0 ? 0 : _ref5$stack,
+      mountBeforeFlip = _ref5.mountBeforeFlip;
+
+  var _useFillState = useFillState(name, stack),
+      _useFillState2 = _slicedToArray__default['default'](_useFillState, 2),
+      slot = _useFillState2[0],
+      onStack = _useFillState2[1];
 
-  if (slot === null || slot === void 0 ? void 0 : slot.refs) {
-    return slot === null || slot === void 0 ? void 0 : slot.refs.map(function (ref) {
-      return (ref === null || ref === void 0 ? void 0 : ref.current) && ReactDOM__default['default'].createPortal(children, ref.current);
+  if ((slot === null || slot === void 0 ? void 0 : slot.infos) && onStack) {
+    return slot === null || slot === void 0 ? void 0 : slot.infos.map(function (info) {
+      var _info$ref;
+
+      return ((_info$ref = info.ref) === null || _info$ref === void 0 ? void 0 : _info$ref.current) && ReactDOM__default['default'].createPortal(utils.callIfFunction(children, info), info.ref.current);
     });
-  } else if (withFlip) {
+  } else if (mountBeforeFlip) {
     return React__default['default'].createElement(FillBeforeFlip, {
       name: name,
       slot: slot
     }, children);
   } else {
-    slots.set(name, {
-      children: children,
-      update: function update() {
-        return forceUpdate({});
-      }
-    });
     return null;
   }
 };
@@ -536,8 +633,12 @@ var useToggleInternal = function useToggleInternal() {
       console.log(key, refIsOpen.get() !== value ? "toggle" : "clear", refIsOpen.get(), value);
     }
 
-    if (refIsOpen.get() !== value) {
-      toggleWith(value);
+    var nextValue = utils.callIfFunction(value, refIsOpen.get());
+
+    if (refIsOpen.get() !== nextValue) {
+      toggleWith(function () {
+        return nextValue;
+      });
     } else {
       clearClosing();
     }
@@ -699,6 +800,10 @@ var usePopupToggle = function usePopupToggle(startWith, callback) {
         return sameTick = false;
       }, 1);
     }
+
+    if (v === false) {
+      prevOpenToggleClose = function prevOpenToggleClose() {};
+    }
   });
   return toggle;
 };
@@ -763,6 +868,16 @@ function (_React$Component) {
     key: "componentDidMount",
     value: function componentDidMount() {
       utils.fixMediaQuery();
+
+      var addVHFix = function addVHFix() {
+        var _document$documentEle, _document$documentEle2;
+
+        var vh = window.innerHeight * 0.01;
+        (_document$documentEle = document.documentElement) === null || _document$documentEle === void 0 ? void 0 : (_document$documentEle2 = _document$documentEle.style) === null || _document$documentEle2 === void 0 ? void 0 : _document$documentEle2.setProperty('--vh', "".concat(vh, "px"));
+      };
+
+      window.addEventListener('resize', _debounce__default['default'](200, addVHFix));
+      addVHFix();
     }
   }, {
     key: "render",
@@ -937,6 +1052,184 @@ function (_React$Component) {
   return WithRef;
 }(React__default['default'].Component);
 
+var scrollWidth = function () {
+  if (!window.document) return 0;
+  var html = document.documentElement;
+  var oldOverflow = html.style.overflowY;
+  html.style.overflowY = 'scroll';
+  var width = window.innerWidth - html.clientWidth;
+  html.style.overflowY = oldOverflow;
+  return width;
+}();
+
+var callIfFunction = function callIfFunction(prop) {
+  for (var _len6 = arguments.length, args = new Array(_len6 > 1 ? _len6 - 1 : 0), _key6 = 1; _key6 < _len6; _key6++) {
+    args[_key6 - 1] = arguments[_key6];
+  }
+
+  return typeof prop === "function" ? prop.apply(void 0, args) : prop;
+};
+var ifUndefined = function ifUndefined(v) {
+  for (var _len10 = arguments.length, or = new Array(_len10 > 1 ? _len10 - 1 : 0), _key10 = 1; _key10 < _len10; _key10++) {
+    or[_key10 - 1] = arguments[_key10];
+  }
+
+  return v !== undefined ? v : or.length === 1 ? or[0] : ifUndefined.apply(void 0, [or[0]].concat(_toConsumableArray__default['default'](or.slice(1))));
+};
+
+var moveElement = ___default['default'].curry(function (from, to, list) {
+  var el = list[from];
+
+  var without = ___default['default'].pullAt(from, list);
+
+  without.splice(to, 0, el);
+  return without;
+});
+var unsetOrRemoveAt = ___default['default'].curry(function (path, value) {
+  var pathArr = toPath(path);
+
+  var _pathArr$slice = pathArr.slice(-1),
+      _pathArr$slice2 = _slicedToArray__default['default'](_pathArr$slice, 1),
+      lastKey = _pathArr$slice2[0];
+
+  return update(pathArr.slice(0, -1), function (v) {
+    return Array.isArray(v) ? removeAt(lastKey, v) : unset(lastKey, v);
+  }, value);
+});
+
+var sanitizePath = function sanitizePath(path) {
+  return Array.isArray(path) ? path.map(sanitizePath) : typeof path === 'number' ? path.toString() : path === undefined ? [] : path;
+};
+
+var toPath = function toPath(path) {
+  return ___default['default'].toPath(sanitizePath(path));
+};
+
+var isEmptyPath = function isEmptyPath(path) {
+  return path && !path.length;
+};
+
+var update = ___default['default'].curry(function (path, updater, state) {
+  var sanitizedPath = sanitizePath(path);
+
+  if (isEmptyPath(sanitizedPath)) {
+    return updater(state);
+  } else {
+    return ___default['default'].update(sanitizedPath, updater, state);
+  }
+});
+var get = ___default['default'].curry(function (path, state) {
+  var sanitizedPath = sanitizePath(path);
+
+  if (isEmptyPath(sanitizedPath)) {
+    return state;
+  } else {
+    return ___default['default'].get(sanitizedPath, state);
+  }
+});
+var set = ___default['default'].curry(function (path, value, state) {
+  var sanitizedPath = sanitizePath(path);
+
+  if (isEmptyPath(sanitizedPath)) {
+    return value;
+  } else {
+    return ___default['default'].set(sanitizedPath, value, state);
+  }
+});
+var unset = ___default['default'].curry(function (path, state) {
+  var sanitizedPath = sanitizePath(path);
+
+  if (isEmptyPath(sanitizedPath)) {
+    return undefined;
+  } else {
+    return ___default['default'].unset(sanitizedPath, state);
+  }
+});
+var removeNAt = ___default['default'].curry(function (pos, n, value) {
+  return _toConsumableArray__default['default'](value.slice(0, Number(pos))).concat(_toConsumableArray__default['default'](value.slice(Number(pos) + n)));
+});
+var removeAt = removeNAt(___default['default'].__, 1);
+var when = ___default['default'].curry(function (cond, fn, value) {
+  return callIfFunction(cond, value) ? fn(value) : value;
+});
+var assign = ___default['default'].curry(function (a, b) {
+  return ___default['default'].assign(b, a);
+});
+var concat = ___default['default'].curry(function (a, b) {
+  return ___default['default'].concat(b, a);
+});
+var each = ___default['default'].each.convert({
+  cap: false
+});
+var find = ___default['default'].find.convert({
+  cap: false
+});
+var filter = ___default['default'].filter.convert({
+  cap: false
+});
+var map = ___default['default'].map.convert({
+  cap: false
+});
+var insertAt = ___default['default'].curry(function (pos, newElements, value) {
+  return _toConsumableArray__default['default'](value.slice(0, pos).concat(newElements)).concat(_toConsumableArray__default['default'](value.slice(pos)));
+});
+
+function _templateObject() {
+  var data = _taggedTemplateLiteral__default['default'](["\n  ", ""]);
+
+  _templateObject = function _templateObject() {
+    return data;
+  };
+
+  return data;
+}
+var media = function media() {
+  for (var _len3 = arguments.length, sizePairs = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+    sizePairs[_key3] = arguments[_key3];
+  }
+
+  return function () {
+    return styled.css(["@media ", "{", "}"], sizePairs.map(function (_ref4) {
+      var _ref5 = _slicedToArray__default['default'](_ref4, 2),
+          size = _ref5[0],
+          type = _ref5[1];
+
+      return "(".concat(type, ": ").concat(size + scrollWidth, "px)");
+    }).join(' and '), styled.css.apply(void 0, arguments));
+  };
+};
+media.mobile = media([600, 'max-width']);
+
+media.between = function (min, max) {
+  return media([min, 'min-width'], [max, 'max-width']);
+};
+
+media.max = function (n) {
+  return media([n, 'max-width']);
+};
+
+media.min = function (n) {
+  return media([n, 'min-width']);
+};
+
+media.desktop = media([601, 'min-width']);
+
+var getFrameOffset = function getFrameOffset(i, total) {
+  return Math.round(i * 100 / (total - 1));
+};
+
+var oneWayAnimation = function oneWayAnimation() {
+  for (var _len4 = arguments.length, frames = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+    frames[_key4] = arguments[_key4];
+  }
+
+  return emotion.keyframes(_templateObject(), frames.map(function (frame, i) {
+    return !frame ? '' : "".concat(getFrameOffset(i, frames.length), "% {\n      ").concat(frame, "\n    }");
+  }));
+};
+var identityTranslateFrames = oneWayAnimation('transform: translateY(0);', 'transform: translateY(0);');
+var identityOpacityFrames = oneWayAnimation('opacity: 1;', 'opacity:1;');
+
 var addExtraProp = function addExtraProp(element, extra) {
   var override = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
   return React__default['default'].cloneElement(element, override ? _objectSpread__default['default']({}, element.props, extra) : _objectSpread__default['default']({}, extra, element.props), element.props.children);
@@ -945,15 +1238,14 @@ var addExtraProp = function addExtraProp(element, extra) {
 var WithLazyResource = function WithLazyResource(_ref) {
   var value = _ref.value,
       wrap = _ref.wrap,
-      _ref$fallback = _ref.fallback,
-      fallback = _ref$fallback === void 0 ? null : _ref$fallback,
+      fallback = _ref.fallback,
       children = _ref.children,
       _ref$forwardProps = _ref.forwardProps,
       forwardProps = _ref$forwardProps === void 0 ? false : _ref$forwardProps,
       props = _objectWithoutProperties__default['default'](_ref, ["value", "wrap", "fallback", "children", "forwardProps"]);
 
-  return wrap ? React__default['default'].createElement(React__default['default'].Suspense, {
-    fallback: fallback
+  return wrap || fallback !== undefined ? React__default['default'].createElement(React__default['default'].Suspense, {
+    fallback: ifUndefined(fallback, null)
   }, React__default['default'].createElement(Load, {
     value: value,
     forwardProps: forwardProps && props,
@@ -1119,30 +1411,82 @@ function usePrevious(value, initialValue) {
   });
   return ref.current;
 }
+function usePreviousUnique(value, initialValue) {
+  var ref = React.useRef(initialValue);
+  React.useEffect(function () {
+    if (value !== ref.current) {
+      ref.current = value;
+    }
+  });
+  return ref.current;
+}
 
 var useEnsureRef = function useEnsureRef(forwardedRef) {
   var ref = React.useRef();
   return forwardedRef || ref;
 };
 
-var not_defined = {};
-var useConstant = function useConstant(value) {
-  var ref = React.useRef(not_defined);
+var useForceUpdate = function useForceUpdate() {
+  var _useState = React.useState(0),
+      _useState2 = _slicedToArray__default['default'](_useState, 2),
+      value = _useState2[0],
+      setValue = _useState2[1]; // integer state
 
-  if (ref.current === not_defined) {
-    ref.current = value;
-  }
 
-  return ref.current;
+  return function () {
+    return setValue(function (value) {
+      return value + 1;
+    });
+  }; // update the state to force render
 };
-var useLazyConstant = function useLazyConstant(value) {
-  var ref = React.useRef(not_defined);
+var willUseForceUpdate = function willUseForceUpdate() {
+  var _willUseSharedState = willUseSharedState(),
+      _willUseSharedState2 = _slicedToArray__default['default'](_willUseSharedState, 3),
+      useValue = _willUseSharedState2[0],
+      set = _willUseSharedState2[2];
+
+  var useForceUpdate = function useForceUpdate() {
+    var _useValue = useValue(0),
+        _useValue2 = _slicedToArray__default['default'](_useValue, 2),
+        v = _useValue2[0],
+        setV = _useValue2[1];
 
-  if (ref.current === not_defined) {
-    ref.current = utils.callIfFunction(value);
-  }
+    return function () {
+      return setV(function (value) {
+        return value + 1;
+      });
+    };
+  };
 
-  return ref.current;
+  return [useForceUpdate, function () {
+    return set(function (value) {
+      return value + 1;
+    });
+  }];
+};
+
+var useUpdateOnResize = function useUpdateOnResize() {
+  var debounceInterval = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 200;
+  var update = useForceUpdate();
+  React.useEffect(function () {
+    var trigger = _debounce__default['default'](debounceInterval, update);
+
+    window.addEventListener('resize', trigger);
+    return function () {
+      window.removeEventListener('resize', trigger);
+    };
+  }, []);
+};
+
+var useAsyncEffect = function useAsyncEffect(fn, args) {
+  React.useEffect(function () {
+    var result = fn();
+    return function () {
+      result.then(function (end) {
+        return utils.callIfFunction(end);
+      });
+    };
+  }, args);
 };
 
 var useUpdateEffect = function useUpdateEffect(effect, inputs) {
@@ -1194,9 +1538,11 @@ var parsePathOrSelector = function parsePathOrSelector(pathOrSelector) {
   }
 };
 
-var willUseSpreadState = function willUseSpreadState() {
-  var Context = React__default['default'].createContext();
+var willUseSpreadState = function willUseSpreadState(defaultContextValue) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var Context = React__default['default'].createContext(defaultContextValue);
   var EMPTY_GLOBAL = {};
+  var prevInitState = EMPTY_GLOBAL;
   var globalState = EMPTY_GLOBAL;
 
   var getGlobalState = function getGlobalState() {
@@ -1213,10 +1559,22 @@ var willUseSpreadState = function willUseSpreadState() {
 
     var state = useRefState(initState, setCallback);
 
+    if (options.initRefCheck) {
+      if (prevInitState !== initState) {
+        globalState = initState;
+      }
+
+      prevInitState = initState;
+    }
+
     if (globalState === EMPTY_GLOBAL) {
       globalState = initState;
     }
 
+    React.useEffect(function () {
+      globalState = state.get();
+    }, []);
+
     var setState = function setState(newState, fastPath, config) {
       // console.log("Fastpath noop:"+fastPath)
       state.set(newState, config);
@@ -1273,9 +1631,16 @@ var willUseSpreadState = function willUseSpreadState() {
     }, pathOrInput);
     useCatalogManager(manager, input);
     var setState = React.useCallback(function (v) {
-      return setSpreadState((_isFunction__default['default'](v) ? _update__default['default'] : _set__default['default'])(path, v), path);
+      return setSpreadState((_isFunction__default['default'](v) ? pathOrSelector === undefined ? function () {
+        return v;
+      } : _update__default['default'] : _set__default['default'])(path, v), path);
     }, pathOrInput);
-    return [value, setState];
+
+    var getValue = function getValue() {
+      return selector(getGlobalState());
+    };
+
+    return [value, setState, getValue];
   };
 
   return [useProvideSpreadState, useSpreadState, Context, getGlobalState];
@@ -1296,21 +1661,26 @@ exports.WithLazyResource = WithLazyResource;
 exports.WithRef = WithRef;
 exports.clearPopups = clearPopups;
 exports.consumes = consumes;
+exports.useAsyncEffect = useAsyncEffect;
 exports.useCatalogManager = useCatalogManager;
 exports.useConstant = useConstant;
 exports.useConsumerCatalog = useConsumerCatalog;
 exports.useEnsureRef = useEnsureRef;
 exports.useFill = useFill;
+exports.useForceUpdate = useForceUpdate;
 exports.useHiddenFill = useHiddenFill;
 exports.useIsUnmounted = useIsUnmounted;
 exports.useLazyConstant = useLazyConstant;
 exports.usePopupToggle = usePopupToggle;
 exports.usePrevious = usePrevious;
+exports.usePreviousUnique = usePreviousUnique;
 exports.useRefState = useRefState;
 exports.useRefToggle = useRefToggle;
 exports.useTitle = useTitle;
 exports.useToggle = useToggle;
 exports.useUpdateEffect = useUpdateEffect;
+exports.useUpdateOnResize = useUpdateOnResize;
+exports.willUseForceUpdate = willUseForceUpdate;
 exports.willUseLayers = willUseLayers;
 exports.willUseSharedCallback = willUseSharedCallback;
 exports.willUseSharedState = willUseSharedState;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@startlibs/core",
-  "version": "1.0.0-alpha-6o",
+  "version": "1.0.0-alpha-6s",
   "description": "Startlibs Core",
   "main": "lib/index.js",
   "sideEffects": false,