@cloud-app-dev/vidc 2.3.0 → 3.0.0

package/es/{List/DynamicDeviceList → Map/Config}/utils.js

@@ -3,63 +3,66 @@ function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" =
 function _regeneratorRuntime() { "use strict"; /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */ _regeneratorRuntime = function _regeneratorRuntime() { return exports; }; var exports = {}, Op = Object.prototype, hasOwn = Op.hasOwnProperty, $Symbol = "function" == typeof Symbol ? Symbol : {}, iteratorSymbol = $Symbol.iterator || "@@iterator", asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator", toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag"; function define(obj, key, value) { return Object.defineProperty(obj, key, { value: value, enumerable: !0, configurable: !0, writable: !0 }), obj[key]; } try { define({}, ""); } catch (err) { define = function define(obj, key, value) { return obj[key] = value; }; } function wrap(innerFn, outerFn, self, tryLocsList) { var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator, generator = Object.create(protoGenerator.prototype), context = new Context(tryLocsList || []); return generator._invoke = function (innerFn, self, context) { var state = "suspendedStart"; return function (method, arg) { if ("executing" === state) throw new Error("Generator is already running"); if ("completed" === state) { if ("throw" === method) throw arg; return doneResult(); } for (context.method = method, context.arg = arg;;) { var delegate = context.delegate; if (delegate) { var delegateResult = maybeInvokeDelegate(delegate, context); if (delegateResult) { if (delegateResult === ContinueSentinel) continue; return delegateResult; } } if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) { if ("suspendedStart" === state) throw state = "completed", context.arg; context.dispatchException(context.arg); } else "return" === context.method && context.abrupt("return", context.arg); state = "executing"; var record = tryCatch(innerFn, self, context); if ("normal" === record.type) { if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue; return { value: record.arg, done: context.done }; } "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg); } }; }(innerFn, self, context), generator; } function tryCatch(fn, obj, arg) { try { return { type: "normal", arg: fn.call(obj, arg) }; } catch (err) { return { type: "throw", arg: err }; } } exports.wrap = wrap; var ContinueSentinel = {}; function Generator() {} function GeneratorFunction() {} function GeneratorFunctionPrototype() {} var IteratorPrototype = {}; define(IteratorPrototype, iteratorSymbol, function () { return this; }); var getProto = Object.getPrototypeOf, NativeIteratorPrototype = getProto && getProto(getProto(values([]))); NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype); var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype); function defineIteratorMethods(prototype) { ["next", "throw", "return"].forEach(function (method) { define(prototype, method, function (arg) { return this._invoke(method, arg); }); }); } function AsyncIterator(generator, PromiseImpl) { function invoke(method, arg, resolve, reject) { var record = tryCatch(generator[method], generator, arg); if ("throw" !== record.type) { var result = record.arg, value = result.value; return value && "object" == _typeof(value) && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) { invoke("next", value, resolve, reject); }, function (err) { invoke("throw", err, resolve, reject); }) : PromiseImpl.resolve(value).then(function (unwrapped) { result.value = unwrapped, resolve(result); }, function (error) { return invoke("throw", error, resolve, reject); }); } reject(record.arg); } var previousPromise; this._invoke = function (method, arg) { function callInvokeWithMethodAndArg() { return new PromiseImpl(function (resolve, reject) { invoke(method, arg, resolve, reject); }); } return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg(); }; } function maybeInvokeDelegate(delegate, context) { var method = delegate.iterator[context.method]; if (undefined === method) { if (context.delegate = null, "throw" === context.method) { if (delegate.iterator.return && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method)) return ContinueSentinel; context.method = "throw", context.arg = new TypeError("The iterator does not provide a 'throw' method"); } return ContinueSentinel; } var record = tryCatch(method, delegate.iterator, context.arg); if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel; var info = record.arg; return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel); } function pushTryEntry(locs) { var entry = { tryLoc: locs[0] }; 1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry); } function resetTryEntry(entry) { var record = entry.completion || {}; record.type = "normal", delete record.arg, entry.completion = record; } function Context(tryLocsList) { this.tryEntries = [{ tryLoc: "root" }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0); } function values(iterable) { if (iterable) { var iteratorMethod = iterable[iteratorSymbol]; if (iteratorMethod) return iteratorMethod.call(iterable); if ("function" == typeof iterable.next) return iterable; if (!isNaN(iterable.length)) { var i = -1, next = function next() { for (; ++i < iterable.length;) { if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next; } return next.value = undefined, next.done = !0, next; }; return next.next = next; } } return { next: doneResult }; } function doneResult() { return { value: undefined, done: !0 }; } return GeneratorFunction.prototype = GeneratorFunctionPrototype, define(Gp, "constructor", GeneratorFunctionPrototype), define(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) { var ctor = "function" == typeof genFun && genFun.constructor; return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name)); }, exports.mark = function (genFun) { return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun; }, exports.awrap = function (arg) { return { __await: arg }; }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () { return this; }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) { void 0 === PromiseImpl && (PromiseImpl = Promise); var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl); return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) { return result.done ? result.value : iter.next(); }); }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () { return this; }), define(Gp, "toString", function () { return "[object Generator]"; }), exports.keys = function (object) { var keys = []; for (var key in object) { keys.push(key); } return keys.reverse(), function next() { for (; keys.length;) { var key = keys.pop(); if (key in object) return next.value = key, next.done = !1, next; } return next.done = !0, next; }; }, exports.values = values, Context.prototype = { constructor: Context, reset: function reset(skipTempReset) { if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) { "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined); } }, stop: function stop() { this.done = !0; var rootRecord = this.tryEntries[0].completion; if ("throw" === rootRecord.type) throw rootRecord.arg; return this.rval; }, dispatchException: function dispatchException(exception) { if (this.done) throw exception; var context = this; function handle(loc, caught) { return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught; } for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i], record = entry.completion; if ("root" === entry.tryLoc) return handle("end"); if (entry.tryLoc <= this.prev) { var hasCatch = hasOwn.call(entry, "catchLoc"), hasFinally = hasOwn.call(entry, "finallyLoc"); if (hasCatch && hasFinally) { if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0); if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc); } else if (hasCatch) { if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0); } else { if (!hasFinally) throw new Error("try statement without catch or finally"); if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc); } } } }, abrupt: function abrupt(type, arg) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) { var finallyEntry = entry; break; } } finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null); var record = finallyEntry ? finallyEntry.completion : {}; return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record); }, complete: function complete(record, afterLoc) { if ("throw" === record.type) throw record.arg; return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel; }, finish: function finish(finallyLoc) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel; } }, catch: function _catch(tryLoc) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.tryLoc === tryLoc) { var record = entry.completion; if ("throw" === record.type) { var thrown = record.arg; resetTryEntry(entry); } return thrown; } } throw new Error("illegal catch attempt"); }, delegateYield: function delegateYield(iterable, resultName, nextLoc) { return this.delegate = { iterator: values(iterable), resultName: resultName, nextLoc: nextLoc }, "next" === this.method && (this.arg = undefined), ContinueSentinel; } }, exports; }
 
 import { __awaiter } from "tslib";
