nsc-react-component 2.0.14 → 2.0.17

package/lib/base/input/index.js

@@ -0,0 +1,242 @@
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+import "antd/es/input/style/css";
+import _Input from "antd/es/input";
+var _excluded = ["type", "onChange", "defaultStyle", "maxLength"];
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+/*
+ * @Descripttion: input组件，直接返回value,加密后的value以及校验的值
+ * @version:
+ * @Author: rxzhu
+ * @Date: 2021-03-24 17:15:47
+ * @LastEditors: rxzhu
+ * @LastEditTime: 2021-04-22 14:20:09
+ */
+import React, { PureComponent } from "react";
+import InputEmail from "./Email";
+import Password from "./Password";
+import TextArea from "./TextArea";
+import Search from "./Search";
+import InputNumber from "./Number";
+import omit from "omit.js";
+import cls from "classnames";
+import styles from "./index.less";
+import config from "../../config";
+
+var NscInput = /*#__PURE__*/function (_PureComponent) {
+  _inherits(NscInput, _PureComponent);
+
+  var _super = _createSuper(NscInput);
+
+  function NscInput(props) {
+    var _this;
+
+    _classCallCheck(this, NscInput);
+
+    _this = _super.call(this, props);
+
+    _defineProperty(_assertThisInitialized(_this), "ref", /*#__PURE__*/React.createRef());
+
+    _defineProperty(_assertThisInitialized(_this), "state", {
+      value: ""
+    });
+
+    return _this;
+  }
+
+  _createClass(NscInput, [{
+    key: "onChange",
+    value: function onChange(e) {
+      var _this$props = this.props,
+          onChange = _this$props.onChange,
+          _this$props$allowChar = _this$props.allowChars,
+          allowChars = _this$props$allowChar === void 0 ? false : _this$props$allowChar;
+      var reg = /^[0-9a-zA-Z\u4E00-\u9FA5\uF900-\uFA2D]*$/;
+      var reg2 = /[a-zA-Z]'[a-zA-Z]/g;
+      var reg3 = /[a-zA-Z]\s[a-zA-Z]/g;
+
+      if (onChange) {
+        if (allowChars) {
+          this.setState({
+            value: e.target.value
+          });
+          onChange(e.target.value, e);
+        } else {
+          var _value = e.target.value;
+
+          if (reg.test(_value) || reg2.test(_value) || reg3.test(_value)) {
+            this.setState({
+              value: e.target.value
+            });
+            onChange(e.target.value, e);
+          }
+        }
+      } else {
+        if (allowChars) {
+          this.setState({
+            value: e.target.value
+          });
+        } else {
+          var _value2 = e.target.value;
+
+          if (reg.test(_value2) || reg2.test(_value2) || reg3.test(_value2)) {
+            this.setState({
+              value: e.target.value
+            });
+          }
+        }
+      }
+    }
+  }, {
+    key: "getValue",
+    value: function getValue() {
+      return this.state.value;
+    }
+  }, {
+    key: "setValue",
+    value: function setValue(value) {
+      this.setState({
+        value: value
+      });
+    }
+  }, {
+    key: "focus",
+    value: function focus() {
+      var _this$ref$current;
+
+      (_this$ref$current = this.ref.current) === null || _this$ref$current === void 0 ? void 0 : _this$ref$current.focus();
+    }
+  }, {
+    key: "blur",
+    value: function blur() {
+      var _this$ref$current2;
+
+      (_this$ref$current2 = this.ref.current) === null || _this$ref$current2 === void 0 ? void 0 : _this$ref$current2.blur();
+    }
+  }, {
+    key: "returnChildren",
+    value: function returnChildren() {
+      var _this$props2 = this.props,
+          type = _this$props2.type,
+          onChange = _this$props2.onChange,
+          defaultStyle = _this$props2.defaultStyle,
+          maxLength = _this$props2.maxLength,
+          params = _objectWithoutProperties(_this$props2, _excluded);
+
+      if (type == "number") {
+        var numberProps = omit(this.props, ["type", "defaultStyle"]);
+        return /*#__PURE__*/React.createElement(InputNumber, _extends({}, numberProps, {
+          ref: this.ref
+        }));
+      } else if (type == "email") {
+        var emailProps = omit(this.props, ["type", "defaultStyle"]);
+        return /*#__PURE__*/React.createElement(InputEmail, _extends({}, emailProps, {
+          ref: this.ref
+        }));
+      } else if (type == "textarea") {
+        var textProps = omit(this.props, ["type", "defaultStyle"]);
+        return /*#__PURE__*/React.createElement(TextArea, _extends({}, textProps, {
+          ref: this.ref
+        }));
+      } else if (type == "password") {
+        var passwordProps = omit(this.props, ["type", "maxLength", "defaultStyle", "allowChars"]);
+
+        if (!(maxLength === false)) {
+          passwordProps = _objectSpread({
+            maxLength: maxLength ? maxLength : 50
+          }, passwordProps);
+        }
+
+        return /*#__PURE__*/React.createElement(Password, _extends({}, passwordProps, {
+          ref: this.ref
+        }));
+      } else {
+        var inputProps = omit(this.props, ["onChange", "defaultStyle", "allowChars", "maxLength"]);
+
+        if (!(maxLength === false)) {
+          inputProps = _objectSpread({
+            maxLength: maxLength ? maxLength : 50
+          }, inputProps);
+        }
+
+        var _config = config(),
+            antdStyle = _config.antdStyle;
+
+        if ((defaultStyle || antdStyle) && defaultStyle === true) {
+          return /*#__PURE__*/React.createElement("div", {
+            className: cls(styles["nsc_input"], this.props.className)
+          }, /*#__PURE__*/React.createElement(_Input, _extends({
+            placeholder: "\u8BF7\u8F93\u5165",
+            onChange: this.onChange.bind(this),
+            allowClear: true,
+            value: this.state.value
+          }, inputProps, {
+            ref: this.ref
+          })));
+        } else {
+          return /*#__PURE__*/React.createElement(_Input, _extends({
+            placeholder: "\u8BF7\u8F93\u5165",
+            onChange: this.onChange.bind(this),
+            allowClear: true,
+            value: this.state.value,
+            ref: this.ref
+          }, inputProps));
+        }
+      }
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/React.createElement(React.Fragment, null, this.returnChildren());
+    }
+  }]);
+
+  return NscInput;
+}(PureComponent);
+
+_defineProperty(NscInput, "Number", InputNumber);
+
+_defineProperty(NscInput, "Email", InputEmail);
+
+_defineProperty(NscInput, "Password", Password);
+
+_defineProperty(NscInput, "TextArea", TextArea);
+
+_defineProperty(NscInput, "Group", _Input.Group);
+
+_defineProperty(NscInput, "Search", Search);
+
+export { NscInput as default };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/components/base/input/index.tsx"],"names":["React","PureComponent","InputEmail","Password","TextArea","Search","InputNumber","omit","cls","styles","config","NscInput","props","createRef","value","e","onChange","allowChars","reg","reg2","reg3","setState","target","test","state","ref","current","focus","blur","type","defaultStyle","maxLength","params","numberProps","emailProps","textProps","passwordProps","inputProps","antdStyle","className","bind","returnChildren","Group"],"mappings":"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","sourcesContent":["/*\r\n * @Descripttion: input组件，直接返回value,加密后的value以及校验的值\r\n * @version:\r\n * @Author: rxzhu\r\n * @Date: 2021-03-24 17:15:47\r\n * @LastEditors: rxzhu\r\n * @LastEditTime: 2021-04-22 14:20:09\r\n */\r\nimport React, { PureComponent } from \"react\";\r\n\r\nimport { Input, InputProps } from \"antd\";\r\nimport InputEmail from \"./Email\";\r\nimport Password from \"./Password\";\r\nimport TextArea from \"./TextArea\";\r\nimport Search from \"./Search\";\r\nimport InputNumber from \"./Number\";\r\nimport omit from \"omit.js\";\r\nimport cls from \"classnames\";\r\n\r\nimport styles from \"./index.less\";\r\nimport { FastForwardFilled } from \"@ant-design/icons\";\r\nimport config from \"../../config\";\r\ninterface IInputProps {\r\n  type?: \"number\" | \"email\" | \"password\" | \"textarea\" | \"text\";\r\n  onChange?: (value: any, target?: any) => void;\r\n  defaultStyle?: boolean;\r\n  allowChars?: boolean;\r\n  maxLength?: number | boolean;\r\n  [proName: string]: any;\r\n}\r\nexport default class NscInput extends PureComponent<IInputProps, any> {\r\n  static Number = InputNumber;\r\n  static Email = InputEmail;\r\n  static Password = Password;\r\n  static TextArea = TextArea;\r\n  static Group = Input.Group;\r\n  static Search = Search;\r\n  ref = React.createRef<any>();\r\n  constructor(props) {\r\n    super(props);\r\n  }\r\n  state = {\r\n    value: \"\",\r\n  };\r\n  onChange(e) {\r\n    const { onChange, allowChars = false } = this.props;\r\n    const reg = /^[0-9a-zA-Z\\u4E00-\\u9FA5\\uF900-\\uFA2D]*$/;\r\n    const reg2 = /[a-zA-Z]'[a-zA-Z]/g;\r\n    const reg3 = /[a-zA-Z]\\s[a-zA-Z]/g;\r\n    if (onChange) {\r\n      if (allowChars) {\r\n        this.setState({\r\n          value: e.target.value,\r\n        });\r\n        onChange(e.target.value, e);\r\n      } else {\r\n        const value = e.target.value;\r\n        if (reg.test(value) || reg2.test(value) || reg3.test(value)) {\r\n          this.setState({\r\n            value: e.target.value,\r\n          });\r\n          onChange(e.target.value, e);\r\n        }\r\n      }\r\n    } else {\r\n      if (allowChars) {\r\n        this.setState({\r\n          value: e.target.value,\r\n        });\r\n      } else {\r\n        const value = e.target.value;\r\n        if (reg.test(value) || reg2.test(value) || reg3.test(value)) {\r\n          this.setState({\r\n            value: e.target.value,\r\n          });\r\n        }\r\n      }\r\n    }\r\n  }\r\n  getValue() {\r\n    return this.state.value;\r\n  }\r\n  setValue(value) {\r\n    this.setState({\r\n      value: value,\r\n    });\r\n  }\r\n\r\n  focus() {\r\n    this.ref.current?.focus();\r\n  }\r\n\r\n  blur() {\r\n    this.ref.current?.blur();\r\n  }\r\n\r\n  returnChildren() {\r\n    const { type, onChange, defaultStyle, maxLength, ...params } = this.props;\r\n\r\n    if (type == \"number\") {\r\n      const numberProps = omit(this.props, [\"type\", \"defaultStyle\"]);\r\n      return <InputNumber {...numberProps} ref={this.ref} />;\r\n    } else if (type == \"email\") {\r\n      const emailProps = omit(this.props, [\"type\", \"defaultStyle\"]);\r\n      return <InputEmail {...emailProps} ref={this.ref} />;\r\n    } else if (type == \"textarea\") {\r\n      const textProps = omit(this.props, [\"type\", \"defaultStyle\"]);\r\n      return <TextArea {...textProps} ref={this.ref} />;\r\n    } else if (type == \"password\") {\r\n      let passwordProps = omit(this.props, [\r\n        \"type\",\r\n        \"maxLength\",\r\n        \"defaultStyle\",\r\n        \"allowChars\",\r\n      ]);\r\n      if (!(maxLength === false)) {\r\n        passwordProps = {\r\n          maxLength: maxLength ? maxLength : 50,\r\n          ...passwordProps,\r\n        };\r\n      }\r\n      return <Password {...passwordProps} ref={this.ref} />;\r\n    } else {\r\n      let inputProps = omit(this.props, [\r\n        \"onChange\",\r\n        \"defaultStyle\",\r\n        \"allowChars\",\r\n        \"maxLength\",\r\n      ]);\r\n      if (!(maxLength === false)) {\r\n        inputProps = { maxLength: maxLength ? maxLength : 50, ...inputProps };\r\n      }\r\n      let { antdStyle } = config();\r\n      if ((defaultStyle || antdStyle) && defaultStyle === true) {\r\n        return (\r\n          <div className={cls(styles[\"nsc_input\"], this.props.className)}>\r\n            <Input\r\n              placeholder=\"请输入\"\r\n              onChange={this.onChange.bind(this)}\r\n              allowClear={true}\r\n              value={this.state.value}\r\n              {...inputProps}\r\n              ref={this.ref}\r\n            />\r\n          </div>\r\n        );\r\n      } else {\r\n        return (\r\n          <Input\r\n            placeholder=\"请输入\"\r\n            onChange={this.onChange.bind(this)}\r\n            allowClear={true}\r\n            value={this.state.value}\r\n            ref={this.ref}\r\n            {...inputProps}\r\n          />\r\n        );\r\n      }\r\n    }\r\n  }\r\n  render() {\r\n    return <>{this.returnChildren()}</>;\r\n  }\r\n}\r\n"]}

