@semcore/core 16.6.1 → 16.6.2-prerelease.0

package/.cache/esbuild_plugin_semcore_resolver/src_styled_reshadow-core.ts_contents

@@ -0,0 +1,236 @@
+import _typeof from "@babel/runtime/helpers/typeof";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+/**
+ * This is source form @reshadow/core@0.0.1
+ * Put it here, because we can't use the version from the package in ESM builds.
+ * The package is not update for 3 years and we have plans to remove them. So, this tmp copy version is acceptable
+ */
+// @ts-nocheck
+var _Symbol = function _Symbol(key) {
+  return typeof Symbol !== 'undefined' ? Symbol(key) : key;
+};
+var KEYS = {
+  __id__: _Symbol('__id__'),
+  __store__: _Symbol('__store__'),
+  __prev__: _Symbol('__prev__'),
+  __use__: _Symbol('__use__'),
+  __elements__: '__elements__',
+  __style__: '$$style',
+  __styles__: 'styles',
+  __css__: '__css__',
+  __hash__: '__hash__',
+  /**
+   * This prop is needed for the interop between different component frameworks
+   */
+  __classProp__: 'className'
+};
+var index = 0;
+var use = function use(obj) {
+  var result = {};
+  result[KEYS.__use__] = obj;
+  return result;
+};
+var create = function create(args) {
+  var len = args.length;
+  var newStyle = {};
+  var id = '';
+  var vars = null;
+  var uses = null;
+  for (var i = 0; i < len; i++) {
+    var _style = args[i];
+    if (!_style) continue;
+    if (!_style[KEYS.__id__]) {
+      _style[KEYS.__id__] = ++index;
+      _style[KEYS.__store__] = _defineProperty({}, '_' + _style[KEYS.__id__], _style);
+    }
+    id += '_' + _style[KEYS.__id__];
+    if (_style[KEYS.__style__]) {
+      vars = Object.assign(vars || {}, _style[KEYS.__style__]);
+    }
+    if (_style[KEYS.__use__]) {
+      uses = Object.assign(uses || {}, _style[KEYS.__use__]);
+    }
+    if (_style[KEYS.__store__][id]) {
+      newStyle = _style[KEYS.__store__][id];
+      continue;
+    }
+    newStyle = Object.create(newStyle);
+    for (var key in _style) {
+      if (key in KEYS) continue;
+      newStyle[key] = appendClassName(_style[key], newStyle[key]);
+    }
+    _style[KEYS.__store__][id] = newStyle;
+    newStyle[KEYS.__id__] = index;
+    newStyle[KEYS.__store__] = _defineProperty({}, '_' + _style[KEYS.__id__], newStyle);
+  }
+  if (vars || use) {
+    newStyle = Object.create(newStyle);
+    newStyle[KEYS.__style__] = vars;
+    newStyle[KEYS.__use__] = uses;
+  }
+  return newStyle;
+};
+var isSSR = !(typeof window !== 'undefined' && window.document && window.document.createElement);
+var serverMap = {};
+var getStyles = function getStyles() {
+  return {
+    map: serverMap,
+    get css() {
+      var serverStyles = '';
+      for (var id in serverMap) {
+        serverStyles += "<style type=\"text/css\" id=\"".concat(id, "\">").concat(serverMap[id], "</style>");
+      }
+      return serverStyles;
+    }
+  };
+};
+var clearStyles = function clearStyles() {
+  serverStyles = '';
+};
+var RESHADOW_ID = '__reshadow__';
+var appendChildToDocumentHead = function appendChildToDocumentHead(element) {
+  return document.head.appendChild(element);
+};
+var css = function css(code, hash) {
+  var id = "reshadow-".concat(hash);
+  if (isSSR) {
+    serverMap[id] = code;
+    return;
+  }
+  var container = document.getElementById(RESHADOW_ID);
+  if (!container) {
+    container = document.createElement('object');
+    container.id = RESHADOW_ID;
+    if (document.head) {
+      appendChildToDocumentHead(container);
+    } else {
+      document.addEventListener('DOMContentLoaded', function () {
+        appendChildToDocumentHead(container);
+      });
+    }
+  }
+  var css = document.getElementById(id);
+  if (!css) {
+    css = document.createElement('style');
+    css.id = id;
+    css.type = 'text/css';
+    container.appendChild(css);
+  }
+  css.innerHTML = code;
+};
+var styles = {};
+var style;
+var stack = [];
+var _styled = function styled(elem) {
+  var curr = stack.pop() || [];
+  styles = curr[0] || styles;
+  style = curr[1] || style;
+  _styled[KEYS.__styles__] = styles;
+  _styled[KEYS.__style__] = style;
+  return elem;
+};
+_styled[KEYS.__styles__] = styles;
+var set = function set(args, newStyle) {
+  var newStyles = create(args);
+  stack.push([styles, style]);
+  styles = newStyles;
+  style = newStyle;
+  if (styles[KEYS.__style__]) {
+    style = style ? Object.assign({}, style, styles[KEYS.__style__]) : styles[KEYS.__style__];
+  }
+  _styled[KEYS.__styles__] = styles;
+  _styled[KEYS.__style__] = style;
+};
+var USE_PREFIX = 'use--';
+var ELEMENT_PREFIX = '__';
+var MOD_PREFIX = '_';
+var MOD_SEPARATOR = '_';
+var parseElement = function parseElement(name) {
+  return name.replace(ELEMENT_PREFIX, '');
+};
+var parseAttribute = function parseAttribute(name) {
+  return name.replace(MOD_PREFIX, '').split(MOD_SEPARATOR);
+};
+var appendClassName = function appendClassName(className) {
+  var cn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  if (className) {
+    cn += (cn ? ' ' : '') + className;
+  }
+  return cn;
+};
+var appendElement = function appendElement(styles, key) {
+  var cn = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+  return appendClassName(styles[ELEMENT_PREFIX + key], cn);
+};
+var appendModifier = function appendModifier(styles, key, value) {
+  var cn = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '';
+  // isFalsy
+  if (value === undefined || value === null || value === false || value === '') return cn;
+  cn = appendClassName(styles[MOD_PREFIX + key], cn);
+
+  // value should be only primitive
+  if (typeof value === 'boolean' || _typeof(value) === 'object' || typeof value === 'function') return cn;
+  cn = appendClassName(styles[MOD_SEPARATOR + key + MOD_SEPARATOR + value], cn);
+  return cn;
+};
+function map(element) {
+  var currStyles = _styled[KEYS.__styles__];
+  var nextProps = {};
+  var cn = appendElement(currStyles, element);
+  var vars = null;
+  var uses = currStyles[KEYS.__use__] || {};
+  var len = arguments.length;
+  var useProps;
+  for (var i = len - 1; i > 0; i--) {
+    // eslint-disable-next-line prefer-rest-params
+    var currProps = arguments[i];
+    if (!currProps) continue;
+    useProps = useProps || currProps[KEYS.__use__];
+    if (!vars && KEYS.__style__ in currProps) {
+      vars = _styled[KEYS.__style__];
+    }
+    for (var key in currProps) {
+      if (key === KEYS.__use__ || key === KEYS.__style__ || key in nextProps) {
+        continue;
+      }
+      var value = currProps[key];
+      cn = appendModifier(currStyles, key, value, cn);
+      var valueType = _typeof(value);
+      if (valueType === 'string' || valueType === 'boolean' || valueType === 'number') {
+        var useKey = key + '_' + value;
+        if (key + '_' + true in uses || useKey in uses) {
+          cn = appendModifier(currStyles, USE_PREFIX + key, value, cn);
+          if (uses[useKey]) {
+            continue;
+          }
+        }
+      }
+      nextProps[key] = value;
+    }
+  }
+  if (useProps) {
+    for (var _key in useProps) {
+      var _value = useProps[_key];
+      cn = appendModifier(currStyles, USE_PREFIX + _key, _value, cn);
+    }
+  }
+  cn = appendClassName(nextProps[KEYS.__classProp__], cn);
+  if (cn) nextProps[KEYS.__classProp__] = cn;
+  if (vars) {
+    nextProps.style = typeof style === 'string' ? vars + (nextProps.style || '') : Object.assign({}, vars, nextProps.style || {});
+  }
+  return nextProps;
+}
+export { _styled as styled, use, css, create, set, map,
+// '__css__': css,
+// '__extract__': () => ({
+//     [KEYS.__styles__]: styled[[KEYS.__styles__]],
+//     [KEYS.__style__]: styled[[KEYS.__style__]],
+// }),
+
+// ssr
+getStyles, clearStyles,
+// utils
+appendModifier, appendElement, appendClassName, parseAttribute, parseElement,
+// constants
+MOD_SEPARATOR, MOD_PREFIX, ELEMENT_PREFIX, USE_PREFIX, KEYS, RESHADOW_ID };

