@semcore/core 17.0.0-prerelease.20-prerelease.20 → 17.0.0-prerelease.22

package/lib/esm/enhancement/functionDefaultProps.mjs

@@ -1,7 +1,7 @@
 function Enhancement() {
-  var defaultProps = {};
+  let defaultProps = {};
   return {
-    condition: function condition(Component) {
+    condition: function(Component) {
       if (!Component.defaultProps) {
         return false;
       }
@@ -10,13 +10,13 @@ function Enhancement() {
       }
       return Boolean(Object.keys(Component.defaultProps).length);
     },
-    "static": function _static(WrapperComponent) {
+    static: function(WrapperComponent) {
       defaultProps = WrapperComponent.defaultProps;
       return {
         defaultProps: {}
       };
     },
-    wrapperProps: function wrapperProps(props) {
+    wrapperProps: function(props) {
       if (typeof defaultProps === "function") {
         return Object.assign({}, defaultProps(props), props);
       }

package/lib/esm/enhancement/i18n.mjs

@@ -1,17 +1,18 @@
-import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
-import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
 import React from "react";
 import { Context } from "../utils/enhances/WithI18n.mjs";
-var _excluded = ["locale"];
 function i18nAppLocaleEnhance() {
   return {
-    wrapperProps: function wrapperProps(props) {
-      var locale = props.locale, other = _objectWithoutProperties(props, _excluded);
-      var contextLocale = React.useContext(Context);
+    wrapperProps: (props) => {
+      const {
+        locale,
+        ...other
+      } = props;
+      const contextLocale = React.useContext(Context);
       if (!locale && !contextLocale) return props;
-      return _objectSpread(_objectSpread({}, other), {}, {
-        locale: locale !== null && locale !== void 0 ? locale : contextLocale
-      });
+      return {
+        ...other,
+        locale: locale ?? contextLocale
+      };
     }
   };
 }

package/lib/esm/enhancement/inheritedName.mjs

@@ -1,13 +1,13 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 import { INHERITED_NAME } from "../core-types/symbols.mjs";
 function Enhancement() {
   return {
-    condition: function condition(Component) {
+    condition: function(Component) {
       return Boolean(Component.displayName);
     },
-    "static": function _static(WrapperComponent) {
-      return _defineProperty({}, INHERITED_NAME, _toConsumableArray(new Set([].concat(_toConsumableArray(WrapperComponent[INHERITED_NAME] || []), [WrapperComponent.displayName]))));
+    static: function(WrapperComponent) {
+      return {
+        [INHERITED_NAME]: [.../* @__PURE__ */ new Set([...WrapperComponent[INHERITED_NAME] || [], WrapperComponent.displayName])]
+      };
     }
   };
 }

package/lib/esm/enhancement/staticChildren.mjs

@@ -1,58 +1,51 @@
-import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import React from "react";
 import assignProps from "../utils/assignProps.mjs";
 import logger from "../utils/logger.mjs";
 import pick from "../utils/pick.mjs";
 function assign(target, source) {
-  return Object.defineProperties(target, Object.keys(source).reduce(function(descriptors, key) {
+  return Object.defineProperties(target, Object.keys(source).reduce((descriptors, key) => {
     descriptors[key] = Object.getOwnPropertyDescriptor(source, key);
     return descriptors;
   }, {}));
 }
 function getterMethodName(name) {
-  return "get".concat(name, "Props");
+  return `get${name}Props`;
 }
-function getterMethodNameByDisplayName() {
-  var displayName = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "";
-  var displayNames = displayName.split(".");
-  var name = displayNames.slice(-(displayNames.length - 1)).join("");
+function getterMethodNameByDisplayName(displayName = "") {
+  const displayNames = displayName.split(".");
+  const name = displayNames.slice(-(displayNames.length - 1)).join("");
   return getterMethodName(name);
 }
 function flatGetterMethodNames(childComponents, parentName) {
-  return Object.entries(childComponents).reduce(function(acc, _ref) {
-    var _ref2 = _slicedToArray(_ref, 2), name = _ref2[0], value = _ref2[1];
+  return Object.entries(childComponents).reduce((acc, [name, value]) => {
     if (Array.isArray(value)) {
-      acc.push.apply(acc, _toConsumableArray(flatGetterMethodNames(value[1], name)));
+      acc.push(...flatGetterMethodNames(value[1], name));
     }
-    name = parentName ? "".concat(parentName).concat(name) : name;
+    name = parentName ? `${parentName}${name}` : name;
     acc.push(getterMethodName(name));
     return acc;
   }, []);
 }
-var STATIC_COMPONENT = Symbol("STATIC_COMPONENT");
-var ROOT_COMPONENT = Symbol("ROOT_COMPONENT");
-var SELF_GETTER_METHOD = Symbol("SELF_GETTER_METHOD");
+const STATIC_COMPONENT = Symbol("STATIC_COMPONENT");
+const ROOT_COMPONENT = Symbol("ROOT_COMPONENT");
+const SELF_GETTER_METHOD = Symbol("SELF_GETTER_METHOD");
 function Enhancement(childComponents, createComponent, options) {
-  var getterMethodNames = flatGetterMethodNames(childComponents);
+  const getterMethodNames = flatGetterMethodNames(childComponents);
   return {
-    condition: function condition(Component) {
+    condition: function(Component) {
       return Boolean(Component[STATIC_COMPONENT] || Object.keys(childComponents).length);
     },
-    init: function init(props, WrapperComponent) {
-      var _this = this;
-      var getterMethods = pick(this, getterMethodNames);
-      this[SELF_GETTER_METHOD] = function() {
-        var selfGetterMethod = getterMethodNameByDisplayName(WrapperComponent.displayName);
-        logger.warn(true, "Getter `".concat(selfGetterMethod, "` can't be fired as it is a getter of static component"), props["data-ui-name"] || WrapperComponent.displayName);
+    init: function(props, WrapperComponent) {
+      const getterMethods = pick(this, getterMethodNames);
+      this[SELF_GETTER_METHOD] = () => {
+        const selfGetterMethod = getterMethodNameByDisplayName(WrapperComponent.displayName);
+        logger.warn(true, `Getter \`${selfGetterMethod}\` can't be fired as it is a getter of static component`, props["data-ui-name"] || WrapperComponent.displayName);
       };
-      assign(this, getterMethodNames.reduce(function(acc, name) {
-        var getterMethod = getterMethods[name];
+      assign(this, getterMethodNames.reduce((acc, name) => {
+        const getterMethod = getterMethods[name];
         if (!getterMethod) return acc;
-        acc[name] = function() {
-          var childrenProps = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
-          var getterProps = getterMethod.call(_this, childrenProps, acc[name].index);
+        acc[name] = (childrenProps = {}) => {
+          const getterProps = getterMethod.call(this, childrenProps, acc[name].index);
           return assignProps(childrenProps, getterProps);
         };
         acc[name].index = -1;
@@ -60,20 +53,19 @@ function Enhancement(childComponents, createComponent, options) {
         return acc;
       }, {}));
     },
-    "static": function _static(WrapperComponent, Component) {
+    static: function(WrapperComponent, Component) {
       if (Object.keys(childComponents).length && !WrapperComponent.displayName) {
         throw new Error('"displayName" is not defined');
       }
-      return Object.entries(childComponents).reduce(function(acc, _ref3) {
-        var _ref4 = _slicedToArray(_ref3, 2), name = _ref4[0], value = _ref4[1];
-        var childComponents2 = {};
+      return Object.entries(childComponents).reduce((acc, [name, value]) => {
+        let childComponents2 = {};
         if (Array.isArray(value)) {
           childComponents2 = value[1];
           value = value[0];
         }
-        var prevStaticComponent = value[STATIC_COMPONENT];
-        var prevDisplayName = value.displayName;
-        value.displayName = "".concat(WrapperComponent.displayName, ".").concat(name);
+        const prevStaticComponent = value[STATIC_COMPONENT];
+        const prevDisplayName = value.displayName;
+        value.displayName = `${WrapperComponent.displayName}.${name}`;
         value[STATIC_COMPONENT] = true;
         value[ROOT_COMPONENT] = Component[ROOT_COMPONENT] || Component;
         acc[name] = createComponent(value, childComponents2, options);
@@ -82,13 +74,17 @@ function Enhancement(childComponents, createComponent, options) {
         return acc;
       }, {});
     },
-    context: function context(_context) {
-      return _objectSpread(_objectSpread({}, _context), pick(this, getterMethodNames));
+    context: function(context) {
+      return {
+        ...context,
+        // [getterMethod]: this[SELF_GETTER_METHOD],
+        ...pick(this, getterMethodNames)
+      };
     },
-    wrapperProps: function wrapperProps(props, WrapperComponent) {
+    wrapperProps: function(props, WrapperComponent) {
       if (!WrapperComponent[STATIC_COMPONENT]) return props;
-      var context = React.useContext(options.context);
-      var getterMethod = context[getterMethodNameByDisplayName(WrapperComponent.displayName)];
+      const context = React.useContext(options.context);
+      const getterMethod = context[getterMethodNameByDisplayName(WrapperComponent.displayName)];
       if (getterMethod) {
         if (!getterMethod.cache.has(this)) {
           getterMethod.cache.add(this);
@@ -100,14 +96,13 @@ function Enhancement(childComponents, createComponent, options) {
       }
       return props;
     },
-    render: function render(_render) {
-      var _this2 = this;
-      getterMethodNames.forEach(function(name) {
-        if (_this2[name] === void 0) return;
-        _this2[name].index = -1;
-        _this2[name].cache.clear();
+    render: function(render) {
+      getterMethodNames.forEach((name) => {
+        if (this[name] === void 0) return;
+        this[name].index = -1;
+        this[name].cache.clear();
       });
-      return _render;
+      return render;
     }
   };
 }

package/lib/esm/enhancement/style.mjs

@@ -1,19 +1,15 @@
-import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 import React from "react";
 import { STATIC_COMPONENT } from "./staticChildren.mjs";
 import "../styled/index.mjs";
 import { sstyled } from "../styled/sstyled.mjs";
-var _excluded = ["_styles", "styles"], _excluded2 = ["styles"];
-var STYLES_CONTEXT = Symbol("STYLES_CONTEXT");
-var STYLES_SELF = Symbol("STYLES_SELF");
+const STYLES_CONTEXT = Symbol("STYLES_CONTEXT");
+const STYLES_SELF = Symbol("STYLES_SELF");
 function Enhancement(childComponents, Context) {
   return {
-    condition: function condition(Component) {
+    condition: function(Component) {
       return Boolean(Component.style || Component[STATIC_COMPONENT]);
     },
-    init: function init(props, WrapperComponent) {
+    init: function(props, WrapperComponent) {
       if (props.styles) {
         this[STYLES_SELF] = props.styles;
       }
@@ -21,25 +17,35 @@ function Enhancement(childComponents, Context) {
         this[STYLES_SELF] = sstyled.merge(WrapperComponent.style, props._styles);
       }
     },
-    context: function context(_context) {
+    context: function(context) {
       if (!this[STYLES_SELF] || !Object.keys(childComponents).length) {
-        return _context;
+        return context;
       }
-      return _objectSpread(_objectSpread({}, _context), {}, _defineProperty({}, STYLES_CONTEXT, this[STYLES_SELF]));
+      return {
+        ...context,
+        [STYLES_CONTEXT]: this[STYLES_SELF]
+      };
     },
-    asProps: function asProps(_ref) {
-      var _styles = _ref._styles, styles = _ref.styles, props = _objectWithoutProperties(_ref, _excluded);
-      return _objectSpread(_objectSpread({}, props), {}, {
+    asProps: function({
+      _styles,
+      styles,
+      ...props
+    }) {
+      return {
+        ...props,
         styles: this[STYLES_SELF]
-      });
+      };
     },
-    wrapperProps: function wrapperProps(_ref2) {
-      var styles = _ref2.styles, props = _objectWithoutProperties(_ref2, _excluded2);
-      var context = React.useContext(Context);
-      return _objectSpread(_objectSpread({}, props), {}, {
+    wrapperProps: function({
+      styles,
+      ...props
+    }) {
+      const context = React.useContext(Context);
+      return {
+        ...props,
         _styles: styles,
         styles: context[STYLES_CONTEXT]
-      });
+      };
     }
   };
 }

package/lib/esm/enhancement/uncontrolledProps.mjs

@@ -1,26 +1,18 @@
-import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import _arrayLikeToArray from "@babel/runtime/helpers/esm/arrayLikeToArray";
-import _toArray from "@babel/runtime/helpers/esm/toArray";
-import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
-import _toPropertyKey from "@babel/runtime/helpers/esm/toPropertyKey";
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
 import { callAllEventHandlers } from "../utils/assignProps.mjs";
 import capitalizeFirstLetter from "../utils/capitalizeFirstLetter.mjs";
 function assign(target, source) {
-  return Object.defineProperties(target, Object.keys(source).reduce(function(descriptors, key) {
+  return Object.defineProperties(target, Object.keys(source).reduce((descriptors, key) => {
     descriptors[key] = Object.getOwnPropertyDescriptor(source, key);
     return descriptors;
   }, {}));
 }
 function defaultProp(prop) {
-  return "default".concat(capitalizeFirstLetter(prop));
+  return `default${capitalizeFirstLetter(prop)}`;
 }
 function handlerProp(prop) {
   if (prop === "value") prop = "";
   if (prop === "checked") prop = "";
-  return "on".concat(capitalizeFirstLetter(prop), "Change");
+  return `on${capitalizeFirstLetter(prop)}Change`;
 }
 function isControlled(propValue) {
   return propValue !== void 0;
@@ -29,48 +21,46 @@ function uncontrolledProp(self, propName, propValue, propDefaultValue, propHandl
   function getValue() {
     return isControlled(propValue) ? propValue : propName in self.state ? self.state[propName] : propDefaultValue;
   }
-  return [getValue(), function(value) {
-    var oldValue = getValue();
+  return [getValue(), (value, ...args) => {
+    const oldValue = getValue();
     if (oldValue === value) return false;
-    if (!isControlled(propValue)) self.setState(_defineProperty({}, propName, value));
-    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-      args[_key - 1] = arguments[_key];
-    }
-    return callAllEventHandlers.apply(void 0, [propHandler].concat(_toConsumableArray(chainHandler))).apply(void 0, [value].concat(args));
+    if (!isControlled(propValue)) self.setState({
+      [propName]: value
+    });
+    return callAllEventHandlers(propHandler, ...chainHandler)(value, ...args);
   }];
 }
 function uncontrolledUniversal(props, config, uncontrolledProp2) {
-  var handlerProps = {};
-  var uncontrolledProps = Object.keys(config).reduce(function(result, propName) {
-    var handlerName = handlerProp(propName);
-    var defaultPropName = defaultProp(propName);
-    var propDefaultValue = result[defaultPropName], propValue = result[propName], propHandler = result[handlerName], other = _objectWithoutProperties(result, [defaultPropName, propName, handlerName].map(_toPropertyKey));
+  const handlerProps = {};
+  const uncontrolledProps = Object.keys(config).reduce((result, propName) => {
+    const handlerName = handlerProp(propName);
+    const defaultPropName = defaultProp(propName);
+    const {
+      [defaultPropName]: propDefaultValue,
+      [propName]: propValue,
+      [handlerName]: propHandler,
+      ...other
+    } = result;
     if (propDefaultValue === void 0) {
       console.warn(defaultPropName, 'must be installed in "defaultProps"');
     }
-    var setter = config[propName];
-    var chainHandler = [];
-    if (Array.isArray(setter)) {
-      var _setter = setter;
-      var _setter2 = _toArray(_setter);
-      setter = _setter2[0];
-      chainHandler = _arrayLikeToArray(_setter2).slice(1);
-    }
-    setter = setter || function(v) {
-      return v;
-    };
-    var _uncontrolledProp = uncontrolledProp2(propName, propValue, propDefaultValue, propHandler, chainHandler), _uncontrolledProp2 = _slicedToArray(_uncontrolledProp, 2), value = _uncontrolledProp2[0], handler = _uncontrolledProp2[1];
+    let setter = config[propName];
+    let chainHandler = [];
+    if (Array.isArray(setter)) [setter, ...chainHandler] = setter;
+    setter = setter || ((v) => v);
+    const [value, handler] = uncontrolledProp2(propName, propValue, propDefaultValue, propHandler, chainHandler);
     handlerProps[propName] = handler;
-    return _objectSpread(_objectSpread({}, other), {}, _defineProperty(_defineProperty({}, propName, value), handlerName, function(eventOrValue) {
-      for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
-        args[_key2 - 1] = arguments[_key2];
-      }
-      var result2 = [setter.apply(void 0, [eventOrValue].concat(args))].concat(args);
-      if (eventOrValue !== null && eventOrValue !== void 0 && eventOrValue.target) {
-        result2.push(eventOrValue);
+    return {
+      ...other,
+      [propName]: value,
+      [handlerName]: (eventOrValue, ...args) => {
+        const result2 = [setter(eventOrValue, ...args), ...args];
+        if (eventOrValue == null ? void 0 : eventOrValue.target) {
+          result2.push(eventOrValue);
+        }
+        return handler(...result2);
       }
-      return handler.apply(void 0, _toConsumableArray(result2));
-    }));
+    };
   }, props);
   return [uncontrolledProps, handlerProps];
 }
@@ -79,25 +69,26 @@ function uncontrolled(self, props, config) {
 }
 function Enhancement() {
   return {
-    condition: function condition(Component) {
+    condition: function(Component) {
       return Boolean(Component.prototype.uncontrolledProps);
     },
-    init: function init() {
+    init: function() {
       this.state = this.state || {};
       assign(this, {
         get handlers() {
-          var _uncontrolled = uncontrolled(this, this.props, this.uncontrolledProps()), _uncontrolled2 = _slicedToArray(_uncontrolled, 2), uncontrolledHandlers = _uncontrolled2[1];
+          const [, uncontrolledHandlers] = uncontrolled(this, this.props, this.uncontrolledProps());
           return uncontrolledHandlers;
         }
       });
     },
-    context: function context(_context) {
-      return _objectSpread(_objectSpread({}, _context), {}, {
+    context: function(context) {
+      return {
+        ...context,
         handlers: this.handlers
-      });
+      };
     },
-    asProps: function asProps(props) {
-      var _uncontrolled3 = uncontrolled(this, props, this.uncontrolledProps()), _uncontrolled4 = _slicedToArray(_uncontrolled3, 1), uncontrolledProps = _uncontrolled4[0];
+    asProps: function(props) {
+      const [uncontrolledProps] = uncontrolled(this, props, this.uncontrolledProps());
       return uncontrolledProps;
     }
   };

package/lib/esm/register.mjs

@@ -1,28 +1,20 @@
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime/helpers/esm/createClass";
 import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-var Register = /* @__PURE__ */ (function() {
-  function Register2() {
-    _classCallCheck(this, Register2);
+class Register {
+  constructor() {
     _defineProperty(this, "data", {});
   }
-  return _createClass(Register2, [{
-    key: "get",
-    value: function get(name, defaultValue) {
-      if (name in this.data) {
-        return this.data[name];
-      } else {
-        return this.set(name, defaultValue);
-      }
-    }
-  }, {
-    key: "set",
-    value: function set(name, value) {
-      this.data[name] = value;
+  get(name, defaultValue) {
+    if (name in this.data) {
       return this.data[name];
+    } else {
+      return this.set(name, defaultValue);
     }
-  }]);
-})();
+  }
+  set(name, value) {
+    this.data[name] = value;
+    return this.data[name];
+  }
+}
 const register = new Register();
 export {
   Register,