package/lib/{layout → base/layout}/index.js

@@ -61,4 +61,4 @@ _defineProperty(NscLayout, "Footer", Footer);
 _defineProperty(NscLayout, "Sider", Sider);
 
 export { NscLayout as default };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb21wb25lbnRzL2xheW91dC9pbmRleC50c3giXSwibmFtZXMiOlsiUmVhY3QiLCJIZWFkZXIiLCJDb250ZW50IiwiRm9vdGVyIiwiU2lkZXIiLCJOc2NMYXlvdXQiLCJwcm9wcyIsIlB1cmVDb21wb25lbnQiXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLE9BQU8sS0FBS0EsS0FBWixNQUF1QixPQUF2QjtBQUVBLElBQVFDLE1BQVIsV0FBUUEsTUFBUjtBQUFBLElBQWdCQyxPQUFoQixXQUFnQkEsT0FBaEI7QUFBQSxJQUF5QkMsTUFBekIsV0FBeUJBLE1BQXpCO0FBQUEsSUFBaUNDLEtBQWpDLFdBQWlDQSxLQUFqQzs7SUFDcUJDLFM7Ozs7Ozs7Ozs7Ozs7V0FLbkIsa0JBQTBCO0FBQ3hCLDBCQUFPLDZCQUFZLEtBQUtDLEtBQWpCLENBQVA7QUFDRDs7OztFQVBvQ04sS0FBSyxDQUFDTyxhOztnQkFBeEJGLFMsWUFDSEosTTs7Z0JBREdJLFMsYUFFRkgsTzs7Z0JBRkVHLFMsWUFHSEYsTTs7Z0JBSEdFLFMsV0FJSkQsSzs7U0FKSUMsUyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIFJlYWN0IGZyb20gXCJyZWFjdFwiO1xyXG5pbXBvcnQgeyBMYXlvdXRQcm9wcywgTGF5b3V0IH0gZnJvbSBcImFudGRcIjtcclxuY29uc3QgeyBIZWFkZXIsIENvbnRlbnQsIEZvb3RlciwgU2lkZXIgfSA9IExheW91dDtcclxuZXhwb3J0IGRlZmF1bHQgY2xhc3MgTnNjTGF5b3V0IGV4dGVuZHMgUmVhY3QuUHVyZUNvbXBvbmVudDxMYXlvdXRQcm9wcywgYW55PiB7XHJcbiAgc3RhdGljIEhlYWRlciA9IEhlYWRlcjtcclxuICBzdGF0aWMgQ29udGVudCA9IENvbnRlbnQ7XHJcbiAgc3RhdGljIEZvb3RlciA9IEZvb3RlcjtcclxuICBzdGF0aWMgU2lkZXIgPSBTaWRlcjtcclxuICByZW5kZXIoKTogUmVhY3QuUmVhY3ROb2RlIHtcclxuICAgIHJldHVybiA8TGF5b3V0IHsuLi50aGlzLnByb3BzfSAvPjtcclxuICB9XHJcbn1cclxuIl19
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb21wb25lbnRzL2Jhc2UvbGF5b3V0L2luZGV4LnRzeCJdLCJuYW1lcyI6WyJSZWFjdCIsIkhlYWRlciIsIkNvbnRlbnQiLCJGb290ZXIiLCJTaWRlciIsIk5zY0xheW91dCIsInByb3BzIiwiUHVyZUNvbXBvbmVudCJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsT0FBTyxLQUFLQSxLQUFaLE1BQXVCLE9BQXZCO0FBRUEsSUFBUUMsTUFBUixXQUFRQSxNQUFSO0FBQUEsSUFBZ0JDLE9BQWhCLFdBQWdCQSxPQUFoQjtBQUFBLElBQXlCQyxNQUF6QixXQUF5QkEsTUFBekI7QUFBQSxJQUFpQ0MsS0FBakMsV0FBaUNBLEtBQWpDOztJQUNxQkMsUzs7Ozs7Ozs7Ozs7OztXQUtuQixrQkFBMEI7QUFDeEIsMEJBQU8sNkJBQVksS0FBS0MsS0FBakIsQ0FBUDtBQUNEOzs7O0VBUG9DTixLQUFLLENBQUNPLGE7O2dCQUF4QkYsUyxZQUNISixNOztnQkFER0ksUyxhQUVGSCxPOztnQkFGRUcsUyxZQUdIRixNOztnQkFIR0UsUyxXQUlKRCxLOztTQUpJQyxTIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0ICogYXMgUmVhY3QgZnJvbSBcInJlYWN0XCI7XHJcbmltcG9ydCB7IExheW91dFByb3BzLCBMYXlvdXQgfSBmcm9tIFwiYW50ZFwiO1xyXG5jb25zdCB7IEhlYWRlciwgQ29udGVudCwgRm9vdGVyLCBTaWRlciB9ID0gTGF5b3V0O1xyXG5leHBvcnQgZGVmYXVsdCBjbGFzcyBOc2NMYXlvdXQgZXh0ZW5kcyBSZWFjdC5QdXJlQ29tcG9uZW50PExheW91dFByb3BzLCBhbnk+IHtcclxuICBzdGF0aWMgSGVhZGVyID0gSGVhZGVyO1xyXG4gIHN0YXRpYyBDb250ZW50ID0gQ29udGVudDtcclxuICBzdGF0aWMgRm9vdGVyID0gRm9vdGVyO1xyXG4gIHN0YXRpYyBTaWRlciA9IFNpZGVyO1xyXG4gIHJlbmRlcigpOiBSZWFjdC5SZWFjdE5vZGUge1xyXG4gICAgcmV0dXJuIDxMYXlvdXQgey4uLnRoaXMucHJvcHN9IC8+O1xyXG4gIH1cclxufVxyXG4iXX0=

