@semcore/core 17.0.0 → 17.0.1-prerelease.0

package/lib/esm/enhancement/enhance.mjs

@@ -1,10 +1,13 @@
 function Enhancement() {
   return {
-    condition: function(Component) {
-      return Boolean(Component.enhance?.length);
+    condition: function condition(Component) {
+      var _Component$enhance;
+      return Boolean((_Component$enhance = Component.enhance) === null || _Component$enhance === void 0 ? void 0 : _Component$enhance.length);
     },
-    wrapperProps: function(props, WrapperComponent) {
-      return WrapperComponent.enhance.reduce((acc, enhance) => enhance(acc), props);
+    wrapperProps: function wrapperProps(props, WrapperComponent) {
+      return WrapperComponent.enhance.reduce(function(acc, enhance) {
+        return enhance(acc);
+      }, props);
     }
   };
 }

package/lib/esm/enhancement/functionDefaultProps.mjs

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

package/lib/esm/enhancement/i18n.mjs

@@ -1,18 +1,17 @@
+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: (props) => {
-      const {
-        locale,
-        ...other
-      } = props;
-      const contextLocale = React.useContext(Context);
+    wrapperProps: function wrapperProps(props) {
+      var locale = props.locale, other = _objectWithoutProperties(props, _excluded);
+      var contextLocale = React.useContext(Context);
       if (!locale && !contextLocale) return props;
-      return {
-        ...other,
-        locale: locale ?? contextLocale
-      };
+      return _objectSpread(_objectSpread({}, other), {}, {
+        locale: locale !== null && locale !== void 0 ? 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(Component) {
+    condition: function condition(Component) {
       return Boolean(Component.displayName);
     },
-    static: function(WrapperComponent) {
-      return {
-        [INHERITED_NAME]: [.../* @__PURE__ */ new Set([...WrapperComponent[INHERITED_NAME] || [], WrapperComponent.displayName])]
-      };
+    "static": function _static(WrapperComponent) {
+      return _defineProperty({}, INHERITED_NAME, _toConsumableArray(new Set([].concat(_toConsumableArray(WrapperComponent[INHERITED_NAME] || []), [WrapperComponent.displayName]))));
     }
   };
 }

package/lib/esm/enhancement/staticChildren.mjs

@@ -1,51 +1,58 @@
+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((descriptors, key) => {
+  return Object.defineProperties(target, Object.keys(source).reduce(function(descriptors, key) {
     descriptors[key] = Object.getOwnPropertyDescriptor(source, key);
     return descriptors;
   }, {}));
 }
 function getterMethodName(name) {
-  return `get${name}Props`;
+  return "get".concat(name, "Props");
 }
-function getterMethodNameByDisplayName(displayName = "") {
-  const displayNames = displayName.split(".");
-  const name = displayNames.slice(-(displayNames.length - 1)).join("");
+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("");
   return getterMethodName(name);
 }
 function flatGetterMethodNames(childComponents, parentName) {
-  return Object.entries(childComponents).reduce((acc, [name, value]) => {
+  return Object.entries(childComponents).reduce(function(acc, _ref) {
+    var _ref2 = _slicedToArray(_ref, 2), name = _ref2[0], value = _ref2[1];
     if (Array.isArray(value)) {
-      acc.push(...flatGetterMethodNames(value[1], name));
+      acc.push.apply(acc, _toConsumableArray(flatGetterMethodNames(value[1], name)));
     }
-    name = parentName ? `${parentName}${name}` : name;
+    name = parentName ? "".concat(parentName).concat(name) : name;
     acc.push(getterMethodName(name));
     return acc;
   }, []);
 }
-const STATIC_COMPONENT = /* @__PURE__ */ Symbol("STATIC_COMPONENT");
-const ROOT_COMPONENT = /* @__PURE__ */ Symbol("ROOT_COMPONENT");
-const SELF_GETTER_METHOD = /* @__PURE__ */ Symbol("SELF_GETTER_METHOD");
+var STATIC_COMPONENT = /* @__PURE__ */ Symbol("STATIC_COMPONENT");
+var ROOT_COMPONENT = /* @__PURE__ */ Symbol("ROOT_COMPONENT");
+var SELF_GETTER_METHOD = /* @__PURE__ */ Symbol("SELF_GETTER_METHOD");
 function Enhancement(childComponents, createComponent, options) {
-  const getterMethodNames = flatGetterMethodNames(childComponents);
+  var getterMethodNames = flatGetterMethodNames(childComponents);
   return {
-    condition: function(Component) {
+    condition: function condition(Component) {
       return Boolean(Component[STATIC_COMPONENT] || Object.keys(childComponents).length);
     },
-    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);
+    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);
       };
-      assign(this, getterMethodNames.reduce((acc, name) => {
-        const getterMethod = getterMethods[name];
+      assign(this, getterMethodNames.reduce(function(acc, name) {
+        var getterMethod = getterMethods[name];
         if (!getterMethod) return acc;
-        acc[name] = (childrenProps = {}) => {
-          const getterProps = getterMethod.call(this, childrenProps, acc[name].index);
+        acc[name] = function() {
+          var childrenProps = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+          var getterProps = getterMethod.call(_this, childrenProps, acc[name].index);
           return assignProps(childrenProps, getterProps);
         };
         acc[name].index = -1;
@@ -53,19 +60,20 @@ function Enhancement(childComponents, createComponent, options) {
         return acc;
       }, {}));
     },
-    static: function(WrapperComponent, Component) {
+    "static": function _static(WrapperComponent, Component) {
       if (Object.keys(childComponents).length && !WrapperComponent.displayName) {
         throw new Error('"displayName" is not defined');
       }
-      return Object.entries(childComponents).reduce((acc, [name, value]) => {
-        let childComponents2 = {};
+      return Object.entries(childComponents).reduce(function(acc, _ref3) {
+        var _ref4 = _slicedToArray(_ref3, 2), name = _ref4[0], value = _ref4[1];
+        var childComponents2 = {};
         if (Array.isArray(value)) {
           childComponents2 = value[1];
           value = value[0];
         }
-        const prevStaticComponent = value[STATIC_COMPONENT];
-        const prevDisplayName = value.displayName;
-        value.displayName = `${WrapperComponent.displayName}.${name}`;
+        var prevStaticComponent = value[STATIC_COMPONENT];
+        var prevDisplayName = value.displayName;
+        value.displayName = "".concat(WrapperComponent.displayName, ".").concat(name);
         value[STATIC_COMPONENT] = true;
         value[ROOT_COMPONENT] = Component[ROOT_COMPONENT] || Component;
         acc[name] = createComponent(value, childComponents2, options);
@@ -74,17 +82,13 @@ function Enhancement(childComponents, createComponent, options) {
         return acc;
       }, {});
     },
-    context: function(context) {
-      return {
-        ...context,
-        // [getterMethod]: this[SELF_GETTER_METHOD],
-        ...pick(this, getterMethodNames)
-      };
+    context: function context(_context) {
+      return _objectSpread(_objectSpread({}, _context), pick(this, getterMethodNames));
     },
-    wrapperProps: function(props, WrapperComponent) {
+    wrapperProps: function wrapperProps(props, WrapperComponent) {
       if (!WrapperComponent[STATIC_COMPONENT]) return props;
-      const context = React.useContext(options.context);
-      const getterMethod = context[getterMethodNameByDisplayName(WrapperComponent.displayName)];
+      var context = React.useContext(options.context);
+      var getterMethod = context[getterMethodNameByDisplayName(WrapperComponent.displayName)];
       if (getterMethod) {
         if (!getterMethod.cache.has(this)) {
           getterMethod.cache.add(this);
@@ -96,13 +100,14 @@ function Enhancement(childComponents, createComponent, options) {
       }
       return props;
     },
-    render: function(render) {
-      getterMethodNames.forEach((name) => {
-        if (this[name] === void 0) return;
-        this[name].index = -1;
-        this[name].cache.clear();
+    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();
       });
-      return render;
+      return _render;
     }
   };
 }

package/lib/esm/enhancement/style.mjs

@@ -1,15 +1,19 @@
+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";
-const STYLES_CONTEXT = /* @__PURE__ */ Symbol("STYLES_CONTEXT");
-const STYLES_SELF = /* @__PURE__ */ Symbol("STYLES_SELF");
+var _excluded = ["_styles", "styles"], _excluded2 = ["styles"];
+var STYLES_CONTEXT = /* @__PURE__ */ Symbol("STYLES_CONTEXT");
+var STYLES_SELF = /* @__PURE__ */ Symbol("STYLES_SELF");
 function Enhancement(childComponents, Context) {
   return {
-    condition: function(Component) {
+    condition: function condition(Component) {
       return Boolean(Component.style || Component[STATIC_COMPONENT]);
     },
-    init: function(props, WrapperComponent) {
+    init: function init(props, WrapperComponent) {
       if (props.styles) {
         this[STYLES_SELF] = props.styles;
       }
@@ -17,35 +21,25 @@ function Enhancement(childComponents, Context) {
         this[STYLES_SELF] = sstyled.merge(WrapperComponent.style, props._styles);
       }
     },
-    context: function(context) {
+    context: function context(_context) {
       if (!this[STYLES_SELF] || !Object.keys(childComponents).length) {
-        return context;
+        return _context;
       }
-      return {
-        ...context,
-        [STYLES_CONTEXT]: this[STYLES_SELF]
-      };
+      return _objectSpread(_objectSpread({}, _context), {}, _defineProperty({}, STYLES_CONTEXT, this[STYLES_SELF]));
     },
-    asProps: function({
-      _styles,
-      styles,
-      ...props
-    }) {
-      return {
-        ...props,
+    asProps: function asProps(_ref) {
+      var _styles = _ref._styles, styles = _ref.styles, props = _objectWithoutProperties(_ref, _excluded);
+      return _objectSpread(_objectSpread({}, props), {}, {
         styles: this[STYLES_SELF]
-      };
+      });
     },
-    wrapperProps: function({
-      styles,
-      ...props
-    }) {
-      const context = React.useContext(Context);
-      return {
-        ...props,
+    wrapperProps: function wrapperProps(_ref2) {
+      var styles = _ref2.styles, props = _objectWithoutProperties(_ref2, _excluded2);
+      var context = React.useContext(Context);
+      return _objectSpread(_objectSpread({}, props), {}, {
         _styles: styles,
         styles: context[STYLES_CONTEXT]
-      };
+      });
     }
   };
 }

package/lib/esm/enhancement/uncontrolledProps.mjs

@@ -1,18 +1,26 @@
+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((descriptors, key) => {
+  return Object.defineProperties(target, Object.keys(source).reduce(function(descriptors, key) {
     descriptors[key] = Object.getOwnPropertyDescriptor(source, key);
     return descriptors;
   }, {}));
 }
 function defaultProp(prop) {
-  return `default${capitalizeFirstLetter(prop)}`;
+  return "default".concat(capitalizeFirstLetter(prop));
 }
 function handlerProp(prop) {
   if (prop === "value") prop = "";
   if (prop === "checked") prop = "";
-  return `on${capitalizeFirstLetter(prop)}Change`;
+  return "on".concat(capitalizeFirstLetter(prop), "Change");
 }
 function isControlled(propValue) {
   return propValue !== void 0;
@@ -21,46 +29,48 @@ function uncontrolledProp(self, propName, propValue, propDefaultValue, propHandl
   function getValue() {
     return isControlled(propValue) ? propValue : propName in self.state ? self.state[propName] : propDefaultValue;
   }
-  return [getValue(), (value, ...args) => {
-    const oldValue = getValue();
+  return [getValue(), function(value) {
+    var oldValue = getValue();
     if (oldValue === value) return false;
-    if (!isControlled(propValue)) self.setState({
-      [propName]: value
-    });
-    return callAllEventHandlers(propHandler, ...chainHandler)(value, ...args);
+    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));
   }];
 }
 function uncontrolledUniversal(props, config, uncontrolledProp2) {
-  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;
+  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));
     if (propDefaultValue === void 0) {
       console.warn(defaultPropName, 'must be installed in "defaultProps"');
     }
-    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);
+    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];
     handlerProps[propName] = handler;
-    return {
-      ...other,
-      [propName]: value,
-      [handlerName]: (eventOrValue, ...args) => {
-        const result2 = [setter(eventOrValue, ...args), ...args];
-        if (eventOrValue?.target) {
-          result2.push(eventOrValue);
-        }
-        return handler(...result2);
+    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 handler.apply(void 0, _toConsumableArray(result2));
+    }));
   }, props);
   return [uncontrolledProps, handlerProps];
 }
@@ -69,26 +79,25 @@ function uncontrolled(self, props, config) {
 }
 function Enhancement() {
   return {
-    condition: function(Component) {
+    condition: function condition(Component) {
       return Boolean(Component.prototype.uncontrolledProps);
     },
-    init: function() {
+    init: function init() {
       this.state = this.state || {};
       assign(this, {
         get handlers() {
-          const [, uncontrolledHandlers] = uncontrolled(this, this.props, this.uncontrolledProps());
+          var _uncontrolled = uncontrolled(this, this.props, this.uncontrolledProps()), _uncontrolled2 = _slicedToArray(_uncontrolled, 2), uncontrolledHandlers = _uncontrolled2[1];
           return uncontrolledHandlers;
         }
       });
     },
-    context: function(context) {
-      return {
-        ...context,
+    context: function context(_context) {
+      return _objectSpread(_objectSpread({}, _context), {}, {
         handlers: this.handlers
-      };
+      });
     },
-    asProps: function(props) {
-      const [uncontrolledProps] = uncontrolled(this, props, this.uncontrolledProps());
+    asProps: function asProps(props) {
+      var _uncontrolled3 = uncontrolled(this, props, this.uncontrolledProps()), _uncontrolled4 = _slicedToArray(_uncontrolled3, 1), uncontrolledProps = _uncontrolled4[0];
       return uncontrolledProps;
     }
   };

package/lib/esm/register.mjs

@@ -1,20 +1,28 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
 import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-class Register {
-  constructor() {
+var Register = /* @__PURE__ */ (function() {
+  function Register2() {
+    _classCallCheck(this, Register2);
     _defineProperty(this, "data", {});
   }
-  get(name, defaultValue) {
-    if (name in 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;
       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,