@startlibs/core 1.0.2 → 1.0.4

package/lib/index.js

@@ -4,7 +4,7 @@ import _possibleConstructorReturn from '@babel/runtime/helpers/possibleConstruct
 import _getPrototypeOf from '@babel/runtime/helpers/getPrototypeOf';
 import _inherits from '@babel/runtime/helpers/inherits';
 import _debounce from 'lodash/fp/debounce';
-import React, { useCallback, useState, useRef, useEffect, useMemo, useContext, useLayoutEffect, useReducer, useInsertionEffect } from 'react';
+import React, { useCallback, useState, useRef, useEffect, useMemo, useContext, useLayoutEffect, useReducer, useInsertionEffect, startTransition, use } from 'react';
 import { callIfFunction, fixMediaQuery, ifUndefined, formatPath, _s, callIfFunctions, callMany } from '@startlibs/utils';
 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';
 import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
@@ -36,7 +36,9 @@ import mitt from 'mitt';
 import _typeof from '@babel/runtime/helpers/typeof';
 import _regeneratorRuntime from '@babel/runtime/regenerator';
 import _asyncToGenerator from '@babel/runtime/helpers/asyncToGenerator';
+import _isPlainObject from 'lodash/fp/isPlainObject';
 import _identity from 'lodash/fp/identity';
+import 'lodash/array';
 
 var StartlibsContext = React.createContext({});
 var PopupContext = React.createContext({});
