@ng-maps/core
Version:
**@ng-maps/core** is a simple, modular and tree-shakable library for displaying google-maps inside an angular application
260 lines • 28.5 kB
JavaScript
import { Directive, EventEmitter, Input, Output, } from '@angular/core';
import { Subscription } from 'rxjs';
import { PolygonManager } from '../services/managers/polygon.manager';
import * as i0 from "@angular/core";
import * as i1 from "../services/managers/polygon.manager";
/**
* NgMapsPolygon renders a polygon on a {@link https://ng-maps.github.io/core/components/NgMapsViewComponent.html|NgMapsView}
*/
export class NgMapsPolygonDirective {
constructor(_polygonManager) {
this._polygonManager = _polygonManager;
/**
* Indicates whether this Polygon handles mouse events. Defaults to true.
*/
this.clickable = true;
/**
* If set to true, the user can drag this shape over the map. The geodesic
* property defines the mode of dragging. Defaults to false.
*/
// eslint-disable-next-line @angular-eslint/no-input-rename
this.draggable = false;
/**
* If set to true, the user can edit this shape by dragging the control
* points shown at the vertices and on each segment. Defaults to false.
*/
this.editable = false;
/**
* When true, edges of the polygon are interpreted as geodesic and will
* follow the curvature of the Earth. When false, edges of the polygon are
* rendered as straight lines in screen space. Note that the shape of a
* geodesic polygon may appear to change when dragged, as the dimensions
* are maintained relative to the surface of the earth. Defaults to false.
*/
this.geodesic = false;
/**
* The ordered sequence of coordinates that designates a closed loop.
* Unlike polylines, a polygon may consist of one or more paths.
* As a result, the paths property may specify one or more arrays of
* LatLng coordinates. Paths are closed automatically; do not repeat the
* first vertex of the path as the last vertex. Simple polygons may be
* defined using a single array of LatLngs. More complex polygons may
* specify an array of arrays. Any simple arrays are converted into Arrays.
* Inserting or removing LatLngs from the Array will automatically update
* the polygon on the map.
*/
this.paths = [];
/**
* This event is fired when the DOM click event is fired on the Polygon.
*/
this.polyClick = new EventEmitter();
/**
* This event is fired when the DOM dblclick event is fired on the Polygon.
*/
this.polyDblClick = new EventEmitter();
/**
* This event is repeatedly fired while the user drags the polygon.
*/
this.polyDrag = new EventEmitter();
/**
* This event is fired when the user stops dragging the polygon.
*/
this.polyDragEnd = new EventEmitter();
/**
* This event is fired when the user starts dragging the polygon.
*/
this.polyDragStart = new EventEmitter();
/**
* This event is fired when the DOM mousedown event is fired on the Polygon.
*/
this.polyMouseDown = new EventEmitter();
/**
* This event is fired when the DOM mousemove event is fired on the Polygon.
*/
this.polyMouseMove = new EventEmitter();
/**
* This event is fired on Polygon mouseout.
*/
this.polyMouseOut = new EventEmitter();
/**
* This event is fired on Polygon mouseover.
*/
this.polyMouseOver = new EventEmitter();
/**
* This event is fired whe the DOM mouseup event is fired on the Polygon
*/
this.polyMouseUp = new EventEmitter();
/**
* This even is fired when the Polygon is right-clicked on.
*/
this.polyRightClick = new EventEmitter();
this._polygonAddedToManager = false;
this.subscription = new Subscription();
}
static { this._polygonOptionsAttributes = [
'clickable',
'draggable',
'editable',
'fillColor',
'fillOpacity',
'geodesic',
'icon',
'map',
'paths',
'strokeColor',
'strokeOpacity',
'strokeWeight',
'visible',
'zIndex',
'draggable',
'editable',
'visible',
]; }
/** @internal */
ngAfterContentInit() {
if (!this._polygonAddedToManager) {
this._init();
}
}
ngOnChanges(changes) {
if (!this._polygonAddedToManager) {
this._init();
return;
}
this._polygonManager.setPolygonOptions(this, this._updatePolygonOptions(changes));
}
_init() {
this._polygonManager.addPolygon(this);
this._polygonAddedToManager = true;
this._addEventListeners();
}
_addEventListeners() {
const handlers = [
{
name: 'click',
handler: (ev) => this.polyClick.emit(ev),
},
{
name: 'dblclick',
handler: (ev) => this.polyDblClick.emit(ev),
},
{ name: 'drag', handler: (ev) => this.polyDrag.emit(ev) },
{
name: 'dragend',
handler: (ev) => this.polyDragEnd.emit(ev),
},
{
name: 'dragstart',
handler: (ev) => this.polyDragStart.emit(ev),
},
{
name: 'mousedown',
handler: (ev) => this.polyMouseDown.emit(ev),
},
{
name: 'mousemove',
handler: (ev) => this.polyMouseMove.emit(ev),
},
{
name: 'mouseout',
handler: (ev) => this.polyMouseOut.emit(ev),
},
{
name: 'mouseover',
handler: (ev) => this.polyMouseOver.emit(ev),
},
{
name: 'mouseup',
handler: (ev) => this.polyMouseUp.emit(ev),
},
{
name: 'rightclick',
handler: (ev) => this.polyRightClick.emit(ev),
},
];
handlers.forEach((obj) => {
const os = this._polygonManager
.createEventObservable(obj.name, this)
// FIXME
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
.subscribe(obj.handler);
this.subscription.add(os);
});
}
_updatePolygonOptions(changes) {
return Object.keys(changes)
.filter((k) => NgMapsPolygonDirective._polygonOptionsAttributes.indexOf(k) !== -1)
.reduce((obj, k) => {
obj[k] = changes[k].currentValue;
return obj;
}, {});
}
/** @internal */
id() {
return this._id;
}
/** @internal */
ngOnDestroy() {
this._polygonManager.deletePolygon(this);
// unsubscribe all registered observable subscriptions
this.subscription.unsubscribe();
}
static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: NgMapsPolygonDirective, deps: [{ token: i1.PolygonManager }], target: i0.ɵɵFactoryTarget.Directive }); }
static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.8", type: NgMapsPolygonDirective, selector: "map-polygon", inputs: { clickable: "clickable", draggable: ["polyDraggable", "draggable"], editable: "editable", fillColor: "fillColor", fillOpacity: "fillOpacity", geodesic: "geodesic", paths: "paths", strokeColor: "strokeColor", strokeOpacity: "strokeOpacity", strokeWeight: "strokeWeight", visible: "visible", zIndex: "zIndex" }, outputs: { polyClick: "polyClick", polyDblClick: "polyDblClick", polyDrag: "polyDrag", polyDragEnd: "polyDragEnd", polyDragStart: "polyDragStart", polyMouseDown: "polyMouseDown", polyMouseMove: "polyMouseMove", polyMouseOut: "polyMouseOut", polyMouseOver: "polyMouseOver", polyMouseUp: "polyMouseUp", polyRightClick: "polyRightClick" }, usesOnChanges: true, ngImport: i0 }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: NgMapsPolygonDirective, decorators: [{
type: Directive,
args: [{
// eslint-disable-next-line @angular-eslint/directive-selector
selector: 'map-polygon',
}]
}], ctorParameters: () => [{ type: i1.PolygonManager }], propDecorators: { clickable: [{
type: Input
}], draggable: [{
type: Input,
args: ['polyDraggable']
}], editable: [{
type: Input
}], fillColor: [{
type: Input
}], fillOpacity: [{
type: Input
}], geodesic: [{
type: Input
}], paths: [{
type: Input
}], strokeColor: [{
type: Input
}], strokeOpacity: [{
type: Input
}], strokeWeight: [{
type: Input
}], visible: [{
type: Input
}], zIndex: [{
type: Input
}], polyClick: [{
type: Output
}], polyDblClick: [{
type: Output
}], polyDrag: [{
type: Output
}], polyDragEnd: [{
type: Output
}], polyDragStart: [{
type: Output
}], polyMouseDown: [{
type: Output
}], polyMouseMove: [{
type: Output
}], polyMouseOut: [{
type: Output
}], polyMouseOver: [{
type: Output
}], polyMouseUp: [{
type: Output
}], polyRightClick: [{
type: Output
}] } });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"polygon.js","sourceRoot":"","sources":["../../../../../../libs/core/src/lib/directives/polygon.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterContentInit,\n  Directive,\n  EventEmitter,\n  Input,\n  OnChanges,\n  OnDestroy,\n  Output,\n  SimpleChanges,\n} from '@angular/core';\nimport { Subscription } from 'rxjs';\n\nimport { GeoPoint } from '../interface/geo-point';\nimport { PolygonManager } from '../services/managers/polygon.manager';\n\n/**\n * NgMapsPolygon renders a polygon on a {@link https://ng-maps.github.io/core/components/NgMapsViewComponent.html|NgMapsView}\n */\n@Directive({\n  // eslint-disable-next-line @angular-eslint/directive-selector\n  selector: 'map-polygon',\n})\nexport class NgMapsPolygonDirective\n  implements OnDestroy, OnChanges, AfterContentInit\n{\n  constructor(private _polygonManager: PolygonManager) {}\n\n  private static _polygonOptionsAttributes: Array<string> = [\n    'clickable',\n    'draggable',\n    'editable',\n    'fillColor',\n    'fillOpacity',\n    'geodesic',\n    'icon',\n    'map',\n    'paths',\n    'strokeColor',\n    'strokeOpacity',\n    'strokeWeight',\n    'visible',\n    'zIndex',\n    'draggable',\n    'editable',\n    'visible',\n  ];\n  /**\n   * Indicates whether this Polygon handles mouse events. Defaults to true.\n   */\n  @Input() public clickable: boolean = true;\n\n  /**\n   * If set to true, the user can drag this shape over the map. The geodesic\n   * property defines the mode of dragging. Defaults to false.\n   */\n  // eslint-disable-next-line @angular-eslint/no-input-rename\n  @Input('polyDraggable') public draggable: boolean = false;\n\n  /**\n   * If set to true, the user can edit this shape by dragging the control\n   * points shown at the vertices and on each segment. Defaults to false.\n   */\n  @Input() public editable: boolean = false;\n\n  /**\n   * The fill color. All CSS3 colors are supported except for extended\n   * named colors.\n   */\n  @Input() public fillColor?: string;\n\n  /**\n   * The fill opacity between 0.0 and 1.0\n   */\n  @Input() public fillOpacity?: number;\n\n  /**\n   * When true, edges of the polygon are interpreted as geodesic and will\n   * follow the curvature of the Earth. When false, edges of the polygon are\n   * rendered as straight lines in screen space. Note that the shape of a\n   * geodesic polygon may appear to change when dragged, as the dimensions\n   * are maintained relative to the surface of the earth. Defaults to false.\n   */\n  @Input() public geodesic: boolean = false;\n\n  /**\n   * The ordered sequence of coordinates that designates a closed loop.\n   * Unlike polylines, a polygon may consist of one or more paths.\n   *  As a result, the paths property may specify one or more arrays of\n   * LatLng coordinates. Paths are closed automatically; do not repeat the\n   * first vertex of the path as the last vertex. Simple polygons may be\n   * defined using a single array of LatLngs. More complex polygons may\n   * specify an array of arrays. Any simple arrays are converted into Arrays.\n   * Inserting or removing LatLngs from the Array will automatically update\n   * the polygon on the map.\n   */\n  @Input() public paths: Array<GeoPoint> | Array<Array<GeoPoint>> = [];\n\n  /**\n   * The stroke color. All CSS3 colors are supported except for extended\n   * named colors.\n   */\n  @Input() public strokeColor?: string;\n\n  /**\n   * The stroke opacity between 0.0 and 1.0\n   */\n  @Input() public strokeOpacity?: number;\n\n  /**\n   * The stroke width in pixels.\n   */\n  @Input() public strokeWeight?: number;\n\n  /**\n   * Whether this polygon is visible on the map. Defaults to true.\n   */\n  @Input() public visible?: boolean;\n\n  /**\n   * The zIndex compared to other polys.\n   */\n  @Input() public zIndex?: number;\n\n  /**\n   * This event is fired when the DOM click event is fired on the Polygon.\n   */\n  @Output()\n  public polyClick: EventEmitter<google.maps.PolyMouseEvent> =\n    new EventEmitter<google.maps.PolyMouseEvent>();\n\n  /**\n   * This event is fired when the DOM dblclick event is fired on the Polygon.\n   */\n  @Output()\n  public polyDblClick: EventEmitter<google.maps.PolyMouseEvent> =\n    new EventEmitter<google.maps.PolyMouseEvent>();\n\n  /**\n   * This event is repeatedly fired while the user drags the polygon.\n   */\n  @Output()\n  public polyDrag: EventEmitter<MouseEvent> = new EventEmitter<MouseEvent>();\n\n  /**\n   * This event is fired when the user stops dragging the polygon.\n   */\n  @Output()\n  public polyDragEnd: EventEmitter<MouseEvent> = new EventEmitter<MouseEvent>();\n\n  /**\n   * This event is fired when the user starts dragging the polygon.\n   */\n  @Output()\n  public polyDragStart: EventEmitter<MouseEvent> =\n    new EventEmitter<MouseEvent>();\n\n  /**\n   * This event is fired when the DOM mousedown event is fired on the Polygon.\n   */\n  @Output()\n  public polyMouseDown: EventEmitter<google.maps.PolyMouseEvent> =\n    new EventEmitter<google.maps.PolyMouseEvent>();\n\n  /**\n   * This event is fired when the DOM mousemove event is fired on the Polygon.\n   */\n  @Output()\n  public polyMouseMove: EventEmitter<google.maps.PolyMouseEvent> =\n    new EventEmitter<google.maps.PolyMouseEvent>();\n\n  /**\n   * This event is fired on Polygon mouseout.\n   */\n  @Output()\n  public polyMouseOut: EventEmitter<google.maps.PolyMouseEvent> =\n    new EventEmitter<google.maps.PolyMouseEvent>();\n\n  /**\n   * This event is fired on Polygon mouseover.\n   */\n  @Output()\n  public polyMouseOver: EventEmitter<google.maps.PolyMouseEvent> =\n    new EventEmitter<google.maps.PolyMouseEvent>();\n\n  /**\n   * This event is fired whe the DOM mouseup event is fired on the Polygon\n   */\n  @Output()\n  public polyMouseUp: EventEmitter<google.maps.PolyMouseEvent> =\n    new EventEmitter<google.maps.PolyMouseEvent>();\n\n  /**\n   * This even is fired when the Polygon is right-clicked on.\n   */\n  @Output()\n  public polyRightClick: EventEmitter<google.maps.PolyMouseEvent> =\n    new EventEmitter<google.maps.PolyMouseEvent>();\n\n  private _id?: string;\n  private _polygonAddedToManager: boolean = false;\n  private subscription: Subscription = new Subscription();\n\n  /** @internal */\n  public ngAfterContentInit() {\n    if (!this._polygonAddedToManager) {\n      this._init();\n    }\n  }\n\n  public ngOnChanges(changes: SimpleChanges): any {\n    if (!this._polygonAddedToManager) {\n      this._init();\n      return;\n    }\n\n    this._polygonManager.setPolygonOptions(\n      this,\n      this._updatePolygonOptions(changes),\n    );\n  }\n\n  private _init() {\n    this._polygonManager.addPolygon(this);\n    this._polygonAddedToManager = true;\n    this._addEventListeners();\n  }\n\n  private _addEventListeners() {\n    const handlers = [\n      {\n        name: 'click',\n        handler: (ev: google.maps.PolyMouseEvent) => this.polyClick.emit(ev),\n      },\n      {\n        name: 'dblclick',\n        handler: (ev: google.maps.PolyMouseEvent) => this.polyDblClick.emit(ev),\n      },\n      { name: 'drag', handler: (ev: MouseEvent) => this.polyDrag.emit(ev) },\n      {\n        name: 'dragend',\n        handler: (ev: MouseEvent) => this.polyDragEnd.emit(ev),\n      },\n      {\n        name: 'dragstart',\n        handler: (ev: MouseEvent) => this.polyDragStart.emit(ev),\n      },\n      {\n        name: 'mousedown',\n        handler: (ev: google.maps.PolyMouseEvent) =>\n          this.polyMouseDown.emit(ev),\n      },\n      {\n        name: 'mousemove',\n        handler: (ev: google.maps.PolyMouseEvent) =>\n          this.polyMouseMove.emit(ev),\n      },\n      {\n        name: 'mouseout',\n        handler: (ev: google.maps.PolyMouseEvent) => this.polyMouseOut.emit(ev),\n      },\n      {\n        name: 'mouseover',\n        handler: (ev: google.maps.PolyMouseEvent) =>\n          this.polyMouseOver.emit(ev),\n      },\n      {\n        name: 'mouseup',\n        handler: (ev: google.maps.PolyMouseEvent) => this.polyMouseUp.emit(ev),\n      },\n      {\n        name: 'rightclick',\n        handler: (ev: google.maps.PolyMouseEvent) =>\n          this.polyRightClick.emit(ev),\n      },\n    ];\n    handlers.forEach((obj) => {\n      const os = this._polygonManager\n        .createEventObservable(obj.name, this)\n        // FIXME\n        // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n        // @ts-ignore\n        .subscribe(obj.handler);\n      this.subscription.add(os);\n    });\n  }\n\n  private _updatePolygonOptions(\n    changes: SimpleChanges,\n  ): google.maps.PolygonOptions {\n    return Object.keys(changes)\n      .filter(\n        (k) =>\n          NgMapsPolygonDirective._polygonOptionsAttributes.indexOf(k) !== -1,\n      )\n      .reduce((obj: any, k: string) => {\n        obj[k] = changes[k].currentValue;\n        return obj;\n      }, {});\n  }\n\n  /** @internal */\n  public id(): string | undefined {\n    return this._id;\n  }\n\n  /** @internal */\n  public ngOnDestroy() {\n    this._polygonManager.deletePolygon(this);\n    // unsubscribe all registered observable subscriptions\n    this.subscription.unsubscribe();\n  }\n}\n"]}