-import Service from '../../Service';
-import { getHeader } from '../../utils';
-export function queryDeviceList() {
-  var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  return Service.http({
-    method: 'post',
-    url: '/api/udm-api/device/queryList',
-    requestId: 'queryDeviceList',
-    headers: getHeader(),
-    data: Object.assign(Object.assign({}, params), {
-      includeSubOrganizations: 1,
-      isPagination: true
-    })
-  });
-}
-export var LIMIT = 30;
-/**
- * @desc 懒加载方法
- */
-
-export var loadNextPage = function loadNextPage(d, defaultLimit) {
-  var params = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+var localconfig = {
+  url: 'http://webrd0{s}.is.autonavi.com/appmaptile?lang=zh_cn&size=1&scale=1&style=8&x={x}&y={y}&z={z}',
+  subdomains: ['1', '2', '3', '4'],
+  crs: 'EPSG3857',
+  center: [118.767413, 32.041544],
+  maxZoom: 18,
+  minZoom: 3,
+  zoom: 8,
+  zoomOffset: 0,
+  distance: 50,
+  amapStyle: 'normal',
+  maxBounds: [[66.749529, 3.31743], [138.55617, 56.353861]]
+};
+export function queryMapConfig(type) {
   return __awaiter(this, void 0, void 0, /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
-    var _ref, offset, limit, pageLimit, pageOffset, res;
-
+    var url, crs, maxBounds, subdomains, zoom, zoomOffset, center, maxZoom, minZoom, distance, amapStyle;
     return _regeneratorRuntime().wrap(function _callee$(_context) {
       while (1) {
         switch (_context.prev = _context.next) {
           case 0:
-            _ref = d || {}, offset = _ref.offset, limit = _ref.limit;
-            pageLimit = typeof limit === 'number' ? limit : defaultLimit || LIMIT;
-            pageOffset = typeof offset === 'number' ? offset + pageLimit : 0;
-            _context.next = 5;
-            return queryDeviceList(Object.assign({
-              offset: pageOffset,
-              limit: pageLimit
-            }, params));
+            url = localconfig.url, crs = localconfig.crs, maxBounds = localconfig.maxBounds, subdomains = localconfig.subdomains, zoom = localconfig.zoom, zoomOffset = localconfig.zoomOffset, center = localconfig.center, maxZoom = localconfig.maxZoom, minZoom = localconfig.minZoom, distance = localconfig.distance, amapStyle = localconfig.amapStyle;
+
+            if (!(type == 'L')) {
+              _context.next = 3;
+              break;
+            }
 
-          case 5:
-            res = _context.sent;
             return _context.abrupt("return", {
-              list: res.data || [],
-              count: res.totalCount,
-              offset: pageOffset,
-              limit: pageLimit
+              url: url,
+              crs: crs,
+              subdomains: subdomains,
+              maxBounds: maxBounds.map(function (v) {
+                return v.reverse();
+              }),
+              zoom: zoom,
+              zoomOffset: zoomOffset,
+              center: center.reverse(),
+              maxZoom: maxZoom,
+              minZoom: minZoom,
+              distance: distance
             });
 
-          case 7:
+          case 3:
+            return _context.abrupt("return", {
+              crs: crs,
+              center: center,
+              maxZoom: maxZoom,
+              minZoom: minZoom,
+              zoom: zoom,
+              zoomOffset: zoomOffset,
+              distance: distance,
+              maxBounds: maxBounds,
+              amapStyle: amapStyle
+            });
+
+          case 4:
           case "end":
             return _context.stop();
         }
       }
     }, _callee);
   }));
