bbj-screen-widget 2.4.46 → 2.4.47

package/esm2015/lib/custom-baidu-map/custom-baidu-map.component.js

@@ -0,0 +1,655 @@
+import { __awaiter, __decorate, __metadata } from "tslib";
+import { HttpClient } from '@angular/common/http';
+import { ChangeDetectorRef, Component, ElementRef, EventEmitter, HostBinding, NgZone, Optional, ViewChild, } from '@angular/core';
+import { Subject } from 'rxjs';
+import { take, takeUntil } from 'rxjs/operators';
+import { ScaleSubject, TemplateUtil, WidgetRef } from 'bbj-widget-base';
+import { Data, DataOutput, Property, Widget, Event } from 'bbj-widget-base';
+import { BaiduMapService } from 'bbj-screen-widget/core';
+const MapTypeEnum = [
+    { label: '普通', value: 'normal' },
+    { label: '深色', value: 'dark' },
+    { label: '卫星', value: 'satellite' },
+    { label: '自定义', value: 'custom' },
+];
+let CustomBaiduMapComponent = class CustomBaiduMapComponent {
+    constructor(baiduMapService, http, elementRef, zone, scale$, cd, widgetRef) {
+        this.baiduMapService = baiduMapService;
+        this.http = http;
+        this.elementRef = elementRef;
+        this.zone = zone;
+        this.scale$ = scale$;
+        this.cd = cd;
+        this.widgetRef = widgetRef;
+        // @Property('字体', { ui: { widget: 'myFont' } })
+        // font: any = {
+        //   family: '',
+        //   color: '#000000',
+        //   weight: 'normal',
+        //   size: 16,
+        //   space: 0,
+        //   lineHeight: 0,
+        // };
+        this.mapType = 'normal';
+        this.minMapShow = false;
+        this.showType = 'click';
+        this.dragging = true;
+        this.shadeColor = '#004395';
+        this.mapCityColor = '#41b7ff';
+        this.zoom = 12;
+        // @Property('放大比例', { type: 'number' })
+        // scale = 1;
+        this.fillOpacity = 0;
+        this.strokesize = 2;
+        this.nightMode = false;
+        this.tilt = 73;
+        // @Property('中心经度', {
+        //   ui: {widget: 'myRange', min: -180, max: 180, step: 1},
+        // })
+        this.centerLng = 120.7;
+        // @Property('中心纬度', {
+        //   ui: {widget: 'myRange', min: -90, max: 90, step: 1},
+        // })
+        this.centerLat = 28;
+        this.cityName = null;
+        // markerTierClick: any;
+        // pingyang = '';
+        // ruian = '';
+        this._data = [{ lng: 120.7, lat: 28 }];
+        this.dataChange = new EventEmitter();
+        this.zoomChange = new EventEmitter();
+        this.mapClick = new EventEmitter();
+        this.destroy$ = new Subject();
+        // containerStyle: any = {};
+        // unloadedChildren = {};
+        this.overlaysMap = {};
+        this.init$ = new Promise((resolve) => {
+            this.inited = resolve;
+        });
+        this.mapTypeEnum = MapTypeEnum.slice(0, 3);
+    }
+    get element() {
+        return this.elementRef.nativeElement;
+    }
+    addLayer(layer) {
+        if (this.view) {
+            this.view.addLayer(layer);
+        }
+    }
+    removeLayer(layer) {
+        if (this.view) {
+            this.view.removeLayer(layer);
+        }
+    }
+    ngOnChanges(changes) {
+        if (changes._data && this._data[0]) {
+            this.centerLng = +this._data[0].lng;
+            this.centerLat = +this._data[0].lat;
+            this.setCenter(this.centerLng, this.centerLat);
+        }
+    }
+    ngOnInit() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.scale$) {
+                // 这是为了解决地图缩放中心不在鼠标所在位置的问题
+                this.scale$.pipe(takeUntil(this.destroy$)).subscribe((scale) => {
+                    const { x: sx, y: sy, scaleContent } = scale;
+                    const style = this.element.style;
+                    if (scaleContent === false) {
+                        this.zone.onStable.pipe(take(1)).subscribe(() => {
+                            const parent = this.element.parentNode;
+                            if (parent) {
+                                const match = /translate\(([-\d.]+)px, ([-\d.]+)px\)/.exec(parent.style.transform);
+                                if (match) {
+                                    const offsetX = parseFloat(match[1]);
+                                    const offsetY = parseFloat(match[2]);
+                                    style.transform = `translate(${-offsetX}px,${-offsetY}px)`;
+                                    style.height = parent.clientHeight + offsetY + 'px';
+                                    style.width = parent.clientWidth + offsetX + 'px';
+                                    style.padding = `${offsetY}px 0 0 ${offsetX}px`;
+                                    // this.containerStyle = {
+                                    //   transformOrigin: `0 0`,
+                                    //   transform: `translate(${-offsetX}px,${-offsetY}px)`,
+                                    //   height: parent.clientHeight + offsetY + 'px',
+                                    //   width: parent.clientWidth + offsetX + 'px',
+                                    //   padding: `${offsetY}px 0 0 ${offsetX}px`,
+                                    // };
+                                }
+                            }
+                            // this.cd.markForCheck();
+                        });
+                    }
+                    else {
+                        const { position, size } = this.widgetRef.widget;
+                        const { x, y } = position;
+                        const { width, height } = size;
+                        style.transform = `translate(${-x}px,${-y}px) scale(${1 / sx},${1 / sy})`;
+                        style.height = (y + height) * sy + 'px';
+                        style.width = (x + width) * sx + 'px';
+                        style.padding = `${y * sy}px 0 0 ${x * sx}px`;
+                    }
+                    // this.cd.markForCheck();
+                });
+            }
+            yield this.initMap();
+        });
+    }
+    initMap() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.baiduMapService.loadMapGL();
+            yield this.baiduMapService.loadMapVGL();
+            this.mapTypeValue = this.mapType;
+            // 兼容老的配置
+            if (this.mapType == null) {
+                if (this.uploadStyle) {
+                    this.mapTypeValue = 'custom';
+                }
+                else if (this.nightMode) {
+                    this.mapTypeValue = 'dark';
+                }
+            }
+            if (!this.destroyed) {
+                this.zone.runOutsideAngular(() => {
+                    this.map = new BMapGL.Map(this.container.nativeElement, { restrictCenter: false });
+                    this.map.centerAndZoom(new BMapGL.Point(this.centerLng, this.centerLat), this.zoom); // 设置中心点和缩放级别
+                    this.map.enableScrollWheelZoom(); // 启用滚轮进行缩放功能
+                    // var dist = new BMapGL.DistrictLayer({
+                    //   name: '(温州市)',
+                    //   kind: 1,
+                    //    fillColor: '#fff',
+                    //   fillOpacity: 0.1,
+                    //   strokeColor: '#daeafa',
+                    //   viewport: true,
+                    // });
+                    // this.map.addDistrictLayer(dist);
+                    this.mapTypeChange(this.mapTypeValue);
+                    if (this.edit || this.dragging === false) {
+                        this.map.disableDragging();
+                    }
+                    if (this.enable3D) {
+                        this.map.setTilt(this.tilt == null ? 73 : this.tilt, { noAnimation: true });
+                        this.map.setDisplayOptions({ skyColors: ['rgba(0, 0, 0, 0)'] }); // 隐藏天空
+                        // const navi3DCtrl = new BMapGL.NavigationControl3D(); // 添加3D控件
+                        // this.map.addControl(navi3DCtrl);
+                    }
+                    else {
+                        this.map.disableTilt();
+                        this.map.disableRotate();
+                    }
+                    if (this.showLocationControl) {
+                        const options = {
+                            // 控件的停靠位置（可选，默认左上角）
+                            anchor: BMAP_ANCHOR_TOP_LEFT,
+                            // 控件基于停靠位置的偏移量（可选）
+                            offset: new BMapGL.Size(20, 20),
+                        };
+                        let locationControl = new BMapGL.LocationControl(options);
+                        // 将控件添加到地图上
+                        this.map.addControl(locationControl);
+                    }
+                    if (this.minMapShow) {
+                        const stCtrl = new BMapGL.PanoramaControl();
+                        stCtrl.setOffset(new BMapGL.Size(20, 20));
+                        this.map.addControl(stCtrl);
+                    }
+                    if (this.infoWindowBackground) {
+                        this.element.style.setProperty('--info-window-background', this.infoWindowBackground);
+                    }
+                    if (this.infoWindowColor) {
+                        this.element.style.setProperty('--info-window-color', this.infoWindowColor);
+                    }
+                    this.map.addEventListener('moveend', (event) => {
+                        const center = this.map.getCenter();
+                        this.dataChange.emit(center);
+                    });
+                    this.map.addEventListener('click', (event) => {
+                        this.mapClick.emit(event.pointer);
+                    });
+                    this.map.addEventListener('zoomend', (event) => {
+                        this.zoomChange.emit(this.map.getZoom());
+                        this.dataChange.emit(this.map.getCenter());
+                    });
+                    this.view = new mapvgl.View({
+                        map: this.map,
+                    });
+                    this.mapLoaded(this.map);
+                });
+                this.inited(this.map);
+            }
+        });
+    }
+    setCenter(lng, lat) {
+        if (this.map && lng && lat) {
+            const center = this.map.getCenter();
+            if (center.lng != lng || center.lat != lat) {
+                this.setCenterAndZoom(lng, lat, this.map.getZoom());
+            }
+        }
+    }
+    setCenterAndZoom(lng, lat, zoom) {
+        const center = this.map.getCenter();
+        const currentZoom = this.map.getZoom();
+        // 误差范围内不移动,防止背景抖动
+        if (zoom != currentZoom || Math.abs(lng - center.lng) > 1e-13 || Math.abs(lat - center.lat) > 1e-7) {
+            const point = new BMapGL.Point(lng, lat);
+            this.map.centerAndZoom(point, zoom, { tilt: this.map.getTilt() });
+        }
+    }
+    /**
+     * 根据经纬度范围设置中心和缩放等级
+     * @param minLng
+     * @param maxLng
+     * @param minLat
+     * @param maxLat
+     */
+    setRectCenterAndZoom(minLng, maxLng, minLat, maxLat) {
+        this.setCenterAndZoom((maxLng + minLng) / 2, (maxLat + minLat) / 2, this.getZoom(maxLng, minLng, maxLat, minLat));
+    }
+    getZoom(maxLng, minLng, maxLat, minLat) {
+        const zooms = [
+            50, 100, 200, 500, 1000, 2000, 5000, 10000, 20000, 25000, 50000, 100000, 200000, 500000, 1000000, 2000000,
+        ]; //级别18到3。
+        const pointA = new BMapGL.Point(maxLng, maxLat); // 创建点坐标A
+        const pointB = new BMapGL.Point(minLng, minLat); // 创建点坐标B
+        const distance = +this.map.getDistance(pointA, pointB).toFixed(1); //获取两点距离,保留小数点后两位
+        const i = zooms.findIndex((zoom) => zoom - distance > 0);
+        if (i === -1) {
+            return 5;
+        }
+        //之所以会多3，是因为地图范围常常是比例尺距离的10倍以上。所以级别会增加3。
+        return 18 - i + 3;
+    }
+    openInfoWindow(data, lng, lat) {
+        if (data.information || this.infoWindowTemplate) {
+            const point = new BMapGL.Point(+lng, +lat);
+            // let offsetY = -25;
+            // if (this.hideInfoWindowTail) {
+            //   offsetY = 0;
+            // }
+            let information = data.information;
+            if (this.infoWindowTemplate) {
+                information = TemplateUtil.parse(this.infoWindowTemplate, data);
+            }
+            const options = {
+                offset: new BMapGL.Size(0, 0),
+                width: this.infoWindowWidth || 0,
+                height: this.infoWindowHeight || 0,
+            };
+            const infoWindow = new BMapGL.InfoWindow(information, options);
+            // 第一次打开信息窗口后在短时间关闭或重新打开会导致click事件失效，临时解决方案是第一次打开后0.5秒内不关闭
+            if (!this.firstOpen) {
+                if (this.firstOpenPromise) {
+                    this.firstOpenPromise.then(() => {
+                        this.map.openInfoWindow(infoWindow, point);
+                    });
+                }
+                else {
+                    this.firstOpenPromise = new Promise((resolve) => {
+                        setTimeout(() => {
+                            this.firstOpen = true;
+                            this.firstOpenPromise = null;
+                            resolve();
+                        }, 500);
+                    });
+                    this.map.openInfoWindow(infoWindow, point);
+                }
+                const rawClose = infoWindow.close;
+                infoWindow.close = () => {
+                    if (this.firstOpenPromise) {
+                        this.firstOpenPromise.then(() => rawClose.call(infoWindow));
+                    }
+                    else {
+                        rawClose.call(infoWindow);
+                    }
+                };
+            }
+            else {
+                this.map.openInfoWindow(infoWindow, point);
+            }
+            return infoWindow;
+        }
+    }
+    getCanvasOverlay(child) {
+        let canvasOverlay;
+        if (this.enable3D) {
+            const item = child.item;
+            if (item) {
+                var pStart = new BMapGL.Point(item.start.lng, item.start.lat);
+                var pEnd = new BMapGL.Point(item.end.lng, item.end.lat);
+                var bounds = new BMapGL.Bounds(new BMapGL.Point(pStart.lng, pEnd.lat), new BMapGL.Point(pEnd.lng, pStart.lat));
+                canvasOverlay = new BMapGL.GroundOverlay(bounds, {
+                    type: 'canvas',
+                    url: item.canvas,
+                    opacity: 1,
+                });
+            }
+        }
+        else {
+            const pointToPixel = (data) => {
+                const point = new BMapGL.Point(data.lng, data.lat);
+                return this.map.pointToPixel(point);
+            };
+            canvasOverlay = new BMapGL.CanvasLayer({
+                paneName: 'markerShadow',
+                update: function () {
+                    var ctx = this.canvas.getContext('2d');
+                    if (!ctx) {
+                        return;
+                    }
+                    ctx.clearRect(0, 0, ctx.canvas.width, ctx.canvas.height);
+                    child.update(ctx, pointToPixel);
+                },
+            });
+        }
+        return canvasOverlay;
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+        this.destroyed = true;
+        if (this.view) {
+            this.view.destroy();
+        }
+        if (this.map) {
+            this.map.destroy();
+        }
+    }
+    mapLoaded(map) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.cityName) {
+                if (this.cityName === '温州') {
+                    this.cityName = 'wenzhou';
+                }
+                const json = yield this.http.get('assets/echarts/map/json/' + this.cityName + '.json').toPromise();
+                const polygonData = [];
+                let encodeScale = json.UTF8Scale || 1024;
+                json.features.forEach(({ geometry }) => {
+                    geometry.coordinates = geometry.coordinates.forEach((coordinate, i) => {
+                        if (geometry.type === 'MultiPolygon') {
+                            const coordinates = coordinate.map((points, j) => {
+                                if (json.UTF8Encoding) {
+                                    points = this.decodePolygon(points, geometry.encodeOffsets[i][j], encodeScale);
+                                }
+                                return points;
+                            });
+                            polygonData.push(coordinates);
+                        }
+                        else {
+                            if (json.UTF8Encoding) {
+                                coordinate = this.decodePolygon(coordinate, geometry.encodeOffsets[i], encodeScale);
+                            }
+                            polygonData.push([coordinate]);
+                        }
+                    });
+                });
+                const data = [
+                    {
+                        geometry: {
+                            type: 'MultiPolygon',
+                            coordinates: polygonData,
+                        },
+                    },
+                ];
+                var layer = new mapvgl.PolygonLayer({
+                    lineColor: this.mapCityColor,
+                    lineWidth: this.strokesize || 2,
+                    fillColor: this.shadeColor,
+                    data,
+                    renderOrder: -2,
+                });
+                this.view.addLayer(layer);
+                if (this.mapBackColor && !this.mapBackColor.match(/rgba\(\d+,\d+,\d+,0\)/)) {
+                    var maskLayer = new mapvgl.MaskLayer({
+                        color: this.mapBackColor,
+                        data,
+                        renderOrder: -3,
+                    });
+                    this.view.addLayer(maskLayer);
+                }
+            }
+        });
+    }
+    decodePolygon(coordinate, encodeOffsets, encodeScale) {
+        const result = [];
+        let prevX = encodeOffsets[0];
+        let prevY = encodeOffsets[1];
+        for (let i = 0; i < coordinate.length; i += 2) {
+            var x = coordinate.charCodeAt(i) - 64;
+            var y = coordinate.charCodeAt(i + 1) - 64;
+            // ZigZag decoding
+            x = (x >> 1) ^ -(x & 1);
+            y = (y >> 1) ^ -(y & 1);
+            // Delta deocding
+            x += prevX;
+            y += prevY;
+            prevX = x;
+            prevY = y;
+            // Dequantize
+            result.push([x / encodeScale, y / encodeScale]);
+        }
+        return result;
+    }
+    mapTypeChange(mapType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            switch (mapType) {
+                case 'dark':
+                    if (!this.darkStyle) {
+                        this.darkStyle = yield this.http.get('assets/echarts/map/json/custom_map.json').toPromise();
+                    }
+                    this.map.setMapType(BMAP_NORMAL_MAP);
+                    this.map.setMapStyleV2({ styleJson: this.darkStyle });
+                    break;
+                case 'satellite':
+                    this.map.setMapType(BMAP_SATELLITE_MAP);
+                    break;
+                case 'custom':
+                    if (this.uploadStyle) {
+                        const styleJson = yield this.http.get(this.uploadStyle).toPromise();
+                        this.map.setMapType(BMAP_NORMAL_MAP);
+                        this.map.setMapStyleV2({ styleJson });
+                    }
+                    break;
+                default:
+                    this.map.setMapType(BMAP_NORMAL_MAP);
+                    this.map.setMapStyleV2({ styleJson: null });
+            }
+        });
+    }
+};
+CustomBaiduMapComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'sc-custom-baidu-map',
+                template: "<ng-template *ngFor=\"let child of children\" widget-host [widget]=\"child\"></ng-template>\n\n<!-- {{children|json}} -->\n<!-- <div class=\"map-container\" [ngStyle]=\"containerStyle\"> -->\n<div #container class=\"map\"></div>\n<nz-radio-group\n  *ngIf=\"showMapTypeRadio\"\n  class=\"map-type-radio\"\n  [(ngModel)]=\"mapTypeValue\"\n  (ngModelChange)=\"mapTypeChange($event)\"\n  nzButtonStyle=\"solid\"\n>\n  <label *ngFor=\"let item of mapTypeEnum\" nz-radio-button [nzValue]=\"item.value\">{{ item.label }}</label>\n</nz-radio-group>\n<!-- </div> -->\n",
+                styles: [":host{display:block;height:100%;width:100%;overflow:hidden;transform-origin:0 0;z-index:0;pointer-events:none}:host>*{pointer-events:auto}.map{height:100%;width:100%}:host::ng-deep .BMap_bubble_pop{background-color:var(--info-window-background,#fff)!important}:host::ng-deep .BMap_bubble_content{color:var(--info-window-color,\"#555555\")!important}:host::ng-deep .BMap_pop div{background-color:var(--info-window-background,#fff)!important}:host::ng-deep .BMap_pop>div:nth-child(8){background-color:transparent!important}:host.hideInfoWindowTail::ng-deep .BMap_bubble_pop>img,:host.hideInfoWindowTail::ng-deep .BMap_pop>div:nth-child(8),:host::ng-deep img[src$=\"/image/api/iws3.png\"]{display:none}:host.hideInfoWindowTop::ng-deep .BMap_bubble_pop{transform:translateY(31px)}:host.hideInfoWindowTop::ng-deep .BMap_bubble_pop>img{transform:translateY(-31px)}:host.hideInfoWindowTop::ng-deep .BMap_bubble_top,:host::ng-deep .anchorBL{display:none}.map-type-radio{position:absolute;bottom:20px;right:20px;z-index:10}"]
+            },] }
+];
+CustomBaiduMapComponent.ctorParameters = () => [
+    { type: BaiduMapService },
+    { type: HttpClient },
+    { type: ElementRef },
+    { type: NgZone },
+    { type: ScaleSubject, decorators: [{ type: Optional }] },
+    { type: ChangeDetectorRef },
+    { type: WidgetRef }
+];
+CustomBaiduMapComponent.propDecorators = {
+    hideInfoWindowTail: [{ type: HostBinding, args: ['class.hideInfoWindowTail',] }],
+    hideInfoWindowTop: [{ type: HostBinding, args: ['class.hideInfoWindowTop',] }],
+    container: [{ type: ViewChild, args: ['container', { static: true },] }]
+};
+__decorate([
+    Property('地图类型', {
+        enum: MapTypeEnum,
+    }),
+    __metadata("design:type", Object)
+], CustomBaiduMapComponent.prototype, "mapType", void 0);
+__decorate([
+    Property('上传样式', { type: 'string', ui: { widget: 'myUploadAudio', visibleIf: { mapType: ['custom'] } } }),
+    __metadata("design:type", String)
+], CustomBaiduMapComponent.prototype, "uploadStyle", void 0);
+__decorate([
+    Property('切换按钮'),
+    __metadata("design:type", Boolean)
+], CustomBaiduMapComponent.prototype, "showMapTypeRadio", void 0);
+__decorate([
+    Property('全景地图', { type: 'boolean' }),
+    __metadata("design:type", Object)
+], CustomBaiduMapComponent.prototype, "minMapShow", void 0);
+__decorate([
+    Property('显示信息', {
+        ui: { widget: 'select' },
+        enum: [
+            { label: '点击', value: 'click' },
+            { label: '悬停', value: 'mouseover' },
+        ],
+    }),
+    __metadata("design:type", Object)
+], CustomBaiduMapComponent.prototype, "showType", void 0);
+__decorate([
+    Property('信息窗背景', { ui: { widget: 'myColor' } }),
+    __metadata("design:type", String)
+], CustomBaiduMapComponent.prototype, "infoWindowBackground", void 0);
+__decorate([
+    Property('信息窗字体', { ui: { widget: 'myColor' } }),
+    __metadata("design:type", String)
+], CustomBaiduMapComponent.prototype, "infoWindowColor", void 0);
+__decorate([
+    Property('信息窗宽度'),
+    __metadata("design:type", Number)
+], CustomBaiduMapComponent.prototype, "infoWindowWidth", void 0);
+__decorate([
+    Property('信息窗高度'),
+    __metadata("design:type", Number)
+], CustomBaiduMapComponent.prototype, "infoWindowHeight", void 0);
+__decorate([
+    Property('信息窗模板', { ui: { widget: 'textarea' } }),
+    __metadata("design:type", String)
+], CustomBaiduMapComponent.prototype, "infoWindowTemplate", void 0);
+__decorate([
+    Property('隐藏尖角'),
+    __metadata("design:type", Boolean)
+], CustomBaiduMapComponent.prototype, "hideInfoWindowTail", void 0);
+__decorate([
+    Property('隐藏关闭按钮'),
+    __metadata("design:type", Boolean)
+], CustomBaiduMapComponent.prototype, "hideInfoWindowTop", void 0);
+__decorate([
+    Property('地图拖动', { type: 'boolean' }),
+    __metadata("design:type", Object)
+], CustomBaiduMapComponent.prototype, "dragging", void 0);
+__decorate([
+    Property('遮罩颜色', {
+        ui: { widget: 'myColor' },
+        example: ['#ffffff', '#F5A623', '#F8E71C', '#50E3C2', '#3285FF', '#B45FFF', '#9B9B9B', null],
+    }),
+    __metadata("design:type", Object)
+], CustomBaiduMapComponent.prototype, "shadeColor", void 0);
+__decorate([
+    Property('背景颜色', {
+        ui: { widget: 'myColor' },
+        example: ['#ffffff', '#F5A623', '#F8E71C', '#50E3C2', '#3285FF', '#B45FFF', '#9B9B9B', null],
+    }),
+    __metadata("design:type", String)
+], CustomBaiduMapComponent.prototype, "mapBackColor", void 0);
+__decorate([
+    Property('多边线色', {
+        ui: { widget: 'myColor' },
+        example: ['#ffffff', '#F5A623', '#F8E71C', '#50E3C2', '#3285FF', '#B45FFF', '#9B9B9B', null],
+    }),
+    __metadata("design:type", Object)
+], CustomBaiduMapComponent.prototype, "mapCityColor", void 0);
+__decorate([
+    Property('地图缩放', {
+        ui: { widget: 'myRange', min: 1, max: 40, step: 1 },
+    }),
+    __metadata("design:type", Object)
+], CustomBaiduMapComponent.prototype, "zoom", void 0);
+__decorate([
+    Property('遮罩透明', { type: 'number' }),
+    __metadata("design:type", Object)
+], CustomBaiduMapComponent.prototype, "fillOpacity", void 0);
+__decorate([
+    Property('多边线粗', { type: 'number' }),
+    __metadata("design:type", Object)
+], CustomBaiduMapComponent.prototype, "strokesize", void 0);
+__decorate([
+    Property('黑夜模式', { type: 'boolean', ui: { hidden: true } }),
+    __metadata("design:type", Object)
+], CustomBaiduMapComponent.prototype, "nightMode", void 0);
+__decorate([
+    Property('3D视角'),
+    __metadata("design:type", Boolean)
+], CustomBaiduMapComponent.prototype, "enable3D", void 0);
+__decorate([
+    Property('定位控件'),
+    __metadata("design:type", Boolean)
+], CustomBaiduMapComponent.prototype, "showLocationControl", void 0);
+__decorate([
+    Property('初始角度', { type: 'number', ui: { visibleIf: { enable3D: [true] } } }),
+    __metadata("design:type", Object)
+], CustomBaiduMapComponent.prototype, "tilt", void 0);
+__decorate([
+    Property('显示省市', {
+        ui: {
+            widget: 'myUrlSelect',
+            allowClear: true,
+            url: '/assets/mapListItem.json',
+        },
+    }),
+    __metadata("design:type", Object)
+], CustomBaiduMapComponent.prototype, "cityName", void 0);
+__decorate([
+    Data({
+        properties: {
+            lng: { type: 'number', title: '经度' },
+            lat: { type: 'number', title: '纬度' },
+        },
+    }),
+    __metadata("design:type", Array)
+], CustomBaiduMapComponent.prototype, "_data", void 0);
+__decorate([
+    DataOutput(['lng', 'lat']),
+    Event('中心点改变', {
+        params: { properties: { lng: { title: '经度', type: 'number' }, lat: { title: '纬度', type: 'number' } } },
+    }),
+    __metadata("design:type", Object)
+], CustomBaiduMapComponent.prototype, "dataChange", void 0);
+__decorate([
+    DataOutput('缩放等级'),
+    Event('缩放', {
+        params: '缩放等级',
+    }),
+    __metadata("design:type", Object)
+], CustomBaiduMapComponent.prototype, "zoomChange", void 0);
+__decorate([
+    Event('地图点击', {
+        params: { properties: { lng: { title: '经度', type: 'number' }, lat: { title: '纬度', type: 'number' } } },
+    }),
+    __metadata("design:type", Object)
+], CustomBaiduMapComponent.prototype, "mapClick", void 0);
+CustomBaiduMapComponent = __decorate([
+    Widget('百度地图', {
+        group: 'component',
+        image: 'assets/img/screen/my-baidu-map.png',
+        children: [
+            {
+                title: '标记层',
+                type: 'sc-baidu-marker-layer',
+                option: {},
+                hidden: true,
+                hideChild: true,
+            },
+        ],
+        childTypes: ['sc-baidu-marker-layer', 'sc-baidu-polyline-layer', 'sc-wind-layer', 'sc-typhoon-area-layer'],
+        description: 'hasChildItem',
+    }),
+    __metadata("design:paramtypes", [BaiduMapService,
+        HttpClient,
+        ElementRef,
+        NgZone,
+        ScaleSubject,
+        ChangeDetectorRef,
+        WidgetRef])
+], CustomBaiduMapComponent);
+export { CustomBaiduMapComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"custom-baidu-map.component.js","sourceRoot":"","sources":["../../../../../projects/screen-widget/src/lib/custom-baidu-map/custom-baidu-map.component.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EAEL,iBAAiB,EACjB,SAAS,EACT,UAAU,EACV,YAAY,EAEZ,WAAW,EAGX,MAAM,EAIN,QAAQ,EAER,SAAS,GACV,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/B,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACxE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAC5E,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAWzD,MAAM,WAAW,GAAG;IAClB,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE;IAChC,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE;IAC9B,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,EAAE;IACnC,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE;CAClC,CAAC;IAqBW,uBAAuB,SAAvB,uBAAuB;IA8KlC,YACU,eAAgC,EAChC,IAAgB,EAChB,UAAsB,EACtB,IAAY,EACA,MAAoB,EAChC,EAAqB,EACrB,SAAoB;QANpB,oBAAe,GAAf,eAAe,CAAiB;QAChC,SAAI,GAAJ,IAAI,CAAY;QAChB,eAAU,GAAV,UAAU,CAAY;QACtB,SAAI,GAAJ,IAAI,CAAQ;QACA,WAAM,GAAN,MAAM,CAAc;QAChC,OAAE,GAAF,EAAE,CAAmB;QACrB,cAAS,GAAT,SAAS,CAAW;QApL9B,gDAAgD;QAChD,gBAAgB;QAChB,gBAAgB;QAChB,sBAAsB;QACtB,sBAAsB;QACtB,cAAc;QACd,cAAc;QACd,mBAAmB;QACnB,KAAK;QAIL,YAAO,GAAG,QAAQ,CAAC;QAOnB,eAAU,GAAG,KAAK,CAAC;QAQnB,aAAQ,GAAG,OAAO,CAAC;QAkBnB,aAAQ,GAAG,IAAI,CAAC;QAMhB,eAAU,GAAG,SAAS,CAAC;QAWvB,iBAAY,GAAG,SAAS,CAAC;QAIzB,SAAI,GAAG,EAAE,CAAC;QACV,wCAAwC;QACxC,aAAa;QAEb,gBAAW,GAAG,CAAC,CAAC;QAEhB,eAAU,GAAG,CAAC,CAAC;QAEf,cAAS,GAAG,KAAK,CAAC;QAMlB,SAAI,GAAG,EAAE,CAAC;QACV,sBAAsB;QACtB,2DAA2D;QAC3D,KAAK;QACL,cAAS,GAAG,KAAK,CAAC;QAClB,sBAAsB;QACtB,yDAAyD;QACzD,KAAK;QACL,cAAS,GAAG,EAAE,CAAC;QAQf,aAAQ,GAAG,IAAI,CAAC;QA2BhB,wBAAwB;QACxB,iBAAiB;QACjB,cAAc;QAOd,UAAK,GAAU,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC;QAKzC,eAAU,GAAG,IAAI,YAAY,EAAO,CAAC;QAMrC,eAAU,GAAG,IAAI,YAAY,EAAO,CAAC;QAIrC,aAAQ,GAAG,IAAI,YAAY,EAAO,CAAC;QAKnC,aAAQ,GAAG,IAAI,OAAO,EAAE,CAAC;QAEzB,4BAA4B;QAC5B,yBAAyB;QACzB,gBAAW,GAAG,EAAE,CAAC;QAMjB,UAAK,GAAG,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;YAC9B,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC;QACxB,CAAC,CAAC,CAAC;QAKH,gBAAW,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAYnC,CAAC;IAEJ,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC;IACvC,CAAC;IAED,QAAQ,CAAC,KAAU;QACjB,IAAI,IAAI,CAAC,IAAI,EAAE;YACb,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;SAC3B;IACH,CAAC;IAED,WAAW,CAAC,KAAU;QACpB,IAAI,IAAI,CAAC,IAAI,EAAE;YACb,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;SAC9B;IACH,CAAC;IAED,WAAW,CAAC,OAAsB;QAChC,IAAI,OAAO,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE;YAClC,IAAI,CAAC,SAAS,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;YACpC,IAAI,CAAC,SAAS,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;YACpC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;SAChD;IACH,CAAC;IAEK,QAAQ;;YACZ,IAAI,IAAI,CAAC,MAAM,EAAE;gBACf,0BAA0B;gBAC1B,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,KAAK,EAAE,EAAE;oBAC7D,MAAM,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,YAAY,EAAE,GAAG,KAAY,CAAC;oBACpD,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC;oBACjC,IAAI,YAAY,KAAK,KAAK,EAAE;wBAC1B,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE;4BAC9C,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,UAAyB,CAAC;4BACtD,IAAI,MAAM,EAAE;gCACV,MAAM,KAAK,GAAG,uCAAuC,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;gCACnF,IAAI,KAAK,EAAE;oCACT,MAAM,OAAO,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;oCACrC,MAAM,OAAO,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;oCACrC,KAAK,CAAC,SAAS,GAAG,aAAa,CAAC,OAAO,MAAM,CAAC,OAAO,KAAK,CAAC;oCAC3D,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,YAAY,GAAG,OAAO,GAAG,IAAI,CAAC;oCACpD,KAAK,CAAC,KAAK,GAAG,MAAM,CAAC,WAAW,GAAG,OAAO,GAAG,IAAI,CAAC;oCAClD,KAAK,CAAC,OAAO,GAAG,GAAG,OAAO,UAAU,OAAO,IAAI,CAAC;oCAChD,0BAA0B;oCAC1B,4BAA4B;oCAC5B,yDAAyD;oCACzD,kDAAkD;oCAClD,gDAAgD;oCAChD,8CAA8C;oCAC9C,KAAK;iCACN;6BACF;4BAED,0BAA0B;wBAC5B,CAAC,CAAC,CAAC;qBACJ;yBAAM;wBACL,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,MAAa,CAAC;wBACxD,MAAM,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,QAAQ,CAAC;wBAC1B,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;wBAC/B,KAAK,CAAC,SAAS,GAAG,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC,aAAa,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,CAAC;wBAC1E,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC;wBACxC,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC;wBACtC,KAAK,CAAC,OAAO,GAAG,GAAG,CAAC,GAAG,EAAE,UAAU,CAAC,GAAG,EAAE,IAAI,CAAC;qBAC/C;oBAED,0BAA0B;gBAC5B,CAAC,CAAC,CAAC;aACJ;YACD,MAAM,IAAI,CAAC,OAAO,EAAE,CAAC;QACvB,CAAC;KAAA;IAEK,OAAO;;YACX,MAAM,IAAI,CAAC,eAAe,CAAC,SAAS,EAAE,CAAC;YACvC,MAAM,IAAI,CAAC,eAAe,CAAC,UAAU,EAAE,CAAC;YACxC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC;YACjC,SAAS;YACT,IAAI,IAAI,CAAC,OAAO,IAAI,IAAI,EAAE;gBACxB,IAAI,IAAI,CAAC,WAAW,EAAE;oBACpB,IAAI,CAAC,YAAY,GAAG,QAAQ,CAAC;iBAC9B;qBAAM,IAAI,IAAI,CAAC,SAAS,EAAE;oBACzB,IAAI,CAAC,YAAY,GAAG,MAAM,CAAC;iBAC5B;aACF;YACD,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE;gBACnB,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,GAAG,EAAE;oBAC/B,IAAI,CAAC,GAAG,GAAG,IAAI,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,aAAa,EAAE,EAAE,cAAc,EAAE,KAAK,EAAE,CAAC,CAAC;oBACnF,IAAI,CAAC,GAAG,CAAC,aAAa,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,aAAa;oBAClG,IAAI,CAAC,GAAG,CAAC,qBAAqB,EAAE,CAAC,CAAC,aAAa;oBAC/C,wCAAwC;oBACxC,mBAAmB;oBACnB,aAAa;oBACb,wBAAwB;oBACxB,sBAAsB;oBACtB,4BAA4B;oBAC5B,oBAAoB;oBACpB,MAAM;oBACN,mCAAmC;oBACnC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;oBACtC,IAAI,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,QAAQ,KAAK,KAAK,EAAE;wBACxC,IAAI,CAAC,GAAG,CAAC,eAAe,EAAE,CAAC;qBAC5B;oBACD,IAAI,IAAI,CAAC,QAAQ,EAAE;wBACjB,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC,CAAC;wBAC5E,IAAI,CAAC,GAAG,CAAC,iBAAiB,CAAC,EAAE,SAAS,EAAE,CAAC,kBAAkB,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO;wBACxE,iEAAiE;wBACjE,mCAAmC;qBACpC;yBAAM;wBACL,IAAI,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC;wBACvB,IAAI,CAAC,GAAG,CAAC,aAAa,EAAE,CAAC;qBAC1B;oBACD,IAAI,IAAI,CAAC,mBAAmB,EAAE;wBAC5B,MAAM,OAAO,GAAG;4BACd,oBAAoB;4BACpB,MAAM,EAAE,oBAAoB;4BAC5B,mBAAmB;4BACnB,MAAM,EAAE,IAAI,MAAM,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,CAAC;yBAChC,CAAC;wBACF,IAAI,eAAe,GAAG,IAAI,MAAM,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;wBAC1D,YAAY;wBACZ,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC;qBACtC;oBACD,IAAI,IAAI,CAAC,UAAU,EAAE;wBACnB,MAAM,MAAM,GAAG,IAAI,MAAM,CAAC,eAAe,EAAE,CAAC;wBAC5C,MAAM,CAAC,SAAS,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;wBAC1C,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;qBAC7B;oBACD,IAAI,IAAI,CAAC,oBAAoB,EAAE;wBAC7B,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,WAAW,CAAC,0BAA0B,EAAE,IAAI,CAAC,oBAAoB,CAAC,CAAC;qBACvF;oBACD,IAAI,IAAI,CAAC,eAAe,EAAE;wBACxB,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,WAAW,CAAC,qBAAqB,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC;qBAC7E;oBACD,IAAI,CAAC,GAAG,CAAC,gBAAgB,CAAC,SAAS,EAAE,CAAC,KAAK,EAAE,EAAE;wBAC7C,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,CAAC;wBACpC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;oBAC/B,CAAC,CAAC,CAAC;oBACH,IAAI,CAAC,GAAG,CAAC,gBAAgB,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,EAAE;wBAC3C,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;oBACpC,CAAC,CAAC,CAAC;oBACH,IAAI,CAAC,GAAG,CAAC,gBAAgB,CAAC,SAAS,EAAE,CAAC,KAAK,EAAE,EAAE;wBAC7C,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC;wBACzC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,CAAC,CAAC;oBAC7C,CAAC,CAAC,CAAC;oBACH,IAAI,CAAC,IAAI,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC;wBAC1B,GAAG,EAAE,IAAI,CAAC,GAAG;qBACd,CAAC,CAAC;oBACH,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;gBAC3B,CAAC,CAAC,CAAC;gBACH,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;aACvB;QACH,CAAC;KAAA;IAED,SAAS,CAAC,GAAW,EAAE,GAAW;QAChC,IAAI,IAAI,CAAC,GAAG,IAAI,GAAG,IAAI,GAAG,EAAE;YAC1B,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,CAAC;YACpC,IAAI,MAAM,CAAC,GAAG,IAAI,GAAG,IAAI,MAAM,CAAC,GAAG,IAAI,GAAG,EAAE;gBAC1C,IAAI,CAAC,gBAAgB,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC;aACrD;SACF;IACH,CAAC;IAED,gBAAgB,CAAC,GAAW,EAAE,GAAW,EAAE,IAAY;QACrD,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,CAAC;QACpC,MAAM,WAAW,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;QACvC,kBAAkB;QAClB,IAAI,IAAI,IAAI,WAAW,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,GAAG,IAAI,EAAE;YAClG,MAAM,KAAK,GAAG,IAAI,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;YACzC,IAAI,CAAC,GAAG,CAAC,aAAa,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;SACnE;IACH,CAAC;IAED;;;;;;OAMG;IACH,oBAAoB,CAAC,MAAc,EAAE,MAAc,EAAE,MAAc,EAAE,MAAc;QACjF,IAAI,CAAC,gBAAgB,CAAC,CAAC,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACpH,CAAC;IAED,OAAO,CAAC,MAAc,EAAE,MAAc,EAAE,MAAc,EAAE,MAAc;QACpE,MAAM,KAAK,GAAG;YACZ,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO;SAC1G,CAAC,CAAC,SAAS;QACZ,MAAM,MAAM,GAAG,IAAI,MAAM,CAAC,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,SAAS;QAC1D,MAAM,MAAM,GAAG,IAAI,MAAM,CAAC,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,SAAS;QAC1D,MAAM,QAAQ,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,iBAAiB;QACpF,MAAM,CAAC,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,QAAQ,GAAG,CAAC,CAAC,CAAC;QACzD,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE;YACZ,OAAO,CAAC,CAAC;SACV;QACD,wCAAwC;QACxC,OAAO,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC;IACpB,CAAC;IAED,cAAc,CAAC,IAAS,EAAE,GAAW,EAAE,GAAW;QAChD,IAAI,IAAI,CAAC,WAAW,IAAI,IAAI,CAAC,kBAAkB,EAAE;YAC/C,MAAM,KAAK,GAAG,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC;YAC3C,qBAAqB;YACrB,iCAAiC;YACjC,iBAAiB;YACjB,IAAI;YACJ,IAAI,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC;YACnC,IAAI,IAAI,CAAC,kBAAkB,EAAE;gBAC3B,WAAW,GAAG,YAAY,CAAC,KAAK,CAAC,IAAI,CAAC,kBAAkB,EAAE,IAAI,CAAC,CAAC;aACjE;YACD,MAAM,OAAO,GAAG;gBACd,MAAM,EAAE,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC;gBAC7B,KAAK,EAAE,IAAI,CAAC,eAAe,IAAI,CAAC;gBAChC,MAAM,EAAE,IAAI,CAAC,gBAAgB,IAAI,CAAC;aACnC,CAAC;YACF,MAAM,UAAU,GAAG,IAAI,MAAM,CAAC,UAAU,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;YAC/D,0DAA0D;YAC1D,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE;gBACnB,IAAI,IAAI,CAAC,gBAAgB,EAAE;oBACzB,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,GAAG,EAAE;wBAC9B,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;oBAC7C,CAAC,CAAC,CAAC;iBACJ;qBAAM;oBACL,IAAI,CAAC,gBAAgB,GAAG,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE;wBACpD,UAAU,CAAC,GAAG,EAAE;4BACd,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;4BACtB,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;4BAC7B,OAAO,EAAE,CAAC;wBACZ,CAAC,EAAE,GAAG,CAAC,CAAC;oBACV,CAAC,CAAC,CAAC;oBACH,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;iBAC5C;gBACD,MAAM,QAAQ,GAAG,UAAU,CAAC,KAAK,CAAC;gBAClC,UAAU,CAAC,KAAK,GAAG,GAAG,EAAE;oBACtB,IAAI,IAAI,CAAC,gBAAgB,EAAE;wBACzB,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC;qBAC7D;yBAAM;wBACL,QAAQ,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;qBAC3B;gBACH,CAAC,CAAC;aACH;iBAAM;gBACL,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;aAC5C;YACD,OAAO,UAAU,CAAC;SACnB;IACH,CAAC;IAED,gBAAgB,CAAC,KAAU;QACzB,IAAI,aAAa,CAAC;QAClB,IAAI,IAAI,CAAC,QAAQ,EAAE;YACjB,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC;YACxB,IAAI,IAAI,EAAE;gBACR,IAAI,MAAM,GAAG,IAAI,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;gBAC9D,IAAI,IAAI,GAAG,IAAI,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;gBACxD,IAAI,MAAM,GAAG,IAAI,MAAM,CAAC,MAAM,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC,EAAE,IAAI,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;gBAC/G,aAAa,GAAG,IAAI,MAAM,CAAC,aAAa,CAAC,MAAM,EAAE;oBAC/C,IAAI,EAAE,QAAQ;oBACd,GAAG,EAAE,IAAI,CAAC,MAAM;oBAChB,OAAO,EAAE,CAAC;iBACX,CAAC,CAAC;aACJ;SACF;aAAM;YACL,MAAM,YAAY,GAAG,CAAC,IAAI,EAAE,EAAE;gBAC5B,MAAM,KAAK,GAAG,IAAI,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC;gBACnD,OAAO,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;YACtC,CAAC,CAAC;YACF,aAAa,GAAG,IAAI,MAAM,CAAC,WAAW,CAAC;gBACrC,QAAQ,EAAE,cAAc;gBACxB,MAAM,EAAE;oBACN,IAAI,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;oBACvC,IAAI,CAAC,GAAG,EAAE;wBACR,OAAO;qBACR;oBACD,GAAG,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;oBACzD,KAAK,CAAC,MAAM,CAAC,GAAG,EAAE,YAAY,CAAC,CAAC;gBAClC,CAAC;aACF,CAAC,CAAC;SACJ;QACD,OAAO,aAAa,CAAC;IACvB,CAAC;IAED,WAAW;QACT,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;QACrB,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC;QACzB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACtB,IAAI,IAAI,CAAC,IAAI,EAAE;YACb,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;SACrB;QACD,IAAI,IAAI,CAAC,GAAG,EAAE;YACZ,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;SACpB;IACH,CAAC;IAEK,SAAS,CAAC,GAAQ;;YACtB,IAAI,IAAI,CAAC,QAAQ,EAAE;gBACjB,IAAI,IAAI,CAAC,QAAQ,KAAK,IAAI,EAAE;oBAC1B,IAAI,CAAC,QAAQ,GAAG,SAAS,CAAC;iBAC3B;gBACD,MAAM,IAAI,GAAQ,MAAM,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,0BAA0B,GAAG,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC,CAAC,SAAS,EAAE,CAAC;gBACxG,MAAM,WAAW,GAAG,EAAE,CAAC;gBACvB,IAAI,WAAW,GAAG,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC;gBACzC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE;oBACrC,QAAQ,CAAC,WAAW,GAAI,QAAQ,CAAC,WAAqB,CAAC,OAAO,CAAC,CAAC,UAAU,EAAE,CAAC,EAAE,EAAE;wBAC/E,IAAI,QAAQ,CAAC,IAAI,KAAK,cAAc,EAAE;4BACpC,MAAM,WAAW,GAAI,UAAoB,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;gCAC1D,IAAI,IAAI,CAAC,YAAY,EAAE;oCACrB,MAAM,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC;iCAChF;gCACD,OAAO,MAAM,CAAC;4BAChB,CAAC,CAAC,CAAC;4BACH,WAAW,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;yBAC/B;6BAAM;4BACL,IAAI,IAAI,CAAC,YAAY,EAAE;gCACrB,UAAU,GAAG,IAAI,CAAC,aAAa,CAAC,UAAU,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC;6BACrF;4BACD,WAAW,CAAC,IAAI,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC;yBAChC;oBACH,CAAC,CAAC,CAAC;gBACL,CAAC,CAAC,CAAC;gBACH,MAAM,IAAI,GAAG;oBACX;wBACE,QAAQ,EAAE;4BACR,IAAI,EAAE,cAAc;4BACpB,WAAW,EAAE,WAAW;yBACzB;qBACF;iBACF,CAAC;gBACF,IAAI,KAAK,GAAG,IAAI,MAAM,CAAC,YAAY,CAAC;oBAClC,SAAS,EAAE,IAAI,CAAC,YAAY;oBAC5B,SAAS,EAAE,IAAI,CAAC,UAAU,IAAI,CAAC;oBAC/B,SAAS,EAAE,IAAI,CAAC,UAAU;oBAC1B,IAAI;oBACJ,WAAW,EAAE,CAAC,CAAC;iBAChB,CAAC,CAAC;gBACH,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;gBAC1B,IAAI,IAAI,CAAC,YAAY,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,uBAAuB,CAAC,EAAE;oBAC1E,IAAI,SAAS,GAAG,IAAI,MAAM,CAAC,SAAS,CAAC;wBACnC,KAAK,EAAE,IAAI,CAAC,YAAY;wBACxB,IAAI;wBACJ,WAAW,EAAE,CAAC,CAAC;qBAChB,CAAC,CAAC;oBACH,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;iBAC/B;aACF;QACH,CAAC;KAAA;IAED,aAAa,CAAC,UAAkB,EAAE,aAAuB,EAAE,WAAmB;QAC5E,MAAM,MAAM,GAAG,EAAE,CAAC;QAClB,IAAI,KAAK,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC;QAC7B,IAAI,KAAK,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC;QAE7B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE;YAC7C,IAAI,CAAC,GAAG,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;YACtC,IAAI,CAAC,GAAG,UAAU,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC;YAC1C,kBAAkB;YAClB,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;YACxB,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;YACxB,iBAAiB;YACjB,CAAC,IAAI,KAAK,CAAC;YACX,CAAC,IAAI,KAAK,CAAC;YAEX,KAAK,GAAG,CAAC,CAAC;YACV,KAAK,GAAG,CAAC,CAAC;YACV,aAAa;YACb,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,WAAW,EAAE,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC;SACjD;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAEK,aAAa,CAAC,OAAe;;YACjC,QAAQ,OAAO,EAAE;gBACf,KAAK,MAAM;oBACT,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE;wBACnB,IAAI,CAAC,SAAS,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,yCAAyC,CAAC,CAAC,SAAS,EAAE,CAAC;qBAC7F;oBACD,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC;oBACrC,IAAI,CAAC,GAAG,CAAC,aAAa,CAAC,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC;oBACtD,MAAM;gBACR,KAAK,WAAW;oBACd,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,kBAAkB,CAAC,CAAC;oBACxC,MAAM;gBACR,KAAK,QAAQ;oBACX,IAAI,IAAI,CAAC,WAAW,EAAE;wBACpB,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,SAAS,EAAE,CAAC;wBACpE,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC;wBACrC,IAAI,CAAC,GAAG,CAAC,aAAa,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC;qBACvC;oBACD,MAAM;gBACR;oBACE,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC;oBACrC,IAAI,CAAC,GAAG,CAAC,aAAa,CAAC,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;aAC/C;QACH,CAAC;KAAA;CACF,CAAA;;YAnlBA,SAAS,SAAC;gBACT,QAAQ,EAAE,qBAAqB;gBAC/B,2jBAAgD;;aAEjD;;;YArBQ,eAAe;YAvBf,UAAU;YAKjB,UAAU;YAMV,MAAM;YAUC,YAAY,uBA0NhB,QAAQ;YA5OX,iBAAiB;YAkBkB,SAAS;;;iCA+E3C,WAAW,SAAC,0BAA0B;gCAGtC,WAAW,SAAC,yBAAyB;wBA2GrC,SAAS,SAAC,WAAW,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE;;AAzIxC;IAHC,QAAQ,CAAC,MAAM,EAAE;QAChB,IAAI,EAAE,WAAW;KAClB,CAAC;;wDACiB;AAGnB;IADC,QAAQ,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,eAAe,EAAE,SAAS,EAAE,EAAE,OAAO,EAAE,CAAC,QAAQ,CAAC,EAAE,EAAE,EAAE,CAAC;;4DACtF;AAEpB;IADC,QAAQ,CAAC,MAAM,CAAC;;iEACS;AAE1B;IADC,QAAQ,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;;2DACnB;AAQnB;IAPC,QAAQ,CAAC,MAAM,EAAE;QAChB,EAAE,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE;QACxB,IAAI,EAAE;YACJ,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE;YAC/B,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,EAAE;SACpC;KACF,CAAC;;yDACiB;AAEnB;IADC,QAAQ,CAAC,OAAO,EAAE,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE,CAAC;;qEACpB;AAE7B;IADC,QAAQ,CAAC,OAAO,EAAE,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE,CAAC;;gEACzB;AAExB;IADC,QAAQ,CAAC,OAAO,CAAC;;gEACM;AAExB;IADC,QAAQ,CAAC,OAAO,CAAC;;iEACO;AAEzB;IADC,QAAQ,CAAC,OAAO,EAAE,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,EAAE,CAAC;;mEACvB;AAG3B;IAFC,QAAQ,CAAC,MAAM,CAAC;;mEAEW;AAG5B;IAFC,QAAQ,CAAC,QAAQ,CAAC;;kEAEQ;AAE3B;IADC,QAAQ,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;;yDACtB;AAMhB;IAJC,QAAQ,CAAC,MAAM,EAAE;QAChB,EAAE,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE;QACzB,OAAO,EAAE,CAAC,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,IAAI,CAAC;KAC7F,CAAC;;2DACqB;AAKvB;IAJC,QAAQ,CAAC,MAAM,EAAE;QAChB,EAAE,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE;QACzB,OAAO,EAAE,CAAC,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,IAAI,CAAC;KAC7F,CAAC;;6DACmB;AAMrB;IAJC,QAAQ,CAAC,MAAM,EAAE;QAChB,EAAE,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE;QACzB,OAAO,EAAE,CAAC,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,IAAI,CAAC;KAC7F,CAAC;;6DACuB;AAIzB;IAHC,QAAQ,CAAC,MAAM,EAAE;QAChB,EAAE,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE;KACpD,CAAC;;qDACQ;AAIV;IADC,QAAQ,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;;4DACrB;AAEhB;IADC,QAAQ,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;;2DACtB;AAEf;IADC,QAAQ,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,CAAC;;0DAC1C;AAElB;IADC,QAAQ,CAAC,MAAM,CAAC;;yDACC;AAElB;IADC,QAAQ,CAAC,MAAM,CAAC;;oEACY;AAE7B;IADC,QAAQ,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,EAAE,SAAS,EAAE,EAAE,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,CAAC;;qDACpE;AAgBV;IAPC,QAAQ,CAAC,MAAM,EAAE;QAChB,EAAE,EAAE;YACF,MAAM,EAAE,aAAa;YACrB,UAAU,EAAE,IAAI;YAChB,GAAG,EAAE,0BAA0B;SAChC;KACF,CAAC;;yDACc;AAoChB;IANC,IAAI,CAAC;QACJ,UAAU,EAAE;YACV,GAAG,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE;YACpC,GAAG,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE;SACrC;KACF,CAAC;;sDACuC;AAKzC;IAJC,UAAU,CAAC,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IAC1B,KAAK,CAAC,OAAO,EAAE;QACd,MAAM,EAAE,EAAE,UAAU,EAAE,EAAE,GAAG,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,GAAG,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE;KACvG,CAAC;;2DACmC;AAMrC;IAJC,UAAU,CAAC,MAAM,CAAC;IAClB,KAAK,CAAC,IAAI,EAAE;QACX,MAAM,EAAE,MAAM;KACf,CAAC;;2DACmC;AAIrC;IAHC,KAAK,CAAC,MAAM,EAAE;QACb,MAAM,EAAE,EAAE,UAAU,EAAE,EAAE,GAAG,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,GAAG,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE;KACvG,CAAC;;yDACiC;AApJxB,uBAAuB;IAfnC,MAAM,CAAC,MAAM,EAAE;QACd,KAAK,EAAE,WAAW;QAClB,KAAK,EAAE,oCAAoC;QAC3C,QAAQ,EAAE;YACR;gBACE,KAAK,EAAE,KAAK;gBACZ,IAAI,EAAE,uBAAuB;gBAC7B,MAAM,EAAE,EAAE;gBACV,MAAM,EAAE,IAAI;gBACZ,SAAS,EAAE,IAAI;aAChB;SACF;QACD,UAAU,EAAE,CAAC,uBAAuB,EAAE,yBAAyB,EAAE,eAAe,EAAE,uBAAuB,CAAC;QAC1G,WAAW,EAAE,cAAc;KACrB,CAAC;qCAgLoB,eAAe;QAC1B,UAAU;QACJ,UAAU;QAChB,MAAM;QACQ,YAAY;QAC5B,iBAAiB;QACV,SAAS;GArLnB,uBAAuB,CA+jBnC;SA/jBY,uBAAuB","sourcesContent":["import { HttpClient } from '@angular/common/http';\r\nimport {\r\n  ChangeDetectionStrategy,\r\n  ChangeDetectorRef,\r\n  Component,\r\n  ElementRef,\r\n  EventEmitter,\r\n  forwardRef,\r\n  HostBinding,\r\n  HostListener,\r\n  Inject,\r\n  NgZone,\r\n  OnChanges,\r\n  OnDestroy,\r\n  OnInit,\r\n  Optional,\r\n  SimpleChanges,\r\n  ViewChild,\r\n} from '@angular/core';\r\nimport { Subject } from 'rxjs';\r\nimport { take, takeUntil } from 'rxjs/operators';\r\nimport { ScaleSubject, TemplateUtil, WidgetRef } from 'bbj-widget-base';\r\nimport { Data, DataOutput, Property, Widget, Event } from 'bbj-widget-base';\r\nimport { BaiduMapService } from 'bbj-screen-widget/core';\r\n\r\n// declare const BMap;\r\ndeclare const BMapGL: any;\r\n// declare const BMapGLLib;\r\n// declare const BMapLib;\r\n// declare const BMAP_ANCHOR_BOTTOM_LEFT: number;\r\ndeclare const BMAP_ANCHOR_TOP_LEFT: number;\r\ndeclare const mapvgl: any;\r\ndeclare const BMAP_SATELLITE_MAP: number;\r\ndeclare const BMAP_NORMAL_MAP: number;\r\nconst MapTypeEnum = [\r\n  { label: '普通', value: 'normal' },\r\n  { label: '深色', value: 'dark' },\r\n  { label: '卫星', value: 'satellite' },\r\n  { label: '自定义', value: 'custom' },\r\n];\r\n@Component({\r\n  selector: 'sc-custom-baidu-map',\r\n  templateUrl: './custom-baidu-map.component.html',\r\n  styleUrls: ['./custom-baidu-map.component.less'],\r\n})\r\n@Widget('百度地图', {\r\n  group: 'component',\r\n  image: 'assets/img/screen/my-baidu-map.png',\r\n  children: [\r\n    {\r\n      title: '标记层',\r\n      type: 'sc-baidu-marker-layer',\r\n      option: {},\r\n      hidden: true,\r\n      hideChild: true,\r\n    },\r\n  ],\r\n  childTypes: ['sc-baidu-marker-layer', 'sc-baidu-polyline-layer', 'sc-wind-layer', 'sc-typhoon-area-layer'],\r\n  description: 'hasChildItem',\r\n} as any)\r\nexport class CustomBaiduMapComponent implements OnInit, OnDestroy, OnChanges {\r\n  // @Property('字体', { ui: { widget: 'myFont' } })\r\n  // font: any = {\r\n  //   family: '',\r\n  //   color: '#000000',\r\n  //   weight: 'normal',\r\n  //   size: 16,\r\n  //   space: 0,\r\n  //   lineHeight: 0,\r\n  // };\r\n  @Property('地图类型', {\r\n    enum: MapTypeEnum,\r\n  })\r\n  mapType = 'normal';\r\n  mapTypeValue: string;\r\n  @Property('上传样式', { type: 'string', ui: { widget: 'myUploadAudio', visibleIf: { mapType: ['custom'] } } })\r\n  uploadStyle: string;\r\n  @Property('切换按钮')\r\n  showMapTypeRadio: boolean;\r\n  @Property('全景地图', { type: 'boolean' })\r\n  minMapShow = false;\r\n  @Property('显示信息', {\r\n    ui: { widget: 'select' },\r\n    enum: [\r\n      { label: '点击', value: 'click' },\r\n      { label: '悬停', value: 'mouseover' },\r\n    ],\r\n  })\r\n  showType = 'click';\r\n  @Property('信息窗背景', { ui: { widget: 'myColor' } })\r\n  infoWindowBackground: string;\r\n  @Property('信息窗字体', { ui: { widget: 'myColor' } })\r\n  infoWindowColor: string;\r\n  @Property('信息窗宽度')\r\n  infoWindowWidth: number;\r\n  @Property('信息窗高度')\r\n  infoWindowHeight: number;\r\n  @Property('信息窗模板', { ui: { widget: 'textarea' } })\r\n  infoWindowTemplate: string;\r\n  @Property('隐藏尖角')\r\n  @HostBinding('class.hideInfoWindowTail')\r\n  hideInfoWindowTail: boolean;\r\n  @Property('隐藏关闭按钮')\r\n  @HostBinding('class.hideInfoWindowTop')\r\n  hideInfoWindowTop: boolean;\r\n  @Property('地图拖动', { type: 'boolean' })\r\n  dragging = true;\r\n\r\n  @Property('遮罩颜色', {\r\n    ui: { widget: 'myColor' },\r\n    example: ['#ffffff', '#F5A623', '#F8E71C', '#50E3C2', '#3285FF', '#B45FFF', '#9B9B9B', null],\r\n  })\r\n  shadeColor = '#004395';\r\n  @Property('背景颜色', {\r\n    ui: { widget: 'myColor' },\r\n    example: ['#ffffff', '#F5A623', '#F8E71C', '#50E3C2', '#3285FF', '#B45FFF', '#9B9B9B', null],\r\n  })\r\n  mapBackColor: string;\r\n\r\n  @Property('多边线色', {\r\n    ui: { widget: 'myColor' },\r\n    example: ['#ffffff', '#F5A623', '#F8E71C', '#50E3C2', '#3285FF', '#B45FFF', '#9B9B9B', null],\r\n  })\r\n  mapCityColor = '#41b7ff';\r\n  @Property('地图缩放', {\r\n    ui: { widget: 'myRange', min: 1, max: 40, step: 1 },\r\n  })\r\n  zoom = 12;\r\n  // @Property('放大比例', { type: 'number' })\r\n  // scale = 1;\r\n  @Property('遮罩透明', { type: 'number' })\r\n  fillOpacity = 0;\r\n  @Property('多边线粗', { type: 'number' })\r\n  strokesize = 2;\r\n  @Property('黑夜模式', { type: 'boolean', ui: { hidden: true } })\r\n  nightMode = false;\r\n  @Property('3D视角')\r\n  enable3D: boolean;\r\n  @Property('定位控件')\r\n  showLocationControl: boolean;\r\n  @Property('初始角度', { type: 'number', ui: { visibleIf: { enable3D: [true] } } })\r\n  tilt = 73;\r\n  // @Property('中心经度', {\r\n  //   ui: {widget: 'myRange', min: -180, max: 180, step: 1},\r\n  // })\r\n  centerLng = 120.7;\r\n  // @Property('中心纬度', {\r\n  //   ui: {widget: 'myRange', min: -90, max: 90, step: 1},\r\n  // })\r\n  centerLat = 28;\r\n  @Property('显示省市', {\r\n    ui: {\r\n      widget: 'myUrlSelect',\r\n      allowClear: true,\r\n      url: '/assets/mapListItem.json',\r\n    },\r\n  })\r\n  cityName = null;\r\n  point: any;\r\n\r\n  // _data = [\r\n  //   {\r\n  //     options: {\r\n  //       icon: {\r\n  //         imageUrl: 'assets/img/screen/number-flop.png',\r\n  //         size: {\r\n  //           height: 260,\r\n  //           width: 250\r\n  //         }\r\n  //       }\r\n  //     },\r\n  //     point: {\r\n  //       lng: 120.7,   // 经度\r\n  //       lat: 28,    // 纬度\r\n  //     }\r\n  //   },\r\n  // ];\r\n  // 文字标注\r\n\r\n  public text: string;\r\n  // _children = [];\r\n  type: string;\r\n  map: any;\r\n  edit: boolean;\r\n  // markerTierClick: any;\r\n  // pingyang = '';\r\n  // ruian = '';\r\n  @Data({\r\n    properties: {\r\n      lng: { type: 'number', title: '经度' },\r\n      lat: { type: 'number', title: '纬度' },\r\n    },\r\n  })\r\n  _data: any[] = [{ lng: 120.7, lat: 28 }];\r\n  @DataOutput(['lng', 'lat'])\r\n  @Event('中心点改变', {\r\n    params: { properties: { lng: { title: '经度', type: 'number' }, lat: { title: '纬度', type: 'number' } } },\r\n  })\r\n  dataChange = new EventEmitter<any>();\r\n\r\n  @DataOutput('缩放等级')\r\n  @Event('缩放', {\r\n    params: '缩放等级',\r\n  })\r\n  zoomChange = new EventEmitter<any>();\r\n  @Event('地图点击', {\r\n    params: { properties: { lng: { title: '经度', type: 'number' }, lat: { title: '纬度', type: 'number' } } },\r\n  })\r\n  mapClick = new EventEmitter<any>();\r\n\r\n  @ViewChild('container', { static: true })\r\n  container: ElementRef;\r\n  children: any[];\r\n  destroy$ = new Subject();\r\n  destroyed: boolean;\r\n  // containerStyle: any = {};\r\n  // unloadedChildren = {};\r\n  overlaysMap = {};\r\n\r\n  // @HostBinding('class.hideInfoWindowTail')\r\n  // hideInfoWindowTail: boolean;\r\n\r\n  private inited: (map: any) => void;\r\n  init$ = new Promise((resolve) => {\r\n    this.inited = resolve;\r\n  });\r\n  view: any;\r\n  pickerEvent: any;\r\n  pickerItem: any;\r\n  pickerTimeout: any;\r\n  mapTypeEnum = MapTypeEnum.slice(0, 3);\r\n  darkStyle: any;\r\n  firstOpen: boolean;\r\n  firstOpenPromise: Promise<void>;\r\n  constructor(\r\n    private baiduMapService: BaiduMapService,\r\n    private http: HttpClient,\r\n    private elementRef: ElementRef,\r\n    private zone: NgZone,\r\n    @Optional() private scale$: ScaleSubject,\r\n    private cd: ChangeDetectorRef,\r\n    private widgetRef: WidgetRef,\r\n  ) {}\r\n\r\n  get element(): HTMLElement {\r\n    return this.elementRef.nativeElement;\r\n  }\r\n\r\n  addLayer(layer: any) {\r\n    if (this.view) {\r\n      this.view.addLayer(layer);\r\n    }\r\n  }\r\n\r\n  removeLayer(layer: any) {\r\n    if (this.view) {\r\n      this.view.removeLayer(layer);\r\n    }\r\n  }\r\n\r\n  ngOnChanges(changes: SimpleChanges): void {\r\n    if (changes._data && this._data[0]) {\r\n      this.centerLng = +this._data[0].lng;\r\n      this.centerLat = +this._data[0].lat;\r\n      this.setCenter(this.centerLng, this.centerLat);\r\n    }\r\n  }\r\n\r\n  async ngOnInit() {\r\n    if (this.scale$) {\r\n      // 这是为了解决地图缩放中心不在鼠标所在位置的问题\r\n      this.scale$.pipe(takeUntil(this.destroy$)).subscribe((scale) => {\r\n        const { x: sx, y: sy, scaleContent } = scale as any;\r\n        const style = this.element.style;\r\n        if (scaleContent === false) {\r\n          this.zone.onStable.pipe(take(1)).subscribe(() => {\r\n            const parent = this.element.parentNode as HTMLElement;\r\n            if (parent) {\r\n              const match = /translate\\(([-\\d.]+)px, ([-\\d.]+)px\\)/.exec(parent.style.transform);\r\n              if (match) {\r\n                const offsetX = parseFloat(match[1]);\r\n                const offsetY = parseFloat(match[2]);\r\n                style.transform = `translate(${-offsetX}px,${-offsetY}px)`;\r\n                style.height = parent.clientHeight + offsetY + 'px';\r\n                style.width = parent.clientWidth + offsetX + 'px';\r\n                style.padding = `${offsetY}px 0 0 ${offsetX}px`;\r\n                // this.containerStyle = {\r\n                //   transformOrigin: `0 0`,\r\n                //   transform: `translate(${-offsetX}px,${-offsetY}px)`,\r\n                //   height: parent.clientHeight + offsetY + 'px',\r\n                //   width: parent.clientWidth + offsetX + 'px',\r\n                //   padding: `${offsetY}px 0 0 ${offsetX}px`,\r\n                // };\r\n              }\r\n            }\r\n\r\n            // this.cd.markForCheck();\r\n          });\r\n        } else {\r\n          const { position, size } = this.widgetRef.widget as any;\r\n          const { x, y } = position;\r\n          const { width, height } = size;\r\n          style.transform = `translate(${-x}px,${-y}px) scale(${1 / sx},${1 / sy})`;\r\n          style.height = (y + height) * sy + 'px';\r\n          style.width = (x + width) * sx + 'px';\r\n          style.padding = `${y * sy}px 0 0 ${x * sx}px`;\r\n        }\r\n\r\n        // this.cd.markForCheck();\r\n      });\r\n    }\r\n    await this.initMap();\r\n  }\r\n\r\n  async initMap() {\r\n    await this.baiduMapService.loadMapGL();\r\n    await this.baiduMapService.loadMapVGL();\r\n    this.mapTypeValue = this.mapType;\r\n    // 兼容老的配置\r\n    if (this.mapType == null) {\r\n      if (this.uploadStyle) {\r\n        this.mapTypeValue = 'custom';\r\n      } else if (this.nightMode) {\r\n        this.mapTypeValue = 'dark';\r\n      }\r\n    }\r\n    if (!this.destroyed) {\r\n      this.zone.runOutsideAngular(() => {\r\n        this.map = new BMapGL.Map(this.container.nativeElement, { restrictCenter: false });\r\n        this.map.centerAndZoom(new BMapGL.Point(this.centerLng, this.centerLat), this.zoom); // 设置中心点和缩放级别\r\n        this.map.enableScrollWheelZoom(); // 启用滚轮进行缩放功能\r\n        // var dist = new BMapGL.DistrictLayer({\r\n        //   name: '(温州市)',\r\n        //   kind: 1,\r\n        //    fillColor: '#fff',\r\n        //   fillOpacity: 0.1,\r\n        //   strokeColor: '#daeafa',\r\n        //   viewport: true,\r\n        // });\r\n        // this.map.addDistrictLayer(dist);\r\n        this.mapTypeChange(this.mapTypeValue);\r\n        if (this.edit || this.dragging === false) {\r\n          this.map.disableDragging();\r\n        }\r\n        if (this.enable3D) {\r\n          this.map.setTilt(this.tilt == null ? 73 : this.tilt, { noAnimation: true });\r\n          this.map.setDisplayOptions({ skyColors: ['rgba(0, 0, 0, 0)'] }); // 隐藏天空\r\n          // const navi3DCtrl = new BMapGL.NavigationControl3D(); // 添加3D控件\r\n          // this.map.addControl(navi3DCtrl);\r\n        } else {\r\n          this.map.disableTilt();\r\n          this.map.disableRotate();\r\n        }\r\n        if (this.showLocationControl) {\r\n          const options = {\r\n            // 控件的停靠位置（可选，默认左上角）\r\n            anchor: BMAP_ANCHOR_TOP_LEFT,\r\n            // 控件基于停靠位置的偏移量（可选）\r\n            offset: new BMapGL.Size(20, 20),\r\n          };\r\n          let locationControl = new BMapGL.LocationControl(options);\r\n          // 将控件添加到地图上\r\n          this.map.addControl(locationControl);\r\n        }\r\n        if (this.minMapShow) {\r\n          const stCtrl = new BMapGL.PanoramaControl();\r\n          stCtrl.setOffset(new BMapGL.Size(20, 20));\r\n          this.map.addControl(stCtrl);\r\n        }\r\n        if (this.infoWindowBackground) {\r\n          this.element.style.setProperty('--info-window-background', this.infoWindowBackground);\r\n        }\r\n        if (this.infoWindowColor) {\r\n          this.element.style.setProperty('--info-window-color', this.infoWindowColor);\r\n        }\r\n        this.map.addEventListener('moveend', (event) => {\r\n          const center = this.map.getCenter();\r\n          this.dataChange.emit(center);\r\n        });\r\n        this.map.addEventListener('click', (event) => {\r\n          this.mapClick.emit(event.pointer);\r\n        });\r\n        this.map.addEventListener('zoomend', (event) => {\r\n          this.zoomChange.emit(this.map.getZoom());\r\n          this.dataChange.emit(this.map.getCenter());\r\n        });\r\n        this.view = new mapvgl.View({\r\n          map: this.map,\r\n        });\r\n        this.mapLoaded(this.map);\r\n      });\r\n      this.inited(this.map);\r\n    }\r\n  }\r\n\r\n  setCenter(lng: number, lat: number) {\r\n    if (this.map && lng && lat) {\r\n      const center = this.map.getCenter();\r\n      if (center.lng != lng || center.lat != lat) {\r\n        this.setCenterAndZoom(lng, lat, this.map.getZoom());\r\n      }\r\n    }\r\n  }\r\n\r\n  setCenterAndZoom(lng: number, lat: number, zoom: number) {\r\n    const center = this.map.getCenter();\r\n    const currentZoom = this.map.getZoom();\r\n    // 误差范围内不移动,防止背景抖动\r\n    if (zoom != currentZoom || Math.abs(lng - center.lng) > 1e-13 || Math.abs(lat - center.lat) > 1e-7) {\r\n      const point = new BMapGL.Point(lng, lat);\r\n      this.map.centerAndZoom(point, zoom, { tilt: this.map.getTilt() });\r\n    }\r\n  }\r\n\r\n  /**\r\n   * 根据经纬度范围设置中心和缩放等级\r\n   * @param minLng\r\n   * @param maxLng\r\n   * @param minLat\r\n   * @param maxLat\r\n   */\r\n  setRectCenterAndZoom(minLng: number, maxLng: number, minLat: number, maxLat: number) {\r\n    this.setCenterAndZoom((maxLng + minLng) / 2, (maxLat + minLat) / 2, this.getZoom(maxLng, minLng, maxLat, minLat));\r\n  }\r\n\r\n  getZoom(maxLng: number, minLng: number, maxLat: number, minLat: number) {\r\n    const zooms = [\r\n      50, 100, 200, 500, 1000, 2000, 5000, 10000, 20000, 25000, 50000, 100000, 200000, 500000, 1000000, 2000000,\r\n    ]; //级别18到3。\r\n    const pointA = new BMapGL.Point(maxLng, maxLat); // 创建点坐标A\r\n    const pointB = new BMapGL.Point(minLng, minLat); // 创建点坐标B\r\n    const distance = +this.map.getDistance(pointA, pointB).toFixed(1); //获取两点距离,保留小数点后两位\r\n    const i = zooms.findIndex((zoom) => zoom - distance > 0);\r\n    if (i === -1) {\r\n      return 5;\r\n    }\r\n    //之所以会多3，是因为地图范围常常是比例尺距离的10倍以上。所以级别会增加3。\r\n    return 18 - i + 3;\r\n  }\r\n\r\n  openInfoWindow(data: any, lng: number, lat: number) {\r\n    if (data.information || this.infoWindowTemplate) {\r\n      const point = new BMapGL.Point(+lng, +lat);\r\n      // let offsetY = -25;\r\n      // if (this.hideInfoWindowTail) {\r\n      //   offsetY = 0;\r\n      // }\r\n      let information = data.information;\r\n      if (this.infoWindowTemplate) {\r\n        information = TemplateUtil.parse(this.infoWindowTemplate, data);\r\n      }\r\n      const options = {\r\n        offset: new BMapGL.Size(0, 0),\r\n        width: this.infoWindowWidth || 0,\r\n        height: this.infoWindowHeight || 0,\r\n      };\r\n      const infoWindow = new BMapGL.InfoWindow(information, options);\r\n      // 第一次打开信息窗口后在短时间关闭或重新打开会导致click事件失效，临时解决方案是第一次打开后0.5秒内不关闭\r\n      if (!this.firstOpen) {\r\n        if (this.firstOpenPromise) {\r\n          this.firstOpenPromise.then(() => {\r\n            this.map.openInfoWindow(infoWindow, point);\r\n          });\r\n        } else {\r\n          this.firstOpenPromise = new Promise<void>((resolve) => {\r\n            setTimeout(() => {\r\n              this.firstOpen = true;\r\n              this.firstOpenPromise = null;\r\n              resolve();\r\n            }, 500);\r\n          });\r\n          this.map.openInfoWindow(infoWindow, point);\r\n        }\r\n        const rawClose = infoWindow.close;\r\n        infoWindow.close = () => {\r\n          if (this.firstOpenPromise) {\r\n            this.firstOpenPromise.then(() => rawClose.call(infoWindow));\r\n          } else {\r\n            rawClose.call(infoWindow);\r\n          }\r\n        };\r\n      } else {\r\n        this.map.openInfoWindow(infoWindow, point);\r\n      }\r\n      return infoWindow;\r\n    }\r\n  }\r\n\r\n  getCanvasOverlay(child: any) {\r\n    let canvasOverlay;\r\n    if (this.enable3D) {\r\n      const item = child.item;\r\n      if (item) {\r\n        var pStart = new BMapGL.Point(item.start.lng, item.start.lat);\r\n        var pEnd = new BMapGL.Point(item.end.lng, item.end.lat);\r\n        var bounds = new BMapGL.Bounds(new BMapGL.Point(pStart.lng, pEnd.lat), new BMapGL.Point(pEnd.lng, pStart.lat));\r\n        canvasOverlay = new BMapGL.GroundOverlay(bounds, {\r\n          type: 'canvas',\r\n          url: item.canvas,\r\n          opacity: 1,\r\n        });\r\n      }\r\n    } else {\r\n      const pointToPixel = (data) => {\r\n        const point = new BMapGL.Point(data.lng, data.lat);\r\n        return this.map.pointToPixel(point);\r\n      };\r\n      canvasOverlay = new BMapGL.CanvasLayer({\r\n        paneName: 'markerShadow',\r\n        update: function () {\r\n          var ctx = this.canvas.getContext('2d');\r\n          if (!ctx) {\r\n            return;\r\n          }\r\n          ctx.clearRect(0, 0, ctx.canvas.width, ctx.canvas.height);\r\n          child.update(ctx, pointToPixel);\r\n        },\r\n      });\r\n    }\r\n    return canvasOverlay;\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this.destroy$.next();\r\n    this.destroy$.complete();\r\n    this.destroyed = true;\r\n    if (this.view) {\r\n      this.view.destroy();\r\n    }\r\n    if (this.map) {\r\n      this.map.destroy();\r\n    }\r\n  }\r\n\r\n  async mapLoaded(map: any) {\r\n    if (this.cityName) {\r\n      if (this.cityName === '温州') {\r\n        this.cityName = 'wenzhou';\r\n      }\r\n      const json: any = await this.http.get('assets/echarts/map/json/' + this.cityName + '.json').toPromise();\r\n      const polygonData = [];\r\n      let encodeScale = json.UTF8Scale || 1024;\r\n      json.features.forEach(({ geometry }) => {\r\n        geometry.coordinates = (geometry.coordinates as any[]).forEach((coordinate, i) => {\r\n          if (geometry.type === 'MultiPolygon') {\r\n            const coordinates = (coordinate as any[]).map((points, j) => {\r\n              if (json.UTF8Encoding) {\r\n                points = this.decodePolygon(points, geometry.encodeOffsets[i][j], encodeScale);\r\n              }\r\n              return points;\r\n            });\r\n            polygonData.push(coordinates);\r\n          } else {\r\n            if (json.UTF8Encoding) {\r\n              coordinate = this.decodePolygon(coordinate, geometry.encodeOffsets[i], encodeScale);\r\n            }\r\n            polygonData.push([coordinate]);\r\n          }\r\n        });\r\n      });\r\n      const data = [\r\n        {\r\n          geometry: {\r\n            type: 'MultiPolygon',\r\n            coordinates: polygonData,\r\n          },\r\n        },\r\n      ];\r\n      var layer = new mapvgl.PolygonLayer({\r\n        lineColor: this.mapCityColor,\r\n        lineWidth: this.strokesize || 2,\r\n        fillColor: this.shadeColor,\r\n        data,\r\n        renderOrder: -2,\r\n      });\r\n      this.view.addLayer(layer);\r\n      if (this.mapBackColor && !this.mapBackColor.match(/rgba\\(\\d+,\\d+,\\d+,0\\)/)) {\r\n        var maskLayer = new mapvgl.MaskLayer({\r\n          color: this.mapBackColor,\r\n          data,\r\n          renderOrder: -3,\r\n        });\r\n        this.view.addLayer(maskLayer);\r\n      }\r\n    }\r\n  }\r\n\r\n  decodePolygon(coordinate: string, encodeOffsets: number[], encodeScale: number) {\r\n    const result = [];\r\n    let prevX = encodeOffsets[0];\r\n    let prevY = encodeOffsets[1];\r\n\r\n    for (let i = 0; i < coordinate.length; i += 2) {\r\n      var x = coordinate.charCodeAt(i) - 64;\r\n      var y = coordinate.charCodeAt(i + 1) - 64;\r\n      // ZigZag decoding\r\n      x = (x >> 1) ^ -(x & 1);\r\n      y = (y >> 1) ^ -(y & 1);\r\n      // Delta deocding\r\n      x += prevX;\r\n      y += prevY;\r\n\r\n      prevX = x;\r\n      prevY = y;\r\n      // Dequantize\r\n      result.push([x / encodeScale, y / encodeScale]);\r\n    }\r\n\r\n    return result;\r\n  }\r\n\r\n  async mapTypeChange(mapType: string) {\r\n    switch (mapType) {\r\n      case 'dark':\r\n        if (!this.darkStyle) {\r\n          this.darkStyle = await this.http.get('assets/echarts/map/json/custom_map.json').toPromise();\r\n        }\r\n        this.map.setMapType(BMAP_NORMAL_MAP);\r\n        this.map.setMapStyleV2({ styleJson: this.darkStyle });\r\n        break;\r\n      case 'satellite':\r\n        this.map.setMapType(BMAP_SATELLITE_MAP);\r\n        break;\r\n      case 'custom':\r\n        if (this.uploadStyle) {\r\n          const styleJson = await this.http.get(this.uploadStyle).toPromise();\r\n          this.map.setMapType(BMAP_NORMAL_MAP);\r\n          this.map.setMapStyleV2({ styleJson });\r\n        }\r\n        break;\r\n      default:\r\n        this.map.setMapType(BMAP_NORMAL_MAP);\r\n        this.map.setMapStyleV2({ styleJson: null });\r\n    }\r\n  }\r\n}\r\n"]}