package/.cache/esbuild_plugin_semcore_resolver/src_styled_reshadow-core.ts_hash_sum

@@ -0,0 +1 @@
+50b300cb0e6b8801aca02fbc2f43fdb7

package/.cache/esbuild_plugin_semcore_resolver/src_styled_reshadow-core.ts_last_use

@@ -0,0 +1 @@
+1779370328819

package/.cache/esbuild_plugin_semcore_resolver/src_styled_sstyled.tsx_contents

@@ -0,0 +1,143 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _cn from 'classnames';
+/** @ts-ignore */
+import { getStyles as reshadowGetStyles } from './reshadow-core';
+var RESHADOW_ID = '__reshadow__';
+var isSSR = !(typeof window !== 'undefined' && window.document && window.document.createElement);
+var serverMap = reshadowGetStyles().map;
+var getStyles = function getStyles() {
+  return {
+    map: serverMap,
+    get css() {
+      var serverStyles = '';
+      for (var id in serverMap) {
+        serverStyles += "<style type='text/css' id='".concat(id, "'>").concat(serverMap[id], "</style>");
+      }
+      return serverStyles;
+    }
+  };
+};
+function insert(code, hash) {
+  var id = 'reshadow-'.concat(hash);
+  if (isSSR) {
+    serverMap[id] = code;
+    return;
+  }
+  var container = document.getElementById(RESHADOW_ID);
+  if (!container) {
+    container = document.createElement('object');
+    container.id = RESHADOW_ID;
+    if (document.head) {
+      document.head.appendChild(container);
+    } else {
+      document.addEventListener('DOMContentLoaded', function () {
+        document.head.appendChild(container);
+      });
+    }
+  }
+  var css = document.getElementById(id);
+  if (!css) {
+    css = document.createElement('style');
+    css.id = id;
+    // @ts-ignore
+    css.type = 'text/css';
+    container.appendChild(css);
+  }
+  css.innerHTML = code;
+}
+function merge() {
+  var s1 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var s2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  return Object.entries(s2).reduce(function (acc, _ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+      key = _ref2[0],
+      value = _ref2[1];
+    if (key.startsWith('@') || key.startsWith('--')) {
+      acc[key] = value;
+    } else {
+      acc[key] = _cn(acc[key], value);
+    }
+    return acc;
+  }, Object.assign({}, s1));
+}
+function getClassAndVars(styles, name, props) {
+  function getPropValue(key, props) {
+    var _props;
+    return (_props = props["use:".concat(key)]) !== null && _props !== void 0 ? _props : props[key];
+  }
+  return Object.entries(styles).reduce(function (acc, _ref3) {
+    var _ref4 = _slicedToArray(_ref3, 2),
+      key = _ref4[0],
+      value = _ref4[1];
+    if (key.startsWith('--')) {
+      // @ts-ignore
+      acc[1][value] = getPropValue(key.substring(2), props);
+    } else if (name === key) {
+      // @ts-ignore
+      acc[0][value] = true;
+    } else {
+      var _key$split = key.split('='),
+        _key$split2 = _slicedToArray(_key$split, 2),
+        mod = _key$split2[0],
+        modValue = _key$split2[1];
+      var propValue = getPropValue(mod, props);
+      if (modValue === undefined) {
+        // @ts-ignore
+        acc[0][value] = Boolean(propValue !== null && propValue !== void 0 ? propValue : false);
+      } else {
+        // @ts-ignore
+
+        acc[0][value] = propValue == modValue;
+      }
+    }
+    return acc;
+  }, [{}, {}]);
+}
+var reshadowMap = new WeakMap();
+function reshadowToShadow(obj) {
+  if (reshadowMap.has(obj)) {
+    return reshadowMap.get(obj);
+  }
+  var shadowStyle = Object.entries(obj).reduce(function (style, _ref5) {
+    var _ref6 = _slicedToArray(_ref5, 2),
+      name = _ref6[0],
+      value = _ref6[1];
+    var n = name;
+    if (name.startsWith('__')) {
+      n = name.replace(/^__/, '');
+    } else if (name.startsWith('_')) {
+      n = name.replace(/^_/, '').replace('_', '=');
+    }
+    style[n] = value;
+    return style;
+  }, {});
+  reshadowMap.set(obj, shadowStyle);
+  return shadowStyle;
+}
+function sstyled() {
+  var styles = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  // @ts-ignore
+  return {
+    cn: function cn(name, props) {
+      var _getClassAndVars = getClassAndVars(reshadowToShadow(styles), name, props),
+        _getClassAndVars2 = _slicedToArray(_getClassAndVars, 2),
+        classes = _getClassAndVars2[0],
+        style = _getClassAndVars2[1];
+      if (Object.keys(classes).length) {
+        props.className = _cn(props.className, classes);
+      }
+      if (Object.keys(style).length) {
+        props.style = Object.assign(style, props.style);
+      }
+      return props;
+    }
+  };
+}
+sstyled.css = function (_css) {
+  throw new Error('Enable babel plugin');
+};
+sstyled.insert = insert;
+sstyled.merge = merge;
+sstyled.getStyles = getStyles;
+sstyled.SHADOW_STYLES = Symbol('SHADOW_STYLES');
+export { sstyled };