-};
-export var skeletonList = Array.from(new Array(LIMIT)).map(function () {
-  return {
-    skeleton: true
-  };
-});
+}

package/es/Map/Context/index.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { IMapInstance } from '../interface';
+export interface IContenxtProps {
+    instance: IMapInstance;
+    glaobalKey: 'L' | 'AMap';
+}
+export declare const mapContext: React.Context<IContenxtProps>;
+export declare const Provider: React.Provider<IContenxtProps>;
+export declare const Consumer: React.Consumer<IContenxtProps>;
+declare function map(Component: new () => React.Component<any>): React.ForwardRefExoticComponent<React.RefAttributes<unknown>>;
+export default map;

package/es/Map/Context/index.js

@@ -0,0 +1,66 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _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); Object.defineProperty(Constructor, "prototype", { writable: false }); 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 } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : 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.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+import { __rest } from "tslib";
+import React from 'react';
+export var mapContext = /*#__PURE__*/React.createContext(null);
+export var Provider = mapContext.Provider;
+export var Consumer = mapContext.Consumer;
+
+function map(Component) {
+  var MapWithComponent = /*#__PURE__*/function (_React$Component) {
+    _inherits(MapWithComponent, _React$Component);
+
+    var _super = _createSuper(MapWithComponent);
+
+    function MapWithComponent() {
+      _classCallCheck(this, MapWithComponent);
+
+      return _super.apply(this, arguments);
+    }
+
+    _createClass(MapWithComponent, [{
+      key: "render",
+      value: function render() {
+        var _a = this.props,
+            forwardRef = _a.forwardRef,
+            props = __rest(_a, ["forwardRef"]);
+
+        return /*#__PURE__*/React.createElement(Consumer, null, function (context) {
+          return /*#__PURE__*/React.createElement(Component, Object.assign({}, props, context, {
+            ref: forwardRef
+          }));
+        });
+      }
+    }]);
+
+    return MapWithComponent;
+  }(React.Component);
+
+  return /*#__PURE__*/React.forwardRef(function (props, ref) {
+    return /*#__PURE__*/React.createElement(MapWithComponent, Object.assign({}, props, {
+      forwardRef: ref
+    }));
+  });
+}
+
+export default map;

