igniteui-angular-maps 12.1.1

package/esm2015/lib/igx-geographic-map-component.js

@@ -0,0 +1,688 @@
+/*
+THIS INFRAGISTICS ULTIMATE SOFTWARE LICENSE  AGREEMENT ("AGREEMENT") LOCATED HERE:
+https://www.infragistics.com/legal/license/igultimate-la
+https://www.infragistics.com/legal/license/igultimate-eula
+GOVERNS THE LICENSING, INSTALLATION AND USE OF INFRAGISTICS SOFTWARE. BY DOWNLOADING AND/OR INSTALLING AND USING INFRAGISTICS SOFTWARE:  you are indicating that you have read and understand this Agreement, and agree to be legally bound by it on behalf of the yourself and your company.
+*/
+var IgxGeographicMapComponent_1;
+import * as tslib_1 from "tslib";
+import { EventEmitter, Output, Injector, ComponentFactoryResolver, Component, Renderer2, ViewChild, ContentChildren, QueryList, Input, forwardRef, NgZone, ChangeDetectionStrategy, ViewContainerRef } from '@angular/core';
+import { IgxSeriesComponent } from "igniteui-angular-charts";
+import { IgxSeriesViewerComponent } from "igniteui-angular-charts";
+import { AngularRenderer, AngularWrapper } from "igniteui-angular-core";
+import { TypeRegistrar } from "igniteui-angular-core";
+import { XamGeographicMap } from './XamGeographicMap';
+import { CollectionAdapter, toPoint, fromPoint, toRect, fromRect, ensureBool, ensureEnum, NamePatcher } from "igniteui-angular-core";
+import { DataChartStylingDefaults } from "igniteui-angular-charts";
+import { IgxDataContext } from "igniteui-angular-core";
+import { delegateCombine } from "igniteui-angular-core";
+import { IgxSeriesCollection } from "igniteui-angular-charts";
+import { NotifyCollectionChangedAction } from "igniteui-angular-core";
+import { IgxImageTilesReadyEventArgs } from './igx-image-tiles-ready-event-args';
+import { IgxNumericXAxisComponent } from "igniteui-angular-charts";
+import { IgxNumericYAxisComponent } from "igniteui-angular-charts";
+import { MapResizeBehavior, MapResizeBehavior_$type } from './MapResizeBehavior';
+import { MapBackgroundTilingMode, MapBackgroundTilingMode_$type } from './MapBackgroundTilingMode';
+export const IgxGeographicMapComponent_PROVIDERS = [{ provide: IgxSeriesViewerComponent, useExisting: forwardRef(() => IgxGeographicMapComponent) }];
+/**
+ * Represents the Infragistics IgxGeographicMapComponent control.
+*/
+let IgxGeographicMapComponent = IgxGeographicMapComponent_1 = class IgxGeographicMapComponent extends IgxSeriesViewerComponent {
+    constructor(_renderer, _elRef, _ngZone, _componentFactoryResolver, _injector) {
+        super();
+        this._renderer = _renderer;
+        this._elRef = _elRef;
+        this._ngZone = _ngZone;
+        this._componentFactoryResolver = _componentFactoryResolver;
+        this._injector = _injector;
+        /**
+         * The series actually present in the chart. Do not directly modify this array.
+         * This array's contents can be modified by causing Angular to reproject the child content.
+         * Or adding and removing series from the manual series collection on the series property.
+         */
+        this.actualSeries = [];
+        this._series = null;
+        this._dataSource = null;
+        this._seriesAdapter = null;
+        this._defaultTooltips = null;
+        this._imageTilesReady = null;
+        if (this._styling) {
+            NamePatcher.ensureStylablePatched(Object.getPrototypeOf(this));
+        }
+        this._zoneRunner = (act) => this._ngZone.run(act);
+        this._container = _renderer.createElement("div");
+        _renderer.appendChild(_elRef.element.nativeElement, this._container);
+        _renderer.setStyle(this._container, "display", "block");
+        _renderer.setStyle(this._container, "width", "100%");
+        _renderer.setStyle(this._container, "height", "100%");
+        var root;
+        root = this._container;
+        if (this._container.nativeElement != null) {
+            root = this._container.nativeElement;
+        }
+        var ren = new AngularRenderer(root, this._renderer, window.document, this._ngZone, true, DataChartStylingDefaults);
+        this._wrapper = ren;
+        var chart = this.i;
+        this._chart = chart;
+        chart.provideContainer(ren);
+        ren.addSizeWatcher(() => {
+            this._chart.notifyContainerResized();
+        });
+    }
+    set height(value) {
+        this._height = value;
+        this._renderer.setStyle(this._elRef.element.nativeElement, "height", value);
+        this._chart.notifyContainerResized();
+    }
+    get height() {
+        return this._height;
+    }
+    set width(value) {
+        this._width = value;
+        this._renderer.setStyle(this._elRef.element.nativeElement, "width", value);
+        this._chart.notifyContainerResized();
+    }
+    get width() {
+        return this._width;
+    }
+    /**
+     * Gets or sets the legend used for the current chart.
+    */
+    get legend() {
+        if (this.i.legend != null)
+            return this.i.legend.externalObject;
+    }
+    set legend(v) {
+        if (v != undefined && v != null)
+            this.i.legend = v.i;
+    }
+    /**
+     * A collection or manually added series for the chart.
+    */
+    get series() {
+        if (this._series === null) {
+            let coll = new IgxSeriesCollection();
+            let inner = coll._innerColl;
+            inner.addListener((sender, e) => {
+                switch (e.action) {
+                    case NotifyCollectionChangedAction.Add:
+                        this._seriesAdapter.addManualItem(e.newItems.item(0));
+                        break;
+                    case NotifyCollectionChangedAction.Remove:
+                        this._seriesAdapter.removeManualItemAt(e.oldStartingIndex);
+                        break;
+                    case NotifyCollectionChangedAction.Replace:
+                        this._seriesAdapter.removeManualItemAt(e.oldStartingIndex);
+                        this._seriesAdapter.insertManualItem(e.newStartingIndex, e.newItems.item(0));
+                        break;
+                    case NotifyCollectionChangedAction.Reset:
+                        this._seriesAdapter.clearManualItems();
+                        break;
+                }
+            });
+            this._series = coll;
+        }
+        return this._series;
+    }
+    ngOnDestroy() {
+        this._chart.destroy();
+        this._wrapper.destroy();
+    }
+    createImplementation() {
+        return new XamGeographicMap();
+    }
+    set dataSource(value) {
+        this._dataSource = value;
+        this.bindData();
+    }
+    get dataSource() {
+        return this._dataSource;
+    }
+    bindData() {
+        if (this.actualSeries && this.actualSeries.length > 0) {
+            var currSeries = this.actualSeries;
+            for (var i = 0; i < currSeries.length; i++) {
+                currSeries[i].provideData(this._dataSource);
+            }
+        }
+    }
+    ngAfterContentInit() {
+        if (TypeRegistrar.isRegistered("IgxDataChartDefaultTooltipsComponent")) {
+            let c = TypeRegistrar.get("IgxDataChartDefaultTooltipsComponent");
+            let cf = this._componentFactoryResolver.resolveComponentFactory(c);
+            let cr = this._dynamicContent.createComponent(cf);
+            //let cr = cf.create(this._injector);
+            this._defaultTooltips = cr;
+            cr.instance.onContentReady.subscribe(() => {
+                this._onDefaultTooltipsReady(cr);
+            });
+            //this._container.appendChild(cr.location.nativeElement);
+        }
+        this._seriesAdapter = new CollectionAdapter(this.contentSeries, this.i.series, this.actualSeries, (c) => c.i, (i) => {
+            i.owner = this;
+            i._provideRenderer(this._dataSource);
+            i.provideData(this._dataSource);
+            //i.bindAxes(this.axes);
+            this._ensureDefaultTooltip(i);
+            this._ensureTooltipCreated(i);
+        }, (i) => { i._provideRenderer(null); i.provideData(null); });
+        this.i.notifyContainerResized();
+    }
+    _ensureTooltipCreated(series) {
+        series._ensureTooltipCreated(() => this.createTooltip(), (ele) => {
+            let wrapper = new AngularWrapper(ele, this._renderer, this._ngZone);
+            wrapper.updateToolTip = ele.updateToolTip;
+            wrapper.hideToolTip = ele.hideToolTip;
+            return wrapper;
+        });
+    }
+    _ensureDefaultTooltip(series) {
+        if (this._defaultTooltips == null) {
+            return;
+        }
+        this._defaultTooltips.instance["ensureDefaultTooltip"](series);
+    }
+    _onDefaultTooltipsReady(cr) {
+        if (this.actualSeries && this.actualSeries.length > 0) {
+            var currSeries = this.actualSeries;
+            for (var i = 0; i < currSeries.length; i++) {
+                if (currSeries[i].showDefaultTooltip) {
+                    this._ensureDefaultTooltip(currSeries[i]);
+                }
+            }
+        }
+    }
+    createTooltip() {
+        if (!TypeRegistrar.isRegistered("IgxTooltipContainerComponent")) {
+            return null;
+        }
+        let t = TypeRegistrar.get("IgxTooltipContainerComponent");
+        let cf = this._componentFactoryResolver.resolveComponentFactory(t);
+        //let cr = cf.create(this._injector);
+        let cr = this._dynamicContent.createComponent(cf);
+        let ele = cr.location.nativeElement;
+        let self = this;
+        ele.updateToolTip = function (c, isSubContent) {
+            if (c.externalObject) {
+                c = c.externalObject;
+            }
+            else {
+                let ext = new IgxDataContext();
+                ext._implementation = c;
+                c = ext;
+            }
+            if (!isSubContent) {
+                if (ele.parentElement != self._container) {
+                    if (ele.parentElement != null) {
+                        ele.parentElement.removeChild(ele);
+                    }
+                    self._container.appendChild(ele);
+                }
+            }
+            else {
+                c.isSubContent = true;
+            }
+            cr.instance.context = c;
+            ele.style.display = "block";
+            return true;
+        };
+        ele.hideToolTip = function () {
+            ele.style.display = "none";
+        };
+        ele.style.display = "none";
+        return cr;
+    }
+    /**
+     * An imagery to display behind all series, inside the viewport of the IgxGeographicMapComponent control.
+    */
+    get backgroundContent() {
+        if (this.i.backgroundContent != null) {
+            return this.i.backgroundContent.externalObject;
+        }
+        else {
+            return null;
+        }
+    }
+    set backgroundContent(v) {
+        if (v != undefined && v != null) {
+            this.i.backgroundContent = v.i;
+        }
+        else {
+            this.i.backgroundContent = null;
+        }
+    }
+    /**
+                             * @hidden
+                             */
+    get i() {
+        return this._implementation;
+    }
+    /**
+ * Gets or sets zoomability of the current control
+*/
+    get zoomable() {
+        return this.i.px;
+    }
+    set zoomable(v) {
+        this.i.px = ensureBool(v);
+    }
+    /**
+     * Gets or sets the behavior to use during resize.
+    */
+    get resizeBehavior() {
+        return this.i.pq;
+    }
+    set resizeBehavior(v) {
+        this.i.pq = ensureEnum(MapResizeBehavior_$type, v);
+    }
+    /**
+     * Gets or sets if the map should horizontally wrap.
+    */
+    get isHorizontalWrappingEnabled() {
+        return this.i.pu;
+    }
+    set isHorizontalWrappingEnabled(v) {
+        this.i.pu = ensureBool(v);
+    }
+    /**
+     * Gets or sets if the map should horizontally wrap.
+    */
+    get backgroundTilingMode() {
+        return this.i.pm;
+    }
+    set backgroundTilingMode(v) {
+        this.i.pm = ensureEnum(MapBackgroundTilingMode_$type, v);
+    }
+    /**
+     * Gets or sets whether to use the uncoerced world rect to constrain the zoom bounds.
+    */
+    get useWorldRectForZoomBounds() {
+        return this.i.pw;
+    }
+    set useWorldRectForZoomBounds(v) {
+        this.i.pw = ensureBool(v);
+    }
+    /**
+     * Gets or sets whether skip resetting the zoom when the world rect changes.
+    */
+    get suppressZoomResetOnWorldRectChange() {
+        return this.i.pv;
+    }
+    set suppressZoomResetOnWorldRectChange(v) {
+        this.i.pv = ensureBool(v);
+    }
+    /**
+     * Gets or sets the world bounding rectangle.
+    */
+    get worldRect() {
+        return fromRect(this.i.rs);
+    }
+    set worldRect(v) {
+        this.i.rs = toRect(v);
+    }
+    /**
+     * Gets the actual value of the WorldRect.
+    */
+    get actualWorldRect() {
+        return fromRect(this.i.rg);
+    }
+    set actualWorldRect(v) {
+        this.i.rg = toRect(v);
+    }
+    /**
+     * The X-axis for this IgxGeographicMap.Component
+     * Under normal circumstances, this property should not be set in application code.  By default, it will be set to a numeric axis with a spherical mercator scaler.
+    */
+    get xAxis() {
+        if (this.i.pf == null) {
+            return null;
+        }
+        if (!this.i.pf.externalObject) {
+            let e = IgxNumericXAxisComponent._createFromInternal(this.i.pf);
+            if (e) {
+                e._implementation = this.i.pf;
+            }
+            this.i.pf.externalObject = e;
+        }
+        return this.i.pf.externalObject;
+    }
+    set xAxis(v) {
+        if (v != null && this._stylingContainer && v._styling)
+            v._styling(this._stylingContainer, this, this);
+        v == null ? this.i.pf = null : this.i.pf = v.i;
+    }
+    /**
+     * The Y-axis for this IgxGeographicMap.Component
+     * Under normal circumstances, this property should not be set in application code.  By default, it will be set to a numeric axis with a spherical mercator scaler.
+    */
+    get yAxis() {
+        if (this.i.ph == null) {
+            return null;
+        }
+        if (!this.i.ph.externalObject) {
+            let e = IgxNumericYAxisComponent._createFromInternal(this.i.ph);
+            if (e) {
+                e._implementation = this.i.ph;
+            }
+            this.i.ph.externalObject = e;
+        }
+        return this.i.ph.externalObject;
+    }
+    set yAxis(v) {
+        if (v != null && this._stylingContainer && v._styling)
+            v._styling(this._stylingContainer, this, this);
+        v == null ? this.i.ph = null : this.i.ph = v.i;
+    }
+    /**
+     * Indicates if this SeriesViewer is a map.
+    */
+    get isMap() {
+        return this.i.dq;
+    }
+    /**
+     * A number between 0 and 1 determining the scale of the horizontal/vertical zoom.
+     * This property is effectively a shortcut to the Width/Height of the WindowRect property.
+    */
+    get windowScale() {
+        return this.i.p2;
+    }
+    set windowScale(v) {
+        this.i.p2 = +v;
+    }
+    /**
+     * A number between 0 and 1 determining the scale of the horizontal/vertical zoom.
+     * This property is effectively a shortcut to the Width/Height of the ActualWindowRect property.
+    */
+    get actualWindowScale() {
+        return this.i.p1;
+    }
+    set actualWindowScale(v) {
+        this.i.p1 = +v;
+    }
+    /**
+     * Gets whether or not the control is ready for zooming
+    */
+    get zoomIsReady() {
+        return this.i.py;
+    }
+    findByName(name) {
+        var baseResult = super.findByName(name);
+        if (baseResult) {
+            return baseResult;
+        }
+        if (this.backgroundContent && this.backgroundContent.name && this.backgroundContent.name == name) {
+            return this.backgroundContent;
+        }
+        return null;
+    }
+    _styling(container, component, parent) {
+        super._styling(container, component, parent);
+        this._inStyling = true;
+        if (this.xAxis && this.xAxis._styling) {
+            this.xAxis._styling(container, component, this);
+        }
+        if (this.yAxis && this.yAxis._styling) {
+            this.yAxis._styling(container, component, this);
+        }
+        this._inStyling = false;
+    }
+    getCurrentActualWorldRect() {
+        let iv = this.i.rk();
+        return fromRect(iv);
+    }
+    /**
+     * Given the current plot area of the control and a geographic region, get the WindowRect that would encompass that geographic region.
+    
+    * @param geographic  * The geographic area.
+    */
+    getZoomRectFromGeoRect(geographic) {
+        let iv = this.i.getZoomRectFromGeoRect(toRect(geographic));
+        return fromRect(iv);
+    }
+    updateZoomWindow(zoomWindow) {
+        this.i.qw(toRect(zoomWindow));
+    }
+    updateWorldRect(worldRect) {
+        this.i.qv(toRect(worldRect));
+    }
+    /**
+     * Given the current plot area of the control and a geographic region, get the WindowRect that would encompass that geographic region.
+    
+    * @param geographic  * The geographic area.
+    */
+    getZoomFromGeographicRect(geographic) {
+        let iv = this.i.getZoomFromGeographicRect(toRect(geographic));
+        return fromRect(iv);
+    }
+    convertGeographicToZoom(geographic, extraPixelPadding) {
+        let iv = this.i.rh(toRect(geographic), extraPixelPadding);
+        return fromRect(iv);
+    }
+    getZoomFromGeographicPoints(northWest, southEast) {
+        let iv = this.i.getZoomFromGeographicPoints(toPoint(northWest), toPoint(southEast));
+        return fromRect(iv);
+    }
+    /**
+     * Given a WindowRect and the current plot area, get the geographic region represented by that WindowRect.
+    
+    * @param windowRect  * The zoom area.
+    */
+    getGeographicFromZoom(windowRect) {
+        let iv = this.i.rm(toRect(windowRect));
+        return fromRect(iv);
+    }
+    /**
+     * Convert a pixel-based coordinate to a geographic coordinate.
+    
+    * @param pixelCoordinate  * A pixel-based coordinate
+    */
+    getGeographicPoint(pixelCoordinate) {
+        let iv = this.i.q8(toPoint(pixelCoordinate));
+        return fromPoint(iv);
+    }
+    /**
+     * Convert a geographic coordinate to a pixel-based coordinate.
+    
+    * @param geographicCoordinate  * A geographic coordinate
+    */
+    getPixelPoint(geographicCoordinate) {
+        let iv = this.i.q9(toPoint(geographicCoordinate));
+        return fromPoint(iv);
+    }
+    /**
+     * Convert a geographic coordinate to a pixel-based coordinate.
+    
+    * @param geographicCoordinate  * A geographic coordinate
+    */
+    getWindowPoint(geographicCoordinate) {
+        let iv = this.i.ra(toPoint(geographicCoordinate));
+        return fromPoint(iv);
+    }
+    /**
+     * Removes all cached tile images from the map imagery assigned to the map's background content.
+    
+    */
+    clearTileCache() {
+        this.i.qj();
+    }
+    /**
+     * Notifies the chart that the CSS styles in effect have been updated.
+    
+    */
+    styleUpdated() {
+        this.i.qr();
+    }
+    /**
+     * Gets actual window scale for horizontal dimension of the control
+    
+    */
+    getActualWindowScaleHorizontal() {
+        let iv = this.i.fe();
+        return (iv);
+    }
+    /**
+     * Gets actual window scale for vertical dimension of the control
+    
+    */
+    getActualWindowScaleVertical() {
+        let iv = this.i.ff();
+        return (iv);
+    }
+    /**
+     * Calls for a deferred refresh to the GeographicMap's background.
+    
+    */
+    deferredRefresh() {
+        this.i.deferredRefresh();
+    }
+    /**
+     * Returns the chart visuals expressed as a ChartVisualData object.
+    
+    */
+    exportVisualData() {
+        let iv = this.i.p5();
+        return (iv);
+    }
+    /**
+     * Zoom in to the geographic region specified, when possible (may need to wait for map to be initialized).
+    
+    * @param geographic  * The geographic region to zoom to.
+    */
+    zoomToGeographic(geographic) {
+        this.i.qy(toRect(geographic));
+    }
+    /**
+     * This event is fired whenever the image tiles transition from a loading state (e.g. some are fading in) to a loaded state.
+    */
+    get imageTilesReady() {
+        if (this._imageTilesReady == null) {
+            this._imageTilesReady = new EventEmitter();
+            this.i.imageTilesReady = delegateCombine(this.i.imageTilesReady, (o, e) => {
+                let outerArgs = new IgxImageTilesReadyEventArgs();
+                outerArgs._provideImplementation(e);
+                if (this.beforeImageTilesReady) {
+                    this.beforeImageTilesReady(this, outerArgs);
+                }
+                this._imageTilesReady.emit({
+                    sender: this,
+                    args: outerArgs
+                });
+            });
+        }
+        return this._imageTilesReady;
+    }
+};
+tslib_1.__decorate([
+    ContentChildren(IgxSeriesComponent),
+    tslib_1.__metadata("design:type", QueryList)
+], IgxGeographicMapComponent.prototype, "contentSeries", void 0);
+tslib_1.__decorate([
+    ViewChild("dynamicContent", { read: ViewContainerRef, static: true }),
+    tslib_1.__metadata("design:type", ViewContainerRef)
+], IgxGeographicMapComponent.prototype, "_dynamicContent", void 0);
+tslib_1.__decorate([
+    Input(),
+    tslib_1.__metadata("design:type", String),
+    tslib_1.__metadata("design:paramtypes", [String])
+], IgxGeographicMapComponent.prototype, "height", null);
+tslib_1.__decorate([
+    Input(),
+    tslib_1.__metadata("design:type", String),
+    tslib_1.__metadata("design:paramtypes", [String])
+], IgxGeographicMapComponent.prototype, "width", null);
+tslib_1.__decorate([
+    Input(),
+    tslib_1.__metadata("design:type", Object),
+    tslib_1.__metadata("design:paramtypes", [Object])
+], IgxGeographicMapComponent.prototype, "legend", null);
+tslib_1.__decorate([
+    Input(),
+    tslib_1.__metadata("design:type", Object),
+    tslib_1.__metadata("design:paramtypes", [Object])
+], IgxGeographicMapComponent.prototype, "dataSource", null);
+tslib_1.__decorate([
+    Input(),
+    tslib_1.__metadata("design:type", Boolean),
+    tslib_1.__metadata("design:paramtypes", [Boolean])
+], IgxGeographicMapComponent.prototype, "zoomable", null);
+tslib_1.__decorate([
+    Input(),
+    tslib_1.__metadata("design:type", Number),
+    tslib_1.__metadata("design:paramtypes", [Number])
+], IgxGeographicMapComponent.prototype, "resizeBehavior", null);
+tslib_1.__decorate([
+    Input(),
+    tslib_1.__metadata("design:type", Boolean),
+    tslib_1.__metadata("design:paramtypes", [Boolean])
+], IgxGeographicMapComponent.prototype, "isHorizontalWrappingEnabled", null);
+tslib_1.__decorate([
+    Input(),
+    tslib_1.__metadata("design:type", Number),
+    tslib_1.__metadata("design:paramtypes", [Number])
+], IgxGeographicMapComponent.prototype, "backgroundTilingMode", null);
+tslib_1.__decorate([
+    Input(),
+    tslib_1.__metadata("design:type", Boolean),
+    tslib_1.__metadata("design:paramtypes", [Boolean])
+], IgxGeographicMapComponent.prototype, "useWorldRectForZoomBounds", null);
+tslib_1.__decorate([
+    Input(),
+    tslib_1.__metadata("design:type", Boolean),
+    tslib_1.__metadata("design:paramtypes", [Boolean])
+], IgxGeographicMapComponent.prototype, "suppressZoomResetOnWorldRectChange", null);
+tslib_1.__decorate([
+    Input(),
+    tslib_1.__metadata("design:type", Object),
+    tslib_1.__metadata("design:paramtypes", [Object])
+], IgxGeographicMapComponent.prototype, "worldRect", null);
+tslib_1.__decorate([
+    Input(),
+    tslib_1.__metadata("design:type", Object),
+    tslib_1.__metadata("design:paramtypes", [Object])
+], IgxGeographicMapComponent.prototype, "actualWorldRect", null);
+tslib_1.__decorate([
+    Input(),
+    tslib_1.__metadata("design:type", IgxNumericXAxisComponent),
+    tslib_1.__metadata("design:paramtypes", [IgxNumericXAxisComponent])
+], IgxGeographicMapComponent.prototype, "xAxis", null);
+tslib_1.__decorate([
+    Input(),
+    tslib_1.__metadata("design:type", IgxNumericYAxisComponent),
+    tslib_1.__metadata("design:paramtypes", [IgxNumericYAxisComponent])
+], IgxGeographicMapComponent.prototype, "yAxis", null);
+tslib_1.__decorate([
+    Input(),
+    tslib_1.__metadata("design:type", Number),
+    tslib_1.__metadata("design:paramtypes", [Number])
+], IgxGeographicMapComponent.prototype, "windowScale", null);
+tslib_1.__decorate([
+    Input(),
+    tslib_1.__metadata("design:type", Number),
+    tslib_1.__metadata("design:paramtypes", [Number])
+], IgxGeographicMapComponent.prototype, "actualWindowScale", null);
+tslib_1.__decorate([
+    Output(),
+    tslib_1.__metadata("design:type", EventEmitter),
+    tslib_1.__metadata("design:paramtypes", [])
+], IgxGeographicMapComponent.prototype, "imageTilesReady", null);
+IgxGeographicMapComponent = IgxGeographicMapComponent_1 = tslib_1.__decorate([
+    Component({
+        selector: 'igx-geographic-map',
+        template: `<ng-container #dynamicContent></ng-container>`,
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        providers: [{ provide: IgxSeriesViewerComponent, useExisting: forwardRef(() => IgxGeographicMapComponent_1) }],
+        host: { 'class': 'igx-geographic-map ig-geographic-map' },
+        styles: [`
+		:host {
+			display: block;
+		}
+	`]
+    }),
+    tslib_1.__metadata("design:paramtypes", [Renderer2,
+        ViewContainerRef,
+        NgZone,
+        ComponentFactoryResolver,
+        Injector])
+], IgxGeographicMapComponent);
+export { IgxGeographicMapComponent };
+//# sourceMappingURL=igx-geographic-map-component.js.map