package/lib/{list → base/list}/index.js

@@ -51,4 +51,4 @@ var NscList = /*#__PURE__*/function (_React$PureComponent) {
 _defineProperty(NscList, "Item", _List.Item);
 
 export { NscList as default };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb21wb25lbnRzL2xpc3QvaW5kZXgudHN4Il0sIm5hbWVzIjpbIlJlYWN0IiwiTnNjTGlzdCIsInByb3BzIiwiUHVyZUNvbXBvbmVudCIsIkl0ZW0iXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLE9BQU8sS0FBS0EsS0FBWixNQUF1QixPQUF2Qjs7SUFHcUJDLE87Ozs7Ozs7Ozs7Ozs7V0FFbkIsa0JBQTBCO0FBQ3hCLDBCQUFPLDJCQUFVLEtBQUtDLEtBQWYsQ0FBUDtBQUNEOzs7O0VBSmtDRixLQUFLLENBQUNHLGE7O2dCQUF0QkYsTyxVQUNMLE1BQUtHLEk7O1NBREFILE8iLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyBSZWFjdCBmcm9tIFwicmVhY3RcIjtcclxuaW1wb3J0IHsgTGlzdCwgTGlzdFByb3BzIH0gZnJvbSBcImFudGRcIjtcclxuXHJcbmV4cG9ydCBkZWZhdWx0IGNsYXNzIE5zY0xpc3QgZXh0ZW5kcyBSZWFjdC5QdXJlQ29tcG9uZW50PExpc3RQcm9wczxhbnk+LCBhbnk+IHtcclxuICBzdGF0aWMgSXRlbSA9IExpc3QuSXRlbTtcclxuICByZW5kZXIoKTogUmVhY3QuUmVhY3ROb2RlIHtcclxuICAgIHJldHVybiA8TGlzdCB7Li4udGhpcy5wcm9wc30gLz47XHJcbiAgfVxyXG59XHJcbiJdfQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb21wb25lbnRzL2Jhc2UvbGlzdC9pbmRleC50c3giXSwibmFtZXMiOlsiUmVhY3QiLCJOc2NMaXN0IiwicHJvcHMiLCJQdXJlQ29tcG9uZW50IiwiSXRlbSJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsT0FBTyxLQUFLQSxLQUFaLE1BQXVCLE9BQXZCOztJQUdxQkMsTzs7Ozs7Ozs7Ozs7OztXQUVuQixrQkFBMEI7QUFDeEIsMEJBQU8sMkJBQVUsS0FBS0MsS0FBZixDQUFQO0FBQ0Q7Ozs7RUFKa0NGLEtBQUssQ0FBQ0csYTs7Z0JBQXRCRixPLFVBQ0wsTUFBS0csSTs7U0FEQUgsTyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIFJlYWN0IGZyb20gXCJyZWFjdFwiO1xyXG5pbXBvcnQgeyBMaXN0LCBMaXN0UHJvcHMgfSBmcm9tIFwiYW50ZFwiO1xyXG5cclxuZXhwb3J0IGRlZmF1bHQgY2xhc3MgTnNjTGlzdCBleHRlbmRzIFJlYWN0LlB1cmVDb21wb25lbnQ8TGlzdFByb3BzPGFueT4sIGFueT4ge1xyXG4gIHN0YXRpYyBJdGVtID0gTGlzdC5JdGVtO1xyXG4gIHJlbmRlcigpOiBSZWFjdC5SZWFjdE5vZGUge1xyXG4gICAgcmV0dXJuIDxMaXN0IHsuLi50aGlzLnByb3BzfSAvPjtcclxuICB9XHJcbn1cclxuIl19

package/lib/base/menu/index.js

@@ -0,0 +1,247 @@
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+import "antd/es/tooltip/style/css";
+import _Tooltip from "antd/es/tooltip";
+import "antd/es/menu/style/css";
+import _Menu from "antd/es/menu";
+var _excluded = ["url", "listeners", "viewname"];
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+/*
+ * @Descripttion:
+ * @version:
+ * @Author: rxzhu
+ * @Date: 2021-04-16 09:43:28
+ * @LastEditors: Please set LastEditors
+ * @LastEditTime: 2022-02-26 15:13:22
+ */
+import React, { PureComponent } from "react";
+import Store from "@bj-nsc/msn";
+import { utils } from "@bj-nsc/msn/lib/utils";
+import { getIcon } from "../../utils";
+import omit from "omit.js";
+var SubMenu = _Menu.SubMenu,
+    Item = _Menu.Item,
+    ItemGroup = _Menu.ItemGroup;
+
+var NSCMenu = /*#__PURE__*/function (_PureComponent) {
+  _inherits(NSCMenu, _PureComponent);
+
+  var _super = _createSuper(NSCMenu);
+
+  function NSCMenu(props) {
+    var _this2;
+
+    _classCallCheck(this, NSCMenu);
+
+    _this2 = _super.call(this, props);
+
+    _defineProperty(_assertThisInitialized(_this2), "state", {
+      dataSource: []
+    });
+
+    _defineProperty(_assertThisInitialized(_this2), "store", {});
+
+    _defineProperty(_assertThisInitialized(_this2), "renderMenuItem", function (menusData) {
+      if (!menusData || !Array.isArray(menusData)) {
+        return [];
+      }
+
+      var _this2$props = _this2.props,
+          _this2$props$titleFie = _this2$props.titleField,
+          titleField = _this2$props$titleFie === void 0 ? "title" : _this2$props$titleFie,
+          _this2$props$keyField = _this2$props.keyField,
+          keyField = _this2$props$keyField === void 0 ? "key" : _this2$props$keyField,
+          _this2$props$showIcon = _this2$props.showIcon,
+          showIcon = _this2$props$showIcon === void 0 ? true : _this2$props$showIcon,
+          _this2$props$subMenuP = _this2$props.subMenuProps,
+          subMenuProps = _this2$props$subMenuP === void 0 ? {} : _this2$props$subMenuP,
+          _this2$props$tooltip = _this2$props.tooltip,
+          tooltip = _this2$props$tooltip === void 0 ? false : _this2$props$tooltip;
+      return menusData.map(function (item) {
+        var style = item.style,
+            icon = item.icon,
+            disabled = item.disabled;
+        var title = item[titleField];
+        var spantitle = /*#__PURE__*/React.createElement("span", {
+          style: style
+        }, title);
+        var tooltiptitle = /*#__PURE__*/React.createElement(_Tooltip, {
+          title: title
+        }, title);
+        var newtitle = tooltip ? tooltiptitle : spantitle;
+
+        if (item["childNodes"] || item["children"]) {
+          var menuGroupData = {},
+              menuData = [];
+          var childData = item["childNodes"] || item["children"];
+          childData.map(function (item) {
+            var gruoptitle = item.groupName;
+
+            if (gruoptitle) {
+              if (!menuGroupData[gruoptitle]) menuGroupData[gruoptitle] = [];
+              menuGroupData[gruoptitle].push(item);
+            } else {
+              menuData.push(item);
+            }
+          });
+          return /*#__PURE__*/React.createElement(SubMenu, _extends({
+            key: item[keyField],
+            title: showIcon && icon ? /*#__PURE__*/React.createElement("span", null, getIcon(icon), newtitle) : newtitle
+          }, subMenuProps), Object.keys(menuGroupData).map(function (key) {
+            return /*#__PURE__*/React.createElement(ItemGroup, {
+              key: key,
+              title: key
+            }, _this2.renderMenuItem(menuGroupData[key]));
+          }), _this2.renderMenuItem(menuData));
+        } else {
+          return /*#__PURE__*/React.createElement(_Menu.Item, {
+            key: item[keyField],
+            disabled: disabled
+          }, showIcon && icon ? /*#__PURE__*/React.createElement("span", null, getIcon(icon), newtitle) : newtitle);
+        }
+      });
+    });
+
+    _defineProperty(_assertThisInitialized(_this2), "renderChildren", function () {
+      var children = _this2.props.children;
+      var dataSource = _this2.state.dataSource;
+
+      if (children) {
+        return /*#__PURE__*/React.createElement(React.Fragment, null, children);
+      } else {
+        return _this2.renderMenuItem(dataSource);
+      }
+    });
+
+    var data = props.data,
+        _props$store = props.store,
+        store = _props$store === void 0 ? {} : _props$store,
+        _children = props.children;
+
+    var url = store.url,
+        _store$listeners = store.listeners,
+        listenersPops = _store$listeners === void 0 ? {} : _store$listeners,
+        viewname = store.viewname,
+        stores = _objectWithoutProperties(store, _excluded);
+
+    if (!_children) {
+      if (!(data || url)) {
+        throw new Error("url、data不能都为空！");
+      }
+
+      var _this = _assertThisInitialized(_this2);
+
+      var storeProps = _objectSpread({
+        model: "model",
+        component: _assertThisInitialized(_this2),
+        listeners: {
+          onBeforeLoad: function onBeforeLoad(store, options) {
+            utils.callback(listenersPops.onBeforeLoad, _this, [store, options]);
+          },
+          load: function load(data, modelData, store) {
+            _this.setState({
+              dataSource: modelData
+            });
+
+            utils.callback(listenersPops.load, _this, [data, modelData, store]);
+          },
+          dataChanged: function dataChanged(data, modelData, store) {
+            _this.setState({
+              dataSource: modelData
+            });
+
+            utils.callback(listenersPops.dataChanged, _this, [data, modelData, store]);
+          }
+        }
+      }, stores);
+
+      if (url && data == null) {
+        storeProps = _objectSpread(_objectSpread({}, {
+          autoLoad: true,
+          url: url //读字典，url固定，viewname
+
+        }), storeProps);
+      }
+
+      _this2.store = new Store(storeProps);
+    }
+
+    return _this2;
+  }
+
+  _createClass(NSCMenu, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      if (this.props.data) {
+        this.setState({
+          dataSource: this.props.data
+        });
+      }
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var menuProps = omit(this.props, ["data", "store", "titleField", "keyField", "showIcon", "tooltip"]);
+      return /*#__PURE__*/React.createElement(_Menu, menuProps, this.renderChildren());
+    }
+  }], [{
+    key: "getDerivedStateFromProps",
+    value: function getDerivedStateFromProps(nextProps, prevState) {
+      var dataSource = prevState.dataSource;
+      var data = nextProps.data;
+
+      if (data) {
+        if (JSON.stringify(dataSource) !== JSON.stringify(data)) {
+          return {
+            dataSource: data
+          };
+        }
+      }
+
+      return null;
+    }
+  }]);
+
+  return NSCMenu;
+}(PureComponent);
+
+_defineProperty(NSCMenu, "SubMenu", SubMenu);
+
+_defineProperty(NSCMenu, "Item", Item);
+
+_defineProperty(NSCMenu, "ItemGroup", ItemGroup);
+
+export { NSCMenu as default };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/components/base/menu/index.tsx"],"names":["React","PureComponent","Store","utils","getIcon","omit","SubMenu","Item","ItemGroup","NSCMenu","props","dataSource","menusData","Array","isArray","titleField","keyField","showIcon","subMenuProps","tooltip","map","item","style","icon","disabled","title","spantitle","tooltiptitle","newtitle","menuGroupData","menuData","childData","gruoptitle","groupName","push","Object","keys","key","renderMenuItem","children","state","data","store","url","listeners","listenersPops","viewname","stores","Error","_this","storeProps","model","component","onBeforeLoad","options","callback","load","modelData","setState","dataChanged","autoLoad","menuProps","renderChildren","nextProps","prevState","JSON","stringify"],"mappings":"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","sourcesContent":["/*\r\n * @Descripttion:\r\n * @version:\r\n * @Author: rxzhu\r\n * @Date: 2021-04-16 09:43:28\r\n * @LastEditors: Please set LastEditors\r\n * @LastEditTime: 2022-02-26 15:13:22\r\n */\r\nimport React, { PureComponent } from \"react\";\r\n\r\nimport { Menu, MenuProps, SubMenuProps, Tooltip } from \"antd\";\r\nimport Store, { StoreProps } from \"@bj-nsc/msn\";\r\nimport { utils } from \"@bj-nsc/msn/lib/utils\";\r\nimport { getIcon } from \"../../utils\";\r\nimport omit from \"omit.js\";\r\n\r\ninterface IMenuProps extends MenuProps {\r\n  data?: Array<object>;\r\n  titleField?: string;\r\n  keyField?: string;\r\n  store?: StoreProps;\r\n  showIcon?: boolean; //是否显示icon ,默认true\r\n  subMenuProps?: SubMenuProps;\r\n  tooltip?: boolean;\r\n}\r\nconst { SubMenu, Item, ItemGroup } = Menu;\r\n\r\nexport default class NSCMenu extends PureComponent<IMenuProps> {\r\n  static SubMenu = SubMenu;\r\n  static Item = Item;\r\n  static ItemGroup = ItemGroup;\r\n\r\n  state = {\r\n    dataSource: [],\r\n  };\r\n\r\n  store = {} as StoreProps;\r\n  static getDerivedStateFromProps(nextProps, prevState: any) {\r\n    const { dataSource } = prevState;\r\n    const { data } = nextProps;\r\n    if (data) {\r\n      if (JSON.stringify(dataSource) !== JSON.stringify(data)) {\r\n        return {\r\n          dataSource: data,\r\n        };\r\n      }\r\n    }\r\n    return null;\r\n  }\r\n  constructor(props) {\r\n    super(props);\r\n    const { data, store = {}, children } = props;\r\n    const { url, listeners: listenersPops = {}, viewname, ...stores } = store;\r\n    if (!children) {\r\n      if (!(data || url)) {\r\n        throw new Error(\"url、data不能都为空！\");\r\n      }\r\n      let _this = this;\r\n      let storeProps = {\r\n        model: \"model\",\r\n        component: this,\r\n        listeners: {\r\n          onBeforeLoad: function (store, options) {\r\n            utils.callback(listenersPops.onBeforeLoad, _this, [store, options]);\r\n          },\r\n          load: function (data, modelData, store) {\r\n            _this.setState({ dataSource: modelData });\r\n            utils.callback(listenersPops.load, _this, [data, modelData, store]);\r\n          },\r\n          dataChanged: function (data, modelData, store) {\r\n            _this.setState({ dataSource: modelData });\r\n            utils.callback(listenersPops.dataChanged, _this, [\r\n              data,\r\n              modelData,\r\n              store,\r\n            ]);\r\n          },\r\n        },\r\n        ...stores,\r\n      };\r\n      if (url && data == null) {\r\n        storeProps = {\r\n          ...{\r\n            autoLoad: true,\r\n            url: url, //读字典，url固定，viewname\r\n          },\r\n          ...storeProps,\r\n        };\r\n      }\r\n      this.store = new Store(storeProps);\r\n    }\r\n  }\r\n  componentDidMount() {\r\n    if (this.props.data) {\r\n      this.setState({\r\n        dataSource: this.props.data,\r\n      });\r\n    }\r\n  }\r\n  renderMenuItem = (menusData) => {\r\n    if (!menusData || !Array.isArray(menusData)) {\r\n      return [];\r\n    }\r\n    const {\r\n      titleField = \"title\",\r\n      keyField = \"key\",\r\n      showIcon = true,\r\n      subMenuProps = {},\r\n      tooltip = false,\r\n    } = this.props;\r\n    return menusData.map((item) => {\r\n      const { style, icon, disabled } = item;\r\n\r\n      const title = item[titleField];\r\n      const spantitle = <span style={style}>{title}</span>;\r\n      const tooltiptitle = <Tooltip title={title}>{title}</Tooltip>;\r\n      const newtitle = tooltip?tooltiptitle:spantitle\r\n      if (item[\"childNodes\"] || item[\"children\"]) {\r\n        let menuGroupData = {},\r\n          menuData = [];\r\n        let childData = item[\"childNodes\"] || item[\"children\"];\r\n        childData.map((item) => {\r\n          let gruoptitle = item.groupName;\r\n          if (gruoptitle) {\r\n            if (!menuGroupData[gruoptitle]) menuGroupData[gruoptitle] = [];\r\n            menuGroupData[gruoptitle].push(item);\r\n          } else {\r\n            menuData.push(item);\r\n          }\r\n        });\r\n        return (\r\n          <SubMenu\r\n            key={item[keyField]}\r\n            title={\r\n              showIcon && icon ? (\r\n                <span>\r\n                  {getIcon(icon)}\r\n                  {newtitle}\r\n                </span>\r\n              ) : (\r\n                newtitle\r\n              )\r\n            }\r\n            {...subMenuProps}\r\n          >\r\n            {Object.keys(menuGroupData).map((key) => {\r\n              return (\r\n                <ItemGroup key={key} title={key}>\r\n                  {this.renderMenuItem(menuGroupData[key])}\r\n                </ItemGroup>\r\n              );\r\n            })}\r\n            {this.renderMenuItem(menuData)}\r\n          </SubMenu>\r\n        );\r\n      } else {\r\n        return (\r\n          <Menu.Item key={item[keyField]} disabled={disabled}>\r\n            {showIcon && icon ? (\r\n              <span>\r\n                {getIcon(icon)}\r\n                {newtitle}\r\n              </span>\r\n            ) : (\r\n              newtitle\r\n            )}\r\n          </Menu.Item>\r\n        );\r\n      }\r\n    });\r\n  };\r\n  renderChildren = () => {\r\n    const { children } = this.props;\r\n    const { dataSource } = this.state;\r\n    if (children) {\r\n      return <>{children}</>;\r\n    } else {\r\n      return this.renderMenuItem(dataSource);\r\n    }\r\n  };\r\n\r\n  render() {\r\n    const menuProps = omit(this.props, [\r\n      \"data\",\r\n      \"store\",\r\n      \"titleField\",\r\n      \"keyField\",\r\n      \"showIcon\",\r\n      \"tooltip\",\r\n    ]);\r\n    return <Menu {...menuProps}>{this.renderChildren()}</Menu>;\r\n  }\r\n}\r\n"]}