package/es/Map/FindPio/index.css

@@ -0,0 +1,7 @@
+.map-find-pio {
+  position: absolute;
+  width: 240px;
+  left: 20px;
+  top: 20px;
+  z-index: 2;
+}

package/es/Map/FindPio/index.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import './index.less';
+declare function FindPio(): JSX.Element;
+export default FindPio;

package/es/Map/FindPio/index.js

@@ -0,0 +1,16 @@
+import "antd/lib/select/style";
+import _Select from "antd/lib/select";
+import React from 'react';
+import "./index.css";
+
+function FindPio() {
+  return /*#__PURE__*/React.createElement(_Select, {
+    className: "map-find-pio",
+    labelInValue: true,
+    notFoundContent: null,
+    filterOption: false,
+    placeholder: "\u8BF7\u8F93\u5165\u5173\u952E\u5B57"
+  });
+}
+
+export default FindPio;

package/es/{List/DynamicDeviceList/Demo.js → Map/InfoWindow/demo.js}

@@ -1,6 +1,3 @@
-import "antd/lib/config-provider/style";
-import _ConfigProvider from "antd/lib/config-provider";
-
 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."); }
@@ -14,41 +11,46 @@ function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Sy
 function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 
 import React, { useState } from 'react';
-import DynamicDeviceList from './index';
+import Map from '../BasicMap';
+import ClusterLayer from '../ClusterLayer';
+import InfoWindow from '.';
+import deviceList from '../points.json';
+import Player from '../../Player';
 
