@smartbit4all/ng-client 5.0.21 → 6.0.1

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

@@ -0,0 +1,422 @@
+import { Component } from '@angular/core';
+import { AbstractMap } from '../abstract-map';
+import { GeoMapItemKind } from '../api';
+import * as i0 from "@angular/core";
+function createLeafletMapItem(item, config) {
+    let color = item.color ?? config.color;
+    switch (item.kind) {
+        case GeoMapItemKind.MARKER:
+            let marker = L.marker(L.latLng(item.position.latitude, item.position.longitude), {
+                draggable: config.draggable,
+            }).bindTooltip(item.label, {
+                permanent: item.permanentLabel ?? false,
+                direction: 'auto',
+            });
+            marker.originalLatLng = L.latLng(item.position.latitude, item.position.longitude); //
+            return marker;
+        case GeoMapItemKind.POLYGON:
+            const polygonRoutePoints = item.route.points;
+            return L.layerGroup([
+                L.polygon(polygonRoutePoints.map((p) => [p.latitude, p.longitude]), { title: item.label, color: color }),
+                ...polygonRoutePoints.map((p) => L.marker([p.latitude, p.longitude], {
+                    title: item.label,
+                    markerColor: color,
+                    draggable: config.draggable,
+                    icon: getIcon(color),
+                })),
+            ]);
+        case GeoMapItemKind.LINE:
+            const lineRoutePoints = item.route.points;
+            return L.layerGroup([
+                L.polyline(lineRoutePoints.map((p) => [p.latitude, p.longitude]), { title: item.label, color: color }),
+                ...lineRoutePoints.map((p) => L.marker([p.latitude, p.longitude], {
+                    title: item.label,
+                    color: color,
+                    draggable: config.draggable,
+                    icon: getIcon(color),
+                })),
+            ]);
+    }
+}
+export class LeafletMap extends AbstractMap {
+    constructor(el, cd, zone) {
+        super(el, cd, zone, createLeafletMapItem);
+        this.offsetDistance = 0.00004;
+        this.markers = [];
+    }
+    ngAfterViewChecked() {
+        if (!this.map && this.el.nativeElement.offsetParent) {
+            this.initialize();
+        }
+    }
+    initialize() {
+        const options = this.createLeafletMapOptions();
+        this.map = L.map('leaflet', { preferCanvas: true }).setView(options.centre, options.zoom);
+        L.tileLayer('https://tile.openstreetmap.org/{z}/{x}/{y}.png', {
+            maxZoom: 19,
+            attribution: '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a>',
+        }).addTo(this.map);
+        const items = this.items();
+        const toAdd = items.map((it) => ({
+            id: it.id,
+            record: createLeafletMapItem(it, { color: '#3388ff', draggable: false }),
+        }));
+        this.handleItemChanges([], toAdd);
+        const model = this.model();
+        if (model.viewState?.fitToInitialItems) {
+            const datasetBounds = this.findDatasetBounds();
+            if (datasetBounds) {
+                const { a, b } = datasetBounds;
+                const pntA = L.latLng(a.x, a.y);
+                const pntB = L.latLng(b.x, b.y);
+                const bounds = L.latLngBounds(pntA, pntB);
+                this.zone.run(() => {
+                    this.map.fitBounds(bounds);
+                });
+            }
+        }
+        this.map.on('click', (event) => {
+            this.zone.run(() => {
+                const pos = event.latlng;
+                this.onMapClick.emit({
+                    coordinates: {
+                        latitude: pos.lat,
+                        longitude: pos.lng,
+                    },
+                    originalEvent: event,
+                });
+            });
+        });
+        this.map.on('moveend', (event) => {
+            this.zone.run(() => {
+                const viewport = this.getViewport();
+                this.onMapDragEnd.emit({
+                    viewport,
+                    originalEvent: event,
+                });
+            });
+        });
+        this.map.on('zoomend', (event) => {
+            this.zone.run(() => {
+                const viewport = this.getViewport();
+                this.onMapDragEnd.emit({
+                    viewport,
+                    originalEvent: event,
+                });
+            });
+        });
+    }
+    getViewport() {
+        if (!this.map) {
+            throw new Error('Map is not yet initialised!');
+        }
+        const center = this.map.getCenter();
+        const zoomLevel = this.map.getZoom();
+        const leafletBounds = this.map.getBounds();
+        const { lat: swLat, lng: swLng } = leafletBounds.getSouthWest();
+        const { lat: neLat, lng: neLng } = leafletBounds.getNorthEast();
+        return {
+            center: {
+                latitude: center.lat,
+                longitude: center.lng,
+            },
+            zoomLevel,
+            bounds: [
+                { latitude: swLat, longitude: swLng },
+                { latitude: neLat, longitude: neLng },
+            ],
+        };
+    }
+    createLeafletMapOptions() {
+        const viewport = this.model().viewport;
+        return {
+            centre: [viewport.center.latitude, viewport.center.longitude],
+            zoom: viewport.zoomLevel,
+        };
+    }
+    handleItemChanges(toRemove, toAdd) {
+        if (!this.map) {
+            return;
+        }
+        this.markers = [];
+        const markerGroups = new Map();
+        toAdd.forEach((item) => {
+            if (item.record instanceof L.Marker) {
+                const key = item.record.getLatLng().lat.toFixed(6) + ',' + item.record.getLatLng().lng.toFixed(6);
+                if (!markerGroups.get(key)) {
+                    markerGroups.set(key, []);
+                }
+                markerGroups.get(key).push(item.record);
+            }
+        });
+        toRemove.forEach((it) => {
+            it.record.remove();
+            this.overlays.delete(it.id);
+        });
+        toAdd.forEach((it, index) => {
+            let record = it.record;
+            if (record instanceof L.LayerGroup) {
+                Object.values(record._layers).forEach((at) => {
+                    at.on('click', (event) => {
+                        this.zone.run(() => {
+                            this.onOverlayClick.emit({
+                                itemId: it.id,
+                                originalEvent: {
+                                    originalEvent: event,
+                                    overlay: it.record,
+                                    map: this.map,
+                                },
+                            });
+                        });
+                    });
+                });
+            }
+            else {
+                it.record.on('click', (event) => {
+                    this.zone.run(() => {
+                        this.onOverlayClick.emit({
+                            itemId: it.id,
+                            originalEvent: {
+                                originalEvent: event,
+                                overlay: it.record,
+                                map: this.map,
+                            },
+                        });
+                    });
+                });
+                let group = markerGroups.get(it.record.getLatLng().lat.toFixed(6) + ',' + it.record.getLatLng().lng.toFixed(6));
+                if (group && group.length > 1) {
+                    const icon = this.createNumberedIcon(group.length);
+                    const label = this.createLabel(group);
+                    const extraMarker = L.marker(group[0].originalLatLng, { icon });
+                    if (!extraMarker._tooltip) {
+                        extraMarker.bindTooltip(label, {
+                            permanent: false,
+                            direction: 'auto',
+                        });
+                        this.markers.push(extraMarker);
+                    }
+                    const clusterMarker = extraMarker.addTo(this.map);
+                    it.record.on('mouseover', (_event) => {
+                        toAdd.forEach((item, index) => {
+                            if (item.record instanceof L.Marker &&
+                                item.record.originalLatLng.lat == it.record.originalLatLng.lat &&
+                                item.record.originalLatLng.lng == it.record.originalLatLng.lng) {
+                                it.record.setZIndexOffset(1000);
+                                const angle = ((360 / toAdd.length) * index * Math.PI) / 180;
+                                const newLat = item.record.originalLatLng.lat + this.offsetDistance * Math.cos(angle);
+                                const newLng = item.record.originalLatLng.lng + this.offsetDistance * Math.sin(angle);
+                                item.record.setLatLng([newLat, newLng]);
+                            }
+                        });
+                        if (this.map.hasLayer(clusterMarker)) {
+                            this.map.removeLayer(clusterMarker);
+                        }
+                    });
+                    it.record.on('mouseout', (_event) => {
+                        toAdd.forEach((item, _index) => {
+                            if (item.record instanceof L.Marker) {
+                                item.record.setLatLng(item.record.originalLatLng);
+                                it.record.setZIndexOffset(0);
+                            }
+                        });
+                        if (!this.map.hasLayer(clusterMarker)) {
+                            clusterMarker.addTo(this.map);
+                        }
+                    });
+                }
+                else {
+                    this.markers.push(it.record);
+                }
+            }
+            it.record.addTo(this.map);
+            this.overlays.set(it.id, it.record);
+        });
+    }
+    handleEditingItemChanges(toRemove, toAdd) {
+        if (!this.map) {
+            return;
+        }
+        toRemove.forEach((it) => {
+            it.record.remove();
+            this.editingOverlays.delete(it.id);
+        });
+        toAdd.forEach((it) => {
+            let record = it.record;
+            if (record instanceof L.LayerGroup) {
+                Object.values(record._layers).forEach((at) => {
+                    at.on('click', (event) => {
+                        this.zone.run(() => {
+                            this.onEditingOverlayClick.emit({
+                                itemId: it.id,
+                                coord: {
+                                    x: event.latlng.lng,
+                                    y: event.latlng.lat,
+                                },
+                            });
+                        });
+                    });
+                    at.on('dragstart', (event) => {
+                        this.originalLatLng = event.target.getLatLng();
+                    });
+                    at.on('dragend', (event) => {
+                        this.zone.run(() => {
+                            this.onEditingOverlayDrag.emit({
+                                itemId: it.id,
+                                startPosition: {
+                                    x: this.originalLatLng.lng,
+                                    y: this.originalLatLng.lat,
+                                },
+                                dragTo: {
+                                    x: event.target.getLatLng().lng,
+                                    y: event.target.getLatLng().lat,
+                                },
+                            });
+                        });
+                        this.originalLatLng = null;
+                    });
+                });
+            }
+            else {
+                it.record.on('click', (event) => {
+                    this.zone.run(() => {
+                        this.onEditingOverlayClick.emit({
+                            itemId: it.id,
+                            coord: {
+                                x: event.latlng.lng,
+                                y: event.latlng.lat,
+                            },
+                        });
+                    });
+                });
+            }
+            it.record.addTo(this.map);
+            this.editingOverlays.set(it.id, it.record);
+        });
+    }
+    findDatasetBounds() {
+        const items = this.items()
+            .flatMap((it) => (it.position ? [it.position] : it.route ? it.route.points : []))
+            .map((it) => {
+            return { x: it.latitude, y: it.longitude };
+        });
+        if (!items || items.length === 0) {
+            return null;
+        }
+        let southwest = { x: items[0].x, y: items[0].y };
+        let northeast = { x: items[0].x, y: items[0].y };
+        items.forEach((it) => {
+            if (it.x < southwest.x)
+                southwest.x = it.x;
+            if (it.y < southwest.y)
+                southwest.y = it.y;
+            if (it.x > northeast.x)
+                northeast.x = it.x;
+            if (it.y > northeast.y)
+                northeast.y = it.y;
+        });
+        return { a: southwest, b: northeast };
+    }
+    toBase64() {
+        return new Promise((resolve, reject) => {
+            setTimeout(() => {
+                leafletImage(this.map, (err, canvas) => {
+                    if (err) {
+                        console.error('Leaflet image capture error', err);
+                        reject(err);
+                        return;
+                    }
+                    const ctx = canvas.getContext('2d');
+                    if (!ctx) {
+                        reject('No context');
+                        return;
+                    }
+                    this.markers.forEach((marker) => {
+                        const tooltip = marker.getTooltip();
+                        if (!tooltip) {
+                            return;
+                        }
+                        const latLng = marker.getLatLng();
+                        const point = this.map.latLngToContainerPoint(latLng);
+                        const text = tooltip.getContent();
+                        // Tooltip szöveg megjelenítése
+                        ctx.font = 'bold 30px sans-serif';
+                        ctx.fillStyle = 'black';
+                        ctx.strokeStyle = 'white';
+                        ctx.lineWidth = 4;
+                        ctx.textAlign = 'center';
+                        ctx.textBaseline = 'bottom';
+                        ctx.strokeText(text, point.x, point.y + 10); // fehér kontúr
+                        ctx.fillText(text, point.x, point.y + 10); // fekete szöveg
+                    });
+                    resolve(canvas.toDataURL('image/png'));
+                });
+            }, 300);
+        });
+    }
+    createLabel(group) {
+        let label = '';
+        group.forEach((item) => {
+            label += item._tooltip._content + ', ';
+            item._tooltip.permanent = false;
+        });
+        return label;
+    }
+    createNumberedIcon(number) {
+        const size = 35;
+        const scaleFactor = 15;
+        const scaledSize = size * scaleFactor;
+        const canvas = document.createElement('canvas');
+        canvas.width = scaledSize;
+        canvas.height = scaledSize;
+        canvas.style.width = canvas.style.height = '35px';
+        const ctx = canvas.getContext('2d');
+        ctx.scale(scaleFactor, scaleFactor);
+        ctx.beginPath();
+        ctx.arc(size / 2, size / 2, size / 2 - 2, 0, 2 * Math.PI, false);
+        ctx.fillStyle = '#0078d4';
+        ctx.fill();
+        ctx.lineWidth = 2;
+        ctx.strokeStyle = '#ffffff';
+        ctx.stroke();
+        ctx.fillStyle = '#ffffff';
+        ctx.font = 'bold 16px sans-serif';
+        ctx.textAlign = 'center';
+        ctx.textBaseline = 'middle';
+        ctx.fillText(number.toString(), size / 2, size / 2);
+        return L.icon({
+            iconUrl: canvas.toDataURL(),
+            iconSize: [size, size],
+            iconAnchor: [size / 2, size / 2],
+            popupAnchor: [0, -size / 2],
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: LeafletMap, 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: LeafletMap, selector: "leaflet-map", usesInheritance: true, ngImport: i0, template: ` <div id="leaflet"></div>`, isInline: true, styles: ["#leaflet{height:720px}::ng-deep .marker-count{background-color:#0078d4;color:#fff;font-weight:700;border-radius:50%;width:30px;height:30px;line-height:30px;text-align:center;border:2px solid white;box-shadow:0 0 4px #0006}::ng-deep .custom-cluster-icon{pointer-events:auto!important}\n"] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: LeafletMap, decorators: [{
+            type: Component,
+            args: [{ selector: 'leaflet-map', template: ` <div id="leaflet"></div>`, styles: ["#leaflet{height:720px}::ng-deep .marker-count{background-color:#0078d4;color:#fff;font-weight:700;border-radius:50%;width:30px;height:30px;line-height:30px;text-align:center;border:2px solid white;box-shadow:0 0 4px #0006}::ng-deep .custom-cluster-icon{pointer-events:auto!important}\n"] }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.ChangeDetectorRef }, { type: i0.NgZone }] });
+function getIcon(color) {
+    const size = 12;
+    const scaleFactor = 12;
+    const scaledSize = size * scaleFactor;
+    const canvas = document.createElement('canvas');
+    canvas.width = scaledSize;
+    canvas.height = scaledSize;
+    canvas.style.width = canvas.style.height = `${size}px`;
+    const ctx = canvas.getContext('2d');
+    ctx.scale(scaleFactor, scaleFactor);
+    ctx.beginPath();
+    ctx.arc(size / 2, size / 2, size / 2, 0, 2 * Math.PI, false);
+    ctx.fillStyle = color;
+    ctx.fill();
+    return L.icon({
+        iconUrl: canvas.toDataURL(),
+        iconSize: [size, size],
+        iconAnchor: [size / 2, size / 2],
+        popupAnchor: [0, -size / 2],
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"leaflet-map.js","sourceRoot":"","sources":["../../../../../../projects/smart-ng-client/src/lib/smart-map/impl/leaflet-map.ts"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewChecked, ChangeDetectorRef, Component, ElementRef, NgZone } from '@angular/core';\nimport { AbstractMap, RecordWithId } from '../abstract-map';\nimport { GeoMapItem, GeoMapItemKind, GeoMapViewport } from '../api';\nimport { Coord, MapItemConfiguration } from '../smart-map.types';\nimport { I } from '@angular/cdk/keycodes';\n\ndeclare var L: any;\ndeclare const leafletImage: any;\n\ninterface LeafletMapOptions {\n  centre: Array<number>;\n  zoom: number;\n}\n\nfunction createLeafletMapItem(item: GeoMapItem, config: MapItemConfiguration): any {\n  let color = item.color ?? config.color;\n  switch (item.kind) {\n    case GeoMapItemKind.MARKER:\n      let marker = L.marker(L.latLng(item.position!.latitude, item.position!.longitude), {\n        draggable: config.draggable,\n      }).bindTooltip(item.label, {\n        permanent: item.permanentLabel ?? false,\n        direction: 'auto',\n      });\n      marker.originalLatLng = L.latLng(item.position!.latitude, item.position!.longitude); //\n      return marker;\n    case GeoMapItemKind.POLYGON:\n      const polygonRoutePoints = item.route!.points;\n      return L.layerGroup([\n        L.polygon(\n          polygonRoutePoints.map((p) => [p.latitude, p.longitude]),\n          { title: item.label, color: color }\n        ),\n        ...polygonRoutePoints.map((p) =>\n          L.marker([p.latitude, p.longitude], {\n            title: item.label,\n            markerColor: color,\n            draggable: config.draggable,\n            icon: getIcon(color),\n          })\n        ),\n      ]);\n    case GeoMapItemKind.LINE:\n      const lineRoutePoints = item.route!.points;\n\n      return L.layerGroup([\n        L.polyline(\n          lineRoutePoints.map((p) => [p.latitude, p.longitude]),\n          { title: item.label, color: color }\n        ),\n        ...lineRoutePoints.map((p) =>\n          L.marker([p.latitude, p.longitude], {\n            title: item.label,\n            color: color,\n            draggable: config.draggable,\n            icon: getIcon(color),\n          })\n        ),\n      ]);\n  }\n}\n\n@Component({\n  selector: 'leaflet-map',\n  template: ` <div id=\"leaflet\"></div>`,\n  styles: `\n      #leaflet {\n          height: 720px;\n      }\n     ::ng-deep .marker-count {\n          background-color: #0078d4;\n          color: white;\n          font-weight: bold;\n          border-radius: 50%;\n          width: 30px;\n          height: 30px;\n          line-height: 30px;\n          text-align: center;\n          border: 2px solid white;\n          box-shadow: 0 0 4px rgba(0,0,0,0.4);\n    }\n     ::ng-deep .custom-cluster-icon {\n          pointer-events: auto !important;\n    }`,\n})\nexport class LeafletMap extends AbstractMap implements AfterViewChecked {\n  originalLatLng: any;\n  offsetDistance = 0.00004;\n  markers: any = [];\n  constructor(el: ElementRef, cd: ChangeDetectorRef, zone: NgZone) {\n    super(el, cd, zone, createLeafletMapItem);\n  }\n\n  ngAfterViewChecked(): void {\n    if (!this.map && this.el.nativeElement.offsetParent) {\n      this.initialize();\n    }\n  }\n\n  private initialize(): void {\n    const options = this.createLeafletMapOptions();\n    this.map = L.map('leaflet', { preferCanvas: true }).setView(options.centre, options.zoom);\n    L.tileLayer('https://tile.openstreetmap.org/{z}/{x}/{y}.png', {\n      maxZoom: 19,\n      attribution: '&copy; <a href=\"http://www.openstreetmap.org/copyright\">OpenStreetMap</a>',\n    }).addTo(this.map);\n\n    const items = this.items();\n    const toAdd: Array<RecordWithId> = items.map((it) => ({\n      id: it.id!,\n      record: createLeafletMapItem(it, { color: '#3388ff', draggable: false }),\n    }));\n    this.handleItemChanges([], toAdd);\n    const model = this.model();\n    if (model.viewState?.fitToInitialItems) {\n      const datasetBounds = this.findDatasetBounds();\n      if (datasetBounds) {\n        const { a, b } = datasetBounds;\n        const pntA = L.latLng(a.x, a.y);\n        const pntB = L.latLng(b.x, b.y);\n        const bounds = L.latLngBounds(pntA, pntB);\n        this.zone.run(() => {\n          this.map.fitBounds(bounds);\n        });\n      }\n    }\n    this.map.on('click', (event: any) => {\n      this.zone.run(() => {\n        const pos = event.latlng;\n        this.onMapClick.emit({\n          coordinates: {\n            latitude: pos.lat as number,\n            longitude: pos.lng as number,\n          },\n          originalEvent: event,\n        });\n      });\n    });\n\n    this.map.on('moveend', (event: any) => {\n      this.zone.run(() => {\n        const viewport = this.getViewport();\n        this.onMapDragEnd.emit({\n          viewport,\n          originalEvent: event,\n        });\n      });\n    });\n\n    this.map.on('zoomend', (event: any) => {\n      this.zone.run(() => {\n        const viewport = this.getViewport();\n        this.onMapDragEnd.emit({\n          viewport,\n          originalEvent: event,\n        });\n      });\n    });\n  }\n\n  getViewport(): GeoMapViewport {\n    if (!this.map) {\n      throw new Error('Map is not yet initialised!');\n    }\n\n    const center = this.map.getCenter();\n    const zoomLevel = this.map.getZoom() as number;\n    const leafletBounds = this.map.getBounds();\n    const { lat: swLat, lng: swLng } = leafletBounds.getSouthWest();\n    const { lat: neLat, lng: neLng } = leafletBounds.getNorthEast();\n\n    return {\n      center: {\n        latitude: center.lat as number,\n        longitude: center.lng as number,\n      },\n      zoomLevel,\n      bounds: [\n        { latitude: swLat, longitude: swLng },\n        { latitude: neLat, longitude: neLng },\n      ],\n    };\n  }\n\n  private createLeafletMapOptions(): LeafletMapOptions {\n    const viewport: GeoMapViewport = this.model().viewport!;\n    return {\n      centre: [viewport.center!.latitude, viewport.center!.longitude],\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    this.markers = [];\n    const markerGroups: Map<string, any[]> = new Map();\n\n    toAdd.forEach((item) => {\n      if (item.record instanceof L.Marker) {\n        const key =\n          item.record.getLatLng().lat.toFixed(6) + ',' + item.record.getLatLng().lng.toFixed(6);\n        if (!markerGroups.get(key)) {\n          markerGroups.set(key, []);\n        }\n        markerGroups.get(key)!.push(item.record);\n      }\n    });\n\n    toRemove.forEach((it) => {\n      it.record.remove();\n      this.overlays.delete(it.id);\n    });\n\n    toAdd.forEach((it, index) => {\n      let record = it.record;\n      if (record instanceof L.LayerGroup) {\n        Object.values(record._layers).forEach((at: any) => {\n          at.on('click', (event: any) => {\n            this.zone.run(() => {\n              this.onOverlayClick.emit({\n                itemId: it.id,\n                originalEvent: {\n                  originalEvent: event,\n                  overlay: it.record,\n                  map: this.map,\n                },\n              });\n            });\n          });\n        });\n      } else {\n        it.record.on('click', (event: any) => {\n          this.zone.run(() => {\n            this.onOverlayClick.emit({\n              itemId: it.id,\n              originalEvent: {\n                originalEvent: event,\n                overlay: it.record,\n                map: this.map,\n              },\n            });\n          });\n        });\n\n        let group = markerGroups.get(\n          it.record.getLatLng().lat.toFixed(6) + ',' + it.record.getLatLng().lng.toFixed(6)\n        );\n        if (group && group.length > 1) {\n          const icon = this.createNumberedIcon(group.length);\n          const label = this.createLabel(group);\n          const extraMarker = L.marker(group[0].originalLatLng, { icon });\n\n          if (!extraMarker._tooltip) {\n            extraMarker.bindTooltip(label, {\n              permanent: false,\n              direction: 'auto',\n            });\n            this.markers.push(extraMarker);\n          }\n          const clusterMarker = extraMarker.addTo(this.map);\n          it.record.on('mouseover', (_event: any) => {\n            toAdd.forEach((item, index) => {\n              if (\n                item.record instanceof L.Marker &&\n                item.record.originalLatLng.lat == it.record.originalLatLng.lat &&\n                item.record.originalLatLng.lng == it.record.originalLatLng.lng\n              ) {\n                it.record.setZIndexOffset(1000);\n                const angle = ((360 / toAdd.length) * index * Math.PI) / 180;\n                const newLat =\n                  item.record.originalLatLng.lat + this.offsetDistance * Math.cos(angle);\n                const newLng =\n                  item.record.originalLatLng.lng + this.offsetDistance * Math.sin(angle);\n                item.record.setLatLng([newLat, newLng]);\n              }\n            });\n            if (this.map.hasLayer(clusterMarker)) {\n              this.map.removeLayer(clusterMarker);\n            }\n          });\n          it.record.on('mouseout', (_event: any) => {\n            toAdd.forEach((item, _index) => {\n              if (item.record instanceof L.Marker) {\n                item.record.setLatLng(item.record.originalLatLng);\n                it.record.setZIndexOffset(0);\n              }\n            });\n            if (!this.map.hasLayer(clusterMarker)) {\n              clusterMarker.addTo(this.map);\n            }\n          });\n        } else {\n          this.markers.push(it.record);\n        }\n      }\n      it.record.addTo(this.map);\n      this.overlays.set(it.id, it.record);\n    });\n  }\n  override handleEditingItemChanges(\n    toRemove: Array<RecordWithId>,\n    toAdd: Array<RecordWithId>\n  ): void {\n    if (!this.map) {\n      return;\n    }\n\n    toRemove.forEach((it) => {\n      it.record.remove();\n      this.editingOverlays.delete(it.id);\n    });\n\n    toAdd.forEach((it) => {\n      let record = it.record;\n      if (record instanceof L.LayerGroup) {\n        Object.values(record._layers).forEach((at: any) => {\n          at.on('click', (event: any) => {\n            this.zone.run(() => {\n              this.onEditingOverlayClick.emit({\n                itemId: it.id,\n                coord: {\n                  x: event.latlng.lng,\n                  y: event.latlng.lat,\n                },\n              });\n            });\n          });\n          at.on('dragstart', (event: any) => {\n            this.originalLatLng = event.target.getLatLng();\n          });\n          at.on('dragend', (event: any) => {\n            this.zone.run(() => {\n              this.onEditingOverlayDrag.emit({\n                itemId: it.id,\n                startPosition: {\n                  x: this.originalLatLng.lng,\n                  y: this.originalLatLng.lat,\n                },\n                dragTo: {\n                  x: event.target.getLatLng().lng,\n                  y: event.target.getLatLng().lat,\n                },\n              });\n            });\n            this.originalLatLng = null;\n          });\n        });\n      } else {\n        it.record.on('click', (event: any) => {\n          this.zone.run(() => {\n            this.onEditingOverlayClick.emit({\n              itemId: it.id,\n              coord: {\n                x: event.latlng.lng,\n                y: event.latlng.lat,\n              },\n            });\n          });\n        });\n      }\n\n      it.record.addTo(this.map);\n      this.editingOverlays.set(it.id, it.record);\n    });\n  }\n\n  private findDatasetBounds(): { a: Coord; b: Coord } | null {\n    const items: Array<Coord> = this.items()\n      .flatMap((it) => (it.position ? [it.position] : it.route ? it.route.points : []))\n      .map((it) => {\n        return { x: it.latitude, y: it.longitude };\n      });\n    if (!items || items.length === 0) {\n      return null;\n    }\n\n    let southwest: Coord = { x: items[0].x, y: items[0].y };\n    let northeast: Coord = { x: items[0].x, y: items[0].y };\n\n    items.forEach((it) => {\n      if (it.x < southwest.x) southwest.x = it.x;\n      if (it.y < southwest.y) southwest.y = it.y;\n\n      if (it.x > northeast.x) northeast.x = it.x;\n      if (it.y > northeast.y) northeast.y = it.y;\n    });\n\n    return { a: southwest, b: northeast };\n  }\n\n  override toBase64(): Promise<string> {\n    return new Promise((resolve, reject) => {\n      setTimeout(() => {\n        leafletImage(this.map, (err: any, canvas: HTMLCanvasElement) => {\n          if (err) {\n            console.error('Leaflet image capture error', err);\n            reject(err);\n            return;\n          }\n\n          const ctx = canvas.getContext('2d');\n          if (!ctx) {\n            reject('No context');\n            return;\n          }\n\n          this.markers.forEach((marker: { getTooltip: () => any; getLatLng: () => any }) => {\n            const tooltip = marker.getTooltip();\n            if (!tooltip) {\n              return;\n            }\n            const latLng = marker.getLatLng();\n            const point = this.map.latLngToContainerPoint(latLng);\n            const text = tooltip.getContent();\n\n            // Tooltip szöveg megjelenítése\n            ctx.font = 'bold 30px sans-serif';\n            ctx.fillStyle = 'black';\n            ctx.strokeStyle = 'white';\n            ctx.lineWidth = 4;\n            ctx.textAlign = 'center';\n            ctx.textBaseline = 'bottom';\n            ctx.strokeText(text, point.x, point.y + 10); // fehér kontúr\n            ctx.fillText(text, point.x, point.y + 10); // fekete szöveg\n          });\n\n          resolve(canvas.toDataURL('image/png'));\n        });\n      }, 300);\n    });\n  }\n\n  createLabel(group: any[]) {\n    let label: string = '';\n    group.forEach((item) => {\n      label += item._tooltip._content + ', ';\n      item._tooltip.permanent = false;\n    });\n    return label;\n  }\n  createNumberedIcon(number: number) {\n    const size = 35;\n    const scaleFactor = 15;\n    const scaledSize = size * scaleFactor;\n\n    const canvas = document.createElement('canvas');\n    canvas.width = scaledSize;\n    canvas.height = scaledSize;\n    canvas.style.width = canvas.style.height = '35px';\n    const ctx = canvas.getContext('2d')!;\n    ctx.scale(scaleFactor, scaleFactor);\n\n    ctx.beginPath();\n    ctx.arc(size / 2, size / 2, size / 2 - 2, 0, 2 * Math.PI, false);\n    ctx.fillStyle = '#0078d4';\n    ctx.fill();\n    ctx.lineWidth = 2;\n    ctx.strokeStyle = '#ffffff';\n    ctx.stroke();\n\n    ctx.fillStyle = '#ffffff';\n    ctx.font = 'bold 16px sans-serif';\n    ctx.textAlign = 'center';\n    ctx.textBaseline = 'middle';\n    ctx.fillText(number.toString(), size / 2, size / 2);\n\n    return L.icon({\n      iconUrl: canvas.toDataURL(),\n      iconSize: [size, size],\n      iconAnchor: [size / 2, size / 2],\n      popupAnchor: [0, -size / 2],\n    });\n  }\n}\nfunction getIcon(color: string) {\n  const size = 12;\n  const scaleFactor = 12;\n  const scaledSize = size * scaleFactor;\n\n  const canvas = document.createElement('canvas');\n  canvas.width = scaledSize;\n  canvas.height = scaledSize;\n  canvas.style.width = canvas.style.height = `${size}px`;\n  const ctx = canvas.getContext('2d')!;\n  ctx.scale(scaleFactor, scaleFactor);\n\n  ctx.beginPath();\n  ctx.arc(size / 2, size / 2, size / 2, 0, 2 * Math.PI, false);\n  ctx.fillStyle = color;\n  ctx.fill();\n\n  return L.icon({\n    iconUrl: canvas.toDataURL(),\n    iconSize: [size, size],\n    iconAnchor: [size / 2, size / 2],\n    popupAnchor: [0, -size / 2],\n  });\n}\n"]}

package/esm2022/lib/smart-map/projects.mjs

@@ -0,0 +1,9 @@
+export * from './smart-map.component';
+export * from './smart-map.module';
+export * from './impl/google-map';
+export * from './impl/leaflet-map';
+export * from './api/model/models';
+export * from './smart-map.types';
+export * from './abstract-map';
+export * from './api-default/api-default';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvamVjdHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zbWFydC1uZy1jbGllbnQvc3JjL2xpYi9zbWFydC1tYXAvcHJvamVjdHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLDJCQUEyQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9zbWFydC1tYXAuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vc21hcnQtbWFwLm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL2ltcGwvZ29vZ2xlLW1hcCc7XG5leHBvcnQgKiBmcm9tICcuL2ltcGwvbGVhZmxldC1tYXAnO1xuZXhwb3J0ICogZnJvbSAnLi9hcGkvbW9kZWwvbW9kZWxzJztcbmV4cG9ydCAqIGZyb20gJy4vc21hcnQtbWFwLnR5cGVzJztcbmV4cG9ydCAqIGZyb20gJy4vYWJzdHJhY3QtbWFwJztcbmV4cG9ydCAqIGZyb20gJy4vYXBpLWRlZmF1bHQvYXBpLWRlZmF1bHQnO1xuIl19