package/.cache/esbuild_plugin_semcore_resolver/src_styled_sstyled.tsx_hash_sum

@@ -0,0 +1 @@
+52c5c59a08205200549a79b1e701bf56

package/.cache/esbuild_plugin_semcore_resolver/src_styled_sstyled.tsx_last_use

@@ -0,0 +1 @@
+1779370328819

package/.cache/esbuild_plugin_semcore_resolver/src_utils_assignProps.ts_contents

@@ -0,0 +1,83 @@
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
+import cn from 'classnames';
+import { forkRef } from './ref';
+import { sstyled } from '../styled/index';
+export function callAllEventHandlers() {
+  for (var _len = arguments.length, fns = new Array(_len), _key = 0; _key < _len; _key++) {
+    fns[_key] = arguments[_key];
+  }
+  return function () {
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
+    return !fns.some(function (fn) {
+      var result;
+      if (fn) {
+        result = fn.apply(void 0, args);
+      }
+      return typeof result === 'boolean' && !result;
+    });
+  };
+}
+export function assignHandlers(props, source) {
+  return Object.keys(source).reduce(function (proxySource, propName) {
+    if (typeof source[propName] === 'function' && propName.startsWith('on')) {
+      proxySource[propName] = callAllEventHandlers(props[propName], source[propName]);
+    }
+    return proxySource;
+  }, {});
+}
+function assignHandlersInner(props, source) {
+  return Object.keys(source).reduce(function (proxySource, propName) {
+    if (propName !== 'ref' && propName.startsWith('on')) {
+      if (typeof source[propName] === 'function' && typeof props[propName] === 'function') {
+        proxySource[propName] = callAllEventHandlers(props[propName], source[propName]);
+      } else if (typeof source[propName] === 'function') {
+        proxySource[propName] = source[propName];
+      } else if (typeof props[propName] === 'function') {
+        proxySource[propName] = props[propName];
+      }
+    }
+    return proxySource;
+  }, {});
+}
+export default function assignProps() {
+  var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var source = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  // @ts-ignore
+  if (props === source) return props;
+  var newProps = _objectSpread(_objectSpread(_objectSpread({}, source), props), assignHandlersInner(props, source));
+  for (var _key3 in source) {
+    if (_key3.startsWith('use:')) {
+      var originalKey = _key3.slice('use:'.length);
+      newProps[originalKey] = source[_key3];
+    }
+  }
+  for (var _key4 in props) {
+    if (_key4.startsWith('use:')) {
+      var _originalKey = _key4.slice('use:'.length);
+      newProps[_originalKey] = props[_key4];
+    }
+  }
+
+  // because react set getter for ref
+  var sourceDescriptorRef = Object.getOwnPropertyDescriptor(source, 'ref');
+  var propsDescriptorRef = Object.getOwnPropertyDescriptor(props, 'ref');
+  if (sourceDescriptorRef !== null && sourceDescriptorRef !== void 0 && sourceDescriptorRef.configurable && propsDescriptorRef !== null && propsDescriptorRef !== void 0 && propsDescriptorRef.configurable) {
+    newProps.ref = forkRef(source.ref, props.ref);
+  }
+  if (props.forwardRef) {
+    newProps.ref = forkRef(newProps.ref, props.forwardRef);
+    newProps.forwardRef = newProps.ref;
+  }
+  if (source.style && props.style) {
+    newProps.style = _objectSpread(_objectSpread({}, source.style), props.style);
+  }
+  if (source.className) {
+    newProps.className = cn(props.className, source.className);
+  }
+  if (source.styles && props.styles) {
+    newProps.styles = sstyled.merge(source.styles, props.styles);
+  }
+  return newProps;
+}

