@cloud-app-dev/vidc 1.0.49 → 2.0.0-alpha.2

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;
+}

package/es/Dict/utils.d.ts

@@ -0,0 +1,11 @@
+import { DictItem } from './interface';
+export declare function queryByTypeCode(typeCode: any): Promise<{
+    data: DictItem[];
+}>;
+export declare function queryByTypeCodes(typeCodes?: any[], isWebVisible?: boolean): Promise<{
+    data: DictItem[];
+}>;
+export declare function queryTypeCodes(): Promise<DictItem[]>;
+export declare function formartItemTextExt(text: string): {
+    [key: string]: any;
+};

package/es/Dict/utils.js

@@ -0,0 +1,51 @@
+import _cache from "@cloud-app-dev/utils/es/cache";
+import Service from '../Service';
+export function queryByTypeCode(typeCode) {
+  var headers = {
+    Authorization: _cache.getCache('token', 'session')
+  };
+  return Service.$http({
+    url: "/api/dictionary/v1/queryByTypeCode/".concat(typeCode),
+    method: 'get',
+    requestId: 'queryByTypeCode',
+    headers: headers,
+    data: {}
+  });
+}
+export function queryByTypeCodes() {
+  var typeCodes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var isWebVisible = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  var headers = {
+    Authorization: _cache.getCache('token', 'session')
+  };
+  return Service.$http({
+    url: "/api/dictionary/v1/queryDictionaryListByCondition",
+    method: 'post',
+    requestId: 'queryByTypeCode',
+    headers: headers,
+    data: {
+      isWebVisible: isWebVisible,
+      typeCodeList: typeCodes
+    }
+  });
+}
+export function queryTypeCodes() {
+  return Service.$http({
+    url: "/micro-apps/micro-dep-librarys/config/typeCodes.json",
+    method: 'get',
+    requestId: 'queryTypeCodes'
+  });
+}
+export function formartItemTextExt(text) {
+  var ext = {};
+
+  if (!text) {
+    return ext;
+  }
+
+  try {
+    ext = JSON.stringify(text);
+  } catch (e) {}
+
+  return ext;
+}

package/es/Drag/DragAndDropItem.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { IDragAndDropItemProps } from './interface';
+declare function DragAndDropItem<T>({ children, dragData, dragId, style, onDropEnd, disabledCopyElement }: IDragAndDropItemProps<T>): React.FunctionComponentElement<any>;
+export default DragAndDropItem;