@smartbit4all/ng-client 5.0.21 → 6.0.1

package/esm2022/lib/smart-map/impl/google-map.mjs

@@ -0,0 +1,224 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, ViewEncapsulation, } from '@angular/core';
+import { AbstractMap } from '../abstract-map';
+import { GeoMapItemKind } from '../api';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+function createGoogleMapsItem(item, config) {
+    switch (item.kind) {
+        case GeoMapItemKind.MARKER:
+            return new google.maps.Marker({
+                position: {
+                    lat: item.position.latitude,
+                    lng: item.position.longitude,
+                },
+                title: item.label,
+            });
+        case GeoMapItemKind.LINE:
+            return new google.maps.Polyline({
+                path: item.route.points.map((it) => {
+                    return { lat: it.latitude, lng: it.longitude };
+                }),
+                geodesic: true,
+                strokeColor: '#FF0000',
+                strokeOpacity: 0.5,
+                strokeWeight: 2,
+            });
+        case GeoMapItemKind.POLYGON:
+            return new google.maps.Polygon({
+                path: item.route.points.map((it) => {
+                    return { lat: it.latitude, lng: it.longitude };
+                }),
+                strokeOpacity: 0.5,
+                storeWeight: 1,
+                fillColor: '#1976D2',
+                fillOpacity: 0.35,
+            });
+    }
+    return null;
+}
+export class GoogleMap extends AbstractMap {
+    constructor(el, cd, zone) {
+        super(el, cd, zone, createGoogleMapsItem);
+        this.onOverlayDblClick = new EventEmitter();
+        this.onOverlayDragStart = new EventEmitter();
+        this.onOverlayDrag = new EventEmitter();
+        this.onOverlayDragEnd = new EventEmitter();
+        this.onMapReady = new EventEmitter();
+    }
+    ngAfterViewChecked() {
+        if (!this.map && this.el.nativeElement.offsetParent) {
+            this.initialize();
+        }
+    }
+    initialize() {
+        this.map = new google.maps.Map(this.el.nativeElement.children[0], this.createGoogleMapsOptions());
+        const items = this.items();
+        const toAdd = items.map((it) => ({
+            id: it.id,
+            record: createGoogleMapsItem(it, { color: '#3388ff', draggable: false }),
+        }));
+        this.handleItemChanges([], toAdd);
+        this.onMapReady.emit({
+            map: this.map,
+        });
+        this.map.addListener('click', (event) => {
+            this.zone.run(() => {
+                const center = this.map.getCenter(); // FIXME get actual coordinates
+                this.onMapClick.emit({
+                    coordinates: {
+                        latitude: center.lat,
+                        longitude: center.lng,
+                    },
+                    originalEvent: event,
+                });
+            });
+        });
+        this.map.addListener('dragend', (event) => {
+            this.zone.run(() => {
+                const center = this.map.getCenter();
+                const zoom = this.map.getZoom();
+                const bounds = this.map.getBounds();
+                const ne = bounds.getNorthEast();
+                const sw = bounds.getSouthWest();
+                this.onMapDragEnd.emit({
+                    originalEvent: event,
+                    viewport: {
+                        center: {
+                            latitude: center.lat,
+                            longitude: center.lng,
+                        },
+                        zoomLevel: zoom,
+                        bounds: [
+                            { latitude: ne.lat, longitude: ne.lng },
+                            { latitude: sw.lat, longitude: sw.lng },
+                        ],
+                    },
+                });
+            });
+        });
+        this.map.addListener('zoom_changed', (event) => {
+            this.zone.run(() => {
+                this.onZoomChanged.emit({
+                    viewport: {
+                        zoomLevel: this.map.getZoom(),
+                        ...this.model().viewport,
+                    },
+                    originalEvent: event,
+                });
+            });
+        });
+    }
+    createGoogleMapsOptions() {
+        const viewport = this.model().viewport;
+        return {
+            center: {
+                lat: viewport.center?.latitude,
+                lng: viewport.center?.longitude,
+            },
+            zoom: viewport.zoomLevel,
+        };
+    }
+    handleItemChanges(toRemove, toAdd) {
+        if (!this.map) {
+            return;
+        }
+        toRemove.forEach((it) => {
+            google.maps.event.clearInstanceListeners(it.record.item);
+            it.record.item.setMap(null);
+            this.overlays.delete(it.id);
+        });
+        toAdd.forEach((it) => {
+            it.record.item.setMap(this.map);
+            it.record.item.addListener('click', (event) => {
+                this.zone.run(() => {
+                    this.onOverlayClick.emit({
+                        itemId: it.id,
+                        originalEvent: {
+                            originalEvent: event,
+                            overlay: it.record.item,
+                            map: this.map,
+                        },
+                    });
+                });
+            });
+            it.record.item.addListener('dblclick', (event) => {
+                this.zone.run(() => {
+                    this.onOverlayDblClick.emit({
+                        originalEvent: event,
+                        overlay: it,
+                        map: this.map,
+                    });
+                });
+            });
+            if (it.record.item.getDraggable()) {
+                this.bindDragEvents(it.record.item);
+            }
+            this.overlays.set(it.id, it.record);
+        });
+    }
+    handleEditingItemChanges(toRemove, toAdd) { }
+    bindDragEvents(overlay) {
+        overlay.addListener('dragstart', (event) => {
+            this.zone.run(() => {
+                this.onOverlayDragStart.emit({
+                    originalEvent: event,
+                    overlay: overlay,
+                    map: this.map,
+                });
+            });
+        });
+        overlay.addListener('drag', (event) => {
+            this.zone.run(() => {
+                this.onOverlayDrag.emit({
+                    originalEvent: event,
+                    overlay: overlay,
+                    map: this.map,
+                });
+            });
+        });
+        overlay.addListener('dragend', (event) => {
+            this.zone.run(() => {
+                this.onOverlayDragEnd.emit({
+                    originalEvent: event,
+                    overlay: overlay,
+                    map: this.map,
+                });
+            });
+        });
+    }
+    getMap() {
+        return this.map;
+    }
+    toBase64() {
+        throw new Error('Method not implemented.');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: GoogleMap, deps: [{ token: i0.ElementRef }, { token: i0.ChangeDetectorRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.11", type: GoogleMap, selector: "google-map", inputs: { style: "style", styleClass: "styleClass" }, outputs: { onOverlayDblClick: "onOverlayDblClick", onOverlayDragStart: "onOverlayDragStart", onOverlayDrag: "onOverlayDrag", onOverlayDragEnd: "onOverlayDragEnd", onMapReady: "onMapReady" }, host: { classAttribute: "p-element" }, usesInheritance: true, ngImport: i0, template: ` <div [ngStyle]="style" [class]="styleClass"></div>`, isInline: true, dependencies: [{ kind: "directive", type: i1.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: GoogleMap, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'google-map',
+                    template: ` <div [ngStyle]="style" [class]="styleClass"></div>`,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    encapsulation: ViewEncapsulation.None,
+                    host: {
+                        class: 'p-element', // this is fancy, but can we use it actually?
+                    },
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.ChangeDetectorRef }, { type: i0.NgZone }], propDecorators: { style: [{
+                type: Input
+            }], styleClass: [{
+                type: Input
+            }], onOverlayDblClick: [{
+                type: Output
+            }], onOverlayDragStart: [{
+                type: Output
+            }], onOverlayDrag: [{
+                type: Output
+            }], onOverlayDragEnd: [{
+                type: Output
+            }], onMapReady: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"google-map.js","sourceRoot":"","sources":["../../../../../../projects/smart-ng-client/src/lib/smart-map/impl/google-map.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewChecked,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ElementRef,\n  EventEmitter,\n  Input,\n  NgZone,\n  Output,\n  ViewEncapsulation,\n} from '@angular/core';\nimport { AbstractMap, RecordWithId } from '../abstract-map';\nimport { GeoMapItem, GeoMapItemKind, GeoMapViewport } from '../api';\nimport { MapItemConfiguration } from '../smart-map.types';\n\ndeclare var google: any;\n\nfunction createGoogleMapsItem(item: GeoMapItem, config: MapItemConfiguration): any {\n  switch (item.kind) {\n    case GeoMapItemKind.MARKER:\n      return new google.maps.Marker({\n        position: {\n          lat: item.position!.latitude,\n          lng: item.position!.longitude,\n        },\n        title: item.label,\n      });\n    case GeoMapItemKind.LINE:\n      return new google.maps.Polyline({\n        path: item.route!.points.map((it) => {\n          return { lat: it.latitude, lng: it.longitude };\n        }),\n        geodesic: true,\n        strokeColor: '#FF0000',\n        strokeOpacity: 0.5,\n        strokeWeight: 2,\n      });\n    case GeoMapItemKind.POLYGON:\n      return new google.maps.Polygon({\n        path: item.route!.points.map((it) => {\n          return { lat: it.latitude, lng: it.longitude };\n        }),\n        strokeOpacity: 0.5,\n        storeWeight: 1,\n        fillColor: '#1976D2',\n        fillOpacity: 0.35,\n      });\n  }\n  return null;\n}\n\n@Component({\n  selector: 'google-map',\n  template: ` <div [ngStyle]=\"style\" [class]=\"styleClass\"></div>`,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  encapsulation: ViewEncapsulation.None,\n  host: {\n    class: 'p-element', // this is fancy, but can we use it actually?\n  },\n})\nexport class GoogleMap extends AbstractMap implements AfterViewChecked {\n  @Input() style?: any;\n  @Input() styleClass?: string;\n\n  @Output() onOverlayDblClick: EventEmitter<any> = new EventEmitter();\n  @Output() onOverlayDragStart: EventEmitter<any> = new EventEmitter();\n  @Output() onOverlayDrag: EventEmitter<any> = new EventEmitter();\n  @Output() onOverlayDragEnd: EventEmitter<any> = new EventEmitter();\n  @Output() onMapReady: EventEmitter<any> = new EventEmitter();\n\n  constructor(el: ElementRef, cd: ChangeDetectorRef, zone: NgZone) {\n    super(el, cd, zone, createGoogleMapsItem);\n  }\n\n  ngAfterViewChecked() {\n    if (!this.map && this.el.nativeElement.offsetParent) {\n      this.initialize();\n    }\n  }\n\n  private initialize(): void {\n    this.map = new google.maps.Map(\n      this.el.nativeElement.children[0],\n      this.createGoogleMapsOptions()\n    );\n    const items = this.items();\n    const toAdd: Array<RecordWithId> = items.map((it) => ({\n      id: it.id!,\n      record: createGoogleMapsItem(it, { color: '#3388ff', draggable: false }),\n    }));\n    this.handleItemChanges([], toAdd);\n\n    this.onMapReady.emit({\n      map: this.map,\n    });\n\n    this.map.addListener('click', (event: any) => {\n      this.zone.run(() => {\n        const center = this.map.getCenter(); // FIXME get actual coordinates\n        this.onMapClick.emit({\n          coordinates: {\n            latitude: center.lat as number,\n            longitude: center.lng as number,\n          },\n          originalEvent: event,\n        });\n      });\n    });\n\n    this.map.addListener('dragend', (event: any) => {\n      this.zone.run(() => {\n        const center = this.map.getCenter();\n        const zoom = this.map.getZoom();\n        const bounds = this.map.getBounds();\n        const ne = bounds.getNorthEast();\n        const sw = bounds.getSouthWest();\n        this.onMapDragEnd.emit({\n          originalEvent: event,\n          viewport: {\n            center: {\n              latitude: center.lat as number,\n              longitude: center.lng as number,\n            },\n            zoomLevel: zoom as number,\n            bounds: [\n              { latitude: ne.lat, longitude: ne.lng },\n              { latitude: sw.lat, longitude: sw.lng },\n            ],\n          },\n        });\n      });\n    });\n\n    this.map.addListener('zoom_changed', (event: any) => {\n      this.zone.run(() => {\n        this.onZoomChanged.emit({\n          viewport: {\n            zoomLevel: this.map.getZoom() as number,\n            ...this.model().viewport!,\n          },\n          originalEvent: event,\n        });\n      });\n    });\n  }\n\n  private createGoogleMapsOptions(): any {\n    const viewport: GeoMapViewport = this.model().viewport!;\n    return {\n      center: {\n        lat: viewport.center?.latitude,\n        lng: viewport.center?.longitude,\n      },\n      zoom: viewport.zoomLevel,\n    };\n  }\n\n  override handleItemChanges(toRemove: Array<RecordWithId>, toAdd: Array<RecordWithId>): void {\n    if (!this.map) {\n      return;\n    }\n    toRemove.forEach((it: RecordWithId) => {\n      google.maps.event.clearInstanceListeners(it.record.item);\n      it.record.item.setMap(null);\n      this.overlays.delete(it.id);\n    });\n\n    toAdd.forEach((it: RecordWithId) => {\n      it.record.item.setMap(this.map);\n      it.record.item.addListener('click', (event: any) => {\n        this.zone.run(() => {\n          this.onOverlayClick.emit({\n            itemId: it.id,\n            originalEvent: {\n              originalEvent: event,\n              overlay: it.record.item,\n              map: this.map,\n            },\n          });\n        });\n      });\n      it.record.item.addListener('dblclick', (event: any) => {\n        this.zone.run(() => {\n          this.onOverlayDblClick.emit({\n            originalEvent: event,\n            overlay: it,\n            map: this.map,\n          });\n        });\n      });\n\n      if (it.record.item.getDraggable()) {\n        this.bindDragEvents(it.record.item);\n      }\n      this.overlays.set(it.id, it.record);\n    });\n  }\n\n  override handleEditingItemChanges(\n    toRemove: Array<RecordWithId>,\n    toAdd: Array<RecordWithId>\n  ): void {}\n\n  bindDragEvents(overlay: any) {\n    overlay.addListener('dragstart', (event: any) => {\n      this.zone.run(() => {\n        this.onOverlayDragStart.emit({\n          originalEvent: event,\n          overlay: overlay,\n          map: this.map,\n        });\n      });\n    });\n\n    overlay.addListener('drag', (event: any) => {\n      this.zone.run(() => {\n        this.onOverlayDrag.emit({\n          originalEvent: event,\n          overlay: overlay,\n          map: this.map,\n        });\n      });\n    });\n\n    overlay.addListener('dragend', (event: any) => {\n      this.zone.run(() => {\n        this.onOverlayDragEnd.emit({\n          originalEvent: event,\n          overlay: overlay,\n          map: this.map,\n        });\n      });\n    });\n  }\n\n  getMap() {\n    return this.map;\n  }\n\n  override toBase64(): Promise<string> {\n    throw new Error('Method not implemented.');\n  }\n}\n"]}