@emuanalytics/flow-rdf-core 1.1.6 → 1.1.7

package/dist/cjs/lib/map/plugins/annotations/annotation.plugin.js

@@ -0,0 +1,736 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnnotationPlugin = void 0;
+var mapbox_gl_draw_1 = __importDefault(require("@emuanalytics/mapbox-gl-draw"));
+var area_1 = __importDefault(require("@turf/area"));
+var bbox_1 = __importDefault(require("@turf/bbox"));
+var boolean_equal_1 = __importDefault(require("@turf/boolean-equal"));
+var buffer_1 = __importDefault(require("@turf/buffer"));
+var length_1 = __importDefault(require("@turf/length"));
+var debug_1 = __importDefault(require("debug"));
+var hat_1 = __importDefault(require("hat"));
+var errors_1 = require("../../../errors");
+var feature_type_checks_1 = require("../../../utils/feature-type-checks");
+var map_plugin_base_1 = require("../map-plugin-base");
+var selection_plugin_1 = require("../selection/selection.plugin");
+var annotation_layers_1 = require("./annotation-layers");
+var annotation_events_1 = require("./annotation.events");
+var maplibre_gl_draw_circle_1 = require("./maplibre-gl-draw-circle");
+var debug = (0, debug_1.default)('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 = (0, annotation_layers_1.addAnnotationLayers)(this.map);
+            if (this.options.selectionOptions) {
+                this.map.getPlugin(selection_plugin_1.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 errors_1.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' ? (0, bbox_1.default)((0, buffer_1.default)(feature, 50)) : (0, bbox_1.default)(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 (!(0, boolean_equal_1.default)(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(selection_plugin_1.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 mapbox_gl_draw_1.default({
+                displayControlsDefault: false,
+                keybindings: false,
+                modes: __assign(__assign({}, mapbox_gl_draw_1.default.modes), { drag_circle: maplibre_gl_draw_circle_1.DragCircleMode, direct_select: maplibre_gl_draw_circle_1.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 (0, hat_1.default)();
+            }
+        }
+    });
+    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(selection_plugin_1.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(selection_plugin_1.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 ((0, feature_type_checks_1.isPolygon)(feature)) {
+                return (feature.geometry.coordinates[0][0] !== null &&
+                    feature.geometry.coordinates[0].length > 3 &&
+                    (0, area_1.default)(feature) > 0);
+            }
+            else if ((0, feature_type_checks_1.isLineString)(feature)) {
+                return feature.geometry.coordinates.length > 1 && (0, length_1.default)(feature) > 0;
+            }
+            else if ((0, feature_type_checks_1.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 annotation_events_1.AnnotationEvent('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;
+}(map_plugin_base_1.MapPluginBase));
+exports.AnnotationPlugin = AnnotationPlugin;
+//# sourceMappingURL=annotation.plugin.js.map