-function App() {
+var App = function App() {
   var _useState = useState({
-    keyword: ''
+    visible: false,
+    center: undefined
   }),
       _useState2 = _slicedToArray(_useState, 2),
       state = _useState2[0],
       setState = _useState2[1];
 
-  return /*#__PURE__*/React.createElement(_ConfigProvider, {
-    prefixCls: "cloudapp"
-  }, /*#__PURE__*/React.createElement("div", {
-    style: {
-      display: 'flex'
-    }
-  }, /*#__PURE__*/React.createElement("div", {
+  return /*#__PURE__*/React.createElement("div", {
     style: {
-      height: 400,
-      width: 300
+      width: '100%',
+      height: 800
     }
-  }, /*#__PURE__*/React.createElement(DynamicDeviceList, {
-    onChecked: console.log,
-    params: {
-      keywords: state.keyword
-    },
-    title: "\u5217\u8868",
-    onKeywordChange: function onKeywordChange(e) {
+  }, /*#__PURE__*/React.createElement(Map, null, /*#__PURE__*/React.createElement(ClusterLayer, {
+    points: deviceList,
+    onPointClick: function onPointClick(point) {
       return setState(function (old) {
         return Object.assign(Object.assign({}, old), {
-          keyword: e
+          visible: true,
+          center: [point.longitude, point.latitude]
         });
       });
     }
-  }))));
-}
+  }), /*#__PURE__*/React.createElement(InfoWindow, {
+    visible: state.visible,
+    center: state.center
+  }, /*#__PURE__*/React.createElement("div", {
+    style: {
+      width: 560,
+      height: 360,
+      background: '#fff'
+    }
+  }, /*#__PURE__*/React.createElement(Player, null)))));
+};
 
 export default App;

package/es/Map/InfoWindow/index.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+interface InfoWindowProps {
+    children: React.ReactNode;
+    visible?: boolean;
+    center?: [number, number];
+}
+export default function InfoWindow({ children, visible, center }: InfoWindowProps): JSX.Element;
+export {};

package/es/Map/InfoWindow/index.js

@@ -0,0 +1,74 @@
+function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct.bind(); } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
+
+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 _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+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 _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 _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 _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; }
+
+import React, { useContext, useEffect, useRef } from 'react';
+import ReactDOM from 'react-dom';
+import { mapContext } from '../Context';
+import useMapType from '../hook/useMapType';
+var _global = window;
+export default function InfoWindow(_ref) {
+  var children = _ref.children,
+      visible = _ref.visible,
+      center = _ref.center;
+
+  var _useContext = useContext(mapContext),
+      instance = _useContext.instance;
+
+  var domref = useRef(null);
+  var infoWindowRef = useRef(null);
+  var type = useMapType();
+  useEffect(function () {
+    if (!instance.map) {
+      return;
+    } // leaflet下还未实现
+
+
+    if (type.AMap && !infoWindowRef.current) {
+      var AMap = _global.AMap;
+      var infoWindow = new AMap.InfoWindow({
+        isCustom: true,
+        content: domref.current,
+        autoMove: false,
+        offset: [0, -32]
+      });
+      infoWindowRef.current = infoWindow;
+    } // eslint-disable-next-line react-hooks/exhaustive-deps
+
+  }, [instance.map, visible, center]);
+  useEffect(function () {
+    var infoWindow = infoWindowRef.current;
+
+    if (!infoWindow || !center) {
+      return undefined;
+    }
+
+    if (type.AMap) {
+      var AMap = _global.AMap;
+
+      var lnglat = _construct(AMap.LngLat, _toConsumableArray(center));
+
+      instance.map.setCenter(lnglat); // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+
+      visible ? !infoWindow.getIsOpen() ? (infoWindow.close(), infoWindow.open(instance.map, lnglat)) : infoWindow.open(instance.map, lnglat) : infoWindow.close();
+    } // eslint-disable-next-line react-hooks/exhaustive-deps
+
+  }, [visible, center, instance.map]);
+  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("div", {
+    ref: domref
+  }), domref.current && /*#__PURE__*/ReactDOM.createPortal(children, domref.current));
+}

package/es/Map/LevelCenter/DragMarker/index.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import { LatLng } from '../../interface';
+export interface IDragMarkerProps {
+    center?: [number, number];
+    zoom?: number;
+    onChange?: (options: {
+        center: [number, number] | LatLng;
+        zoom: number;
+    }) => void;
+}
+declare function DragMarker({ center, onChange }: IDragMarkerProps): JSX.Element;
+export default DragMarker;

package/es/Map/LevelCenter/DragMarker/index.js

