@semcore/core 17.0.0-prerelease.43 → 17.0.1-prerelease.0

package/lib/esm/coreFactory.mjs

@@ -1,5 +1,15 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _superPropGet from "@babel/runtime/helpers/esm/superPropGet";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _callSuper from "@babel/runtime/helpers/esm/callSuper";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
 import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
 import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
 import hoistNonReactStatics from "hoist-non-react-statics";
 import React from "react";
 import { Component } from "./core-types/Component.mjs";
@@ -17,18 +27,19 @@ import Enhancement$2 from "./enhancement/uncontrolledProps.mjs";
 import assignProps$1 from "./utils/assignProps.mjs";
 import { useForkRef } from "./utils/ref.mjs";
 import useEnhancedEffect from "./utils/use/useEnhancedEffect.mjs";
+var _excluded = ["forwardRef"], _excluded2 = ["forwardRef", "__WRAPPER_PROPS_BIND__"], _excluded3 = ["ref"];
 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, Component2, isFunction) {
   return function getField(key) {
-    return enhancements.filter((enhancement) => {
+    return enhancements.filter(function(enhancement) {
       if (!enhancement.condition) {
         return true;
       }
       return enhancement.condition(Component2, isFunction);
-    }).reduce((acc, item) => {
+    }).reduce(function(acc, item) {
       if (item[key]) {
         acc.push(item[key]);
       }
@@ -37,160 +48,200 @@ function createGetField(enhancements, Component2, isFunction) {
   };
 }
 function createForwardWrapper(Component2, wrapperProps, statics, isFunction) {
-  const RootComponent = Component2[ROOT_COMPONENT];
-  const getterMethodName = getterMethodNameByDisplayName(Component2?.displayName);
-  const getterMethod = RootComponent?.prototype ? RootComponent.prototype[getterMethodName] : void 0;
-  const useGetterIndex = getterMethod?.length >= 2;
-  function WrapperForwardRefWithBind({
-    forwardRef = null,
-    ...other
-  }, ref) {
+  var RootComponent = Component2[ROOT_COMPONENT];
+  var getterMethodName = getterMethodNameByDisplayName(Component2 === null || Component2 === void 0 ? void 0 : Component2.displayName);
+  var getterMethod = RootComponent !== null && RootComponent !== void 0 && RootComponent.prototype ? RootComponent.prototype[getterMethodName] : void 0;
+  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({
-    forwardRef = null,
-    __WRAPPER_PROPS_BIND__,
-    ...other
-  }, ref) {
-    const {
-      ref: enhancementRef = null,
-      ...props
-    } = (__WRAPPER_PROPS_BIND__ || wrapperProps).reduce((acc, enhancement) => enhancement(acc, WrapperComponent, isFunction), other);
+  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(Component2, _extends({}, props, {
       forwardRef: useForkRef(enhancementRef, ref, forwardRef)
     }));
   }
-  class BindingWrapper extends React.Component {
-    constructor(...args) {
-      super(...args);
-      _defineProperty(this, "index", -1);
-    }
-    render() {
-      return /* @__PURE__ */ React.createElement(WrapperForwardRef, _extends({}, this.props, {
-        __WRAPPER_PROPS_BIND__: wrapperProps.map((fn) => fn.bind(this))
-      }));
+  var BindingWrapper = /* @__PURE__ */ (function(_React$Component) {
+    function BindingWrapper2() {
+      var _this;
+      _classCallCheck(this, BindingWrapper2);
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      _this = _callSuper(this, BindingWrapper2, [].concat(args));
+      _defineProperty(_this, "index", -1);
+      return _this;
     }
-  }
-  const WrapperComponent = /* @__PURE__ */ React.forwardRef(useGetterIndex ? WrapperForwardRefWithBind : WrapperForwardRef);
+    _inherits(BindingWrapper2, _React$Component);
+    return _createClass(BindingWrapper2, [{
+      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, Component2);
   WrapperComponent.displayName = Component2.displayName;
   WrapperComponent.defaultProps = Component2.defaultProps;
-  statics.forEach((enhancement) => Object.assign(WrapperComponent, enhancement(WrapperComponent, Component2, isFunction)));
+  statics.forEach(function(enhancement) {
+    return Object.assign(WrapperComponent, enhancement(WrapperComponent, Component2, isFunction));
+  });
   return WrapperComponent;
 }
 function wrapClass(OriginComponent, enhancements, Context) {
-  const getField = createGetField(enhancements, OriginComponent, false);
-  const inits = getField("init");
-  const props = getField("asProps");
-  const renders = getField("render");
-  const statics = getField("static");
-  const wrapperProps = getField("wrapperProps");
-  const contexts = getField("context");
-  class Component2 extends OriginComponent {
-    constructor(props2, context) {
-      super(props2, context);
-      _defineProperty(this, CORE_AS_PROPS, null);
-      _defineProperty(this, CORE_INSTANCE, WrapperComponent);
-      _defineProperty(this, CORE_INIT, false);
-      inits.forEach((enhancement) => enhancement.call(this, props2, WrapperComponent, false));
-      this[CORE_INIT] = true;
+  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 Component2 = /* @__PURE__ */ (function(_OriginComponent2) {
+    function Component3(props2, context) {
+      var _this3;
+      _classCallCheck(this, Component3);
+      _this3 = _callSuper(this, Component3, [props2, context]);
+      _defineProperty(_this3, CORE_AS_PROPS, null);
+      _defineProperty(_this3, CORE_INSTANCE, WrapperComponent);
+      _defineProperty(_this3, CORE_INIT, false);
+      inits.forEach(function(enhancement) {
+        return enhancement.call(_this3, props2, WrapperComponent, false);
+      });
+      _this3[CORE_INIT] = true;
+      return _this3;
     }
-    get asProps() {
-      if (!this[CORE_INIT]) {
-        throw new Error("Can not call asProps in constructor");
-      }
-      if (!this[CORE_AS_PROPS]) {
-        this[CORE_AS_PROPS] = props.reduce((acc, enhancement) => {
-          return enhancement.call(this, acc, WrapperComponent, false);
-        }, this.props);
-        if (this[CORE_AS_PROPS] !== null) {
-          const prefixesMap = /* @__PURE__ */ new Map();
-          Object.entries(this[CORE_AS_PROPS]).forEach(([key, value]) => {
-            const [prefix, propertyKey] = key.split(":");
-            if (prefix !== "use" && propertyKey) {
-              const obj = prefixesMap.get(prefix) ?? {};
-              obj[propertyKey] = value;
-              prefixesMap.set(prefix, obj);
-            }
-          });
-          for (const [key, value] of prefixesMap.entries()) {
-            Object.defineProperty(this[CORE_AS_PROPS], `${key}Props`, {
-              value
+    _inherits(Component3, _OriginComponent2);
+    return _createClass(Component3, [{
+      key: "asProps",
+      get: function get() {
+        var _this4 = this;
+        if (!this[CORE_INIT]) {
+          throw new Error("Can not call asProps in constructor");
+        }
+        if (!this[CORE_AS_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 = /* @__PURE__ */ new Map();
+            Object.entries(this[CORE_AS_PROPS]).forEach(function(_ref3) {
+              var _ref4 = _slicedToArray(_ref3, 2), key2 = _ref4[0], value2 = _ref4[1];
+              var _key$split = key2.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] = value2;
+                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
+                });
+              }
+            } catch (err) {
+              _iterator.e(err);
+            } finally {
+              _iterator.f();
+            }
           }
         }
+        return this[CORE_AS_PROPS];
       }
-      return this[CORE_AS_PROPS];
-    }
-    setContext() {
-      const contextProps = super.setContext ? super.setContext() : {};
-      return contexts.reduce((acc, enhancement) => enhancement.call(this, acc, WrapperComponent, false), contextProps);
-    }
-    render() {
-      this[CORE_AS_PROPS] = null;
-      if (!super.render) {
-        throw new Error("Component `render` method is not defined");
+    }, {
+      key: "setContext",
+      value: function setContext() {
+        var _this5 = this;
+        var contextProps = _superPropGet(Component3, "setContext", this, 1) ? _superPropGet(Component3, "setContext", this, 3)([]) : {};
+        return contexts.reduce(function(acc, enhancement) {
+          return enhancement.call(_this5, acc, WrapperComponent, false);
+        }, contextProps);
       }
-      const asProps = this.asProps;
-      const ctx = this.setContext();
-      const render = renders.reduce((acc, enhancement) => enhancement.call(this, acc, asProps, WrapperComponent, false), super.render());
-      if (!WrapperComponent[STATIC_COMPONENT] && !isEmptyObject(ctx)) {
-        return /* @__PURE__ */ React.createElement(Context.Provider, {
-          value: {
-            ...asProps,
-            ...ctx
-          }
-        }, render);
-      } else {
-        return render;
+    }, {
+      key: "render",
+      value: function render() {
+        var _this6 = this;
+        this[CORE_AS_PROPS] = null;
+        if (!_superPropGet(Component3, "render", this, 1)) {
+          throw new Error("Component `render` method is not defined");
+        }
+        var asProps = this.asProps;
+        var ctx = this.setContext();
+        var render2 = renders.reduce(function(acc, enhancement) {
+          return enhancement.call(_this6, acc, asProps, WrapperComponent, false);
+        }, _superPropGet(Component3, "render", this, 3)([]));
+        if (!WrapperComponent[STATIC_COMPONENT] && !isEmptyObject(ctx)) {
+          return /* @__PURE__ */ React.createElement(Context.Provider, {
+            value: _objectSpread(_objectSpread({}, asProps), ctx)
+          }, render2);
+        } else {
+          return render2;
+        }
       }
-    }
-  }
-  const WrapperComponent = createForwardWrapper(Component2, wrapperProps, statics, false);
+    }]);
+  })(OriginComponent);
+  var WrapperComponent = createForwardWrapper(Component2, wrapperProps, statics, false);
   return WrapperComponent;
 }
 function wrapFunction(OriginComponent, enhancements, Context) {
-  const getField = createGetField(enhancements, OriginComponent, true);
-  const inits = getField("init");
-  const props = getField("asProps");
-  const renders = getField("render");
-  const statics = getField("static");
-  const wrapperProps = getField("wrapperProps");
-  const contexts = getField("context");
-  const Component2 = /* @__PURE__ */ React.memo(function FunctionMemoComponent(other) {
-    const selfRef = React.useRef({});
-    const firstRender = React.useRef(true);
-    useEnhancedEffect(() => {
+  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 Component2 = /* @__PURE__ */ React.memo(function FunctionMemoComponent(other) {
+    var selfRef = React.useRef({});
+    var firstRender = React.useRef(true);
+    useEnhancedEffect(function() {
       firstRender.current = false;
     }, []);
     if (firstRender.current) {
-      inits.forEach((enhancement) => enhancement.call(selfRef.current, other, WrapperComponent, true));
+      inits.forEach(function(enhancement) {
+        return enhancement.call(selfRef.current, other, WrapperComponent, true);
+      });
     }
-    const asProps = props.reduce((acc, enhancement) => enhancement.call(selfRef.current, acc, WrapperComponent, true), other);
-    const ctx = contexts.reduce((acc, enhancement) => enhancement.call(selfRef.current, acc, WrapperComponent, true), {});
-    const render = renders.reduce((acc, enhancement) => enhancement.call(selfRef.current, acc, asProps, WrapperComponent, true), /* @__PURE__ */ React.createElement(OriginComponent, asProps));
+    var asProps = props.reduce(function(acc, enhancement) {
+      return enhancement.call(selfRef.current, acc, WrapperComponent, true);
+    }, other);
+    var ctx = contexts.reduce(function(acc, enhancement) {
+      return enhancement.call(selfRef.current, acc, WrapperComponent, true);
+    }, {});
+    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: {
-          ...asProps,
-          ...ctx
-        }
+        value: _objectSpread(_objectSpread({}, asProps), ctx)
       }, render);
     } else {
       return render;
     }
   });
   Object.assign(Component2, OriginComponent);
-  const WrapperComponent = createForwardWrapper(Component2, wrapperProps, statics, true);
+  var WrapperComponent = createForwardWrapper(Component2, wrapperProps, statics, true);
   return WrapperComponent;
 }
 function wrapCore(OriginComponent, enhancements, Context) {
-  const Component2 = function({
-    Root
-  }) {
-    const defaultProps = OriginComponent.defaultProps || {};
+  var Component2 = function Component3(_ref5) {
+    var Root = _ref5.Root;
+    var defaultProps = OriginComponent.defaultProps || {};
     return /* @__PURE__ */ React.createElement(Root, _extends({}, defaultProps, {
       render: OriginComponent
     }));
@@ -217,17 +268,15 @@ function createComposeComponent(OriginComponent, Context, enhancements) {
 function assignProps(p1, p2) {
   return assignProps$1(p2, p1);
 }
-function createComponent(OriginComponent, childComponents = {}, options = {}) {
-  const {
-    context = /* @__PURE__ */ React.createContext({}),
-    parent = [],
-    enhancements = []
-  } = options;
-  let parents = Array.isArray(parent) ? parent : [parent];
+function createComponent(OriginComponent) {
+  var childComponents = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+  var options = arguments.length > 2 && arguments[2] !== void 0 ? 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) {
-    const wholeFamily = parents.reduce((acc, parent2) => {
+    var wholeFamily = parents.reduce(function(acc, parent2) {
       if (parent2[PARENT_COMPONENTS]) {
-        acc = [...parent2[PARENT_COMPONENTS], ...acc];
+        acc = [].concat(_toConsumableArray(parent2[PARENT_COMPONENTS]), _toConsumableArray(acc));
       }
       return acc;
     }, parents);
@@ -237,9 +286,9 @@ function createComponent(OriginComponent, childComponents = {}, options = {}) {
   if (OriginComponent[CORE_COMPONENT]) {
     parents.push(OriginComponent);
   }
-  const Component2 = createComposeComponent(OriginComponent, context, [
-    // @ts-ignore
-    ...enhancements.map((f) => f(context, parents, createComponent, childComponents)),
+  var Component2 = createComposeComponent(OriginComponent, context, [].concat(_toConsumableArray(enhancements.map(function(f) {
+    return f(context, parents, createComponent, childComponents);
+  })), [
     i18nAppLocaleEnhance(),
     Enhancement(context, parents),
     // root must be under the children
@@ -259,21 +308,28 @@ function createComponent(OriginComponent, childComponents = {}, options = {}) {
     // enhanceEnhancement must be under the functionDefaultPropsEnhancement
     Enhancement$7(),
     Enhancement$8(childComponents, context)
-  ]);
+  ]));
   Component2[CONTEXT_COMPONENT] = context;
   Component2._______childrenComponents = childComponents;
-  Component2[CREATE_COMPONENT] = function(_OriginComponent = OriginComponent, _childComponents = childComponents, _options = options) {
+  Component2[CREATE_COMPONENT] = function() {
+    var _OriginComponent = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : OriginComponent;
+    var _childComponents = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : childComponents;
+    var _options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : options;
     return createComponent(_OriginComponent, _childComponents, _options);
   };
-  Component2.newInstance = function(_OriginComponent = OriginComponent, _childComponents = childComponents, _options = options) {
+  Component2.newInstance = function() {
+    var _OriginComponent = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : OriginComponent;
+    var _childComponents = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : childComponents;
+    var _options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : options;
     return createComponent(_OriginComponent, _childComponents, _options);
   };
   Component2[CORE_COMPONENT] = true;
   return Component2;
 }
 function createBaseComponent(OriginComponent) {
-  const Component2 = /* @__PURE__ */ React.forwardRef(OriginComponent);
-  Component2.displayName = OriginComponent.displayName ?? "";
+  var _OriginComponent$disp;
+  var Component2 = /* @__PURE__ */ React.forwardRef(OriginComponent);
+  Component2.displayName = (_OriginComponent$disp = OriginComponent.displayName) !== null && _OriginComponent$disp !== void 0 ? _OriginComponent$disp : "";
   Component2.defaultProps = {
     "data-ui-name": OriginComponent.displayName
   };

package/lib/esm/enhancement/Children.mjs

@@ -1,9 +1,15 @@
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import React from "react";
 import { CHILDREN_COMPONENT, CONTEXT_COMPONENT } from "../core-types/symbols.mjs";
-const CHILDREN_SELF = /* @__PURE__ */ Symbol("CHILDREN_SELF");
-const GETTER_REG = /^get[\w]+Props$/;
+var _excluded = ["handlers", "getters"], _excluded2 = ["handlers"];
+var CHILDREN_SELF = /* @__PURE__ */ Symbol("CHILDREN_SELF");
+var GETTER_REG = /^get[\w]+Props$/;
 function splitPropsAndGetters(props) {
-  return Object.entries(props).reduce((acc, [key, value]) => {
+  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 {
@@ -21,79 +27,67 @@ function getterToArray(getter) {
   }
   return getter;
 }
-function mergeObjects(a = {}, b = {}) {
-  const core = {
-    ...a,
-    ...b
-  };
-  return Object.keys(core).reduce((acc, key) => {
+function mergeObjects() {
+  var a = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+  var b = arguments.length > 1 && arguments[1] !== void 0 ? 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] = [...a[key], ...b[key]];
+    acc[key] = [].concat(_toConsumableArray(a[key]), _toConsumableArray(b[key]));
     return acc;
   }, {});
 }
 function assignGettersChain(getters) {
-  return function(props = {}) {
-    return getters.reduce((acc, getter) => {
+  return function() {
+    var props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+    return getters.reduce(function(acc, getter) {
       return getter(acc);
     }, props);
   };
 }
 function createChildren(Context, contexts) {
-  const Children = function() {
-    const children = Children.origin;
+  var _Children = function Children() {
+    var children = _Children.origin;
     if (typeof children === "function") {
-      const {
-        handlers = {},
-        getters = {},
-        ...props
-      } = [...contexts, Context].reduce((acc, ctx) => {
-        const {
-          handlers: handlers2,
-          ...propsAndGetters
-        } = React.useContext(ctx);
-        const {
-          props: props2,
-          getters: getters2
-        } = splitPropsAndGetters(propsAndGetters);
-        return Object.assign({}, acc, {
+      var _reduce = [].concat(_toConsumableArray(contexts), [Context]).reduce(function(acc, ctx) {
+        var _ref3 = React.useContext(ctx), handlers2 = _ref3.handlers, propsAndGetters = _objectWithoutProperties(_ref3, _excluded2);
+        var _splitPropsAndGetters = splitPropsAndGetters(propsAndGetters), props2 = _splitPropsAndGetters.props, getters2 = _splitPropsAndGetters.getters;
+        return Object.assign({}, acc, _objectSpread({
           handlers: Object.assign({}, acc.handlers, handlers2),
-          getters: mergeObjects(acc.getters, getters2),
-          ...props2
-        });
-      }, Children.props);
-      const mergedGetters = Object.entries(getters).reduce((acc, [key, value]) => {
+          getters: mergeObjects(acc.getters, getters2)
+        }, props2));
+      }, _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({
-        ...props,
-        ...mergedGetters
-      }, handlers);
+      return children(_objectSpread(_objectSpread({}, props), mergedGetters), handlers);
     } else if (children === void 0) {
       return null;
     }
     return children;
   };
-  Children.origin = null;
-  Children.props = {};
-  Children[CHILDREN_COMPONENT] = true;
-  return Children;
+  _Children.origin = null;
+  _Children.props = {};
+  _Children[CHILDREN_COMPONENT] = true;
+  return _Children;
 }
 function Enhancement(Context, parent) {
   return {
-    init: function() {
-      const contexts = (Array.isArray(parent) ? parent : [parent]).map((component) => component[CONTEXT_COMPONENT]).filter(Boolean);
+    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(props) {
+    asProps: function asProps(props) {
       this[CHILDREN_SELF].origin = props.children;
       this[CHILDREN_SELF].props = props;
-      return {
-        ...props,
+      return _objectSpread(_objectSpread({}, props), {}, {
         Children: this[CHILDREN_SELF]
-      };
+      });
     }
   };
 }

package/lib/esm/enhancement/Root.mjs

@@ -1,37 +1,28 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
 import React from "react";
 import assignProps from "../utils/assignProps.mjs";
 import { useForkRef } from "../utils/ref.mjs";
+var _excluded = ["render"], _excluded2 = ["Root", "styles", "children", "Children", "forwardRef"];
 function createRootRender() {
-  const Root = /* @__PURE__ */ React.forwardRef(function({
-    render: Tag,
-    ...source
-  }, ref) {
-    const {
-      Root: _Root,
-      styles: _styles,
-      children: _children,
-      Children,
-      forwardRef = null,
-      ...props
-      // @ts-ignore
-    } = Root.props;
-    const clearProps = Object.entries(props).reduce((props2, [name, value]) => {
+  var Root = /* @__PURE__ */ React.forwardRef(function(_ref, ref) {
+    var Tag = _ref.render, source = _objectWithoutProperties(_ref, _excluded);
+    var _Root$props = Root.props, _Root = _Root$props.Root, _styles = _Root$props.styles, _children = _Root$props.children, Children = _Root$props.Children, _Root$props$forwardRe = _Root$props.forwardRef, forwardRef = _Root$props$forwardRe === void 0 ? null : _Root$props$forwardRe, props = _objectWithoutProperties(_Root$props, _excluded2);
+    var clearProps = Object.entries(props).reduce(function(props2, _ref2) {
+      var _ref3 = _slicedToArray(_ref2, 2), name = _ref3[0], value = _ref3[1];
       if (value !== void 0) {
         props2[name] = value;
       }
       return props2;
     }, {});
-    const child = {};
+    var child = {};
     if (typeof Children.origin !== "undefined") {
       child.children = /* @__PURE__ */ React.createElement(Children, null);
     }
-    const other = assignProps({
-      ...clearProps,
+    var other = assignProps(_objectSpread(_objectSpread({}, clearProps), {}, {
       ref: useForkRef(forwardRef, ref)
-    }, {
-      ...child,
-      ...source
-    });
+    }), _objectSpread(_objectSpread({}, child), source));
     if (!Tag) {
       throw new Error("`render` prop of Root is not provided");
     }
@@ -43,21 +34,20 @@ function createRootRender() {
 }
 function Enhancement() {
   return {
-    init: function() {
+    init: function init() {
       this.Root = createRootRender();
     },
-    asProps: function(props, _WrapperComponent, isFunction) {
+    asProps: function asProps(props, _WrapperComponent, isFunction) {
       if (isFunction) {
-        return {
-          ...props,
+        return _objectSpread(_objectSpread({}, props), {}, {
           Root: this.Root
-        };
+        });
       }
       return props;
     },
-    render: function(render, props) {
+    render: function render(_render, props) {
       this.Root.props = props;
-      return render;
+      return _render;
     }
   };
 }

package/lib/esm/enhancement/dataName.mjs

@@ -1,10 +1,10 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 function Enhancement() {
   return {
-    wrapperProps: function(props, WrapperComponent) {
-      return {
-        "data-ui-name": WrapperComponent.displayName,
-        ...props
-      };
+    wrapperProps: function wrapperProps(props, WrapperComponent) {
+      return _objectSpread({
+        "data-ui-name": WrapperComponent.displayName
+      }, props);
     }
   };
 }