package/.cache/esbuild_plugin_semcore_resolver/src_utils_assignProps.ts_hash_sum

@@ -0,0 +1 @@
+33fde77e749b51ff7c902c01eb00f89b

package/.cache/esbuild_plugin_semcore_resolver/src_utils_assignProps.ts_last_use

@@ -0,0 +1 @@
+1779370328821

package/.cache/esbuild_plugin_semcore_resolver/src_utils_canUseDOM.ts_contents

@@ -0,0 +1,3 @@
+export default function () {
+  return !!(typeof window !== 'undefined' && window.document && window.document.createElement);
+}

package/.cache/esbuild_plugin_semcore_resolver/src_utils_canUseDOM.ts_hash_sum

@@ -0,0 +1 @@
+2ece09f1a8c108447dd396c1253b638d

package/.cache/esbuild_plugin_semcore_resolver/src_utils_canUseDOM.ts_last_use

@@ -0,0 +1 @@
+1779370328819

package/.cache/esbuild_plugin_semcore_resolver/src_utils_capitalizeFirstLetter.ts_contents

@@ -0,0 +1,3 @@
+export default function capitalizeFirstLetter(input) {
+  return input.charAt(0).toUpperCase() + input.slice(1);
+}

package/.cache/esbuild_plugin_semcore_resolver/src_utils_capitalizeFirstLetter.ts_hash_sum