@@ -0,0 +1,48 @@
+import { mapContext } from '../../Context';
+import React, { useContext, useEffect } from 'react';
+import useMarker from '../../useMarker';
+import { createMapCenterIcon } from '../../icon';
+import useMapType from '../../hook/useMapType';
+
+function DragMarker(_ref) {
+  var center = _ref.center,
+      onChange = _ref.onChange;
+
+  var _useContext = useContext(mapContext),
+      instance = _useContext.instance;
+
+  var type = useMapType();
+  var marker = useMarker({
+    map: instance.map,
+    center: center,
+    createIcon: createMapCenterIcon,
+    options: {
+      draggable: true
+    }
+  });
+  useEffect(function () {
+    if (!marker) {
+      return;
+    }
+
+    marker.on('dragend', function (e) {
+      var latlng = type.leaflet ? e.target.getLatLng() : e.target.getPosition();
+      instance.setCenter(latlng);
+      onChange && onChange({
+        center: latlng,
+        zoom: instance.getZoom()
+      });
+    });
+    instance.map.on('zoomend', function (e) {
+      var zoom = e.target.getZoom();
+      var latlng = type.leaflet ? marker.getLatLng() : marker.getPosition();
+      onChange && onChange({
+        center: latlng,
+        zoom: zoom
+      });
+    }); // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [marker]);
+  return /*#__PURE__*/React.createElement(React.Fragment, null);
+}
+
+export default DragMarker;

package/es/Map/LevelCenter/index.d.ts

@@ -0,0 +1,13 @@
+import { LatLng, MapPoint } from '../interface';
+import './index.less';
+export interface ILevelCenter {
+    center?: [number, number];
+    zoom?: number;
+    points: MapPoint[];
+    onLevelCenterChange?: (options: {
+        center: [number, number] | LatLng;
+        zoom: number;
+    }) => void;
+}
+declare const _default: (props: ILevelCenter) => JSX.Element;
+export default _default;

package/es/Map/LevelCenter/index.js

@@ -0,0 +1,42 @@
+import React, { useCallback, useContext, useEffect, useMemo } from 'react';
+import ClusterLayer from '../ClusterLayer';
+import FindPio from '../FindPio';
+import ResetTools from '../ResetTools';
+import DragMarker from './DragMarker';
+import withMap from '../withMap';
+import { mapContext } from '../Context';
+import "./index.css";
+
+function LevelCenter(_ref) {
+  var center = _ref.center,
+      zoom = _ref.zoom,
+      points = _ref.points,
+      onLevelCenterChange = _ref.onLevelCenterChange;
+
+  var _useContext = useContext(mapContext),
+      instance = _useContext.instance;
+
+  var defaultCenter = useMemo(function () {
+    return center || instance.config.center;
+  }, [center, instance]);
+  var defaultZoom = useMemo(function () {
+    return zoom || instance.config.zoom;
+  }, [zoom, instance]);
+  var mapRest = useCallback(function () {
+    return instance.setZoomAndCenter(defaultZoom, defaultCenter);
+  }, [defaultZoom, defaultCenter]);
+  useEffect(function () {
+    return mapRest();
+  }, []);
+  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(ClusterLayer, {
+    points: points
+  }), /*#__PURE__*/React.createElement(FindPio, null), /*#__PURE__*/React.createElement(ResetTools, {
+    onMapReset: mapRest
+  }), /*#__PURE__*/React.createElement(DragMarker, {
+    center: defaultCenter,
+    zoom: defaultZoom,
+    onChange: onLevelCenterChange
+  }));
+}
+
+export default withMap(LevelCenter, 'lv-center-map-container');

package/es/Map/LoaderMap/index.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+interface ILoaderMapProps {
+    children: React.ReactElement;
+    MAP_GLABAL_KEY?: 'L' | 'AMap';
+}
+declare function LoaderMap({ children, MAP_GLABAL_KEY, ...props }: ILoaderMapProps): JSX.Element;
+declare namespace LoaderMap {
+    var defaultProps: {
+        MAP_GLABAL_KEY: string;
+    };
+}
+export default LoaderMap;

package/es/Map/LoaderMap/index.js

@@ -0,0 +1,58 @@
+import { __rest } from "tslib";
+import React, { useMemo } from 'react';
+import Config from '../../Config';
+import LoaderScript from '../../LoaderScript';
+var L_SCRIPTS = [{
+  scripts: ['https://cdn.bootcdn.net/ajax/libs/leaflet/1.8.0/leaflet.min.js'],
+  styles: ['https://cdn.bootcdn.net/ajax/libs/leaflet/1.8.0/leaflet.min.css'] // scripts: ['/statics/libs/map/leaflet/leaflet.min.js'],
+  // styles: ['/statics/libs/map/leaflet/leaflet.min.css'],
+
+}, {
+  scripts: ['https://cdn.bootcdn.net/ajax/libs/leaflet.markercluster/1.5.3/leaflet.markercluster.min.js' // '/statics/libs/map/leaflet/echarts-leaflet.js'
+  // '/statics/libs/map/leaflet/leaflet.markercluster.js'
+  ],
+  styles: ['https://cdn.bootcdn.net/ajax/libs/leaflet.markercluster/1.5.3/MarkerCluster.min.css', 'https://cdn.bootcdn.net/ajax/libs/leaflet.markercluster/1.5.3/MarkerCluster.Default.min.css' // '/statics/libs/map/leaflet/MarkerCluster.css'
+  // '/statics/libs/map/leaflet/MarkerCluster.Default.css'
+  ]
+}];
+var AMAP_SCRIPTS = [{
+  scripts: ['https://webapi.amap.com/maps?v=2.0&key=2232e46c0b578b711e6e9851cb92dbfe']
+}];
+
+function EmptyParent(_ref) {
+  var children = _ref.children;
+  return /*#__PURE__*/React.createElement(React.Fragment, null, children);
+}
+
+function LoaderMap(_a) {
+  var children = _a.children,
+      MAP_GLABAL_KEY = _a.MAP_GLABAL_KEY,
+      props = __rest(_a, ["children", "MAP_GLABAL_KEY"]);
+
+  var glaobalKey = useMemo(function () {
+    return MAP_GLABAL_KEY ? MAP_GLABAL_KEY : Config.BSConfig.MAP_GLABAL_KEY || 'L';
+  }, []);
+  var isL = useMemo(function () {
+    return glaobalKey === 'L';
+  }, [glaobalKey]);
+  var isGlobalKey = useMemo(function () {
+    return !!window[glaobalKey];
+  }, [glaobalKey]);
+  var options = useMemo(function () {
+    return isL ? L_SCRIPTS : AMAP_SCRIPTS;
+  }, [isL]);
+  var Parent = useMemo(function () {
+    return isGlobalKey ? EmptyParent : LoaderScript;
+  }, [isGlobalKey]);
+  return /*#__PURE__*/React.createElement(Parent, {
+    options: options
+  }, /*#__PURE__*/React.cloneElement(children, Object.assign(Object.assign({}, props), {
+    isL: isL,
+    glaobalKey: glaobalKey
+  })));
+}
+
+LoaderMap.defaultProps = {
+  MAP_GLABAL_KEY: 'AMap'
+};
+export default LoaderMap;

package/es/Map/ResetTools/index.css

@@ -0,0 +1,32 @@
+.map-reset-tool-container {
+  position: absolute;
+  right: 10px;
+  bottom: 10px;
+  z-index: 3;
+  padding: 5px 0;
+  background: #ffffff;
+}
+.map-reset-tool-container .map-reset,
+.map-reset-tool-container .map-zoom {
+  background: #ffffff;
+}
+.map-reset-tool-container .map-zoom {
+  margin-bottom: 0;
+}
+.map-reset-tool-container .map-tool-icon {
+  width: 30px;
+  height: 25px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  font-size: 18px;
+  color: vart(--icon);
+  cursor: pointer;
+}
+.map-reset-tool-container .map-tool-icon:hover {
+  color: var(--primary);
+}
+.map-rest-tools-item-popup .ant-popover-inner-content {
+  padding: 4px 8px;
+  font-size: var(--fs-small);
+}

package/es/Map/ResetTools/index.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import './index.less';
+export interface IResetTools {
+    onMapReset?: () => void;
+    onMapZoom?: (num: number) => void;
+    className?: string;
+}
+declare function ResetTools({ onMapReset, onMapZoom, className }: IResetTools): JSX.Element;
+export default ResetTools;