@emuanalytics/flow-rdf-core 1.1.0 → 1.1.2

package/dist/esm5/lib/flow-core-map/plugins/annotations/annotation.plugin.js

@@ -0,0 +1,701 @@
+import { __assign, __extends } from "tslib";
+import MapboxDraw from '@emuanalytics/mapbox-gl-draw';
+import { area as turfArea, booleanEqual as turfBooleanEqual, length as turfLength, bbox as turfBBox, buffer as turfBuffer } from '@turf/turf';
+import Debug from 'debug';
+import hat from 'hat';
+import { FlowCoreError } from '../../../errors';
+import { isLineString, isPoint, isPolygon } from '../../../utils/feature-type-checks';
+import { FlowCoreMapPlugin } from '../flow-core-map-plugin';
+import { SelectionPlugin } from '../selection/selection.plugin';
+import { addMapAnnotationLayers } from './annotation-layers';
+import { FlowCoreMapAnnotationEvent } from './annotation.events';
+import { DirectMode, DragCircleMode } from './maplibre-gl-draw-circle';
+var debug = Debug('flow:annotation-plugin');
+var AnnotationPlugin = (function (_super) {
+    __extends(AnnotationPlugin, _super);
+    function AnnotationPlugin(pluginManager, options) {
+        var _this = _super.call(this, pluginManager, options) || this;
+        Object.defineProperty(_this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'AnnotationPlugin'
+        });
+        Object.defineProperty(_this, "_features", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(_this, "_featureIds", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(_this, "_undoStack", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(_this, "_redoStack", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(_this, "_mode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'idle'
+        });
+        Object.defineProperty(_this, "_activeFeatureId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(_this, "_activeFeatureType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(_this, "_onCommitCleanup", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(_this, "_annotationDataSource", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(_this, "_drawControl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(_this, "_removeKeyboardShortcuts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        _this.options = __assign(__assign({}, AnnotationPlugin._defaultOptions), options);
+        _this.options.defaultStyle = __assign(__assign({}, AnnotationPlugin._defaultOptions.defaultStyle), options === null || options === void 0 ? void 0 : options.defaultStyle);
+        return _this;
+    }
+    Object.defineProperty(AnnotationPlugin.prototype, "initialize", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            var _this = this;
+            this._annotationDataSource = addMapAnnotationLayers(this.map);
+            if (this.options.selectionOptions) {
+                this.map.getPlugin(SelectionPlugin).enableSelection(this._annotationDataSource.id, this.options.selectionOptions);
+            }
+            if (this.options.interactive) {
+                this._removeKeyboardShortcuts = this.pluginManager.addKeyboardShortcuts({
+                    'Enter,Escape': function () {
+                        _this.commit();
+                    },
+                    'Delete,Backspace': function () { return _this.deleteSelectedFeature(); },
+                    'Ctrl+KeyZ': function () {
+                        _this.undo();
+                    },
+                    'Ctrl+Shift+KeyZ': function () {
+                        _this.redo();
+                    },
+                    KeyP: function () { return _this.createFeature('Polygon'); },
+                    KeyL: function () { return _this.createFeature('LineString'); },
+                    KeyM: function () { return _this.createFeature('Point'); },
+                    KeyC: function () { return _this.createFeature('Circle'); }
+                });
+            }
+        }
+    });
+    Object.defineProperty(AnnotationPlugin.prototype, "destroy", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            if (this._removeKeyboardShortcuts)
+                this._removeKeyboardShortcuts();
+        }
+    });
+    Object.defineProperty(AnnotationPlugin.prototype, "clear", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            this.commit();
+            this._featureIds = [];
+            this._features = new Map();
+            this._undoStack = [];
+            this._redoStack = [];
+            this._mode = 'idle';
+            this._activeFeatureId = null;
+            this._activeFeatureType = null;
+            this.render();
+            return this;
+        }
+    });
+    Object.defineProperty(AnnotationPlugin.prototype, "undo", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            var operation = this._undoStack.pop();
+            if (operation) {
+                operation.undo();
+                this._redoStack.push(operation);
+                this.render();
+            }
+            return this;
+        }
+    });
+    Object.defineProperty(AnnotationPlugin.prototype, "redo", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            var operation = this._redoStack.pop();
+            if (operation) {
+                operation.do();
+                this._undoStack.push(operation);
+                this.render();
+            }
+            return this;
+        }
+    });
+    Object.defineProperty(AnnotationPlugin.prototype, "getFeature", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (featureId) {
+            var feature = this._features.get(featureId);
+            if (!feature) {
+                throw new FlowCoreError("<AnnotationPlugin>: No feature with id '".concat(featureId, "'"));
+            }
+            return feature;
+        }
+    });
+    Object.defineProperty(AnnotationPlugin.prototype, "getFeatures", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            var _this = this;
+            return this._featureIds.map(function (id) { return _this._features.get(id); });
+        }
+    });
+    Object.defineProperty(AnnotationPlugin.prototype, "setFeatures", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (features) {
+            var _this = this;
+            this.commit();
+            var normalizedFeatures = features.map(function (f) { return _this.applyDefaults(f); });
+            var oldFeatures = this._features;
+            var oldFeatureIds = this._featureIds;
+            var operation = {
+                do: function () {
+                    _this._featureIds = normalizedFeatures.map(function (f) { return f.id; });
+                    _this._features = new Map(normalizedFeatures.map(function (f) { return [f.id, f]; }));
+                },
+                undo: function () {
+                    _this._featureIds = oldFeatureIds;
+                    _this._features = oldFeatures;
+                }
+            };
+            this.performOperation(operation);
+            return this;
+        }
+    });
+    Object.defineProperty(AnnotationPlugin.prototype, "addFeature", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (feature) {
+            var _this = this;
+            this.commit();
+            var fullFeature = this.applyDefaults(feature);
+            var operation = {
+                do: function () {
+                    _this._features.set(fullFeature.id, fullFeature);
+                    _this._featureIds.push(fullFeature.id);
+                },
+                undo: function () {
+                    _this._features.delete(fullFeature.id);
+                    var index = _this._featureIds.indexOf(fullFeature.id);
+                    if (index !== -1) {
+                        _this._featureIds.splice(index, 1);
+                    }
+                }
+            };
+            this.performOperation(operation);
+            return fullFeature;
+        }
+    });
+    Object.defineProperty(AnnotationPlugin.prototype, "deleteFeature", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (featureId) {
+            var _this = this;
+            this.commit();
+            if (!featureId) {
+                return this;
+            }
+            this.deselectFeature(featureId);
+            var feature = this.getFeature(featureId);
+            var operation = {
+                do: function () {
+                    _this._features.delete(featureId);
+                    var index = _this._featureIds.indexOf(featureId);
+                    if (index !== -1) {
+                        _this._featureIds.splice(index, 1);
+                    }
+                },
+                undo: function () {
+                    _this._features.set(featureId, feature);
+                    _this._featureIds.push(featureId);
+                }
+            };
+            this.performOperation(operation);
+            return this;
+        }
+    });
+    Object.defineProperty(AnnotationPlugin.prototype, "createFeature", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (featureType) {
+            var _this = this;
+            this.commit();
+            this.startDrawing();
+            this._drawControl.changeMode(this.drawModeForFeatureType(featureType));
+            this._mode = 'creating';
+            this._activeFeatureId = null;
+            this._activeFeatureType = featureType;
+            this.emitStateChange();
+            var commitChanges = function () {
+                setTimeout(function () { return _this.commit(); }, 0);
+            };
+            this.map.maplibreMap.once('draw.create', commitChanges);
+            this.map.maplibreMap.once('draw.modechange', commitChanges);
+            this._onCommitCleanup.push(function () {
+                _this.map.maplibreMap.off('draw.create', commitChanges);
+                _this.map.maplibreMap.off('draw.modechange', commitChanges);
+            });
+        }
+    });
+    Object.defineProperty(AnnotationPlugin.prototype, "editFeature", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (featureId) {
+            var _this = this;
+            var feature = this.getFeature(featureId);
+            this._mode = 'editing';
+            this._activeFeatureId = featureId;
+            this._activeFeatureType = feature.properties.type;
+            var commitChanges = function () {
+                setTimeout(function () { return _this.commit(); }, 0);
+            };
+            this.startDrawing();
+            this._drawControl.add(feature);
+            this.setFeatureProperty(featureId, 'visible', false);
+            this.render();
+            switch (this.editModeForFeature(feature)) {
+                case 'direct_select':
+                    this._drawControl.changeMode('direct_select', {
+                        featureId: featureId
+                    });
+                    this.map.maplibreMap.once('draw.modechange', commitChanges);
+                    this._onCommitCleanup.push(function () { return _this.map.maplibreMap.off('draw.modechange', commitChanges); });
+                    break;
+                case 'simple_select':
+                    this._drawControl.changeMode('simple_select', {
+                        featureIds: [featureId]
+                    });
+                    this.map.maplibreMap.once('draw.selectionchange', commitChanges);
+                    this._onCommitCleanup.push(function () { return _this.map.maplibreMap.off('draw.selectionchange', commitChanges); });
+                    break;
+            }
+        }
+    });
+    Object.defineProperty(AnnotationPlugin.prototype, "zoomToFeature", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (featureId, animationOptions) {
+            var feature = this.getFeature(featureId);
+            if (!feature)
+                return this;
+            var bbox = (feature.properties.type === 'Point' ? turfBBox(turfBuffer(feature, 50)) : turfBBox(feature));
+            this.map.setBounds(bbox, animationOptions);
+            return this;
+        }
+    });
+    Object.defineProperty(AnnotationPlugin.prototype, "setFeatureProperty", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (featureId, property, value) {
+            var _a;
+            var feature = this.getFeature(featureId);
+            var featureCopy = __assign(__assign({}, feature), { properties: __assign(__assign({}, feature.properties), (_a = {}, _a[property] = value, _a)) });
+            this._features.set(featureId, featureCopy);
+            return this;
+        }
+    });
+    Object.defineProperty(AnnotationPlugin.prototype, "commit", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            var _this = this;
+            this._onCommitCleanup.forEach(function (f) { return f(); });
+            this._onCommitCleanup = [];
+            if (this._mode === 'idle')
+                return this;
+            var drawControlFeature = this._drawControl.getAll().features[0];
+            var operation = null;
+            if (this._mode === 'editing') {
+                var mapFeature_1 = this.getFeature(this._activeFeatureId);
+                this.setFeatureProperty(mapFeature_1.id, 'visible', true);
+                if (!turfBooleanEqual(mapFeature_1.geometry, drawControlFeature.geometry)) {
+                    operation = {
+                        do: function () {
+                            _this.setFeatureGeometry(mapFeature_1.id, drawControlFeature.geometry);
+                            if (drawControlFeature.properties.type === 'Circle') {
+                                _this.setFeatureProperty(mapFeature_1.id, 'center', drawControlFeature.properties.circleCenter);
+                                _this.setFeatureProperty(mapFeature_1.id, 'radiusInKm', drawControlFeature.properties.circleRadius);
+                            }
+                        },
+                        undo: function () {
+                            _this.setFeatureGeometry(mapFeature_1.id, mapFeature_1.geometry);
+                            if (mapFeature_1.properties.type === 'Circle') {
+                                _this.setFeatureProperty(mapFeature_1.id, 'center', mapFeature_1.properties.circleCenter);
+                                _this.setFeatureProperty(mapFeature_1.id, 'radiusInKm', mapFeature_1.properties.circleRadius);
+                            }
+                        }
+                    };
+                }
+            }
+            else if (this._mode === 'creating') {
+                if (this.isValidGeometry(drawControlFeature)) {
+                    var createdFeature_1 = drawControlFeature;
+                    this.applyDefaults(createdFeature_1);
+                    operation = {
+                        do: function () {
+                            var _a, _b;
+                            _this._features.set(drawControlFeature.id, drawControlFeature);
+                            _this._featureIds.push(drawControlFeature.id);
+                            if (((_a = _this.options.selectionOptions) === null || _a === void 0 ? void 0 : _a.mode) === 'single' || ((_b = _this.options.selectionOptions) === null || _b === void 0 ? void 0 : _b.mode) === 'multi') {
+                                _this.map.getPlugin(SelectionPlugin).selectFeatures(_this._annotationDataSource.id, drawControlFeature.id);
+                            }
+                        },
+                        undo: function () {
+                            createdFeature_1 = _this._features.get(createdFeature_1.id);
+                            _this._features.delete(createdFeature_1.id);
+                            var index = _this._featureIds.indexOf(createdFeature_1.id);
+                            if (index !== -1) {
+                                _this._featureIds.splice(index, 1);
+                            }
+                        }
+                    };
+                }
+            }
+            if (operation) {
+                this.performOperation(operation);
+            }
+            this._mode = 'idle';
+            this._activeFeatureId = null;
+            this._activeFeatureType = null;
+            this.endDrawing();
+            this.render();
+            return this;
+        }
+    });
+    Object.defineProperty(AnnotationPlugin.prototype, "cancel", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            this._onCommitCleanup.forEach(function (f) { return f(); });
+            this._onCommitCleanup = [];
+            if (this._mode === 'idle')
+                return this;
+            if (this._mode === 'editing') {
+                this.setFeatureProperty(this._activeFeatureId, 'visible', true);
+            }
+            this._activeFeatureId = null;
+            this._activeFeatureType = null;
+            this._mode = 'idle';
+            this.endDrawing();
+            this.render();
+            return this;
+        }
+    });
+    Object.defineProperty(AnnotationPlugin.prototype, "render", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            var _this = this;
+            var renderedFeatures = {
+                type: 'FeatureCollection',
+                features: this._featureIds.map(function (id) { return _this._features.get(id); })
+            };
+            this._annotationDataSource.setSrc(renderedFeatures);
+            this.emitStateChange();
+            return this;
+        }
+    });
+    Object.defineProperty(AnnotationPlugin.prototype, "handleDblClick", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (event) {
+            if (!this.options.interactive) {
+                return;
+            }
+            var clickedFeature = event.features[0];
+            if (clickedFeature && clickedFeature.source === this._annotationDataSource.id) {
+                this.editFeature(clickedFeature.id.toString());
+            }
+        }
+    });
+    Object.defineProperty(AnnotationPlugin.prototype, "handleBeforeStyleChanged", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (event) {
+            var oldStyle = event.oldStyle, newStyle = event.newStyle;
+            if (this._drawControl) {
+                if (oldStyle.sources['mapbox-gl-draw']) {
+                    newStyle.sources['mapbox-gl-draw'] = oldStyle.sources['mapbox-gl-draw'];
+                }
+                oldStyle.layers.filter(function (l) { return l.id.startsWith('gl-draw'); }).forEach(function (l) { return newStyle.layers.push(l); });
+            }
+            return newStyle;
+        }
+    });
+    Object.defineProperty(AnnotationPlugin.prototype, "startDrawing", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            if (this._drawControl) {
+                return this._drawControl;
+            }
+            this.pluginManager.setExclusivePlugin(this);
+            this._drawControl = new MapboxDraw({
+                displayControlsDefault: false,
+                keybindings: false,
+                modes: __assign(__assign({}, MapboxDraw.modes), { drag_circle: DragCircleMode, direct_select: DirectMode }),
+                userProperties: true
+            });
+            this.map.maplibreMap.addControl(this._drawControl);
+            return this._drawControl;
+        }
+    });
+    Object.defineProperty(AnnotationPlugin.prototype, "endDrawing", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            this.pluginManager.removeExclusivePlugin(this);
+            if (this._drawControl) {
+                this.map.maplibreMap.removeControl(this._drawControl);
+                this._drawControl = null;
+            }
+        }
+    });
+    Object.defineProperty(AnnotationPlugin.prototype, "applyDefaults", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (feature) {
+            var _a;
+            feature.id = feature.properties.id = this.generateFeatureId(feature);
+            feature.properties = __assign(__assign({ id: this.generateFeatureId(feature), name: this.generateFeatureName(feature), type: (_a = feature.properties.type) !== null && _a !== void 0 ? _a : feature.geometry.type, selected: false }, this.options.defaultStyle), feature.properties);
+            feature.id = feature.properties.id;
+            return feature;
+        }
+    });
+    Object.defineProperty(AnnotationPlugin.prototype, "generateFeatureId", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (feature) {
+            if (feature.id) {
+                return feature.id.toString();
+            }
+            else {
+                return hat();
+            }
+        }
+    });
+    Object.defineProperty(AnnotationPlugin.prototype, "generateFeatureName", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (feature) {
+            var _a;
+            var type = (_a = feature.properties.type) !== null && _a !== void 0 ? _a : feature.geometry.type;
+            return "".concat(type, " ").concat(this._featureIds.length);
+        }
+    });
+    Object.defineProperty(AnnotationPlugin.prototype, "performOperation", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (operation) {
+            this._undoStack.push(operation);
+            this._redoStack.length = 0;
+            operation.do();
+        }
+    });
+    Object.defineProperty(AnnotationPlugin.prototype, "deselectFeature", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (featureId) {
+            var _a, _b;
+            if (((_a = this.options.selectionOptions) === null || _a === void 0 ? void 0 : _a.mode) === 'single' || ((_b = this.options.selectionOptions) === null || _b === void 0 ? void 0 : _b.mode) === 'multi') {
+                this.map.getPlugin(SelectionPlugin).deselectFeatures(this._annotationDataSource.id, featureId);
+            }
+        }
+    });
+    Object.defineProperty(AnnotationPlugin.prototype, "deleteSelectedFeature", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            var _this = this;
+            var _a, _b;
+            if (((_a = this.options.selectionOptions) === null || _a === void 0 ? void 0 : _a.mode) === 'single' || ((_b = this.options.selectionOptions) === null || _b === void 0 ? void 0 : _b.mode) === 'multi') {
+                var selected = this.map.getPlugin(SelectionPlugin).selectedFeatureIds(this._annotationDataSource.id);
+                selected.forEach(function (id) { return _this.deleteFeature(id); });
+                this.render();
+            }
+        }
+    });
+    Object.defineProperty(AnnotationPlugin.prototype, "editModeForFeature", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (feature) {
+            switch (feature.geometry.type) {
+                case 'Point':
+                    return 'simple_select';
+                default:
+                    return 'direct_select';
+            }
+        }
+    });
+    Object.defineProperty(AnnotationPlugin.prototype, "drawModeForFeatureType", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (featureType) {
+            switch (featureType) {
+                case 'Polygon':
+                    return 'draw_polygon';
+                case 'LineString':
+                    return 'draw_line_string';
+                case 'Point':
+                    return 'draw_point';
+                case 'Circle':
+                    return 'drag_circle';
+                default:
+                    throw new Error("Unrecognized feature type: ".concat(featureType));
+            }
+        }
+    });
+    Object.defineProperty(AnnotationPlugin.prototype, "setFeatureGeometry", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (featureId, geometry) {
+            var feature = this.getFeature(featureId);
+            var featureCopy = __assign(__assign({}, feature), { geometry: geometry });
+            this._features.set(featureId, featureCopy);
+            return featureCopy;
+        }
+    });
+    Object.defineProperty(AnnotationPlugin.prototype, "isValidGeometry", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (feature) {
+            if (isPolygon(feature)) {
+                return (feature.geometry.coordinates[0][0] !== null &&
+                    feature.geometry.coordinates[0].length > 3 &&
+                    turfArea(feature) > 0);
+            }
+            else if (isLineString(feature)) {
+                return feature.geometry.coordinates.length > 1 && turfLength(feature) > 0;
+            }
+            else if (isPoint(feature)) {
+                return feature.geometry.coordinates.length > 0;
+            }
+            return false;
+        }
+    });
+    Object.defineProperty(AnnotationPlugin.prototype, "emitStateChange", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            var _this = this;
+            var eventData = {
+                mode: this._mode,
+                canUndo: this._undoStack.length > 0,
+                canRedo: this._redoStack.length > 0,
+                activeFeatureId: this._activeFeatureId,
+                activeFeatureType: this._activeFeatureType,
+                features: this._featureIds.map(function (id) { return _this._features.get(id); })
+            };
+            this.emit('annotationStateChanged', new FlowCoreMapAnnotationEvent('annotationStateChanged', this.map, eventData));
+        }
+    });
+    Object.defineProperty(AnnotationPlugin, "_defaultOptions", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: {
+            interactive: true,
+            defaultStyle: {
+                labelSize: 10,
+                labelColor: '#ffffff',
+                labelMaxWidth: 10,
+                labelOffset: [0, 0.5],
+                labelJustify: 'auto',
+                labelAnchor: 'top',
+                polygonLabelAnchor: 'center',
+                radius: 5,
+                fillColor: 'rgba(204,204,204,0.65)',
+                strokeWidth: 1,
+                strokeColor: '#ffffff',
+                selectionStrokeColor: 'orange',
+                selectionStrokeOpacity: 0.5,
+                selectionWidth: 3
+            }
+        }
+    });
+    return AnnotationPlugin;
+}(FlowCoreMapPlugin));
+export { AnnotationPlugin };
+//# sourceMappingURL=annotation.plugin.js.map