package/lib/{message → base/message}/index.js

@@ -56,4 +56,4 @@ _defineProperty(NscAffix, "config", _message.config);
 _defineProperty(NscAffix, "destroy", _message.destroy);
 
 export { NscAffix as default };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb21wb25lbnRzL21lc3NhZ2UvaW5kZXgudHN4Il0sIm5hbWVzIjpbIlJlYWN0IiwiTnNjQWZmaXgiLCJQdXJlQ29tcG9uZW50Iiwic3VjY2VzcyIsImVycm9yIiwiaW5mbyIsIndhcm4iLCJ3YXJuaW5nIiwibG9hZGluZyIsIm9wZW4iLCJjb25maWciLCJkZXN0cm95Il0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLE9BQU8sS0FBS0EsS0FBWixNQUF1QixPQUF2Qjs7SUFHcUJDLFE7Ozs7Ozs7Ozs7OztFQUFpQkQsS0FBSyxDQUFDRSxhOztnQkFBdkJELFEsYUFDRixTQUFRRSxPOztnQkFETkYsUSxXQUVKLFNBQVFHLEs7O2dCQUZKSCxRLFVBR0wsU0FBUUksSTs7Z0JBSEhKLFEsVUFJTCxTQUFRSyxJOztnQkFKSEwsUSxhQUtGLFNBQVFNLE87O2dCQUxOTixRLGFBTUYsU0FBUU8sTzs7Z0JBTk5QLFEsVUFPTCxTQUFRUSxJOztnQkFQSFIsUSxZQVFILFNBQVFTLE07O2dCQVJMVCxRLGFBU0YsU0FBUVUsTzs7U0FUTlYsUSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIFJlYWN0IGZyb20gXCJyZWFjdFwiO1xyXG5pbXBvcnQgeyBtZXNzYWdlLCBNZXNzYWdlQXJnc1Byb3BzIH0gZnJvbSBcImFudGRcIjtcclxuXHJcbmV4cG9ydCBkZWZhdWx0IGNsYXNzIE5zY0FmZml4IGV4dGVuZHMgUmVhY3QuUHVyZUNvbXBvbmVudDxhbnksIGFueT4ge1xyXG4gIHN0YXRpYyBzdWNjZXNzID0gbWVzc2FnZS5zdWNjZXNzO1xyXG4gIHN0YXRpYyBlcnJvciA9IG1lc3NhZ2UuZXJyb3I7XHJcbiAgc3RhdGljIGluZm8gPSBtZXNzYWdlLmluZm87XHJcbiAgc3RhdGljIHdhcm4gPSBtZXNzYWdlLndhcm47XHJcbiAgc3RhdGljIHdhcm5pbmcgPSBtZXNzYWdlLndhcm5pbmc7XHJcbiAgc3RhdGljIGxvYWRpbmcgPSBtZXNzYWdlLmxvYWRpbmc7XHJcbiAgc3RhdGljIG9wZW4gPSBtZXNzYWdlLm9wZW47XHJcbiAgc3RhdGljIGNvbmZpZyA9IG1lc3NhZ2UuY29uZmlnO1xyXG4gIHN0YXRpYyBkZXN0cm95ID0gbWVzc2FnZS5kZXN0cm95O1xyXG5cclxuICAvLyAgIHJlbmRlcigpOiBSZWFjdC5SZWFjdE5vZGUge1xyXG4gIC8vICAgICByZXR1cm4gPG1lc3NhZ2Ugey4uLnRoaXMucHJvcHN9IC8+O1xyXG4gIC8vICAgfVxyXG59XHJcbiJdfQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb21wb25lbnRzL2Jhc2UvbWVzc2FnZS9pbmRleC50c3giXSwibmFtZXMiOlsiUmVhY3QiLCJOc2NBZmZpeCIsIlB1cmVDb21wb25lbnQiLCJzdWNjZXNzIiwiZXJyb3IiLCJpbmZvIiwid2FybiIsIndhcm5pbmciLCJsb2FkaW5nIiwib3BlbiIsImNvbmZpZyIsImRlc3Ryb3kiXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsT0FBTyxLQUFLQSxLQUFaLE1BQXVCLE9BQXZCOztJQUdxQkMsUTs7Ozs7Ozs7Ozs7O0VBQWlCRCxLQUFLLENBQUNFLGE7O2dCQUF2QkQsUSxhQUNGLFNBQVFFLE87O2dCQURORixRLFdBRUosU0FBUUcsSzs7Z0JBRkpILFEsVUFHTCxTQUFRSSxJOztnQkFISEosUSxVQUlMLFNBQVFLLEk7O2dCQUpITCxRLGFBS0YsU0FBUU0sTzs7Z0JBTE5OLFEsYUFNRixTQUFRTyxPOztnQkFOTlAsUSxVQU9MLFNBQVFRLEk7O2dCQVBIUixRLFlBUUgsU0FBUVMsTTs7Z0JBUkxULFEsYUFTRixTQUFRVSxPOztTQVROVixRIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0ICogYXMgUmVhY3QgZnJvbSBcInJlYWN0XCI7XHJcbmltcG9ydCB7IG1lc3NhZ2UsIE1lc3NhZ2VBcmdzUHJvcHMgfSBmcm9tIFwiYW50ZFwiO1xyXG5cclxuZXhwb3J0IGRlZmF1bHQgY2xhc3MgTnNjQWZmaXggZXh0ZW5kcyBSZWFjdC5QdXJlQ29tcG9uZW50PGFueSwgYW55PiB7XHJcbiAgc3RhdGljIHN1Y2Nlc3MgPSBtZXNzYWdlLnN1Y2Nlc3M7XHJcbiAgc3RhdGljIGVycm9yID0gbWVzc2FnZS5lcnJvcjtcclxuICBzdGF0aWMgaW5mbyA9IG1lc3NhZ2UuaW5mbztcclxuICBzdGF0aWMgd2FybiA9IG1lc3NhZ2Uud2FybjtcclxuICBzdGF0aWMgd2FybmluZyA9IG1lc3NhZ2Uud2FybmluZztcclxuICBzdGF0aWMgbG9hZGluZyA9IG1lc3NhZ2UubG9hZGluZztcclxuICBzdGF0aWMgb3BlbiA9IG1lc3NhZ2Uub3BlbjtcclxuICBzdGF0aWMgY29uZmlnID0gbWVzc2FnZS5jb25maWc7XHJcbiAgc3RhdGljIGRlc3Ryb3kgPSBtZXNzYWdlLmRlc3Ryb3k7XHJcblxyXG4gIC8vICAgcmVuZGVyKCk6IFJlYWN0LlJlYWN0Tm9kZSB7XHJcbiAgLy8gICAgIHJldHVybiA8bWVzc2FnZSB7Li4udGhpcy5wcm9wc30gLz47XHJcbiAgLy8gICB9XHJcbn1cclxuIl19

