@semcore/core 16.6.1 → 16.6.2

package/.cache/esbuild_plugin_semcore_resolver/src_LastInteractionType.ts_contents

@@ -0,0 +1,47 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import canUseDOM from './utils/canUseDOM';
+var LastInteractionType = /*#__PURE__*/function () {
+  function LastInteractionType() {
+    _classCallCheck(this, LastInteractionType);
+    _defineProperty(this, "lastFocusSource", 'none');
+    this.handleKeyDown = this.handleKeyDown.bind(this);
+    this.handleMouseDown = this.handleMouseDown.bind(this);
+    if (canUseDOM()) {
+      document.addEventListener('mousedown', this.handleMouseDown, {
+        capture: true
+      });
+      document.addEventListener('keydown', this.handleKeyDown, {
+        capture: true
+      });
+    }
+  }
+  return _createClass(LastInteractionType, [{
+    key: "type",
+    get: function get() {
+      return this.lastFocusSource;
+    }
+  }, {
+    key: "isKeyboard",
+    value: function isKeyboard() {
+      return this.lastFocusSource === 'keyboard';
+    }
+  }, {
+    key: "isMouse",
+    value: function isMouse() {
+      return this.lastFocusSource === 'mouse';
+    }
+  }, {
+    key: "handleMouseDown",
+    value: function handleMouseDown() {
+      this.lastFocusSource = 'mouse';
+    }
+  }, {
+    key: "handleKeyDown",
+    value: function handleKeyDown() {
+      this.lastFocusSource = 'keyboard';
+    }
+  }]);
+}();
+export var lastInteraction = new LastInteractionType();

package/.cache/esbuild_plugin_semcore_resolver/src_LastInteractionType.ts_hash_sum

@@ -0,0 +1 @@
+82ce00d70329f80ea8eb538c829f12ed

package/.cache/esbuild_plugin_semcore_resolver/src_LastInteractionType.ts_last_use

@@ -0,0 +1 @@
+1779370328805

package/.cache/esbuild_plugin_semcore_resolver/src_core-types_Component.ts_contents

@@ -0,0 +1,49 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _callSuper from "@babel/runtime/helpers/callSuper";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { PureComponent } from 'react';
+
+/** @deprecated */
+
+var Root = undefined;
+export { Root };
+export var Component = /*#__PURE__*/function (_PureComponent) {
+  function Component() {
+    var _this;
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _classCallCheck(this, Component);
+    _this = _callSuper(this, Component, [].concat(args));
+    _defineProperty(_this, "Root", undefined);
+    _defineProperty(_this, "isControlled", false);
+    return _this;
+  }
+  _inherits(Component, _PureComponent);
+  return _createClass(Component, [{
+    key: "uncontrolledProps",
+    value: function uncontrolledProps() {
+      // @ts-ignore. This is a default value. Should be defined in related classes.
+      return {};
+    }
+  }, {
+    key: "handlers",
+    get: function get() {
+      // @ts-ignore. The body will be generated in factory
+      return {};
+    }
+  }, {
+    key: "asProps",
+    get: function get() {
+      return {};
+    }
+  }]);
+}(PureComponent);
+
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export var Intergalactic;
+export var wrapIntergalacticComponent = function wrapIntergalacticComponent(wrapper) {
+  return wrapper;
+};

package/.cache/esbuild_plugin_semcore_resolver/src_core-types_Component.ts_hash_sum

@@ -0,0 +1 @@
+f21d20f58ee0e7a41b8775a0d00a2170

package/.cache/esbuild_plugin_semcore_resolver/src_core-types_Component.ts_last_use

@@ -0,0 +1 @@
+1779370328805

package/.cache/esbuild_plugin_semcore_resolver/src_core-types_symbols.ts_contents

@@ -0,0 +1,9 @@
+export var CORE_COMPONENT = Symbol('CORE_COMPONENT');
+export var CORE_INSTANCE = Symbol('CORE_INSTANCE');
+export var CORE_AS_PROPS = Symbol('CORE_AS_PROPS');
+export var CORE_INIT = Symbol('CORE_INIT');
+export var CONTEXT_COMPONENT = Symbol('CONTEXT_COMPONENT');
+export var CREATE_COMPONENT = Symbol('CREATE_COMPONENT');
+export var PARENT_COMPONENTS = Symbol('PARENT_COMPONENTS');
+export var CHILDREN_COMPONENT = Symbol('CHILDREN_COMPONENT');
+export var INHERITED_NAME = Symbol('INHERITED_NAME');

