@cloud-app-dev/vidc 2.0.0-alpha.1 → 2.0.0-alpha.13

package/es/DeviceSelect/index.js

@@ -1,13 +1,3 @@
-import _IconFont from "@cloud-app-dev/basic-components/es/IconFont";
-import "antd/lib/menu/style";
-import _Menu from "antd/lib/menu";
-import "antd/lib/dropdown/style";
-import _Dropdown from "antd/lib/dropdown";
-import "antd/lib/col/style";
-import _Col from "antd/lib/col";
-import "antd/lib/row/style";
-import _Row from "antd/lib/row";
-
 function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
 
 function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
@@ -29,10 +19,11 @@ function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Sy
 function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 
 import React, { useCallback, useEffect, useMemo, useState } from 'react';
-import TreeMode from '../TreeMode';
-import DynamicDeviceList from '../DynamicDeviceList';
-import DeviceList from '../DeviceList';
-import { uniq, uniqBy } from 'lodash';
+import TreeMode from '../Tree';
+import DynamicDeviceList from '../List/DynamicDeviceList';
+import DeviceList from '../List/DeviceList';
+import { uniq, uniqBy } from 'lodash-es';
+import TreeType from './TreeType';
 import "./index.css";
 
 function DeviceSelect(_ref) {
@@ -162,61 +153,39 @@ function DeviceSelect(_ref) {
   var treeSelectedKeys = useMemo(function () {
     return state.mode === 'Bz' ? [state.buzGroupId] : [state.areaCode];
   }, [state.mode, state.buzGroupId, state.areaCode]);
-  return /*#__PURE__*/React.createElement(_Row, {
+  return /*#__PURE__*/React.createElement("div", {
     className: "vidc-device-select-layout"
-  }, /*#__PURE__*/React.createElement(_Col, {
-    span: 7
   }, /*#__PURE__*/React.createElement(TreeMode, {
-    key: state.mode,
     mode: state.mode,
     inputPlaceholder: "\u8BF7\u8F93\u5165\u540D\u79F0",
     onSelect: onSelectTree,
     selectedKeys: treeSelectedKeys,
-    title: /*#__PURE__*/React.createElement(_Dropdown, {
-      overlay: /*#__PURE__*/React.createElement(_Menu, {
-        onClick: function onClick(info) {
-          return setState(function (old) {
-            return Object.assign(Object.assign({}, old), {
-              mode: info.key
-            });
+    title: /*#__PURE__*/React.createElement(TreeType, {
+      mode: state.mode,
+      onChange: function onChange(mode) {
+        return setState(function (old) {
+          return Object.assign(Object.assign({}, old), {
+            mode: mode
           });
-        }
-      }, /*#__PURE__*/React.createElement(_Menu.Item, {
-        style: {
-          fontSize: 12
-        },
-        key: "Bz"
-      }, "\u8BBE\u5907\u4E1A\u52A1\u6811"), /*#__PURE__*/React.createElement(_Menu.Item, {
-        style: {
-          fontSize: 12
-        },
-        key: "Place"
-      }, "\u884C\u653F\u533A\u5212"))
-    }, /*#__PURE__*/React.createElement("span", null, state.mode === 'Place' ? '行政区划' : '设备业务树', " ", /*#__PURE__*/React.createElement(_IconFont, {
-      style: {
-        position: 'relative',
-        top: 1
-      },
-      type: "icon-S_Arrow_BigDown"
-    })))
-  })), /*#__PURE__*/React.createElement(_Col, {
-    span: 8
-  }, /*#__PURE__*/React.createElement(DynamicDeviceList, {
+        });
+      }
+    })
+  }), /*#__PURE__*/React.createElement(DynamicDeviceList, {
     title: "\u8BBE\u5907\u5217\u8868",
     onChecked: onCheked1,
+    key: state.mode,
     checkedKeys: state.tempSelectIds,
     params: listParams
-  })), /*#__PURE__*/React.createElement(_Col, {
-    span: 1
-  }), /*#__PURE__*/React.createElement(_Col, {
-    span: 8
-  }, /*#__PURE__*/React.createElement(DeviceList, {
+  }), /*#__PURE__*/React.createElement(DeviceList, {
     itemKey: "cid",
     deviceList: state.selectDevices || [],
     onChecked: onCheked2,
     checkedKeys: state.selectIds,
     title: "\u5DF2\u9009\u8BBE\u5907\u5217\u8868"
-  })));
+  }));
 }
 
+DeviceSelect.defaultProps = {
+  className: ''
+};
 export default DeviceSelect;

package/es/Dict/cache.d.ts

@@ -0,0 +1,3 @@
+import { CacheDictType } from './interface';
+declare const LMDict: CacheDictType;
+export default LMDict;

package/es/Dict/cache.js

@@ -0,0 +1,21 @@
+import produce from 'immer';
+var dictMap = {
+  data: produce({}, function () {}),
+  updateDictMap: function updateDictMap(key, value) {
+    this.data = produce(this.data, function (draft) {
+      draft[key] = value;
+    });
+  }
+};
+var _global = window;
+
+var LMDict = function () {
+  if (_global._LM_DICT_) {
+    return _global._LM_DICT_;
+  } else {
+    _global._LM_DICT_ = dictMap;
+    return dictMap;
+  }
+}();
+
+export default LMDict;

package/es/Dict/desc.d.ts

@@ -0,0 +1,64 @@
+import React from 'react';
+import { DictItem } from './interface';
+export declare function withDict(codes?: any[], isWebVisible?: boolean): (Component: any) => (props: any) => JSX.Element;
+export declare function withTypeCodes(Component: any): {
+    new (props: any): {
+        componentDidMount(): void;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends "typeCodes" | "isInit">(state: {
+            typeCodes: DictItem[];
+            isInit: boolean;
+        } | ((prevState: Readonly<{
+            typeCodes: DictItem[];
+            isInit: boolean;
+        }>, props: Readonly<any>) => {
+            typeCodes: DictItem[];
+            isInit: boolean;
+        } | Pick<{
+            typeCodes: DictItem[];
+            isInit: boolean;
+        }, K>) | Pick<{
+            typeCodes: DictItem[];
+            isInit: boolean;
+        }, K>, callback?: () => void): void;
+        forceUpdate(callback?: () => void): void;
+        readonly props: Readonly<any> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        state: Readonly<{
+            typeCodes: DictItem[];
+            isInit: boolean;
+        }>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        shouldComponentUpdate?(nextProps: Readonly<any>, nextState: Readonly<{
+            typeCodes: DictItem[];
+            isInit: boolean;
+        }>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<any>, prevState: Readonly<{
+            typeCodes: DictItem[];
+            isInit: boolean;
+        }>): any;
+        componentDidUpdate?(prevProps: Readonly<any>, prevState: Readonly<{
+            typeCodes: DictItem[];
+            isInit: boolean;
+        }>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<any>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<any>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<any>, nextState: Readonly<{
+            typeCodes: DictItem[];
+            isInit: boolean;
+        }>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<any>, nextState: Readonly<{
+            typeCodes: DictItem[];
+            isInit: boolean;
+        }>, nextContext: any): void;
+    };
+    contextType?: React.Context<any>;
+};

package/es/Dict/desc.js

@@ -0,0 +1,162 @@
+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; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } 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 _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+import React, { useRef, useState, useEffect } from 'react';
+import { queryByTypeCodes, queryTypeCodes, formartItemTextExt } from './utils';
+import LMDict from './cache';
+export function withDict() {
+  var codes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var isWebVisible = arguments.length > 1 ? arguments[1] : undefined;
+  return function (Component) {
+    return function (props) {
+      var isInitRef = useRef(false);
+
+      var _useState = useState(function () {
+        var map = {};
+        codes.forEach(function (code) {
+          if (LMDict.data[code]) {
+            map[code] = LMDict.data[code];
+          } else {
+            map[code] = [];
+          }
+        });
+        return map;
+      }),
+          _useState2 = _slicedToArray(_useState, 2),
+          dictMap = _useState2[0],
+          setDictMap = _useState2[1];
+
+      useEffect(function () {
+        var nocacheCodes = codes.filter(function (v) {
+          return !LMDict.data[v];
+        });
+
+        if (nocacheCodes.length === 0) {
+          isInitRef.current = true;
+          setDictMap(function (old) {
+            return Object.assign({}, old);
+          });
+          return;
+        }
+
+        queryByTypeCodes(nocacheCodes, isWebVisible).then(function (res) {
+          isInitRef.current = true;
+          var data = res.data;
+          data.forEach(function (item) {
+            item.label = item.name;
+            item.value = item.code;
+            item = Object.assign(Object.assign({}, item), formartItemTextExt(item.extText));
+          });
+          setDictMap(function (old) {
+            nocacheCodes.forEach(function (code) {
+              var itemCodes = data.filter(function (v1) {
+                return +v1.typeCode === +code;
+              });
+              old[code] = itemCodes;
+              LMDict.updateDictMap(code, itemCodes);
+            });
+            return Object.assign({}, old);
+          });
+        });
+      }, []);
+
+      if (!isInitRef.current) {
+        return null;
+      }
+
+      return /*#__PURE__*/React.createElement(Component, Object.assign({}, props, {
+        dictMap: dictMap
+      }));
+    };
+  };
+}
+export function withTypeCodes(Component) {
+  return /*#__PURE__*/function (_React$Component) {
+    _inherits(withTypeCodesComponent, _React$Component);
+
+    var _super = _createSuper(withTypeCodesComponent);
+
+    function withTypeCodesComponent(props) {
+      var _this;
+
+      _classCallCheck(this, withTypeCodesComponent);
+
+      _this = _super.call(this, props);
+      _this.state = {
+        typeCodes: LMDict.data['typeCodes'] || [],
+        isInit: false
+      };
+      return _this;
+    }
+
+    _createClass(withTypeCodesComponent, [{
+      key: "componentDidMount",
+      value: function componentDidMount() {
+        var _this2 = this;
+
+        if (!LMDict.data['typeCodes']) {
+          queryTypeCodes().then(function (res) {
+            LMDict.updateDictMap('typeCodes', res);
+
+            _this2.setState({
+              typeCodes: res,
+              isInit: true
+            });
+          }).catch(function () {
+            _this2.setState({
+              typeCodes: [],
+              isInit: true
+            });
+          });
+        } else this.setState({
+          typeCodes: LMDict.data['typeCodes'],
+          isInit: true
+        });
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        if (!this.state.isInit) {
+          return null;
+        }
+
+        return /*#__PURE__*/React.createElement(Component, Object.assign({}, this.props, {
+          typeCodes: this.state.typeCodes
+        }));
+      }
+    }]);
+
+    return withTypeCodesComponent;
+  }(React.Component);
+}

package/es/Dict/device.d.ts

@@ -0,0 +1,28 @@
+import { DictItem } from './interface';
+export declare const ptjk: DictItem;
+export declare const rlzp: DictItem;
+export declare const zpj: DictItem;
+export declare const clzpj: DictItem;
+export declare const qmbzpj: DictItem;
+export declare const ydjc: DictItem;
+export declare const qtzp: DictItem;
+export declare const znxj: DictItem;
+export declare const qj: DictItem;
+export declare const db: DictItem;
+export declare const qt: DictItem;
+export declare const dz: DictItem;
+export declare const wgsb: DictItem;
+export declare const xfs: DictItem;
+export declare const znjg: DictItem;
+export declare const wifi: DictItem;
+export declare const mj: DictItem;
+export declare const hw: DictItem;
+export declare const yg: DictItem;
+export declare const deviceStatus: DictItem[];
+export declare const deviceLocation: DictItem[];
+export declare const deviceLocationzWithoutAll: DictItem[];
+export declare const cameraType: DictItem[];
+export declare const cameraDeviceType: DictItem[];
+export declare const cameraAndSoldierType: DictItem[];
+export declare const deviceAndMjType: DictItem[];
+export declare const deviceType: DictItem[];

package/es/Dict/device.js

@@ -0,0 +1,117 @@
+var all = {
+  value: '-1',
+  label: '全部'
+}; //摄像机状态
+
+var on = {
+  value: '1',
+  label: '在线'
+};
+var off = {
+  value: '0',
+  label: '离线'
+}; //经纬度状态
+
+var noSet = {
+  value: '0',
+  label: '未设置'
+};
+var isSet = {
+  value: '1',
+  label: '已设置'
+}; //摄像机类别
+
+export var ptjk = {
+  value: '119651',
+  label: '普通监控'
+};
+export var rlzp = {
+  value: '119652',
+  label: '人脸抓拍机'
+};
+export var zpj = {
+  value: '119653',
+  label: '人像抓拍机'
+};
+export var clzpj = {
+  value: '119654',
+  label: '车辆抓拍机'
+};
+export var qmbzpj = {
+  value: '119655',
+  label: '全目标抓拍机'
+};
+export var ydjc = {
+  value: '119656',
+  label: '移动监测'
+};
+export var qtzp = {
+  value: '119657',
+  label: '其他'
+}; //设备类型
+
+export var znxj = {
+  value: '100604',
+  label: '智能枪机'
+};
+export var qj = {
+  value: '100602',
+  label: '球机'
+};
+export var db = {
+  value: '100605',
+  label: '单兵'
+};
+export var qt = {
+  value: '100601',
+  label: '其他摄像机'
+};
+export var dz = {
+  value: '100607',
+  label: '道闸'
+};
+export var wgsb = {
+  value: '100606',
+  label: '网关设备'
+};
+export var xfs = {
+  value: '100612',
+  label: '消防栓'
+};
+export var znjg = {
+  value: '100614',
+  label: '智能井盖'
+}; //wifi
+
+export var wifi = {
+  value: '100611',
+  label: 'WI-FI'
+}; //门禁
+
+export var mj = {
+  value: '103501,103502',
+  label: '门禁'
+}; //闸机
+// export const zj = {value: "103407", label: "闸机"}as DictItem
+//红外传感器
+
+export var hw = {
+  value: '100609',
+  label: '红外传感器'
+}; //烟感传感器
+
+export var yg = {
+  value: '100610',
+  label: '烟感传感器'
+};
+export var deviceStatus = [all, on, off];
+export var deviceLocation = [all, noSet, isSet];
+export var deviceLocationzWithoutAll = [noSet, isSet];
+export var cameraType = [all, ptjk, rlzp, zpj, clzpj, qmbzpj, ydjc, qtzp];
+export var cameraDeviceType = [all, znxj, qj, db, qt]; //摄像机+单兵
+
+export var cameraAndSoldierType = [all, znxj, qj, db, qt]; //摄像机（无单兵）+门禁
+
+export var deviceAndMjType = [all, znxj, qj, wifi, mj, wgsb, dz, xfs, znjg, qt]; //所有设备类型
+
+export var deviceType = [all, znxj, qj, db, wifi, mj, wgsb, dz, xfs, znjg, qt, hw, yg];

package/es/Dict/hook.d.ts

@@ -0,0 +1,4 @@
+import { DictItem } from './interface';
+export declare function useDict(typeCode: string | number): DictItem[];
+export declare function useTypeCodes(): DictItem[];
+export declare function useDicts(typeCodes?: any[], isWebVisible?: boolean): DictItem[][];

package/es/Dict/hook.js

@@ -0,0 +1,114 @@
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+import { useMemo, useState, useEffect } from 'react';
+import { queryByTypeCode, queryByTypeCodes, queryTypeCodes, formartItemTextExt } from './utils';
+import LMDict from './cache';
+export function useDict(typeCode) {
+  var _useState = useState(LMDict.data[typeCode] || []),
+      _useState2 = _slicedToArray(_useState, 2),
+      codes = _useState2[0],
+      setCodes = _useState2[1];
+
+  useEffect(function () {
+    if (typeCode && !LMDict.data[typeCode]) {
+      queryByTypeCode(typeCode).then(function (res) {
+        var data = res.data || [];
+        data.forEach(function (item) {
+          item.label = item.name;
+          item.value = item.code;
+          item = Object.assign(Object.assign({}, item), formartItemTextExt(item.extText));
+        });
+        LMDict.updateDictMap(typeCode, data);
+        setCodes(data);
+      });
+    } else {
+      setCodes(function (old) {
+        return old.length > 0 ? old : LMDict.data[typeCode] || [];
+      });
+    }
+  }, [typeCode]);
+  return codes;
+}
+export function useTypeCodes() {
+  var _useState3 = useState(LMDict.data['typeCodes'] || []),
+      _useState4 = _slicedToArray(_useState3, 2),
+      typeCodes = _useState4[0],
+      setTypeCodes = _useState4[1];
+
+  useEffect(function () {
+    if (!LMDict.data['typeCodes']) {
+      queryTypeCodes().then(function (res) {
+        setTypeCodes(res);
+        LMDict.updateDictMap('typeCode', res);
+      });
+    }
+  }, []);
+  return typeCodes;
+}
+export function useDicts() {
+  var typeCodes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var isWebVisible = arguments.length > 1 ? arguments[1] : undefined;
+  var typeStr = useMemo(function () {
+    return typeCodes.toString();
+  }, [typeCodes]);
+
+  var _useState5 = useState(function () {
+    return typeCodes.map(function (v) {
+      return LMDict.data[v] ? LMDict.data[v] : [];
+    });
+  }),
+      _useState6 = _slicedToArray(_useState5, 2),
+      dicts = _useState6[0],
+      setDicts = _useState6[1];
+
+  useEffect(function () {
+    var codes = typeCodes.filter(function (v) {
+      return !LMDict.data[v];
+    });
+
+    if (codes.length === 0) {
+      return;
+    }
+
+    queryByTypeCodes(codes, isWebVisible).then(function (res) {
+      var data = res.data;
+      data.forEach(function (item) {
+        item.label = item.name;
+        item.value = item.code;
+        item = Object.assign(Object.assign({}, item), formartItemTextExt(item.extText));
+      });
+      setDicts(function (old) {
+        codes.forEach(function (code) {
+          var itemCodes = data.filter(function (v1) {
+            return +v1.typeCode === +code;
+          });
+          var index = typeCodes.findIndex(function (v) {
+            return v === code;
+          });
+          old[index] = itemCodes;
+          LMDict.updateDictMap(code, itemCodes);
+        });
+        return _toConsumableArray(old);
+      });
+    }); // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [typeStr]);
+  return dicts;
+}

package/es/Dict/index.d.ts

@@ -0,0 +1,13 @@
+import * as device from './device';
+import { useDict, useDicts, useTypeCodes } from './hook';
+import { withDict, withTypeCodes } from './desc';
+declare const Dict: {
+    useDict: typeof useDict;
+    useDicts: typeof useDicts;
+    device: typeof device;
+    cacheMap: import("./interface").CacheDictType;
+    withDict: typeof withDict;
+    useTypeCodes: typeof useTypeCodes;
+    withTypeCodes: typeof withTypeCodes;
+};
+export default Dict;

package/es/Dict/index.js

@@ -0,0 +1,14 @@
+import LMDict from './cache';
+import * as device from './device';
+import { useDict, useDicts, useTypeCodes } from './hook';
+import { withDict, withTypeCodes } from './desc';
+var Dict = {
+  useDict: useDict,
+  useDicts: useDicts,
+  device: device,
+  cacheMap: LMDict,
+  withDict: withDict,
+  useTypeCodes: useTypeCodes,
+  withTypeCodes: withTypeCodes
+};
+export default Dict;

package/es/Dict/interface.d.ts

@@ -0,0 +1,16 @@
+export interface DictItem {
+  label: string;
+  code: string;
+  id: string;
+  value: any;
+  name: string;
+  extText?: string;
+  typeCode?: string;
+  disabled?: boolean;
+  icon?: string;
+}
+
+export interface CacheDictType {
+  data: { [key: string]: DictItem[] };
+  updateDictMap: (key: any, valuse: DictItem[]) => void;
+}