nsc-react-component 2.0.14 → 2.0.17

package/lib/{common → base/common}/PageRequest.js

@@ -175,4 +175,4 @@ var NscPageRequest = /*#__PURE__*/function (_PureComponent) {
 }(PureComponent);
 
 export default NscPageRequest;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/{common → base/common}/TreePanel.d.ts

@@ -4,6 +4,7 @@ import { StoreConfigType } from "@bj-nsc/msn";
 import { TreeProps } from "antd";
 export interface TreeCommonProps {
     titleAlias?: string;
+    subTitleAlias?: string;
     handleAdd?: (params: any) => void;
     handleDelete?: (params: any) => void;
     handleEdit?: (params: any) => void;
@@ -36,7 +37,7 @@ declare class TreePanel<P> extends Component<ITreePanelProps & TreeCommonProps &
     };
     componentDidUpdate(prevProps: any): void;
     constructor(props: any);
-    getTitle(data: any): string;
+    getTitle(data: any, type?: string): any;
     dataChangeBefore: (data: any) => any;
     _iterator: (data: any) => any;
     /**

package/lib/base/common/TreePanel.js

@@ -0,0 +1,290 @@
+var _excluded = ["listeners"];
+
+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 _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); }
+
+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; }
+
+import React, { Component } from "react";
+import treeutils from "../../treeUtils";
+import { TreeStore } from "@bj-nsc/msn";
+import { utils } from "@bj-nsc/msn/lib/utils";
+import "antd/es/tree/style"; // import { StoreConfigType } from "@bj-nsc/msn/lib/types/Store/TreeStore.d";
+
+import cloneDeep from "clone-deep";
+
+var TreePanel = /*#__PURE__*/function (_Component) {
+  _inherits(TreePanel, _Component);
+
+  var _super = _createSuper(TreePanel);
+
+  function TreePanel(props) {
+    var _this2;
+
+    _classCallCheck(this, TreePanel);
+
+    _this2 = _super.call(this, props);
+
+    _defineProperty(_assertThisInitialized(_this2), "state", {
+      //搜索文本
+      searchText: null,
+      fieldOption: {
+        keyField: "key",
+        titleField: "title",
+        pathsField: "children"
+      },
+      searchColor: null,
+      loading: false,
+      treeDatas: [],
+      checkedKeys: [],
+      expandedKeys: [],
+      selectedKeys: [],
+      selectNode: null
+    });
+
+    _defineProperty(_assertThisInitialized(_this2), "store", {});
+
+    _defineProperty(_assertThisInitialized(_this2), "dataChangeBefore", function (data) {
+      var originData = cloneDeep(data);
+
+      if (!_this2.props.titleAlias) {
+        return originData;
+      }
+
+      if (Array.isArray(originData)) {
+        var newData = _this2._iterator(originData);
+
+        return newData;
+      } else if (originData && _typeof(originData) === "object") {
+        originData.title = _this2.getTitle(originData);
+        originData.subTitle = _this2.getTitle(originData, "subTitleAlias");
+        if (originData.children) _this2._iterator(originData.children);
+      }
+
+      return originData;
+    });
+
+    _defineProperty(_assertThisInitialized(_this2), "_iterator", function (data) {
+      // const titleAlias = this.props.titleAlias;
+      // 如果传入的data是dva中model数据是不允许修改的,所以先转换一下
+      // const newData = data.map((item) => ({ ...item }));
+      data.forEach(function (item) {
+        item.title = _this2.getTitle(item);
+        item.subtitle = _this2.getTitle(item, "subTitleAlias");
+
+        if (item.children) {
+          _this2._iterator(item.children);
+        }
+      });
+      return data;
+    });
+
+    _defineProperty(_assertThisInitialized(_this2), "mapData", function () {});
+
+    var _this = _assertThisInitialized(_this2);
+
+    var treeData = props.treeData || [];
+    var nodeProps = props.nodeProps || {};
+
+    if (props.store instanceof TreeStore) {
+      _this2.store = props.store;
+    } else {
+      var _props$store = props.store,
+          _props$store$listener = _props$store.listeners,
+          listenersProps = _props$store$listener === void 0 ? {} : _props$store$listener,
+          restStore = _objectWithoutProperties(_props$store, _excluded);
+
+      var storeOption = _objectSpread({
+        component: _assertThisInitialized(_this2),
+        model: "treemodel",
+        treePrimaryKey: nodeProps.key || "id",
+        // 树节点唯一key
+        listeners: {
+          onBeforeLoad: function onBeforeLoad(store, options) {
+            var loading = props.lazyload != true;
+
+            _this.setState(_objectSpread(_objectSpread({}, _this.state), {
+              loading: loading
+            }));
+
+            utils.callback(listenersProps.onBeforeLoad, this, [store, options]);
+          },
+          dataChangeBefore: _this.dataChangeBefore,
+          dataChanged: function dataChanged(data, modelData, store) {
+            _this.setState({
+              treeDatas: modelData,
+              checkedKeys: _this._dataToCheckedKeys(modelData),
+              loading: false
+            });
+
+            utils.callback(listenersProps.dataChanged, this, [data, modelData, store]);
+          },
+          load: function load(data, modelData, store) {
+            utils.callback(listenersProps.load, _assertThisInitialized(_this2), [data, modelData, store]);
+          },
+          onErrorLoad: function onErrorLoad(err, response) {
+            _this2.setState({
+              loading: false
+            });
+
+            utils.callback(listenersProps.onErrorLoad, _assertThisInitialized(_this2), [err, response]);
+          }
+        },
+        data: treeData.length > 0 ? treeData : null,
+        autoLoad: restStore.autoLoad !== false ? true : false
+      }, restStore);
+
+      _this2.store = new TreeStore(storeOption);
+    }
+
+    return _this2;
+  }
+
+  _createClass(TreePanel, [{
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps) {
+      var oldTreeData = prevProps.treeData || [];
+      var treeData = this.props.treeData;
+
+      if (Array.isArray(treeData) && JSON.stringify(treeData) !== JSON.stringify(oldTreeData)) {
+        if (this.store) {
+          this.store.setData(treeData);
+        }
+      }
+    }
+  }, {
+    key: "getTitle",
+    value: function getTitle(data) {
+      var type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "titleAlias";
+      var title = "";
+
+      if (this.props[type]) {
+        return data[this.props[type]];
+      } else {
+        title = type == "titleAlias" ? data.title : data.subtitle;
+      }
+
+      return title;
+    }
+  }, {
+    key: "_dataToCheckedKeys",
+    value:
+    /**
+     * 初始化节点选中
+     * @param {*} modelData  数据
+     */
+    function _dataToCheckedKeys(modelData) {
+      return []; // return { checked: [], halfChecked: [] };
+    }
+    /**
+     * 界面渲染
+     */
+
+  }, {
+    key: "renderTemplate",
+    value: function renderTemplate(treeProps, newTreeDatas) {
+      return /*#__PURE__*/React.createElement(React.Fragment, null);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$state = this.state,
+          searchText = _this$state.searchText,
+          treeDatas = _this$state.treeDatas,
+          checkedKeys = _this$state.checkedKeys,
+          fieldOption = _this$state.fieldOption,
+          searchColor = _this$state.searchColor,
+          treeProps = utils.omit(this.props, ["store"], {
+        checkedKeys: checkedKeys
+      });
+      var newTreeDatas = [];
+
+      if (searchText) {
+        var data = treeutils.getSearchMenuDatas(this, searchText, fieldOption, searchColor);
+        newTreeDatas = data.treeDatas;
+        treeProps.openKeys = data.openKeys;
+      } else {
+        newTreeDatas = treeDatas;
+      }
+
+      return this.renderTemplate(treeProps, newTreeDatas);
+    }
+    /**
+     * 获取数据对象
+     */
+
+  }, {
+    key: "getStore",
+    value: function getStore() {
+      return this.store;
+    }
+    /**
+     * 获取数据模型对象
+     */
+
+  }, {
+    key: "getModel",
+    value: function getModel() {
+      return this.store.getModel();
+    }
+    /**
+     *  刷新界面
+     * @param {Object} options 参数
+     */
+
+  }, {
+    key: "reload",
+    value: function reload(options) {
+      this.store.reload(options);
+      return this;
+    }
+    /**
+     * 菜单搜索过滤显示
+     * @param {String} val
+     */
+
+  }, {
+    key: "handleSearch",
+    value: function handleSearch(val, fieldOption, searchColor) {
+      this.setState({
+        searchText: val,
+        fieldOption: fieldOption,
+        searchColor: searchColor
+      });
+    }
+  }]);
+
+  return TreePanel;
+}(Component);
+
+_defineProperty(TreePanel, "defaultProps", void 0);
+
+export default TreePanel;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/components/base/common/TreePanel.tsx"],"names":["React","Component","treeutils","TreeStore","utils","cloneDeep","TreePanel","props","searchText","fieldOption","keyField","titleField","pathsField","searchColor","loading","treeDatas","checkedKeys","expandedKeys","selectedKeys","selectNode","data","originData","titleAlias","Array","isArray","newData","_iterator","title","getTitle","subTitle","children","forEach","item","subtitle","_this","treeData","nodeProps","store","listeners","listenersProps","restStore","storeOption","component","model","treePrimaryKey","key","onBeforeLoad","options","lazyload","setState","state","callback","dataChangeBefore","dataChanged","modelData","_dataToCheckedKeys","load","onErrorLoad","err","response","length","autoLoad","prevProps","oldTreeData","JSON","stringify","setData","type","treeProps","newTreeDatas","omit","getSearchMenuDatas","openKeys","renderTemplate","getModel","reload","val"],"mappings":"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","sourcesContent":["import React, { Component } from \"react\";\r\nimport treeutils from \"../../treeUtils\";\r\nimport Store, { TreeStore } from \"@bj-nsc/msn\";\r\nimport { utils } from \"@bj-nsc/msn/lib/utils\";\r\nimport \"antd/es/tree/style\";\r\n// import { StoreConfigType } from \"@bj-nsc/msn/lib/types/Store/TreeStore.d\";\r\nimport { StoreConfigType } from \"@bj-nsc/msn\";\r\nimport { TreeProps } from \"antd\";\r\nimport { flattenDeep } from \"lodash\";\r\nimport cloneDeep from \"clone-deep\";\r\nexport interface TreeCommonProps {\r\n  titleAlias?: string;\r\n  subTitleAlias?: string;\r\n  handleAdd?: (params: any) => void;\r\n  handleDelete?: (params: any) => void;\r\n  handleEdit?: (params: any) => void;\r\n}\r\nexport interface ITreePanelProps extends TreeProps {\r\n  store: StoreConfigType<any>;\r\n  checkPropagation?: boolean;\r\n  renderTreeNode?: (props: ITreePanelProps, item: any) => React.ReactElement;\r\n  openKeys?: string[] | null;\r\n}\r\n\r\nclass TreePanel<P> extends Component<\r\n  ITreePanelProps & TreeCommonProps & P,\r\n  any\r\n> {\r\n  state = {\r\n    //搜索文本\r\n    searchText: null,\r\n    fieldOption: {\r\n      keyField: \"key\",\r\n      titleField: \"title\",\r\n      pathsField: \"children\",\r\n    },\r\n    searchColor: null,\r\n\r\n    loading: false,\r\n    treeDatas: [],\r\n    checkedKeys: [],\r\n    expandedKeys: [],\r\n    selectedKeys: [],\r\n    selectNode: null,\r\n  };\r\n\r\n  store = {} as typeof Store;\r\n\r\n  static defaultProps: { store: {} };\r\n\r\n  componentDidUpdate(prevProps) {\r\n    const oldTreeData = prevProps.treeData || [];\r\n    const treeData = this.props.treeData;\r\n    if (\r\n      Array.isArray(treeData) &&\r\n      JSON.stringify(treeData) !== JSON.stringify(oldTreeData)\r\n    ) {\r\n      if (this.store) {\r\n        this.store.setData(treeData);\r\n      }\r\n    }\r\n  }\r\n\r\n  constructor(props) {\r\n    super(props);\r\n    const _this = this;\r\n    const treeData = props.treeData || [];\r\n    const nodeProps = props.nodeProps || {};\r\n    if (props.store instanceof TreeStore) {\r\n      this.store = props.store;\r\n    } else {\r\n      const { listeners: listenersProps = {}, ...restStore } = props.store;\r\n      const storeOption = {\r\n        component: this,\r\n        model: \"treemodel\",\r\n        treePrimaryKey: nodeProps.key || \"id\", // 树节点唯一key\r\n        listeners: {\r\n          onBeforeLoad: function (store, options) {\r\n            let loading = props.lazyload != true;\r\n            _this.setState({ ..._this.state, ...{ loading: loading } });\r\n            utils.callback(listenersProps.onBeforeLoad, this, [store, options]);\r\n          },\r\n          dataChangeBefore: _this.dataChangeBefore,\r\n          dataChanged: function (data, modelData, store) {\r\n            _this.setState({\r\n              treeDatas: modelData,\r\n              checkedKeys: _this._dataToCheckedKeys(modelData),\r\n              loading: false,\r\n            });\r\n            utils.callback(listenersProps.dataChanged, this, [\r\n              data,\r\n              modelData,\r\n              store,\r\n            ]);\r\n          },\r\n          load: (data, modelData, store) => {\r\n            utils.callback(listenersProps.load, this, [data, modelData, store]);\r\n          },\r\n          onErrorLoad: (err, response) => {\r\n            this.setState({ loading: false });\r\n            utils.callback(listenersProps.onErrorLoad, this, [err, response]);\r\n          },\r\n        },\r\n        data: treeData.length > 0 ? treeData : null,\r\n        autoLoad: restStore.autoLoad !== false ? true : false,\r\n        ...restStore,\r\n      };\r\n      this.store = new TreeStore(storeOption);\r\n    }\r\n  }\r\n\r\n  getTitle(data, type = \"titleAlias\") {\r\n    let title = \"\";\r\n    if (this.props[type]) {\r\n      return data[this.props[type]];\r\n    } else {\r\n      title = type == \"titleAlias\" ? data.title : data.subtitle;\r\n    }\r\n    return title;\r\n  }\r\n\r\n  dataChangeBefore = (data) => {\r\n    const originData = cloneDeep(data);\r\n    if (!this.props.titleAlias) {\r\n      return originData;\r\n    }\r\n    if (Array.isArray(originData)) {\r\n      const newData = this._iterator(originData);\r\n      return newData;\r\n    } else if (originData && typeof originData === \"object\") {\r\n      originData.title = this.getTitle(originData);\r\n      originData.subTitle = this.getTitle(originData, \"subTitleAlias\");\r\n      if (originData.children) this._iterator(originData.children);\r\n    }\r\n    return originData;\r\n  };\r\n\r\n  _iterator = (data) => {\r\n    // const titleAlias = this.props.titleAlias;\r\n    // 如果传入的data是dva中model数据是不允许修改的,所以先转换一下\r\n    // const newData = data.map((item) => ({ ...item }));\r\n    data.forEach((item) => {\r\n      item.title = this.getTitle(item);\r\n      item.subtitle = this.getTitle(item, \"subTitleAlias\");\r\n      if (item.children) {\r\n        this._iterator(item.children);\r\n      }\r\n    });\r\n    return data;\r\n  };\r\n\r\n  /**\r\n   * 修改数据\r\n   */\r\n  mapData = () => {};\r\n\r\n  /**\r\n   * 初始化节点选中\r\n   * @param {*} modelData  数据\r\n   */\r\n  _dataToCheckedKeys(modelData) {\r\n    return [];\r\n    // return { checked: [], halfChecked: [] };\r\n  }\r\n\r\n  /**\r\n   * 界面渲染\r\n   */\r\n  renderTemplate(treeProps: ITreePanelProps, newTreeDatas) {\r\n    return <></>;\r\n  }\r\n\r\n  render(): React.ReactNode {\r\n    const { searchText, treeDatas, checkedKeys, fieldOption, searchColor } =\r\n        this.state,\r\n      treeProps = utils.omit(this.props, [\"store\"], {\r\n        checkedKeys: checkedKeys,\r\n      });\r\n    let newTreeDatas = [];\r\n    if (searchText) {\r\n      const data = treeutils.getSearchMenuDatas(\r\n        this,\r\n        searchText,\r\n        fieldOption,\r\n        searchColor\r\n      );\r\n      newTreeDatas = data.treeDatas;\r\n      treeProps.openKeys = data.openKeys;\r\n    } else {\r\n      newTreeDatas = treeDatas;\r\n    }\r\n    return this.renderTemplate(treeProps, newTreeDatas);\r\n  }\r\n\r\n  /**\r\n   * 获取数据对象\r\n   */\r\n  getStore() {\r\n    return this.store;\r\n  }\r\n\r\n  /**\r\n   * 获取数据模型对象\r\n   */\r\n  getModel() {\r\n    return this.store.getModel();\r\n  }\r\n\r\n  /**\r\n   *  刷新界面\r\n   * @param {Object} options 参数\r\n   */\r\n  reload(options) {\r\n    this.store.reload(options);\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * 菜单搜索过滤显示\r\n   * @param {String} val\r\n   */\r\n  handleSearch(val, fieldOption?, searchColor?) {\r\n    this.setState({\r\n      searchText: val,\r\n      fieldOption: fieldOption,\r\n      searchColor: searchColor,\r\n    });\r\n  }\r\n}\r\n\r\nexport default TreePanel;\r\n"]}

