@startlibs/core 1.0.1 → 1.0.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/lib/index.js +321 -418
  2. package/package.json +2 -1
  3. package/rollup.config.js +9 -1
package/lib/index.js CHANGED
@@ -1,90 +1,46 @@
1
- 'use strict';
2
-
3
- Object.defineProperty(exports, '__esModule', { value: true });
4
-
5
- var _classCallCheck = require('@babel/runtime/helpers/classCallCheck');
6
- var _createClass = require('@babel/runtime/helpers/createClass');
7
- var _possibleConstructorReturn = require('@babel/runtime/helpers/possibleConstructorReturn');
8
- var _getPrototypeOf = require('@babel/runtime/helpers/getPrototypeOf');
9
- var _inherits = require('@babel/runtime/helpers/inherits');
10
- var _debounce = require('lodash/fp/debounce');
11
- var React = require('react');
12
- var utils = require('@startlibs/utils');
13
- var core = require('@startlibs/core');
14
- var _slicedToArray = require('@babel/runtime/helpers/slicedToArray');
15
- var _toConsumableArray = require('@babel/runtime/helpers/toConsumableArray');
16
- var _set = require('lodash/fp/set');
17
- var _update = require('lodash/fp/update');
18
- var _isFunction = require('lodash/fp/isFunction');
19
- var _get = require('lodash/fp/get');
20
- var _isArray = require('lodash/fp/isArray');
21
- var _isString = require('lodash/fp/isString');
22
- var _objectDestructuringEmpty = require('@babel/runtime/helpers/objectDestructuringEmpty');
23
- var _objectSpread = require('@babel/runtime/helpers/objectSpread');
24
- var _extends = require('@babel/runtime/helpers/extends');
25
- var _objectWithoutProperties = require('@babel/runtime/helpers/objectWithoutProperties');
26
- var _unset = require('lodash/fp/unset');
27
- var _uniqueId = require('lodash/fp/uniqueId');
28
- var _differenceBy = require('lodash/fp/differenceBy');
29
- var _findIndex = require('lodash/fp/findIndex');
30
- var _isFinite = require('lodash/fp/isFinite');
31
- var _max = require('lodash/fp/max');
32
- var _flatMap = require('lodash/fp/flatMap');
33
- var _without = require('lodash/fp/without');
34
- var _union = require('lodash/fp/union');
35
- var _flow = require('lodash/fp/flow');
36
- var ReactDOM = require('react-dom');
37
- var styled = require('styled-components');
38
- var _defineProperty = require('@babel/runtime/helpers/defineProperty');
39
- var mitt = require('mitt');
40
- var _typeof = require('@babel/runtime/helpers/typeof');
41
- var _regeneratorRuntime = require('@babel/runtime/regenerator');
42
- var _asyncToGenerator = require('@babel/runtime/helpers/asyncToGenerator');
43
- var _identity = require('lodash/fp/identity');
44
-
45
- function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
46
-
47
- var _classCallCheck__default = /*#__PURE__*/_interopDefaultLegacy(_classCallCheck);
48
- var _createClass__default = /*#__PURE__*/_interopDefaultLegacy(_createClass);
49
- var _possibleConstructorReturn__default = /*#__PURE__*/_interopDefaultLegacy(_possibleConstructorReturn);
50
- var _getPrototypeOf__default = /*#__PURE__*/_interopDefaultLegacy(_getPrototypeOf);
51
- var _inherits__default = /*#__PURE__*/_interopDefaultLegacy(_inherits);
52
- var _debounce__default = /*#__PURE__*/_interopDefaultLegacy(_debounce);
53
- var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
54
- var _slicedToArray__default = /*#__PURE__*/_interopDefaultLegacy(_slicedToArray);
55
- var _toConsumableArray__default = /*#__PURE__*/_interopDefaultLegacy(_toConsumableArray);
56
- var _set__default = /*#__PURE__*/_interopDefaultLegacy(_set);
57
- var _update__default = /*#__PURE__*/_interopDefaultLegacy(_update);
58
- var _isFunction__default = /*#__PURE__*/_interopDefaultLegacy(_isFunction);
59
- var _get__default = /*#__PURE__*/_interopDefaultLegacy(_get);
60
- var _isArray__default = /*#__PURE__*/_interopDefaultLegacy(_isArray);
61
- var _isString__default = /*#__PURE__*/_interopDefaultLegacy(_isString);
62
- var _objectDestructuringEmpty__default = /*#__PURE__*/_interopDefaultLegacy(_objectDestructuringEmpty);
63
- var _objectSpread__default = /*#__PURE__*/_interopDefaultLegacy(_objectSpread);
64
- var _extends__default = /*#__PURE__*/_interopDefaultLegacy(_extends);
65
- var _objectWithoutProperties__default = /*#__PURE__*/_interopDefaultLegacy(_objectWithoutProperties);
66
- var _unset__default = /*#__PURE__*/_interopDefaultLegacy(_unset);
67
- var _uniqueId__default = /*#__PURE__*/_interopDefaultLegacy(_uniqueId);
68
- var _differenceBy__default = /*#__PURE__*/_interopDefaultLegacy(_differenceBy);
69
- var _findIndex__default = /*#__PURE__*/_interopDefaultLegacy(_findIndex);
70
- var _isFinite__default = /*#__PURE__*/_interopDefaultLegacy(_isFinite);
71
- var _max__default = /*#__PURE__*/_interopDefaultLegacy(_max);
72
- var _flatMap__default = /*#__PURE__*/_interopDefaultLegacy(_flatMap);
73
- var _without__default = /*#__PURE__*/_interopDefaultLegacy(_without);
74
- var _union__default = /*#__PURE__*/_interopDefaultLegacy(_union);
75
- var _flow__default = /*#__PURE__*/_interopDefaultLegacy(_flow);
76
- var ReactDOM__default = /*#__PURE__*/_interopDefaultLegacy(ReactDOM);
77
- var styled__default = /*#__PURE__*/_interopDefaultLegacy(styled);
78
- var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
79
- var mitt__default = /*#__PURE__*/_interopDefaultLegacy(mitt);
80
- var _typeof__default = /*#__PURE__*/_interopDefaultLegacy(_typeof);
81
- var _regeneratorRuntime__default = /*#__PURE__*/_interopDefaultLegacy(_regeneratorRuntime);
82
- var _asyncToGenerator__default = /*#__PURE__*/_interopDefaultLegacy(_asyncToGenerator);
83
- var _identity__default = /*#__PURE__*/_interopDefaultLegacy(_identity);
84
-
85
- var StartlibsContext = React__default['default'].createContext({});
86
- var PopupContext = React__default['default'].createContext({});
87
- var StartlibsMetacontext = React__default['default'].createContext(function () {});
1
+ import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
2
+ import _createClass from '@babel/runtime/helpers/createClass';
3
+ import _possibleConstructorReturn from '@babel/runtime/helpers/possibleConstructorReturn';
4
+ import _getPrototypeOf from '@babel/runtime/helpers/getPrototypeOf';
5
+ import _inherits from '@babel/runtime/helpers/inherits';
6
+ import _debounce from 'lodash/fp/debounce';
7
+ import React, { useCallback, useState, useRef, useEffect, useMemo, useContext, useLayoutEffect, useReducer, useInsertionEffect } from 'react';
8
+ import { callIfFunction, fixMediaQuery, ifUndefined, formatPath, _s, callIfFunctions, callMany } from '@startlibs/utils';
9
+ import { clearPopups as clearPopups$1, SlotProvider as SlotProvider$1, willUseSharedCallback as willUseSharedCallback$1, useConsumerCatalog as useConsumerCatalog$1, useRefState as useRefState$1, useIsUnmounted as useIsUnmounted$1, useCatalogManager as useCatalogManager$1, willUseSharedState as willUseSharedState$1, useConstant as useConstant$1, useCallState as useCallState$1, useToggle as useToggle$1, willUseLayers as willUseLayers$1, useForceUpdate as useForceUpdate$1, useLazyConstant as useLazyConstant$1 } from '@startlibs/core';
10
+ import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
11
+ import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
12
+ import _set from 'lodash/fp/set';
13
+ import _update from 'lodash/fp/update';
14
+ import _isFunction from 'lodash/fp/isFunction';
15
+ import _get from 'lodash/fp/get';
16
+ import _isArray from 'lodash/fp/isArray';
17
+ import _isString from 'lodash/fp/isString';
18
+ import _objectDestructuringEmpty from '@babel/runtime/helpers/objectDestructuringEmpty';
19
+ import _objectSpread from '@babel/runtime/helpers/objectSpread';
20
+ import _extends from '@babel/runtime/helpers/extends';
21
+ import _objectWithoutProperties from '@babel/runtime/helpers/objectWithoutProperties';
22
+ import _unset from 'lodash/fp/unset';
23
+ import _uniqueId from 'lodash/fp/uniqueId';
24
+ import _differenceBy from 'lodash/fp/differenceBy';
25
+ import _findIndex from 'lodash/fp/findIndex';
26
+ import _isFinite from 'lodash/fp/isFinite';
27
+ import _max from 'lodash/fp/max';
28
+ import _flatMap from 'lodash/fp/flatMap';
29
+ import _without from 'lodash/fp/without';
30
+ import _union from 'lodash/fp/union';
31
+ import _flow from 'lodash/fp/flow';
32
+ import ReactDOM from 'react-dom';
33
+ import styled from 'styled-components';
34
+ import _defineProperty from '@babel/runtime/helpers/defineProperty';
35
+ import mitt from 'mitt';
36
+ import _typeof from '@babel/runtime/helpers/typeof';
37
+ import _regeneratorRuntime from '@babel/runtime/regenerator';
38
+ import _asyncToGenerator from '@babel/runtime/helpers/asyncToGenerator';
39
+ import _identity from 'lodash/fp/identity';
40
+
41
+ var StartlibsContext = React.createContext({});
42
+ var PopupContext = React.createContext({});
43
+ var StartlibsMetacontext = React.createContext(function () {});
88
44
  var StartlibsConsumer = StartlibsContext.Consumer;
