@startlibs/core 1.0.0-alpha-6t → 1.0.0-alpha-6u

package/lib/index.js

@@ -0,0 +1,1752 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _classCallCheck = require('@babel/runtime/helpers/classCallCheck');
+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');
+var _unset = require('lodash/fp/unset');
+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 _isFinite = require('lodash/fp/isFinite');
+var _max = require('lodash/fp/max');
+var _flatMap = require('lodash/fp/flatMap');
+var _without = require('lodash/fp/without');
+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 _toConsumableArray = require('@babel/runtime/helpers/toConsumableArray');
+var _typeof = require('@babel/runtime/helpers/typeof');
+var _regeneratorRuntime = require('@babel/runtime/regenerator');
+var _asyncToGenerator = require('@babel/runtime/helpers/asyncToGenerator');
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var mitt = require('mitt');
+var _isArray = require('lodash/fp/isArray');
+var _isFunction = require('lodash/fp/isFunction');
+var _get = require('lodash/fp/get');
+var _isString = require('lodash/fp/isString');
+var _identity = require('lodash/fp/identity');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _classCallCheck__default = /*#__PURE__*/_interopDefaultLegacy(_classCallCheck);
+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);
+var _unset__default = /*#__PURE__*/_interopDefaultLegacy(_unset);
+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 _isFinite__default = /*#__PURE__*/_interopDefaultLegacy(_isFinite);
+var _max__default = /*#__PURE__*/_interopDefaultLegacy(_max);
+var _flatMap__default = /*#__PURE__*/_interopDefaultLegacy(_flatMap);
+var _without__default = /*#__PURE__*/_interopDefaultLegacy(_without);
+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 _toConsumableArray__default = /*#__PURE__*/_interopDefaultLegacy(_toConsumableArray);
+var _typeof__default = /*#__PURE__*/_interopDefaultLegacy(_typeof);
+var _regeneratorRuntime__default = /*#__PURE__*/_interopDefaultLegacy(_regeneratorRuntime);
+var _asyncToGenerator__default = /*#__PURE__*/_interopDefaultLegacy(_asyncToGenerator);
+var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
+var mitt__default = /*#__PURE__*/_interopDefaultLegacy(mitt);
+var _isArray__default = /*#__PURE__*/_interopDefaultLegacy(_isArray);
+var _isFunction__default = /*#__PURE__*/_interopDefaultLegacy(_isFunction);
+var _get__default = /*#__PURE__*/_interopDefaultLegacy(_get);
+var _isString__default = /*#__PURE__*/_interopDefaultLegacy(_isString);
+var _identity__default = /*#__PURE__*/_interopDefaultLegacy(_identity);
+
+var callList = function callList(list, firstArg) {
+  for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+    args[_key - 2] = arguments[_key];
+  }
+
+  return list.map(function (_ref) {
+    var current = _ref.current;
+    return typeof firstArg === 'function' ? firstArg(current) : current.apply(void 0, [firstArg].concat(args));
+  });
+};
+
+var willUseSharedCallback = function willUseSharedCallback() {
+  var useEffect = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : React__default['default'].useEffect;
+  var mountedCallbacks = [];
+  var listenerCallbacks = [];
+
+  var remove = function remove(ref) {
+    return mountedCallbacks = mountedCallbacks.filter(function (_) {
+      return _ !== ref;
+    });
+  };
+
+  var add = function add(ref) {
+    return mountedCallbacks = mountedCallbacks.concat([ref]);
+  };
+
+  var get = function get() {
+    return mountedCallbacks;
+  };
+
+  var removeListener = function removeListener(ref) {
+    return listenerCallbacks = listenerCallbacks.filter(function (_) {
+      return _ !== ref;
+    });
+  };
+
+  var addListener = function addListener(ref) {
+    return listenerCallbacks = listenerCallbacks.concat([ref]);
+  };
+
+  var getListeners = function getListeners(ref) {
+    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];
+    }
+
+    var resp = callList.apply(void 0, [get()].concat(args));
+    callList.apply(void 0, [getListeners()].concat(args));
+    lastCall.current = args;
+    lastCall.index++;
+    return resp;
+  };
+
+  var getSize = function getSize() {
+    return get().length;
+  };
+
+  var useRegister = function useRegister(callback) {
+    var listener = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    var ref = React.useRef(callback);
+
+    if (ref.current !== callback) {
+      ref.current = callback;
+    }
+
+    var lastCallIndex = lastCall.index;
+    useEffect(function () {
+      if (!ref.current) {
+        return;
+      }
+
+      if (listener) {
+        addListener(ref);
+      } else {
+        add(ref);
+
+        if (lastCallIndex !== lastCall.index && lastCall.current) {
+          callList.apply(void 0, [[ref]].concat(_toConsumableArray__default['default'](lastCall.current)));
+        }
+      }
+
+      return function () {
+        if (listener) {
+          removeListener(ref);
+        } else {
+          remove(ref);
+        }
+      };
+    }, []);
+    return function () {
+      return get().indexOf(ref);
+    };
+  };
+
+  return [useRegister, call, getSize];
+};
+
+var notDefined = {};
+var willUseSharedState = function willUseSharedState(initialValue) {
+  var _willUseSharedCallbac = willUseSharedCallback(),
+      _willUseSharedCallbac2 = _slicedToArray__default['default'](_willUseSharedCallbac, 3),
+      useRegisterGroupCallback = _willUseSharedCallbac2[0],
+      callGroup = _willUseSharedCallbac2[1],
+      getSize = _willUseSharedCallbac2[2];
+
+  var sharedValue = utils.ifUndefined(initialValue, notDefined);
+
+  var setGroupState = function setGroupState(newValue) {
+    sharedValue = utils.callIfFunction(newValue, sharedValue);
+    callGroup(sharedValue);
+  };
+
+  var refState = function refState() {
+    useRegisterGroupCallback();
+    return [function () {
+      return sharedValue;
+    }, setGroupState];
+  };
+
+  var valueState = function valueState(defaultValue) {
+    var prevValue = sharedValue !== notDefined ? sharedValue : defaultValue;
+
+    if (prevValue === defaultValue) {
+      sharedValue = defaultValue;
+    }
+
+    var _useState = React.useState(prevValue),
+        _useState2 = _slicedToArray__default['default'](_useState, 2),
+        value = _useState2[0],
+        setValue = _useState2[1];
+
+    useRegisterGroupCallback(setValue);
+    return [value, setGroupState];
+  };
+
+  var clear = function clear() {
+    sharedValue = notDefined;
+  };
+
+  return [valueState, refState, setGroupState, function () {
+    return sharedValue;
+  }, 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(),
+    _willUseSharedState2 = _slicedToArray__default['default'](_willUseSharedState, 2),
+    useFillHookState = _willUseSharedState2[0],
+    useFillHookStateRef = _willUseSharedState2[1];
+
+var _willUseSharedState3 = willUseSharedState(),
+    _willUseSharedState4 = _slicedToArray__default['default'](_willUseSharedState3, 2),
+    useHiddenFillHookState = _willUseSharedState4[0],
+    useHiddenFillHookStateRef = _willUseSharedState4[1];
+
+var DEFAULT_CONTEXT = new Map();
+var SlotProvider = function SlotProvider(_ref) {
+  var children = _ref.children;
+  return React__default['default'].createElement(SlotContext.Provider, {
+    value: DEFAULT_CONTEXT
+  }, children, React__default['default'].createElement(React__default['default'].Suspense, {
+    fallback: null
+  }, React__default['default'].createElement(FillHooks, null)), React__default['default'].createElement(HiddenFillHooks, null));
+};
+var Slot = function Slot(_ref2) {
+  var name = _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 updates = (previous === null || previous === void 0 ? void 0 : previous.updates) || [];
+
+    if (previous === null || previous === void 0 ? void 0 : previous.children) ;
+
+    slots.set(name, _flow__default['default'](_update__default['default']('infos', _union__default['default']([slotInfo])))(previous));
+    updates.forEach(function (v) {
+      return v({});
+    });
+    return function () {
+      var _previous$infos, _previous$updates;
+
+      var previous = slots.get(name);
+      previous.infos = _without__default['default']([slotInfo], previous.infos);
+
+      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 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
+  }));
+};
+var Invisible = styled__default['default'].div.withConfig({
+  displayName: "SlotFill__Invisible",
+  componentId: "h3oh7r-0"
+})(["display:none"]);
+
+var FillBeforeFlip = function FillBeforeFlip(_ref3) {
+  var name = _ref3.name,
+      children = _ref3.children,
+      slot = _ref3.slot;
+  var slots = React.useContext(SlotContext);
+  var ref = React.useRef();
+  React.useLayoutEffect(function () {
+    var _slots$get;
+
+    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 ref = _ref4.ref;
+      return ref === null || ref === void 0 ? void 0 : ref.current;
+    }, infos);
+
+    var clones = [];
+
+    var getClone = function getClone() {
+      var cloned = ref.current.cloneNode(true);
+      cloned.className = 'JS-fill-flip';
+      clones.push(cloned);
+      return cloned;
+    };
+
+    mounted.map(function (_) {
+      return _.appendChild(getClone());
+    });
+    return function () {
+      clones.forEach(function (el) {
+        return el.remove();
+      });
+    };
+  }, []);
+  return React__default['default'].createElement(Invisible, {
+    ref: ref
+  }, 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,
+      _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.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 (mountBeforeFlip) {
+    return React__default['default'].createElement(FillBeforeFlip, {
+      name: name,
+      slot: slot
+    }, children);
+  } else {
+    return null;
+  }
+};
+
+var FillHooks = function FillHooks(_ref6) {
+  _objectDestructuringEmpty__default['default'](_ref6);
+
+  var _useFillHookState = useFillHookState({}),
+      _useFillHookState2 = _slicedToArray__default['default'](_useFillHookState, 1),
+      hooked = _useFillHookState2[0];
+
+  return Object.entries(hooked).map(function (_ref7) {
+    var _ref8 = _slicedToArray__default['default'](_ref7, 2),
+        name = _ref8[0],
+        childs = _ref8[1];
+
+    return childs.map(function (_ref9, i) {
+      var children = _ref9.children;
+      return React__default['default'].createElement(Fill, {
+        key: name + i,
+        name: name
+      }, children);
+    });
+  });
+};
+
+var uid = 0;
+var useFill = function useFill(name, children, inputs) {
+  var _useFillHookStateRef = useFillHookStateRef(),
+      _useFillHookStateRef2 = _slicedToArray__default['default'](_useFillHookStateRef, 2),
+      set = _useFillHookStateRef2[1];
+
+  var key = React.useRef(uid++);
+  React.useLayoutEffect(function () {
+    if (children) {
+      set(_update__default['default']([name], function () {
+        var list = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+
+        var index = _findIndex__default['default'](['key', key.current], list);
+
+        var value = {
+          children: children,
+          key: key.current
+        };
+
+        if (index >= 0) {
+          return _set__default['default']([index], value, list);
+        } else {
+          return list.concat(value);
+        }
+      }));
+    } else {
+      set(_update__default['default']([name], _differenceBy__default['default']('key', _differenceBy__default['default'].placeholder, [{
+        children: children,
+        key: key.current
+      }])));
+    }
+  }, inputs || children);
+  React.useLayoutEffect(function () {
+    return function () {
+      return set(_update__default['default']([name], _differenceBy__default['default']('key', _differenceBy__default['default'].placeholder, [{
+        key: key.current
+      }])));
+    };
+  }, []);
+};
+
+var HiddenFillHooks = function HiddenFillHooks(_ref10) {
+  _objectDestructuringEmpty__default['default'](_ref10);
+
+  var _useHiddenFillHookSta = useHiddenFillHookState({}),
+      _useHiddenFillHookSta2 = _slicedToArray__default['default'](_useHiddenFillHookSta, 1),
+      hookedChildren = _useHiddenFillHookSta2[0];
+
+  return React__default['default'].createElement("div", null, Object.values(hookedChildren));
+};
+
+var useHiddenFill = function useHiddenFill(children, inputs) {
+  var _useHiddenFillHookSta3 = useHiddenFillHookStateRef(),
+      _useHiddenFillHookSta4 = _slicedToArray__default['default'](_useHiddenFillHookSta3, 2),
+      set = _useHiddenFillHookSta4[1];
+
+  var _useMemo = React.useMemo(function () {
+    return _uniqueId__default['default']("");
+  }, []),
+      _useMemo2 = _slicedToArray__default['default'](_useMemo, 1),
+      uid = _useMemo2[0];
+
+  set(_set__default['default']([uid], children ? React__default['default'].cloneElement(children, {
+    key: uid
+  }) : null));
+  React.useEffect(function () {
+    return function () {
+      return set(_unset__default['default']([uid]));
+    };
+  }, []);
+};
+
+var isPath = function isPath(path) {
+  return typeof path === 'string' || typeof path === 'number' || Array.isArray(path);
+};
+
+var getter = function getter(value) {
+  return function (path) {
+    return path !== "" && isPath(path) ? utils._s.get(path, value) : value;
+  };
+};
+
+var uninitialized = {};
+var useRefState = function useRefState(defaultValue, setCallback) {
+  var ref = React.useRef(uninitialized);
+
+  if (ref.current === uninitialized) {
+    ref.current = utils.callIfFunction(defaultValue);
+  }
+
+  return React.useMemo(function () {
+    var get = function get(path) {
+      return getter(ref.current)(path);
+    };
+
+    var set = function set(v, config) {
+      var prev = ref.current;
+      ref.current = utils.callIfFunctions(v, function () {
+        return get();
+      });
+
+      if (prev !== ref.current && (!config || !config.ignoreCallback)) {
+        utils.callIfFunction(setCallback, prev, ref.current);
+      }
+    };
+
+    return {
+      get: get,
+      set: set
+    };
+  }, []);
+};
+
+var useCallState = function useCallState(defaultValue, setCallback) {
+  var _useState = React.useState(defaultValue),
+      _useState2 = _slicedToArray__default['default'](_useState, 2),
+      val = _useState2[0],
+      setValue = _useState2[1];
+
+  return React.useMemo(function () {
+    var get = function get() {
+      return val;
+    };
+
+    return {
+      get: get,
+      val: val,
+      set: setValue
+    };
+  }, [val]);
+};
+
+var useIsUnmounted = function useIsUnmounted() {
+  var unmounted = React.useRef();
+  React.useEffect(function () {
+    return function () {
+      return unmounted.current = true;
+    };
+  }, []);
+  return function () {
+    return unmounted.current;
+  };
+};
+
+var useToggleInternal = function useToggleInternal() {
+  var startWith = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+  var useStore = arguments.length > 1 ? arguments[1] : undefined;
+  var callback = arguments.length > 2 ? arguments[2] : undefined;
+  var key = arguments.length > 3 ? arguments[3] : undefined;
+  var isOpen = useStore(startWith);
+  var closing = useStore(false);
+  var refIsOpen = useRefState(isOpen.get());
+  var refIsClosing = useRefState(closing.get());
+  var timerId = React.useRef();
+  var isUnmounted = useIsUnmounted();
+
+  var clearClosing = function clearClosing() {
+    if (refIsClosing.get() !== false) {
+      closing.set(false);
+      refIsClosing.set(false);
+      window.clearTimeout(timerId.current);
+    }
+  };
+
+  var toggleWith = function toggleWith() {
+    var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+    var calledValue = utils.callIfFunction(value, refIsOpen.get());
+    var newValue = refIsOpen.get() === calledValue ? !calledValue : calledValue;
+
+    if (!isUnmounted() && refIsOpen.get() !== newValue) {
+      var result = utils.callIfFunction(callback, newValue, refIsOpen.get());
+
+      if (result === false) {
+        return;
+      }
+
+      isOpen.set(newValue);
+      refIsOpen.set(newValue);
+      clearClosing();
+    }
+  };
+
+  var openWith = function openWith(value) {
+    if (process.env.NODE_ENV !== 'production' && key) {
+      console.log(key, refIsOpen.get() !== value ? "toggle" : "clear", refIsOpen.get(), value);
+    }
+
+    var nextValue = utils.callIfFunction(value, refIsOpen.get());
+
+    if (refIsOpen.get() !== nextValue) {
+      toggleWith(function () {
+        return nextValue;
+      });
+    } else {
+      clearClosing();
+    }
+  };
+
+  var nextClosingTick = function nextClosingTick(ticks, tickIndex) {
+    if (ticks.length) {
+      if (isNaN(ticks[0])) {
+        clearClosing();
+      } else if (!isNaN(ticks[0])) {
+        closing.set(tickIndex + 1);
+        refIsClosing.set(tickIndex + 1);
+        timerId.current = setTimeout(function () {
+          return nextClosingTick(ticks.slice(1), tickIndex + 1);
+        }, Number(ticks[0]));
+      }
+    } else {
+      openWith(false);
+    }
+  };
+
+  var closeAfter = function closeAfter() {
+    if (process.env.NODE_ENV !== 'production' && key) {
+      console.log(key, !refIsOpen.get() || refIsClosing.get() ? "addCLosing" : "closing");
+    }
+
+    if (!refIsOpen.get() || refIsClosing.get()) return;
+
+    for (var _len = arguments.length, millisecs = new Array(_len), _key = 0; _key < _len; _key++) {
+      millisecs[_key] = arguments[_key];
+    }
+
+    nextClosingTick(millisecs, 0);
+  };
+
+  var _wait = function _wait(promise) {
+    var start = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    var end = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    return (
+      /*#__PURE__*/
+      _asyncToGenerator__default['default'](
+      /*#__PURE__*/
+      _regeneratorRuntime__default['default'].mark(function _callee() {
+        var _len2,
+            args,
+            _key2,
+            _args = arguments;
+
+        return _regeneratorRuntime__default['default'].wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                openWith(start);
+                _context.prev = 1;
+
+                for (_len2 = _args.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+                  args[_key2] = _args[_key2];
+                }
+
+                _context.next = 5;
+                return utils.callIfFunction.apply(void 0, [promise].concat(args));
+
+              case 5:
+                return _context.abrupt("return", _context.sent);
+
+              case 6:
+                _context.prev = 6;
+                openWith(end);
+                return _context.finish(6);
+
+              case 9:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this, [[1,, 6, 9]]);
+      }))
+    );
+  };
+
+  var setters = React.useMemo(function () {
+    return {
+      wait: function wait(promise) {
+        var start = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+        var end = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+        return _wait(promise, start, end)();
+      },
+      willWait: _wait,
+      open: function open(e) {
+        if (process.env.NODE_ENV !== 'production') {
+          if (['string', 'number', 'boolean'].indexOf(_typeof__default['default'](e)) >= 0) {
+            console.log("You are trying to open toggle with ".concat(e, ". Please, use openWith to open with a value"));
+          }
+        }
+
+        return openWith(true);
+      },
+      close: function close() {
+        return openWith(false);
+      },
+      toggle: function toggle(e) {
+        if (process.env.NODE_ENV !== 'production') {
+          if (['string', 'number', 'boolean'].indexOf(_typeof__default['default'](e)) >= 0) {
+            console.log("You are trying to toogle a toggle with ".concat(e, ". Please, use openWith to open with a value"));
+          }
+        }
+
+        toggleWith(true);
+      },
+      willOpenWith: function willOpenWith(value) {
+        return function () {
+          return openWith(value);
+        };
+      },
+      willCloseAfter: function willCloseAfter() {
+        for (var _len3 = arguments.length, millsecs = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+          millsecs[_key3] = arguments[_key3];
+        }
+
+        return function () {
+          return closeAfter.apply(void 0, millsecs);
+        };
+      },
+      willToggleWith: function willToggleWith(value) {
+        return function () {
+          return toggleWith(value);
+        };
+      },
+      openWith: openWith,
+      closeAfter: closeAfter,
+      toggleWith: toggleWith,
+      get: refIsOpen.get
+    };
+  }, []);
+
+  var settersWithNewRef = _objectSpread__default['default']({}, setters);
+
+  if (closing.val) {
+    return Object.assign(settersWithNewRef, {
+      isOpen: isOpen.val,
+      closing: closing.val
+    });
+  } else {
+    Object.defineProperties(settersWithNewRef, {
+      isOpen: {
+        enumerable: true,
+        get: isOpen.get
+      },
+      closing: {
+        enumerable: true,
+        get: closing.get
+      }
+    });
+    return settersWithNewRef;
+  }
+};
+
+var useToggle = function useToggle(startWith, callback, key) {
+  return useToggleInternal(startWith, useCallState, callback, key);
+};
+var useRefToggle = function useRefToggle(startWith) {
+  return useToggleInternal(startWith, useRefState);
+};
+
+var prevOpenToggleClose = function prevOpenToggleClose() {};
+
+var sameTick = false;
+var clearPopups = function clearPopups() {
+  if (!sameTick) {
+    prevOpenToggleClose();
+
+    prevOpenToggleClose = function prevOpenToggleClose() {};
+  }
+};
+var usePopupToggle = function usePopupToggle(startWith, callback) {
+  var toggle = useToggle(startWith, function (v, prev) {
+    var result = utils.callIfFunction(callback, v, prev);
+
+    if (result === false) {
+      return false;
+    }
+
+    if (v !== false && prevOpenToggleClose !== toggle.close) {
+      prevOpenToggleClose();
+      prevOpenToggleClose = toggle.close;
+      sameTick = true;
+      window.setTimeout(function () {
+        return sameTick = false;
+      }, 1);
+    }
+
+    if (v === false) {
+      prevOpenToggleClose = function prevOpenToggleClose() {};
+    }
+  });
+  return toggle;
+};
+
+var StartlibsContext = React__default['default'].createContext({});
+var PopupContext = React__default['default'].createContext({});
+var StartlibsMetacontext = React__default['default'].createContext(function () {});
+var StartlibsConsumer = StartlibsContext.Consumer;
+var wrappeStyle = {
+  height: '100%'
+};
+var StartlibsProvider =
+/*#__PURE__*/
+function (_React$Component) {
+  _inherits__default['default'](StartlibsProvider, _React$Component);
+
+  function StartlibsProvider() {
+    var _getPrototypeOf2;
+
+    var _this;
+
+    _classCallCheck__default['default'](this, StartlibsProvider);
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _possibleConstructorReturn__default['default'](this, (_getPrototypeOf2 = _getPrototypeOf__default['default'](StartlibsProvider)).call.apply(_getPrototypeOf2, [this].concat(args)));
+    _this.openToggles = new Map();
+
+    _this.popupToggleRender = function (_ref, ref) {
+      var isOpen = _ref.isOpen,
+          close = _ref.close;
+
+      if (isOpen && !_this.openToggles.has(ref)) {
+        _this.closePopup();
+
+        _this.openToggles.set(ref, close);
+      }
+    };
+
+    _this.closePopup = function () {
+      clearPopups();
+    };
+
+    _this.startlibsMeta = new Map();
+
+    _this.getMeta = function (key, initValue) {
+      var exists = _this.startlibsMeta.get(key);
+
+      if (exists) return exists;
+
+      _this.startlibsMeta.set(key, utils.callIfFunction(initValue));
+
+      return initValue;
+    };
+
+    return _this;
+  }
+
+  _createClass__default['default'](StartlibsProvider, [{
+    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",
+    value: function render() {
+      return React__default['default'].createElement(StartlibsContext.Provider, {
+        value: this.props.value
+      }, React__default['default'].createElement(StartlibsMetacontext.Provider, {
+        value: this.getMeta
+      }, React__default['default'].createElement(PopupContext.Provider, {
+        value: this.popupToggleRender
+      }, React__default['default'].createElement(SlotProvider, null, React__default['default'].createElement("div", {
+        style: wrappeStyle,
+        onClick: this.closePopup
+      }, this.props.children)))));
+    }
+  }]);
+
+  return StartlibsProvider;
+}(React__default['default'].Component);
+
+var propsOrConsume = function propsOrConsume(prop, Consumer, childrenAsFunction) {
+  return prop ? childrenAsFunction(prop) : React__default['default'].createElement(Consumer, null, childrenAsFunction);
+};
+
+var addConsumers = function addConsumers(Component, obj) {
+  return Object.entries(obj).reduce(function (acc, _ref) {
+    var _ref2 = _slicedToArray__default['default'](_ref, 2),
+        propKey = _ref2[0],
+        Consumer = _ref2[1];
+
+    return function (props) {
+      return propsOrConsume(props[propKey], Consumer, function (v) {
+        return acc(_objectSpread__default['default'](_defineProperty__default['default']({}, propKey, v), props));
+      });
+    };
+  }, function (props) {
+    return React__default['default'].createElement(Component, props);
+  });
+};
+
+var consumes = function consumes(obj) {
+  return function (Component) {
+    var withConsumers = addConsumers(Component, obj);
+    return function (props) {
+      return withConsumers(props);
+    };
+  };
+};
+
+var withDialogError = function withDialogError(Dialog) {
+  var ErrorBoundedComponent = React__default['default'].forwardRef(function (props, ref) {
+    return React__default['default'].createElement(Dialog, _extends__default['default']({
+      ref: ref
+    }, props)); // const ErrorBoundary = __internals('ErrorBoundary')
+
+    /*return (
+      <ErrorBoundary Error={props.Error || __internals('DialogError')} closeDialog={props.closeDialog}>
+        <Dialog {...props}/>
+      </ErrorBoundary>
+    )*/
+  }); // ErrorBoundedComponent.contextTypes = {startlibs:()=>null}
+
+  return ErrorBoundedComponent;
+};
+
+var GroupEventFactory = function GroupEventFactory() {
+  var emitter = mitt__default['default']();
+
+  var WithGroupEvent =
+  /*#__PURE__*/
+  function (_React$Component) {
+    _inherits__default['default'](WithGroupEvent, _React$Component);
+
+    function WithGroupEvent() {
+      var _getPrototypeOf2;
+
+      var _this;
+
+      _classCallCheck__default['default'](this, WithGroupEvent);
+
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+
+      _this = _possibleConstructorReturn__default['default'](this, (_getPrototypeOf2 = _getPrototypeOf__default['default'](WithGroupEvent)).call.apply(_getPrototypeOf2, [this].concat(args)));
+      _this.events = {};
+
+      _this.processEvent = function (type, event) {
+        (_this.events[type] || []).forEach(function (c) {
+          return c(event);
+        });
+      };
+
+      _this.groupEventProps = {
+        on: function on(type, callback) {
+          _this.events[type] = (_this.events[type] || []).concat(callback);
+        },
+        off: function off(type, callback) {
+          _this.events[type] = (_this.events[type] || []).filter(function (e) {
+            return e !== callback;
+          });
+        },
+        emit: emitter.emit
+      };
+      return _this;
+    }
+
+    _createClass__default['default'](WithGroupEvent, [{
+      key: "componentDidMount",
+      value: function componentDidMount() {
+        emitter.on('*', this.processEvent);
+      }
+    }, {
+      key: "componentWillUnmount",
+      value: function componentWillUnmount() {
+        emitter.off('*', this.processEvent);
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        return this.props.children(this.groupEventProps);
+      }
+    }]);
+
+    return WithGroupEvent;
+  }(React__default['default'].Component);
+
+  return WithGroupEvent;
+};
+var withGroupEvent = function withGroupEvent(Component) {
+  var WithGroupEvent = GroupEventFactory();
+  return React__default['default'].forwardRef(function (props, ref) {
+    return React__default['default'].createElement(WithGroupEvent, null, function (groupEvent) {
+      return React__default['default'].createElement(Component, _extends__default['default']({}, props, {
+        ref: ref,
+        groupEvent: groupEvent
+      }));
+    });
+  });
+};
+
+var WithRef =
+/*#__PURE__*/
+function (_React$Component) {
+  _inherits__default['default'](WithRef, _React$Component);
+
+  function WithRef(props) {
+    var _this;
+
+    _classCallCheck__default['default'](this, WithRef);
+
+    _this = _possibleConstructorReturn__default['default'](this, _getPrototypeOf__default['default'](WithRef).call(this, props));
+    var total = props.length || props.children.length;
+    var refs = new Array(total);
+
+    for (var i = 0; i < total; i++) {
+      refs[i] = React__default['default'].createRef();
+    }
+
+    _this.createdRefs = refs;
+    return _this;
+  }
+
+  _createClass__default['default'](WithRef, [{
+    key: "render",
+    value: function render() {
+      var children = this.props.children;
+      return children.apply(void 0, _toConsumableArray__default['default'](this.createdRefs));
+    }
+  }]);
+
+  return WithRef;
+}(React__default['default'].Component);
+
+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);
+};
+
+var WithLazyResource = function WithLazyResource(_ref) {
+  var value = _ref.value,
+      wrap = _ref.wrap,
+      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 || fallback !== undefined ? React__default['default'].createElement(React__default['default'].Suspense, {
+    fallback: utils.ifUndefined(fallback, null)
+  }, React__default['default'].createElement(Load, {
+    value: value,
+    forwardProps: forwardProps && props,
+    children: children
+  })) : React__default['default'].createElement(Load, {
+    value: value,
+    children: children,
+    forwardProps: forwardProps && props
+  });
+};
+
+var Load = function Load(_ref2) {
+  var value = _ref2.value,
+      children = _ref2.children,
+      forwardProps = _ref2.forwardProps;
+  var loaded = _isArray__default['default'](value) ? value.forEach(function (v) {
+    return v.promise();
+  }) || value.map(function (v) {
+    return v.read();
+  }) : value.read();
+
+  var _useReducer = React.useReducer(function (s) {
+    return s + 1;
+  }, 0),
+      _useReducer2 = _slicedToArray__default['default'](_useReducer, 2),
+      update = _useReducer2[1];
+
+  var refresh = function refresh() {
+    return Promise.all(_isArray__default['default'](value) ? value.map(function (v) {
+      return v.refresh().promise();
+    }) : [value.refresh().promise()]).then(update);
+  };
+
+  return forwardProps ? addExtraProp(children(loaded, {
+    refresh: refresh,
+    update: update
+  }), forwardProps) : children(loaded, {
+    refresh: refresh,
+    update: update
+  });
+};
+
+var WithEffect = function WithEffect(_ref) {
+  var _ref$inputs = _ref.inputs,
+      inputs = _ref$inputs === void 0 ? [] : _ref$inputs,
+      children = _ref.children;
+  React.useEffect(children, inputs);
+  return null;
+};
+
+var useConsumerCatalog = function useConsumerCatalog(mountCallback, unmountCallback) {
+  var elements = useRefState([]);
+  var register = utils.callMany(function (element) {
+    return elements.set(function (elements) {
+      return elements.concat([element]);
+    });
+  }, mountCallback);
+  var unregister = utils.callMany(function (element) {
+    return elements.set(function (elements) {
+      return elements.filter(function (_) {
+        return _ !== element;
+      });
+    });
+  }, unmountCallback);
+  var manager = React.useMemo(function () {
+    return {
+      register: register,
+      unregister: unregister
+    };
+  }, []);
+  return [elements.get, manager];
+};
+var useCatalogManager = function useCatalogManager(_ref, ref) {
+  var register = _ref.register,
+      unregister = _ref.unregister;
+  React.useEffect(function () {
+    register(ref);
+    return function () {
+      return unregister(ref);
+    };
+  }, [ref]);
+};
+
+var willUseLayers = function willUseLayers() {
+  var useEffect = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : React__default['default'].useEffect;
+
+  var _willUseSharedCallbac = willUseSharedCallback(useEffect),
+      _willUseSharedCallbac2 = _slicedToArray__default['default'](_willUseSharedCallbac, 3),
+      useRegisterSharedCallback = _willUseSharedCallbac2[0],
+      callGroup = _willUseSharedCallbac2[1],
+      _getSize = _willUseSharedCallbac2[2];
+
+  var useLayer = function useLayer() {
+    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+        onFirst = _ref.onFirst,
+        onEmpty = _ref.onEmpty,
+        onTop = _ref.onTop;
+
+    var listener = arguments.length > 1 ? arguments[1] : undefined;
+    var resetIndex = React.useCallback(function () {
+      setIndex(getIndex());
+
+      if (getIndex() + 1 === _getSize()) {
+        utils.callIfFunction(onTop, getIndex);
+      }
+    }, []);
+    var getIndex = useRegisterSharedCallback(resetIndex, listener);
+
+    var _useState = React.useState(getIndex()),
+        _useState2 = _slicedToArray__default['default'](_useState, 2),
+        index = _useState2[0],
+        setIndex = _useState2[1];
+
+    useEffect(function () {
+      if (getIndex() === 0) {
+        utils.callIfFunction(onFirst);
+      }
+
+      resetIndex();
+      return function () {
+        if (_getSize() === 0) {
+          utils.callIfFunction(onEmpty);
+        }
+
+        callGroup();
+      };
+    }, []);
+    return [index, {
+      isFirst: function isFirst() {
+        return getIndex() === 1;
+      },
+      isTop: function isTop() {
+        return getIndex() === _getSize() - 1;
+      },
+      isEmpty: function isEmpty() {
+        return _getSize() === 0;
+      },
+      getSize: function getSize() {
+        return _getSize();
+      }
+    }];
+  };
+
+  return [useLayer, _getSize];
+};
+
+var _willUseLayers = willUseLayers(),
+    _willUseLayers2 = _slicedToArray__default['default'](_willUseLayers, 1),
+    useTitleLayers = _willUseLayers2[0];
+
+var useTitle = function useTitle(title) {
+  var layer = useTitleLayers({
+    onTop: function onTop() {
+      document.title = title;
+    }
+  });
+};
+
+var TabFocus = styled__default['default'].div.withConfig({
+  displayName: "useRecycleFocus__TabFocus",
+  componentId: "kxnccs-0"
+})(["width:0;height:0;position:absolute;"]);
+var useRecycleFocus = function useRecycleFocus(ref) {
+  var enabled = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  var lastIndex = arguments.length > 2 ? arguments[2] : undefined;
+
+  var recycle = function recycle(i) {
+    return function (e) {
+      if (!enabled || !ref.current) {
+        return;
+      }
+
+      var nextTab = ref.current.querySelectorAll('[tabindex]');
+
+      if (nextTab) {
+        if (i < 0) {
+          console.log(nextTab[1]);
+          nextTab[1].focus();
+        } else {
+          console.log(nextTab[nextTab.length - 2]);
+          nextTab[nextTab.length - 2].focus();
+        }
+      }
+    };
+  };
+
+  return [React__default['default'].createElement(TabFocus, {
+    tabIndex: 1,
+    onFocus: recycle(0)
+  }), React__default['default'].createElement(TabFocus, {
+    tabIndex: lastIndex || 1,
+    onFocus: recycle(-1)
+  })];
+};
+
+function usePrevious(value, initialValue) {
+  var ref = React.useRef(initialValue);
+  React.useEffect(function () {
+    ref.current = value;
+  });
+  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;
+}
+function usePreviousForEffect(value, initialValue) {
+  var ref = React.useRef(initialValue);
+  React.useEffect(function () {
+    return function () {
+      ref.current = value;
+    };
+  }, [value]);
+  return ref.current;
+}
+
+var useEnsureRef = function useEnsureRef(forwardedRef) {
+  var ref = React.useRef();
+  return forwardedRef || ref;
+};
+
+var useForceUpdate = function useForceUpdate() {
+  var _useState = React.useState(0),
+      _useState2 = _slicedToArray__default['default'](_useState, 2),
+      value = _useState2[0],
+      setValue = _useState2[1]; // integer state
+
+
+  return function () {
+    return setValue(function (value) {
+      return value + 1;
+    });
+  }; // update the state to force render
+};
+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];
+
+    return function () {
+      return setV(function (value) {
+        return value + 1;
+      });
+    };
+  };
+
+  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) {
+  var pastFirstTime = React.useRef();
+  React.useEffect(function () {
+    if (pastFirstTime.current) {
+      return effect();
+    } else {
+      pastFirstTime.current = true;
+    }
+  }, inputs);
+};
+
+var updateAllInputsState = function updateAllInputsState(inputs, values) {
+  var deferedUndefined = [];
+  inputs.forEach(function (input) {
+    var _input = _slicedToArray__default['default'](input, 2),
+        setValue = _input[0],
+        selector = _input[1];
+
+    var newValue = selector(values);
+
+    if (newValue === undefined) {
+      deferedUndefined.push([setValue, newValue]);
+    } else {
+      setValue(newValue);
+    }
+  });
+  deferedUndefined.forEach(function (_ref) {
+    var _ref2 = _slicedToArray__default['default'](_ref, 2),
+        set = _ref2[0],
+        value = _ref2[1];
+
+    return set(value);
+  });
+};
+
+var pathSelector = function pathSelector(path) {
+  return utils._s.get(path || []);
+};
+
+var parsePathOrSelector = function parsePathOrSelector(pathOrSelector) {
+  var isNotSelector = typeof pathOrSelector !== 'function';
+
+  if (isNotSelector) {
+    return [utils.formatPath(pathOrSelector), pathSelector(pathOrSelector)];
+  } else {
+    return ['', pathOrSelector];
+  }
+};
+
+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(key) {
+    return _isString__default['default'](key) || _isArray__default['default'](key) ? _get__default['default'](key, globalState) : globalState;
+  };
+
+  var useProvideSpreadState = function useProvideSpreadState(initState, setCallback) {
+    var _useConsumerCatalog = useConsumerCatalog(function (input) {
+      return updateAllInputsState([input], state.get());
+    }),
+        _useConsumerCatalog2 = _slicedToArray__default['default'](_useConsumerCatalog, 2),
+        consumerList = _useConsumerCatalog2[0],
+        manager = _useConsumerCatalog2[1];
+
+    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);
+      globalState = state.get();
+      updateAllInputsState(consumerList(), state.get());
+    };
+
+    var contextValue = React.useMemo(function () {
+      return [state.get, setState, manager];
+    }, []);
+    return [Context.Provider, contextValue, [state.get, setState]];
+  };
+
+  var useSpreadState = function useSpreadState(pathOrSelector, inputs) {
+    var _useContext = React.useContext(Context),
+        _useContext2 = _slicedToArray__default['default'](_useContext, 3),
+        getSpreadState = _useContext2[0],
+        setSpreadState = _useContext2[1],
+        manager = _useContext2[2];
+
+    var _parsePathOrSelector = parsePathOrSelector(pathOrSelector),
+        _parsePathOrSelector2 = _slicedToArray__default['default'](_parsePathOrSelector, 2),
+        path = _parsePathOrSelector2[0],
+        selector = _parsePathOrSelector2[1];
+
+    var pathOrInput = [path] || inputs || [];
+
+    var _useState = React.useState(selector(getSpreadState())),
+        _useState2 = _slicedToArray__default['default'](_useState, 2),
+        value = _useState2[0],
+        setValue = _useState2[1];
+
+    var isUnmounted = useIsUnmounted();
+    var currentPath = useRefState(path);
+
+    if (path !== currentPath.get()) {
+      /* when path changes, the consumerCatalogCallback will update the new value
+      *  another solution would be to call setValue here directly
+      *  the return value will still be the old, but will be changed before render, just like getDerivedStateFromProps
+      *
+      *  if there's a need for the return value to be the same, the value or, if enters here new value,
+      *  can be returned in an temp variable
+      * */
+      currentPath.set(path);
+    }
+
+    var input = React.useMemo(function () {
+      return [function (v) {
+        /* noop for elements that may be unregistered while looping through consumerList */
+        if (path === currentPath.get() && !isUnmounted()) {
+          setValue(v);
+        }
+      }, selector];
+    }, pathOrInput);
+    useCatalogManager(manager, input);
+    var setState = React.useCallback(function (v) {
+      return setSpreadState((_isFunction__default['default'](v) ? pathOrSelector === undefined ? function () {
+        return v;
+      } : _update__default['default'] : _set__default['default'])(path, v), path);
+    }, pathOrInput);
+
+    var getValue = function getValue() {
+      return selector(getGlobalState());
+    };
+
+    return [value, setState, getValue];
+  };
+
+  return [useProvideSpreadState, useSpreadState, Context, getGlobalState];
+};
+
+var useRefMemo = function useRefMemo(value) {
+  var ref = React.useRef(value);
+
+  if (ref.current !== value) {
+    ref.current = utils.callIfFunction(value);
+  }
+
+  return ref;
+};
+
+var IS_ARRAY_ITEMS_EQUALS = function IS_ARRAY_ITEMS_EQUALS(a, b) {
+  return a.length === b.length && !a.find(function (itemA, i) {
+    return !Object.is(itemA, b[i]);
+  });
+};
+
+var IS_DEPS_EQUALS = function IS_DEPS_EQUALS() {
+  var a = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var b = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  return Object.is(a, b) || IS_ARRAY_ITEMS_EQUALS(a, b);
+};
+
+var SHALLOW_IS_EQUAL = function SHALLOW_IS_EQUAL(a, b) {
+  return Object.is(a, b) || _isArray__default['default'](a) && _isArray__default['default'](b) && IS_ARRAY_ITEMS_EQUALS(a, b);
+};
+
+var EMPTY_DEPS = [];
+var useUpdateSignal = function useUpdateSignal(initialValue) {
+  var value = React.useRef(initialValue);
+  value.current = initialValue;
+  return useLazyConstant(function () {
+    var registered = [];
+
+    var register = function register() {
+      var selector = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _identity__default['default'];
+      var isEqual = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : SHALLOW_IS_EQUAL;
+      var selectorRef = React.useRef();
+      selectorRef.current = selector;
+      var update = useForceUpdate();
+      var lastValueRef = React.useRef(utils._s.select(selectorRef.current, value.current));
+      React.useEffect(function () {
+        var item = [update, selectorRef, isEqual, lastValueRef];
+        registered = _toConsumableArray__default['default'](registered).concat([item]);
+        return function () {
+          registered = registered.filter(function (v) {
+            return v !== item;
+          });
+        };
+      }, []);
+      return lastValueRef.current;
+    };
+
+    var call = function call() {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+
+      return registered.forEach(function (_ref) {
+        var _ref2 = _slicedToArray__default['default'](_ref, 4),
+            fn = _ref2[0],
+            selectorRef = _ref2[1],
+            isEqual = _ref2[2],
+            lastValueRef = _ref2[3];
+
+        var nextValue = utils._s.select.apply(utils._s, [selectorRef.current].concat(args));
+
+        if (!utils.callIfFunction(isEqual, nextValue, lastValueRef.current)) {
+          lastValueRef.current = nextValue;
+          fn(nextValue);
+        }
+      });
+    };
+
+    return [register, call];
+  });
+};
+var useSelectorSignal = function useSelectorSignal(value) {
+  var prevValue = React.useRef(value);
+  var prevDeps = React.useRef(EMPTY_DEPS);
+
+  var _useState = React.useState(prevDeps.current),
+      _useState2 = _slicedToArray__default['default'](_useState, 2),
+      currentDeps = _useState2[0],
+      setCurrentDeps = _useState2[1];
+
+  var _useUpdateSignal = useUpdateSignal(value),
+      _useUpdateSignal2 = _slicedToArray__default['default'](_useUpdateSignal, 2),
+      _register = _useUpdateSignal2[0],
+      call = _useUpdateSignal2[1];
+
+  var register = React.useCallback(function (selector, deps, isEqual) {
+    if (!IS_DEPS_EQUALS(deps, prevDeps.current)) {
+      setCurrentDeps(deps);
+    }
+
+    return _register(selector, isEqual);
+  }, []);
+  React.useEffect(function () {
+    if (prevValue.current !== value || currentDeps !== prevDeps.current) {
+      prevValue.current = value;
+      prevDeps.current = currentDeps;
+      call(value);
+    }
+  }, [value, currentDeps]);
+  return register;
+};
+var createStatefulContext = function createStatefulContext(v) {
+  var Ctx = React__default['default'].createContext(v);
+
+  var Provider = function Provider(_ref3) {
+    var value = _ref3.value,
+        setValue = _ref3.setValue,
+        utils = _ref3.utils,
+        children = _ref3.children;
+    var register = useSelectorSignal(value);
+    var v = useLazyConstant(function () {
+      return [register, setValue, utils];
+    });
+    return React__default['default'].createElement(Ctx.Provider, {
+      value: v
+    }, children);
+  };
+
+  var useSelectValue = function useSelectValue(selector, deps, isEqual) {
+    var _useContext = React.useContext(Ctx),
+        _useContext2 = _slicedToArray__default['default'](_useContext, 1),
+        useRegister = _useContext2[0];
+
+    return useRegister(selector, deps, isEqual);
+  };
+
+  var useState = function useState(path, deps) {
+    var _useContext3 = React.useContext(Ctx),
+        _useContext4 = _slicedToArray__default['default'](_useContext3, 3),
+        useRegister = _useContext4[0],
+        set = _useContext4[1],
+        utils$1 = _useContext4[2];
+
+    var setValue = useConstant(function (update) {
+      return set(function (state) {
+        return path ? _update__default['default'](path, function (v) {
+          return utils.callIfFunction(update, v);
+        }, state) : utils.callIfFunction(update, state);
+      });
+    });
+    return [useRegister(path, deps), setValue, utils$1];
+  };
+
+  return [Provider, useState, useSelectValue];
+};
+var createSelectableContext = function createSelectableContext(v) {
+  var _createStatefulContex = createStatefulContext(v),
+      _createStatefulContex2 = _slicedToArray__default['default'](_createStatefulContex, 3),
+      Provider = _createStatefulContex2[0],
+      useSelectValue = _createStatefulContex2[2];
+
+  return [Provider, useSelectValue];
+};
+
+exports.Fill = Fill;
+exports.GroupEventFactory = GroupEventFactory;
+exports.PopupContext = PopupContext;
+exports.Slot = Slot;
+exports.SlotContext = SlotContext;
+exports.SlotProvider = SlotProvider;
+exports.StartlibsConsumer = StartlibsConsumer;
+exports.StartlibsContext = StartlibsContext;
+exports.StartlibsMetacontext = StartlibsMetacontext;
+exports.StartlibsProvider = StartlibsProvider;
+exports.WithEffect = WithEffect;
+exports.WithLazyResource = WithLazyResource;
+exports.WithRef = WithRef;
+exports.clearPopups = clearPopups;
+exports.consumes = consumes;
+exports.createSelectableContext = createSelectableContext;
+exports.createStatefulContext = createStatefulContext;
+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.usePreviousForEffect = usePreviousForEffect;
+exports.usePreviousUnique = usePreviousUnique;
+exports.useRecycleFocus = useRecycleFocus;
+exports.useRefMemo = useRefMemo;
+exports.useRefState = useRefState;
+exports.useRefToggle = useRefToggle;
+exports.useSelectorSignal = useSelectorSignal;
+exports.useTitle = useTitle;
+exports.useToggle = useToggle;
+exports.useUpdateEffect = useUpdateEffect;
+exports.useUpdateOnResize = useUpdateOnResize;
+exports.useUpdateSignal = useUpdateSignal;
+exports.willUseForceUpdate = willUseForceUpdate;
+exports.willUseLayers = willUseLayers;
+exports.willUseSharedCallback = willUseSharedCallback;
+exports.willUseSharedState = willUseSharedState;
+exports.willUseSpreadState = willUseSpreadState;
+exports.withDialogError = withDialogError;
+exports.withGroupEvent = withGroupEvent;