package/lib/base/common/withZhLocale.js

@@ -0,0 +1,20 @@
+import "antd/es/config-provider/style/css";
+import _ConfigProvider from "antd/es/config-provider";
+
+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); }
+
+import zhCN from "antd/lib/locale/zh_CN";
+import React from "react";
+
+function withZhLocale(Component) {
+  return /*#__PURE__*/React.forwardRef(function (props, ref) {
+    return /*#__PURE__*/React.createElement(_ConfigProvider, {
+      locale: zhCN
+    }, /*#__PURE__*/React.createElement(Component, _extends({
+      ref: ref
+    }, props)));
+  });
+}
+
+export default withZhLocale;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb21wb25lbnRzL2Jhc2UvY29tbW9uL3dpdGhaaExvY2FsZS50c3giXSwibmFtZXMiOlsiemhDTiIsIlJlYWN0Iiwid2l0aFpoTG9jYWxlIiwiQ29tcG9uZW50IiwiZm9yd2FyZFJlZiIsInByb3BzIiwicmVmIl0sIm1hcHBpbmdzIjoiOzs7OztBQUNBLE9BQU9BLElBQVAsTUFBaUIsdUJBQWpCO0FBQ0EsT0FBT0MsS0FBUCxNQUFrQixPQUFsQjs7QUFFQSxTQUFTQyxZQUFULENBQXlCQyxTQUF6QixFQUE0RDtBQUMxRCxzQkFBT0YsS0FBSyxDQUFDRyxVQUFOLENBQXlCLFVBQUNDLEtBQUQsRUFBUUMsR0FBUixFQUFnQjtBQUM5Qyx3QkFDRTtBQUFnQixNQUFBLE1BQU0sRUFBRU47QUFBeEIsb0JBQ0Usb0JBQUMsU0FBRDtBQUFXLE1BQUEsR0FBRyxFQUFFTTtBQUFoQixPQUF5QkQsS0FBekIsRUFERixDQURGO0FBS0QsR0FOTSxDQUFQO0FBT0Q7O0FBRUQsZUFBZUgsWUFBZiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbmZpZ1Byb3ZpZGVyIH0gZnJvbSBcImFudGRcIjtcclxuaW1wb3J0IHpoQ04gZnJvbSBcImFudGQvbGliL2xvY2FsZS96aF9DTlwiO1xyXG5pbXBvcnQgUmVhY3QgZnJvbSBcInJlYWN0XCI7XHJcblxyXG5mdW5jdGlvbiB3aXRoWmhMb2NhbGU8UD4oQ29tcG9uZW50OiBSZWFjdC5Db21wb25lbnRUeXBlPFA+KSB7XHJcbiAgcmV0dXJuIFJlYWN0LmZvcndhcmRSZWY8UCwgYW55PigocHJvcHMsIHJlZikgPT4ge1xyXG4gICAgcmV0dXJuIChcclxuICAgICAgPENvbmZpZ1Byb3ZpZGVyIGxvY2FsZT17emhDTn0+XHJcbiAgICAgICAgPENvbXBvbmVudCByZWY9e3JlZn0gey4uLnByb3BzfSAvPlxyXG4gICAgICA8L0NvbmZpZ1Byb3ZpZGVyPlxyXG4gICAgKTtcclxuICB9KTtcclxufVxyXG5cclxuZXhwb3J0IGRlZmF1bHQgd2l0aFpoTG9jYWxlO1xyXG4iXX0=

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