package/lib/{modal → base/modal}/index.js

@@ -195,4 +195,4 @@ _defineProperty(NscModal, "error", _Modal.error);
 _defineProperty(NscModal, "warning", _Modal.warning);
 
 export { NscModal as default };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb21wb25lbnRzL2Jhc2UvbW9kYWwvaW5kZXgudHN4Il0sIm5hbWVzIjpbIlJlYWN0IiwiUHVyZUNvbXBvbmVudCIsInV0aWxzIiwiTnNjTW9kYWwiLCJ2aXNpYmxlIiwic2NvcGUiLCJwYXJhbXMiLCJiZWZvcmVSZW5kZXIiLCJjYWxsYmFja0JlZm9yZUNsb3NlIiwiY2FsbGJhY2siLCJvcHRpb24iLCJzZXRTdGF0ZSIsInJldHVyblZhbHVlIiwicmVzdWx0IiwiX3RoaXMiLCJzZXRSZXR1cm5WYWx1ZSIsInIiLCJrZXkiLCJwcm9wcyIsInR5cGUiLCJzdGF0ZSIsImNsb3NlIiwiY29uZmlybSIsImluZm8iLCJzdWNjZXNzIiwiZXJyb3IiLCJ3YXJuaW5nIl0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsT0FBT0EsS0FBUCxJQUFnQkMsYUFBaEIsUUFBcUMsT0FBckM7QUFFQSxTQUFTQyxLQUFULFFBQXNCLHVCQUF0Qjs7SUFNcUJDLFE7Ozs7Ozs7Ozs7Ozs7Ozs7bUVBUUwsSTs7NkRBRU47QUFDTkMsTUFBQUEsT0FBTyxFQUFFO0FBREgsSzs7OERBR007QUFDWjtBQUNBQyxNQUFBQSxLQUFLLGdDQUZPO0FBR1o7QUFDQUMsTUFBQUEsTUFBTSxFQUFFLEVBSkk7QUFLWjtBQUNBQyxNQUFBQSxZQUFZLEVBQUUsSUFORjtBQU9aO0FBQ0FDLE1BQUFBLG1CQUFtQixFQUFFLElBUlQ7QUFTWjtBQUNBQyxNQUFBQSxRQUFRLEVBQUU7QUFWRSxLOzs7Ozs7OztBQVlkO0FBQ0Y7QUFDQTtBQUNBO0FBRUU7QUFDQSxvQkFBdUI7QUFBQSxVQUFsQkMsTUFBa0IsdUVBQUosRUFBSTtBQUNyQixVQUFRTCxLQUFSLEdBQWtCLEtBQUtLLE1BQXZCLENBQVFMLEtBQVI7QUFDQSxVQUFRRSxZQUFSLEdBQXlCRyxNQUF6QixDQUFRSCxZQUFSO0FBQ0EsV0FBS0csTUFBTCxtQ0FBbUIsS0FBS0EsTUFBeEIsR0FBbUNBLE1BQW5DO0FBQ0FSLE1BQUFBLEtBQUssQ0FBQ08sUUFBTixDQUFlRixZQUFmLEVBQTZCRixLQUE3QjtBQUNBLFdBQUtNLFFBQUwsQ0FBYztBQUFFUCxRQUFBQSxPQUFPLEVBQUU7QUFBWCxPQUFkO0FBQ0QsSyxDQUVEOzs7O1dBQ0EsZ0JBQU87QUFDTCxXQUFLTyxRQUFMLENBQWM7QUFBRVAsUUFBQUEsT0FBTyxFQUFFO0FBQVgsT0FBZDtBQUNELEssQ0FFRDs7OztXQUNBLHdCQUFlUSxXQUFmLEVBQTRCO0FBQzFCLFdBQUtBLFdBQUwsR0FBbUJBLFdBQW5CO0FBQ0QsSyxDQUVEOzs7O1dBQ0EsMEJBQWlCO0FBQ2YsYUFBTyxLQUFLQSxXQUFaO0FBQ0Q7QUFFRDtBQUNGO0FBQ0E7Ozs7V0FDRSxlQUFNQyxNQUFOLEVBQW9CO0FBQ2xCLFVBQUlDLEtBQUssR0FBRyxJQUFaOztBQUNBLHlCQUFpRCxLQUFLSixNQUF0RDtBQUFBLFVBQVFELFFBQVIsZ0JBQVFBLFFBQVI7QUFBQSxVQUFrQkosS0FBbEIsZ0JBQWtCQSxLQUFsQjtBQUFBLFVBQXlCRyxtQkFBekIsZ0JBQXlCQSxtQkFBekI7QUFDQSxVQUFJSyxNQUFKLEVBQVksS0FBS0UsY0FBTCxDQUFvQkYsTUFBcEI7QUFDWixVQUFNRyxDQUFDLEdBQUdkLEtBQUssQ0FBQ08sUUFBTixDQUFlRCxtQkFBZixFQUFvQ0gsS0FBcEMsRUFBMkMsQ0FBQyxLQUFLTyxXQUFOLENBQTNDLENBQVY7QUFDQSxVQUFJSSxDQUFDLEtBQUssS0FBVixFQUFpQixLQUFLTCxRQUFMLENBQWM7QUFBRVAsUUFBQUEsT0FBTyxFQUFFO0FBQVgsT0FBZDtBQUNqQkYsTUFBQUEsS0FBSyxDQUFDTyxRQUFOLENBQWVBLFFBQWYsRUFBeUJKLEtBQXpCLEVBQWdDLENBQUNTLEtBQUssQ0FBQ0YsV0FBUCxDQUFoQztBQUNEO0FBRUQ7QUFDRjtBQUNBO0FBQ0E7Ozs7V0FDRSxtQkFBVUssR0FBVixFQUFlO0FBQ2IsVUFBSUEsR0FBSixFQUFTLE9BQU8sS0FBS1AsTUFBTCxDQUFZSixNQUFaLENBQW1CVyxHQUFuQixDQUFQO0FBQ1QsYUFBTyxLQUFLUCxNQUFMLENBQVlKLE1BQW5CO0FBQ0Q7OztXQUNELGtCQUFTO0FBQUE7O0FBQ1Asd0JBQXNDLEtBQUtZLEtBQTNDO0FBQUEseUNBQVFDLElBQVI7QUFBQSxVQUFRQSxJQUFSLGlDQUFlLE9BQWY7QUFBQSxVQUEyQmIsTUFBM0I7O0FBQ0EsVUFBSWEsSUFBSSxJQUFJLFFBQVosRUFBc0I7QUFDcEIsNEJBQ0U7QUFDRSxVQUFBLE9BQU8sRUFBRSxLQUFLQyxLQUFMLENBQVdoQixPQUR0QjtBQUVFLFVBQUEsT0FBTyxFQUFFLG1CQUFNO0FBQ2IsWUFBQSxNQUFJLENBQUNpQixLQUFMO0FBQ0Q7QUFKSCxXQUtNZixNQUxOLEVBREY7QUFTRCxPQVZELE1BVU87QUFDTCw0QkFDRTtBQUNFLFVBQUEsT0FBTyxFQUFFLEtBQUtjLEtBQUwsQ0FBV2hCLE9BRHRCO0FBRUUsVUFBQSxRQUFRLEVBQUUsb0JBQU07QUFDZCxZQUFBLE1BQUksQ0FBQ2lCLEtBQUw7QUFDRCxXQUpIO0FBS0UsVUFBQSxJQUFJLEVBQUUsZ0JBQU07QUFDVixZQUFBLE1BQUksQ0FBQ0EsS0FBTDtBQUNELFdBUEg7QUFRRSxVQUFBLE1BQU0sRUFBRSxJQVJWO0FBU0UsVUFBQSxVQUFVLEVBQUU7QUFUZCxXQVVNZixNQVZOLEVBREY7QUFjRDtBQUNGOzs7O0VBdEdtQ0wsYTs7Z0JBQWpCRSxRLGFBQ0YsT0FBTW1CLE87O2dCQURKbkIsUSxVQUVMLE9BQU1vQixJOztnQkFGRHBCLFEsYUFHRixPQUFNcUIsTzs7Z0JBSEpyQixRLFdBSUosT0FBTXNCLEs7O2dCQUpGdEIsUSxhQUtGLE9BQU11QixPOztTQUxKdkIsUSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBSZWFjdCwgeyBQdXJlQ29tcG9uZW50IH0gZnJvbSBcInJlYWN0XCI7XHJcbmltcG9ydCB7IE1vZGFsLCBNb2RhbFByb3BzLCBEcmF3ZXIsIERyYXdlclByb3BzIH0gZnJvbSBcImFudGRcIjtcclxuaW1wb3J0IHsgdXRpbHMgfSBmcm9tIFwiQGJqLW5zYy9tc24vbGliL3V0aWxzXCI7XHJcblxyXG5pbnRlcmZhY2UgTnNjTW9kYWxQb3JwcyBleHRlbmRzIE1vZGFsUHJvcHMsIERyYXdlclByb3BzIHtcclxuICB0eXBlPzogXCJtb2RhbFwiIHwgXCJkcmF3ZXJcIjtcclxufVxyXG5cclxuZXhwb3J0IGRlZmF1bHQgY2xhc3MgTnNjTW9kYWwgZXh0ZW5kcyBQdXJlQ29tcG9uZW50PE5zY01vZGFsUG9ycHM+IHtcclxuICBzdGF0aWMgY29uZmlybSA9IE1vZGFsLmNvbmZpcm07XHJcbiAgc3RhdGljIGluZm8gPSBNb2RhbC5pbmZvO1xyXG4gIHN0YXRpYyBzdWNjZXNzID0gTW9kYWwuc3VjY2VzcztcclxuICBzdGF0aWMgZXJyb3IgPSBNb2RhbC5lcnJvcjtcclxuICBzdGF0aWMgd2FybmluZyA9IE1vZGFsLndhcm5pbmc7XHJcblxyXG4gIC8v6L+U5Zue5YC8XHJcbiAgcmV0dXJuVmFsdWUgPSBudWxsO1xyXG5cclxuICBzdGF0ZSA9IHtcclxuICAgIHZpc2libGU6IGZhbHNlLFxyXG4gIH07XHJcbiAgb3B0aW9uOiBhbnkgPSB7XHJcbiAgICAvL+Wbnuiwg+S9nOeUqOWfn1xyXG4gICAgc2NvcGU6IHRoaXMsXHJcbiAgICAvL29wZW7kvKDpgJLov4fmnaXnmoTpobXpnaLlj4LmlbBcclxuICAgIHBhcmFtczoge30sXHJcbiAgICAvL+aYvuekuuS5i+WJjeWbnuiwg1xyXG4gICAgYmVmb3JlUmVuZGVyOiBudWxsLFxyXG4gICAgLy/lhbPpl63kuYvliY3lm57osIPvvIzlpoLmnpxyZXR1cm4gZmFsc2XvvIzkuJTnqpflj6PkuI3lhbPpl61cclxuICAgIGNhbGxiYWNrQmVmb3JlQ2xvc2U6IG51bGwsXHJcbiAgICAvL+WFs+mXreWQjuWbnuiwg++8jOW8guatpeaTjeS9nFxyXG4gICAgY2FsbGJhY2s6IG51bGwsXHJcbiAgfTtcclxuICAvKipcclxuICAgKiDmuLLmn5PlrozmiJBcclxuICAgKiBAcGFyYW0geyp9IG9wdGlvbiAg5pW05pS55Lyg6YCS5a+56LGhXHJcbiAgICovXHJcblxyXG4gIC8v5pi+56S6XHJcbiAgc2hvdyhvcHRpb246IGFueSA9IHt9KSB7XHJcbiAgICBjb25zdCB7IHNjb3BlIH0gPSB0aGlzLm9wdGlvbjtcclxuICAgIGNvbnN0IHsgYmVmb3JlUmVuZGVyIH0gPSBvcHRpb247XHJcbiAgICB0aGlzLm9wdGlvbiA9IHsgLi4udGhpcy5vcHRpb24sIC4uLm9wdGlvbiB9O1xyXG4gICAgdXRpbHMuY2FsbGJhY2soYmVmb3JlUmVuZGVyLCBzY29wZSk7XHJcbiAgICB0aGlzLnNldFN0YXRlKHsgdmlzaWJsZTogdHJ1ZSB9KTtcclxuICB9XHJcblxyXG4gIC8v6ZqQ6JePXHJcbiAgaGlkZSgpIHtcclxuICAgIHRoaXMuc2V0U3RhdGUoeyB2aXNpYmxlOiBmYWxzZSB9KTtcclxuICB9XHJcblxyXG4gIC8v6K6+572u6ZyA6KaB6L+U5Zue55qE5YC8XHJcbiAgc2V0UmV0dXJuVmFsdWUocmV0dXJuVmFsdWUpIHtcclxuICAgIHRoaXMucmV0dXJuVmFsdWUgPSByZXR1cm5WYWx1ZTtcclxuICB9XHJcblxyXG4gIC8v6I635Y+W6ZyA6KaB6L+U5Zue55qE5YC8XHJcbiAgZ2V0UmV0dXJuVmFsdWUoKSB7XHJcbiAgICByZXR1cm4gdGhpcy5yZXR1cm5WYWx1ZTtcclxuICB9XHJcblxyXG4gIC8qKlxyXG4gICAqIOWFs+mXreW4puWbnuiwg1xyXG4gICAqL1xyXG4gIGNsb3NlKHJlc3VsdD86IGFueSkge1xyXG4gICAgdmFyIF90aGlzID0gdGhpcztcclxuICAgIGNvbnN0IHsgY2FsbGJhY2ssIHNjb3BlLCBjYWxsYmFja0JlZm9yZUNsb3NlIH0gPSB0aGlzLm9wdGlvbjtcclxuICAgIGlmIChyZXN1bHQpIHRoaXMuc2V0UmV0dXJuVmFsdWUocmVzdWx0KTtcclxuICAgIGNvbnN0IHIgPSB1dGlscy5jYWxsYmFjayhjYWxsYmFja0JlZm9yZUNsb3NlLCBzY29wZSwgW3RoaXMucmV0dXJuVmFsdWVdKTtcclxuICAgIGlmIChyICE9PSBmYWxzZSkgdGhpcy5zZXRTdGF0ZSh7IHZpc2libGU6IGZhbHNlIH0pO1xyXG4gICAgdXRpbHMuY2FsbGJhY2soY2FsbGJhY2ssIHNjb3BlLCBbX3RoaXMucmV0dXJuVmFsdWVdKTtcclxuICB9XHJcblxyXG4gIC8qKlxyXG4gICAqIOiOt+WPluWPguaVsO+8jOWmguaenGtleeS4jeS8oOmAku+8jOS4lOiOt+WPluWFqOmDqFxyXG4gICAqIEBwYXJhbSB7U3RyaW5nfSBrZXlcclxuICAgKi9cclxuICBnZXRQYXJhbXMoa2V5KSB7XHJcbiAgICBpZiAoa2V5KSByZXR1cm4gdGhpcy5vcHRpb24ucGFyYW1zW2tleV07XHJcbiAgICByZXR1cm4gdGhpcy5vcHRpb24ucGFyYW1zO1xyXG4gIH1cclxuICByZW5kZXIoKSB7XHJcbiAgICBjb25zdCB7IHR5cGUgPSBcIm1vZGFsXCIsIC4uLnBhcmFtcyB9ID0gdGhpcy5wcm9wcztcclxuICAgIGlmICh0eXBlID09IFwiZHJhd2VyXCIpIHtcclxuICAgICAgcmV0dXJuIChcclxuICAgICAgICA8RHJhd2VyXHJcbiAgICAgICAgICB2aXNpYmxlPXt0aGlzLnN0YXRlLnZpc2libGV9XHJcbiAgICAgICAgICBvbkNsb3NlPXsoKSA9PiB7XHJcbiAgICAgICAgICAgIHRoaXMuY2xvc2UoKTtcclxuICAgICAgICAgIH19XHJcbiAgICAgICAgICB7Li4ucGFyYW1zfVxyXG4gICAgICAgIC8+XHJcbiAgICAgICk7XHJcbiAgICB9IGVsc2Uge1xyXG4gICAgICByZXR1cm4gKFxyXG4gICAgICAgIDxNb2RhbFxyXG4gICAgICAgICAgdmlzaWJsZT17dGhpcy5zdGF0ZS52aXNpYmxlfVxyXG4gICAgICAgICAgb25DYW5jZWw9eygpID0+IHtcclxuICAgICAgICAgICAgdGhpcy5jbG9zZSgpO1xyXG4gICAgICAgICAgfX1cclxuICAgICAgICAgIG9uT2s9eygpID0+IHtcclxuICAgICAgICAgICAgdGhpcy5jbG9zZSgpO1xyXG4gICAgICAgICAgfX1cclxuICAgICAgICAgIG9rVGV4dD17XCLnoa7lrppcIn1cclxuICAgICAgICAgIGNhbmNlbFRleHQ9e1wi5Y+W5raIXCJ9XHJcbiAgICAgICAgICB7Li4ucGFyYW1zfVxyXG4gICAgICAgIC8+XHJcbiAgICAgICk7XHJcbiAgICB9XHJcbiAgfVxyXG59XHJcbiJdfQ==