@@ -1428,10 +1430,11 @@ function usePreviousForEffect(value, initialValue) {
 }
 
 var useIsUnmounted = function useIsUnmounted() {
-  var unmounted = useRef();
+  var unmounted = useRef(false);
   useEffect(function () {
+    unmounted.current = false;
     return function () {
-      return unmounted.current = true;
+      unmounted.current = true;
     };
   }, []);
   return function () {
@@ -1549,9 +1552,9 @@ var useRefMemo = function useRefMemo(value) {
 };
 
 var IS_ARRAY_ITEMS_EQUALS = function IS_ARRAY_ITEMS_EQUALS(a, b) {
-  return a.length === b.length && a.findIndex(function (itemA, i) {
-    return !Object.is(itemA, b[i]);
-  }) < 0;
+  return a.length === b.length && !a.some(function (x, i) {
+    return !Object.is(x, b[i]);
+  });
 };
 
 var IS_DEPS_EQUALS = function IS_DEPS_EQUALS() {
@@ -1565,6 +1568,9 @@ var SHALLOW_IS_EQUAL = function SHALLOW_IS_EQUAL(a, b) {
 };
 
 var EMPTY_DEPS = [];
+var EMPTY_VALUE = {
+  "EMPTY": true
+};
 var useUpdateSignal = function useUpdateSignal(initialValue) {
   var value = useRef(initialValue);
   value.current = initialValue;
@@ -1574,12 +1580,13 @@ var useUpdateSignal = function useUpdateSignal(initialValue) {
     var register = function register() {
       var selector = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _identity;
       var isEqual = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : SHALLOW_IS_EQUAL;
+      var withTransition = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
       var selectorRef = useRef();
       selectorRef.current = selector;
       var update = useForceUpdate$1();
       var lastValueRef = useRef(_s.select(selectorRef.current, value.current));
       useEffect(function () {
-        var item = [update, selectorRef, isEqual, lastValueRef];
+        var item = [update, selectorRef, isEqual, lastValueRef, withTransition];
         registered = _toConsumableArray(registered).concat([item]);
         return function () {
           registered = registered.filter(function (v) {
@@ -1587,6 +1594,11 @@ var useUpdateSignal = function useUpdateSignal(initialValue) {
           });
         };
       }, []);
+
+      if (value.current === EMPTY_VALUE) {
+        return EMPTY_VALUE;
+      }
+
       return lastValueRef.current;
     };
 
@@ -1596,17 +1608,25 @@ var useUpdateSignal = function useUpdateSignal(initialValue) {
       }
 
       return registered.forEach(function (_ref) {
-        var _ref2 = _slicedToArray(_ref, 4),
+        var _ref2 = _slicedToArray(_ref, 5),
             fn = _ref2[0],
             selectorRef = _ref2[1],
             isEqual = _ref2[2],
-            lastValueRef = _ref2[3];
+            lastValueRef = _ref2[3],
+            withTransition = _ref2[4];
 
         var nextValue = _s.select.apply(_s, [selectorRef.current].concat(args));
 
         if (!callIfFunction(isEqual, nextValue, lastValueRef.current)) {
           lastValueRef.current = nextValue;
-          fn(nextValue);
+
+          if (withTransition) {
+            (withTransition === true ? startTransition : withTransition)(function () {
+              return fn(nextValue);
+            });
+          } else {
+            fn(nextValue);
+          }
         }
       });
     };
@@ -1614,37 +1634,43 @@ var useUpdateSignal = function useUpdateSignal(initialValue) {
     return [register, call];
   });
 };
+
 var useSelectorSignal = function useSelectorSignal(value) {
   var prevValue = useRef(value);
-  var prevDeps = useRef(EMPTY_DEPS);
-
-  var _useState = useState(prevDeps.current),
-      _useState2 = _slicedToArray(_useState, 2),
-      currentDeps = _useState2[0],
-      setCurrentDeps = _useState2[1];
 
   var _useUpdateSignal = useUpdateSignal(value),
       _useUpdateSignal2 = _slicedToArray(_useUpdateSignal, 2),
       _register = _useUpdateSignal2[0],
       call = _useUpdateSignal2[1];
 
-  var register = useCallback(function (selector, deps, isEqual) {
-    if (!IS_DEPS_EQUALS(deps, prevDeps.current)) {
-      setCurrentDeps(deps);
+  var register = useCallback(function (selector, deps, isEqual, withTransition) {
+    var prevDeps = useRef(EMPTY_DEPS);
+
+    if (prevDeps.current !== EMPTY_DEPS && !IS_DEPS_EQUALS(deps, prevDeps.current)) {
+      call(prevValue.current);
     }
 
-    return _register(selector, isEqual);
+    prevDeps.current = deps;
+    return _register(selector, isEqual, withTransition);
   }, []);
   useEffect(function () {
-    if (prevValue.current !== value || currentDeps !== prevDeps.current) {
+    if (prevValue.current !== value) {
       prevValue.current = value;
-      prevDeps.current = currentDeps;
       call(value);
     }
-  }, [value, currentDeps]);
+  }, [value]);
   return register;
 };
-var createStatefulContext = function createStatefulContext(v) {
+
+var updateStateFn = function updateStateFn(path, update) {
+  return function (state) {
+    return path ? _update(path, function (v) {
+      return callIfFunction(update, v);
+    }, state) : callIfFunction(update, state);
+  };
+};
+
+var createStatefulContext = function createStatefulContext(v, defaultIsEqual) {
   var Ctx = React.createContext(v);
 
   var Provider = function Provider(_ref3) {
@@ -1661,119 +1687,189 @@ var createStatefulContext = function createStatefulContext(v) {
     }, children);
   };
 
-  var useSelectValue = function useSelectValue(selector, deps, isEqual) {
-    var _useContext = useContext(Ctx),
-        _useContext2 = _slicedToArray(_useContext, 1),
-        useRegister = _useContext2[0];
+  var useCtx = function useCtx() {
+    return useContext(Ctx);
+  };
+
+  var useSelectValue = function useSelectValue(selector, deps, defaultIsEqual, withTransition) {
+    var _useCtx = useCtx(),
+        _useCtx2 = _slicedToArray(_useCtx, 1),
+        useRegister = _useCtx2[0];
 
-    return useRegister(selector, deps, isEqual);
+    if (deps === true) {
+      return useRegister(selector, [], undefined, startTransition);
+    } else if (_isPlainObject(deps)) {
+      return useRegister(selector, deps.deps, deps.isEqual, deps.withTransition);
+    } else {
+      return useRegister(selector, _isArray(deps) ? deps : deps === null || deps === void 0 ? void 0 : deps.deps, isEqual, withTransition);
+    }
   };
 
-  var useSetValue = function useSetValue(path, deps) {
-    var _useContext3 = useContext(Ctx),
-        _useContext4 = _slicedToArray(_useContext3, 2),
-        reg = _useContext4[0],
-        set = _useContext4[1];
+  var useSetValue = function useSetValue(path) {
+    var _useCtx3 = useCtx(),
+        _useCtx4 = _slicedToArray(_useCtx3, 2),
+        reg = _useCtx4[0],
+        set = _useCtx4[1];
 
     return useConstant$1(function (update) {
-      return set(function (state) {
-        return path ? _update(path, function (v) {
-          return callIfFunction(update, v);
-        }, state) : callIfFunction(update, state);
-      });
+      return set(updateStateFn(path, update));
     });
   };
 
   var useUtils = function useUtils(path, deps) {
-    var _useContext5 = useContext(Ctx),
-        _useContext6 = _slicedToArray(_useContext5, 3),
-        reg = _useContext6[0],
-        set = _useContext6[1],
-        utils = _useContext6[2];
+    var _useCtx5 = useCtx(),
+        _useCtx6 = _slicedToArray(_useCtx5, 3),
+        reg = _useCtx6[0],
+        set = _useCtx6[1],
+        utils = _useCtx6[2];
 
     return utils;
   };
 
-  return [Provider, [useSelectValue, useSetValue, useUtils]];
+  return [Provider, [useSelectValue, useSetValue, useUtils, useCtx]];
 };
-var createSelfStatefulContext = function createSelfStatefulContext(v) {
-  var Ctx = React.createContext(v);
+var createSelfStatefulContext = function createSelfStatefulContext(v, defaultIsEqual) {
+  var _createStatefulContex = createStatefulContext(v),
+      _createStatefulContex2 = _slicedToArray(_createStatefulContex, 2),
+      Provider = _createStatefulContex2[0],
+      _createStatefulContex3 = _slicedToArray(_createStatefulContex2[1], 4),
+      useSelectValue = _createStatefulContex3[0],
+      useSetValue = _createStatefulContex3[1],
+      useUtils = _createStatefulContex3[2],
+      useCtx = _createStatefulContex3[3];
 
-  var Provider = function Provider(_ref4) {
+  var StateFullProvider = function StateFullProvider(_ref4) {
     var _ref4$init = _ref4.init,
         init = _ref4$init === void 0 ? {} : _ref4$init,
         utils = _ref4.utils,
         children = _ref4.children;
 
-    var _useState3 = useState(init),
-        _useState4 = _slicedToArray(_useState3, 2),
-        value = _useState4[0],
-        setValue = _useState4[1];
+    var _useState = useState(init),
+        _useState2 = _slicedToArray(_useState, 2),
+        state = _useState2[0],
+        setState = _useState2[1];
 
-    var register = useSelectorSignal(value);
-    var v = useLazyConstant$1(function () {
-      return [register, setValue, utils];
-    });
-    return React.createElement(Ctx.Provider, {
-      value: v
+    return React.createElement(Provider, {
+      value: state,
+      setValue: setState,
+      utils: utils
     }, children);
   };
 
-  var useSelectValue = function useSelectValue(selector, deps, isEqual) {
-    var _useContext7 = useContext(Ctx),
-        _useContext8 = _slicedToArray(_useContext7, 1),
-        useRegister = _useContext8[0];
+  return [StateFullProvider, [useSelectValue, useSetValue, useUtils, useCtx]];
+};
+var createLazyStatefulContext = function createLazyStatefulContext(toPromise, defaultIsEqual) {
+  var _createStatefulContex4 = createStatefulContext(EMPTY_VALUE),
+      _createStatefulContex5 = _slicedToArray(_createStatefulContex4, 2),
+      Provider = _createStatefulContex5[0],
+      _createStatefulContex6 = _slicedToArray(_createStatefulContex5[1], 4),
+      useSelectValue = _createStatefulContex6[0],
+      useSetValue = _createStatefulContex6[1],
+      useUtils = _createStatefulContex6[2],
+      useCtx = _createStatefulContex6[3];
+
+  var useSelectLazyValue = function useSelectLazyValue(selector, deps) {
+    var isEqual = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : defaultIsEqual;
+    var withTransition = arguments.length > 3 ? arguments[3] : undefined;
+    var value = useSelectValue(selector, deps, isEqual, withTransition);
+    var utils = useUtils();
+
+    if (value === EMPTY_VALUE) {
+      var loadedValue = use(utils._lazyValue());
+      return _s.select(selector, loadedValue);
+    }
 
-    return useRegister(selector, deps, isEqual);
+    return value;
   };
 
-  var useSetState = function useSetState(path, deps) {
-    var _useContext9 = useContext(Ctx),
-        _useContext10 = _slicedToArray(_useContext9, 3),
-        useRegister = _useContext10[0],
-        set = _useContext10[1],
-        utils = _useContext10[2];
-
-    var setValue = useConstant$1(function (update) {
-      return set(function (state) {
-        return path ? _update(path, function (v) {
-          return callIfFunction(update, v);
-        }, state) : callIfFunction(update, state);
+  var useSetLazyValue = function useSetLazyValue(path) {
+    var _useCtx7 = useCtx(),
+        _useCtx8 = _slicedToArray(_useCtx7, 3),
+        setValue = _useCtx8[1],
+        utils = _useCtx8[2];
+
+    return useConstant$1(function (update) {
+      return setValue(function (value) {
+        return value === EMPTY_VALUE ? updateStateFn(path, update)(utils.loadedValue()) : updateStateFn(path, update)(value);
       });
     });
-    return setValue;
   };
 
-  var useUtils = function useUtils(path, deps) {
-    var _useContext11 = useContext(Ctx),
-        _useContext12 = _slicedToArray(_useContext11, 3),
-        useRegister = _useContext12[0],
-        set = _useContext12[1],
-        utils = _useContext12[2];
+  var useValuePromise = function useValuePromise(selector, deps, isEqual, withTransition) {
+    var value = useSelectValue(selector, deps, isEqual, withTransition);
+    var utils = useUtils();
+    return useCallback(function () {
+      if (value === EMPTY_VALUE) {
+        return utils._lazyValue().then(function (v) {
+          return console.log(v, _s.select(selector, v), selector) || _s.select(selector, v);
+        });
+      }
 
-    return utils;
+      return new Promise(value);
+    }, [value, deps]);
   };
 
-  return [Provider, [useSelectValue, useSetState, useUtils]];
+  var LazyStateFullProvider = function LazyStateFullProvider(_ref5) {
+    var value = _ref5.value,
+        utils = _ref5.utils,
+        children = _ref5.children,
+        _ref5$fallback = _ref5.fallback,
+        fallback = _ref5$fallback === void 0 ? null : _ref5$fallback;
+
+    var _useState3 = useState(EMPTY_VALUE),
+        _useState4 = _slicedToArray(_useState3, 2),
+        state = _useState4[0],
+        setState = _useState4[1];
+
+    var promise = useRef();
+
+    var _loadedValue = useRef();
+
+    var lazyUtils = useMemo(function () {
+      return _objectSpread({}, utils, {
+        _lazyValue: function _lazyValue() {
+          var _promise$current;
+
+          (_promise$current = promise.current) !== null && _promise$current !== void 0 ? _promise$current : promise.current = callIfFunction(toPromise || _identity, value);
+          promise.current.then(function (value) {
+            _loadedValue.current = value;
+          });
+          return promise.current;
+        },
+        loadedValue: function loadedValue() {
+          return _loadedValue.current;
+        }
+      });
+    }, [value, utils]);
+    return React.createElement(Provider, {
+      value: state,
+      setValue: setState,
+      utils: lazyUtils
+    }, fallback === false ? children : React.createElement(React.Suspense, {
+      fallback: fallback
+    }, children));
+  };
+
+  return [LazyStateFullProvider, [useSelectLazyValue, useSetLazyValue, useValuePromise]];
 };
 var createSelectableContext = function createSelectableContext(v) {
-  var _createStatefulContex = createStatefulContext(v),
-      _createStatefulContex2 = _slicedToArray(_createStatefulContex, 2),
-      Provider = _createStatefulContex2[0],
-      _createStatefulContex3 = _slicedToArray(_createStatefulContex2[1], 1),
-      useSelectValue = _createStatefulContex3[0];
+  var _createStatefulContex7 = createStatefulContext(v),
+      _createStatefulContex8 = _slicedToArray(_createStatefulContex7, 2),
+      Provider = _createStatefulContex8[0],
+      _createStatefulContex9 = _slicedToArray(_createStatefulContex8[1], 1),
+      useSelectValue = _createStatefulContex9[0];
 
   return [Provider, useSelectValue];
 };
 var createTriggerUpdateContext = function createTriggerUpdateContext(v) {
-  var _createStatefulContex4 = createStatefulContext(v),
-      _createStatefulContex5 = _slicedToArray(_createStatefulContex4, 2),
-      Provider = _createStatefulContex5[0],
-      _createStatefulContex6 = _slicedToArray(_createStatefulContex5[1], 1),
-      useSelectValue = _createStatefulContex6[0];
+  var _createStatefulContex10 = createStatefulContext(v),
+      _createStatefulContex11 = _slicedToArray(_createStatefulContex10, 2),
+      Provider = _createStatefulContex11[0],
+      _createStatefulContex12 = _slicedToArray(_createStatefulContex11[1], 1),
+      useSelectValue = _createStatefulContex12[0];
 
-  var TriggerProvider = React.forwardRef(function (_ref5, ref) {
-    var children = _ref5.children;
+  var TriggerProvider = React.forwardRef(function (_ref6, ref) {
+    var children = _ref6.children;
 
     var _useState5 = useState(0),
         _useState6 = _slicedToArray(_useState5, 2),
@@ -1808,4 +1904,4 @@ var WithConstant = function WithConstant(_ref) {
   return children(constant);
 };
 
-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 };
+export { Fill, GroupEventFactory, PopupContext, Slot, SlotContext, SlotProvider, StartlibsConsumer, StartlibsContext, StartlibsMetacontext, StartlibsProvider, WithConstant, WithEffect, WithLazyPlaceholder, WithLazyResource, WithRef, clearPopups, consumes, createLazyStatefulContext, createSelectableContext, createSelfStatefulContext, createStatefulContext, createTriggerUpdateContext, useAsyncEffect, useCallState, useCallbackStable, useCatalogManager, useConstant, useConsumerCatalog, useEnsureRef, useFill, useForceUpdate, useHiddenFill, useIsUnmounted, useLazyConstant, usePopupToggle, usePrevious, usePreviousForEffect, usePreviousUnique, useRecycleFocus, useRefMemo, useRefState, useRefToggle, useTitle, useToggle, useUpdateEffect, useUpdateOnResize, useUpdateSignal, willUseForceUpdate, willUseLayers, willUseSharedCallback, willUseSharedState, willUseSpreadState, withDialogError, withGroupEvent };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@startlibs/core",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Startlibs Core",
   "main": "lib/index.js",
   "sideEffects": false,
@@ -18,6 +18,8 @@
     "@babel/plugin-proposal-class-properties": "^7.2.1",
     "@babel/plugin-proposal-export-namespace-from": "^7.2.0",
     "@babel/plugin-proposal-json-strings": "^7.2.0",
+    "@babel/plugin-proposal-logical-assignment-operators": "^7.20.7",
+    "@babel/plugin-proposal-nullish-coalescing-operator": "^7.18.6",
     "@babel/plugin-proposal-object-rest-spread": "^7.2.0",
     "@babel/plugin-proposal-optional-chaining": "^7.12.0",
     "@babel/plugin-proposal-throw-expressions": "^7.2.0",

package/rollup.config.js

@@ -38,6 +38,8 @@ export default {
         '@babel/plugin-transform-arrow-functions',
         '@babel/plugin-transform-spread',
         '@babel/plugin-proposal-object-rest-spread',
+        '@babel/plugin-proposal-nullish-coalescing-operator',
+        '@babel/plugin-proposal-logical-assignment-operators',
         ['@babel/plugin-proposal-class-properties', {'loose': true}]
       ]
     }),