@@ -51,4 +51,4 @@ var NscConfigProvider = /*#__PURE__*/function (_React$PureComponent) {
 _defineProperty(NscConfigProvider, "config", _ConfigProvider.config);
 
 export { NscConfigProvider as default };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb21wb25lbnRzL2NvbmZpZ1Byb3ZpZGVyL2luZGV4LnRzeCJdLCJuYW1lcyI6WyJSZWFjdCIsIk5zY0NvbmZpZ1Byb3ZpZGVyIiwicHJvcHMiLCJQdXJlQ29tcG9uZW50IiwiY29uZmlnIl0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxPQUFPLEtBQUtBLEtBQVosTUFBdUIsT0FBdkI7O0lBR3FCQyxpQjs7Ozs7Ozs7Ozs7OztXQUVuQixrQkFBMEI7QUFDeEIsMEJBQU8scUNBQW9CLEtBQUtDLEtBQXpCLENBQVA7QUFDRDs7OztFQUo0Q0YsS0FBSyxDQUFDRyxhOztnQkFBaENGLGlCLFlBQ0gsZ0JBQWVHLE07O1NBRFpILGlCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0ICogYXMgUmVhY3QgZnJvbSBcInJlYWN0XCI7XHJcbmltcG9ydCB7IENvbmZpZ1Byb3ZpZGVyIH0gZnJvbSBcImFudGRcIjtcclxuXHJcbmV4cG9ydCBkZWZhdWx0IGNsYXNzIE5zY0NvbmZpZ1Byb3ZpZGVyIGV4dGVuZHMgUmVhY3QuUHVyZUNvbXBvbmVudDxhbnksIGFueT4ge1xyXG4gIHN0YXRpYyBjb25maWcgPSBDb25maWdQcm92aWRlci5jb25maWc7XHJcbiAgcmVuZGVyKCk6IFJlYWN0LlJlYWN0Tm9kZSB7XHJcbiAgICByZXR1cm4gPENvbmZpZ1Byb3ZpZGVyIHsuLi50aGlzLnByb3BzfSAvPjtcclxuICB9XHJcbn1cclxuIl19
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb21wb25lbnRzL2Jhc2UvY29uZmlnUHJvdmlkZXIvaW5kZXgudHN4Il0sIm5hbWVzIjpbIlJlYWN0IiwiTnNjQ29uZmlnUHJvdmlkZXIiLCJwcm9wcyIsIlB1cmVDb21wb25lbnQiLCJjb25maWciXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLE9BQU8sS0FBS0EsS0FBWixNQUF1QixPQUF2Qjs7SUFHcUJDLGlCOzs7Ozs7Ozs7Ozs7O1dBRW5CLGtCQUEwQjtBQUN4QiwwQkFBTyxxQ0FBb0IsS0FBS0MsS0FBekIsQ0FBUDtBQUNEOzs7O0VBSjRDRixLQUFLLENBQUNHLGE7O2dCQUFoQ0YsaUIsWUFDSCxnQkFBZUcsTTs7U0FEWkgsaUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyBSZWFjdCBmcm9tIFwicmVhY3RcIjtcclxuaW1wb3J0IHsgQ29uZmlnUHJvdmlkZXIgfSBmcm9tIFwiYW50ZFwiO1xyXG5cclxuZXhwb3J0IGRlZmF1bHQgY2xhc3MgTnNjQ29uZmlnUHJvdmlkZXIgZXh0ZW5kcyBSZWFjdC5QdXJlQ29tcG9uZW50PGFueSwgYW55PiB7XHJcbiAgc3RhdGljIGNvbmZpZyA9IENvbmZpZ1Byb3ZpZGVyLmNvbmZpZztcclxuICByZW5kZXIoKTogUmVhY3QuUmVhY3ROb2RlIHtcclxuICAgIHJldHVybiA8Q29uZmlnUHJvdmlkZXIgey4uLnRoaXMucHJvcHN9IC8+O1xyXG4gIH1cclxufVxyXG4iXX0=