package/.cache/esbuild_plugin_semcore_resolver/src_core-types_symbols.ts_hash_sum

@@ -0,0 +1 @@
+08732fdf3ec8c47aefc3daad23bb5671

package/.cache/esbuild_plugin_semcore_resolver/src_core-types_symbols.ts_last_use

@@ -0,0 +1 @@
+1779370328805

package/.cache/esbuild_plugin_semcore_resolver/src_coreFactory.tsx_contents

@@ -0,0 +1,374 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
+import _readOnlyError from "@babel/runtime/helpers/readOnlyError";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/createForOfIteratorHelper";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _superPropGet from "@babel/runtime/helpers/superPropGet";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _callSuper from "@babel/runtime/helpers/callSuper";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _extends from "@babel/runtime/helpers/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+var _excluded = ["forwardRef"],
+  _excluded2 = ["forwardRef", "__WRAPPER_PROPS_BIND__"],
+  _excluded3 = ["ref"];
+import hoistNonReactStatics from 'hoist-non-react-statics';
+import React from 'react';
+import { Component } from './core-types/Component';
+import { CONTEXT_COMPONENT, CORE_AS_PROPS, CORE_COMPONENT, CORE_INIT, CORE_INSTANCE, CREATE_COMPONENT, PARENT_COMPONENTS } from './core-types/symbols';
+import childrenEnhancement from './enhancement/Children';
+import dataNameEnhancement from './enhancement/dataName';
+import enhanceEnhancement from './enhancement/enhance';
+import functionDefaultPropsEnhancement from './enhancement/functionDefaultProps';
+import i18nAppLocaleEnhance from './enhancement/i18n';
+import inheritedNameEnhancement from './enhancement/inheritedName';
+import rootEnhancement from './enhancement/Root';
+import staticChildrenEnhancement, { getterMethodNameByDisplayName, ROOT_COMPONENT, STATIC_COMPONENT } from './enhancement/staticChildren';
+import styleEnhancement from './enhancement/style';
+import uncontrolledPropsEnhancement from './enhancement/uncontrolledProps';
+import _assignProps from './utils/assignProps';
+import { useForkRef } from './utils/ref';
+import useEnhancedEffect from './utils/use/useEnhancedEffect';
+function isEmptyObject(obj) {
+  return Object.getOwnPropertyNames(obj).length === 0 && Object.getOwnPropertySymbols &&
+  // For IE 11
+  Object.getOwnPropertySymbols(obj).length === 0 && Object.getPrototypeOf(obj) === Object.prototype;
+}
+function createGetField(enhancements, Component, isFunction) {
+  return function getField(key) {
+    return enhancements.filter(function (enhancement) {
+      if (!enhancement.condition) {
+        return true;
+      }
+      return enhancement.condition(Component, isFunction);
+    }).reduce(function (acc, item) {
+      if (item[key]) {
+        acc.push(item[key]);
+      }
+      return acc;
+    }, []);
+  };
+}
+function createForwardWrapper(Component, wrapperProps, statics, isFunction) {
+  var RootComponent = Component[ROOT_COMPONENT];
+  var getterMethodName = getterMethodNameByDisplayName(Component === null || Component === void 0 ? void 0 : Component.displayName);
+  var getterMethod = RootComponent !== null && RootComponent !== void 0 && RootComponent.prototype ? RootComponent.prototype[getterMethodName] : undefined;
+  var useGetterIndex = (getterMethod === null || getterMethod === void 0 ? void 0 : getterMethod.length) >= 2;
+  function WrapperForwardRefWithBind(_ref, ref) {
+    var _ref$forwardRef = _ref.forwardRef,
+      forwardRef = _ref$forwardRef === void 0 ? null : _ref$forwardRef,
+      other = _objectWithoutProperties(_ref, _excluded);
+    return /*#__PURE__*/React.createElement(BindingWrapper, _extends({}, other, {
+      forwardRef: useForkRef(ref, forwardRef)
+    }));
+  }
+  function WrapperForwardRef(_ref2, ref) {
+    var _ref2$forwardRef = _ref2.forwardRef,
+      forwardRef = _ref2$forwardRef === void 0 ? null : _ref2$forwardRef,
+      __WRAPPER_PROPS_BIND__ = _ref2.__WRAPPER_PROPS_BIND__,
+      other = _objectWithoutProperties(_ref2, _excluded2);
+    var _reduce = (__WRAPPER_PROPS_BIND__ || wrapperProps).reduce(function (acc, enhancement) {
+        return enhancement(acc, WrapperComponent, isFunction);
+      }, other),
+      _reduce$ref = _reduce.ref,
+      enhancementRef = _reduce$ref === void 0 ? null : _reduce$ref,
+      props = _objectWithoutProperties(_reduce, _excluded3);
+    return /*#__PURE__*/React.createElement(Component, _extends({}, props, {
+      forwardRef: useForkRef(enhancementRef, ref, forwardRef)
+    }));
+  }
+  var BindingWrapper = /*#__PURE__*/function (_React$Component) {
+    function BindingWrapper() {
+      var _this;
+      _classCallCheck(this, BindingWrapper);
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      _this = _callSuper(this, BindingWrapper, [].concat(args));
+      _defineProperty(_this, "index", -1);
+      return _this;
+    }
+    _inherits(BindingWrapper, _React$Component);
+    return _createClass(BindingWrapper, [{
+      key: "render",
+      value: function render() {
+        var _this2 = this;
+        return /*#__PURE__*/React.createElement(WrapperForwardRef, _extends({}, this.props, {
+          __WRAPPER_PROPS_BIND__: wrapperProps.map(function (fn) {
+            return fn.bind(_this2);
+          })
+        }));
+      }
+    }]);
+  }(React.Component);
+  var WrapperComponent = /*#__PURE__*/React.forwardRef(useGetterIndex ? WrapperForwardRefWithBind : WrapperForwardRef);
+  hoistNonReactStatics(WrapperComponent, Component);
+  WrapperComponent.displayName = Component.displayName;
+  // TODO: defaultProps is only empty
+  WrapperComponent.defaultProps = Component.defaultProps;
+  // STATIC
+  statics.forEach(function (enhancement) {
+    return Object.assign(WrapperComponent, enhancement(WrapperComponent, Component, isFunction));
+  });
+  return WrapperComponent;
+}
+function wrapClass(OriginComponent, enhancements, Context) {
+  var getField = createGetField(enhancements, OriginComponent, false);
+  var inits = getField('init');
+  var props = getField('asProps');
+  var renders = getField('render');
+  var statics = getField('static');
+  var wrapperProps = getField('wrapperProps');
+  var contexts = getField('context');
+  var Component = /*#__PURE__*/function (_OriginComponent2) {
+    function Component(props, context) {
+      var _this3;
+      _classCallCheck(this, Component);
+      _this3 = _callSuper(this, Component, [props, context]);
+      // INITS
+      _defineProperty(_this3, CORE_AS_PROPS, null);
+      _defineProperty(_this3, CORE_INSTANCE, WrapperComponent);
+      _defineProperty(_this3, CORE_INIT, false);
+      inits.forEach(function (enhancement) {
+        return enhancement.call(_this3, props, WrapperComponent, false);
+      });
+      _this3[CORE_INIT] = true;
+      return _this3;
+    }
+    _inherits(Component, _OriginComponent2);
+    return _createClass(Component, [{
+      key: "asProps",
+      get: function get() {
+        var _this4 = this;
+        // TODO if not production
+        if (!this[CORE_INIT]) {
+          throw new Error('Can not call asProps in constructor');
+        }
+        if (!this[CORE_AS_PROPS]) {
+          // PROPS
+          this[CORE_AS_PROPS] = props.reduce(function (acc, enhancement) {
+            return enhancement.call(_this4, acc, WrapperComponent, false);
+          }, this.props);
+          if (this[CORE_AS_PROPS] !== null) {
+            var prefixesMap = new Map();
+            Object.entries(this[CORE_AS_PROPS]).forEach(function (_ref3) {
+              var _ref4 = _slicedToArray(_ref3, 2),
+                key = _ref4[0],
+                value = _ref4[1];
+              var _key$split = key.split(':'),
+                _key$split2 = _slicedToArray(_key$split, 2),
+                prefix = _key$split2[0],
+                propertyKey = _key$split2[1];
+              if (prefix !== 'use' && propertyKey) {
+                var _prefixesMap$get;
+                var obj = (_prefixesMap$get = prefixesMap.get(prefix)) !== null && _prefixesMap$get !== void 0 ? _prefixesMap$get : {};
+                obj[propertyKey] = value;
+                prefixesMap.set(prefix, obj);
+              }
+            });
+            var _iterator = _createForOfIteratorHelper(prefixesMap.entries()),
+              _step;
+            try {
+              for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                var _step$value = _slicedToArray(_step.value, 2),
+                  key = _step$value[0],
+                  value = _step$value[1];
+                Object.defineProperty(this[CORE_AS_PROPS], "".concat(key, "Props"), {
+                  value: value
+                });
+              }
+            } catch (err) {
+              _iterator.e(err);
+            } finally {
+              _iterator.f();
+            }
+          }
+        }
+        return this[CORE_AS_PROPS];
+      }
+    }, {
+      key: "setContext",
+      value: function setContext() {
+        var _this5 = this;
+        var contextProps = _superPropGet(Component, "setContext", this, 1) ? _superPropGet(Component, "setContext", this, 3)([]) : {};
+        // CONTEXT
+        return contexts.reduce(function (acc, enhancement) {
+          return enhancement.call(_this5, acc, WrapperComponent, false);
+        }, contextProps);
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var _this6 = this;
+        this[CORE_AS_PROPS] = null;
+        // TODO if not production
+        if (!_superPropGet(Component, "render", this, 1)) {
+          throw new Error('Component `render` method is not defined');
+        }
+        var asProps = this.asProps;
+        var ctx = this.setContext();
+        // RENDER
+        var render = renders.reduce(function (acc, enhancement) {
+          return enhancement.call(_this6, acc, asProps, WrapperComponent, false);
+        }, _superPropGet(Component, "render", this, 3)([]));
+        if (!WrapperComponent[STATIC_COMPONENT] && !isEmptyObject(ctx)) {
+          return /*#__PURE__*/React.createElement(Context.Provider, {
+            value: _objectSpread(_objectSpread({}, asProps), ctx)
+          }, render);
+        } else {
+          return render;
+        }
+      }
+    }]);
+  }(OriginComponent);
+  var WrapperComponent = createForwardWrapper(Component, wrapperProps, statics, false);
+  return WrapperComponent;
+}
+function wrapFunction(OriginComponent, enhancements, Context) {
+  var getField = createGetField(enhancements, OriginComponent, true);
+  var inits = getField('init');
+  var props = getField('asProps');
+  var renders = getField('render');
+  var statics = getField('static');
+  var wrapperProps = getField('wrapperProps');
+  var contexts = getField('context');
+  var Component = /*#__PURE__*/React.memo(function FunctionMemoComponent(other) {
+    var selfRef = React.useRef({});
+    var firstRender = React.useRef(true);
+    useEnhancedEffect(function () {
+      firstRender.current = false;
+    }, []);
+    if (firstRender.current) {
+      // INITS
+      inits.forEach(function (enhancement) {
+        return enhancement.call(selfRef.current, other, WrapperComponent, true);
+      });
+    }
+    // PROPS
+    var asProps = props.reduce(function (acc, enhancement) {
+      return enhancement.call(selfRef.current, acc, WrapperComponent, true);
+    }, other);
+    // CONTEXT
+    var ctx = contexts.reduce(function (acc, enhancement) {
+      return enhancement.call(selfRef.current, acc, WrapperComponent, true);
+    }, {});
+
+    // RENDER
+    var render = renders.reduce(function (acc, enhancement) {
+      return enhancement.call(selfRef.current, acc, asProps, WrapperComponent, true);
+    }, /*#__PURE__*/React.createElement(OriginComponent, asProps));
+    if (!WrapperComponent[STATIC_COMPONENT] && !isEmptyObject(ctx)) {
+      return /*#__PURE__*/React.createElement(Context.Provider, {
+        value: _objectSpread(_objectSpread({}, asProps), ctx)
+      }, render);
+    } else {
+      return render;
+    }
+  });
+  Object.assign(Component, OriginComponent);
+  var WrapperComponent = createForwardWrapper(Component, wrapperProps, statics, true);
+  return WrapperComponent;
+}
+function wrapCore(OriginComponent, enhancements, Context) {
+  var Component = function Component(_ref5) {
+    var Root = _ref5.Root;
+    var defaultProps = OriginComponent.defaultProps || {};
+    return /*#__PURE__*/React.createElement(Root, _extends({}, defaultProps, {
+      render: OriginComponent
+    }));
+  };
+  hoistNonReactStatics(Component, OriginComponent);
+  Component.displayName = OriginComponent.displayName;
+  return wrapFunction(Component, enhancements, Context);
+}
+function createComposeComponent(OriginComponent, Context, enhancements) {
+  if (React.PureComponent.isPrototypeOf(OriginComponent) || React.Component.isPrototypeOf(OriginComponent)) {
+    if (OriginComponent.prototype instanceof Component) {
+      return wrapClass(OriginComponent, enhancements, Context);
+    } else {
+      throw new Error('Must inherit from our component');
+    }
+  } else if (typeof OriginComponent === 'function') {
+    return wrapFunction(OriginComponent, enhancements, Context);
+  } else if (OriginComponent[CORE_COMPONENT]) {
+    return wrapCore(OriginComponent, enhancements, Context);
+  } else {
+    throw new Error('Must be a React component');
+  }
+}
+export function assignProps(p1, p2) {
+  return _assignProps(p2, p1);
+}
+function createComponent(OriginComponent) {
+  var childComponents = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  var _options$context = options.context,
+    context = _options$context === void 0 ? /*#__PURE__*/React.createContext({}) : _options$context,
+    _options$parent = options.parent,
+    parent = _options$parent === void 0 ? [] : _options$parent,
+    _options$enhancements = options.enhancements,
+    enhancements = _options$enhancements === void 0 ? [] : _options$enhancements;
+  var parents = Array.isArray(parent) ? parent : [parent];
+  if (parents.length) {
+    var wholeFamily = parents.reduce(function (acc, parent) {
+      if (parent[PARENT_COMPONENTS]) {
+        acc = [].concat(_toConsumableArray(parent[PARENT_COMPONENTS]), _toConsumableArray(acc));
+      }
+      return acc;
+    }, parents);
+    // @ts-ignore
+    OriginComponent[PARENT_COMPONENTS] = wholeFamily;
+    parents = wholeFamily;
+  }
+  // @ts-ignore
+  if (OriginComponent[CORE_COMPONENT]) {
+    parents.push(OriginComponent);
+  }
+  var Component = createComposeComponent(OriginComponent, context, [].concat(_toConsumableArray(enhancements.map(function (f) {
+    return f(context, parents, createComponent, childComponents);
+  })), [i18nAppLocaleEnhance(), childrenEnhancement(context, parents),
+  // root must be under the children
+  rootEnhancement(), uncontrolledPropsEnhancement(), staticChildrenEnhancement(childComponents, createComponent, {
+    context: context,
+    parent: parent,
+    enhancements: enhancements
+  }),
+  // functionDefaultProps must be under the staticChild
+  functionDefaultPropsEnhancement(),
+  // inheritedName must be under the staticChild
+  inheritedNameEnhancement(),
+  // dataName must be under the staticChild
+  dataNameEnhancement(),
+  // enhanceEnhancement must be under the functionDefaultPropsEnhancement
+  enhanceEnhancement(), styleEnhancement(childComponents, context)]));
+  Component[CONTEXT_COMPONENT] = context;
+  Component._______childrenComponents = childComponents;
+  Component[CREATE_COMPONENT] = function () {
+    var _OriginComponent = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : OriginComponent;
+    var _childComponents = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : childComponents;
+    var _options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : options;
+    return createComponent(_OriginComponent, _childComponents, _options);
+  };
+  Component.newInstance = function () {
+    var _OriginComponent = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : OriginComponent;
+    var _childComponents = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : childComponents;
+    var _options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : options;
+    return createComponent(_OriginComponent, _childComponents, _options);
+  };
+  Component[CORE_COMPONENT] = true;
+  return Component;
+}
+function createBaseComponent(OriginComponent) {
+  var _OriginComponent$disp;
+  var Component = /*#__PURE__*/React.forwardRef(OriginComponent);
+  Component.displayName = (_OriginComponent$disp = OriginComponent.displayName) !== null && _OriginComponent$disp !== void 0 ? _OriginComponent$disp : '';
+  // @ts-ignore
+  Component.defaultProps = {
+    'data-ui-name': OriginComponent.displayName
+  };
+  Component[CORE_COMPONENT] = true;
+  return Component;
+}
+export { createComponent, createBaseComponent };

