intergalactic 15.126.0-prerelease.1 → 15.126.0-prerelease.11

package/utils/lib/enhances/animatedSizeEnhance.mjs

@@ -1,59 +1,90 @@
-import z from "@babel/runtime/helpers/esm/objectSpread2";
-import F from "@babel/runtime/helpers/esm/toConsumableArray";
-import L from "@babel/runtime/helpers/esm/objectWithoutProperties";
-import s from "react";
-import { useForkRef as S } from "../ref.mjs";
-import T from "../use/useEnhancedEffect.mjs";
-var A = ["ref", "__animatedEnhanceInstanceId", "duration"], O = 0;
-function $(v) {
-  var h = v.animateProps, t = h === void 0 ? [] : h, g = v.onChangeOf, I = g === void 0 ? [] : g;
-  return function(a) {
-    var b = a.ref, i = a.__animatedEnhanceInstanceId, E = a.duration, C = L(a, A), m = /* @__PURE__ */ s.createRef(), u = s.useRef([]), P = s.useRef(a), R = s.useRef(O++);
-    return P.current = a, T(function() {
-      if (!a.animationsDisabled && !(i !== void 0 && i !== R.current) && m.current) {
-        var e = m.current;
-        if (u.current.every(function(n) {
-          return n === void 0;
-        })) {
-          for (var c = 0; c < t.length; c++)
-            u.current[c] = e.getBoundingClientRect()[t[c]];
-          return;
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+var _excluded = ["ref", "__animatedEnhanceInstanceId", "duration"];
+import React from 'react';
+import { useForkRef } from "../ref.mjs";
+import useEnhancedEffect from "../use/useEnhancedEffect.mjs";
+var uniqueId = 0;
+function animatedSizeEnhance(_ref) {
+  var _ref$animateProps = _ref.animateProps,
+    animateProps = _ref$animateProps === void 0 ? [] : _ref$animateProps,
+    _ref$onChangeOf = _ref.onChangeOf,
+    onChangeOf = _ref$onChangeOf === void 0 ? [] : _ref$onChangeOf;
+  return function (props) {
+    var ref = props.ref,
+      __animatedEnhanceInstanceId = props.__animatedEnhanceInstanceId,
+      duration = props.duration,
+      other = _objectWithoutProperties(props, _excluded);
+    var nodeRef = /*#__PURE__*/React.createRef();
+    var lastSizesRef = React.useRef([]);
+    var prevPropsRef = React.useRef(props);
+    var animatedSizeInstanceIdRef = React.useRef(uniqueId++);
+    prevPropsRef.current = props;
+    useEnhancedEffect(function () {
+      if (props.animationsDisabled) return;
+      if (__animatedEnhanceInstanceId !== undefined && __animatedEnhanceInstanceId !== animatedSizeInstanceIdRef.current) return;
+      if (!nodeRef.current) {
+        return;
+      }
+      var node = nodeRef.current;
+      if (lastSizesRef.current.every(function (value) {
+        return value === undefined;
+      })) {
+        for (var i = 0; i < animateProps.length; i++) {
+          lastSizesRef.current[i] = node.getBoundingClientRect()[animateProps[i]];
         }
-        for (var o = [], r = 0; r < t.length; r++)
-          o[r] = e.getBoundingClientRect()[t[r]], (Math.abs(u.current[r] - o[r]) < 3 || e.style.getPropertyValue(t[r]).endsWith("%")) && (u.current[r] = o[r], o[r] = void 0);
-        if (!o.every(function(n) {
-          return n === void 0;
-        })) {
-          e.style.transition = "none";
-          for (var f = 0; f < t.length; f++)
-            e.style[t[f]] = "".concat(u.current[f], "px");
-          var y = -1, d = function n() {
-            if (clearTimeout(y), !!e) {
-              e.style.transition = null;
-              for (var l = 0; l < t.length; l++)
-                e.style[t[l]] = null;
-              e.removeEventListener("transitionend", n), e.removeEventListener("transitioncancel", n);
-            }
-          }, x = requestAnimationFrame(function() {
-            if (e) {
-              e.addEventListener("transitionend", d), e.addEventListener("transitioncancel", d), e.style.transition = "".concat(E, "ms all ease-in-out");
-              for (var n = 0; n < t.length; n++)
-                u.current[n] = o[n], e.style[t[n]] = "".concat(o[n], "px");
-            }
-          });
-          return y = setTimeout(d, 500), function() {
-            cancelAnimationFrame(x), d();
-          };
+        return;
+      }
+      var sizes = [];
+      for (var _i = 0; _i < animateProps.length; _i++) {
+        sizes[_i] = node.getBoundingClientRect()[animateProps[_i]];
+        if (Math.abs(lastSizesRef.current[_i] - sizes[_i]) < 3 || node.style.getPropertyValue(animateProps[_i]).endsWith('%')) {
+          lastSizesRef.current[_i] = sizes[_i];
+          sizes[_i] = undefined;
         }
       }
-    }, [i, a.animationsDisabled, E].concat(F(I.map(function(e) {
-      return a[e];
-    })))), z({
-      ref: S(b, m),
-      __animatedEnhanceInstanceId: i ?? R.current
-    }, C);
+      if (sizes.every(function (value) {
+        return value === undefined;
+      })) return;
+      node.style.transition = 'none';
+      for (var _i2 = 0; _i2 < animateProps.length; _i2++) {
+        node.style[animateProps[_i2]] = "".concat(lastSizesRef.current[_i2], "px");
+      }
+      var timeout = -1;
+      var handleTransitionEnd = function handleTransitionEnd() {
+        clearTimeout(timeout);
+        if (!node) return;
+        node.style.transition = null;
+        for (var _i3 = 0; _i3 < animateProps.length; _i3++) {
+          node.style[animateProps[_i3]] = null;
+        }
+        node.removeEventListener('transitionend', handleTransitionEnd);
+        node.removeEventListener('transitioncancel', handleTransitionEnd);
+      };
+      var animationFrame = requestAnimationFrame(function () {
+        if (!node) return;
+        node.addEventListener('transitionend', handleTransitionEnd);
+        node.addEventListener('transitioncancel', handleTransitionEnd);
+        node.style.transition = "".concat(duration, "ms all ease-in-out");
+        for (var _i4 = 0; _i4 < animateProps.length; _i4++) {
+          lastSizesRef.current[_i4] = sizes[_i4];
+          node.style[animateProps[_i4]] = "".concat(sizes[_i4], "px");
+        }
+      });
+      timeout = setTimeout(handleTransitionEnd, 500);
+      return function () {
+        cancelAnimationFrame(animationFrame);
+        handleTransitionEnd();
+      };
+    }, [__animatedEnhanceInstanceId, props.animationsDisabled, duration].concat(_toConsumableArray(onChangeOf.map(function (propName) {
+      return props[propName];
+    }))));
+    return _objectSpread({
+      ref: useForkRef(ref, nodeRef),
+      __animatedEnhanceInstanceId: __animatedEnhanceInstanceId !== null && __animatedEnhanceInstanceId !== void 0 ? __animatedEnhanceInstanceId : animatedSizeInstanceIdRef.current
+    }, other);
   };
 }
-export {
-  $ as default
-};
+export default animatedSizeEnhance;
+//# sourceMappingURL=animatedSizeEnhance.mjs.map

package/utils/lib/enhances/autoFocusEnhance.mjs

@@ -1,34 +1,38 @@
-import c from "@babel/runtime/helpers/esm/objectSpread2";
-import a from "@babel/runtime/helpers/esm/objectWithoutProperties";
-import u from "react";
-import { useForkRef as m } from "../ref.mjs";
-var s = ["autoFocus", "ref"];
-function d(e) {
-  return typeof e == "boolean" || typeof e == "number";
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+var _excluded = ["autoFocus", "ref"];
+import React from 'react';
+import { useForkRef } from "../ref.mjs";
+function notUsingNativeAutoFocus(autoFocus) {
+  return typeof autoFocus === 'boolean' || typeof autoFocus === 'number';
 }
-function p() {
-  return function(e) {
-    var r = e.autoFocus, n = e.ref, f = a(e, s);
-    if (!d(r))
-      return e;
-    var o = /* @__PURE__ */ u.createRef();
-    return u.useEffect(function() {
-      if (r !== !1) {
-        var t = o.current;
-        if (!(!t || !t.focus)) {
-          var i = setTimeout(function() {
-            return t == null ? void 0 : t.focus();
-          }, r || 0);
-          return function() {
-            clearTimeout(i);
-          };
-        }
-      }
-    }, [r]), c({
-      ref: m(n, o)
-    }, f);
+
+/** @deprecated */
+
+function autoFocusEnhance() {
+  return function (props) {
+    var autoFocus = props.autoFocus,
+      ref = props.ref,
+      other = _objectWithoutProperties(props, _excluded);
+    if (!notUsingNativeAutoFocus(autoFocus)) {
+      return props;
+    }
+    var nodeRef = /*#__PURE__*/React.createRef();
+    React.useEffect(function () {
+      if (autoFocus === false) return;
+      var inputNode = nodeRef.current;
+      if (!inputNode || !inputNode.focus) return;
+      var timer = setTimeout(function () {
+        return inputNode === null || inputNode === void 0 ? void 0 : inputNode.focus();
+      }, autoFocus || 0);
+      return function () {
+        clearTimeout(timer);
+      };
+    }, [autoFocus]);
+    return _objectSpread({
+      ref: useForkRef(ref, nodeRef)
+    }, other);
   };
 }
-export {
-  p as default
-};
+export default autoFocusEnhance;
+//# sourceMappingURL=autoFocusEnhance.mjs.map

package/utils/lib/enhances/contextEnhance.mjs

@@ -1,14 +1,14 @@
-import f from "@babel/runtime/helpers/esm/defineProperty";
-import r from "@babel/runtime/helpers/esm/objectSpread2";
-import i from "@babel/runtime/helpers/esm/objectDestructuringEmpty";
-import u from "@babel/runtime/helpers/esm/extends";
-import a from "react";
-function s(e, o) {
-  return function(t) {
-    var n = u({}, (i(t), t)), m = a.useContext(e);
-    return r(r({}, n), {}, f({}, o, m));
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
+import _objectDestructuringEmpty from "@babel/runtime/helpers/objectDestructuringEmpty";
+import _extends from "@babel/runtime/helpers/extends";
+import React from 'react';
+function contextEnhance(context, setOnProp) {
+  return function (props) {
+    var other = _extends({}, (_objectDestructuringEmpty(props), props));
+    var value = React.useContext(context);
+    return _objectSpread(_objectSpread({}, other), {}, _defineProperty({}, setOnProp, value));
   };
 }
-export {
-  s as default
-};
+export default contextEnhance;
+//# sourceMappingURL=contextEnhance.mjs.map

package/utils/lib/enhances/focusSourceEnhance.mjs

@@ -1,50 +1,66 @@
-import n from "react";
-import m from "../assignProps.mjs";
-var i = "none", r = [], b = function() {
-  var u = n.useCallback(function() {
-    return r.forEach(function(e) {
-      return e.setFocusSource("mouse");
+import React from 'react';
+import assignProps from "../assignProps.mjs";
+var lastFocusSource = 'none';
+var focusSourceListeners = [];
+export var useFocusSource = function useFocusSource() {
+  var handleMouseDown = React.useCallback(function () {
+    return focusSourceListeners.forEach(function (listener) {
+      return listener.setFocusSource('mouse');
     });
-  }, []), o = n.useCallback(function() {
-    return r.forEach(function(e) {
-      return e.setFocusSource("keyboard");
+  }, []);
+  var handleKeyDown = React.useCallback(function () {
+    return focusSourceListeners.forEach(function (listener) {
+      return listener.setFocusSource('keyboard');
     });
-  }, []), t = n.useRef(i), d = n.useCallback(function(e) {
-    t.current = e, i = e;
-  }, []), c = n.useCallback(function() {
-    document.addEventListener("mousedown", u, {
-      capture: !0
-    }), document.addEventListener("keydown", o, {
-      capture: !0
+  }, []);
+  var focusSourceRef = React.useRef(lastFocusSource);
+  var setFocusSource = React.useCallback(function (source) {
+    focusSourceRef.current = source;
+    lastFocusSource = source;
+  }, []);
+  var subscribeListeners = React.useCallback(function () {
+    document.addEventListener('mousedown', handleMouseDown, {
+      capture: true
     });
-  }, []), v = n.useCallback(function() {
-    document.removeEventListener("mousedown", u, {
-      capture: !0
-    }), document.removeEventListener("keydown", o, {
-      capture: !0
+    document.addEventListener('keydown', handleKeyDown, {
+      capture: true
     });
   }, []);
-  return n.useEffect(function() {
-    var e = r.length === 0, s = {
-      setFocusSource: d,
-      subscribeListeners: c
+  var unsubscribeListeners = React.useCallback(function () {
+    document.removeEventListener('mousedown', handleMouseDown, {
+      capture: true
+    });
+    document.removeEventListener('keydown', handleKeyDown, {
+      capture: true
+    });
+  }, []);
+  React.useEffect(function () {
+    var needToAddListeners = focusSourceListeners.length === 0;
+    var sourceListener = {
+      setFocusSource: setFocusSource,
+      subscribeListeners: subscribeListeners
     };
-    r.push(s), e && c();
-    var a = e;
-    return function() {
-      var l = r.indexOf(s);
-      r.splice(l, 1), a && v(), a && r.length > 0 && r[0].subscribeListeners();
+    focusSourceListeners.push(sourceListener);
+    if (needToAddListeners) subscribeListeners();
+    var needToRemoveListeners = needToAddListeners;
+    return function () {
+      var sourceListenerIndex = focusSourceListeners.indexOf(sourceListener);
+      focusSourceListeners.splice(sourceListenerIndex, 1);
+      if (needToRemoveListeners) unsubscribeListeners();
+      if (needToRemoveListeners && focusSourceListeners.length > 0) {
+        focusSourceListeners[0].subscribeListeners();
+      }
     };
-  }, []), t;
-}, p = function() {
-  return function(u) {
-    var o = b();
-    return m(u, {
-      focusSourceRef: o
+  }, []);
+  return focusSourceRef;
+};
+var focusSourceEnhance = function focusSourceEnhance() {
+  return function (props) {
+    var focusSourceRef = useFocusSource();
+    return assignProps(props, {
+      focusSourceRef: focusSourceRef
     });
   };
 };
-export {
-  p as default,
-  b as useFocusSource
-};
+export default focusSourceEnhance;
+//# sourceMappingURL=focusSourceEnhance.mjs.map

package/utils/lib/enhances/i18nEnhance.mjs

@@ -1,72 +1,92 @@
-import q from "@babel/runtime/helpers/esm/defineProperty";
-import $ from "@babel/runtime/helpers/esm/typeof";
-import w from "@babel/runtime/helpers/esm/regeneratorRuntime";
-import f from "@babel/runtime/helpers/esm/objectSpread2";
-import y from "@babel/runtime/helpers/esm/slicedToArray";
-import z from "@babel/runtime/helpers/esm/asyncToGenerator";
-import o from "react";
-import { useI18n as B } from "./WithI18n.mjs";
-var W = function(e, r, u) {
-  var c, i = o.useMemo(function() {
-    if (!u) return e;
-    if (!e) return u;
-    if (e === u) return e;
-    var s = {}, t = function(n) {
-      if (typeof e[n] == "function" || typeof u[n] == "function")
-        s[n] = /* @__PURE__ */ z(/* @__PURE__ */ w().mark(function O() {
-          var j, p, I, P;
-          return w().wrap(function(v) {
-            for (; ; ) switch (v.prev = v.next) {
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _typeof from "@babel/runtime/helpers/typeof";
+import _regeneratorRuntime from "@babel/runtime/helpers/regeneratorRuntime";
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import React from 'react';
+import { useI18n } from "./WithI18n.mjs";
+export var useAsyncI18nMessages = function useAsyncI18nMessages(primaryContainer, locale, fallbackContainer) {
+  var _store$locale;
+  var container = React.useMemo(function () {
+    if (!fallbackContainer) return primaryContainer;
+    if (!primaryContainer) return fallbackContainer;
+    if (primaryContainer === fallbackContainer) return primaryContainer;
+    var container = {};
+    var _loop = function _loop(_locale) {
+      if (typeof primaryContainer[_locale] === 'function' || typeof fallbackContainer[_locale] === 'function') {
+        container[_locale] = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+          var _yield$Promise$all, _yield$Promise$all2, primary, fallback;
+          return _regeneratorRuntime().wrap(function _callee$(_context) {
+            while (1) switch (_context.prev = _context.next) {
               case 0:
-                return v.next = 2, Promise.all([e[n], u[n]]);
+                _context.next = 2;
+                return Promise.all([primaryContainer[_locale], fallbackContainer[_locale]]);
               case 2:
-                return j = v.sent, p = y(j, 2), I = p[0], P = p[1], v.abrupt("return", f(f({}, I), P));
+                _yield$Promise$all = _context.sent;
+                _yield$Promise$all2 = _slicedToArray(_yield$Promise$all, 2);
+                primary = _yield$Promise$all2[0];
+                fallback = _yield$Promise$all2[1];
+                return _context.abrupt("return", _objectSpread(_objectSpread({}, primary), fallback));
               case 7:
               case "end":
-                return v.stop();
+                return _context.stop();
             }
-          }, O);
+          }, _callee);
         }));
-      else {
-        var a, g;
-        s[n] = f(f({}, (a = e[n]) !== null && a !== void 0 ? a : {}), (g = u[n]) !== null && g !== void 0 ? g : {});
+      } else {
+        var _primaryContainer$_lo, _fallbackContainer$_l;
+        container[_locale] = _objectSpread(_objectSpread({}, (_primaryContainer$_lo = primaryContainer[_locale]) !== null && _primaryContainer$_lo !== void 0 ? _primaryContainer$_lo : {}), (_fallbackContainer$_l = fallbackContainer[_locale]) !== null && _fallbackContainer$_l !== void 0 ? _fallbackContainer$_l : {});
       }
     };
-    for (var m in e)
-      t(m);
-    return s;
-  }, [e, u]), A = o.useMemo(function() {
-    var s = {};
-    for (var t in i)
-      $(i[t]) === "object" && (s[t] = i[t]);
-    return s;
-  }, [i]), L = o.useState(A), M = y(L, 2), d = M[0], T = M[1], E = o.useRef(null);
-  d[r] && (E.current = r);
-  var G = o.useMemo(function() {
-    return Object.values(d)[0];
-  }, [d]), S = o.useRef(null);
-  return o.useEffect(function() {
-    S.current = r;
-    var s = i[r];
-    typeof s == "function" && s().then(function(t) {
-      if (S.current === r) {
-        var m = t;
-        "default" in t && $(t.default) === "object" && (m = t.default), T(function(h) {
-          return f(f({}, h), {}, q({}, r, m));
-        });
+    for (var _locale in primaryContainer) {
+      _loop(_locale);
+    }
+    return container;
+  }, [primaryContainer, fallbackContainer]);
+  var initStore = React.useMemo(function () {
+    var store = {};
+    for (var _locale2 in container) {
+      if (_typeof(container[_locale2]) === 'object') {
+        store[_locale2] = container[_locale2];
       }
-    }).catch(console.error);
-  }, [i, r]), (c = d[r]) !== null && c !== void 0 ? c : G;
+    }
+    return store;
+  }, [container]);
+  var _React$useState = React.useState(initStore),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    store = _React$useState2[0],
+    setStore = _React$useState2[1];
+  var lastLoadedLocaleRef = React.useRef(null);
+  if (store[locale]) lastLoadedLocaleRef.current = locale;
+  var fallbackMessages = React.useMemo(function () {
+    return Object.values(store)[0];
+  }, [store]);
+  var loadingLocaleRef = React.useRef(null);
+  React.useEffect(function () {
+    loadingLocaleRef.current = locale;
+    var asyncMessages = container[locale];
+    if (typeof asyncMessages === 'function') {
+      asyncMessages().then(function (module) {
+        if (loadingLocaleRef.current !== locale) return;
+        var messages = module;
+        if ('default' in module && _typeof(module["default"]) === 'object') messages = module["default"];
+        setStore(function (store) {
+          return _objectSpread(_objectSpread({}, store), {}, _defineProperty({}, locale, messages));
+        });
+      })["catch"](console.error);
+    }
+  }, [container, locale]);
+  return (_store$locale = store[locale]) !== null && _store$locale !== void 0 ? _store$locale : fallbackMessages;
 };
-const X = function(R) {
-  return function(e) {
-    var r = e.i18n, u = e.locale, c = B(r, u, R);
-    return f(f({}, e), {}, {
-      getI18nText: c
+export default (function (container) {
+  return function (props) {
+    var i18n = props.i18n,
+      locale = props.locale;
+    var getI18nText = useI18n(i18n, locale, container);
+    return _objectSpread(_objectSpread({}, props), {}, {
+      getI18nText: getI18nText
     });
   };
-};
-export {
-  X as default,
-  W as useAsyncI18nMessages
-};
+});
+//# sourceMappingURL=i18nEnhance.mjs.map

package/utils/lib/enhances/keyboardFocusEnhance.mjs

@@ -1,40 +1,59 @@
-import k from "@babel/runtime/helpers/esm/slicedToArray";
-import e from "react";
-import x from "../assignProps.mjs";
-import { useFocusSource as g } from "./focusSourceEnhance.mjs";
-var h = /* @__PURE__ */ e.createContext(!1), I = function() {
-  var d = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : !0;
-  return function(r) {
-    var t, o = r.autoFocus, u = r.disabled || r.loading, i = (t = r.tabIndex) !== null && t !== void 0 ? t : d ? 0 : void 0, l = e.useState(!1), s = k(l, 2), v = s[0], a = s[1], b = g(), f = e.useRef(null), m = e.useCallback(function(n) {
-      n.isTrusted === !0 && b.current !== "keyboard" || a(!0);
-    }, []), F = e.useCallback(function() {
-      return a(!1);
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import React from 'react';
+import assignProps from "../assignProps.mjs";
+import { useFocusSource } from "./focusSourceEnhance.mjs";
+export { useFocusSource };
+
+/** @deprecated */
+
+export var enforcedKeyboardFocusEnhanceContext = /*#__PURE__*/React.createContext(false);
+var keyboardFocusEnhance = function keyboardFocusEnhance() {
+  var makeFocusable = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+  return function (props) {
+    var _props$tabIndex;
+    var autoFocus = props.autoFocus;
+    var disabled = props.disabled || props.loading;
+    var tabIndex = (_props$tabIndex = props.tabIndex) !== null && _props$tabIndex !== void 0 ? _props$tabIndex : makeFocusable ? 0 : undefined;
+    var _React$useState = React.useState(false),
+      _React$useState2 = _slicedToArray(_React$useState, 2),
+      keyboardFocused = _React$useState2[0],
+      setKeyboardFocused = _React$useState2[1];
+    var focusSourceRef = useFocusSource();
+    var ref = React.useRef(null);
+    var handleFocus = React.useCallback(function (event) {
+      if (event.isTrusted === true) {
+        if (focusSourceRef.current !== 'keyboard') return;
+      }
+      setKeyboardFocused(true);
+    }, []);
+    var handlerBlur = React.useCallback(function () {
+      return setKeyboardFocused(false);
     }, []);
-    e.useEffect(function() {
-      if (!(typeof o != "number" && !o)) {
-        var n = setTimeout(function() {
-          var c;
-          (c = f.current) === null || c === void 0 || c.focus(), a(!0);
-        }, 0);
-        return function() {
-          clearTimeout(n);
-        };
+    React.useEffect(function () {
+      if (typeof autoFocus !== 'number' && !autoFocus) return;
+      var timer = setTimeout(function () {
+        var _ref$current;
+        (_ref$current = ref.current) === null || _ref$current === void 0 ? void 0 : _ref$current.focus();
+        setKeyboardFocused(true);
+      }, 0);
+      return function () {
+        clearTimeout(timer);
+      };
+    }, [autoFocus]);
+    React.useEffect(function () {
+      if (disabled) {
+        setKeyboardFocused(false);
       }
-    }, [o]), e.useEffect(function() {
-      u && a(!1);
-    }, [u]);
-    var y = e.useContext(h);
-    return x(r, {
-      tabIndex: u ? -1 : i,
-      keyboardFocused: (v || y) && !u,
-      onFocus: m,
-      onBlur: F,
-      ref: f
+    }, [disabled]);
+    var enforcedKeyboardFocus = React.useContext(enforcedKeyboardFocusEnhanceContext);
+    return assignProps(props, {
+      tabIndex: disabled ? -1 : tabIndex,
+      keyboardFocused: (keyboardFocused || enforcedKeyboardFocus) && !disabled,
+      onFocus: handleFocus,
+      onBlur: handlerBlur,
+      ref: ref
     });
   };
 };
-export {
-  I as default,
-  h as enforcedKeyboardFocusEnhanceContext,
-  g as useFocusSource
-};
+export default keyboardFocusEnhance;
+//# sourceMappingURL=keyboardFocusEnhance.mjs.map

package/utils/lib/enhances/resolveColorEnhance.mjs

@@ -1,16 +1,17 @@
-import n from "react";
-import { useColorResolver as t } from "../use/useColorResolver.mjs";
-import { useForkRef as a } from "../ref.mjs";
-import l from "../assignProps.mjs";
-var c = function() {
-  return function(r) {
-    var e = r.ref, o = n.useRef(), f = t();
-    return l(r, {
-      ref: a(e, o),
-      resolveColor: f
+import React from 'react';
+import { useColorResolver } from "../use/useColorResolver.mjs";
+import { useForkRef } from "../ref.mjs";
+import assignProps from "../assignProps.mjs";
+var resolveColorEnhance = function resolveColorEnhance() {
+  return function (props) {
+    var ref = props.ref;
+    var internalRef = React.useRef();
+    var resolveColor = useColorResolver();
+    return assignProps(props, {
+      ref: useForkRef(ref, internalRef),
+      resolveColor: resolveColor
     });
   };
 };
-export {
-  c as default
-};
+export default resolveColorEnhance;
+//# sourceMappingURL=resolveColorEnhance.mjs.map