89
45
  var wrappeStyle = {
90
46
  height: '100%'
@@ -92,20 +48,20 @@ var wrappeStyle = {
92
48
  var StartlibsProvider =
93
49
  /*#__PURE__*/
94
50
  function (_React$Component) {
95
- _inherits__default['default'](StartlibsProvider, _React$Component);
51
+ _inherits(StartlibsProvider, _React$Component);
96
52
 
97
53
  function StartlibsProvider() {
98
54
  var _getPrototypeOf2;
99
55
 
100
56
  var _this;
101
57
 
102
- _classCallCheck__default['default'](this, StartlibsProvider);
58
+ _classCallCheck(this, StartlibsProvider);
103
59
 
104
60
  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
105
61
  args[_key] = arguments[_key];
106
62
  }
107
63
 
108
- _this = _possibleConstructorReturn__default['default'](this, (_getPrototypeOf2 = _getPrototypeOf__default['default'](StartlibsProvider)).call.apply(_getPrototypeOf2, [this].concat(args)));
64
+ _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(StartlibsProvider)).call.apply(_getPrototypeOf2, [this].concat(args)));
109
65
  _this.openToggles = new Map();
110
66
 
111
67
  _this.popupToggleRender = function (_ref, ref) {
@@ -120,7 +76,7 @@ function (_React$Component) {
120
76
  };
121
77
 
122
78
  _this.closePopup = function () {
123
- core.clearPopups();
79
+ clearPopups$1();
124
80
  };
125
81
 
126
82
  _this.startlibsMeta = new Map();
@@ -130,7 +86,7 @@ function (_React$Component) {
130
86
 
131
87
  if (exists) return exists;
132
88
 
133
- _this.startlibsMeta.set(key, utils.callIfFunction(initValue));
89
+ _this.startlibsMeta.set(key, callIfFunction(initValue));
134
90
 
135
91
  return initValue;
136
92
  };
@@ -138,10 +94,10 @@ function (_React$Component) {
138
94
  return _this;
139
95
  }
140
96
 
141
- _createClass__default['default'](StartlibsProvider, [{
97
+ _createClass(StartlibsProvider, [{
142
98
  key: "componentDidMount",
143
99
  value: function componentDidMount() {
144
- utils.fixMediaQuery();
100
+ fixMediaQuery();
145
101
 
146
102
  var addVHFix = function addVHFix() {
147
103
  var _document$documentEle, _document$documentEle2;
@@ -150,33 +106,33 @@ function (_React$Component) {
150
106
  (_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"));
151
107
  };
152
108
 
153
- window.addEventListener('resize', _debounce__default['default'](200, addVHFix));
109
+ window.addEventListener('resize', _debounce(200, addVHFix));
154
110
  addVHFix();
155
111
  }
156
112
  }, {
157
113
  key: "render",
158
114
  value: function render() {
159
- return React__default['default'].createElement(StartlibsContext.Provider, {
115
+ return React.createElement(StartlibsContext.Provider, {
160
116
  value: this.props.value
161
- }, React__default['default'].createElement(StartlibsMetacontext.Provider, {
117
+ }, React.createElement(StartlibsMetacontext.Provider, {
162
118
  value: this.getMeta
163
- }, React__default['default'].createElement(PopupContext.Provider, {
119
+ }, React.createElement(PopupContext.Provider, {
164
120
  value: this.popupToggleRender
165
- }, React__default['default'].createElement("div", {
121
+ }, React.createElement("div", {
166
122
  style: wrappeStyle,
167
123
  onClick: this.closePopup
168
- }, React__default['default'].createElement(core.SlotProvider, null, this.props.children)))));
124
+ }, React.createElement(SlotProvider$1, null, this.props.children)))));
169
125
  }
170
126
  }]);
171
127
 
172
128
  return StartlibsProvider;
173
- }(React__default['default'].Component);
129
+ }(React.Component);
174
130
 
175
131
  var willUseLayers = function willUseLayers() {
176
- var useEffect = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : React__default['default'].useEffect;
132
+ var useEffect = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : React.useEffect;
177
133
 
178
- var _willUseSharedCallbac = core.willUseSharedCallback(useEffect),
179
- _willUseSharedCallbac2 = _slicedToArray__default['default'](_willUseSharedCallbac, 3),
134
+ var _willUseSharedCallbac = willUseSharedCallback$1(useEffect),
135
+ _willUseSharedCallbac2 = _slicedToArray(_willUseSharedCallbac, 3),
180
136
  useRegisterSharedCallback = _willUseSharedCallbac2[0],
181
137
  callGroup = _willUseSharedCallbac2[1],
182
138
  _getSize = _willUseSharedCallbac2[2];
@@ -189,31 +145,31 @@ var willUseLayers = function willUseLayers() {
189
145
  onRemove = _ref.onRemove;
190
146
 
191
147
  var listener = arguments.length > 1 ? arguments[1] : undefined;
192
- var resetIndex = React.useCallback(function () {
148
+ var resetIndex = useCallback(function () {
193
149
  setIndex(getIndex());
194
150
 
195
151
  if (getIndex() + 1 === _getSize()) {
196
- utils.callIfFunction(onTop, getIndex);
152
+ callIfFunction(onTop, getIndex);
197
153
  }
198
154
  }, []);
199
155
  var getIndex = useRegisterSharedCallback(resetIndex, listener);
200
156
 
201
- var _useState = React.useState(getIndex()),
202
- _useState2 = _slicedToArray__default['default'](_useState, 2),
157
+ var _useState = useState(getIndex()),
158
+ _useState2 = _slicedToArray(_useState, 2),
203
159
  index = _useState2[0],
204
160
  setIndex = _useState2[1];
205
161
 
206
162
  useEffect(function () {
207
163
  if (getIndex() === 0) {
208
- utils.callIfFunction(onFirst);
164
+ callIfFunction(onFirst);
209
165
  }
210
166
 
211
167
  resetIndex();
212
168
  return function () {
213
- utils.callIfFunction(onRemove, _getSize());
169
+ callIfFunction(onRemove, _getSize());
214
170
 
215
171
  if (_getSize() === 0) {
216
- utils.callIfFunction(onEmpty);
172
+ callIfFunction(onEmpty);
217
173
  }
218
174
 
219
175
  callGroup();
@@ -250,7 +206,7 @@ var callList = function callList(list, firstArg) {
250
206
  };
251
207
 
252
208
  var willUseSharedCallback = function willUseSharedCallback() {
253
- var useEffect = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : React__default['default'].useEffect;
209
+ var useEffect = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : React.useEffect;
254
210
  var mountedCallbacks = [];
255
211
  var listenerCallbacks = [];
256
212
 
@@ -305,7 +261,7 @@ var willUseSharedCallback = function willUseSharedCallback() {
305
261
 
306
262
  var useRegister = function useRegister(callback) {
307
263
  var listener = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
308
- var ref = React.useRef(callback);
264
+ var ref = useRef(callback);
309
265
 
310
266
  if (ref.current !== callback) {
311
267
  ref.current = callback;
@@ -323,7 +279,7 @@ var willUseSharedCallback = function willUseSharedCallback() {
323
279
  add(ref);
324
280
 
325
281
  if (lastCallIndex !== lastCall.index && lastCall.current) {
326
- callList.apply(void 0, [[ref]].concat(_toConsumableArray__default['default'](lastCall.current)));
282
+ callList.apply(void 0, [[ref]].concat(_toConsumableArray(lastCall.current)));
327
283
  }
328
284
  }
329
285
 
@@ -345,16 +301,16 @@ var willUseSharedCallback = function willUseSharedCallback() {
345
301
 
346
302
  var notDefined = {};
347
303
  var willUseSharedState = function willUseSharedState(initialValue) {
348
- var _willUseSharedCallbac = core.willUseSharedCallback(),
349
- _willUseSharedCallbac2 = _slicedToArray__default['default'](_willUseSharedCallbac, 3),
304
+ var _willUseSharedCallbac = willUseSharedCallback$1(),
305
+ _willUseSharedCallbac2 = _slicedToArray(_willUseSharedCallbac, 3),
350
306
  useRegisterGroupCallback = _willUseSharedCallbac2[0],
351
307
  callGroup = _willUseSharedCallbac2[1],
352
308
  getSize = _willUseSharedCallbac2[2];
353
309
 
354
- var sharedValue = utils.ifUndefined(initialValue, notDefined);
310
+ var sharedValue = ifUndefined(initialValue, notDefined);
355
311
 
356
312
  var setGroupState = function setGroupState(newValue) {
357
- sharedValue = utils.callIfFunction(newValue, sharedValue);
313
+ sharedValue = callIfFunction(newValue, sharedValue);
358
314
  callGroup(sharedValue);
359
315
  };
360
316
 
@@ -372,8 +328,8 @@ var willUseSharedState = function willUseSharedState(initialValue) {
372
328
  sharedValue = defaultValue;
373
329
  }
374
330
 
375
- var _useState = React.useState(prevValue),
376
- _useState2 = _slicedToArray__default['default'](_useState, 2),
331
+ var _useState = useState(prevValue),
332
+ _useState2 = _slicedToArray(_useState, 2),
377
333
  value = _useState2[0],
378
334
  setValue = _useState2[1];
379
335
 
@@ -393,7 +349,7 @@ var willUseSharedState = function willUseSharedState(initialValue) {
393
349
  var updateAllInputsState = function updateAllInputsState(inputs, values) {
394
350
  var deferedUndefined = [];
395
351
  inputs.forEach(function (input) {
396
- var _input = _slicedToArray__default['default'](input, 2),
352
+ var _input = _slicedToArray(input, 2),
397
353
  setValue = _input[0],
398
354
  selector = _input[1];
399
355
 
@@ -406,7 +362,7 @@ var updateAllInputsState = function updateAllInputsState(inputs, values) {
406
362
  }
407
363
  });
408
364
  deferedUndefined.forEach(function (_ref) {
409
- var _ref2 = _slicedToArray__default['default'](_ref, 2),
365
+ var _ref2 = _slicedToArray(_ref, 2),
410
366
  set = _ref2[0],
411
367
  value = _ref2[1];
412
368
 
@@ -415,14 +371,14 @@ var updateAllInputsState = function updateAllInputsState(inputs, values) {
415
371
  };
416
372
 
417
373
  var pathSelector = function pathSelector(path) {
418
- return utils._s.get(path || []);
374
+ return _s.get(path || []);
419
375
  };
420
376
 
421
377
  var parsePathOrSelector = function parsePathOrSelector(pathOrSelector) {
422
378
  var isNotSelector = typeof pathOrSelector !== 'function';
423
379
 
424
380
  if (isNotSelector) {
425
- return [utils.formatPath(pathOrSelector), pathSelector(pathOrSelector)];
381
+ return [formatPath(pathOrSelector), pathSelector(pathOrSelector)];
426
382
  } else {
427
383
  return ['', pathOrSelector];
428
384
  }
@@ -430,24 +386,24 @@ var parsePathOrSelector = function parsePathOrSelector(pathOrSelector) {
430
386
 
431
387
  var willUseSpreadState = function willUseSpreadState(defaultContextValue) {
432
388
  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
433
- var Context = React__default['default'].createContext(defaultContextValue);
389
+ var Context = React.createContext(defaultContextValue);
434
390
  var EMPTY_GLOBAL = {};
435
391
  var prevInitState = EMPTY_GLOBAL;
436
392
  var globalState = EMPTY_GLOBAL;
437
393
 
438
394
  var getGlobalState = function getGlobalState(key) {
439
- return _isString__default['default'](key) || _isArray__default['default'](key) ? _get__default['default'](key, globalState) : globalState;
395
+ return _isString(key) || _isArray(key) ? _get(key, globalState) : globalState;
440
396
  };
441
397
 
442
398
  var useProvideSpreadState = function useProvideSpreadState(initState, setCallback) {
443
- var _useConsumerCatalog = core.useConsumerCatalog(function (input) {
399
+ var _useConsumerCatalog = useConsumerCatalog$1(function (input) {
444
400
  return updateAllInputsState([input], state.get());
445
401
  }),
446
- _useConsumerCatalog2 = _slicedToArray__default['default'](_useConsumerCatalog, 2),
402
+ _useConsumerCatalog2 = _slicedToArray(_useConsumerCatalog, 2),
447
403
  consumerList = _useConsumerCatalog2[0],
448
404
  manager = _useConsumerCatalog2[1];
449
405
 
450
- var state = core.useRefState(initState, setCallback);
406
+ var state = useRefState$1(initState, setCallback);
451
407
 
452
408
  if (options.initRefCheck) {
453
409
  if (prevInitState !== initState) {
@@ -461,7 +417,7 @@ var willUseSpreadState = function willUseSpreadState(defaultContextValue) {
461
417
  globalState = initState;
462
418
  }
463
419
 
464
- React.useEffect(function () {
420
+ useEffect(function () {
465
421
  globalState = state.get();
466
422
  }, []);
467
423
 
@@ -472,33 +428,33 @@ var willUseSpreadState = function willUseSpreadState(defaultContextValue) {
472
428
  updateAllInputsState(consumerList(), state.get());
473
429
  };
474
430
 
475
- var contextValue = React.useMemo(function () {
431
+ var contextValue = useMemo(function () {
476
432
  return [state.get, setState, manager];
477
433
  }, []);
478
434
  return [Context.Provider, contextValue, [state.get, setState]];
479
435
  };
480
436
 
481
437
  var useSpreadState = function useSpreadState(pathOrSelector, inputs) {
482
- var _useContext = React.useContext(Context),
483
- _useContext2 = _slicedToArray__default['default'](_useContext, 3),
438
+ var _useContext = useContext(Context),
439
+ _useContext2 = _slicedToArray(_useContext, 3),
484
440
  getSpreadState = _useContext2[0],
485
441
  setSpreadState = _useContext2[1],
486
442
  manager = _useContext2[2];
487
443
 
488
444
  var _parsePathOrSelector = parsePathOrSelector(pathOrSelector),
489
- _parsePathOrSelector2 = _slicedToArray__default['default'](_parsePathOrSelector, 2),
445
+ _parsePathOrSelector2 = _slicedToArray(_parsePathOrSelector, 2),
490
446
  path = _parsePathOrSelector2[0],
491
447
  selector = _parsePathOrSelector2[1];
492
448
 
493
449
  var pathOrInput = [path] || inputs || [];
494
450
 
495
- var _useState = React.useState(selector(getSpreadState())),
496
- _useState2 = _slicedToArray__default['default'](_useState, 2),
451
+ var _useState = useState(selector(getSpreadState())),
452
+ _useState2 = _slicedToArray(_useState, 2),
497
453
  value = _useState2[0],
498
454
  setValue = _useState2[1];
499
455
 
500
- var isUnmounted = core.useIsUnmounted();
501
- var currentPath = core.useRefState(path);
456
+ var isUnmounted = useIsUnmounted$1();
457
+ var currentPath = useRefState$1(path);
502
458
 
503
459
  if (path !== currentPath.get()) {
504
460
  /* when path changes, the consumerCatalogCallback will update the new value
@@ -511,7 +467,7 @@ var willUseSpreadState = function willUseSpreadState(defaultContextValue) {
511
467
  currentPath.set(path);
512
468
  }
513
469
 
514
- var input = React.useMemo(function () {
470
+ var input = useMemo(function () {
515
471
  return [function (v) {
516
472
  /* noop for elements that may be unregistered while looping through consumerList */
517
473
  if (path === currentPath.get() && !isUnmounted()) {
@@ -519,11 +475,11 @@ var willUseSpreadState = function willUseSpreadState(defaultContextValue) {
519
475
  }
520
476
  }, selector];
521
477
  }, pathOrInput);
522
- core.useCatalogManager(manager, input);
523
- var setState = React.useCallback(function (v) {
524
- return setSpreadState((_isFunction__default['default'](v) ? pathOrSelector === undefined ? function () {
478
+ useCatalogManager$1(manager, input);
479
+ var setState = useCallback(function (v) {
480
+ return setSpreadState((_isFunction(v) ? pathOrSelector === undefined ? function () {
525
481
  return v;
526
- } : _update__default['default'] : _set__default['default'])(path, v), path);
482
+ } : _update : _set)(path, v), path);
527
483
  }, pathOrInput);
528
484
 
529
485
  var getValue = function getValue() {
@@ -536,44 +492,44 @@ var willUseSpreadState = function willUseSpreadState(defaultContextValue) {
536
492
  return [useProvideSpreadState, useSpreadState, Context, getGlobalState];
537
493
  };
538
494
 
539
- var SlotContext = React__default['default'].createContext(new Map());
495
+ var SlotContext = React.createContext(new Map());
540
496
 
541
- var _willUseSharedState = core.willUseSharedState(),
542
- _willUseSharedState2 = _slicedToArray__default['default'](_willUseSharedState, 2),
497
+ var _willUseSharedState = willUseSharedState$1(),
498
+ _willUseSharedState2 = _slicedToArray(_willUseSharedState, 2),
543
499
  useFillHookState = _willUseSharedState2[0],
544
500
  useFillHookStateRef = _willUseSharedState2[1];
545
501
 
546
- var _willUseSharedState3 = core.willUseSharedState(),
547
- _willUseSharedState4 = _slicedToArray__default['default'](_willUseSharedState3, 2),
502
+ var _willUseSharedState3 = willUseSharedState$1(),
503
+ _willUseSharedState4 = _slicedToArray(_willUseSharedState3, 2),
548
504
  useHiddenFillHookState = _willUseSharedState4[0],
549
505
  useHiddenFillHookStateRef = _willUseSharedState4[1];
550
506
 
551
507
  var DEFAULT_CONTEXT = new Map();
552
508
  var SlotProvider = function SlotProvider(_ref) {
553
509
  var children = _ref.children;
554
- return React__default['default'].createElement(SlotContext.Provider, {
510
+ return React.createElement(SlotContext.Provider, {
555
511
  value: DEFAULT_CONTEXT
556
- }, children, React__default['default'].createElement(React__default['default'].Suspense, {
512
+ }, children, React.createElement(React.Suspense, {
557
513
  fallback: null
558
- }, React__default['default'].createElement(FillHooks, null)), React__default['default'].createElement(HiddenFillHooks, null));
514
+ }, React.createElement(FillHooks, null)), React.createElement(HiddenFillHooks, null));
559
515
  };
560
516
  var Slot = function Slot(_ref2) {
561
517
  var name = _ref2.name,
562
518
  children = _ref2.children,
563
- rest = _objectWithoutProperties__default['default'](_ref2, ["name", "children"]);
519
+ rest = _objectWithoutProperties(_ref2, ["name", "children"]);
564
520
 
565
- var ref = React.useRef();
566
- var slotInfo = core.useConstant({
521
+ var ref = useRef();
522
+ var slotInfo = useConstant$1({
567
523
  ref: ref
568
524
  });
569
- var slots = React.useContext(SlotContext);
570
- React.useLayoutEffect(function () {
525
+ var slots = useContext(SlotContext);
526
+ useLayoutEffect(function () {
571
527
  var previous = slots.get(name);
572
528
  var updates = (previous === null || previous === void 0 ? void 0 : previous.updates) || [];
573
529
 
574
530
  if (previous === null || previous === void 0 ? void 0 : previous.children) ;
575
531
 
576
- slots.set(name, _flow__default['default'](_update__default['default']('infos', _union__default['default']([slotInfo])))(previous));
532
+ slots.set(name, _flow(_update('infos', _union([slotInfo])))(previous));
577
533
  updates.forEach(function (v) {
578
534
  return v({});
579
535
  });
@@ -581,29 +537,29 @@ var Slot = function Slot(_ref2) {
581
537
  var _previous$infos, _previous$updates;
582
538
 
583
539
  var previous = slots.get(name);
584
- previous.infos = _without__default['default']([slotInfo], previous.infos);
540
+ previous.infos = _without([slotInfo], previous.infos);
585
541
 
586
542
  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)) {
587
543
  slots.delete(name);
588
544
  }
589
545
  };
590
546
  }, [name]);
591
- return children ? React__default['default'].createElement(React__default['default'].Fragment, null, React__default['default'].createElement("div", _extends__default['default']({
547
+ return children ? React.createElement(React.Fragment, null, React.createElement("div", _extends({
592
548
  "data-id": name
593
549
  }, rest, {
594
550
  ref: ref
595
- })), React__default['default'].Children.map(children, function (c) {
596
- return React__default['default'].cloneElement(c, _objectSpread__default['default']({}, c.props, {
551
+ })), React.Children.map(children, function (c) {
552
+ return React.cloneElement(c, _objectSpread({}, c.props, {
597
553
  name: name,
598
554
  stack: Number.MIN_SAFE_INTEGER
599
555
  }));
600
- })) : React__default['default'].createElement("div", _extends__default['default']({
556
+ })) : React.createElement("div", _extends({
601
557
  "data-id": name
602
558
  }, rest, {
603
559
  ref: ref
604
560
  }));
605
561
  };
606
- var Invisible = styled__default['default'].div.withConfig({
562
+ var Invisible = styled.div.withConfig({
607
563
  displayName: "SlotFill__Invisible",
608
564
  componentId: "h3oh7r-0"
609
565
  })(["display:none"]);
@@ -612,14 +568,14 @@ var FillBeforeFlip = function FillBeforeFlip(_ref3) {
612
568
  var name = _ref3.name,
613
569
  children = _ref3.children,
614
570
  slot = _ref3.slot;
615
- var slots = React.useContext(SlotContext);
616
- var ref = React.useRef();
617
- React.useLayoutEffect(function () {
571
+ var slots = useContext(SlotContext);
572
+ var ref = useRef();
573
+ useLayoutEffect(function () {
618
574
  var _slots$get;
619
575
 
620
576
  var infos = ((_slots$get = slots.get(name)) === null || _slots$get === void 0 ? void 0 : _slots$get.infos) || [];
621
577
 
622
- var mounted = _flatMap__default['default'](function (_ref4) {
578
+ var mounted = _flatMap(function (_ref4) {
623
579
  var ref = _ref4.ref;
624
580
  return ref === null || ref === void 0 ? void 0 : ref.current;
625
581
  }, infos);
@@ -642,23 +598,23 @@ var FillBeforeFlip = function FillBeforeFlip(_ref3) {
642
598
  });
643
599
  };
644
600
  }, []);
645
- return React__default['default'].createElement(Invisible, {
601
+ return React.createElement(Invisible, {
646
602
  ref: ref
647
603
  }, children);
648
604
  };
649
605
 
650
606
  var useFillState = function useFillState(name, stack) {
651
- var forceUpdate = React__default['default'].useState(false)[1];
652
- var slots = React.useContext(SlotContext);
607
+ var forceUpdate = React.useState(false)[1];
608
+ var slots = useContext(SlotContext);
653
609
  var renderSlot = slots.get(name);
654
610
 
655
- var maxStack = _max__default['default'](renderSlot === null || renderSlot === void 0 ? void 0 : renderSlot.stacks);
611
+ var maxStack = _max(renderSlot === null || renderSlot === void 0 ? void 0 : renderSlot.stacks);
656
612
 
657
- var onStack = !_isFinite__default['default'](maxStack) || maxStack === stack;
658
- React.useLayoutEffect(function () {
613
+ var onStack = !_isFinite(maxStack) || maxStack === stack;
614
+ useLayoutEffect(function () {
659
615
  var slot = slots.get(name);
660
616
 
661
- var updatedSlot = _flow__default['default'](_update__default['default']('updates', _union__default['default']([forceUpdate])), _update__default['default']('stacks', _union__default['default']([stack])))(slot);
617
+ var updatedSlot = _flow(_update('updates', _union([forceUpdate])), _update('stacks', _union([stack])))(slot);
662
618
 
663
619
  slots.set(name, updatedSlot);
664
620
  updatedSlot.updates.forEach(function (v) {
@@ -668,7 +624,7 @@ var useFillState = function useFillState(name, stack) {
668
624
  var previous = slots.get(name);
669
625
  var index = previous.updates.indexOf(forceUpdate);
670
626
 
671
- var next = _flow__default['default'](_update__default['default']('updates', utils._s.removeAt(index)), _update__default['default']('stacks', utils._s.removeAt(index)))(previous);
627
+ var next = _flow(_update('updates', _s.removeAt(index)), _update('stacks', _s.removeAt(index)))(previous);
672
628
 
673
629
  slots.set(name, next);
674
630
  next.updates.forEach(function (v) {
@@ -687,7 +643,7 @@ var Fill = function Fill(_ref5) {
687
643
  mountBeforeFlip = _ref5.mountBeforeFlip;
688
644
 
689
645
  var _useFillState = useFillState(name, stack),
690
- _useFillState2 = _slicedToArray__default['default'](_useFillState, 2),
646
+ _useFillState2 = _slicedToArray(_useFillState, 2),
691
647
  slot = _useFillState2[0],
692
648
  onStack = _useFillState2[1];
693
649
 
@@ -695,10 +651,10 @@ var Fill = function Fill(_ref5) {
695
651
  return slot === null || slot === void 0 ? void 0 : slot.infos.map(function (info) {
696
652
  var _info$ref;
697
653
 
698
- 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);
654
+ return ((_info$ref = info.ref) === null || _info$ref === void 0 ? void 0 : _info$ref.current) && ReactDOM.createPortal(callIfFunction(children, info), info.ref.current);
699
655
  });
700
656
  } else if (mountBeforeFlip) {
701
- return React__default['default'].createElement(FillBeforeFlip, {
657
+ return React.createElement(FillBeforeFlip, {
702
658
  name: name,
703
659
  slot: slot
704
660
  }, children);
@@ -708,20 +664,20 @@ var Fill = function Fill(_ref5) {
708
664
  };
709
665
 
710
666
  var FillHooks = function FillHooks(_ref6) {
711
- _objectDestructuringEmpty__default['default'](_ref6);
667
+ _objectDestructuringEmpty(_ref6);
712
668
 
713
669
  var _useFillHookState = useFillHookState({}),
714
- _useFillHookState2 = _slicedToArray__default['default'](_useFillHookState, 1),
670
+ _useFillHookState2 = _slicedToArray(_useFillHookState, 1),
715
671
  hooked = _useFillHookState2[0];
716
672
 
717
673
  return Object.entries(hooked).map(function (_ref7) {
718
- var _ref8 = _slicedToArray__default['default'](_ref7, 2),
674
+ var _ref8 = _slicedToArray(_ref7, 2),
719
675
  name = _ref8[0],
720
676
  childs = _ref8[1];
721
677
 
722
678
  return childs.map(function (_ref9, i) {
723
679
  var children = _ref9.children;
724
- return React__default['default'].createElement(Fill, {
680
+ return React.createElement(Fill, {
725
681
  key: name + i,
726
682
  name: name
727
683
  }, children);
@@ -732,16 +688,16 @@ var FillHooks = function FillHooks(_ref6) {
732
688
  var uid = 0;
733
689
  var useFill = function useFill(name, children, inputs) {
734
690
  var _useFillHookStateRef = useFillHookStateRef(),
735
- _useFillHookStateRef2 = _slicedToArray__default['default'](_useFillHookStateRef, 2),
691
+ _useFillHookStateRef2 = _slicedToArray(_useFillHookStateRef, 2),
736
692
  set = _useFillHookStateRef2[1];
737
693
 
738
- var key = React.useRef(uid++);
739
- React.useLayoutEffect(function () {
694
+ var key = useRef(uid++);
695
+ useLayoutEffect(function () {
740
696
  if (children) {
741
- set(_update__default['default']([name], function () {
697
+ set(_update([name], function () {
742
698
  var list = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
743
699
 
744
- var index = _findIndex__default['default'](['key', key.current], list);
700
+ var index = _findIndex(['key', key.current], list);
745
701
 
746
702
  var value = {
747
703
  children: children,
@@ -749,21 +705,21 @@ var useFill = function useFill(name, children, inputs) {
749
705
  };
750
706
 
751
707
  if (index >= 0) {
752
- return _set__default['default']([index], value, list);
708
+ return _set([index], value, list);
753
709
  } else {
754
710
  return list.concat(value);
755
711
  }
756
712
  }));
757
713
  } else {
758
- set(_update__default['default']([name], _differenceBy__default['default']('key', _differenceBy__default['default'].placeholder, [{
714
+ set(_update([name], _differenceBy('key', _differenceBy.placeholder, [{
759
715
  children: children,
760
716
  key: key.current
761
717
  }])));
762
718
  }
763
719
  }, inputs || children);
764
- React.useLayoutEffect(function () {
720
+ useLayoutEffect(function () {
765
721
  return function () {
766
- return set(_update__default['default']([name], _differenceBy__default['default']('key', _differenceBy__default['default'].placeholder, [{
722
+ return set(_update([name], _differenceBy('key', _differenceBy.placeholder, [{
767
723
  key: key.current
768
724
  }])));
769
725
  };
@@ -771,53 +727,53 @@ var useFill = function useFill(name, children, inputs) {
771
727
  };
772
728
 
773
729
  var HiddenFillHooks = function HiddenFillHooks(_ref10) {
774
- _objectDestructuringEmpty__default['default'](_ref10);
730
+ _objectDestructuringEmpty(_ref10);
775
731
 
776
732
  var _useHiddenFillHookSta = useHiddenFillHookState({}),
777
- _useHiddenFillHookSta2 = _slicedToArray__default['default'](_useHiddenFillHookSta, 1),
733
+ _useHiddenFillHookSta2 = _slicedToArray(_useHiddenFillHookSta, 1),
778
734
  hookedChildren = _useHiddenFillHookSta2[0];
779
735
 
780
- return React__default['default'].createElement("div", null, Object.values(hookedChildren));
736
+ return React.createElement("div", null, Object.values(hookedChildren));
781
737
  };
782
738
 
783
739
  var useHiddenFill = function useHiddenFill(children, inputs) {
784
740
  var _useHiddenFillHookSta3 = useHiddenFillHookStateRef(),
785
- _useHiddenFillHookSta4 = _slicedToArray__default['default'](_useHiddenFillHookSta3, 2),
741
+ _useHiddenFillHookSta4 = _slicedToArray(_useHiddenFillHookSta3, 2),
786
742
  set = _useHiddenFillHookSta4[1];
787
743
 
788
- var _useMemo = React.useMemo(function () {
789
- return _uniqueId__default['default']("");
744
+ var _useMemo = useMemo(function () {
745
+ return _uniqueId("");
790
746
  }, []),
791
- _useMemo2 = _slicedToArray__default['default'](_useMemo, 1),
747
+ _useMemo2 = _slicedToArray(_useMemo, 1),
792
748
  uid = _useMemo2[0];
793
749
 
794
- set(_set__default['default']([uid], children ? React__default['default'].cloneElement(children, {
750
+ set(_set([uid], children ? React.cloneElement(children, {
795
751
  key: uid
796
752
  }) : null));
797
- React.useEffect(function () {
753
+ useEffect(function () {
798
754
  return function () {
799
- return set(_unset__default['default']([uid]));
755
+ return set(_unset([uid]));
800
756
  };
801
757
  }, []);
802
758
  };
803
759
 
804
760
  var propsOrConsume = function propsOrConsume(prop, Consumer, childrenAsFunction) {
805
- return prop ? childrenAsFunction(prop) : React__default['default'].createElement(Consumer, null, childrenAsFunction);
761
+ return prop ? childrenAsFunction(prop) : React.createElement(Consumer, null, childrenAsFunction);
806
762
  };
807
763
 
808
764
  var addConsumers = function addConsumers(Component, obj) {
809
765
  return Object.entries(obj).reduce(function (acc, _ref) {
810
- var _ref2 = _slicedToArray__default['default'](_ref, 2),
766
+ var _ref2 = _slicedToArray(_ref, 2),
811
767
  propKey = _ref2[0],
812
768
  Consumer = _ref2[1];
813
769
 
814
770
  return function (props) {
815
771
  return propsOrConsume(props[propKey], Consumer, function (v) {
816
- return acc(_objectSpread__default['default'](_defineProperty__default['default']({}, propKey, v), props));
772
+ return acc(_objectSpread(_defineProperty({}, propKey, v), props));
817
773
  });
818
774
  };
819
775
  }, function (props) {
820
- return React__default['default'].createElement(Component, props);
776
+ return React.createElement(Component, props);
821
777
  });
822
778
  };
823
779
 
@@ -831,8 +787,8 @@ var consumes = function consumes(obj) {
831
787
  };
832
788
 
833
789
  var withDialogError = function withDialogError(Dialog) {
834
- var ErrorBoundedComponent = React__default['default'].forwardRef(function (props, ref) {
835
- return React__default['default'].createElement(Dialog, _extends__default['default']({
790
+ var ErrorBoundedComponent = React.forwardRef(function (props, ref) {
791
+ return React.createElement(Dialog, _extends({
836
792
  ref: ref
837
793
  }, props)); // const ErrorBoundary = __internals('ErrorBoundary')
838
794
 
@@ -847,25 +803,25 @@ var withDialogError = function withDialogError(Dialog) {
847
803
  };
848
804
 
849
805
  var GroupEventFactory = function GroupEventFactory() {
850
- var emitter = mitt__default['default']();
806
+ var emitter = mitt();
851
807
 
852
808
  var WithGroupEvent =
853
809
  /*#__PURE__*/
854
810
  function (_React$Component) {
855
- _inherits__default['default'](WithGroupEvent, _React$Component);
811
+ _inherits(WithGroupEvent, _React$Component);
856
812
 
857
813
  function WithGroupEvent() {
858
814
  var _getPrototypeOf2;
859
815
 
860
816
  var _this;
861
817
 
862
- _classCallCheck__default['default'](this, WithGroupEvent);
818
+ _classCallCheck(this, WithGroupEvent);
863
819
 
864
820
  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
865
821
  args[_key] = arguments[_key];
866
822
  }
867
823
 
868
- _this = _possibleConstructorReturn__default['default'](this, (_getPrototypeOf2 = _getPrototypeOf__default['default'](WithGroupEvent)).call.apply(_getPrototypeOf2, [this].concat(args)));
824
+ _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(WithGroupEvent)).call.apply(_getPrototypeOf2, [this].concat(args)));
869
825
  _this.events = {};
870
826
 
871
827
  _this.processEvent = function (type, event) {
@@ -888,7 +844,7 @@ var GroupEventFactory = function GroupEventFactory() {
888
844
  return _this;
889
845
  }
890
846
 
891
- _createClass__default['default'](WithGroupEvent, [{
847
+ _createClass(WithGroupEvent, [{
892
848
  key: "componentDidMount",
893
849
  value: function componentDidMount() {
894
850
  emitter.on('*', this.processEvent);
@@ -906,15 +862,15 @@ var GroupEventFactory = function GroupEventFactory() {
906
862
  }]);
907
863
 
908
864
  return WithGroupEvent;
909
- }(React__default['default'].Component);
865
+ }(React.Component);
910
866
 
911
867
  return WithGroupEvent;
912
868
  };
913
869
  var withGroupEvent = function withGroupEvent(Component) {
914
870
  var WithGroupEvent = GroupEventFactory();
915
- return React__default['default'].forwardRef(function (props, ref) {
916
- return React__default['default'].createElement(WithGroupEvent, null, function (groupEvent) {
917
- return React__default['default'].createElement(Component, _extends__default['default']({}, props, {
871
+ return React.forwardRef(function (props, ref) {
872
+ return React.createElement(WithGroupEvent, null, function (groupEvent) {
873
+ return React.createElement(Component, _extends({}, props, {
918
874
  ref: ref,
919
875
  groupEvent: groupEvent
920
876
  }));
@@ -925,39 +881,39 @@ var withGroupEvent = function withGroupEvent(Component) {
925
881
  var WithRef =
926
882
  /*#__PURE__*/
927
883
  function (_React$Component) {
928
- _inherits__default['default'](WithRef, _React$Component);
884
+ _inherits(WithRef, _React$Component);
929
885
 
930
886
  function WithRef(props) {
931
887
  var _this;
932
888
 
933
- _classCallCheck__default['default'](this, WithRef);
889
+ _classCallCheck(this, WithRef);
934
890
 
935
- _this = _possibleConstructorReturn__default['default'](this, _getPrototypeOf__default['default'](WithRef).call(this, props));
891
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(WithRef).call(this, props));
936
892
  var total = props.length || props.children.length;
937
893
  var refs = new Array(total);
938
894
 
939
895
  for (var i = 0; i < total; i++) {
940
- refs[i] = React__default['default'].createRef();
896
+ refs[i] = React.createRef();
941
897
  }
942
898
 
943
899
  _this.createdRefs = refs;
944
900
  return _this;
945
901
  }
946
902
 
947
- _createClass__default['default'](WithRef, [{
903
+ _createClass(WithRef, [{
948
904
  key: "render",
949
905
  value: function render() {
950
906
  var children = this.props.children;
951
- return children.apply(void 0, _toConsumableArray__default['default'](this.createdRefs));
907
+ return children.apply(void 0, _toConsumableArray(this.createdRefs));
952
908
  }
953
909
  }]);
954
910
 
955
911
  return WithRef;
956
- }(React__default['default'].Component);
912
+ }(React.Component);
957
913
 
958
914
  var addExtraProp = function addExtraProp(element, extra) {
959
915
  var override = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
960
- return React__default['default'].cloneElement(element, override ? _objectSpread__default['default']({}, element.props, extra) : _objectSpread__default['default']({}, extra, element.props), element.props.children);
916
+ return React.cloneElement(element, override ? _objectSpread({}, element.props, extra) : _objectSpread({}, extra, element.props), element.props.children);
961
917
  };
962
918
 
963
919
  var WithLazyPlaceholder = function WithLazyPlaceholder(_ref) {
@@ -966,17 +922,17 @@ var WithLazyPlaceholder = function WithLazyPlaceholder(_ref) {
966
922
  children = _ref.children,
967
923
  _ref$forwardProps = _ref.forwardProps,
968
924
  forwardProps = _ref$forwardProps === void 0 ? false : _ref$forwardProps,
969
- props = _objectWithoutProperties__default['default'](_ref, ["value", "fallback", "children", "forwardProps"]);
925
+ props = _objectWithoutProperties(_ref, ["value", "fallback", "children", "forwardProps"]);
970
926
 
971
- return React__default['default'].createElement(React__default['default'].Suspense, {
972
- fallback: React__default['default'].Children.map(children(fallback, {
927
+ return React.createElement(React.Suspense, {
928
+ fallback: React.Children.map(children(fallback, {
973
929
  isLoading: true
974
930
  }), function (child) {
975
- return React__default['default'].isValidElement(child) ? addExtraProp(child, {
931
+ return React.isValidElement(child) ? addExtraProp(child, {
976
932
  isLoading: true
977
933
  }, false) : child;
978
934
  })
979
- }, React__default['default'].createElement(Load, {
935
+ }, React.createElement(Load, {
980
936
  value: value,
981
937
  children: children,
982
938
  forwardProps: forwardProps && props
@@ -989,15 +945,15 @@ var WithLazyResource = function WithLazyResource(_ref2) {
989
945
  children = _ref2.children,
990
946
  _ref2$forwardProps = _ref2.forwardProps,
991
947
  forwardProps = _ref2$forwardProps === void 0 ? false : _ref2$forwardProps,
992
- props = _objectWithoutProperties__default['default'](_ref2, ["value", "wrap", "fallback", "children", "forwardProps"]);
948
+ props = _objectWithoutProperties(_ref2, ["value", "wrap", "fallback", "children", "forwardProps"]);
993
949
 
994
- return wrap || fallback !== undefined ? React__default['default'].createElement(React__default['default'].Suspense, {
995
- fallback: utils.ifUndefined(fallback, null)
996
- }, React__default['default'].createElement(Load, {
950
+ return wrap || fallback !== undefined ? React.createElement(React.Suspense, {
951
+ fallback: ifUndefined(fallback, null)
952
+ }, React.createElement(Load, {
997
953
  value: value,
998
954
  forwardProps: forwardProps && props,
999
955
  children: children
1000
- })) : React__default['default'].createElement(Load, {
956
+ })) : React.createElement(Load, {
1001
957
  value: value,
1002
958
  children: children,
1003
959
  forwardProps: forwardProps && props
@@ -1008,20 +964,20 @@ var Load = function Load(_ref3) {
1008
964
  var value = _ref3.value,
1009
965
  children = _ref3.children,
1010
966
  forwardProps = _ref3.forwardProps;
1011
- var loaded = _isArray__default['default'](value) ? value.forEach(function (v) {
967
+ var loaded = _isArray(value) ? value.forEach(function (v) {
1012
968
  return v.promise();
1013
969
  }) || value.map(function (v) {
1014
970
  return v.read();
1015
971
  }) : value.read();
1016
972
 
1017
- var _useReducer = React.useReducer(function (s) {
973
+ var _useReducer = useReducer(function (s) {
1018
974
  return s + 1;
1019
975
  }, 0),
1020
- _useReducer2 = _slicedToArray__default['default'](_useReducer, 2),
976
+ _useReducer2 = _slicedToArray(_useReducer, 2),
1021
977
  update = _useReducer2[1];
1022
978
 
1023
979
  var refresh = function refresh() {
1024
- return Promise.all(_isArray__default['default'](value) ? value.map(function (v) {
980
+ return Promise.all(_isArray(value) ? value.map(function (v) {
1025
981
  return v.refresh().promise();
1026
982
  }) : [value.refresh().promise()]).then(update);
1027
983
  };
@@ -1036,13 +992,13 @@ var Load = function Load(_ref3) {
1036
992
  };
1037
993
 
1038
994
  var useCallbackStable = function useCallbackStable(fn) {
1039
- var ref = React__default['default'].useRef([fn, function () {
995
+ var ref = React.useRef([fn, function () {
1040
996
  return ref[0].apply(ref, arguments);
1041
997
  }]).current; // Per Dan Abramov: useInsertionEffect executes marginally closer to the
1042
998
  // correct timing for ref synchronization than useLayoutEffect on React 18.
1043
999
  // See: https://github.com/facebook/react/pull/25881#issuecomment-1356244360
1044
1000
 
1045
- React.useInsertionEffect(function () {
1001
+ useInsertionEffect(function () {
1046
1002
  ref[0] = fn;
1047
1003
  });
1048
1004
  return ref[1];
@@ -1052,7 +1008,7 @@ var WithEffect = function WithEffect(_ref) {
1052
1008
  var _ref$inputs = _ref.inputs,
1053
1009
  inputs = _ref$inputs === void 0 ? [] : _ref$inputs,
1054
1010
  children = _ref.children;
1055
- React.useEffect(children, inputs);
1011
+ useEffect(children, inputs);
1056
1012
  return null;
1057
1013
  };
1058
1014
 
@@ -1063,10 +1019,10 @@ var useToggleInternal = function useToggleInternal() {
1063
1019
  var key = arguments.length > 3 ? arguments[3] : undefined;
1064
1020
  var isOpen = useStore(startWith);
1065
1021
  var closing = useStore(false);
1066
- var refIsOpen = core.useRefState(isOpen.get());
1067
- var refIsClosing = core.useRefState(closing.get());
1068
- var timerId = React.useRef();
1069
- var isUnmounted = core.useIsUnmounted();
1022
+ var refIsOpen = useRefState$1(isOpen.get());
1023
+ var refIsClosing = useRefState$1(closing.get());
1024
+ var timerId = useRef();
1025
+ var isUnmounted = useIsUnmounted$1();
1070
1026
 
1071
1027
  var clearClosing = function clearClosing() {
1072
1028
  if (refIsClosing.get() !== false) {
@@ -1078,11 +1034,11 @@ var useToggleInternal = function useToggleInternal() {
1078
1034
 
1079
1035
  var toggleWith = function toggleWith() {
1080
1036
  var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
1081
- var calledValue = utils.callIfFunction(value, refIsOpen.get());
1037
+ var calledValue = callIfFunction(value, refIsOpen.get());
1082
1038
  var newValue = refIsOpen.get() === calledValue ? !calledValue : calledValue;
1083
1039
 
1084
1040
  if (!isUnmounted() && refIsOpen.get() !== newValue) {
1085
- var result = utils.callIfFunction(callback, newValue, refIsOpen.get());
1041
+ var result = callIfFunction(callback, newValue, refIsOpen.get());
1086
1042
 
1087
1043
  if (result === false) {
1088
1044
  return;
@@ -1099,7 +1055,7 @@ var useToggleInternal = function useToggleInternal() {
1099
1055
  console.log(key, refIsOpen.get() !== value ? "toggle" : "clear", refIsOpen.get(), value);
1100
1056
  }
1101
1057
 
1102
- var nextValue = utils.callIfFunction(value, refIsOpen.get());
1058
+ var nextValue = callIfFunction(value, refIsOpen.get());
1103
1059
 
1104
1060
  if (refIsOpen.get() !== nextValue) {
1105
1061
  toggleWith(function () {
@@ -1145,15 +1101,15 @@ var useToggleInternal = function useToggleInternal() {
1145
1101
  var end = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
1146
1102
  return (
1147
1103
  /*#__PURE__*/
1148
- _asyncToGenerator__default['default'](
1104
+ _asyncToGenerator(
1149
1105
  /*#__PURE__*/
1150
- _regeneratorRuntime__default['default'].mark(function _callee() {
1106
+ _regeneratorRuntime.mark(function _callee() {
1151
1107
  var _len2,
1152
1108
  args,
1153
1109
  _key2,
1154
1110
  _args = arguments;
1155
1111
 
1156
- return _regeneratorRuntime__default['default'].wrap(function _callee$(_context) {
1112
+ return _regeneratorRuntime.wrap(function _callee$(_context) {
1157
1113
  while (1) {
1158
1114
  switch (_context.prev = _context.next) {
1159
1115
  case 0:
@@ -1165,7 +1121,7 @@ var useToggleInternal = function useToggleInternal() {
1165
1121
  }
1166
1122
 
1167
1123
  _context.next = 5;
1168
- return utils.callIfFunction.apply(void 0, [promise].concat(args));
1124
+ return callIfFunction.apply(void 0, [promise].concat(args));
1169
1125
 
1170
1126
  case 5:
1171
1127
  return _context.abrupt("return", _context.sent);
@@ -1185,7 +1141,7 @@ var useToggleInternal = function useToggleInternal() {
1185
1141
  );
1186
1142
  };
1187
1143
 
1188
- var setters = React.useMemo(function () {
1144
+ var setters = useMemo(function () {
1189
1145
  return {
1190
1146
  wait: function wait(promise) {
1191
1147
  var start = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
@@ -1195,7 +1151,7 @@ var useToggleInternal = function useToggleInternal() {
1195
1151
  willWait: _wait,
1196
1152
  open: function open(e) {
1197
1153
  if (process.env.NODE_ENV !== 'production') {
1198
- if (['string', 'number', 'boolean'].indexOf(_typeof__default['default'](e)) >= 0) {
1154
+ if (['string', 'number', 'boolean'].indexOf(_typeof(e)) >= 0) {
1199
1155
  console.log("You are trying to open toggle with ".concat(e, ". Please, use openWith to open with a value"));
1200
1156
  }
1201
1157
  }
@@ -1207,7 +1163,7 @@ var useToggleInternal = function useToggleInternal() {
1207
1163
  },
1208
1164
  toggle: function toggle(e) {
1209
1165
  if (process.env.NODE_ENV !== 'production') {
1210
- if (['string', 'number', 'boolean'].indexOf(_typeof__default['default'](e)) >= 0) {
1166
+ if (['string', 'number', 'boolean'].indexOf(_typeof(e)) >= 0) {
1211
1167
  console.log("You are trying to toogle a toggle with ".concat(e, ". Please, use openWith to open with a value"));
1212
1168
  }
1213
1169
  }
@@ -1240,7 +1196,7 @@ var useToggleInternal = function useToggleInternal() {
1240
1196
  };
1241
1197
  }, []);
1242
1198
 
1243
- var settersWithNewRef = _objectSpread__default['default']({}, setters);
1199
+ var settersWithNewRef = _objectSpread({}, setters);
1244
1200
 
1245
1201
  if (closing.val) {
1246
1202
  return Object.assign(settersWithNewRef, {
@@ -1263,10 +1219,10 @@ var useToggleInternal = function useToggleInternal() {
1263
1219
  };
1264
1220
 
1265
1221
  var useToggle = function useToggle(startWith, callback, key) {
1266
- return useToggleInternal(startWith, core.useCallState, callback, key);
1222
+ return useToggleInternal(startWith, useCallState$1, callback, key);
1267
1223
  };
1268
1224
  var useRefToggle = function useRefToggle(startWith) {
1269
- return useToggleInternal(startWith, core.useRefState);
1225
+ return useToggleInternal(startWith, useRefState$1);
1270
1226
  };
1271
1227
 
1272
1228
  var prevOpenToggleClose = function prevOpenToggleClose() {};
@@ -1280,8 +1236,8 @@ var clearPopups = function clearPopups() {
1280
1236
  }
1281
1237
  };
1282
1238
  var usePopupToggle = function usePopupToggle(startWith, callback) {
1283
- var toggle = core.useToggle(startWith, function (v, prev) {
1284
- var result = utils.callIfFunction(callback, v, prev);
1239
+ var toggle = useToggle$1(startWith, function (v, prev) {
1240
+ var result = callIfFunction(callback, v, prev);
1285
1241
 
1286
1242
  if (result === false) {
1287
1243
  return false;
@@ -1304,12 +1260,12 @@ var usePopupToggle = function usePopupToggle(startWith, callback) {
1304
1260
  };
1305
1261
 
1306
1262
  var useCallState = function useCallState(defaultValue, setCallback) {
1307
- var _useState = React.useState(defaultValue),
1308
- _useState2 = _slicedToArray__default['default'](_useState, 2),
1263
+ var _useState = useState(defaultValue),
1264
+ _useState2 = _slicedToArray(_useState, 2),
1309
1265
  val = _useState2[0],
1310
1266
  setValue = _useState2[1];
1311
1267
 
1312
- return React.useMemo(function () {
1268
+ return useMemo(function () {
1313
1269
  var get = function get() {
1314
1270
  return val;
1315
1271
  };
@@ -1328,31 +1284,31 @@ var isPath = function isPath(path) {
1328
1284
 
1329
1285
  var getter = function getter(value) {
1330
1286
  return function (path) {
1331
- return path !== "" && isPath(path) ? utils._s.get(path, value) : value;
1287
+ return path !== "" && isPath(path) ? _s.get(path, value) : value;
1332
1288
  };
1333
1289
  };
1334
1290
 
1335
1291
  var uninitialized = {};
1336
1292
  var useRefState = function useRefState(defaultValue, setCallback) {
1337
- var ref = React.useRef(uninitialized);
1293
+ var ref = useRef(uninitialized);
1338
1294
 
1339
1295
  if (ref.current === uninitialized) {
1340
- ref.current = utils.callIfFunction(defaultValue);
1296
+ ref.current = callIfFunction(defaultValue);
1341
1297
  }
1342
1298
 
1343
- return React.useMemo(function () {
1299
+ return useMemo(function () {
1344
1300
  var get = function get(path) {
1345
1301
  return getter(ref.current)(path);
1346
1302
  };
1347
1303
 
1348
1304
  var set = function set(v, config) {
1349
1305
  var prev = ref.current;
1350
- ref.current = utils.callIfFunctions(v, function () {
1306
+ ref.current = callIfFunctions(v, function () {
1351
1307
  return get();
1352
1308
  });
1353
1309
 
1354
1310
  if (prev !== ref.current && (!config || !config.ignoreCallback)) {
1355
- utils.callIfFunction(setCallback, prev, ref.current);
1311
+ callIfFunction(setCallback, prev, ref.current);
1356
1312
  }
1357
1313
  };
1358
1314
 
@@ -1364,20 +1320,20 @@ var useRefState = function useRefState(defaultValue, setCallback) {
1364
1320
  };
1365
1321
 
1366
1322
  var useConsumerCatalog = function useConsumerCatalog(mountCallback, unmountCallback) {
1367
- var elements = core.useRefState([]);
1368
- var register = utils.callMany(function (element) {
1323
+ var elements = useRefState$1([]);
1324
+ var register = callMany(function (element) {
1369
1325
  return elements.set(function (elements) {
1370
1326
  return elements.concat([element]);
1371
1327
  });
1372
1328
  }, mountCallback);
1373
- var unregister = utils.callMany(function (element) {
1329
+ var unregister = callMany(function (element) {
1374
1330
  return elements.set(function (elements) {
1375
1331
  return elements.filter(function (_) {
1376
1332
  return _ !== element;
1377
1333
  });
1378
1334
  });
1379
1335
  }, unmountCallback);
1380
- var manager = React.useMemo(function () {
1336
+ var manager = useMemo(function () {
1381
1337
  return {
1382
1338
  register: register,
1383
1339
  unregister: unregister
@@ -1388,7 +1344,7 @@ var useConsumerCatalog = function useConsumerCatalog(mountCallback, unmountCallb
1388
1344
  var useCatalogManager = function useCatalogManager(_ref, ref) {
1389
1345
  var register = _ref.register,
1390
1346
  unregister = _ref.unregister;
1391
- React.useEffect(function () {
1347
+ useEffect(function () {
1392
1348
  register(ref);
1393
1349
  return function () {
1394
1350
  return unregister(ref);
@@ -1396,8 +1352,8 @@ var useCatalogManager = function useCatalogManager(_ref, ref) {
1396
1352
  }, [ref]);
1397
1353
  };
1398
1354
 
1399
- var _willUseLayers = core.willUseLayers(),
1400
- _willUseLayers2 = _slicedToArray__default['default'](_willUseLayers, 1),
1355
+ var _willUseLayers = willUseLayers$1(),
1356
+ _willUseLayers2 = _slicedToArray(_willUseLayers, 1),
1401
1357
  useTitleLayers = _willUseLayers2[0];
1402
1358
 
1403
1359
  var useTitle = function useTitle(title) {
@@ -1408,7 +1364,7 @@ var useTitle = function useTitle(title) {
1408
1364
  });
1409
1365
  };
1410
1366
 
1411
- var TabFocus = styled__default['default'].div.withConfig({
1367
+ var TabFocus = styled.div.withConfig({
1412
1368
  displayName: "useRecycleFocus__TabFocus",
1413
1369
  componentId: "kxnccs-0"
1414
1370
  })(["width:0;height:0;position:absolute;"]);
@@ -1436,25 +1392,25 @@ var useRecycleFocus = function useRecycleFocus(ref) {
1436
1392
  };
1437
1393
  };
1438
1394
 
1439
- return [React__default['default'].createElement(TabFocus, {
1395
+ return [React.createElement(TabFocus, {
1440
1396
  tabIndex: 1,
1441
1397
  onFocus: recycle(0)
1442
- }), React__default['default'].createElement(TabFocus, {
1398
+ }), React.createElement(TabFocus, {
1443
1399
  tabIndex: lastIndex || 1,
1444
1400
  onFocus: recycle(-1)
1445
1401
  })];
1446
1402
  };
1447
1403
 
1448
1404
  function usePrevious(value, initialValue) {
1449
- var ref = React.useRef(initialValue);
1450
- React.useEffect(function () {
1405
+ var ref = useRef(initialValue);
1406
+ useEffect(function () {
1451
1407
  ref.current = value;
1452
1408
  });
1453
1409
  return ref.current;
1454
1410
  }
1455
1411
  function usePreviousUnique(value, initialValue) {
1456
- var ref = React.useRef(initialValue);
1457
- React.useEffect(function () {
1412
+ var ref = useRef(initialValue);
1413
+ useEffect(function () {
1458
1414
  if (value !== ref.current) {
1459
1415
  ref.current = value;
1460
1416
  }
@@ -1462,8 +1418,8 @@ function usePreviousUnique(value, initialValue) {
1462
1418
  return ref.current;
1463
1419
  }
1464
1420
  function usePreviousForEffect(value, initialValue) {
1465
- var ref = React.useRef(initialValue);
1466
- React.useEffect(function () {
1421
+ var ref = useRef(initialValue);
1422
+ useEffect(function () {
1467
1423
  return function () {
1468
1424
  ref.current = value;
1469
1425
  };
@@ -1472,8 +1428,8 @@ function usePreviousForEffect(value, initialValue) {
1472
1428
  }
1473
1429
 
1474
1430
  var useIsUnmounted = function useIsUnmounted() {
1475
- var unmounted = React.useRef();
1476
- React.useEffect(function () {
1431
+ var unmounted = useRef();
1432
+ useEffect(function () {
1477
1433
  return function () {
1478
1434
  return unmounted.current = true;
1479
1435
  };
@@ -1484,13 +1440,13 @@ var useIsUnmounted = function useIsUnmounted() {
1484
1440
  };
1485
1441
 
1486
1442
  var useEnsureRef = function useEnsureRef(forwardedRef) {
1487
- var ref = React.useRef();
1443
+ var ref = useRef();
1488
1444
  return forwardedRef || ref;
1489
1445
  };
1490
1446
 
1491
1447
  var not_defined = {};
1492
1448
  var useConstant = function useConstant(value) {
1493
- var ref = React.useRef(not_defined);
1449
+ var ref = useRef(not_defined);
1494
1450
 
1495
1451
  if (ref.current === not_defined) {
1496
1452
  ref.current = value;
@@ -1499,18 +1455,18 @@ var useConstant = function useConstant(value) {
1499
1455
  return ref.current;
1500
1456
  };
1501
1457
  var useLazyConstant = function useLazyConstant(value) {
1502
- var ref = React.useRef(not_defined);
1458
+ var ref = useRef(not_defined);
1503
1459
 
1504
1460
  if (ref.current === not_defined) {
1505
- ref.current = utils.callIfFunction(value);
1461
+ ref.current = callIfFunction(value);
1506
1462
  }
1507
1463
 
1508
1464
  return ref.current;
1509
1465
  };
1510
1466
 
1511
1467
  var useForceUpdate = function useForceUpdate() {
1512
- var _useState = React.useState(0),
1513
- _useState2 = _slicedToArray__default['default'](_useState, 2),
1468
+ var _useState = useState(0),
1469
+ _useState2 = _slicedToArray(_useState, 2),
1514
1470
  value = _useState2[0],
1515
1471
  setValue = _useState2[1]; // integer state
1516
1472
 
@@ -1522,14 +1478,14 @@ var useForceUpdate = function useForceUpdate() {
1522
1478
  }; // update the state to force render
1523
1479
  };
1524
1480
  var willUseForceUpdate = function willUseForceUpdate() {
1525
- var _willUseSharedState = core.willUseSharedState(),
1526
- _willUseSharedState2 = _slicedToArray__default['default'](_willUseSharedState, 3),
1481
+ var _willUseSharedState = willUseSharedState$1(),
1482
+ _willUseSharedState2 = _slicedToArray(_willUseSharedState, 3),
1527
1483
  useValue = _willUseSharedState2[0],
1528
1484
  set = _willUseSharedState2[2];
1529
1485
 
1530
1486
  var useForceUpdate = function useForceUpdate() {
1531
1487
  var _useValue = useValue(0),
1532
- _useValue2 = _slicedToArray__default['default'](_useValue, 2),
1488
+ _useValue2 = _slicedToArray(_useValue, 2),
1533
1489
  v = _useValue2[0],
1534
1490
  setV = _useValue2[1];
1535
1491
 
@@ -1549,9 +1505,9 @@ var willUseForceUpdate = function willUseForceUpdate() {
1549
1505
 
1550
1506
  var useUpdateOnResize = function useUpdateOnResize() {
1551
1507
  var debounceInterval = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 200;
1552
- var update = core.useForceUpdate();
1553
- React.useEffect(function () {
1554
- var trigger = _debounce__default['default'](debounceInterval, update);
1508
+ var update = useForceUpdate$1();
1509
+ useEffect(function () {
1510
+ var trigger = _debounce(debounceInterval, update);
1555
1511
 
1556
1512
  window.addEventListener('resize', trigger);
1557
1513
  return function () {
@@ -1561,19 +1517,19 @@ var useUpdateOnResize = function useUpdateOnResize() {
1561
1517
  };
1562
1518
 
1563
1519
  var useAsyncEffect = function useAsyncEffect(fn, args) {
1564
- React.useEffect(function () {
1520
+ useEffect(function () {
1565
1521
  var result = fn();
1566
1522
  return function () {
1567
1523
  result.then(function (end) {
1568
- return utils.callIfFunction(end);
1524
+ return callIfFunction(end);
1569
1525
  });
1570
1526
  };
1571
1527
  }, args);
1572
1528
  };
1573
1529
 
1574
1530
  var useUpdateEffect = function useUpdateEffect(effect, inputs) {
1575
- var pastFirstTime = React.useRef();
1576
- React.useEffect(function () {
1531
+ var pastFirstTime = useRef();
1532
+ useEffect(function () {
1577
1533
  if (pastFirstTime.current) {
1578
1534
  return effect();
1579
1535
  } else {
@@ -1583,10 +1539,10 @@ var useUpdateEffect = function useUpdateEffect(effect, inputs) {
1583
1539
  };
1584
1540
 
1585
1541
  var useRefMemo = function useRefMemo(value) {
1586
- var ref = React.useRef(value);
1542
+ var ref = useRef(value);
1587
1543
 
1588
1544
  if (ref.current !== value) {
1589
- ref.current = utils.callIfFunction(value);
1545
+ ref.current = callIfFunction(value);
1590
1546
  }
1591
1547
 
1592
1548
  return ref;
@@ -1605,26 +1561,26 @@ var IS_DEPS_EQUALS = function IS_DEPS_EQUALS() {
1605
1561
  };
1606
1562
 
1607
1563
  var SHALLOW_IS_EQUAL = function SHALLOW_IS_EQUAL(a, b) {
1608
- return Object.is(a, b) || _isArray__default['default'](a) && _isArray__default['default'](b) && IS_ARRAY_ITEMS_EQUALS(a, b);
1564
+ return Object.is(a, b) || _isArray(a) && _isArray(b) && IS_ARRAY_ITEMS_EQUALS(a, b);
1609
1565
  };
1610
1566
 
1611
1567
  var EMPTY_DEPS = [];
1612
1568
  var useUpdateSignal = function useUpdateSignal(initialValue) {
1613
- var value = React.useRef(initialValue);
1569
+ var value = useRef(initialValue);
1614
1570
  value.current = initialValue;
1615
- return core.useLazyConstant(function () {
1571
+ return useLazyConstant$1(function () {
1616
1572
  var registered = [];
1617
1573
 
1618
1574
  var register = function register() {
1619
- var selector = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _identity__default['default'];
1575
+ var selector = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _identity;
1620
1576
  var isEqual = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : SHALLOW_IS_EQUAL;
1621
- var selectorRef = React.useRef();
1577
+ var selectorRef = useRef();
1622
1578
  selectorRef.current = selector;
1623
- var update = core.useForceUpdate();
1624
- var lastValueRef = React.useRef(utils._s.select(selectorRef.current, value.current));
1625
- React.useEffect(function () {
1579
+ var update = useForceUpdate$1();
1580
+ var lastValueRef = useRef(_s.select(selectorRef.current, value.current));
1581
+ useEffect(function () {
1626
1582
  var item = [update, selectorRef, isEqual, lastValueRef];
1627
- registered = _toConsumableArray__default['default'](registered).concat([item]);
1583
+ registered = _toConsumableArray(registered).concat([item]);
1628
1584
  return function () {
1629
1585
  registered = registered.filter(function (v) {
1630
1586
  return v !== item;
@@ -1640,15 +1596,15 @@ var useUpdateSignal = function useUpdateSignal(initialValue) {
1640
1596
  }
1641
1597
 
1642
1598
  return registered.forEach(function (_ref) {
1643
- var _ref2 = _slicedToArray__default['default'](_ref, 4),
1599
+ var _ref2 = _slicedToArray(_ref, 4),
1644
1600
  fn = _ref2[0],
1645
1601
  selectorRef = _ref2[1],
1646
1602
  isEqual = _ref2[2],
1647
1603
  lastValueRef = _ref2[3];
1648
1604
 
1649
- var nextValue = utils._s.select.apply(utils._s, [selectorRef.current].concat(args));
1605
+ var nextValue = _s.select.apply(_s, [selectorRef.current].concat(args));
1650
1606
 
1651
- if (!utils.callIfFunction(isEqual, nextValue, lastValueRef.current)) {
1607
+ if (!callIfFunction(isEqual, nextValue, lastValueRef.current)) {
1652
1608
  lastValueRef.current = nextValue;
1653
1609
  fn(nextValue);
1654
1610
  }
@@ -1659,27 +1615,27 @@ var useUpdateSignal = function useUpdateSignal(initialValue) {
1659
1615
  });
1660
1616
  };
1661
1617
  var useSelectorSignal = function useSelectorSignal(value) {
1662
- var prevValue = React.useRef(value);
1663
- var prevDeps = React.useRef(EMPTY_DEPS);
1618
+ var prevValue = useRef(value);
1619
+ var prevDeps = useRef(EMPTY_DEPS);
1664
1620
 
1665
- var _useState = React.useState(prevDeps.current),
1666
- _useState2 = _slicedToArray__default['default'](_useState, 2),
1621
+ var _useState = useState(prevDeps.current),
1622
+ _useState2 = _slicedToArray(_useState, 2),
1667
1623
  currentDeps = _useState2[0],
1668
1624
  setCurrentDeps = _useState2[1];
1669
1625
 
1670
1626
  var _useUpdateSignal = useUpdateSignal(value),
1671
- _useUpdateSignal2 = _slicedToArray__default['default'](_useUpdateSignal, 2),
1627
+ _useUpdateSignal2 = _slicedToArray(_useUpdateSignal, 2),
1672
1628
  _register = _useUpdateSignal2[0],
1673
1629
  call = _useUpdateSignal2[1];
1674
1630
 
1675
- var register = React.useCallback(function (selector, deps, isEqual) {
1631
+ var register = useCallback(function (selector, deps, isEqual) {
1676
1632
  if (!IS_DEPS_EQUALS(deps, prevDeps.current)) {
1677
1633
  setCurrentDeps(deps);
1678
1634
  }
1679
1635
 
1680
1636
  return _register(selector, isEqual);
1681
1637
  }, []);
1682
- React.useEffect(function () {
1638
+ useEffect(function () {
1683
1639
  if (prevValue.current !== value || currentDeps !== prevDeps.current) {
1684
1640
  prevValue.current = value;
1685
1641
  prevDeps.current = currentDeps;
@@ -1689,7 +1645,7 @@ var useSelectorSignal = function useSelectorSignal(value) {
1689
1645
  return register;
1690
1646
  };
1691
1647
  var createStatefulContext = function createStatefulContext(v) {
1692
- var Ctx = React__default['default'].createContext(v);
1648
+ var Ctx = React.createContext(v);
1693
1649
 
1694
1650
  var Provider = function Provider(_ref3) {
1695
1651
  var value = _ref3.value,
@@ -1697,40 +1653,40 @@ var createStatefulContext = function createStatefulContext(v) {
1697
1653
  utils = _ref3.utils,
1698
1654
  children = _ref3.children;
1699
1655
  var register = useSelectorSignal(value);
1700
- var v = core.useLazyConstant(function () {
1656
+ var v = useLazyConstant$1(function () {
1701
1657
  return [register, setValue, utils];
1702
1658
  });
1703
- return React__default['default'].createElement(Ctx.Provider, {
1659
+ return React.createElement(Ctx.Provider, {
1704
1660
  value: v
1705
1661
  }, children);
1706
1662
  };
1707
1663
 
1708
1664
  var useSelectValue = function useSelectValue(selector, deps, isEqual) {
1709
- var _useContext = React.useContext(Ctx),
1710
- _useContext2 = _slicedToArray__default['default'](_useContext, 1),
1665
+ var _useContext = useContext(Ctx),
1666
+ _useContext2 = _slicedToArray(_useContext, 1),
1711
1667
  useRegister = _useContext2[0];
1712
1668
 
1713
1669
  return useRegister(selector, deps, isEqual);
1714
1670
  };
1715
1671
 
1716
1672
  var useSetValue = function useSetValue(path, deps) {
1717
- var _useContext3 = React.useContext(Ctx),
1718
- _useContext4 = _slicedToArray__default['default'](_useContext3, 2),
1673
+ var _useContext3 = useContext(Ctx),
1674
+ _useContext4 = _slicedToArray(_useContext3, 2),
1719
1675
  reg = _useContext4[0],
1720
1676
  set = _useContext4[1];
1721
1677
 
1722
- return core.useConstant(function (update) {
1678
+ return useConstant$1(function (update) {
1723
1679
  return set(function (state) {
1724
- return path ? _update__default['default'](path, function (v) {
1725
- return utils.callIfFunction(update, v);
1726
- }, state) : utils.callIfFunction(update, state);
1680
+ return path ? _update(path, function (v) {
1681
+ return callIfFunction(update, v);
1682
+ }, state) : callIfFunction(update, state);
1727
1683
  });
1728
1684
  });
1729
1685
  };
1730
1686
 
1731
1687
  var useUtils = function useUtils(path, deps) {
1732
- var _useContext5 = React.useContext(Ctx),
1733
- _useContext6 = _slicedToArray__default['default'](_useContext5, 3),
1688
+ var _useContext5 = useContext(Ctx),
1689
+ _useContext6 = _slicedToArray(_useContext5, 3),
1734
1690
  reg = _useContext6[0],
1735
1691
  set = _useContext6[1],
1736
1692
  utils = _useContext6[2];
@@ -1741,7 +1697,7 @@ var createStatefulContext = function createStatefulContext(v) {
1741
1697
  return [Provider, [useSelectValue, useSetValue, useUtils]];
1742
1698
  };
1743
1699
  var createSelfStatefulContext = function createSelfStatefulContext(v) {
1744
- var Ctx = React__default['default'].createContext(v);
1700
+ var Ctx = React.createContext(v);
1745
1701
 
1746
1702
  var Provider = function Provider(_ref4) {
1747
1703
  var _ref4$init = _ref4.init,
@@ -1749,48 +1705,48 @@ var createSelfStatefulContext = function createSelfStatefulContext(v) {
1749
1705
  utils = _ref4.utils,
1750
1706
  children = _ref4.children;
1751
1707
 
1752
- var _useState3 = React.useState(init),
1753
- _useState4 = _slicedToArray__default['default'](_useState3, 2),
1708
+ var _useState3 = useState(init),
1709
+ _useState4 = _slicedToArray(_useState3, 2),
1754
1710
  value = _useState4[0],
1755
1711
  setValue = _useState4[1];
1756
1712
 
1757
1713
  var register = useSelectorSignal(value);
1758
- var v = core.useLazyConstant(function () {
1714
+ var v = useLazyConstant$1(function () {
1759
1715
  return [register, setValue, utils];
1760
1716
  });
1761
- return React__default['default'].createElement(Ctx.Provider, {
1717
+ return React.createElement(Ctx.Provider, {
1762
1718
  value: v
1763
1719
  }, children);
1764
1720
  };
1765
1721
 
1766
1722
  var useSelectValue = function useSelectValue(selector, deps, isEqual) {
1767
- var _useContext7 = React.useContext(Ctx),
1768
- _useContext8 = _slicedToArray__default['default'](_useContext7, 1),
1723
+ var _useContext7 = useContext(Ctx),
1724
+ _useContext8 = _slicedToArray(_useContext7, 1),
1769
1725
  useRegister = _useContext8[0];
1770
1726
 
1771
1727
  return useRegister(selector, deps, isEqual);
1772
1728
  };
1773
1729
 
1774
1730
  var useSetState = function useSetState(path, deps) {
1775
- var _useContext9 = React.useContext(Ctx),
1776
- _useContext10 = _slicedToArray__default['default'](_useContext9, 3),
1731
+ var _useContext9 = useContext(Ctx),
1732
+ _useContext10 = _slicedToArray(_useContext9, 3),
1777
1733
  useRegister = _useContext10[0],
1778
1734
  set = _useContext10[1],
1779
- utils$1 = _useContext10[2];
1735
+ utils = _useContext10[2];
1780
1736
 
1781
- var setValue = core.useConstant(function (update) {
1737
+ var setValue = useConstant$1(function (update) {
1782
1738
  return set(function (state) {
1783
- return path ? _update__default['default'](path, function (v) {
1784
- return utils.callIfFunction(update, v);
1785
- }, state) : utils.callIfFunction(update, state);
1739
+ return path ? _update(path, function (v) {
1740
+ return callIfFunction(update, v);
1741
+ }, state) : callIfFunction(update, state);
1786
1742
  });
1787
1743
  });
1788
1744
  return setValue;
1789
1745
  };
1790
1746
 
1791
1747
  var useUtils = function useUtils(path, deps) {
1792
- var _useContext11 = React.useContext(Ctx),
1793
- _useContext12 = _slicedToArray__default['default'](_useContext11, 3),
1748
+ var _useContext11 = useContext(Ctx),
1749
+ _useContext12 = _slicedToArray(_useContext11, 3),
1794
1750
  useRegister = _useContext12[0],
1795
1751
  set = _useContext12[1],
1796
1752
  utils = _useContext12[2];
@@ -1802,41 +1758,41 @@ var createSelfStatefulContext = function createSelfStatefulContext(v) {
1802
1758
  };
1803
1759
  var createSelectableContext = function createSelectableContext(v) {
1804
1760
  var _createStatefulContex = createStatefulContext(v),
1805
- _createStatefulContex2 = _slicedToArray__default['default'](_createStatefulContex, 2),
1761
+ _createStatefulContex2 = _slicedToArray(_createStatefulContex, 2),
1806
1762
  Provider = _createStatefulContex2[0],
1807
- _createStatefulContex3 = _slicedToArray__default['default'](_createStatefulContex2[1], 1),
1763
+ _createStatefulContex3 = _slicedToArray(_createStatefulContex2[1], 1),
1808
1764
  useSelectValue = _createStatefulContex3[0];
1809
1765
 
1810
1766
  return [Provider, useSelectValue];
1811
1767
  };
1812
1768
  var createTriggerUpdateContext = function createTriggerUpdateContext(v) {
1813
1769
  var _createStatefulContex4 = createStatefulContext(v),
1814
- _createStatefulContex5 = _slicedToArray__default['default'](_createStatefulContex4, 2),
1770
+ _createStatefulContex5 = _slicedToArray(_createStatefulContex4, 2),
1815
1771
  Provider = _createStatefulContex5[0],
1816
- _createStatefulContex6 = _slicedToArray__default['default'](_createStatefulContex5[1], 1),
1772
+ _createStatefulContex6 = _slicedToArray(_createStatefulContex5[1], 1),
1817
1773
  useSelectValue = _createStatefulContex6[0];
1818
1774
 
1819
- var TriggerProvider = React__default['default'].forwardRef(function (_ref5, ref) {
1775
+ var TriggerProvider = React.forwardRef(function (_ref5, ref) {
1820
1776
  var children = _ref5.children;
1821
1777
 
1822
- var _useState5 = React.useState(0),
1823
- _useState6 = _slicedToArray__default['default'](_useState5, 2),
1778
+ var _useState5 = useState(0),
1779
+ _useState6 = _slicedToArray(_useState5, 2),
1824
1780
  v = _useState6[0],
1825
1781
  setV = _useState6[1];
1826
1782
 
1827
- var trigger = React__default['default'].useMemo(function () {
1783
+ var trigger = React.useMemo(function () {
1828
1784
  return function () {
1829
1785
  return setV(function (v) {
1830
1786
  return v + 1;
1831
1787
  });
1832
1788
  };
1833
1789
  }, [v]);
1834
- React__default['default'].useImperativeHandle(ref, function () {
1790
+ React.useImperativeHandle(ref, function () {
1835
1791
  return {
1836
1792
  trigger: trigger
1837
1793
  };
1838
1794
  }, []);
1839
- return React__default['default'].createElement(Provider, {
1795
+ return React.createElement(Provider, {
1840
1796
  value: trigger
1841
1797
  }, children);
1842
1798
  });
@@ -1848,61 +1804,8 @@ var WithConstant = function WithConstant(_ref) {
1848
1804
  inputs = _ref$inputs === void 0 ? [] : _ref$inputs,
1849
1805
  value = _ref.value,
1850
1806
  children = _ref.children;
1851
- var constant = core.useLazyConstant(value, inputs);
1807
+ var constant = useLazyConstant$1(value, inputs);
1852
1808
  return children(constant);
1853
1809
  };
1854
1810
 
1855
- exports.Fill = Fill;
1856
- exports.GroupEventFactory = GroupEventFactory;
1857
- exports.PopupContext = PopupContext;
1858
- exports.Slot = Slot;
1859
- exports.SlotContext = SlotContext;
1860
- exports.SlotProvider = SlotProvider;
1861
- exports.StartlibsConsumer = StartlibsConsumer;
1862
- exports.StartlibsContext = StartlibsContext;
1863
- exports.StartlibsMetacontext = StartlibsMetacontext;
1864
- exports.StartlibsProvider = StartlibsProvider;
1865
- exports.WithConstant = WithConstant;
1866
- exports.WithEffect = WithEffect;
1867
- exports.WithLazyPlaceholder = WithLazyPlaceholder;
1868
- exports.WithLazyResource = WithLazyResource;
1869
- exports.WithRef = WithRef;
1870
- exports.clearPopups = clearPopups;
1871
- exports.consumes = consumes;
1872
- exports.createSelectableContext = createSelectableContext;
1873
- exports.createSelfStatefulContext = createSelfStatefulContext;
1874
- exports.createStatefulContext = createStatefulContext;
1875
- exports.createTriggerUpdateContext = createTriggerUpdateContext;
1876
- exports.useAsyncEffect = useAsyncEffect;
1877
- exports.useCallState = useCallState;
1878
- exports.useCallbackStable = useCallbackStable;
1879
- exports.useCatalogManager = useCatalogManager;
1880
- exports.useConstant = useConstant;
1881
- exports.useConsumerCatalog = useConsumerCatalog;
1882
- exports.useEnsureRef = useEnsureRef;
1883
- exports.useFill = useFill;
1884
- exports.useForceUpdate = useForceUpdate;
1885
- exports.useHiddenFill = useHiddenFill;
1886
- exports.useIsUnmounted = useIsUnmounted;
1887
- exports.useLazyConstant = useLazyConstant;
1888
- exports.usePopupToggle = usePopupToggle;
1889
- exports.usePrevious = usePrevious;
1890
- exports.usePreviousForEffect = usePreviousForEffect;
1891
- exports.usePreviousUnique = usePreviousUnique;
1892
- exports.useRecycleFocus = useRecycleFocus;
1893
- exports.useRefMemo = useRefMemo;
1894
- exports.useRefState = useRefState;
1895
- exports.useRefToggle = useRefToggle;
1896
- exports.useSelectorSignal = useSelectorSignal;
1897
- exports.useTitle = useTitle;
1898
- exports.useToggle = useToggle;
1899
- exports.useUpdateEffect = useUpdateEffect;
1900
- exports.useUpdateOnResize = useUpdateOnResize;
1901
- exports.useUpdateSignal = useUpdateSignal;
1902
- exports.willUseForceUpdate = willUseForceUpdate;
1903
- exports.willUseLayers = willUseLayers;
1904
- exports.willUseSharedCallback = willUseSharedCallback;
1905
- exports.willUseSharedState = willUseSharedState;
1906
- exports.willUseSpreadState = willUseSpreadState;
1907
- exports.withDialogError = withDialogError;
1908
- exports.withGroupEvent = withGroupEvent;
1811
+ export { Fill, GroupEventFactory, PopupContext, Slot, SlotContext, SlotProvider, StartlibsConsumer, StartlibsContext, StartlibsMetacontext, StartlibsProvider, WithConstant, WithEffect, WithLazyPlaceholder, WithLazyResource, WithRef, clearPopups, consumes, createSelectableContext, createSelfStatefulContext, createStatefulContext, createTriggerUpdateContext, useAsyncEffect, useCallState, useCallbackStable, useCatalogManager, useConstant, useConsumerCatalog, useEnsureRef, useFill, useForceUpdate, useHiddenFill, useIsUnmounted, useLazyConstant, usePopupToggle, usePrevious, usePreviousForEffect, usePreviousUnique, useRecycleFocus, useRefMemo, useRefState, useRefToggle, useSelectorSignal, useTitle, useToggle, useUpdateEffect, useUpdateOnResize, useUpdateSignal, willUseForceUpdate, willUseLayers, willUseSharedCallback, willUseSharedState, willUseSpreadState, withDialogError, withGroupEvent };