package/.cache/esbuild_plugin_semcore_resolver/src_coreFactory.tsx_hash_sum

@@ -0,0 +1 @@
+09848346d1a5105ef3794692d491fe50

package/.cache/esbuild_plugin_semcore_resolver/src_coreFactory.tsx_last_use

@@ -0,0 +1 @@
+1779370328805

package/.cache/esbuild_plugin_semcore_resolver/src_enhancement_Children.tsx_contents

@@ -0,0 +1,110 @@
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+var _excluded = ["handlers", "getters"],
+  _excluded2 = ["handlers"];
+import React from 'react';
+import { CONTEXT_COMPONENT, CHILDREN_COMPONENT } from '../core-types/symbols';
+var CHILDREN_SELF = Symbol('CHILDREN_SELF');
+var GETTER_REG = /^get[\w]+Props$/;
+function splitPropsAndGetters(props) {
+  return Object.entries(props).reduce(function (acc, _ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+      key = _ref2[0],
+      value = _ref2[1];
+    if (GETTER_REG.exec(key) === null) {
+      acc.props[key] = value;
+    } else {
+      acc.getters[key] = value;
+    }
+    return acc;
+  }, {
+    props: {},
+    getters: {}
+  });
+}
+function getterToArray(getter) {
+  if (!Array.isArray(getter)) {
+    return typeof getter === 'function' ? [getter] : [];
+  }
+  return getter;
+}
+function mergeObjects() {
+  var a = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var b = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var core = _objectSpread(_objectSpread({}, a), b);
+  return Object.keys(core).reduce(function (acc, key) {
+    a[key] = getterToArray(a[key]);
+    b[key] = getterToArray(b[key]);
+    acc[key] = [].concat(_toConsumableArray(a[key]), _toConsumableArray(b[key]));
+    return acc;
+  }, {});
+}
+function assignGettersChain(getters) {
+  return function () {
+    var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    return getters.reduce(function (acc, getter) {
+      return getter(acc);
+    }, props);
+  };
+}
+function createChildren(Context, contexts) {
+  var _Children = function Children() {
+    var children = _Children.origin;
+    if (typeof children === 'function') {
+      var _reduce = [].concat(_toConsumableArray(contexts), [Context]).reduce(function (acc, ctx) {
+          var _ref3 = React.useContext(ctx),
+            handlers = _ref3.handlers,
+            propsAndGetters = _objectWithoutProperties(_ref3, _excluded2);
+          var _splitPropsAndGetters = splitPropsAndGetters(propsAndGetters),
+            props = _splitPropsAndGetters.props,
+            getters = _splitPropsAndGetters.getters;
+          return Object.assign({}, acc, _objectSpread({
+            handlers: Object.assign({}, acc.handlers, handlers),
+            getters: mergeObjects(acc.getters, getters)
+          }, props));
+        }, _Children.props),
+        _reduce$handlers = _reduce.handlers,
+        handlers = _reduce$handlers === void 0 ? {} : _reduce$handlers,
+        _reduce$getters = _reduce.getters,
+        getters = _reduce$getters === void 0 ? {} : _reduce$getters,
+        props = _objectWithoutProperties(_reduce, _excluded);
+      var mergedGetters = Object.entries(getters).reduce(function (acc, _ref4) {
+        var _ref5 = _slicedToArray(_ref4, 2),
+          key = _ref5[0],
+          value = _ref5[1];
+        acc[key] = assignGettersChain(value);
+        return acc;
+      }, {});
+      return children(_objectSpread(_objectSpread({}, props), mergedGetters), handlers);
+    } else if (children === undefined) {
+      return null;
+    }
+    return children;
+  };
+  _Children.origin = null;
+  _Children.props = {};
+  _Children[CHILDREN_COMPONENT] = true;
+  return _Children;
+}
+function Enhancement(Context, parent) {
+  return {
+    init: function init() {
+      var contexts = (Array.isArray(parent) ? parent : [parent]).map(function (component) {
+        return component[CONTEXT_COMPONENT];
+      }).filter(Boolean);
+      this[CHILDREN_SELF] = createChildren(Context, contexts);
+    },
+    asProps: function asProps(props) {
+      // TODO: learn the reason what it was used for (by lsroman)
+      // this[CHILDREN_SELF].origin = _Children ? _Children.origin : children;
+      this[CHILDREN_SELF].origin = props.children;
+      this[CHILDREN_SELF].props = props;
+      return _objectSpread(_objectSpread({}, props), {}, {
+        Children: this[CHILDREN_SELF]
+      });
+    }
+  };
+}
+export default Enhancement;

package/.cache/esbuild_plugin_semcore_resolver/src_enhancement_Children.tsx_hash_sum

@@ -0,0 +1 @@
+8cfc76dc72aa7ad0e3c89a85f64cd74e

package/.cache/esbuild_plugin_semcore_resolver/src_enhancement_Children.tsx_last_use

@@ -0,0 +1 @@
+1779370328820