@@ -0,0 +1 @@
+dfa37f168dfd548716ff86a0d4774c9d

package/.cache/esbuild_plugin_semcore_resolver/src_utils_capitalizeFirstLetter.ts_last_use

@@ -0,0 +1 @@
+1779370328836

package/.cache/esbuild_plugin_semcore_resolver/src_utils_enhances_WithI18n.tsx_contents

@@ -0,0 +1,26 @@
+import { createIntl, createIntlCache } from '@formatjs/intl';
+import React, { createContext } from 'react';
+import { useAsyncI18nMessages } from './i18nEnhance';
+export var Context = /*#__PURE__*/createContext(undefined);
+var I18nProvider = Context.Provider,
+  I18nConsumer = Context.Consumer;
+var messagesCache = createIntlCache();
+var useI18n = function useI18n(dictionary) {
+  var _React$useContext;
+  var locale = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'en';
+  var fallbackDictionary = arguments.length > 2 ? arguments[2] : undefined;
+  var lang = (_React$useContext = React.useContext(Context)) !== null && _React$useContext !== void 0 ? _React$useContext : locale;
+  var resolvedDictionary = useAsyncI18nMessages(dictionary, lang, fallbackDictionary);
+  var intl = React.useMemo(function () {
+    return createIntl({
+      locale: lang,
+      messages: resolvedDictionary
+    }, messagesCache);
+  }, [resolvedDictionary, lang]);
+  return React.useCallback(function (messageId, variables) {
+    return intl.formatMessage({
+      id: messageId !== null && messageId !== void 0 ? messageId : ''
+    }, variables);
+  }, [intl]);
+};
+export { useI18n, I18nProvider, I18nConsumer };

package/.cache/esbuild_plugin_semcore_resolver/src_utils_enhances_WithI18n.tsx_hash_sum

@@ -0,0 +1 @@
+b2045b494405b013b90aac0df8dee41a

package/.cache/esbuild_plugin_semcore_resolver/src_utils_enhances_WithI18n.tsx_last_use

@@ -0,0 +1 @@
+1779370328836

package/.cache/esbuild_plugin_semcore_resolver/src_utils_enhances_i18nEnhance.tsx_contents

@@ -0,0 +1,91 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _typeof from "@babel/runtime/helpers/typeof";
+import _regenerator from "@babel/runtime/helpers/regenerator";
+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';
+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__*/_regenerator().m(function _callee() {
+          var _yield$Promise$all, _yield$Promise$all2, primary, fallback;
+          return _regenerator().w(function (_context) {
+            while (1) switch (_context.n) {
+              case 0:
+                _context.n = 1;
+                return Promise.all([primaryContainer[_locale], fallbackContainer[_locale]]);
+              case 1:
+                _yield$Promise$all = _context.v;
+                _yield$Promise$all2 = _slicedToArray(_yield$Promise$all, 2);
+                primary = _yield$Promise$all2[0];
+                fallback = _yield$Promise$all2[1];
+                return _context.a(2, _objectSpread(_objectSpread({}, primary), fallback));
+            }
+          }, _callee);
+        }));
+      } 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 _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];
+      }
+    }
+    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"](function (err) {
+        // eslint-disable-next-line no-console
+        console.error(err);
+      });
+    }
+  }, [container, locale]);
+  return (_store$locale = store[locale]) !== null && _store$locale !== void 0 ? _store$locale : fallbackMessages;
+};
+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
+    });
+  };
+});

package/.cache/esbuild_plugin_semcore_resolver/src_utils_enhances_i18nEnhance.tsx_hash_sum

@@ -0,0 +1 @@
+f7e63a244e5772d450af9e587c18a24a

package/.cache/esbuild_plugin_semcore_resolver/src_utils_enhances_i18nEnhance.tsx_last_use

@@ -0,0 +1 @@
+1779370328840